[PATCH v4] clk: axs10x: introduce AXS10X pll driver

[PATCH v4] clk: axs10x: introduce AXS10X pll driver

[Eugeniy Paltsev]

AXS10X boards manages it's clocks using various PLLs. These PLL has same
dividers and corresponding control registers mapped to different addresses.
So we add one common driver for such PLLs.

Each PLL on AXS10X board consist of three dividers: IDIV, FBDIV and
ODIV. Output clock value is managed using these dividers.

We add pre-defined tables with supported rate values and appropriate
configurations of IDIV, FBDIV and ODIV for each value.

As of today we add support for PLLs that generate clock for the
following devices:
 * ARC core on AXC CPU tiles.
 * ARC PGU on ARC SDP Mainboard.
and more to come later.

By this patch we add support for two plls (arc core pll and pgu pll),
so we had to use two different init types: CLK_OF_DECLARE for arc core pll and
regular probing for pgu pll.

Acked-by: Rob Herring <robh@kernel.org>
Acked-by: Jose Abreu <joabreu@synopsys.com>

Signed-off-by: Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
Signed-off-by: Vlad Zakharov <vzakhar@synopsys.com>
Signed-off-by: Jose Abreu <joabreu@synopsys.com>
---
Changes for v4:
  - fix resource freing after error in of_axs10x_pll_clk_setup
  - add axs10x* prefix to main functions and structures
  - style fixies

Changes for v2..v3:
  - replaced complex data structures with simple cfg tables
  - replaced non-hw based provider and clk registration functions with hw-based
  - fixed typos and minor code styling issues

 .../devicetree/bindings/clock/snps,pll-clock.txt   |  28 ++
 MAINTAINERS                                        |   6 +
 drivers/clk/axs10x/Makefile                        |   1 +
 drivers/clk/axs10x/pll_clock.c                     | 344 +++++++++++++++++++++
 4 files changed, 379 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/clock/snps,pll-clock.txt
 create mode 100644 drivers/clk/axs10x/pll_clock.c

diff --git a/Documentation/devicetree/bindings/clock/snps,pll-clock.txt b/Documentation/devicetree/bindings/clock/snps,pll-clock.txt
new file mode 100644
index 0000000..11fe487
--- /dev/null
+++ b/Documentation/devicetree/bindings/clock/snps,pll-clock.txt
@@ -0,0 +1,28 @@
+Binding for the AXS10X Generic PLL clock
+
+This binding uses the common clock binding[1].
+
+[1] Documentation/devicetree/bindings/clock/clock-bindings.txt
+
+Required properties:
+- compatible: should be "snps,axs10x-<name>-pll-clock"
+  "snps,axs10x-arc-pll-clock"
+  "snps,axs10x-pgu-pll-clock"
+- reg: should always contain 2 pairs address - length: first for PLL config
+registers and second for corresponding LOCK CGU register.
+- clocks: shall be the input parent clock phandle for the PLL.
+- #clock-cells: from common clock binding; Should always be set to 0.
+
+Example:
+	input-clk: input-clk {
+		clock-frequency = <33333333>;
+		compatible = "fixed-clock";
+		#clock-cells = <0>;
+	};
+
+	core-clk: core-clk@80 {
+		compatible = "snps,axs10x-arc-pll-clock";
+		reg = <0x80 0x10>, <0x100 0x10>;
+		#clock-cells = <0>;
+		clocks = <&input-clk>;
+	};
diff --git a/MAINTAINERS b/MAINTAINERS
index 6b4395c..c5219d6 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -12560,6 +12560,12 @@ F:	arch/arc/plat-axs10x
 F:	arch/arc/boot/dts/ax*
 F:	Documentation/devicetree/bindings/arc/axs10*
 
+SYNOPSYS ARC SDP clock driver
+M:	Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
+S:	Supported
+F:	drivers/clk/axs10x/*
+F:	Documentation/devicetree/bindings/clock/snps,pll-clock.txt
+
 SYSTEM CONFIGURATION (SYSCON)
 M:	Lee Jones <lee.jones@linaro.org>
 M:	Arnd Bergmann <arnd@arndb.de>
diff --git a/drivers/clk/axs10x/Makefile b/drivers/clk/axs10x/Makefile
index 01996b8..d747dea 100644
--- a/drivers/clk/axs10x/Makefile
+++ b/drivers/clk/axs10x/Makefile
@@ -1 +1,2 @@
 obj-y += i2s_pll_clock.o
+obj-y += pll_clock.o
diff --git a/drivers/clk/axs10x/pll_clock.c b/drivers/clk/axs10x/pll_clock.c
new file mode 100644
index 0000000..69f72ac
--- /dev/null
+++ b/drivers/clk/axs10x/pll_clock.c
@@ -0,0 +1,344 @@
+/*
+ * Synopsys AXS10X SDP Generic PLL clock driver
+ *
+ * Copyright (C) 2017 Synopsys
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#include <linux/platform_device.h>
+#include <linux/module.h>
+#include <linux/clk-provider.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/device.h>
+#include <linux/of_address.h>
+#include <linux/of_device.h>
+#include <linux/slab.h>
+#include <linux/of.h>
+
+/* PLL registers addresses */
+#define PLL_REG_IDIV	0x0
+#define PLL_REG_FBDIV	0x4
+#define PLL_REG_ODIV	0x8
+
+/*
+ * Bit fields of the PLL IDIV/FBDIV/ODIV registers:
+ *  ________________________________________________________________________
+ * |31                15|    14    |   13   |  12  |11         6|5         0|
+ * |-------RESRVED------|-NOUPDATE-|-BYPASS-|-EDGE-|--HIGHTIME--|--LOWTIME--|
+ * |____________________|__________|________|______|____________|___________|
+ *
+ * Following macros determine the way of access to these registers
+ * They should be set up only using the macros.
+ * reg should be an u32 variable.
+ */
+
+#define PLL_REG_GET_LOW(reg)			\
+	(((reg) & (0x3F << 0)) >> 0)
+#define PLL_REG_GET_HIGH(reg)			\
+	(((reg) & (0x3F << 6)) >> 6)
+#define PLL_REG_GET_EDGE(reg)			\
+	(((reg) & (BIT(12))) ? 1 : 0)
+#define PLL_REG_GET_BYPASS(reg)			\
+	(((reg) & (BIT(13))) ? 1 : 0)
+#define PLL_REG_GET_NOUPD(reg)			\
+	(((reg) & (BIT(14))) ? 1 : 0)
+#define PLL_REG_GET_PAD(reg)			\
+	(((reg) & (0x1FFFF << 15)) >> 15)
+
+#define PLL_REG_SET_LOW(reg, value)		\
+	{ reg |= (((value) & 0x3F) << 0); }
+#define PLL_REG_SET_HIGH(reg, value)		\
+	{ reg |= (((value) & 0x3F) << 6); }
+#define PLL_REG_SET_EDGE(reg, value)		\
+	{ reg |= (((value) & 0x01) << 12); }
+#define PLL_REG_SET_BYPASS(reg, value)		\
+	{ reg |= (((value) & 0x01) << 13); }
+#define PLL_REG_SET_NOUPD(reg, value)		\
+	{ reg |= (((value) & 0x01) << 14); }
+#define PLL_REG_SET_PAD(reg, value)		\
+	{ reg |= (((value) & 0x1FFFF) << 15); }
+
+#define PLL_LOCK	BIT(0)
+#define PLL_ERROR	BIT(1)
+#define PLL_MAX_LOCK_TIME 100 /* 100 us */
+
+struct axs10x_pll_cfg {
+	u32 rate;
+	u32 idiv;
+	u32 fbdiv;
+	u32 odiv;
+};
+
+static const struct axs10x_pll_cfg arc_pll_cfg[] = {
+	{ 33333333,  1, 1,  1 },
+	{ 50000000,  1, 30, 20 },
+	{ 75000000,  2, 45, 10 },
+	{ 90000000,  2, 54, 10 },
+	{ 100000000, 1, 30, 10 },
+	{ 125000000, 2, 45, 6 },
+	{}
+};
+
+static const struct axs10x_pll_cfg pgu_pll_cfg[] = {
+	{ 25200000, 1, 84, 90 },
+	{ 50000000, 1, 100, 54 },
+	{ 74250000, 1, 44, 16 },
+	{}
+};
+
+struct axs10x_pll_clk {
+	struct clk_hw hw;
+	void __iomem *base;
+	void __iomem *lock;
+	const struct axs10x_pll_cfg *pll_cfg;
+	struct device *dev;
+};
+
+static inline void axs10x_pll_write(struct axs10x_pll_clk *clk, u32 reg,
+				    u32 val)
+{
+	iowrite32(val, clk->base + reg);
+}
+
+static inline u32 axs10x_pll_read(struct axs10x_pll_clk *clk, u32 reg)
+{
+	return ioread32(clk->base + reg);
+}
+
+static inline struct axs10x_pll_clk *to_axs10x_pll_clk(struct clk_hw *hw)
+{
+	return container_of(hw, struct axs10x_pll_clk, hw);
+}
+
+static inline u32 axs10x_div_get_value(u32 reg)
+{
+	if (PLL_REG_GET_BYPASS(reg))
+		return 1;
+
+	return PLL_REG_GET_HIGH(reg) + PLL_REG_GET_LOW(reg);
+}
+
+static inline u32 axs10x_encode_div(unsigned int id, int upd)
+{
+	u32 div = 0;
+
+	PLL_REG_SET_LOW(div, (id % 2 == 0) ? id >> 1 : (id >> 1) + 1);
+	PLL_REG_SET_HIGH(div, id >> 1);
+	PLL_REG_SET_EDGE(div, id % 2);
+	PLL_REG_SET_BYPASS(div, id == 1 ? 1 : 0);
+	PLL_REG_SET_NOUPD(div, !upd);
+
+	return div;
+}
+
+static unsigned long axs10x_pll_recalc_rate(struct clk_hw *hw,
+					    unsigned long parent_rate)
+{
+	u64 rate;
+	u32 idiv, fbdiv, odiv;
+	struct axs10x_pll_clk *clk = to_axs10x_pll_clk(hw);
+
+	idiv = axs10x_div_get_value(axs10x_pll_read(clk, PLL_REG_IDIV));
+	fbdiv = axs10x_div_get_value(axs10x_pll_read(clk, PLL_REG_FBDIV));
+	odiv = axs10x_div_get_value(axs10x_pll_read(clk, PLL_REG_ODIV));
+
+	rate = (u64)parent_rate * fbdiv;
+	do_div(rate, idiv * odiv);
+
+	return rate;
+}
+
+static long axs10x_pll_round_rate(struct clk_hw *hw, unsigned long rate,
+				  unsigned long *prate)
+{
+	int i;
+	long best_rate;
+	struct axs10x_pll_clk *clk = to_axs10x_pll_clk(hw);
+	const struct axs10x_pll_cfg *pll_cfg = clk->pll_cfg;
+
+	if (pll_cfg[0].rate == 0)
+		return -EINVAL;
+
+	best_rate = pll_cfg[0].rate;
+
+	for (i = 1; pll_cfg[i].rate != 0; i++) {
+		if (abs(rate - pll_cfg[i].rate) < abs(rate - best_rate))
+			best_rate = pll_cfg[i].rate;
+	}
+
+	return best_rate;
+}
+
+static int axs10x_pll_set_rate(struct clk_hw *hw, unsigned long rate,
+			       unsigned long parent_rate)
+{
+	int i;
+	struct axs10x_pll_clk *clk = to_axs10x_pll_clk(hw);
+	const struct axs10x_pll_cfg *pll_cfg = clk->pll_cfg;
+
+	for (i = 0; pll_cfg[i].rate != 0; i++) {
+		if (pll_cfg[i].rate == rate) {
+			axs10x_pll_write(clk, PLL_REG_IDIV,
+					 axs10x_encode_div(pll_cfg[i].idiv, 0));
+			axs10x_pll_write(clk, PLL_REG_FBDIV,
+					 axs10x_encode_div(pll_cfg[i].fbdiv, 0));
+			axs10x_pll_write(clk, PLL_REG_ODIV,
+					 axs10x_encode_div(pll_cfg[i].odiv, 1));
+
+			/*
+			 * Wait until CGU relocks and check error status.
+			 * If after timeout CGU is unlocked yet return error
+			 */
+			udelay(PLL_MAX_LOCK_TIME);
+			if (!(ioread32(clk->lock) & PLL_LOCK))
+				return -ETIMEDOUT;
+
+			if (ioread32(clk->lock) & PLL_ERROR)
+				return -EINVAL;
+
+			return 0;
+		}
+	}
+
+	dev_err(clk->dev, "invalid rate=%ld, parent_rate=%ld\n", rate,
+			parent_rate);
+	return -EINVAL;
+}
+
+static const struct clk_ops axs10x_pll_ops = {
+	.recalc_rate = axs10x_pll_recalc_rate,
+	.round_rate = axs10x_pll_round_rate,
+	.set_rate = axs10x_pll_set_rate,
+};
+
+static int axs10x_pll_clk_probe(struct platform_device *pdev)
+{
+	struct device *dev = &pdev->dev;
+	const char *parent_name;
+	struct axs10x_pll_clk *pll_clk;
+	struct resource *mem;
+	struct clk_init_data init = { };
+	int ret;
+
+	pll_clk = devm_kzalloc(dev, sizeof(*pll_clk), GFP_KERNEL);
+	if (!pll_clk)
+		return -ENOMEM;
+
+	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+	pll_clk->base = devm_ioremap_resource(dev, mem);
+	if (IS_ERR(pll_clk->base))
+		return PTR_ERR(pll_clk->base);
+
+	mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+	pll_clk->lock = devm_ioremap_resource(dev, mem);
+	if (IS_ERR(pll_clk->lock))
+		return PTR_ERR(pll_clk->lock);
+
+	init.name = dev->of_node->name;
+	init.ops = &axs10x_pll_ops;
+	parent_name = of_clk_get_parent_name(dev->of_node, 0);
+	init.parent_names = &parent_name;
+	init.num_parents = 1;
+	pll_clk->hw.init = &init;
+	pll_clk->dev = dev;
+	pll_clk->pll_cfg = of_device_get_match_data(dev);
+
+	if (!pll_clk->pll_cfg) {
+		dev_err(dev, "No OF match data provided\n");
+		return -EINVAL;
+	}
+
+	ret = devm_clk_hw_register(dev, &pll_clk->hw);
+	if (ret) {
+		dev_err(dev, "failed to register %s clock\n", init.name);
+		return ret;
+	}
+
+	return of_clk_add_hw_provider(dev->of_node, of_clk_hw_simple_get,
+			&pll_clk->hw);
+}
+
+static int axs10x_pll_clk_remove(struct platform_device *pdev)
+{
+	of_clk_del_provider(pdev->dev.of_node);
+	return 0;
+}
+
+static void __init of_axs10x_pll_clk_setup(struct device_node *node)
+{
+	const char *parent_name;
+	struct axs10x_pll_clk *pll_clk;
+	struct clk_init_data init = { };
+	int ret;
+
+	pll_clk = kzalloc(sizeof(*pll_clk), GFP_KERNEL);
+	if (!pll_clk)
+		return;
+
+	pll_clk->base = of_iomap(node, 0);
+	if (!pll_clk->base) {
+		pr_err("failed to map pll div registers\n");
+		goto err_free_pll_clk;
+	}
+
+	pll_clk->lock = of_iomap(node, 1);
+	if (!pll_clk->lock) {
+		pr_err("failed to map pll lock register\n");
+		goto err_unmap_base;
+	}
+
+	init.name = node->name;
+	init.ops = &axs10x_pll_ops;
+	parent_name = of_clk_get_parent_name(node, 0);
+	init.parent_names = &parent_name;
+	init.num_parents = parent_name ? 1 : 0;
+	pll_clk->hw.init = &init;
+	pll_clk->pll_cfg = arc_pll_cfg;
+
+	ret = clk_hw_register(NULL, &pll_clk->hw);
+	if (ret) {
+		pr_err("failed to register %s clock\n", node->name);
+		goto err_unmap_lock;
+	}
+
+	ret = of_clk_add_hw_provider(node, of_clk_hw_simple_get, &pll_clk->hw);
+	if (ret) {
+		pr_err("failed to add hw provider for %s clock\n", node->name);
+		goto err_unmap_lock;
+	}
+
+	return;
+
+err_unmap_lock:
+	iounmap(pll_clk->lock);
+err_unmap_base:
+	iounmap(pll_clk->base);
+err_free_pll_clk:
+	kfree(pll_clk);
+}
+CLK_OF_DECLARE(axs10x_pll_clock, "snps,axs10x-arc-pll-clock",
+	       of_axs10x_pll_clk_setup);
+
+static const struct of_device_id axs10x_pll_clk_id[] = {
+	{ .compatible = "snps,axs10x-pgu-pll-clock", .data = &pgu_pll_cfg},
+	{ },
+};
+MODULE_DEVICE_TABLE(of, axs10x_pll_clk_id);
+
+static struct platform_driver axs10x_pll_clk_driver = {
+	.driver = {
+		.name = "axs10x-pll-clock",
+		.of_match_table = axs10x_pll_clk_id,
+	},
+	.probe = axs10x_pll_clk_probe,
+	.remove = axs10x_pll_clk_remove,
+};
+builtin_platform_driver(axs10x_pll_clk_driver);
+
+MODULE_AUTHOR("Vlad Zakharov <vzakhar@synopsys.com>");
+MODULE_DESCRIPTION("Synopsys AXS10X SDP Generic PLL Clock Driver");
+MODULE_LICENSE("GPL v2");
-- 
2.9.3

Re: [PATCH v4] clk: axs10x: introduce AXS10X pll driver

[Eugeniy Paltsev]
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Re: [PATCH v4] clk: axs10x: introduce AXS10X pll driver

[Stephen Boyd]

On 06/21, Eugeniy Paltsev wrote:
> AXS10X boards manages it's clocks using various PLLs. These PLL has same
> dividers and corresponding control registers mapped to different addresses.
> So we add one common driver for such PLLs.
> 
> Each PLL on AXS10X board consist of three dividers: IDIV, FBDIV and
> ODIV. Output clock value is managed using these dividers.
> 
> We add pre-defined tables with supported rate values and appropriate
> configurations of IDIV, FBDIV and ODIV for each value.
> 
> As of today we add support for PLLs that generate clock for the
> following devices:
>  * ARC core on AXC CPU tiles.
>  * ARC PGU on ARC SDP Mainboard.
> and more to come later.
> 
> By this patch we add support for two plls (arc core pll and pgu pll),
> so we had to use two different init types: CLK_OF_DECLARE for arc core pll and
> regular probing for pgu pll.
> 
> Acked-by: Rob Herring <robh@kernel.org>
> Acked-by: Jose Abreu <joabreu@synopsys.com>
> 
> Signed-off-by: Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
> Signed-off-by: Vlad Zakharov <vzakhar@synopsys.com>
> Signed-off-by: Jose Abreu <joabreu@synopsys.com>

Sorry this missed the cutoff for new code for v4.13. Should be in
clk-next next week though.

> +}
> +
> +static inline struct axs10x_pll_clk *to_axs10x_pll_clk(struct clk_hw *hw)
> +{
> +	return container_of(hw, struct axs10x_pll_clk, hw);
> +}
> +
> +static inline u32 axs10x_div_get_value(u32 reg)
> +{
> +	if (PLL_REG_GET_BYPASS(reg))
> +		return 1;
> +
> +	return PLL_REG_GET_HIGH(reg) + PLL_REG_GET_LOW(reg);
> +}
> +
> +static inline u32 axs10x_encode_div(unsigned int id, int upd)
> +{
> +	u32 div = 0;
> +
> +	PLL_REG_SET_LOW(div, (id % 2 == 0) ? id >> 1 : (id >> 1) + 1);
> +	PLL_REG_SET_HIGH(div, id >> 1);
> +	PLL_REG_SET_EDGE(div, id % 2);
> +	PLL_REG_SET_BYPASS(div, id == 1 ? 1 : 0);
> +	PLL_REG_SET_NOUPD(div, !upd);

So sparse complains here about a "dubious !x & y". Perhaps this
can be changed to

	PLL_REG_SET_NOUPD(div, upd == 0 ? 1 : 0);

That way sparse doesn't complain. I can make the change when
applying if you agree.

-- 
Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum,
a Linux Foundation Collaborative Project

Re: [PATCH v4] clk: axs10x: introduce AXS10X pll driver

[Eugeniy Paltsev]
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Re: [PATCH v4] clk: axs10x: introduce AXS10X pll driver

[sboyd]

On 07/12, Eugeniy Paltsev wrote:
> On Tue, 2017-07-11 at 22:25 -0700, Stephen Boyd wrote:
> > On 06/21, Eugeniy Paltsev wrote:
> > > AXS10X boards manages it's clocks using various PLLs. These PLL has
> > > same
> > > dividers and corresponding control registers mapped to different
> > > addresses.
> > > So we add one common driver for such PLLs.
> > > 
> > > Each PLL on AXS10X board consist of three dividers: IDIV, FBDIV and
> > > ODIV. Output clock value is managed using these dividers.
> > > 
> > > We add pre-defined tables with supported rate values and
> > > appropriate
> > > configurations of IDIV, FBDIV and ODIV for each value.
> > > 
> > > As of today we add support for PLLs that generate clock for the
> > > following devices:
> > >  * ARC core on AXC CPU tiles.
> > >  * ARC PGU on ARC SDP Mainboard.
> > > and more to come later.
> > > 
> > > By this patch we add support for two plls (arc core pll and pgu
> > > pll),
> > > so we had to use two different init types: CLK_OF_DECLARE for arc
> > > core pll and
> > > regular probing for pgu pll.
> > > 
> > > Acked-by: Rob Herring <robh@kernel.org>
> > > Acked-by: Jose Abreu <joabreu@synopsys.com>
> > > 
> > > Signed-off-by: Eugeniy Paltsev <Eugeniy.Paltsev@synopsys.com>
> > > Signed-off-by: Vlad Zakharov <vzakhar@synopsys.com>
> > > Signed-off-by: Jose Abreu <joabreu@synopsys.com>
> > 
> > Sorry this missed the cutoff for new code for v4.13. Should be in
> > clk-next next week though.
> > 
> > > +}
> > > +
> > > +static inline struct axs10x_pll_clk *to_axs10x_pll_clk(struct
> > > clk_hw *hw)
> > > +{
> > > +	return container_of(hw, struct axs10x_pll_clk, hw);
> > > +}
> > > +
> > > +static inline u32 axs10x_div_get_value(u32 reg)
> > > +{
> > > +	if (PLL_REG_GET_BYPASS(reg))
> > > +		return 1;
> > > +
> > > +	return PLL_REG_GET_HIGH(reg) + PLL_REG_GET_LOW(reg);
> > > +}
> > > +
> > > +static inline u32 axs10x_encode_div(unsigned int id, int upd)
> > > +{
> > > +	u32 div = 0;
> > > +
> > > +	PLL_REG_SET_LOW(div, (id % 2 == 0) ? id >> 1 : (id >> 1) +
> > > 1);
> > > +	PLL_REG_SET_HIGH(div, id >> 1);
> > > +	PLL_REG_SET_EDGE(div, id % 2);
> > > +	PLL_REG_SET_BYPASS(div, id == 1 ? 1 : 0);
> > > +	PLL_REG_SET_NOUPD(div, !upd);
> > 
> > So sparse complains here about a "dubious !x & y". Perhaps this
> > can be changed to
> > 
> > 	PLL_REG_SET_NOUPD(div, upd == 0 ? 1 : 0);
> > 
> > That way sparse doesn't complain. I can make the change when
> > applying if you agree.
> 
> Sure, thanks a lot.
> 

Ok. Applied to clk-next.

-- 
Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum,
a Linux Foundation Collaborative Project