[linux-2.6-block.git] / drivers / regulator / vctrl-regulator.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Driver for voltage controller regulators
 *
 * Copyright (C) 2017 Google, Inc.
 */

#include <linux/delay.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/of_regulator.h>
#include <linux/sort.h>

struct vctrl_voltage_range {
	int min_uV;
	int max_uV;
};

struct vctrl_voltage_ranges {
	struct vctrl_voltage_range ctrl;
	struct vctrl_voltage_range out;
};

struct vctrl_voltage_table {
	int ctrl;
	int out;
	int ovp_min_sel;
};

struct vctrl_data {
	struct regulator_dev *rdev;
	struct regulator_desc desc;
	struct regulator *ctrl_reg;
	bool enabled;
	unsigned int min_slew_down_rate;
	unsigned int ovp_threshold;
	struct vctrl_voltage_ranges vrange;
	struct vctrl_voltage_table *vtable;
	unsigned int sel;
};

static int vctrl_calc_ctrl_voltage(struct vctrl_data *vctrl, int out_uV)
{
	struct vctrl_voltage_range *ctrl = &vctrl->vrange.ctrl;
	struct vctrl_voltage_range *out = &vctrl->vrange.out;

	return ctrl->min_uV +
		DIV_ROUND_CLOSEST_ULL((s64)(out_uV - out->min_uV) *
				      (ctrl->max_uV - ctrl->min_uV),
				      out->max_uV - out->min_uV);
}

static int vctrl_calc_output_voltage(struct vctrl_data *vctrl, int ctrl_uV)
{
	struct vctrl_voltage_range *ctrl = &vctrl->vrange.ctrl;
	struct vctrl_voltage_range *out = &vctrl->vrange.out;

	if (ctrl_uV < 0) {
		pr_err("vctrl: failed to get control voltage\n");
		return ctrl_uV;
	}

	if (ctrl_uV < ctrl->min_uV)
		return out->min_uV;

	if (ctrl_uV > ctrl->max_uV)
		return out->max_uV;

	return out->min_uV +
		DIV_ROUND_CLOSEST_ULL((s64)(ctrl_uV - ctrl->min_uV) *
				      (out->max_uV - out->min_uV),
				      ctrl->max_uV - ctrl->min_uV);
}

static int vctrl_get_voltage(struct regulator_dev *rdev)
{
	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
	int ctrl_uV = regulator_get_voltage(vctrl->ctrl_reg);

	return vctrl_calc_output_voltage(vctrl, ctrl_uV);
}

static int vctrl_set_voltage(struct regulator_dev *rdev,
			     int req_min_uV, int req_max_uV,
			     unsigned int *selector)
{
	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
	struct regulator *ctrl_reg = vctrl->ctrl_reg;
	int orig_ctrl_uV = regulator_get_voltage(ctrl_reg);
	int uV = vctrl_calc_output_voltage(vctrl, orig_ctrl_uV);
	int ret;

	if (req_min_uV >= uV || !vctrl->ovp_threshold)
		/* voltage rising or no OVP */
		return regulator_set_voltage(
			ctrl_reg,
			vctrl_calc_ctrl_voltage(vctrl, req_min_uV),
			vctrl_calc_ctrl_voltage(vctrl, req_max_uV));

	while (uV > req_min_uV) {
		int max_drop_uV = (uV * vctrl->ovp_threshold) / 100;
		int next_uV;
		int next_ctrl_uV;
		int delay;

		/* Make sure no infinite loop even in crazy cases */
		if (max_drop_uV == 0)
			max_drop_uV = 1;

		next_uV = max_t(int, req_min_uV, uV - max_drop_uV);
		next_ctrl_uV = vctrl_calc_ctrl_voltage(vctrl, next_uV);

		ret = regulator_set_voltage(ctrl_reg,
					    next_ctrl_uV,
					    next_ctrl_uV);
		if (ret)
			goto err;

		delay = DIV_ROUND_UP(uV - next_uV, vctrl->min_slew_down_rate);
		usleep_range(delay, delay + DIV_ROUND_UP(delay, 10));

		uV = next_uV;
	}

	return 0;

err:
	/* Try to go back to original voltage */
	regulator_set_voltage(ctrl_reg, orig_ctrl_uV, orig_ctrl_uV);

	return ret;
}

static int vctrl_get_voltage_sel(struct regulator_dev *rdev)
{
	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);

	return vctrl->sel;
}

static int vctrl_set_voltage_sel(struct regulator_dev *rdev,
				 unsigned int selector)
{
	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
	struct regulator *ctrl_reg = vctrl->ctrl_reg;
	unsigned int orig_sel = vctrl->sel;
	int ret;

	if (selector >= rdev->desc->n_voltages)
		return -EINVAL;

	if (selector >= vctrl->sel || !vctrl->ovp_threshold) {
		/* voltage rising or no OVP */
		ret = regulator_set_voltage(ctrl_reg,
					    vctrl->vtable[selector].ctrl,
					    vctrl->vtable[selector].ctrl);
		if (!ret)
			vctrl->sel = selector;

		return ret;
	}

	while (vctrl->sel != selector) {
		unsigned int next_sel;
		int delay;

		if (selector >= vctrl->vtable[vctrl->sel].ovp_min_sel)
			next_sel = selector;
		else
			next_sel = vctrl->vtable[vctrl->sel].ovp_min_sel;

		ret = regulator_set_voltage(ctrl_reg,
					    vctrl->vtable[next_sel].ctrl,
					    vctrl->vtable[next_sel].ctrl);
		if (ret) {
			dev_err(&rdev->dev,
				"failed to set control voltage to %duV\n",
				vctrl->vtable[next_sel].ctrl);
			goto err;
		}
		vctrl->sel = next_sel;

		delay = DIV_ROUND_UP(vctrl->vtable[vctrl->sel].out -
				     vctrl->vtable[next_sel].out,
				     vctrl->min_slew_down_rate);
		usleep_range(delay, delay + DIV_ROUND_UP(delay, 10));
	}

	return 0;

err:
	if (vctrl->sel != orig_sel) {
		/* Try to go back to original voltage */
		if (!regulator_set_voltage(ctrl_reg,
					   vctrl->vtable[orig_sel].ctrl,
					   vctrl->vtable[orig_sel].ctrl))
			vctrl->sel = orig_sel;
		else
			dev_warn(&rdev->dev,
				 "failed to restore original voltage\n");
	}

	return ret;
}

static int vctrl_list_voltage(struct regulator_dev *rdev,
			      unsigned int selector)
{
	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);

	if (selector >= rdev->desc->n_voltages)
		return -EINVAL;

	return vctrl->vtable[selector].out;
}

static int vctrl_parse_dt(struct platform_device *pdev,
			  struct vctrl_data *vctrl)
{
	int ret;
	struct device_node *np = pdev->dev.of_node;
	u32 pval;
	u32 vrange_ctrl[2];

	vctrl->ctrl_reg = devm_regulator_get(&pdev->dev, "ctrl");
	if (IS_ERR(vctrl->ctrl_reg))
		return PTR_ERR(vctrl->ctrl_reg);

	ret = of_property_read_u32(np, "ovp-threshold-percent", &pval);
	if (!ret) {
		vctrl->ovp_threshold = pval;
		if (vctrl->ovp_threshold > 100) {
			dev_err(&pdev->dev,
				"ovp-threshold-percent (%u) > 100\n",
				vctrl->ovp_threshold);
			return -EINVAL;
		}
	}

	ret = of_property_read_u32(np, "min-slew-down-rate", &pval);
	if (!ret) {
		vctrl->min_slew_down_rate = pval;

		/* We use the value as int and as divider; sanity check */
		if (vctrl->min_slew_down_rate == 0) {
			dev_err(&pdev->dev,
				"min-slew-down-rate must not be 0\n");
			return -EINVAL;
		} else if (vctrl->min_slew_down_rate > INT_MAX) {
			dev_err(&pdev->dev, "min-slew-down-rate (%u) too big\n",
				vctrl->min_slew_down_rate);
			return -EINVAL;
		}
	}

	if (vctrl->ovp_threshold && !vctrl->min_slew_down_rate) {
		dev_err(&pdev->dev,
			"ovp-threshold-percent requires min-slew-down-rate\n");
		return -EINVAL;
	}

	ret = of_property_read_u32(np, "regulator-min-microvolt", &pval);
	if (ret) {
		dev_err(&pdev->dev,
			"failed to read regulator-min-microvolt: %d\n", ret);
		return ret;
	}
	vctrl->vrange.out.min_uV = pval;

	ret = of_property_read_u32(np, "regulator-max-microvolt", &pval);
	if (ret) {
		dev_err(&pdev->dev,
			"failed to read regulator-max-microvolt: %d\n", ret);
		return ret;
	}
	vctrl->vrange.out.max_uV = pval;

	ret = of_property_read_u32_array(np, "ctrl-voltage-range", vrange_ctrl,
					 2);
	if (ret) {
		dev_err(&pdev->dev, "failed to read ctrl-voltage-range: %d\n",
			ret);
		return ret;
	}

	if (vrange_ctrl[0] >= vrange_ctrl[1]) {
		dev_err(&pdev->dev, "ctrl-voltage-range is invalid: %d-%d\n",
			vrange_ctrl[0], vrange_ctrl[1]);
		return -EINVAL;
	}

	vctrl->vrange.ctrl.min_uV = vrange_ctrl[0];
	vctrl->vrange.ctrl.max_uV = vrange_ctrl[1];

	return 0;
}

static int vctrl_cmp_ctrl_uV(const void *a, const void *b)
{
	const struct vctrl_voltage_table *at = a;
	const struct vctrl_voltage_table *bt = b;

	return at->ctrl - bt->ctrl;
}

static int vctrl_init_vtable(struct platform_device *pdev)
{
	struct vctrl_data *vctrl = platform_get_drvdata(pdev);
	struct regulator_desc *rdesc = &vctrl->desc;
	struct regulator *ctrl_reg = vctrl->ctrl_reg;
	struct vctrl_voltage_range *vrange_ctrl = &vctrl->vrange.ctrl;
	int n_voltages;
	int ctrl_uV;
	int i, idx_vt;

	n_voltages = regulator_count_voltages(ctrl_reg);

	rdesc->n_voltages = n_voltages;

	/* determine number of steps within the range of the vctrl regulator */
	for (i = 0; i < n_voltages; i++) {
		ctrl_uV = regulator_list_voltage(ctrl_reg, i);

		if (ctrl_uV < vrange_ctrl->min_uV ||
		    ctrl_uV > vrange_ctrl->max_uV)
			rdesc->n_voltages--;
	}

	if (rdesc->n_voltages == 0) {
		dev_err(&pdev->dev, "invalid configuration\n");
		return -EINVAL;
	}

	vctrl->vtable = devm_kcalloc(&pdev->dev, rdesc->n_voltages,
				     sizeof(struct vctrl_voltage_table),
				     GFP_KERNEL);
	if (!vctrl->vtable)
		return -ENOMEM;

	/* create mapping control <=> output voltage */
	for (i = 0, idx_vt = 0; i < n_voltages; i++) {
		ctrl_uV = regulator_list_voltage(ctrl_reg, i);

		if (ctrl_uV < vrange_ctrl->min_uV ||
		    ctrl_uV > vrange_ctrl->max_uV)
			continue;

		vctrl->vtable[idx_vt].ctrl = ctrl_uV;
		vctrl->vtable[idx_vt].out =
			vctrl_calc_output_voltage(vctrl, ctrl_uV);
		idx_vt++;
	}

	/* we rely on the table to be ordered by ascending voltage */
	sort(vctrl->vtable, rdesc->n_voltages,
	     sizeof(struct vctrl_voltage_table), vctrl_cmp_ctrl_uV,
	     NULL);

	/* pre-calculate OVP-safe downward transitions */
	for (i = rdesc->n_voltages - 1; i > 0; i--) {
		int j;
		int ovp_min_uV = (vctrl->vtable[i].out *
				  (100 - vctrl->ovp_threshold)) / 100;

		for (j = 0; j < i; j++) {
			if (vctrl->vtable[j].out >= ovp_min_uV) {
				vctrl->vtable[i].ovp_min_sel = j;
				break;
			}
		}

		if (j == i) {
			dev_warn(&pdev->dev, "switching down from %duV may cause OVP shutdown\n",
				vctrl->vtable[i].out);
			/* use next lowest voltage */
			vctrl->vtable[i].ovp_min_sel = i - 1;
		}
	}

	return 0;
}

static int vctrl_enable(struct regulator_dev *rdev)
{
	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
	int ret = regulator_enable(vctrl->ctrl_reg);

	if (!ret)
		vctrl->enabled = true;

	return ret;
}

static int vctrl_disable(struct regulator_dev *rdev)
{
	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
	int ret = regulator_disable(vctrl->ctrl_reg);

	if (!ret)
		vctrl->enabled = false;

	return ret;
}

static int vctrl_is_enabled(struct regulator_dev *rdev)
{
	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);

	return vctrl->enabled;
}

static const struct regulator_ops vctrl_ops_cont = {
	.enable		  = vctrl_enable,
	.disable	  = vctrl_disable,
	.is_enabled	  = vctrl_is_enabled,
	.get_voltage	  = vctrl_get_voltage,
	.set_voltage	  = vctrl_set_voltage,
};

static const struct regulator_ops vctrl_ops_non_cont = {
	.enable		  = vctrl_enable,
	.disable	  = vctrl_disable,
	.is_enabled	  = vctrl_is_enabled,
	.set_voltage_sel = vctrl_set_voltage_sel,
	.get_voltage_sel = vctrl_get_voltage_sel,
	.list_voltage    = vctrl_list_voltage,
	.map_voltage     = regulator_map_voltage_iterate,
};

static int vctrl_probe(struct platform_device *pdev)
{
	struct device_node *np = pdev->dev.of_node;
	struct vctrl_data *vctrl;
	const struct regulator_init_data *init_data;
	struct regulator_desc *rdesc;
	struct regulator_config cfg = { };
	struct vctrl_voltage_range *vrange_ctrl;
	int ctrl_uV;
	int ret;

	vctrl = devm_kzalloc(&pdev->dev, sizeof(struct vctrl_data),
			     GFP_KERNEL);
	if (!vctrl)
		return -ENOMEM;

	platform_set_drvdata(pdev, vctrl);

	ret = vctrl_parse_dt(pdev, vctrl);
	if (ret)
		return ret;

	vrange_ctrl = &vctrl->vrange.ctrl;

	rdesc = &vctrl->desc;
	rdesc->name = "vctrl";
	rdesc->type = REGULATOR_VOLTAGE;
	rdesc->owner = THIS_MODULE;

	if ((regulator_get_linear_step(vctrl->ctrl_reg) == 1) ||
	    (regulator_count_voltages(vctrl->ctrl_reg) == -EINVAL)) {
		rdesc->continuous_voltage_range = true;
		rdesc->ops = &vctrl_ops_cont;
	} else {
		rdesc->ops = &vctrl_ops_non_cont;
	}

	init_data = of_get_regulator_init_data(&pdev->dev, np, rdesc);
	if (!init_data)
		return -ENOMEM;

	cfg.of_node = np;
	cfg.dev = &pdev->dev;
	cfg.driver_data = vctrl;
	cfg.init_data = init_data;

	if (!rdesc->continuous_voltage_range) {
		ret = vctrl_init_vtable(pdev);
		if (ret)
			return ret;

		ctrl_uV = regulator_get_voltage(vctrl->ctrl_reg);
		if (ctrl_uV < 0) {
			dev_err(&pdev->dev, "failed to get control voltage\n");
			return ctrl_uV;
		}

		/* determine current voltage selector from control voltage */
		if (ctrl_uV < vrange_ctrl->min_uV) {
			vctrl->sel = 0;
		} else if (ctrl_uV > vrange_ctrl->max_uV) {
			vctrl->sel = rdesc->n_voltages - 1;
		} else {
			int i;

			for (i = 0; i < rdesc->n_voltages; i++) {
				if (ctrl_uV == vctrl->vtable[i].ctrl) {
					vctrl->sel = i;
					break;
				}
			}
		}
	}

	vctrl->rdev = devm_regulator_register(&pdev->dev, rdesc, &cfg);
	if (IS_ERR(vctrl->rdev)) {
		ret = PTR_ERR(vctrl->rdev);
		dev_err(&pdev->dev, "failed to register regulator: %d\n", ret);
		return ret;
	}

	return 0;
}

static const struct of_device_id vctrl_of_match[] = {
	{ .compatible = "vctrl-regulator", },
	{},
};
MODULE_DEVICE_TABLE(of, vctrl_of_match);

static struct platform_driver vctrl_driver = {
	.probe		= vctrl_probe,
	.driver		= {
		.name		= "vctrl-regulator",
		.of_match_table = of_match_ptr(vctrl_of_match),
	},
};

module_platform_driver(vctrl_driver);

MODULE_DESCRIPTION("Voltage Controlled Regulator Driver");
MODULE_AUTHOR("Matthias Kaehlcke <mka@chromium.org>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
9c92ab61	1	// SPDX-License-Identifier: GPL-2.0-only
9dee7a72 MK	2	/*
	3	* Driver for voltage controller regulators
	4	*
	5	* Copyright (C) 2017 Google, Inc.
9dee7a72 MK	6	*/
	7
	8	#include <linux/delay.h>
	9	#include <linux/err.h>
	10	#include <linux/init.h>
	11	#include <linux/module.h>
	12	#include <linux/of.h>
	13	#include <linux/of_device.h>
	14	#include <linux/regulator/driver.h>
	15	#include <linux/regulator/of_regulator.h>
	16	#include <linux/sort.h>
	17
	18	struct vctrl_voltage_range {
	19	int min_uV;
	20	int max_uV;
	21	};
	22
	23	struct vctrl_voltage_ranges {
	24	struct vctrl_voltage_range ctrl;
	25	struct vctrl_voltage_range out;
	26	};
	27
	28	struct vctrl_voltage_table {
	29	int ctrl;
	30	int out;
	31	int ovp_min_sel;
	32	};
	33
	34	struct vctrl_data {
	35	struct regulator_dev *rdev;
	36	struct regulator_desc desc;
	37	struct regulator *ctrl_reg;
	38	bool enabled;
	39	unsigned int min_slew_down_rate;
	40	unsigned int ovp_threshold;
	41	struct vctrl_voltage_ranges vrange;
	42	struct vctrl_voltage_table *vtable;
	43	unsigned int sel;
	44	};
	45
	46	static int vctrl_calc_ctrl_voltage(struct vctrl_data *vctrl, int out_uV)
	47	{
	48	struct vctrl_voltage_range *ctrl = &vctrl->vrange.ctrl;
	49	struct vctrl_voltage_range *out = &vctrl->vrange.out;
	50
	51	return ctrl->min_uV +
	52	DIV_ROUND_CLOSEST_ULL((s64)(out_uV - out->min_uV) *
	53	(ctrl->max_uV - ctrl->min_uV),
	54	out->max_uV - out->min_uV);
	55	}
	56
	57	static int vctrl_calc_output_voltage(struct vctrl_data *vctrl, int ctrl_uV)
	58	{
	59	struct vctrl_voltage_range *ctrl = &vctrl->vrange.ctrl;
	60	struct vctrl_voltage_range *out = &vctrl->vrange.out;
	61
	62	if (ctrl_uV < 0) {
	63	pr_err("vctrl: failed to get control voltage\n");
	64	return ctrl_uV;
	65	}
	66
	67	if (ctrl_uV < ctrl->min_uV)
	68	return out->min_uV;
	69
70	if (ctrl_uV > ctrl->max_uV)
71	return out->max_uV;
72
73	return out->min_uV +
74	DIV_ROUND_CLOSEST_ULL((s64)(ctrl_uV - ctrl->min_uV) *
75	(out->max_uV - out->min_uV),
76	ctrl->max_uV - ctrl->min_uV);
77	}
78
79	static int vctrl_get_voltage(struct regulator_dev *rdev)
80	{
81	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
82	int ctrl_uV = regulator_get_voltage(vctrl->ctrl_reg);
83
84	return vctrl_calc_output_voltage(vctrl, ctrl_uV);
85	}
86
87	static int vctrl_set_voltage(struct regulator_dev *rdev,
88	int req_min_uV, int req_max_uV,
89	unsigned int *selector)
90	{
91	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
92	struct regulator *ctrl_reg = vctrl->ctrl_reg;
93	int orig_ctrl_uV = regulator_get_voltage(ctrl_reg);
94	int uV = vctrl_calc_output_voltage(vctrl, orig_ctrl_uV);
95	int ret;
96
97	if (req_min_uV >= uV \|\| !vctrl->ovp_threshold)
98	/* voltage rising or no OVP */
99	return regulator_set_voltage(
100	ctrl_reg,
101	vctrl_calc_ctrl_voltage(vctrl, req_min_uV),
102	vctrl_calc_ctrl_voltage(vctrl, req_max_uV));
103
104	while (uV > req_min_uV) {
105	int max_drop_uV = (uV * vctrl->ovp_threshold) / 100;
106	int next_uV;
107	int next_ctrl_uV;
108	int delay;
109
110	/* Make sure no infinite loop even in crazy cases */
111	if (max_drop_uV == 0)
112	max_drop_uV = 1;
113
114	next_uV = max_t(int, req_min_uV, uV - max_drop_uV);
115	next_ctrl_uV = vctrl_calc_ctrl_voltage(vctrl, next_uV);
116
117	ret = regulator_set_voltage(ctrl_reg,
118	next_ctrl_uV,
119	next_ctrl_uV);
120	if (ret)
121	goto err;
122
123	delay = DIV_ROUND_UP(uV - next_uV, vctrl->min_slew_down_rate);
124	usleep_range(delay, delay + DIV_ROUND_UP(delay, 10));
125
126	uV = next_uV;
127	}
128
129	return 0;
130
131	err:
132	/* Try to go back to original voltage */
133	regulator_set_voltage(ctrl_reg, orig_ctrl_uV, orig_ctrl_uV);
134
135	return ret;
136	}
137
138	static int vctrl_get_voltage_sel(struct regulator_dev *rdev)
139	{
140	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
141
142	return vctrl->sel;
143	}
144
145	static int vctrl_set_voltage_sel(struct regulator_dev *rdev,
146	unsigned int selector)
147	{
148	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
149	struct regulator *ctrl_reg = vctrl->ctrl_reg;
150	unsigned int orig_sel = vctrl->sel;
151	int ret;
152
153	if (selector >= rdev->desc->n_voltages)
154	return -EINVAL;
155
156	if (selector >= vctrl->sel \|\| !vctrl->ovp_threshold) {
157	/* voltage rising or no OVP */
158	ret = regulator_set_voltage(ctrl_reg,
159	vctrl->vtable[selector].ctrl,
160	vctrl->vtable[selector].ctrl);
161	if (!ret)
162	vctrl->sel = selector;
163
164	return ret;
165	}
166
167	while (vctrl->sel != selector) {
168	unsigned int next_sel;
169	int delay;
170
171	if (selector >= vctrl->vtable[vctrl->sel].ovp_min_sel)
172	next_sel = selector;
173	else
174	next_sel = vctrl->vtable[vctrl->sel].ovp_min_sel;
175
176	ret = regulator_set_voltage(ctrl_reg,
177	vctrl->vtable[next_sel].ctrl,
178	vctrl->vtable[next_sel].ctrl);
179	if (ret) {
180	dev_err(&rdev->dev,
181	"failed to set control voltage to %duV\n",
182	vctrl->vtable[next_sel].ctrl);
183	goto err;
184	}
185	vctrl->sel = next_sel;
186
187	delay = DIV_ROUND_UP(vctrl->vtable[vctrl->sel].out -
188	vctrl->vtable[next_sel].out,
189	vctrl->min_slew_down_rate);
190	usleep_range(delay, delay + DIV_ROUND_UP(delay, 10));
191	}
192
193	return 0;
194
195	err:
196	if (vctrl->sel != orig_sel) {
197	/* Try to go back to original voltage */
198	if (!regulator_set_voltage(ctrl_reg,
199	vctrl->vtable[orig_sel].ctrl,
200	vctrl->vtable[orig_sel].ctrl))
201	vctrl->sel = orig_sel;
202	else
203	dev_warn(&rdev->dev,
204	"failed to restore original voltage\n");
205	}
206
207	return ret;
208	}
209
210	static int vctrl_list_voltage(struct regulator_dev *rdev,
211	unsigned int selector)
212	{
213	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
214
215	if (selector >= rdev->desc->n_voltages)
216	return -EINVAL;
217
218	return vctrl->vtable[selector].out;
219	}
220
221	static int vctrl_parse_dt(struct platform_device *pdev,
222	struct vctrl_data *vctrl)
223	{
224	int ret;
225	struct device_node *np = pdev->dev.of_node;
226	u32 pval;
227	u32 vrange_ctrl[2];
228
229	vctrl->ctrl_reg = devm_regulator_get(&pdev->dev, "ctrl");
230	if (IS_ERR(vctrl->ctrl_reg))
231	return PTR_ERR(vctrl->ctrl_reg);
232
233	ret = of_property_read_u32(np, "ovp-threshold-percent", &pval);
234	if (!ret) {
235	vctrl->ovp_threshold = pval;
236	if (vctrl->ovp_threshold > 100) {
237	dev_err(&pdev->dev,
238	"ovp-threshold-percent (%u) > 100\n",
239	vctrl->ovp_threshold);
240	return -EINVAL;
241	}
242	}
243
244	ret = of_property_read_u32(np, "min-slew-down-rate", &pval);
245	if (!ret) {
246	vctrl->min_slew_down_rate = pval;
247
248	/* We use the value as int and as divider; sanity check */
249	if (vctrl->min_slew_down_rate == 0) {
250	dev_err(&pdev->dev,
251	"min-slew-down-rate must not be 0\n");
252	return -EINVAL;
253	} else if (vctrl->min_slew_down_rate > INT_MAX) {
254	dev_err(&pdev->dev, "min-slew-down-rate (%u) too big\n",
255	vctrl->min_slew_down_rate);
256	return -EINVAL;
257	}
258	}
259
260	if (vctrl->ovp_threshold && !vctrl->min_slew_down_rate) {
261	dev_err(&pdev->dev,
262	"ovp-threshold-percent requires min-slew-down-rate\n");
263	return -EINVAL;
264	}
265
266	ret = of_property_read_u32(np, "regulator-min-microvolt", &pval);
267	if (ret) {
268	dev_err(&pdev->dev,
269	"failed to read regulator-min-microvolt: %d\n", ret);
270	return ret;
271	}
272	vctrl->vrange.out.min_uV = pval;
273
274	ret = of_property_read_u32(np, "regulator-max-microvolt", &pval);
275	if (ret) {
276	dev_err(&pdev->dev,
277	"failed to read regulator-max-microvolt: %d\n", ret);
278	return ret;
279	}
280	vctrl->vrange.out.max_uV = pval;
281
282	ret = of_property_read_u32_array(np, "ctrl-voltage-range", vrange_ctrl,
283	2);
284	if (ret) {
285	dev_err(&pdev->dev, "failed to read ctrl-voltage-range: %d\n",
286	ret);
287	return ret;
288	}
289
290	if (vrange_ctrl[0] >= vrange_ctrl[1]) {
291	dev_err(&pdev->dev, "ctrl-voltage-range is invalid: %d-%d\n",
292	vrange_ctrl[0], vrange_ctrl[1]);
293	return -EINVAL;
294	}
295
296	vctrl->vrange.ctrl.min_uV = vrange_ctrl[0];
297	vctrl->vrange.ctrl.max_uV = vrange_ctrl[1];
298
299	return 0;
300	}
301
302	static int vctrl_cmp_ctrl_uV(const void a, const void b)
303	{
304	const struct vctrl_voltage_table *at = a;
305	const struct vctrl_voltage_table *bt = b;
306
307	return at->ctrl - bt->ctrl;
308	}
309
310	static int vctrl_init_vtable(struct platform_device *pdev)
311	{
312	struct vctrl_data *vctrl = platform_get_drvdata(pdev);
313	struct regulator_desc *rdesc = &vctrl->desc;
314	struct regulator *ctrl_reg = vctrl->ctrl_reg;
315	struct vctrl_voltage_range *vrange_ctrl = &vctrl->vrange.ctrl;
316	int n_voltages;
317	int ctrl_uV;
318	int i, idx_vt;
319
320	n_voltages = regulator_count_voltages(ctrl_reg);
321
322	rdesc->n_voltages = n_voltages;
323
324	/* determine number of steps within the range of the vctrl regulator */
325	for (i = 0; i < n_voltages; i++) {
326	ctrl_uV = regulator_list_voltage(ctrl_reg, i);
327
328	if (ctrl_uV < vrange_ctrl->min_uV \|\|
9e488c0a	329	ctrl_uV > vrange_ctrl->max_uV)
9dee7a72	330	rdesc->n_voltages--;
9dee7a72 MK	331	}
	332
	333	if (rdesc->n_voltages == 0) {
	334	dev_err(&pdev->dev, "invalid configuration\n");
	335	return -EINVAL;
	336	}
	337
a9bbb453 AL	338	vctrl->vtable = devm_kcalloc(&pdev->dev, rdesc->n_voltages,
	339	sizeof(struct vctrl_voltage_table),
	340	GFP_KERNEL);
9dee7a72 MK	341	if (!vctrl->vtable)
	342	return -ENOMEM;
	343
	344	/* create mapping control <=> output voltage */
	345	for (i = 0, idx_vt = 0; i < n_voltages; i++) {
	346	ctrl_uV = regulator_list_voltage(ctrl_reg, i);
	347
	348	if (ctrl_uV < vrange_ctrl->min_uV \|\|
	349	ctrl_uV > vrange_ctrl->max_uV)
	350	continue;
	351
	352	vctrl->vtable[idx_vt].ctrl = ctrl_uV;
	353	vctrl->vtable[idx_vt].out =
	354	vctrl_calc_output_voltage(vctrl, ctrl_uV);
	355	idx_vt++;
	356	}
	357
	358	/* we rely on the table to be ordered by ascending voltage */
	359	sort(vctrl->vtable, rdesc->n_voltages,
	360	sizeof(struct vctrl_voltage_table), vctrl_cmp_ctrl_uV,
	361	NULL);
	362
	363	/* pre-calculate OVP-safe downward transitions */
a9bbb453	364	for (i = rdesc->n_voltages - 1; i > 0; i--) {
9dee7a72 MK	365	int j;
	366	int ovp_min_uV = (vctrl->vtable[i].out *
	367	(100 - vctrl->ovp_threshold)) / 100;
	368
	369	for (j = 0; j < i; j++) {
	370	if (vctrl->vtable[j].out >= ovp_min_uV) {
	371	vctrl->vtable[i].ovp_min_sel = j;
	372	break;
	373	}
	374	}
	375
	376	if (j == i) {
	377	dev_warn(&pdev->dev, "switching down from %duV may cause OVP shutdown\n",
	378	vctrl->vtable[i].out);
	379	/* use next lowest voltage */
	380	vctrl->vtable[i].ovp_min_sel = i - 1;
	381	}
	382	}
	383
	384	return 0;
	385	}
	386
	387	static int vctrl_enable(struct regulator_dev *rdev)
	388	{
	389	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
	390	int ret = regulator_enable(vctrl->ctrl_reg);
	391
	392	if (!ret)
	393	vctrl->enabled = true;
	394
	395	return ret;
	396	}
	397
	398	static int vctrl_disable(struct regulator_dev *rdev)
	399	{
	400	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
	401	int ret = regulator_disable(vctrl->ctrl_reg);
	402
	403	if (!ret)
	404	vctrl->enabled = false;
	405
	406	return ret;
	407	}
	408
	409	static int vctrl_is_enabled(struct regulator_dev *rdev)
	410	{
	411	struct vctrl_data *vctrl = rdev_get_drvdata(rdev);
	412
	413	return vctrl->enabled;
	414	}
	415
	416	static const struct regulator_ops vctrl_ops_cont = {
	417	.enable = vctrl_enable,
	418	.disable = vctrl_disable,
	419	.is_enabled = vctrl_is_enabled,
	420	.get_voltage = vctrl_get_voltage,
	421	.set_voltage = vctrl_set_voltage,
	422	};
	423
	424	static const struct regulator_ops vctrl_ops_non_cont = {
	425	.enable = vctrl_enable,
	426	.disable = vctrl_disable,
	427	.is_enabled = vctrl_is_enabled,
	428	.set_voltage_sel = vctrl_set_voltage_sel,
429	.get_voltage_sel = vctrl_get_voltage_sel,
430	.list_voltage = vctrl_list_voltage,
431	.map_voltage = regulator_map_voltage_iterate,
432	};
433
434	static int vctrl_probe(struct platform_device *pdev)
435	{
436	struct device_node *np = pdev->dev.of_node;
437	struct vctrl_data *vctrl;
438	const struct regulator_init_data *init_data;
439	struct regulator_desc *rdesc;
440	struct regulator_config cfg = { };
441	struct vctrl_voltage_range *vrange_ctrl;
442	int ctrl_uV;
443	int ret;
444
445	vctrl = devm_kzalloc(&pdev->dev, sizeof(struct vctrl_data),
446	GFP_KERNEL);
447	if (!vctrl)
448	return -ENOMEM;
449
450	platform_set_drvdata(pdev, vctrl);
451
452	ret = vctrl_parse_dt(pdev, vctrl);
453	if (ret)
454	return ret;
455
456	vrange_ctrl = &vctrl->vrange.ctrl;
457
458	rdesc = &vctrl->desc;
459	rdesc->name = "vctrl";
460	rdesc->type = REGULATOR_VOLTAGE;
461	rdesc->owner = THIS_MODULE;
462
463	if ((regulator_get_linear_step(vctrl->ctrl_reg) == 1) \|\|
464	(regulator_count_voltages(vctrl->ctrl_reg) == -EINVAL)) {
465	rdesc->continuous_voltage_range = true;
466	rdesc->ops = &vctrl_ops_cont;
467	} else {
468	rdesc->ops = &vctrl_ops_non_cont;
469	}
470
471	init_data = of_get_regulator_init_data(&pdev->dev, np, rdesc);
472	if (!init_data)
473	return -ENOMEM;
474
475	cfg.of_node = np;
476	cfg.dev = &pdev->dev;
477	cfg.driver_data = vctrl;
478	cfg.init_data = init_data;
479
480	if (!rdesc->continuous_voltage_range) {
481	ret = vctrl_init_vtable(pdev);
482	if (ret)
483	return ret;
484
485	ctrl_uV = regulator_get_voltage(vctrl->ctrl_reg);
486	if (ctrl_uV < 0) {
487	dev_err(&pdev->dev, "failed to get control voltage\n");
488	return ctrl_uV;
489	}
490
491	/* determine current voltage selector from control voltage */
492	if (ctrl_uV < vrange_ctrl->min_uV) {
493	vctrl->sel = 0;
494	} else if (ctrl_uV > vrange_ctrl->max_uV) {
495	vctrl->sel = rdesc->n_voltages - 1;
496	} else {
497	int i;
498
499	for (i = 0; i < rdesc->n_voltages; i++) {
500	if (ctrl_uV == vctrl->vtable[i].ctrl) {
501	vctrl->sel = i;
502	break;
503	}
504	}
505	}
506	}
507
508	vctrl->rdev = devm_regulator_register(&pdev->dev, rdesc, &cfg);
509	if (IS_ERR(vctrl->rdev)) {
510	ret = PTR_ERR(vctrl->rdev);
511	dev_err(&pdev->dev, "failed to register regulator: %d\n", ret);
512	return ret;
513	}
514
515	return 0;
516	}
517
518	static const struct of_device_id vctrl_of_match[] = {
519	{ .compatible = "vctrl-regulator", },
520	{},
521	};
522	MODULE_DEVICE_TABLE(of, vctrl_of_match);
523
524	static struct platform_driver vctrl_driver = {
525	.probe = vctrl_probe,
526	.driver = {
527	.name = "vctrl-regulator",
528	.of_match_table = of_match_ptr(vctrl_of_match),
529	},
530	};
531
532	module_platform_driver(vctrl_driver);
533
534	MODULE_DESCRIPTION("Voltage Controlled Regulator Driver");
535	MODULE_AUTHOR("Matthias Kaehlcke <mka@chromium.org>");
536	MODULE_LICENSE("GPL v2");