Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > linux.kernel > #1201665 > unrolled thread

[PATCH v5 6/7] clocksource: Add Pistachio clocksource-only driver

Back to article view | Back to linux.kernel

Contents

  [PATCH v5 6/7] clocksource: Add Pistachio clocksource-only driver Govindraj Raja <govindraj.raja@imgtec.com> - 2015-08-06 13:30 +0200
    Re: [PATCH v5 6/7] clocksource: Add Pistachio clocksource-only driver Daniel Lezcano <daniel.lezcano@linaro.org> - 2015-08-07 12:30 +0200
      RE: [PATCH v5 6/7] clocksource: Add Pistachio clocksource-only  driver Govindraj Raja <Govindraj.Raja@imgtec.com> - 2015-08-07 17:20 +0200

#1201665 — [PATCH v5 6/7] clocksource: Add Pistachio clocksource-only driver

From: Ezequiel Garcia <ezequiel.garcia@imgtec.com>

The Pistachio SoC provides four general purpose timers, and allow
to implement a clocksource driver.

This driver can be used as a replacement for the MIPS GIC and MIPS R4K
clocksources and sched clocks, which are clocked from the CPU clock.

Given the general purpose timers are clocked from an independent clock,
this new clocksource driver will be useful to introduce CPUFreq support
for Pistachio machines.

Signed-off-by: Ezequiel Garcia <ezequiel.garcia@imgtec.com>
Signed-off-by: Govindraj Raja <govindraj.raja@imgtec.com>
---

changes from v4
----------------
Fixes comments from Daniel as dicussed in below thread:
http://patchwork.linux-mips.org/patch/10784/


 drivers/clocksource/Kconfig          |   5 +
 drivers/clocksource/Makefile         |   1 +
 drivers/clocksource/time-pistachio.c | 216 +++++++++++++++++++++++++++++++++++
 3 files changed, 222 insertions(+)
 create mode 100644 drivers/clocksource/time-pistachio.c

diff --git a/drivers/clocksource/Kconfig b/drivers/clocksource/Kconfig
index 4e57730..e642825 100644
--- a/drivers/clocksource/Kconfig
+++ b/drivers/clocksource/Kconfig
@@ -111,6 +111,11 @@ config CLKSRC_LPC32XX
 	select CLKSRC_MMIO
 	select CLKSRC_OF
 
+config CLKSRC_PISTACHIO
+	bool
+	default y if MACH_PISTACHIO
+	select CLKSRC_OF
+
 config CLKSRC_STM32
 	bool "Clocksource for STM32 SoCs" if !ARCH_STM32
 	depends on OF && ARM && (ARCH_STM32 || COMPILE_TEST)
diff --git a/drivers/clocksource/Makefile b/drivers/clocksource/Makefile
index f228354..066337e 100644
--- a/drivers/clocksource/Makefile
+++ b/drivers/clocksource/Makefile
@@ -44,6 +44,7 @@ obj-$(CONFIG_FSL_FTM_TIMER)	+= fsl_ftm_timer.o
 obj-$(CONFIG_VF_PIT_TIMER)	+= vf_pit_timer.o
 obj-$(CONFIG_CLKSRC_QCOM)	+= qcom-timer.o
 obj-$(CONFIG_MTK_TIMER)		+= mtk_timer.o
+obj-$(CONFIG_CLKSRC_PISTACHIO)	+= time-pistachio.o
 
 obj-$(CONFIG_ARM_ARCH_TIMER)		+= arm_arch_timer.o
 obj-$(CONFIG_ARM_GLOBAL_TIMER)		+= arm_global_timer.o
diff --git a/drivers/clocksource/time-pistachio.c b/drivers/clocksource/time-pistachio.c
new file mode 100644
index 0000000..a2e3c5d
--- /dev/null
+++ b/drivers/clocksource/time-pistachio.c
@@ -0,0 +1,216 @@
+/*
+ * Pistachio clocksource based on general-purpose timers
+ *
+ * Copyright (C) 2015 Imagination Technologies
+ *
+ * This file is subject to the terms and conditions of the GNU General Public
+ * License. See the file "COPYING" in the main directory of this archive
+ * for more details.
+ */
+
+#define pr_fmt(fmt) "%s: " fmt, __func__
+
+#include <linux/clk.h>
+#include <linux/clocksource.h>
+#include <linux/clockchips.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <linux/mfd/syscon.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/platform_device.h>
+#include <linux/regmap.h>
+#include <linux/sched_clock.h>
+#include <linux/time.h>
+
+/* Top level reg */
+#define CR_TIMER_CTRL_CFG		0x00
+#define TIMER_ME_GLOBAL			BIT(0)
+#define CR_TIMER_REV			0x10
+
+/* Timer specific registers */
+#define TIMER_CFG			0x20
+#define TIMER_ME_LOCAL			BIT(0)
+#define TIMER_RELOAD_VALUE		0x24
+#define TIMER_CURRENT_VALUE		0x28
+#define TIMER_CURRENT_OVERFLOW_VALUE	0x2C
+#define TIMER_IRQ_STATUS		0x30
+#define TIMER_IRQ_CLEAR			0x34
+#define TIMER_IRQ_MASK			0x38
+
+#define PERIP_TIMER_CONTROL		0x90
+
+/* Timer specific configuration Values */
+#define RELOAD_VALUE			0xffffffff
+
+struct pistachio_clocksource {
+	void __iomem *base;
+	raw_spinlock_t lock;
+	struct clocksource cs;
+};
+
+struct pistachio_clocksource pcs_gpt;
+
+#define to_pistachio_clocksource(cs)	\
+	container_of(cs, struct pistachio_clocksource, cs)
+
+static inline u32 gpt_readl(void __iomem *base, u32 offset, u32 gpt_id)
+{
+	return readl(base + 0x20 * gpt_id + offset);
+}
+
+static inline void gpt_writel(void __iomem *base, u32 value, u32 offset,
+		u32 gpt_id)
+{
+	writel(value, base + 0x20 * gpt_id + offset);
+}
+
+static cycle_t pistachio_clocksource_read_cycles(struct clocksource *cs)
+{
+	struct pistachio_clocksource *pcs = to_pistachio_clocksource(cs);
+	u32 counter, overflw;
+	unsigned long flags;
+
+	/* The counter value is only refreshed after the overflow value is read.
+	 * And they must be read in strict order, hence raw spin lock added.
+	 */
+
+	raw_spin_lock_irqsave(&pcs->lock, flags);
+	overflw = gpt_readl(pcs->base, TIMER_CURRENT_OVERFLOW_VALUE, 0);
+	counter = gpt_readl(pcs->base, TIMER_CURRENT_VALUE, 0);
+	raw_spin_unlock_irqrestore(&pcs->lock, flags);
+
+	return ~(cycle_t)counter;
+}
+
+static u64 notrace pistachio_read_sched_clock(void)
+{
+	return pistachio_clocksource_read_cycles(&pcs_gpt.cs);
+}
+
+static void pistachio_clksrc_set_mode(struct clocksource *cs, int timeridx,
+			int enable)
+{
+	struct pistachio_clocksource *pcs = to_pistachio_clocksource(cs);
+	u32 val;
+
+	val = gpt_readl(pcs->base, TIMER_CFG, timeridx);
+	if (enable)
+		val |= TIMER_ME_LOCAL;
+	else
+		val &= ~TIMER_ME_LOCAL;
+
+	gpt_writel(pcs->base, val, TIMER_CFG, timeridx);
+}
+
+static void pistachio_clksrc_enable(struct clocksource *cs, int timeridx)
+{
+	struct pistachio_clocksource *pcs = to_pistachio_clocksource(cs);
+
+	/* Disable GPT local before loading reload value */
+	pistachio_clksrc_set_mode(cs, timeridx, false);
+	gpt_writel(pcs->base, RELOAD_VALUE, TIMER_RELOAD_VALUE, timeridx);
+	pistachio_clksrc_set_mode(cs, timeridx, true);
+}
+
+static void pistachio_clksrc_disable(struct clocksource *cs, int timeridx)
+{
+	/* Disable GPT local */
+	pistachio_clksrc_set_mode(cs, timeridx, false);
+}
+
+static int pistachio_clocksource_enable(struct clocksource *cs)
+{
+	pistachio_clksrc_enable(cs, 0);
+	return 0;
+}
+
+static void pistachio_clocksource_disable(struct clocksource *cs)
+{
+	pistachio_clksrc_disable(cs, 0);
+}
+
+/* Desirable clock source for pistachio platform */
+struct pistachio_clocksource pcs_gpt = {
+	.cs =	{
+		.name		= "gptimer",
+		.rating		= 300,
+		.enable		= pistachio_clocksource_enable,
+		.disable	= pistachio_clocksource_disable,
+		.read		= pistachio_clocksource_read_cycles,
+		.mask		= CLOCKSOURCE_MASK(32),
+		.flags		= CLOCK_SOURCE_IS_CONTINUOUS |
+				  CLOCK_SOURCE_SUSPEND_NONSTOP,
+		},
+};
+
+static void __init pistachio_clksrc_of_init(struct device_node *node)
+{
+	struct clk *sys_clk, *fast_clk;
+	struct regmap *periph_regs;
+	unsigned long rate;
+	int ret;
+
+	pcs_gpt.base = of_iomap(node, 0);
+	if (!pcs_gpt.base) {
+		pr_err("cannot iomap\n");
+		return;
+	}
+
+	periph_regs = syscon_regmap_lookup_by_phandle(node, "img,cr-periph");
+	if (IS_ERR(periph_regs)) {
+		pr_err("cannot get peripheral regmap (%lu)\n",
+		       PTR_ERR(periph_regs));
+		return;
+	}
+
+	/* Switch to using the fast counter clock */
+	ret = regmap_update_bits(periph_regs, PERIP_TIMER_CONTROL,
+				 0xf, 0x0);
+	if (ret)
+		return;
+
+	sys_clk = of_clk_get_by_name(node, "sys");
+	if (IS_ERR(sys_clk)) {
+		pr_err("clock get failed (%lu)\n", PTR_ERR(sys_clk));
+		return;
+	}
+
+	fast_clk = of_clk_get_by_name(node, "fast");
+	if (IS_ERR(fast_clk)) {
+		pr_err("clock get failed (%lu)\n", PTR_ERR(fast_clk));
+		return;
+	}
+
+	ret = clk_prepare_enable(sys_clk);
+	if (ret < 0) {
+		pr_err("failed to enable clock (%d)\n", ret);
+		return;
+	}
+
+	ret = clk_prepare_enable(fast_clk);
+	if (ret < 0) {
+		pr_err("failed to enable clock (%d)\n", ret);
+		clk_disable_unprepare(sys_clk);
+		return;
+	}
+
+	rate = clk_get_rate(fast_clk);
+
+	/* Disable irq's for clocksource usage */
+	gpt_writel(&pcs_gpt.base, 0, TIMER_IRQ_MASK, 0);
+	gpt_writel(&pcs_gpt.base, 0, TIMER_IRQ_MASK, 1);
+	gpt_writel(&pcs_gpt.base, 0, TIMER_IRQ_MASK, 2);
+	gpt_writel(&pcs_gpt.base, 0, TIMER_IRQ_MASK, 3);
+
+	/* Enable timer block */
+	writel(TIMER_ME_GLOBAL, pcs_gpt.base);
+
+	raw_spin_lock_init(&pcs_gpt.lock);
+	sched_clock_register(pistachio_read_sched_clock, 32, rate);
+	clocksource_register_hz(&pcs_gpt.cs, rate);
+}
+CLOCKSOURCE_OF_DECLARE(pistachio_gptimer, "img,pistachio-gptimer",
+		       pistachio_clksrc_of_init);
-- 
1.9.1

--
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/

[toc] | [next] | [standalone]

#1202544

On 08/06/2015 01:22 PM, Govindraj Raja wrote:
> From: Ezequiel Garcia <ezequiel.garcia@imgtec.com>
>
> The Pistachio SoC provides four general purpose timers, and allow
> to implement a clocksource driver.
>
> This driver can be used as a replacement for the MIPS GIC and MIPS R4K
> clocksources and sched clocks, which are clocked from the CPU clock.
>
> Given the general purpose timers are clocked from an independent clock,
> this new clocksource driver will be useful to introduce CPUFreq support
> for Pistachio machines.
>
> Signed-off-by: Ezequiel Garcia <ezequiel.garcia@imgtec.com>
> Signed-off-by: Govindraj Raja <govindraj.raja@imgtec.com>
> ---
>
> changes from v4
> ----------------
> Fixes comments from Daniel as dicussed in below thread:
> http://patchwork.linux-mips.org/patch/10784/
>
>
>   drivers/clocksource/Kconfig          |   5 +
>   drivers/clocksource/Makefile         |   1 +
>   drivers/clocksource/time-pistachio.c | 216 +++++++++++++++++++++++++++++++++++
>   3 files changed, 222 insertions(+)
>   create mode 100644 drivers/clocksource/time-pistachio.c
>
> diff --git a/drivers/clocksource/Kconfig b/drivers/clocksource/Kconfig

[ ... ]

> index 4e57730..e642825 100644
> --- a/drivers/clocksource/Kconfig
> +++ b/drivers/clocksource/Kconfig
> @@ -111,6 +111,11 @@ config CLKSRC_LPC32XX
>   	select CLKSRC_MMIO
>   	select CLKSRC_OF
>
> +config CLKSRC_PISTACHIO
> +	bool
> +	default y if MACH_PISTACHIO

You don't need to add this condition.

> +	select CLKSRC_OF

[ ... ]

> +
> +struct pistachio_clocksource pcs_gpt;

static.

> +#define to_pistachio_clocksource(cs)	\
> +	container_of(cs, struct pistachio_clocksource, cs)
> +
> +static inline u32 gpt_readl(void __iomem *base, u32 offset, u32 gpt_id)
> +{
> +	return readl(base + 0x20 * gpt_id + offset);

Are you sure of the address computation ? I guess it is correct but just 
wanted you to double check.

> +}
> +
> +static inline void gpt_writel(void __iomem *base, u32 value, u32 offset,
> +		u32 gpt_id)
> +{
> +	writel(value, base + 0x20 * gpt_id + offset);
> +}
> +
> +static cycle_t pistachio_clocksource_read_cycles(struct clocksource *cs)
> +{
> +	struct pistachio_clocksource *pcs = to_pistachio_clocksource(cs);
> +	u32 counter, overflw;
> +	unsigned long flags;
> +
> +	/* The counter value is only refreshed after the overflow value is read.
> +	 * And they must be read in strict order, hence raw spin lock added.
> +	 */

nit: extra carriage return and comment format:

	/*
	 * blabla
	 */

> +	raw_spin_lock_irqsave(&pcs->lock, flags);
> +	overflw = gpt_readl(pcs->base, TIMER_CURRENT_OVERFLOW_VALUE, 0);
> +	counter = gpt_readl(pcs->base, TIMER_CURRENT_VALUE, 0);
> +	raw_spin_unlock_irqrestore(&pcs->lock, flags);
> +
> +	return ~(cycle_t)counter;
> +}
> +
> +static u64 notrace pistachio_read_sched_clock(void)
> +{
> +	return pistachio_clocksource_read_cycles(&pcs_gpt.cs);

Can you double check the u32 cast to cycle_t returning a u64 from this 
function ?

> +}
> +
> +static void pistachio_clksrc_set_mode(struct clocksource *cs, int timeridx,
> +			int enable)
> +{
> +	struct pistachio_clocksource *pcs = to_pistachio_clocksource(cs);
> +	u32 val;
> +
> +	val = gpt_readl(pcs->base, TIMER_CFG, timeridx);
> +	if (enable)
> +		val |= TIMER_ME_LOCAL;
> +	else
> +		val &= ~TIMER_ME_LOCAL;
> +
> +	gpt_writel(pcs->base, val, TIMER_CFG, timeridx);
> +}
> +
> +static void pistachio_clksrc_enable(struct clocksource *cs, int timeridx)
> +{
> +	struct pistachio_clocksource *pcs = to_pistachio_clocksource(cs);
> +
> +	/* Disable GPT local before loading reload value */
> +	pistachio_clksrc_set_mode(cs, timeridx, false);
> +	gpt_writel(pcs->base, RELOAD_VALUE, TIMER_RELOAD_VALUE, timeridx);
> +	pistachio_clksrc_set_mode(cs, timeridx, true);
> +}
> +
> +static void pistachio_clksrc_disable(struct clocksource *cs, int timeridx)
> +{
> +	/* Disable GPT local */
> +	pistachio_clksrc_set_mode(cs, timeridx, false);
> +}
> +
> +static int pistachio_clocksource_enable(struct clocksource *cs)
> +{
> +	pistachio_clksrc_enable(cs, 0);
> +	return 0;
> +}
> +
> +static void pistachio_clocksource_disable(struct clocksource *cs)
> +{
> +	pistachio_clksrc_disable(cs, 0);
> +}
> +
> +/* Desirable clock source for pistachio platform */
> +struct pistachio_clocksource pcs_gpt = {

static.

Thanks !

   -- Daniel


-- 
  <http://www.linaro.org/> Linaro.org │ Open source software for ARM SoCs

Follow Linaro:  <http://www.facebook.com/pages/Linaro> Facebook |
<http://twitter.com/#!/linaroorg> Twitter |
<http://www.linaro.org/linaro-blog/> Blog

--
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/

[toc] | [prev] | [next] | [standalone]

#1202809 — RE: [PATCH v5 6/7] clocksource: Add Pistachio clocksource-only driver
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--
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/

[toc] | [prev] | [standalone]

Back to top | Article view | linux.kernel

csiph-web