[mirror_ubuntu-jammy-kernel.git] / drivers / regulator / pwm-regulator.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Regulator driver for PWM Regulators
 *
 * Copyright (C) 2014 - STMicroelectronics Inc.
 *
 * Author: Lee Jones <lee.jones@linaro.org>
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/of_regulator.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/pwm.h>
#include <linux/gpio/consumer.h>

struct pwm_continuous_reg_data {
	unsigned int min_uV_dutycycle;
	unsigned int max_uV_dutycycle;
	unsigned int dutycycle_unit;
};

struct pwm_regulator_data {
	/*  Shared */
	struct pwm_device *pwm;

	/* Voltage table */
	struct pwm_voltages *duty_cycle_table;

	/* Continuous mode info */
	struct pwm_continuous_reg_data continuous;

	/* regulator descriptor */
	struct regulator_desc desc;

	int state;

	/* Enable GPIO */
	struct gpio_desc *enb_gpio;
};

struct pwm_voltages {
	unsigned int uV;
	unsigned int dutycycle;
};

/*
 * Voltage table call-backs
 */
static void pwm_regulator_init_state(struct regulator_dev *rdev)
{
	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
	struct pwm_state pwm_state;
	unsigned int dutycycle;
	int i;

	pwm_get_state(drvdata->pwm, &pwm_state);
	dutycycle = pwm_get_relative_duty_cycle(&pwm_state, 100);

	for (i = 0; i < rdev->desc->n_voltages; i++) {
		if (dutycycle == drvdata->duty_cycle_table[i].dutycycle) {
			drvdata->state = i;
			return;
		}
	}
}

static int pwm_regulator_get_voltage_sel(struct regulator_dev *rdev)
{
	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);

	if (drvdata->state < 0)
		pwm_regulator_init_state(rdev);

	return drvdata->state;
}

static int pwm_regulator_set_voltage_sel(struct regulator_dev *rdev,
					 unsigned selector)
{
	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
	struct pwm_state pstate;
	int ret;

	pwm_init_state(drvdata->pwm, &pstate);
	pwm_set_relative_duty_cycle(&pstate,
			drvdata->duty_cycle_table[selector].dutycycle, 100);

	ret = pwm_apply_state(drvdata->pwm, &pstate);
	if (ret) {
		dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret);
		return ret;
	}

	drvdata->state = selector;

	return 0;
}

static int pwm_regulator_list_voltage(struct regulator_dev *rdev,
				      unsigned selector)
{
	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);

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

	return drvdata->duty_cycle_table[selector].uV;
}

static int pwm_regulator_enable(struct regulator_dev *dev)
{
	struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);

	gpiod_set_value_cansleep(drvdata->enb_gpio, 1);

	return pwm_enable(drvdata->pwm);
}

static int pwm_regulator_disable(struct regulator_dev *dev)
{
	struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);

	pwm_disable(drvdata->pwm);

	gpiod_set_value_cansleep(drvdata->enb_gpio, 0);

	return 0;
}

static int pwm_regulator_is_enabled(struct regulator_dev *dev)
{
	struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);

	if (drvdata->enb_gpio && !gpiod_get_value_cansleep(drvdata->enb_gpio))
		return false;

	return pwm_is_enabled(drvdata->pwm);
}

static int pwm_regulator_get_voltage(struct regulator_dev *rdev)
{
	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
	unsigned int min_uV_duty = drvdata->continuous.min_uV_dutycycle;
	unsigned int max_uV_duty = drvdata->continuous.max_uV_dutycycle;
	unsigned int duty_unit = drvdata->continuous.dutycycle_unit;
	int min_uV = rdev->constraints->min_uV;
	int max_uV = rdev->constraints->max_uV;
	int diff_uV = max_uV - min_uV;
	struct pwm_state pstate;
	unsigned int diff_duty;
	unsigned int voltage;

	pwm_get_state(drvdata->pwm, &pstate);

	voltage = pwm_get_relative_duty_cycle(&pstate, duty_unit);

	/*
	 * The dutycycle for min_uV might be greater than the one for max_uV.
	 * This is happening when the user needs an inversed polarity, but the
	 * PWM device does not support inversing it in hardware.
	 */
	if (max_uV_duty < min_uV_duty) {
		voltage = min_uV_duty - voltage;
		diff_duty = min_uV_duty - max_uV_duty;
	} else {
		voltage = voltage - min_uV_duty;
		diff_duty = max_uV_duty - min_uV_duty;
	}

	voltage = DIV_ROUND_CLOSEST_ULL((u64)voltage * diff_uV, diff_duty);

	return voltage + min_uV;
}

static int pwm_regulator_set_voltage(struct regulator_dev *rdev,
				     int req_min_uV, int req_max_uV,
				     unsigned int *selector)
{
	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
	unsigned int min_uV_duty = drvdata->continuous.min_uV_dutycycle;
	unsigned int max_uV_duty = drvdata->continuous.max_uV_dutycycle;
	unsigned int duty_unit = drvdata->continuous.dutycycle_unit;
	int min_uV = rdev->constraints->min_uV;
	int max_uV = rdev->constraints->max_uV;
	int diff_uV = max_uV - min_uV;
	struct pwm_state pstate;
	unsigned int diff_duty;
	unsigned int dutycycle;
	int ret;

	pwm_init_state(drvdata->pwm, &pstate);

	/*
	 * The dutycycle for min_uV might be greater than the one for max_uV.
	 * This is happening when the user needs an inversed polarity, but the
	 * PWM device does not support inversing it in hardware.
	 */
	if (max_uV_duty < min_uV_duty)
		diff_duty = min_uV_duty - max_uV_duty;
	else
		diff_duty = max_uV_duty - min_uV_duty;

	dutycycle = DIV_ROUND_CLOSEST_ULL((u64)(req_min_uV - min_uV) *
					  diff_duty,
					  diff_uV);

	if (max_uV_duty < min_uV_duty)
		dutycycle = min_uV_duty - dutycycle;
	else
		dutycycle = min_uV_duty + dutycycle;

	pwm_set_relative_duty_cycle(&pstate, dutycycle, duty_unit);

	ret = pwm_apply_state(drvdata->pwm, &pstate);
	if (ret) {
		dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret);
		return ret;
	}

	return 0;
}

static const struct regulator_ops pwm_regulator_voltage_table_ops = {
	.set_voltage_sel = pwm_regulator_set_voltage_sel,
	.get_voltage_sel = pwm_regulator_get_voltage_sel,
	.list_voltage    = pwm_regulator_list_voltage,
	.map_voltage     = regulator_map_voltage_iterate,
	.enable          = pwm_regulator_enable,
	.disable         = pwm_regulator_disable,
	.is_enabled      = pwm_regulator_is_enabled,
};

static const struct regulator_ops pwm_regulator_voltage_continuous_ops = {
	.get_voltage = pwm_regulator_get_voltage,
	.set_voltage = pwm_regulator_set_voltage,
	.enable          = pwm_regulator_enable,
	.disable         = pwm_regulator_disable,
	.is_enabled      = pwm_regulator_is_enabled,
};

static const struct regulator_desc pwm_regulator_desc = {
	.name		= "pwm-regulator",
	.type		= REGULATOR_VOLTAGE,
	.owner		= THIS_MODULE,
	.supply_name    = "pwm",
};

static int pwm_regulator_init_table(struct platform_device *pdev,
				    struct pwm_regulator_data *drvdata)
{
	struct device_node *np = pdev->dev.of_node;
	struct pwm_voltages *duty_cycle_table;
	unsigned int length = 0;
	int ret;

	of_find_property(np, "voltage-table", &length);

	if ((length < sizeof(*duty_cycle_table)) ||
	    (length % sizeof(*duty_cycle_table))) {
		dev_err(&pdev->dev, "voltage-table length(%d) is invalid\n",
			length);
		return -EINVAL;
	}

	duty_cycle_table = devm_kzalloc(&pdev->dev, length, GFP_KERNEL);
	if (!duty_cycle_table)
		return -ENOMEM;

	ret = of_property_read_u32_array(np, "voltage-table",
					 (u32 *)duty_cycle_table,
					 length / sizeof(u32));
	if (ret) {
		dev_err(&pdev->dev, "Failed to read voltage-table: %d\n", ret);
		return ret;
	}

	drvdata->state			= -ENOTRECOVERABLE;
	drvdata->duty_cycle_table	= duty_cycle_table;
	drvdata->desc.ops = &pwm_regulator_voltage_table_ops;
	drvdata->desc.n_voltages	= length / sizeof(*duty_cycle_table);

	return 0;
}

static int pwm_regulator_init_continuous(struct platform_device *pdev,
					 struct pwm_regulator_data *drvdata)
{
	u32 dutycycle_range[2] = { 0, 100 };
	u32 dutycycle_unit = 100;

	drvdata->desc.ops = &pwm_regulator_voltage_continuous_ops;
	drvdata->desc.continuous_voltage_range = true;

	of_property_read_u32_array(pdev->dev.of_node,
				   "pwm-dutycycle-range",
				   dutycycle_range, 2);
	of_property_read_u32(pdev->dev.of_node, "pwm-dutycycle-unit",
			     &dutycycle_unit);

	if (dutycycle_range[0] > dutycycle_unit ||
	    dutycycle_range[1] > dutycycle_unit)
		return -EINVAL;

	drvdata->continuous.dutycycle_unit = dutycycle_unit;
	drvdata->continuous.min_uV_dutycycle = dutycycle_range[0];
	drvdata->continuous.max_uV_dutycycle = dutycycle_range[1];

	return 0;
}

static int pwm_regulator_probe(struct platform_device *pdev)
{
	const struct regulator_init_data *init_data;
	struct pwm_regulator_data *drvdata;
	struct regulator_dev *regulator;
	struct regulator_config config = { };
	struct device_node *np = pdev->dev.of_node;
	enum gpiod_flags gpio_flags;
	int ret;

	if (!np) {
		dev_err(&pdev->dev, "Device Tree node missing\n");
		return -EINVAL;
	}

	drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL);
	if (!drvdata)
		return -ENOMEM;

	memcpy(&drvdata->desc, &pwm_regulator_desc, sizeof(drvdata->desc));

	if (of_find_property(np, "voltage-table", NULL))
		ret = pwm_regulator_init_table(pdev, drvdata);
	else
		ret = pwm_regulator_init_continuous(pdev, drvdata);
	if (ret)
		return ret;

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

	config.of_node = np;
	config.dev = &pdev->dev;
	config.driver_data = drvdata;
	config.init_data = init_data;

	drvdata->pwm = devm_pwm_get(&pdev->dev, NULL);
	if (IS_ERR(drvdata->pwm)) {
		ret = PTR_ERR(drvdata->pwm);
		if (ret == -EPROBE_DEFER)
			dev_dbg(&pdev->dev,
				"Failed to get PWM, deferring probe\n");
		else
			dev_err(&pdev->dev, "Failed to get PWM: %d\n", ret);
		return ret;
	}

	if (init_data->constraints.boot_on || init_data->constraints.always_on)
		gpio_flags = GPIOD_OUT_HIGH;
	else
		gpio_flags = GPIOD_OUT_LOW;
	drvdata->enb_gpio = devm_gpiod_get_optional(&pdev->dev, "enable",
						    gpio_flags);
	if (IS_ERR(drvdata->enb_gpio)) {
		ret = PTR_ERR(drvdata->enb_gpio);
		dev_err(&pdev->dev, "Failed to get enable GPIO: %d\n", ret);
		return ret;
	}

	ret = pwm_adjust_config(drvdata->pwm);
	if (ret)
		return ret;

	regulator = devm_regulator_register(&pdev->dev,
					    &drvdata->desc, &config);
	if (IS_ERR(regulator)) {
		ret = PTR_ERR(regulator);
		dev_err(&pdev->dev, "Failed to register regulator %s: %d\n",
			drvdata->desc.name, ret);
		return ret;
	}

	return 0;
}

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

static struct platform_driver pwm_regulator_driver = {
	.driver = {
		.name		= "pwm-regulator",
		.of_match_table = of_match_ptr(pwm_of_match),
	},
	.probe = pwm_regulator_probe,
};

module_platform_driver(pwm_regulator_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org>");
MODULE_DESCRIPTION("PWM Regulator Driver");
MODULE_ALIAS("platform:pwm-regulator");
Commit	Line	Data
d2912cb1	1	// SPDX-License-Identifier: GPL-2.0-only
aa66cc66 CZ	2	/*
	3	* Regulator driver for PWM Regulators
	4	*
	5	* Copyright (C) 2014 - STMicroelectronics Inc.
	6	*
	7	* Author: Lee Jones <lee.jones@linaro.org>
aa66cc66 CZ	8	*/
	9
	10	#include <linux/module.h>
	11	#include <linux/init.h>
	12	#include <linux/err.h>
	13	#include <linux/regulator/driver.h>
	14	#include <linux/regulator/machine.h>
	15	#include <linux/regulator/of_regulator.h>
	16	#include <linux/of.h>
	17	#include <linux/of_device.h>
	18	#include <linux/pwm.h>
27bfa889	19	#include <linux/gpio/consumer.h>
aa66cc66	20
ea398e28 BB	21	struct pwm_continuous_reg_data {
	22	unsigned int min_uV_dutycycle;
	23	unsigned int max_uV_dutycycle;
	24	unsigned int dutycycle_unit;
	25	};
	26
aa66cc66	27	struct pwm_regulator_data {
4773be18	28	/* Shared */
aa66cc66	29	struct pwm_device *pwm;
4773be18 LJ	30
	31	/* Voltage table */
	32	struct pwm_voltages *duty_cycle_table;
f907a0a9	33
ea398e28 BB	34	/* Continuous mode info */
	35	struct pwm_continuous_reg_data continuous;
	36
f907a0a9 LD	37	/* regulator descriptor */
	38	struct regulator_desc desc;
	39
aa66cc66	40	int state;
4773be18	41
27bfa889 AC	42	/* Enable GPIO */
27bfa889 AC	43	struct gpio_desc *enb_gpio;
aa66cc66 CZ	44	};
	45
	46	struct pwm_voltages {
	47	unsigned int uV;
	48	unsigned int dutycycle;
	49	};
	50
4e773e73	51	/*
4773be18 LJ	52	* Voltage table call-backs
4773be18 LJ	53	*/
87248991 BB	54	static void pwm_regulator_init_state(struct regulator_dev *rdev)
	55	{
	56	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
	57	struct pwm_state pwm_state;
	58	unsigned int dutycycle;
	59	int i;
	60
	61	pwm_get_state(drvdata->pwm, &pwm_state);
	62	dutycycle = pwm_get_relative_duty_cycle(&pwm_state, 100);
	63
	64	for (i = 0; i < rdev->desc->n_voltages; i++) {
	65	if (dutycycle == drvdata->duty_cycle_table[i].dutycycle) {
	66	drvdata->state = i;
	67	return;
	68	}
	69	}
	70	}
	71
ab101e35	72	static int pwm_regulator_get_voltage_sel(struct regulator_dev *rdev)
aa66cc66	73	{
ab101e35	74	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
aa66cc66	75
87248991 BB	76	if (drvdata->state < 0)
	77	pwm_regulator_init_state(rdev);
	78
aa66cc66 CZ	79	return drvdata->state;
	80	}
	81
ab101e35	82	static int pwm_regulator_set_voltage_sel(struct regulator_dev *rdev,
aa66cc66 CZ	83	unsigned selector)
aa66cc66 CZ	84	{
ab101e35	85	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
3f4eb39b	86	struct pwm_state pstate;
aa66cc66 CZ	87	int ret;
aa66cc66 CZ	88
3f4eb39b BB	89	pwm_init_state(drvdata->pwm, &pstate);
	90	pwm_set_relative_duty_cycle(&pstate,
	91	drvdata->duty_cycle_table[selector].dutycycle, 100);
aa66cc66	92
3f4eb39b	93	ret = pwm_apply_state(drvdata->pwm, &pstate);
aa66cc66	94	if (ret) {
5bf59bd5	95	dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret);
aa66cc66 CZ	96	return ret;
	97	}
	98
	99	drvdata->state = selector;
	100
aa66cc66 CZ	101	return 0;
	102	}
	103
ab101e35	104	static int pwm_regulator_list_voltage(struct regulator_dev *rdev,
aa66cc66 CZ	105	unsigned selector)
aa66cc66 CZ	106	{
ab101e35	107	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
aa66cc66	108
ab101e35	109	if (selector >= rdev->desc->n_voltages)
aa66cc66 CZ	110	return -EINVAL;
	111
	112	return drvdata->duty_cycle_table[selector].uV;
	113	}
4773be18	114
1de7d802 BB	115	static int pwm_regulator_enable(struct regulator_dev *dev)
	116	{
	117	struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
	118
a4aae5af	119	gpiod_set_value_cansleep(drvdata->enb_gpio, 1);
27bfa889	120
1de7d802 BB	121	return pwm_enable(drvdata->pwm);
	122	}
	123
	124	static int pwm_regulator_disable(struct regulator_dev *dev)
	125	{
	126	struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
	127
	128	pwm_disable(drvdata->pwm);
	129
a4aae5af	130	gpiod_set_value_cansleep(drvdata->enb_gpio, 0);
27bfa889	131
1de7d802 BB	132	return 0;
	133	}
	134
	135	static int pwm_regulator_is_enabled(struct regulator_dev *dev)
	136	{
	137	struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
	138
27bfa889 AC	139	if (drvdata->enb_gpio && !gpiod_get_value_cansleep(drvdata->enb_gpio))
	140	return false;
	141
1de7d802 BB	142	return pwm_is_enabled(drvdata->pwm);
	143	}
	144
4773be18 LJ	145	static int pwm_regulator_get_voltage(struct regulator_dev *rdev)
	146	{
	147	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
ea398e28 BB	148	unsigned int min_uV_duty = drvdata->continuous.min_uV_dutycycle;
	149	unsigned int max_uV_duty = drvdata->continuous.max_uV_dutycycle;
	150	unsigned int duty_unit = drvdata->continuous.dutycycle_unit;
d9070fdb	151	int min_uV = rdev->constraints->min_uV;
ea398e28 BB	152	int max_uV = rdev->constraints->max_uV;
ea398e28 BB	153	int diff_uV = max_uV - min_uV;
d9070fdb	154	struct pwm_state pstate;
ea398e28 BB	155	unsigned int diff_duty;
ea398e28 BB	156	unsigned int voltage;
4773be18	157
d9070fdb BB	158	pwm_get_state(drvdata->pwm, &pstate);
d9070fdb BB	159
ea398e28 BB	160	voltage = pwm_get_relative_duty_cycle(&pstate, duty_unit);
	161
	162	/*
	163	* The dutycycle for min_uV might be greater than the one for max_uV.
	164	* This is happening when the user needs an inversed polarity, but the
	165	* PWM device does not support inversing it in hardware.
	166	*/
	167	if (max_uV_duty < min_uV_duty) {
	168	voltage = min_uV_duty - voltage;
	169	diff_duty = min_uV_duty - max_uV_duty;
	170	} else {
	171	voltage = voltage - min_uV_duty;
	172	diff_duty = max_uV_duty - min_uV_duty;
	173	}
	174
	175	voltage = DIV_ROUND_CLOSEST_ULL((u64)voltage * diff_uV, diff_duty);
	176
	177	return voltage + min_uV;
4773be18 LJ	178	}
	179
	180	static int pwm_regulator_set_voltage(struct regulator_dev *rdev,
ea398e28 BB	181	int req_min_uV, int req_max_uV,
ea398e28 BB	182	unsigned int *selector)
4773be18 LJ	183	{
4773be18 LJ	184	struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
ea398e28 BB	185	unsigned int min_uV_duty = drvdata->continuous.min_uV_dutycycle;
	186	unsigned int max_uV_duty = drvdata->continuous.max_uV_dutycycle;
	187	unsigned int duty_unit = drvdata->continuous.dutycycle_unit;
ea398e28 BB	188	int min_uV = rdev->constraints->min_uV;
	189	int max_uV = rdev->constraints->max_uV;
	190	int diff_uV = max_uV - min_uV;
3f4eb39b	191	struct pwm_state pstate;
ea398e28 BB	192	unsigned int diff_duty;
ea398e28 BB	193	unsigned int dutycycle;
4773be18 LJ	194	int ret;
4773be18 LJ	195
3f4eb39b	196	pwm_init_state(drvdata->pwm, &pstate);
fd786fb0	197
ea398e28 BB	198	/*
	199	* The dutycycle for min_uV might be greater than the one for max_uV.
	200	* This is happening when the user needs an inversed polarity, but the
	201	* PWM device does not support inversing it in hardware.
	202	*/
	203	if (max_uV_duty < min_uV_duty)
	204	diff_duty = min_uV_duty - max_uV_duty;
	205	else
	206	diff_duty = max_uV_duty - min_uV_duty;
	207
	208	dutycycle = DIV_ROUND_CLOSEST_ULL((u64)(req_min_uV - min_uV) *
	209	diff_duty,
	210	diff_uV);
	211
	212	if (max_uV_duty < min_uV_duty)
	213	dutycycle = min_uV_duty - dutycycle;
	214	else
	215	dutycycle = min_uV_duty + dutycycle;
	216
	217	pwm_set_relative_duty_cycle(&pstate, dutycycle, duty_unit);
4773be18	218
3f4eb39b	219	ret = pwm_apply_state(drvdata->pwm, &pstate);
4773be18	220	if (ret) {
5bf59bd5	221	dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret);
4773be18 LJ	222	return ret;
	223	}
	224
4773be18 LJ	225	return 0;
	226	}
	227
638aef7a	228	static const struct regulator_ops pwm_regulator_voltage_table_ops = {
aa66cc66 CZ	229	.set_voltage_sel = pwm_regulator_set_voltage_sel,
	230	.get_voltage_sel = pwm_regulator_get_voltage_sel,
	231	.list_voltage = pwm_regulator_list_voltage,
	232	.map_voltage = regulator_map_voltage_iterate,
1de7d802 BB	233	.enable = pwm_regulator_enable,
	234	.disable = pwm_regulator_disable,
	235	.is_enabled = pwm_regulator_is_enabled,
aa66cc66 CZ	236	};
aa66cc66 CZ	237
638aef7a	238	static const struct regulator_ops pwm_regulator_voltage_continuous_ops = {
4773be18 LJ	239	.get_voltage = pwm_regulator_get_voltage,
4773be18 LJ	240	.set_voltage = pwm_regulator_set_voltage,
1de7d802 BB	241	.enable = pwm_regulator_enable,
	242	.disable = pwm_regulator_disable,
	243	.is_enabled = pwm_regulator_is_enabled,
4773be18 LJ	244	};
4773be18 LJ	245
638aef7a	246	static const struct regulator_desc pwm_regulator_desc = {
aa66cc66	247	.name = "pwm-regulator",
aa66cc66 CZ	248	.type = REGULATOR_VOLTAGE,
	249	.owner = THIS_MODULE,
	250	.supply_name = "pwm",
	251	};
	252
f9178dad LJ	253	static int pwm_regulator_init_table(struct platform_device *pdev,
	254	struct pwm_regulator_data *drvdata)
	255	{
	256	struct device_node *np = pdev->dev.of_node;
	257	struct pwm_voltages *duty_cycle_table;
60cb65eb	258	unsigned int length = 0;
f9178dad LJ	259	int ret;
	260
	261	of_find_property(np, "voltage-table", &length);
	262
	263	if ((length < sizeof(*duty_cycle_table)) \|\|
	264	(length % sizeof(*duty_cycle_table))) {
5bf59bd5	265	dev_err(&pdev->dev, "voltage-table length(%d) is invalid\n",
f9178dad LJ	266	length);
	267	return -EINVAL;
	268	}
	269
	270	duty_cycle_table = devm_kzalloc(&pdev->dev, length, GFP_KERNEL);
	271	if (!duty_cycle_table)
	272	return -ENOMEM;
	273
	274	ret = of_property_read_u32_array(np, "voltage-table",
	275	(u32 *)duty_cycle_table,
	276	length / sizeof(u32));
	277	if (ret) {
5bf59bd5	278	dev_err(&pdev->dev, "Failed to read voltage-table: %d\n", ret);
f9178dad LJ	279	return ret;
	280	}
	281
59ae97a7	282	drvdata->state = -ENOTRECOVERABLE;
f9178dad	283	drvdata->duty_cycle_table = duty_cycle_table;
638aef7a	284	drvdata->desc.ops = &pwm_regulator_voltage_table_ops;
f907a0a9	285	drvdata->desc.n_voltages = length / sizeof(*duty_cycle_table);
f9178dad LJ	286
	287	return 0;
	288	}
	289
4773be18 LJ	290	static int pwm_regulator_init_continuous(struct platform_device *pdev,
	291	struct pwm_regulator_data *drvdata)
	292	{
ea398e28 BB	293	u32 dutycycle_range[2] = { 0, 100 };
	294	u32 dutycycle_unit = 100;
	295
638aef7a	296	drvdata->desc.ops = &pwm_regulator_voltage_continuous_ops;
f907a0a9	297	drvdata->desc.continuous_voltage_range = true;
4773be18	298
ea398e28 BB	299	of_property_read_u32_array(pdev->dev.of_node,
	300	"pwm-dutycycle-range",
	301	dutycycle_range, 2);
	302	of_property_read_u32(pdev->dev.of_node, "pwm-dutycycle-unit",
	303	&dutycycle_unit);
	304
	305	if (dutycycle_range[0] > dutycycle_unit \|\|
	306	dutycycle_range[1] > dutycycle_unit)
	307	return -EINVAL;
	308
	309	drvdata->continuous.dutycycle_unit = dutycycle_unit;
	310	drvdata->continuous.min_uV_dutycycle = dutycycle_range[0];
	311	drvdata->continuous.max_uV_dutycycle = dutycycle_range[1];
	312
4773be18 LJ	313	return 0;
	314	}
	315
aa66cc66 CZ	316	static int pwm_regulator_probe(struct platform_device *pdev)
aa66cc66 CZ	317	{
5ad2cb14	318	const struct regulator_init_data *init_data;
aa66cc66	319	struct pwm_regulator_data *drvdata;
aa66cc66 CZ	320	struct regulator_dev *regulator;
	321	struct regulator_config config = { };
	322	struct device_node *np = pdev->dev.of_node;
27bfa889	323	enum gpiod_flags gpio_flags;
f9178dad	324	int ret;
aa66cc66 CZ	325
	326	if (!np) {
	327	dev_err(&pdev->dev, "Device Tree node missing\n");
	328	return -EINVAL;
	329	}
	330
	331	drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL);
	332	if (!drvdata)
	333	return -ENOMEM;
	334
f907a0a9 LD	335	memcpy(&drvdata->desc, &pwm_regulator_desc, sizeof(drvdata->desc));
f907a0a9 LD	336
4773be18	337	if (of_find_property(np, "voltage-table", NULL))
f9178dad	338	ret = pwm_regulator_init_table(pdev, drvdata);
4773be18 LJ	339	else
	340	ret = pwm_regulator_init_continuous(pdev, drvdata);
	341	if (ret)
	342	return ret;
aa66cc66	343
5ad2cb14	344	init_data = of_get_regulator_init_data(&pdev->dev, np,
f907a0a9	345	&drvdata->desc);
5ad2cb14	346	if (!init_data)
aa66cc66 CZ	347	return -ENOMEM;
	348
	349	config.of_node = np;
	350	config.dev = &pdev->dev;
	351	config.driver_data = drvdata;
5ad2cb14	352	config.init_data = init_data;
aa66cc66 CZ	353
	354	drvdata->pwm = devm_pwm_get(&pdev->dev, NULL);
	355	if (IS_ERR(drvdata->pwm)) {
5bf59bd5	356	ret = PTR_ERR(drvdata->pwm);
0cd71b9a JH	357	if (ret == -EPROBE_DEFER)
	358	dev_dbg(&pdev->dev,
	359	"Failed to get PWM, deferring probe\n");
	360	else
	361	dev_err(&pdev->dev, "Failed to get PWM: %d\n", ret);
5bf59bd5	362	return ret;
aa66cc66 CZ	363	}
aa66cc66 CZ	364
27bfa889 AC	365	if (init_data->constraints.boot_on \|\| init_data->constraints.always_on)
	366	gpio_flags = GPIOD_OUT_HIGH;
	367	else
	368	gpio_flags = GPIOD_OUT_LOW;
	369	drvdata->enb_gpio = devm_gpiod_get_optional(&pdev->dev, "enable",
	370	gpio_flags);
	371	if (IS_ERR(drvdata->enb_gpio)) {
	372	ret = PTR_ERR(drvdata->enb_gpio);
	373	dev_err(&pdev->dev, "Failed to get enable GPIO: %d\n", ret);
	374	return ret;
	375	}
	376
fd4f99c4 BB	377	ret = pwm_adjust_config(drvdata->pwm);
	378	if (ret)
	379	return ret;
8c12ad8e	380
aa66cc66	381	regulator = devm_regulator_register(&pdev->dev,
f907a0a9	382	&drvdata->desc, &config);
aa66cc66	383	if (IS_ERR(regulator)) {
5bf59bd5 LD	384	ret = PTR_ERR(regulator);
	385	dev_err(&pdev->dev, "Failed to register regulator %s: %d\n",
	386	drvdata->desc.name, ret);
	387	return ret;
aa66cc66 CZ	388	}
	389
	390	return 0;
	391	}
	392
dc8c5ea3	393	static const struct of_device_id __maybe_unused pwm_of_match[] = {
aa66cc66 CZ	394	{ .compatible = "pwm-regulator" },
	395	{ },
	396	};
	397	MODULE_DEVICE_TABLE(of, pwm_of_match);
	398
	399	static struct platform_driver pwm_regulator_driver = {
	400	.driver = {
	401	.name = "pwm-regulator",
aa66cc66 CZ	402	.of_match_table = of_match_ptr(pwm_of_match),
	403	},
	404	.probe = pwm_regulator_probe,
	405	};
	406
	407	module_platform_driver(pwm_regulator_driver);
	408
	409	MODULE_LICENSE("GPL");
	410	MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org>");
	411	MODULE_DESCRIPTION("PWM Regulator Driver");
	412	MODULE_ALIAS("platform:pwm-regulator");