2019-05-27 06:55:01 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2019-06-17 17:16:52 +00:00
|
|
|
//
|
|
|
|
// core.c -- Voltage/Current Regulator framework.
|
|
|
|
//
|
|
|
|
// Copyright 2007, 2008 Wolfson Microelectronics PLC.
|
|
|
|
// Copyright 2008 SlimLogic Ltd.
|
|
|
|
//
|
|
|
|
// Author: Liam Girdwood <lrg@slimlogic.co.uk>
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
2010-12-21 23:49:31 +00:00
|
|
|
#include <linux/debugfs.h>
|
2008-04-30 14:59:04 +00:00
|
|
|
#include <linux/device.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2011-05-24 00:12:40 +00:00
|
|
|
#include <linux/async.h>
|
2008-04-30 14:59:04 +00:00
|
|
|
#include <linux/err.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/suspend.h>
|
2009-12-21 12:21:52 +00:00
|
|
|
#include <linux/delay.h>
|
2014-06-29 16:55:54 +00:00
|
|
|
#include <linux/gpio/consumer.h>
|
2011-11-18 11:17:20 +00:00
|
|
|
#include <linux/of.h>
|
2012-04-15 10:16:05 +00:00
|
|
|
#include <linux/regmap.h>
|
2011-11-18 11:17:20 +00:00
|
|
|
#include <linux/regulator/of_regulator.h>
|
2008-04-30 14:59:04 +00:00
|
|
|
#include <linux/regulator/consumer.h>
|
2019-06-23 21:08:31 +00:00
|
|
|
#include <linux/regulator/coupler.h>
|
2008-04-30 14:59:04 +00:00
|
|
|
#include <linux/regulator/driver.h>
|
|
|
|
#include <linux/regulator/machine.h>
|
2011-07-17 20:28:23 +00:00
|
|
|
#include <linux/module.h>
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2010-11-10 14:38:30 +00:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/regulator.h>
|
|
|
|
|
2010-02-12 10:18:08 +00:00
|
|
|
#include "dummy.h"
|
2013-09-11 12:15:40 +00:00
|
|
|
#include "internal.h"
|
2010-02-12 10:18:08 +00:00
|
|
|
|
2011-06-09 15:06:37 +00:00
|
|
|
#define rdev_crit(rdev, fmt, ...) \
|
|
|
|
pr_crit("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
|
2010-11-30 13:53:48 +00:00
|
|
|
#define rdev_err(rdev, fmt, ...) \
|
|
|
|
pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
|
|
|
|
#define rdev_warn(rdev, fmt, ...) \
|
|
|
|
pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
|
|
|
|
#define rdev_info(rdev, fmt, ...) \
|
|
|
|
pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
|
|
|
|
#define rdev_dbg(rdev, fmt, ...) \
|
|
|
|
pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
static DEFINE_WW_CLASS(regulator_ww_class);
|
|
|
|
static DEFINE_MUTEX(regulator_nesting_mutex);
|
2008-04-30 14:59:04 +00:00
|
|
|
static DEFINE_MUTEX(regulator_list_mutex);
|
|
|
|
static LIST_HEAD(regulator_map_list);
|
2013-02-18 06:50:39 +00:00
|
|
|
static LIST_HEAD(regulator_ena_gpio_list);
|
2013-10-15 19:14:20 +00:00
|
|
|
static LIST_HEAD(regulator_supply_alias_list);
|
2019-06-23 21:08:31 +00:00
|
|
|
static LIST_HEAD(regulator_coupler_list);
|
2010-12-21 23:30:07 +00:00
|
|
|
static bool has_full_constraints;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2010-12-21 23:49:31 +00:00
|
|
|
static struct dentry *debugfs_root;
|
|
|
|
|
2008-12-31 12:52:40 +00:00
|
|
|
/*
|
2008-04-30 14:59:04 +00:00
|
|
|
* struct regulator_map
|
|
|
|
*
|
|
|
|
* Used to provide symbolic supply names to devices.
|
|
|
|
*/
|
|
|
|
struct regulator_map {
|
|
|
|
struct list_head list;
|
2009-06-17 16:56:39 +00:00
|
|
|
const char *dev_name; /* The dev_name() for the consumer */
|
2008-04-30 14:59:04 +00:00
|
|
|
const char *supply;
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *regulator;
|
2008-04-30 14:59:04 +00:00
|
|
|
};
|
|
|
|
|
2013-02-18 06:50:39 +00:00
|
|
|
/*
|
|
|
|
* struct regulator_enable_gpio
|
|
|
|
*
|
|
|
|
* Management for shared enable GPIO pin
|
|
|
|
*/
|
|
|
|
struct regulator_enable_gpio {
|
|
|
|
struct list_head list;
|
2014-06-29 16:55:54 +00:00
|
|
|
struct gpio_desc *gpiod;
|
2013-02-18 06:50:39 +00:00
|
|
|
u32 enable_count; /* a number of enabled shared GPIO */
|
|
|
|
u32 request_count; /* a number of requested shared GPIO */
|
|
|
|
};
|
|
|
|
|
2013-10-15 19:14:20 +00:00
|
|
|
/*
|
|
|
|
* struct regulator_supply_alias
|
|
|
|
*
|
|
|
|
* Used to map lookups for a supply onto an alternative device.
|
|
|
|
*/
|
|
|
|
struct regulator_supply_alias {
|
|
|
|
struct list_head list;
|
|
|
|
struct device *src_dev;
|
|
|
|
const char *src_supply;
|
|
|
|
struct device *alias_dev;
|
|
|
|
const char *alias_supply;
|
|
|
|
};
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
static int _regulator_is_enabled(struct regulator_dev *rdev);
|
2018-11-20 17:52:53 +00:00
|
|
|
static int _regulator_disable(struct regulator *regulator);
|
2008-04-30 14:59:04 +00:00
|
|
|
static int _regulator_get_current_limit(struct regulator_dev *rdev);
|
|
|
|
static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
|
2014-08-28 19:36:04 +00:00
|
|
|
static int _notifier_call_chain(struct regulator_dev *rdev,
|
2008-04-30 14:59:04 +00:00
|
|
|
unsigned long event, void *data);
|
2010-12-12 14:25:50 +00:00
|
|
|
static int _regulator_do_set_voltage(struct regulator_dev *rdev,
|
|
|
|
int min_uV, int max_uV);
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
static int regulator_balance_voltage(struct regulator_dev *rdev,
|
|
|
|
suspend_state_t state);
|
2011-06-09 15:22:22 +00:00
|
|
|
static struct regulator *create_regulator(struct regulator_dev *rdev,
|
|
|
|
struct device *dev,
|
|
|
|
const char *supply_name);
|
2020-07-16 04:20:51 +00:00
|
|
|
static void destroy_regulator(struct regulator *regulator);
|
2015-07-15 14:10:29 +00:00
|
|
|
static void _regulator_put(struct regulator *regulator);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2019-06-23 21:08:32 +00:00
|
|
|
const char *rdev_get_name(struct regulator_dev *rdev)
|
2009-10-22 15:31:32 +00:00
|
|
|
{
|
|
|
|
if (rdev->constraints && rdev->constraints->name)
|
|
|
|
return rdev->constraints->name;
|
|
|
|
else if (rdev->desc->name)
|
|
|
|
return rdev->desc->name;
|
|
|
|
else
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
2013-11-27 16:13:10 +00:00
|
|
|
static bool have_full_constraints(void)
|
|
|
|
{
|
2013-11-27 16:22:53 +00:00
|
|
|
return has_full_constraints || of_have_populated_dt();
|
2013-11-27 16:13:10 +00:00
|
|
|
}
|
|
|
|
|
2016-04-23 07:11:05 +00:00
|
|
|
static bool regulator_ops_is_valid(struct regulator_dev *rdev, int ops)
|
|
|
|
{
|
|
|
|
if (!rdev->constraints) {
|
|
|
|
rdev_err(rdev, "no constraints\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rdev->constraints->valid_ops_mask & ops)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
/**
|
|
|
|
* regulator_lock_nested - lock a single regulator
|
|
|
|
* @rdev: regulator source
|
2018-11-18 21:56:17 +00:00
|
|
|
* @ww_ctx: w/w mutex acquire context
|
2018-04-23 14:33:37 +00:00
|
|
|
*
|
|
|
|
* This function can be called many times by one task on
|
|
|
|
* a single regulator and its mutex will be locked only
|
|
|
|
* once. If a task, which is calling this function is other
|
|
|
|
* than the one, which initially locked the mutex, it will
|
|
|
|
* wait on mutex.
|
|
|
|
*/
|
2018-11-18 21:56:17 +00:00
|
|
|
static inline int regulator_lock_nested(struct regulator_dev *rdev,
|
|
|
|
struct ww_acquire_ctx *ww_ctx)
|
2018-04-23 14:33:37 +00:00
|
|
|
{
|
2018-11-18 21:56:17 +00:00
|
|
|
bool lock = false;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
mutex_lock(®ulator_nesting_mutex);
|
|
|
|
|
|
|
|
if (ww_ctx || !ww_mutex_trylock(&rdev->mutex)) {
|
|
|
|
if (rdev->mutex_owner == current)
|
2018-04-23 14:33:37 +00:00
|
|
|
rdev->ref_cnt++;
|
2018-11-18 21:56:17 +00:00
|
|
|
else
|
|
|
|
lock = true;
|
|
|
|
|
|
|
|
if (lock) {
|
|
|
|
mutex_unlock(®ulator_nesting_mutex);
|
|
|
|
ret = ww_mutex_lock(&rdev->mutex, ww_ctx);
|
|
|
|
mutex_lock(®ulator_nesting_mutex);
|
2018-04-23 14:33:37 +00:00
|
|
|
}
|
2018-11-18 21:56:17 +00:00
|
|
|
} else {
|
|
|
|
lock = true;
|
2018-04-23 14:33:37 +00:00
|
|
|
}
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
if (lock && ret != -EDEADLK) {
|
|
|
|
rdev->ref_cnt++;
|
|
|
|
rdev->mutex_owner = current;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(®ulator_nesting_mutex);
|
|
|
|
|
|
|
|
return ret;
|
2018-04-23 14:33:37 +00:00
|
|
|
}
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
/**
|
|
|
|
* regulator_lock - lock a single regulator
|
|
|
|
* @rdev: regulator source
|
|
|
|
*
|
|
|
|
* This function can be called many times by one task on
|
|
|
|
* a single regulator and its mutex will be locked only
|
|
|
|
* once. If a task, which is calling this function is other
|
|
|
|
* than the one, which initially locked the mutex, it will
|
|
|
|
* wait on mutex.
|
|
|
|
*/
|
|
|
|
void regulator_lock(struct regulator_dev *rdev)
|
2018-04-23 14:33:37 +00:00
|
|
|
{
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_lock_nested(rdev, NULL);
|
2018-04-23 14:33:37 +00:00
|
|
|
}
|
2018-11-20 01:20:19 +00:00
|
|
|
EXPORT_SYMBOL_GPL(regulator_lock);
|
2018-04-23 14:33:37 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_unlock - unlock a single regulator
|
|
|
|
* @rdev: regulator_source
|
|
|
|
*
|
|
|
|
* This function unlocks the mutex when the
|
|
|
|
* reference counter reaches 0.
|
|
|
|
*/
|
2018-11-18 21:56:17 +00:00
|
|
|
void regulator_unlock(struct regulator_dev *rdev)
|
2018-04-23 14:33:37 +00:00
|
|
|
{
|
2018-11-18 21:56:17 +00:00
|
|
|
mutex_lock(®ulator_nesting_mutex);
|
2018-04-23 14:33:37 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
if (--rdev->ref_cnt == 0) {
|
|
|
|
rdev->mutex_owner = NULL;
|
|
|
|
ww_mutex_unlock(&rdev->mutex);
|
2018-04-23 14:33:37 +00:00
|
|
|
}
|
2018-11-18 21:56:17 +00:00
|
|
|
|
|
|
|
WARN_ON_ONCE(rdev->ref_cnt < 0);
|
|
|
|
|
|
|
|
mutex_unlock(®ulator_nesting_mutex);
|
2018-04-23 14:33:37 +00:00
|
|
|
}
|
2018-11-20 01:20:19 +00:00
|
|
|
EXPORT_SYMBOL_GPL(regulator_unlock);
|
2018-04-23 14:33:37 +00:00
|
|
|
|
2018-11-18 21:56:18 +00:00
|
|
|
static bool regulator_supply_is_couple(struct regulator_dev *rdev)
|
2018-04-23 14:33:37 +00:00
|
|
|
{
|
2018-11-18 21:56:18 +00:00
|
|
|
struct regulator_dev *c_rdev;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 1; i < rdev->coupling_desc.n_coupled; i++) {
|
|
|
|
c_rdev = rdev->coupling_desc.coupled_rdevs[i];
|
2018-04-23 14:33:37 +00:00
|
|
|
|
2018-11-18 21:56:18 +00:00
|
|
|
if (rdev->supply->rdev == c_rdev)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
static void regulator_unlock_recursive(struct regulator_dev *rdev,
|
|
|
|
unsigned int n_coupled)
|
2015-09-30 14:05:42 +00:00
|
|
|
{
|
2018-10-05 15:36:29 +00:00
|
|
|
struct regulator_dev *c_rdev;
|
2015-11-20 14:24:39 +00:00
|
|
|
int i;
|
2015-09-30 14:05:42 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
for (i = n_coupled; i > 0; i--) {
|
|
|
|
c_rdev = rdev->coupling_desc.coupled_rdevs[i - 1];
|
2018-10-05 15:36:29 +00:00
|
|
|
|
|
|
|
if (!c_rdev)
|
|
|
|
continue;
|
|
|
|
|
2018-11-18 21:56:18 +00:00
|
|
|
if (c_rdev->supply && !regulator_supply_is_couple(c_rdev))
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_unlock_recursive(
|
|
|
|
c_rdev->supply->rdev,
|
|
|
|
c_rdev->coupling_desc.n_coupled);
|
2018-10-05 15:36:29 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_unlock(c_rdev);
|
|
|
|
}
|
2015-09-30 14:05:42 +00:00
|
|
|
}
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
static int regulator_lock_recursive(struct regulator_dev *rdev,
|
|
|
|
struct regulator_dev **new_contended_rdev,
|
|
|
|
struct regulator_dev **old_contended_rdev,
|
|
|
|
struct ww_acquire_ctx *ww_ctx)
|
2015-09-30 14:05:42 +00:00
|
|
|
{
|
2018-10-05 15:36:29 +00:00
|
|
|
struct regulator_dev *c_rdev;
|
2018-11-18 21:56:17 +00:00
|
|
|
int i, err;
|
2015-09-30 14:05:42 +00:00
|
|
|
|
2018-10-05 15:36:29 +00:00
|
|
|
for (i = 0; i < rdev->coupling_desc.n_coupled; i++) {
|
|
|
|
c_rdev = rdev->coupling_desc.coupled_rdevs[i];
|
2018-04-23 14:33:42 +00:00
|
|
|
|
2018-10-05 15:36:29 +00:00
|
|
|
if (!c_rdev)
|
|
|
|
continue;
|
2015-09-30 14:05:42 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
if (c_rdev != *old_contended_rdev) {
|
|
|
|
err = regulator_lock_nested(c_rdev, ww_ctx);
|
|
|
|
if (err) {
|
|
|
|
if (err == -EDEADLK) {
|
|
|
|
*new_contended_rdev = c_rdev;
|
|
|
|
goto err_unlock;
|
|
|
|
}
|
2018-10-05 15:36:29 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
/* shouldn't happen */
|
|
|
|
WARN_ON_ONCE(err != -EALREADY);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
*old_contended_rdev = NULL;
|
|
|
|
}
|
|
|
|
|
2018-11-18 21:56:18 +00:00
|
|
|
if (c_rdev->supply && !regulator_supply_is_couple(c_rdev)) {
|
2018-11-18 21:56:17 +00:00
|
|
|
err = regulator_lock_recursive(c_rdev->supply->rdev,
|
|
|
|
new_contended_rdev,
|
|
|
|
old_contended_rdev,
|
|
|
|
ww_ctx);
|
|
|
|
if (err) {
|
|
|
|
regulator_unlock(c_rdev);
|
|
|
|
goto err_unlock;
|
|
|
|
}
|
2018-04-23 14:33:37 +00:00
|
|
|
}
|
|
|
|
}
|
2018-11-18 21:56:17 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_unlock:
|
|
|
|
regulator_unlock_recursive(rdev, i);
|
|
|
|
|
|
|
|
return err;
|
2018-04-23 14:33:37 +00:00
|
|
|
}
|
|
|
|
|
2018-05-30 14:20:03 +00:00
|
|
|
/**
|
2018-11-18 21:56:17 +00:00
|
|
|
* regulator_unlock_dependent - unlock regulator's suppliers and coupled
|
|
|
|
* regulators
|
|
|
|
* @rdev: regulator source
|
|
|
|
* @ww_ctx: w/w mutex acquire context
|
|
|
|
*
|
2019-01-08 12:12:33 +00:00
|
|
|
* Unlock all regulators related with rdev by coupling or supplying.
|
2018-05-30 14:20:03 +00:00
|
|
|
*/
|
2018-11-18 21:56:17 +00:00
|
|
|
static void regulator_unlock_dependent(struct regulator_dev *rdev,
|
|
|
|
struct ww_acquire_ctx *ww_ctx)
|
2015-09-30 14:05:42 +00:00
|
|
|
{
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_unlock_recursive(rdev, rdev->coupling_desc.n_coupled);
|
|
|
|
ww_acquire_fini(ww_ctx);
|
2015-09-30 14:05:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2018-10-05 15:36:29 +00:00
|
|
|
* regulator_lock_dependent - lock regulator's suppliers and coupled regulators
|
|
|
|
* @rdev: regulator source
|
2018-11-18 21:56:17 +00:00
|
|
|
* @ww_ctx: w/w mutex acquire context
|
2018-10-05 15:36:29 +00:00
|
|
|
*
|
|
|
|
* This function as a wrapper on regulator_lock_recursive(), which locks
|
2019-01-08 12:12:33 +00:00
|
|
|
* all regulators related with rdev by coupling or supplying.
|
2015-09-30 14:05:42 +00:00
|
|
|
*/
|
2018-11-18 21:56:17 +00:00
|
|
|
static void regulator_lock_dependent(struct regulator_dev *rdev,
|
|
|
|
struct ww_acquire_ctx *ww_ctx)
|
2015-09-30 14:05:42 +00:00
|
|
|
{
|
2018-11-18 21:56:17 +00:00
|
|
|
struct regulator_dev *new_contended_rdev = NULL;
|
|
|
|
struct regulator_dev *old_contended_rdev = NULL;
|
|
|
|
int err;
|
2015-09-30 14:05:42 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
mutex_lock(®ulator_list_mutex);
|
2018-04-23 14:33:42 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
ww_acquire_init(ww_ctx, ®ulator_ww_class);
|
2015-09-30 14:05:42 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
do {
|
|
|
|
if (new_contended_rdev) {
|
|
|
|
ww_mutex_lock_slow(&new_contended_rdev->mutex, ww_ctx);
|
|
|
|
old_contended_rdev = new_contended_rdev;
|
|
|
|
old_contended_rdev->ref_cnt++;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = regulator_lock_recursive(rdev,
|
|
|
|
&new_contended_rdev,
|
|
|
|
&old_contended_rdev,
|
|
|
|
ww_ctx);
|
|
|
|
|
|
|
|
if (old_contended_rdev)
|
|
|
|
regulator_unlock(old_contended_rdev);
|
|
|
|
|
|
|
|
} while (err == -EDEADLK);
|
|
|
|
|
|
|
|
ww_acquire_done(ww_ctx);
|
|
|
|
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
2015-09-30 14:05:42 +00:00
|
|
|
}
|
|
|
|
|
2018-11-14 09:38:22 +00:00
|
|
|
/**
|
|
|
|
* of_get_child_regulator - get a child regulator device node
|
|
|
|
* based on supply name
|
|
|
|
* @parent: Parent device node
|
|
|
|
* @prop_name: Combination regulator supply name and "-supply"
|
|
|
|
*
|
|
|
|
* Traverse all child nodes.
|
|
|
|
* Extract the child regulator device node corresponding to the supply name.
|
|
|
|
* returns the device node corresponding to the regulator if found, else
|
|
|
|
* returns NULL.
|
|
|
|
*/
|
|
|
|
static struct device_node *of_get_child_regulator(struct device_node *parent,
|
|
|
|
const char *prop_name)
|
|
|
|
{
|
|
|
|
struct device_node *regnode = NULL;
|
|
|
|
struct device_node *child = NULL;
|
|
|
|
|
|
|
|
for_each_child_of_node(parent, child) {
|
|
|
|
regnode = of_parse_phandle(child, prop_name, 0);
|
|
|
|
|
|
|
|
if (!regnode) {
|
|
|
|
regnode = of_get_child_regulator(child, prop_name);
|
2019-08-15 05:37:04 +00:00
|
|
|
if (regnode)
|
|
|
|
goto err_node_put;
|
2018-11-14 09:38:22 +00:00
|
|
|
} else {
|
2019-08-15 05:37:04 +00:00
|
|
|
goto err_node_put;
|
2018-11-14 09:38:22 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return NULL;
|
2019-08-15 05:37:04 +00:00
|
|
|
|
|
|
|
err_node_put:
|
|
|
|
of_node_put(child);
|
|
|
|
return regnode;
|
2018-11-14 09:38:22 +00:00
|
|
|
}
|
|
|
|
|
2011-11-18 11:17:20 +00:00
|
|
|
/**
|
|
|
|
* of_get_regulator - get a regulator device node based on supply name
|
|
|
|
* @dev: Device pointer for the consumer (of regulator) device
|
|
|
|
* @supply: regulator supply name
|
|
|
|
*
|
|
|
|
* Extract the regulator device node corresponding to the supply name.
|
2013-03-23 10:00:41 +00:00
|
|
|
* returns the device node corresponding to the regulator if found, else
|
2011-11-18 11:17:20 +00:00
|
|
|
* returns NULL.
|
|
|
|
*/
|
|
|
|
static struct device_node *of_get_regulator(struct device *dev, const char *supply)
|
|
|
|
{
|
|
|
|
struct device_node *regnode = NULL;
|
|
|
|
char prop_name[32]; /* 32 is max size of property name */
|
|
|
|
|
|
|
|
dev_dbg(dev, "Looking up %s-supply from device tree\n", supply);
|
|
|
|
|
|
|
|
snprintf(prop_name, 32, "%s-supply", supply);
|
|
|
|
regnode = of_parse_phandle(dev->of_node, prop_name, 0);
|
|
|
|
|
|
|
|
if (!regnode) {
|
2018-11-14 09:38:22 +00:00
|
|
|
regnode = of_get_child_regulator(dev->of_node, prop_name);
|
|
|
|
if (regnode)
|
|
|
|
return regnode;
|
|
|
|
|
2017-07-18 21:43:26 +00:00
|
|
|
dev_dbg(dev, "Looking up %s property in node %pOF failed\n",
|
|
|
|
prop_name, dev->of_node);
|
2011-11-18 11:17:20 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return regnode;
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/* Platform voltage constraint check */
|
2019-06-23 21:08:32 +00:00
|
|
|
int regulator_check_voltage(struct regulator_dev *rdev,
|
|
|
|
int *min_uV, int *max_uV)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
|
|
|
BUG_ON(*min_uV > *max_uV);
|
|
|
|
|
2016-04-23 07:11:05 +00:00
|
|
|
if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
|
2015-09-16 19:10:26 +00:00
|
|
|
rdev_err(rdev, "voltage operation not allowed\n");
|
2008-04-30 14:59:04 +00:00
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*max_uV > rdev->constraints->max_uV)
|
|
|
|
*max_uV = rdev->constraints->max_uV;
|
|
|
|
if (*min_uV < rdev->constraints->min_uV)
|
|
|
|
*min_uV = rdev->constraints->min_uV;
|
|
|
|
|
2011-07-12 02:20:37 +00:00
|
|
|
if (*min_uV > *max_uV) {
|
|
|
|
rdev_err(rdev, "unsupportable voltage range: %d-%duV\n",
|
2011-07-21 14:07:37 +00:00
|
|
|
*min_uV, *max_uV);
|
2008-04-30 14:59:04 +00:00
|
|
|
return -EINVAL;
|
2011-07-12 02:20:37 +00:00
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-01-26 13:08:47 +00:00
|
|
|
/* return 0 if the state is valid */
|
|
|
|
static int regulator_check_states(suspend_state_t state)
|
|
|
|
{
|
|
|
|
return (state > PM_SUSPEND_MAX || state == PM_SUSPEND_TO_IDLE);
|
|
|
|
}
|
|
|
|
|
2010-12-03 10:31:07 +00:00
|
|
|
/* Make sure we select a voltage that suits the needs of all
|
|
|
|
* regulator consumers
|
|
|
|
*/
|
2019-06-23 21:08:32 +00:00
|
|
|
int regulator_check_consumers(struct regulator_dev *rdev,
|
|
|
|
int *min_uV, int *max_uV,
|
|
|
|
suspend_state_t state)
|
2010-12-03 10:31:07 +00:00
|
|
|
{
|
|
|
|
struct regulator *regulator;
|
2018-01-26 13:08:44 +00:00
|
|
|
struct regulator_voltage *voltage;
|
2010-12-03 10:31:07 +00:00
|
|
|
|
|
|
|
list_for_each_entry(regulator, &rdev->consumer_list, list) {
|
2018-01-26 13:08:44 +00:00
|
|
|
voltage = ®ulator->voltage[state];
|
2011-05-14 20:42:34 +00:00
|
|
|
/*
|
|
|
|
* Assume consumers that didn't say anything are OK
|
|
|
|
* with anything in the constraint range.
|
|
|
|
*/
|
2018-01-26 13:08:44 +00:00
|
|
|
if (!voltage->min_uV && !voltage->max_uV)
|
2011-05-14 20:42:34 +00:00
|
|
|
continue;
|
|
|
|
|
2018-01-26 13:08:44 +00:00
|
|
|
if (*max_uV > voltage->max_uV)
|
|
|
|
*max_uV = voltage->max_uV;
|
|
|
|
if (*min_uV < voltage->min_uV)
|
|
|
|
*min_uV = voltage->min_uV;
|
2010-12-03 10:31:07 +00:00
|
|
|
}
|
|
|
|
|
2012-11-28 17:09:27 +00:00
|
|
|
if (*min_uV > *max_uV) {
|
2013-02-14 12:46:33 +00:00
|
|
|
rdev_err(rdev, "Restricting voltage, %u-%uuV\n",
|
|
|
|
*min_uV, *max_uV);
|
2010-12-03 10:31:07 +00:00
|
|
|
return -EINVAL;
|
2012-11-28 17:09:27 +00:00
|
|
|
}
|
2010-12-03 10:31:07 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/* current constraint check */
|
|
|
|
static int regulator_check_current_limit(struct regulator_dev *rdev,
|
|
|
|
int *min_uA, int *max_uA)
|
|
|
|
{
|
|
|
|
BUG_ON(*min_uA > *max_uA);
|
|
|
|
|
2016-04-23 07:11:05 +00:00
|
|
|
if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_CURRENT)) {
|
2015-09-16 19:10:26 +00:00
|
|
|
rdev_err(rdev, "current operation not allowed\n");
|
2008-04-30 14:59:04 +00:00
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*max_uA > rdev->constraints->max_uA)
|
|
|
|
*max_uA = rdev->constraints->max_uA;
|
|
|
|
if (*min_uA < rdev->constraints->min_uA)
|
|
|
|
*min_uA = rdev->constraints->min_uA;
|
|
|
|
|
2011-07-12 02:20:37 +00:00
|
|
|
if (*min_uA > *max_uA) {
|
|
|
|
rdev_err(rdev, "unsupportable current range: %d-%duA\n",
|
2011-07-21 14:07:37 +00:00
|
|
|
*min_uA, *max_uA);
|
2008-04-30 14:59:04 +00:00
|
|
|
return -EINVAL;
|
2011-07-12 02:20:37 +00:00
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* operating mode constraint check */
|
2016-11-29 11:50:03 +00:00
|
|
|
static int regulator_mode_constrain(struct regulator_dev *rdev,
|
|
|
|
unsigned int *mode)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
2011-03-29 21:29:12 +00:00
|
|
|
switch (*mode) {
|
2008-11-16 19:46:56 +00:00
|
|
|
case REGULATOR_MODE_FAST:
|
|
|
|
case REGULATOR_MODE_NORMAL:
|
|
|
|
case REGULATOR_MODE_IDLE:
|
|
|
|
case REGULATOR_MODE_STANDBY:
|
|
|
|
break;
|
|
|
|
default:
|
2011-07-12 02:20:37 +00:00
|
|
|
rdev_err(rdev, "invalid mode %x specified\n", *mode);
|
2008-11-16 19:46:56 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-04-23 07:11:05 +00:00
|
|
|
if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_MODE)) {
|
2015-09-16 19:10:26 +00:00
|
|
|
rdev_err(rdev, "mode operation not allowed\n");
|
2008-04-30 14:59:04 +00:00
|
|
|
return -EPERM;
|
|
|
|
}
|
2011-03-29 21:29:12 +00:00
|
|
|
|
|
|
|
/* The modes are bitmasks, the most power hungry modes having
|
|
|
|
* the lowest values. If the requested mode isn't supported
|
|
|
|
* try higher modes. */
|
|
|
|
while (*mode) {
|
|
|
|
if (rdev->constraints->valid_modes_mask & *mode)
|
|
|
|
return 0;
|
|
|
|
*mode /= 2;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2011-03-29 21:29:12 +00:00
|
|
|
|
|
|
|
return -EINVAL;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
2018-01-26 13:08:47 +00:00
|
|
|
static inline struct regulator_state *
|
|
|
|
regulator_get_suspend_state(struct regulator_dev *rdev, suspend_state_t state)
|
|
|
|
{
|
|
|
|
if (rdev->constraints == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
switch (state) {
|
|
|
|
case PM_SUSPEND_STANDBY:
|
|
|
|
return &rdev->constraints->state_standby;
|
|
|
|
case PM_SUSPEND_MEM:
|
|
|
|
return &rdev->constraints->state_mem;
|
|
|
|
case PM_SUSPEND_MAX:
|
|
|
|
return &rdev->constraints->state_disk;
|
|
|
|
default:
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-04 07:08:37 +00:00
|
|
|
static const struct regulator_state *
|
|
|
|
regulator_get_suspend_state_check(struct regulator_dev *rdev, suspend_state_t state)
|
|
|
|
{
|
|
|
|
const struct regulator_state *rstate;
|
|
|
|
|
|
|
|
rstate = regulator_get_suspend_state(rdev, state);
|
|
|
|
if (rstate == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* If we have no suspend mode configuration don't set anything;
|
|
|
|
* only warn if the driver implements set_suspend_voltage or
|
|
|
|
* set_suspend_mode callback.
|
|
|
|
*/
|
|
|
|
if (rstate->enabled != ENABLE_IN_SUSPEND &&
|
|
|
|
rstate->enabled != DISABLE_IN_SUSPEND) {
|
|
|
|
if (rdev->desc->ops->set_suspend_voltage ||
|
|
|
|
rdev->desc->ops->set_suspend_mode)
|
|
|
|
rdev_warn(rdev, "No configuration\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rstate;
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
static ssize_t regulator_uV_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2019-09-10 19:22:29 +00:00
|
|
|
int uV;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2019-09-10 19:22:29 +00:00
|
|
|
uV = regulator_get_voltage_rdev(rdev);
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2019-09-10 19:22:29 +00:00
|
|
|
if (uV < 0)
|
|
|
|
return uV;
|
|
|
|
return sprintf(buf, "%d\n", uV);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(microvolts, 0444, regulator_uV_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_uA_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", _regulator_get_current_limit(rdev));
|
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(microamps, 0444, regulator_uA_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2013-07-24 22:05:21 +00:00
|
|
|
static ssize_t name_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2008-10-10 14:33:20 +00:00
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
|
|
|
|
2009-10-22 15:31:32 +00:00
|
|
|
return sprintf(buf, "%s\n", rdev_get_name(rdev));
|
2008-10-10 14:33:20 +00:00
|
|
|
}
|
2013-07-24 22:05:21 +00:00
|
|
|
static DEVICE_ATTR_RO(name);
|
2008-10-10 14:33:20 +00:00
|
|
|
|
2018-08-16 20:28:01 +00:00
|
|
|
static const char *regulator_opmode_to_str(int mode)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
|
|
|
switch (mode) {
|
|
|
|
case REGULATOR_MODE_FAST:
|
2018-08-16 20:28:01 +00:00
|
|
|
return "fast";
|
2008-04-30 14:59:04 +00:00
|
|
|
case REGULATOR_MODE_NORMAL:
|
2018-08-16 20:28:01 +00:00
|
|
|
return "normal";
|
2008-04-30 14:59:04 +00:00
|
|
|
case REGULATOR_MODE_IDLE:
|
2018-08-16 20:28:01 +00:00
|
|
|
return "idle";
|
2008-04-30 14:59:04 +00:00
|
|
|
case REGULATOR_MODE_STANDBY:
|
2018-08-16 20:28:01 +00:00
|
|
|
return "standby";
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2018-08-16 20:28:01 +00:00
|
|
|
return "unknown";
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t regulator_print_opmode(char *buf, int mode)
|
|
|
|
{
|
|
|
|
return sprintf(buf, "%s\n", regulator_opmode_to_str(mode));
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
2008-11-12 01:38:53 +00:00
|
|
|
static ssize_t regulator_opmode_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2008-11-12 01:38:53 +00:00
|
|
|
return regulator_print_opmode(buf, _regulator_get_mode(rdev));
|
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(opmode, 0444, regulator_opmode_show, NULL);
|
2008-11-12 01:38:53 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_print_state(char *buf, int state)
|
|
|
|
{
|
2008-04-30 14:59:04 +00:00
|
|
|
if (state > 0)
|
|
|
|
return sprintf(buf, "enabled\n");
|
|
|
|
else if (state == 0)
|
|
|
|
return sprintf(buf, "disabled\n");
|
|
|
|
else
|
|
|
|
return sprintf(buf, "unknown\n");
|
|
|
|
}
|
|
|
|
|
2008-11-12 01:38:53 +00:00
|
|
|
static ssize_t regulator_state_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2009-08-03 17:49:56 +00:00
|
|
|
ssize_t ret;
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2009-08-03 17:49:56 +00:00
|
|
|
ret = regulator_print_state(buf, _regulator_is_enabled(rdev));
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2008-11-12 01:38:53 +00:00
|
|
|
|
2009-08-03 17:49:56 +00:00
|
|
|
return ret;
|
2008-11-12 01:38:53 +00:00
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(state, 0444, regulator_state_show, NULL);
|
2008-11-12 01:38:53 +00:00
|
|
|
|
2009-01-15 07:03:17 +00:00
|
|
|
static ssize_t regulator_status_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
|
|
|
int status;
|
|
|
|
char *label;
|
|
|
|
|
|
|
|
status = rdev->desc->ops->get_status(rdev);
|
|
|
|
if (status < 0)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
switch (status) {
|
|
|
|
case REGULATOR_STATUS_OFF:
|
|
|
|
label = "off";
|
|
|
|
break;
|
|
|
|
case REGULATOR_STATUS_ON:
|
|
|
|
label = "on";
|
|
|
|
break;
|
|
|
|
case REGULATOR_STATUS_ERROR:
|
|
|
|
label = "error";
|
|
|
|
break;
|
|
|
|
case REGULATOR_STATUS_FAST:
|
|
|
|
label = "fast";
|
|
|
|
break;
|
|
|
|
case REGULATOR_STATUS_NORMAL:
|
|
|
|
label = "normal";
|
|
|
|
break;
|
|
|
|
case REGULATOR_STATUS_IDLE:
|
|
|
|
label = "idle";
|
|
|
|
break;
|
|
|
|
case REGULATOR_STATUS_STANDBY:
|
|
|
|
label = "standby";
|
|
|
|
break;
|
2012-08-31 17:36:37 +00:00
|
|
|
case REGULATOR_STATUS_BYPASS:
|
|
|
|
label = "bypass";
|
|
|
|
break;
|
2012-07-12 12:53:35 +00:00
|
|
|
case REGULATOR_STATUS_UNDEFINED:
|
|
|
|
label = "undefined";
|
|
|
|
break;
|
2009-01-15 07:03:17 +00:00
|
|
|
default:
|
|
|
|
return -ERANGE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return sprintf(buf, "%s\n", label);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR(status, 0444, regulator_status_show, NULL);
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
static ssize_t regulator_min_uA_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
if (!rdev->constraints)
|
|
|
|
return sprintf(buf, "constraint not defined\n");
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->min_uA);
|
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(min_microamps, 0444, regulator_min_uA_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_max_uA_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
if (!rdev->constraints)
|
|
|
|
return sprintf(buf, "constraint not defined\n");
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->max_uA);
|
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(max_microamps, 0444, regulator_max_uA_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_min_uV_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
if (!rdev->constraints)
|
|
|
|
return sprintf(buf, "constraint not defined\n");
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->min_uV);
|
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(min_microvolts, 0444, regulator_min_uV_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_max_uV_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
if (!rdev->constraints)
|
|
|
|
return sprintf(buf, "constraint not defined\n");
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->max_uV);
|
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(max_microvolts, 0444, regulator_max_uV_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_total_uA_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
struct regulator *regulator;
|
|
|
|
int uA = 0;
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2018-11-20 17:52:53 +00:00
|
|
|
list_for_each_entry(regulator, &rdev->consumer_list, list) {
|
|
|
|
if (regulator->enable_count)
|
|
|
|
uA += regulator->uA_load;
|
|
|
|
}
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
return sprintf(buf, "%d\n", uA);
|
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(requested_microamps, 0444, regulator_total_uA_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2013-07-24 22:05:21 +00:00
|
|
|
static ssize_t num_users_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
return sprintf(buf, "%d\n", rdev->use_count);
|
|
|
|
}
|
2013-07-24 22:05:21 +00:00
|
|
|
static DEVICE_ATTR_RO(num_users);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2013-07-24 22:05:21 +00:00
|
|
|
static ssize_t type_show(struct device *dev, struct device_attribute *attr,
|
|
|
|
char *buf)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
switch (rdev->desc->type) {
|
|
|
|
case REGULATOR_VOLTAGE:
|
|
|
|
return sprintf(buf, "voltage\n");
|
|
|
|
case REGULATOR_CURRENT:
|
|
|
|
return sprintf(buf, "current\n");
|
|
|
|
}
|
|
|
|
return sprintf(buf, "unknown\n");
|
|
|
|
}
|
2013-07-24 22:05:21 +00:00
|
|
|
static DEVICE_ATTR_RO(type);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_mem_uV_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->state_mem.uV);
|
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(suspend_mem_microvolts, 0444,
|
|
|
|
regulator_suspend_mem_uV_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_disk_uV_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->state_disk.uV);
|
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(suspend_disk_microvolts, 0444,
|
|
|
|
regulator_suspend_disk_uV_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_standby_uV_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", rdev->constraints->state_standby.uV);
|
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(suspend_standby_microvolts, 0444,
|
|
|
|
regulator_suspend_standby_uV_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_mem_mode_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2008-11-12 01:38:53 +00:00
|
|
|
return regulator_print_opmode(buf,
|
|
|
|
rdev->constraints->state_mem.mode);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(suspend_mem_mode, 0444,
|
|
|
|
regulator_suspend_mem_mode_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_disk_mode_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2008-11-12 01:38:53 +00:00
|
|
|
return regulator_print_opmode(buf,
|
|
|
|
rdev->constraints->state_disk.mode);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(suspend_disk_mode, 0444,
|
|
|
|
regulator_suspend_disk_mode_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_standby_mode_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2008-11-12 01:38:53 +00:00
|
|
|
return regulator_print_opmode(buf,
|
|
|
|
rdev->constraints->state_standby.mode);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(suspend_standby_mode, 0444,
|
|
|
|
regulator_suspend_standby_mode_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_mem_state_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2008-11-12 01:38:53 +00:00
|
|
|
return regulator_print_state(buf,
|
|
|
|
rdev->constraints->state_mem.enabled);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(suspend_mem_state, 0444,
|
|
|
|
regulator_suspend_mem_state_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_disk_state_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2008-11-12 01:38:53 +00:00
|
|
|
return regulator_print_state(buf,
|
|
|
|
rdev->constraints->state_disk.enabled);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(suspend_disk_state, 0444,
|
|
|
|
regulator_suspend_disk_state_show, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static ssize_t regulator_suspend_standby_state_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2008-11-12 01:38:53 +00:00
|
|
|
return regulator_print_state(buf,
|
|
|
|
rdev->constraints->state_standby.enabled);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
static DEVICE_ATTR(suspend_standby_state, 0444,
|
|
|
|
regulator_suspend_standby_state_show, NULL);
|
|
|
|
|
2012-08-31 17:36:37 +00:00
|
|
|
static ssize_t regulator_bypass_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
|
|
|
const char *report;
|
|
|
|
bool bypass;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = rdev->desc->ops->get_bypass(rdev, &bypass);
|
|
|
|
|
|
|
|
if (ret != 0)
|
|
|
|
report = "unknown";
|
|
|
|
else if (bypass)
|
|
|
|
report = "enabled";
|
|
|
|
else
|
|
|
|
report = "disabled";
|
|
|
|
|
|
|
|
return sprintf(buf, "%s\n", report);
|
|
|
|
}
|
|
|
|
static DEVICE_ATTR(bypass, 0444,
|
|
|
|
regulator_bypass_show, NULL);
|
2008-10-10 14:33:20 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/* Calculate the new optimum regulator operating mode based on the new total
|
|
|
|
* consumer load. All locks held by caller */
|
2015-01-28 02:46:31 +00:00
|
|
|
static int drms_uA_update(struct regulator_dev *rdev)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
|
|
|
struct regulator *sibling;
|
|
|
|
int current_uA = 0, output_uV, input_uV, err;
|
|
|
|
unsigned int mode;
|
|
|
|
|
2015-01-28 02:46:31 +00:00
|
|
|
/*
|
|
|
|
* first check to see if we can set modes at all, otherwise just
|
|
|
|
* tell the consumer everything is OK.
|
|
|
|
*/
|
2019-02-21 11:55:22 +00:00
|
|
|
if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_DRMS)) {
|
|
|
|
rdev_dbg(rdev, "DRMS operation not allowed\n");
|
2015-01-28 02:46:31 +00:00
|
|
|
return 0;
|
2019-02-21 11:55:22 +00:00
|
|
|
}
|
2015-01-28 02:46:31 +00:00
|
|
|
|
2015-02-12 03:39:12 +00:00
|
|
|
if (!rdev->desc->ops->get_optimum_mode &&
|
|
|
|
!rdev->desc->ops->set_load)
|
2015-01-28 02:46:31 +00:00
|
|
|
return 0;
|
|
|
|
|
2015-02-12 03:39:12 +00:00
|
|
|
if (!rdev->desc->ops->set_mode &&
|
|
|
|
!rdev->desc->ops->set_load)
|
2015-01-28 02:46:31 +00:00
|
|
|
return -EINVAL;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
/* calc total requested load */
|
2018-11-20 17:52:53 +00:00
|
|
|
list_for_each_entry(sibling, &rdev->consumer_list, list) {
|
|
|
|
if (sibling->enable_count)
|
|
|
|
current_uA += sibling->uA_load;
|
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2015-06-12 00:37:03 +00:00
|
|
|
current_uA += rdev->constraints->system_load;
|
|
|
|
|
2015-02-12 03:39:12 +00:00
|
|
|
if (rdev->desc->ops->set_load) {
|
|
|
|
/* set the optimum mode for our new total regulator load */
|
|
|
|
err = rdev->desc->ops->set_load(rdev, current_uA);
|
|
|
|
if (err < 0)
|
|
|
|
rdev_err(rdev, "failed to set load %d\n", current_uA);
|
|
|
|
} else {
|
2016-09-19 21:46:54 +00:00
|
|
|
/* get output voltage */
|
2019-06-23 21:08:32 +00:00
|
|
|
output_uV = regulator_get_voltage_rdev(rdev);
|
2016-09-19 21:46:54 +00:00
|
|
|
if (output_uV <= 0) {
|
|
|
|
rdev_err(rdev, "invalid output voltage found\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* get input voltage */
|
|
|
|
input_uV = 0;
|
|
|
|
if (rdev->supply)
|
|
|
|
input_uV = regulator_get_voltage(rdev->supply);
|
|
|
|
if (input_uV <= 0)
|
|
|
|
input_uV = rdev->constraints->input_uV;
|
|
|
|
if (input_uV <= 0) {
|
|
|
|
rdev_err(rdev, "invalid input voltage found\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2015-02-12 03:39:12 +00:00
|
|
|
/* now get the optimum mode for our new total regulator load */
|
|
|
|
mode = rdev->desc->ops->get_optimum_mode(rdev, input_uV,
|
|
|
|
output_uV, current_uA);
|
|
|
|
|
|
|
|
/* check the new mode is allowed */
|
|
|
|
err = regulator_mode_constrain(rdev, &mode);
|
|
|
|
if (err < 0) {
|
|
|
|
rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n",
|
|
|
|
current_uA, input_uV, output_uV);
|
|
|
|
return err;
|
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2015-02-12 03:39:12 +00:00
|
|
|
err = rdev->desc->ops->set_mode(rdev, mode);
|
|
|
|
if (err < 0)
|
|
|
|
rdev_err(rdev, "failed to set optimum mode %x\n", mode);
|
2015-01-28 02:46:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return err;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
2020-08-04 07:08:37 +00:00
|
|
|
static int __suspend_set_state(struct regulator_dev *rdev,
|
|
|
|
const struct regulator_state *rstate)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
2009-10-22 15:31:33 +00:00
|
|
|
|
2018-01-26 13:08:45 +00:00
|
|
|
if (rstate->enabled == ENABLE_IN_SUSPEND &&
|
|
|
|
rdev->desc->ops->set_suspend_enable)
|
2008-04-30 14:59:04 +00:00
|
|
|
ret = rdev->desc->ops->set_suspend_enable(rdev);
|
2018-01-26 13:08:45 +00:00
|
|
|
else if (rstate->enabled == DISABLE_IN_SUSPEND &&
|
|
|
|
rdev->desc->ops->set_suspend_disable)
|
2008-04-30 14:59:04 +00:00
|
|
|
ret = rdev->desc->ops->set_suspend_disable(rdev);
|
2012-04-14 01:14:34 +00:00
|
|
|
else /* OK if set_suspend_enable or set_suspend_disable is NULL */
|
|
|
|
ret = 0;
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
if (ret < 0) {
|
2010-11-30 13:53:48 +00:00
|
|
|
rdev_err(rdev, "failed to enabled/disable\n");
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
|
|
|
|
ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
|
|
|
|
if (ret < 0) {
|
2010-11-30 13:53:48 +00:00
|
|
|
rdev_err(rdev, "failed to set voltage\n");
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
|
|
|
|
ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
|
|
|
|
if (ret < 0) {
|
2010-11-30 13:53:48 +00:00
|
|
|
rdev_err(rdev, "failed to set mode\n");
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-26 13:08:47 +00:00
|
|
|
return ret;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
2020-08-04 07:08:37 +00:00
|
|
|
static int suspend_set_initial_state(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
const struct regulator_state *rstate;
|
|
|
|
|
|
|
|
rstate = regulator_get_suspend_state_check(rdev,
|
|
|
|
rdev->constraints->initial_state);
|
|
|
|
if (!rstate)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return __suspend_set_state(rdev, rstate);
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
static void print_constraints(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
struct regulation_constraints *constraints = rdev->constraints;
|
2015-06-09 20:09:42 +00:00
|
|
|
char buf[160] = "";
|
2015-06-10 06:13:15 +00:00
|
|
|
size_t len = sizeof(buf) - 1;
|
2009-10-22 15:31:31 +00:00
|
|
|
int count = 0;
|
|
|
|
int ret;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2009-10-22 15:31:31 +00:00
|
|
|
if (constraints->min_uV && constraints->max_uV) {
|
2008-04-30 14:59:04 +00:00
|
|
|
if (constraints->min_uV == constraints->max_uV)
|
2015-06-10 06:13:15 +00:00
|
|
|
count += scnprintf(buf + count, len - count, "%d mV ",
|
|
|
|
constraints->min_uV / 1000);
|
2008-04-30 14:59:04 +00:00
|
|
|
else
|
2015-06-10 06:13:15 +00:00
|
|
|
count += scnprintf(buf + count, len - count,
|
|
|
|
"%d <--> %d mV ",
|
|
|
|
constraints->min_uV / 1000,
|
|
|
|
constraints->max_uV / 1000);
|
2009-10-22 15:31:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!constraints->min_uV ||
|
|
|
|
constraints->min_uV != constraints->max_uV) {
|
2019-06-23 21:08:32 +00:00
|
|
|
ret = regulator_get_voltage_rdev(rdev);
|
2009-10-22 15:31:31 +00:00
|
|
|
if (ret > 0)
|
2015-06-10 06:13:15 +00:00
|
|
|
count += scnprintf(buf + count, len - count,
|
|
|
|
"at %d mV ", ret / 1000);
|
2009-10-22 15:31:31 +00:00
|
|
|
}
|
|
|
|
|
2011-05-08 21:13:37 +00:00
|
|
|
if (constraints->uV_offset)
|
2015-06-10 06:13:15 +00:00
|
|
|
count += scnprintf(buf + count, len - count, "%dmV offset ",
|
|
|
|
constraints->uV_offset / 1000);
|
2011-05-08 21:13:37 +00:00
|
|
|
|
2009-10-22 15:31:31 +00:00
|
|
|
if (constraints->min_uA && constraints->max_uA) {
|
2008-04-30 14:59:04 +00:00
|
|
|
if (constraints->min_uA == constraints->max_uA)
|
2015-06-10 06:13:15 +00:00
|
|
|
count += scnprintf(buf + count, len - count, "%d mA ",
|
|
|
|
constraints->min_uA / 1000);
|
2008-04-30 14:59:04 +00:00
|
|
|
else
|
2015-06-10 06:13:15 +00:00
|
|
|
count += scnprintf(buf + count, len - count,
|
|
|
|
"%d <--> %d mA ",
|
|
|
|
constraints->min_uA / 1000,
|
|
|
|
constraints->max_uA / 1000);
|
2009-10-22 15:31:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!constraints->min_uA ||
|
|
|
|
constraints->min_uA != constraints->max_uA) {
|
|
|
|
ret = _regulator_get_current_limit(rdev);
|
|
|
|
if (ret > 0)
|
2015-06-10 06:13:15 +00:00
|
|
|
count += scnprintf(buf + count, len - count,
|
|
|
|
"at %d mA ", ret / 1000);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2009-10-22 15:31:31 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
if (constraints->valid_modes_mask & REGULATOR_MODE_FAST)
|
2015-06-10 06:13:15 +00:00
|
|
|
count += scnprintf(buf + count, len - count, "fast ");
|
2008-04-30 14:59:04 +00:00
|
|
|
if (constraints->valid_modes_mask & REGULATOR_MODE_NORMAL)
|
2015-06-10 06:13:15 +00:00
|
|
|
count += scnprintf(buf + count, len - count, "normal ");
|
2008-04-30 14:59:04 +00:00
|
|
|
if (constraints->valid_modes_mask & REGULATOR_MODE_IDLE)
|
2015-06-10 06:13:15 +00:00
|
|
|
count += scnprintf(buf + count, len - count, "idle ");
|
2008-04-30 14:59:04 +00:00
|
|
|
if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
|
2015-06-10 06:13:15 +00:00
|
|
|
count += scnprintf(buf + count, len - count, "standby");
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2012-08-07 19:01:37 +00:00
|
|
|
if (!count)
|
2015-06-10 06:13:15 +00:00
|
|
|
scnprintf(buf, len, "no parameters");
|
2012-08-07 19:01:37 +00:00
|
|
|
|
2014-10-31 19:11:59 +00:00
|
|
|
rdev_dbg(rdev, "%s\n", buf);
|
2012-02-09 13:26:13 +00:00
|
|
|
|
|
|
|
if ((constraints->min_uV != constraints->max_uV) &&
|
2016-04-23 07:11:05 +00:00
|
|
|
!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE))
|
2012-02-09 13:26:13 +00:00
|
|
|
rdev_warn(rdev,
|
|
|
|
"Voltage range but no REGULATOR_CHANGE_VOLTAGE\n");
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
2009-10-19 14:53:50 +00:00
|
|
|
static int machine_constraints_voltage(struct regulator_dev *rdev,
|
2009-10-22 15:31:32 +00:00
|
|
|
struct regulation_constraints *constraints)
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
{
|
2014-08-13 11:33:38 +00:00
|
|
|
const struct regulator_ops *ops = rdev->desc->ops;
|
2009-10-22 15:31:30 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* do we need to apply the constraint voltage */
|
|
|
|
if (rdev->constraints->apply_uV &&
|
2016-03-21 18:12:52 +00:00
|
|
|
rdev->constraints->min_uV && rdev->constraints->max_uV) {
|
|
|
|
int target_min, target_max;
|
2019-06-23 21:08:32 +00:00
|
|
|
int current_uV = regulator_get_voltage_rdev(rdev);
|
2018-05-15 22:07:17 +00:00
|
|
|
|
|
|
|
if (current_uV == -ENOTRECOVERABLE) {
|
2019-01-08 12:12:33 +00:00
|
|
|
/* This regulator can't be read and must be initialized */
|
2018-05-15 22:07:17 +00:00
|
|
|
rdev_info(rdev, "Setting %d-%duV\n",
|
|
|
|
rdev->constraints->min_uV,
|
|
|
|
rdev->constraints->max_uV);
|
|
|
|
_regulator_do_set_voltage(rdev,
|
|
|
|
rdev->constraints->min_uV,
|
|
|
|
rdev->constraints->max_uV);
|
2019-06-23 21:08:32 +00:00
|
|
|
current_uV = regulator_get_voltage_rdev(rdev);
|
2018-05-15 22:07:17 +00:00
|
|
|
}
|
|
|
|
|
2014-05-20 10:12:16 +00:00
|
|
|
if (current_uV < 0) {
|
2014-06-04 19:53:25 +00:00
|
|
|
rdev_err(rdev,
|
|
|
|
"failed to get the current voltage(%d)\n",
|
|
|
|
current_uV);
|
2014-05-20 10:12:16 +00:00
|
|
|
return current_uV;
|
|
|
|
}
|
2016-03-21 18:12:52 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're below the minimum voltage move up to the
|
|
|
|
* minimum voltage, if we're above the maximum voltage
|
|
|
|
* then move down to the maximum.
|
|
|
|
*/
|
|
|
|
target_min = current_uV;
|
|
|
|
target_max = current_uV;
|
|
|
|
|
|
|
|
if (current_uV < rdev->constraints->min_uV) {
|
|
|
|
target_min = rdev->constraints->min_uV;
|
|
|
|
target_max = rdev->constraints->min_uV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (current_uV > rdev->constraints->max_uV) {
|
|
|
|
target_min = rdev->constraints->max_uV;
|
|
|
|
target_max = rdev->constraints->max_uV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (target_min != current_uV || target_max != current_uV) {
|
2016-03-29 23:33:42 +00:00
|
|
|
rdev_info(rdev, "Bringing %duV into %d-%duV\n",
|
|
|
|
current_uV, target_min, target_max);
|
2014-05-20 10:12:16 +00:00
|
|
|
ret = _regulator_do_set_voltage(
|
2016-03-21 18:12:52 +00:00
|
|
|
rdev, target_min, target_max);
|
2014-05-20 10:12:16 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
rdev_err(rdev,
|
2016-03-21 18:12:52 +00:00
|
|
|
"failed to apply %d-%duV constraint(%d)\n",
|
|
|
|
target_min, target_max, ret);
|
2014-05-20 10:12:16 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2010-12-12 14:25:50 +00:00
|
|
|
}
|
2009-10-22 15:31:30 +00:00
|
|
|
}
|
2008-09-09 15:21:19 +00:00
|
|
|
|
2009-02-26 19:48:36 +00:00
|
|
|
/* constrain machine-level voltage specs to fit
|
|
|
|
* the actual range supported by this regulator.
|
|
|
|
*/
|
|
|
|
if (ops->list_voltage && rdev->desc->n_voltages) {
|
|
|
|
int count = rdev->desc->n_voltages;
|
|
|
|
int i;
|
|
|
|
int min_uV = INT_MAX;
|
|
|
|
int max_uV = INT_MIN;
|
|
|
|
int cmin = constraints->min_uV;
|
|
|
|
int cmax = constraints->max_uV;
|
|
|
|
|
2009-04-28 10:09:38 +00:00
|
|
|
/* it's safe to autoconfigure fixed-voltage supplies
|
|
|
|
and the constraints are used by list_voltage. */
|
2009-02-26 19:48:36 +00:00
|
|
|
if (count == 1 && !cmin) {
|
2009-04-28 10:09:38 +00:00
|
|
|
cmin = 1;
|
2009-02-26 19:48:36 +00:00
|
|
|
cmax = INT_MAX;
|
2009-04-28 10:09:38 +00:00
|
|
|
constraints->min_uV = cmin;
|
|
|
|
constraints->max_uV = cmax;
|
2009-02-26 19:48:36 +00:00
|
|
|
}
|
|
|
|
|
2009-03-10 16:28:36 +00:00
|
|
|
/* voltage constraints are optional */
|
|
|
|
if ((cmin == 0) && (cmax == 0))
|
2009-10-19 14:53:50 +00:00
|
|
|
return 0;
|
2009-03-10 16:28:36 +00:00
|
|
|
|
2009-02-26 19:48:36 +00:00
|
|
|
/* else require explicit machine-level constraints */
|
2009-03-10 16:28:36 +00:00
|
|
|
if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
|
2010-11-30 13:53:48 +00:00
|
|
|
rdev_err(rdev, "invalid voltage constraints\n");
|
2009-10-19 14:53:50 +00:00
|
|
|
return -EINVAL;
|
2009-02-26 19:48:36 +00:00
|
|
|
}
|
|
|
|
|
2019-12-09 12:52:39 +00:00
|
|
|
/* no need to loop voltages if range is continuous */
|
|
|
|
if (rdev->desc->continuous_voltage_range)
|
|
|
|
return 0;
|
|
|
|
|
2009-02-26 19:48:36 +00:00
|
|
|
/* initial: [cmin..cmax] valid, [min_uV..max_uV] not */
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
int value;
|
|
|
|
|
|
|
|
value = ops->list_voltage(rdev, i);
|
|
|
|
if (value <= 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* maybe adjust [min_uV..max_uV] */
|
|
|
|
if (value >= cmin && value < min_uV)
|
|
|
|
min_uV = value;
|
|
|
|
if (value <= cmax && value > max_uV)
|
|
|
|
max_uV = value;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* final: [min_uV..max_uV] valid iff constraints valid */
|
|
|
|
if (max_uV < min_uV) {
|
2012-11-27 18:48:56 +00:00
|
|
|
rdev_err(rdev,
|
|
|
|
"unsupportable voltage constraints %u-%uuV\n",
|
|
|
|
min_uV, max_uV);
|
2009-10-19 14:53:50 +00:00
|
|
|
return -EINVAL;
|
2009-02-26 19:48:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* use regulator's subset of machine constraints */
|
|
|
|
if (constraints->min_uV < min_uV) {
|
2010-11-30 13:53:48 +00:00
|
|
|
rdev_dbg(rdev, "override min_uV, %d -> %d\n",
|
|
|
|
constraints->min_uV, min_uV);
|
2009-02-26 19:48:36 +00:00
|
|
|
constraints->min_uV = min_uV;
|
|
|
|
}
|
|
|
|
if (constraints->max_uV > max_uV) {
|
2010-11-30 13:53:48 +00:00
|
|
|
rdev_dbg(rdev, "override max_uV, %d -> %d\n",
|
|
|
|
constraints->max_uV, max_uV);
|
2009-02-26 19:48:36 +00:00
|
|
|
constraints->max_uV = max_uV;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-19 14:53:50 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-09-20 07:43:02 +00:00
|
|
|
static int machine_constraints_current(struct regulator_dev *rdev,
|
|
|
|
struct regulation_constraints *constraints)
|
|
|
|
{
|
2014-08-13 11:33:38 +00:00
|
|
|
const struct regulator_ops *ops = rdev->desc->ops;
|
2013-09-20 07:43:02 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!constraints->min_uA && !constraints->max_uA)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (constraints->min_uA > constraints->max_uA) {
|
|
|
|
rdev_err(rdev, "Invalid current constraints\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ops->set_current_limit || !ops->get_current_limit) {
|
|
|
|
rdev_warn(rdev, "Operation of current configuration missing\n");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set regulator current in constraints range */
|
|
|
|
ret = ops->set_current_limit(rdev, constraints->min_uA,
|
|
|
|
constraints->max_uA);
|
|
|
|
if (ret < 0) {
|
|
|
|
rdev_err(rdev, "Failed to set current constraint, %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-20 16:36:03 +00:00
|
|
|
static int _regulator_do_enable(struct regulator_dev *rdev);
|
|
|
|
|
2009-10-19 14:53:50 +00:00
|
|
|
/**
|
|
|
|
* set_machine_constraints - sets regulator constraints
|
|
|
|
* @rdev: regulator source
|
|
|
|
* @constraints: constraints to apply
|
|
|
|
*
|
|
|
|
* Allows platform initialisation code to define and constrain
|
|
|
|
* regulator circuits e.g. valid voltage/current ranges, etc. NOTE:
|
|
|
|
* Constraints *must* be set by platform code in order for some
|
|
|
|
* regulator operations to proceed i.e. set_voltage, set_current_limit,
|
|
|
|
* set_mode.
|
|
|
|
*/
|
|
|
|
static int set_machine_constraints(struct regulator_dev *rdev,
|
2010-11-29 15:55:17 +00:00
|
|
|
const struct regulation_constraints *constraints)
|
2009-10-19 14:53:50 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
2014-08-13 11:33:38 +00:00
|
|
|
const struct regulator_ops *ops = rdev->desc->ops;
|
2009-10-19 14:53:50 +00:00
|
|
|
|
2011-11-29 18:11:19 +00:00
|
|
|
if (constraints)
|
|
|
|
rdev->constraints = kmemdup(constraints, sizeof(*constraints),
|
|
|
|
GFP_KERNEL);
|
|
|
|
else
|
|
|
|
rdev->constraints = kzalloc(sizeof(*constraints),
|
|
|
|
GFP_KERNEL);
|
2010-11-29 15:55:17 +00:00
|
|
|
if (!rdev->constraints)
|
|
|
|
return -ENOMEM;
|
2009-10-22 15:31:30 +00:00
|
|
|
|
2010-11-29 15:55:17 +00:00
|
|
|
ret = machine_constraints_voltage(rdev, rdev->constraints);
|
2009-10-19 14:53:50 +00:00
|
|
|
if (ret != 0)
|
2016-01-26 16:38:59 +00:00
|
|
|
return ret;
|
2009-10-19 14:53:50 +00:00
|
|
|
|
2013-09-20 07:43:02 +00:00
|
|
|
ret = machine_constraints_current(rdev, rdev->constraints);
|
2009-10-19 14:53:50 +00:00
|
|
|
if (ret != 0)
|
2016-01-26 16:38:59 +00:00
|
|
|
return ret;
|
2009-10-19 14:53:50 +00:00
|
|
|
|
2015-06-12 00:37:06 +00:00
|
|
|
if (rdev->constraints->ilim_uA && ops->set_input_current_limit) {
|
|
|
|
ret = ops->set_input_current_limit(rdev,
|
|
|
|
rdev->constraints->ilim_uA);
|
|
|
|
if (ret < 0) {
|
|
|
|
rdev_err(rdev, "failed to set input limit\n");
|
2016-01-26 16:38:59 +00:00
|
|
|
return ret;
|
2015-06-12 00:37:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
/* do we need to setup our suspend state */
|
2011-11-29 18:11:19 +00:00
|
|
|
if (rdev->constraints->initial_state) {
|
2020-08-04 07:08:37 +00:00
|
|
|
ret = suspend_set_initial_state(rdev);
|
2008-09-09 15:21:19 +00:00
|
|
|
if (ret < 0) {
|
2010-11-30 13:53:48 +00:00
|
|
|
rdev_err(rdev, "failed to set suspend state\n");
|
2016-01-26 16:38:59 +00:00
|
|
|
return ret;
|
2008-09-09 15:21:19 +00:00
|
|
|
}
|
|
|
|
}
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
|
2011-11-29 18:11:19 +00:00
|
|
|
if (rdev->constraints->initial_mode) {
|
2009-02-26 19:24:19 +00:00
|
|
|
if (!ops->set_mode) {
|
2010-11-30 13:53:48 +00:00
|
|
|
rdev_err(rdev, "no set_mode operation\n");
|
2016-01-26 16:38:59 +00:00
|
|
|
return -EINVAL;
|
2009-02-26 19:24:19 +00:00
|
|
|
}
|
|
|
|
|
2010-11-29 15:55:17 +00:00
|
|
|
ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
|
2009-02-26 19:24:19 +00:00
|
|
|
if (ret < 0) {
|
2010-11-30 13:53:48 +00:00
|
|
|
rdev_err(rdev, "failed to set initial mode: %d\n", ret);
|
2016-01-26 16:38:59 +00:00
|
|
|
return ret;
|
2009-02-26 19:24:19 +00:00
|
|
|
}
|
2018-11-26 17:08:27 +00:00
|
|
|
} else if (rdev->constraints->system_load) {
|
|
|
|
/*
|
|
|
|
* We'll only apply the initial system load if an
|
|
|
|
* initial mode wasn't specified.
|
|
|
|
*/
|
|
|
|
drms_uA_update(rdev);
|
2009-02-26 19:24:19 +00:00
|
|
|
}
|
|
|
|
|
2013-06-29 12:51:15 +00:00
|
|
|
if ((rdev->constraints->ramp_delay || rdev->constraints->ramp_disable)
|
|
|
|
&& ops->set_ramp_delay) {
|
2012-06-11 12:11:08 +00:00
|
|
|
ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
|
|
|
|
if (ret < 0) {
|
|
|
|
rdev_err(rdev, "failed to set ramp_delay\n");
|
2016-01-26 16:38:59 +00:00
|
|
|
return ret;
|
2012-06-11 12:11:08 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-12 00:37:04 +00:00
|
|
|
if (rdev->constraints->pull_down && ops->set_pull_down) {
|
|
|
|
ret = ops->set_pull_down(rdev);
|
|
|
|
if (ret < 0) {
|
|
|
|
rdev_err(rdev, "failed to set pull down\n");
|
2016-01-26 16:38:59 +00:00
|
|
|
return ret;
|
2015-06-12 00:37:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-12 00:37:05 +00:00
|
|
|
if (rdev->constraints->soft_start && ops->set_soft_start) {
|
|
|
|
ret = ops->set_soft_start(rdev);
|
|
|
|
if (ret < 0) {
|
|
|
|
rdev_err(rdev, "failed to set soft start\n");
|
2016-01-26 16:38:59 +00:00
|
|
|
return ret;
|
2015-06-12 00:37:05 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-07-17 21:41:54 +00:00
|
|
|
if (rdev->constraints->over_current_protection
|
|
|
|
&& ops->set_over_current_protection) {
|
|
|
|
ret = ops->set_over_current_protection(rdev);
|
|
|
|
if (ret < 0) {
|
|
|
|
rdev_err(rdev, "failed to set over current protection\n");
|
2016-01-26 16:38:59 +00:00
|
|
|
return ret;
|
2015-07-17 21:41:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-03-02 10:54:46 +00:00
|
|
|
if (rdev->constraints->active_discharge && ops->set_active_discharge) {
|
|
|
|
bool ad_state = (rdev->constraints->active_discharge ==
|
|
|
|
REGULATOR_ACTIVE_DISCHARGE_ENABLE) ? true : false;
|
|
|
|
|
|
|
|
ret = ops->set_active_discharge(rdev, ad_state);
|
|
|
|
if (ret < 0) {
|
|
|
|
rdev_err(rdev, "failed to set active discharge\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-26 15:27:44 +00:00
|
|
|
/* If the constraints say the regulator should be on at this point
|
|
|
|
* and we have control then make sure it is enabled.
|
|
|
|
*/
|
|
|
|
if (rdev->constraints->always_on || rdev->constraints->boot_on) {
|
2018-12-06 22:23:18 +00:00
|
|
|
if (rdev->supply) {
|
|
|
|
ret = regulator_enable(rdev->supply);
|
|
|
|
if (ret < 0) {
|
|
|
|
_regulator_put(rdev->supply);
|
|
|
|
rdev->supply = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-26 15:27:44 +00:00
|
|
|
ret = _regulator_do_enable(rdev);
|
|
|
|
if (ret < 0 && ret != -EINVAL) {
|
|
|
|
rdev_err(rdev, "failed to enable\n");
|
|
|
|
return ret;
|
|
|
|
}
|
2019-11-13 10:27:37 +00:00
|
|
|
|
|
|
|
if (rdev->constraints->always_on)
|
|
|
|
rdev->use_count++;
|
2018-11-26 15:27:44 +00:00
|
|
|
}
|
|
|
|
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
print_constraints(rdev);
|
2011-07-15 02:50:43 +00:00
|
|
|
return 0;
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* set_supply - set regulator supply regulator
|
2008-12-31 12:52:41 +00:00
|
|
|
* @rdev: regulator name
|
|
|
|
* @supply_rdev: supply regulator name
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
*
|
|
|
|
* Called by platform initialisation code to set the supply regulator for this
|
|
|
|
* regulator. This ensures that a regulators supply will also be enabled by the
|
|
|
|
* core if it's child is enabled.
|
|
|
|
*/
|
|
|
|
static int set_supply(struct regulator_dev *rdev,
|
2011-06-09 15:22:22 +00:00
|
|
|
struct regulator_dev *supply_rdev)
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2011-06-09 15:22:22 +00:00
|
|
|
rdev_info(rdev, "supplied by %s\n", rdev_get_name(supply_rdev));
|
|
|
|
|
2015-07-15 14:10:28 +00:00
|
|
|
if (!try_module_get(supply_rdev->owner))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2011-06-09 15:22:22 +00:00
|
|
|
rdev->supply = create_regulator(supply_rdev, &rdev->dev, "SUPPLY");
|
2011-12-29 09:03:20 +00:00
|
|
|
if (rdev->supply == NULL) {
|
|
|
|
err = -ENOMEM;
|
2011-06-09 15:22:22 +00:00
|
|
|
return err;
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
}
|
2012-07-23 15:05:46 +00:00
|
|
|
supply_rdev->open_count++;
|
2011-06-09 15:22:22 +00:00
|
|
|
|
|
|
|
return 0;
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2010-11-18 23:02:26 +00:00
|
|
|
* set_consumer_device_supply - Bind a regulator to a symbolic supply
|
2008-12-31 12:52:41 +00:00
|
|
|
* @rdev: regulator source
|
2009-06-17 16:56:39 +00:00
|
|
|
* @consumer_dev_name: dev_name() string for device supply applies to
|
2008-12-31 12:52:41 +00:00
|
|
|
* @supply: symbolic name for supply
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
*
|
|
|
|
* Allows platform initialisation code to map physical regulator
|
|
|
|
* sources to symbolic names for supplies for use by devices. Devices
|
|
|
|
* should use these symbolic names to request regulators, avoiding the
|
|
|
|
* need to provide board-specific regulator names as platform data.
|
|
|
|
*/
|
|
|
|
static int set_consumer_device_supply(struct regulator_dev *rdev,
|
2012-02-02 00:10:51 +00:00
|
|
|
const char *consumer_dev_name,
|
|
|
|
const char *supply)
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
{
|
2020-08-12 01:31:36 +00:00
|
|
|
struct regulator_map *node, *new_node;
|
2009-07-21 15:00:26 +00:00
|
|
|
int has_dev;
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
|
|
|
|
if (supply == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2009-07-21 15:00:26 +00:00
|
|
|
if (consumer_dev_name != NULL)
|
|
|
|
has_dev = 1;
|
|
|
|
else
|
|
|
|
has_dev = 0;
|
|
|
|
|
2020-08-12 01:31:36 +00:00
|
|
|
new_node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
|
|
|
|
if (new_node == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
new_node->regulator = rdev;
|
|
|
|
new_node->supply = supply;
|
|
|
|
|
|
|
|
if (has_dev) {
|
|
|
|
new_node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
|
|
|
|
if (new_node->dev_name == NULL) {
|
|
|
|
kfree(new_node);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_lock(®ulator_list_mutex);
|
2008-12-31 12:54:19 +00:00
|
|
|
list_for_each_entry(node, ®ulator_map_list, list) {
|
2010-04-29 07:55:09 +00:00
|
|
|
if (node->dev_name && consumer_dev_name) {
|
|
|
|
if (strcmp(node->dev_name, consumer_dev_name) != 0)
|
|
|
|
continue;
|
|
|
|
} else if (node->dev_name || consumer_dev_name) {
|
2008-12-31 12:54:19 +00:00
|
|
|
continue;
|
2010-04-29 07:55:09 +00:00
|
|
|
}
|
|
|
|
|
2008-12-31 12:54:19 +00:00
|
|
|
if (strcmp(node->supply, supply) != 0)
|
|
|
|
continue;
|
|
|
|
|
2012-02-02 00:10:51 +00:00
|
|
|
pr_debug("%s: %s/%s is '%s' supply; fail %s/%s\n",
|
|
|
|
consumer_dev_name,
|
|
|
|
dev_name(&node->regulator->dev),
|
|
|
|
node->regulator->desc->name,
|
|
|
|
supply,
|
|
|
|
dev_name(&rdev->dev), rdev_get_name(rdev));
|
2020-08-12 01:31:36 +00:00
|
|
|
goto fail;
|
2008-12-31 12:54:19 +00:00
|
|
|
}
|
|
|
|
|
2020-08-12 01:31:36 +00:00
|
|
|
list_add(&new_node->list, ®ulator_map_list);
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
2009-06-17 16:56:39 +00:00
|
|
|
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
return 0;
|
2020-08-12 01:31:36 +00:00
|
|
|
|
|
|
|
fail:
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
kfree(new_node->dev_name);
|
|
|
|
kfree(new_node);
|
|
|
|
return -EBUSY;
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
}
|
|
|
|
|
2009-01-22 14:00:29 +00:00
|
|
|
static void unset_regulator_supplies(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
struct regulator_map *node, *n;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(node, n, ®ulator_map_list, list) {
|
|
|
|
if (rdev == node->regulator) {
|
|
|
|
list_del(&node->list);
|
2009-06-17 16:56:39 +00:00
|
|
|
kfree(node->dev_name);
|
2009-01-22 14:00:29 +00:00
|
|
|
kfree(node);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-21 16:23:21 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
static ssize_t constraint_flags_read_file(struct file *file,
|
|
|
|
char __user *user_buf,
|
|
|
|
size_t count, loff_t *ppos)
|
|
|
|
{
|
|
|
|
const struct regulator *regulator = file->private_data;
|
|
|
|
const struct regulation_constraints *c = regulator->rdev->constraints;
|
|
|
|
char *buf;
|
|
|
|
ssize_t ret;
|
|
|
|
|
|
|
|
if (!c)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
ret = snprintf(buf, PAGE_SIZE,
|
|
|
|
"always_on: %u\n"
|
|
|
|
"boot_on: %u\n"
|
|
|
|
"apply_uV: %u\n"
|
|
|
|
"ramp_disable: %u\n"
|
|
|
|
"soft_start: %u\n"
|
|
|
|
"pull_down: %u\n"
|
|
|
|
"over_current_protection: %u\n",
|
|
|
|
c->always_on,
|
|
|
|
c->boot_on,
|
|
|
|
c->apply_uV,
|
|
|
|
c->ramp_disable,
|
|
|
|
c->soft_start,
|
|
|
|
c->pull_down,
|
|
|
|
c->over_current_protection);
|
|
|
|
|
|
|
|
ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
|
|
|
|
kfree(buf);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static const struct file_operations constraint_flags_fops = {
|
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
.open = simple_open,
|
|
|
|
.read = constraint_flags_read_file,
|
|
|
|
.llseek = default_llseek,
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2011-06-09 15:22:20 +00:00
|
|
|
#define REG_STR_SIZE 64
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
static struct regulator *create_regulator(struct regulator_dev *rdev,
|
|
|
|
struct device *dev,
|
|
|
|
const char *supply_name)
|
|
|
|
{
|
|
|
|
struct regulator *regulator;
|
2020-08-12 01:31:35 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if (dev) {
|
|
|
|
char buf[REG_STR_SIZE];
|
|
|
|
int size;
|
|
|
|
|
|
|
|
size = snprintf(buf, REG_STR_SIZE, "%s-%s",
|
|
|
|
dev->kobj.name, supply_name);
|
|
|
|
if (size >= REG_STR_SIZE)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
supply_name = kstrdup(buf, GFP_KERNEL);
|
|
|
|
if (supply_name == NULL)
|
|
|
|
return NULL;
|
|
|
|
} else {
|
|
|
|
supply_name = kstrdup_const(supply_name, GFP_KERNEL);
|
|
|
|
if (supply_name == NULL)
|
|
|
|
return NULL;
|
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
regulator = kzalloc(sizeof(*regulator), GFP_KERNEL);
|
2020-08-12 01:31:35 +00:00
|
|
|
if (regulator == NULL) {
|
|
|
|
kfree(supply_name);
|
2008-04-30 14:59:04 +00:00
|
|
|
return NULL;
|
2020-08-12 01:31:35 +00:00
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
regulator->rdev = rdev;
|
2020-08-12 01:31:35 +00:00
|
|
|
regulator->supply_name = supply_name;
|
|
|
|
|
|
|
|
regulator_lock(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
list_add(®ulator->list, &rdev->consumer_list);
|
2020-08-12 01:31:35 +00:00
|
|
|
regulator_unlock(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
if (dev) {
|
2012-07-05 06:19:42 +00:00
|
|
|
regulator->dev = dev;
|
|
|
|
|
2012-06-22 10:39:16 +00:00
|
|
|
/* Add a link to the device sysfs entry */
|
2015-06-02 01:47:54 +00:00
|
|
|
err = sysfs_create_link_nowarn(&rdev->dev.kobj, &dev->kobj,
|
2020-08-12 01:31:35 +00:00
|
|
|
supply_name);
|
2008-04-30 14:59:04 +00:00
|
|
|
if (err) {
|
2015-06-02 01:47:54 +00:00
|
|
|
rdev_dbg(rdev, "could not add device link %s err %d\n",
|
2010-11-30 13:53:48 +00:00
|
|
|
dev->kobj.name, err);
|
2012-06-22 10:39:16 +00:00
|
|
|
/* non-fatal */
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2011-06-19 12:33:16 +00:00
|
|
|
}
|
|
|
|
|
2020-08-12 01:31:35 +00:00
|
|
|
regulator->debugfs = debugfs_create_dir(supply_name,
|
2011-06-19 12:33:16 +00:00
|
|
|
rdev->debugfs);
|
2012-02-21 06:50:42 +00:00
|
|
|
if (!regulator->debugfs) {
|
2015-06-02 01:47:55 +00:00
|
|
|
rdev_dbg(rdev, "Failed to create debugfs directory\n");
|
2011-06-19 12:33:16 +00:00
|
|
|
} else {
|
|
|
|
debugfs_create_u32("uA_load", 0444, regulator->debugfs,
|
|
|
|
®ulator->uA_load);
|
|
|
|
debugfs_create_u32("min_uV", 0444, regulator->debugfs,
|
2018-01-26 13:08:44 +00:00
|
|
|
®ulator->voltage[PM_SUSPEND_ON].min_uV);
|
2011-06-19 12:33:16 +00:00
|
|
|
debugfs_create_u32("max_uV", 0444, regulator->debugfs,
|
2018-01-26 13:08:44 +00:00
|
|
|
®ulator->voltage[PM_SUSPEND_ON].max_uV);
|
2016-04-21 16:23:21 +00:00
|
|
|
debugfs_create_file("constraint_flags", 0444,
|
|
|
|
regulator->debugfs, regulator,
|
|
|
|
&constraint_flags_fops);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2011-06-19 12:33:16 +00:00
|
|
|
|
2012-04-19 12:19:07 +00:00
|
|
|
/*
|
|
|
|
* Check now if the regulator is an always on regulator - if
|
|
|
|
* it is then we don't need to do nearly so much work for
|
|
|
|
* enable/disable calls.
|
|
|
|
*/
|
2016-04-23 07:11:05 +00:00
|
|
|
if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS) &&
|
2012-04-19 12:19:07 +00:00
|
|
|
_regulator_is_enabled(rdev))
|
|
|
|
regulator->always_on = true;
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
return regulator;
|
|
|
|
}
|
|
|
|
|
2009-12-21 12:21:52 +00:00
|
|
|
static int _regulator_get_enable_time(struct regulator_dev *rdev)
|
|
|
|
{
|
2013-09-18 12:48:02 +00:00
|
|
|
if (rdev->constraints && rdev->constraints->enable_time)
|
|
|
|
return rdev->constraints->enable_time;
|
2019-05-04 03:33:36 +00:00
|
|
|
if (rdev->desc->ops->enable_time)
|
|
|
|
return rdev->desc->ops->enable_time(rdev);
|
|
|
|
return rdev->desc->enable_time;
|
2009-12-21 12:21:52 +00:00
|
|
|
}
|
|
|
|
|
2013-10-15 19:14:20 +00:00
|
|
|
static struct regulator_supply_alias *regulator_find_supply_alias(
|
|
|
|
struct device *dev, const char *supply)
|
|
|
|
{
|
|
|
|
struct regulator_supply_alias *map;
|
|
|
|
|
|
|
|
list_for_each_entry(map, ®ulator_supply_alias_list, list)
|
|
|
|
if (map->src_dev == dev && strcmp(map->src_supply, supply) == 0)
|
|
|
|
return map;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void regulator_supply_alias(struct device **dev, const char **supply)
|
|
|
|
{
|
|
|
|
struct regulator_supply_alias *map;
|
|
|
|
|
|
|
|
map = regulator_find_supply_alias(*dev, *supply);
|
|
|
|
if (map) {
|
|
|
|
dev_dbg(*dev, "Mapping supply %s to %s,%s\n",
|
|
|
|
*supply, map->alias_supply,
|
|
|
|
dev_name(map->alias_dev));
|
|
|
|
*dev = map->alias_dev;
|
|
|
|
*supply = map->alias_supply;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-21 14:02:47 +00:00
|
|
|
static int regulator_match(struct device *dev, const void *data)
|
|
|
|
{
|
|
|
|
struct regulator_dev *r = dev_to_rdev(dev);
|
|
|
|
|
|
|
|
return strcmp(rdev_get_name(r), data) == 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct regulator_dev *regulator_lookup_by_name(const char *name)
|
|
|
|
{
|
|
|
|
struct device *dev;
|
|
|
|
|
|
|
|
dev = class_find_device(®ulator_class, NULL, name, regulator_match);
|
|
|
|
|
|
|
|
return dev ? dev_to_rdev(dev) : NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_dev_lookup - lookup a regulator device.
|
|
|
|
* @dev: device for regulator "consumer".
|
|
|
|
* @supply: Supply name or regulator ID.
|
|
|
|
*
|
|
|
|
* If successful, returns a struct regulator_dev that corresponds to the name
|
2017-02-04 18:19:21 +00:00
|
|
|
* @supply and with the embedded struct device refcount incremented by one.
|
|
|
|
* The refcount must be dropped by calling put_device().
|
|
|
|
* On failure one of the following ERR-PTR-encoded values is returned:
|
|
|
|
* -ENODEV if lookup fails permanently, -EPROBE_DEFER if lookup could succeed
|
|
|
|
* in the future.
|
2015-09-21 14:02:47 +00:00
|
|
|
*/
|
2011-11-18 11:17:20 +00:00
|
|
|
static struct regulator_dev *regulator_dev_lookup(struct device *dev,
|
2017-02-04 18:19:21 +00:00
|
|
|
const char *supply)
|
2011-11-18 11:17:20 +00:00
|
|
|
{
|
2017-06-13 15:12:47 +00:00
|
|
|
struct regulator_dev *r = NULL;
|
2011-11-18 11:17:20 +00:00
|
|
|
struct device_node *node;
|
2012-03-30 11:24:37 +00:00
|
|
|
struct regulator_map *map;
|
|
|
|
const char *devname = NULL;
|
2011-11-18 11:17:20 +00:00
|
|
|
|
2013-10-15 19:14:20 +00:00
|
|
|
regulator_supply_alias(&dev, &supply);
|
|
|
|
|
2011-11-18 11:17:20 +00:00
|
|
|
/* first do a dt based lookup */
|
|
|
|
if (dev && dev->of_node) {
|
|
|
|
node = of_get_regulator(dev, supply);
|
2012-03-29 13:19:02 +00:00
|
|
|
if (node) {
|
2015-09-21 14:02:47 +00:00
|
|
|
r = of_find_regulator_by_node(node);
|
|
|
|
if (r)
|
|
|
|
return r;
|
2017-02-04 18:19:21 +00:00
|
|
|
|
2012-03-29 13:19:02 +00:00
|
|
|
/*
|
2017-02-04 18:19:21 +00:00
|
|
|
* We have a node, but there is no device.
|
|
|
|
* assume it has not registered yet.
|
2012-03-29 13:19:02 +00:00
|
|
|
*/
|
2017-02-04 18:19:21 +00:00
|
|
|
return ERR_PTR(-EPROBE_DEFER);
|
2012-03-29 13:19:02 +00:00
|
|
|
}
|
2011-11-18 11:17:20 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* if not found, try doing it non-dt way */
|
2012-03-30 11:24:37 +00:00
|
|
|
if (dev)
|
|
|
|
devname = dev_name(dev);
|
|
|
|
|
2015-09-21 14:02:47 +00:00
|
|
|
mutex_lock(®ulator_list_mutex);
|
2012-03-30 11:24:37 +00:00
|
|
|
list_for_each_entry(map, ®ulator_map_list, list) {
|
|
|
|
/* If the mapping has a device set up it must match */
|
|
|
|
if (map->dev_name &&
|
|
|
|
(!devname || strcmp(map->dev_name, devname)))
|
|
|
|
continue;
|
|
|
|
|
2015-09-21 14:02:47 +00:00
|
|
|
if (strcmp(map->supply, supply) == 0 &&
|
|
|
|
get_device(&map->regulator->dev)) {
|
2017-02-04 18:19:21 +00:00
|
|
|
r = map->regulator;
|
|
|
|
break;
|
2015-09-21 14:02:47 +00:00
|
|
|
}
|
2012-03-30 11:24:37 +00:00
|
|
|
}
|
2015-09-21 14:02:47 +00:00
|
|
|
mutex_unlock(®ulator_list_mutex);
|
2012-03-30 11:24:37 +00:00
|
|
|
|
2017-06-13 15:12:47 +00:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = regulator_lookup_by_name(supply);
|
2017-02-04 18:19:21 +00:00
|
|
|
if (r)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
return ERR_PTR(-ENODEV);
|
2011-11-18 11:17:20 +00:00
|
|
|
}
|
|
|
|
|
2015-03-25 01:56:05 +00:00
|
|
|
static int regulator_resolve_supply(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
struct regulator_dev *r;
|
|
|
|
struct device *dev = rdev->dev.parent;
|
|
|
|
int ret;
|
|
|
|
|
2019-01-08 12:12:33 +00:00
|
|
|
/* No supply to resolve? */
|
2015-03-25 01:56:05 +00:00
|
|
|
if (!rdev->supply_name)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Supply already resolved? */
|
|
|
|
if (rdev->supply)
|
|
|
|
return 0;
|
|
|
|
|
2017-02-04 18:19:21 +00:00
|
|
|
r = regulator_dev_lookup(dev, rdev->supply_name);
|
|
|
|
if (IS_ERR(r)) {
|
|
|
|
ret = PTR_ERR(r);
|
|
|
|
|
2015-10-01 09:59:48 +00:00
|
|
|
/* Did the lookup explicitly defer for us? */
|
|
|
|
if (ret == -EPROBE_DEFER)
|
|
|
|
return ret;
|
|
|
|
|
2015-07-14 10:17:26 +00:00
|
|
|
if (have_full_constraints()) {
|
|
|
|
r = dummy_regulator_rdev;
|
2015-09-21 14:02:47 +00:00
|
|
|
get_device(&r->dev);
|
2015-07-14 10:17:26 +00:00
|
|
|
} else {
|
|
|
|
dev_err(dev, "Failed to resolve %s-supply for %s\n",
|
|
|
|
rdev->supply_name, rdev->desc->name);
|
|
|
|
return -EPROBE_DEFER;
|
|
|
|
}
|
2015-03-25 01:56:05 +00:00
|
|
|
}
|
|
|
|
|
2017-01-11 17:44:25 +00:00
|
|
|
/*
|
|
|
|
* If the supply's parent device is not the same as the
|
|
|
|
* regulator's parent device, then ensure the parent device
|
|
|
|
* is bound before we resolve the supply, in case the parent
|
|
|
|
* device get probe deferred and unregisters the supply.
|
|
|
|
*/
|
|
|
|
if (r->dev.parent && r->dev.parent != rdev->dev.parent) {
|
|
|
|
if (!device_is_bound(r->dev.parent)) {
|
|
|
|
put_device(&r->dev);
|
|
|
|
return -EPROBE_DEFER;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-25 01:56:05 +00:00
|
|
|
/* Recursively resolve the supply of the supply */
|
|
|
|
ret = regulator_resolve_supply(r);
|
2015-09-21 14:02:47 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
put_device(&r->dev);
|
2015-03-25 01:56:05 +00:00
|
|
|
return ret;
|
2015-09-21 14:02:47 +00:00
|
|
|
}
|
2015-03-25 01:56:05 +00:00
|
|
|
|
|
|
|
ret = set_supply(rdev, r);
|
2015-09-21 14:02:47 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
put_device(&r->dev);
|
2015-03-25 01:56:05 +00:00
|
|
|
return ret;
|
2015-09-21 14:02:47 +00:00
|
|
|
}
|
2015-03-25 01:56:05 +00:00
|
|
|
|
2018-12-06 22:23:18 +00:00
|
|
|
/*
|
|
|
|
* 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) {
|
2015-03-25 01:56:05 +00:00
|
|
|
ret = regulator_enable(rdev->supply);
|
2015-07-15 14:10:29 +00:00
|
|
|
if (ret < 0) {
|
2015-09-02 10:44:06 +00:00
|
|
|
_regulator_put(rdev->supply);
|
2016-04-21 16:11:58 +00:00
|
|
|
rdev->supply = NULL;
|
2015-03-25 01:56:05 +00:00
|
|
|
return ret;
|
2015-07-15 14:10:29 +00:00
|
|
|
}
|
2015-03-25 01:56:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-07-21 15:00:23 +00:00
|
|
|
/* Internal regulator request function */
|
2017-02-03 21:56:02 +00:00
|
|
|
struct regulator *_regulator_get(struct device *dev, const char *id,
|
|
|
|
enum regulator_get_type get_type)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
|
|
|
struct regulator_dev *rdev;
|
2017-02-03 21:56:00 +00:00
|
|
|
struct regulator *regulator;
|
2019-11-15 00:04:38 +00:00
|
|
|
struct device_link *link;
|
2014-01-27 17:34:07 +00:00
|
|
|
int ret;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2017-02-03 21:56:02 +00:00
|
|
|
if (get_type >= MAX_GET_TYPE) {
|
|
|
|
dev_err(dev, "invalid type %d in %s\n", get_type, __func__);
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
if (id == NULL) {
|
2010-11-30 13:53:48 +00:00
|
|
|
pr_err("get() with no identifier\n");
|
2013-09-20 11:32:18 +00:00
|
|
|
return ERR_PTR(-EINVAL);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
2017-02-04 18:19:21 +00:00
|
|
|
rdev = regulator_dev_lookup(dev, id);
|
2017-02-07 03:56:14 +00:00
|
|
|
if (IS_ERR(rdev)) {
|
|
|
|
ret = PTR_ERR(rdev);
|
2013-04-16 21:45:16 +00:00
|
|
|
|
2017-02-07 03:56:14 +00:00
|
|
|
/*
|
|
|
|
* If regulator_dev_lookup() fails with error other
|
|
|
|
* than -ENODEV our job here is done, we simply return it.
|
|
|
|
*/
|
|
|
|
if (ret != -ENODEV)
|
|
|
|
return ERR_PTR(ret);
|
2010-02-12 10:18:08 +00:00
|
|
|
|
2017-02-07 03:56:14 +00:00
|
|
|
if (!have_full_constraints()) {
|
|
|
|
dev_warn(dev,
|
|
|
|
"incomplete constraints, dummy supplies not allowed\n");
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
2013-09-13 18:50:37 +00:00
|
|
|
|
2017-02-07 03:56:14 +00:00
|
|
|
switch (get_type) {
|
|
|
|
case NORMAL_GET:
|
|
|
|
/*
|
|
|
|
* Assume that a regulator is physically present and
|
|
|
|
* enabled, even if it isn't hooked up, and just
|
|
|
|
* provide a dummy.
|
|
|
|
*/
|
2020-03-12 18:32:45 +00:00
|
|
|
dev_warn(dev, "supply %s not found, using dummy regulator\n", id);
|
2017-02-07 03:56:14 +00:00
|
|
|
rdev = dummy_regulator_rdev;
|
|
|
|
get_device(&rdev->dev);
|
|
|
|
break;
|
2010-02-12 10:18:08 +00:00
|
|
|
|
2017-02-07 03:56:14 +00:00
|
|
|
case EXCLUSIVE_GET:
|
|
|
|
dev_warn(dev,
|
|
|
|
"dummy supplies not allowed for exclusive requests\n");
|
|
|
|
/* fall through */
|
2010-02-12 10:18:08 +00:00
|
|
|
|
2017-02-07 03:56:14 +00:00
|
|
|
default:
|
|
|
|
return ERR_PTR(-ENODEV);
|
|
|
|
}
|
2010-02-12 10:18:08 +00:00
|
|
|
}
|
|
|
|
|
2009-07-21 15:00:23 +00:00
|
|
|
if (rdev->exclusive) {
|
|
|
|
regulator = ERR_PTR(-EPERM);
|
2015-09-21 14:02:47 +00:00
|
|
|
put_device(&rdev->dev);
|
|
|
|
return regulator;
|
2009-07-21 15:00:23 +00:00
|
|
|
}
|
|
|
|
|
2017-02-03 21:56:02 +00:00
|
|
|
if (get_type == EXCLUSIVE_GET && rdev->open_count) {
|
2009-07-21 15:00:23 +00:00
|
|
|
regulator = ERR_PTR(-EBUSY);
|
2015-09-21 14:02:47 +00:00
|
|
|
put_device(&rdev->dev);
|
|
|
|
return regulator;
|
2009-07-21 15:00:23 +00:00
|
|
|
}
|
|
|
|
|
2018-10-05 15:36:31 +00:00
|
|
|
mutex_lock(®ulator_list_mutex);
|
|
|
|
ret = (rdev->coupling_desc.n_resolved != rdev->coupling_desc.n_coupled);
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
|
|
|
|
if (ret != 0) {
|
|
|
|
regulator = ERR_PTR(-EPROBE_DEFER);
|
|
|
|
put_device(&rdev->dev);
|
|
|
|
return regulator;
|
|
|
|
}
|
|
|
|
|
2015-03-25 01:56:05 +00:00
|
|
|
ret = regulator_resolve_supply(rdev);
|
|
|
|
if (ret < 0) {
|
|
|
|
regulator = ERR_PTR(ret);
|
2015-09-21 14:02:47 +00:00
|
|
|
put_device(&rdev->dev);
|
|
|
|
return regulator;
|
2015-03-25 01:56:05 +00:00
|
|
|
}
|
|
|
|
|
2015-09-21 14:02:47 +00:00
|
|
|
if (!try_module_get(rdev->owner)) {
|
2017-02-03 21:56:00 +00:00
|
|
|
regulator = ERR_PTR(-EPROBE_DEFER);
|
2015-09-21 14:02:47 +00:00
|
|
|
put_device(&rdev->dev);
|
|
|
|
return regulator;
|
|
|
|
}
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
regulator = create_regulator(rdev, dev, id);
|
|
|
|
if (regulator == NULL) {
|
|
|
|
regulator = ERR_PTR(-ENOMEM);
|
|
|
|
module_put(rdev->owner);
|
2019-11-24 14:58:35 +00:00
|
|
|
put_device(&rdev->dev);
|
2015-09-21 14:02:47 +00:00
|
|
|
return regulator;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
2009-07-21 15:00:23 +00:00
|
|
|
rdev->open_count++;
|
2017-02-03 21:56:02 +00:00
|
|
|
if (get_type == EXCLUSIVE_GET) {
|
2009-07-21 15:00:23 +00:00
|
|
|
rdev->exclusive = 1;
|
|
|
|
|
|
|
|
ret = _regulator_is_enabled(rdev);
|
|
|
|
if (ret > 0)
|
|
|
|
rdev->use_count = 1;
|
|
|
|
else
|
|
|
|
rdev->use_count = 0;
|
|
|
|
}
|
|
|
|
|
2019-11-15 00:04:38 +00:00
|
|
|
link = device_link_add(dev, &rdev->dev, DL_FLAG_STATELESS);
|
|
|
|
if (!IS_ERR_OR_NULL(link))
|
|
|
|
regulator->device_link = true;
|
2018-07-05 14:25:56 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
return regulator;
|
|
|
|
}
|
2009-07-21 15:00:23 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get - lookup and obtain a reference to a regulator.
|
|
|
|
* @dev: device for regulator "consumer"
|
|
|
|
* @id: Supply name or regulator ID.
|
|
|
|
*
|
|
|
|
* Returns a struct regulator corresponding to the regulator producer,
|
|
|
|
* or IS_ERR() condition containing errno.
|
|
|
|
*
|
|
|
|
* Use of supply names configured via regulator_set_device_supply() is
|
|
|
|
* strongly encouraged. It is recommended that the supply name used
|
|
|
|
* should match the name used for the supply and/or the relevant
|
|
|
|
* device pins in the datasheet.
|
|
|
|
*/
|
|
|
|
struct regulator *regulator_get(struct device *dev, const char *id)
|
|
|
|
{
|
2017-02-03 21:56:02 +00:00
|
|
|
return _regulator_get(dev, id, NORMAL_GET);
|
2009-07-21 15:00:23 +00:00
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
EXPORT_SYMBOL_GPL(regulator_get);
|
|
|
|
|
2009-07-21 15:00:23 +00:00
|
|
|
/**
|
|
|
|
* regulator_get_exclusive - obtain exclusive access to a regulator.
|
|
|
|
* @dev: device for regulator "consumer"
|
|
|
|
* @id: Supply name or regulator ID.
|
|
|
|
*
|
|
|
|
* Returns a struct regulator corresponding to the regulator producer,
|
|
|
|
* or IS_ERR() condition containing errno. Other consumers will be
|
2014-05-28 19:41:28 +00:00
|
|
|
* unable to obtain this regulator while this reference is held and the
|
|
|
|
* use count for the regulator will be initialised to reflect the current
|
|
|
|
* state of the regulator.
|
2009-07-21 15:00:23 +00:00
|
|
|
*
|
|
|
|
* This is intended for use by consumers which cannot tolerate shared
|
|
|
|
* use of the regulator such as those which need to force the
|
|
|
|
* regulator off for correct operation of the hardware they are
|
|
|
|
* controlling.
|
|
|
|
*
|
|
|
|
* Use of supply names configured via regulator_set_device_supply() is
|
|
|
|
* strongly encouraged. It is recommended that the supply name used
|
|
|
|
* should match the name used for the supply and/or the relevant
|
|
|
|
* device pins in the datasheet.
|
|
|
|
*/
|
|
|
|
struct regulator *regulator_get_exclusive(struct device *dev, const char *id)
|
|
|
|
{
|
2017-02-03 21:56:02 +00:00
|
|
|
return _regulator_get(dev, id, EXCLUSIVE_GET);
|
2009-07-21 15:00:23 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_exclusive);
|
|
|
|
|
2013-07-29 20:42:42 +00:00
|
|
|
/**
|
|
|
|
* regulator_get_optional - obtain optional access to a regulator.
|
|
|
|
* @dev: device for regulator "consumer"
|
|
|
|
* @id: Supply name or regulator ID.
|
|
|
|
*
|
|
|
|
* Returns a struct regulator corresponding to the regulator producer,
|
2014-05-28 19:41:28 +00:00
|
|
|
* or IS_ERR() condition containing errno.
|
2013-07-29 20:42:42 +00:00
|
|
|
*
|
|
|
|
* This is intended for use by consumers for devices which can have
|
|
|
|
* some supplies unconnected in normal use, such as some MMC devices.
|
|
|
|
* It can allow the regulator core to provide stub supplies for other
|
|
|
|
* supplies requested using normal regulator_get() calls without
|
|
|
|
* disrupting the operation of drivers that can handle absent
|
|
|
|
* supplies.
|
|
|
|
*
|
|
|
|
* Use of supply names configured via regulator_set_device_supply() is
|
|
|
|
* strongly encouraged. It is recommended that the supply name used
|
|
|
|
* should match the name used for the supply and/or the relevant
|
|
|
|
* device pins in the datasheet.
|
|
|
|
*/
|
|
|
|
struct regulator *regulator_get_optional(struct device *dev, const char *id)
|
|
|
|
{
|
2017-02-03 21:56:02 +00:00
|
|
|
return _regulator_get(dev, id, OPTIONAL_GET);
|
2013-07-29 20:42:42 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_optional);
|
|
|
|
|
2020-07-16 04:20:51 +00:00
|
|
|
static void destroy_regulator(struct regulator *regulator)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
2020-07-16 04:20:51 +00:00
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2011-06-19 12:33:16 +00:00
|
|
|
debugfs_remove_recursive(regulator->debugfs);
|
|
|
|
|
2018-07-05 14:25:56 +00:00
|
|
|
if (regulator->dev) {
|
2019-11-15 00:04:38 +00:00
|
|
|
if (regulator->device_link)
|
|
|
|
device_link_remove(regulator->dev, &rdev->dev);
|
2018-07-05 14:25:56 +00:00
|
|
|
|
|
|
|
/* remove any sysfs entries */
|
2008-04-30 14:59:04 +00:00
|
|
|
sysfs_remove_link(&rdev->dev.kobj, regulator->supply_name);
|
2018-07-05 14:25:56 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
list_del(®ulator->list);
|
|
|
|
|
2009-07-21 15:00:23 +00:00
|
|
|
rdev->open_count--;
|
|
|
|
rdev->exclusive = 0;
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2009-07-21 15:00:23 +00:00
|
|
|
|
2017-03-17 01:07:14 +00:00
|
|
|
kfree_const(regulator->supply_name);
|
2015-08-07 20:19:26 +00:00
|
|
|
kfree(regulator);
|
2020-07-16 04:20:51 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* regulator_list_mutex lock held by regulator_put() */
|
|
|
|
static void _regulator_put(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev;
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(regulator))
|
|
|
|
return;
|
|
|
|
|
|
|
|
lockdep_assert_held_once(®ulator_list_mutex);
|
|
|
|
|
|
|
|
/* Docs say you must disable before calling regulator_put() */
|
|
|
|
WARN_ON(regulator->enable_count);
|
|
|
|
|
|
|
|
rdev = regulator->rdev;
|
|
|
|
|
|
|
|
destroy_regulator(regulator);
|
2015-08-07 20:19:26 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
module_put(rdev->owner);
|
2019-11-24 14:58:35 +00:00
|
|
|
put_device(&rdev->dev);
|
2012-11-14 09:39:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_put - "free" the regulator source
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* Note: drivers must ensure that all regulator_enable calls made on this
|
|
|
|
* regulator source are balanced by regulator_disable calls prior to calling
|
|
|
|
* this function.
|
|
|
|
*/
|
|
|
|
void regulator_put(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
mutex_lock(®ulator_list_mutex);
|
|
|
|
_regulator_put(regulator);
|
2008-04-30 14:59:04 +00:00
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_put);
|
|
|
|
|
2013-10-15 19:14:20 +00:00
|
|
|
/**
|
|
|
|
* regulator_register_supply_alias - Provide device alias for supply lookup
|
|
|
|
*
|
|
|
|
* @dev: device that will be given as the regulator "consumer"
|
|
|
|
* @id: Supply name or regulator ID
|
|
|
|
* @alias_dev: device that should be used to lookup the supply
|
|
|
|
* @alias_id: Supply name or regulator ID that should be used to lookup the
|
|
|
|
* supply
|
|
|
|
*
|
|
|
|
* All lookups for id on dev will instead be conducted for alias_id on
|
|
|
|
* alias_dev.
|
|
|
|
*/
|
|
|
|
int regulator_register_supply_alias(struct device *dev, const char *id,
|
|
|
|
struct device *alias_dev,
|
|
|
|
const char *alias_id)
|
|
|
|
{
|
|
|
|
struct regulator_supply_alias *map;
|
|
|
|
|
|
|
|
map = regulator_find_supply_alias(dev, id);
|
|
|
|
if (map)
|
|
|
|
return -EEXIST;
|
|
|
|
|
|
|
|
map = kzalloc(sizeof(struct regulator_supply_alias), GFP_KERNEL);
|
|
|
|
if (!map)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
map->src_dev = dev;
|
|
|
|
map->src_supply = id;
|
|
|
|
map->alias_dev = alias_dev;
|
|
|
|
map->alias_supply = alias_id;
|
|
|
|
|
|
|
|
list_add(&map->list, ®ulator_supply_alias_list);
|
|
|
|
|
|
|
|
pr_info("Adding alias for supply %s,%s -> %s,%s\n",
|
|
|
|
id, dev_name(dev), alias_id, dev_name(alias_dev));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_register_supply_alias);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_unregister_supply_alias - Remove device alias
|
|
|
|
*
|
|
|
|
* @dev: device that will be given as the regulator "consumer"
|
|
|
|
* @id: Supply name or regulator ID
|
|
|
|
*
|
|
|
|
* Remove a lookup alias if one exists for id on dev.
|
|
|
|
*/
|
|
|
|
void regulator_unregister_supply_alias(struct device *dev, const char *id)
|
|
|
|
{
|
|
|
|
struct regulator_supply_alias *map;
|
|
|
|
|
|
|
|
map = regulator_find_supply_alias(dev, id);
|
|
|
|
if (map) {
|
|
|
|
list_del(&map->list);
|
|
|
|
kfree(map);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_unregister_supply_alias);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_bulk_register_supply_alias - register multiple aliases
|
|
|
|
*
|
|
|
|
* @dev: device that will be given as the regulator "consumer"
|
|
|
|
* @id: List of supply names or regulator IDs
|
|
|
|
* @alias_dev: device that should be used to lookup the supply
|
|
|
|
* @alias_id: List of supply names or regulator IDs that should be used to
|
|
|
|
* lookup the supply
|
|
|
|
* @num_id: Number of aliases to register
|
|
|
|
*
|
|
|
|
* @return 0 on success, an errno on failure.
|
|
|
|
*
|
|
|
|
* This helper function allows drivers to register several supply
|
|
|
|
* aliases in one operation. If any of the aliases cannot be
|
|
|
|
* registered any aliases that were registered will be removed
|
|
|
|
* before returning to the caller.
|
|
|
|
*/
|
2014-05-23 15:44:10 +00:00
|
|
|
int regulator_bulk_register_supply_alias(struct device *dev,
|
|
|
|
const char *const *id,
|
2013-10-15 19:14:20 +00:00
|
|
|
struct device *alias_dev,
|
2014-05-23 15:44:10 +00:00
|
|
|
const char *const *alias_id,
|
2013-10-15 19:14:20 +00:00
|
|
|
int num_id)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
for (i = 0; i < num_id; ++i) {
|
|
|
|
ret = regulator_register_supply_alias(dev, id[i], alias_dev,
|
|
|
|
alias_id[i]);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
dev_err(dev,
|
|
|
|
"Failed to create supply alias %s,%s -> %s,%s\n",
|
|
|
|
id[i], dev_name(dev), alias_id[i], dev_name(alias_dev));
|
|
|
|
|
|
|
|
while (--i >= 0)
|
|
|
|
regulator_unregister_supply_alias(dev, id[i]);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_bulk_register_supply_alias);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_bulk_unregister_supply_alias - unregister multiple aliases
|
|
|
|
*
|
|
|
|
* @dev: device that will be given as the regulator "consumer"
|
|
|
|
* @id: List of supply names or regulator IDs
|
|
|
|
* @num_id: Number of aliases to unregister
|
|
|
|
*
|
|
|
|
* This helper function allows drivers to unregister several supply
|
|
|
|
* aliases in one operation.
|
|
|
|
*/
|
|
|
|
void regulator_bulk_unregister_supply_alias(struct device *dev,
|
2014-05-23 15:44:10 +00:00
|
|
|
const char *const *id,
|
2013-10-15 19:14:20 +00:00
|
|
|
int num_id)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_id; ++i)
|
|
|
|
regulator_unregister_supply_alias(dev, id[i]);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_bulk_unregister_supply_alias);
|
|
|
|
|
|
|
|
|
2013-02-18 06:50:39 +00:00
|
|
|
/* Manage enable GPIO list. Same GPIO pin can be shared among regulators */
|
|
|
|
static int regulator_ena_gpio_request(struct regulator_dev *rdev,
|
|
|
|
const struct regulator_config *config)
|
|
|
|
{
|
2020-08-12 01:31:34 +00:00
|
|
|
struct regulator_enable_gpio *pin, *new_pin;
|
2014-06-29 16:55:54 +00:00
|
|
|
struct gpio_desc *gpiod;
|
2013-02-18 06:50:39 +00:00
|
|
|
|
2019-01-29 10:31:56 +00:00
|
|
|
gpiod = config->ena_gpiod;
|
2020-08-12 01:31:34 +00:00
|
|
|
new_pin = kzalloc(sizeof(*new_pin), GFP_KERNEL);
|
|
|
|
|
|
|
|
mutex_lock(®ulator_list_mutex);
|
2014-06-29 16:55:54 +00:00
|
|
|
|
2013-02-18 06:50:39 +00:00
|
|
|
list_for_each_entry(pin, ®ulator_ena_gpio_list, list) {
|
2014-06-29 16:55:54 +00:00
|
|
|
if (pin->gpiod == gpiod) {
|
2019-01-29 10:31:56 +00:00
|
|
|
rdev_dbg(rdev, "GPIO is already used\n");
|
2013-02-18 06:50:39 +00:00
|
|
|
goto update_ena_gpio_to_rdev;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-12 01:31:34 +00:00
|
|
|
if (new_pin == NULL) {
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
2013-02-18 06:50:39 +00:00
|
|
|
return -ENOMEM;
|
2020-08-12 01:31:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pin = new_pin;
|
|
|
|
new_pin = NULL;
|
2013-02-18 06:50:39 +00:00
|
|
|
|
2014-06-29 16:55:54 +00:00
|
|
|
pin->gpiod = gpiod;
|
2013-02-18 06:50:39 +00:00
|
|
|
list_add(&pin->list, ®ulator_ena_gpio_list);
|
|
|
|
|
|
|
|
update_ena_gpio_to_rdev:
|
|
|
|
pin->request_count++;
|
|
|
|
rdev->ena_pin = pin;
|
2020-08-12 01:31:34 +00:00
|
|
|
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
kfree(new_pin);
|
|
|
|
|
2013-02-18 06:50:39 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void regulator_ena_gpio_free(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
struct regulator_enable_gpio *pin, *n;
|
|
|
|
|
|
|
|
if (!rdev->ena_pin)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* Free the GPIO only in case of no use */
|
|
|
|
list_for_each_entry_safe(pin, n, ®ulator_ena_gpio_list, list) {
|
2020-08-12 01:31:37 +00:00
|
|
|
if (pin != rdev->ena_pin)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (--pin->request_count)
|
|
|
|
break;
|
|
|
|
|
|
|
|
gpiod_put(pin->gpiod);
|
|
|
|
list_del(&pin->list);
|
|
|
|
kfree(pin);
|
|
|
|
break;
|
2013-02-18 06:50:39 +00:00
|
|
|
}
|
2020-08-12 01:31:37 +00:00
|
|
|
|
|
|
|
rdev->ena_pin = NULL;
|
2013-02-18 06:50:39 +00:00
|
|
|
}
|
|
|
|
|
2013-02-18 06:50:48 +00:00
|
|
|
/**
|
2013-05-02 14:19:11 +00:00
|
|
|
* regulator_ena_gpio_ctrl - balance enable_count of each GPIO and actual GPIO pin control
|
|
|
|
* @rdev: regulator_dev structure
|
|
|
|
* @enable: enable GPIO at initial use?
|
|
|
|
*
|
2013-02-18 06:50:48 +00:00
|
|
|
* GPIO is enabled in case of initial use. (enable_count is 0)
|
|
|
|
* GPIO is disabled when it is not shared any more. (enable_count <= 1)
|
|
|
|
*/
|
|
|
|
static int regulator_ena_gpio_ctrl(struct regulator_dev *rdev, bool enable)
|
|
|
|
{
|
|
|
|
struct regulator_enable_gpio *pin = rdev->ena_pin;
|
|
|
|
|
|
|
|
if (!pin)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (enable) {
|
|
|
|
/* Enable GPIO at initial use */
|
|
|
|
if (pin->enable_count == 0)
|
2019-01-29 10:31:53 +00:00
|
|
|
gpiod_set_value_cansleep(pin->gpiod, 1);
|
2013-02-18 06:50:48 +00:00
|
|
|
|
|
|
|
pin->enable_count++;
|
|
|
|
} else {
|
|
|
|
if (pin->enable_count > 1) {
|
|
|
|
pin->enable_count--;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Disable GPIO if not used */
|
|
|
|
if (pin->enable_count <= 1) {
|
2019-01-29 10:31:53 +00:00
|
|
|
gpiod_set_value_cansleep(pin->gpiod, 0);
|
2013-02-18 06:50:48 +00:00
|
|
|
pin->enable_count = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-13 11:33:39 +00:00
|
|
|
/**
|
|
|
|
* _regulator_enable_delay - a delay helper function
|
|
|
|
* @delay: time to delay in microseconds
|
|
|
|
*
|
|
|
|
* Delay for the requested amount of time as per the guidelines in:
|
|
|
|
*
|
2019-06-12 17:53:00 +00:00
|
|
|
* Documentation/timers/timers-howto.rst
|
2014-08-13 11:33:39 +00:00
|
|
|
*
|
|
|
|
* The assumption here is that regulators will never be enabled in
|
|
|
|
* atomic context and therefore sleeping functions can be used.
|
|
|
|
*/
|
|
|
|
static void _regulator_enable_delay(unsigned int delay)
|
|
|
|
{
|
|
|
|
unsigned int ms = delay / 1000;
|
|
|
|
unsigned int us = delay % 1000;
|
|
|
|
|
|
|
|
if (ms > 0) {
|
|
|
|
/*
|
|
|
|
* For small enough values, handle super-millisecond
|
|
|
|
* delays in the usleep_range() call below.
|
|
|
|
*/
|
|
|
|
if (ms < 20)
|
|
|
|
us += ms * 1000;
|
|
|
|
else
|
|
|
|
msleep(ms);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Give the scheduler some room to coalesce with any other
|
|
|
|
* wakeup sources. For delays shorter than 10 us, don't even
|
|
|
|
* bother setting up high-resolution timers and just busy-
|
|
|
|
* loop.
|
|
|
|
*/
|
|
|
|
if (us >= 10)
|
|
|
|
usleep_range(us, us + 100);
|
|
|
|
else
|
|
|
|
udelay(us);
|
|
|
|
}
|
|
|
|
|
2020-06-22 12:41:07 +00:00
|
|
|
/**
|
|
|
|
* _regulator_check_status_enabled
|
|
|
|
*
|
|
|
|
* A helper function to check if the regulator status can be interpreted
|
|
|
|
* as 'regulator is enabled'.
|
|
|
|
* @rdev: the regulator device to check
|
|
|
|
*
|
|
|
|
* Return:
|
|
|
|
* * 1 - if status shows regulator is in enabled state
|
|
|
|
* * 0 - if not enabled state
|
|
|
|
* * Error Value - as received from ops->get_status()
|
|
|
|
*/
|
|
|
|
static inline int _regulator_check_status_enabled(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
int ret = rdev->desc->ops->get_status(rdev);
|
|
|
|
|
|
|
|
if (ret < 0) {
|
|
|
|
rdev_info(rdev, "get_status returned error: %d\n", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (ret) {
|
|
|
|
case REGULATOR_STATUS_OFF:
|
|
|
|
case REGULATOR_STATUS_ERROR:
|
|
|
|
case REGULATOR_STATUS_UNDEFINED:
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-27 12:21:26 +00:00
|
|
|
static int _regulator_do_enable(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
int ret, delay;
|
|
|
|
|
|
|
|
/* Query before enabling in case configuration dependent. */
|
|
|
|
ret = _regulator_get_enable_time(rdev);
|
|
|
|
if (ret >= 0) {
|
|
|
|
delay = ret;
|
|
|
|
} else {
|
|
|
|
rdev_warn(rdev, "enable_time() failed: %d\n", ret);
|
|
|
|
delay = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
trace_regulator_enable(rdev_get_name(rdev));
|
|
|
|
|
2014-08-13 11:33:40 +00:00
|
|
|
if (rdev->desc->off_on_delay) {
|
|
|
|
/* if needed, keep a distance of off_on_delay from last time
|
|
|
|
* this regulator was disabled.
|
|
|
|
*/
|
|
|
|
unsigned long start_jiffy = jiffies;
|
|
|
|
unsigned long intended, max_delay, remaining;
|
|
|
|
|
|
|
|
max_delay = usecs_to_jiffies(rdev->desc->off_on_delay);
|
|
|
|
intended = rdev->last_off_jiffy + max_delay;
|
|
|
|
|
|
|
|
if (time_before(start_jiffy, intended)) {
|
|
|
|
/* calc remaining jiffies to deal with one-time
|
|
|
|
* timer wrapping.
|
|
|
|
* in case of multiple timer wrapping, either it can be
|
|
|
|
* detected by out-of-range remaining, or it cannot be
|
2019-01-08 12:12:33 +00:00
|
|
|
* detected and we get a penalty of
|
2014-08-13 11:33:40 +00:00
|
|
|
* _regulator_enable_delay().
|
|
|
|
*/
|
|
|
|
remaining = intended - start_jiffy;
|
|
|
|
if (remaining <= max_delay)
|
|
|
|
_regulator_enable_delay(
|
|
|
|
jiffies_to_usecs(remaining));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-18 06:50:48 +00:00
|
|
|
if (rdev->ena_pin) {
|
2015-03-03 23:20:47 +00:00
|
|
|
if (!rdev->ena_gpio_state) {
|
|
|
|
ret = regulator_ena_gpio_ctrl(rdev, true);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
rdev->ena_gpio_state = 1;
|
|
|
|
}
|
2012-06-27 13:14:38 +00:00
|
|
|
} else if (rdev->desc->ops->enable) {
|
2012-06-27 12:21:26 +00:00
|
|
|
ret = rdev->desc->ops->enable(rdev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
} else {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allow the regulator to ramp; it would be useful to extend
|
|
|
|
* this for bulk operations so that the regulators can ramp
|
|
|
|
* together. */
|
|
|
|
trace_regulator_enable_delay(rdev_get_name(rdev));
|
|
|
|
|
2020-06-22 12:41:07 +00:00
|
|
|
/* If poll_enabled_time is set, poll upto the delay calculated
|
|
|
|
* above, delaying poll_enabled_time uS to check if the regulator
|
|
|
|
* actually got enabled.
|
|
|
|
* If the regulator isn't enabled after enable_delay has
|
|
|
|
* expired, return -ETIMEDOUT.
|
|
|
|
*/
|
|
|
|
if (rdev->desc->poll_enabled_time) {
|
|
|
|
unsigned int time_remaining = delay;
|
|
|
|
|
|
|
|
while (time_remaining > 0) {
|
|
|
|
_regulator_enable_delay(rdev->desc->poll_enabled_time);
|
|
|
|
|
|
|
|
if (rdev->desc->ops->get_status) {
|
|
|
|
ret = _regulator_check_status_enabled(rdev);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
else if (ret)
|
|
|
|
break;
|
|
|
|
} else if (rdev->desc->ops->is_enabled(rdev))
|
|
|
|
break;
|
|
|
|
|
|
|
|
time_remaining -= rdev->desc->poll_enabled_time;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (time_remaining <= 0) {
|
|
|
|
rdev_err(rdev, "Enabled check timed out\n");
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
_regulator_enable_delay(delay);
|
|
|
|
}
|
2012-06-27 12:21:26 +00:00
|
|
|
|
|
|
|
trace_regulator_enable_complete(rdev_get_name(rdev));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-11-20 17:52:53 +00:00
|
|
|
/**
|
|
|
|
* _regulator_handle_consumer_enable - handle that a consumer enabled
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* Some things on a regulator consumer (like the contribution towards total
|
|
|
|
* load on the regulator) only have an effect when the consumer wants the
|
|
|
|
* regulator enabled. Explained in example with two consumers of the same
|
|
|
|
* regulator:
|
|
|
|
* consumer A: set_load(100); => total load = 0
|
|
|
|
* consumer A: regulator_enable(); => total load = 100
|
|
|
|
* consumer B: set_load(1000); => total load = 100
|
|
|
|
* consumer B: regulator_enable(); => total load = 1100
|
|
|
|
* consumer A: regulator_disable(); => total_load = 1000
|
|
|
|
*
|
|
|
|
* This function (together with _regulator_handle_consumer_disable) is
|
|
|
|
* responsible for keeping track of the refcount for a given regulator consumer
|
|
|
|
* and applying / unapplying these things.
|
|
|
|
*
|
|
|
|
* Returns 0 upon no error; -error upon error.
|
|
|
|
*/
|
|
|
|
static int _regulator_handle_consumer_enable(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
|
|
|
|
lockdep_assert_held_once(&rdev->mutex.base);
|
|
|
|
|
|
|
|
regulator->enable_count++;
|
|
|
|
if (regulator->uA_load && regulator->enable_count == 1)
|
|
|
|
return drms_uA_update(rdev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* _regulator_handle_consumer_disable - handle that a consumer disabled
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* The opposite of _regulator_handle_consumer_enable().
|
|
|
|
*
|
|
|
|
* Returns 0 upon no error; -error upon error.
|
|
|
|
*/
|
|
|
|
static int _regulator_handle_consumer_disable(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
|
|
|
|
lockdep_assert_held_once(&rdev->mutex.base);
|
|
|
|
|
|
|
|
if (!regulator->enable_count) {
|
|
|
|
rdev_err(rdev, "Underflow of regulator enable count\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
regulator->enable_count--;
|
|
|
|
if (regulator->uA_load && regulator->enable_count == 0)
|
|
|
|
return drms_uA_update(rdev);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/* locks held by regulator_enable() */
|
2018-11-20 17:52:53 +00:00
|
|
|
static int _regulator_enable(struct regulator *regulator)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
2018-11-20 17:52:53 +00:00
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
2012-06-27 12:21:26 +00:00
|
|
|
int ret;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
lockdep_assert_held_once(&rdev->mutex.base);
|
|
|
|
|
2018-11-20 17:52:54 +00:00
|
|
|
if (rdev->use_count == 0 && rdev->supply) {
|
2018-11-20 17:52:53 +00:00
|
|
|
ret = _regulator_enable(rdev->supply);
|
2018-11-18 21:56:17 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* balance only if there are regulators coupled */
|
|
|
|
if (rdev->coupling_desc.n_coupled > 1) {
|
|
|
|
ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err_disable_supply;
|
|
|
|
}
|
2015-06-29 00:04:43 +00:00
|
|
|
|
2018-11-20 17:52:53 +00:00
|
|
|
ret = _regulator_handle_consumer_enable(regulator);
|
|
|
|
if (ret < 0)
|
|
|
|
goto err_disable_supply;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2009-08-03 17:49:57 +00:00
|
|
|
if (rdev->use_count == 0) {
|
|
|
|
/* The regulator may on if it's not switchable or left on */
|
|
|
|
ret = _regulator_is_enabled(rdev);
|
|
|
|
if (ret == -EINVAL || ret == 0) {
|
2016-04-23 07:11:05 +00:00
|
|
|
if (!regulator_ops_is_valid(rdev,
|
2018-11-18 21:56:17 +00:00
|
|
|
REGULATOR_CHANGE_STATUS)) {
|
|
|
|
ret = -EPERM;
|
2018-11-20 17:52:53 +00:00
|
|
|
goto err_consumer_disable;
|
2018-11-18 21:56:17 +00:00
|
|
|
}
|
2009-08-03 17:49:57 +00:00
|
|
|
|
2012-06-27 12:21:26 +00:00
|
|
|
ret = _regulator_do_enable(rdev);
|
2009-12-21 12:21:52 +00:00
|
|
|
if (ret < 0)
|
2018-11-20 17:52:53 +00:00
|
|
|
goto err_consumer_disable;
|
2009-12-21 12:21:52 +00:00
|
|
|
|
2017-02-23 17:06:52 +00:00
|
|
|
_notifier_call_chain(rdev, REGULATOR_EVENT_ENABLE,
|
|
|
|
NULL);
|
2009-08-26 10:54:04 +00:00
|
|
|
} else if (ret < 0) {
|
2010-11-30 13:53:48 +00:00
|
|
|
rdev_err(rdev, "is_enabled() failed: %d\n", ret);
|
2018-11-20 17:52:53 +00:00
|
|
|
goto err_consumer_disable;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2009-08-26 10:54:04 +00:00
|
|
|
/* Fallthrough on positive return values - already enabled */
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
2009-08-03 17:49:57 +00:00
|
|
|
rdev->use_count++;
|
|
|
|
|
|
|
|
return 0;
|
2018-11-18 21:56:17 +00:00
|
|
|
|
2018-11-20 17:52:53 +00:00
|
|
|
err_consumer_disable:
|
|
|
|
_regulator_handle_consumer_disable(regulator);
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
err_disable_supply:
|
2018-11-20 17:52:54 +00:00
|
|
|
if (rdev->use_count == 0 && rdev->supply)
|
2018-11-20 17:52:53 +00:00
|
|
|
_regulator_disable(rdev->supply);
|
2018-11-18 21:56:17 +00:00
|
|
|
|
|
|
|
return ret;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_enable - enable regulator output
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
2008-12-31 12:52:43 +00:00
|
|
|
* Request that the regulator be enabled with the regulator output at
|
|
|
|
* the predefined voltage or current value. Calls to regulator_enable()
|
|
|
|
* must be balanced with calls to regulator_disable().
|
|
|
|
*
|
2008-04-30 14:59:04 +00:00
|
|
|
* NOTE: the output value can be set by other drivers, boot loader or may be
|
2008-12-31 12:52:43 +00:00
|
|
|
* hardwired in the regulator.
|
2008-04-30 14:59:04 +00:00
|
|
|
*/
|
|
|
|
int regulator_enable(struct regulator *regulator)
|
|
|
|
{
|
2008-11-16 19:44:46 +00:00
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
2018-11-18 21:56:17 +00:00
|
|
|
struct ww_acquire_ctx ww_ctx;
|
2018-11-20 17:52:53 +00:00
|
|
|
int ret;
|
2012-04-19 12:19:07 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_lock_dependent(rdev, &ww_ctx);
|
2018-11-20 17:52:53 +00:00
|
|
|
ret = _regulator_enable(regulator);
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_unlock_dependent(rdev, &ww_ctx);
|
2011-06-09 15:22:22 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_enable);
|
|
|
|
|
2012-06-27 12:21:26 +00:00
|
|
|
static int _regulator_do_disable(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
trace_regulator_disable(rdev_get_name(rdev));
|
|
|
|
|
2013-02-18 06:50:48 +00:00
|
|
|
if (rdev->ena_pin) {
|
2015-03-03 23:20:47 +00:00
|
|
|
if (rdev->ena_gpio_state) {
|
|
|
|
ret = regulator_ena_gpio_ctrl(rdev, false);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
rdev->ena_gpio_state = 0;
|
|
|
|
}
|
2012-06-27 12:21:26 +00:00
|
|
|
|
|
|
|
} else if (rdev->desc->ops->disable) {
|
|
|
|
ret = rdev->desc->ops->disable(rdev);
|
|
|
|
if (ret != 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-08-13 11:33:40 +00:00
|
|
|
/* cares about last_off_jiffy only if off_on_delay is required by
|
|
|
|
* device.
|
|
|
|
*/
|
|
|
|
if (rdev->desc->off_on_delay)
|
|
|
|
rdev->last_off_jiffy = jiffies;
|
|
|
|
|
2012-06-27 12:21:26 +00:00
|
|
|
trace_regulator_disable_complete(rdev_get_name(rdev));
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/* locks held by regulator_disable() */
|
2018-11-20 17:52:53 +00:00
|
|
|
static int _regulator_disable(struct regulator *regulator)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
2018-11-20 17:52:53 +00:00
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
2008-04-30 14:59:04 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
lockdep_assert_held_once(&rdev->mutex.base);
|
2015-06-29 00:04:43 +00:00
|
|
|
|
2009-03-12 00:43:34 +00:00
|
|
|
if (WARN(rdev->use_count <= 0,
|
2010-12-06 22:05:19 +00:00
|
|
|
"unbalanced disables for %s\n", rdev_get_name(rdev)))
|
2009-03-12 00:43:34 +00:00
|
|
|
return -EIO;
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/* are we the last user and permitted to disable ? */
|
2009-10-13 12:06:50 +00:00
|
|
|
if (rdev->use_count == 1 &&
|
|
|
|
(rdev->constraints && !rdev->constraints->always_on)) {
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
/* we are last user */
|
2016-04-23 07:11:05 +00:00
|
|
|
if (regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS)) {
|
2014-11-24 14:10:52 +00:00
|
|
|
ret = _notifier_call_chain(rdev,
|
|
|
|
REGULATOR_EVENT_PRE_DISABLE,
|
|
|
|
NULL);
|
|
|
|
if (ret & NOTIFY_STOP_MASK)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-06-27 12:21:26 +00:00
|
|
|
ret = _regulator_do_disable(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
if (ret < 0) {
|
2010-11-30 13:53:48 +00:00
|
|
|
rdev_err(rdev, "failed to disable\n");
|
2014-11-24 14:10:52 +00:00
|
|
|
_notifier_call_chain(rdev,
|
|
|
|
REGULATOR_EVENT_ABORT_DISABLE,
|
|
|
|
NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2014-02-20 16:36:04 +00:00
|
|
|
_notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
|
|
|
|
NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
rdev->use_count = 0;
|
|
|
|
} else if (rdev->use_count > 1) {
|
|
|
|
rdev->use_count--;
|
|
|
|
}
|
2011-06-09 15:22:22 +00:00
|
|
|
|
2018-11-20 17:52:53 +00:00
|
|
|
if (ret == 0)
|
|
|
|
ret = _regulator_handle_consumer_disable(regulator);
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
if (ret == 0 && rdev->coupling_desc.n_coupled > 1)
|
|
|
|
ret = regulator_balance_voltage(rdev, PM_SUSPEND_ON);
|
|
|
|
|
2018-11-20 17:52:54 +00:00
|
|
|
if (ret == 0 && rdev->use_count == 0 && rdev->supply)
|
2018-11-20 17:52:53 +00:00
|
|
|
ret = _regulator_disable(rdev->supply);
|
2018-11-18 21:56:17 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_disable - disable regulator output
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
2008-12-31 12:52:43 +00:00
|
|
|
* Disable the regulator output voltage or current. Calls to
|
|
|
|
* regulator_enable() must be balanced with calls to
|
|
|
|
* regulator_disable().
|
2008-12-31 12:52:41 +00:00
|
|
|
*
|
2008-04-30 14:59:04 +00:00
|
|
|
* NOTE: this will only disable the regulator output if no other consumer
|
2008-12-31 12:52:43 +00:00
|
|
|
* devices have it enabled, the regulator device supports disabling and
|
|
|
|
* machine constraints permit this operation.
|
2008-04-30 14:59:04 +00:00
|
|
|
*/
|
|
|
|
int regulator_disable(struct regulator *regulator)
|
|
|
|
{
|
2008-11-16 19:44:46 +00:00
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
2018-11-18 21:56:17 +00:00
|
|
|
struct ww_acquire_ctx ww_ctx;
|
2018-11-20 17:52:53 +00:00
|
|
|
int ret;
|
2012-04-19 12:19:07 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_lock_dependent(rdev, &ww_ctx);
|
2018-11-20 17:52:53 +00:00
|
|
|
ret = _regulator_disable(regulator);
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_unlock_dependent(rdev, &ww_ctx);
|
2010-10-08 19:49:19 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_disable);
|
|
|
|
|
|
|
|
/* locks held by regulator_force_disable() */
|
2011-06-09 15:22:22 +00:00
|
|
|
static int _regulator_force_disable(struct regulator_dev *rdev)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
lockdep_assert_held_once(&rdev->mutex.base);
|
2015-06-29 00:04:43 +00:00
|
|
|
|
2014-11-24 14:10:52 +00:00
|
|
|
ret = _notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
|
|
|
|
REGULATOR_EVENT_PRE_DISABLE, NULL);
|
|
|
|
if (ret & NOTIFY_STOP_MASK)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-02-20 16:36:04 +00:00
|
|
|
ret = _regulator_do_disable(rdev);
|
|
|
|
if (ret < 0) {
|
|
|
|
rdev_err(rdev, "failed to force disable\n");
|
2014-11-24 14:10:52 +00:00
|
|
|
_notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
|
|
|
|
REGULATOR_EVENT_ABORT_DISABLE, NULL);
|
2014-02-20 16:36:04 +00:00
|
|
|
return ret;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
2014-02-20 16:36:04 +00:00
|
|
|
_notifier_call_chain(rdev, REGULATOR_EVENT_FORCE_DISABLE |
|
|
|
|
REGULATOR_EVENT_DISABLE, NULL);
|
|
|
|
|
|
|
|
return 0;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_force_disable - force disable regulator output
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* Forcibly disable the regulator output voltage or current.
|
|
|
|
* NOTE: this *will* disable the regulator output even if other consumer
|
|
|
|
* devices have it enabled. This should be used for situations when device
|
|
|
|
* damage will likely occur if the regulator is not disabled (e.g. over temp).
|
|
|
|
*/
|
|
|
|
int regulator_force_disable(struct regulator *regulator)
|
|
|
|
{
|
2011-05-09 09:41:02 +00:00
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
2018-11-18 21:56:17 +00:00
|
|
|
struct ww_acquire_ctx ww_ctx;
|
2008-04-30 14:59:04 +00:00
|
|
|
int ret;
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_lock_dependent(rdev, &ww_ctx);
|
2018-11-20 17:52:53 +00:00
|
|
|
|
2011-06-09 15:22:22 +00:00
|
|
|
ret = _regulator_force_disable(regulator->rdev);
|
2018-11-20 17:52:53 +00:00
|
|
|
|
2018-10-05 15:36:29 +00:00
|
|
|
if (rdev->coupling_desc.n_coupled > 1)
|
|
|
|
regulator_balance_voltage(rdev, PM_SUSPEND_ON);
|
2018-11-20 17:52:53 +00:00
|
|
|
|
|
|
|
if (regulator->uA_load) {
|
|
|
|
regulator->uA_load = 0;
|
|
|
|
ret = drms_uA_update(rdev);
|
|
|
|
}
|
|
|
|
|
2018-11-20 17:52:54 +00:00
|
|
|
if (rdev->use_count != 0 && rdev->supply)
|
|
|
|
_regulator_disable(rdev->supply);
|
2010-10-08 19:49:19 +00:00
|
|
|
|
2018-11-20 17:52:54 +00:00
|
|
|
regulator_unlock_dependent(rdev, &ww_ctx);
|
2010-10-08 19:49:19 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_force_disable);
|
|
|
|
|
2011-09-11 08:53:50 +00:00
|
|
|
static void regulator_disable_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = container_of(work, struct regulator_dev,
|
|
|
|
disable_work.work);
|
2018-11-18 21:56:17 +00:00
|
|
|
struct ww_acquire_ctx ww_ctx;
|
2011-09-11 08:53:50 +00:00
|
|
|
int count, i, ret;
|
2018-11-20 17:52:53 +00:00
|
|
|
struct regulator *regulator;
|
|
|
|
int total_count = 0;
|
2011-09-11 08:53:50 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_lock_dependent(rdev, &ww_ctx);
|
2011-09-11 08:53:50 +00:00
|
|
|
|
2017-07-12 11:38:13 +00:00
|
|
|
/*
|
|
|
|
* Workqueue functions queue the new work instance while the previous
|
|
|
|
* work instance is being processed. Cancel the queued work instance
|
|
|
|
* as the work instance under processing does the job of the queued
|
|
|
|
* work instance.
|
|
|
|
*/
|
|
|
|
cancel_delayed_work(&rdev->disable_work);
|
|
|
|
|
2018-11-20 17:52:53 +00:00
|
|
|
list_for_each_entry(regulator, &rdev->consumer_list, list) {
|
|
|
|
count = regulator->deferred_disables;
|
|
|
|
|
|
|
|
if (!count)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
total_count += count;
|
|
|
|
regulator->deferred_disables = 0;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
ret = _regulator_disable(regulator);
|
|
|
|
if (ret != 0)
|
|
|
|
rdev_err(rdev, "Deferred disable failed: %d\n", ret);
|
|
|
|
}
|
2011-09-11 08:53:50 +00:00
|
|
|
}
|
2018-11-20 17:52:53 +00:00
|
|
|
WARN_ON(!total_count);
|
2011-09-11 08:53:50 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
if (rdev->coupling_desc.n_coupled > 1)
|
|
|
|
regulator_balance_voltage(rdev, PM_SUSPEND_ON);
|
|
|
|
|
|
|
|
regulator_unlock_dependent(rdev, &ww_ctx);
|
2011-09-11 08:53:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_disable_deferred - disable regulator output with delay
|
|
|
|
* @regulator: regulator source
|
2019-01-08 12:12:33 +00:00
|
|
|
* @ms: milliseconds until the regulator is disabled
|
2011-09-11 08:53:50 +00:00
|
|
|
*
|
|
|
|
* Execute regulator_disable() on the regulator after a delay. This
|
|
|
|
* is intended for use with devices that require some time to quiesce.
|
|
|
|
*
|
|
|
|
* NOTE: this will only disable the regulator output if no other consumer
|
|
|
|
* devices have it enabled, the regulator device supports disabling and
|
|
|
|
* machine constraints permit this operation.
|
|
|
|
*/
|
|
|
|
int regulator_disable_deferred(struct regulator *regulator, int ms)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
|
2012-09-07 03:00:53 +00:00
|
|
|
if (!ms)
|
|
|
|
return regulator_disable(regulator);
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2018-11-20 17:52:53 +00:00
|
|
|
regulator->deferred_disables++;
|
2017-07-12 11:38:13 +00:00
|
|
|
mod_delayed_work(system_power_efficient_wq, &rdev->disable_work,
|
|
|
|
msecs_to_jiffies(ms));
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2011-09-11 08:53:50 +00:00
|
|
|
|
2016-01-07 10:03:08 +00:00
|
|
|
return 0;
|
2011-09-11 08:53:50 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_disable_deferred);
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
static int _regulator_is_enabled(struct regulator_dev *rdev)
|
|
|
|
{
|
2012-06-27 13:14:38 +00:00
|
|
|
/* A GPIO control always takes precedence */
|
2013-02-18 06:50:55 +00:00
|
|
|
if (rdev->ena_pin)
|
2012-06-27 13:14:38 +00:00
|
|
|
return rdev->ena_gpio_state;
|
|
|
|
|
2010-02-11 17:22:45 +00:00
|
|
|
/* If we don't know then assume that the regulator is always on */
|
2009-08-03 17:49:56 +00:00
|
|
|
if (!rdev->desc->ops->is_enabled)
|
2010-02-11 17:22:45 +00:00
|
|
|
return 1;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2009-08-03 17:49:56 +00:00
|
|
|
return rdev->desc->ops->is_enabled(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
2018-01-22 14:30:07 +00:00
|
|
|
static int _regulator_list_voltage(struct regulator_dev *rdev,
|
|
|
|
unsigned selector, int lock)
|
2015-09-30 14:05:43 +00:00
|
|
|
{
|
|
|
|
const struct regulator_ops *ops = rdev->desc->ops;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (rdev->desc->fixed_uV && rdev->desc->n_voltages == 1 && !selector)
|
|
|
|
return rdev->desc->fixed_uV;
|
|
|
|
|
|
|
|
if (ops->list_voltage) {
|
|
|
|
if (selector >= rdev->desc->n_voltages)
|
|
|
|
return -EINVAL;
|
|
|
|
if (lock)
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2015-09-30 14:05:43 +00:00
|
|
|
ret = ops->list_voltage(rdev, selector);
|
|
|
|
if (lock)
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2017-03-27 23:54:12 +00:00
|
|
|
} else if (rdev->is_switch && rdev->supply) {
|
2018-01-22 14:30:07 +00:00
|
|
|
ret = _regulator_list_voltage(rdev->supply->rdev,
|
|
|
|
selector, lock);
|
2015-09-30 14:05:43 +00:00
|
|
|
} else {
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret > 0) {
|
|
|
|
if (ret < rdev->constraints->min_uV)
|
|
|
|
ret = 0;
|
|
|
|
else if (ret > rdev->constraints->max_uV)
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/**
|
|
|
|
* regulator_is_enabled - is the regulator output enabled
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
2008-11-16 19:44:46 +00:00
|
|
|
* Returns positive if the regulator driver backing the source/client
|
|
|
|
* has requested that the device be enabled, zero if it hasn't, else a
|
|
|
|
* negative errno code.
|
|
|
|
*
|
|
|
|
* Note that the device backing this regulator handle can have multiple
|
|
|
|
* users, so it might be enabled even if regulator_enable() was never
|
|
|
|
* called for this particular source.
|
2008-04-30 14:59:04 +00:00
|
|
|
*/
|
|
|
|
int regulator_is_enabled(struct regulator *regulator)
|
|
|
|
{
|
2009-08-03 17:49:56 +00:00
|
|
|
int ret;
|
|
|
|
|
2012-04-19 12:19:07 +00:00
|
|
|
if (regulator->always_on)
|
|
|
|
return 1;
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_lock(regulator->rdev);
|
2009-08-03 17:49:56 +00:00
|
|
|
ret = _regulator_is_enabled(regulator->rdev);
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_unlock(regulator->rdev);
|
2009-08-03 17:49:56 +00:00
|
|
|
|
|
|
|
return ret;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_is_enabled);
|
|
|
|
|
2009-02-26 19:48:36 +00:00
|
|
|
/**
|
|
|
|
* regulator_count_voltages - count regulator_list_voltage() selectors
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* Returns number of selectors, or negative errno. Selectors are
|
|
|
|
* numbered starting at zero, and typically correspond to bitfields
|
|
|
|
* in hardware registers.
|
|
|
|
*/
|
|
|
|
int regulator_count_voltages(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
|
2014-07-29 16:28:56 +00:00
|
|
|
if (rdev->desc->n_voltages)
|
|
|
|
return rdev->desc->n_voltages;
|
|
|
|
|
2017-03-27 23:54:12 +00:00
|
|
|
if (!rdev->is_switch || !rdev->supply)
|
2014-07-29 16:28:56 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return regulator_count_voltages(rdev->supply);
|
2009-02-26 19:48:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_count_voltages);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_list_voltage - enumerate supported voltages
|
|
|
|
* @regulator: regulator source
|
|
|
|
* @selector: identify voltage to list
|
|
|
|
* Context: can sleep
|
|
|
|
*
|
|
|
|
* Returns a voltage that can be passed to @regulator_set_voltage(),
|
2010-03-16 10:47:56 +00:00
|
|
|
* zero if this selector code can't be used on this system, or a
|
2009-02-26 19:48:36 +00:00
|
|
|
* negative errno.
|
|
|
|
*/
|
|
|
|
int regulator_list_voltage(struct regulator *regulator, unsigned selector)
|
|
|
|
{
|
2018-01-22 14:30:07 +00:00
|
|
|
return _regulator_list_voltage(regulator->rdev, selector, 1);
|
2009-02-26 19:48:36 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_list_voltage);
|
|
|
|
|
2014-07-21 15:38:48 +00:00
|
|
|
/**
|
|
|
|
* regulator_get_regmap - get the regulator's register map
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* Returns the register map for the given regulator, or an ERR_PTR value
|
|
|
|
* if the regulator doesn't use regmap.
|
|
|
|
*/
|
|
|
|
struct regmap *regulator_get_regmap(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
struct regmap *map = regulator->rdev->regmap;
|
|
|
|
|
|
|
|
return map ? map : ERR_PTR(-EOPNOTSUPP);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get_hardware_vsel_register - get the HW voltage selector register
|
|
|
|
* @regulator: regulator source
|
|
|
|
* @vsel_reg: voltage selector register, output parameter
|
|
|
|
* @vsel_mask: mask for voltage selector bitfield, output parameter
|
|
|
|
*
|
|
|
|
* Returns the hardware register offset and bitmask used for setting the
|
|
|
|
* regulator voltage. This might be useful when configuring voltage-scaling
|
|
|
|
* hardware or firmware that can make I2C requests behind the kernel's back,
|
|
|
|
* for example.
|
|
|
|
*
|
|
|
|
* On success, the output parameters @vsel_reg and @vsel_mask are filled in
|
|
|
|
* and 0 is returned, otherwise a negative errno is returned.
|
|
|
|
*/
|
|
|
|
int regulator_get_hardware_vsel_register(struct regulator *regulator,
|
|
|
|
unsigned *vsel_reg,
|
|
|
|
unsigned *vsel_mask)
|
|
|
|
{
|
2014-08-19 10:07:41 +00:00
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
const struct regulator_ops *ops = rdev->desc->ops;
|
2014-07-21 15:38:48 +00:00
|
|
|
|
|
|
|
if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
2017-12-07 13:30:09 +00:00
|
|
|
*vsel_reg = rdev->desc->vsel_reg;
|
|
|
|
*vsel_mask = rdev->desc->vsel_mask;
|
2014-07-21 15:38:48 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_hardware_vsel_register);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_list_hardware_vsel - get the HW-specific register value for a selector
|
|
|
|
* @regulator: regulator source
|
|
|
|
* @selector: identify voltage to list
|
|
|
|
*
|
|
|
|
* Converts the selector to a hardware-specific voltage selector that can be
|
|
|
|
* directly written to the regulator registers. The address of the voltage
|
|
|
|
* register can be determined by calling @regulator_get_hardware_vsel_register.
|
|
|
|
*
|
|
|
|
* On error a negative errno is returned.
|
|
|
|
*/
|
|
|
|
int regulator_list_hardware_vsel(struct regulator *regulator,
|
|
|
|
unsigned selector)
|
|
|
|
{
|
2014-08-19 10:07:41 +00:00
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
const struct regulator_ops *ops = rdev->desc->ops;
|
2014-07-21 15:38:48 +00:00
|
|
|
|
|
|
|
if (selector >= rdev->desc->n_voltages)
|
|
|
|
return -EINVAL;
|
|
|
|
if (ops->set_voltage_sel != regulator_set_voltage_sel_regmap)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
|
|
|
return selector;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_list_hardware_vsel);
|
|
|
|
|
2013-06-07 08:06:56 +00:00
|
|
|
/**
|
|
|
|
* regulator_get_linear_step - return the voltage step size between VSEL values
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* Returns the voltage step size between VSEL values for linear
|
|
|
|
* regulators, or return 0 if the regulator isn't a linear regulator.
|
|
|
|
*/
|
|
|
|
unsigned int regulator_get_linear_step(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
|
|
|
|
return rdev->desc->uV_step;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_linear_step);
|
|
|
|
|
2009-07-21 15:00:24 +00:00
|
|
|
/**
|
|
|
|
* regulator_is_supported_voltage - check if a voltage range can be supported
|
|
|
|
*
|
|
|
|
* @regulator: Regulator to check.
|
|
|
|
* @min_uV: Minimum required voltage in uV.
|
|
|
|
* @max_uV: Maximum required voltage in uV.
|
|
|
|
*
|
2019-04-22 17:28:24 +00:00
|
|
|
* Returns a boolean.
|
2009-07-21 15:00:24 +00:00
|
|
|
*/
|
|
|
|
int regulator_is_supported_voltage(struct regulator *regulator,
|
|
|
|
int min_uV, int max_uV)
|
|
|
|
{
|
2012-07-02 14:00:18 +00:00
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
2009-07-21 15:00:24 +00:00
|
|
|
int i, voltages, ret;
|
|
|
|
|
2012-07-02 14:00:18 +00:00
|
|
|
/* If we can't change voltage check the current voltage */
|
2016-04-23 07:11:05 +00:00
|
|
|
if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
|
2012-07-02 14:00:18 +00:00
|
|
|
ret = regulator_get_voltage(regulator);
|
|
|
|
if (ret >= 0)
|
2014-01-08 01:02:16 +00:00
|
|
|
return min_uV <= ret && ret <= max_uV;
|
2012-07-02 14:00:18 +00:00
|
|
|
else
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-09-24 17:56:53 +00:00
|
|
|
/* Any voltage within constrains range is fine? */
|
|
|
|
if (rdev->desc->continuous_voltage_range)
|
|
|
|
return min_uV >= rdev->constraints->min_uV &&
|
|
|
|
max_uV <= rdev->constraints->max_uV;
|
|
|
|
|
2009-07-21 15:00:24 +00:00
|
|
|
ret = regulator_count_voltages(regulator);
|
|
|
|
if (ret < 0)
|
2019-04-22 17:28:24 +00:00
|
|
|
return 0;
|
2009-07-21 15:00:24 +00:00
|
|
|
voltages = ret;
|
|
|
|
|
|
|
|
for (i = 0; i < voltages; i++) {
|
|
|
|
ret = regulator_list_voltage(regulator, i);
|
|
|
|
|
|
|
|
if (ret >= min_uV && ret <= max_uV)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2011-12-28 12:48:45 +00:00
|
|
|
EXPORT_SYMBOL_GPL(regulator_is_supported_voltage);
|
2009-07-21 15:00:24 +00:00
|
|
|
|
2015-10-20 12:37:27 +00:00
|
|
|
static int regulator_map_voltage(struct regulator_dev *rdev, int min_uV,
|
|
|
|
int max_uV)
|
|
|
|
{
|
|
|
|
const struct regulator_desc *desc = rdev->desc;
|
|
|
|
|
|
|
|
if (desc->ops->map_voltage)
|
|
|
|
return desc->ops->map_voltage(rdev, min_uV, max_uV);
|
|
|
|
|
|
|
|
if (desc->ops->list_voltage == regulator_list_voltage_linear)
|
|
|
|
return regulator_map_voltage_linear(rdev, min_uV, max_uV);
|
|
|
|
|
|
|
|
if (desc->ops->list_voltage == regulator_list_voltage_linear_range)
|
|
|
|
return regulator_map_voltage_linear_range(rdev, min_uV, max_uV);
|
|
|
|
|
2018-09-14 08:31:36 +00:00
|
|
|
if (desc->ops->list_voltage ==
|
|
|
|
regulator_list_voltage_pickable_linear_range)
|
|
|
|
return regulator_map_voltage_pickable_linear_range(rdev,
|
|
|
|
min_uV, max_uV);
|
|
|
|
|
2015-10-20 12:37:27 +00:00
|
|
|
return regulator_map_voltage_iterate(rdev, min_uV, max_uV);
|
|
|
|
}
|
|
|
|
|
2014-08-28 19:36:04 +00:00
|
|
|
static int _regulator_call_set_voltage(struct regulator_dev *rdev,
|
|
|
|
int min_uV, int max_uV,
|
|
|
|
unsigned *selector)
|
|
|
|
{
|
|
|
|
struct pre_voltage_change_data data;
|
|
|
|
int ret;
|
|
|
|
|
2019-06-23 21:08:32 +00:00
|
|
|
data.old_uV = regulator_get_voltage_rdev(rdev);
|
2014-08-28 19:36:04 +00:00
|
|
|
data.min_uV = min_uV;
|
|
|
|
data.max_uV = max_uV;
|
|
|
|
ret = _notifier_call_chain(rdev, REGULATOR_EVENT_PRE_VOLTAGE_CHANGE,
|
|
|
|
&data);
|
|
|
|
if (ret & NOTIFY_STOP_MASK)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV, selector);
|
|
|
|
if (ret >= 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
_notifier_call_chain(rdev, REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE,
|
|
|
|
(void *)data.old_uV);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int _regulator_call_set_voltage_sel(struct regulator_dev *rdev,
|
|
|
|
int uV, unsigned selector)
|
|
|
|
{
|
|
|
|
struct pre_voltage_change_data data;
|
|
|
|
int ret;
|
|
|
|
|
2019-06-23 21:08:32 +00:00
|
|
|
data.old_uV = regulator_get_voltage_rdev(rdev);
|
2014-08-28 19:36:04 +00:00
|
|
|
data.min_uV = uV;
|
|
|
|
data.max_uV = uV;
|
|
|
|
ret = _notifier_call_chain(rdev, REGULATOR_EVENT_PRE_VOLTAGE_CHANGE,
|
|
|
|
&data);
|
|
|
|
if (ret & NOTIFY_STOP_MASK)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
ret = rdev->desc->ops->set_voltage_sel(rdev, selector);
|
|
|
|
if (ret >= 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
_notifier_call_chain(rdev, REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE,
|
|
|
|
(void *)data.old_uV);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-07-03 16:10:34 +00:00
|
|
|
static int _regulator_set_voltage_sel_step(struct regulator_dev *rdev,
|
|
|
|
int uV, int new_selector)
|
|
|
|
{
|
|
|
|
const struct regulator_ops *ops = rdev->desc->ops;
|
|
|
|
int diff, old_sel, curr_sel, ret;
|
|
|
|
|
|
|
|
/* Stepping is only needed if the regulator is enabled. */
|
|
|
|
if (!_regulator_is_enabled(rdev))
|
|
|
|
goto final_set;
|
|
|
|
|
|
|
|
if (!ops->get_voltage_sel)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
old_sel = ops->get_voltage_sel(rdev);
|
|
|
|
if (old_sel < 0)
|
|
|
|
return old_sel;
|
|
|
|
|
|
|
|
diff = new_selector - old_sel;
|
|
|
|
if (diff == 0)
|
|
|
|
return 0; /* No change needed. */
|
|
|
|
|
|
|
|
if (diff > 0) {
|
|
|
|
/* Stepping up. */
|
|
|
|
for (curr_sel = old_sel + rdev->desc->vsel_step;
|
|
|
|
curr_sel < new_selector;
|
|
|
|
curr_sel += rdev->desc->vsel_step) {
|
|
|
|
/*
|
|
|
|
* Call the callback directly instead of using
|
|
|
|
* _regulator_call_set_voltage_sel() as we don't
|
|
|
|
* want to notify anyone yet. Same in the branch
|
|
|
|
* below.
|
|
|
|
*/
|
|
|
|
ret = ops->set_voltage_sel(rdev, curr_sel);
|
|
|
|
if (ret)
|
|
|
|
goto try_revert;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Stepping down. */
|
|
|
|
for (curr_sel = old_sel - rdev->desc->vsel_step;
|
|
|
|
curr_sel > new_selector;
|
|
|
|
curr_sel -= rdev->desc->vsel_step) {
|
|
|
|
ret = ops->set_voltage_sel(rdev, curr_sel);
|
|
|
|
if (ret)
|
|
|
|
goto try_revert;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
final_set:
|
|
|
|
/* The final selector will trigger the notifiers. */
|
|
|
|
return _regulator_call_set_voltage_sel(rdev, uV, new_selector);
|
|
|
|
|
|
|
|
try_revert:
|
|
|
|
/*
|
|
|
|
* At least try to return to the previous voltage if setting a new
|
|
|
|
* one failed.
|
|
|
|
*/
|
|
|
|
(void)ops->set_voltage_sel(rdev, old_sel);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-09-14 16:52:08 +00:00
|
|
|
static int _regulator_set_voltage_time(struct regulator_dev *rdev,
|
|
|
|
int old_uV, int new_uV)
|
|
|
|
{
|
|
|
|
unsigned int ramp_delay = 0;
|
|
|
|
|
|
|
|
if (rdev->constraints->ramp_delay)
|
|
|
|
ramp_delay = rdev->constraints->ramp_delay;
|
|
|
|
else if (rdev->desc->ramp_delay)
|
|
|
|
ramp_delay = rdev->desc->ramp_delay;
|
2017-04-04 13:29:50 +00:00
|
|
|
else if (rdev->constraints->settling_time)
|
|
|
|
return rdev->constraints->settling_time;
|
2017-05-16 18:43:43 +00:00
|
|
|
else if (rdev->constraints->settling_time_up &&
|
|
|
|
(new_uV > old_uV))
|
|
|
|
return rdev->constraints->settling_time_up;
|
|
|
|
else if (rdev->constraints->settling_time_down &&
|
|
|
|
(new_uV < old_uV))
|
|
|
|
return rdev->constraints->settling_time_down;
|
2016-09-14 16:52:08 +00:00
|
|
|
|
|
|
|
if (ramp_delay == 0) {
|
2016-10-27 12:31:39 +00:00
|
|
|
rdev_dbg(rdev, "ramp_delay not set\n");
|
2016-09-14 16:52:08 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return DIV_ROUND_UP(abs(new_uV - old_uV), ramp_delay);
|
|
|
|
}
|
|
|
|
|
2010-12-12 14:25:50 +00:00
|
|
|
static int _regulator_do_set_voltage(struct regulator_dev *rdev,
|
|
|
|
int min_uV, int max_uV)
|
|
|
|
{
|
|
|
|
int ret;
|
2011-03-17 12:24:36 +00:00
|
|
|
int delay = 0;
|
2012-06-26 09:57:51 +00:00
|
|
|
int best_val = 0;
|
2010-12-12 14:25:50 +00:00
|
|
|
unsigned int selector;
|
2012-04-04 02:32:10 +00:00
|
|
|
int old_selector = -1;
|
2016-09-14 16:52:05 +00:00
|
|
|
const struct regulator_ops *ops = rdev->desc->ops;
|
2019-06-23 21:08:32 +00:00
|
|
|
int old_uV = regulator_get_voltage_rdev(rdev);
|
2010-12-12 14:25:50 +00:00
|
|
|
|
|
|
|
trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
|
|
|
|
|
2011-05-08 21:13:37 +00:00
|
|
|
min_uV += rdev->constraints->uV_offset;
|
|
|
|
max_uV += rdev->constraints->uV_offset;
|
|
|
|
|
2012-04-04 02:32:10 +00:00
|
|
|
/*
|
|
|
|
* If we can't obtain the old selector there is not enough
|
|
|
|
* info to call set_voltage_time_sel().
|
|
|
|
*/
|
2012-05-21 01:37:52 +00:00
|
|
|
if (_regulator_is_enabled(rdev) &&
|
2016-09-14 16:52:05 +00:00
|
|
|
ops->set_voltage_time_sel && ops->get_voltage_sel) {
|
|
|
|
old_selector = ops->get_voltage_sel(rdev);
|
2012-04-04 02:32:10 +00:00
|
|
|
if (old_selector < 0)
|
|
|
|
return old_selector;
|
|
|
|
}
|
|
|
|
|
2016-09-14 16:52:05 +00:00
|
|
|
if (ops->set_voltage) {
|
2014-08-28 19:36:04 +00:00
|
|
|
ret = _regulator_call_set_voltage(rdev, min_uV, max_uV,
|
|
|
|
&selector);
|
2012-06-26 09:57:51 +00:00
|
|
|
|
|
|
|
if (ret >= 0) {
|
2016-09-14 16:52:05 +00:00
|
|
|
if (ops->list_voltage)
|
|
|
|
best_val = ops->list_voltage(rdev,
|
|
|
|
selector);
|
2012-06-26 09:57:51 +00:00
|
|
|
else
|
2019-06-23 21:08:32 +00:00
|
|
|
best_val = regulator_get_voltage_rdev(rdev);
|
2012-06-26 09:57:51 +00:00
|
|
|
}
|
|
|
|
|
2016-09-14 16:52:05 +00:00
|
|
|
} else if (ops->set_voltage_sel) {
|
2015-10-20 12:37:27 +00:00
|
|
|
ret = regulator_map_voltage(rdev, min_uV, max_uV);
|
2012-05-09 20:16:06 +00:00
|
|
|
if (ret >= 0) {
|
2016-09-14 16:52:05 +00:00
|
|
|
best_val = ops->list_voltage(rdev, ret);
|
2012-06-26 09:57:51 +00:00
|
|
|
if (min_uV <= best_val && max_uV >= best_val) {
|
|
|
|
selector = ret;
|
2013-02-06 03:09:48 +00:00
|
|
|
if (old_selector == selector)
|
|
|
|
ret = 0;
|
2019-07-03 16:10:34 +00:00
|
|
|
else if (rdev->desc->vsel_step)
|
|
|
|
ret = _regulator_set_voltage_sel_step(
|
|
|
|
rdev, best_val, selector);
|
2013-02-06 03:09:48 +00:00
|
|
|
else
|
2014-08-28 19:36:04 +00:00
|
|
|
ret = _regulator_call_set_voltage_sel(
|
|
|
|
rdev, best_val, selector);
|
2012-06-26 09:57:51 +00:00
|
|
|
} else {
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
2010-12-12 14:36:17 +00:00
|
|
|
}
|
2010-12-12 14:25:50 +00:00
|
|
|
} else {
|
|
|
|
ret = -EINVAL;
|
|
|
|
}
|
2010-12-12 14:36:17 +00:00
|
|
|
|
2016-09-14 16:52:06 +00:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2011-03-17 12:24:36 +00:00
|
|
|
|
2016-09-14 16:52:08 +00:00
|
|
|
if (ops->set_voltage_time_sel) {
|
|
|
|
/*
|
|
|
|
* Call set_voltage_time_sel if successfully obtained
|
|
|
|
* old_selector
|
|
|
|
*/
|
|
|
|
if (old_selector >= 0 && old_selector != selector)
|
|
|
|
delay = ops->set_voltage_time_sel(rdev, old_selector,
|
|
|
|
selector);
|
|
|
|
} else {
|
|
|
|
if (old_uV != best_val) {
|
|
|
|
if (ops->set_voltage_time)
|
|
|
|
delay = ops->set_voltage_time(rdev, old_uV,
|
|
|
|
best_val);
|
|
|
|
else
|
|
|
|
delay = _regulator_set_voltage_time(rdev,
|
|
|
|
old_uV,
|
|
|
|
best_val);
|
2010-12-12 14:36:17 +00:00
|
|
|
}
|
2016-09-14 16:52:08 +00:00
|
|
|
}
|
2010-12-12 14:25:50 +00:00
|
|
|
|
2016-09-14 16:52:08 +00:00
|
|
|
if (delay < 0) {
|
|
|
|
rdev_warn(rdev, "failed to get delay: %d\n", delay);
|
|
|
|
delay = 0;
|
2011-03-17 12:24:36 +00:00
|
|
|
}
|
|
|
|
|
2016-09-14 16:52:08 +00:00
|
|
|
/* Insert any necessary delays */
|
|
|
|
if (delay >= 1000) {
|
|
|
|
mdelay(delay / 1000);
|
|
|
|
udelay(delay % 1000);
|
|
|
|
} else if (delay) {
|
|
|
|
udelay(delay);
|
2011-03-17 12:24:36 +00:00
|
|
|
}
|
|
|
|
|
2016-09-14 16:52:06 +00:00
|
|
|
if (best_val >= 0) {
|
2012-08-06 15:44:19 +00:00
|
|
|
unsigned long data = best_val;
|
|
|
|
|
2010-12-16 13:59:10 +00:00
|
|
|
_notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
|
2012-08-06 15:44:19 +00:00
|
|
|
(void *)data);
|
|
|
|
}
|
2010-12-16 13:59:10 +00:00
|
|
|
|
2016-09-14 16:52:06 +00:00
|
|
|
out:
|
2012-04-04 02:32:10 +00:00
|
|
|
trace_regulator_set_voltage_complete(rdev_get_name(rdev), best_val);
|
2010-12-12 14:25:50 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2018-01-26 13:08:47 +00:00
|
|
|
static int _regulator_do_set_suspend_voltage(struct regulator_dev *rdev,
|
|
|
|
int min_uV, int max_uV, suspend_state_t state)
|
|
|
|
{
|
|
|
|
struct regulator_state *rstate;
|
|
|
|
int uV, sel;
|
|
|
|
|
|
|
|
rstate = regulator_get_suspend_state(rdev, state);
|
|
|
|
if (rstate == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (min_uV < rstate->min_uV)
|
|
|
|
min_uV = rstate->min_uV;
|
|
|
|
if (max_uV > rstate->max_uV)
|
|
|
|
max_uV = rstate->max_uV;
|
|
|
|
|
|
|
|
sel = regulator_map_voltage(rdev, min_uV, max_uV);
|
|
|
|
if (sel < 0)
|
|
|
|
return sel;
|
|
|
|
|
|
|
|
uV = rdev->desc->ops->list_voltage(rdev, sel);
|
|
|
|
if (uV >= min_uV && uV <= max_uV)
|
|
|
|
rstate->uV = uV;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-10-13 10:45:25 +00:00
|
|
|
static int regulator_set_voltage_unlocked(struct regulator *regulator,
|
2018-01-26 13:08:44 +00:00
|
|
|
int min_uV, int max_uV,
|
|
|
|
suspend_state_t state)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
2018-01-26 13:08:44 +00:00
|
|
|
struct regulator_voltage *voltage = ®ulator->voltage[state];
|
2010-12-16 15:49:37 +00:00
|
|
|
int ret = 0;
|
2012-12-13 09:13:00 +00:00
|
|
|
int old_min_uV, old_max_uV;
|
2014-02-05 20:30:26 +00:00
|
|
|
int current_uV;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2010-12-16 15:49:37 +00:00
|
|
|
/* If we're setting the same range as last time the change
|
|
|
|
* should be a noop (some cpufreq implementations use the same
|
|
|
|
* voltage for multiple frequencies, for example).
|
|
|
|
*/
|
2018-01-26 13:08:44 +00:00
|
|
|
if (voltage->min_uV == min_uV && voltage->max_uV == max_uV)
|
2010-12-16 15:49:37 +00:00
|
|
|
goto out;
|
|
|
|
|
2014-02-05 20:30:26 +00:00
|
|
|
/* If we're trying to set a range that overlaps the current voltage,
|
2015-08-13 12:39:49 +00:00
|
|
|
* return successfully even though the regulator does not support
|
2014-02-05 20:30:26 +00:00
|
|
|
* changing the voltage.
|
|
|
|
*/
|
2016-04-23 07:11:05 +00:00
|
|
|
if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_VOLTAGE)) {
|
2019-06-23 21:08:32 +00:00
|
|
|
current_uV = regulator_get_voltage_rdev(rdev);
|
2014-02-05 20:30:26 +00:00
|
|
|
if (min_uV <= current_uV && current_uV <= max_uV) {
|
2018-01-26 13:08:44 +00:00
|
|
|
voltage->min_uV = min_uV;
|
|
|
|
voltage->max_uV = max_uV;
|
2014-02-05 20:30:26 +00:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/* sanity check */
|
2010-12-12 14:36:17 +00:00
|
|
|
if (!rdev->desc->ops->set_voltage &&
|
|
|
|
!rdev->desc->ops->set_voltage_sel) {
|
2008-04-30 14:59:04 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* constraints check */
|
|
|
|
ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
2014-01-08 01:02:16 +00:00
|
|
|
|
2012-12-13 09:13:00 +00:00
|
|
|
/* restore original values in case of error */
|
2018-01-26 13:08:44 +00:00
|
|
|
old_min_uV = voltage->min_uV;
|
|
|
|
old_max_uV = voltage->max_uV;
|
|
|
|
voltage->min_uV = min_uV;
|
|
|
|
voltage->max_uV = max_uV;
|
2010-11-10 14:38:29 +00:00
|
|
|
|
2018-10-05 15:36:29 +00:00
|
|
|
/* for not coupled regulators this will just set the voltage */
|
|
|
|
ret = regulator_balance_voltage(rdev, state);
|
2019-03-18 16:17:57 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
voltage->min_uV = old_min_uV;
|
|
|
|
voltage->max_uV = old_max_uV;
|
|
|
|
}
|
2010-12-03 10:31:07 +00:00
|
|
|
|
2018-10-05 15:36:29 +00:00
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-06-23 21:08:32 +00:00
|
|
|
int regulator_set_voltage_rdev(struct regulator_dev *rdev, int min_uV,
|
|
|
|
int max_uV, suspend_state_t state)
|
2018-10-05 15:36:29 +00:00
|
|
|
{
|
|
|
|
int best_supply_uV = 0;
|
|
|
|
int supply_change_uV = 0;
|
|
|
|
int ret;
|
|
|
|
|
2017-04-13 17:36:59 +00:00
|
|
|
if (rdev->supply &&
|
|
|
|
regulator_ops_is_valid(rdev->supply->rdev,
|
|
|
|
REGULATOR_CHANGE_VOLTAGE) &&
|
2017-05-25 10:03:17 +00:00
|
|
|
(rdev->desc->min_dropout_uV || !(rdev->desc->ops->get_voltage ||
|
|
|
|
rdev->desc->ops->get_voltage_sel))) {
|
2015-10-20 12:37:28 +00:00
|
|
|
int current_supply_uV;
|
|
|
|
int selector;
|
|
|
|
|
|
|
|
selector = regulator_map_voltage(rdev, min_uV, max_uV);
|
|
|
|
if (selector < 0) {
|
|
|
|
ret = selector;
|
2018-10-05 15:36:29 +00:00
|
|
|
goto out;
|
2015-10-20 12:37:28 +00:00
|
|
|
}
|
|
|
|
|
2018-01-26 17:55:30 +00:00
|
|
|
best_supply_uV = _regulator_list_voltage(rdev, selector, 0);
|
2015-10-20 12:37:28 +00:00
|
|
|
if (best_supply_uV < 0) {
|
|
|
|
ret = best_supply_uV;
|
2018-10-05 15:36:29 +00:00
|
|
|
goto out;
|
2015-10-20 12:37:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
best_supply_uV += rdev->desc->min_dropout_uV;
|
|
|
|
|
2019-06-23 21:08:32 +00:00
|
|
|
current_supply_uV = regulator_get_voltage_rdev(rdev->supply->rdev);
|
2015-10-20 12:37:28 +00:00
|
|
|
if (current_supply_uV < 0) {
|
|
|
|
ret = current_supply_uV;
|
2018-10-05 15:36:29 +00:00
|
|
|
goto out;
|
2015-10-20 12:37:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
supply_change_uV = best_supply_uV - current_supply_uV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (supply_change_uV > 0) {
|
|
|
|
ret = regulator_set_voltage_unlocked(rdev->supply,
|
2018-01-26 13:08:44 +00:00
|
|
|
best_supply_uV, INT_MAX, state);
|
2015-10-20 12:37:28 +00:00
|
|
|
if (ret) {
|
|
|
|
dev_err(&rdev->dev, "Failed to increase supply voltage: %d\n",
|
|
|
|
ret);
|
2018-10-05 15:36:29 +00:00
|
|
|
goto out;
|
2015-10-20 12:37:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-26 13:08:47 +00:00
|
|
|
if (state == PM_SUSPEND_ON)
|
|
|
|
ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
|
|
|
|
else
|
|
|
|
ret = _regulator_do_set_suspend_voltage(rdev, min_uV,
|
|
|
|
max_uV, state);
|
2012-12-13 09:13:00 +00:00
|
|
|
if (ret < 0)
|
2018-10-05 15:36:29 +00:00
|
|
|
goto out;
|
2014-01-08 01:02:16 +00:00
|
|
|
|
2015-10-20 12:37:28 +00:00
|
|
|
if (supply_change_uV < 0) {
|
|
|
|
ret = regulator_set_voltage_unlocked(rdev->supply,
|
2018-01-26 13:08:44 +00:00
|
|
|
best_supply_uV, INT_MAX, state);
|
2015-10-20 12:37:28 +00:00
|
|
|
if (ret)
|
|
|
|
dev_warn(&rdev->dev, "Failed to decrease supply voltage: %d\n",
|
|
|
|
ret);
|
|
|
|
/* No need to fail here */
|
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
out:
|
2015-10-13 10:45:25 +00:00
|
|
|
return ret;
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, don't change its voltage if it breaks the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-04-23 14:33:41 +00:00
|
|
|
}
|
2020-01-20 12:39:21 +00:00
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_voltage_rdev);
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, don't change its voltage if it breaks the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-04-23 14:33:41 +00:00
|
|
|
|
2018-10-05 15:36:35 +00:00
|
|
|
static int regulator_limit_voltage_step(struct regulator_dev *rdev,
|
|
|
|
int *current_uV, int *min_uV)
|
|
|
|
{
|
|
|
|
struct regulation_constraints *constraints = rdev->constraints;
|
|
|
|
|
|
|
|
/* Limit voltage change only if necessary */
|
|
|
|
if (!constraints->max_uV_step || !_regulator_is_enabled(rdev))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
if (*current_uV < 0) {
|
2019-06-23 21:08:32 +00:00
|
|
|
*current_uV = regulator_get_voltage_rdev(rdev);
|
2018-10-05 15:36:35 +00:00
|
|
|
|
|
|
|
if (*current_uV < 0)
|
|
|
|
return *current_uV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (abs(*current_uV - *min_uV) <= constraints->max_uV_step)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
/* Clamp target voltage within the given step */
|
|
|
|
if (*current_uV < *min_uV)
|
|
|
|
*min_uV = min(*current_uV + constraints->max_uV_step,
|
|
|
|
*min_uV);
|
|
|
|
else
|
|
|
|
*min_uV = max(*current_uV - constraints->max_uV_step,
|
|
|
|
*min_uV);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
static int regulator_get_optimal_voltage(struct regulator_dev *rdev,
|
|
|
|
int *current_uV,
|
|
|
|
int *min_uV, int *max_uV,
|
|
|
|
suspend_state_t state,
|
|
|
|
int n_coupled)
|
|
|
|
{
|
|
|
|
struct coupling_desc *c_desc = &rdev->coupling_desc;
|
|
|
|
struct regulator_dev **c_rdevs = c_desc->coupled_rdevs;
|
|
|
|
struct regulation_constraints *constraints = rdev->constraints;
|
|
|
|
int desired_min_uV = 0, desired_max_uV = INT_MAX;
|
|
|
|
int max_current_uV = 0, min_current_uV = INT_MAX;
|
|
|
|
int highest_min_uV = 0, target_uV, possible_uV;
|
2019-06-23 21:08:31 +00:00
|
|
|
int i, ret, max_spread;
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
bool done;
|
|
|
|
|
|
|
|
*current_uV = -1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there are no coupled regulators, simply set the voltage
|
|
|
|
* demanded by consumers.
|
|
|
|
*/
|
|
|
|
if (n_coupled == 1) {
|
|
|
|
/*
|
|
|
|
* If consumers don't provide any demands, set voltage
|
|
|
|
* to min_uV
|
|
|
|
*/
|
|
|
|
desired_min_uV = constraints->min_uV;
|
|
|
|
desired_max_uV = constraints->max_uV;
|
|
|
|
|
|
|
|
ret = regulator_check_consumers(rdev,
|
|
|
|
&desired_min_uV,
|
|
|
|
&desired_max_uV, state);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
possible_uV = desired_min_uV;
|
|
|
|
done = true;
|
|
|
|
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find highest min desired voltage */
|
|
|
|
for (i = 0; i < n_coupled; i++) {
|
|
|
|
int tmp_min = 0;
|
|
|
|
int tmp_max = INT_MAX;
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
lockdep_assert_held_once(&c_rdevs[i]->mutex.base);
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
|
|
|
|
ret = regulator_check_consumers(c_rdevs[i],
|
|
|
|
&tmp_min,
|
|
|
|
&tmp_max, state);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
ret = regulator_check_voltage(c_rdevs[i], &tmp_min, &tmp_max);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, don't change its voltage if it breaks the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-04-23 14:33:41 +00:00
|
|
|
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
highest_min_uV = max(highest_min_uV, tmp_min);
|
|
|
|
|
|
|
|
if (i == 0) {
|
|
|
|
desired_min_uV = tmp_min;
|
|
|
|
desired_max_uV = tmp_max;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-23 21:08:31 +00:00
|
|
|
max_spread = constraints->max_spread[0];
|
|
|
|
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
/*
|
|
|
|
* 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 = 1; i < n_coupled; i++) {
|
|
|
|
int tmp_act;
|
|
|
|
|
|
|
|
if (!_regulator_is_enabled(c_rdevs[i]))
|
|
|
|
continue;
|
|
|
|
|
2019-06-23 21:08:32 +00:00
|
|
|
tmp_act = regulator_get_voltage_rdev(c_rdevs[i]);
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
if (tmp_act < 0)
|
|
|
|
return tmp_act;
|
|
|
|
|
|
|
|
min_current_uV = min(tmp_act, min_current_uV);
|
|
|
|
max_current_uV = max(tmp_act, max_current_uV);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
done = (possible_uV == target_uV);
|
|
|
|
desired_min_uV = possible_uV;
|
|
|
|
|
|
|
|
finish:
|
2018-10-05 15:36:35 +00:00
|
|
|
/* Apply max_uV_step constraint if necessary */
|
|
|
|
if (state == PM_SUSPEND_ON) {
|
|
|
|
ret = regulator_limit_voltage_step(rdev, current_uV,
|
|
|
|
&desired_min_uV);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (ret == 0)
|
|
|
|
done = false;
|
|
|
|
}
|
|
|
|
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
/* Set current_uV if wasn't done earlier in the code and if necessary */
|
|
|
|
if (n_coupled > 1 && *current_uV == -1) {
|
|
|
|
|
|
|
|
if (_regulator_is_enabled(rdev)) {
|
2019-06-23 21:08:32 +00:00
|
|
|
ret = regulator_get_voltage_rdev(rdev);
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
*current_uV = ret;
|
|
|
|
} else {
|
|
|
|
*current_uV = desired_min_uV;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*min_uV = desired_min_uV;
|
|
|
|
*max_uV = desired_max_uV;
|
|
|
|
|
|
|
|
return done;
|
|
|
|
}
|
|
|
|
|
2020-05-29 12:49:39 +00:00
|
|
|
int regulator_do_balance_voltage(struct regulator_dev *rdev,
|
|
|
|
suspend_state_t state, bool skip_coupled)
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
{
|
|
|
|
struct regulator_dev **c_rdevs;
|
|
|
|
struct regulator_dev *best_rdev;
|
|
|
|
struct coupling_desc *c_desc = &rdev->coupling_desc;
|
|
|
|
int i, ret, n_coupled, best_min_uV, best_max_uV, best_c_rdev;
|
|
|
|
unsigned int delta, best_delta;
|
2019-06-23 21:08:31 +00:00
|
|
|
unsigned long c_rdev_done = 0;
|
|
|
|
bool best_c_rdev_done;
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
|
|
|
|
c_rdevs = c_desc->coupled_rdevs;
|
2020-05-29 12:49:39 +00:00
|
|
|
n_coupled = skip_coupled ? 1 : c_desc->n_coupled;
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Find the best possible voltage change on each loop. Leave the loop
|
|
|
|
* if there isn't any possible change.
|
|
|
|
*/
|
|
|
|
do {
|
|
|
|
best_c_rdev_done = false;
|
|
|
|
best_delta = 0;
|
|
|
|
best_min_uV = 0;
|
|
|
|
best_max_uV = 0;
|
|
|
|
best_c_rdev = 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 = 0, optimal_max_uV = 0, current_uV = 0;
|
|
|
|
|
2019-06-23 21:08:31 +00:00
|
|
|
if (test_bit(i, &c_rdev_done))
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = regulator_get_optimal_voltage(c_rdevs[i],
|
|
|
|
¤t_uV,
|
|
|
|
&optimal_uV,
|
|
|
|
&optimal_max_uV,
|
|
|
|
state, n_coupled);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
delta = abs(optimal_uV - current_uV);
|
|
|
|
|
|
|
|
if (delta && best_delta <= delta) {
|
|
|
|
best_c_rdev_done = ret;
|
|
|
|
best_delta = delta;
|
|
|
|
best_rdev = c_rdevs[i];
|
|
|
|
best_min_uV = optimal_uV;
|
|
|
|
best_max_uV = optimal_max_uV;
|
|
|
|
best_c_rdev = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Nothing to change, return successfully */
|
|
|
|
if (!best_rdev) {
|
|
|
|
ret = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
2018-10-05 15:36:29 +00:00
|
|
|
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
ret = regulator_set_voltage_rdev(best_rdev, best_min_uV,
|
|
|
|
best_max_uV, state);
|
2018-10-05 15:36:29 +00:00
|
|
|
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
2019-06-23 21:08:31 +00:00
|
|
|
if (best_c_rdev_done)
|
|
|
|
set_bit(best_c_rdev, &c_rdev_done);
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, change its voltage so that it doesn't break the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Dmitry Osipenko <digetx@gmail.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-10-05 15:36:28 +00:00
|
|
|
|
|
|
|
} while (n_coupled > 1);
|
|
|
|
|
|
|
|
out:
|
regulator: core: Add voltage balancing mechanism
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.
Introduce new function regulator_balance_voltage(), which
keeps max_spread constraint fulfilled between a group of coupled
regulators. It should be called if a regulator changes its
voltage or after disabling or enabling. Disabled regulators should
follow changes of the enabled ones, but their consumers' demands
shouldn't be taken into account while calculating voltage of other
coupled regulators.
Find voltages, which are closest to suiting all the consumers' demands,
while fulfilling max_spread constraint, keeping the following rules:
- if one regulator is about to rise its voltage, rise others
voltages in order to keep the max_spread
- if a regulator, which has caused rising other regulators, is
lowered, lower other regulators if possible
- if one regulator is about to lower its voltage, but it hasn't caused
rising other regulators, don't change its voltage if it breaks the
max_spread
Change regulators' voltages step by step, keeping max_spread constraint
fulfilled all the time. Function regulator_get_optimal_voltage()
should find the best possible change for the regulator, which doesn't
break max_spread constraint. In function regulator_balance_voltage()
optimize number of steps by finding highest voltage difference on
each iteration.
If a regulator, which is about to change its voltage, is not coupled,
method regulator_get_optimal_voltage() should simply return the lowest
voltage fulfilling consumers' demands.
Coupling should be checked only if the system is in PM_SUSPEND_ON state.
Signed-off-by: Maciej Purski <m.purski@samsung.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2018-04-23 14:33:41 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-05-29 12:49:39 +00:00
|
|
|
static int regulator_balance_voltage(struct regulator_dev *rdev,
|
|
|
|
suspend_state_t state)
|
|
|
|
{
|
|
|
|
struct coupling_desc *c_desc = &rdev->coupling_desc;
|
|
|
|
struct regulator_coupler *coupler = c_desc->coupler;
|
|
|
|
bool skip_coupled = false;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If system is in a state other than PM_SUSPEND_ON, don't check
|
|
|
|
* other coupled regulators.
|
|
|
|
*/
|
|
|
|
if (state != PM_SUSPEND_ON)
|
|
|
|
skip_coupled = true;
|
|
|
|
|
|
|
|
if (c_desc->n_resolved < c_desc->n_coupled) {
|
|
|
|
rdev_err(rdev, "Not all coupled regulators registered\n");
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Invoke custom balancer for customized couplers */
|
|
|
|
if (coupler && coupler->balance_voltage)
|
|
|
|
return coupler->balance_voltage(coupler, rdev, state);
|
|
|
|
|
|
|
|
return regulator_do_balance_voltage(rdev, state, skip_coupled);
|
|
|
|
}
|
|
|
|
|
2015-10-13 10:45:25 +00:00
|
|
|
/**
|
|
|
|
* regulator_set_voltage - set regulator output voltage
|
|
|
|
* @regulator: regulator source
|
|
|
|
* @min_uV: Minimum required voltage in uV
|
|
|
|
* @max_uV: Maximum acceptable voltage in uV
|
|
|
|
*
|
|
|
|
* Sets a voltage regulator to the desired output voltage. This can be set
|
|
|
|
* during any regulator state. IOW, regulator can be disabled or enabled.
|
|
|
|
*
|
|
|
|
* If the regulator is enabled then the voltage will change to the new value
|
|
|
|
* immediately otherwise if the regulator is disabled the regulator will
|
|
|
|
* output at the new voltage when enabled.
|
|
|
|
*
|
|
|
|
* NOTE: If the regulator is shared between several devices then the lowest
|
|
|
|
* request voltage that meets the system constraints will be used.
|
|
|
|
* Regulator system constraints must be set for this regulator before
|
|
|
|
* calling this function otherwise this call will fail.
|
|
|
|
*/
|
|
|
|
int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
|
|
|
|
{
|
2018-11-18 21:56:17 +00:00
|
|
|
struct ww_acquire_ctx ww_ctx;
|
|
|
|
int ret;
|
2015-10-13 10:45:25 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_lock_dependent(regulator->rdev, &ww_ctx);
|
2015-10-13 10:45:25 +00:00
|
|
|
|
2018-01-26 13:08:44 +00:00
|
|
|
ret = regulator_set_voltage_unlocked(regulator, min_uV, max_uV,
|
|
|
|
PM_SUSPEND_ON);
|
2015-10-13 10:45:25 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_unlock_dependent(regulator->rdev, &ww_ctx);
|
2015-10-13 10:45:25 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_voltage);
|
|
|
|
|
2018-01-26 13:08:47 +00:00
|
|
|
static inline int regulator_suspend_toggle(struct regulator_dev *rdev,
|
|
|
|
suspend_state_t state, bool en)
|
|
|
|
{
|
|
|
|
struct regulator_state *rstate;
|
|
|
|
|
|
|
|
rstate = regulator_get_suspend_state(rdev, state);
|
|
|
|
if (rstate == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!rstate->changeable)
|
|
|
|
return -EPERM;
|
|
|
|
|
2018-09-03 14:49:37 +00:00
|
|
|
rstate->enabled = (en) ? ENABLE_IN_SUSPEND : DISABLE_IN_SUSPEND;
|
2018-01-26 13:08:47 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int regulator_suspend_enable(struct regulator_dev *rdev,
|
|
|
|
suspend_state_t state)
|
|
|
|
{
|
|
|
|
return regulator_suspend_toggle(rdev, state, true);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_suspend_enable);
|
|
|
|
|
|
|
|
int regulator_suspend_disable(struct regulator_dev *rdev,
|
|
|
|
suspend_state_t state)
|
|
|
|
{
|
|
|
|
struct regulator *regulator;
|
|
|
|
struct regulator_voltage *voltage;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if any consumer wants this regulator device keeping on in
|
|
|
|
* suspend states, don't set it as disabled.
|
|
|
|
*/
|
|
|
|
list_for_each_entry(regulator, &rdev->consumer_list, list) {
|
|
|
|
voltage = ®ulator->voltage[state];
|
|
|
|
if (voltage->min_uV || voltage->max_uV)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return regulator_suspend_toggle(rdev, state, false);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_suspend_disable);
|
|
|
|
|
|
|
|
static int _regulator_set_suspend_voltage(struct regulator *regulator,
|
|
|
|
int min_uV, int max_uV,
|
|
|
|
suspend_state_t state)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
struct regulator_state *rstate;
|
|
|
|
|
|
|
|
rstate = regulator_get_suspend_state(rdev, state);
|
|
|
|
if (rstate == NULL)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (rstate->min_uV == rstate->max_uV) {
|
|
|
|
rdev_err(rdev, "The suspend voltage can't be changed!\n");
|
|
|
|
return -EPERM;
|
|
|
|
}
|
|
|
|
|
|
|
|
return regulator_set_voltage_unlocked(regulator, min_uV, max_uV, state);
|
|
|
|
}
|
|
|
|
|
|
|
|
int regulator_set_suspend_voltage(struct regulator *regulator, int min_uV,
|
|
|
|
int max_uV, suspend_state_t state)
|
|
|
|
{
|
2018-11-18 21:56:17 +00:00
|
|
|
struct ww_acquire_ctx ww_ctx;
|
|
|
|
int ret;
|
2018-01-26 13:08:47 +00:00
|
|
|
|
|
|
|
/* PM_SUSPEND_ON is handled by regulator_set_voltage() */
|
|
|
|
if (regulator_check_states(state) || state == PM_SUSPEND_ON)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_lock_dependent(regulator->rdev, &ww_ctx);
|
2018-01-26 13:08:47 +00:00
|
|
|
|
|
|
|
ret = _regulator_set_suspend_voltage(regulator, min_uV,
|
|
|
|
max_uV, state);
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_unlock_dependent(regulator->rdev, &ww_ctx);
|
2018-01-26 13:08:47 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_suspend_voltage);
|
|
|
|
|
2011-03-17 12:24:52 +00:00
|
|
|
/**
|
|
|
|
* regulator_set_voltage_time - get raise/fall time
|
|
|
|
* @regulator: regulator source
|
|
|
|
* @old_uV: starting voltage in microvolts
|
|
|
|
* @new_uV: target voltage in microvolts
|
|
|
|
*
|
|
|
|
* Provided with the starting and ending voltage, this function attempts to
|
|
|
|
* calculate the time in microseconds required to rise or fall to this new
|
|
|
|
* voltage.
|
|
|
|
*/
|
|
|
|
int regulator_set_voltage_time(struct regulator *regulator,
|
|
|
|
int old_uV, int new_uV)
|
|
|
|
{
|
2014-08-13 11:33:38 +00:00
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
const struct regulator_ops *ops = rdev->desc->ops;
|
2011-03-17 12:24:52 +00:00
|
|
|
int old_sel = -1;
|
|
|
|
int new_sel = -1;
|
|
|
|
int voltage;
|
|
|
|
int i;
|
|
|
|
|
2016-09-14 16:52:08 +00:00
|
|
|
if (ops->set_voltage_time)
|
|
|
|
return ops->set_voltage_time(rdev, old_uV, new_uV);
|
|
|
|
else if (!ops->set_voltage_time_sel)
|
|
|
|
return _regulator_set_voltage_time(rdev, old_uV, new_uV);
|
|
|
|
|
2011-03-17 12:24:52 +00:00
|
|
|
/* Currently requires operations to do this */
|
2016-09-14 16:52:08 +00:00
|
|
|
if (!ops->list_voltage || !rdev->desc->n_voltages)
|
2011-03-17 12:24:52 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
for (i = 0; i < rdev->desc->n_voltages; i++) {
|
|
|
|
/* We only look for exact voltage matches here */
|
|
|
|
voltage = regulator_list_voltage(regulator, i);
|
|
|
|
if (voltage < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
if (voltage == 0)
|
|
|
|
continue;
|
|
|
|
if (voltage == old_uV)
|
|
|
|
old_sel = i;
|
|
|
|
if (voltage == new_uV)
|
|
|
|
new_sel = i;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (old_sel < 0 || new_sel < 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return ops->set_voltage_time_sel(rdev, old_sel, new_sel);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
|
|
|
|
|
2012-06-09 11:10:38 +00:00
|
|
|
/**
|
2012-08-19 00:44:14 +00:00
|
|
|
* regulator_set_voltage_time_sel - get raise/fall time
|
|
|
|
* @rdev: regulator source device
|
2012-06-09 11:10:38 +00:00
|
|
|
* @old_selector: selector for starting voltage
|
|
|
|
* @new_selector: selector for target voltage
|
|
|
|
*
|
|
|
|
* Provided with the starting and target voltage selectors, this function
|
|
|
|
* returns time in microseconds required to rise or fall to this new voltage
|
|
|
|
*
|
2012-06-19 01:38:45 +00:00
|
|
|
* Drivers providing ramp_delay in regulation_constraints can use this as their
|
2012-06-18 02:11:28 +00:00
|
|
|
* set_voltage_time_sel() operation.
|
2012-06-09 11:10:38 +00:00
|
|
|
*/
|
|
|
|
int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
|
|
|
|
unsigned int old_selector,
|
|
|
|
unsigned int new_selector)
|
|
|
|
{
|
2012-06-19 01:38:45 +00:00
|
|
|
int old_volt, new_volt;
|
2012-06-18 02:11:28 +00:00
|
|
|
|
2012-06-19 01:38:45 +00:00
|
|
|
/* sanity check */
|
|
|
|
if (!rdev->desc->ops->list_voltage)
|
|
|
|
return -EINVAL;
|
2012-06-18 02:11:28 +00:00
|
|
|
|
2012-06-19 01:38:45 +00:00
|
|
|
old_volt = rdev->desc->ops->list_voltage(rdev, old_selector);
|
|
|
|
new_volt = rdev->desc->ops->list_voltage(rdev, new_selector);
|
|
|
|
|
2016-09-14 16:52:08 +00:00
|
|
|
if (rdev->desc->ops->set_voltage_time)
|
|
|
|
return rdev->desc->ops->set_voltage_time(rdev, old_volt,
|
|
|
|
new_volt);
|
|
|
|
else
|
|
|
|
return _regulator_set_voltage_time(rdev, old_volt, new_volt);
|
2012-06-09 11:10:38 +00:00
|
|
|
}
|
2012-06-23 10:34:20 +00:00
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel);
|
2012-06-09 11:10:38 +00:00
|
|
|
|
2010-12-16 15:49:36 +00:00
|
|
|
/**
|
|
|
|
* regulator_sync_voltage - re-apply last regulator output voltage
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* Re-apply the last configured voltage. This is intended to be used
|
|
|
|
* where some external control source the consumer is cooperating with
|
|
|
|
* has caused the configured voltage to change.
|
|
|
|
*/
|
|
|
|
int regulator_sync_voltage(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
2018-01-26 13:08:44 +00:00
|
|
|
struct regulator_voltage *voltage = ®ulator->voltage[PM_SUSPEND_ON];
|
2010-12-16 15:49:36 +00:00
|
|
|
int ret, min_uV, max_uV;
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2010-12-16 15:49:36 +00:00
|
|
|
|
|
|
|
if (!rdev->desc->ops->set_voltage &&
|
|
|
|
!rdev->desc->ops->set_voltage_sel) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This is only going to work if we've had a voltage configured. */
|
2018-01-26 13:08:44 +00:00
|
|
|
if (!voltage->min_uV && !voltage->max_uV) {
|
2010-12-16 15:49:36 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2018-01-26 13:08:44 +00:00
|
|
|
min_uV = voltage->min_uV;
|
|
|
|
max_uV = voltage->max_uV;
|
2010-12-16 15:49:36 +00:00
|
|
|
|
|
|
|
/* This should be a paranoia check... */
|
|
|
|
ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
2018-01-26 13:08:44 +00:00
|
|
|
ret = regulator_check_consumers(rdev, &min_uV, &max_uV, 0);
|
2010-12-16 15:49:36 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
|
|
|
|
|
|
|
|
out:
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2010-12-16 15:49:36 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_sync_voltage);
|
|
|
|
|
2019-06-23 21:08:32 +00:00
|
|
|
int regulator_get_voltage_rdev(struct regulator_dev *rdev)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
2011-05-08 21:13:37 +00:00
|
|
|
int sel, ret;
|
2016-04-07 14:22:36 +00:00
|
|
|
bool bypassed;
|
|
|
|
|
|
|
|
if (rdev->desc->ops->get_bypass) {
|
|
|
|
ret = rdev->desc->ops->get_bypass(rdev, &bypassed);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
if (bypassed) {
|
|
|
|
/* if bypassed the regulator must have a supply */
|
regulator: core: Add early supply resolution for regulators
The call to set_machine_constraints() in regulator_register(), will
attempt to get the voltage for the regulator. If a regulator is in
bypass will fail to get the voltage (ie. it's bypass voltage) and
hence register the regulator, because the supply for the regulator has
not been resolved yet.
To fix this, add a call to regulator_resolve_supply() before we call
set_machine_constraints(). If the call to regulator_resolve_supply()
fails, rather than returning an error at this point, allow the
registration of the regulator to continue because for some regulators
resolving the supply at this point may not be necessary and it will be
resolved later as more regulators are added. Furthermore, if the supply
is still not resolved for a bypassed regulator, this will be detected
when we attempt to get the voltage for the regulator and an error will
be propagated at this point.
If a bypassed regulator does not have a supply when we attempt to get
the voltage, rather than returing -EINVAL, return -EPROBE_DEFER instead
to allow the registration of the regulator to be deferred and tried
again later.
Please note that regulator_resolve_supply() will call
regulator_dev_lookup() which may acquire the regulator_list_mutex. To
avoid any deadlocks we cannot hold the regulator_list_mutex when calling
regulator_resolve_supply(). Therefore, rather than holding the lock
around a large portion of the registration code, just hold the lock when
aquiring any GPIOs and setting up supplies because these sections may
add entries to the regulator_map_list and regulator_ena_gpio_list,
respectively.
Signed-off-by: Jon Hunter <jonathanh@nvidia.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2016-04-26 10:29:45 +00:00
|
|
|
if (!rdev->supply) {
|
|
|
|
rdev_err(rdev,
|
|
|
|
"bypassed regulator has no supply!\n");
|
|
|
|
return -EPROBE_DEFER;
|
|
|
|
}
|
2016-04-07 14:22:36 +00:00
|
|
|
|
2019-06-23 21:08:32 +00:00
|
|
|
return regulator_get_voltage_rdev(rdev->supply->rdev);
|
2016-04-07 14:22:36 +00:00
|
|
|
}
|
|
|
|
}
|
2010-12-10 17:28:07 +00:00
|
|
|
|
|
|
|
if (rdev->desc->ops->get_voltage_sel) {
|
|
|
|
sel = rdev->desc->ops->get_voltage_sel(rdev);
|
|
|
|
if (sel < 0)
|
|
|
|
return sel;
|
2011-05-08 21:13:37 +00:00
|
|
|
ret = rdev->desc->ops->list_voltage(rdev, sel);
|
2011-05-23 12:08:10 +00:00
|
|
|
} else if (rdev->desc->ops->get_voltage) {
|
2011-05-08 21:13:37 +00:00
|
|
|
ret = rdev->desc->ops->get_voltage(rdev);
|
2012-08-09 15:42:19 +00:00
|
|
|
} else if (rdev->desc->ops->list_voltage) {
|
|
|
|
ret = rdev->desc->ops->list_voltage(rdev, 0);
|
2013-09-10 10:15:05 +00:00
|
|
|
} else if (rdev->desc->fixed_uV && (rdev->desc->n_voltages == 1)) {
|
|
|
|
ret = rdev->desc->fixed_uV;
|
2014-07-29 16:28:55 +00:00
|
|
|
} else if (rdev->supply) {
|
2019-06-23 21:08:32 +00:00
|
|
|
ret = regulator_get_voltage_rdev(rdev->supply->rdev);
|
2011-05-23 12:08:10 +00:00
|
|
|
} else {
|
2008-04-30 14:59:04 +00:00
|
|
|
return -EINVAL;
|
2011-05-23 12:08:10 +00:00
|
|
|
}
|
2011-05-08 21:13:37 +00:00
|
|
|
|
2011-05-23 12:08:10 +00:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2011-05-08 21:13:37 +00:00
|
|
|
return ret - rdev->constraints->uV_offset;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2020-01-20 12:39:21 +00:00
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_voltage_rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get_voltage - get regulator output voltage
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* This returns the current regulator voltage in uV.
|
|
|
|
*
|
|
|
|
* NOTE: If the regulator is disabled it will return the voltage value. This
|
|
|
|
* function should not be used to determine regulator state.
|
|
|
|
*/
|
|
|
|
int regulator_get_voltage(struct regulator *regulator)
|
|
|
|
{
|
2018-11-18 21:56:17 +00:00
|
|
|
struct ww_acquire_ctx ww_ctx;
|
2008-04-30 14:59:04 +00:00
|
|
|
int ret;
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_lock_dependent(regulator->rdev, &ww_ctx);
|
2019-06-23 21:08:32 +00:00
|
|
|
ret = regulator_get_voltage_rdev(regulator->rdev);
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_unlock_dependent(regulator->rdev, &ww_ctx);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_voltage);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_set_current_limit - set regulator output current limit
|
|
|
|
* @regulator: regulator source
|
2013-05-21 14:04:07 +00:00
|
|
|
* @min_uA: Minimum supported current in uA
|
2008-04-30 14:59:04 +00:00
|
|
|
* @max_uA: Maximum supported current in uA
|
|
|
|
*
|
|
|
|
* Sets current sink to the desired output current. This can be set during
|
|
|
|
* any regulator state. IOW, regulator can be disabled or enabled.
|
|
|
|
*
|
|
|
|
* If the regulator is enabled then the current will change to the new value
|
|
|
|
* immediately otherwise if the regulator is disabled the regulator will
|
|
|
|
* output at the new current when enabled.
|
|
|
|
*
|
|
|
|
* NOTE: Regulator system constraints must be set for this regulator before
|
|
|
|
* calling this function otherwise this call will fail.
|
|
|
|
*/
|
|
|
|
int regulator_set_current_limit(struct regulator *regulator,
|
|
|
|
int min_uA, int max_uA)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
int ret;
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
if (!rdev->desc->ops->set_current_limit) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* constraints check */
|
|
|
|
ret = regulator_check_current_limit(rdev, &min_uA, &max_uA);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = rdev->desc->ops->set_current_limit(rdev, min_uA, max_uA);
|
|
|
|
out:
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_current_limit);
|
|
|
|
|
2018-08-16 20:28:03 +00:00
|
|
|
static int _regulator_get_current_limit_unlocked(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
/* sanity check */
|
|
|
|
if (!rdev->desc->ops->get_current_limit)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return rdev->desc->ops->get_current_limit(rdev);
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
static int _regulator_get_current_limit(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2018-08-16 20:28:03 +00:00
|
|
|
ret = _regulator_get_current_limit_unlocked(rdev);
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2018-08-16 20:28:03 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get_current_limit - get regulator output current
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* This returns the current supplied by the specified current sink in uA.
|
|
|
|
*
|
|
|
|
* NOTE: If the regulator is disabled it will return the current value. This
|
|
|
|
* function should not be used to determine regulator state.
|
|
|
|
*/
|
|
|
|
int regulator_get_current_limit(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
return _regulator_get_current_limit(regulator->rdev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_current_limit);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_set_mode - set regulator operating mode
|
|
|
|
* @regulator: regulator source
|
|
|
|
* @mode: operating mode - one of the REGULATOR_MODE constants
|
|
|
|
*
|
|
|
|
* Set regulator operating mode to increase regulator efficiency or improve
|
|
|
|
* regulation performance.
|
|
|
|
*
|
|
|
|
* NOTE: Regulator system constraints must be set for this regulator before
|
|
|
|
* calling this function otherwise this call will fail.
|
|
|
|
*/
|
|
|
|
int regulator_set_mode(struct regulator *regulator, unsigned int mode)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
|
|
|
int ret;
|
2010-05-17 15:54:48 +00:00
|
|
|
int regulator_curr_mode;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
if (!rdev->desc->ops->set_mode) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2010-05-17 15:54:48 +00:00
|
|
|
/* return if the same mode is requested */
|
|
|
|
if (rdev->desc->ops->get_mode) {
|
|
|
|
regulator_curr_mode = rdev->desc->ops->get_mode(rdev);
|
|
|
|
if (regulator_curr_mode == mode) {
|
|
|
|
ret = 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/* constraints check */
|
2011-04-01 10:25:25 +00:00
|
|
|
ret = regulator_mode_constrain(rdev, &mode);
|
2008-04-30 14:59:04 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
ret = rdev->desc->ops->set_mode(rdev, mode);
|
|
|
|
out:
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_mode);
|
|
|
|
|
2018-08-16 20:28:03 +00:00
|
|
|
static unsigned int _regulator_get_mode_unlocked(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
/* sanity check */
|
|
|
|
if (!rdev->desc->ops->get_mode)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return rdev->desc->ops->get_mode(rdev);
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
static unsigned int _regulator_get_mode(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2018-08-16 20:28:03 +00:00
|
|
|
ret = _regulator_get_mode_unlocked(rdev);
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2018-08-16 20:28:03 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get_mode - get regulator operating mode
|
|
|
|
* @regulator: regulator source
|
|
|
|
*
|
|
|
|
* Get the current regulator operating mode.
|
|
|
|
*/
|
|
|
|
unsigned int regulator_get_mode(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
return _regulator_get_mode(regulator->rdev);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_mode);
|
|
|
|
|
2016-11-03 11:11:42 +00:00
|
|
|
static int _regulator_get_error_flags(struct regulator_dev *rdev,
|
|
|
|
unsigned int *flags)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2016-11-03 11:11:42 +00:00
|
|
|
|
|
|
|
/* sanity check */
|
|
|
|
if (!rdev->desc->ops->get_error_flags) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = rdev->desc->ops->get_error_flags(rdev, flags);
|
|
|
|
out:
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2016-11-03 11:11:42 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get_error_flags - get regulator error information
|
|
|
|
* @regulator: regulator source
|
|
|
|
* @flags: pointer to store error flags
|
|
|
|
*
|
|
|
|
* Get the current regulator error information.
|
|
|
|
*/
|
|
|
|
int regulator_get_error_flags(struct regulator *regulator,
|
|
|
|
unsigned int *flags)
|
|
|
|
{
|
|
|
|
return _regulator_get_error_flags(regulator->rdev, flags);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_error_flags);
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/**
|
2015-02-12 03:35:27 +00:00
|
|
|
* regulator_set_load - set regulator load
|
2008-04-30 14:59:04 +00:00
|
|
|
* @regulator: regulator source
|
|
|
|
* @uA_load: load current
|
|
|
|
*
|
|
|
|
* Notifies the regulator core of a new device load. This is then used by
|
|
|
|
* DRMS (if enabled by constraints) to set the most efficient regulator
|
|
|
|
* operating mode for the new regulator loading.
|
|
|
|
*
|
|
|
|
* Consumer devices notify their supply regulator of the maximum power
|
|
|
|
* they will require (can be taken from device datasheet in the power
|
|
|
|
* consumption tables) when they change operational status and hence power
|
|
|
|
* state. Examples of operational state changes that can affect power
|
|
|
|
* consumption are :-
|
|
|
|
*
|
|
|
|
* o Device is opened / closed.
|
|
|
|
* o Device I/O is about to begin or has just finished.
|
|
|
|
* o Device is idling in between work.
|
|
|
|
*
|
|
|
|
* This information is also exported via sysfs to userspace.
|
|
|
|
*
|
|
|
|
* DRMS will sum the total requested load on the regulator and change
|
|
|
|
* to the most efficient operating mode if platform constraints allow.
|
|
|
|
*
|
2018-11-20 17:52:53 +00:00
|
|
|
* NOTE: when a regulator consumer requests to have a regulator
|
|
|
|
* disabled then any load that consumer requested no longer counts
|
|
|
|
* toward the total requested load. If the regulator is re-enabled
|
|
|
|
* then the previously requested load will start counting again.
|
|
|
|
*
|
|
|
|
* If a regulator is an always-on regulator then an individual consumer's
|
|
|
|
* load will still be removed if that consumer is fully disabled.
|
|
|
|
*
|
2015-02-12 03:35:27 +00:00
|
|
|
* On error a negative errno is returned.
|
2008-04-30 14:59:04 +00:00
|
|
|
*/
|
2015-02-12 03:35:27 +00:00
|
|
|
int regulator_set_load(struct regulator *regulator, int uA_load)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
2018-11-20 17:52:53 +00:00
|
|
|
int old_uA_load;
|
|
|
|
int ret = 0;
|
2012-07-03 02:21:06 +00:00
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2018-11-20 17:52:53 +00:00
|
|
|
old_uA_load = regulator->uA_load;
|
2008-04-30 14:59:04 +00:00
|
|
|
regulator->uA_load = uA_load;
|
2018-11-20 17:52:53 +00:00
|
|
|
if (regulator->enable_count && old_uA_load != uA_load) {
|
|
|
|
ret = drms_uA_update(rdev);
|
|
|
|
if (ret < 0)
|
|
|
|
regulator->uA_load = old_uA_load;
|
|
|
|
}
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2015-01-28 02:46:31 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2015-02-12 03:35:27 +00:00
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_load);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2012-08-31 17:36:37 +00:00
|
|
|
/**
|
|
|
|
* regulator_allow_bypass - allow the regulator to go into bypass mode
|
|
|
|
*
|
|
|
|
* @regulator: Regulator to configure
|
2013-03-01 00:44:54 +00:00
|
|
|
* @enable: enable or disable bypass mode
|
2012-08-31 17:36:37 +00:00
|
|
|
*
|
|
|
|
* Allow the regulator to go into bypass mode if all other consumers
|
|
|
|
* for the regulator also enable bypass mode and the machine
|
|
|
|
* constraints allow this. Bypass mode means that the regulator is
|
|
|
|
* simply passing the input directly to the output with no regulation.
|
|
|
|
*/
|
|
|
|
int regulator_allow_bypass(struct regulator *regulator, bool enable)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = regulator->rdev;
|
2020-05-29 15:22:16 +00:00
|
|
|
const char *name = rdev_get_name(rdev);
|
2012-08-31 17:36:37 +00:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (!rdev->desc->ops->set_bypass)
|
|
|
|
return 0;
|
|
|
|
|
2016-04-23 07:11:05 +00:00
|
|
|
if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_BYPASS))
|
2012-08-31 17:36:37 +00:00
|
|
|
return 0;
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2012-08-31 17:36:37 +00:00
|
|
|
|
|
|
|
if (enable && !regulator->bypass) {
|
|
|
|
rdev->bypass_count++;
|
|
|
|
|
|
|
|
if (rdev->bypass_count == rdev->open_count) {
|
2020-05-29 15:22:16 +00:00
|
|
|
trace_regulator_bypass_enable(name);
|
|
|
|
|
2012-08-31 17:36:37 +00:00
|
|
|
ret = rdev->desc->ops->set_bypass(rdev, enable);
|
|
|
|
if (ret != 0)
|
|
|
|
rdev->bypass_count--;
|
2020-05-29 15:22:16 +00:00
|
|
|
else
|
|
|
|
trace_regulator_bypass_enable_complete(name);
|
2012-08-31 17:36:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} else if (!enable && regulator->bypass) {
|
|
|
|
rdev->bypass_count--;
|
|
|
|
|
|
|
|
if (rdev->bypass_count != rdev->open_count) {
|
2020-05-29 15:22:16 +00:00
|
|
|
trace_regulator_bypass_disable(name);
|
|
|
|
|
2012-08-31 17:36:37 +00:00
|
|
|
ret = rdev->desc->ops->set_bypass(rdev, enable);
|
|
|
|
if (ret != 0)
|
|
|
|
rdev->bypass_count++;
|
2020-05-29 15:22:16 +00:00
|
|
|
else
|
|
|
|
trace_regulator_bypass_disable_complete(name);
|
2012-08-31 17:36:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret == 0)
|
|
|
|
regulator->bypass = enable;
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2012-08-31 17:36:37 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_allow_bypass);
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/**
|
|
|
|
* regulator_register_notifier - register regulator event notifier
|
|
|
|
* @regulator: regulator source
|
2008-12-31 12:52:41 +00:00
|
|
|
* @nb: notifier block
|
2008-04-30 14:59:04 +00:00
|
|
|
*
|
|
|
|
* Register notifier block to receive regulator events.
|
|
|
|
*/
|
|
|
|
int regulator_register_notifier(struct regulator *regulator,
|
|
|
|
struct notifier_block *nb)
|
|
|
|
{
|
|
|
|
return blocking_notifier_chain_register(®ulator->rdev->notifier,
|
|
|
|
nb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_register_notifier);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_unregister_notifier - unregister regulator event notifier
|
|
|
|
* @regulator: regulator source
|
2008-12-31 12:52:41 +00:00
|
|
|
* @nb: notifier block
|
2008-04-30 14:59:04 +00:00
|
|
|
*
|
|
|
|
* Unregister regulator event notifier block.
|
|
|
|
*/
|
|
|
|
int regulator_unregister_notifier(struct regulator *regulator,
|
|
|
|
struct notifier_block *nb)
|
|
|
|
{
|
|
|
|
return blocking_notifier_chain_unregister(®ulator->rdev->notifier,
|
|
|
|
nb);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_unregister_notifier);
|
|
|
|
|
2009-01-19 18:20:58 +00:00
|
|
|
/* notify regulator consumers and downstream regulator consumers.
|
|
|
|
* Note mutex must be held by caller.
|
|
|
|
*/
|
2014-08-28 19:36:04 +00:00
|
|
|
static int _notifier_call_chain(struct regulator_dev *rdev,
|
2008-04-30 14:59:04 +00:00
|
|
|
unsigned long event, void *data)
|
|
|
|
{
|
|
|
|
/* call rdev chain first */
|
2014-08-28 19:36:04 +00:00
|
|
|
return blocking_notifier_call_chain(&rdev->notifier, event, data);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_bulk_get - get multiple regulator consumers
|
|
|
|
*
|
|
|
|
* @dev: Device to supply
|
|
|
|
* @num_consumers: Number of consumers to register
|
|
|
|
* @consumers: Configuration of consumers; clients are stored here.
|
|
|
|
*
|
|
|
|
* @return 0 on success, an errno on failure.
|
|
|
|
*
|
|
|
|
* This helper function allows drivers to get several regulator
|
|
|
|
* consumers in one operation. If any of the regulators cannot be
|
|
|
|
* acquired then any regulators that were allocated will be freed
|
|
|
|
* before returning to the caller.
|
|
|
|
*/
|
|
|
|
int regulator_bulk_get(struct device *dev, int num_consumers,
|
|
|
|
struct regulator_bulk_data *consumers)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
for (i = 0; i < num_consumers; i++)
|
|
|
|
consumers[i].consumer = NULL;
|
|
|
|
|
|
|
|
for (i = 0; i < num_consumers; i++) {
|
2016-08-16 18:50:32 +00:00
|
|
|
consumers[i].consumer = regulator_get(dev,
|
|
|
|
consumers[i].supply);
|
2008-04-30 14:59:04 +00:00
|
|
|
if (IS_ERR(consumers[i].consumer)) {
|
|
|
|
ret = PTR_ERR(consumers[i].consumer);
|
|
|
|
consumers[i].consumer = NULL;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
2019-04-17 19:24:43 +00:00
|
|
|
if (ret != -EPROBE_DEFER)
|
|
|
|
dev_err(dev, "Failed to get supply '%s': %d\n",
|
|
|
|
consumers[i].supply, ret);
|
|
|
|
else
|
|
|
|
dev_dbg(dev, "Failed to get supply '%s', deferring\n",
|
|
|
|
consumers[i].supply);
|
|
|
|
|
2012-02-20 02:32:16 +00:00
|
|
|
while (--i >= 0)
|
2008-04-30 14:59:04 +00:00
|
|
|
regulator_put(consumers[i].consumer);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_bulk_get);
|
|
|
|
|
2011-05-24 00:12:40 +00:00
|
|
|
static void regulator_bulk_enable_async(void *data, async_cookie_t cookie)
|
|
|
|
{
|
|
|
|
struct regulator_bulk_data *bulk = data;
|
|
|
|
|
|
|
|
bulk->ret = regulator_enable(bulk->consumer);
|
|
|
|
}
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/**
|
|
|
|
* regulator_bulk_enable - enable multiple regulator consumers
|
|
|
|
*
|
|
|
|
* @num_consumers: Number of consumers
|
|
|
|
* @consumers: Consumer data; clients are stored here.
|
|
|
|
* @return 0 on success, an errno on failure
|
|
|
|
*
|
|
|
|
* This convenience API allows consumers to enable multiple regulator
|
|
|
|
* clients in a single API call. If any consumers cannot be enabled
|
|
|
|
* then any others that were enabled will be disabled again prior to
|
|
|
|
* return.
|
|
|
|
*/
|
|
|
|
int regulator_bulk_enable(int num_consumers,
|
|
|
|
struct regulator_bulk_data *consumers)
|
|
|
|
{
|
2012-07-10 02:33:25 +00:00
|
|
|
ASYNC_DOMAIN_EXCLUSIVE(async_domain);
|
2008-04-30 14:59:04 +00:00
|
|
|
int i;
|
2011-05-24 00:12:40 +00:00
|
|
|
int ret = 0;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2012-04-19 12:19:07 +00:00
|
|
|
for (i = 0; i < num_consumers; i++) {
|
2018-11-20 17:52:53 +00:00
|
|
|
async_schedule_domain(regulator_bulk_enable_async,
|
|
|
|
&consumers[i], &async_domain);
|
2012-04-19 12:19:07 +00:00
|
|
|
}
|
2011-05-24 00:12:40 +00:00
|
|
|
|
|
|
|
async_synchronize_full_domain(&async_domain);
|
|
|
|
|
|
|
|
/* If any consumer failed we need to unwind any that succeeded */
|
2008-04-30 14:59:04 +00:00
|
|
|
for (i = 0; i < num_consumers; i++) {
|
2011-05-24 00:12:40 +00:00
|
|
|
if (consumers[i].ret != 0) {
|
|
|
|
ret = consumers[i].ret;
|
2008-04-30 14:59:04 +00:00
|
|
|
goto err;
|
2011-05-24 00:12:40 +00:00
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
2013-03-01 11:24:05 +00:00
|
|
|
for (i = 0; i < num_consumers; i++) {
|
|
|
|
if (consumers[i].ret < 0)
|
|
|
|
pr_err("Failed to enable %s: %d\n", consumers[i].supply,
|
|
|
|
consumers[i].ret);
|
|
|
|
else
|
|
|
|
regulator_disable(consumers[i].consumer);
|
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_bulk_enable);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_bulk_disable - disable multiple regulator consumers
|
|
|
|
*
|
|
|
|
* @num_consumers: Number of consumers
|
|
|
|
* @consumers: Consumer data; clients are stored here.
|
|
|
|
* @return 0 on success, an errno on failure
|
|
|
|
*
|
|
|
|
* This convenience API allows consumers to disable multiple regulator
|
2012-01-25 11:35:38 +00:00
|
|
|
* clients in a single API call. If any consumers cannot be disabled
|
|
|
|
* then any others that were disabled will be enabled again prior to
|
2008-04-30 14:59:04 +00:00
|
|
|
* return.
|
|
|
|
*/
|
|
|
|
int regulator_bulk_disable(int num_consumers,
|
|
|
|
struct regulator_bulk_data *consumers)
|
|
|
|
{
|
|
|
|
int i;
|
2012-03-28 20:36:38 +00:00
|
|
|
int ret, r;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2012-01-25 11:35:38 +00:00
|
|
|
for (i = num_consumers - 1; i >= 0; --i) {
|
2008-04-30 14:59:04 +00:00
|
|
|
ret = regulator_disable(consumers[i].consumer);
|
|
|
|
if (ret != 0)
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
2010-11-30 13:53:48 +00:00
|
|
|
pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret);
|
2012-03-28 20:36:38 +00:00
|
|
|
for (++i; i < num_consumers; ++i) {
|
|
|
|
r = regulator_enable(consumers[i].consumer);
|
|
|
|
if (r != 0)
|
2017-02-03 23:16:16 +00:00
|
|
|
pr_err("Failed to re-enable %s: %d\n",
|
2012-03-28 20:36:38 +00:00
|
|
|
consumers[i].supply, r);
|
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_bulk_disable);
|
|
|
|
|
2012-01-03 07:22:03 +00:00
|
|
|
/**
|
|
|
|
* regulator_bulk_force_disable - force disable multiple regulator consumers
|
|
|
|
*
|
|
|
|
* @num_consumers: Number of consumers
|
|
|
|
* @consumers: Consumer data; clients are stored here.
|
|
|
|
* @return 0 on success, an errno on failure
|
|
|
|
*
|
|
|
|
* This convenience API allows consumers to forcibly disable multiple regulator
|
|
|
|
* clients in a single API call.
|
|
|
|
* NOTE: This should be used for situations when device damage will
|
|
|
|
* likely occur if the regulators are not disabled (e.g. over temp).
|
|
|
|
* Although regulator_force_disable function call for some consumers can
|
|
|
|
* return error numbers, the function is called for all consumers.
|
|
|
|
*/
|
|
|
|
int regulator_bulk_force_disable(int num_consumers,
|
|
|
|
struct regulator_bulk_data *consumers)
|
|
|
|
{
|
|
|
|
int i;
|
2017-02-03 23:16:17 +00:00
|
|
|
int ret = 0;
|
2012-01-03 07:22:03 +00:00
|
|
|
|
2017-02-03 23:16:17 +00:00
|
|
|
for (i = 0; i < num_consumers; i++) {
|
2012-01-03 07:22:03 +00:00
|
|
|
consumers[i].ret =
|
|
|
|
regulator_force_disable(consumers[i].consumer);
|
|
|
|
|
2017-02-03 23:16:17 +00:00
|
|
|
/* Store first error for reporting */
|
|
|
|
if (consumers[i].ret && !ret)
|
2012-01-03 07:22:03 +00:00
|
|
|
ret = consumers[i].ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_bulk_force_disable);
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/**
|
|
|
|
* regulator_bulk_free - free multiple regulator consumers
|
|
|
|
*
|
|
|
|
* @num_consumers: Number of consumers
|
|
|
|
* @consumers: Consumer data; clients are stored here.
|
|
|
|
*
|
|
|
|
* This convenience API allows consumers to free multiple regulator
|
|
|
|
* clients in a single API call.
|
|
|
|
*/
|
|
|
|
void regulator_bulk_free(int num_consumers,
|
|
|
|
struct regulator_bulk_data *consumers)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < num_consumers; i++) {
|
|
|
|
regulator_put(consumers[i].consumer);
|
|
|
|
consumers[i].consumer = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_bulk_free);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_notifier_call_chain - call regulator event notifier
|
2008-12-31 12:52:41 +00:00
|
|
|
* @rdev: regulator source
|
2008-04-30 14:59:04 +00:00
|
|
|
* @event: notifier block
|
2008-12-31 12:52:41 +00:00
|
|
|
* @data: callback-specific data.
|
2008-04-30 14:59:04 +00:00
|
|
|
*
|
|
|
|
* Called by regulator drivers to notify clients a regulator event has
|
|
|
|
* occurred. We also notify regulator clients downstream.
|
2009-01-19 18:20:58 +00:00
|
|
|
* Note lock must be held by caller.
|
2008-04-30 14:59:04 +00:00
|
|
|
*/
|
|
|
|
int regulator_notifier_call_chain(struct regulator_dev *rdev,
|
|
|
|
unsigned long event, void *data)
|
|
|
|
{
|
2018-11-18 21:56:17 +00:00
|
|
|
lockdep_assert_held_once(&rdev->mutex.base);
|
2015-06-29 00:04:43 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
_notifier_call_chain(rdev, event, data);
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_notifier_call_chain);
|
|
|
|
|
2009-08-04 18:09:52 +00:00
|
|
|
/**
|
|
|
|
* regulator_mode_to_status - convert a regulator mode into a status
|
|
|
|
*
|
|
|
|
* @mode: Mode to convert
|
|
|
|
*
|
|
|
|
* Convert a regulator mode into a status.
|
|
|
|
*/
|
|
|
|
int regulator_mode_to_status(unsigned int mode)
|
|
|
|
{
|
|
|
|
switch (mode) {
|
|
|
|
case REGULATOR_MODE_FAST:
|
|
|
|
return REGULATOR_STATUS_FAST;
|
|
|
|
case REGULATOR_MODE_NORMAL:
|
|
|
|
return REGULATOR_STATUS_NORMAL;
|
|
|
|
case REGULATOR_MODE_IDLE:
|
|
|
|
return REGULATOR_STATUS_IDLE;
|
2012-07-12 10:50:38 +00:00
|
|
|
case REGULATOR_MODE_STANDBY:
|
2009-08-04 18:09:52 +00:00
|
|
|
return REGULATOR_STATUS_STANDBY;
|
|
|
|
default:
|
2012-07-12 12:53:35 +00:00
|
|
|
return REGULATOR_STATUS_UNDEFINED;
|
2009-08-04 18:09:52 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_mode_to_status);
|
|
|
|
|
2015-01-30 19:29:31 +00:00
|
|
|
static struct attribute *regulator_dev_attrs[] = {
|
|
|
|
&dev_attr_name.attr,
|
|
|
|
&dev_attr_num_users.attr,
|
|
|
|
&dev_attr_type.attr,
|
|
|
|
&dev_attr_microvolts.attr,
|
|
|
|
&dev_attr_microamps.attr,
|
|
|
|
&dev_attr_opmode.attr,
|
|
|
|
&dev_attr_state.attr,
|
|
|
|
&dev_attr_status.attr,
|
|
|
|
&dev_attr_bypass.attr,
|
|
|
|
&dev_attr_requested_microamps.attr,
|
|
|
|
&dev_attr_min_microvolts.attr,
|
|
|
|
&dev_attr_max_microvolts.attr,
|
|
|
|
&dev_attr_min_microamps.attr,
|
|
|
|
&dev_attr_max_microamps.attr,
|
|
|
|
&dev_attr_suspend_standby_state.attr,
|
|
|
|
&dev_attr_suspend_mem_state.attr,
|
|
|
|
&dev_attr_suspend_disk_state.attr,
|
|
|
|
&dev_attr_suspend_standby_microvolts.attr,
|
|
|
|
&dev_attr_suspend_mem_microvolts.attr,
|
|
|
|
&dev_attr_suspend_disk_microvolts.attr,
|
|
|
|
&dev_attr_suspend_standby_mode.attr,
|
|
|
|
&dev_attr_suspend_mem_mode.attr,
|
|
|
|
&dev_attr_suspend_disk_mode.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2008-11-12 01:39:02 +00:00
|
|
|
/*
|
|
|
|
* To avoid cluttering sysfs (and memory) with useless state, only
|
|
|
|
* create attributes that can be meaningfully displayed.
|
|
|
|
*/
|
2015-01-30 19:29:31 +00:00
|
|
|
static umode_t regulator_attr_is_visible(struct kobject *kobj,
|
|
|
|
struct attribute *attr, int idx)
|
2008-11-12 01:39:02 +00:00
|
|
|
{
|
2015-01-30 19:29:31 +00:00
|
|
|
struct device *dev = kobj_to_dev(kobj);
|
2016-01-05 14:07:55 +00:00
|
|
|
struct regulator_dev *rdev = dev_to_rdev(dev);
|
2014-08-13 11:33:38 +00:00
|
|
|
const struct regulator_ops *ops = rdev->desc->ops;
|
2015-01-30 19:29:31 +00:00
|
|
|
umode_t mode = attr->mode;
|
|
|
|
|
|
|
|
/* these three are always present */
|
|
|
|
if (attr == &dev_attr_name.attr ||
|
|
|
|
attr == &dev_attr_num_users.attr ||
|
|
|
|
attr == &dev_attr_type.attr)
|
|
|
|
return mode;
|
2008-11-12 01:39:02 +00:00
|
|
|
|
|
|
|
/* some attributes need specific methods to be displayed */
|
2015-01-30 19:29:31 +00:00
|
|
|
if (attr == &dev_attr_microvolts.attr) {
|
|
|
|
if ((ops->get_voltage && ops->get_voltage(rdev) >= 0) ||
|
|
|
|
(ops->get_voltage_sel && ops->get_voltage_sel(rdev) >= 0) ||
|
|
|
|
(ops->list_voltage && ops->list_voltage(rdev, 0) >= 0) ||
|
|
|
|
(rdev->desc->fixed_uV && rdev->desc->n_voltages == 1))
|
|
|
|
return mode;
|
|
|
|
return 0;
|
2012-08-31 17:36:37 +00:00
|
|
|
}
|
2008-11-12 01:39:02 +00:00
|
|
|
|
2015-01-30 19:29:31 +00:00
|
|
|
if (attr == &dev_attr_microamps.attr)
|
|
|
|
return ops->get_current_limit ? mode : 0;
|
|
|
|
|
|
|
|
if (attr == &dev_attr_opmode.attr)
|
|
|
|
return ops->get_mode ? mode : 0;
|
|
|
|
|
|
|
|
if (attr == &dev_attr_state.attr)
|
|
|
|
return (rdev->ena_pin || ops->is_enabled) ? mode : 0;
|
|
|
|
|
|
|
|
if (attr == &dev_attr_status.attr)
|
|
|
|
return ops->get_status ? mode : 0;
|
|
|
|
|
|
|
|
if (attr == &dev_attr_bypass.attr)
|
|
|
|
return ops->get_bypass ? mode : 0;
|
|
|
|
|
2008-11-12 01:39:02 +00:00
|
|
|
/* constraints need specific supporting methods */
|
2015-01-30 19:29:31 +00:00
|
|
|
if (attr == &dev_attr_min_microvolts.attr ||
|
|
|
|
attr == &dev_attr_max_microvolts.attr)
|
|
|
|
return (ops->set_voltage || ops->set_voltage_sel) ? mode : 0;
|
|
|
|
|
|
|
|
if (attr == &dev_attr_min_microamps.attr ||
|
|
|
|
attr == &dev_attr_max_microamps.attr)
|
|
|
|
return ops->set_current_limit ? mode : 0;
|
|
|
|
|
|
|
|
if (attr == &dev_attr_suspend_standby_state.attr ||
|
|
|
|
attr == &dev_attr_suspend_mem_state.attr ||
|
|
|
|
attr == &dev_attr_suspend_disk_state.attr)
|
|
|
|
return mode;
|
|
|
|
|
|
|
|
if (attr == &dev_attr_suspend_standby_microvolts.attr ||
|
|
|
|
attr == &dev_attr_suspend_mem_microvolts.attr ||
|
|
|
|
attr == &dev_attr_suspend_disk_microvolts.attr)
|
|
|
|
return ops->set_suspend_voltage ? mode : 0;
|
|
|
|
|
|
|
|
if (attr == &dev_attr_suspend_standby_mode.attr ||
|
|
|
|
attr == &dev_attr_suspend_mem_mode.attr ||
|
|
|
|
attr == &dev_attr_suspend_disk_mode.attr)
|
|
|
|
return ops->set_suspend_mode ? mode : 0;
|
|
|
|
|
|
|
|
return mode;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct attribute_group regulator_dev_group = {
|
|
|
|
.attrs = regulator_dev_attrs,
|
|
|
|
.is_visible = regulator_attr_is_visible,
|
|
|
|
};
|
|
|
|
|
|
|
|
static const struct attribute_group *regulator_dev_groups[] = {
|
|
|
|
®ulator_dev_group,
|
|
|
|
NULL
|
|
|
|
};
|
2008-11-12 01:39:02 +00:00
|
|
|
|
2015-01-30 19:29:31 +00:00
|
|
|
static void regulator_dev_release(struct device *dev)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = dev_get_drvdata(dev);
|
2015-08-07 19:01:32 +00:00
|
|
|
|
|
|
|
kfree(rdev->constraints);
|
|
|
|
of_node_put(rdev->dev.of_node);
|
2015-01-30 19:29:31 +00:00
|
|
|
kfree(rdev);
|
2008-11-12 01:39:02 +00:00
|
|
|
}
|
|
|
|
|
2010-12-21 23:49:31 +00:00
|
|
|
static void rdev_init_debugfs(struct regulator_dev *rdev)
|
|
|
|
{
|
2014-10-17 15:17:03 +00:00
|
|
|
struct device *parent = rdev->dev.parent;
|
|
|
|
const char *rname = rdev_get_name(rdev);
|
|
|
|
char name[NAME_MAX];
|
|
|
|
|
|
|
|
/* Avoid duplicate debugfs directory names */
|
|
|
|
if (parent && rname == rdev->desc->name) {
|
|
|
|
snprintf(name, sizeof(name), "%s-%s", dev_name(parent),
|
|
|
|
rname);
|
|
|
|
rname = name;
|
|
|
|
}
|
|
|
|
|
|
|
|
rdev->debugfs = debugfs_create_dir(rname, debugfs_root);
|
2012-02-21 06:50:42 +00:00
|
|
|
if (!rdev->debugfs) {
|
2010-12-21 23:49:31 +00:00
|
|
|
rdev_warn(rdev, "Failed to create debugfs directory\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
debugfs_create_u32("use_count", 0444, rdev->debugfs,
|
|
|
|
&rdev->use_count);
|
|
|
|
debugfs_create_u32("open_count", 0444, rdev->debugfs,
|
|
|
|
&rdev->open_count);
|
2012-08-31 17:36:37 +00:00
|
|
|
debugfs_create_u32("bypass_count", 0444, rdev->debugfs,
|
|
|
|
&rdev->bypass_count);
|
2010-12-21 23:49:31 +00:00
|
|
|
}
|
|
|
|
|
2016-03-23 23:59:34 +00:00
|
|
|
static int regulator_register_resolve_supply(struct device *dev, void *data)
|
|
|
|
{
|
2016-04-21 16:11:57 +00:00
|
|
|
struct regulator_dev *rdev = dev_to_rdev(dev);
|
|
|
|
|
|
|
|
if (regulator_resolve_supply(rdev))
|
|
|
|
rdev_dbg(rdev, "unable to resolve supply\n");
|
|
|
|
|
|
|
|
return 0;
|
2016-03-23 23:59:34 +00:00
|
|
|
}
|
|
|
|
|
2019-06-23 21:08:31 +00:00
|
|
|
int regulator_coupler_register(struct regulator_coupler *coupler)
|
|
|
|
{
|
|
|
|
mutex_lock(®ulator_list_mutex);
|
|
|
|
list_add_tail(&coupler->list, ®ulator_coupler_list);
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct regulator_coupler *
|
|
|
|
regulator_find_coupler(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
struct regulator_coupler *coupler;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note that regulators are appended to the list and the generic
|
|
|
|
* coupler is registered first, hence it will be attached at last
|
|
|
|
* if nobody cared.
|
|
|
|
*/
|
|
|
|
list_for_each_entry_reverse(coupler, ®ulator_coupler_list, list) {
|
|
|
|
err = coupler->attach_regulator(coupler, rdev);
|
|
|
|
if (!err) {
|
|
|
|
if (!coupler->balance_voltage &&
|
|
|
|
rdev->coupling_desc.n_coupled > 2)
|
|
|
|
goto err_unsupported;
|
|
|
|
|
|
|
|
return coupler;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (err < 0)
|
|
|
|
return ERR_PTR(err);
|
|
|
|
|
|
|
|
if (err == 1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
|
|
|
err_unsupported:
|
|
|
|
if (coupler->detach_regulator)
|
|
|
|
coupler->detach_regulator(coupler, rdev);
|
|
|
|
|
|
|
|
rdev_err(rdev,
|
|
|
|
"Voltage balancing for multiple regulator couples is unimplemented\n");
|
|
|
|
|
|
|
|
return ERR_PTR(-EPERM);
|
|
|
|
}
|
|
|
|
|
2018-10-05 15:36:30 +00:00
|
|
|
static void regulator_resolve_coupling(struct regulator_dev *rdev)
|
2018-04-23 14:33:40 +00:00
|
|
|
{
|
2019-06-23 21:08:31 +00:00
|
|
|
struct regulator_coupler *coupler = rdev->coupling_desc.coupler;
|
2018-04-23 14:33:40 +00:00
|
|
|
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);
|
|
|
|
|
2018-10-05 15:36:30 +00:00
|
|
|
if (!c_rdev)
|
|
|
|
continue;
|
2018-04-23 14:33:40 +00:00
|
|
|
|
2019-06-23 21:08:31 +00:00
|
|
|
if (c_rdev->coupling_desc.coupler != coupler) {
|
|
|
|
rdev_err(rdev, "coupler mismatch with %s\n",
|
|
|
|
rdev_get_name(c_rdev));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-10-05 15:36:30 +00:00
|
|
|
regulator_lock(c_rdev);
|
2018-04-23 14:33:40 +00:00
|
|
|
|
2018-10-05 15:36:30 +00:00
|
|
|
c_desc->coupled_rdevs[i] = c_rdev;
|
|
|
|
c_desc->n_resolved++;
|
2018-04-23 14:33:40 +00:00
|
|
|
|
2018-10-05 15:36:30 +00:00
|
|
|
regulator_unlock(c_rdev);
|
2018-04-23 14:33:40 +00:00
|
|
|
|
2018-10-05 15:36:30 +00:00
|
|
|
regulator_resolve_coupling(c_rdev);
|
|
|
|
}
|
2018-04-23 14:33:40 +00:00
|
|
|
}
|
|
|
|
|
2018-10-05 15:36:36 +00:00
|
|
|
static void regulator_remove_coupling(struct regulator_dev *rdev)
|
2018-04-23 14:33:40 +00:00
|
|
|
{
|
2019-06-23 21:08:31 +00:00
|
|
|
struct regulator_coupler *coupler = rdev->coupling_desc.coupler;
|
2018-10-05 15:36:36 +00:00
|
|
|
struct coupling_desc *__c_desc, *c_desc = &rdev->coupling_desc;
|
|
|
|
struct regulator_dev *__c_rdev, *c_rdev;
|
|
|
|
unsigned int __n_coupled, n_coupled;
|
|
|
|
int i, k;
|
2019-06-23 21:08:31 +00:00
|
|
|
int err;
|
2018-04-23 14:33:40 +00:00
|
|
|
|
2018-10-05 15:36:36 +00:00
|
|
|
n_coupled = c_desc->n_coupled;
|
2018-04-23 14:33:40 +00:00
|
|
|
|
2018-10-05 15:36:36 +00:00
|
|
|
for (i = 1; i < n_coupled; i++) {
|
|
|
|
c_rdev = c_desc->coupled_rdevs[i];
|
2018-04-23 14:33:40 +00:00
|
|
|
|
2018-10-05 15:36:36 +00:00
|
|
|
if (!c_rdev)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
regulator_lock(c_rdev);
|
|
|
|
|
|
|
|
__c_desc = &c_rdev->coupling_desc;
|
|
|
|
__n_coupled = __c_desc->n_coupled;
|
|
|
|
|
|
|
|
for (k = 1; k < __n_coupled; k++) {
|
|
|
|
__c_rdev = __c_desc->coupled_rdevs[k];
|
|
|
|
|
|
|
|
if (__c_rdev == rdev) {
|
|
|
|
__c_desc->coupled_rdevs[k] = NULL;
|
|
|
|
__c_desc->n_resolved--;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
regulator_unlock(c_rdev);
|
|
|
|
|
|
|
|
c_desc->coupled_rdevs[i] = NULL;
|
|
|
|
c_desc->n_resolved--;
|
|
|
|
}
|
2019-06-23 21:08:31 +00:00
|
|
|
|
|
|
|
if (coupler && coupler->detach_regulator) {
|
|
|
|
err = coupler->detach_regulator(coupler, rdev);
|
|
|
|
if (err)
|
|
|
|
rdev_err(rdev, "failed to detach from coupler: %d\n",
|
|
|
|
err);
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(rdev->coupling_desc.coupled_rdevs);
|
|
|
|
rdev->coupling_desc.coupled_rdevs = NULL;
|
2018-04-23 14:33:40 +00:00
|
|
|
}
|
|
|
|
|
2018-10-05 15:36:30 +00:00
|
|
|
static int regulator_init_coupling(struct regulator_dev *rdev)
|
2018-04-23 14:33:40 +00:00
|
|
|
{
|
2020-08-09 19:21:16 +00:00
|
|
|
struct regulator_dev **coupled;
|
2019-06-23 21:08:31 +00:00
|
|
|
int err, n_phandles;
|
2018-04-23 14:33:40 +00:00
|
|
|
|
|
|
|
if (!IS_ENABLED(CONFIG_OF))
|
|
|
|
n_phandles = 0;
|
|
|
|
else
|
|
|
|
n_phandles = of_get_n_coupled(rdev);
|
|
|
|
|
2020-08-09 19:21:16 +00:00
|
|
|
coupled = kcalloc(n_phandles + 1, sizeof(*coupled), GFP_KERNEL);
|
|
|
|
if (!coupled)
|
2019-06-23 21:08:31 +00:00
|
|
|
return -ENOMEM;
|
2018-04-23 14:33:40 +00:00
|
|
|
|
2020-08-09 19:21:16 +00:00
|
|
|
rdev->coupling_desc.coupled_rdevs = coupled;
|
|
|
|
|
2018-04-23 14:33:40 +00:00
|
|
|
/*
|
|
|
|
* 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;
|
|
|
|
|
2019-06-23 21:08:31 +00:00
|
|
|
if (!of_check_coupling_data(rdev))
|
2018-04-23 14:33:40 +00:00
|
|
|
return -EPERM;
|
|
|
|
|
2020-08-12 01:31:34 +00:00
|
|
|
mutex_lock(®ulator_list_mutex);
|
2019-06-23 21:08:31 +00:00
|
|
|
rdev->coupling_desc.coupler = regulator_find_coupler(rdev);
|
2020-08-12 01:31:34 +00:00
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
|
2019-06-23 21:08:31 +00:00
|
|
|
if (IS_ERR(rdev->coupling_desc.coupler)) {
|
|
|
|
err = PTR_ERR(rdev->coupling_desc.coupler);
|
|
|
|
rdev_err(rdev, "failed to get coupler: %d\n", err);
|
|
|
|
return err;
|
2018-04-23 14:33:40 +00:00
|
|
|
}
|
|
|
|
|
2019-06-23 21:08:31 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int generic_coupler_attach(struct regulator_coupler *coupler,
|
|
|
|
struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
if (rdev->coupling_desc.n_coupled > 2) {
|
|
|
|
rdev_err(rdev,
|
|
|
|
"Voltage balancing for multiple regulator couples is unimplemented\n");
|
2018-04-23 14:33:40 +00:00
|
|
|
return -EPERM;
|
2019-06-23 21:08:31 +00:00
|
|
|
}
|
2018-04-23 14:33:40 +00:00
|
|
|
|
2019-10-25 00:22:40 +00:00
|
|
|
if (!rdev->constraints->always_on) {
|
|
|
|
rdev_err(rdev,
|
|
|
|
"Coupling of a non always-on regulator is unimplemented\n");
|
|
|
|
return -ENOTSUPP;
|
|
|
|
}
|
|
|
|
|
2018-04-23 14:33:40 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-06-23 21:08:31 +00:00
|
|
|
static struct regulator_coupler generic_regulator_coupler = {
|
|
|
|
.attach_regulator = generic_coupler_attach,
|
|
|
|
};
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/**
|
|
|
|
* regulator_register - register regulator
|
2008-12-31 12:52:41 +00:00
|
|
|
* @regulator_desc: regulator to register
|
2015-01-12 08:01:39 +00:00
|
|
|
* @cfg: runtime configuration for regulator
|
2008-04-30 14:59:04 +00:00
|
|
|
*
|
|
|
|
* Called by regulator drivers to register a regulator.
|
2013-01-03 13:01:47 +00:00
|
|
|
* Returns a valid pointer to struct regulator_dev on success
|
|
|
|
* or an ERR_PTR() on error.
|
2008-04-30 14:59:04 +00:00
|
|
|
*/
|
2012-04-03 19:46:53 +00:00
|
|
|
struct regulator_dev *
|
|
|
|
regulator_register(const struct regulator_desc *regulator_desc,
|
2015-01-05 11:48:41 +00:00
|
|
|
const struct regulator_config *cfg)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
2011-11-29 18:11:19 +00:00
|
|
|
const struct regulation_constraints *constraints = NULL;
|
2012-04-03 23:50:22 +00:00
|
|
|
const struct regulator_init_data *init_data;
|
2015-01-05 11:48:41 +00:00
|
|
|
struct regulator_config *config = NULL;
|
2014-12-28 16:38:38 +00:00
|
|
|
static atomic_t regulator_no = ATOMIC_INIT(-1);
|
2008-04-30 14:59:04 +00:00
|
|
|
struct regulator_dev *rdev;
|
2018-12-06 12:43:37 +00:00
|
|
|
bool dangling_cfg_gpiod = false;
|
|
|
|
bool dangling_of_gpiod = false;
|
2012-04-11 09:19:12 +00:00
|
|
|
struct device *dev;
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
int ret, i;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2018-12-06 12:43:37 +00:00
|
|
|
if (cfg == NULL)
|
2008-04-30 14:59:04 +00:00
|
|
|
return ERR_PTR(-EINVAL);
|
2018-12-06 12:43:37 +00:00
|
|
|
if (cfg->ena_gpiod)
|
|
|
|
dangling_cfg_gpiod = true;
|
|
|
|
if (regulator_desc == NULL) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto rinse;
|
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2015-01-05 11:48:41 +00:00
|
|
|
dev = cfg->dev;
|
2012-05-08 17:09:12 +00:00
|
|
|
WARN_ON(!dev);
|
2012-04-11 09:19:12 +00:00
|
|
|
|
2018-12-06 12:43:37 +00:00
|
|
|
if (regulator_desc->name == NULL || regulator_desc->ops == NULL) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto rinse;
|
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2009-04-14 01:04:47 +00:00
|
|
|
if (regulator_desc->type != REGULATOR_VOLTAGE &&
|
2018-12-06 12:43:37 +00:00
|
|
|
regulator_desc->type != REGULATOR_CURRENT) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto rinse;
|
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2010-12-10 17:28:07 +00:00
|
|
|
/* Only one of each should be implemented */
|
|
|
|
WARN_ON(regulator_desc->ops->get_voltage &&
|
|
|
|
regulator_desc->ops->get_voltage_sel);
|
2010-12-12 14:36:17 +00:00
|
|
|
WARN_ON(regulator_desc->ops->set_voltage &&
|
|
|
|
regulator_desc->ops->set_voltage_sel);
|
2010-12-10 17:28:07 +00:00
|
|
|
|
|
|
|
/* If we're using selectors we must implement list_voltage. */
|
|
|
|
if (regulator_desc->ops->get_voltage_sel &&
|
|
|
|
!regulator_desc->ops->list_voltage) {
|
2018-12-06 12:43:37 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto rinse;
|
2010-12-10 17:28:07 +00:00
|
|
|
}
|
2010-12-12 14:36:17 +00:00
|
|
|
if (regulator_desc->ops->set_voltage_sel &&
|
|
|
|
!regulator_desc->ops->list_voltage) {
|
2018-12-06 12:43:37 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto rinse;
|
2010-12-12 14:36:17 +00:00
|
|
|
}
|
2010-12-10 17:28:07 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
|
2018-12-06 12:43:37 +00:00
|
|
|
if (rdev == NULL) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto rinse;
|
|
|
|
}
|
2020-08-12 01:31:36 +00:00
|
|
|
device_initialize(&rdev->dev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2015-01-05 11:48:41 +00:00
|
|
|
/*
|
|
|
|
* Duplicate the config so the driver could override it after
|
|
|
|
* parsing init data.
|
|
|
|
*/
|
|
|
|
config = kmemdup(cfg, sizeof(*cfg), GFP_KERNEL);
|
|
|
|
if (config == NULL) {
|
2018-12-06 12:43:37 +00:00
|
|
|
ret = -ENOMEM;
|
2020-08-12 01:31:36 +00:00
|
|
|
goto clean;
|
2015-01-05 11:48:41 +00:00
|
|
|
}
|
|
|
|
|
2015-01-05 11:48:42 +00:00
|
|
|
init_data = regulator_of_get_init_data(dev, regulator_desc, config,
|
2014-09-09 22:13:57 +00:00
|
|
|
&rdev->dev.of_node);
|
2019-09-17 15:40:21 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Sometimes not all resources are probed already so we need to take
|
|
|
|
* that into account. This happens most the time if the ena_gpiod comes
|
|
|
|
* from a gpio extender or something else.
|
|
|
|
*/
|
|
|
|
if (PTR_ERR(init_data) == -EPROBE_DEFER) {
|
|
|
|
ret = -EPROBE_DEFER;
|
2020-08-12 01:31:36 +00:00
|
|
|
goto clean;
|
2019-09-17 15:40:21 +00:00
|
|
|
}
|
|
|
|
|
2018-12-06 12:43:37 +00:00
|
|
|
/*
|
|
|
|
* We need to keep track of any GPIO descriptor coming from the
|
|
|
|
* device tree until we have handled it over to the core. If the
|
|
|
|
* config that was passed in to this function DOES NOT contain
|
|
|
|
* a descriptor, and the config after this call DOES contain
|
2019-01-08 12:12:33 +00:00
|
|
|
* a descriptor, we definitely got one from parsing the device
|
2018-12-06 12:43:37 +00:00
|
|
|
* tree.
|
|
|
|
*/
|
|
|
|
if (!cfg->ena_gpiod && config->ena_gpiod)
|
|
|
|
dangling_of_gpiod = true;
|
2014-09-09 22:13:57 +00:00
|
|
|
if (!init_data) {
|
|
|
|
init_data = config->init_data;
|
|
|
|
rdev->dev.of_node = of_node_get(config->of_node);
|
|
|
|
}
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
ww_mutex_init(&rdev->mutex, ®ulator_ww_class);
|
2012-04-03 23:50:22 +00:00
|
|
|
rdev->reg_data = config->driver_data;
|
2008-04-30 14:59:04 +00:00
|
|
|
rdev->owner = regulator_desc->owner;
|
|
|
|
rdev->desc = regulator_desc;
|
2012-05-08 17:10:45 +00:00
|
|
|
if (config->regmap)
|
|
|
|
rdev->regmap = config->regmap;
|
2012-09-07 15:15:05 +00:00
|
|
|
else if (dev_get_regmap(dev, NULL))
|
2012-05-08 17:10:45 +00:00
|
|
|
rdev->regmap = dev_get_regmap(dev, NULL);
|
2012-09-07 15:15:05 +00:00
|
|
|
else if (dev->parent)
|
|
|
|
rdev->regmap = dev_get_regmap(dev->parent, NULL);
|
2008-04-30 14:59:04 +00:00
|
|
|
INIT_LIST_HEAD(&rdev->consumer_list);
|
|
|
|
INIT_LIST_HEAD(&rdev->list);
|
|
|
|
BLOCKING_INIT_NOTIFIER_HEAD(&rdev->notifier);
|
2011-09-11 08:53:50 +00:00
|
|
|
INIT_DELAYED_WORK(&rdev->disable_work, regulator_disable_work);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
/* preform any regulator specific init */
|
2011-11-29 18:11:19 +00:00
|
|
|
if (init_data && init_data->regulator_init) {
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
ret = init_data->regulator_init(rdev->reg_data);
|
2008-11-12 01:38:53 +00:00
|
|
|
if (ret < 0)
|
|
|
|
goto clean;
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
}
|
|
|
|
|
2019-01-29 10:31:56 +00:00
|
|
|
if (config->ena_gpiod) {
|
2016-02-22 08:24:00 +00:00
|
|
|
ret = regulator_ena_gpio_request(rdev, config);
|
|
|
|
if (ret != 0) {
|
2019-01-29 10:31:56 +00:00
|
|
|
rdev_err(rdev, "Failed to request enable GPIO: %d\n",
|
|
|
|
ret);
|
2016-02-24 10:52:50 +00:00
|
|
|
goto clean;
|
2016-02-22 08:24:00 +00:00
|
|
|
}
|
2018-12-06 12:43:37 +00:00
|
|
|
/* The regulator core took over the GPIO descriptor */
|
|
|
|
dangling_cfg_gpiod = false;
|
|
|
|
dangling_of_gpiod = false;
|
2016-02-22 08:24:00 +00:00
|
|
|
}
|
|
|
|
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
/* register with sysfs */
|
2008-04-30 14:59:04 +00:00
|
|
|
rdev->dev.class = ®ulator_class;
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
rdev->dev.parent = dev;
|
2014-12-28 16:38:38 +00:00
|
|
|
dev_set_name(&rdev->dev, "regulator.%lu",
|
2014-12-29 17:06:48 +00:00
|
|
|
(unsigned long) atomic_inc_return(®ulator_no));
|
2020-07-24 00:50:13 +00:00
|
|
|
dev_set_drvdata(&rdev->dev, rdev);
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
|
2008-11-25 12:53:53 +00:00
|
|
|
/* set regulator constraints */
|
2011-11-29 18:11:19 +00:00
|
|
|
if (init_data)
|
|
|
|
constraints = &init_data->constraints;
|
|
|
|
|
|
|
|
if (init_data && init_data->supply_regulator)
|
2015-03-25 01:56:05 +00:00
|
|
|
rdev->supply_name = init_data->supply_regulator;
|
2011-11-18 11:17:20 +00:00
|
|
|
else if (regulator_desc->supply_name)
|
2015-03-25 01:56:05 +00:00
|
|
|
rdev->supply_name = regulator_desc->supply_name;
|
2010-04-26 14:18:14 +00:00
|
|
|
|
regulator: core: Add early supply resolution for regulators
The call to set_machine_constraints() in regulator_register(), will
attempt to get the voltage for the regulator. If a regulator is in
bypass will fail to get the voltage (ie. it's bypass voltage) and
hence register the regulator, because the supply for the regulator has
not been resolved yet.
To fix this, add a call to regulator_resolve_supply() before we call
set_machine_constraints(). If the call to regulator_resolve_supply()
fails, rather than returning an error at this point, allow the
registration of the regulator to continue because for some regulators
resolving the supply at this point may not be necessary and it will be
resolved later as more regulators are added. Furthermore, if the supply
is still not resolved for a bypassed regulator, this will be detected
when we attempt to get the voltage for the regulator and an error will
be propagated at this point.
If a bypassed regulator does not have a supply when we attempt to get
the voltage, rather than returing -EINVAL, return -EPROBE_DEFER instead
to allow the registration of the regulator to be deferred and tried
again later.
Please note that regulator_resolve_supply() will call
regulator_dev_lookup() which may acquire the regulator_list_mutex. To
avoid any deadlocks we cannot hold the regulator_list_mutex when calling
regulator_resolve_supply(). Therefore, rather than holding the lock
around a large portion of the registration code, just hold the lock when
aquiring any GPIOs and setting up supplies because these sections may
add entries to the regulator_map_list and regulator_ena_gpio_list,
respectively.
Signed-off-by: Jon Hunter <jonathanh@nvidia.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2016-04-26 10:29:45 +00:00
|
|
|
/*
|
|
|
|
* Attempt to resolve the regulator supply, if specified,
|
|
|
|
* but don't return an error if we fail because we will try
|
|
|
|
* to resolve it again later as more regulators are added.
|
|
|
|
*/
|
|
|
|
if (regulator_resolve_supply(rdev))
|
|
|
|
rdev_dbg(rdev, "unable to resolve supply\n");
|
|
|
|
|
|
|
|
ret = set_machine_constraints(rdev, constraints);
|
|
|
|
if (ret < 0)
|
|
|
|
goto wash;
|
|
|
|
|
2018-10-05 15:36:30 +00:00
|
|
|
ret = regulator_init_coupling(rdev);
|
|
|
|
if (ret < 0)
|
2018-04-23 14:33:40 +00:00
|
|
|
goto wash;
|
|
|
|
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
/* add consumers devices */
|
2011-11-29 18:11:19 +00:00
|
|
|
if (init_data) {
|
|
|
|
for (i = 0; i < init_data->num_consumer_supplies; i++) {
|
|
|
|
ret = set_consumer_device_supply(rdev,
|
|
|
|
init_data->consumer_supplies[i].dev_name,
|
2011-02-24 17:39:09 +00:00
|
|
|
init_data->consumer_supplies[i].supply);
|
2011-11-29 18:11:19 +00:00
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(dev, "Failed to set supply %s\n",
|
|
|
|
init_data->consumer_supplies[i].supply);
|
|
|
|
goto unset_supplies;
|
|
|
|
}
|
2011-02-24 17:39:09 +00:00
|
|
|
}
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
|
2017-03-27 23:54:12 +00:00
|
|
|
if (!rdev->desc->ops->get_voltage &&
|
|
|
|
!rdev->desc->ops->list_voltage &&
|
|
|
|
!rdev->desc->fixed_uV)
|
|
|
|
rdev->is_switch = true;
|
|
|
|
|
2020-07-24 00:50:13 +00:00
|
|
|
ret = device_add(&rdev->dev);
|
|
|
|
if (ret != 0)
|
2016-04-21 16:11:59 +00:00
|
|
|
goto unset_supplies;
|
|
|
|
|
2010-12-21 23:49:31 +00:00
|
|
|
rdev_init_debugfs(rdev);
|
2016-03-23 23:59:34 +00:00
|
|
|
|
2018-10-05 15:36:30 +00:00
|
|
|
/* try to resolve regulators coupling since a new one was registered */
|
|
|
|
mutex_lock(®ulator_list_mutex);
|
|
|
|
regulator_resolve_coupling(rdev);
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
|
|
|
|
2016-03-23 23:59:34 +00:00
|
|
|
/* try to resolve regulators supply since a new one was registered */
|
|
|
|
class_for_each_device(®ulator_class, NULL, NULL,
|
|
|
|
regulator_register_resolve_supply);
|
2015-01-05 11:48:41 +00:00
|
|
|
kfree(config);
|
2008-04-30 14:59:04 +00:00
|
|
|
return rdev;
|
2008-11-12 01:38:53 +00:00
|
|
|
|
2010-04-29 07:55:11 +00:00
|
|
|
unset_supplies:
|
regulator: core: Add early supply resolution for regulators
The call to set_machine_constraints() in regulator_register(), will
attempt to get the voltage for the regulator. If a regulator is in
bypass will fail to get the voltage (ie. it's bypass voltage) and
hence register the regulator, because the supply for the regulator has
not been resolved yet.
To fix this, add a call to regulator_resolve_supply() before we call
set_machine_constraints(). If the call to regulator_resolve_supply()
fails, rather than returning an error at this point, allow the
registration of the regulator to continue because for some regulators
resolving the supply at this point may not be necessary and it will be
resolved later as more regulators are added. Furthermore, if the supply
is still not resolved for a bypassed regulator, this will be detected
when we attempt to get the voltage for the regulator and an error will
be propagated at this point.
If a bypassed regulator does not have a supply when we attempt to get
the voltage, rather than returing -EINVAL, return -EPROBE_DEFER instead
to allow the registration of the regulator to be deferred and tried
again later.
Please note that regulator_resolve_supply() will call
regulator_dev_lookup() which may acquire the regulator_list_mutex. To
avoid any deadlocks we cannot hold the regulator_list_mutex when calling
regulator_resolve_supply(). Therefore, rather than holding the lock
around a large portion of the registration code, just hold the lock when
aquiring any GPIOs and setting up supplies because these sections may
add entries to the regulator_map_list and regulator_ena_gpio_list,
respectively.
Signed-off-by: Jon Hunter <jonathanh@nvidia.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2016-04-26 10:29:45 +00:00
|
|
|
mutex_lock(®ulator_list_mutex);
|
2010-04-29 07:55:11 +00:00
|
|
|
unset_regulator_supplies(rdev);
|
2019-06-23 21:08:31 +00:00
|
|
|
regulator_remove_coupling(rdev);
|
regulator: core: Add early supply resolution for regulators
The call to set_machine_constraints() in regulator_register(), will
attempt to get the voltage for the regulator. If a regulator is in
bypass will fail to get the voltage (ie. it's bypass voltage) and
hence register the regulator, because the supply for the regulator has
not been resolved yet.
To fix this, add a call to regulator_resolve_supply() before we call
set_machine_constraints(). If the call to regulator_resolve_supply()
fails, rather than returning an error at this point, allow the
registration of the regulator to continue because for some regulators
resolving the supply at this point may not be necessary and it will be
resolved later as more regulators are added. Furthermore, if the supply
is still not resolved for a bypassed regulator, this will be detected
when we attempt to get the voltage for the regulator and an error will
be propagated at this point.
If a bypassed regulator does not have a supply when we attempt to get
the voltage, rather than returing -EINVAL, return -EPROBE_DEFER instead
to allow the registration of the regulator to be deferred and tried
again later.
Please note that regulator_resolve_supply() will call
regulator_dev_lookup() which may acquire the regulator_list_mutex. To
avoid any deadlocks we cannot hold the regulator_list_mutex when calling
regulator_resolve_supply(). Therefore, rather than holding the lock
around a large portion of the registration code, just hold the lock when
aquiring any GPIOs and setting up supplies because these sections may
add entries to the regulator_map_list and regulator_ena_gpio_list,
respectively.
Signed-off-by: Jon Hunter <jonathanh@nvidia.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2016-04-26 10:29:45 +00:00
|
|
|
mutex_unlock(®ulator_list_mutex);
|
2016-02-24 10:52:50 +00:00
|
|
|
wash:
|
2019-10-25 00:22:39 +00:00
|
|
|
kfree(rdev->coupling_desc.coupled_rdevs);
|
regulator: core: Add early supply resolution for regulators
The call to set_machine_constraints() in regulator_register(), will
attempt to get the voltage for the regulator. If a regulator is in
bypass will fail to get the voltage (ie. it's bypass voltage) and
hence register the regulator, because the supply for the regulator has
not been resolved yet.
To fix this, add a call to regulator_resolve_supply() before we call
set_machine_constraints(). If the call to regulator_resolve_supply()
fails, rather than returning an error at this point, allow the
registration of the regulator to continue because for some regulators
resolving the supply at this point may not be necessary and it will be
resolved later as more regulators are added. Furthermore, if the supply
is still not resolved for a bypassed regulator, this will be detected
when we attempt to get the voltage for the regulator and an error will
be propagated at this point.
If a bypassed regulator does not have a supply when we attempt to get
the voltage, rather than returing -EINVAL, return -EPROBE_DEFER instead
to allow the registration of the regulator to be deferred and tried
again later.
Please note that regulator_resolve_supply() will call
regulator_dev_lookup() which may acquire the regulator_list_mutex. To
avoid any deadlocks we cannot hold the regulator_list_mutex when calling
regulator_resolve_supply(). Therefore, rather than holding the lock
around a large portion of the registration code, just hold the lock when
aquiring any GPIOs and setting up supplies because these sections may
add entries to the regulator_map_list and regulator_ena_gpio_list,
respectively.
Signed-off-by: Jon Hunter <jonathanh@nvidia.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2016-04-26 10:29:45 +00:00
|
|
|
mutex_lock(®ulator_list_mutex);
|
2016-02-24 10:52:50 +00:00
|
|
|
regulator_ena_gpio_free(rdev);
|
regulator: core: Add early supply resolution for regulators
The call to set_machine_constraints() in regulator_register(), will
attempt to get the voltage for the regulator. If a regulator is in
bypass will fail to get the voltage (ie. it's bypass voltage) and
hence register the regulator, because the supply for the regulator has
not been resolved yet.
To fix this, add a call to regulator_resolve_supply() before we call
set_machine_constraints(). If the call to regulator_resolve_supply()
fails, rather than returning an error at this point, allow the
registration of the regulator to continue because for some regulators
resolving the supply at this point may not be necessary and it will be
resolved later as more regulators are added. Furthermore, if the supply
is still not resolved for a bypassed regulator, this will be detected
when we attempt to get the voltage for the regulator and an error will
be propagated at this point.
If a bypassed regulator does not have a supply when we attempt to get
the voltage, rather than returing -EINVAL, return -EPROBE_DEFER instead
to allow the registration of the regulator to be deferred and tried
again later.
Please note that regulator_resolve_supply() will call
regulator_dev_lookup() which may acquire the regulator_list_mutex. To
avoid any deadlocks we cannot hold the regulator_list_mutex when calling
regulator_resolve_supply(). Therefore, rather than holding the lock
around a large portion of the registration code, just hold the lock when
aquiring any GPIOs and setting up supplies because these sections may
add entries to the regulator_map_list and regulator_ena_gpio_list,
respectively.
Signed-off-by: Jon Hunter <jonathanh@nvidia.com>
Signed-off-by: Mark Brown <broonie@kernel.org>
2016-04-26 10:29:45 +00:00
|
|
|
mutex_unlock(®ulator_list_mutex);
|
2008-11-12 01:38:53 +00:00
|
|
|
clean:
|
2018-12-06 12:43:37 +00:00
|
|
|
if (dangling_of_gpiod)
|
|
|
|
gpiod_put(config->ena_gpiod);
|
2016-03-30 16:09:13 +00:00
|
|
|
kfree(config);
|
2020-08-12 01:31:36 +00:00
|
|
|
put_device(&rdev->dev);
|
2018-12-06 12:43:37 +00:00
|
|
|
rinse:
|
|
|
|
if (dangling_cfg_gpiod)
|
|
|
|
gpiod_put(cfg->ena_gpiod);
|
2016-03-30 16:09:13 +00:00
|
|
|
return ERR_PTR(ret);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_register);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_unregister - unregister regulator
|
2008-12-31 12:52:41 +00:00
|
|
|
* @rdev: regulator to unregister
|
2008-04-30 14:59:04 +00:00
|
|
|
*
|
|
|
|
* Called by regulator drivers to unregister a regulator.
|
|
|
|
*/
|
|
|
|
void regulator_unregister(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
if (rdev == NULL)
|
|
|
|
return;
|
|
|
|
|
2013-07-08 08:14:45 +00:00
|
|
|
if (rdev->supply) {
|
|
|
|
while (rdev->use_count--)
|
|
|
|
regulator_disable(rdev->supply);
|
2012-03-28 20:17:55 +00:00
|
|
|
regulator_put(rdev->supply);
|
2013-07-08 08:14:45 +00:00
|
|
|
}
|
2018-11-18 21:56:19 +00:00
|
|
|
|
2019-04-04 15:32:18 +00:00
|
|
|
flush_work(&rdev->disable_work.work);
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
mutex_lock(®ulator_list_mutex);
|
2018-11-18 21:56:19 +00:00
|
|
|
|
2010-12-21 23:49:31 +00:00
|
|
|
debugfs_remove_recursive(rdev->debugfs);
|
2009-07-21 15:00:25 +00:00
|
|
|
WARN_ON(rdev->open_count);
|
2018-10-05 15:36:36 +00:00
|
|
|
regulator_remove_coupling(rdev);
|
2009-01-22 14:00:29 +00:00
|
|
|
unset_regulator_supplies(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
list_del(&rdev->list);
|
2013-02-18 06:50:39 +00:00
|
|
|
regulator_ena_gpio_free(rdev);
|
2011-11-28 14:38:37 +00:00
|
|
|
device_unregister(&rdev->dev);
|
2018-11-18 21:56:19 +00:00
|
|
|
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_unregister);
|
|
|
|
|
2018-01-26 13:08:47 +00:00
|
|
|
#ifdef CONFIG_SUSPEND
|
2008-04-30 14:59:04 +00:00
|
|
|
/**
|
2018-07-05 14:25:57 +00:00
|
|
|
* regulator_suspend - prepare regulators for system wide suspend
|
2018-09-04 15:30:05 +00:00
|
|
|
* @dev: ``&struct device`` pointer that is passed to _regulator_suspend()
|
2008-04-30 14:59:04 +00:00
|
|
|
*
|
|
|
|
* Configure each regulator with it's suspend operating parameters for state.
|
|
|
|
*/
|
2018-07-05 14:25:57 +00:00
|
|
|
static int regulator_suspend(struct device *dev)
|
2008-04-30 14:59:04 +00:00
|
|
|
{
|
2018-09-03 14:49:36 +00:00
|
|
|
struct regulator_dev *rdev = dev_to_rdev(dev);
|
2018-01-26 13:08:47 +00:00
|
|
|
suspend_state_t state = pm_suspend_target_state;
|
2018-09-03 14:49:36 +00:00
|
|
|
int ret;
|
2020-08-04 07:08:37 +00:00
|
|
|
const struct regulator_state *rstate;
|
|
|
|
|
|
|
|
rstate = regulator_get_suspend_state_check(rdev, state);
|
|
|
|
if (!rstate)
|
|
|
|
return 0;
|
2018-09-03 14:49:36 +00:00
|
|
|
|
|
|
|
regulator_lock(rdev);
|
2020-08-04 07:08:37 +00:00
|
|
|
ret = __suspend_set_state(rdev, rstate);
|
2018-09-03 14:49:36 +00:00
|
|
|
regulator_unlock(rdev);
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2018-09-03 14:49:36 +00:00
|
|
|
return ret;
|
2015-09-21 14:02:47 +00:00
|
|
|
}
|
2018-03-22 07:23:35 +00:00
|
|
|
|
2018-09-03 14:49:36 +00:00
|
|
|
static int regulator_resume(struct device *dev)
|
2015-09-21 14:02:47 +00:00
|
|
|
{
|
2018-09-03 14:49:36 +00:00
|
|
|
suspend_state_t state = pm_suspend_target_state;
|
2015-09-21 14:02:47 +00:00
|
|
|
struct regulator_dev *rdev = dev_to_rdev(dev);
|
2018-01-26 13:08:47 +00:00
|
|
|
struct regulator_state *rstate;
|
2018-09-03 14:49:36 +00:00
|
|
|
int ret = 0;
|
2018-01-26 13:08:47 +00:00
|
|
|
|
2018-09-03 14:49:36 +00:00
|
|
|
rstate = regulator_get_suspend_state(rdev, state);
|
2018-01-26 13:08:47 +00:00
|
|
|
if (rstate == NULL)
|
2018-02-13 09:37:59 +00:00
|
|
|
return 0;
|
2008-04-30 14:59:04 +00:00
|
|
|
|
2020-08-04 07:08:37 +00:00
|
|
|
/* Avoid grabbing the lock if we don't need to */
|
|
|
|
if (!rdev->desc->ops->resume)
|
|
|
|
return 0;
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2015-09-21 14:02:47 +00:00
|
|
|
|
2020-08-04 07:08:37 +00:00
|
|
|
if (rstate->enabled == ENABLE_IN_SUSPEND ||
|
|
|
|
rstate->enabled == DISABLE_IN_SUSPEND)
|
2018-07-05 14:25:57 +00:00
|
|
|
ret = rdev->desc->ops->resume(rdev);
|
2018-01-26 13:08:47 +00:00
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2015-09-21 14:02:47 +00:00
|
|
|
|
2018-01-26 13:08:47 +00:00
|
|
|
return ret;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
2018-01-26 13:08:47 +00:00
|
|
|
#else /* !CONFIG_SUSPEND */
|
|
|
|
|
2018-07-05 14:25:57 +00:00
|
|
|
#define regulator_suspend NULL
|
|
|
|
#define regulator_resume NULL
|
2018-01-26 13:08:47 +00:00
|
|
|
|
|
|
|
#endif /* !CONFIG_SUSPEND */
|
|
|
|
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
static const struct dev_pm_ops __maybe_unused regulator_pm_ops = {
|
2018-07-05 14:25:57 +00:00
|
|
|
.suspend = regulator_suspend,
|
|
|
|
.resume = regulator_resume,
|
2018-01-26 13:08:47 +00:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2018-01-26 17:40:03 +00:00
|
|
|
struct class regulator_class = {
|
2018-01-26 13:08:47 +00:00
|
|
|
.name = "regulator",
|
|
|
|
.dev_release = regulator_dev_release,
|
|
|
|
.dev_groups = regulator_dev_groups,
|
|
|
|
#ifdef CONFIG_PM
|
|
|
|
.pm = ®ulator_pm_ops,
|
|
|
|
#endif
|
|
|
|
};
|
2009-03-16 19:36:34 +00:00
|
|
|
/**
|
|
|
|
* regulator_has_full_constraints - the system has fully specified constraints
|
|
|
|
*
|
|
|
|
* Calling this function will cause the regulator API to disable all
|
|
|
|
* regulators which have a zero use count and don't have an always_on
|
|
|
|
* constraint in a late_initcall.
|
|
|
|
*
|
|
|
|
* The intention is that this will become the default behaviour in a
|
|
|
|
* future kernel release so users are encouraged to use this facility
|
|
|
|
* now.
|
|
|
|
*/
|
|
|
|
void regulator_has_full_constraints(void)
|
|
|
|
{
|
|
|
|
has_full_constraints = 1;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_has_full_constraints);
|
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
/**
|
|
|
|
* rdev_get_drvdata - get rdev regulator driver data
|
2008-12-31 12:52:41 +00:00
|
|
|
* @rdev: regulator
|
2008-04-30 14:59:04 +00:00
|
|
|
*
|
|
|
|
* Get rdev regulator driver private data. This call can be used in the
|
|
|
|
* regulator driver context.
|
|
|
|
*/
|
|
|
|
void *rdev_get_drvdata(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
return rdev->reg_data;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rdev_get_drvdata);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get_drvdata - get regulator driver data
|
|
|
|
* @regulator: regulator
|
|
|
|
*
|
|
|
|
* Get regulator driver private data. This call can be used in the consumer
|
|
|
|
* driver context when non API regulator specific functions need to be called.
|
|
|
|
*/
|
|
|
|
void *regulator_get_drvdata(struct regulator *regulator)
|
|
|
|
{
|
|
|
|
return regulator->rdev->reg_data;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_drvdata);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_set_drvdata - set regulator driver data
|
|
|
|
* @regulator: regulator
|
|
|
|
* @data: data
|
|
|
|
*/
|
|
|
|
void regulator_set_drvdata(struct regulator *regulator, void *data)
|
|
|
|
{
|
|
|
|
regulator->rdev->reg_data = data;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_set_drvdata);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* regulator_get_id - get regulator ID
|
2008-12-31 12:52:41 +00:00
|
|
|
* @rdev: regulator
|
2008-04-30 14:59:04 +00:00
|
|
|
*/
|
|
|
|
int rdev_get_id(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
return rdev->desc->id;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rdev_get_id);
|
|
|
|
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
struct device *rdev_get_dev(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
return &rdev->dev;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rdev_get_dev);
|
|
|
|
|
2019-01-09 17:44:00 +00:00
|
|
|
struct regmap *rdev_get_regmap(struct regulator_dev *rdev)
|
|
|
|
{
|
|
|
|
return rdev->regmap;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rdev_get_regmap);
|
|
|
|
|
regulator: core - Rework machine API to remove string based functions.
This improves the machine level API in order to configure
regulator constraints and consumers as platform data and removes the
old string based API that required several calls to set up each regulator.
The intention is to create a struct regulator_init_data, populate
it's fields with constraints, consumers devices, etc and then register
the regulator device from board.c in the standard Linux way.
e.g. regulator LDO2 (supplying codec and sim) platform data.
/* regulator LDO2 consumer devices */
static struct regulator_consumer_supply ldo2_consumers[] = {
{
.dev = &platform_audio_device.dev,
.supply = "codec_avdd",
},
{
.dev = &platform_sim_device.dev,
.supply = "sim_vcc",
}
};
/* regulator LDO2 constraints */
static struct regulator_init_data ldo2_data = {
.constraints = {
.min_uV = 3300000,
.max_uV = 3300000,
.valid_modes_mask = REGULATOR_MODE_NORMAL,
.apply_uV = 1,
},
.num_consumer_supplies = ARRAY_SIZE(ldo2_consumers),
.consumer_supplies = ldo2_consumers,
};
/* machine regulator devices with thier consumers and constraints */
static struct platform_device wm8350_regulator_devices[] = {
{
.name = "wm8350-regulator",
.id = WM8350_LDO_2,
.dev = {
.platform_data = &ldo2_data,
},
},
};
Changes in detail:-
o Removed all const char* regulator config functions in machine API.
o Created new struct regulator_init_data to contain regulator
machine configuration constraints and consmuers.
o Changed set_supply(), set_machine_constraints(),
set_consumer_device_supply() to remove their string identifier
parameters. Also made them static and moved functions nearer top of
core.c.
o Removed no longer used inline func to_rdev()
o Added regulator_get_init_drvdata() to retrieve init data.
o Added struct device* as parameter to regulator_register().
o Changed my email address.
Signed-off-by: Eric Miao <eric.miao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Liam Girdwood <lrg@slimlogic.co.uk>
2008-10-10 12:22:20 +00:00
|
|
|
void *regulator_get_init_drvdata(struct regulator_init_data *reg_init_data)
|
|
|
|
{
|
|
|
|
return reg_init_data->driver_data;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(regulator_get_init_drvdata);
|
|
|
|
|
2011-08-23 16:39:10 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
2017-06-30 03:43:42 +00:00
|
|
|
static int supply_map_show(struct seq_file *sf, void *data)
|
2011-08-23 16:39:10 +00:00
|
|
|
{
|
|
|
|
struct regulator_map *map;
|
|
|
|
|
|
|
|
list_for_each_entry(map, ®ulator_map_list, list) {
|
2017-06-30 03:43:42 +00:00
|
|
|
seq_printf(sf, "%s -> %s.%s\n",
|
|
|
|
rdev_get_name(map->regulator), map->dev_name,
|
|
|
|
map->supply);
|
2011-08-23 16:39:10 +00:00
|
|
|
}
|
|
|
|
|
2017-06-30 03:43:42 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2018-12-15 08:21:48 +00:00
|
|
|
DEFINE_SHOW_ATTRIBUTE(supply_map);
|
2011-08-23 16:39:10 +00:00
|
|
|
|
2015-09-21 14:02:47 +00:00
|
|
|
struct summary_data {
|
|
|
|
struct seq_file *s;
|
|
|
|
struct regulator_dev *parent;
|
|
|
|
int level;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void regulator_summary_show_subtree(struct seq_file *s,
|
|
|
|
struct regulator_dev *rdev,
|
|
|
|
int level);
|
|
|
|
|
|
|
|
static int regulator_summary_show_children(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = dev_to_rdev(dev);
|
|
|
|
struct summary_data *summary_data = data;
|
|
|
|
|
|
|
|
if (rdev->supply && rdev->supply->rdev == summary_data->parent)
|
|
|
|
regulator_summary_show_subtree(summary_data->s, rdev,
|
|
|
|
summary_data->level + 1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-04-07 14:16:39 +00:00
|
|
|
static void regulator_summary_show_subtree(struct seq_file *s,
|
|
|
|
struct regulator_dev *rdev,
|
|
|
|
int level)
|
|
|
|
{
|
|
|
|
struct regulation_constraints *c;
|
|
|
|
struct regulator *consumer;
|
2015-09-21 14:02:47 +00:00
|
|
|
struct summary_data summary_data;
|
2018-08-16 20:28:03 +00:00
|
|
|
unsigned int opmode;
|
2015-04-07 14:16:39 +00:00
|
|
|
|
|
|
|
if (!rdev)
|
|
|
|
return;
|
|
|
|
|
2018-08-16 20:28:03 +00:00
|
|
|
opmode = _regulator_get_mode_unlocked(rdev);
|
2018-08-16 20:28:01 +00:00
|
|
|
seq_printf(s, "%*s%-*s %3d %4d %6d %7s ",
|
2015-04-07 14:16:39 +00:00
|
|
|
level * 3 + 1, "",
|
|
|
|
30 - level * 3, rdev_get_name(rdev),
|
2018-08-16 20:28:01 +00:00
|
|
|
rdev->use_count, rdev->open_count, rdev->bypass_count,
|
2018-08-16 20:28:03 +00:00
|
|
|
regulator_opmode_to_str(opmode));
|
2015-04-07 14:16:39 +00:00
|
|
|
|
2019-06-23 21:08:32 +00:00
|
|
|
seq_printf(s, "%5dmV ", regulator_get_voltage_rdev(rdev) / 1000);
|
2018-08-16 20:28:03 +00:00
|
|
|
seq_printf(s, "%5dmA ",
|
|
|
|
_regulator_get_current_limit_unlocked(rdev) / 1000);
|
2015-04-07 14:16:39 +00:00
|
|
|
|
|
|
|
c = rdev->constraints;
|
|
|
|
if (c) {
|
|
|
|
switch (rdev->desc->type) {
|
|
|
|
case REGULATOR_VOLTAGE:
|
|
|
|
seq_printf(s, "%5dmV %5dmV ",
|
|
|
|
c->min_uV / 1000, c->max_uV / 1000);
|
|
|
|
break;
|
|
|
|
case REGULATOR_CURRENT:
|
|
|
|
seq_printf(s, "%5dmA %5dmA ",
|
|
|
|
c->min_uA / 1000, c->max_uA / 1000);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_puts(s, "\n");
|
|
|
|
|
|
|
|
list_for_each_entry(consumer, &rdev->consumer_list, list) {
|
2017-02-14 15:31:03 +00:00
|
|
|
if (consumer->dev && consumer->dev->class == ®ulator_class)
|
2015-04-07 14:16:39 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
seq_printf(s, "%*s%-*s ",
|
|
|
|
(level + 1) * 3 + 1, "",
|
2017-02-14 15:31:03 +00:00
|
|
|
30 - (level + 1) * 3,
|
2020-04-04 00:11:57 +00:00
|
|
|
consumer->supply_name ? consumer->supply_name :
|
2017-02-14 15:31:03 +00:00
|
|
|
consumer->dev ? dev_name(consumer->dev) : "deviceless");
|
2015-04-07 14:16:39 +00:00
|
|
|
|
|
|
|
switch (rdev->desc->type) {
|
|
|
|
case REGULATOR_VOLTAGE:
|
2018-11-20 17:52:53 +00:00
|
|
|
seq_printf(s, "%3d %33dmA%c%5dmV %5dmV",
|
|
|
|
consumer->enable_count,
|
2018-08-16 20:28:02 +00:00
|
|
|
consumer->uA_load / 1000,
|
2018-11-20 17:52:53 +00:00
|
|
|
consumer->uA_load && !consumer->enable_count ?
|
|
|
|
'*' : ' ',
|
2018-01-26 13:08:44 +00:00
|
|
|
consumer->voltage[PM_SUSPEND_ON].min_uV / 1000,
|
|
|
|
consumer->voltage[PM_SUSPEND_ON].max_uV / 1000);
|
2015-04-07 14:16:39 +00:00
|
|
|
break;
|
|
|
|
case REGULATOR_CURRENT:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
seq_puts(s, "\n");
|
|
|
|
}
|
|
|
|
|
2015-09-21 14:02:47 +00:00
|
|
|
summary_data.s = s;
|
|
|
|
summary_data.level = level;
|
|
|
|
summary_data.parent = rdev;
|
2015-04-07 14:16:39 +00:00
|
|
|
|
2015-09-21 14:02:47 +00:00
|
|
|
class_for_each_device(®ulator_class, NULL, &summary_data,
|
|
|
|
regulator_summary_show_children);
|
2018-11-18 21:56:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
struct summary_lock_data {
|
|
|
|
struct ww_acquire_ctx *ww_ctx;
|
|
|
|
struct regulator_dev **new_contended_rdev;
|
|
|
|
struct regulator_dev **old_contended_rdev;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int regulator_summary_lock_one(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = dev_to_rdev(dev);
|
|
|
|
struct summary_lock_data *lock_data = data;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
if (rdev != *lock_data->old_contended_rdev) {
|
|
|
|
ret = regulator_lock_nested(rdev, lock_data->ww_ctx);
|
|
|
|
|
|
|
|
if (ret == -EDEADLK)
|
|
|
|
*lock_data->new_contended_rdev = rdev;
|
|
|
|
else
|
|
|
|
WARN_ON_ONCE(ret);
|
|
|
|
} else {
|
|
|
|
*lock_data->old_contended_rdev = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int regulator_summary_unlock_one(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
struct regulator_dev *rdev = dev_to_rdev(dev);
|
|
|
|
struct summary_lock_data *lock_data = data;
|
|
|
|
|
|
|
|
if (lock_data) {
|
|
|
|
if (rdev == *lock_data->new_contended_rdev)
|
|
|
|
return -EDEADLK;
|
|
|
|
}
|
2018-08-16 20:28:03 +00:00
|
|
|
|
|
|
|
regulator_unlock(rdev);
|
2018-11-18 21:56:17 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int regulator_summary_lock_all(struct ww_acquire_ctx *ww_ctx,
|
|
|
|
struct regulator_dev **new_contended_rdev,
|
|
|
|
struct regulator_dev **old_contended_rdev)
|
|
|
|
{
|
|
|
|
struct summary_lock_data lock_data;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
lock_data.ww_ctx = ww_ctx;
|
|
|
|
lock_data.new_contended_rdev = new_contended_rdev;
|
|
|
|
lock_data.old_contended_rdev = old_contended_rdev;
|
|
|
|
|
|
|
|
ret = class_for_each_device(®ulator_class, NULL, &lock_data,
|
|
|
|
regulator_summary_lock_one);
|
|
|
|
if (ret)
|
|
|
|
class_for_each_device(®ulator_class, NULL, &lock_data,
|
|
|
|
regulator_summary_unlock_one);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void regulator_summary_lock(struct ww_acquire_ctx *ww_ctx)
|
|
|
|
{
|
|
|
|
struct regulator_dev *new_contended_rdev = NULL;
|
|
|
|
struct regulator_dev *old_contended_rdev = NULL;
|
|
|
|
int err;
|
|
|
|
|
2018-11-18 21:56:19 +00:00
|
|
|
mutex_lock(®ulator_list_mutex);
|
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
ww_acquire_init(ww_ctx, ®ulator_ww_class);
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (new_contended_rdev) {
|
|
|
|
ww_mutex_lock_slow(&new_contended_rdev->mutex, ww_ctx);
|
|
|
|
old_contended_rdev = new_contended_rdev;
|
|
|
|
old_contended_rdev->ref_cnt++;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = regulator_summary_lock_all(ww_ctx,
|
|
|
|
&new_contended_rdev,
|
|
|
|
&old_contended_rdev);
|
|
|
|
|
|
|
|
if (old_contended_rdev)
|
|
|
|
regulator_unlock(old_contended_rdev);
|
|
|
|
|
|
|
|
} while (err == -EDEADLK);
|
|
|
|
|
|
|
|
ww_acquire_done(ww_ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void regulator_summary_unlock(struct ww_acquire_ctx *ww_ctx)
|
|
|
|
{
|
|
|
|
class_for_each_device(®ulator_class, NULL, NULL,
|
|
|
|
regulator_summary_unlock_one);
|
|
|
|
ww_acquire_fini(ww_ctx);
|
2018-11-18 21:56:19 +00:00
|
|
|
|
|
|
|
mutex_unlock(®ulator_list_mutex);
|
2015-04-07 14:16:39 +00:00
|
|
|
}
|
|
|
|
|
2015-09-21 14:02:47 +00:00
|
|
|
static int regulator_summary_show_roots(struct device *dev, void *data)
|
2015-04-07 14:16:39 +00:00
|
|
|
{
|
2015-09-21 14:02:47 +00:00
|
|
|
struct regulator_dev *rdev = dev_to_rdev(dev);
|
|
|
|
struct seq_file *s = data;
|
2015-04-07 14:16:39 +00:00
|
|
|
|
2015-09-21 14:02:47 +00:00
|
|
|
if (!rdev->supply)
|
|
|
|
regulator_summary_show_subtree(s, rdev, 0);
|
2015-04-07 14:16:39 +00:00
|
|
|
|
2015-09-21 14:02:47 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2015-04-07 14:16:39 +00:00
|
|
|
|
2015-09-21 14:02:47 +00:00
|
|
|
static int regulator_summary_show(struct seq_file *s, void *data)
|
|
|
|
{
|
2018-11-18 21:56:17 +00:00
|
|
|
struct ww_acquire_ctx ww_ctx;
|
|
|
|
|
2018-08-16 20:28:01 +00:00
|
|
|
seq_puts(s, " regulator use open bypass opmode voltage current min max\n");
|
|
|
|
seq_puts(s, "---------------------------------------------------------------------------------------\n");
|
2015-04-07 14:16:39 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_summary_lock(&ww_ctx);
|
|
|
|
|
2015-09-21 14:02:47 +00:00
|
|
|
class_for_each_device(®ulator_class, NULL, s,
|
|
|
|
regulator_summary_show_roots);
|
2015-04-07 14:16:39 +00:00
|
|
|
|
2018-11-18 21:56:17 +00:00
|
|
|
regulator_summary_unlock(&ww_ctx);
|
|
|
|
|
2015-04-07 14:16:39 +00:00
|
|
|
return 0;
|
|
|
|
}
|
2018-12-15 08:21:48 +00:00
|
|
|
DEFINE_SHOW_ATTRIBUTE(regulator_summary);
|
|
|
|
#endif /* CONFIG_DEBUG_FS */
|
2015-04-07 14:16:39 +00:00
|
|
|
|
2008-04-30 14:59:04 +00:00
|
|
|
static int __init regulator_init(void)
|
|
|
|
{
|
2010-02-12 10:18:08 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = class_register(®ulator_class);
|
|
|
|
|
2010-12-21 23:49:31 +00:00
|
|
|
debugfs_root = debugfs_create_dir("regulator", NULL);
|
2012-02-21 06:50:42 +00:00
|
|
|
if (!debugfs_root)
|
2010-12-21 23:49:31 +00:00
|
|
|
pr_warn("regulator: Failed to create debugfs directory\n");
|
2011-08-23 16:39:10 +00:00
|
|
|
|
2018-12-15 08:21:48 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
2012-02-20 21:01:04 +00:00
|
|
|
debugfs_create_file("supply_map", 0444, debugfs_root, NULL,
|
|
|
|
&supply_map_fops);
|
2010-12-21 23:49:31 +00:00
|
|
|
|
2015-04-07 14:16:39 +00:00
|
|
|
debugfs_create_file("regulator_summary", 0444, debugfs_root,
|
2015-09-21 14:02:47 +00:00
|
|
|
NULL, ®ulator_summary_fops);
|
2018-12-15 08:21:48 +00:00
|
|
|
#endif
|
2010-02-12 10:18:08 +00:00
|
|
|
regulator_dummy_init();
|
|
|
|
|
2019-06-23 21:08:31 +00:00
|
|
|
regulator_coupler_register(&generic_regulator_coupler);
|
|
|
|
|
2010-02-12 10:18:08 +00:00
|
|
|
return ret;
|
2008-04-30 14:59:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* init early to allow our consumers to complete system booting */
|
|
|
|
core_initcall(regulator_init);
|
2009-03-16 19:36:34 +00:00
|
|
|
|
2019-09-04 12:42:50 +00:00
|
|
|
static int regulator_late_cleanup(struct device *dev, void *data)
|
2009-03-16 19:36:34 +00:00
|
|
|
{
|
2015-08-10 18:43:47 +00:00
|
|
|
struct regulator_dev *rdev = dev_to_rdev(dev);
|
|
|
|
const struct regulator_ops *ops = rdev->desc->ops;
|
|
|
|
struct regulation_constraints *c = rdev->constraints;
|
2009-03-16 19:36:34 +00:00
|
|
|
int enabled, ret;
|
|
|
|
|
2015-08-10 18:43:47 +00:00
|
|
|
if (c && c->always_on)
|
|
|
|
return 0;
|
|
|
|
|
2016-04-23 07:11:05 +00:00
|
|
|
if (!regulator_ops_is_valid(rdev, REGULATOR_CHANGE_STATUS))
|
2015-08-10 18:43:47 +00:00
|
|
|
return 0;
|
|
|
|
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_lock(rdev);
|
2015-08-10 18:43:47 +00:00
|
|
|
|
|
|
|
if (rdev->use_count)
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
/* If we can't read the status assume it's on. */
|
|
|
|
if (ops->is_enabled)
|
|
|
|
enabled = ops->is_enabled(rdev);
|
|
|
|
else
|
|
|
|
enabled = 1;
|
|
|
|
|
|
|
|
if (!enabled)
|
|
|
|
goto unlock;
|
|
|
|
|
|
|
|
if (have_full_constraints()) {
|
|
|
|
/* We log since this may kill the system if it goes
|
|
|
|
* wrong. */
|
|
|
|
rdev_info(rdev, "disabling\n");
|
|
|
|
ret = _regulator_do_disable(rdev);
|
|
|
|
if (ret != 0)
|
|
|
|
rdev_err(rdev, "couldn't disable: %d\n", ret);
|
|
|
|
} else {
|
|
|
|
/* The intention is that in future we will
|
|
|
|
* assume that full constraints are provided
|
|
|
|
* so warn even if we aren't going to do
|
|
|
|
* anything here.
|
|
|
|
*/
|
|
|
|
rdev_warn(rdev, "incomplete constraints, leaving on\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
unlock:
|
2018-04-23 14:33:37 +00:00
|
|
|
regulator_unlock(rdev);
|
2015-08-10 18:43:47 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-09-04 12:42:50 +00:00
|
|
|
static void regulator_init_complete_work_function(struct work_struct *work)
|
2015-08-10 18:43:47 +00:00
|
|
|
{
|
2017-02-16 17:30:02 +00:00
|
|
|
/*
|
|
|
|
* Regulators may had failed to resolve their input supplies
|
|
|
|
* when were registered, either because the input supply was
|
|
|
|
* not registered yet or because its parent device was not
|
|
|
|
* bound yet. So attempt to resolve the input supplies for
|
|
|
|
* pending regulators before trying to disable unused ones.
|
|
|
|
*/
|
|
|
|
class_for_each_device(®ulator_class, NULL, NULL,
|
|
|
|
regulator_register_resolve_supply);
|
|
|
|
|
2009-03-16 19:36:34 +00:00
|
|
|
/* If we have a full configuration then disable any regulators
|
2014-06-01 18:15:16 +00:00
|
|
|
* we have permission to change the status for and which are
|
|
|
|
* not in use or always_on. This is effectively the default
|
|
|
|
* for DT and ACPI as they have full constraints.
|
2009-03-16 19:36:34 +00:00
|
|
|
*/
|
2015-08-10 18:43:47 +00:00
|
|
|
class_for_each_device(®ulator_class, NULL, NULL,
|
|
|
|
regulator_late_cleanup);
|
2019-09-04 12:42:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
/*
|
2020-04-29 17:23:49 +00:00
|
|
|
* 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.
|
2019-09-04 12:42:50 +00:00
|
|
|
*/
|
2020-04-29 17:23:49 +00:00
|
|
|
schedule_delayed_work(®ulator_init_complete_work,
|
|
|
|
msecs_to_jiffies(30000));
|
2009-03-16 19:36:34 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2014-04-23 23:10:50 +00:00
|
|
|
late_initcall_sync(regulator_init_complete);
|