From patchwork Tue Feb 21 13:11:10 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Zakharov Vlad X-Patchwork-Id: 730541 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from bombadil.infradead.org (bombadil.infradead.org [65.50.211.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 3vSLj31Vs2z9s0m for ; Wed, 22 Feb 2017 00:20:39 +1100 (AEDT) Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="mKYWmaJr"; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=infradead.org header.i=@infradead.org header.b="GWXa0G1B"; dkim-atps=neutral DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Cc:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:Message-Id:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To: References:List-Owner; bh=/9aJ7cBNhCxIU8EFhRtKUZWJojJJa6Jpmvyu1vqj4ec=; b=mKY WmaJr7LJp+6gh4qS8wTyFd1WT0ci+vBfSVfQeY+jjU+pD/jHSAoogpruYURm0bSn+TsNsEi8CnVQ3 8eVHvGXe04UgLq5ylHQOmRq4bDQ/ClNzyDYtOPSJBb+S8JjA4Nh4/qtj8ayhHxdTbCLL6IgQfebA0 W+rgX9Yl9R7XTgx3UrU81Xjms7WRSSoIuTL/7QtctPS6qaaxxWmsYYZOrFOG0+Hrp50/Ua49nhK5M RB3W4S8621uwOw12mHyW46+uKCcdPNo26qLoItMx6vcxNg1Nect+9stxDOD2sqJA+yeMApL0XKSD/ T4o8utaf+OnZ1PZuCNm2iiYG4qolJdg==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.87 #1 (Red Hat Linux)) id 1cgAMv-0007nl-Nu; Tue, 21 Feb 2017 13:20:37 +0000 Received: from casper.infradead.org ([2001:770:15f::2]) by bombadil.infradead.org with esmtps (Exim 4.87 #1 (Red Hat Linux)) id 1cgAMa-00065h-Ep for linux-snps-arc@bombadil.infradead.org; Tue, 21 Feb 2017 13:20:16 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=casper.20170209; h=Message-Id:Date:Subject:Cc:To:From: Sender:Reply-To:MIME-Version:Content-Type:Content-Transfer-Encoding: Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender: Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To:References:List-Id: List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive; bh=IdMnn7z+HqDrd754COJh9/K8w2DW+szQeMwS+QJfpdA=; b=GWXa0G1BzTb5Yd0N7FHqrpAm+ sRYhk0k+kuLLMGv/MI3GZFHWRY7b/ML1mfXRcR/1QWcGlr0yNZfZBeYW6uZGcMkB6cCR2J3fQP69u R6zzW32rRZv8pyEsYM2EZis9M9LOd1+KsjXLC/TOrdWdcwx7WOoCQVtmbxye59v2HracbBF3Bv9pT OoGMkZG3N5uz/aUMy/+GOFPp4x8UCJ2alBHMSeWTzGaRZqblYE1InQVZ/C6Bny5KE3OBNK+qCr3Kp CXYF68OrwRngnDacuFaQoTiFA5YZVMmI2ajYI+Y+73CujhbBJo7v2TKXpY55FL+BI4PmU7FW7QkhH o691ed1Qw==; Received: from us01smtprelay-2.synopsys.com ([198.182.60.111] helo=smtprelay.synopsys.com) by casper.infradead.org with esmtps (Exim 4.87 #1 (Red Hat Linux)) id 1cgAEH-0007Co-4q for linux-snps-arc@lists.infradead.org; Tue, 21 Feb 2017 13:11:45 +0000 Received: from mailhost.synopsys.com (mailhost1.synopsys.com [10.12.238.239]) by smtprelay.synopsys.com (Postfix) with ESMTP id A28F310C1621; Tue, 21 Feb 2017 05:11:14 -0800 (PST) Received: from mailhost.synopsys.com (localhost [127.0.0.1]) by mailhost.synopsys.com (Postfix) with ESMTP id 54F504B8; Tue, 21 Feb 2017 05:11:14 -0800 (PST) Received: from vzakhar-8460.internal.synopsys.com (vzakhar-8460.internal.synopsys.com [10.121.8.100]) by mailhost.synopsys.com (Postfix) with ESMTP id 931CD46D; Tue, 21 Feb 2017 05:11:11 -0800 (PST) From: Vlad Zakharov To: linux-clk@vger.kernel.org Subject: [PATCH v2] clk/axs10x: introduce AXS10X pll driver Date: Tue, 21 Feb 2017 16:11:10 +0300 Message-Id: <1487682670-4164-1-git-send-email-vzakhar@synopsys.com> X-Mailer: git-send-email 2.7.4 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20170221_131141_471975_5D4ADDC1 X-CRM114-Status: GOOD ( 29.24 ) X-Spam-Score: -1.9 (-) X-Spam-Report: SpamAssassin version 3.4.1 on casper.infradead.org summary: Content analysis details: (-1.9 points, 5.0 required) pts rule name description ---- ---------------------- -------------------------------------------------- -0.0 RCVD_IN_DNSWL_NONE RBL: Sender listed at http://www.dnswl.org/, no trust [198.182.60.111 listed in list.dnswl.org] -0.0 RCVD_IN_MSPIKE_H3 RBL: Good reputation (+3) [198.182.60.111 listed in wl.mailspike.net] -0.0 RP_MATCHES_RCVD Envelope sender domain matches handover relay domain -1.9 BAYES_00 BODY: Bayes spam probability is 0 to 1% [score: 0.0000] -0.0 RCVD_IN_MSPIKE_WL Mailspike good senders X-BeenThere: linux-snps-arc@lists.infradead.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: Linux on Synopsys ARC Processors List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Jose Abreu , devicetree@vger.kernel.org, Rob Herring , Michael Turquette , Stephen Boyd , linux-kernel@vger.kernel.org, Vlad Zakharov , Mark Rutland , linux-snps-arc@lists.infradead.org MIME-Version: 1.0 Sender: "linux-snps-arc" Errors-To: linux-snps-arc-bounces+incoming=patchwork.ozlabs.org@lists.infradead.org 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. Acked-by: Rob Herring Signed-off-by: Vlad Zakharov Signed-off-by: Jose Abreu Cc: Michael Turquette Cc: Stephen Boyd Cc: Mark Rutland --- Cc: Rob Herring Changes v1..v2 - Replace '_' with '-' in device tree nodes .../devicetree/bindings/clock/snps,pll-clock.txt | 28 ++ MAINTAINERS | 6 + drivers/clk/axs10x/Makefile | 1 + drivers/clk/axs10x/pll_clock.c | 384 +++++++++++++++++++++ 4 files changed, 419 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..5706246 --- /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--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 3960e7f..5805833 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -11910,6 +11910,12 @@ F: arch/arc/plat-axs10x F: arch/arc/boot/dts/ax* F: Documentation/devicetree/bindings/arc/axs10* +SYNOPSYS ARC SDP clock driver +M: Vlad Zakharov +S: Supported +F: drivers/clk/axs10x/* +F: Documentation/devicetree/bindings/clock/snps,pll-clock.txt + SYSTEM CONFIGURATION (SYSCON) M: Lee Jones M: Arnd Bergmann 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..784a0a2 --- /dev/null +++ b/drivers/clk/axs10x/pll_clock.c @@ -0,0 +1,384 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* 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 detirmine the way of access to these registers + * They should be set up only using the macros. + * reg should be and uint32_t 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 0x1 +#define PLL_MAX_LOCK_TIME 100 /* 100 us */ + +struct pll_cfg { + u32 rate; + u32 idiv; + u32 fbdiv; + u32 odiv; +}; + +struct pll_of_table { + unsigned long prate; + struct pll_cfg *pll_cfg_table; +}; + +struct pll_of_data { + struct pll_of_table *pll_table; +}; + +static struct pll_of_data pgu_pll_data = { + .pll_table = (struct pll_of_table []){ + { + .prate = 27000000, + .pll_cfg_table = (struct pll_cfg []){ + { 25200000, 1, 84, 90 }, + { 50000000, 1, 100, 54 }, + { 74250000, 1, 44, 16 }, + { }, + }, + }, + /* Used as list limiter */ + { }, + }, +}; + +static struct pll_of_data arc_pll_data = { + .pll_table = (struct pll_of_table []){ + { + .prate = 33333333, + .pll_cfg_table = (struct 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 }, + { }, + }, + }, + /* Used as list limiter */ + { }, + }, +}; + +struct pll_clk { + void __iomem *base; + void __iomem *lock; + const struct pll_of_data *pll_data; + struct clk_hw hw; + struct device *dev; +}; + +static inline void pll_write(struct pll_clk *clk, unsigned int reg, + unsigned int val) +{ + iowrite32(val, clk->base + reg); +} + +static inline u32 pll_read(struct pll_clk *clk, + unsigned int reg) +{ + return ioread32(clk->base + reg); +} + +static inline struct pll_clk *to_pll_clk(struct clk_hw *hw) +{ + return container_of(hw, struct pll_clk, hw); +} + +static inline u32 div_get_value(unsigned int reg) +{ + if (PLL_REG_GET_BYPASS(reg)) + return 1; + + return (PLL_REG_GET_HIGH(reg) + PLL_REG_GET_LOW(reg)); +} + +static inline u32 encode_div(unsigned int id, int upd) +{ + uint32_t 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 const struct pll_cfg *pll_get_cfg(unsigned long prate, + const struct pll_of_table *pll_table) +{ + int i; + + for (i = 0; pll_table[i].prate != 0; i++) + if (pll_table[i].prate == prate) + return pll_table[i].pll_cfg_table; + + return NULL; +} + +static unsigned long pll_recalc_rate(struct clk_hw *hw, + unsigned long parent_rate) +{ + u64 rate; + u32 idiv, fbdiv, odiv; + struct pll_clk *clk = to_pll_clk(hw); + + idiv = div_get_value(pll_read(clk, PLL_REG_IDIV)); + fbdiv = div_get_value(pll_read(clk, PLL_REG_FBDIV)); + odiv = div_get_value(pll_read(clk, PLL_REG_ODIV)); + + rate = (u64)parent_rate * fbdiv; + do_div(rate, idiv * odiv); + + return (unsigned long)rate; +} + +static long pll_round_rate(struct clk_hw *hw, unsigned long rate, + unsigned long *prate) +{ + int i; + long best_rate; + struct pll_clk *clk = to_pll_clk(hw); + const struct pll_cfg *pll_cfg = pll_get_cfg(*prate, + clk->pll_data->pll_table); + + if (!pll_cfg) { + dev_err(clk->dev, "invalid parent rate=%ld\n", *prate); + return -EINVAL; + } + + 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 pll_set_rate(struct clk_hw *hw, unsigned long rate, + unsigned long parent_rate) +{ + int i; + struct pll_clk *clk = to_pll_clk(hw); + const struct pll_cfg *pll_cfg = pll_get_cfg(parent_rate, + clk->pll_data->pll_table); + + if (!pll_cfg) { + dev_err(clk->dev, "invalid parent rate=%ld\n", parent_rate); + return -EINVAL; + } + + for (i = 0; pll_cfg[i].rate != 0; i++) { + if (pll_cfg[i].rate == rate) { + pll_write(clk, PLL_REG_IDIV, + encode_div(pll_cfg[i].idiv, 0)); + pll_write(clk, PLL_REG_FBDIV, + encode_div(pll_cfg[i].fbdiv, 0)); + pll_write(clk, PLL_REG_ODIV, + encode_div(pll_cfg[i].odiv, 1)); + + /* + * Wait until CGU relocks. + * If after timeout CGU is unlocked yet return error + */ + udelay(PLL_MAX_LOCK_TIME); + if (ioread32(clk->lock) & PLL_LOCK) + return 0; + else + return -ETIMEDOUT; + } + } + + dev_err(clk->dev, "invalid rate=%ld, parent_rate=%ld\n", rate, + parent_rate); + return -EINVAL; +} + +static const struct clk_ops pll_ops = { + .recalc_rate = pll_recalc_rate, + .round_rate = pll_round_rate, + .set_rate = pll_set_rate, +}; + +static int pll_clk_probe(struct platform_device *pdev) +{ + struct device *dev = &pdev->dev; + const char *parent_name; + struct clk *clk; + struct pll_clk *pll_clk; + struct resource *mem; + struct clk_init_data init = { }; + + 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->base); + + init.name = dev->of_node->name; + init.ops = &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_data = of_device_get_match_data(dev); + + if (!pll_clk->pll_data) { + dev_err(dev, "No OF match data provided\n"); + return -EINVAL; + } + + clk = devm_clk_register(dev, &pll_clk->hw); + if (IS_ERR(clk)) { + dev_err(dev, "failed to register %s clock (%ld)\n", + init.name, PTR_ERR(clk)); + return PTR_ERR(clk); + } + + return of_clk_add_provider(dev->of_node, of_clk_src_simple_get, clk); +} + +static int pll_clk_remove(struct platform_device *pdev) +{ + of_clk_del_provider(pdev->dev.of_node); + return 0; +} + +static void __init of_pll_clk_setup(struct device_node *node) +{ + const char *parent_name; + struct clk *clk; + struct pll_clk *pll_clk; + struct clk_init_data init = { }; + + 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"); + iounmap(pll_clk->base); + return; + } + + pll_clk->lock = of_iomap(node, 1); + if (!pll_clk->lock) { + pr_err("failed to map pll lock register\n"); + iounmap(pll_clk->lock); + return; + } + + init.name = node->name; + init.ops = &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_data = &arc_pll_data; + + clk = clk_register(NULL, &pll_clk->hw); + if (IS_ERR(clk)) { + pr_err("failed to register %s clock (%ld)\n", + node->name, PTR_ERR(clk)); + kfree(pll_clk); + return; + } + + of_clk_add_provider(node, of_clk_src_simple_get, clk); +} + +CLK_OF_DECLARE(axs10x_pll_clock, "snps,axs10x-arc-pll-clock", of_pll_clk_setup); + +static const struct of_device_id pll_clk_id[] = { + { .compatible = "snps,axs10x-arc-pll-clock", .data = &arc_pll_data}, + { .compatible = "snps,axs10x-pgu-pll-clock", .data = &pgu_pll_data}, + { }, +}; +MODULE_DEVICE_TABLE(of, pll_clk_id); + +static struct platform_driver pll_clk_driver = { + .driver = { + .name = "axs10x-pll-clock", + .of_match_table = pll_clk_id, + }, + .probe = pll_clk_probe, + .remove = pll_clk_remove, +}; +builtin_platform_driver(pll_clk_driver); + +MODULE_AUTHOR("Vlad Zakharov "); +MODULE_DESCRIPTION("Synopsys AXS10X SDP Generic PLL Clock Driver"); +MODULE_LICENSE("GPL v2");