2 * Regulator driver for PWM Regulators
4 * Copyright (C) 2014 - STMicroelectronics Inc.
6 * Author: Lee Jones <lee.jones@linaro.org>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/delay.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/err.h>
17 #include <linux/regulator/driver.h>
18 #include <linux/regulator/machine.h>
19 #include <linux/regulator/of_regulator.h>
21 #include <linux/of_device.h>
22 #include <linux/pwm.h>
23 #include <linux/gpio/consumer.h>
25 struct pwm_regulator_data {
27 struct pwm_device *pwm;
30 struct pwm_voltages *duty_cycle_table;
32 /* regulator descriptor */
33 struct regulator_desc desc;
36 struct regulator_ops ops;
40 /* Continuous voltage */
44 struct gpio_desc *enb_gpio;
49 unsigned int dutycycle;
53 * Voltage table call-backs
55 static int pwm_regulator_get_voltage_sel(struct regulator_dev *rdev)
57 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
59 return drvdata->state;
62 static int pwm_regulator_set_voltage_sel(struct regulator_dev *rdev,
65 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
66 struct pwm_args pargs;
70 pwm_get_args(drvdata->pwm, &pargs);
72 dutycycle = (pargs.period *
73 drvdata->duty_cycle_table[selector].dutycycle) / 100;
75 ret = pwm_config(drvdata->pwm, dutycycle, pargs.period);
77 dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret);
81 drvdata->state = selector;
86 static int pwm_regulator_list_voltage(struct regulator_dev *rdev,
89 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
91 if (selector >= rdev->desc->n_voltages)
94 return drvdata->duty_cycle_table[selector].uV;
97 static int pwm_regulator_enable(struct regulator_dev *dev)
99 struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
101 if (drvdata->enb_gpio)
102 gpiod_set_value_cansleep(drvdata->enb_gpio, 1);
104 return pwm_enable(drvdata->pwm);
107 static int pwm_regulator_disable(struct regulator_dev *dev)
109 struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
111 pwm_disable(drvdata->pwm);
113 if (drvdata->enb_gpio)
114 gpiod_set_value_cansleep(drvdata->enb_gpio, 0);
119 static int pwm_regulator_is_enabled(struct regulator_dev *dev)
121 struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
123 if (drvdata->enb_gpio && !gpiod_get_value_cansleep(drvdata->enb_gpio))
126 return pwm_is_enabled(drvdata->pwm);
129 static int pwm_regulator_get_voltage(struct regulator_dev *rdev)
131 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
133 return drvdata->volt_uV;
136 static int pwm_regulator_set_voltage(struct regulator_dev *rdev,
137 int min_uV, int max_uV,
140 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
141 unsigned int ramp_delay = rdev->constraints->ramp_delay;
142 struct pwm_args pargs;
143 unsigned int req_diff = min_uV - rdev->constraints->min_uV;
145 unsigned int duty_pulse;
150 pwm_get_args(drvdata->pwm, &pargs);
151 diff = rdev->constraints->max_uV - rdev->constraints->min_uV;
153 /* First try to find out if we get the iduty cycle time which is
154 * factor of PWM period time. If (request_diff_to_min * pwm_period)
155 * is perfect divided by voltage_range_diff then it is possible to
156 * get duty cycle time which is factor of PWM period. This will help
157 * to get output voltage nearer to requested value as there is no
160 req_period = req_diff * pargs.period;
161 div_u64_rem(req_period, diff, &rem);
163 do_div(req_period, diff);
164 duty_pulse = (unsigned int)req_period;
166 duty_pulse = (pargs.period / 100) * ((req_diff * 100) / diff);
169 ret = pwm_config(drvdata->pwm, duty_pulse, pargs.period);
171 dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret);
175 drvdata->volt_uV = min_uV;
177 /* Delay required by PWM regulator to settle to the new voltage */
178 usleep_range(ramp_delay, ramp_delay + 1000);
183 static struct regulator_ops pwm_regulator_voltage_table_ops = {
184 .set_voltage_sel = pwm_regulator_set_voltage_sel,
185 .get_voltage_sel = pwm_regulator_get_voltage_sel,
186 .list_voltage = pwm_regulator_list_voltage,
187 .map_voltage = regulator_map_voltage_iterate,
188 .enable = pwm_regulator_enable,
189 .disable = pwm_regulator_disable,
190 .is_enabled = pwm_regulator_is_enabled,
193 static struct regulator_ops pwm_regulator_voltage_continuous_ops = {
194 .get_voltage = pwm_regulator_get_voltage,
195 .set_voltage = pwm_regulator_set_voltage,
196 .enable = pwm_regulator_enable,
197 .disable = pwm_regulator_disable,
198 .is_enabled = pwm_regulator_is_enabled,
201 static struct regulator_desc pwm_regulator_desc = {
202 .name = "pwm-regulator",
203 .type = REGULATOR_VOLTAGE,
204 .owner = THIS_MODULE,
205 .supply_name = "pwm",
208 static int pwm_regulator_init_table(struct platform_device *pdev,
209 struct pwm_regulator_data *drvdata)
211 struct device_node *np = pdev->dev.of_node;
212 struct pwm_voltages *duty_cycle_table;
213 unsigned int length = 0;
216 of_find_property(np, "voltage-table", &length);
218 if ((length < sizeof(*duty_cycle_table)) ||
219 (length % sizeof(*duty_cycle_table))) {
220 dev_err(&pdev->dev, "voltage-table length(%d) is invalid\n",
225 duty_cycle_table = devm_kzalloc(&pdev->dev, length, GFP_KERNEL);
226 if (!duty_cycle_table)
229 ret = of_property_read_u32_array(np, "voltage-table",
230 (u32 *)duty_cycle_table,
231 length / sizeof(u32));
233 dev_err(&pdev->dev, "Failed to read voltage-table: %d\n", ret);
237 drvdata->duty_cycle_table = duty_cycle_table;
238 memcpy(&drvdata->ops, &pwm_regulator_voltage_table_ops,
239 sizeof(drvdata->ops));
240 drvdata->desc.ops = &drvdata->ops;
241 drvdata->desc.n_voltages = length / sizeof(*duty_cycle_table);
246 static int pwm_regulator_init_continuous(struct platform_device *pdev,
247 struct pwm_regulator_data *drvdata)
249 memcpy(&drvdata->ops, &pwm_regulator_voltage_continuous_ops,
250 sizeof(drvdata->ops));
251 drvdata->desc.ops = &drvdata->ops;
252 drvdata->desc.continuous_voltage_range = true;
257 static int pwm_regulator_probe(struct platform_device *pdev)
259 const struct regulator_init_data *init_data;
260 struct pwm_regulator_data *drvdata;
261 struct regulator_dev *regulator;
262 struct regulator_config config = { };
263 struct device_node *np = pdev->dev.of_node;
264 enum gpiod_flags gpio_flags;
268 dev_err(&pdev->dev, "Device Tree node missing\n");
272 drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL);
276 memcpy(&drvdata->desc, &pwm_regulator_desc, sizeof(drvdata->desc));
278 if (of_find_property(np, "voltage-table", NULL))
279 ret = pwm_regulator_init_table(pdev, drvdata);
281 ret = pwm_regulator_init_continuous(pdev, drvdata);
285 init_data = of_get_regulator_init_data(&pdev->dev, np,
291 config.dev = &pdev->dev;
292 config.driver_data = drvdata;
293 config.init_data = init_data;
295 drvdata->pwm = devm_pwm_get(&pdev->dev, NULL);
296 if (IS_ERR(drvdata->pwm)) {
297 ret = PTR_ERR(drvdata->pwm);
298 dev_err(&pdev->dev, "Failed to get PWM: %d\n", ret);
302 if (init_data->constraints.boot_on || init_data->constraints.always_on)
303 gpio_flags = GPIOD_OUT_HIGH;
305 gpio_flags = GPIOD_OUT_LOW;
306 drvdata->enb_gpio = devm_gpiod_get_optional(&pdev->dev, "enable",
308 if (IS_ERR(drvdata->enb_gpio)) {
309 ret = PTR_ERR(drvdata->enb_gpio);
310 dev_err(&pdev->dev, "Failed to get enable GPIO: %d\n", ret);
315 * FIXME: pwm_apply_args() should be removed when switching to the
318 pwm_apply_args(drvdata->pwm);
320 regulator = devm_regulator_register(&pdev->dev,
321 &drvdata->desc, &config);
322 if (IS_ERR(regulator)) {
323 ret = PTR_ERR(regulator);
324 dev_err(&pdev->dev, "Failed to register regulator %s: %d\n",
325 drvdata->desc.name, ret);
332 static const struct of_device_id pwm_of_match[] = {
333 { .compatible = "pwm-regulator" },
336 MODULE_DEVICE_TABLE(of, pwm_of_match);
338 static struct platform_driver pwm_regulator_driver = {
340 .name = "pwm-regulator",
341 .of_match_table = of_match_ptr(pwm_of_match),
343 .probe = pwm_regulator_probe,
346 module_platform_driver(pwm_regulator_driver);
348 MODULE_LICENSE("GPL");
349 MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org>");
350 MODULE_DESCRIPTION("PWM Regulator Driver");
351 MODULE_ALIAS("platform:pwm-regulator");