Commit e37e3bc7 authored by Linus Torvalds's avatar Linus Torvalds

Merge tag 'pwm/for-5.4-rc1' of...

Merge tag 'pwm/for-5.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/thierry.reding/linux-pwm

Pull pwm updates from Thierry Reding:
 "Besides one new driver being added for the PWM controller found in
  various Spreadtrum SoCs, this series of changes brings a slew of,
  mostly minor, fixes and cleanups for existing drivers, as well as some
  enhancements to the core code.

  Lastly, Uwe is added to the PWM subsystem entry of the MAINTAINERS
  file, making official his role as a reviewer"

* tag 'pwm/for-5.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/thierry.reding/linux-pwm: (34 commits)
  MAINTAINERS: Add myself as reviewer for the PWM subsystem
  MAINTAINERS: Add patchwork link for PWM entry
  MAINTAINERS: Add a selection of PWM related keywords to the PWM entry
  pwm: mediatek: Add MT7629 compatible string
  dt-bindings: pwm: Update bindings for MT7629 SoC
  pwm: mediatek: Update license and switch to SPDX tag
  pwm: mediatek: Use pwm_mediatek as common prefix
  pwm: mediatek: Allocate the clks array dynamically
  pwm: mediatek: Remove the has_clks field
  pwm: mediatek: Drop the check for of_device_get_match_data()
  pwm: atmel: Consolidate driver data initialization
  pwm: atmel: Remove unneeded check for match data
  pwm: atmel: Remove platform_device_id and use only dt bindings
  pwm: stm32-lp: Add check in case requested period cannot be achieved
  pwm: Ensure pwm_apply_state() doesn't modify the state argument
  pwm: fsl-ftm: Don't update the state for the caller of pwm_apply_state()
  pwm: sun4i: Don't update the state for the caller of pwm_apply_state()
  pwm: rockchip: Don't update the state for the caller of pwm_apply_state()
  pwm: Let pwm_get_state() return the last implemented state
  pwm: Introduce local struct pwm_chip in pwm_apply_state()
  ...
parents 738f531d da635e7a
...@@ -6,6 +6,8 @@ Required properties: ...@@ -6,6 +6,8 @@ Required properties:
- "mediatek,mt7622-pwm": found on mt7622 SoC. - "mediatek,mt7622-pwm": found on mt7622 SoC.
- "mediatek,mt7623-pwm": found on mt7623 SoC. - "mediatek,mt7623-pwm": found on mt7623 SoC.
- "mediatek,mt7628-pwm": found on mt7628 SoC. - "mediatek,mt7628-pwm": found on mt7628 SoC.
- "mediatek,mt7629-pwm", "mediatek,mt7622-pwm": found on mt7629 SoC.
- "mediatek,mt8516-pwm": found on mt8516 SoC.
- reg: physical base address and length of the controller's registers. - reg: physical base address and length of the controller's registers.
- #pwm-cells: must be 2. See pwm.txt in this directory for a description of - #pwm-cells: must be 2. See pwm.txt in this directory for a description of
the cell format. the cell format.
......
Spreadtrum PWM controller
Spreadtrum SoCs PWM controller provides 4 PWM channels.
Required properties:
- compatible : Should be "sprd,ums512-pwm".
- reg: Physical base address and length of the controller's registers.
- clocks: The phandle and specifier referencing the controller's clocks.
- clock-names: Should contain following entries:
"pwmn": used to derive the functional clock for PWM channel n (n range: 0 ~ 3).
"enablen": for PWM channel n enable clock (n range: 0 ~ 3).
- #pwm-cells: Should be 2. See pwm.txt in this directory for a description of
the cells format.
Optional properties:
- assigned-clocks: Reference to the PWM clock entries.
- assigned-clock-parents: The phandle of the parent clock of PWM clock.
Example:
pwms: pwm@32260000 {
compatible = "sprd,ums512-pwm";
reg = <0 0x32260000 0 0x10000>;
clock-names = "pwm0", "enable0",
"pwm1", "enable1",
"pwm2", "enable2",
"pwm3", "enable3";
clocks = <&aon_clk CLK_PWM0>, <&aonapb_gate CLK_PWM0_EB>,
<&aon_clk CLK_PWM1>, <&aonapb_gate CLK_PWM1_EB>,
<&aon_clk CLK_PWM2>, <&aonapb_gate CLK_PWM2_EB>,
<&aon_clk CLK_PWM3>, <&aonapb_gate CLK_PWM3_EB>;
assigned-clocks = <&aon_clk CLK_PWM0>,
<&aon_clk CLK_PWM1>,
<&aon_clk CLK_PWM2>,
<&aon_clk CLK_PWM3>;
assigned-clock-parents = <&ext_26m>,
<&ext_26m>,
<&ext_26m>,
<&ext_26m>;
#pwm-cells = <2>;
};
...@@ -13246,9 +13246,11 @@ F: drivers/media/rc/pwm-ir-tx.c ...@@ -13246,9 +13246,11 @@ F: drivers/media/rc/pwm-ir-tx.c
PWM SUBSYSTEM PWM SUBSYSTEM
M: Thierry Reding <thierry.reding@gmail.com> M: Thierry Reding <thierry.reding@gmail.com>
R: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
L: linux-pwm@vger.kernel.org L: linux-pwm@vger.kernel.org
S: Maintained S: Maintained
T: git git://git.kernel.org/pub/scm/linux/kernel/git/thierry.reding/linux-pwm.git T: git git://git.kernel.org/pub/scm/linux/kernel/git/thierry.reding/linux-pwm.git
Q: https://patchwork.ozlabs.org/project/linux-pwm/list/
F: Documentation/driver-api/pwm.rst F: Documentation/driver-api/pwm.rst
F: Documentation/devicetree/bindings/pwm/ F: Documentation/devicetree/bindings/pwm/
F: include/linux/pwm.h F: include/linux/pwm.h
...@@ -13257,6 +13259,7 @@ F: drivers/video/backlight/pwm_bl.c ...@@ -13257,6 +13259,7 @@ F: drivers/video/backlight/pwm_bl.c
F: include/linux/pwm_backlight.h F: include/linux/pwm_backlight.h
F: drivers/gpio/gpio-mvebu.c F: drivers/gpio/gpio-mvebu.c
F: Documentation/devicetree/bindings/gpio/gpio-mvebu.txt F: Documentation/devicetree/bindings/gpio/gpio-mvebu.txt
K: pwm_(config|apply_state|ops)
PXA GPIO DRIVER PXA GPIO DRIVER
M: Robert Jarzmik <robert.jarzmik@free.fr> M: Robert Jarzmik <robert.jarzmik@free.fr>
......
...@@ -694,7 +694,7 @@ static void mvebu_pwm_get_state(struct pwm_chip *chip, ...@@ -694,7 +694,7 @@ static void mvebu_pwm_get_state(struct pwm_chip *chip,
} }
static int mvebu_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int mvebu_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct mvebu_pwm *mvpwm = to_mvebu_pwm(chip); struct mvebu_pwm *mvpwm = to_mvebu_pwm(chip);
struct mvebu_gpio_chip *mvchip = mvpwm->mvchip; struct mvebu_gpio_chip *mvchip = mvpwm->mvchip;
......
...@@ -44,7 +44,7 @@ config PWM_AB8500 ...@@ -44,7 +44,7 @@ config PWM_AB8500
config PWM_ATMEL config PWM_ATMEL
tristate "Atmel PWM support" tristate "Atmel PWM support"
depends on ARCH_AT91 depends on ARCH_AT91 && OF
help help
Generic PWM framework driver for Atmel SoC. Generic PWM framework driver for Atmel SoC.
...@@ -423,6 +423,17 @@ config PWM_SPEAR ...@@ -423,6 +423,17 @@ config PWM_SPEAR
To compile this driver as a module, choose M here: the module To compile this driver as a module, choose M here: the module
will be called pwm-spear. will be called pwm-spear.
config PWM_SPRD
tristate "Spreadtrum PWM support"
depends on ARCH_SPRD || COMPILE_TEST
depends on HAS_IOMEM
help
Generic PWM framework driver for the PWM controller on
Spreadtrum SoCs.
To compile this driver as a module, choose M here: the module
will be called pwm-sprd.
config PWM_STI config PWM_STI
tristate "STiH4xx PWM support" tristate "STiH4xx PWM support"
depends on ARCH_STI depends on ARCH_STI
......
...@@ -41,6 +41,7 @@ obj-$(CONFIG_PWM_ROCKCHIP) += pwm-rockchip.o ...@@ -41,6 +41,7 @@ obj-$(CONFIG_PWM_ROCKCHIP) += pwm-rockchip.o
obj-$(CONFIG_PWM_SAMSUNG) += pwm-samsung.o obj-$(CONFIG_PWM_SAMSUNG) += pwm-samsung.o
obj-$(CONFIG_PWM_SIFIVE) += pwm-sifive.o obj-$(CONFIG_PWM_SIFIVE) += pwm-sifive.o
obj-$(CONFIG_PWM_SPEAR) += pwm-spear.o obj-$(CONFIG_PWM_SPEAR) += pwm-spear.o
obj-$(CONFIG_PWM_SPRD) += pwm-sprd.o
obj-$(CONFIG_PWM_STI) += pwm-sti.o obj-$(CONFIG_PWM_STI) += pwm-sti.o
obj-$(CONFIG_PWM_STM32) += pwm-stm32.o obj-$(CONFIG_PWM_STM32) += pwm-stm32.o
obj-$(CONFIG_PWM_STM32_LP) += pwm-stm32-lp.o obj-$(CONFIG_PWM_STM32_LP) += pwm-stm32-lp.o
......
...@@ -448,36 +448,44 @@ EXPORT_SYMBOL_GPL(pwm_free); ...@@ -448,36 +448,44 @@ EXPORT_SYMBOL_GPL(pwm_free);
/** /**
* pwm_apply_state() - atomically apply a new state to a PWM device * pwm_apply_state() - atomically apply a new state to a PWM device
* @pwm: PWM device * @pwm: PWM device
* @state: new state to apply. This can be adjusted by the PWM driver * @state: new state to apply
* if the requested config is not achievable, for example,
* ->duty_cycle and ->period might be approximated.
*/ */
int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state) int pwm_apply_state(struct pwm_device *pwm, const struct pwm_state *state)
{ {
struct pwm_chip *chip;
int err; int err;
if (!pwm || !state || !state->period || if (!pwm || !state || !state->period ||
state->duty_cycle > state->period) state->duty_cycle > state->period)
return -EINVAL; return -EINVAL;
chip = pwm->chip;
if (state->period == pwm->state.period && if (state->period == pwm->state.period &&
state->duty_cycle == pwm->state.duty_cycle && state->duty_cycle == pwm->state.duty_cycle &&
state->polarity == pwm->state.polarity && state->polarity == pwm->state.polarity &&
state->enabled == pwm->state.enabled) state->enabled == pwm->state.enabled)
return 0; return 0;
if (pwm->chip->ops->apply) { if (chip->ops->apply) {
err = pwm->chip->ops->apply(pwm->chip, pwm, state); err = chip->ops->apply(chip, pwm, state);
if (err) if (err)
return err; return err;
/*
* .apply might have to round some values in *state, if possible
* read the actually implemented value back.
*/
if (chip->ops->get_state)
chip->ops->get_state(chip, pwm, &pwm->state);
else
pwm->state = *state; pwm->state = *state;
} else { } else {
/* /*
* FIXME: restore the initial state in case of error. * FIXME: restore the initial state in case of error.
*/ */
if (state->polarity != pwm->state.polarity) { if (state->polarity != pwm->state.polarity) {
if (!pwm->chip->ops->set_polarity) if (!chip->ops->set_polarity)
return -ENOTSUPP; return -ENOTSUPP;
/* /*
...@@ -486,11 +494,11 @@ int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state) ...@@ -486,11 +494,11 @@ int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state)
* ->apply(). * ->apply().
*/ */
if (pwm->state.enabled) { if (pwm->state.enabled) {
pwm->chip->ops->disable(pwm->chip, pwm); chip->ops->disable(chip, pwm);
pwm->state.enabled = false; pwm->state.enabled = false;
} }
err = pwm->chip->ops->set_polarity(pwm->chip, pwm, err = chip->ops->set_polarity(chip, pwm,
state->polarity); state->polarity);
if (err) if (err)
return err; return err;
...@@ -500,7 +508,7 @@ int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state) ...@@ -500,7 +508,7 @@ int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state)
if (state->period != pwm->state.period || if (state->period != pwm->state.period ||
state->duty_cycle != pwm->state.duty_cycle) { state->duty_cycle != pwm->state.duty_cycle) {
err = pwm->chip->ops->config(pwm->chip, pwm, err = chip->ops->config(pwm->chip, pwm,
state->duty_cycle, state->duty_cycle,
state->period); state->period);
if (err) if (err)
...@@ -512,11 +520,11 @@ int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state) ...@@ -512,11 +520,11 @@ int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state)
if (state->enabled != pwm->state.enabled) { if (state->enabled != pwm->state.enabled) {
if (state->enabled) { if (state->enabled) {
err = pwm->chip->ops->enable(pwm->chip, pwm); err = chip->ops->enable(chip, pwm);
if (err) if (err)
return err; return err;
} else { } else {
pwm->chip->ops->disable(pwm->chip, pwm); chip->ops->disable(chip, pwm);
} }
pwm->state.enabled = state->enabled; pwm->state.enabled = state->enabled;
......
...@@ -39,7 +39,7 @@ static inline struct atmel_hlcdc_pwm *to_atmel_hlcdc_pwm(struct pwm_chip *chip) ...@@ -39,7 +39,7 @@ static inline struct atmel_hlcdc_pwm *to_atmel_hlcdc_pwm(struct pwm_chip *chip)
} }
static int atmel_hlcdc_pwm_apply(struct pwm_chip *c, struct pwm_device *pwm, static int atmel_hlcdc_pwm_apply(struct pwm_chip *c, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct atmel_hlcdc_pwm *chip = to_atmel_hlcdc_pwm(c); struct atmel_hlcdc_pwm *chip = to_atmel_hlcdc_pwm(c);
struct atmel_hlcdc *hlcdc = chip->hlcdc; struct atmel_hlcdc *hlcdc = chip->hlcdc;
......
...@@ -209,7 +209,7 @@ static void atmel_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm, ...@@ -209,7 +209,7 @@ static void atmel_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm,
} }
static int atmel_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int atmel_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct atmel_pwm_chip *atmel_pwm = to_atmel_pwm_chip(chip); struct atmel_pwm_chip *atmel_pwm = to_atmel_pwm_chip(chip);
struct pwm_state cstate; struct pwm_state cstate;
...@@ -318,19 +318,6 @@ static const struct atmel_pwm_data mchp_sam9x60_pwm_data = { ...@@ -318,19 +318,6 @@ static const struct atmel_pwm_data mchp_sam9x60_pwm_data = {
}, },
}; };
static const struct platform_device_id atmel_pwm_devtypes[] = {
{
.name = "at91sam9rl-pwm",
.driver_data = (kernel_ulong_t)&atmel_sam9rl_pwm_data,
}, {
.name = "sama5d3-pwm",
.driver_data = (kernel_ulong_t)&atmel_sama5_pwm_data,
}, {
/* sentinel */
},
};
MODULE_DEVICE_TABLE(platform, atmel_pwm_devtypes);
static const struct of_device_id atmel_pwm_dt_ids[] = { static const struct of_device_id atmel_pwm_dt_ids[] = {
{ {
.compatible = "atmel,at91sam9rl-pwm", .compatible = "atmel,at91sam9rl-pwm",
...@@ -350,34 +337,20 @@ static const struct of_device_id atmel_pwm_dt_ids[] = { ...@@ -350,34 +337,20 @@ static const struct of_device_id atmel_pwm_dt_ids[] = {
}; };
MODULE_DEVICE_TABLE(of, atmel_pwm_dt_ids); MODULE_DEVICE_TABLE(of, atmel_pwm_dt_ids);
static inline const struct atmel_pwm_data *
atmel_pwm_get_driver_data(struct platform_device *pdev)
{
const struct platform_device_id *id;
if (pdev->dev.of_node)
return of_device_get_match_data(&pdev->dev);
id = platform_get_device_id(pdev);
return (struct atmel_pwm_data *)id->driver_data;
}
static int atmel_pwm_probe(struct platform_device *pdev) static int atmel_pwm_probe(struct platform_device *pdev)
{ {
const struct atmel_pwm_data *data;
struct atmel_pwm_chip *atmel_pwm; struct atmel_pwm_chip *atmel_pwm;
struct resource *res; struct resource *res;
int ret; int ret;
data = atmel_pwm_get_driver_data(pdev);
if (!data)
return -ENODEV;
atmel_pwm = devm_kzalloc(&pdev->dev, sizeof(*atmel_pwm), GFP_KERNEL); atmel_pwm = devm_kzalloc(&pdev->dev, sizeof(*atmel_pwm), GFP_KERNEL);
if (!atmel_pwm) if (!atmel_pwm)
return -ENOMEM; return -ENOMEM;
mutex_init(&atmel_pwm->isr_lock);
atmel_pwm->data = of_device_get_match_data(&pdev->dev);
atmel_pwm->updated_pwms = 0;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0); res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
atmel_pwm->base = devm_ioremap_resource(&pdev->dev, res); atmel_pwm->base = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(atmel_pwm->base)) if (IS_ERR(atmel_pwm->base))
...@@ -395,17 +368,10 @@ static int atmel_pwm_probe(struct platform_device *pdev) ...@@ -395,17 +368,10 @@ static int atmel_pwm_probe(struct platform_device *pdev)
atmel_pwm->chip.dev = &pdev->dev; atmel_pwm->chip.dev = &pdev->dev;
atmel_pwm->chip.ops = &atmel_pwm_ops; atmel_pwm->chip.ops = &atmel_pwm_ops;
if (pdev->dev.of_node) {
atmel_pwm->chip.of_xlate = of_pwm_xlate_with_flags; atmel_pwm->chip.of_xlate = of_pwm_xlate_with_flags;
atmel_pwm->chip.of_pwm_n_cells = 3; atmel_pwm->chip.of_pwm_n_cells = 3;
}
atmel_pwm->chip.base = -1; atmel_pwm->chip.base = -1;
atmel_pwm->chip.npwm = 4; atmel_pwm->chip.npwm = 4;
atmel_pwm->data = data;
atmel_pwm->updated_pwms = 0;
mutex_init(&atmel_pwm->isr_lock);
ret = pwmchip_add(&atmel_pwm->chip); ret = pwmchip_add(&atmel_pwm->chip);
if (ret < 0) { if (ret < 0) {
...@@ -437,7 +403,6 @@ static struct platform_driver atmel_pwm_driver = { ...@@ -437,7 +403,6 @@ static struct platform_driver atmel_pwm_driver = {
.name = "atmel-pwm", .name = "atmel-pwm",
.of_match_table = of_match_ptr(atmel_pwm_dt_ids), .of_match_table = of_match_ptr(atmel_pwm_dt_ids),
}, },
.id_table = atmel_pwm_devtypes,
.probe = atmel_pwm_probe, .probe = atmel_pwm_probe,
.remove = atmel_pwm_remove, .remove = atmel_pwm_remove,
}; };
......
...@@ -115,7 +115,7 @@ static void iproc_pwmc_get_state(struct pwm_chip *chip, struct pwm_device *pwm, ...@@ -115,7 +115,7 @@ static void iproc_pwmc_get_state(struct pwm_chip *chip, struct pwm_device *pwm,
} }
static int iproc_pwmc_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int iproc_pwmc_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
unsigned long prescale = IPROC_PWM_PRESCALE_MIN; unsigned long prescale = IPROC_PWM_PRESCALE_MIN;
struct iproc_pwmc *ip = to_iproc_pwmc(chip); struct iproc_pwmc *ip = to_iproc_pwmc(chip);
......
...@@ -21,7 +21,7 @@ ...@@ -21,7 +21,7 @@
#define PERIOD(x) (((x) * 0x10) + 0x10) #define PERIOD(x) (((x) * 0x10) + 0x10)
#define DUTY(x) (((x) * 0x10) + 0x14) #define DUTY(x) (((x) * 0x10) + 0x14)
#define MIN_PERIOD 108 /* 9.2 MHz max. PWM clock */ #define PERIOD_MIN 0x2
struct bcm2835_pwm { struct bcm2835_pwm {
struct pwm_chip chip; struct pwm_chip chip;
...@@ -64,6 +64,7 @@ static int bcm2835_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm, ...@@ -64,6 +64,7 @@ static int bcm2835_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
struct bcm2835_pwm *pc = to_bcm2835_pwm(chip); struct bcm2835_pwm *pc = to_bcm2835_pwm(chip);
unsigned long rate = clk_get_rate(pc->clk); unsigned long rate = clk_get_rate(pc->clk);
unsigned long scaler; unsigned long scaler;
u32 period;
if (!rate) { if (!rate) {
dev_err(pc->dev, "failed to get clock rate\n"); dev_err(pc->dev, "failed to get clock rate\n");
...@@ -71,17 +72,14 @@ static int bcm2835_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm, ...@@ -71,17 +72,14 @@ static int bcm2835_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
} }
scaler = DIV_ROUND_CLOSEST(NSEC_PER_SEC, rate); scaler = DIV_ROUND_CLOSEST(NSEC_PER_SEC, rate);
period = DIV_ROUND_CLOSEST(period_ns, scaler);
if (period_ns <= MIN_PERIOD) { if (period < PERIOD_MIN)
dev_err(pc->dev, "period %d not supported, minimum %d\n",
period_ns, MIN_PERIOD);
return -EINVAL; return -EINVAL;
}
writel(DIV_ROUND_CLOSEST(duty_ns, scaler), writel(DIV_ROUND_CLOSEST(duty_ns, scaler),
pc->base + DUTY(pwm->hwpwm)); pc->base + DUTY(pwm->hwpwm));
writel(DIV_ROUND_CLOSEST(period_ns, scaler), writel(period, pc->base + PERIOD(pwm->hwpwm));
pc->base + PERIOD(pwm->hwpwm));
return 0; return 0;
} }
...@@ -155,8 +153,11 @@ static int bcm2835_pwm_probe(struct platform_device *pdev) ...@@ -155,8 +153,11 @@ static int bcm2835_pwm_probe(struct platform_device *pdev)
pc->clk = devm_clk_get(&pdev->dev, NULL); pc->clk = devm_clk_get(&pdev->dev, NULL);
if (IS_ERR(pc->clk)) { if (IS_ERR(pc->clk)) {
dev_err(&pdev->dev, "clock not found: %ld\n", PTR_ERR(pc->clk)); ret = PTR_ERR(pc->clk);
return PTR_ERR(pc->clk); if (ret != -EPROBE_DEFER)
dev_err(&pdev->dev, "clock not found: %d\n", ret);
return ret;
} }
ret = clk_prepare_enable(pc->clk); ret = clk_prepare_enable(pc->clk);
......
...@@ -93,7 +93,7 @@ static int cros_ec_pwm_get_duty(struct cros_ec_device *ec, u8 index) ...@@ -93,7 +93,7 @@ static int cros_ec_pwm_get_duty(struct cros_ec_device *ec, u8 index)
} }
static int cros_ec_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int cros_ec_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct cros_ec_pwm_device *ec_pwm = pwm_to_cros_ec_pwm(chip); struct cros_ec_pwm_device *ec_pwm = pwm_to_cros_ec_pwm(chip);
int duty_cycle; int duty_cycle;
......
...@@ -227,7 +227,7 @@ static bool fsl_pwm_is_other_pwm_enabled(struct fsl_pwm_chip *fpc, ...@@ -227,7 +227,7 @@ static bool fsl_pwm_is_other_pwm_enabled(struct fsl_pwm_chip *fpc,
static int fsl_pwm_apply_config(struct fsl_pwm_chip *fpc, static int fsl_pwm_apply_config(struct fsl_pwm_chip *fpc,
struct pwm_device *pwm, struct pwm_device *pwm,
struct pwm_state *newstate) const struct pwm_state *newstate)
{ {
unsigned int duty; unsigned int duty;
u32 reg_polarity; u32 reg_polarity;
...@@ -292,17 +292,13 @@ static int fsl_pwm_apply_config(struct fsl_pwm_chip *fpc, ...@@ -292,17 +292,13 @@ static int fsl_pwm_apply_config(struct fsl_pwm_chip *fpc,
regmap_update_bits(fpc->regmap, FTM_POL, BIT(pwm->hwpwm), reg_polarity); regmap_update_bits(fpc->regmap, FTM_POL, BIT(pwm->hwpwm), reg_polarity);
newstate->period = fsl_pwm_ticks_to_ns(fpc,
fpc->period.mod_period + 1);
newstate->duty_cycle = fsl_pwm_ticks_to_ns(fpc, duty);
ftm_set_write_protection(fpc); ftm_set_write_protection(fpc);
return 0; return 0;
} }
static int fsl_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int fsl_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *newstate) const struct pwm_state *newstate)
{ {
struct fsl_pwm_chip *fpc = to_fsl_chip(chip); struct fsl_pwm_chip *fpc = to_fsl_chip(chip);
struct pwm_state *oldstate = &pwm->state; struct pwm_state *oldstate = &pwm->state;
......
...@@ -149,7 +149,7 @@ static void hibvt_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm, ...@@ -149,7 +149,7 @@ static void hibvt_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,
} }
static int hibvt_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int hibvt_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct hibvt_pwm_chip *hi_pwm_chip = to_hibvt_pwm_chip(chip); struct hibvt_pwm_chip *hi_pwm_chip = to_hibvt_pwm_chip(chip);
......
...@@ -89,7 +89,7 @@ to_imx_tpm_pwm_chip(struct pwm_chip *chip) ...@@ -89,7 +89,7 @@ to_imx_tpm_pwm_chip(struct pwm_chip *chip)
static int pwm_imx_tpm_round_state(struct pwm_chip *chip, static int pwm_imx_tpm_round_state(struct pwm_chip *chip,
struct imx_tpm_pwm_param *p, struct imx_tpm_pwm_param *p,
struct pwm_state *real_state, struct pwm_state *real_state,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct imx_tpm_pwm_chip *tpm = to_imx_tpm_pwm_chip(chip); struct imx_tpm_pwm_chip *tpm = to_imx_tpm_pwm_chip(chip);
u32 rate, prescale, period_count, clock_unit; u32 rate, prescale, period_count, clock_unit;
...@@ -289,7 +289,7 @@ static int pwm_imx_tpm_apply_hw(struct pwm_chip *chip, ...@@ -289,7 +289,7 @@ static int pwm_imx_tpm_apply_hw(struct pwm_chip *chip,
static int pwm_imx_tpm_apply(struct pwm_chip *chip, static int pwm_imx_tpm_apply(struct pwm_chip *chip,
struct pwm_device *pwm, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct imx_tpm_pwm_chip *tpm = to_imx_tpm_pwm_chip(chip); struct imx_tpm_pwm_chip *tpm = to_imx_tpm_pwm_chip(chip);
struct imx_tpm_pwm_param param; struct imx_tpm_pwm_param param;
......
...@@ -3,6 +3,10 @@ ...@@ -3,6 +3,10 @@
* simple driver for PWM (Pulse Width Modulator) controller * simple driver for PWM (Pulse Width Modulator) controller
* *
* Derived from pxa PWM driver by eric miao <eric.miao@marvell.com> * Derived from pxa PWM driver by eric miao <eric.miao@marvell.com>
*
* Limitations:
* - When disabled the output is driven to 0 independent of the configured
* polarity.
*/ */
#include <linux/bitfield.h> #include <linux/bitfield.h>
...@@ -205,7 +209,7 @@ static void pwm_imx27_wait_fifo_slot(struct pwm_chip *chip, ...@@ -205,7 +209,7 @@ static void pwm_imx27_wait_fifo_slot(struct pwm_chip *chip,
} }
static int pwm_imx27_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int pwm_imx27_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
unsigned long period_cycles, duty_cycles, prescale; unsigned long period_cycles, duty_cycles, prescale;
struct pwm_imx27_chip *imx = to_pwm_imx27_chip(chip); struct pwm_imx27_chip *imx = to_pwm_imx27_chip(chip);
......
...@@ -2,6 +2,11 @@ ...@@ -2,6 +2,11 @@
/* /*
* Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de> * Copyright (C) 2010, Lars-Peter Clausen <lars@metafoo.de>
* JZ4740 platform PWM support * JZ4740 platform PWM support
*
* Limitations:
* - The .apply callback doesn't complete the currently running period before
* reconfiguring the hardware.
* - Each period starts with the inactive part.
*/ */
#include <linux/clk.h> #include <linux/clk.h>
...@@ -83,7 +88,7 @@ static void jz4740_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm) ...@@ -83,7 +88,7 @@ static void jz4740_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
} }
static int jz4740_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int jz4740_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct jz4740_pwm_chip *jz4740 = to_jz4740(pwm->chip); struct jz4740_pwm_chip *jz4740 = to_jz4740(pwm->chip);
unsigned long long tmp; unsigned long long tmp;
......
...@@ -122,7 +122,7 @@ static inline void pwm_lpss_cond_enable(struct pwm_device *pwm, bool cond) ...@@ -122,7 +122,7 @@ static inline void pwm_lpss_cond_enable(struct pwm_device *pwm, bool cond)
} }
static int pwm_lpss_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int pwm_lpss_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct pwm_lpss_chip *lpwm = to_lpwm(chip); struct pwm_lpss_chip *lpwm = to_lpwm(chip);
int ret; int ret;
......
This diff is collapsed.
...@@ -159,7 +159,7 @@ static void meson_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm) ...@@ -159,7 +159,7 @@ static void meson_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
} }
static int meson_pwm_calc(struct meson_pwm *meson, struct pwm_device *pwm, static int meson_pwm_calc(struct meson_pwm *meson, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct meson_pwm_channel *channel = pwm_get_chip_data(pwm); struct meson_pwm_channel *channel = pwm_get_chip_data(pwm);
unsigned int duty, period, pre_div, cnt, duty_cnt; unsigned int duty, period, pre_div, cnt, duty_cnt;
...@@ -265,7 +265,7 @@ static void meson_pwm_disable(struct meson_pwm *meson, struct pwm_device *pwm) ...@@ -265,7 +265,7 @@ static void meson_pwm_disable(struct meson_pwm *meson, struct pwm_device *pwm)
} }
static int meson_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int meson_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct meson_pwm_channel *channel = pwm_get_chip_data(pwm); struct meson_pwm_channel *channel = pwm_get_chip_data(pwm);
struct meson_pwm *meson = to_meson_pwm(chip); struct meson_pwm *meson = to_meson_pwm(chip);
......
...@@ -126,15 +126,13 @@ static int mxs_pwm_probe(struct platform_device *pdev) ...@@ -126,15 +126,13 @@ static int mxs_pwm_probe(struct platform_device *pdev)
{ {
struct device_node *np = pdev->dev.of_node; struct device_node *np = pdev->dev.of_node;
struct mxs_pwm_chip *mxs; struct mxs_pwm_chip *mxs;
struct resource *res;
int ret; int ret;
mxs = devm_kzalloc(&pdev->dev, sizeof(*mxs), GFP_KERNEL); mxs = devm_kzalloc(&pdev->dev, sizeof(*mxs), GFP_KERNEL);
if (!mxs) if (!mxs)
return -ENOMEM; return -ENOMEM;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0); mxs->base = devm_platform_ioremap_resource(pdev, 0);
mxs->base = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(mxs->base)) if (IS_ERR(mxs->base))
return PTR_ERR(mxs->base); return PTR_ERR(mxs->base);
......
...@@ -158,7 +158,7 @@ static void rcar_pwm_disable(struct rcar_pwm_chip *rp) ...@@ -158,7 +158,7 @@ static void rcar_pwm_disable(struct rcar_pwm_chip *rp)
} }
static int rcar_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int rcar_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct rcar_pwm_chip *rp = to_rcar_pwm_chip(chip); struct rcar_pwm_chip *rp = to_rcar_pwm_chip(chip);
struct pwm_state cur_state; struct pwm_state cur_state;
...@@ -187,7 +187,7 @@ static int rcar_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, ...@@ -187,7 +187,7 @@ static int rcar_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
/* The SYNC should be set to 0 even if rcar_pwm_set_counter failed */ /* The SYNC should be set to 0 even if rcar_pwm_set_counter failed */
rcar_pwm_update(rp, RCAR_PWMCR_SYNC, 0, RCAR_PWMCR); rcar_pwm_update(rp, RCAR_PWMCR_SYNC, 0, RCAR_PWMCR);
if (!ret && state->enabled) if (!ret)
ret = rcar_pwm_enable(rp); ret = rcar_pwm_enable(rp);
return ret; return ret;
......
...@@ -90,16 +90,16 @@ static void rockchip_pwm_get_state(struct pwm_chip *chip, ...@@ -90,16 +90,16 @@ static void rockchip_pwm_get_state(struct pwm_chip *chip,
state->enabled = ((val & enable_conf) == enable_conf) ? state->enabled = ((val & enable_conf) == enable_conf) ?
true : false; true : false;
if (pc->data->supports_polarity) { if (pc->data->supports_polarity && !(val & PWM_DUTY_POSITIVE))
if (!(val & PWM_DUTY_POSITIVE))
state->polarity = PWM_POLARITY_INVERSED; state->polarity = PWM_POLARITY_INVERSED;
} else
state->polarity = PWM_POLARITY_NORMAL;
clk_disable(pc->pclk); clk_disable(pc->pclk);
} }
static void rockchip_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm, static void rockchip_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct rockchip_pwm_chip *pc = to_rockchip_pwm_chip(chip); struct rockchip_pwm_chip *pc = to_rockchip_pwm_chip(chip);
unsigned long period, duty; unsigned long period, duty;
...@@ -183,7 +183,7 @@ static int rockchip_pwm_enable(struct pwm_chip *chip, ...@@ -183,7 +183,7 @@ static int rockchip_pwm_enable(struct pwm_chip *chip,
} }
static int rockchip_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int rockchip_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct rockchip_pwm_chip *pc = to_rockchip_pwm_chip(chip); struct rockchip_pwm_chip *pc = to_rockchip_pwm_chip(chip);
struct pwm_state curstate; struct pwm_state curstate;
...@@ -212,12 +212,6 @@ static int rockchip_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, ...@@ -212,12 +212,6 @@ static int rockchip_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
goto out; goto out;
} }
/*
* Update the state with the real hardware, which can differ a bit
* because of period/duty_cycle approximation.
*/
rockchip_pwm_get_state(chip, pwm, state);
out: out:
clk_disable(pc->pclk); clk_disable(pc->pclk);
......
...@@ -147,7 +147,7 @@ static int pwm_sifive_enable(struct pwm_chip *chip, bool enable) ...@@ -147,7 +147,7 @@ static int pwm_sifive_enable(struct pwm_chip *chip, bool enable)
} }
static int pwm_sifive_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int pwm_sifive_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct pwm_sifive_ddata *ddata = pwm_sifive_chip_to_ddata(chip); struct pwm_sifive_ddata *ddata = pwm_sifive_chip_to_ddata(chip);
struct pwm_state cur_state; struct pwm_state cur_state;
...@@ -250,10 +250,8 @@ static int pwm_sifive_probe(struct platform_device *pdev) ...@@ -250,10 +250,8 @@ static int pwm_sifive_probe(struct platform_device *pdev)
res = platform_get_resource(pdev, IORESOURCE_MEM, 0); res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
ddata->regs = devm_ioremap_resource(dev, res); ddata->regs = devm_ioremap_resource(dev, res);
if (IS_ERR(ddata->regs)) { if (IS_ERR(ddata->regs))
dev_err(dev, "Unable to map IO resources\n");
return PTR_ERR(ddata->regs); return PTR_ERR(ddata->regs);
}
ddata->clk = devm_clk_get(dev, NULL); ddata->clk = devm_clk_get(dev, NULL);
if (IS_ERR(ddata->clk)) { if (IS_ERR(ddata->clk)) {
......
// SPDX-License-Identifier: GPL-2.0
/*
* Copyright (C) 2019 Spreadtrum Communications Inc.
*/
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/io.h>
#include <linux/math64.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/pwm.h>
#define SPRD_PWM_PRESCALE 0x0
#define SPRD_PWM_MOD 0x4
#define SPRD_PWM_DUTY 0x8
#define SPRD_PWM_ENABLE 0x18
#define SPRD_PWM_MOD_MAX GENMASK(7, 0)
#define SPRD_PWM_DUTY_MSK GENMASK(15, 0)
#define SPRD_PWM_PRESCALE_MSK GENMASK(7, 0)
#define SPRD_PWM_ENABLE_BIT BIT(0)
#define SPRD_PWM_CHN_NUM 4
#define SPRD_PWM_REGS_SHIFT 5
#define SPRD_PWM_CHN_CLKS_NUM 2
#define SPRD_PWM_CHN_OUTPUT_CLK 1
struct sprd_pwm_chn {
struct clk_bulk_data clks[SPRD_PWM_CHN_CLKS_NUM];
u32 clk_rate;
};
struct sprd_pwm_chip {
void __iomem *base;
struct device *dev;
struct pwm_chip chip;
int num_pwms;
struct sprd_pwm_chn chn[SPRD_PWM_CHN_NUM];
};
/*
* The list of clocks required by PWM channels, and each channel has 2 clocks:
* enable clock and pwm clock.
*/
static const char * const sprd_pwm_clks[] = {
"enable0", "pwm0",
"enable1", "pwm1",
"enable2", "pwm2",
"enable3", "pwm3",
};
static u32 sprd_pwm_read(struct sprd_pwm_chip *spc, u32 hwid, u32 reg)
{
u32 offset = reg + (hwid << SPRD_PWM_REGS_SHIFT);
return readl_relaxed(spc->base + offset);
}
static void sprd_pwm_write(struct sprd_pwm_chip *spc, u32 hwid,
u32 reg, u32 val)
{
u32 offset = reg + (hwid << SPRD_PWM_REGS_SHIFT);
writel_relaxed(val, spc->base + offset);
}
static void sprd_pwm_get_state(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state)
{
struct sprd_pwm_chip *spc =
container_of(chip, struct sprd_pwm_chip, chip);
struct sprd_pwm_chn *chn = &spc->chn[pwm->hwpwm];
u32 val, duty, prescale;
u64 tmp;
int ret;
/*
* The clocks to PWM channel has to be enabled first before
* reading to the registers.
*/
ret = clk_bulk_prepare_enable(SPRD_PWM_CHN_CLKS_NUM, chn->clks);
if (ret) {
dev_err(spc->dev, "failed to enable pwm%u clocks\n",
pwm->hwpwm);
return;
}
val = sprd_pwm_read(spc, pwm->hwpwm, SPRD_PWM_ENABLE);
if (val & SPRD_PWM_ENABLE_BIT)
state->enabled = true;
else
state->enabled = false;
/*
* The hardware provides a counter that is feed by the source clock.
* The period length is (PRESCALE + 1) * MOD counter steps.
* The duty cycle length is (PRESCALE + 1) * DUTY counter steps.
* Thus the period_ns and duty_ns calculation formula should be:
* period_ns = NSEC_PER_SEC * (prescale + 1) * mod / clk_rate
* duty_ns = NSEC_PER_SEC * (prescale + 1) * duty / clk_rate
*/
val = sprd_pwm_read(spc, pwm->hwpwm, SPRD_PWM_PRESCALE);
prescale = val & SPRD_PWM_PRESCALE_MSK;
tmp = (prescale + 1) * NSEC_PER_SEC * SPRD_PWM_MOD_MAX;
state->period = DIV_ROUND_CLOSEST_ULL(tmp, chn->clk_rate);
val = sprd_pwm_read(spc, pwm->hwpwm, SPRD_PWM_DUTY);
duty = val & SPRD_PWM_DUTY_MSK;
tmp = (prescale + 1) * NSEC_PER_SEC * duty;
state->duty_cycle = DIV_ROUND_CLOSEST_ULL(tmp, chn->clk_rate);
/* Disable PWM clocks if the PWM channel is not in enable state. */
if (!state->enabled)
clk_bulk_disable_unprepare(SPRD_PWM_CHN_CLKS_NUM, chn->clks);
}
static int sprd_pwm_config(struct sprd_pwm_chip *spc, struct pwm_device *pwm,
int duty_ns, int period_ns)
{
struct sprd_pwm_chn *chn = &spc->chn[pwm->hwpwm];
u32 prescale, duty;
u64 tmp;
/*
* The hardware provides a counter that is feed by the source clock.
* The period length is (PRESCALE + 1) * MOD counter steps.
* The duty cycle length is (PRESCALE + 1) * DUTY counter steps.
*
* To keep the maths simple we're always using MOD = SPRD_PWM_MOD_MAX.
* The value for PRESCALE is selected such that the resulting period
* gets the maximal length not bigger than the requested one with the
* given settings (MOD = SPRD_PWM_MOD_MAX and input clock).
*/
duty = duty_ns * SPRD_PWM_MOD_MAX / period_ns;
tmp = (u64)chn->clk_rate * period_ns;
do_div(tmp, NSEC_PER_SEC);
prescale = DIV_ROUND_CLOSEST_ULL(tmp, SPRD_PWM_MOD_MAX) - 1;
if (prescale > SPRD_PWM_PRESCALE_MSK)
prescale = SPRD_PWM_PRESCALE_MSK;
/*
* Note: Writing DUTY triggers the hardware to actually apply the
* values written to MOD and DUTY to the output, so must keep writing
* DUTY last.
*
* The hardware can ensures that current running period is completed
* before changing a new configuration to avoid mixed settings.
*/
sprd_pwm_write(spc, pwm->hwpwm, SPRD_PWM_PRESCALE, prescale);
sprd_pwm_write(spc, pwm->hwpwm, SPRD_PWM_MOD, SPRD_PWM_MOD_MAX);
sprd_pwm_write(spc, pwm->hwpwm, SPRD_PWM_DUTY, duty);
return 0;
}
static int sprd_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
const struct pwm_state *state)
{
struct sprd_pwm_chip *spc =
container_of(chip, struct sprd_pwm_chip, chip);
struct sprd_pwm_chn *chn = &spc->chn[pwm->hwpwm];
struct pwm_state *cstate = &pwm->state;
int ret;
if (state->enabled) {
if (!cstate->enabled) {
/*
* The clocks to PWM channel has to be enabled first
* before writing to the registers.
*/
ret = clk_bulk_prepare_enable(SPRD_PWM_CHN_CLKS_NUM,
chn->clks);
if (ret) {
dev_err(spc->dev,
"failed to enable pwm%u clocks\n",
pwm->hwpwm);
return ret;
}
}
if (state->period != cstate->period ||
state->duty_cycle != cstate->duty_cycle) {
ret = sprd_pwm_config(spc, pwm, state->duty_cycle,
state->period);
if (ret)
return ret;
}
sprd_pwm_write(spc, pwm->hwpwm, SPRD_PWM_ENABLE, 1);
} else if (cstate->enabled) {
/*
* Note: After setting SPRD_PWM_ENABLE to zero, the controller
* will not wait for current period to be completed, instead it
* will stop the PWM channel immediately.
*/
sprd_pwm_write(spc, pwm->hwpwm, SPRD_PWM_ENABLE, 0);
clk_bulk_disable_unprepare(SPRD_PWM_CHN_CLKS_NUM, chn->clks);
}
return 0;
}
static const struct pwm_ops sprd_pwm_ops = {
.apply = sprd_pwm_apply,
.get_state = sprd_pwm_get_state,
.owner = THIS_MODULE,
};
static int sprd_pwm_clk_init(struct sprd_pwm_chip *spc)
{
struct clk *clk_pwm;
int ret, i;
for (i = 0; i < SPRD_PWM_CHN_NUM; i++) {
struct sprd_pwm_chn *chn = &spc->chn[i];
int j;
for (j = 0; j < SPRD_PWM_CHN_CLKS_NUM; ++j)
chn->clks[j].id =
sprd_pwm_clks[i * SPRD_PWM_CHN_CLKS_NUM + j];
ret = devm_clk_bulk_get(spc->dev, SPRD_PWM_CHN_CLKS_NUM,
chn->clks);
if (ret) {
if (ret == -ENOENT)
break;
if (ret != -EPROBE_DEFER)
dev_err(spc->dev,
"failed to get channel clocks\n");
return ret;
}
clk_pwm = chn->clks[SPRD_PWM_CHN_OUTPUT_CLK].clk;
chn->clk_rate = clk_get_rate(clk_pwm);
}
if (!i) {
dev_err(spc->dev, "no available PWM channels\n");
return -ENODEV;
}
spc->num_pwms = i;
return 0;
}
static int sprd_pwm_probe(struct platform_device *pdev)
{
struct sprd_pwm_chip *spc;
int ret;
spc = devm_kzalloc(&pdev->dev, sizeof(*spc), GFP_KERNEL);
if (!spc)
return -ENOMEM;
spc->base = devm_platform_ioremap_resource(pdev, 0);
if (IS_ERR(spc->base))
return PTR_ERR(spc->base);
spc->dev = &pdev->dev;
platform_set_drvdata(pdev, spc);
ret = sprd_pwm_clk_init(spc);
if (ret)
return ret;
spc->chip.dev = &pdev->dev;
spc->chip.ops = &sprd_pwm_ops;
spc->chip.base = -1;
spc->chip.npwm = spc->num_pwms;
ret = pwmchip_add(&spc->chip);
if (ret)
dev_err(&pdev->dev, "failed to add PWM chip\n");
return ret;
}
static int sprd_pwm_remove(struct platform_device *pdev)
{
struct sprd_pwm_chip *spc = platform_get_drvdata(pdev);
return pwmchip_remove(&spc->chip);
}
static const struct of_device_id sprd_pwm_of_match[] = {
{ .compatible = "sprd,ums512-pwm", },
{ },
};
MODULE_DEVICE_TABLE(of, sprd_pwm_of_match);
static struct platform_driver sprd_pwm_driver = {
.driver = {
.name = "sprd-pwm",
.of_match_table = sprd_pwm_of_match,
},
.probe = sprd_pwm_probe,
.remove = sprd_pwm_remove,
};
module_platform_driver(sprd_pwm_driver);
MODULE_DESCRIPTION("Spreadtrum PWM Driver");
MODULE_LICENSE("GPL v2");
...@@ -564,10 +564,8 @@ static int sti_pwm_probe(struct platform_device *pdev) ...@@ -564,10 +564,8 @@ static int sti_pwm_probe(struct platform_device *pdev)
return PTR_ERR(pc->regmap); return PTR_ERR(pc->regmap);
irq = platform_get_irq(pdev, 0); irq = platform_get_irq(pdev, 0);
if (irq < 0) { if (irq < 0)
dev_err(&pdev->dev, "Failed to obtain IRQ\n");
return irq; return irq;
}
ret = devm_request_irq(&pdev->dev, irq, sti_pwm_interrupt, 0, ret = devm_request_irq(&pdev->dev, irq, sti_pwm_interrupt, 0,
pdev->name, pc); pdev->name, pc);
......
...@@ -32,7 +32,7 @@ static inline struct stm32_pwm_lp *to_stm32_pwm_lp(struct pwm_chip *chip) ...@@ -32,7 +32,7 @@ static inline struct stm32_pwm_lp *to_stm32_pwm_lp(struct pwm_chip *chip)
#define STM32_LPTIM_MAX_PRESCALER 128 #define STM32_LPTIM_MAX_PRESCALER 128
static int stm32_pwm_lp_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int stm32_pwm_lp_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct stm32_pwm_lp *priv = to_stm32_pwm_lp(chip); struct stm32_pwm_lp *priv = to_stm32_pwm_lp(chip);
unsigned long long prd, div, dty; unsigned long long prd, div, dty;
...@@ -59,6 +59,12 @@ static int stm32_pwm_lp_apply(struct pwm_chip *chip, struct pwm_device *pwm, ...@@ -59,6 +59,12 @@ static int stm32_pwm_lp_apply(struct pwm_chip *chip, struct pwm_device *pwm,
/* Calculate the period and prescaler value */ /* Calculate the period and prescaler value */
div = (unsigned long long)clk_get_rate(priv->clk) * state->period; div = (unsigned long long)clk_get_rate(priv->clk) * state->period;
do_div(div, NSEC_PER_SEC); do_div(div, NSEC_PER_SEC);
if (!div) {
/* Clock is too slow to achieve requested period. */
dev_dbg(priv->chip.dev, "Can't reach %u ns\n", state->period);
return -EINVAL;
}
prd = div; prd = div;
while (div > STM32_LPTIM_MAX_ARR) { while (div > STM32_LPTIM_MAX_ARR) {
presc++; presc++;
......
...@@ -440,7 +440,7 @@ static void stm32_pwm_disable(struct stm32_pwm *priv, int ch) ...@@ -440,7 +440,7 @@ static void stm32_pwm_disable(struct stm32_pwm *priv, int ch)
} }
static int stm32_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int stm32_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
bool enabled; bool enabled;
struct stm32_pwm *priv = to_stm32_pwm_dev(chip); struct stm32_pwm *priv = to_stm32_pwm_dev(chip);
...@@ -468,7 +468,7 @@ static int stm32_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, ...@@ -468,7 +468,7 @@ static int stm32_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
} }
static int stm32_pwm_apply_locked(struct pwm_chip *chip, struct pwm_device *pwm, static int stm32_pwm_apply_locked(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct stm32_pwm *priv = to_stm32_pwm_dev(chip); struct stm32_pwm *priv = to_stm32_pwm_dev(chip);
int ret; int ret;
......
...@@ -145,7 +145,7 @@ static void sun4i_pwm_get_state(struct pwm_chip *chip, ...@@ -145,7 +145,7 @@ static void sun4i_pwm_get_state(struct pwm_chip *chip,
} }
static int sun4i_pwm_calculate(struct sun4i_pwm_chip *sun4i_pwm, static int sun4i_pwm_calculate(struct sun4i_pwm_chip *sun4i_pwm,
struct pwm_state *state, const struct pwm_state *state,
u32 *dty, u32 *prd, unsigned int *prsclr) u32 *dty, u32 *prd, unsigned int *prsclr)
{ {
u64 clk_rate, div = 0; u64 clk_rate, div = 0;
...@@ -192,17 +192,11 @@ static int sun4i_pwm_calculate(struct sun4i_pwm_chip *sun4i_pwm, ...@@ -192,17 +192,11 @@ static int sun4i_pwm_calculate(struct sun4i_pwm_chip *sun4i_pwm,
*dty = div; *dty = div;
*prsclr = prescaler; *prsclr = prescaler;
div = (u64)pval * NSEC_PER_SEC * *prd;
state->period = DIV_ROUND_CLOSEST_ULL(div, clk_rate);
div = (u64)pval * NSEC_PER_SEC * *dty;
state->duty_cycle = DIV_ROUND_CLOSEST_ULL(div, clk_rate);
return 0; return 0;
} }
static int sun4i_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int sun4i_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct sun4i_pwm_chip *sun4i_pwm = to_sun4i_pwm_chip(chip); struct sun4i_pwm_chip *sun4i_pwm = to_sun4i_pwm_chip(chip);
struct pwm_state cstate; struct pwm_state cstate;
......
...@@ -148,7 +148,7 @@ static int zx_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm, ...@@ -148,7 +148,7 @@ static int zx_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
} }
static int zx_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm, static int zx_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state) const struct pwm_state *state)
{ {
struct zx_pwm_chip *zpc = to_zx_pwm_chip(chip); struct zx_pwm_chip *zpc = to_zx_pwm_chip(chip);
struct pwm_state cstate; struct pwm_state cstate;
......
...@@ -262,7 +262,7 @@ struct pwm_ops { ...@@ -262,7 +262,7 @@ struct pwm_ops {
int (*capture)(struct pwm_chip *chip, struct pwm_device *pwm, int (*capture)(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_capture *result, unsigned long timeout); struct pwm_capture *result, unsigned long timeout);
int (*apply)(struct pwm_chip *chip, struct pwm_device *pwm, int (*apply)(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state); const struct pwm_state *state);
void (*get_state)(struct pwm_chip *chip, struct pwm_device *pwm, void (*get_state)(struct pwm_chip *chip, struct pwm_device *pwm,
struct pwm_state *state); struct pwm_state *state);
struct module *owner; struct module *owner;
...@@ -316,7 +316,7 @@ struct pwm_capture { ...@@ -316,7 +316,7 @@ struct pwm_capture {
/* PWM user APIs */ /* PWM user APIs */
struct pwm_device *pwm_request(int pwm_id, const char *label); struct pwm_device *pwm_request(int pwm_id, const char *label);
void pwm_free(struct pwm_device *pwm); void pwm_free(struct pwm_device *pwm);
int pwm_apply_state(struct pwm_device *pwm, struct pwm_state *state); int pwm_apply_state(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);
/** /**
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment