[mirror_ubuntu-jammy-kernel.git] / drivers / regulator / scmi-regulator.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");
Commit	Line	Data
0fbeae70 CM	1	// SPDX-License-Identifier: GPL-2.0
	2	//
	3	// System Control and Management Interface (SCMI) based regulator driver
	4	//
59046d15	5	// Copyright (C) 2020-2021 ARM Ltd.
0fbeae70 CM	6	//
	7	// Implements a regulator driver on top of the SCMI Voltage Protocol.
	8	//
	9	// The ARM SCMI Protocol aims in general to hide as much as possible all the
	10	// underlying operational details while providing an abstracted interface for
	11	// its users to operate upon: as a consequence the resulting operational
	12	// capabilities and configurability of this regulator device are much more
	13	// limited than the ones usually available on a standard physical regulator.
	14	//
	15	// The supported SCMI regulator ops are restricted to the bare minimum:
	16	//
	17	// - 'status_ops': enable/disable/is_enabled
	18	// - 'voltage_ops': get_voltage_sel/set_voltage_sel
	19	// list_voltage/map_voltage
	20	//
	21	// Each SCMI regulator instance is associated, through the means of a proper DT
	22	// entry description, to a specific SCMI Voltage Domain.
	23
	24	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	25
	26	#include <linux/linear_range.h>
	27	#include <linux/module.h>
	28	#include <linux/of.h>
	29	#include <linux/regulator/driver.h>
	30	#include <linux/regulator/machine.h>
	31	#include <linux/regulator/of_regulator.h>
	32	#include <linux/scmi_protocol.h>
	33	#include <linux/slab.h>
	34	#include <linux/types.h>
	35
59046d15 CM	36	static const struct scmi_voltage_proto_ops *voltage_ops;
59046d15 CM	37
0fbeae70 CM	38	struct scmi_regulator {
	39	u32 id;
	40	struct scmi_device *sdev;
59046d15	41	struct scmi_protocol_handle *ph;
0fbeae70 CM	42	struct regulator_dev *rdev;
	43	struct device_node *of_node;
	44	struct regulator_desc desc;
	45	struct regulator_config conf;
	46	};
	47
	48	struct scmi_regulator_info {
	49	int num_doms;
	50	struct scmi_regulator **sregv;
	51	};
	52
	53	static int scmi_reg_enable(struct regulator_dev *rdev)
	54	{
	55	struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
0fbeae70	56
59046d15 CM	57	return voltage_ops->config_set(sreg->ph, sreg->id,
59046d15 CM	58	SCMI_VOLTAGE_ARCH_STATE_ON);
0fbeae70 CM	59	}
	60
	61	static int scmi_reg_disable(struct regulator_dev *rdev)
	62	{
	63	struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
0fbeae70	64
59046d15 CM	65	return voltage_ops->config_set(sreg->ph, sreg->id,
59046d15 CM	66	SCMI_VOLTAGE_ARCH_STATE_OFF);
0fbeae70 CM	67	}
	68
	69	static int scmi_reg_is_enabled(struct regulator_dev *rdev)
	70	{
	71	int ret;
	72	u32 config;
	73	struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
0fbeae70	74
59046d15	75	ret = voltage_ops->config_get(sreg->ph, sreg->id, &config);
0fbeae70 CM	76	if (ret) {
	77	dev_err(&sreg->sdev->dev,
	78	"Error %d reading regulator %s status.\n",
	79	ret, sreg->desc.name);
	80	return ret;
	81	}
	82
	83	return config & SCMI_VOLTAGE_ARCH_STATE_ON;
	84	}
	85
	86	static int scmi_reg_get_voltage_sel(struct regulator_dev *rdev)
	87	{
	88	int ret;
	89	s32 volt_uV;
	90	struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
0fbeae70	91
59046d15	92	ret = voltage_ops->level_get(sreg->ph, sreg->id, &volt_uV);
0fbeae70 CM	93	if (ret)
	94	return ret;
	95
	96	return sreg->desc.ops->map_voltage(rdev, volt_uV, volt_uV);
	97	}
	98
	99	static int scmi_reg_set_voltage_sel(struct regulator_dev *rdev,
	100	unsigned int selector)
	101	{
	102	s32 volt_uV;
	103	struct scmi_regulator *sreg = rdev_get_drvdata(rdev);
0fbeae70 CM	104
	105	volt_uV = sreg->desc.ops->list_voltage(rdev, selector);
	106	if (volt_uV <= 0)
	107	return -EINVAL;
	108
59046d15	109	return voltage_ops->level_set(sreg->ph, sreg->id, 0x0, volt_uV);
0fbeae70 CM	110	}
	111
	112	static const struct regulator_ops scmi_reg_fixed_ops = {
	113	.enable = scmi_reg_enable,
	114	.disable = scmi_reg_disable,
	115	.is_enabled = scmi_reg_is_enabled,
	116	};
	117
	118	static const struct regulator_ops scmi_reg_linear_ops = {
	119	.enable = scmi_reg_enable,
	120	.disable = scmi_reg_disable,
	121	.is_enabled = scmi_reg_is_enabled,
	122	.get_voltage_sel = scmi_reg_get_voltage_sel,
	123	.set_voltage_sel = scmi_reg_set_voltage_sel,
	124	.list_voltage = regulator_list_voltage_linear,
	125	.map_voltage = regulator_map_voltage_linear,
	126	};
	127
	128	static const struct regulator_ops scmi_reg_discrete_ops = {
	129	.enable = scmi_reg_enable,
	130	.disable = scmi_reg_disable,
	131	.is_enabled = scmi_reg_is_enabled,
	132	.get_voltage_sel = scmi_reg_get_voltage_sel,
	133	.set_voltage_sel = scmi_reg_set_voltage_sel,
	134	.list_voltage = regulator_list_voltage_table,
	135	.map_voltage = regulator_map_voltage_iterate,
	136	};
	137
	138	static int
	139	scmi_config_linear_regulator_mappings(struct scmi_regulator *sreg,
	140	const struct scmi_voltage_info *vinfo)
	141	{
	142	s32 delta_uV;
	143
	144	/*
	145	* Note that SCMI voltage domains describable by linear ranges
	146	* (segments) {low, high, step} are guaranteed to come in one single
	147	* triplet by the SCMI Voltage Domain protocol support itself.
	148	*/
	149
	150	delta_uV = (vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_HIGH] -
	151	vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW]);
	152
	153	/* Rule out buggy negative-intervals answers from fw */
	154	if (delta_uV < 0) {
	155	dev_err(&sreg->sdev->dev,
	156	"Invalid volt-range %d-%duV for domain %d\n",
	157	vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW],
	158	vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_HIGH],
	159	sreg->id);
	160	return -EINVAL;
	161	}
	162
	163	if (!delta_uV) {
	164	/* Just one fixed voltage exposed by SCMI */
	165	sreg->desc.fixed_uV =
	166	vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW];
	167	sreg->desc.n_voltages = 1;
	168	sreg->desc.ops = &scmi_reg_fixed_ops;
	169	} else {
	170	/* One simple linear mapping. */
	171	sreg->desc.min_uV =
	172	vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_LOW];
	173	sreg->desc.uV_step =
174	vinfo->levels_uv[SCMI_VOLTAGE_SEGMENT_STEP];
175	sreg->desc.linear_min_sel = 0;
36cb555f	176	sreg->desc.n_voltages = (delta_uV / sreg->desc.uV_step) + 1;
0fbeae70 CM	177	sreg->desc.ops = &scmi_reg_linear_ops;
	178	}
	179
	180	return 0;
	181	}
	182
	183	static int
	184	scmi_config_discrete_regulator_mappings(struct scmi_regulator *sreg,
	185	const struct scmi_voltage_info *vinfo)
	186	{
	187	/* Discrete non linear levels are mapped to volt_table */
	188	sreg->desc.n_voltages = vinfo->num_levels;
	189
	190	if (sreg->desc.n_voltages > 1) {
	191	sreg->desc.volt_table = (const unsigned int *)vinfo->levels_uv;
	192	sreg->desc.ops = &scmi_reg_discrete_ops;
	193	} else {
	194	sreg->desc.fixed_uV = vinfo->levels_uv[0];
	195	sreg->desc.ops = &scmi_reg_fixed_ops;
	196	}
	197
	198	return 0;
	199	}
	200
	201	static int scmi_regulator_common_init(struct scmi_regulator *sreg)
	202	{
	203	int ret;
0fbeae70 CM	204	struct device *dev = &sreg->sdev->dev;
	205	const struct scmi_voltage_info *vinfo;
	206
59046d15	207	vinfo = voltage_ops->info_get(sreg->ph, sreg->id);
0fbeae70 CM	208	if (!vinfo) {
	209	dev_warn(dev, "Failure to get voltage domain %d\n",
	210	sreg->id);
	211	return -ENODEV;
	212	}
	213
	214	/*
	215	* Regulator framework does not fully support negative voltages
	216	* so we discard any voltage domain reported as supporting negative
	217	* voltages: as a consequence each levels_uv entry is guaranteed to
	218	* be non-negative from here on.
	219	*/
	220	if (vinfo->negative_volts_allowed) {
	221	dev_warn(dev, "Negative voltages NOT supported...skip %s\n",
	222	sreg->of_node->full_name);
	223	return -EOPNOTSUPP;
	224	}
	225
	226	sreg->desc.name = devm_kasprintf(dev, GFP_KERNEL, "%s", vinfo->name);
	227	if (!sreg->desc.name)
	228	return -ENOMEM;
	229
	230	sreg->desc.id = sreg->id;
	231	sreg->desc.type = REGULATOR_VOLTAGE;
	232	sreg->desc.owner = THIS_MODULE;
	233	sreg->desc.of_match_full_name = true;
	234	sreg->desc.of_match = sreg->of_node->full_name;
	235	sreg->desc.regulators_node = "regulators";
	236	if (vinfo->segmented)
	237	ret = scmi_config_linear_regulator_mappings(sreg, vinfo);
	238	else
	239	ret = scmi_config_discrete_regulator_mappings(sreg, vinfo);
	240	if (ret)
	241	return ret;
	242
	243	/*
	244	* Using the scmi device here to have DT searched from Voltage
	245	* protocol node down.
	246	*/
	247	sreg->conf.dev = dev;
	248
	249	/* Store for later retrieval via rdev_get_drvdata() */
	250	sreg->conf.driver_data = sreg;
	251
	252	return 0;
	253	}
	254
	255	static int process_scmi_regulator_of_node(struct scmi_device *sdev,
59046d15	256	struct scmi_protocol_handle *ph,
0fbeae70 CM	257	struct device_node *np,
	258	struct scmi_regulator_info *rinfo)
	259	{
	260	u32 dom, ret;
	261
	262	ret = of_property_read_u32(np, "reg", &dom);
	263	if (ret)
	264	return ret;
	265
	266	if (dom >= rinfo->num_doms)
	267	return -ENODEV;
	268
	269	if (rinfo->sregv[dom]) {
	270	dev_err(&sdev->dev,
	271	"SCMI Voltage Domain %d already in use. Skipping: %s\n",
	272	dom, np->full_name);
	273	return -EINVAL;
	274	}
	275
	276	rinfo->sregv[dom] = devm_kzalloc(&sdev->dev,
	277	sizeof(struct scmi_regulator),
	278	GFP_KERNEL);
	279	if (!rinfo->sregv[dom])
	280	return -ENOMEM;
	281
	282	rinfo->sregv[dom]->id = dom;
	283	rinfo->sregv[dom]->sdev = sdev;
59046d15	284	rinfo->sregv[dom]->ph = ph;
0fbeae70 CM	285
	286	/* get hold of good nodes */
	287	of_node_get(np);
	288	rinfo->sregv[dom]->of_node = np;
	289
	290	dev_dbg(&sdev->dev,
	291	"Found SCMI Regulator entry -- OF node [%d] -> %s\n",
	292	dom, np->full_name);
	293
	294	return 0;
	295	}
	296
	297	static int scmi_regulator_probe(struct scmi_device *sdev)
	298	{
	299	int d, ret, num_doms;
	300	struct device_node np, child;
	301	const struct scmi_handle *handle = sdev->handle;
	302	struct scmi_regulator_info *rinfo;
59046d15	303	struct scmi_protocol_handle *ph;
0fbeae70	304
59046d15	305	if (!handle)
0fbeae70 CM	306	return -ENODEV;
0fbeae70 CM	307
59046d15 CM	308	voltage_ops = handle->devm_protocol_get(sdev,
	309	SCMI_PROTOCOL_VOLTAGE, &ph);
	310	if (IS_ERR(voltage_ops))
	311	return PTR_ERR(voltage_ops);
	312
	313	num_doms = voltage_ops->num_domains_get(ph);
0fbeae70 CM	314	if (num_doms <= 0) {
	315	if (!num_doms) {
	316	dev_err(&sdev->dev,
	317	"number of voltage domains invalid\n");
	318	num_doms = -EINVAL;
	319	} else {
	320	dev_err(&sdev->dev,
	321	"failed to get voltage domains - err:%d\n",
	322	num_doms);
	323	}
	324
	325	return num_doms;
	326	}
	327
	328	rinfo = devm_kzalloc(&sdev->dev, sizeof(*rinfo), GFP_KERNEL);
	329	if (!rinfo)
	330	return -ENOMEM;
	331
	332	/* Allocate pointers array for all possible domains */
	333	rinfo->sregv = devm_kcalloc(&sdev->dev, num_doms,
	334	sizeof(void *), GFP_KERNEL);
	335	if (!rinfo->sregv)
	336	return -ENOMEM;
	337
	338	rinfo->num_doms = num_doms;
	339
	340	/*
	341	* Start collecting into rinfo->sregv possibly good SCMI Regulators as
	342	* described by a well-formed DT entry and associated with an existing
	343	* plausible SCMI Voltage Domain number, all belonging to this SCMI
	344	* platform instance node (handle->dev->of_node).
	345	*/
	346	np = of_find_node_by_name(handle->dev->of_node, "regulators");
	347	for_each_child_of_node(np, child) {
59046d15	348	ret = process_scmi_regulator_of_node(sdev, ph, child, rinfo);
0fbeae70	349	/* abort on any mem issue */
45ee8b79 YL	350	if (ret == -ENOMEM) {
45ee8b79 YL	351	of_node_put(child);
0fbeae70	352	return ret;
45ee8b79	353	}
0fbeae70 CM	354	}
	355
	356	/*
	357	* Register a regulator for each valid regulator-DT-entry that we
	358	* can successfully reach via SCMI and has a valid associated voltage
	359	* domain.
	360	*/
	361	for (d = 0; d < num_doms; d++) {
	362	struct scmi_regulator *sreg = rinfo->sregv[d];
	363
	364	/* Skip empty slots */
	365	if (!sreg)
	366	continue;
	367
	368	ret = scmi_regulator_common_init(sreg);
	369	/* Skip invalid voltage domains */
	370	if (ret)
	371	continue;
	372
	373	sreg->rdev = devm_regulator_register(&sdev->dev, &sreg->desc,
	374	&sreg->conf);
	375	if (IS_ERR(sreg->rdev)) {
	376	sreg->rdev = NULL;
	377	continue;
	378	}
	379
	380	dev_info(&sdev->dev,
	381	"Regulator %s registered for domain [%d]\n",
	382	sreg->desc.name, sreg->id);
	383	}
	384
	385	dev_set_drvdata(&sdev->dev, rinfo);
	386
	387	return 0;
	388	}
	389
	390	static void scmi_regulator_remove(struct scmi_device *sdev)
	391	{
	392	int d;
	393	struct scmi_regulator_info *rinfo;
	394
	395	rinfo = dev_get_drvdata(&sdev->dev);
	396	if (!rinfo)
	397	return;
	398
	399	for (d = 0; d < rinfo->num_doms; d++) {
	400	if (!rinfo->sregv[d])
	401	continue;
	402	of_node_put(rinfo->sregv[d]->of_node);
	403	}
	404	}
	405
	406	static const struct scmi_device_id scmi_regulator_id_table[] = {
	407	{ SCMI_PROTOCOL_VOLTAGE, "regulator" },
	408	{ },
	409	};
	410	MODULE_DEVICE_TABLE(scmi, scmi_regulator_id_table);
	411
	412	static struct scmi_driver scmi_drv = {
	413	.name = "scmi-regulator",
	414	.probe = scmi_regulator_probe,
	415	.remove = scmi_regulator_remove,
	416	.id_table = scmi_regulator_id_table,
	417	};
418
419	module_scmi_driver(scmi_drv);
420
421	MODULE_AUTHOR("Cristian Marussi <cristian.marussi@arm.com>");
422	MODULE_DESCRIPTION("ARM SCMI regulator driver");
423	MODULE_LICENSE("GPL v2");