diff options
author | Thierry Reding <thierry.reding@gmail.com> | 2016-05-17 08:57:58 -0400 |
---|---|---|
committer | Thierry Reding <thierry.reding@gmail.com> | 2016-05-17 08:57:58 -0400 |
commit | 18c588786c08458f5d965d8735ab48f9e51e0b4b (patch) | |
tree | 925893d58c00432f93830d1b83405c9d44d79bb8 | |
parent | d2a3f206846b4b140aa1fe5be29499e9191fb1fe (diff) | |
parent | 23e3523f5d3a980edf7f189743cf4bb9490400a9 (diff) |
Merge branch 'for-4.7/pwm-atomic' into for-next
-rw-r--r-- | Documentation/pwm.txt | 30 | ||||
-rw-r--r-- | arch/arm/mach-s3c24xx/mach-rx1950.c | 6 | ||||
-rw-r--r-- | drivers/clk/clk-pwm.c | 17 | ||||
-rw-r--r-- | drivers/gpu/drm/i915/intel_panel.c | 6 | ||||
-rw-r--r-- | drivers/hwmon/pwm-fan.c | 26 | ||||
-rw-r--r-- | drivers/input/misc/max77693-haptic.c | 17 | ||||
-rw-r--r-- | drivers/input/misc/max8997_haptic.c | 6 | ||||
-rw-r--r-- | drivers/input/misc/pwm-beeper.c | 6 | ||||
-rw-r--r-- | drivers/leds/leds-pwm.c | 11 | ||||
-rw-r--r-- | drivers/pwm/core.c | 222 | ||||
-rw-r--r-- | drivers/pwm/pwm-crc.c | 2 | ||||
-rw-r--r-- | drivers/pwm/pwm-lpc18xx-sct.c | 2 | ||||
-rw-r--r-- | drivers/pwm/pwm-omap-dmtimer.c | 2 | ||||
-rw-r--r-- | drivers/pwm/pwm-rcar.c | 2 | ||||
-rw-r--r-- | drivers/pwm/pwm-sun4i.c | 3 | ||||
-rw-r--r-- | drivers/pwm/sysfs.c | 70 | ||||
-rw-r--r-- | drivers/video/backlight/lm3630a_bl.c | 9 | ||||
-rw-r--r-- | drivers/video/backlight/lp855x_bl.c | 6 | ||||
-rw-r--r-- | drivers/video/backlight/lp8788_bl.c | 6 | ||||
-rw-r--r-- | drivers/video/backlight/pwm_bl.c | 14 | ||||
-rw-r--r-- | drivers/video/fbdev/ssd1307fb.c | 11 | ||||
-rw-r--r-- | include/linux/pwm.h | 319 |
22 files changed, 580 insertions, 213 deletions
diff --git a/Documentation/pwm.txt b/Documentation/pwm.txt index ca895fd211e4..789b27c6ec99 100644 --- a/Documentation/pwm.txt +++ b/Documentation/pwm.txt | |||
@@ -42,9 +42,26 @@ variants of these functions, devm_pwm_get() and devm_pwm_put(), also exist. | |||
42 | 42 | ||
43 | After being requested, a PWM has to be configured using: | 43 | After being requested, a PWM has to be configured using: |
44 | 44 | ||
45 | int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns); | 45 | int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state); |
46 | 46 | ||
47 | To start/stop toggling the PWM output use pwm_enable()/pwm_disable(). | 47 | This API controls both the PWM period/duty_cycle config and the |
48 | enable/disable state. | ||
49 | |||
50 | The pwm_config(), pwm_enable() and pwm_disable() functions are just wrappers | ||
51 | around pwm_apply_state() and should not be used if the user wants to change | ||
52 | several parameter at once. For example, if you see pwm_config() and | ||
53 | pwm_{enable,disable}() calls in the same function, this probably means you | ||
54 | should switch to pwm_apply_state(). | ||
55 | |||
56 | The PWM user API also allows one to query the PWM state with pwm_get_state(). | ||
57 | |||
58 | In addition to the PWM state, the PWM API also exposes PWM arguments, which | ||
59 | are the reference PWM config one should use on this PWM. | ||
60 | PWM arguments are usually platform-specific and allows the PWM user to only | ||
61 | care about dutycycle relatively to the full period (like, duty = 50% of the | ||
62 | period). struct pwm_args contains 2 fields (period and polarity) and should | ||
63 | be used to set the initial PWM config (usually done in the probe function | ||
64 | of the PWM user). PWM arguments are retrieved with pwm_get_args(). | ||
48 | 65 | ||
49 | Using PWMs with the sysfs interface | 66 | Using PWMs with the sysfs interface |
50 | ----------------------------------- | 67 | ----------------------------------- |
@@ -105,6 +122,15 @@ goes low for the remainder of the period. Conversely, a signal with inversed | |||
105 | polarity starts low for the duration of the duty cycle and goes high for the | 122 | polarity starts low for the duration of the duty cycle and goes high for the |
106 | remainder of the period. | 123 | remainder of the period. |
107 | 124 | ||
125 | Drivers are encouraged to implement ->apply() instead of the legacy | ||
126 | ->enable(), ->disable() and ->config() methods. Doing that should provide | ||
127 | atomicity in the PWM config workflow, which is required when the PWM controls | ||
128 | a critical device (like a regulator). | ||
129 | |||
130 | The implementation of ->get_state() (a method used to retrieve initial PWM | ||
131 | state) is also encouraged for the same reason: letting the PWM user know | ||
132 | about the current PWM state would allow him to avoid glitches. | ||
133 | |||
108 | Locking | 134 | Locking |
109 | ------- | 135 | ------- |
110 | 136 | ||
diff --git a/arch/arm/mach-s3c24xx/mach-rx1950.c b/arch/arm/mach-s3c24xx/mach-rx1950.c index 774c982a7b7e..25a139bb9826 100644 --- a/arch/arm/mach-s3c24xx/mach-rx1950.c +++ b/arch/arm/mach-s3c24xx/mach-rx1950.c | |||
@@ -496,6 +496,12 @@ static int rx1950_backlight_init(struct device *dev) | |||
496 | return PTR_ERR(lcd_pwm); | 496 | return PTR_ERR(lcd_pwm); |
497 | } | 497 | } |
498 | 498 | ||
499 | /* | ||
500 | * FIXME: pwm_apply_args() should be removed when switching to | ||
501 | * the atomic PWM API. | ||
502 | */ | ||
503 | pwm_apply_args(lcd_pwm); | ||
504 | |||
499 | rx1950_lcd_power(1); | 505 | rx1950_lcd_power(1); |
500 | rx1950_bl_power(1); | 506 | rx1950_bl_power(1); |
501 | 507 | ||
diff --git a/drivers/clk/clk-pwm.c b/drivers/clk/clk-pwm.c index 883045814dac..1630a1f085f7 100644 --- a/drivers/clk/clk-pwm.c +++ b/drivers/clk/clk-pwm.c | |||
@@ -59,6 +59,7 @@ static int clk_pwm_probe(struct platform_device *pdev) | |||
59 | struct clk_init_data init; | 59 | struct clk_init_data init; |
60 | struct clk_pwm *clk_pwm; | 60 | struct clk_pwm *clk_pwm; |
61 | struct pwm_device *pwm; | 61 | struct pwm_device *pwm; |
62 | struct pwm_args pargs; | ||
62 | const char *clk_name; | 63 | const char *clk_name; |
63 | struct clk *clk; | 64 | struct clk *clk; |
64 | int ret; | 65 | int ret; |
@@ -71,22 +72,28 @@ static int clk_pwm_probe(struct platform_device *pdev) | |||
71 | if (IS_ERR(pwm)) | 72 | if (IS_ERR(pwm)) |
72 | return PTR_ERR(pwm); | 73 | return PTR_ERR(pwm); |
73 | 74 | ||
74 | if (!pwm->period) { | 75 | pwm_get_args(pwm, &pargs); |
76 | if (!pargs.period) { | ||
75 | dev_err(&pdev->dev, "invalid PWM period\n"); | 77 | dev_err(&pdev->dev, "invalid PWM period\n"); |
76 | return -EINVAL; | 78 | return -EINVAL; |
77 | } | 79 | } |
78 | 80 | ||
79 | if (of_property_read_u32(node, "clock-frequency", &clk_pwm->fixed_rate)) | 81 | if (of_property_read_u32(node, "clock-frequency", &clk_pwm->fixed_rate)) |
80 | clk_pwm->fixed_rate = NSEC_PER_SEC / pwm->period; | 82 | clk_pwm->fixed_rate = NSEC_PER_SEC / pargs.period; |
81 | 83 | ||
82 | if (pwm->period != NSEC_PER_SEC / clk_pwm->fixed_rate && | 84 | if (pargs.period != NSEC_PER_SEC / clk_pwm->fixed_rate && |
83 | pwm->period != DIV_ROUND_UP(NSEC_PER_SEC, clk_pwm->fixed_rate)) { | 85 | pargs.period != DIV_ROUND_UP(NSEC_PER_SEC, clk_pwm->fixed_rate)) { |
84 | dev_err(&pdev->dev, | 86 | dev_err(&pdev->dev, |
85 | "clock-frequency does not match PWM period\n"); | 87 | "clock-frequency does not match PWM period\n"); |
86 | return -EINVAL; | 88 | return -EINVAL; |
87 | } | 89 | } |
88 | 90 | ||
89 | ret = pwm_config(pwm, (pwm->period + 1) >> 1, pwm->period); | 91 | /* |
92 | * FIXME: pwm_apply_args() should be removed when switching to the | ||
93 | * atomic PWM API. | ||
94 | */ | ||
95 | pwm_apply_args(pwm); | ||
96 | ret = pwm_config(pwm, (pargs.period + 1) >> 1, pargs.period); | ||
90 | if (ret < 0) | 97 | if (ret < 0) |
91 | return ret; | 98 | return ret; |
92 | 99 | ||
diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c index 21ee6477bf98..dc3a2e4f74c2 100644 --- a/drivers/gpu/drm/i915/intel_panel.c +++ b/drivers/gpu/drm/i915/intel_panel.c | |||
@@ -1640,6 +1640,12 @@ static int pwm_setup_backlight(struct intel_connector *connector, | |||
1640 | return -ENODEV; | 1640 | return -ENODEV; |
1641 | } | 1641 | } |
1642 | 1642 | ||
1643 | /* | ||
1644 | * FIXME: pwm_apply_args() should be removed when switching to | ||
1645 | * the atomic PWM API. | ||
1646 | */ | ||
1647 | pwm_apply_args(panel->backlight.pwm); | ||
1648 | |||
1643 | retval = pwm_config(panel->backlight.pwm, CRC_PMIC_PWM_PERIOD_NS, | 1649 | retval = pwm_config(panel->backlight.pwm, CRC_PMIC_PWM_PERIOD_NS, |
1644 | CRC_PMIC_PWM_PERIOD_NS); | 1650 | CRC_PMIC_PWM_PERIOD_NS); |
1645 | if (retval < 0) { | 1651 | if (retval < 0) { |
diff --git a/drivers/hwmon/pwm-fan.c b/drivers/hwmon/pwm-fan.c index 3e23003f78b0..f9af3935b427 100644 --- a/drivers/hwmon/pwm-fan.c +++ b/drivers/hwmon/pwm-fan.c | |||
@@ -40,15 +40,18 @@ struct pwm_fan_ctx { | |||
40 | 40 | ||
41 | static int __set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm) | 41 | static int __set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm) |
42 | { | 42 | { |
43 | struct pwm_args pargs; | ||
43 | unsigned long duty; | 44 | unsigned long duty; |
44 | int ret = 0; | 45 | int ret = 0; |
45 | 46 | ||
47 | pwm_get_args(ctx->pwm, &pargs); | ||
48 | |||
46 | mutex_lock(&ctx->lock); | 49 | mutex_lock(&ctx->lock); |
47 | if (ctx->pwm_value == pwm) | 50 | if (ctx->pwm_value == pwm) |
48 | goto exit_set_pwm_err; | 51 | goto exit_set_pwm_err; |
49 | 52 | ||
50 | duty = DIV_ROUND_UP(pwm * (ctx->pwm->period - 1), MAX_PWM); | 53 | duty = DIV_ROUND_UP(pwm * (pargs.period - 1), MAX_PWM); |
51 | ret = pwm_config(ctx->pwm, duty, ctx->pwm->period); | 54 | ret = pwm_config(ctx->pwm, duty, pargs.period); |
52 | if (ret) | 55 | if (ret) |
53 | goto exit_set_pwm_err; | 56 | goto exit_set_pwm_err; |
54 | 57 | ||
@@ -215,6 +218,7 @@ static int pwm_fan_probe(struct platform_device *pdev) | |||
215 | { | 218 | { |
216 | struct thermal_cooling_device *cdev; | 219 | struct thermal_cooling_device *cdev; |
217 | struct pwm_fan_ctx *ctx; | 220 | struct pwm_fan_ctx *ctx; |
221 | struct pwm_args pargs; | ||
218 | struct device *hwmon; | 222 | struct device *hwmon; |
219 | int duty_cycle; | 223 | int duty_cycle; |
220 | int ret; | 224 | int ret; |
@@ -233,11 +237,19 @@ static int pwm_fan_probe(struct platform_device *pdev) | |||
233 | 237 | ||
234 | platform_set_drvdata(pdev, ctx); | 238 | platform_set_drvdata(pdev, ctx); |
235 | 239 | ||
240 | /* | ||
241 | * FIXME: pwm_apply_args() should be removed when switching to the | ||
242 | * atomic PWM API. | ||
243 | */ | ||
244 | pwm_apply_args(ctx->pwm); | ||
245 | |||
236 | /* Set duty cycle to maximum allowed */ | 246 | /* Set duty cycle to maximum allowed */ |
237 | duty_cycle = ctx->pwm->period - 1; | 247 | pwm_get_args(ctx->pwm, &pargs); |
248 | |||
249 | duty_cycle = pargs.period - 1; | ||
238 | ctx->pwm_value = MAX_PWM; | 250 | ctx->pwm_value = MAX_PWM; |
239 | 251 | ||
240 | ret = pwm_config(ctx->pwm, duty_cycle, ctx->pwm->period); | 252 | ret = pwm_config(ctx->pwm, duty_cycle, pargs.period); |
241 | if (ret) { | 253 | if (ret) { |
242 | dev_err(&pdev->dev, "Failed to configure PWM\n"); | 254 | dev_err(&pdev->dev, "Failed to configure PWM\n"); |
243 | return ret; | 255 | return ret; |
@@ -303,14 +315,16 @@ static int pwm_fan_suspend(struct device *dev) | |||
303 | static int pwm_fan_resume(struct device *dev) | 315 | static int pwm_fan_resume(struct device *dev) |
304 | { | 316 | { |
305 | struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); | 317 | struct pwm_fan_ctx *ctx = dev_get_drvdata(dev); |
318 | struct pwm_args pargs; | ||
306 | unsigned long duty; | 319 | unsigned long duty; |
307 | int ret; | 320 | int ret; |
308 | 321 | ||
309 | if (ctx->pwm_value == 0) | 322 | if (ctx->pwm_value == 0) |
310 | return 0; | 323 | return 0; |
311 | 324 | ||
312 | duty = DIV_ROUND_UP(ctx->pwm_value * (ctx->pwm->period - 1), MAX_PWM); | 325 | pwm_get_args(ctx->pwm, &pargs); |
313 | ret = pwm_config(ctx->pwm, duty, ctx->pwm->period); | 326 | duty = DIV_ROUND_UP(ctx->pwm_value * (pargs.period - 1), MAX_PWM); |
327 | ret = pwm_config(ctx->pwm, duty, pargs.period); | ||
314 | if (ret) | 328 | if (ret) |
315 | return ret; | 329 | return ret; |
316 | return pwm_enable(ctx->pwm); | 330 | return pwm_enable(ctx->pwm); |
diff --git a/drivers/input/misc/max77693-haptic.c b/drivers/input/misc/max77693-haptic.c index 6d96bff32a0e..29ddeb7be84b 100644 --- a/drivers/input/misc/max77693-haptic.c +++ b/drivers/input/misc/max77693-haptic.c | |||
@@ -70,10 +70,13 @@ struct max77693_haptic { | |||
70 | 70 | ||
71 | static int max77693_haptic_set_duty_cycle(struct max77693_haptic *haptic) | 71 | static int max77693_haptic_set_duty_cycle(struct max77693_haptic *haptic) |
72 | { | 72 | { |
73 | int delta = (haptic->pwm_dev->period + haptic->pwm_duty) / 2; | 73 | struct pwm_args pargs; |
74 | int delta; | ||
74 | int error; | 75 | int error; |
75 | 76 | ||
76 | error = pwm_config(haptic->pwm_dev, delta, haptic->pwm_dev->period); | 77 | pwm_get_args(haptic->pwm_dev, &pargs); |
78 | delta = (pargs.period + haptic->pwm_duty) / 2; | ||
79 | error = pwm_config(haptic->pwm_dev, delta, pargs.period); | ||
77 | if (error) { | 80 | if (error) { |
78 | dev_err(haptic->dev, "failed to configure pwm: %d\n", error); | 81 | dev_err(haptic->dev, "failed to configure pwm: %d\n", error); |
79 | return error; | 82 | return error; |
@@ -234,6 +237,7 @@ static int max77693_haptic_play_effect(struct input_dev *dev, void *data, | |||
234 | struct ff_effect *effect) | 237 | struct ff_effect *effect) |
235 | { | 238 | { |
236 | struct max77693_haptic *haptic = input_get_drvdata(dev); | 239 | struct max77693_haptic *haptic = input_get_drvdata(dev); |
240 | struct pwm_args pargs; | ||
237 | u64 period_mag_multi; | 241 | u64 period_mag_multi; |
238 | 242 | ||
239 | haptic->magnitude = effect->u.rumble.strong_magnitude; | 243 | haptic->magnitude = effect->u.rumble.strong_magnitude; |
@@ -245,7 +249,8 @@ static int max77693_haptic_play_effect(struct input_dev *dev, void *data, | |||
245 | * The formula to convert magnitude to pwm_duty as follows: | 249 | * The formula to convert magnitude to pwm_duty as follows: |
246 | * - pwm_duty = (magnitude * pwm_period) / MAX_MAGNITUDE(0xFFFF) | 250 | * - pwm_duty = (magnitude * pwm_period) / MAX_MAGNITUDE(0xFFFF) |
247 | */ | 251 | */ |
248 | period_mag_multi = (u64)haptic->pwm_dev->period * haptic->magnitude; | 252 | pwm_get_args(haptic->pwm_dev, &pargs); |
253 | period_mag_multi = (u64)pargs.period * haptic->magnitude; | ||
249 | haptic->pwm_duty = (unsigned int)(period_mag_multi >> | 254 | haptic->pwm_duty = (unsigned int)(period_mag_multi >> |
250 | MAX_MAGNITUDE_SHIFT); | 255 | MAX_MAGNITUDE_SHIFT); |
251 | 256 | ||
@@ -329,6 +334,12 @@ static int max77693_haptic_probe(struct platform_device *pdev) | |||
329 | return PTR_ERR(haptic->pwm_dev); | 334 | return PTR_ERR(haptic->pwm_dev); |
330 | } | 335 | } |
331 | 336 | ||
337 | /* | ||
338 | * FIXME: pwm_apply_args() should be removed when switching to the | ||
339 | * atomic PWM API. | ||
340 | */ | ||
341 | pwm_apply_args(haptic->pwm_dev); | ||
342 | |||
332 | haptic->motor_reg = devm_regulator_get(&pdev->dev, "haptic"); | 343 | haptic->motor_reg = devm_regulator_get(&pdev->dev, "haptic"); |
333 | if (IS_ERR(haptic->motor_reg)) { | 344 | if (IS_ERR(haptic->motor_reg)) { |
334 | dev_err(&pdev->dev, "failed to get regulator\n"); | 345 | dev_err(&pdev->dev, "failed to get regulator\n"); |
diff --git a/drivers/input/misc/max8997_haptic.c b/drivers/input/misc/max8997_haptic.c index a806ba3818f7..bf17f654ed88 100644 --- a/drivers/input/misc/max8997_haptic.c +++ b/drivers/input/misc/max8997_haptic.c | |||
@@ -304,6 +304,12 @@ static int max8997_haptic_probe(struct platform_device *pdev) | |||
304 | error); | 304 | error); |
305 | goto err_free_mem; | 305 | goto err_free_mem; |
306 | } | 306 | } |
307 | |||
308 | /* | ||
309 | * FIXME: pwm_apply_args() should be removed when switching to | ||
310 | * the atomic PWM API. | ||
311 | */ | ||
312 | pwm_apply_args(chip->pwm); | ||
307 | break; | 313 | break; |
308 | 314 | ||
309 | default: | 315 | default: |
diff --git a/drivers/input/misc/pwm-beeper.c b/drivers/input/misc/pwm-beeper.c index f2261ab54701..8d7133268745 100644 --- a/drivers/input/misc/pwm-beeper.c +++ b/drivers/input/misc/pwm-beeper.c | |||
@@ -87,6 +87,12 @@ static int pwm_beeper_probe(struct platform_device *pdev) | |||
87 | goto err_free; | 87 | goto err_free; |
88 | } | 88 | } |
89 | 89 | ||
90 | /* | ||
91 | * FIXME: pwm_apply_args() should be removed when switching to | ||
92 | * the atomic PWM API. | ||
93 | */ | ||
94 | pwm_apply_args(beeper->pwm); | ||
95 | |||
90 | beeper->input = input_allocate_device(); | 96 | beeper->input = input_allocate_device(); |
91 | if (!beeper->input) { | 97 | if (!beeper->input) { |
92 | dev_err(&pdev->dev, "Failed to allocate input device\n"); | 98 | dev_err(&pdev->dev, "Failed to allocate input device\n"); |
diff --git a/drivers/leds/leds-pwm.c b/drivers/leds/leds-pwm.c index 4783bacb2e9d..a9145aa7f36a 100644 --- a/drivers/leds/leds-pwm.c +++ b/drivers/leds/leds-pwm.c | |||
@@ -91,6 +91,7 @@ static int led_pwm_add(struct device *dev, struct led_pwm_priv *priv, | |||
91 | struct led_pwm *led, struct device_node *child) | 91 | struct led_pwm *led, struct device_node *child) |
92 | { | 92 | { |
93 | struct led_pwm_data *led_data = &priv->leds[priv->num_leds]; | 93 | struct led_pwm_data *led_data = &priv->leds[priv->num_leds]; |
94 | struct pwm_args pargs; | ||
94 | int ret; | 95 | int ret; |
95 | 96 | ||
96 | led_data->active_low = led->active_low; | 97 | led_data->active_low = led->active_low; |
@@ -117,7 +118,15 @@ static int led_pwm_add(struct device *dev, struct led_pwm_priv *priv, | |||
117 | else | 118 | else |
118 | led_data->cdev.brightness_set_blocking = led_pwm_set_blocking; | 119 | led_data->cdev.brightness_set_blocking = led_pwm_set_blocking; |
119 | 120 | ||
120 | led_data->period = pwm_get_period(led_data->pwm); | 121 | /* |
122 | * FIXME: pwm_apply_args() should be removed when switching to the | ||
123 | * atomic PWM API. | ||
124 | */ | ||
125 | pwm_apply_args(led_data->pwm); | ||
126 | |||
127 | pwm_get_args(led_data->pwm, &pargs); | ||
128 | |||
129 | led_data->period = pargs.period; | ||
121 | if (!led_data->period && (led->pwm_period_ns > 0)) | 130 | if (!led_data->period && (led->pwm_period_ns > 0)) |
122 | led_data->period = led->pwm_period_ns; | 131 | led_data->period = led->pwm_period_ns; |
123 | 132 | ||
diff --git a/drivers/pwm/core.c b/drivers/pwm/core.c index e4de9156974d..dba3843c53b8 100644 --- a/drivers/pwm/core.c +++ b/drivers/pwm/core.c | |||
@@ -227,6 +227,19 @@ void *pwm_get_chip_data(struct pwm_device *pwm) | |||
227 | } | 227 | } |
228 | EXPORT_SYMBOL_GPL(pwm_get_chip_data); | 228 | EXPORT_SYMBOL_GPL(pwm_get_chip_data); |
229 | 229 | ||
230 | static bool pwm_ops_check(const struct pwm_ops *ops) | ||
231 | { | ||
232 | /* driver supports legacy, non-atomic operation */ | ||
233 | if (ops->config && ops->enable && ops->disable) | ||
234 | return true; | ||
235 | |||
236 | /* driver supports atomic operation */ | ||
237 | if (ops->apply) | ||
238 | return true; | ||
239 | |||
240 | return false; | ||
241 | } | ||
242 | |||
230 | /** | 243 | /** |
231 | * pwmchip_add_with_polarity() - register a new PWM chip | 244 | * pwmchip_add_with_polarity() - register a new PWM chip |
232 | * @chip: the PWM chip to add | 245 | * @chip: the PWM chip to add |
@@ -245,8 +258,10 @@ int pwmchip_add_with_polarity(struct pwm_chip *chip, | |||
245 | unsigned int i; | 258 | unsigned int i; |
246 | int ret; | 259 | int ret; |
247 | 260 | ||
248 | if (!chip || !chip->dev || !chip->ops || !chip->ops->config || | 261 | if (!chip || !chip->dev || !chip->ops || !chip->npwm) |
249 | !chip->ops->enable || !chip->ops->disable || !chip->npwm) | 262 | return -EINVAL; |
263 | |||
264 | if (!pwm_ops_check(chip->ops)) | ||
250 | return -EINVAL; | 265 | return -EINVAL; |
251 | 266 | ||
252 | mutex_lock(&pwm_lock); | 267 | mutex_lock(&pwm_lock); |
@@ -269,8 +284,10 @@ int pwmchip_add_with_polarity(struct pwm_chip *chip, | |||
269 | pwm->chip = chip; | 284 | pwm->chip = chip; |
270 | pwm->pwm = chip->base + i; | 285 | pwm->pwm = chip->base + i; |
271 | pwm->hwpwm = i; | 286 | pwm->hwpwm = i; |
272 | pwm->polarity = polarity; | 287 | pwm->state.polarity = polarity; |
273 | mutex_init(&pwm->lock); | 288 | |
289 | if (chip->ops->get_state) | ||
290 | chip->ops->get_state(chip, pwm, &pwm->state); | ||
274 | 291 | ||
275 | radix_tree_insert(&pwm_tree, pwm->pwm, pwm); | 292 | radix_tree_insert(&pwm_tree, pwm->pwm, pwm); |
276 | } | 293 | } |
@@ -430,107 +447,138 @@ void pwm_free(struct pwm_device *pwm) | |||
430 | EXPORT_SYMBOL_GPL(pwm_free); | 447 | EXPORT_SYMBOL_GPL(pwm_free); |
431 | 448 | ||
432 | /** | 449 | /** |
433 | * pwm_config() - change a PWM device configuration | 450 | * pwm_apply_state() - atomically apply a new state to a PWM device |
434 | * @pwm: PWM device | 451 | * @pwm: PWM device |
435 | * @duty_ns: "on" time (in nanoseconds) | 452 | * @state: new state to apply. This can be adjusted by the PWM driver |
436 | * @period_ns: duration (in nanoseconds) of one cycle | 453 | * if the requested config is not achievable, for example, |
437 | * | 454 | * ->duty_cycle and ->period might be approximated. |
438 | * Returns: 0 on success or a negative error code on failure. | ||
439 | */ | 455 | */ |
440 | int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns) | 456 | int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state) |
441 | { | 457 | { |
442 | int err; | 458 | int err; |
443 | 459 | ||
444 | if (!pwm || duty_ns < 0 || period_ns <= 0 || duty_ns > period_ns) | 460 | if (!pwm) |
445 | return -EINVAL; | 461 | return -EINVAL; |
446 | 462 | ||
447 | err = pwm->chip->ops->config(pwm->chip, pwm, duty_ns, period_ns); | 463 | if (!memcmp(state, &pwm->state, sizeof(*state))) |
448 | if (err) | 464 | return 0; |
449 | return err; | ||
450 | |||
451 | pwm->duty_cycle = duty_ns; | ||
452 | pwm->period = period_ns; | ||
453 | 465 | ||
454 | return 0; | 466 | if (pwm->chip->ops->apply) { |
455 | } | 467 | err = pwm->chip->ops->apply(pwm->chip, pwm, state); |
456 | EXPORT_SYMBOL_GPL(pwm_config); | 468 | if (err) |
469 | return err; | ||
457 | 470 | ||
458 | /** | 471 | pwm->state = *state; |
459 | * pwm_set_polarity() - configure the polarity of a PWM signal | 472 | } else { |
460 | * @pwm: PWM device | 473 | /* |
461 | * @polarity: new polarity of the PWM signal | 474 | * FIXME: restore the initial state in case of error. |
462 | * | 475 | */ |
463 | * Note that the polarity cannot be configured while the PWM device is | 476 | if (state->polarity != pwm->state.polarity) { |
464 | * enabled. | 477 | if (!pwm->chip->ops->set_polarity) |
465 | * | 478 | return -ENOTSUPP; |
466 | * Returns: 0 on success or a negative error code on failure. | 479 | |
467 | */ | 480 | /* |
468 | int pwm_set_polarity(struct pwm_device *pwm, enum pwm_polarity polarity) | 481 | * Changing the polarity of a running PWM is |
469 | { | 482 | * only allowed when the PWM driver implements |
470 | int err; | 483 | * ->apply(). |
484 | */ | ||
485 | if (pwm->state.enabled) { | ||
486 | pwm->chip->ops->disable(pwm->chip, pwm); | ||
487 | pwm->state.enabled = false; | ||
488 | } | ||
489 | |||
490 | err = pwm->chip->ops->set_polarity(pwm->chip, pwm, | ||
491 | state->polarity); | ||
492 | if (err) | ||
493 | return err; | ||
494 | |||
495 | pwm->state.polarity = state->polarity; | ||
496 | } | ||
471 | 497 | ||
472 | if (!pwm || !pwm->chip->ops) | 498 | if (state->period != pwm->state.period || |
473 | return -EINVAL; | 499 | state->duty_cycle != pwm->state.duty_cycle) { |
500 | err = pwm->chip->ops->config(pwm->chip, pwm, | ||
501 | state->duty_cycle, | ||
502 | state->period); | ||
503 | if (err) | ||
504 | return err; | ||
474 | 505 | ||
475 | if (!pwm->chip->ops->set_polarity) | 506 | pwm->state.duty_cycle = state->duty_cycle; |
476 | return -ENOSYS; | 507 | pwm->state.period = state->period; |
508 | } | ||
477 | 509 | ||
478 | mutex_lock(&pwm->lock); | 510 | if (state->enabled != pwm->state.enabled) { |
511 | if (state->enabled) { | ||
512 | err = pwm->chip->ops->enable(pwm->chip, pwm); | ||
513 | if (err) | ||
514 | return err; | ||
515 | } else { | ||
516 | pwm->chip->ops->disable(pwm->chip, pwm); | ||
517 | } | ||
479 | 518 | ||
480 | if (pwm_is_enabled(pwm)) { | 519 | pwm->state.enabled = state->enabled; |
481 | err = -EBUSY; | 520 | } |
482 | goto unlock; | ||
483 | } | 521 | } |
484 | 522 | ||
485 | err = pwm->chip->ops->set_polarity(pwm->chip, pwm, polarity); | 523 | return 0; |
486 | if (err) | ||
487 | goto unlock; | ||
488 | |||
489 | pwm->polarity = polarity; | ||
490 | |||
491 | unlock: | ||
492 | mutex_unlock(&pwm->lock); | ||
493 | return err; | ||
494 | } | 524 | } |
495 | EXPORT_SYMBOL_GPL(pwm_set_polarity); | 525 | EXPORT_SYMBOL_GPL(pwm_apply_state); |
496 | 526 | ||
497 | /** | 527 | /** |
498 | * pwm_enable() - start a PWM output toggling | 528 | * pwm_adjust_config() - adjust the current PWM config to the PWM arguments |
499 | * @pwm: PWM device | 529 | * @pwm: PWM device |
500 | * | 530 | * |
501 | * Returns: 0 on success or a negative error code on failure. | 531 | * This function will adjust the PWM config to the PWM arguments provided |
532 | * by the DT or PWM lookup table. This is particularly useful to adapt | ||
533 | * the bootloader config to the Linux one. | ||
502 | */ | 534 | */ |
503 | int pwm_enable(struct pwm_device *pwm) | 535 | int pwm_adjust_config(struct pwm_device *pwm) |
504 | { | 536 | { |
505 | int err = 0; | 537 | struct pwm_state state; |
538 | struct pwm_args pargs; | ||
506 | 539 | ||
507 | if (!pwm) | 540 | pwm_get_args(pwm, &pargs); |
508 | return -EINVAL; | 541 | pwm_get_state(pwm, &state); |
509 | 542 | ||
510 | mutex_lock(&pwm->lock); | 543 | /* |
544 | * If the current period is zero it means that either the PWM driver | ||
545 | * does not support initial state retrieval or the PWM has not yet | ||
546 | * been configured. | ||
547 | * | ||
548 | * In either case, we setup the new period and polarity, and assign a | ||
549 | * duty cycle of 0. | ||
550 | */ | ||
551 | if (!state.period) { | ||
552 | state.duty_cycle = 0; | ||
553 | state.period = pargs.period; | ||
554 | state.polarity = pargs.polarity; | ||
511 | 555 | ||
512 | if (!test_and_set_bit(PWMF_ENABLED, &pwm->flags)) { | 556 | return pwm_apply_state(pwm, &state); |
513 | err = pwm->chip->ops->enable(pwm->chip, pwm); | ||
514 | if (err) | ||
515 | clear_bit(PWMF_ENABLED, &pwm->flags); | ||
516 | } | 557 | } |
517 | 558 | ||
518 | mutex_unlock(&pwm->lock); | 559 | /* |
560 | * Adjust the PWM duty cycle/period based on the period value provided | ||
561 | * in PWM args. | ||
562 | */ | ||
563 | if (pargs.period != state.period) { | ||
564 | u64 dutycycle = (u64)state.duty_cycle * pargs.period; | ||
519 | 565 | ||
520 | return err; | 566 | do_div(dutycycle, state.period); |
521 | } | 567 | state.duty_cycle = dutycycle; |
522 | EXPORT_SYMBOL_GPL(pwm_enable); | 568 | state.period = pargs.period; |
569 | } | ||
523 | 570 | ||
524 | /** | 571 | /* |
525 | * pwm_disable() - stop a PWM output toggling | 572 | * If the polarity changed, we should also change the duty cycle. |
526 | * @pwm: PWM device | 573 | */ |
527 | */ | 574 | if (pargs.polarity != state.polarity) { |
528 | void pwm_disable(struct pwm_device *pwm) | 575 | state.polarity = pargs.polarity; |
529 | { | 576 | state.duty_cycle = state.period - state.duty_cycle; |
530 | if (pwm && test_and_clear_bit(PWMF_ENABLED, &pwm->flags)) | 577 | } |
531 | pwm->chip->ops->disable(pwm->chip, pwm); | 578 | |
579 | return pwm_apply_state(pwm, &state); | ||
532 | } | 580 | } |
533 | EXPORT_SYMBOL_GPL(pwm_disable); | 581 | EXPORT_SYMBOL_GPL(pwm_adjust_config); |
534 | 582 | ||
535 | static struct pwm_chip *of_node_to_pwmchip(struct device_node *np) | 583 | static struct pwm_chip *of_node_to_pwmchip(struct device_node *np) |
536 | { | 584 | { |
@@ -621,13 +669,6 @@ struct pwm_device *of_pwm_get(struct device_node *np, const char *con_id) | |||
621 | 669 | ||
622 | pwm->label = con_id; | 670 | pwm->label = con_id; |
623 | 671 | ||
624 | /* | ||
625 | * FIXME: This should be removed once all PWM users properly make use | ||
626 | * of struct pwm_args to initialize the PWM device. As long as this is | ||
627 | * here, the PWM state and hardware state can get out of sync. | ||
628 | */ | ||
629 | pwm_apply_args(pwm); | ||
630 | |||
631 | put: | 672 | put: |
632 | of_node_put(args.np); | 673 | of_node_put(args.np); |
633 | 674 | ||
@@ -762,13 +803,6 @@ struct pwm_device *pwm_get(struct device *dev, const char *con_id) | |||
762 | pwm->args.period = chosen->period; | 803 | pwm->args.period = chosen->period; |
763 | pwm->args.polarity = chosen->polarity; | 804 | pwm->args.polarity = chosen->polarity; |
764 | 805 | ||
765 | /* | ||
766 | * FIXME: This should be removed once all PWM users properly make use | ||
767 | * of struct pwm_args to initialize the PWM device. As long as this is | ||
768 | * here, the PWM state and hardware state can get out of sync. | ||
769 | */ | ||
770 | pwm_apply_args(pwm); | ||
771 | |||
772 | out: | 806 | out: |
773 | mutex_unlock(&pwm_lookup_lock); | 807 | mutex_unlock(&pwm_lookup_lock); |
774 | return pwm; | 808 | return pwm; |
@@ -915,15 +949,23 @@ static void pwm_dbg_show(struct pwm_chip *chip, struct seq_file *s) | |||
915 | 949 | ||
916 | for (i = 0; i < chip->npwm; i++) { | 950 | for (i = 0; i < chip->npwm; i++) { |
917 | struct pwm_device *pwm = &chip->pwms[i]; | 951 | struct pwm_device *pwm = &chip->pwms[i]; |
952 | struct pwm_state state; | ||
953 | |||
954 | pwm_get_state(pwm, &state); | ||
918 | 955 | ||
919 | seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label); | 956 | seq_printf(s, " pwm-%-3d (%-20.20s):", i, pwm->label); |
920 | 957 | ||
921 | if (test_bit(PWMF_REQUESTED, &pwm->flags)) | 958 | if (test_bit(PWMF_REQUESTED, &pwm->flags)) |
922 | seq_puts(s, " requested"); | 959 | seq_puts(s, " requested"); |
923 | 960 | ||
924 | if (pwm_is_enabled(pwm)) | 961 | if (state.enabled) |
925 | seq_puts(s, " enabled"); | 962 | seq_puts(s, " enabled"); |
926 | 963 | ||
964 | seq_printf(s, " period: %u ns", state.period); | ||
965 | seq_printf(s, " duty: %u ns", state.duty_cycle); | ||
966 | seq_printf(s, " polarity: %s", | ||
967 | state.polarity ? "inverse" : "normal"); | ||
968 | |||
927 | seq_puts(s, "\n"); | 969 | seq_puts(s, "\n"); |
928 | } | 970 | } |
929 | } | 971 | } |
diff --git a/drivers/pwm/pwm-crc.c b/drivers/pwm/pwm-crc.c index 7101c7020bf4..bd0ebd04856a 100644 --- a/drivers/pwm/pwm-crc.c +++ b/drivers/pwm/pwm-crc.c | |||
@@ -75,7 +75,7 @@ static int crc_pwm_config(struct pwm_chip *c, struct pwm_device *pwm, | |||
75 | return -EINVAL; | 75 | return -EINVAL; |
76 | } | 76 | } |
77 | 77 | ||
78 | if (pwm->period != period_ns) { | 78 | if (pwm_get_period(pwm) != period_ns) { |
79 | int clk_div; | 79 | int clk_div; |
80 | 80 | ||
81 | /* changing the clk divisor, need to disable fisrt */ | 81 | /* changing the clk divisor, need to disable fisrt */ |
diff --git a/drivers/pwm/pwm-lpc18xx-sct.c b/drivers/pwm/pwm-lpc18xx-sct.c index 9861fed4e67d..19dc64cab2f0 100644 --- a/drivers/pwm/pwm-lpc18xx-sct.c +++ b/drivers/pwm/pwm-lpc18xx-sct.c | |||
@@ -249,7 +249,7 @@ static int lpc18xx_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm) | |||
249 | LPC18XX_PWM_EVSTATEMSK(lpc18xx_data->duty_event), | 249 | LPC18XX_PWM_EVSTATEMSK(lpc18xx_data->duty_event), |
250 | LPC18XX_PWM_EVSTATEMSK_ALL); | 250 | LPC18XX_PWM_EVSTATEMSK_ALL); |
251 | 251 | ||
252 | if (pwm->polarity == PWM_POLARITY_NORMAL) { | 252 | if (pwm_get_polarity(pwm) == PWM_POLARITY_NORMAL) { |
253 | set_event = lpc18xx_pwm->period_event; | 253 | set_event = lpc18xx_pwm->period_event; |
254 | clear_event = lpc18xx_data->duty_event; | 254 | clear_event = lpc18xx_data->duty_event; |
255 | res_action = LPC18XX_PWM_RES_SET; | 255 | res_action = LPC18XX_PWM_RES_SET; |
diff --git a/drivers/pwm/pwm-omap-dmtimer.c b/drivers/pwm/pwm-omap-dmtimer.c index b7e6ecba7d5c..3e95090cd7cf 100644 --- a/drivers/pwm/pwm-omap-dmtimer.c +++ b/drivers/pwm/pwm-omap-dmtimer.c | |||
@@ -192,7 +192,7 @@ static int pwm_omap_dmtimer_config(struct pwm_chip *chip, | |||
192 | load_value, load_value, match_value, match_value); | 192 | load_value, load_value, match_value, match_value); |
193 | 193 | ||
194 | omap->pdata->set_pwm(omap->dm_timer, | 194 | omap->pdata->set_pwm(omap->dm_timer, |
195 | pwm->polarity == PWM_POLARITY_INVERSED, | 195 | pwm_get_polarity(pwm) == PWM_POLARITY_INVERSED, |
196 | true, | 196 | true, |
197 | PWM_OMAP_DMTIMER_TRIGGER_OVERFLOW_AND_COMPARE); | 197 | PWM_OMAP_DMTIMER_TRIGGER_OVERFLOW_AND_COMPARE); |
198 | 198 | ||
diff --git a/drivers/pwm/pwm-rcar.c b/drivers/pwm/pwm-rcar.c index 7b8ac0678137..1c85ecc9e7ac 100644 --- a/drivers/pwm/pwm-rcar.c +++ b/drivers/pwm/pwm-rcar.c | |||
@@ -157,7 +157,7 @@ static int rcar_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm, | |||
157 | return div; | 157 | return div; |
158 | 158 | ||
159 | /* Let the core driver set pwm->period if disabled and duty_ns == 0 */ | 159 | /* Let the core driver set pwm->period if disabled and duty_ns == 0 */ |
160 | if (!test_bit(PWMF_ENABLED, &pwm->flags) && !duty_ns) | 160 | if (!pwm_is_enabled(pwm) && !duty_ns) |
161 | return 0; | 161 | return 0; |
162 | 162 | ||
163 | rcar_pwm_update(rp, RCAR_PWMCR_SYNC, RCAR_PWMCR_SYNC, RCAR_PWMCR); | 163 | rcar_pwm_update(rp, RCAR_PWMCR_SYNC, RCAR_PWMCR_SYNC, RCAR_PWMCR); |
diff --git a/drivers/pwm/pwm-sun4i.c b/drivers/pwm/pwm-sun4i.c index 67af9f62361f..03a99a53c39e 100644 --- a/drivers/pwm/pwm-sun4i.c +++ b/drivers/pwm/pwm-sun4i.c | |||
@@ -354,7 +354,8 @@ static int sun4i_pwm_probe(struct platform_device *pdev) | |||
354 | val = sun4i_pwm_readl(pwm, PWM_CTRL_REG); | 354 | val = sun4i_pwm_readl(pwm, PWM_CTRL_REG); |
355 | for (i = 0; i < pwm->chip.npwm; i++) | 355 | for (i = 0; i < pwm->chip.npwm; i++) |
356 | if (!(val & BIT_CH(PWM_ACT_STATE, i))) | 356 | if (!(val & BIT_CH(PWM_ACT_STATE, i))) |
357 | pwm->chip.pwms[i].polarity = PWM_POLARITY_INVERSED; | 357 | pwm_set_polarity(&pwm->chip.pwms[i], |
358 | PWM_POLARITY_INVERSED); | ||
358 | clk_disable_unprepare(pwm->clk); | 359 | clk_disable_unprepare(pwm->clk); |
359 | 360 | ||
360 | return 0; | 361 | return 0; |
diff --git a/drivers/pwm/sysfs.c b/drivers/pwm/sysfs.c index 9c90886f4123..d98599249a05 100644 --- a/drivers/pwm/sysfs.c +++ b/drivers/pwm/sysfs.c | |||
@@ -26,6 +26,7 @@ | |||
26 | struct pwm_export { | 26 | struct pwm_export { |
27 | struct device child; | 27 | struct device child; |
28 | struct pwm_device *pwm; | 28 | struct pwm_device *pwm; |
29 | struct mutex lock; | ||
29 | }; | 30 | }; |
30 | 31 | ||
31 | static struct pwm_export *child_to_pwm_export(struct device *child) | 32 | static struct pwm_export *child_to_pwm_export(struct device *child) |
@@ -45,15 +46,20 @@ static ssize_t period_show(struct device *child, | |||
45 | char *buf) | 46 | char *buf) |
46 | { | 47 | { |
47 | const struct pwm_device *pwm = child_to_pwm_device(child); | 48 | const struct pwm_device *pwm = child_to_pwm_device(child); |
49 | struct pwm_state state; | ||
48 | 50 | ||
49 | return sprintf(buf, "%u\n", pwm_get_period(pwm)); | 51 | pwm_get_state(pwm, &state); |
52 | |||
53 | return sprintf(buf, "%u\n", state.period); | ||
50 | } | 54 | } |
51 | 55 | ||
52 | static ssize_t period_store(struct device *child, | 56 | static ssize_t period_store(struct device *child, |
53 | struct device_attribute *attr, | 57 | struct device_attribute *attr, |
54 | const char *buf, size_t size) | 58 | const char *buf, size_t size) |
55 | { | 59 | { |
56 | struct pwm_device *pwm = child_to_pwm_device(child); | 60 | struct pwm_export *export = child_to_pwm_export(child); |
61 | struct pwm_device *pwm = export->pwm; | ||
62 | struct pwm_state state; | ||
57 | unsigned int val; | 63 | unsigned int val; |
58 | int ret; | 64 | int ret; |
59 | 65 | ||
@@ -61,7 +67,11 @@ static ssize_t period_store(struct device *child, | |||
61 | if (ret) | 67 | if (ret) |
62 | return ret; | 68 | return ret; |
63 | 69 | ||
64 | ret = pwm_config(pwm, pwm_get_duty_cycle(pwm), val); | 70 | mutex_lock(&export->lock); |
71 | pwm_get_state(pwm, &state); | ||
72 | state.period = val; | ||
73 | ret = pwm_apply_state(pwm, &state); | ||
74 | mutex_unlock(&export->lock); | ||
65 | 75 | ||
66 | return ret ? : size; | 76 | return ret ? : size; |
67 | } | 77 | } |
@@ -71,15 +81,20 @@ static ssize_t duty_cycle_show(struct device *child, | |||
71 | char *buf) | 81 | char *buf) |
72 | { | 82 | { |
73 | const struct pwm_device *pwm = child_to_pwm_device(child); | 83 | const struct pwm_device *pwm = child_to_pwm_device(child); |
84 | struct pwm_state state; | ||
85 | |||
86 | pwm_get_state(pwm, &state); | ||
74 | 87 | ||
75 | return sprintf(buf, "%u\n", pwm_get_duty_cycle(pwm)); | 88 | return sprintf(buf, "%u\n", state.duty_cycle); |
76 | } | 89 | } |
77 | 90 | ||
78 | static ssize_t duty_cycle_store(struct device *child, | 91 | static ssize_t duty_cycle_store(struct device *child, |
79 | struct device_attribute *attr, | 92 | struct device_attribute *attr, |
80 | const char *buf, size_t size) | 93 | const char *buf, size_t size) |
81 | { | 94 | { |
82 | struct pwm_device *pwm = child_to_pwm_device(child); | 95 | struct pwm_export *export = child_to_pwm_export(child); |
96 | struct pwm_device *pwm = export->pwm; | ||
97 | struct pwm_state state; | ||
83 | unsigned int val; | 98 | unsigned int val; |
84 | int ret; | 99 | int ret; |
85 | 100 | ||
@@ -87,7 +102,11 @@ static ssize_t duty_cycle_store(struct device *child, | |||
87 | if (ret) | 102 | if (ret) |
88 | return ret; | 103 | return ret; |
89 | 104 | ||
90 | ret = pwm_config(pwm, val, pwm_get_period(pwm)); | 105 | mutex_lock(&export->lock); |
106 | pwm_get_state(pwm, &state); | ||
107 | state.duty_cycle = val; | ||
108 | ret = pwm_apply_state(pwm, &state); | ||
109 | mutex_unlock(&export->lock); | ||
91 | 110 | ||
92 | return ret ? : size; | 111 | return ret ? : size; |
93 | } | 112 | } |
@@ -97,33 +116,46 @@ static ssize_t enable_show(struct device *child, | |||
97 | char *buf) | 116 | char *buf) |
98 | { | 117 | { |
99 | const struct pwm_device *pwm = child_to_pwm_device(child); | 118 | const struct pwm_device *pwm = child_to_pwm_device(child); |
119 | struct pwm_state state; | ||
120 | |||
121 | pwm_get_state(pwm, &state); | ||
100 | 122 | ||
101 | return sprintf(buf, "%d\n", pwm_is_enabled(pwm)); | 123 | return sprintf(buf, "%d\n", state.enabled); |
102 | } | 124 | } |
103 | 125 | ||
104 | static ssize_t enable_store(struct device *child, | 126 | static ssize_t enable_store(struct device *child, |
105 | struct device_attribute *attr, | 127 | struct device_attribute *attr, |
106 | const char *buf, size_t size) | 128 | const char *buf, size_t size) |
107 | { | 129 | { |
108 | struct pwm_device *pwm = child_to_pwm_device(child); | 130 | struct pwm_export *export = child_to_pwm_export(child); |
131 | struct pwm_device *pwm = export->pwm; | ||
132 | struct pwm_state state; | ||
109 | int val, ret; | 133 | int val, ret; |
110 | 134 | ||
111 | ret = kstrtoint(buf, 0, &val); | 135 | ret = kstrtoint(buf, 0, &val); |
112 | if (ret) | 136 | if (ret) |
113 | return ret; | 137 | return ret; |
114 | 138 | ||
139 | mutex_lock(&export->lock); | ||
140 | |||
141 | pwm_get_state(pwm, &state); | ||
142 | |||
115 | switch (val) { | 143 | switch (val) { |
116 | case 0: | 144 | case 0: |
117 | pwm_disable(pwm); | 145 | state.enabled = false; |
118 | break; | 146 | break; |
119 | case 1: | 147 | case 1: |
120 | ret = pwm_enable(pwm); | 148 | state.enabled = true; |
121 | break; | 149 | break; |
122 | default: | 150 | default: |
123 | ret = -EINVAL; | 151 | ret = -EINVAL; |
124 | break; | 152 | goto unlock; |
125 | } | 153 | } |
126 | 154 | ||
155 | pwm_apply_state(pwm, &state); | ||
156 | |||
157 | unlock: | ||
158 | mutex_unlock(&export->lock); | ||
127 | return ret ? : size; | 159 | return ret ? : size; |
128 | } | 160 | } |
129 | 161 | ||
@@ -133,8 +165,11 @@ static ssize_t polarity_show(struct device *child, | |||
133 | { | 165 | { |
134 | const struct pwm_device *pwm = child_to_pwm_device(child); | 166 | const struct pwm_device *pwm = child_to_pwm_device(child); |
135 | const char *polarity = "unknown"; | 167 | const char *polarity = "unknown"; |
168 | struct pwm_state state; | ||
169 | |||
170 | pwm_get_state(pwm, &state); | ||
136 | 171 | ||
137 | switch (pwm_get_polarity(pwm)) { | 172 | switch (state.polarity) { |
138 | case PWM_POLARITY_NORMAL: | 173 | case PWM_POLARITY_NORMAL: |
139 | polarity = "normal"; | 174 | polarity = "normal"; |
140 | break; | 175 | break; |
@@ -151,8 +186,10 @@ static ssize_t polarity_store(struct device *child, | |||
151 | struct device_attribute *attr, | 186 | struct device_attribute *attr, |
152 | const char *buf, size_t size) | 187 | const char *buf, size_t size) |
153 | { | 188 | { |
154 | struct pwm_device *pwm = child_to_pwm_device(child); | 189 | struct pwm_export *export = child_to_pwm_export(child); |
190 | struct pwm_device *pwm = export->pwm; | ||
155 | enum pwm_polarity polarity; | 191 | enum pwm_polarity polarity; |
192 | struct pwm_state state; | ||
156 | int ret; | 193 | int ret; |
157 | 194 | ||
158 | if (sysfs_streq(buf, "normal")) | 195 | if (sysfs_streq(buf, "normal")) |
@@ -162,7 +199,11 @@ static ssize_t polarity_store(struct device *child, | |||
162 | else | 199 | else |
163 | return -EINVAL; | 200 | return -EINVAL; |
164 | 201 | ||
165 | ret = pwm_set_polarity(pwm, polarity); | 202 | mutex_lock(&export->lock); |
203 | pwm_get_state(pwm, &state); | ||
204 | state.polarity = polarity; | ||
205 | ret = pwm_apply_state(pwm, &state); | ||
206 | mutex_unlock(&export->lock); | ||
166 | 207 | ||
167 | return ret ? : size; | 208 | return ret ? : size; |
168 | } | 209 | } |
@@ -203,6 +244,7 @@ static int pwm_export_child(struct device *parent, struct pwm_device *pwm) | |||
203 | } | 244 | } |
204 | 245 | ||
205 | export->pwm = pwm; | 246 | export->pwm = pwm; |
247 | mutex_init(&export->lock); | ||
206 | 248 | ||
207 | export->child.release = pwm_export_release; | 249 | export->child.release = pwm_export_release; |
208 | export->child.parent = parent; | 250 | export->child.parent = parent; |
diff --git a/drivers/video/backlight/lm3630a_bl.c b/drivers/video/backlight/lm3630a_bl.c index 35fe4825a454..60d6c2ac87aa 100644 --- a/drivers/video/backlight/lm3630a_bl.c +++ b/drivers/video/backlight/lm3630a_bl.c | |||
@@ -162,7 +162,7 @@ static int lm3630a_intr_config(struct lm3630a_chip *pchip) | |||
162 | 162 | ||
163 | static void lm3630a_pwm_ctrl(struct lm3630a_chip *pchip, int br, int br_max) | 163 | static void lm3630a_pwm_ctrl(struct lm3630a_chip *pchip, int br, int br_max) |
164 | { | 164 | { |
165 | unsigned int period = pwm_get_period(pchip->pwmd); | 165 | unsigned int period = pchip->pdata->pwm_period; |
166 | unsigned int duty = br * period / br_max; | 166 | unsigned int duty = br * period / br_max; |
167 | 167 | ||
168 | pwm_config(pchip->pwmd, duty, period); | 168 | pwm_config(pchip->pwmd, duty, period); |
@@ -424,8 +424,13 @@ static int lm3630a_probe(struct i2c_client *client, | |||
424 | dev_err(&client->dev, "fail : get pwm device\n"); | 424 | dev_err(&client->dev, "fail : get pwm device\n"); |
425 | return PTR_ERR(pchip->pwmd); | 425 | return PTR_ERR(pchip->pwmd); |
426 | } | 426 | } |
427 | |||
428 | /* | ||
429 | * FIXME: pwm_apply_args() should be removed when switching to | ||
430 | * the atomic PWM API. | ||
431 | */ | ||
432 | pwm_apply_args(pchip->pwmd); | ||
427 | } | 433 | } |
428 | pchip->pwmd->period = pdata->pwm_period; | ||
429 | 434 | ||
430 | /* interrupt enable : irq 0 is not allowed */ | 435 | /* interrupt enable : irq 0 is not allowed */ |
431 | pchip->irq = client->irq; | 436 | pchip->irq = client->irq; |
diff --git a/drivers/video/backlight/lp855x_bl.c b/drivers/video/backlight/lp855x_bl.c index daca9e6a2bb3..e5b14f52628f 100644 --- a/drivers/video/backlight/lp855x_bl.c +++ b/drivers/video/backlight/lp855x_bl.c | |||
@@ -246,6 +246,12 @@ static void lp855x_pwm_ctrl(struct lp855x *lp, int br, int max_br) | |||
246 | return; | 246 | return; |
247 | 247 | ||
248 | lp->pwm = pwm; | 248 | lp->pwm = pwm; |
249 | |||
250 | /* | ||
251 | * FIXME: pwm_apply_args() should be removed when switching to | ||
252 | * the atomic PWM API. | ||
253 | */ | ||
254 | pwm_apply_args(pwm); | ||
249 | } | 255 | } |
250 | 256 | ||
251 | pwm_config(lp->pwm, duty, period); | 257 | pwm_config(lp->pwm, duty, period); |
diff --git a/drivers/video/backlight/lp8788_bl.c b/drivers/video/backlight/lp8788_bl.c index 5d583d7a517b..cf869ec90cce 100644 --- a/drivers/video/backlight/lp8788_bl.c +++ b/drivers/video/backlight/lp8788_bl.c | |||
@@ -145,6 +145,12 @@ static void lp8788_pwm_ctrl(struct lp8788_bl *bl, int br, int max_br) | |||
145 | } | 145 | } |
146 | 146 | ||
147 | bl->pwm = pwm; | 147 | bl->pwm = pwm; |
148 | |||
149 | /* | ||
150 | * FIXME: pwm_apply_args() should be removed when switching to | ||
151 | * the atomic PWM API. | ||
152 | */ | ||
153 | pwm_apply_args(pwm); | ||
148 | } | 154 | } |
149 | 155 | ||
150 | pwm_config(bl->pwm, duty, period); | 156 | pwm_config(bl->pwm, duty, period); |
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c index 64f9e1b8655f..b2b366bb0f97 100644 --- a/drivers/video/backlight/pwm_bl.c +++ b/drivers/video/backlight/pwm_bl.c | |||
@@ -201,6 +201,7 @@ static int pwm_backlight_probe(struct platform_device *pdev) | |||
201 | struct device_node *node = pdev->dev.of_node; | 201 | struct device_node *node = pdev->dev.of_node; |
202 | struct pwm_bl_data *pb; | 202 | struct pwm_bl_data *pb; |
203 | int initial_blank = FB_BLANK_UNBLANK; | 203 | int initial_blank = FB_BLANK_UNBLANK; |
204 | struct pwm_args pargs; | ||
204 | int ret; | 205 | int ret; |
205 | 206 | ||
206 | if (!data) { | 207 | if (!data) { |
@@ -307,16 +308,21 @@ static int pwm_backlight_probe(struct platform_device *pdev) | |||
307 | dev_dbg(&pdev->dev, "got pwm for backlight\n"); | 308 | dev_dbg(&pdev->dev, "got pwm for backlight\n"); |
308 | 309 | ||
309 | /* | 310 | /* |
311 | * FIXME: pwm_apply_args() should be removed when switching to | ||
312 | * the atomic PWM API. | ||
313 | */ | ||
314 | pwm_apply_args(pb->pwm); | ||
315 | |||
316 | /* | ||
310 | * The DT case will set the pwm_period_ns field to 0 and store the | 317 | * The DT case will set the pwm_period_ns field to 0 and store the |
311 | * period, parsed from the DT, in the PWM device. For the non-DT case, | 318 | * period, parsed from the DT, in the PWM device. For the non-DT case, |
312 | * set the period from platform data if it has not already been set | 319 | * set the period from platform data if it has not already been set |
313 | * via the PWM lookup table. | 320 | * via the PWM lookup table. |
314 | */ | 321 | */ |
315 | pb->period = pwm_get_period(pb->pwm); | 322 | pwm_get_args(pb->pwm, &pargs); |
316 | if (!pb->period && (data->pwm_period_ns > 0)) { | 323 | pb->period = pargs.period; |
324 | if (!pb->period && (data->pwm_period_ns > 0)) | ||
317 | pb->period = data->pwm_period_ns; | 325 | pb->period = data->pwm_period_ns; |
318 | pwm_set_period(pb->pwm, data->pwm_period_ns); | ||
319 | } | ||
320 | 326 | ||
321 | pb->lth_brightness = data->lth_brightness * (pb->period / pb->scale); | 327 | pb->lth_brightness = data->lth_brightness * (pb->period / pb->scale); |
322 | 328 | ||
diff --git a/drivers/video/fbdev/ssd1307fb.c b/drivers/video/fbdev/ssd1307fb.c index fa3480815cdb..652f68880d60 100644 --- a/drivers/video/fbdev/ssd1307fb.c +++ b/drivers/video/fbdev/ssd1307fb.c | |||
@@ -286,6 +286,7 @@ static int ssd1307fb_init(struct ssd1307fb_par *par) | |||
286 | { | 286 | { |
287 | int ret; | 287 | int ret; |
288 | u32 precharge, dclk, com_invdir, compins; | 288 | u32 precharge, dclk, com_invdir, compins; |
289 | struct pwm_args pargs; | ||
289 | 290 | ||
290 | if (par->device_info->need_pwm) { | 291 | if (par->device_info->need_pwm) { |
291 | par->pwm = pwm_get(&par->client->dev, NULL); | 292 | par->pwm = pwm_get(&par->client->dev, NULL); |
@@ -294,7 +295,15 @@ static int ssd1307fb_init(struct ssd1307fb_par *par) | |||
294 | return PTR_ERR(par->pwm); | 295 | return PTR_ERR(par->pwm); |
295 | } | 296 | } |
296 | 297 | ||
297 | par->pwm_period = pwm_get_period(par->pwm); | 298 | /* |
299 | * FIXME: pwm_apply_args() should be removed when switching to | ||
300 | * the atomic PWM API. | ||
301 | */ | ||
302 | pwm_apply_args(par->pwm); | ||
303 | |||
304 | pwm_get_args(par->pwm, &pargs); | ||
305 | |||
306 | par->pwm_period = pargs.period; | ||
298 | /* Enable the PWM */ | 307 | /* Enable the PWM */ |
299 | pwm_config(par->pwm, par->pwm_period / 2, par->pwm_period); | 308 | pwm_config(par->pwm, par->pwm_period / 2, par->pwm_period); |
300 | pwm_enable(par->pwm); | 309 | pwm_enable(par->pwm); |
diff --git a/include/linux/pwm.h b/include/linux/pwm.h index b78d27c42629..17018f3c066e 100644 --- a/include/linux/pwm.h +++ b/include/linux/pwm.h | |||
@@ -5,59 +5,7 @@ | |||
5 | #include <linux/mutex.h> | 5 | #include <linux/mutex.h> |
6 | #include <linux/of.h> | 6 | #include <linux/of.h> |
7 | 7 | ||
8 | struct pwm_device; | ||
9 | struct seq_file; | 8 | struct seq_file; |
10 | |||
11 | #if IS_ENABLED(CONFIG_PWM) | ||
12 | /* | ||
13 | * pwm_request - request a PWM device | ||
14 | */ | ||
15 | struct pwm_device *pwm_request(int pwm_id, const char *label); | ||
16 | |||
17 | /* | ||
18 | * pwm_free - free a PWM device | ||
19 | */ | ||
20 | void pwm_free(struct pwm_device *pwm); | ||
21 | |||
22 | /* | ||
23 | * pwm_config - change a PWM device configuration | ||
24 | */ | ||
25 | int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns); | ||
26 | |||
27 | /* | ||
28 | * pwm_enable - start a PWM output toggling | ||
29 | */ | ||
30 | int pwm_enable(struct pwm_device *pwm); | ||
31 | |||
32 | /* | ||
33 | * pwm_disable - stop a PWM output toggling | ||
34 | */ | ||
35 | void pwm_disable(struct pwm_device *pwm); | ||
36 | #else | ||
37 | static inline struct pwm_device *pwm_request(int pwm_id, const char *label) | ||
38 | { | ||
39 | return ERR_PTR(-ENODEV); | ||
40 | } | ||
41 | |||
42 | static inline void pwm_free(struct pwm_device *pwm) | ||
43 | { | ||
44 | } | ||
45 | |||
46 | static inline int pwm_config(struct pwm_device *pwm, int duty_ns, int period_ns) | ||
47 | { | ||
48 | return -EINVAL; | ||
49 | } | ||
50 | |||
51 | static inline int pwm_enable(struct pwm_device *pwm) | ||
52 | { | ||
53 | return -EINVAL; | ||
54 | } | ||
55 | |||
56 | static inline void pwm_disable(struct pwm_device *pwm) | ||
57 | { | ||
58 | } | ||
59 | #endif | ||
60 | |||
61 | struct pwm_chip; | 9 | struct pwm_chip; |
62 | 10 | ||
63 | /** | 11 | /** |
@@ -94,8 +42,21 @@ struct pwm_args { | |||
94 | 42 | ||
95 | enum { | 43 | enum { |
96 | PWMF_REQUESTED = 1 << 0, | 44 | PWMF_REQUESTED = 1 << 0, |
97 | PWMF_ENABLED = 1 << 1, | 45 | PWMF_EXPORTED = 1 << 1, |
98 | PWMF_EXPORTED = 1 << 2, | 46 | }; |
47 | |||
48 | /* | ||
49 | * struct pwm_state - state of a PWM channel | ||
50 | * @period: PWM period (in nanoseconds) | ||
51 | * @duty_cycle: PWM duty cycle (in nanoseconds) | ||
52 | * @polarity: PWM polarity | ||
53 | * @enabled: PWM enabled status | ||
54 | */ | ||
55 | struct pwm_state { | ||
56 | unsigned int period; | ||
57 | unsigned int duty_cycle; | ||
58 | enum pwm_polarity polarity; | ||
59 | bool enabled; | ||
99 | }; | 60 | }; |
100 | 61 | ||
101 | /** | 62 | /** |
@@ -106,11 +67,8 @@ enum { | |||
106 | * @pwm: global index of the PWM device | 67 | * @pwm: global index of the PWM device |
107 | * @chip: PWM chip providing this PWM device | 68 | * @chip: PWM chip providing this PWM device |
108 | * @chip_data: chip-private data associated with the PWM device | 69 | * @chip_data: chip-private data associated with the PWM device |
109 | * @lock: used to serialize accesses to the PWM device where necessary | ||
110 | * @period: period of the PWM signal (in nanoseconds) | ||
111 | * @duty_cycle: duty cycle of the PWM signal (in nanoseconds) | ||
112 | * @polarity: polarity of the PWM signal | ||
113 | * @args: PWM arguments | 70 | * @args: PWM arguments |
71 | * @state: curent PWM channel state | ||
114 | */ | 72 | */ |
115 | struct pwm_device { | 73 | struct pwm_device { |
116 | const char *label; | 74 | const char *label; |
@@ -119,50 +77,68 @@ struct pwm_device { | |||
119 | unsigned int pwm; | 77 | unsigned int pwm; |
120 | struct pwm_chip *chip; | 78 | struct pwm_chip *chip; |
121 | void *chip_data; | 79 | void *chip_data; |
122 | struct mutex lock; | ||
123 | |||
124 | unsigned int period; | ||
125 | unsigned int duty_cycle; | ||
126 | enum pwm_polarity polarity; | ||
127 | 80 | ||
128 | struct pwm_args args; | 81 | struct pwm_args args; |
82 | struct pwm_state state; | ||
129 | }; | 83 | }; |
130 | 84 | ||
85 | /** | ||
86 | * pwm_get_state() - retrieve the current PWM state | ||
87 | * @pwm: PWM device | ||
88 | * @state: state to fill with the current PWM state | ||
89 | */ | ||
90 | static inline void pwm_get_state(const struct pwm_device *pwm, | ||
91 | struct pwm_state *state) | ||
92 | { | ||
93 | *state = pwm->state; | ||
94 | } | ||
95 | |||
131 | static inline bool pwm_is_enabled(const struct pwm_device *pwm) | 96 | static inline bool pwm_is_enabled(const struct pwm_device *pwm) |
132 | { | 97 | { |
133 | return test_bit(PWMF_ENABLED, &pwm->flags); | 98 | struct pwm_state state; |
99 | |||
100 | pwm_get_state(pwm, &state); | ||
101 | |||
102 | return state.enabled; | ||
134 | } | 103 | } |
135 | 104 | ||
136 | static inline void pwm_set_period(struct pwm_device *pwm, unsigned int period) | 105 | static inline void pwm_set_period(struct pwm_device *pwm, unsigned int period) |
137 | { | 106 | { |
138 | if (pwm) | 107 | if (pwm) |
139 | pwm->period = period; | 108 | pwm->state.period = period; |
140 | } | 109 | } |
141 | 110 | ||
142 | static inline unsigned int pwm_get_period(const struct pwm_device *pwm) | 111 | static inline unsigned int pwm_get_period(const struct pwm_device *pwm) |
143 | { | 112 | { |
144 | return pwm ? pwm->period : 0; | 113 | struct pwm_state state; |
114 | |||
115 | pwm_get_state(pwm, &state); | ||
116 | |||
117 | return state.period; | ||
145 | } | 118 | } |
146 | 119 | ||
147 | static inline void pwm_set_duty_cycle(struct pwm_device *pwm, unsigned int duty) | 120 | static inline void pwm_set_duty_cycle(struct pwm_device *pwm, unsigned int duty) |
148 | { | 121 | { |
149 | if (pwm) | 122 | if (pwm) |
150 | pwm->duty_cycle = duty; | 123 | pwm->state.duty_cycle = duty; |
151 | } | 124 | } |
152 | 125 | ||
153 | static inline unsigned int pwm_get_duty_cycle(const struct pwm_device *pwm) | 126 | static inline unsigned int pwm_get_duty_cycle(const struct pwm_device *pwm) |
154 | { | 127 | { |
155 | return pwm ? pwm->duty_cycle : 0; | 128 | struct pwm_state state; |
156 | } | ||
157 | 129 | ||
158 | /* | 130 | pwm_get_state(pwm, &state); |
159 | * pwm_set_polarity - configure the polarity of a PWM signal | 131 | |
160 | */ | 132 | return state.duty_cycle; |
161 | int pwm_set_polarity(struct pwm_device *pwm, enum pwm_polarity polarity); | 133 | } |
162 | 134 | ||
163 | static inline enum pwm_polarity pwm_get_polarity(const struct pwm_device *pwm) | 135 | static inline enum pwm_polarity pwm_get_polarity(const struct pwm_device *pwm) |
164 | { | 136 | { |
165 | return pwm ? pwm->polarity : PWM_POLARITY_NORMAL; | 137 | struct pwm_state state; |
138 | |||
139 | pwm_get_state(pwm, &state); | ||
140 | |||
141 | return state.polarity; | ||
166 | } | 142 | } |
167 | 143 | ||
168 | static inline void pwm_get_args(const struct pwm_device *pwm, | 144 | static inline void pwm_get_args(const struct pwm_device *pwm, |
@@ -171,12 +147,6 @@ static inline void pwm_get_args(const struct pwm_device *pwm, | |||
171 | *args = pwm->args; | 147 | *args = pwm->args; |
172 | } | 148 | } |
173 | 149 | ||
174 | static inline void pwm_apply_args(struct pwm_device *pwm) | ||
175 | { | ||
176 | pwm_set_period(pwm, pwm->args.period); | ||
177 | pwm_set_polarity(pwm, pwm->args.polarity); | ||
178 | } | ||
179 | |||
180 | /** | 150 | /** |
181 | * struct pwm_ops - PWM controller operations | 151 | * struct pwm_ops - PWM controller operations |
182 | * @request: optional hook for requesting a PWM | 152 | * @request: optional hook for requesting a PWM |
@@ -185,6 +155,13 @@ static inline void pwm_apply_args(struct pwm_device *pwm) | |||
185 | * @set_polarity: configure the polarity of this PWM | 155 | * @set_polarity: configure the polarity of this PWM |
186 | * @enable: enable PWM output toggling | 156 | * @enable: enable PWM output toggling |
187 | * @disable: disable PWM output toggling | 157 | * @disable: disable PWM output toggling |
158 | * @apply: atomically apply a new PWM config. The state argument | ||
159 | * should be adjusted with the real hardware config (if the | ||
160 | * approximate the period or duty_cycle value, state should | ||
161 | * reflect it) | ||
162 | * @get_state: get the current PWM state. This function is only | ||
163 | * called once per PWM device when the PWM chip is | ||
164 | * registered. | ||
188 | * @dbg_show: optional routine to show contents in debugfs | 165 | * @dbg_show: optional routine to show contents in debugfs |
189 | * @owner: helps prevent removal of modules exporting active PWMs | 166 | * @owner: helps prevent removal of modules exporting active PWMs |
190 | */ | 167 | */ |
@@ -197,6 +174,10 @@ struct pwm_ops { | |||
197 | enum pwm_polarity polarity); | 174 | enum pwm_polarity polarity); |
198 | int (*enable)(struct pwm_chip *chip, struct pwm_device *pwm); | 175 | int (*enable)(struct pwm_chip *chip, struct pwm_device *pwm); |
199 | void (*disable)(struct pwm_chip *chip, struct pwm_device *pwm); | 176 | void (*disable)(struct pwm_chip *chip, struct pwm_device *pwm); |
177 | int (*apply)(struct pwm_chip *chip, struct pwm_device *pwm, | ||
178 | struct pwm_state *state); | ||
179 | void (*get_state)(struct pwm_chip *chip, struct pwm_device *pwm, | ||
180 | struct pwm_state *state); | ||
200 | #ifdef CONFIG_DEBUG_FS | 181 | #ifdef CONFIG_DEBUG_FS |
201 | void (*dbg_show)(struct pwm_chip *chip, struct seq_file *s); | 182 | void (*dbg_show)(struct pwm_chip *chip, struct seq_file *s); |
202 | #endif | 183 | #endif |
@@ -232,6 +213,115 @@ struct pwm_chip { | |||
232 | }; | 213 | }; |
233 | 214 | ||
234 | #if IS_ENABLED(CONFIG_PWM) | 215 | #if IS_ENABLED(CONFIG_PWM) |
216 | /* PWM user APIs */ | ||
217 | struct pwm_device *pwm_request(int pwm_id, const char *label); | ||
218 | void pwm_free(struct pwm_device *pwm); | ||
219 | int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state); | ||
220 | int pwm_adjust_config(struct pwm_device *pwm); | ||
221 | |||
222 | /** | ||
223 | * pwm_config() - change a PWM device configuration | ||
224 | * @pwm: PWM device | ||
225 | * @duty_ns: "on" time (in nanoseconds) | ||
226 | * @period_ns: duration (in nanoseconds) of one cycle | ||
227 | * | ||
228 | * Returns: 0 on success or a negative error code on failure. | ||
229 | */ | ||
230 | static inline int pwm_config(struct pwm_device *pwm, int duty_ns, | ||
231 | int period_ns) | ||
232 | { | ||
233 | struct pwm_state state; | ||
234 | |||
235 | if (!pwm) | ||
236 | return -EINVAL; | ||
237 | |||
238 | pwm_get_state(pwm, &state); | ||
239 | if (state.duty_cycle == duty_ns && state.period == period_ns) | ||
240 | return 0; | ||
241 | |||
242 | state.duty_cycle = duty_ns; | ||
243 | state.period = period_ns; | ||
244 | return pwm_apply_state(pwm, &state); | ||
245 | } | ||
246 | |||
247 | /** | ||
248 | * pwm_set_polarity() - configure the polarity of a PWM signal | ||
249 | * @pwm: PWM device | ||
250 | * @polarity: new polarity of the PWM signal | ||
251 | * | ||
252 | * Note that the polarity cannot be configured while the PWM device is | ||
253 | * enabled. | ||
254 | * | ||
255 | * Returns: 0 on success or a negative error code on failure. | ||
256 | */ | ||
257 | static inline int pwm_set_polarity(struct pwm_device *pwm, | ||
258 | enum pwm_polarity polarity) | ||
259 | { | ||
260 | struct pwm_state state; | ||
261 | |||
262 | if (!pwm) | ||
263 | return -EINVAL; | ||
264 | |||
265 | pwm_get_state(pwm, &state); | ||
266 | if (state.polarity == polarity) | ||
267 | return 0; | ||
268 | |||
269 | /* | ||
270 | * Changing the polarity of a running PWM without adjusting the | ||
271 | * dutycycle/period value is a bit risky (can introduce glitches). | ||
272 | * Return -EBUSY in this case. | ||
273 | * Note that this is allowed when using pwm_apply_state() because | ||
274 | * the user specifies all the parameters. | ||
275 | */ | ||
276 | if (state.enabled) | ||
277 | return -EBUSY; | ||
278 | |||
279 | state.polarity = polarity; | ||
280 | return pwm_apply_state(pwm, &state); | ||
281 | } | ||
282 | |||
283 | /** | ||
284 | * pwm_enable() - start a PWM output toggling | ||
285 | * @pwm: PWM device | ||
286 | * | ||
287 | * Returns: 0 on success or a negative error code on failure. | ||
288 | */ | ||
289 | static inline int pwm_enable(struct pwm_device *pwm) | ||
290 | { | ||
291 | struct pwm_state state; | ||
292 | |||
293 | if (!pwm) | ||
294 | return -EINVAL; | ||
295 | |||
296 | pwm_get_state(pwm, &state); | ||
297 | if (state.enabled) | ||
298 | return 0; | ||
299 | |||
300 | state.enabled = true; | ||
301 | return pwm_apply_state(pwm, &state); | ||
302 | } | ||
303 | |||
304 | /** | ||
305 | * pwm_disable() - stop a PWM output toggling | ||
306 | * @pwm: PWM device | ||
307 | */ | ||
308 | static inline void pwm_disable(struct pwm_device *pwm) | ||
309 | { | ||
310 | struct pwm_state state; | ||
311 | |||
312 | if (!pwm) | ||
313 | return; | ||
314 | |||
315 | pwm_get_state(pwm, &state); | ||
316 | if (!state.enabled) | ||
317 | return; | ||
318 | |||
319 | state.enabled = false; | ||
320 | pwm_apply_state(pwm, &state); | ||
321 | } | ||
322 | |||
323 | |||
324 | /* PWM provider APIs */ | ||
235 | int pwm_set_chip_data(struct pwm_device *pwm, void *data); | 325 | int pwm_set_chip_data(struct pwm_device *pwm, void *data); |
236 | void *pwm_get_chip_data(struct pwm_device *pwm); | 326 | void *pwm_get_chip_data(struct pwm_device *pwm); |
237 | 327 | ||
@@ -257,6 +347,47 @@ void devm_pwm_put(struct device *dev, struct pwm_device *pwm); | |||
257 | 347 | ||
258 | bool pwm_can_sleep(struct pwm_device *pwm); | 348 | bool pwm_can_sleep(struct pwm_device *pwm); |
259 | #else | 349 | #else |
350 | static inline struct pwm_device *pwm_request(int pwm_id, const char *label) | ||
351 | { | ||
352 | return ERR_PTR(-ENODEV); | ||
353 | } | ||
354 | |||
355 | static inline void pwm_free(struct pwm_device *pwm) | ||
356 | { | ||
357 | } | ||
358 | |||
359 | static inline int pwm_apply_state(struct pwm_device *pwm, | ||
360 | const struct pwm_state *state) | ||
361 | { | ||
362 | return -ENOTSUPP; | ||
363 | } | ||
364 | |||
365 | static inline int pwm_adjust_config(struct pwm_device *pwm) | ||
366 | { | ||
367 | return -ENOTSUPP; | ||
368 | } | ||
369 | |||
370 | static inline int pwm_config(struct pwm_device *pwm, int duty_ns, | ||
371 | int period_ns) | ||
372 | { | ||
373 | return -EINVAL; | ||
374 | } | ||
375 | |||
376 | static inline int pwm_set_polarity(struct pwm_device *pwm, | ||
377 | enum pwm_polarity polarity) | ||
378 | { | ||
379 | return -ENOTSUPP; | ||
380 | } | ||
381 | |||
382 | static inline int pwm_enable(struct pwm_device *pwm) | ||
383 | { | ||
384 | return -EINVAL; | ||
385 | } | ||
386 | |||
387 | static inline void pwm_disable(struct pwm_device *pwm) | ||
388 | { | ||
389 | } | ||
390 | |||
260 | static inline int pwm_set_chip_data(struct pwm_device *pwm, void *data) | 391 | static inline int pwm_set_chip_data(struct pwm_device *pwm, void *data) |
261 | { | 392 | { |
262 | return -EINVAL; | 393 | return -EINVAL; |
@@ -328,6 +459,34 @@ static inline bool pwm_can_sleep(struct pwm_device *pwm) | |||
328 | } | 459 | } |
329 | #endif | 460 | #endif |
330 | 461 | ||
462 | static inline void pwm_apply_args(struct pwm_device *pwm) | ||
463 | { | ||
464 | /* | ||
465 | * PWM users calling pwm_apply_args() expect to have a fresh config | ||
466 | * where the polarity and period are set according to pwm_args info. | ||
467 | * The problem is, polarity can only be changed when the PWM is | ||
468 | * disabled. | ||
469 | * | ||
470 | * PWM drivers supporting hardware readout may declare the PWM device | ||
471 | * as enabled, and prevent polarity setting, which changes from the | ||
472 | * existing behavior, where all PWM devices are declared as disabled | ||
473 | * at startup (even if they are actually enabled), thus authorizing | ||
474 | * polarity setting. | ||
475 | * | ||
476 | * Instead of setting ->enabled to false, we call pwm_disable() | ||
477 | * before pwm_set_polarity() to ensure that everything is configured | ||
478 | * as expected, and the PWM is really disabled when the user request | ||
479 | * it. | ||
480 | * | ||
481 | * Note that PWM users requiring a smooth handover between the | ||
482 | * bootloader and the kernel (like critical regulators controlled by | ||
483 | * PWM devices) will have to switch to the atomic API and avoid calling | ||
484 | * pwm_apply_args(). | ||
485 | */ | ||
486 | pwm_disable(pwm); | ||
487 | pwm_set_polarity(pwm, pwm->args.polarity); | ||
488 | } | ||
489 | |||
331 | struct pwm_lookup { | 490 | struct pwm_lookup { |
332 | struct list_head list; | 491 | struct list_head list; |
333 | const char *provider; | 492 | const char *provider; |