Commit c9a787b9 authored by Uwe Kleine-König's avatar Uwe Kleine-König Committed by Uwe Kleine-König
Browse files

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: default avatarUwe Kleine-König <u.kleine-koenig@baylibre.com>
Acked-by: default avatarNicolas Ferre <nicolas.ferre@microchip.com>
Link: https://lore.kernel.org/r/20240709092221.47025-2-u.kleine-koenig@baylibre.com


Signed-off-by: default avatarUwe Kleine-König <ukleinek@kernel.org>
parent c1330cb9

drivers/pwm/pwm-atmel-tcb.c

+45 −45
Original line number Diff line number Diff line
@@ -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 @@ static int atmel_tcb_pwm_probe(struct platform_device *pdev) 
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));