Commit 3f3e8051 authored by Uwe Kleine-König's avatar Uwe Kleine-König Committed by Thierry Reding
Browse files

pwm: berlin: use consistent naming for variables 



A struct berlin_pwm_chip * is now always called "bpc" (instead of "pwm"
which is usually used for struct pwm_device * or "chip" which is usually
used for struct pwm_chip *). The struct pwm_device * variables were
named "pwm_dev" or "pwm"; they are now always called "pwm".

Signed-off-by: default avatarUwe Kleine-König <u.kleine-koenig@pengutronix.de>
Signed-off-by: default avatarThierry Reding <thierry.reding@gmail.com>
parent 0ca7acd8

drivers/pwm/pwm-berlin.c

+58 −58
Original line number Diff line number Diff line
@@ -56,17 +56,17 @@ static inline struct berlin_pwm_chip *to_berlin_pwm_chip(struct pwm_chip *chip) 
	return container_of(chip, struct berlin_pwm_chip, chip);

}



static inline u32 berlin_pwm_readl(struct berlin_pwm_chip *chip,

static inline u32 berlin_pwm_readl(struct berlin_pwm_chip *bpc,

				   unsigned int channel, unsigned long offset)

{

	return readl_relaxed(chip->base + channel * 0x10 + offset);

	return readl_relaxed(bpc->base + channel * 0x10 + offset);

}



static inline void berlin_pwm_writel(struct berlin_pwm_chip *chip,

static inline void berlin_pwm_writel(struct berlin_pwm_chip *bpc,

				     unsigned int channel, u32 value,

				     unsigned long offset)

{

	writel_relaxed(value, chip->base + channel * 0x10 + offset);

	writel_relaxed(value, bpc->base + channel * 0x10 + offset);

}



static int berlin_pwm_request(struct pwm_chip *chip, struct pwm_device *pwm)
@@ -87,15 +87,15 @@ static void berlin_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm) 
	kfree(channel);

}



static int berlin_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm_dev,

static int berlin_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,

			     int duty_ns, int period_ns)

{

	struct berlin_pwm_chip *pwm = to_berlin_pwm_chip(chip);

	struct berlin_pwm_chip *bpc = to_berlin_pwm_chip(chip);

	bool prescale_4096 = false;

	u32 value, duty, period;

	u64 cycles;



	cycles = clk_get_rate(pwm->clk);

	cycles = clk_get_rate(bpc->clk);

	cycles *= period_ns;

	do_div(cycles, NSEC_PER_SEC);
@@ -112,59 +112,59 @@ static int berlin_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm_dev, 
	do_div(cycles, period_ns);

	duty = cycles;



	value = berlin_pwm_readl(pwm, pwm_dev->hwpwm, BERLIN_PWM_CONTROL);

	value = berlin_pwm_readl(bpc, pwm->hwpwm, BERLIN_PWM_CONTROL);

	if (prescale_4096)

		value |= BERLIN_PWM_PRESCALE_4096;

	else

		value &= ~BERLIN_PWM_PRESCALE_4096;

	berlin_pwm_writel(pwm, pwm_dev->hwpwm, value, BERLIN_PWM_CONTROL);

	berlin_pwm_writel(bpc, pwm->hwpwm, value, BERLIN_PWM_CONTROL);



	berlin_pwm_writel(pwm, pwm_dev->hwpwm, duty, BERLIN_PWM_DUTY);

	berlin_pwm_writel(pwm, pwm_dev->hwpwm, period, BERLIN_PWM_TCNT);

	berlin_pwm_writel(bpc, pwm->hwpwm, duty, BERLIN_PWM_DUTY);

	berlin_pwm_writel(bpc, pwm->hwpwm, period, BERLIN_PWM_TCNT);



	return 0;

}



static int berlin_pwm_set_polarity(struct pwm_chip *chip,

				   struct pwm_device *pwm_dev,

				   struct pwm_device *pwm,

				   enum pwm_polarity polarity)

{

	struct berlin_pwm_chip *pwm = to_berlin_pwm_chip(chip);

	struct berlin_pwm_chip *bpc = to_berlin_pwm_chip(chip);

	u32 value;



	value = berlin_pwm_readl(pwm, pwm_dev->hwpwm, BERLIN_PWM_CONTROL);

	value = berlin_pwm_readl(bpc, pwm->hwpwm, BERLIN_PWM_CONTROL);



	if (polarity == PWM_POLARITY_NORMAL)

		value &= ~BERLIN_PWM_INVERT_POLARITY;

	else

		value |= BERLIN_PWM_INVERT_POLARITY;



	berlin_pwm_writel(pwm, pwm_dev->hwpwm, value, BERLIN_PWM_CONTROL);

	berlin_pwm_writel(bpc, pwm->hwpwm, value, BERLIN_PWM_CONTROL);



	return 0;

}



static int berlin_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm_dev)

static int berlin_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)

{

	struct berlin_pwm_chip *pwm = to_berlin_pwm_chip(chip);

	struct berlin_pwm_chip *bpc = to_berlin_pwm_chip(chip);

	u32 value;



	value = berlin_pwm_readl(pwm, pwm_dev->hwpwm, BERLIN_PWM_EN);

	value = berlin_pwm_readl(bpc, pwm->hwpwm, BERLIN_PWM_EN);

	value |= BERLIN_PWM_ENABLE;

	berlin_pwm_writel(pwm, pwm_dev->hwpwm, value, BERLIN_PWM_EN);

	berlin_pwm_writel(bpc, pwm->hwpwm, value, BERLIN_PWM_EN);



	return 0;

}



static void berlin_pwm_disable(struct pwm_chip *chip,

			       struct pwm_device *pwm_dev)

			       struct pwm_device *pwm)

{

	struct berlin_pwm_chip *pwm = to_berlin_pwm_chip(chip);

	struct berlin_pwm_chip *bpc = to_berlin_pwm_chip(chip);

	u32 value;



	value = berlin_pwm_readl(pwm, pwm_dev->hwpwm, BERLIN_PWM_EN);

	value = berlin_pwm_readl(bpc, pwm->hwpwm, BERLIN_PWM_EN);

	value &= ~BERLIN_PWM_ENABLE;

	berlin_pwm_writel(pwm, pwm_dev->hwpwm, value, BERLIN_PWM_EN);

	berlin_pwm_writel(bpc, pwm->hwpwm, value, BERLIN_PWM_EN);

}



static const struct pwm_ops berlin_pwm_ops = {
@@ -185,48 +185,48 @@ MODULE_DEVICE_TABLE(of, berlin_pwm_match); 


static int berlin_pwm_probe(struct platform_device *pdev)

{

	struct berlin_pwm_chip *pwm;

	struct berlin_pwm_chip *bpc;

	int ret;



	pwm = devm_kzalloc(&pdev->dev, sizeof(*pwm), GFP_KERNEL);

	if (!pwm)

	bpc = devm_kzalloc(&pdev->dev, sizeof(*bpc), GFP_KERNEL);

	if (!bpc)

		return -ENOMEM;



	pwm->base = devm_platform_ioremap_resource(pdev, 0);

	if (IS_ERR(pwm->base))

		return PTR_ERR(pwm->base);

	bpc->base = devm_platform_ioremap_resource(pdev, 0);

	if (IS_ERR(bpc->base))

		return PTR_ERR(bpc->base);



	pwm->clk = devm_clk_get(&pdev->dev, NULL);

	if (IS_ERR(pwm->clk))

		return PTR_ERR(pwm->clk);

	bpc->clk = devm_clk_get(&pdev->dev, NULL);

	if (IS_ERR(bpc->clk))

		return PTR_ERR(bpc->clk);



	ret = clk_prepare_enable(pwm->clk);

	ret = clk_prepare_enable(bpc->clk);

	if (ret)

		return ret;



	pwm->chip.dev = &pdev->dev;

	pwm->chip.ops = &berlin_pwm_ops;

	pwm->chip.npwm = 4;

	bpc->chip.dev = &pdev->dev;

	bpc->chip.ops = &berlin_pwm_ops;

	bpc->chip.npwm = 4;



	ret = pwmchip_add(&pwm->chip);

	ret = pwmchip_add(&bpc->chip);

	if (ret < 0) {

		dev_err(&pdev->dev, "failed to add PWM chip: %d\n", ret);

		clk_disable_unprepare(pwm->clk);

		clk_disable_unprepare(bpc->clk);

		return ret;

	}



	platform_set_drvdata(pdev, pwm);

	platform_set_drvdata(pdev, bpc);



	return 0;

}



static int berlin_pwm_remove(struct platform_device *pdev)

{

	struct berlin_pwm_chip *pwm = platform_get_drvdata(pdev);

	struct berlin_pwm_chip *bpc = platform_get_drvdata(pdev);

	int ret;



	ret = pwmchip_remove(&pwm->chip);

	clk_disable_unprepare(pwm->clk);

	ret = pwmchip_remove(&bpc->chip);

	clk_disable_unprepare(bpc->clk);



	return ret;

}
@@ -234,48 +234,48 @@ static int berlin_pwm_remove(struct platform_device *pdev) 
#ifdef CONFIG_PM_SLEEP

static int berlin_pwm_suspend(struct device *dev)

{

	struct berlin_pwm_chip *pwm = dev_get_drvdata(dev);

	struct berlin_pwm_chip *bpc = dev_get_drvdata(dev);

	unsigned int i;



	for (i = 0; i < pwm->chip.npwm; i++) {

	for (i = 0; i < bpc->chip.npwm; i++) {

		struct berlin_pwm_channel *channel;



		channel = pwm_get_chip_data(&pwm->chip.pwms[i]);

		channel = pwm_get_chip_data(&bpc->chip.pwms[i]);

		if (!channel)

			continue;



		channel->enable = berlin_pwm_readl(pwm, i, BERLIN_PWM_ENABLE);

		channel->ctrl = berlin_pwm_readl(pwm, i, BERLIN_PWM_CONTROL);

		channel->duty = berlin_pwm_readl(pwm, i, BERLIN_PWM_DUTY);

		channel->tcnt = berlin_pwm_readl(pwm, i, BERLIN_PWM_TCNT);

		channel->enable = berlin_pwm_readl(bpc, i, BERLIN_PWM_ENABLE);

		channel->ctrl = berlin_pwm_readl(bpc, i, BERLIN_PWM_CONTROL);

		channel->duty = berlin_pwm_readl(bpc, i, BERLIN_PWM_DUTY);

		channel->tcnt = berlin_pwm_readl(bpc, i, BERLIN_PWM_TCNT);

	}



	clk_disable_unprepare(pwm->clk);

	clk_disable_unprepare(bpc->clk);



	return 0;

}



static int berlin_pwm_resume(struct device *dev)

{

	struct berlin_pwm_chip *pwm = dev_get_drvdata(dev);

	struct berlin_pwm_chip *bpc = dev_get_drvdata(dev);

	unsigned int i;

	int ret;



	ret = clk_prepare_enable(pwm->clk);

	ret = clk_prepare_enable(bpc->clk);

	if (ret)

		return ret;



	for (i = 0; i < pwm->chip.npwm; i++) {

	for (i = 0; i < bpc->chip.npwm; i++) {

		struct berlin_pwm_channel *channel;



		channel = pwm_get_chip_data(&pwm->chip.pwms[i]);

		channel = pwm_get_chip_data(&bpc->chip.pwms[i]);

		if (!channel)

			continue;



		berlin_pwm_writel(pwm, i, channel->ctrl, BERLIN_PWM_CONTROL);

		berlin_pwm_writel(pwm, i, channel->duty, BERLIN_PWM_DUTY);

		berlin_pwm_writel(pwm, i, channel->tcnt, BERLIN_PWM_TCNT);

		berlin_pwm_writel(pwm, i, channel->enable, BERLIN_PWM_ENABLE);

		berlin_pwm_writel(bpc, i, channel->ctrl, BERLIN_PWM_CONTROL);

		berlin_pwm_writel(bpc, i, channel->duty, BERLIN_PWM_DUTY);

		berlin_pwm_writel(bpc, i, channel->tcnt, BERLIN_PWM_TCNT);

		berlin_pwm_writel(bpc, i, channel->enable, BERLIN_PWM_ENABLE);

	}



	return 0;