[PATCH 04/14] staging: clocking-wizard: Cosmetic cleanups

[James Kelly <jamespeterkelly@gmail.com>]

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 <jamespeterkelly@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
devel@linuxdriverproject.org
http://driverdev.linuxdriverproject.org/mailman/listinfo/driverdev-devel