Linux 6.9-rc1

[linux-2.6-microblaze.git] / drivers / pwm / pwm-stm32-lp.c

diff --git a/drivers/pwm/pwm-stm32-lp.c b/drivers/pwm/pwm-stm32-lp.c
index 439068f..9897312 100644 (file)
--- a/drivers/pwm/pwm-stm32-lp.c
+++ b/drivers/pwm/pwm-stm32-lp.c
@@ -18,14 +18,13 @@
 #include <linux/pwm.h>
 
 struct stm32_pwm_lp {
-       struct pwm_chip chip;
        struct clk *clk;
        struct regmap *regmap;
 };
 
 static inline struct stm32_pwm_lp *to_stm32_pwm_lp(struct pwm_chip *chip)
 {
-       return container_of(chip, struct stm32_pwm_lp, chip);
+       return pwmchip_get_drvdata(chip);
 }
 
 /* STM32 Low-Power Timer is preceded by a configurable power-of-2 prescaler */
@@ -61,7 +60,7 @@ static int stm32_pwm_lp_apply(struct pwm_chip *chip, struct pwm_device *pwm,
        do_div(div, NSEC_PER_SEC);
        if (!div) {
                /* Clock is too slow to achieve requested period. */
-               dev_dbg(priv->chip.dev, "Can't reach %llu ns\n", state->period);
+               dev_dbg(pwmchip_parent(chip), "Can't reach %llu ns\n", state->period);
                return -EINVAL;
        }
 
@@ -69,7 +68,7 @@ static int stm32_pwm_lp_apply(struct pwm_chip *chip, struct pwm_device *pwm,
        while (div > STM32_LPTIM_MAX_ARR) {
                presc++;
                if ((1 << presc) > STM32_LPTIM_MAX_PRESCALER) {
-                       dev_err(priv->chip.dev, "max prescaler exceeded\n");
+                       dev_err(pwmchip_parent(chip), "max prescaler exceeded\n");
                        return -EINVAL;
                }
                div = prd >> presc;
@@ -130,7 +129,7 @@ static int stm32_pwm_lp_apply(struct pwm_chip *chip, struct pwm_device *pwm,
                                       (val & STM32_LPTIM_CMPOK_ARROK) == STM32_LPTIM_CMPOK_ARROK,
                                       100, 1000);
        if (ret) {
-               dev_err(priv->chip.dev, "ARR/CMP registers write issue\n");
+               dev_err(pwmchip_parent(chip), "ARR/CMP registers write issue\n");
                goto err;
        }
        ret = regmap_write(priv->regmap, STM32_LPTIM_ICR,
@@ -197,36 +196,36 @@ static int stm32_pwm_lp_probe(struct platform_device *pdev)
 {
        struct stm32_lptimer *ddata = dev_get_drvdata(pdev->dev.parent);
        struct stm32_pwm_lp *priv;
+       struct pwm_chip *chip;
        int ret;
 
-       priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
-       if (!priv)
-               return -ENOMEM;
+       chip = devm_pwmchip_alloc(&pdev->dev, 1, sizeof(*priv));
+       if (IS_ERR(chip))
+               return PTR_ERR(chip);
+       priv = to_stm32_pwm_lp(chip);
 
        priv->regmap = ddata->regmap;
        priv->clk = ddata->clk;
-       priv->chip.dev = &pdev->dev;
-       priv->chip.ops = &stm32_pwm_lp_ops;
-       priv->chip.npwm = 1;
+       chip->ops = &stm32_pwm_lp_ops;
 
-       ret = devm_pwmchip_add(&pdev->dev, &priv->chip);
+       ret = devm_pwmchip_add(&pdev->dev, chip);
        if (ret < 0)
                return ret;
 
-       platform_set_drvdata(pdev, priv);
+       platform_set_drvdata(pdev, chip);
 
        return 0;
 }
 
 static int stm32_pwm_lp_suspend(struct device *dev)
 {
-       struct stm32_pwm_lp *priv = dev_get_drvdata(dev);
+       struct pwm_chip *chip = dev_get_drvdata(dev);
        struct pwm_state state;
 
-       pwm_get_state(&priv->chip.pwms[0], &state);
+       pwm_get_state(&chip->pwms[0], &state);
        if (state.enabled) {
                dev_err(dev, "The consumer didn't stop us (%s)\n",
-                       priv->chip.pwms[0].label);
+                       chip->pwms[0].label);
                return -EBUSY;
        }