From patchwork Fri Jun 12 08:41:57 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Georgi Djakov X-Patchwork-Id: 49819 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-lb0-f197.google.com (mail-lb0-f197.google.com [209.85.217.197]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id 7894B20C81 for ; Fri, 12 Jun 2015 08:42:49 +0000 (UTC) Received: by lbcak1 with SMTP id ak1sf7949549lbc.2 for ; Fri, 12 Jun 2015 01:42:48 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:mime-version:delivered-to:from:to:cc:subject :date:message-id:in-reply-to:references:sender:precedence:list-id :x-original-sender:x-original-authentication-results:mailing-list :list-post:list-help:list-archive:list-unsubscribe; bh=qG0sTbU/PDORyLwxnYVuUKfkcgibYGV1JQ92ZNQeuYM=; b=mJf4ZwrgOeGXW6gi7ZR0uq4Gh+0kvcgNQHS/E29V4T9yuDnMDOb3MNllu4Lep7JhRg 4h+VbDxUojSpr1NK7ed8RFJuPJ2rzHcKA2CZVB1qra9kZM8LIIuBQZ3892WcZPpZiPmS 0cYnzCE1/iwo50T//vquYtp1YHsuc2d42qYDsOZZOyeBTGei+YhLtQc7GcaI8IppUY7e rvbF+SkumT9fH90RQH+pvSxq2TraZ8a8atP4/fcoiwAZ0toDTFxz8NXPc4VhAIJsax7v f9/VNaJeWYSo0hAyvQ3uAitq/44QAj0iTTAmVLHcsQ2DMCfeM+QBhy//7GnD7Hou6hnv WeqA== X-Gm-Message-State: ALoCoQmvWwLjhsOmZ3FgWRJg0RJ2YKXd1iGDNGFwIuVK9HXhgEviMxtgVr6bo5fZEFSwbsMcAD27 X-Received: by 10.112.203.168 with SMTP id kr8mr13269506lbc.10.1434098568417; Fri, 12 Jun 2015 01:42:48 -0700 (PDT) MIME-Version: 1.0 X-BeenThere: patchwork-forward@linaro.org Received: by 10.152.6.202 with SMTP id d10ls371506laa.69.gmail; Fri, 12 Jun 2015 01:42:48 -0700 (PDT) X-Received: by 10.112.161.40 with SMTP id xp8mr13879096lbb.71.1434098568135; Fri, 12 Jun 2015 01:42:48 -0700 (PDT) Received: from mail-la0-f50.google.com (mail-la0-f50.google.com. [209.85.215.50]) by mx.google.com with ESMTPS id og4si2853958lbb.10.2015.06.12.01.42.48 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Fri, 12 Jun 2015 01:42:48 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.215.50 as permitted sender) client-ip=209.85.215.50; Received: by lazv15 with SMTP id v15so17298532laz.3 for ; Fri, 12 Jun 2015 01:42:48 -0700 (PDT) X-Received: by 10.112.209.106 with SMTP id ml10mr13813020lbc.112.1434098568001; Fri, 12 Jun 2015 01:42:48 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.112.108.230 with SMTP id hn6csp385100lbb; Fri, 12 Jun 2015 01:42:46 -0700 (PDT) X-Received: by 10.66.156.198 with SMTP id wg6mr21472499pab.126.1434098566657; Fri, 12 Jun 2015 01:42:46 -0700 (PDT) Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id bz4si4396041pab.196.2015.06.12.01.42.43; Fri, 12 Jun 2015 01:42:46 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753081AbbFLImj (ORCPT + 29 others); Fri, 12 Jun 2015 04:42:39 -0400 Received: from mail-wg0-f53.google.com ([74.125.82.53]:33316 "EHLO mail-wg0-f53.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751166AbbFLIma (ORCPT ); Fri, 12 Jun 2015 04:42:30 -0400 Received: by wgez8 with SMTP id z8so19563975wge.0 for ; Fri, 12 Jun 2015 01:42:29 -0700 (PDT) X-Received: by 10.194.85.116 with SMTP id g20mr24534881wjz.154.1434098549457; Fri, 12 Jun 2015 01:42:29 -0700 (PDT) Received: from mms.wifi.mm-sol.com ([37.157.136.206]) by mx.google.com with ESMTPSA id 12sm4751195wjw.17.2015.06.12.01.42.28 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Fri, 12 Jun 2015 01:42:28 -0700 (PDT) From: Georgi Djakov To: sboyd@codeaurora.org, agross@codeaurora.org Cc: mturquette@linaro.org, linux-clk@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-msm@vger.kernel.org Subject: [PATCH 3/5] clk: qcom: Add support for regmap mux-div clocks Date: Fri, 12 Jun 2015 11:41:57 +0300 Message-Id: <1434098519-26406-4-git-send-email-georgi.djakov@linaro.org> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: <1434098519-26406-1-git-send-email-georgi.djakov@linaro.org> References: <1434098519-26406-1-git-send-email-georgi.djakov@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: list List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-Removed-Original-Auth: Dkim didn't pass. X-Original-Sender: georgi.djakov@linaro.org X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.215.50 as permitted sender) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org Mailing-list: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org X-Google-Group-Id: 836684582541 List-Post: , List-Help: , List-Archive: List-Unsubscribe: , Add support for hardware that support switching both parent clocks and the divider at the same time. This avoids generating intermediate frequencies from either the old parent clock and new divider or new parent clock and old divider combinations. Signed-off-by: Georgi Djakov --- drivers/clk/qcom/Makefile | 1 + drivers/clk/qcom/clk-regmap-mux-div.c | 297 +++++++++++++++++++++++++++++++++ drivers/clk/qcom/clk-regmap-mux-div.h | 63 +++++++ 3 files changed, 361 insertions(+) create mode 100644 drivers/clk/qcom/clk-regmap-mux-div.c create mode 100644 drivers/clk/qcom/clk-regmap-mux-div.h -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/ diff --git a/drivers/clk/qcom/Makefile b/drivers/clk/qcom/Makefile index 50b337a24a87..38b02a7f2da3 100644 --- a/drivers/clk/qcom/Makefile +++ b/drivers/clk/qcom/Makefile @@ -8,6 +8,7 @@ clk-qcom-y += clk-rcg2.o clk-qcom-y += clk-branch.o clk-qcom-y += clk-regmap-divider.o clk-qcom-y += clk-regmap-mux.o +clk-qcom-y += clk-regmap-mux-div.o clk-qcom-y += reset.o obj-$(CONFIG_APQ_GCC_8084) += gcc-apq8084.o diff --git a/drivers/clk/qcom/clk-regmap-mux-div.c b/drivers/clk/qcom/clk-regmap-mux-div.c new file mode 100644 index 000000000000..fe4664d8bcf3 --- /dev/null +++ b/drivers/clk/qcom/clk-regmap-mux-div.c @@ -0,0 +1,297 @@ +/* + * Copyright (c) 2015, Linaro Limited + * Copyright (c) 2014, The Linux Foundation. All rights reserved. + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#include +#include +#include +#include +#include + +#include "clk-regmap-mux-div.h" + +#define CMD_RCGR 0x0 +#define CMD_RCGR_UPDATE BIT(0) +#define CMD_RCGR_DIRTY_CFG BIT(4) +#define CMD_RCGR_ROOT_OFF BIT(31) +#define CFG_RCGR 0x4 + +static int __mux_div_update_config(struct clk_regmap_mux_div *md) +{ + int ret; + u32 val, count; + const char *name = __clk_get_name(md->clkr.hw.clk); + + ret = regmap_update_bits(md->clkr.regmap, CMD_RCGR + md->reg_offset, + CMD_RCGR_UPDATE, CMD_RCGR_UPDATE); + if (ret) + return ret; + + /* Wait for update to take effect */ + for (count = 500; count > 0; count--) { + ret = regmap_read(md->clkr.regmap, CMD_RCGR + md->reg_offset, + &val); + if (ret) + return ret; + if (!(val & CMD_RCGR_UPDATE)) + return 0; + udelay(1); + } + + pr_err("%s: rcg did not update its configuration.", name); + return -EBUSY; +} + +static int __mux_div_set_src_div(struct clk_regmap_mux_div *md, u32 src_sel, + u32 src_div) +{ + int ret; + u32 val, mask; + + val = (src_div << md->hid_shift) | (src_sel << md->src_shift); + mask = ((BIT(md->hid_width) - 1) << md->hid_shift) | + ((BIT(md->src_width) - 1) << md->src_shift); + + ret = regmap_update_bits(md->clkr.regmap, CFG_RCGR + md->reg_offset, + mask, val); + if (ret) + return ret; + + ret = __mux_div_update_config(md); + return ret; +} + +static void __mux_div_get_src_div(struct clk_regmap_mux_div *md, u32 *src_sel, + u32 *src_div) +{ + u32 val, div, src; + const char *name = __clk_get_name(md->clkr.hw.clk); + + regmap_read(md->clkr.regmap, CMD_RCGR + md->reg_offset, &val); + + if (val & CMD_RCGR_DIRTY_CFG) { + pr_err("%s: rcg configuration is pending.\n", name); + return; + } + + regmap_read(md->clkr.regmap, CFG_RCGR + md->reg_offset, &val); + src = (val >> md->src_shift); + src &= BIT(md->src_width) - 1; + *src_sel = src; + + div = (val >> md->hid_shift); + div &= BIT(md->hid_width) - 1; + *src_div = div; +} + +static int mux_div_enable(struct clk_hw *hw) +{ + struct clk_regmap_mux_div *md = to_clk_regmap_mux_div(hw); + + return __mux_div_set_src_div(md, md->src_sel, md->div); +} + +static inline bool is_better_rate(unsigned long req, unsigned long best, + unsigned long new) +{ + return (req <= new && new < best) || (best < req && best < new); +} + +static long mux_div_determine_rate(struct clk_hw *hw, unsigned long rate, + unsigned long min_rate, + unsigned long max_rate, + unsigned long *best_parent_rate, + struct clk_hw **best_parent_hw) +{ + struct clk_regmap_mux_div *md = to_clk_regmap_mux_div(hw); + unsigned int i, div, max_div; + unsigned long actual_rate, rrate = 0; + + for (i = 0; i < __clk_get_num_parents(hw->clk); i++) { + struct clk *parent = clk_get_parent_by_index(hw->clk, i); + unsigned long parent_rate = __clk_get_rate(parent); + + max_div = BIT(md->hid_width) - 1; + for (div = 1; div < max_div; div++) { + parent_rate = mult_frac(rate, div, 2); + parent_rate = __clk_round_rate(parent, parent_rate); + actual_rate = mult_frac(parent_rate, 2, div); + + if (is_better_rate(rate, rrate, actual_rate)) { + rrate = actual_rate; + *best_parent_rate = parent_rate; + *best_parent_hw = __clk_get_hw(parent); + } + + if (actual_rate < rate || rrate <= rate) + break; + } + } + + if (!rrate) + return -EINVAL; + + return rrate; +} + +static int __mux_div_set_rate_and_parent(struct clk_hw *hw, unsigned long rate, + unsigned long prate, u32 src_sel) +{ + struct clk_regmap_mux_div *md = to_clk_regmap_mux_div(hw); + int ret, i; + u32 div, max_div, best_src = 0, best_div = 0; + unsigned long actual_rate = 0, rrate = 0; + + for (i = 0; i < __clk_get_num_parents(hw->clk); i++) { + struct clk *parent = clk_get_parent_by_index(hw->clk, i); + unsigned long parent_rate = __clk_get_rate(parent); + + max_div = BIT(md->hid_width) - 1; + for (div = 1; div < max_div; div++) { + parent_rate = mult_frac(rate, div, 2); + parent_rate = __clk_round_rate(parent, parent_rate); + actual_rate = mult_frac(parent_rate, 2, div); + + if (is_better_rate(rate, rrate, actual_rate)) { + rrate = actual_rate; + best_src = md->parent_map[i].cfg; + best_div = div - 1; + } + + if (actual_rate < rate || rrate <= rate) + break; + } + } + + ret = __mux_div_set_src_div(md, best_src, best_div); + if (!ret) { + md->div = best_div; + md->src_sel = best_src; + } + + return ret; +} + +static u8 mux_div_get_parent(struct clk_hw *hw) +{ + struct clk_regmap_mux_div *md = to_clk_regmap_mux_div(hw); + int num_parents = __clk_get_num_parents(hw->clk); + const char *name = __clk_get_name(hw->clk); + u32 i, div, src; + + __mux_div_get_src_div(md, &src, &div); + + for (i = 0; i < num_parents; i++) + if (src == md->parent_map[i].cfg) + return i; + + pr_err("%s: Can't find parent %d\n", name, src); + return 0; +} + +static int mux_div_set_parent(struct clk_hw *hw, u8 index) +{ + struct clk_regmap_mux_div *md = to_clk_regmap_mux_div(hw); + + return __mux_div_set_src_div(md, md->parent_map[index].cfg, md->div); +} + +static int mux_div_set_rate(struct clk_hw *hw, + unsigned long rate, unsigned long prate) +{ + struct clk_regmap_mux_div *md = to_clk_regmap_mux_div(hw); + u8 pindex = mux_div_get_parent(hw); + struct clk *parent = clk_get_parent_by_index(hw->clk, pindex); + unsigned long current_prate = __clk_get_rate(parent); + + if (rate > current_prate) + return -EINVAL; + + return __mux_div_set_rate_and_parent(hw, rate, prate, md->src_sel); +} + +static int mux_div_set_rate_and_parent(struct clk_hw *hw, unsigned long rate, + unsigned long prate, u8 index) +{ + struct clk_regmap_mux_div *md = to_clk_regmap_mux_div(hw); + + return __mux_div_set_rate_and_parent(hw, rate, prate, + md->parent_map[index].cfg); +} + +static unsigned long mux_div_recalc_rate(struct clk_hw *hw, unsigned long prate) +{ + struct clk_regmap_mux_div *md = to_clk_regmap_mux_div(hw); + u32 div, src; + int i, num_parents = __clk_get_num_parents(hw->clk); + const char *name = __clk_get_name(hw->clk); + + __mux_div_get_src_div(md, &src, &div); + for (i = 0; i < num_parents; i++) + if (src == md->parent_map[i].cfg) { + struct clk *p = clk_get_parent_by_index(hw->clk, i); + unsigned long parent_rate = __clk_get_rate(p); + + return mult_frac(parent_rate, 2, div + 1); + } + + pr_err("%s: Can't find parent %d\n", name, src); + return 0; +} + +static struct clk_hw *mux_div_get_safe_parent(struct clk_hw *hw, + unsigned long *safe_freq) +{ + int i; + struct clk_regmap_mux_div *md = to_clk_regmap_mux_div(hw); + int num_parents = __clk_get_num_parents(hw->clk); + + if (md->safe_freq) + *safe_freq = md->safe_freq; + + for (i = 0; i < num_parents; i++) + if (md->safe_src == md->parent_map[i].cfg) + break; + + return __clk_get_hw(clk_get_parent_by_index(hw->clk, i)); +} + +static void mux_div_disable(struct clk_hw *hw) +{ + struct clk_regmap_mux_div *md = to_clk_regmap_mux_div(hw); + struct clk_hw *parent; + u32 div; + + if (!md->safe_freq || !md->safe_src) + return; + + parent = mux_div_get_safe_parent(hw, &md->safe_freq); + div = divider_get_val(md->safe_freq, clk_get_rate(parent->clk), NULL, + md->hid_width, CLK_DIVIDER_ROUND_CLOSEST); + div = 2 * div + 1; + + __mux_div_set_src_div(md, md->safe_src, div); +} + +const struct clk_ops clk_regmap_mux_div_ops = { + .enable = mux_div_enable, + .disable = mux_div_disable, + .get_parent = mux_div_get_parent, + .set_parent = mux_div_set_parent, + .set_rate = mux_div_set_rate, + .set_rate_and_parent = mux_div_set_rate_and_parent, + .determine_rate = mux_div_determine_rate, + .recalc_rate = mux_div_recalc_rate, + .get_safe_parent = mux_div_get_safe_parent, +}; +EXPORT_SYMBOL_GPL(clk_regmap_mux_div_ops); diff --git a/drivers/clk/qcom/clk-regmap-mux-div.h b/drivers/clk/qcom/clk-regmap-mux-div.h new file mode 100644 index 000000000000..b887a900ad89 --- /dev/null +++ b/drivers/clk/qcom/clk-regmap-mux-div.h @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2015, Linaro Limited + * Copyright (c) 2014, The Linux Foundation. All rights reserved. + * + * This software is licensed under the terms of the GNU General Public + * License version 2, as published by the Free Software Foundation, and + * may be copied, distributed, and modified under those terms. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + */ + +#ifndef __QCOM_CLK_REGMAP_MUX_DIV_H__ +#define __QCOM_CLK_REGMAP_MUX_DIV_H__ + +#include +#include "clk-regmap.h" +#include "clk-rcg.h" + +/** + * struct mux_div_clk - combined mux/divider clock + * @reg_offset: offset of the mux/divider register + * @hid_width: number of bits in half integer divider + * @hid_shift: lowest bit of hid value field + * @src_width: number of bits in source select + * @src_shift: lowest bit of source select field + * @div: the divider configuration value + * @src_sel: the mux index which will be used if the clock is enabled + * @safe_src: value for safe source + * @safe_freq: When switching rates from A to B, the mux div clock will + * instead switch from A -> safe_freq -> B. This allows the + * mux_div clock to change rates while enabled, even if this + * behavior is not supported by the parent clocks. + * If changing the rate of parent A also causes the rate of + * parent B to change, then safe_freq must be defined. + * safe_freq is expected to have a source clock which is always + * on and runs at only one rate. + * @parent_map: pointer to parent_map struct + * @clkr: handle between common and hardware-specific interfaces + */ + +struct clk_regmap_mux_div { + u32 reg_offset; + u32 hid_width; + u32 hid_shift; + u32 src_width; + u32 src_shift; + u32 div; + u32 src_sel; + u32 safe_src; + unsigned long safe_freq; + const struct parent_map *parent_map; + struct clk_regmap clkr; +}; + +#define to_clk_regmap_mux_div(_hw) \ + container_of(to_clk_regmap(_hw), struct clk_regmap_mux_div, clkr) + +extern const struct clk_ops clk_regmap_mux_div_ops; + +#endif