mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-11-26 02:30:53 +07:00
5451781dad
In general when the consumer of a regulator requests that the
regulator be disabled it no longer will be drawing much load from the
regulator--it should just be the leakage current and that should be
very close to 0.
Up to this point the regulator framework has continued to count a
consumer's load request for disabled regulators. This has led to code
patterns that look like this:
enable_my_thing():
regular_set_load(reg, load_uA)
regulator_enable(reg)
disable_my_thing():
regulator_disable(reg)
regulator_set_load(reg, 0)
Sometimes disable_my_thing() sets a nominal (<= 100 uA) load instead
of setting a 0 uA load. I will make the assertion that nearly all (if
not all) places where we set a nominal load of 100 uA or less we end
up with a result that is the same as if we had set a load of 0 uA.
Specifically:
- The whole point of setting the load is to help set the operating
mode of the regulator. Higher loads may need less efficient
operating modes.
- The only time this matters at all is if there is another consumer of
the regulator that wants the regulator on. If there are no other
consumers of the regulator then the regulator will turn off and we
don't care about the operating mode.
- If there's another consumer that actually wants the regulator on
then presumably it is requesting a load that makes our nominal
<= 100 uA load insignificant.
A quick survey of the existing callers to regulator_set_load() to see
how everyone uses it:
Signed-off-by: Douglas Anderson <dianders@chromium.org>
Signed-off-by: Mark Brown <broonie@kernel.org>
119 lines
2.8 KiB
C
119 lines
2.8 KiB
C
/*
|
|
* internal.h -- Voltage/Current Regulator framework internal code
|
|
*
|
|
* Copyright 2007, 2008 Wolfson Microelectronics PLC.
|
|
* Copyright 2008 SlimLogic Ltd.
|
|
*
|
|
* Author: Liam Girdwood <lrg@slimlogic.co.uk>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version.
|
|
*
|
|
*/
|
|
|
|
#ifndef __REGULATOR_INTERNAL_H
|
|
#define __REGULATOR_INTERNAL_H
|
|
|
|
#include <linux/suspend.h>
|
|
|
|
#define REGULATOR_STATES_NUM (PM_SUSPEND_MAX + 1)
|
|
|
|
struct regulator_voltage {
|
|
int min_uV;
|
|
int max_uV;
|
|
};
|
|
|
|
/*
|
|
* struct regulator
|
|
*
|
|
* One for each consumer device.
|
|
* @voltage - a voltage array for each state of runtime, i.e.:
|
|
* PM_SUSPEND_ON
|
|
* PM_SUSPEND_TO_IDLE
|
|
* PM_SUSPEND_STANDBY
|
|
* PM_SUSPEND_MEM
|
|
* PM_SUSPEND_MAX
|
|
*/
|
|
struct regulator {
|
|
struct device *dev;
|
|
struct list_head list;
|
|
unsigned int always_on:1;
|
|
unsigned int bypass:1;
|
|
int uA_load;
|
|
unsigned int enable_count;
|
|
unsigned int deferred_disables;
|
|
struct regulator_voltage voltage[REGULATOR_STATES_NUM];
|
|
const char *supply_name;
|
|
struct device_attribute dev_attr;
|
|
struct regulator_dev *rdev;
|
|
struct dentry *debugfs;
|
|
};
|
|
|
|
extern struct class regulator_class;
|
|
|
|
static inline struct regulator_dev *dev_to_rdev(struct device *dev)
|
|
{
|
|
return container_of(dev, struct regulator_dev, dev);
|
|
}
|
|
|
|
#ifdef CONFIG_OF
|
|
struct regulator_dev *of_find_regulator_by_node(struct device_node *np);
|
|
struct regulator_init_data *regulator_of_get_init_data(struct device *dev,
|
|
const struct regulator_desc *desc,
|
|
struct regulator_config *config,
|
|
struct device_node **node);
|
|
|
|
struct regulator_dev *of_parse_coupled_regulator(struct regulator_dev *rdev,
|
|
int index);
|
|
|
|
int of_get_n_coupled(struct regulator_dev *rdev);
|
|
|
|
bool of_check_coupling_data(struct regulator_dev *rdev);
|
|
|
|
#else
|
|
static inline struct regulator_dev *
|
|
of_find_regulator_by_node(struct device_node *np)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline struct regulator_init_data *
|
|
regulator_of_get_init_data(struct device *dev,
|
|
const struct regulator_desc *desc,
|
|
struct regulator_config *config,
|
|
struct device_node **node)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline struct regulator_dev *
|
|
of_parse_coupled_regulator(struct regulator_dev *rdev,
|
|
int index)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static inline int of_get_n_coupled(struct regulator_dev *rdev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline bool of_check_coupling_data(struct regulator_dev *rdev)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
#endif
|
|
enum regulator_get_type {
|
|
NORMAL_GET,
|
|
EXCLUSIVE_GET,
|
|
OPTIONAL_GET,
|
|
MAX_GET_TYPE
|
|
};
|
|
|
|
struct regulator *_regulator_get(struct device *dev, const char *id,
|
|
enum regulator_get_type get_type);
|
|
#endif
|