redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

pwm: tiehrpwm: Miscellaneous coding style fixups 

I noticed most of these while reviewing another patch and thought I'd
fix them while at it. These are mostly changes to make variable types
more strict and whitespace fixups.

Signed-off-by: Thierry Reding <thierry.reding@gmail.com>
hifive-unleashed-5.1
Thierry Reding 2017-08-21 08:42:25 +02:00
parent 23f373e6fe
commit d2c95e47f8
1 changed files with 62 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

112
drivers/pwm/pwm-tiehrpwm.c
View File

@ -122,12 +122,12 @@ struct ehrpwm_context {
}; };
struct ehrpwm_pwm_chip { struct ehrpwm_pwm_chip {
struct pwm_chip chip; struct pwm_chip chip;
unsigned int clk_rate; unsigned long clk_rate;
void __iomem *mmio_base; void __iomem *mmio_base;
unsigned long period_cycles[NUM_PWM_CHANNEL]; unsigned long period_cycles[NUM_PWM_CHANNEL];
enum pwm_polarity polarity[NUM_PWM_CHANNEL]; enum pwm_polarity polarity[NUM_PWM_CHANNEL];
struct clk *tbclk; struct clk *tbclk;
struct ehrpwm_context ctx; struct ehrpwm_context ctx;
}; };
@ -136,25 +136,26 @@ static inline struct ehrpwm_pwm_chip *to_ehrpwm_pwm_chip(struct pwm_chip *chip)
return container_of(chip, struct ehrpwm_pwm_chip, chip); return container_of(chip, struct ehrpwm_pwm_chip, chip);
} }
static inline u16 ehrpwm_read(void __iomem *base, int offset) static inline u16 ehrpwm_read(void __iomem *base, unsigned int offset)
{ {
return readw(base + offset); return readw(base + offset);
} }
static inline void ehrpwm_write(void __iomem *base, int offset, unsigned int val) static inline void ehrpwm_write(void __iomem *base, unsigned int offset,
u16 value)
{ {
writew(val & 0xFFFF, base + offset); writew(value, base + offset);
} }
static void ehrpwm_modify(void __iomem *base, int offset, static void ehrpwm_modify(void __iomem *base, unsigned int offset, u16 mask,
unsigned short mask, unsigned short val) u16 value)
{ {
unsigned short regval; unsigned short val;
regval = readw(base + offset); val = readw(base + offset);
regval &= ~mask; val &= ~mask;
regval |= val & mask; val |= value & mask;
writew(regval, base + offset); writew(val, base + offset);
} }
/** /**
@ -163,14 +164,13 @@ static void ehrpwm_modify(void __iomem *base, int offset,
* @prescale_div: prescaler value set * @prescale_div: prescaler value set
* @tb_clk_div: Time Base Control prescaler bits * @tb_clk_div: Time Base Control prescaler bits
*/ */
static int set_prescale_div(unsigned long rqst_prescaler, static int set_prescale_div(unsigned long rqst_prescaler, u16 *prescale_div,
unsigned short *prescale_div, unsigned short *tb_clk_div) u16 *tb_clk_div)
{ {
unsigned int clkdiv, hspclkdiv; unsigned int clkdiv, hspclkdiv;
for (clkdiv = 0; clkdiv <= CLKDIV_MAX; clkdiv++) { for (clkdiv = 0; clkdiv <= CLKDIV_MAX; clkdiv++) {
for (hspclkdiv = 0; hspclkdiv <= HSPCLKDIV_MAX; hspclkdiv++) { for (hspclkdiv = 0; hspclkdiv <= HSPCLKDIV_MAX; hspclkdiv++) {
/* /*
* calculations for prescaler value : * calculations for prescaler value :
* prescale_div = HSPCLKDIVIDER * CLKDIVIDER. * prescale_div = HSPCLKDIVIDER * CLKDIVIDER.
@ -191,13 +191,14 @@ static int set_prescale_div(unsigned long rqst_prescaler,
} }
} }
} }
return 1; return 1;
} }
static void configure_polarity(struct ehrpwm_pwm_chip *pc, int chan) static void configure_polarity(struct ehrpwm_pwm_chip *pc, int chan)
{ {
int aqctl_reg; u16 aqctl_val, aqctl_mask;
unsigned short aqctl_val, aqctl_mask; unsigned int aqctl_reg;
/* /*
* Configure PWM output to HIGH/LOW level on counter * Configure PWM output to HIGH/LOW level on counter
@ -232,13 +233,13 @@ static void configure_polarity(struct ehrpwm_pwm_chip *pc, int chan)
* duty_ns = 10^9 * (ps_divval * duty_cycles) / PWM_CLK_RATE * duty_ns = 10^9 * (ps_divval * duty_cycles) / PWM_CLK_RATE
*/ */
static int ehrpwm_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm, static int ehrpwm_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
int duty_ns, int period_ns) int duty_ns, int period_ns)
{ {
struct ehrpwm_pwm_chip *pc = to_ehrpwm_pwm_chip(chip); struct ehrpwm_pwm_chip *pc = to_ehrpwm_pwm_chip(chip);
u32 period_cycles, duty_cycles;
u16 ps_divval, tb_divval;
unsigned int i, cmp_reg;
unsigned long long c; unsigned long long c;
unsigned long period_cycles, duty_cycles;
unsigned short ps_divval, tb_divval;
int i, cmp_reg;
if (period_ns > NSEC_PER_SEC) if (period_ns > NSEC_PER_SEC)
return -ERANGE; return -ERANGE;
@ -272,8 +273,9 @@ static int ehrpwm_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
if (i == pwm->hwpwm) if (i == pwm->hwpwm)
continue; continue;
dev_err(chip->dev, "Period value conflicts with channel %d\n", dev_err(chip->dev,
i); "period value conflicts with channel %u\n",
i);
return -EINVAL; return -EINVAL;
} }
} }
@ -282,7 +284,7 @@ static int ehrpwm_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
/* Configure clock prescaler to support Low frequency PWM wave */ /* Configure clock prescaler to support Low frequency PWM wave */
if (set_prescale_div(period_cycles/PERIOD_MAX, &ps_divval, if (set_prescale_div(period_cycles/PERIOD_MAX, &ps_divval,
&tb_divval)) { &tb_divval)) {
dev_err(chip->dev, "Unsupported values\n"); dev_err(chip->dev, "Unsupported values\n");
return -EINVAL; return -EINVAL;
} }
@ -303,7 +305,7 @@ static int ehrpwm_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
/* Configure ehrpwm counter for up-count mode */ /* Configure ehrpwm counter for up-count mode */
ehrpwm_modify(pc->mmio_base, TBCTL, TBCTL_CTRMODE_MASK, ehrpwm_modify(pc->mmio_base, TBCTL, TBCTL_CTRMODE_MASK,
TBCTL_CTRMODE_UP); TBCTL_CTRMODE_UP);
if (pwm->hwpwm == 1) if (pwm->hwpwm == 1)
/* Channel 1 configured with compare B register */ /* Channel 1 configured with compare B register */
@ -315,23 +317,26 @@ static int ehrpwm_pwm_config(struct pwm_chip *chip, struct pwm_device *pwm,
ehrpwm_write(pc->mmio_base, cmp_reg, duty_cycles); ehrpwm_write(pc->mmio_base, cmp_reg, duty_cycles);
pm_runtime_put_sync(chip->dev); pm_runtime_put_sync(chip->dev);
return 0; return 0;
} }
static int ehrpwm_pwm_set_polarity(struct pwm_chip *chip, static int ehrpwm_pwm_set_polarity(struct pwm_chip *chip,
struct pwm_device *pwm, enum pwm_polarity polarity) struct pwm_device *pwm,
enum pwm_polarity polarity)
{ {
struct ehrpwm_pwm_chip *pc = to_ehrpwm_pwm_chip(chip); struct ehrpwm_pwm_chip *pc = to_ehrpwm_pwm_chip(chip);
/* Configuration of polarity in hardware delayed, do at enable */ /* Configuration of polarity in hardware delayed, do at enable */
pc->polarity[pwm->hwpwm] = polarity; pc->polarity[pwm->hwpwm] = polarity;
return 0; return 0;
} }
static int ehrpwm_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm) static int ehrpwm_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
{ {
struct ehrpwm_pwm_chip *pc = to_ehrpwm_pwm_chip(chip); struct ehrpwm_pwm_chip *pc = to_ehrpwm_pwm_chip(chip);
unsigned short aqcsfrc_val, aqcsfrc_mask; u16 aqcsfrc_val, aqcsfrc_mask;
int ret; int ret;
/* Leave clock enabled on enabling PWM */ /* Leave clock enabled on enabling PWM */
@ -348,7 +353,7 @@ static int ehrpwm_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
/* Changes to shadow mode */ /* Changes to shadow mode */
ehrpwm_modify(pc->mmio_base, AQSFRC, AQSFRC_RLDCSF_MASK, ehrpwm_modify(pc->mmio_base, AQSFRC, AQSFRC_RLDCSF_MASK,
AQSFRC_RLDCSF_ZRO); AQSFRC_RLDCSF_ZRO);
ehrpwm_modify(pc->mmio_base, AQCSFRC, aqcsfrc_mask, aqcsfrc_val); ehrpwm_modify(pc->mmio_base, AQCSFRC, aqcsfrc_mask, aqcsfrc_val);
@ -358,20 +363,21 @@ static int ehrpwm_pwm_enable(struct pwm_chip *chip, struct pwm_device *pwm)
/* Enable TBCLK before enabling PWM device */ /* Enable TBCLK before enabling PWM device */
ret = clk_enable(pc->tbclk); ret = clk_enable(pc->tbclk);
if (ret) { if (ret) {
dev_err(chip->dev, "Failed to enable TBCLK for %s\n", dev_err(chip->dev, "Failed to enable TBCLK for %s: %d\n",
dev_name(pc->chip.dev)); dev_name(pc->chip.dev), ret);
return ret; return ret;
} }
/* Enable time counter for free_run */ /* Enable time counter for free_run */
ehrpwm_modify(pc->mmio_base, TBCTL, TBCTL_RUN_MASK, TBCTL_FREE_RUN); ehrpwm_modify(pc->mmio_base, TBCTL, TBCTL_RUN_MASK, TBCTL_FREE_RUN);
return 0; return 0;
} }
static void ehrpwm_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm) static void ehrpwm_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
{ {
struct ehrpwm_pwm_chip *pc = to_ehrpwm_pwm_chip(chip); struct ehrpwm_pwm_chip *pc = to_ehrpwm_pwm_chip(chip);
unsigned short aqcsfrc_val, aqcsfrc_mask; u16 aqcsfrc_val, aqcsfrc_mask;
/* Action Qualifier puts PWM output low forcefully */ /* Action Qualifier puts PWM output low forcefully */
if (pwm->hwpwm) { if (pwm->hwpwm) {
@ -387,7 +393,7 @@ static void ehrpwm_pwm_disable(struct pwm_chip *chip, struct pwm_device *pwm)
* Action Qualifier control on PWM output from next TBCLK * Action Qualifier control on PWM output from next TBCLK
*/ */
ehrpwm_modify(pc->mmio_base, AQSFRC, AQSFRC_RLDCSF_MASK, ehrpwm_modify(pc->mmio_base, AQSFRC, AQSFRC_RLDCSF_MASK,
AQSFRC_RLDCSF_IMDT); AQSFRC_RLDCSF_IMDT);
ehrpwm_modify(pc->mmio_base, AQCSFRC, aqcsfrc_mask, aqcsfrc_val); ehrpwm_modify(pc->mmio_base, AQCSFRC, aqcsfrc_mask, aqcsfrc_val);
@ -415,17 +421,17 @@ static void ehrpwm_pwm_free(struct pwm_chip *chip, struct pwm_device *pwm)
} }
static const struct pwm_ops ehrpwm_pwm_ops = { static const struct pwm_ops ehrpwm_pwm_ops = {
.free = ehrpwm_pwm_free, .free = ehrpwm_pwm_free,
.config = ehrpwm_pwm_config, .config = ehrpwm_pwm_config,
.set_polarity = ehrpwm_pwm_set_polarity, .set_polarity = ehrpwm_pwm_set_polarity,
.enable = ehrpwm_pwm_enable, .enable = ehrpwm_pwm_enable,
.disable = ehrpwm_pwm_disable, .disable = ehrpwm_pwm_disable,
.owner = THIS_MODULE, .owner = THIS_MODULE,
}; };
static const struct of_device_id ehrpwm_of_match[] = { static const struct of_device_id ehrpwm_of_match[] = {
{ .compatible = "ti,am3352-ehrpwm" }, { .compatible = "ti,am3352-ehrpwm" },
{ .compatible = "ti,am33xx-ehrpwm" }, { .compatible = "ti,am33xx-ehrpwm" },
{}, {},
}; };
MODULE_DEVICE_TABLE(of, ehrpwm_of_match); MODULE_DEVICE_TABLE(of, ehrpwm_of_match);
@ -433,10 +439,10 @@ MODULE_DEVICE_TABLE(of, ehrpwm_of_match);
static int ehrpwm_pwm_probe(struct platform_device *pdev) static int ehrpwm_pwm_probe(struct platform_device *pdev)
{ {
struct device_node *np = pdev->dev.of_node; struct device_node *np = pdev->dev.of_node;
int ret; struct ehrpwm_pwm_chip *pc;
struct resource *r; struct resource *r;
struct clk *clk; struct clk *clk;
struct ehrpwm_pwm_chip *pc; int ret;
pc = devm_kzalloc(&pdev->dev, sizeof(*pc), GFP_KERNEL); pc = devm_kzalloc(&pdev->dev, sizeof(*pc), GFP_KERNEL);
if (!pc) if (!pc)
@ -510,6 +516,7 @@ static int ehrpwm_pwm_remove(struct platform_device *pdev)
clk_unprepare(pc->tbclk); clk_unprepare(pc->tbclk);
pm_runtime_disable(&pdev->dev); pm_runtime_disable(&pdev->dev);
return pwmchip_remove(&pc->chip); return pwmchip_remove(&pc->chip);
} }
@ -517,6 +524,7 @@ static int ehrpwm_pwm_remove(struct platform_device *pdev)
static void ehrpwm_pwm_save_context(struct ehrpwm_pwm_chip *pc) static void ehrpwm_pwm_save_context(struct ehrpwm_pwm_chip *pc)
{ {
pm_runtime_get_sync(pc->chip.dev); pm_runtime_get_sync(pc->chip.dev);
pc->ctx.tbctl = ehrpwm_read(pc->mmio_base, TBCTL); pc->ctx.tbctl = ehrpwm_read(pc->mmio_base, TBCTL);
pc->ctx.tbprd = ehrpwm_read(pc->mmio_base, TBPRD); pc->ctx.tbprd = ehrpwm_read(pc->mmio_base, TBPRD);
pc->ctx.cmpa = ehrpwm_read(pc->mmio_base, CMPA); pc->ctx.cmpa = ehrpwm_read(pc->mmio_base, CMPA);
@ -525,6 +533,7 @@ static void ehrpwm_pwm_save_context(struct ehrpwm_pwm_chip *pc)
pc->ctx.aqctlb = ehrpwm_read(pc->mmio_base, AQCTLB); pc->ctx.aqctlb = ehrpwm_read(pc->mmio_base, AQCTLB);
pc->ctx.aqsfrc = ehrpwm_read(pc->mmio_base, AQSFRC); pc->ctx.aqsfrc = ehrpwm_read(pc->mmio_base, AQSFRC);
pc->ctx.aqcsfrc = ehrpwm_read(pc->mmio_base, AQCSFRC); pc->ctx.aqcsfrc = ehrpwm_read(pc->mmio_base, AQCSFRC);
pm_runtime_put_sync(pc->chip.dev); pm_runtime_put_sync(pc->chip.dev);
} }
@ -543,9 +552,10 @@ static void ehrpwm_pwm_restore_context(struct ehrpwm_pwm_chip *pc)
static int ehrpwm_pwm_suspend(struct device *dev) static int ehrpwm_pwm_suspend(struct device *dev)
{ {
struct ehrpwm_pwm_chip *pc = dev_get_drvdata(dev); struct ehrpwm_pwm_chip *pc = dev_get_drvdata(dev);
int i; unsigned int i;
ehrpwm_pwm_save_context(pc); ehrpwm_pwm_save_context(pc);
for (i = 0; i < pc->chip.npwm; i++) { for (i = 0; i < pc->chip.npwm; i++) {
struct pwm_device *pwm = &pc->chip.pwms[i]; struct pwm_device *pwm = &pc->chip.pwms[i];
@ -555,13 +565,14 @@ static int ehrpwm_pwm_suspend(struct device *dev)
/* Disable explicitly if PWM is running */ /* Disable explicitly if PWM is running */
pm_runtime_put_sync(dev); pm_runtime_put_sync(dev);
} }
return 0; return 0;
} }
static int ehrpwm_pwm_resume(struct device *dev) static int ehrpwm_pwm_resume(struct device *dev)
{ {
struct ehrpwm_pwm_chip *pc = dev_get_drvdata(dev); struct ehrpwm_pwm_chip *pc = dev_get_drvdata(dev);
int i; unsigned int i;
for (i = 0; i < pc->chip.npwm; i++) { for (i = 0; i < pc->chip.npwm; i++) {
struct pwm_device *pwm = &pc->chip.pwms[i]; struct pwm_device *pwm = &pc->chip.pwms[i];
@ -572,24 +583,25 @@ static int ehrpwm_pwm_resume(struct device *dev)
/* Enable explicitly if PWM was running */ /* Enable explicitly if PWM was running */
pm_runtime_get_sync(dev); pm_runtime_get_sync(dev);
} }
ehrpwm_pwm_restore_context(pc); ehrpwm_pwm_restore_context(pc);
return 0; return 0;
} }
#endif #endif
static SIMPLE_DEV_PM_OPS(ehrpwm_pwm_pm_ops, ehrpwm_pwm_suspend, static SIMPLE_DEV_PM_OPS(ehrpwm_pwm_pm_ops, ehrpwm_pwm_suspend,
ehrpwm_pwm_resume); ehrpwm_pwm_resume);
static struct platform_driver ehrpwm_pwm_driver = { static struct platform_driver ehrpwm_pwm_driver = {
.driver = { .driver = {
.name = "ehrpwm", .name = "ehrpwm",
.of_match_table = ehrpwm_of_match, .of_match_table = ehrpwm_of_match,
.pm = &ehrpwm_pwm_pm_ops, .pm = &ehrpwm_pwm_pm_ops,
}, },
.probe = ehrpwm_pwm_probe, .probe = ehrpwm_pwm_probe,
.remove = ehrpwm_pwm_remove, .remove = ehrpwm_pwm_remove,
}; };
module_platform_driver(ehrpwm_pwm_driver); module_platform_driver(ehrpwm_pwm_driver);
MODULE_DESCRIPTION("EHRPWM PWM driver"); MODULE_DESCRIPTION("EHRPWM PWM driver");