2018-05-22 23:05:04 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
|
|
|
|
//
|
|
|
|
|
// Copyright (C) 2000-2001 Deep Blue Solutions
|
|
|
|
|
// Copyright (C) 2002 Shane Nay (shane@minirl.com)
|
|
|
|
|
// Copyright (C) 2006-2007 Pavel Pisa (ppisa@pikron.com)
|
|
|
|
|
// Copyright (C) 2008 Juergen Beisert (kernel@pengutronix.de)
|
2008-07-05 08:02:50 +00:00
|
|
|
|
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
#include <linux/irq.h>
|
|
|
|
|
#include <linux/clockchips.h>
|
|
|
|
|
#include <linux/clk.h>
|
2014-01-22 11:35:44 +00:00
|
|
|
#include <linux/delay.h>
|
2012-03-09 08:29:27 +00:00
|
|
|
#include <linux/err.h>
|
2013-06-02 06:39:40 +00:00
|
|
|
#include <linux/sched_clock.h>
|
2015-05-22 05:53:45 +00:00
|
|
|
#include <linux/slab.h>
|
2014-04-05 15:57:45 +00:00
|
|
|
#include <linux/of.h>
|
|
|
|
|
#include <linux/of_address.h>
|
|
|
|
|
#include <linux/of_irq.h>
|
2008-07-05 08:02:50 +00:00
|
|
|
|
2009-12-04 08:34:51 +00:00
|
|
|
/*
|
2015-04-29 21:40:27 +00:00
|
|
|
* There are 4 versions of the timer hardware on Freescale MXC hardware.
|
|
|
|
|
* - MX1/MXL
|
|
|
|
|
* - MX21, MX27.
|
|
|
|
|
* - MX25, MX31, MX35, MX37, MX51, MX6Q(rev1.0)
|
|
|
|
|
* - MX6DL, MX6SX, MX6Q(rev1.1+)
|
2009-12-04 08:34:51 +00:00
|
|
|
*/
|
2023-03-28 10:05:31 +00:00
|
|
|
enum imx_gpt_type {
|
|
|
|
|
GPT_TYPE_IMX1, /* i.MX1 */
|
|
|
|
|
GPT_TYPE_IMX21, /* i.MX21/27 */
|
|
|
|
|
GPT_TYPE_IMX31, /* i.MX31/35/25/37/51/6Q */
|
|
|
|
|
GPT_TYPE_IMX6DL, /* i.MX6DL/SX/SL */
|
|
|
|
|
};
|
2009-12-04 08:34:51 +00:00
|
|
|
|
2009-02-18 19:58:40 +00:00
|
|
|
/* defines common for all i.MX */
|
|
|
|
|
#define MXC_TCTL 0x00
|
2009-12-04 08:34:51 +00:00
|
|
|
#define MXC_TCTL_TEN (1 << 0) /* Enable module */
|
2009-02-18 19:58:40 +00:00
|
|
|
#define MXC_TPRER 0x04
|
|
|
|
|
|
|
|
|
|
/* MX1, MX21, MX27 */
|
|
|
|
|
#define MX1_2_TCTL_CLK_PCLK1 (1 << 1)
|
|
|
|
|
#define MX1_2_TCTL_IRQEN (1 << 4)
|
|
|
|
|
#define MX1_2_TCTL_FRR (1 << 8)
|
|
|
|
|
#define MX1_2_TCMP 0x08
|
|
|
|
|
#define MX1_2_TCN 0x10
|
|
|
|
|
#define MX1_2_TSTAT 0x14
|
|
|
|
|
|
|
|
|
|
/* MX21, MX27 */
|
|
|
|
|
#define MX2_TSTAT_CAPT (1 << 1)
|
|
|
|
|
#define MX2_TSTAT_COMP (1 << 0)
|
|
|
|
|
|
ARM: imx: source gpt per clk from OSC for system timer
On i.MX6Q TO > 1.0, i.MX6DL and i.MX6SX, gpt per clock
can be from OSC instead of ipg_per, as ipg_per's rate
may be scaled when system enter low bus mode, to keep
system timer NOT drift, better to make gpt per clock
at fixed rate, here add support for gpt per clock to
be from OSC which is at fixed rate always.
There are some difference on this implementation of
gpt per clock source, see below for details:
i.MX6Q TO > 1.0: GPT_CR_CLKSRC, b'101 selects fix clock
of OSC / 8 for gpt per clk;
i.MX6DL and i.MX6SX: GPT_CR_CLKSRC, b'101 selects OSC
for gpt per clk, and we must enable GPT_CR_24MEM to
enable OSC clk source for gpt per, GPT_PR_PRESCALER24M
is for pre-scaling of this OSC clk, here set it to 8
to make gpt per clk is 3MHz;
i.MX6SL: ipg_per can be from OSC directly, so no need to
implement this new clk source for gpt per.
Signed-off-by: Anson Huang <b20788@freescale.com>
Signed-off-by: Shawn Guo <shawn.guo@freescale.com>
2014-09-11 03:29:42 +00:00
|
|
|
/* MX31, MX35, MX25, MX5, MX6 */
|
2010-04-21 18:34:36 +00:00
|
|
|
#define V2_TCTL_WAITEN (1 << 3) /* Wait enable mode */
|
|
|
|
|
#define V2_TCTL_CLK_IPG (1 << 6)
|
2012-05-15 07:34:40 +00:00
|
|
|
#define V2_TCTL_CLK_PER (2 << 6)
|
ARM: imx: source gpt per clk from OSC for system timer
On i.MX6Q TO > 1.0, i.MX6DL and i.MX6SX, gpt per clock
can be from OSC instead of ipg_per, as ipg_per's rate
may be scaled when system enter low bus mode, to keep
system timer NOT drift, better to make gpt per clock
at fixed rate, here add support for gpt per clock to
be from OSC which is at fixed rate always.
There are some difference on this implementation of
gpt per clock source, see below for details:
i.MX6Q TO > 1.0: GPT_CR_CLKSRC, b'101 selects fix clock
of OSC / 8 for gpt per clk;
i.MX6DL and i.MX6SX: GPT_CR_CLKSRC, b'101 selects OSC
for gpt per clk, and we must enable GPT_CR_24MEM to
enable OSC clk source for gpt per, GPT_PR_PRESCALER24M
is for pre-scaling of this OSC clk, here set it to 8
to make gpt per clk is 3MHz;
i.MX6SL: ipg_per can be from OSC directly, so no need to
implement this new clk source for gpt per.
Signed-off-by: Anson Huang <b20788@freescale.com>
Signed-off-by: Shawn Guo <shawn.guo@freescale.com>
2014-09-11 03:29:42 +00:00
|
|
|
#define V2_TCTL_CLK_OSC_DIV8 (5 << 6)
|
2010-04-21 18:34:36 +00:00
|
|
|
#define V2_TCTL_FRR (1 << 9)
|
ARM: imx: source gpt per clk from OSC for system timer
On i.MX6Q TO > 1.0, i.MX6DL and i.MX6SX, gpt per clock
can be from OSC instead of ipg_per, as ipg_per's rate
may be scaled when system enter low bus mode, to keep
system timer NOT drift, better to make gpt per clock
at fixed rate, here add support for gpt per clock to
be from OSC which is at fixed rate always.
There are some difference on this implementation of
gpt per clock source, see below for details:
i.MX6Q TO > 1.0: GPT_CR_CLKSRC, b'101 selects fix clock
of OSC / 8 for gpt per clk;
i.MX6DL and i.MX6SX: GPT_CR_CLKSRC, b'101 selects OSC
for gpt per clk, and we must enable GPT_CR_24MEM to
enable OSC clk source for gpt per, GPT_PR_PRESCALER24M
is for pre-scaling of this OSC clk, here set it to 8
to make gpt per clk is 3MHz;
i.MX6SL: ipg_per can be from OSC directly, so no need to
implement this new clk source for gpt per.
Signed-off-by: Anson Huang <b20788@freescale.com>
Signed-off-by: Shawn Guo <shawn.guo@freescale.com>
2014-09-11 03:29:42 +00:00
|
|
|
#define V2_TCTL_24MEN (1 << 10)
|
|
|
|
|
#define V2_TPRER_PRE24M 12
|
2010-04-21 18:34:36 +00:00
|
|
|
#define V2_IR 0x0c
|
|
|
|
|
#define V2_TSTAT 0x08
|
|
|
|
|
#define V2_TSTAT_OF1 (1 << 0)
|
|
|
|
|
#define V2_TCN 0x24
|
|
|
|
|
#define V2_TCMP 0x10
|
2008-07-05 08:02:50 +00:00
|
|
|
|
ARM: imx: source gpt per clk from OSC for system timer
On i.MX6Q TO > 1.0, i.MX6DL and i.MX6SX, gpt per clock
can be from OSC instead of ipg_per, as ipg_per's rate
may be scaled when system enter low bus mode, to keep
system timer NOT drift, better to make gpt per clock
at fixed rate, here add support for gpt per clock to
be from OSC which is at fixed rate always.
There are some difference on this implementation of
gpt per clock source, see below for details:
i.MX6Q TO > 1.0: GPT_CR_CLKSRC, b'101 selects fix clock
of OSC / 8 for gpt per clk;
i.MX6DL and i.MX6SX: GPT_CR_CLKSRC, b'101 selects OSC
for gpt per clk, and we must enable GPT_CR_24MEM to
enable OSC clk source for gpt per, GPT_PR_PRESCALER24M
is for pre-scaling of this OSC clk, here set it to 8
to make gpt per clk is 3MHz;
i.MX6SL: ipg_per can be from OSC directly, so no need to
implement this new clk source for gpt per.
Signed-off-by: Anson Huang <b20788@freescale.com>
Signed-off-by: Shawn Guo <shawn.guo@freescale.com>
2014-09-11 03:29:42 +00:00
|
|
|
#define V2_TIMER_RATE_OSC_DIV8 3000000
|
|
|
|
|
|
2015-05-22 05:53:45 +00:00
|
|
|
struct imx_timer {
|
2015-05-15 03:41:39 +00:00
|
|
|
enum imx_gpt_type type;
|
2015-05-22 05:53:45 +00:00
|
|
|
void __iomem *base;
|
|
|
|
|
int irq;
|
|
|
|
|
struct clk *clk_per;
|
|
|
|
|
struct clk *clk_ipg;
|
2015-05-15 06:24:41 +00:00
|
|
|
const struct imx_gpt_data *gpt;
|
2015-05-22 08:38:49 +00:00
|
|
|
struct clock_event_device ced;
|
2015-05-15 06:24:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct imx_gpt_data {
|
2015-05-22 13:39:55 +00:00
|
|
|
int reg_tstat;
|
|
|
|
|
int reg_tcn;
|
|
|
|
|
int reg_tcmp;
|
2015-05-15 06:24:41 +00:00
|
|
|
void (*gpt_setup_tctl)(struct imx_timer *imxtm);
|
2015-05-22 14:42:55 +00:00
|
|
|
void (*gpt_irq_enable)(struct imx_timer *imxtm);
|
|
|
|
|
void (*gpt_irq_disable)(struct imx_timer *imxtm);
|
|
|
|
|
void (*gpt_irq_acknowledge)(struct imx_timer *imxtm);
|
2015-05-22 07:51:41 +00:00
|
|
|
int (*set_next_event)(unsigned long evt,
|
|
|
|
|
struct clock_event_device *ced);
|
2015-05-22 05:53:45 +00:00
|
|
|
};
|
|
|
|
|
|
2015-05-22 08:38:49 +00:00
|
|
|
static inline struct imx_timer *to_imx_timer(struct clock_event_device *ced)
|
|
|
|
|
{
|
|
|
|
|
return container_of(ced, struct imx_timer, ced);
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-22 14:42:55 +00:00
|
|
|
static void imx1_gpt_irq_disable(struct imx_timer *imxtm)
|
2008-07-05 08:02:50 +00:00
|
|
|
{
|
2009-02-18 19:58:40 +00:00
|
|
|
unsigned int tmp;
|
|
|
|
|
|
2015-05-22 14:42:55 +00:00
|
|
|
tmp = readl_relaxed(imxtm->base + MXC_TCTL);
|
|
|
|
|
writel_relaxed(tmp & ~MX1_2_TCTL_IRQEN, imxtm->base + MXC_TCTL);
|
2009-02-18 19:58:40 +00:00
|
|
|
}
|
|
|
|
|
|
2015-05-22 14:42:55 +00:00
|
|
|
static void imx31_gpt_irq_disable(struct imx_timer *imxtm)
|
2009-02-18 19:58:40 +00:00
|
|
|
{
|
2015-05-22 14:42:55 +00:00
|
|
|
writel_relaxed(0, imxtm->base + V2_IR);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void imx1_gpt_irq_enable(struct imx_timer *imxtm)
|
|
|
|
|
{
|
|
|
|
|
unsigned int tmp;
|
|
|
|
|
|
|
|
|
|
tmp = readl_relaxed(imxtm->base + MXC_TCTL);
|
|
|
|
|
writel_relaxed(tmp | MX1_2_TCTL_IRQEN, imxtm->base + MXC_TCTL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void imx31_gpt_irq_enable(struct imx_timer *imxtm)
|
|
|
|
|
{
|
|
|
|
|
writel_relaxed(1<<0, imxtm->base + V2_IR);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void imx1_gpt_irq_acknowledge(struct imx_timer *imxtm)
|
|
|
|
|
{
|
|
|
|
|
writel_relaxed(0, imxtm->base + MX1_2_TSTAT);
|
2009-02-18 19:58:40 +00:00
|
|
|
}
|
|
|
|
|
|
2015-05-22 14:42:55 +00:00
|
|
|
static void imx21_gpt_irq_acknowledge(struct imx_timer *imxtm)
|
2009-02-18 19:58:40 +00:00
|
|
|
{
|
2015-05-22 14:42:55 +00:00
|
|
|
writel_relaxed(MX2_TSTAT_CAPT | MX2_TSTAT_COMP,
|
2015-05-22 14:23:28 +00:00
|
|
|
imxtm->base + MX1_2_TSTAT);
|
2009-02-18 19:58:40 +00:00
|
|
|
}
|
|
|
|
|
|
2015-05-22 14:42:55 +00:00
|
|
|
static void imx31_gpt_irq_acknowledge(struct imx_timer *imxtm)
|
|
|
|
|
{
|
|
|
|
|
writel_relaxed(V2_TSTAT_OF1, imxtm->base + V2_TSTAT);
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-08 13:09:47 +00:00
|
|
|
static void __iomem *sched_clock_reg;
|
2008-07-05 08:02:50 +00:00
|
|
|
|
2013-11-15 23:26:12 +00:00
|
|
|
static u64 notrace mxc_read_sched_clock(void)
|
2011-03-17 12:44:30 +00:00
|
|
|
{
|
2015-05-19 10:47:47 +00:00
|
|
|
return sched_clock_reg ? readl_relaxed(sched_clock_reg) : 0;
|
2011-03-17 12:44:30 +00:00
|
|
|
}
|
|
|
|
|
|
2018-11-05 01:10:27 +00:00
|
|
|
#if defined(CONFIG_ARM)
|
2014-01-22 11:35:44 +00:00
|
|
|
static struct delay_timer imx_delay_timer;
|
|
|
|
|
|
|
|
|
|
static unsigned long imx_read_current_timer(void)
|
|
|
|
|
{
|
2015-05-19 10:47:47 +00:00
|
|
|
return readl_relaxed(sched_clock_reg);
|
2014-01-22 11:35:44 +00:00
|
|
|
}
|
2018-11-05 01:10:27 +00:00
|
|
|
#endif
|
2014-01-22 11:35:44 +00:00
|
|
|
|
2015-05-22 05:53:45 +00:00
|
|
|
static int __init mxc_clocksource_init(struct imx_timer *imxtm)
|
2008-07-05 08:02:50 +00:00
|
|
|
{
|
2015-05-22 05:53:45 +00:00
|
|
|
unsigned int c = clk_get_rate(imxtm->clk_per);
|
2015-05-22 13:39:55 +00:00
|
|
|
void __iomem *reg = imxtm->base + imxtm->gpt->reg_tcn;
|
2008-07-05 08:02:50 +00:00
|
|
|
|
2018-11-05 01:10:27 +00:00
|
|
|
#if defined(CONFIG_ARM)
|
2014-01-22 11:35:44 +00:00
|
|
|
imx_delay_timer.read_current_timer = &imx_read_current_timer;
|
|
|
|
|
imx_delay_timer.freq = c;
|
|
|
|
|
register_current_timer_delay(&imx_delay_timer);
|
2018-11-05 01:10:27 +00:00
|
|
|
#endif
|
2014-01-22 11:35:44 +00:00
|
|
|
|
2011-05-08 13:09:47 +00:00
|
|
|
sched_clock_reg = reg;
|
2009-02-18 19:58:40 +00:00
|
|
|
|
2013-11-15 23:26:12 +00:00
|
|
|
sched_clock_register(mxc_read_sched_clock, 32, c);
|
2011-05-08 13:09:47 +00:00
|
|
|
return clocksource_mmio_init(reg, "mxc_timer1", c, 200, 32,
|
|
|
|
|
clocksource_mmio_readl_up);
|
2008-07-05 08:02:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* clock event */
|
|
|
|
|
|
2009-02-18 19:58:40 +00:00
|
|
|
static int mx1_2_set_next_event(unsigned long evt,
|
2015-05-22 14:23:28 +00:00
|
|
|
struct clock_event_device *ced)
|
2008-07-05 08:02:50 +00:00
|
|
|
{
|
2015-05-22 14:23:28 +00:00
|
|
|
struct imx_timer *imxtm = to_imx_timer(ced);
|
2008-07-05 08:02:50 +00:00
|
|
|
unsigned long tcmp;
|
|
|
|
|
|
2015-05-22 14:23:28 +00:00
|
|
|
tcmp = readl_relaxed(imxtm->base + MX1_2_TCN) + evt;
|
2008-07-05 08:02:50 +00:00
|
|
|
|
2015-05-22 14:23:28 +00:00
|
|
|
writel_relaxed(tcmp, imxtm->base + MX1_2_TCMP);
|
2009-02-18 19:58:40 +00:00
|
|
|
|
2015-05-22 14:23:28 +00:00
|
|
|
return (int)(tcmp - readl_relaxed(imxtm->base + MX1_2_TCN)) < 0 ?
|
2009-02-18 19:58:40 +00:00
|
|
|
-ETIME : 0;
|
|
|
|
|
}
|
|
|
|
|
|
2010-04-21 18:34:36 +00:00
|
|
|
static int v2_set_next_event(unsigned long evt,
|
2015-05-22 14:23:28 +00:00
|
|
|
struct clock_event_device *ced)
|
2009-02-18 19:58:40 +00:00
|
|
|
{
|
2015-05-22 14:23:28 +00:00
|
|
|
struct imx_timer *imxtm = to_imx_timer(ced);
|
2009-02-18 19:58:40 +00:00
|
|
|
unsigned long tcmp;
|
|
|
|
|
|
2015-05-22 14:23:28 +00:00
|
|
|
tcmp = readl_relaxed(imxtm->base + V2_TCN) + evt;
|
2009-02-18 19:58:40 +00:00
|
|
|
|
2015-05-22 14:23:28 +00:00
|
|
|
writel_relaxed(tcmp, imxtm->base + V2_TCMP);
|
2009-02-18 19:58:40 +00:00
|
|
|
|
2012-12-06 14:54:41 +00:00
|
|
|
return evt < 0x7fffffff &&
|
2015-05-22 14:23:28 +00:00
|
|
|
(int)(tcmp - readl_relaxed(imxtm->base + V2_TCN)) < 0 ?
|
2008-07-05 08:02:50 +00:00
|
|
|
-ETIME : 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-06 10:09:18 +00:00
|
|
|
static int mxc_shutdown(struct clock_event_device *ced)
|
|
|
|
|
{
|
|
|
|
|
struct imx_timer *imxtm = to_imx_timer(ced);
|
|
|
|
|
u32 tcn;
|
|
|
|
|
|
|
|
|
|
/* Disable interrupt in GPT module */
|
|
|
|
|
imxtm->gpt->gpt_irq_disable(imxtm);
|
|
|
|
|
|
|
|
|
|
tcn = readl_relaxed(imxtm->base + imxtm->gpt->reg_tcn);
|
|
|
|
|
/* Set event time into far-far future */
|
|
|
|
|
writel_relaxed(tcn - 3, imxtm->base + imxtm->gpt->reg_tcmp);
|
|
|
|
|
|
|
|
|
|
/* Clear pending interrupt */
|
|
|
|
|
imxtm->gpt->gpt_irq_acknowledge(imxtm);
|
|
|
|
|
|
2008-07-05 08:02:50 +00:00
|
|
|
#ifdef DEBUG
|
2015-07-06 10:09:18 +00:00
|
|
|
printk(KERN_INFO "%s: changing mode\n", __func__);
|
2008-07-05 08:02:50 +00:00
|
|
|
#endif /* DEBUG */
|
|
|
|
|
|
2015-07-06 10:09:18 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int mxc_set_oneshot(struct clock_event_device *ced)
|
2008-07-05 08:02:50 +00:00
|
|
|
{
|
2015-05-22 08:38:49 +00:00
|
|
|
struct imx_timer *imxtm = to_imx_timer(ced);
|
2008-07-05 08:02:50 +00:00
|
|
|
|
|
|
|
|
/* Disable interrupt in GPT module */
|
2015-05-22 14:42:55 +00:00
|
|
|
imxtm->gpt->gpt_irq_disable(imxtm);
|
2008-07-05 08:02:50 +00:00
|
|
|
|
2015-07-06 10:09:18 +00:00
|
|
|
if (!clockevent_state_oneshot(ced)) {
|
2015-05-22 13:39:55 +00:00
|
|
|
u32 tcn = readl_relaxed(imxtm->base + imxtm->gpt->reg_tcn);
|
2008-07-05 08:02:50 +00:00
|
|
|
/* Set event time into far-far future */
|
2015-05-22 13:39:55 +00:00
|
|
|
writel_relaxed(tcn - 3, imxtm->base + imxtm->gpt->reg_tcmp);
|
2009-02-18 19:58:40 +00:00
|
|
|
|
2008-07-05 08:02:50 +00:00
|
|
|
/* Clear pending interrupt */
|
2015-05-22 14:42:55 +00:00
|
|
|
imxtm->gpt->gpt_irq_acknowledge(imxtm);
|
2008-07-05 08:02:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2015-07-06 10:09:18 +00:00
|
|
|
printk(KERN_INFO "%s: changing mode\n", __func__);
|
2008-07-05 08:02:50 +00:00
|
|
|
#endif /* DEBUG */
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Do not put overhead of interrupt enable/disable into
|
|
|
|
|
* mxc_set_next_event(), the core has about 4 minutes
|
|
|
|
|
* to call mxc_set_next_event() or shutdown clock after
|
|
|
|
|
* mode switching
|
|
|
|
|
*/
|
2015-07-06 10:09:18 +00:00
|
|
|
imxtm->gpt->gpt_irq_enable(imxtm);
|
|
|
|
|
|
|
|
|
|
return 0;
|
2008-07-05 08:02:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* IRQ handler for the timer
|
|
|
|
|
*/
|
|
|
|
|
static irqreturn_t mxc_timer_interrupt(int irq, void *dev_id)
|
|
|
|
|
{
|
2015-05-22 08:38:49 +00:00
|
|
|
struct clock_event_device *ced = dev_id;
|
2015-05-22 13:39:55 +00:00
|
|
|
struct imx_timer *imxtm = to_imx_timer(ced);
|
2008-07-05 08:02:50 +00:00
|
|
|
|
2023-12-27 14:35:46 +00:00
|
|
|
readl_relaxed(imxtm->base + imxtm->gpt->reg_tstat);
|
2008-07-05 08:02:50 +00:00
|
|
|
|
2015-05-22 14:42:55 +00:00
|
|
|
imxtm->gpt->gpt_irq_acknowledge(imxtm);
|
2008-07-05 08:02:50 +00:00
|
|
|
|
2015-05-22 08:38:49 +00:00
|
|
|
ced->event_handler(ced);
|
2008-07-05 08:02:50 +00:00
|
|
|
|
|
|
|
|
return IRQ_HANDLED;
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-22 05:53:45 +00:00
|
|
|
static int __init mxc_clockevent_init(struct imx_timer *imxtm)
|
2008-07-05 08:02:50 +00:00
|
|
|
{
|
2015-05-22 08:38:49 +00:00
|
|
|
struct clock_event_device *ced = &imxtm->ced;
|
|
|
|
|
|
|
|
|
|
ced->name = "mxc_timer1";
|
2015-10-14 09:24:17 +00:00
|
|
|
ced->features = CLOCK_EVT_FEAT_ONESHOT | CLOCK_EVT_FEAT_DYNIRQ;
|
2015-07-06 10:09:18 +00:00
|
|
|
ced->set_state_shutdown = mxc_shutdown;
|
|
|
|
|
ced->set_state_oneshot = mxc_set_oneshot;
|
|
|
|
|
ced->tick_resume = mxc_shutdown;
|
2015-05-22 08:38:49 +00:00
|
|
|
ced->set_next_event = imxtm->gpt->set_next_event;
|
|
|
|
|
ced->rating = 200;
|
|
|
|
|
ced->cpumask = cpumask_of(0);
|
2015-10-14 09:24:17 +00:00
|
|
|
ced->irq = imxtm->irq;
|
2015-05-22 08:38:49 +00:00
|
|
|
clockevents_config_and_register(ced, clk_get_rate(imxtm->clk_per),
|
2013-01-12 11:50:05 +00:00
|
|
|
0xff, 0xfffffffe);
|
2008-07-05 08:02:50 +00:00
|
|
|
|
2020-02-27 10:59:02 +00:00
|
|
|
return request_irq(imxtm->irq, mxc_timer_interrupt,
|
|
|
|
|
IRQF_TIMER | IRQF_IRQPOLL, "i.MX Timer Tick", ced);
|
2008-07-05 08:02:50 +00:00
|
|
|
}
|
|
|
|
|
|
2015-05-15 06:24:41 +00:00
|
|
|
static void imx1_gpt_setup_tctl(struct imx_timer *imxtm)
|
|
|
|
|
{
|
|
|
|
|
u32 tctl_val;
|
|
|
|
|
|
|
|
|
|
tctl_val = MX1_2_TCTL_FRR | MX1_2_TCTL_CLK_PCLK1 | MXC_TCTL_TEN;
|
|
|
|
|
writel_relaxed(tctl_val, imxtm->base + MXC_TCTL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void imx31_gpt_setup_tctl(struct imx_timer *imxtm)
|
|
|
|
|
{
|
|
|
|
|
u32 tctl_val;
|
|
|
|
|
|
|
|
|
|
tctl_val = V2_TCTL_FRR | V2_TCTL_WAITEN | MXC_TCTL_TEN;
|
|
|
|
|
if (clk_get_rate(imxtm->clk_per) == V2_TIMER_RATE_OSC_DIV8)
|
|
|
|
|
tctl_val |= V2_TCTL_CLK_OSC_DIV8;
|
|
|
|
|
else
|
|
|
|
|
tctl_val |= V2_TCTL_CLK_PER;
|
|
|
|
|
|
|
|
|
|
writel_relaxed(tctl_val, imxtm->base + MXC_TCTL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void imx6dl_gpt_setup_tctl(struct imx_timer *imxtm)
|
2008-07-05 08:02:50 +00:00
|
|
|
{
|
2015-05-15 06:24:41 +00:00
|
|
|
u32 tctl_val;
|
|
|
|
|
|
|
|
|
|
tctl_val = V2_TCTL_FRR | V2_TCTL_WAITEN | MXC_TCTL_TEN;
|
|
|
|
|
if (clk_get_rate(imxtm->clk_per) == V2_TIMER_RATE_OSC_DIV8) {
|
|
|
|
|
tctl_val |= V2_TCTL_CLK_OSC_DIV8;
|
|
|
|
|
/* 24 / 8 = 3 MHz */
|
|
|
|
|
writel_relaxed(7 << V2_TPRER_PRE24M, imxtm->base + MXC_TPRER);
|
|
|
|
|
tctl_val |= V2_TCTL_24MEN;
|
|
|
|
|
} else {
|
|
|
|
|
tctl_val |= V2_TCTL_CLK_PER;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
writel_relaxed(tctl_val, imxtm->base + MXC_TCTL);
|
|
|
|
|
}
|
2012-03-09 08:29:27 +00:00
|
|
|
|
2015-05-15 06:24:41 +00:00
|
|
|
static const struct imx_gpt_data imx1_gpt_data = {
|
2015-05-22 13:39:55 +00:00
|
|
|
.reg_tstat = MX1_2_TSTAT,
|
|
|
|
|
.reg_tcn = MX1_2_TCN,
|
|
|
|
|
.reg_tcmp = MX1_2_TCMP,
|
2015-05-22 14:42:55 +00:00
|
|
|
.gpt_irq_enable = imx1_gpt_irq_enable,
|
|
|
|
|
.gpt_irq_disable = imx1_gpt_irq_disable,
|
|
|
|
|
.gpt_irq_acknowledge = imx1_gpt_irq_acknowledge,
|
2015-05-15 06:24:41 +00:00
|
|
|
.gpt_setup_tctl = imx1_gpt_setup_tctl,
|
2015-05-22 07:51:41 +00:00
|
|
|
.set_next_event = mx1_2_set_next_event,
|
2015-05-15 06:24:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct imx_gpt_data imx21_gpt_data = {
|
2015-05-22 13:39:55 +00:00
|
|
|
.reg_tstat = MX1_2_TSTAT,
|
|
|
|
|
.reg_tcn = MX1_2_TCN,
|
|
|
|
|
.reg_tcmp = MX1_2_TCMP,
|
2023-03-28 09:15:14 +00:00
|
|
|
.gpt_irq_enable = imx1_gpt_irq_enable,
|
|
|
|
|
.gpt_irq_disable = imx1_gpt_irq_disable,
|
2015-05-22 14:42:55 +00:00
|
|
|
.gpt_irq_acknowledge = imx21_gpt_irq_acknowledge,
|
2023-03-28 09:15:14 +00:00
|
|
|
.gpt_setup_tctl = imx1_gpt_setup_tctl,
|
2015-05-22 07:51:41 +00:00
|
|
|
.set_next_event = mx1_2_set_next_event,
|
2015-05-15 06:24:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct imx_gpt_data imx31_gpt_data = {
|
2015-05-22 13:39:55 +00:00
|
|
|
.reg_tstat = V2_TSTAT,
|
|
|
|
|
.reg_tcn = V2_TCN,
|
|
|
|
|
.reg_tcmp = V2_TCMP,
|
2015-05-22 14:42:55 +00:00
|
|
|
.gpt_irq_enable = imx31_gpt_irq_enable,
|
|
|
|
|
.gpt_irq_disable = imx31_gpt_irq_disable,
|
|
|
|
|
.gpt_irq_acknowledge = imx31_gpt_irq_acknowledge,
|
2015-05-15 06:24:41 +00:00
|
|
|
.gpt_setup_tctl = imx31_gpt_setup_tctl,
|
2015-05-22 07:51:41 +00:00
|
|
|
.set_next_event = v2_set_next_event,
|
2015-05-15 06:24:41 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct imx_gpt_data imx6dl_gpt_data = {
|
2015-05-22 13:39:55 +00:00
|
|
|
.reg_tstat = V2_TSTAT,
|
|
|
|
|
.reg_tcn = V2_TCN,
|
|
|
|
|
.reg_tcmp = V2_TCMP,
|
2023-03-28 09:15:14 +00:00
|
|
|
.gpt_irq_enable = imx31_gpt_irq_enable,
|
|
|
|
|
.gpt_irq_disable = imx31_gpt_irq_disable,
|
|
|
|
|
.gpt_irq_acknowledge = imx31_gpt_irq_acknowledge,
|
2015-05-15 06:24:41 +00:00
|
|
|
.gpt_setup_tctl = imx6dl_gpt_setup_tctl,
|
2015-05-22 07:51:41 +00:00
|
|
|
.set_next_event = v2_set_next_event,
|
2015-05-15 06:24:41 +00:00
|
|
|
};
|
|
|
|
|
|
2016-06-06 21:27:05 +00:00
|
|
|
static int __init _mxc_timer_init(struct imx_timer *imxtm)
|
2015-05-15 06:24:41 +00:00
|
|
|
{
|
2016-06-06 21:27:05 +00:00
|
|
|
int ret;
|
|
|
|
|
|
2015-05-15 06:24:41 +00:00
|
|
|
switch (imxtm->type) {
|
|
|
|
|
case GPT_TYPE_IMX1:
|
|
|
|
|
imxtm->gpt = &imx1_gpt_data;
|
|
|
|
|
break;
|
|
|
|
|
case GPT_TYPE_IMX21:
|
|
|
|
|
imxtm->gpt = &imx21_gpt_data;
|
|
|
|
|
break;
|
|
|
|
|
case GPT_TYPE_IMX31:
|
|
|
|
|
imxtm->gpt = &imx31_gpt_data;
|
|
|
|
|
break;
|
|
|
|
|
case GPT_TYPE_IMX6DL:
|
|
|
|
|
imxtm->gpt = &imx6dl_gpt_data;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
2016-06-06 21:27:05 +00:00
|
|
|
return -EINVAL;
|
2015-05-15 06:24:41 +00:00
|
|
|
}
|
|
|
|
|
|
2015-05-22 05:53:45 +00:00
|
|
|
if (IS_ERR(imxtm->clk_per)) {
|
2012-05-16 10:29:53 +00:00
|
|
|
pr_err("i.MX timer: unable to get clk\n");
|
2016-06-06 21:27:05 +00:00
|
|
|
return PTR_ERR(imxtm->clk_per);
|
2012-03-09 08:29:27 +00:00
|
|
|
}
|
2009-02-18 19:58:40 +00:00
|
|
|
|
2015-05-22 05:53:45 +00:00
|
|
|
if (!IS_ERR(imxtm->clk_ipg))
|
|
|
|
|
clk_prepare_enable(imxtm->clk_ipg);
|
2012-05-16 10:29:53 +00:00
|
|
|
|
2015-05-22 05:53:45 +00:00
|
|
|
clk_prepare_enable(imxtm->clk_per);
|
2008-07-05 08:02:50 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Initialise to a known state (all timers off, and timing reset)
|
|
|
|
|
*/
|
|
|
|
|
|
2015-05-22 05:53:45 +00:00
|
|
|
writel_relaxed(0, imxtm->base + MXC_TCTL);
|
|
|
|
|
writel_relaxed(0, imxtm->base + MXC_TPRER); /* see datasheet note */
|
2009-02-18 19:58:40 +00:00
|
|
|
|
2015-05-15 06:24:41 +00:00
|
|
|
imxtm->gpt->gpt_setup_tctl(imxtm);
|
2008-07-05 08:02:50 +00:00
|
|
|
|
|
|
|
|
/* init and register the timer to the framework */
|
2016-06-06 21:27:05 +00:00
|
|
|
ret = mxc_clocksource_init(imxtm);
|
|
|
|
|
if (ret)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
return mxc_clockevent_init(imxtm);
|
2008-07-05 08:02:50 +00:00
|
|
|
}
|
2014-04-05 15:57:45 +00:00
|
|
|
|
2016-06-06 21:27:05 +00:00
|
|
|
static int __init mxc_timer_init_dt(struct device_node *np, enum imx_gpt_type type)
|
2014-04-05 15:57:45 +00:00
|
|
|
{
|
2015-05-22 05:53:45 +00:00
|
|
|
struct imx_timer *imxtm;
|
|
|
|
|
static int initialized;
|
2016-06-06 21:27:05 +00:00
|
|
|
int ret;
|
2014-04-05 15:57:45 +00:00
|
|
|
|
2015-05-22 05:53:45 +00:00
|
|
|
/* Support one instance only */
|
|
|
|
|
if (initialized)
|
2016-06-06 21:27:05 +00:00
|
|
|
return 0;
|
2014-07-13 05:34:00 +00:00
|
|
|
|
2015-05-22 05:53:45 +00:00
|
|
|
imxtm = kzalloc(sizeof(*imxtm), GFP_KERNEL);
|
2016-06-06 21:27:05 +00:00
|
|
|
if (!imxtm)
|
|
|
|
|
return -ENOMEM;
|
2014-04-05 15:57:45 +00:00
|
|
|
|
2015-05-22 05:53:45 +00:00
|
|
|
imxtm->base = of_iomap(np, 0);
|
2023-10-09 08:39:22 +00:00
|
|
|
if (!imxtm->base) {
|
|
|
|
|
ret = -ENXIO;
|
|
|
|
|
goto err_kfree;
|
|
|
|
|
}
|
2016-06-06 21:27:05 +00:00
|
|
|
|
2015-05-22 05:53:45 +00:00
|
|
|
imxtm->irq = irq_of_parse_and_map(np, 0);
|
2023-10-09 08:39:22 +00:00
|
|
|
if (imxtm->irq <= 0) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto err_kfree;
|
|
|
|
|
}
|
2015-05-22 05:53:45 +00:00
|
|
|
|
|
|
|
|
imxtm->clk_ipg = of_clk_get_by_name(np, "ipg");
|
2014-05-27 09:04:46 +00:00
|
|
|
|
ARM: imx: source gpt per clk from OSC for system timer
On i.MX6Q TO > 1.0, i.MX6DL and i.MX6SX, gpt per clock
can be from OSC instead of ipg_per, as ipg_per's rate
may be scaled when system enter low bus mode, to keep
system timer NOT drift, better to make gpt per clock
at fixed rate, here add support for gpt per clock to
be from OSC which is at fixed rate always.
There are some difference on this implementation of
gpt per clock source, see below for details:
i.MX6Q TO > 1.0: GPT_CR_CLKSRC, b'101 selects fix clock
of OSC / 8 for gpt per clk;
i.MX6DL and i.MX6SX: GPT_CR_CLKSRC, b'101 selects OSC
for gpt per clk, and we must enable GPT_CR_24MEM to
enable OSC clk source for gpt per, GPT_PR_PRESCALER24M
is for pre-scaling of this OSC clk, here set it to 8
to make gpt per clk is 3MHz;
i.MX6SL: ipg_per can be from OSC directly, so no need to
implement this new clk source for gpt per.
Signed-off-by: Anson Huang <b20788@freescale.com>
Signed-off-by: Shawn Guo <shawn.guo@freescale.com>
2014-09-11 03:29:42 +00:00
|
|
|
/* Try osc_per first, and fall back to per otherwise */
|
2015-05-22 05:53:45 +00:00
|
|
|
imxtm->clk_per = of_clk_get_by_name(np, "osc_per");
|
|
|
|
|
if (IS_ERR(imxtm->clk_per))
|
|
|
|
|
imxtm->clk_per = of_clk_get_by_name(np, "per");
|
|
|
|
|
|
2015-05-15 05:38:20 +00:00
|
|
|
imxtm->type = type;
|
|
|
|
|
|
2016-06-06 21:27:05 +00:00
|
|
|
ret = _mxc_timer_init(imxtm);
|
|
|
|
|
if (ret)
|
2023-10-09 08:39:22 +00:00
|
|
|
goto err_kfree;
|
ARM: imx: source gpt per clk from OSC for system timer
On i.MX6Q TO > 1.0, i.MX6DL and i.MX6SX, gpt per clock
can be from OSC instead of ipg_per, as ipg_per's rate
may be scaled when system enter low bus mode, to keep
system timer NOT drift, better to make gpt per clock
at fixed rate, here add support for gpt per clock to
be from OSC which is at fixed rate always.
There are some difference on this implementation of
gpt per clock source, see below for details:
i.MX6Q TO > 1.0: GPT_CR_CLKSRC, b'101 selects fix clock
of OSC / 8 for gpt per clk;
i.MX6DL and i.MX6SX: GPT_CR_CLKSRC, b'101 selects OSC
for gpt per clk, and we must enable GPT_CR_24MEM to
enable OSC clk source for gpt per, GPT_PR_PRESCALER24M
is for pre-scaling of this OSC clk, here set it to 8
to make gpt per clk is 3MHz;
i.MX6SL: ipg_per can be from OSC directly, so no need to
implement this new clk source for gpt per.
Signed-off-by: Anson Huang <b20788@freescale.com>
Signed-off-by: Shawn Guo <shawn.guo@freescale.com>
2014-09-11 03:29:42 +00:00
|
|
|
|
2015-05-22 05:53:45 +00:00
|
|
|
initialized = 1;
|
2016-06-06 21:27:05 +00:00
|
|
|
|
|
|
|
|
return 0;
|
2023-10-09 08:39:22 +00:00
|
|
|
|
|
|
|
|
err_kfree:
|
|
|
|
|
kfree(imxtm);
|
|
|
|
|
return ret;
|
2014-04-05 15:57:45 +00:00
|
|
|
}
|
2015-05-15 05:38:20 +00:00
|
|
|
|
2016-06-06 21:27:05 +00:00
|
|
|
static int __init imx1_timer_init_dt(struct device_node *np)
|
2015-05-15 05:38:20 +00:00
|
|
|
{
|
2016-06-06 21:27:05 +00:00
|
|
|
return mxc_timer_init_dt(np, GPT_TYPE_IMX1);
|
2015-05-15 05:38:20 +00:00
|
|
|
}
|
|
|
|
|
|
2016-06-06 21:27:05 +00:00
|
|
|
static int __init imx21_timer_init_dt(struct device_node *np)
|
2015-05-15 05:38:20 +00:00
|
|
|
{
|
2016-06-06 21:27:05 +00:00
|
|
|
return mxc_timer_init_dt(np, GPT_TYPE_IMX21);
|
2015-05-15 05:38:20 +00:00
|
|
|
}
|
|
|
|
|
|
2016-06-06 21:27:05 +00:00
|
|
|
static int __init imx31_timer_init_dt(struct device_node *np)
|
2015-05-15 05:38:20 +00:00
|
|
|
{
|
|
|
|
|
enum imx_gpt_type type = GPT_TYPE_IMX31;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We were using the same compatible string for i.MX6Q/D and i.MX6DL/S
|
|
|
|
|
* GPT device, while they actually have different programming model.
|
|
|
|
|
* This is a workaround to keep the existing i.MX6DL/S DTBs continue
|
|
|
|
|
* working with the new kernel.
|
|
|
|
|
*/
|
|
|
|
|
if (of_machine_is_compatible("fsl,imx6dl"))
|
|
|
|
|
type = GPT_TYPE_IMX6DL;
|
|
|
|
|
|
2016-06-06 21:27:05 +00:00
|
|
|
return mxc_timer_init_dt(np, type);
|
2015-05-15 05:38:20 +00:00
|
|
|
}
|
|
|
|
|
|
2016-06-06 21:27:05 +00:00
|
|
|
static int __init imx6dl_timer_init_dt(struct device_node *np)
|
2015-05-15 05:38:20 +00:00
|
|
|
{
|
2016-06-06 21:27:05 +00:00
|
|
|
return mxc_timer_init_dt(np, GPT_TYPE_IMX6DL);
|
2015-05-15 05:38:20 +00:00
|
|
|
}
|
|
|
|
|
|
2017-05-26 14:56:11 +00:00
|
|
|
TIMER_OF_DECLARE(imx1_timer, "fsl,imx1-gpt", imx1_timer_init_dt);
|
|
|
|
|
TIMER_OF_DECLARE(imx21_timer, "fsl,imx21-gpt", imx21_timer_init_dt);
|
|
|
|
|
TIMER_OF_DECLARE(imx27_timer, "fsl,imx27-gpt", imx21_timer_init_dt);
|
|
|
|
|
TIMER_OF_DECLARE(imx31_timer, "fsl,imx31-gpt", imx31_timer_init_dt);
|
|
|
|
|
TIMER_OF_DECLARE(imx25_timer, "fsl,imx25-gpt", imx31_timer_init_dt);
|
|
|
|
|
TIMER_OF_DECLARE(imx50_timer, "fsl,imx50-gpt", imx31_timer_init_dt);
|
|
|
|
|
TIMER_OF_DECLARE(imx51_timer, "fsl,imx51-gpt", imx31_timer_init_dt);
|
|
|
|
|
TIMER_OF_DECLARE(imx53_timer, "fsl,imx53-gpt", imx31_timer_init_dt);
|
|
|
|
|
TIMER_OF_DECLARE(imx6q_timer, "fsl,imx6q-gpt", imx31_timer_init_dt);
|
|
|
|
|
TIMER_OF_DECLARE(imx6dl_timer, "fsl,imx6dl-gpt", imx6dl_timer_init_dt);
|
|
|
|
|
TIMER_OF_DECLARE(imx6sl_timer, "fsl,imx6sl-gpt", imx6dl_timer_init_dt);
|
|
|
|
|
TIMER_OF_DECLARE(imx6sx_timer, "fsl,imx6sx-gpt", imx6dl_timer_init_dt);
|
