Support changing run-level via I2C and add in-kernel API for allowing
run time changes of run-level voltages.
Signed-off-by: Matti Vaittinen <matti.vaitti...@fi.rohmeurope.com>
---
drivers/regulator/bd71828-regulator.c | 266 ++++++++++++++++++++++----
include/linux/mfd/rohm-bd71828.h | 3 +
2 files changed, 232 insertions(+), 37 deletions(-)
diff --git a/drivers/regulator/bd71828-regulator.c
b/drivers/regulator/bd71828-regulator.c
index 36f5aef941e5..d5d0dcee90cf 100644
--- a/drivers/regulator/bd71828-regulator.c
+++ b/drivers/regulator/bd71828-regulator.c
@@ -19,6 +19,12 @@
#include <linux/regulator/machine.h>
#include <linux/regulator/of_regulator.h>
+/* Drivers should not do this. But we provide this custom kernel interface
+ * for users to switch the run-level. Hence we need to get the rdev from
+ * struct regulator
+ */
+#include "internal.h"
+
#define MAX_GPIO_DVS_BUCKS 4
#define DVS_RUN_LEVELS 4
@@ -39,7 +45,10 @@ struct bd71828_regulator_data {
const struct reg_init *reg_inits;
int reg_init_amnt;
struct run_lvl_ctrl run_lvl[DVS_RUN_LEVELS];
+ struct mutex dvs_lock;
struct gpio_descs *gps;
+ struct regmap *regmap;
+ bool allow_runlvl;
};
static const struct reg_init buck1_inits[] = {
@@ -225,7 +234,7 @@ static int set_runlevel_voltage(struct regmap *regmap,
return ret;
}
-static int buck_set_gpio_hw_dvs_levels(struct device_node *np,
+static int buck_set_runlvl_hw_dvs_levels(struct device_node *np,
const struct regulator_desc *desc,
struct regulator_config *cfg)
{
@@ -245,11 +254,12 @@ static int buck_set_gpio_hw_dvs_levels(struct device_node
*np,
data = container_of(desc, struct bd71828_regulator_data, desc);
+ mutex_lock(&data->dvs_lock);
for (i = 0; i < DVS_RUN_LEVELS; i++) {
ret = of_property_read_u32(np, props[i], &uv);
if (ret) {
if (ret != -EINVAL)
- return ret;
+ goto unlock_out;
uv = 0;
}
if (uv) {
@@ -259,7 +269,7 @@ static int buck_set_gpio_hw_dvs_levels(struct device_node
*np,
ret = set_runlevel_voltage(cfg->regmap, desc, uv, i);
if (ret)
- return ret;
+ goto unlock_out;
ret = regmap_update_bits(cfg->regmap, en_reg,
en_masks[i], en_masks[i]);
@@ -268,10 +278,15 @@ static int buck_set_gpio_hw_dvs_levels(struct device_node
*np,
en_masks[i], 0);
}
if (ret)
- return ret;
+ goto unlock_out;
}
- return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
+ ret = rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
+
+unlock_out:
+ mutex_unlock(&data->dvs_lock);
+
+ return ret;
}
static int ldo6_parse_dt(struct device_node *np,
@@ -324,11 +339,40 @@ static int bd71828_dvs_gpio_set_run_level(struct
bd71828_regulator_data *rd,
return gpiod_set_array_value_cansleep(rd->gps->ndescs, rd->gps->desc,
rd->gps->info, values);
}
+
+/* Get current run level when RUN levels are controlled using I2C */
+static int bd71828_dvs_i2c_set_run_level(struct regmap *regmap,
+ int lvl)
+{
+ unsigned int reg;
+
+ reg = lvl << (ffs(BD71828_MASK_RUN_LVL_CTRL) - 1);
+
+ return regmap_update_bits(regmap, BD71828_REG_PS_CTRL_3,
+ BD71828_MASK_RUN_LVL_CTRL, reg);
+}
+/* Get current run level when RUN levels are controlled using I2C */
+static int bd71828_dvs_i2c_get_run_level(struct regmap *regmap,
+ struct bd71828_regulator_data *rd)
+{
+ int ret;
+ unsigned int val;
+
+ ret = regmap_read(regmap, BD71828_REG_PS_CTRL_3, &val);
+ if (ret)
+ return ret;
+
+ ret = (val & BD71828_MASK_RUN_LVL_CTRL);
+ ret >>= ffs(BD71828_MASK_RUN_LVL_CTRL) - 1;
+
+ return ret;
+}
+
+/* Get current RUN level when run levels are controlled by GPIO */
static int bd71828_dvs_gpio_get_run_level(struct bd71828_regulator_data *rd)
{
int run_level;
int ret;
-
DECLARE_BITMAP(values, 2);
values[0] = 0;
@@ -346,47 +390,131 @@ static int bd71828_dvs_gpio_get_run_level(struct
bd71828_regulator_data *rd)
return run_level;
}
+/*
+ * To be used when BD71828 regulator is controlled by RUN levels
+ * via I2C instead of GPIO
+ */
+static int bd71828_dvs_i2c_is_enabled(struct regulator_dev *rdev)
+{
+ struct bd71828_regulator_data *data = rdev_get_drvdata(rdev);
+ int ret;
+
+ mutex_lock(&data->dvs_lock);
+ ret = bd71828_dvs_i2c_get_run_level(rdev->regmap, data);
+ if (ret < 0)
+ goto unlock_out;
+
+ ret = data->run_lvl[ret].enabled;
+
+unlock_out:
+ mutex_unlock(&data->dvs_lock);
+
+ return ret;
+}
+
+/*
+ * To be used when BD71828 regulator is controlled by RUN levels
+ * via GPIO
+ */
static int bd71828_dvs_gpio_is_enabled(struct regulator_dev *rdev)
{
struct bd71828_regulator_data *data = rdev_get_drvdata(rdev);
int ret;
- // TODO: lock GPIO state (Is this needed)
+ mutex_lock(&data->dvs_lock);
ret = bd71828_dvs_gpio_get_run_level(data);
- if (ret < 0)
+ if (ret < 0 || ret >= DVS_RUN_LEVELS)
goto unlock_out;
ret = data->run_lvl[ret].enabled;
unlock_out:
- //TODO: unlock
+ mutex_unlock(&data->dvs_lock);
return ret;
}
+/*
+ * To be used when BD71828 regulator is controlled by RUN levels
+ * via I2C instead of GPIO
+ */
+static int bd71828_dvs_i2c_get_voltage(struct regulator_dev *rdev)
+{
+ int ret;
+ struct bd71828_regulator_data *data = rdev_get_drvdata(rdev);
+
+ mutex_lock(&data->dvs_lock);
+ ret = bd71828_dvs_i2c_get_run_level(rdev->regmap, data);
+ if (ret < 0)
+ goto unlock_out;
+
+ ret = data->run_lvl[ret].voltage;
+
+unlock_out:
+ mutex_unlock(&data->dvs_lock);
+
+ return ret;
+}
+
+/*
+ * To be used when BD71828 regulator is controlled by RUN levels
+ * via GPIO
+ */
static int bd71828_dvs_gpio_get_voltage(struct regulator_dev *rdev)
{
int ret;
struct bd71828_regulator_data *data = rdev_get_drvdata(rdev);
- // TODO: lock GPIO state (Is this needed)
+ mutex_lock(&data->dvs_lock);
ret = bd71828_dvs_gpio_get_run_level(data);
- if (ret < 0)
+ if (ret < 0 || DVS_RUN_LEVELS <= ret)
goto unlock_out;
ret = data->run_lvl[ret].voltage;
unlock_out:
- //TODO: unlock
+ mutex_unlock(&data->dvs_lock);
+
+ return ret;
+}
+
+/**
+ * bd71828_set_runlevel_voltage - change run-level voltage
+ *
+ * @regulator: pointer to regulator for which the run-level voltage is changed
+ * @uv: New voltage for run-level in micro volts
+ * @level: run-level for which the voltage is to be changed
+ *
+ * Changes the run-level voltage for given regulator
+ */
+int bd71828_set_runlevel_voltage(struct regulator *regulator, unsigned int uv,
+ unsigned int level)
+{
+ struct regulator_dev *rdev = regulator->rdev;
+ struct bd71828_regulator_data *data = rdev_get_drvdata(rdev);
+ int ret;
+
+ if (!data || !data->allow_runlvl)
+ return -EINVAL;
+
+ mutex_lock(&data->dvs_lock);
+ ret = set_runlevel_voltage(rdev->regmap, rdev->desc, uv, level);
+ mutex_unlock(&data->dvs_lock);
return ret;
}
+EXPORT_SYMBOL(bd71828_set_runlevel_voltage);
static const struct regulator_ops dvs_buck_gpio_ops = {
.is_enabled = bd71828_dvs_gpio_is_enabled,
.get_voltage = bd71828_dvs_gpio_get_voltage,
};
+static const struct regulator_ops dvs_buck_i2c_ops = {
+ .is_enabled = bd71828_dvs_i2c_is_enabled,
+ .get_voltage = bd71828_dvs_i2c_get_voltage,
+};
+
static const struct regulator_ops bd71828_buck_ops = {
.enable = regulator_enable_regmap,
.disable = regulator_disable_regmap,
@@ -972,17 +1100,72 @@ static const struct bd71828_regulator_data
bd71828_rdata[] = {
};
struct bd71828_gpio_cfg {
- unsigned int gpiobucks;
+ bool use_gpio;
+ unsigned int runlvl;
struct gpio_descs *gps;
};
+static void mark_regulator_runlvl_controlled(struct device *dev,
+ struct device_node *np,
+ struct bd71828_gpio_cfg *g)
+{
+ int i;
+
+ for (i = 1; i <= ARRAY_SIZE(bd71828_rdata); i++) {
+ if (!of_node_name_eq(np, bd71828_rdata[i-1].desc.of_match))
+ continue;
+ switch (i) {
+ case 1:
+ case 2:
+ case 6:
+ case 7:
+ g->runlvl |= 1 << (i - 1);
+ dev_dbg(dev, "buck %d runlevel controlled\n", i);
+ break;
+ default:
+ dev_err(dev,
+ "Only bucks 1,2,6,7 support run-level dvs\n");
+ break;
+ }
+ }
+}
+
+static int get_runcontrolled_bucks_dt(struct device *dev,
+ struct bd71828_gpio_cfg *g)
+{
+ struct device_node *np;
+ struct device_node *nproot = dev->of_node;
+ const char *prop = "rohm,dvs-runlvl-ctrl";
+
+ g->runlvl = 0;
+
+ nproot = of_get_child_by_name(nproot, "regulators");
+ if (!nproot) {
+ dev_err(dev, "failed to find regulators node\n");
+ return -ENODEV;
+ }
+ for_each_child_of_node(nproot, np)
+ if (of_property_read_bool(np, prop))
+ mark_regulator_runlvl_controlled(dev, np, g);
+
+ of_node_put(nproot);
+ return 0;
+}
+
static int check_dt_for_gpio_controls(struct device *d,
struct bd71828_gpio_cfg *g)
{
- int ret, i;
- struct device_node *np = d->of_node;
- const char *prop = "rohm,dvs_gpio_bucks";
- uint32_t bucks[MAX_GPIO_DVS_BUCKS];
+ int ret;
+
+ ret = get_runcontrolled_bucks_dt(d, g);
+ if (ret)
+ return ret;
+
+ g->use_gpio = false;
+
+ /* If the run level control is not requested by any bucks we're done */
+ if (!g->runlvl)
+ return 0;
g->gps = devm_gpiod_get_array(d, "rohm,dvs-vsel", GPIOD_OUT_LOW);
@@ -996,22 +1179,14 @@ static int check_dt_for_gpio_controls(struct device *d,
if (g->gps->ndescs != 2)
return -ENOENT;
- ret = of_property_read_variable_u32_array(np, prop, bucks, 0,
- ARRAY_SIZE(bucks));
-
- if (ret < 0) {
- if (ret == -EOVERFLOW)
- return -EINVAL;
- }
- for (i = 0; i < ret; i++)
- g->gpiobucks |= 1 << bucks[i];
+ g->use_gpio = true;
return 0;
}
-static void set_buck_gpio_controlled(struct rohm_regmap_dev *bd71828,
- struct bd71828_regulator_data *rd,
- struct bd71828_gpio_cfg *g)
+static void set_buck_runlvl_controlled(struct rohm_regmap_dev *bd71828,
+ struct bd71828_regulator_data *rd,
+ struct bd71828_gpio_cfg *g)
{
switch (rd->desc.id) {
case BD71828_BUCK1:
@@ -1033,9 +1208,16 @@ static void set_buck_gpio_controlled(struct
rohm_regmap_dev *bd71828,
* Disallow setters. Get voltages/enable states based
* on current RUN level
*/
- rd->gps = g->gps;
- rd->desc.ops = &dvs_buck_gpio_ops;
- rd->desc.of_parse_cb = buck_set_gpio_hw_dvs_levels;
+
+ rd->allow_runlvl = true;
+
+ if (g->use_gpio) {
+ rd->gps = g->gps;
+ rd->desc.ops = &dvs_buck_gpio_ops;
+ } else {
+ rd->desc.ops = &dvs_buck_i2c_ops;
+ }
+ rd->desc.of_parse_cb = buck_set_runlvl_hw_dvs_levels;
}
static ssize_t show_runlevel(struct device *dev,
@@ -1044,10 +1226,14 @@ static ssize_t show_runlevel(struct device *dev,
int runlevel;
struct bd71828_regulator_data *rd = dev_get_drvdata(dev);
- if (!rd || !rd->gps)
+ if (!rd)
return -ENOENT;
- runlevel = bd71828_dvs_gpio_get_run_level(rd);
+ if (!rd->gps)
+ runlevel = bd71828_dvs_i2c_get_run_level(rd->regmap, rd);
+ else
+ runlevel = bd71828_dvs_gpio_get_run_level(rd);
+
if (runlevel < 0)
return runlevel;
@@ -1063,7 +1249,10 @@ static ssize_t set_runlevel(struct device *dev, struct
device_attribute *attr,
if (kstrtol(buf, 0, &val) != 0)
return -EINVAL;
- val = bd71828_dvs_gpio_set_run_level(rd, val);
+ if (rd->gps)
+ val = bd71828_dvs_gpio_set_run_level(rd, val);
+ else
+ val = bd71828_dvs_i2c_set_run_level(rd->regmap, val);
if (val)
return val;
@@ -1133,8 +1322,11 @@ static int bd71828_probe(struct platform_device *pdev)
/* Use bd71828_rdata as template */
rd[i] = bd71828_rdata[i];
- if (gcfg.gpiobucks & (1 << i))
- set_buck_gpio_controlled(bd71828, &rd[i], &gcfg);
+ mutex_init(&rd[i].dvs_lock);
+ if (gcfg.runlvl & (1 << i))
+ set_buck_runlvl_controlled(bd71828, &rd[i], &gcfg);
+
+ rd[i].regmap = bd71828->regmap;
}
config.regmap = bd71828->regmap;
diff --git a/include/linux/mfd/rohm-bd71828.h b/include/linux/mfd/rohm-bd71828.h
index eb0557eb5314..5f15c6a309e6 100644
--- a/include/linux/mfd/rohm-bd71828.h
+++ b/include/linux/mfd/rohm-bd71828.h
@@ -422,4 +422,7 @@ enum {
#define BD71828_OUT_TYPE_OPEN_DRAIN 0x0
#define BD71828_OUT_TYPE_CMOS 0x2
+int bd71828_set_runlevel_voltage(struct regulator *regulator, unsigned int uv,
+ unsigned int level);
+
#endif /* __LINUX_MFD_BD71828_H__ */
--
2.21.0
--
Matti Vaittinen, Linux device drivers
ROHM Semiconductors, Finland SWDC
Kiviharjunlenkki 1E
90220 OULU
FINLAND
~~~ "I don't think so," said Rene Descartes. Just then he vanished ~~~
Simon says - in Latin please.
~~~ "non cogito me" dixit Rene Descarte, deinde evanescavit ~~~
Thanks to Simon Glass for the translation =]
