[PATCH 02/10] pwm: atmel-hlcdc: Use consistent variable naming

[claudiu beznea]

On 14.07.2023 23:56, Uwe Kleine-König wrote:
> In pwm drivers the variable name "chip" is usually only used for struct
> pwm_chip pointers. This driver however used "chip" for its driver data
> and pwm_chip pointers are named "chip", too, when there is no driver
> data around and "c" otherwise. Instead use "ddata" for driver data and
> always "chip" for pwm_chips.
> 
> Signed-off-by: Uwe Kleine-König <u.kleine-koenig at pengutronix.de>

Reviewed-by: Claudiu Beznea <claudiu.beznea at tuxon.dev>

> ---
>   drivers/pwm/pwm-atmel-hlcdc.c | 64 +++++++++++++++++------------------
>   1 file changed, 32 insertions(+), 32 deletions(-)
> 
> diff --git a/drivers/pwm/pwm-atmel-hlcdc.c b/drivers/pwm/pwm-atmel-hlcdc.c
> index 96a709a9d49a..9b0165d61c49 100644
> --- a/drivers/pwm/pwm-atmel-hlcdc.c
> +++ b/drivers/pwm/pwm-atmel-hlcdc.c
> @@ -38,11 +38,11 @@ static inline struct atmel_hlcdc_pwm *to_atmel_hlcdc_pwm(struct pwm_chip *chip)
>   	return container_of(chip, struct atmel_hlcdc_pwm, chip);
>   }
>   
> -static int atmel_hlcdc_pwm_apply(struct pwm_chip *c, struct pwm_device *pwm,
> +static int atmel_hlcdc_pwm_apply(struct pwm_chip *chip, struct pwm_device *pwm,
>   				 const struct pwm_state *state)
>   {
> -	struct atmel_hlcdc_pwm *chip = to_atmel_hlcdc_pwm(c);
> -	struct atmel_hlcdc *hlcdc = chip->hlcdc;
> +	struct atmel_hlcdc_pwm *ddata = to_atmel_hlcdc_pwm(chip);
> +	struct atmel_hlcdc *hlcdc = ddata->hlcdc;
>   	unsigned int status;
>   	int ret;
>   
> @@ -54,7 +54,7 @@ static int atmel_hlcdc_pwm_apply(struct pwm_chip *c, struct pwm_device *pwm,
>   		u32 pwmcfg;
>   		int pres;
>   
> -		if (!chip->errata || !chip->errata->slow_clk_erratum) {
> +		if (!ddata->errata || !ddata->errata->slow_clk_erratum) {
>   			clk_freq = clk_get_rate(new_clk);
>   			if (!clk_freq)
>   				return -EINVAL;
> @@ -64,7 +64,7 @@ static int atmel_hlcdc_pwm_apply(struct pwm_chip *c, struct pwm_device *pwm,
>   		}
>   
>   		/* Errata: cannot use slow clk on some IP revisions */
> -		if ((chip->errata && chip->errata->slow_clk_erratum) ||
> +		if ((ddata->errata && ddata->errata->slow_clk_erratum) ||
>   		    clk_period_ns > state->period) {
>   			new_clk = hlcdc->sys_clk;
>   			clk_freq = clk_get_rate(new_clk);
> @@ -77,8 +77,8 @@ static int atmel_hlcdc_pwm_apply(struct pwm_chip *c, struct pwm_device *pwm,
>   
>   		for (pres = 0; pres <= ATMEL_HLCDC_PWMPS_MAX; pres++) {
>   		/* Errata: cannot divide by 1 on some IP revisions */
> -			if (!pres && chip->errata &&
> -			    chip->errata->div1_clk_erratum)
> +			if (!pres && ddata->errata &&
> +			    ddata->errata->div1_clk_erratum)
>   				continue;
>   
>   			if ((clk_period_ns << pres) >= state->period)
> @@ -90,7 +90,7 @@ static int atmel_hlcdc_pwm_apply(struct pwm_chip *c, struct pwm_device *pwm,
>   
>   		pwmcfg = ATMEL_HLCDC_PWMPS(pres);
>   
> -		if (new_clk != chip->cur_clk) {
> +		if (new_clk != ddata->cur_clk) {
>   			u32 gencfg = 0;
>   			int ret;
>   
> @@ -98,8 +98,8 @@ static int atmel_hlcdc_pwm_apply(struct pwm_chip *c, struct pwm_device *pwm,
>   			if (ret)
>   				return ret;
>   
> -			clk_disable_unprepare(chip->cur_clk);
> -			chip->cur_clk = new_clk;
> +			clk_disable_unprepare(ddata->cur_clk);
> +			ddata->cur_clk = new_clk;
>   
>   			if (new_clk == hlcdc->sys_clk)
>   				gencfg = ATMEL_HLCDC_CLKPWMSEL;
> @@ -160,8 +160,8 @@ static int atmel_hlcdc_pwm_apply(struct pwm_chip *c, struct pwm_device *pwm,
>   		if (ret)
>   			return ret;
>   
> -		clk_disable_unprepare(chip->cur_clk);
> -		chip->cur_clk = NULL;
> +		clk_disable_unprepare(ddata->cur_clk);
> +		ddata->cur_clk = NULL;
>   	}
>   
>   	return 0;
> @@ -183,31 +183,31 @@ static const struct atmel_hlcdc_pwm_errata atmel_hlcdc_pwm_sama5d3_errata = {
>   #ifdef CONFIG_PM_SLEEP
>   static int atmel_hlcdc_pwm_suspend(struct device *dev)
>   {
> -	struct atmel_hlcdc_pwm *chip = dev_get_drvdata(dev);
> +	struct atmel_hlcdc_pwm *ddata = dev_get_drvdata(dev);
>   
>   	/* Keep the periph clock enabled if the PWM is still running. */
> -	if (pwm_is_enabled(&chip->chip.pwms[0]))
> -		clk_disable_unprepare(chip->hlcdc->periph_clk);
> +	if (pwm_is_enabled(&ddata->chip.pwms[0]))
> +		clk_disable_unprepare(ddata->hlcdc->periph_clk);
>   
>   	return 0;
>   }
>   
>   static int atmel_hlcdc_pwm_resume(struct device *dev)
>   {
> -	struct atmel_hlcdc_pwm *chip = dev_get_drvdata(dev);
> +	struct atmel_hlcdc_pwm *ddata = dev_get_drvdata(dev);
>   	struct pwm_state state;
>   	int ret;
>   
> -	pwm_get_state(&chip->chip.pwms[0], &state);
> +	pwm_get_state(&ddata->chip.pwms[0], &state);
>   
>   	/* Re-enable the periph clock it was stopped during suspend. */
>   	if (!state.enabled) {
> -		ret = clk_prepare_enable(chip->hlcdc->periph_clk);
> +		ret = clk_prepare_enable(ddata->hlcdc->periph_clk);
>   		if (ret)
>   			return ret;
>   	}
>   
> -	return atmel_hlcdc_pwm_apply(&chip->chip, &chip->chip.pwms[0], &state);
> +	return atmel_hlcdc_pwm_apply(&ddata->chip, &ddata->chip.pwms[0], &state);
>   }
>   #endif
>   
> @@ -244,14 +244,14 @@ static int atmel_hlcdc_pwm_probe(struct platform_device *pdev)
>   {
>   	const struct of_device_id *match;
>   	struct device *dev = &pdev->dev;
> -	struct atmel_hlcdc_pwm *chip;
> +	struct atmel_hlcdc_pwm *ddata;
>   	struct atmel_hlcdc *hlcdc;
>   	int ret;
>   
>   	hlcdc = dev_get_drvdata(dev->parent);
>   
> -	chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
> -	if (!chip)
> +	ddata = devm_kzalloc(dev, sizeof(*ddata), GFP_KERNEL);
> +	if (!ddata)
>   		return -ENOMEM;
>   
>   	ret = clk_prepare_enable(hlcdc->periph_clk);
> @@ -260,31 +260,31 @@ static int atmel_hlcdc_pwm_probe(struct platform_device *pdev)
>   
>   	match = of_match_node(atmel_hlcdc_dt_ids, dev->parent->of_node);
>   	if (match)
> -		chip->errata = match->data;
> +		ddata->errata = match->data;
>   
> -	chip->hlcdc = hlcdc;
> -	chip->chip.ops = &atmel_hlcdc_pwm_ops;
> -	chip->chip.dev = dev;
> -	chip->chip.npwm = 1;
> +	ddata->hlcdc = hlcdc;
> +	ddata->chip.ops = &atmel_hlcdc_pwm_ops;
> +	ddata->chip.dev = dev;
> +	ddata->chip.npwm = 1;
>   
> -	ret = pwmchip_add(&chip->chip);
> +	ret = pwmchip_add(&ddata->chip);
>   	if (ret) {
>   		clk_disable_unprepare(hlcdc->periph_clk);
>   		return ret;
>   	}
>   
> -	platform_set_drvdata(pdev, chip);
> +	platform_set_drvdata(pdev, ddata);
>   
>   	return 0;
>   }
>   
>   static void atmel_hlcdc_pwm_remove(struct platform_device *pdev)
>   {
> -	struct atmel_hlcdc_pwm *chip = platform_get_drvdata(pdev);
> +	struct atmel_hlcdc_pwm *ddata = platform_get_drvdata(pdev);
>   
> -	pwmchip_remove(&chip->chip);
> +	pwmchip_remove(&ddata->chip);
>   
> -	clk_disable_unprepare(chip->hlcdc->periph_clk);
> +	clk_disable_unprepare(ddata->hlcdc->periph_clk);
>   }
>   
>   static const struct of_device_id atmel_hlcdc_pwm_dt_ids[] = {