regulator: pwm: Support extra continuous mode cases

The continuous mode allows one to declare a PWM regulator without having
to declare the voltage <-> dutycycle association table. It works fine as
long as your voltage(dutycycle) function is linear, but also has the
following constraints:

- dutycycle for min_uV = 0%
- dutycycle for max_uV = 100%
- dutycycle for min_uV < dutycycle for max_uV

While the linearity constraint is acceptable for now, we sometimes need to
restrict of the PWM range (to limit the maximum/minimum voltage for
example) or have a min_uV_dutycycle > max_uV_dutycycle (this could be
tweaked with PWM polarity, but not all PWMs support inverted polarity).

Add the pwm-dutycycle-range and pwm-dutycycle-unit DT properties to define
such constraints. If those properties are not defined, the PWM regulator
use the default pwm-dutycycle-range = <0 100> and
pwm-dutycycle-unit = <100> values (existing behavior).

Signed-off-by: Boris Brezillon <boris.brezillon@free-electrons.com>
Reviewed-by: Brian Norris <briannorris@chromium.org>
Tested-by: Brian Norris <briannorris@chromium.org>
Tested-by: Heiko Stuebner <heiko@sntech.de>
Acked-by: Mark Brown <broonie@kernel.org>
Signed-off-by: Thierry Reding <thierry.reding@gmail.com>
This commit is contained in:
Boris Brezillon 2016-06-14 11:13:21 +02:00 committed by Thierry Reding
parent d9070fdbe4
commit ea398e2873
1 changed files with 82 additions and 10 deletions

View File

@ -22,6 +22,12 @@
#include <linux/pwm.h> #include <linux/pwm.h>
#include <linux/gpio/consumer.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 { struct pwm_regulator_data {
/* Shared */ /* Shared */
struct pwm_device *pwm; struct pwm_device *pwm;
@ -29,6 +35,9 @@ struct pwm_regulator_data {
/* Voltage table */ /* Voltage table */
struct pwm_voltages *duty_cycle_table; struct pwm_voltages *duty_cycle_table;
/* Continuous mode info */
struct pwm_continuous_reg_data continuous;
/* regulator descriptor */ /* regulator descriptor */
struct regulator_desc desc; struct regulator_desc desc;
@ -145,32 +154,78 @@ static int pwm_regulator_is_enabled(struct regulator_dev *dev)
static int pwm_regulator_get_voltage(struct regulator_dev *rdev) static int pwm_regulator_get_voltage(struct regulator_dev *rdev)
{ {
struct pwm_regulator_data *drvdata = rdev_get_drvdata(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 min_uV = rdev->constraints->min_uV;
int diff = rdev->constraints->max_uV - min_uV; int max_uV = rdev->constraints->max_uV;
int diff_uV = max_uV - min_uV;
struct pwm_state pstate; struct pwm_state pstate;
unsigned int diff_duty;
unsigned int voltage;
pwm_get_state(drvdata->pwm, &pstate); pwm_get_state(drvdata->pwm, &pstate);
return min_uV + pwm_get_relative_duty_cycle(&pstate, diff); 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, static int pwm_regulator_set_voltage(struct regulator_dev *rdev,
int min_uV, int max_uV, int req_min_uV, int req_max_uV,
unsigned *selector) unsigned int *selector)
{ {
struct pwm_regulator_data *drvdata = rdev_get_drvdata(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;
unsigned int ramp_delay = rdev->constraints->ramp_delay; unsigned int ramp_delay = rdev->constraints->ramp_delay;
unsigned int req_diff = min_uV - rdev->constraints->min_uV; 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; struct pwm_state pstate;
unsigned int diff;
int old_uV = pwm_regulator_get_voltage(rdev); int old_uV = pwm_regulator_get_voltage(rdev);
unsigned int diff_duty;
unsigned int dutycycle;
int ret; int ret;
pwm_init_state(drvdata->pwm, &pstate); pwm_init_state(drvdata->pwm, &pstate);
diff = rdev->constraints->max_uV - rdev->constraints->min_uV;
/* We pass diff as the scale to get a uV precision. */ /*
pwm_set_relative_duty_cycle(&pstate, req_diff, diff); * 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); ret = pwm_apply_state(drvdata->pwm, &pstate);
if (ret) { if (ret) {
@ -182,7 +237,7 @@ static int pwm_regulator_set_voltage(struct regulator_dev *rdev,
return 0; return 0;
/* Ramp delay is in uV/uS. Adjust to uS and delay */ /* Ramp delay is in uV/uS. Adjust to uS and delay */
ramp_delay = DIV_ROUND_UP(abs(min_uV - old_uV), ramp_delay); ramp_delay = DIV_ROUND_UP(abs(req_min_uV - old_uV), ramp_delay);
usleep_range(ramp_delay, ramp_delay + DIV_ROUND_UP(ramp_delay, 10)); usleep_range(ramp_delay, ramp_delay + DIV_ROUND_UP(ramp_delay, 10));
return 0; return 0;
@ -255,11 +310,28 @@ static int pwm_regulator_init_table(struct platform_device *pdev,
static int pwm_regulator_init_continuous(struct platform_device *pdev, static int pwm_regulator_init_continuous(struct platform_device *pdev,
struct pwm_regulator_data *drvdata) struct pwm_regulator_data *drvdata)
{ {
u32 dutycycle_range[2] = { 0, 100 };
u32 dutycycle_unit = 100;
memcpy(&drvdata->ops, &pwm_regulator_voltage_continuous_ops, memcpy(&drvdata->ops, &pwm_regulator_voltage_continuous_ops,
sizeof(drvdata->ops)); sizeof(drvdata->ops));
drvdata->desc.ops = &drvdata->ops; drvdata->desc.ops = &drvdata->ops;
drvdata->desc.continuous_voltage_range = true; 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; return 0;
} }