Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs

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

diff --git a/drivers/pwm/pwm-stm32-lp.c b/drivers/pwm/pwm-stm32-lp.c
index b67974cc18725189fd1bbc33e1449a68d035757a..989731256f5030c5a1752e7d22e2251ff2a41c5b 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 {
 #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)
 {
        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 */
 }
 
 /* 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. */
        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;
        }
 
                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) {
        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;
                        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) {
                                       (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,
                goto err;
        }
        ret = regmap_write(priv->regmap, STM32_LPTIM_ICR,


@@ -197,49 +196,49 @@ 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 stm32_lptimer *ddata = dev_get_drvdata(pdev->dev.parent);
        struct stm32_pwm_lp *priv;

+       struct pwm_chip *chip;

        int ret;
 
        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->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;
 
        if (ret < 0)
                return ret;
 

-       platform_set_drvdata(pdev, priv);
+       platform_set_drvdata(pdev, chip);

 
        return 0;
 }
 
 
        return 0;
 }
 

-static int __maybe_unused stm32_pwm_lp_suspend(struct device *dev)
+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;
 
        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",
        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;
        }
 
        return pinctrl_pm_select_sleep_state(dev);
 }
 
                return -EBUSY;
        }
 
        return pinctrl_pm_select_sleep_state(dev);
 }
 

-static int __maybe_unused stm32_pwm_lp_resume(struct device *dev)
+static int stm32_pwm_lp_resume(struct device *dev)

 {
        return pinctrl_pm_select_default_state(dev);
 }
 
 {
        return pinctrl_pm_select_default_state(dev);
 }
 

-static SIMPLE_DEV_PM_OPS(stm32_pwm_lp_pm_ops, stm32_pwm_lp_suspend,
-                        stm32_pwm_lp_resume);
+static DEFINE_SIMPLE_DEV_PM_OPS(stm32_pwm_lp_pm_ops, stm32_pwm_lp_suspend,
+                               stm32_pwm_lp_resume);

 
 static const struct of_device_id stm32_pwm_lp_of_match[] = {
        { .compatible = "st,stm32-pwm-lp", },
 
 static const struct of_device_id stm32_pwm_lp_of_match[] = {
        { .compatible = "st,stm32-pwm-lp", },


@@ -252,7 +251,7 @@ static struct platform_driver stm32_pwm_lp_driver = {
        .driver = {
                .name = "stm32-pwm-lp",
                .of_match_table = stm32_pwm_lp_of_match,
        .driver = {
                .name = "stm32-pwm-lp",
                .of_match_table = stm32_pwm_lp_of_match,

-               .pm = &stm32_pwm_lp_pm_ops,
+               .pm = pm_ptr(&stm32_pwm_lp_pm_ops),

        },
 };
 module_platform_driver(stm32_pwm_lp_driver);
        },
 };
 module_platform_driver(stm32_pwm_lp_driver);