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>
24 struct pwm_regulator_data {
26 struct pwm_device *pwm;
29 struct pwm_voltages *duty_cycle_table;
31 /* regulator descriptor */
32 struct regulator_desc desc;
35 struct regulator_ops ops;
39 /* Continuous voltage */
45 unsigned int dutycycle;
49 * Voltage table call-backs
51 static int pwm_regulator_get_voltage_sel(struct regulator_dev *rdev)
53 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
55 return drvdata->state;
58 static int pwm_regulator_set_voltage_sel(struct regulator_dev *rdev,
61 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
62 struct pwm_args pargs;
66 pwm_get_args(drvdata->pwm, &pargs);
68 dutycycle = (pargs.period *
69 drvdata->duty_cycle_table[selector].dutycycle) / 100;
71 ret = pwm_config(drvdata->pwm, dutycycle, pargs.period);
73 dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret);
77 drvdata->state = selector;
82 static int pwm_regulator_list_voltage(struct regulator_dev *rdev,
85 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
87 if (selector >= rdev->desc->n_voltages)
90 return drvdata->duty_cycle_table[selector].uV;
93 static int pwm_regulator_enable(struct regulator_dev *dev)
95 struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
97 return pwm_enable(drvdata->pwm);
100 static int pwm_regulator_disable(struct regulator_dev *dev)
102 struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
104 pwm_disable(drvdata->pwm);
109 static int pwm_regulator_is_enabled(struct regulator_dev *dev)
111 struct pwm_regulator_data *drvdata = rdev_get_drvdata(dev);
113 return pwm_is_enabled(drvdata->pwm);
116 static int pwm_regulator_get_voltage(struct regulator_dev *rdev)
118 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
120 return drvdata->volt_uV;
123 static int pwm_regulator_set_voltage(struct regulator_dev *rdev,
124 int min_uV, int max_uV,
127 struct pwm_regulator_data *drvdata = rdev_get_drvdata(rdev);
128 unsigned int ramp_delay = rdev->constraints->ramp_delay;
129 struct pwm_args pargs;
130 unsigned int req_diff = min_uV - rdev->constraints->min_uV;
132 unsigned int duty_pulse;
137 pwm_get_args(drvdata->pwm, &pargs);
138 diff = rdev->constraints->max_uV - rdev->constraints->min_uV;
140 /* First try to find out if we get the iduty cycle time which is
141 * factor of PWM period time. If (request_diff_to_min * pwm_period)
142 * is perfect divided by voltage_range_diff then it is possible to
143 * get duty cycle time which is factor of PWM period. This will help
144 * to get output voltage nearer to requested value as there is no
147 req_period = req_diff * pargs.period;
148 div_u64_rem(req_period, diff, &rem);
150 do_div(req_period, diff);
151 duty_pulse = (unsigned int)req_period;
153 duty_pulse = (pargs.period / 100) * ((req_diff * 100) / diff);
156 ret = pwm_config(drvdata->pwm, duty_pulse, pargs.period);
158 dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret);
162 ret = pwm_enable(drvdata->pwm);
164 dev_err(&rdev->dev, "Failed to enable PWM: %d\n", ret);
167 drvdata->volt_uV = min_uV;
169 /* Delay required by PWM regulator to settle to the new voltage */
170 usleep_range(ramp_delay, ramp_delay + 1000);
175 static struct regulator_ops pwm_regulator_voltage_table_ops = {
176 .set_voltage_sel = pwm_regulator_set_voltage_sel,
177 .get_voltage_sel = pwm_regulator_get_voltage_sel,
178 .list_voltage = pwm_regulator_list_voltage,
179 .map_voltage = regulator_map_voltage_iterate,
180 .enable = pwm_regulator_enable,
181 .disable = pwm_regulator_disable,
182 .is_enabled = pwm_regulator_is_enabled,
185 static struct regulator_ops pwm_regulator_voltage_continuous_ops = {
186 .get_voltage = pwm_regulator_get_voltage,
187 .set_voltage = pwm_regulator_set_voltage,
188 .enable = pwm_regulator_enable,
189 .disable = pwm_regulator_disable,
190 .is_enabled = pwm_regulator_is_enabled,
193 static struct regulator_desc pwm_regulator_desc = {
194 .name = "pwm-regulator",
195 .type = REGULATOR_VOLTAGE,
196 .owner = THIS_MODULE,
197 .supply_name = "pwm",
200 static int pwm_regulator_init_table(struct platform_device *pdev,
201 struct pwm_regulator_data *drvdata)
203 struct device_node *np = pdev->dev.of_node;
204 struct pwm_voltages *duty_cycle_table;
205 unsigned int length = 0;
208 of_find_property(np, "voltage-table", &length);
210 if ((length < sizeof(*duty_cycle_table)) ||
211 (length % sizeof(*duty_cycle_table))) {
212 dev_err(&pdev->dev, "voltage-table length(%d) is invalid\n",
217 duty_cycle_table = devm_kzalloc(&pdev->dev, length, GFP_KERNEL);
218 if (!duty_cycle_table)
221 ret = of_property_read_u32_array(np, "voltage-table",
222 (u32 *)duty_cycle_table,
223 length / sizeof(u32));
225 dev_err(&pdev->dev, "Failed to read voltage-table: %d\n", ret);
229 drvdata->duty_cycle_table = duty_cycle_table;
230 memcpy(&drvdata->ops, &pwm_regulator_voltage_table_ops,
231 sizeof(drvdata->ops));
232 drvdata->desc.ops = &drvdata->ops;
233 drvdata->desc.n_voltages = length / sizeof(*duty_cycle_table);
238 static int pwm_regulator_init_continuous(struct platform_device *pdev,
239 struct pwm_regulator_data *drvdata)
241 memcpy(&drvdata->ops, &pwm_regulator_voltage_continuous_ops,
242 sizeof(drvdata->ops));
243 drvdata->desc.ops = &drvdata->ops;
244 drvdata->desc.continuous_voltage_range = true;
249 static int pwm_regulator_probe(struct platform_device *pdev)
251 const struct regulator_init_data *init_data;
252 struct pwm_regulator_data *drvdata;
253 struct regulator_dev *regulator;
254 struct regulator_config config = { };
255 struct device_node *np = pdev->dev.of_node;
259 dev_err(&pdev->dev, "Device Tree node missing\n");
263 drvdata = devm_kzalloc(&pdev->dev, sizeof(*drvdata), GFP_KERNEL);
267 memcpy(&drvdata->desc, &pwm_regulator_desc, sizeof(drvdata->desc));
269 if (of_find_property(np, "voltage-table", NULL))
270 ret = pwm_regulator_init_table(pdev, drvdata);
272 ret = pwm_regulator_init_continuous(pdev, drvdata);
276 init_data = of_get_regulator_init_data(&pdev->dev, np,
282 config.dev = &pdev->dev;
283 config.driver_data = drvdata;
284 config.init_data = init_data;
286 drvdata->pwm = devm_pwm_get(&pdev->dev, NULL);
287 if (IS_ERR(drvdata->pwm)) {
288 ret = PTR_ERR(drvdata->pwm);
289 dev_err(&pdev->dev, "Failed to get PWM: %d\n", ret);
294 * FIXME: pwm_apply_args() should be removed when switching to the
297 pwm_apply_args(drvdata->pwm);
299 regulator = devm_regulator_register(&pdev->dev,
300 &drvdata->desc, &config);
301 if (IS_ERR(regulator)) {
302 ret = PTR_ERR(regulator);
303 dev_err(&pdev->dev, "Failed to register regulator %s: %d\n",
304 drvdata->desc.name, ret);
311 static const struct of_device_id pwm_of_match[] = {
312 { .compatible = "pwm-regulator" },
315 MODULE_DEVICE_TABLE(of, pwm_of_match);
317 static struct platform_driver pwm_regulator_driver = {
319 .name = "pwm-regulator",
320 .of_match_table = of_match_ptr(pwm_of_match),
322 .probe = pwm_regulator_probe,
325 module_platform_driver(pwm_regulator_driver);
327 MODULE_LICENSE("GPL");
328 MODULE_AUTHOR("Lee Jones <lee.jones@linaro.org>");
329 MODULE_DESCRIPTION("PWM Regulator Driver");
330 MODULE_ALIAS("platform:pwm-regulator");