Do some cosmetic cleanups before we start adding lots of code.
- Shorten clk_wzrd identifier to cw to keep lines short
- Replace &pdev->dev with dev to keep lines short
- Remove convenience variable np as it was only used once in function
- Add some tabs to make clk_wzrd structure definitions easier to read
- Use #define for clock names in case we want to change them later
Signed-off-by: James Kelly <jamespeterke...@gmail.com>
---
.../clocking-wizard/clk-xlnx-clock-wizard.c | 210 ++++++++++-----------
1 file changed, 105 insertions(+), 105 deletions(-)
diff --git a/drivers/staging/clocking-wizard/clk-xlnx-clock-wizard.c
b/drivers/staging/clocking-wizard/clk-xlnx-clock-wizard.c
index 4dec1bfc303a..3b66ac3b5ed0 100644
--- a/drivers/staging/clocking-wizard/clk-xlnx-clock-wizard.c
+++ b/drivers/staging/clocking-wizard/clk-xlnx-clock-wizard.c
@@ -70,6 +70,8 @@
#define WZRD_NUM_OUTPUTS 7
#define WZRD_ACLK_MAX_FREQ 250000000UL
+#define WZRD_CLKNAME_AXI "s_axi_aclk"
+#define WZRD_CLKNAME_IN1 "clk_in1"
#define WZRD_CLK_CFG_REG(n) (0x200 + 4 * (n))
@@ -102,15 +104,15 @@ enum clk_wzrd_int_clks {
* @suspended: Flag indicating power state of the device
*/
struct clk_wzrd {
- struct clk_onecell_data clk_data;
- struct notifier_block nb;
- void __iomem *base;
- struct clk *clk_in1;
- struct clk *axi_clk;
- struct clk *clks_internal[wzrd_clk_int_max];
- struct clk *clkout[WZRD_NUM_OUTPUTS];
- unsigned int speed_grade;
- bool suspended;
+ struct clk_onecell_data clk_data;
+ struct notifier_block nb;
+ void __iomem *base;
+ struct clk *clk_in1;
+ struct clk *axi_clk;
+ struct clk *clks_internal[wzrd_clk_int_max];
+ struct clk *clkout[WZRD_NUM_OUTPUTS];
+ unsigned int speed_grade;
+ bool suspended;
};
#define to_clk_wzrd(_nb) container_of(_nb, struct clk_wzrd, nb)
@@ -127,14 +129,14 @@ static int clk_wzrd_clk_notifier(struct notifier_block
*nb, unsigned long event,
{
unsigned long max;
struct clk_notifier_data *ndata = data;
- struct clk_wzrd *clk_wzrd = to_clk_wzrd(nb);
+ struct clk_wzrd *cw = to_clk_wzrd(nb);
- if (clk_wzrd->suspended)
+ if (cw->suspended)
return NOTIFY_OK;
- if (ndata->clk == clk_wzrd->clk_in1)
- max = clk_wzrd_max_freq[clk_wzrd->speed_grade - 1];
- else if (ndata->clk == clk_wzrd->axi_clk)
+ if (ndata->clk == cw->clk_in1)
+ max = clk_wzrd_max_freq[cw->speed_grade - 1];
+ else if (ndata->clk == cw->axi_clk)
max = WZRD_ACLK_MAX_FREQ;
else
return NOTIFY_DONE; /* should never happen */
@@ -153,10 +155,10 @@ static int clk_wzrd_clk_notifier(struct notifier_block
*nb, unsigned long event,
static int __maybe_unused clk_wzrd_suspend(struct device *dev)
{
- struct clk_wzrd *clk_wzrd = dev_get_drvdata(dev);
+ struct clk_wzrd *cw = dev_get_drvdata(dev);
- clk_disable_unprepare(clk_wzrd->axi_clk);
- clk_wzrd->suspended = true;
+ clk_disable_unprepare(cw->axi_clk);
+ cw->suspended = true;
return 0;
}
@@ -164,15 +166,15 @@ static int __maybe_unused clk_wzrd_suspend(struct device
*dev)
static int __maybe_unused clk_wzrd_resume(struct device *dev)
{
int ret;
- struct clk_wzrd *clk_wzrd = dev_get_drvdata(dev);
+ struct clk_wzrd *cw = dev_get_drvdata(dev);
- ret = clk_prepare_enable(clk_wzrd->axi_clk);
+ ret = clk_prepare_enable(cw->axi_clk);
if (ret) {
dev_err(dev, "unable to enable s_axi_aclk\n");
return ret;
}
- clk_wzrd->suspended = false;
+ cw->suspended = false;
return 0;
}
@@ -184,47 +186,46 @@ static int clk_wzrd_get_device_tree_data(struct device
*dev)
{
int ret;
unsigned long rate;
- struct clk_wzrd *clk_wzrd;
- struct platform_device *pdev = to_platform_device(dev);
- struct device_node *np = pdev->dev.of_node;
+ struct clk_wzrd *cw;
- clk_wzrd = devm_kzalloc(&pdev->dev, sizeof(*clk_wzrd), GFP_KERNEL);
- if (!clk_wzrd)
+ cw = devm_kzalloc(dev, sizeof(*cw), GFP_KERNEL);
+ if (!cw)
return -ENOMEM;
- platform_set_drvdata(pdev, clk_wzrd);
+ dev_set_drvdata(dev, cw);
- ret = of_property_read_u32(np, "speed-grade", &clk_wzrd->speed_grade);
+ ret = of_property_read_u32(dev->of_node, "speed-grade",
+ &cw->speed_grade);
if (!ret) {
- if (clk_wzrd->speed_grade < 1 || clk_wzrd->speed_grade > 3) {
- dev_warn(&pdev->dev, "invalid speed grade '%d'\n",
- clk_wzrd->speed_grade);
- clk_wzrd->speed_grade = 0;
+ if (cw->speed_grade < 1 || cw->speed_grade > 3) {
+ dev_warn(dev, "invalid speed grade '%d'\n",
+ cw->speed_grade);
+ cw->speed_grade = 0;
}
}
- clk_wzrd->clk_in1 = devm_clk_get(&pdev->dev, "clk_in1");
- if (IS_ERR(clk_wzrd->clk_in1)) {
- if (clk_wzrd->clk_in1 != ERR_PTR(-EPROBE_DEFER))
- dev_err(&pdev->dev, "clk_in1 not found\n");
- return PTR_ERR(clk_wzrd->clk_in1);
+ cw->clk_in1 = devm_clk_get(dev, WZRD_CLKNAME_IN1);
+ if (IS_ERR(cw->clk_in1)) {
+ if (cw->clk_in1 != ERR_PTR(-EPROBE_DEFER))
+ dev_err(dev, "Clock %s not found\n", WZRD_CLKNAME_IN1);
+ return PTR_ERR(cw->clk_in1);
}
- clk_wzrd->axi_clk = devm_clk_get(&pdev->dev, "s_axi_aclk");
- if (IS_ERR(clk_wzrd->axi_clk)) {
- if (clk_wzrd->axi_clk != ERR_PTR(-EPROBE_DEFER))
- dev_err(&pdev->dev, "s_axi_aclk not found\n");
- return PTR_ERR(clk_wzrd->axi_clk);
+ cw->axi_clk = devm_clk_get(dev, WZRD_CLKNAME_AXI);
+ if (IS_ERR(cw->axi_clk)) {
+ if (cw->axi_clk != ERR_PTR(-EPROBE_DEFER))
+ dev_err(dev, "Clock %s not found\n", WZRD_CLKNAME_AXI);
+ return PTR_ERR(cw->axi_clk);
}
- ret = clk_prepare_enable(clk_wzrd->axi_clk);
+ ret = clk_prepare_enable(cw->axi_clk);
if (ret) {
- dev_err(&pdev->dev, "enabling s_axi_aclk failed\n");
+ dev_err(dev, "enabling %s failed\n", WZRD_CLKNAME_AXI);
return ret;
}
- rate = clk_get_rate(clk_wzrd->axi_clk);
+ rate = clk_get_rate(cw->axi_clk);
if (rate > WZRD_ACLK_MAX_FREQ) {
- dev_err(&pdev->dev, "s_axi_aclk frequency (%lu) too high\n",
+ dev_err(dev, "%s frequency (%lu) too high\n", WZRD_CLKNAME_AXI,
rate);
- clk_disable_unprepare(clk_wzrd->axi_clk);
+ clk_disable_unprepare(cw->axi_clk);
return -EINVAL;
}
@@ -234,13 +235,12 @@ static int clk_wzrd_get_device_tree_data(struct device
*dev)
static int clk_wzrd_regmap_alloc(struct device *dev)
{
struct resource *mem;
- struct clk_wzrd *clk_wzrd = dev_get_drvdata(dev);
- struct platform_device *pdev = to_platform_device(dev);
+ struct clk_wzrd *cw = dev_get_drvdata(dev);
- mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- clk_wzrd->base = devm_ioremap_resource(&pdev->dev, mem);
- if (IS_ERR(clk_wzrd->base))
- return PTR_ERR(clk_wzrd->base);
+ mem = platform_get_resource(to_platform_device(dev), IORESOURCE_MEM, 0);
+ cw->base = devm_ioremap_resource(dev, mem);
+ if (IS_ERR(cw->base))
+ return PTR_ERR(cw->base);
return 0;
}
@@ -250,52 +250,50 @@ static int clk_wzrd_register_ccf(struct device *dev)
int i, ret;
u32 reg;
const char *clk_name;
- struct platform_device *pdev = to_platform_device(dev);
- struct clk_wzrd *clk_wzrd = dev_get_drvdata(dev);
- struct device_node *np = pdev->dev.of_node;
+ struct clk_wzrd *cw = dev_get_drvdata(dev);
/* we don't support fractional div/mul yet */
- reg = readl(clk_wzrd->base + WZRD_CLK_CFG_REG(0)) &
+ reg = readl(cw->base + WZRD_CLK_CFG_REG(0)) &
WZRD_CLKFBOUT_FRAC_EN;
- reg |= readl(clk_wzrd->base + WZRD_CLK_CFG_REG(2)) &
+ reg |= readl(cw->base + WZRD_CLK_CFG_REG(2)) &
WZRD_CLKOUT0_FRAC_EN;
if (reg)
- dev_warn(&pdev->dev, "fractional div/mul not supported\n");
+ dev_warn(dev, "fractional div/mul not supported\n");
/* register div */
- reg = (readl(clk_wzrd->base + WZRD_CLK_CFG_REG(0)) &
- WZRD_DIVCLK_DIVIDE_MASK) >> WZRD_DIVCLK_DIVIDE_SHIFT;
- clk_name = kasprintf(GFP_KERNEL, "%s_mul_div", dev_name(&pdev->dev));
+ reg = (readl(cw->base + WZRD_CLK_CFG_REG(0)) &
+ WZRD_DIVCLK_DIVIDE_MASK) >> WZRD_DIVCLK_DIVIDE_SHIFT;
+ clk_name = kasprintf(GFP_KERNEL, "%s_mul_div", dev_name(dev));
if (!clk_name) {
ret = -ENOMEM;
goto err_disable_clk;
}
- clk_wzrd->clks_internal[wzrd_clk_mul_div] = clk_register_fixed_factor(
- &pdev->dev, clk_name,
- __clk_get_name(clk_wzrd->clk_in1),
+ cw->clks_internal[wzrd_clk_mul_div] = clk_register_fixed_factor(
+ dev, clk_name,
+ __clk_get_name(cw->clk_in1),
0, 1, reg);
kfree(clk_name);
- if (IS_ERR(clk_wzrd->clks_internal[wzrd_clk_mul_div])) {
- dev_err(&pdev->dev, "unable to register divider clock\n");
- ret = PTR_ERR(clk_wzrd->clks_internal[wzrd_clk_mul_div]);
+ if (IS_ERR(cw->clks_internal[wzrd_clk_mul_div])) {
+ dev_err(dev, "unable to register divider clock\n");
+ ret = PTR_ERR(cw->clks_internal[wzrd_clk_mul_div]);
goto err_disable_clk;
}
/* register multiplier */
- reg = (readl(clk_wzrd->base + WZRD_CLK_CFG_REG(0)) &
- WZRD_CLKFBOUT_MULT_MASK) >> WZRD_CLKFBOUT_MULT_SHIFT;
- clk_name = kasprintf(GFP_KERNEL, "%s_mul", dev_name(&pdev->dev));
+ reg = (readl(cw->base + WZRD_CLK_CFG_REG(0)) &
+ WZRD_CLKFBOUT_MULT_MASK) >> WZRD_CLKFBOUT_MULT_SHIFT;
+ clk_name = kasprintf(GFP_KERNEL, "%s_mul", dev_name(dev));
if (!clk_name) {
ret = -ENOMEM;
goto err_rm_int_clk;
}
- clk_wzrd->clks_internal[wzrd_clk_mul] = clk_register_fixed_factor(
- &pdev->dev, clk_name,
-
__clk_get_name(clk_wzrd->clks_internal[wzrd_clk_mul_div]),
+ cw->clks_internal[wzrd_clk_mul] = clk_register_fixed_factor(
+ dev, clk_name,
+ __clk_get_name(cw->clks_internal[wzrd_clk_mul_div]),
0, reg, 1);
- if (IS_ERR(clk_wzrd->clks_internal[wzrd_clk_mul])) {
- dev_err(&pdev->dev, "unable to register fixed-factor clock\n");
- ret = PTR_ERR(clk_wzrd->clks_internal[wzrd_clk_mul]);
+ if (IS_ERR(cw->clks_internal[wzrd_clk_mul])) {
+ dev_err(dev, "unable to register fixed-factor clock\n");
+ ret = PTR_ERR(cw->clks_internal[wzrd_clk_mul]);
goto err_rm_int_clk;
}
@@ -303,60 +301,62 @@ static int clk_wzrd_register_ccf(struct device *dev)
for (i = WZRD_NUM_OUTPUTS - 1; i >= 0 ; i--) {
const char *clkout_name;
- if (of_property_read_string_index(np, "clock-output-names", i,
+ if (of_property_read_string_index(dev->of_node,
+ "clock-output-names", i,
&clkout_name)) {
- dev_err(&pdev->dev,
+ dev_err(dev,
"clock output name not specified\n");
ret = -EINVAL;
goto err_rm_int_clks;
}
- reg = readl(clk_wzrd->base + WZRD_CLK_CFG_REG(2) + i * 12);
+ reg = readl(cw->base + WZRD_CLK_CFG_REG(2) + i * 12);
reg &= WZRD_CLKOUT_DIVIDE_MASK;
reg >>= WZRD_CLKOUT_DIVIDE_SHIFT;
- clk_wzrd->clkout[i] = clk_register_fixed_factor(&pdev->dev,
- clkout_name, clk_name, 0, 1, reg);
- if (IS_ERR(clk_wzrd->clkout[i])) {
+ cw->clkout[i] = clk_register_fixed_factor(dev, clkout_name,
+ clk_name, 0, 1, reg);
+ if (IS_ERR(cw->clkout[i])) {
int j;
for (j = i + 1; j < WZRD_NUM_OUTPUTS; j++)
- clk_unregister(clk_wzrd->clkout[j]);
- dev_err(&pdev->dev,
+ clk_unregister(cw->clkout[j]);
+ dev_err(dev,
"unable to register divider clock\n");
- ret = PTR_ERR(clk_wzrd->clkout[i]);
+ ret = PTR_ERR(cw->clkout[i]);
goto err_rm_int_clks;
}
}
kfree(clk_name);
- clk_wzrd->clk_data.clks = clk_wzrd->clkout;
- clk_wzrd->clk_data.clk_num = ARRAY_SIZE(clk_wzrd->clkout);
- of_clk_add_provider(np, of_clk_src_onecell_get, &clk_wzrd->clk_data);
+ cw->clk_data.clks = cw->clkout;
+ cw->clk_data.clk_num = ARRAY_SIZE(cw->clkout);
+ of_clk_add_provider(dev->of_node, of_clk_src_onecell_get,
+ &cw->clk_data);
- if (clk_wzrd->speed_grade) {
- clk_wzrd->nb.notifier_call = clk_wzrd_clk_notifier;
+ if (cw->speed_grade) {
+ cw->nb.notifier_call = clk_wzrd_clk_notifier;
- ret = clk_notifier_register(clk_wzrd->clk_in1,
- &clk_wzrd->nb);
+ ret = clk_notifier_register(cw->clk_in1,
+ &cw->nb);
if (ret)
- dev_warn(&pdev->dev,
+ dev_warn(dev,
"unable to register clock notifier\n");
- ret = clk_notifier_register(clk_wzrd->axi_clk, &clk_wzrd->nb);
+ ret = clk_notifier_register(cw->axi_clk, &cw->nb);
if (ret)
- dev_warn(&pdev->dev,
+ dev_warn(dev,
"unable to register clock notifier\n");
}
return 0;
err_rm_int_clks:
- clk_unregister(clk_wzrd->clks_internal[1]);
+ clk_unregister(cw->clks_internal[1]);
err_rm_int_clk:
kfree(clk_name);
- clk_unregister(clk_wzrd->clks_internal[0]);
+ clk_unregister(cw->clks_internal[0]);
err_disable_clk:
- clk_disable_unprepare(clk_wzrd->axi_clk);
+ clk_disable_unprepare(cw->axi_clk);
return ret;
}
@@ -384,21 +384,21 @@ static int clk_wzrd_probe(struct platform_device *pdev)
static int clk_wzrd_remove(struct platform_device *pdev)
{
int i;
- struct clk_wzrd *clk_wzrd = platform_get_drvdata(pdev);
+ struct clk_wzrd *cw = platform_get_drvdata(pdev);
of_clk_del_provider(pdev->dev.of_node);
for (i = 0; i < WZRD_NUM_OUTPUTS; i++)
- clk_unregister(clk_wzrd->clkout[i]);
+ clk_unregister(cw->clkout[i]);
for (i = 0; i < wzrd_clk_int_max; i++)
- clk_unregister(clk_wzrd->clks_internal[i]);
+ clk_unregister(cw->clks_internal[i]);
- if (clk_wzrd->speed_grade) {
- clk_notifier_unregister(clk_wzrd->axi_clk, &clk_wzrd->nb);
- clk_notifier_unregister(clk_wzrd->clk_in1, &clk_wzrd->nb);
+ if (cw->speed_grade) {
+ clk_notifier_unregister(cw->axi_clk, &cw->nb);
+ clk_notifier_unregister(cw->clk_in1, &cw->nb);
}
- clk_disable_unprepare(clk_wzrd->axi_clk);
+ clk_disable_unprepare(cw->axi_clk);
return 0;
}
--
2.15.1 (Apple Git-101)
_______________________________________________
devel mailing list
de...@linuxdriverproject.org
http://driverdev.linuxdriverproject.org/mailman/listinfo/driverdev-devel
