mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-21 08:19:28 +00:00
![Linus Torvalds](/assets/img/avatar_default.png)
A collection of fixes for the regulator API that have come up since the merge window, including a big batch of fixes from Axel Lin's usual careful and detailed review. The one stand out fix here is Dmitry Baryshkov's fix for an issue where we fail to power on the parents of always on regulators during system startup if they weren't already powered on. -----BEGIN PGP SIGNATURE----- iQEzBAABCgAdFiEEreZoqmdXGLWf4p/qJNaLcl1Uh9AFAmC/ao0ACgkQJNaLcl1U h9AoqQf9GYtljFSON07MAOWwMgnjuMQ+rl0ZadqKKzq74QMMi4bxVKDWkftQ28/5 Ulk2M/mxRE6C1OEpOJl9ZnG9K0fWpOdnTURkYgW0FsJniEDiF7ZkdoFypwu93jOD 0r+3QCw/Ti9i08pOdlpFpUKU5rp/O9HYmouOTzBOCiM1SMb9TkkX5GBoDVw8+cWd 2PZqKQXEsaK1uNzeaXYw6UO8+IdSpVQRzSEILdtVWyHCNmXDDJWfI3vYeeqDbhYr C+E3UdrO1ftNsOoJv33NqhscMnulkZDZ6H6lgbLX2FyFAe2M9N+AildGlkR5H1GD xH3q3EvkOE2Y2X3zHteLdJ3MoI91cQ== =poWJ -----END PGP SIGNATURE----- Merge tag 'regulator-fix-v5.13-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regulator Pull regulator fixes from Mark Brown: "A collection of fixes for the regulator API that have come up since the merge window, including a big batch of fixes from Axel Lin's usual careful and detailed review. The one stand out fix here is Dmitry Baryshkov's fix for an issue where we fail to power on the parents of always on regulators during system startup if they weren't already powered on" * tag 'regulator-fix-v5.13-rc4' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regulator: (21 commits) regulator: rt4801: Fix NULL pointer dereference if priv->enable_gpios is NULL regulator: hi6421v600: Fix .vsel_mask setting regulator: bd718x7: Fix the BUCK7 voltage setting on BD71837 regulator: atc260x: Fix n_voltages and min_sel for pickable linear ranges regulator: rtmv20: Fix to make regcache value first reading back from HW regulator: mt6315: Fix function prototype for mt6315_map_mode regulator: rtmv20: Add Richtek to Kconfig text regulator: rtmv20: Fix .set_current_limit/.get_current_limit callbacks regulator: hisilicon: use the correct HiSilicon copyright regulator: bd71828: Fix .n_voltages settings regulator: bd70528: Fix off-by-one for buck123 .n_voltages setting regulator: max77620: Silence deferred probe error regulator: max77620: Use device_set_of_node_from_dev() regulator: scmi: Fix off-by-one for linear regulators .n_voltages setting regulator: core: resolve supply for boot-on/always-on regulators regulator: fixed: Ensure enable_counter is correct if reg_domain_disable fails regulator: Check ramp_delay_table for regulator_set_ramp_delay_regmap regulator: fan53880: Fix missing n_voltages setting regulator: da9121: Return REGULATOR_MODE_INVALID for invalid mode regulator: fan53555: fix TCS4525 voltage calulation ...
423 lines
11 KiB
C
423 lines
11 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
//
|
|
// System Control and Management Interface (SCMI) based regulator driver
|
|
//
|
|
// Copyright (C) 2020-2021 ARM Ltd.
|
|
//
|
|
// Implements a regulator driver on top of the SCMI Voltage Protocol.
|
|
//
|
|
// The ARM SCMI Protocol aims in general to hide as much as possible all the
|
|
// underlying operational details while providing an abstracted interface for
|
|
// its users to operate upon: as a consequence the resulting operational
|
|
// capabilities and configurability of this regulator device are much more
|
|
// limited than the ones usually available on a standard physical regulator.
|
|
//
|
|
// The supported SCMI regulator ops are restricted to the bare minimum:
|
|
//
|
|
// - 'status_ops': enable/disable/is_enabled
|
|
// - 'voltage_ops': get_voltage_sel/set_voltage_sel
|
|
// list_voltage/map_voltage
|
|
//
|
|
// Each SCMI regulator instance is associated, through the means of a proper DT
|
|
// entry description, to a specific SCMI Voltage Domain.
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
#include <linux/linear_range.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of.h>
|
|
#include <linux/regulator/driver.h>
|
|
#include <linux/regulator/machine.h>
|
|
#include <linux/regulator/of_regulator.h>
|
|
#include <linux/scmi_protocol.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/types.h>
|
|
|
|
static const struct scmi_voltage_proto_ops *voltage_ops;
|
|
|
|
struct scmi_regulator {
|
|
u32 id;
|
|
struct scmi_device *sdev;
|
|
struct scmi_protocol_handle *ph;
|
|
struct regulator_dev *rdev;
|
|
struct device_node *of_node;
|
|
struct regulator_desc desc;
|
|
struct regulator_config conf;
|
|
};
|
|
|
|
struct scmi_regulator_info {
|
|
int num_doms;
|
|
struct scmi_regulator **sregv;
|
|
};
|
|
|
|
static int scmi_reg_enable(struct regulator_dev *rdev)
|
|
{
|
|
struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
|
|
|
|
return voltage_ops->config_set(sreg->ph, sreg->id,
|
|
SCMI_VOLTAGE_ARCH_STATE_ON);
|
|
}
|
|
|
|
static int scmi_reg_disable(struct regulator_dev *rdev)
|
|
{
|
|
struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
|
|
|
|
return voltage_ops->config_set(sreg->ph, sreg->id,
|
|
SCMI_VOLTAGE_ARCH_STATE_OFF);
|
|
}
|
|
|
|
static int scmi_reg_is_enabled(struct regulator_dev *rdev)
|
|
{
|
|
int ret;
|
|
u32 config;
|
|
struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
|
|
|
|
ret = voltage_ops->config_get(sreg->ph, sreg->id, &config);
|
|
if (ret) {
|
|
dev_err(&sreg->sdev->dev,
|
|
"Error %d reading regulator %s status.\n",
|
|
ret, sreg->desc.name);
|
|
return ret;
|
|
}
|
|
|
|
return config & SCMI_VOLTAGE_ARCH_STATE_ON;
|
|
}
|
|
|
|
static int scmi_reg_get_voltage_sel(struct regulator_dev *rdev)
|
|
{
|
|
int ret;
|
|
s32 volt_uV;
|
|
struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
|
|
|
|
ret = voltage_ops->level_get(sreg->ph, sreg->id, &volt_uV);
|
|
if (ret)
|
|
return ret;
|
|
|
|
return sreg->desc.ops->map_voltage(rdev, volt_uV, volt_uV);
|
|
}
|
|
|
|
static int scmi_reg_set_voltage_sel(struct regulator_dev *rdev,
|
|
unsigned int selector)
|
|
{
|
|
s32 volt_uV;
|
|
struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
|
|
|
|
volt_uV = sreg->desc.ops->list_voltage(rdev, selector);
|
|
if (volt_uV <= 0)
|
|
return -EINVAL;
|
|
|
|
return voltage_ops->level_set(sreg->ph, sreg->id, 0x0, volt_uV);
|
|
}
|
|
|
|
static const struct regulator_ops scmi_reg_fixed_ops = {
|
|
.enable = scmi_reg_enable,
|
|
.disable = scmi_reg_disable,
|
|
.is_enabled = scmi_reg_is_enabled,
|
|
};
|
|
|
|
static const struct regulator_ops scmi_reg_linear_ops = {
|
|
.enable = scmi_reg_enable,
|
|
.disable = scmi_reg_disable,
|
|
.is_enabled = scmi_reg_is_enabled,
|
|
.get_voltage_sel = scmi_reg_get_voltage_sel,
|
|
.set_voltage_sel = scmi_reg_set_voltage_sel,
|
|
.list_voltage = regulator_list_voltage_linear,
|
|
.map_voltage = regulator_map_voltage_linear,
|
|
};
|
|
|
|
static const struct regulator_ops scmi_reg_discrete_ops = {
|
|
.enable = scmi_reg_enable,
|
|
.disable = scmi_reg_disable,
|
|
.is_enabled = scmi_reg_is_enabled,
|
|
.get_voltage_sel = scmi_reg_get_voltage_sel,
|
|
.set_voltage_sel = scmi_reg_set_voltage_sel,
|
|
.list_voltage = regulator_list_voltage_table,
|
|
.map_voltage = regulator_map_voltage_iterate,
|
|
};
|
|
|
|
static int
|
|
scmi_config_linear_regulator_mappings(struct scmi_regulator *sreg,
|
|
const struct scmi_voltage_info *vinfo)
|
|
{
|
|
s32 delta_uV;
|
|
|
|
/*
|
|
* Note that SCMI voltage domains describable by linear ranges
|
|
* (segments) {low, high, step} are guaranteed to come in one single
|
|
* triplet by the SCMI Voltage Domain protocol support itself.
|
|
*/
|
|
|
|
delta_uV = (vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_HIGH] -
|
|
vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW]);
|
|
|
|
/* Rule out buggy negative-intervals answers from fw */
|
|
if (delta_uV < 0) {
|
|
dev_err(&sreg->sdev->dev,
|
|
"Invalid volt-range %d-%duV for domain %d\n",
|
|
vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW],
|
|
vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_HIGH],
|
|
sreg->id);
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (!delta_uV) {
|
|
/* Just one fixed voltage exposed by SCMI */
|
|
sreg->desc.fixed_uV =
|
|
vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW];
|
|
sreg->desc.n_voltages = 1;
|
|
sreg->desc.ops = &scmi_reg_fixed_ops;
|
|
} else {
|
|
/* One simple linear mapping. */
|
|
sreg->desc.min_uV =
|
|
vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW];
|
|
sreg->desc.uV_step =
|
|
vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_STEP];
|
|
sreg->desc.linear_min_sel = 0;
|
|
sreg->desc.n_voltages = (delta_uV / sreg->desc.uV_step) + 1;
|
|
sreg->desc.ops = &scmi_reg_linear_ops;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
scmi_config_discrete_regulator_mappings(struct scmi_regulator *sreg,
|
|
const struct scmi_voltage_info *vinfo)
|
|
{
|
|
/* Discrete non linear levels are mapped to volt_table */
|
|
sreg->desc.n_voltages = vinfo->num_levels;
|
|
|
|
if (sreg->desc.n_voltages > 1) {
|
|
sreg->desc.volt_table = (const unsigned int *)vinfo->levels_uv;
|
|
sreg->desc.ops = &scmi_reg_discrete_ops;
|
|
} else {
|
|
sreg->desc.fixed_uV = vinfo->levels_uv[0];
|
|
sreg->desc.ops = &scmi_reg_fixed_ops;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int scmi_regulator_common_init(struct scmi_regulator *sreg)
|
|
{
|
|
int ret;
|
|
struct device *dev = &sreg->sdev->dev;
|
|
const struct scmi_voltage_info *vinfo;
|
|
|
|
vinfo = voltage_ops->info_get(sreg->ph, sreg->id);
|
|
if (!vinfo) {
|
|
dev_warn(dev, "Failure to get voltage domain %d\n",
|
|
sreg->id);
|
|
return -ENODEV;
|
|
}
|
|
|
|
/*
|
|
* Regulator framework does not fully support negative voltages
|
|
* so we discard any voltage domain reported as supporting negative
|
|
* voltages: as a consequence each levels_uv entry is guaranteed to
|
|
* be non-negative from here on.
|
|
*/
|
|
if (vinfo->negative_volts_allowed) {
|
|
dev_warn(dev, "Negative voltages NOT supported...skip %s\n",
|
|
sreg->of_node->full_name);
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
sreg->desc.name = devm_kasprintf(dev, GFP_KERNEL, "%s", vinfo->name);
|
|
if (!sreg->desc.name)
|
|
return -ENOMEM;
|
|
|
|
sreg->desc.id = sreg->id;
|
|
sreg->desc.type = REGULATOR_VOLTAGE;
|
|
sreg->desc.owner = THIS_MODULE;
|
|
sreg->desc.of_match_full_name = true;
|
|
sreg->desc.of_match = sreg->of_node->full_name;
|
|
sreg->desc.regulators_node = "regulators";
|
|
if (vinfo->segmented)
|
|
ret = scmi_config_linear_regulator_mappings(sreg, vinfo);
|
|
else
|
|
ret = scmi_config_discrete_regulator_mappings(sreg, vinfo);
|
|
if (ret)
|
|
return ret;
|
|
|
|
/*
|
|
* Using the scmi device here to have DT searched from Voltage
|
|
* protocol node down.
|
|
*/
|
|
sreg->conf.dev = dev;
|
|
|
|
/* Store for later retrieval via rdev_get_drvdata() */
|
|
sreg->conf.driver_data = sreg;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int process_scmi_regulator_of_node(struct scmi_device *sdev,
|
|
struct scmi_protocol_handle *ph,
|
|
struct device_node *np,
|
|
struct scmi_regulator_info *rinfo)
|
|
{
|
|
u32 dom, ret;
|
|
|
|
ret = of_property_read_u32(np, "reg", &dom);
|
|
if (ret)
|
|
return ret;
|
|
|
|
if (dom >= rinfo->num_doms)
|
|
return -ENODEV;
|
|
|
|
if (rinfo->sregv[dom]) {
|
|
dev_err(&sdev->dev,
|
|
"SCMI Voltage Domain %d already in use. Skipping: %s\n",
|
|
dom, np->full_name);
|
|
return -EINVAL;
|
|
}
|
|
|
|
rinfo->sregv[dom] = devm_kzalloc(&sdev->dev,
|
|
sizeof(struct scmi_regulator),
|
|
GFP_KERNEL);
|
|
if (!rinfo->sregv[dom])
|
|
return -ENOMEM;
|
|
|
|
rinfo->sregv[dom]->id = dom;
|
|
rinfo->sregv[dom]->sdev = sdev;
|
|
rinfo->sregv[dom]->ph = ph;
|
|
|
|
/* get hold of good nodes */
|
|
of_node_get(np);
|
|
rinfo->sregv[dom]->of_node = np;
|
|
|
|
dev_dbg(&sdev->dev,
|
|
"Found SCMI Regulator entry -- OF node [%d] -> %s\n",
|
|
dom, np->full_name);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int scmi_regulator_probe(struct scmi_device *sdev)
|
|
{
|
|
int d, ret, num_doms;
|
|
struct device_node *np, *child;
|
|
const struct scmi_handle *handle = sdev->handle;
|
|
struct scmi_regulator_info *rinfo;
|
|
struct scmi_protocol_handle *ph;
|
|
|
|
if (!handle)
|
|
return -ENODEV;
|
|
|
|
voltage_ops = handle->devm_protocol_get(sdev,
|
|
SCMI_PROTOCOL_VOLTAGE, &ph);
|
|
if (IS_ERR(voltage_ops))
|
|
return PTR_ERR(voltage_ops);
|
|
|
|
num_doms = voltage_ops->num_domains_get(ph);
|
|
if (num_doms <= 0) {
|
|
if (!num_doms) {
|
|
dev_err(&sdev->dev,
|
|
"number of voltage domains invalid\n");
|
|
num_doms = -EINVAL;
|
|
} else {
|
|
dev_err(&sdev->dev,
|
|
"failed to get voltage domains - err:%d\n",
|
|
num_doms);
|
|
}
|
|
|
|
return num_doms;
|
|
}
|
|
|
|
rinfo = devm_kzalloc(&sdev->dev, sizeof(*rinfo), GFP_KERNEL);
|
|
if (!rinfo)
|
|
return -ENOMEM;
|
|
|
|
/* Allocate pointers array for all possible domains */
|
|
rinfo->sregv = devm_kcalloc(&sdev->dev, num_doms,
|
|
sizeof(void *), GFP_KERNEL);
|
|
if (!rinfo->sregv)
|
|
return -ENOMEM;
|
|
|
|
rinfo->num_doms = num_doms;
|
|
|
|
/*
|
|
* Start collecting into rinfo->sregv possibly good SCMI Regulators as
|
|
* described by a well-formed DT entry and associated with an existing
|
|
* plausible SCMI Voltage Domain number, all belonging to this SCMI
|
|
* platform instance node (handle->dev->of_node).
|
|
*/
|
|
np = of_find_node_by_name(handle->dev->of_node, "regulators");
|
|
for_each_child_of_node(np, child) {
|
|
ret = process_scmi_regulator_of_node(sdev, ph, child, rinfo);
|
|
/* abort on any mem issue */
|
|
if (ret == -ENOMEM) {
|
|
of_node_put(child);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Register a regulator for each valid regulator-DT-entry that we
|
|
* can successfully reach via SCMI and has a valid associated voltage
|
|
* domain.
|
|
*/
|
|
for (d = 0; d < num_doms; d++) {
|
|
struct scmi_regulator *sreg = rinfo->sregv[d];
|
|
|
|
/* Skip empty slots */
|
|
if (!sreg)
|
|
continue;
|
|
|
|
ret = scmi_regulator_common_init(sreg);
|
|
/* Skip invalid voltage domains */
|
|
if (ret)
|
|
continue;
|
|
|
|
sreg->rdev = devm_regulator_register(&sdev->dev, &sreg->desc,
|
|
&sreg->conf);
|
|
if (IS_ERR(sreg->rdev)) {
|
|
sreg->rdev = NULL;
|
|
continue;
|
|
}
|
|
|
|
dev_info(&sdev->dev,
|
|
"Regulator %s registered for domain [%d]\n",
|
|
sreg->desc.name, sreg->id);
|
|
}
|
|
|
|
dev_set_drvdata(&sdev->dev, rinfo);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void scmi_regulator_remove(struct scmi_device *sdev)
|
|
{
|
|
int d;
|
|
struct scmi_regulator_info *rinfo;
|
|
|
|
rinfo = dev_get_drvdata(&sdev->dev);
|
|
if (!rinfo)
|
|
return;
|
|
|
|
for (d = 0; d < rinfo->num_doms; d++) {
|
|
if (!rinfo->sregv[d])
|
|
continue;
|
|
of_node_put(rinfo->sregv[d]->of_node);
|
|
}
|
|
}
|
|
|
|
static const struct scmi_device_id scmi_regulator_id_table[] = {
|
|
{ SCMI_PROTOCOL_VOLTAGE, "regulator" },
|
|
{ },
|
|
};
|
|
MODULE_DEVICE_TABLE(scmi, scmi_regulator_id_table);
|
|
|
|
static struct scmi_driver scmi_drv = {
|
|
.name = "scmi-regulator",
|
|
.probe = scmi_regulator_probe,
|
|
.remove = scmi_regulator_remove,
|
|
.id_table = scmi_regulator_id_table,
|
|
};
|
|
|
|
module_scmi_driver(scmi_drv);
|
|
|
|
MODULE_AUTHOR("Cristian Marussi <cristian.marussi@arm.com>");
|
|
MODULE_DESCRIPTION("ARM SCMI regulator driver");
|
|
MODULE_LICENSE("GPL v2");
|