Skip to content

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

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
Hide whitespace changes
Inline Side-by-side
Showing with 58 additions and 58 deletions
drivers/pwm/pwm-berlin.c
View file @ 3f3e8051
...@@ -56,17 +56,17 @@ static inline struct berlin_pwm_chip *to_berlin_pwm_chip(struct pwm_chip *chip) ...@@ -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); 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) 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 int channel, u32 value,
unsigned long offset) 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) 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) ...@@ -87,15 +87,15 @@ static void berlin_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
kfree(channel); 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) 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; bool prescale_4096 = false;
u32 value, duty, period; u32 value, duty, period;
u64 cycles; u64 cycles;
cycles = clk_get_rate(pwm->clk); cycles = clk_get_rate(bpc->clk);
cycles *= period_ns; cycles *= period_ns;
do_div(cycles, NSEC_PER_SEC); do_div(cycles, NSEC_PER_SEC);
...@@ -112,59 +112,59 @@ static int berlin_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm_dev, ...@@ -112,59 +112,59 @@ static int berlin_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm_dev,
do_div(cycles, period_ns); do_div(cycles, period_ns);
duty = cycles; 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) if (prescale_4096)
value |= BERLIN_PWM_PRESCALE_4096; value |= BERLIN_PWM_PRESCALE_4096;
else else
value &= ~BERLIN_PWM_PRESCALE_4096; 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(bpc, pwm->hwpwm, duty, BERLIN_PWM_DUTY);
berlin_pwm_writel(pwm, pwm_dev->hwpwm, period, BERLIN_PWM_TCNT); berlin_pwm_writel(bpc, pwm->hwpwm, period, BERLIN_PWM_TCNT);
return 0; return 0;
} }
static int berlin_pwm_set_polarity(struct pwm_chip *chip, static int berlin_pwm_set_polarity(struct pwm_chip *chip,
struct pwm_device *pwm_dev, struct pwm_device *pwm,
enum pwm_polarity polarity) 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; 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) if (polarity == PWM_POLARITY_NORMAL)
value &= ~BERLIN_PWM_INVERT_POLARITY; value &= ~BERLIN_PWM_INVERT_POLARITY;
else else
value |= BERLIN_PWM_INVERT_POLARITY; 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; 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; 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; 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; return 0;
} }
static void berlin_pwm_disable(struct pwm_chip *chip, 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; 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; 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 = { static const struct pwm_ops berlin_pwm_ops = {
...@@ -185,48 +185,48 @@ MODULE_DEVICE_TABLE(of, berlin_pwm_match); ...@@ -185,48 +185,48 @@ MODULE_DEVICE_TABLE(of, berlin_pwm_match);
static int berlin_pwm_probe(struct platform_device *pdev) static int berlin_pwm_probe(struct platform_device *pdev)
{ {
struct berlin_pwm_chip *pwm; struct berlin_pwm_chip *bpc;
int ret; int ret;
pwm = devm_kzalloc(&pdev->dev, sizeof(*pwm), GFP_KERNEL); bpc = devm_kzalloc(&pdev->dev, sizeof(*bpc), GFP_KERNEL);
if (!pwm) if (!bpc)
return -ENOMEM; return -ENOMEM;
pwm->base = devm_platform_ioremap_resource(pdev, 0); bpc->base = devm_platform_ioremap_resource(pdev, 0);
if (IS_ERR(pwm->base)) if (IS_ERR(bpc->base))
return PTR_ERR(pwm->base); return PTR_ERR(bpc->base);
pwm->clk = devm_clk_get(&pdev->dev, NULL); bpc->clk = devm_clk_get(&pdev->dev, NULL);
if (IS_ERR(pwm->clk)) if (IS_ERR(bpc->clk))
return PTR_ERR(pwm->clk); return PTR_ERR(bpc->clk);
ret = clk_prepare_enable(pwm->clk); ret = clk_prepare_enable(bpc->clk);
if (ret) if (ret)
return ret; return ret;
pwm->chip.dev = &pdev->dev; bpc->chip.dev = &pdev->dev;
pwm->chip.ops = &berlin_pwm_ops; bpc->chip.ops = &berlin_pwm_ops;
pwm->chip.npwm = 4; bpc->chip.npwm = 4;
ret = pwmchip_add(&pwm->chip); ret = pwmchip_add(&bpc->chip);
if (ret < 0) { if (ret < 0) {
dev_err(&pdev->dev, "failed to add PWM chip: %d\n", ret); dev_err(&pdev->dev, "failed to add PWM chip: %d\n", ret);
clk_disable_unprepare(pwm->clk); clk_disable_unprepare(bpc->clk);
return ret; return ret;
} }
platform_set_drvdata(pdev, pwm); platform_set_drvdata(pdev, bpc);
return 0; return 0;
} }
static int berlin_pwm_remove(struct platform_device *pdev) 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; int ret;
ret = pwmchip_remove(&pwm->chip); ret = pwmchip_remove(&bpc->chip);
clk_disable_unprepare(pwm->clk); clk_disable_unprepare(bpc->clk);
return ret; return ret;
} }
...@@ -234,48 +234,48 @@ static int berlin_pwm_remove(struct platform_device *pdev) ...@@ -234,48 +234,48 @@ static int berlin_pwm_remove(struct platform_device *pdev)
#ifdef CONFIG_PM_SLEEP #ifdef CONFIG_PM_SLEEP
static int berlin_pwm_suspend(struct device *dev) 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; unsigned int i;
for (i = 0; i < pwm->chip.npwm; i++) { for (i = 0; i < bpc->chip.npwm; i++) {
struct berlin_pwm_channel *channel; 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) if (!channel)
continue; continue;
channel->enable = berlin_pwm_readl(pwm, i, BERLIN_PWM_ENABLE); channel->enable = berlin_pwm_readl(bpc, i, BERLIN_PWM_ENABLE);
channel->ctrl = berlin_pwm_readl(pwm, i, BERLIN_PWM_CONTROL); channel->ctrl = berlin_pwm_readl(bpc, i, BERLIN_PWM_CONTROL);
channel->duty = berlin_pwm_readl(pwm, i, BERLIN_PWM_DUTY); channel->duty = berlin_pwm_readl(bpc, i, BERLIN_PWM_DUTY);
channel->tcnt = berlin_pwm_readl(pwm, i, BERLIN_PWM_TCNT); channel->tcnt = berlin_pwm_readl(bpc, i, BERLIN_PWM_TCNT);
} }
clk_disable_unprepare(pwm->clk); clk_disable_unprepare(bpc->clk);
return 0; return 0;
} }
static int berlin_pwm_resume(struct device *dev) 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; unsigned int i;
int ret; int ret;
ret = clk_prepare_enable(pwm->clk); ret = clk_prepare_enable(bpc->clk);
if (ret) if (ret)
return ret; return ret;
for (i = 0; i < pwm->chip.npwm; i++) { for (i = 0; i < bpc->chip.npwm; i++) {
struct berlin_pwm_channel *channel; 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) if (!channel)
continue; continue;
berlin_pwm_writel(pwm, i, channel->ctrl, BERLIN_PWM_CONTROL); berlin_pwm_writel(bpc, i, channel->ctrl, BERLIN_PWM_CONTROL);
berlin_pwm_writel(pwm, i, channel->duty, BERLIN_PWM_DUTY); berlin_pwm_writel(bpc, i, channel->duty, BERLIN_PWM_DUTY);
berlin_pwm_writel(pwm, i, channel->tcnt, BERLIN_PWM_TCNT); berlin_pwm_writel(bpc, i, channel->tcnt, BERLIN_PWM_TCNT);
berlin_pwm_writel(pwm, i, channel->enable, BERLIN_PWM_ENABLE); berlin_pwm_writel(bpc, i, channel->enable, BERLIN_PWM_ENABLE);
} }
return 0; return 0;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7