pwm: atmel-tcb: Make private data variable naming consistent

Currently the variables of type struct atmel_tcb_pwm_device
are named "tcbpwm", and variables of type atmel_tcb_pwm_chip are either
named "tcbpwm" (too!) or "tcbpwmc". Rename the chips with device name to
"tcbpwmc" to get a consistent naming.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
Acked-by: Nicolas Ferre <nicolas.ferre@microchip.com>
Link: https://lore.kernel.org/r/20240709092221.47025-2-u.kleine-koenig@baylibre.com
Signed-off-by: Uwe Kleine-König <ukleinek@kernel.org>

diff --git a/drivers/pwm/pwm-atmel-tcb.c b/drivers/pwm/pwm-atmel-tcb.c
index 2feee3744b50305b7c9afa01826ee4bebd901743..f9a9c12cbcdd62af617d74439b9c84404af5e666 100644 (file)
--- a/drivers/pwm/pwm-atmel-tcb.c
+++ b/drivers/pwm/pwm-atmel-tcb.c
@@ -382,17 +382,17 @@ static int atmel_tcb_pwm_probe(struct platform_device *pdev)
 {
        struct pwm_chip *chip;
        const struct of_device_id *match;
-       struct atmel_tcb_pwm_chip *tcbpwm;
+       struct atmel_tcb_pwm_chip *tcbpwmc;
        const struct atmel_tcb_config *config;
        struct device_node *np = pdev->dev.of_node;
        char clk_name[] = "t0_clk";
        int err;
        int channel;
 
-       chip = devm_pwmchip_alloc(&pdev->dev, NPWM, sizeof(*tcbpwm));
+       chip = devm_pwmchip_alloc(&pdev->dev, NPWM, sizeof(*tcbpwmc));
        if (IS_ERR(chip))
                return PTR_ERR(chip);
-       tcbpwm = to_tcb_chip(chip);
+       tcbpwmc = to_tcb_chip(chip);
 
        err = of_property_read_u32(np, "reg", &channel);
        if (err < 0) {
@@ -402,20 +402,20 @@ static int atmel_tcb_pwm_probe(struct platform_device *pdev)
                return err;
        }
 
-       tcbpwm->regmap = syscon_node_to_regmap(np->parent);
-       if (IS_ERR(tcbpwm->regmap))
-               return PTR_ERR(tcbpwm->regmap);
+       tcbpwmc->regmap = syscon_node_to_regmap(np->parent);
+       if (IS_ERR(tcbpwmc->regmap))
+               return PTR_ERR(tcbpwmc->regmap);
 
-       tcbpwm->slow_clk = of_clk_get_by_name(np->parent, "slow_clk");
-       if (IS_ERR(tcbpwm->slow_clk))
-               return PTR_ERR(tcbpwm->slow_clk);
+       tcbpwmc->slow_clk = of_clk_get_by_name(np->parent, "slow_clk");
+       if (IS_ERR(tcbpwmc->slow_clk))
+               return PTR_ERR(tcbpwmc->slow_clk);
 
        clk_name[1] += channel;
-       tcbpwm->clk = of_clk_get_by_name(np->parent, clk_name);
-       if (IS_ERR(tcbpwm->clk))
-               tcbpwm->clk = of_clk_get_by_name(np->parent, "t0_clk");
-       if (IS_ERR(tcbpwm->clk)) {
-               err = PTR_ERR(tcbpwm->clk);
+       tcbpwmc->clk = of_clk_get_by_name(np->parent, clk_name);
+       if (IS_ERR(tcbpwmc->clk))
+               tcbpwmc->clk = of_clk_get_by_name(np->parent, "t0_clk");
+       if (IS_ERR(tcbpwmc->clk)) {
+               err = PTR_ERR(tcbpwmc->clk);
                goto err_slow_clk;
        }
 
@@ -423,22 +423,22 @@ static int atmel_tcb_pwm_probe(struct platform_device *pdev)
        config = match->data;
 
        if (config->has_gclk) {
-               tcbpwm->gclk = of_clk_get_by_name(np->parent, "gclk");
-               if (IS_ERR(tcbpwm->gclk)) {
-                       err = PTR_ERR(tcbpwm->gclk);
+               tcbpwmc->gclk = of_clk_get_by_name(np->parent, "gclk");
+               if (IS_ERR(tcbpwmc->gclk)) {
+                       err = PTR_ERR(tcbpwmc->gclk);
                        goto err_clk;
                }
        }
 
        chip->ops = &atmel_tcb_pwm_ops;
-       tcbpwm->channel = channel;
-       tcbpwm->width = config->counter_width;
+       tcbpwmc->channel = channel;
+       tcbpwmc->width = config->counter_width;
 
-       err = clk_prepare_enable(tcbpwm->slow_clk);
+       err = clk_prepare_enable(tcbpwmc->slow_clk);
        if (err)
                goto err_gclk;
 
-       spin_lock_init(&tcbpwm->lock);
+       spin_lock_init(&tcbpwmc->lock);
 
        err = pwmchip_add(chip);
        if (err < 0)
@@ -449,16 +449,16 @@ static int atmel_tcb_pwm_probe(struct platform_device *pdev)
        return 0;
 
 err_disable_clk:
-       clk_disable_unprepare(tcbpwm->slow_clk);
+       clk_disable_unprepare(tcbpwmc->slow_clk);
 
 err_gclk:
-       clk_put(tcbpwm->gclk);
+       clk_put(tcbpwmc->gclk);
 
 err_clk:
-       clk_put(tcbpwm->clk);
+       clk_put(tcbpwmc->clk);
 
 err_slow_clk:
-       clk_put(tcbpwm->slow_clk);
+       clk_put(tcbpwmc->slow_clk);
 
        return err;
 }
@@ -466,14 +466,14 @@ err_slow_clk:
 static void atmel_tcb_pwm_remove(struct platform_device *pdev)
 {
        struct pwm_chip *chip = platform_get_drvdata(pdev);
-       struct atmel_tcb_pwm_chip *tcbpwm = to_tcb_chip(chip);
+       struct atmel_tcb_pwm_chip *tcbpwmc = to_tcb_chip(chip);
 
        pwmchip_remove(chip);
 
-       clk_disable_unprepare(tcbpwm->slow_clk);
-       clk_put(tcbpwm->gclk);
-       clk_put(tcbpwm->clk);
-       clk_put(tcbpwm->slow_clk);
+       clk_disable_unprepare(tcbpwmc->slow_clk);
+       clk_put(tcbpwmc->gclk);
+       clk_put(tcbpwmc->clk);
+       clk_put(tcbpwmc->slow_clk);
 }
 
 static const struct of_device_id atmel_tcb_pwm_dt_ids[] = {
@@ -485,14 +485,14 @@ MODULE_DEVICE_TABLE(of, atmel_tcb_pwm_dt_ids);
 static int atmel_tcb_pwm_suspend(struct device *dev)
 {
        struct pwm_chip *chip = dev_get_drvdata(dev);
-       struct atmel_tcb_pwm_chip *tcbpwm = to_tcb_chip(chip);
-       struct atmel_tcb_channel *chan = &tcbpwm->bkup;
-       unsigned int channel = tcbpwm->channel;
+       struct atmel_tcb_pwm_chip *tcbpwmc = to_tcb_chip(chip);
+       struct atmel_tcb_channel *chan = &tcbpwmc->bkup;
+       unsigned int channel = tcbpwmc->channel;
 
-       regmap_read(tcbpwm->regmap, ATMEL_TC_REG(channel, CMR), &chan->cmr);
-       regmap_read(tcbpwm->regmap, ATMEL_TC_REG(channel, RA), &chan->ra);
-       regmap_read(tcbpwm->regmap, ATMEL_TC_REG(channel, RB), &chan->rb);
-       regmap_read(tcbpwm->regmap, ATMEL_TC_REG(channel, RC), &chan->rc);
+       regmap_read(tcbpwmc->regmap, ATMEL_TC_REG(channel, CMR), &chan->cmr);
+       regmap_read(tcbpwmc->regmap, ATMEL_TC_REG(channel, RA), &chan->ra);
+       regmap_read(tcbpwmc->regmap, ATMEL_TC_REG(channel, RB), &chan->rb);
+       regmap_read(tcbpwmc->regmap, ATMEL_TC_REG(channel, RC), &chan->rc);
 
        return 0;
 }
@@ -500,17 +500,17 @@ static int atmel_tcb_pwm_suspend(struct device *dev)
 static int atmel_tcb_pwm_resume(struct device *dev)
 {
        struct pwm_chip *chip = dev_get_drvdata(dev);
-       struct atmel_tcb_pwm_chip *tcbpwm = to_tcb_chip(chip);
-       struct atmel_tcb_channel *chan = &tcbpwm->bkup;
-       unsigned int channel = tcbpwm->channel;
+       struct atmel_tcb_pwm_chip *tcbpwmc = to_tcb_chip(chip);
+       struct atmel_tcb_channel *chan = &tcbpwmc->bkup;
+       unsigned int channel = tcbpwmc->channel;
 
-       regmap_write(tcbpwm->regmap, ATMEL_TC_REG(channel, CMR), chan->cmr);
-       regmap_write(tcbpwm->regmap, ATMEL_TC_REG(channel, RA), chan->ra);
-       regmap_write(tcbpwm->regmap, ATMEL_TC_REG(channel, RB), chan->rb);
-       regmap_write(tcbpwm->regmap, ATMEL_TC_REG(channel, RC), chan->rc);
+       regmap_write(tcbpwmc->regmap, ATMEL_TC_REG(channel, CMR), chan->cmr);
+       regmap_write(tcbpwmc->regmap, ATMEL_TC_REG(channel, RA), chan->ra);
+       regmap_write(tcbpwmc->regmap, ATMEL_TC_REG(channel, RB), chan->rb);
+       regmap_write(tcbpwmc->regmap, ATMEL_TC_REG(channel, RC), chan->rc);
 
        if (chan->enabled)
-               regmap_write(tcbpwm->regmap,
+               regmap_write(tcbpwmc->regmap,
                             ATMEL_TC_CLKEN | ATMEL_TC_SWTRG,
                             ATMEL_TC_REG(channel, CCR));