pwm: Rename pwm_apply_state() to pwm_apply_might_sleep()
In order to introduce a pwm api which can be used from atomic context, we will need two functions for applying pwm changes: int pwm_apply_might_sleep(struct pwm *, struct pwm_state *); int pwm_apply_atomic(struct pwm *, struct pwm_state *); This commit just deals with renaming pwm_apply_state(), a following commit will introduce the pwm_apply_atomic() function. Acked-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de> Acked-by: Guenter Roeck <linux@roeck-us.net> Acked-by: Mark Brown <broonie@kernel.org> Acked-by: Dmitry Torokhov <dmitry.torokhov@gmail.com> # for input Acked-by: Hans de Goede <hdegoede@redhat.com> Acked-by: Jani Nikula <jani.nikula@intel.com> Acked-by: Lee Jones <lee@kernel.org> Signed-off-by: Sean Young <sean@mess.org> Signed-off-by: Thierry Reding <thierry.reding@gmail.com>
This commit is contained in:
parent
80943bbdcf
commit
c748a6d77c
@ -41,7 +41,7 @@ the getter, devm_pwm_get() and devm_fwnode_pwm_get(), also exist.
|
|||||||
|
|
||||||
After being requested, a PWM has to be configured using::
|
After being requested, a PWM has to be configured using::
|
||||||
|
|
||||||
int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state);
|
int pwm_apply_might_sleep(struct pwm_device *pwm, struct pwm_state *state);
|
||||||
|
|
||||||
This API controls both the PWM period/duty_cycle config and the
|
This API controls both the PWM period/duty_cycle config and the
|
||||||
enable/disable state.
|
enable/disable state.
|
||||||
@ -57,13 +57,13 @@ If supported by the driver, the signal can be optimized, for example to improve
|
|||||||
EMI by phase shifting the individual channels of a chip.
|
EMI by phase shifting the individual channels of a chip.
|
||||||
|
|
||||||
The pwm_config(), pwm_enable() and pwm_disable() functions are just wrappers
|
The pwm_config(), pwm_enable() and pwm_disable() functions are just wrappers
|
||||||
around pwm_apply_state() and should not be used if the user wants to change
|
around pwm_apply_might_sleep() and should not be used if the user wants to change
|
||||||
several parameter at once. For example, if you see pwm_config() and
|
several parameter at once. For example, if you see pwm_config() and
|
||||||
pwm_{enable,disable}() calls in the same function, this probably means you
|
pwm_{enable,disable}() calls in the same function, this probably means you
|
||||||
should switch to pwm_apply_state().
|
should switch to pwm_apply_might_sleep().
|
||||||
|
|
||||||
The PWM user API also allows one to query the PWM state that was passed to the
|
The PWM user API also allows one to query the PWM state that was passed to the
|
||||||
last invocation of pwm_apply_state() using pwm_get_state(). Note this is
|
last invocation of pwm_apply_might_sleep() using pwm_get_state(). Note this is
|
||||||
different to what the driver has actually implemented if the request cannot be
|
different to what the driver has actually implemented if the request cannot be
|
||||||
satisfied exactly with the hardware in use. There is currently no way for
|
satisfied exactly with the hardware in use. There is currently no way for
|
||||||
consumers to get the actually implemented settings.
|
consumers to get the actually implemented settings.
|
||||||
|
@ -17576,7 +17576,7 @@ F: drivers/video/backlight/pwm_bl.c
|
|||||||
F: include/dt-bindings/pwm/
|
F: include/dt-bindings/pwm/
|
||||||
F: include/linux/pwm.h
|
F: include/linux/pwm.h
|
||||||
F: include/linux/pwm_backlight.h
|
F: include/linux/pwm_backlight.h
|
||||||
K: pwm_(config|apply_state|ops)
|
K: pwm_(config|apply_might_sleep|ops)
|
||||||
|
|
||||||
PXA GPIO DRIVER
|
PXA GPIO DRIVER
|
||||||
M: Robert Jarzmik <robert.jarzmik@free.fr>
|
M: Robert Jarzmik <robert.jarzmik@free.fr>
|
||||||
|
@ -274,7 +274,7 @@ static void ext_pwm_set_backlight(const struct drm_connector_state *conn_state,
|
|||||||
struct intel_panel *panel = &to_intel_connector(conn_state->connector)->panel;
|
struct intel_panel *panel = &to_intel_connector(conn_state->connector)->panel;
|
||||||
|
|
||||||
pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100);
|
pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100);
|
||||||
pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
|
pwm_apply_might_sleep(panel->backlight.pwm, &panel->backlight.pwm_state);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void
|
static void
|
||||||
@ -427,7 +427,7 @@ static void ext_pwm_disable_backlight(const struct drm_connector_state *old_conn
|
|||||||
intel_backlight_set_pwm_level(old_conn_state, level);
|
intel_backlight_set_pwm_level(old_conn_state, level);
|
||||||
|
|
||||||
panel->backlight.pwm_state.enabled = false;
|
panel->backlight.pwm_state.enabled = false;
|
||||||
pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
|
pwm_apply_might_sleep(panel->backlight.pwm, &panel->backlight.pwm_state);
|
||||||
}
|
}
|
||||||
|
|
||||||
void intel_backlight_disable(const struct drm_connector_state *old_conn_state)
|
void intel_backlight_disable(const struct drm_connector_state *old_conn_state)
|
||||||
@ -749,7 +749,7 @@ static void ext_pwm_enable_backlight(const struct intel_crtc_state *crtc_state,
|
|||||||
|
|
||||||
pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100);
|
pwm_set_relative_duty_cycle(&panel->backlight.pwm_state, level, 100);
|
||||||
panel->backlight.pwm_state.enabled = true;
|
panel->backlight.pwm_state.enabled = true;
|
||||||
pwm_apply_state(panel->backlight.pwm, &panel->backlight.pwm_state);
|
pwm_apply_might_sleep(panel->backlight.pwm, &panel->backlight.pwm_state);
|
||||||
}
|
}
|
||||||
|
|
||||||
static void __intel_backlight_enable(const struct intel_crtc_state *crtc_state,
|
static void __intel_backlight_enable(const struct intel_crtc_state *crtc_state,
|
||||||
|
@ -319,7 +319,7 @@ static int ssd130x_pwm_enable(struct ssd130x_device *ssd130x)
|
|||||||
|
|
||||||
pwm_init_state(ssd130x->pwm, &pwmstate);
|
pwm_init_state(ssd130x->pwm, &pwmstate);
|
||||||
pwm_set_relative_duty_cycle(&pwmstate, 50, 100);
|
pwm_set_relative_duty_cycle(&pwmstate, 50, 100);
|
||||||
pwm_apply_state(ssd130x->pwm, &pwmstate);
|
pwm_apply_might_sleep(ssd130x->pwm, &pwmstate);
|
||||||
|
|
||||||
/* Enable the PWM */
|
/* Enable the PWM */
|
||||||
pwm_enable(ssd130x->pwm);
|
pwm_enable(ssd130x->pwm);
|
||||||
|
@ -151,7 +151,7 @@ static int pwm_fan_power_on(struct pwm_fan_ctx *ctx)
|
|||||||
}
|
}
|
||||||
|
|
||||||
state->enabled = true;
|
state->enabled = true;
|
||||||
ret = pwm_apply_state(ctx->pwm, state);
|
ret = pwm_apply_might_sleep(ctx->pwm, state);
|
||||||
if (ret) {
|
if (ret) {
|
||||||
dev_err(ctx->dev, "failed to enable PWM\n");
|
dev_err(ctx->dev, "failed to enable PWM\n");
|
||||||
goto disable_regulator;
|
goto disable_regulator;
|
||||||
@ -181,7 +181,7 @@ static int pwm_fan_power_off(struct pwm_fan_ctx *ctx)
|
|||||||
|
|
||||||
state->enabled = false;
|
state->enabled = false;
|
||||||
state->duty_cycle = 0;
|
state->duty_cycle = 0;
|
||||||
ret = pwm_apply_state(ctx->pwm, state);
|
ret = pwm_apply_might_sleep(ctx->pwm, state);
|
||||||
if (ret) {
|
if (ret) {
|
||||||
dev_err(ctx->dev, "failed to disable PWM\n");
|
dev_err(ctx->dev, "failed to disable PWM\n");
|
||||||
return ret;
|
return ret;
|
||||||
@ -207,7 +207,7 @@ static int __set_pwm(struct pwm_fan_ctx *ctx, unsigned long pwm)
|
|||||||
|
|
||||||
period = state->period;
|
period = state->period;
|
||||||
state->duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM);
|
state->duty_cycle = DIV_ROUND_UP(pwm * (period - 1), MAX_PWM);
|
||||||
ret = pwm_apply_state(ctx->pwm, state);
|
ret = pwm_apply_might_sleep(ctx->pwm, state);
|
||||||
if (ret)
|
if (ret)
|
||||||
return ret;
|
return ret;
|
||||||
ret = pwm_fan_power_on(ctx);
|
ret = pwm_fan_power_on(ctx);
|
||||||
@ -278,7 +278,7 @@ static int pwm_fan_update_enable(struct pwm_fan_ctx *ctx, long val)
|
|||||||
state,
|
state,
|
||||||
&enable_regulator);
|
&enable_regulator);
|
||||||
|
|
||||||
pwm_apply_state(ctx->pwm, state);
|
pwm_apply_might_sleep(ctx->pwm, state);
|
||||||
pwm_fan_switch_power(ctx, enable_regulator);
|
pwm_fan_switch_power(ctx, enable_regulator);
|
||||||
pwm_fan_update_state(ctx, 0);
|
pwm_fan_update_state(ctx, 0);
|
||||||
}
|
}
|
||||||
|
@ -352,7 +352,7 @@ static int da7280_haptic_set_pwm(struct da7280_haptic *haptics, bool enabled)
|
|||||||
state.duty_cycle = period_mag_multi;
|
state.duty_cycle = period_mag_multi;
|
||||||
}
|
}
|
||||||
|
|
||||||
error = pwm_apply_state(haptics->pwm_dev, &state);
|
error = pwm_apply_might_sleep(haptics->pwm_dev, &state);
|
||||||
if (error)
|
if (error)
|
||||||
dev_err(haptics->dev, "Failed to apply pwm state: %d\n", error);
|
dev_err(haptics->dev, "Failed to apply pwm state: %d\n", error);
|
||||||
|
|
||||||
@ -1175,7 +1175,7 @@ static int da7280_probe(struct i2c_client *client)
|
|||||||
/* Sync up PWM state and ensure it is off. */
|
/* Sync up PWM state and ensure it is off. */
|
||||||
pwm_init_state(haptics->pwm_dev, &state);
|
pwm_init_state(haptics->pwm_dev, &state);
|
||||||
state.enabled = false;
|
state.enabled = false;
|
||||||
error = pwm_apply_state(haptics->pwm_dev, &state);
|
error = pwm_apply_might_sleep(haptics->pwm_dev, &state);
|
||||||
if (error) {
|
if (error) {
|
||||||
dev_err(dev, "Failed to apply PWM state: %d\n", error);
|
dev_err(dev, "Failed to apply PWM state: %d\n", error);
|
||||||
return error;
|
return error;
|
||||||
|
@ -39,7 +39,7 @@ static int pwm_beeper_on(struct pwm_beeper *beeper, unsigned long period)
|
|||||||
state.period = period;
|
state.period = period;
|
||||||
pwm_set_relative_duty_cycle(&state, 50, 100);
|
pwm_set_relative_duty_cycle(&state, 50, 100);
|
||||||
|
|
||||||
error = pwm_apply_state(beeper->pwm, &state);
|
error = pwm_apply_might_sleep(beeper->pwm, &state);
|
||||||
if (error)
|
if (error)
|
||||||
return error;
|
return error;
|
||||||
|
|
||||||
@ -138,7 +138,7 @@ static int pwm_beeper_probe(struct platform_device *pdev)
|
|||||||
/* Sync up PWM state and ensure it is off. */
|
/* Sync up PWM state and ensure it is off. */
|
||||||
pwm_init_state(beeper->pwm, &state);
|
pwm_init_state(beeper->pwm, &state);
|
||||||
state.enabled = false;
|
state.enabled = false;
|
||||||
error = pwm_apply_state(beeper->pwm, &state);
|
error = pwm_apply_might_sleep(beeper->pwm, &state);
|
||||||
if (error) {
|
if (error) {
|
||||||
dev_err(dev, "failed to apply initial PWM state: %d\n",
|
dev_err(dev, "failed to apply initial PWM state: %d\n",
|
||||||
error);
|
error);
|
||||||
|
@ -56,7 +56,7 @@ static int pwm_vibrator_start(struct pwm_vibrator *vibrator)
|
|||||||
pwm_set_relative_duty_cycle(&state, vibrator->level, 0xffff);
|
pwm_set_relative_duty_cycle(&state, vibrator->level, 0xffff);
|
||||||
state.enabled = true;
|
state.enabled = true;
|
||||||
|
|
||||||
err = pwm_apply_state(vibrator->pwm, &state);
|
err = pwm_apply_might_sleep(vibrator->pwm, &state);
|
||||||
if (err) {
|
if (err) {
|
||||||
dev_err(pdev, "failed to apply pwm state: %d\n", err);
|
dev_err(pdev, "failed to apply pwm state: %d\n", err);
|
||||||
return err;
|
return err;
|
||||||
@ -67,7 +67,7 @@ static int pwm_vibrator_start(struct pwm_vibrator *vibrator)
|
|||||||
state.duty_cycle = vibrator->direction_duty_cycle;
|
state.duty_cycle = vibrator->direction_duty_cycle;
|
||||||
state.enabled = true;
|
state.enabled = true;
|
||||||
|
|
||||||
err = pwm_apply_state(vibrator->pwm_dir, &state);
|
err = pwm_apply_might_sleep(vibrator->pwm_dir, &state);
|
||||||
if (err) {
|
if (err) {
|
||||||
dev_err(pdev, "failed to apply dir-pwm state: %d\n", err);
|
dev_err(pdev, "failed to apply dir-pwm state: %d\n", err);
|
||||||
pwm_disable(vibrator->pwm);
|
pwm_disable(vibrator->pwm);
|
||||||
@ -160,7 +160,7 @@ static int pwm_vibrator_probe(struct platform_device *pdev)
|
|||||||
/* Sync up PWM state and ensure it is off. */
|
/* Sync up PWM state and ensure it is off. */
|
||||||
pwm_init_state(vibrator->pwm, &state);
|
pwm_init_state(vibrator->pwm, &state);
|
||||||
state.enabled = false;
|
state.enabled = false;
|
||||||
err = pwm_apply_state(vibrator->pwm, &state);
|
err = pwm_apply_might_sleep(vibrator->pwm, &state);
|
||||||
if (err) {
|
if (err) {
|
||||||
dev_err(&pdev->dev, "failed to apply initial PWM state: %d\n",
|
dev_err(&pdev->dev, "failed to apply initial PWM state: %d\n",
|
||||||
err);
|
err);
|
||||||
@ -174,7 +174,7 @@ static int pwm_vibrator_probe(struct platform_device *pdev)
|
|||||||
/* Sync up PWM state and ensure it is off. */
|
/* Sync up PWM state and ensure it is off. */
|
||||||
pwm_init_state(vibrator->pwm_dir, &state);
|
pwm_init_state(vibrator->pwm_dir, &state);
|
||||||
state.enabled = false;
|
state.enabled = false;
|
||||||
err = pwm_apply_state(vibrator->pwm_dir, &state);
|
err = pwm_apply_might_sleep(vibrator->pwm_dir, &state);
|
||||||
if (err) {
|
if (err) {
|
||||||
dev_err(&pdev->dev, "failed to apply initial PWM state: %d\n",
|
dev_err(&pdev->dev, "failed to apply initial PWM state: %d\n",
|
||||||
err);
|
err);
|
||||||
|
@ -54,7 +54,7 @@ static int led_pwm_set(struct led_classdev *led_cdev,
|
|||||||
|
|
||||||
led_dat->pwmstate.duty_cycle = duty;
|
led_dat->pwmstate.duty_cycle = duty;
|
||||||
led_dat->pwmstate.enabled = true;
|
led_dat->pwmstate.enabled = true;
|
||||||
return pwm_apply_state(led_dat->pwm, &led_dat->pwmstate);
|
return pwm_apply_might_sleep(led_dat->pwm, &led_dat->pwmstate);
|
||||||
}
|
}
|
||||||
|
|
||||||
__attribute__((nonnull))
|
__attribute__((nonnull))
|
||||||
|
@ -51,8 +51,8 @@ static int led_pwm_mc_set(struct led_classdev *cdev,
|
|||||||
|
|
||||||
priv->leds[i].state.duty_cycle = duty;
|
priv->leds[i].state.duty_cycle = duty;
|
||||||
priv->leds[i].state.enabled = duty > 0;
|
priv->leds[i].state.enabled = duty > 0;
|
||||||
ret = pwm_apply_state(priv->leds[i].pwm,
|
ret = pwm_apply_might_sleep(priv->leds[i].pwm,
|
||||||
&priv->leds[i].state);
|
&priv->leds[i].state);
|
||||||
if (ret)
|
if (ret)
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
@ -68,7 +68,7 @@ static int pwm_ir_tx(struct rc_dev *dev, unsigned int *txbuf,
|
|||||||
|
|
||||||
for (i = 0; i < count; i++) {
|
for (i = 0; i < count; i++) {
|
||||||
state.enabled = !(i % 2);
|
state.enabled = !(i % 2);
|
||||||
pwm_apply_state(pwm, &state);
|
pwm_apply_might_sleep(pwm, &state);
|
||||||
|
|
||||||
edge = ktime_add_us(edge, txbuf[i]);
|
edge = ktime_add_us(edge, txbuf[i]);
|
||||||
delta = ktime_us_delta(edge, ktime_get());
|
delta = ktime_us_delta(edge, ktime_get());
|
||||||
@ -77,7 +77,7 @@ static int pwm_ir_tx(struct rc_dev *dev, unsigned int *txbuf,
|
|||||||
}
|
}
|
||||||
|
|
||||||
state.enabled = false;
|
state.enabled = false;
|
||||||
pwm_apply_state(pwm, &state);
|
pwm_apply_might_sleep(pwm, &state);
|
||||||
|
|
||||||
return count;
|
return count;
|
||||||
}
|
}
|
||||||
|
@ -435,7 +435,7 @@ static int yogabook_pdev_set_kbd_backlight(struct yogabook_data *data, u8 level)
|
|||||||
.enabled = level,
|
.enabled = level,
|
||||||
};
|
};
|
||||||
|
|
||||||
pwm_apply_state(data->kbd_bl_pwm, &state);
|
pwm_apply_might_sleep(data->kbd_bl_pwm, &state);
|
||||||
gpiod_set_value(data->kbd_bl_led_enable, level ? 1 : 0);
|
gpiod_set_value(data->kbd_bl_led_enable, level ? 1 : 0);
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
|
@ -326,8 +326,8 @@ struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
|
|||||||
}
|
}
|
||||||
EXPORT_SYMBOL_GPL(pwm_request_from_chip);
|
EXPORT_SYMBOL_GPL(pwm_request_from_chip);
|
||||||
|
|
||||||
static void pwm_apply_state_debug(struct pwm_device *pwm,
|
static void pwm_apply_debug(struct pwm_device *pwm,
|
||||||
const struct pwm_state *state)
|
const struct pwm_state *state)
|
||||||
{
|
{
|
||||||
struct pwm_state *last = &pwm->last;
|
struct pwm_state *last = &pwm->last;
|
||||||
struct pwm_chip *chip = pwm->chip;
|
struct pwm_chip *chip = pwm->chip;
|
||||||
@ -433,11 +433,11 @@ static void pwm_apply_state_debug(struct pwm_device *pwm,
|
|||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* pwm_apply_state() - atomically apply a new state to a PWM device
|
* pwm_apply_might_sleep() - atomically apply a new state to a PWM device
|
||||||
* @pwm: PWM device
|
* @pwm: PWM device
|
||||||
* @state: new state to apply
|
* @state: new state to apply
|
||||||
*/
|
*/
|
||||||
int pwm_apply_state(struct pwm_device *pwm, const struct pwm_state *state)
|
int pwm_apply_might_sleep(struct pwm_device *pwm, const struct pwm_state *state)
|
||||||
{
|
{
|
||||||
struct pwm_chip *chip;
|
struct pwm_chip *chip;
|
||||||
int err;
|
int err;
|
||||||
@ -445,7 +445,7 @@ int pwm_apply_state(struct pwm_device *pwm, const struct pwm_state *state)
|
|||||||
/*
|
/*
|
||||||
* Some lowlevel driver's implementations of .apply() make use of
|
* Some lowlevel driver's implementations of .apply() make use of
|
||||||
* mutexes, also with some drivers only returning when the new
|
* mutexes, also with some drivers only returning when the new
|
||||||
* configuration is active calling pwm_apply_state() from atomic context
|
* configuration is active calling pwm_apply_might_sleep() from atomic context
|
||||||
* is a bad idea. So make it explicit that calling this function might
|
* is a bad idea. So make it explicit that calling this function might
|
||||||
* sleep.
|
* sleep.
|
||||||
*/
|
*/
|
||||||
@ -475,11 +475,11 @@ int pwm_apply_state(struct pwm_device *pwm, const struct pwm_state *state)
|
|||||||
* only do this after pwm->state was applied as some
|
* only do this after pwm->state was applied as some
|
||||||
* implementations of .get_state depend on this
|
* implementations of .get_state depend on this
|
||||||
*/
|
*/
|
||||||
pwm_apply_state_debug(pwm, state);
|
pwm_apply_debug(pwm, state);
|
||||||
|
|
||||||
return 0;
|
return 0;
|
||||||
}
|
}
|
||||||
EXPORT_SYMBOL_GPL(pwm_apply_state);
|
EXPORT_SYMBOL_GPL(pwm_apply_might_sleep);
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* pwm_capture() - capture and report a PWM signal
|
* pwm_capture() - capture and report a PWM signal
|
||||||
@ -537,7 +537,7 @@ int pwm_adjust_config(struct pwm_device *pwm)
|
|||||||
state.period = pargs.period;
|
state.period = pargs.period;
|
||||||
state.polarity = pargs.polarity;
|
state.polarity = pargs.polarity;
|
||||||
|
|
||||||
return pwm_apply_state(pwm, &state);
|
return pwm_apply_might_sleep(pwm, &state);
|
||||||
}
|
}
|
||||||
|
|
||||||
/*
|
/*
|
||||||
@ -560,7 +560,7 @@ int pwm_adjust_config(struct pwm_device *pwm)
|
|||||||
state.duty_cycle = state.period - state.duty_cycle;
|
state.duty_cycle = state.period - state.duty_cycle;
|
||||||
}
|
}
|
||||||
|
|
||||||
return pwm_apply_state(pwm, &state);
|
return pwm_apply_might_sleep(pwm, &state);
|
||||||
}
|
}
|
||||||
EXPORT_SYMBOL_GPL(pwm_adjust_config);
|
EXPORT_SYMBOL_GPL(pwm_adjust_config);
|
||||||
|
|
||||||
|
@ -172,7 +172,7 @@ static int twl4030_pwmled_apply(struct pwm_chip *chip, struct pwm_device *pwm,
|
|||||||
* We cannot skip calling ->config even if state->period ==
|
* We cannot skip calling ->config even if state->period ==
|
||||||
* pwm->state.period && state->duty_cycle == pwm->state.duty_cycle
|
* pwm->state.period && state->duty_cycle == pwm->state.duty_cycle
|
||||||
* because we might have exited early in the last call to
|
* because we might have exited early in the last call to
|
||||||
* pwm_apply_state because of !state->enabled and so the two values in
|
* pwm_apply_might_sleep because of !state->enabled and so the two values in
|
||||||
* pwm->state might not be configured in hardware.
|
* pwm->state might not be configured in hardware.
|
||||||
*/
|
*/
|
||||||
ret = twl4030_pwmled_config(chip, pwm,
|
ret = twl4030_pwmled_config(chip, pwm,
|
||||||
|
@ -206,7 +206,7 @@ static int vt8500_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
|
|||||||
* We cannot skip calling ->config even if state->period ==
|
* We cannot skip calling ->config even if state->period ==
|
||||||
* pwm->state.period && state->duty_cycle == pwm->state.duty_cycle
|
* pwm->state.period && state->duty_cycle == pwm->state.duty_cycle
|
||||||
* because we might have exited early in the last call to
|
* because we might have exited early in the last call to
|
||||||
* pwm_apply_state because of !state->enabled and so the two values in
|
* pwm_apply_might_sleep because of !state->enabled and so the two values in
|
||||||
* pwm->state might not be configured in hardware.
|
* pwm->state might not be configured in hardware.
|
||||||
*/
|
*/
|
||||||
err = vt8500_pwm_config(chip, pwm, state->duty_cycle, state->period);
|
err = vt8500_pwm_config(chip, pwm, state->duty_cycle, state->period);
|
||||||
|
@ -62,7 +62,7 @@ static ssize_t period_store(struct device *child,
|
|||||||
mutex_lock(&export->lock);
|
mutex_lock(&export->lock);
|
||||||
pwm_get_state(pwm, &state);
|
pwm_get_state(pwm, &state);
|
||||||
state.period = val;
|
state.period = val;
|
||||||
ret = pwm_apply_state(pwm, &state);
|
ret = pwm_apply_might_sleep(pwm, &state);
|
||||||
mutex_unlock(&export->lock);
|
mutex_unlock(&export->lock);
|
||||||
|
|
||||||
return ret ? : size;
|
return ret ? : size;
|
||||||
@ -97,7 +97,7 @@ static ssize_t duty_cycle_store(struct device *child,
|
|||||||
mutex_lock(&export->lock);
|
mutex_lock(&export->lock);
|
||||||
pwm_get_state(pwm, &state);
|
pwm_get_state(pwm, &state);
|
||||||
state.duty_cycle = val;
|
state.duty_cycle = val;
|
||||||
ret = pwm_apply_state(pwm, &state);
|
ret = pwm_apply_might_sleep(pwm, &state);
|
||||||
mutex_unlock(&export->lock);
|
mutex_unlock(&export->lock);
|
||||||
|
|
||||||
return ret ? : size;
|
return ret ? : size;
|
||||||
@ -144,7 +144,7 @@ static ssize_t enable_store(struct device *child,
|
|||||||
goto unlock;
|
goto unlock;
|
||||||
}
|
}
|
||||||
|
|
||||||
ret = pwm_apply_state(pwm, &state);
|
ret = pwm_apply_might_sleep(pwm, &state);
|
||||||
|
|
||||||
unlock:
|
unlock:
|
||||||
mutex_unlock(&export->lock);
|
mutex_unlock(&export->lock);
|
||||||
@ -194,7 +194,7 @@ static ssize_t polarity_store(struct device *child,
|
|||||||
mutex_lock(&export->lock);
|
mutex_lock(&export->lock);
|
||||||
pwm_get_state(pwm, &state);
|
pwm_get_state(pwm, &state);
|
||||||
state.polarity = polarity;
|
state.polarity = polarity;
|
||||||
ret = pwm_apply_state(pwm, &state);
|
ret = pwm_apply_might_sleep(pwm, &state);
|
||||||
mutex_unlock(&export->lock);
|
mutex_unlock(&export->lock);
|
||||||
|
|
||||||
return ret ? : size;
|
return ret ? : size;
|
||||||
@ -401,7 +401,7 @@ static int pwm_class_apply_state(struct pwm_export *export,
|
|||||||
struct pwm_device *pwm,
|
struct pwm_device *pwm,
|
||||||
struct pwm_state *state)
|
struct pwm_state *state)
|
||||||
{
|
{
|
||||||
int ret = pwm_apply_state(pwm, state);
|
int ret = pwm_apply_might_sleep(pwm, state);
|
||||||
|
|
||||||
/* release lock taken in pwm_class_get_state */
|
/* release lock taken in pwm_class_get_state */
|
||||||
mutex_unlock(&export->lock);
|
mutex_unlock(&export->lock);
|
||||||
|
@ -90,7 +90,7 @@ static int pwm_regulator_set_voltage_sel(struct regulator_dev *rdev,
|
|||||||
pwm_set_relative_duty_cycle(&pstate,
|
pwm_set_relative_duty_cycle(&pstate,
|
||||||
drvdata->duty_cycle_table[selector].dutycycle, 100);
|
drvdata->duty_cycle_table[selector].dutycycle, 100);
|
||||||
|
|
||||||
ret = pwm_apply_state(drvdata->pwm, &pstate);
|
ret = pwm_apply_might_sleep(drvdata->pwm, &pstate);
|
||||||
if (ret) {
|
if (ret) {
|
||||||
dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret);
|
dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret);
|
||||||
return ret;
|
return ret;
|
||||||
@ -216,7 +216,7 @@ static int pwm_regulator_set_voltage(struct regulator_dev *rdev,
|
|||||||
|
|
||||||
pwm_set_relative_duty_cycle(&pstate, dutycycle, duty_unit);
|
pwm_set_relative_duty_cycle(&pstate, dutycycle, duty_unit);
|
||||||
|
|
||||||
ret = pwm_apply_state(drvdata->pwm, &pstate);
|
ret = pwm_apply_might_sleep(drvdata->pwm, &pstate);
|
||||||
if (ret) {
|
if (ret) {
|
||||||
dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret);
|
dev_err(&rdev->dev, "Failed to configure PWM: %d\n", ret);
|
||||||
return ret;
|
return ret;
|
||||||
|
@ -180,7 +180,7 @@ static int lm3630a_pwm_ctrl(struct lm3630a_chip *pchip, int br, int br_max)
|
|||||||
|
|
||||||
pchip->pwmd_state.enabled = pchip->pwmd_state.duty_cycle ? true : false;
|
pchip->pwmd_state.enabled = pchip->pwmd_state.duty_cycle ? true : false;
|
||||||
|
|
||||||
return pwm_apply_state(pchip->pwmd, &pchip->pwmd_state);
|
return pwm_apply_might_sleep(pchip->pwmd, &pchip->pwmd_state);
|
||||||
}
|
}
|
||||||
|
|
||||||
/* update and get brightness */
|
/* update and get brightness */
|
||||||
|
@ -234,7 +234,7 @@ static int lp855x_pwm_ctrl(struct lp855x *lp, int br, int max_br)
|
|||||||
state.duty_cycle = div_u64(br * state.period, max_br);
|
state.duty_cycle = div_u64(br * state.period, max_br);
|
||||||
state.enabled = state.duty_cycle;
|
state.enabled = state.duty_cycle;
|
||||||
|
|
||||||
return pwm_apply_state(lp->pwm, &state);
|
return pwm_apply_might_sleep(lp->pwm, &state);
|
||||||
}
|
}
|
||||||
|
|
||||||
static int lp855x_bl_update_status(struct backlight_device *bl)
|
static int lp855x_bl_update_status(struct backlight_device *bl)
|
||||||
|
@ -103,7 +103,7 @@ static int pwm_backlight_update_status(struct backlight_device *bl)
|
|||||||
pwm_get_state(pb->pwm, &state);
|
pwm_get_state(pb->pwm, &state);
|
||||||
state.duty_cycle = compute_duty_cycle(pb, brightness, &state);
|
state.duty_cycle = compute_duty_cycle(pb, brightness, &state);
|
||||||
state.enabled = true;
|
state.enabled = true;
|
||||||
pwm_apply_state(pb->pwm, &state);
|
pwm_apply_might_sleep(pb->pwm, &state);
|
||||||
|
|
||||||
pwm_backlight_power_on(pb);
|
pwm_backlight_power_on(pb);
|
||||||
} else {
|
} else {
|
||||||
@ -120,7 +120,7 @@ static int pwm_backlight_update_status(struct backlight_device *bl)
|
|||||||
* inactive output.
|
* inactive output.
|
||||||
*/
|
*/
|
||||||
state.enabled = !pb->power_supply && !pb->enable_gpio;
|
state.enabled = !pb->power_supply && !pb->enable_gpio;
|
||||||
pwm_apply_state(pb->pwm, &state);
|
pwm_apply_might_sleep(pb->pwm, &state);
|
||||||
}
|
}
|
||||||
|
|
||||||
if (pb->notify_after)
|
if (pb->notify_after)
|
||||||
@ -528,7 +528,7 @@ static int pwm_backlight_probe(struct platform_device *pdev)
|
|||||||
if (!state.period && (data->pwm_period_ns > 0))
|
if (!state.period && (data->pwm_period_ns > 0))
|
||||||
state.period = data->pwm_period_ns;
|
state.period = data->pwm_period_ns;
|
||||||
|
|
||||||
ret = pwm_apply_state(pb->pwm, &state);
|
ret = pwm_apply_might_sleep(pb->pwm, &state);
|
||||||
if (ret) {
|
if (ret) {
|
||||||
dev_err(&pdev->dev, "failed to apply initial PWM state: %d\n",
|
dev_err(&pdev->dev, "failed to apply initial PWM state: %d\n",
|
||||||
ret);
|
ret);
|
||||||
@ -633,7 +633,7 @@ static void pwm_backlight_remove(struct platform_device *pdev)
|
|||||||
pwm_get_state(pb->pwm, &state);
|
pwm_get_state(pb->pwm, &state);
|
||||||
state.duty_cycle = 0;
|
state.duty_cycle = 0;
|
||||||
state.enabled = false;
|
state.enabled = false;
|
||||||
pwm_apply_state(pb->pwm, &state);
|
pwm_apply_might_sleep(pb->pwm, &state);
|
||||||
|
|
||||||
if (pb->exit)
|
if (pb->exit)
|
||||||
pb->exit(&pdev->dev);
|
pb->exit(&pdev->dev);
|
||||||
@ -649,7 +649,7 @@ static void pwm_backlight_shutdown(struct platform_device *pdev)
|
|||||||
pwm_get_state(pb->pwm, &state);
|
pwm_get_state(pb->pwm, &state);
|
||||||
state.duty_cycle = 0;
|
state.duty_cycle = 0;
|
||||||
state.enabled = false;
|
state.enabled = false;
|
||||||
pwm_apply_state(pb->pwm, &state);
|
pwm_apply_might_sleep(pb->pwm, &state);
|
||||||
}
|
}
|
||||||
|
|
||||||
#ifdef CONFIG_PM_SLEEP
|
#ifdef CONFIG_PM_SLEEP
|
||||||
@ -673,7 +673,7 @@ static int pwm_backlight_suspend(struct device *dev)
|
|||||||
pwm_get_state(pb->pwm, &state);
|
pwm_get_state(pb->pwm, &state);
|
||||||
state.duty_cycle = 0;
|
state.duty_cycle = 0;
|
||||||
state.enabled = false;
|
state.enabled = false;
|
||||||
pwm_apply_state(pb->pwm, &state);
|
pwm_apply_might_sleep(pb->pwm, &state);
|
||||||
|
|
||||||
if (pb->notify_after)
|
if (pb->notify_after)
|
||||||
pb->notify_after(pb->dev, 0);
|
pb->notify_after(pb->dev, 0);
|
||||||
|
@ -347,7 +347,7 @@ static int ssd1307fb_init(struct ssd1307fb_par *par)
|
|||||||
|
|
||||||
pwm_init_state(par->pwm, &pwmstate);
|
pwm_init_state(par->pwm, &pwmstate);
|
||||||
pwm_set_relative_duty_cycle(&pwmstate, 50, 100);
|
pwm_set_relative_duty_cycle(&pwmstate, 50, 100);
|
||||||
pwm_apply_state(par->pwm, &pwmstate);
|
pwm_apply_might_sleep(par->pwm, &pwmstate);
|
||||||
|
|
||||||
/* Enable the PWM */
|
/* Enable the PWM */
|
||||||
pwm_enable(par->pwm);
|
pwm_enable(par->pwm);
|
||||||
|
@ -92,8 +92,8 @@ struct pwm_device {
|
|||||||
* @state: state to fill with the current PWM state
|
* @state: state to fill with the current PWM state
|
||||||
*
|
*
|
||||||
* The returned PWM state represents the state that was applied by a previous call to
|
* The returned PWM state represents the state that was applied by a previous call to
|
||||||
* pwm_apply_state(). Drivers may have to slightly tweak that state before programming it to
|
* pwm_apply_might_sleep(). Drivers may have to slightly tweak that state before programming it to
|
||||||
* hardware. If pwm_apply_state() was never called, this returns either the current hardware
|
* hardware. If pwm_apply_might_sleep() was never called, this returns either the current hardware
|
||||||
* state (if supported) or the default settings.
|
* state (if supported) or the default settings.
|
||||||
*/
|
*/
|
||||||
static inline void pwm_get_state(const struct pwm_device *pwm,
|
static inline void pwm_get_state(const struct pwm_device *pwm,
|
||||||
@ -157,20 +157,20 @@ static inline void pwm_get_args(const struct pwm_device *pwm,
|
|||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
* pwm_init_state() - prepare a new state to be applied with pwm_apply_state()
|
* pwm_init_state() - prepare a new state to be applied with pwm_apply_might_sleep()
|
||||||
* @pwm: PWM device
|
* @pwm: PWM device
|
||||||
* @state: state to fill with the prepared PWM state
|
* @state: state to fill with the prepared PWM state
|
||||||
*
|
*
|
||||||
* This functions prepares a state that can later be tweaked and applied
|
* This functions prepares a state that can later be tweaked and applied
|
||||||
* to the PWM device with pwm_apply_state(). This is a convenient function
|
* to the PWM device with pwm_apply_might_sleep(). This is a convenient function
|
||||||
* that first retrieves the current PWM state and the replaces the period
|
* that first retrieves the current PWM state and the replaces the period
|
||||||
* and polarity fields with the reference values defined in pwm->args.
|
* and polarity fields with the reference values defined in pwm->args.
|
||||||
* Once the function returns, you can adjust the ->enabled and ->duty_cycle
|
* Once the function returns, you can adjust the ->enabled and ->duty_cycle
|
||||||
* fields according to your needs before calling pwm_apply_state().
|
* fields according to your needs before calling pwm_apply_might_sleep().
|
||||||
*
|
*
|
||||||
* ->duty_cycle is initially set to zero to avoid cases where the current
|
* ->duty_cycle is initially set to zero to avoid cases where the current
|
||||||
* ->duty_cycle value exceed the pwm_args->period one, which would trigger
|
* ->duty_cycle value exceed the pwm_args->period one, which would trigger
|
||||||
* an error if the user calls pwm_apply_state() without adjusting ->duty_cycle
|
* an error if the user calls pwm_apply_might_sleep() without adjusting ->duty_cycle
|
||||||
* first.
|
* first.
|
||||||
*/
|
*/
|
||||||
static inline void pwm_init_state(const struct pwm_device *pwm,
|
static inline void pwm_init_state(const struct pwm_device *pwm,
|
||||||
@ -226,7 +226,7 @@ pwm_get_relative_duty_cycle(const struct pwm_state *state, unsigned int scale)
|
|||||||
*
|
*
|
||||||
* pwm_init_state(pwm, &state);
|
* pwm_init_state(pwm, &state);
|
||||||
* pwm_set_relative_duty_cycle(&state, 50, 100);
|
* pwm_set_relative_duty_cycle(&state, 50, 100);
|
||||||
* pwm_apply_state(pwm, &state);
|
* pwm_apply_might_sleep(pwm, &state);
|
||||||
*
|
*
|
||||||
* This functions returns -EINVAL if @duty_cycle and/or @scale are
|
* This functions returns -EINVAL if @duty_cycle and/or @scale are
|
||||||
* inconsistent (@scale == 0 or @duty_cycle > @scale).
|
* inconsistent (@scale == 0 or @duty_cycle > @scale).
|
||||||
@ -304,7 +304,7 @@ struct pwm_chip {
|
|||||||
|
|
||||||
#if IS_ENABLED(CONFIG_PWM)
|
#if IS_ENABLED(CONFIG_PWM)
|
||||||
/* PWM user APIs */
|
/* PWM user APIs */
|
||||||
int pwm_apply_state(struct pwm_device *pwm, const struct pwm_state *state);
|
int pwm_apply_might_sleep(struct pwm_device *pwm, const struct pwm_state *state);
|
||||||
int pwm_adjust_config(struct pwm_device *pwm);
|
int pwm_adjust_config(struct pwm_device *pwm);
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@ -332,7 +332,7 @@ static inline int pwm_config(struct pwm_device *pwm, int duty_ns,
|
|||||||
|
|
||||||
state.duty_cycle = duty_ns;
|
state.duty_cycle = duty_ns;
|
||||||
state.period = period_ns;
|
state.period = period_ns;
|
||||||
return pwm_apply_state(pwm, &state);
|
return pwm_apply_might_sleep(pwm, &state);
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@ -353,7 +353,7 @@ static inline int pwm_enable(struct pwm_device *pwm)
|
|||||||
return 0;
|
return 0;
|
||||||
|
|
||||||
state.enabled = true;
|
state.enabled = true;
|
||||||
return pwm_apply_state(pwm, &state);
|
return pwm_apply_might_sleep(pwm, &state);
|
||||||
}
|
}
|
||||||
|
|
||||||
/**
|
/**
|
||||||
@ -372,7 +372,7 @@ static inline void pwm_disable(struct pwm_device *pwm)
|
|||||||
return;
|
return;
|
||||||
|
|
||||||
state.enabled = false;
|
state.enabled = false;
|
||||||
pwm_apply_state(pwm, &state);
|
pwm_apply_might_sleep(pwm, &state);
|
||||||
}
|
}
|
||||||
|
|
||||||
/* PWM provider APIs */
|
/* PWM provider APIs */
|
||||||
@ -403,8 +403,8 @@ struct pwm_device *devm_fwnode_pwm_get(struct device *dev,
|
|||||||
struct fwnode_handle *fwnode,
|
struct fwnode_handle *fwnode,
|
||||||
const char *con_id);
|
const char *con_id);
|
||||||
#else
|
#else
|
||||||
static inline int pwm_apply_state(struct pwm_device *pwm,
|
static inline int pwm_apply_might_sleep(struct pwm_device *pwm,
|
||||||
const struct pwm_state *state)
|
const struct pwm_state *state)
|
||||||
{
|
{
|
||||||
might_sleep();
|
might_sleep();
|
||||||
return -ENOTSUPP;
|
return -ENOTSUPP;
|
||||||
@ -521,7 +521,7 @@ static inline void pwm_apply_args(struct pwm_device *pwm)
|
|||||||
state.period = pwm->args.period;
|
state.period = pwm->args.period;
|
||||||
state.usage_power = false;
|
state.usage_power = false;
|
||||||
|
|
||||||
pwm_apply_state(pwm, &state);
|
pwm_apply_might_sleep(pwm, &state);
|
||||||
}
|
}
|
||||||
|
|
||||||
struct pwm_lookup {
|
struct pwm_lookup {
|
||||||
|
Loading…
Reference in New Issue
Block a user