From patchwork Thu Mar 26 11:13:38 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Leo Yan X-Patchwork-Id: 6097641 Return-Path: X-Original-To: patchwork-linux-arm@patchwork.kernel.org Delivered-To: patchwork-parsemail@patchwork1.web.kernel.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.136]) by patchwork1.web.kernel.org (Postfix) with ESMTP id 920A19F350 for ; Thu, 26 Mar 2015 11:18:50 +0000 (UTC) Received: from mail.kernel.org (localhost [127.0.0.1]) by mail.kernel.org (Postfix) with ESMTP id 5CCF7203EC for ; Thu, 26 Mar 2015 11:18:49 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.9]) (using TLSv1.2 with cipher DHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 213192024C for ; Thu, 26 Mar 2015 11:18:48 +0000 (UTC) Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.80.1 #2 (Red Hat Linux)) id 1Yb5lW-0000sV-68; Thu, 26 Mar 2015 11:15:58 +0000 Received: from mail-pa0-f52.google.com ([209.85.220.52]) by bombadil.infradead.org with esmtps (Exim 4.80.1 #2 (Red Hat Linux)) id 1Yb5kL-0007JZ-0u for linux-arm-kernel@lists.infradead.org; Thu, 26 Mar 2015 11:14:47 +0000 Received: by pacwe9 with SMTP id we9so60066015pac.1 for ; Thu, 26 Mar 2015 04:14:24 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=1qOlj1ri6faxjO+n408l5hrosYMVyQN0dZFrYvHkx5U=; b=AxADwaVyXB2mJuIwzUyaQ0aTNoT7HXs5B+GFpKMQlAjztKfZwe9DXz1eWknEZ655E1 aaYVRGBieobx9YgeJEggglQq5tDyKC2+Iqq5r0QWnd5k3mYuZm0KlGS0Nx8JVF+mpgy8 Pm3daEUpEyjxQ37zrYnt4L6eo6AoCXI2Eys5vwQpAH38bFgO/+gy/sQohPw5/Sh/UYQS z3FNQOaaneRRSTHGzIxvphPhYXjhxbHf5OjcuWUGQo6Q3GD8a6FmnBt8BUN6wEVq2zpk Mc1kYJVGdcA4TMGwHus4ymtlJRfhD9EQBjCEbo0pgSkDQdA77nHpL9T9/3vLulhM7K6F i5yA== X-Gm-Message-State: ALoCoQlNuMlMwxUN06os1Q70mArKFqFfyNg74WrFylhUeOl+jEgwIKXHQPSkjl5jKrY7kI2TBV+8 X-Received: by 10.70.30.225 with SMTP id v1mr25928933pdh.104.1427368463992; Thu, 26 Mar 2015 04:14:23 -0700 (PDT) Received: from localhost.localdomain ([211.79.119.21]) by mx.google.com with ESMTPSA id wg9sm1875069pab.17.2015.03.26.04.14.19 (version=TLSv1.2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Thu, 26 Mar 2015 04:14:23 -0700 (PDT) From: Leo Yan To: Wei Xu , Dan Zhao , zhenwei.wang@hisilicon.com, Haojian Zhuang , Bintian Wang , mturquette@linaro.org, linux-arm-kernel@lists.infradead.org, devicetree@vger.kernel.org Subject: [PATCH 3/4] clk: hisi: add stub clk driver Date: Thu, 26 Mar 2015 19:13:38 +0800 Message-Id: <1427368419-22222-4-git-send-email-leo.yan@linaro.org> X-Mailer: git-send-email 1.9.1 In-Reply-To: <1427368419-22222-1-git-send-email-leo.yan@linaro.org> References: <1427368419-22222-1-git-send-email-leo.yan@linaro.org> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20150326_041445_174715_F71445DF X-CRM114-Status: GOOD ( 20.82 ) X-Spam-Score: -0.7 (/) Cc: Leo Yan X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.18-1 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patchwork-linux-arm=patchwork.kernel.org@lists.infradead.org X-Spam-Status: No, score=-4.2 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_MED, T_RP_MATCHES_RCVD, UNPARSEABLE_RELAY autolearn=unavailable version=3.3.1 X-Spam-Checker-Version: SpamAssassin 3.3.1 (2010-03-16) on mail.kernel.org X-Virus-Scanned: ClamAV using ClamSMTP On hisilicon platform, there have some clocks which can directly send messages to power controller to change frequency; this includes cpu and ddr's clocks. For dynamic frequency scaling, firstly need write the frequency value to sram region, and then write the communication register to trigger power controller to run the state machine. These two part's addresses are different and will be shared w/t other module; so use syscon APIs to pass these two memory region and accessing related registers. This init driver will support cpu frequency change firstly. Signed-off-by: Leo Yan --- drivers/clk/hisilicon/Makefile | 2 +- drivers/clk/hisilicon/clk-stub.c | 284 ++++++++++++++++++++++++++++ drivers/clk/hisilicon/clk.h | 3 + include/dt-bindings/clock/hisi,stub-clock.h | 26 +++ 4 files changed, 314 insertions(+), 1 deletion(-) create mode 100644 drivers/clk/hisilicon/clk-stub.c create mode 100644 include/dt-bindings/clock/hisi,stub-clock.h diff --git a/drivers/clk/hisilicon/Makefile b/drivers/clk/hisilicon/Makefile index 038c02f..fb26ac8 100644 --- a/drivers/clk/hisilicon/Makefile +++ b/drivers/clk/hisilicon/Makefile @@ -2,7 +2,7 @@ # Hisilicon Clock specific Makefile # -obj-y += clk.o clkgate-separated.o +obj-y += clk.o clkgate-separated.o clk-stub.o obj-$(CONFIG_ARCH_HI3xxx) += clk-hi3620.o obj-$(CONFIG_ARCH_HIP04) += clk-hip04.o diff --git a/drivers/clk/hisilicon/clk-stub.c b/drivers/clk/hisilicon/clk-stub.c new file mode 100644 index 0000000..897d6d3 --- /dev/null +++ b/drivers/clk/hisilicon/clk-stub.c @@ -0,0 +1,284 @@ +/* + * Hisilicon stub clock driver + * + * Copyright (c) 2015 Hisilicon Limited. + * Copyright (c) 2015 Linaro Limited. + * + * Author: Leo Yan + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + * + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +/* CPU dynamic frequency scaling */ +#define ACPU_DFS_FREQ_MAX (0x1724) +#define ACPU_DFS_FLAG (0x1AF4) +#define ACPU_DFS_FREQ_REQ (0x1AF8) +#define ACPU_DFS_FREQ_LMT (0x1AFC) + +#define ACPU_DFS_LOCK_FLAG (0xAEAEAEAE) + +/* Multi-core communication */ +#define MC_CORE_ACPU 0x2 +#define MC_COM_CPU_RAW_INT_OFFSET(i) (0x400 + (i << 4)) +#define MC_COM_INT_ACPU_DFS 15 + +#define to_stub_clk(hw) container_of(hw, struct hisi_stub_clk, hw) + +struct hisi_stub_clk { + struct clk_hw hw; + + /* + * hi6220: + * - 0: A53; 1: A53; 2: gpu; 3: ddr; + */ + u32 id; + u32 rate; + spinlock_t *lock; +}; + +static int initialized_stub_clk = 0; +static struct regmap *mc_map = NULL; +static struct regmap *dfs_map = NULL; + +static unsigned int hisi_acpu_get_freq(void) +{ + unsigned int freq; + + regmap_read(dfs_map, ACPU_DFS_FREQ_REQ, &freq); + return freq; +} + +static int hisi_acpu_set_freq(unsigned int freq) +{ + /* set the frequency in sram */ + regmap_write(dfs_map, ACPU_DFS_FREQ_REQ, freq); + + /* send request to power controller */ + regmap_write(mc_map, MC_COM_CPU_RAW_INT_OFFSET(MC_CORE_ACPU), + (1 << MC_COM_INT_ACPU_DFS)); + return 0; +} + +static int hisi_acpu_round_freq(unsigned int freq) +{ + unsigned int limit_flag, limit_freq = UINT_MAX; + unsigned int max_freq; + + /* check the constrainted frequency */ + regmap_read(dfs_map, ACPU_DFS_FLAG, &limit_flag); + if (limit_flag == ACPU_DFS_LOCK_FLAG) + regmap_read(dfs_map, ACPU_DFS_FREQ_LMT, &limit_freq); + + /* check the supported maximum frequency */ + regmap_read(dfs_map, ACPU_DFS_FREQ_MAX, &max_freq); + + /* calculate the real maximum frequency */ + max_freq = min(max_freq, limit_freq); + + if (WARN_ON(freq > max_freq)) + freq = max_freq; + + return freq; +} + +static unsigned long hisi_stub_clk_recalc_rate(struct clk_hw *hw, + unsigned long parent_rate) +{ + u32 rate = 0; + struct hisi_stub_clk *stub_clk = to_stub_clk(hw); + unsigned long flags; + + BUG_ON(!stub_clk->lock); + + spin_lock_irqsave(stub_clk->lock, flags); + + switch (stub_clk->id) { + case HISI_STUB_ACPU0: + rate = hisi_acpu_get_freq(); + + /* convert from KHz to Hz */ + rate *= 1000; + break; + + default: + pr_err("%s: un-supported clock id %d\n", __func__, + stub_clk->id); + break; + } + + spin_unlock_irqrestore(stub_clk->lock, flags); + return rate; +} + +static int hisi_stub_clk_set_rate(struct clk_hw *hw, unsigned long rate, + unsigned long parent_rate) +{ + struct hisi_stub_clk *stub_clk = to_stub_clk(hw); + unsigned long flags; + unsigned long new_rate = rate / 1000; /* Khz */ + int ret = 0; + + BUG_ON(!stub_clk->lock); + + spin_lock_irqsave(stub_clk->lock, flags); + + switch (stub_clk->id) { + case HISI_STUB_ACPU0: + ret = hisi_acpu_set_freq(new_rate); + if (ret < 0) { + spin_unlock_irqrestore(stub_clk->lock, flags); + return ret; + } + + break; + + default: + pr_err("%s: un-supported clock id %d\n", __func__, + stub_clk->id); + break; + } + + stub_clk->rate = new_rate; + spin_unlock_irqrestore(stub_clk->lock, flags); + + pr_debug("%s: set rate=%ldKhz\n", __func__, new_rate); + return ret; +} + +static long hisi_stub_clk_round_rate(struct clk_hw *hw, unsigned long rate, + unsigned long *parent_rate) +{ + struct hisi_stub_clk *stub_clk = to_stub_clk(hw); + unsigned long flags; + unsigned long new_rate = rate / 1000; /* Khz */ + + BUG_ON(!stub_clk->lock); + + spin_lock_irqsave(stub_clk->lock, flags); + + switch (stub_clk->id) { + case HISI_STUB_ACPU0: + new_rate = hisi_acpu_round_freq(new_rate); + + /* convert from KHz to Hz */ + new_rate *= 1000; + break; + + default: + pr_err("%s: un-supported clock id %d\n", __func__, + stub_clk->id); + break; + } + + spin_unlock_irqrestore(stub_clk->lock, flags); + return new_rate; +} + +static struct clk_ops hisi_stub_clk_ops = { + .recalc_rate = hisi_stub_clk_recalc_rate, + .round_rate = hisi_stub_clk_round_rate, + .set_rate = hisi_stub_clk_set_rate, +}; + +static int hisi_stub_clk_init(struct device_node *np) +{ + int ret = 0; + int max_freq; + + dfs_map = syscon_regmap_lookup_by_phandle(np, + "hisilicon,clk-stub-sram"); + if (IS_ERR(dfs_map)) { + ret = PTR_ERR(dfs_map); + pr_err("failed to get sram regmap: %d\n", ret); + return ret; + } + + mc_map = syscon_regmap_lookup_by_phandle(np, + "hisilicon,clk-stub-mc"); + if (IS_ERR(mc_map)) { + ret = PTR_ERR(mc_map); + pr_err("failed to get multi-core comm regmap: %d\n", ret); + return ret; + } + + /* initialize buffer to zero */ + regmap_write(dfs_map, ACPU_DFS_FLAG, 0x0); + regmap_write(dfs_map, ACPU_DFS_FREQ_REQ, 0x0); + regmap_write(dfs_map, ACPU_DFS_FREQ_LMT, 0x0); + + /* At boot time, set to maximum frequency */ + regmap_read(dfs_map, ACPU_DFS_FREQ_MAX, &max_freq); + hisi_acpu_set_freq(max_freq); + + return ret; +} + +static struct clk *_register_stub_clk(struct device *dev, unsigned int id, + const char *name, const char *parent_name, unsigned long flags, + spinlock_t *lock) +{ + struct hisi_stub_clk *stub_clk; + struct clk *clk; + struct clk_init_data init; + + stub_clk = kzalloc(sizeof(*stub_clk), GFP_KERNEL); + if (!stub_clk) { + pr_err("%s: fail to alloc stub clk!\n", __func__); + return ERR_PTR(-ENOMEM); + } + + init.name = name; + init.ops = &hisi_stub_clk_ops; + init.parent_names = parent_name ? &parent_name : NULL; + init.num_parents = parent_name ? 1 : 0; + init.flags = flags; + + stub_clk->hw.init = &init; + stub_clk->id = id; + stub_clk->lock = lock; + + clk = clk_register(dev, &stub_clk->hw); + if (IS_ERR(clk)) { + pr_err("%s: fail to register stub clk %s!\n", __func__, name); + kfree(stub_clk); + } + + return clk; +} + +struct clk *hisi_register_stub_clk(struct device_node *np, + unsigned int id, const char *name, const char *parent_name, + unsigned long flags, spinlock_t *lock) +{ + int ret; + struct clk *clk; + + pr_debug("[%s]: clk name = %s...\n", __func__, name); + + if (!initialized_stub_clk) { + ret = hisi_stub_clk_init(np); + if (ret) + return ERR_PTR(-EINVAL); + + initialized_stub_clk = 1; + } + + clk = _register_stub_clk(NULL, id, name, parent_name, flags, lock); + return clk; +} diff --git a/drivers/clk/hisilicon/clk.h b/drivers/clk/hisilicon/clk.h index 624f608..e99184a 100644 --- a/drivers/clk/hisilicon/clk.h +++ b/drivers/clk/hisilicon/clk.h @@ -94,6 +94,9 @@ struct clk *hisi_register_clkgate_sep(struct device *, const char *, const char *, unsigned long, void __iomem *, u8, u8, spinlock_t *); +struct clk *hisi_register_stub_clk(struct device_node *np, + unsigned int id, const char *name, const char *parent_name, + unsigned long flags, spinlock_t *lock); struct hisi_clock_data __init *hisi_clk_init(struct device_node *, int); struct hisi_clock_data __init *hisi_clk_alloc_data(struct device_node *np, diff --git a/include/dt-bindings/clock/hisi,stub-clock.h b/include/dt-bindings/clock/hisi,stub-clock.h new file mode 100644 index 0000000..637d7f5 --- /dev/null +++ b/include/dt-bindings/clock/hisi,stub-clock.h @@ -0,0 +1,26 @@ +/* + * This header provides constants for Hisilicon stub clock driver. + * + * Copyright (c) 2015 Hisilicon Limited. + * Copyright (c) 2015 Linaro Limited. + * + * Author: Leo Yan + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#ifndef _DT_BINDINGS_HISI_STUB_CLOCK_H +#define _DT_BINDINGS_HISI_STUB_CLOCK_H + +/* Stub Clocks */ +#define HISI_STUB_ACPU0 0 +#define HISI_STUB_ACPU1 1 +#define HISI_STUB_GPU 2 +#define HISI_STUB_DDR_MIN 3 +#define HISI_STUB_DDR_MAX 4 +#define HISI_STUB_DDR 5 +#define HISI_STUB_NR_CLKS 6 + +#endif /* _DT_BINDINGS_HISI_STUB_CLOCK_H */