time.c 7.81 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/*
 *  linux/arch/arm/plat-mxc/time.c
 *
 *  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)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 */

#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/clockchips.h>
#include <linux/clk.h>

29
#include <mach/hardware.h>
30
#include <asm/mach/time.h>
31
#include <mach/common.h>
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

/* defines common for all i.MX */
#define MXC_TCTL		0x00
#define MXC_TCTL_TEN		(1 << 0)
#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)

Sascha Hauer's avatar
Sascha Hauer committed
50
/* MX31, MX35, MX25 */
51
52
53
54
55
56
57
58
#define MX3_TCTL_WAITEN		(1 << 3)
#define MX3_TCTL_CLK_IPG	(1 << 6)
#define MX3_TCTL_FRR		(1 << 9)
#define MX3_IR			0x0c
#define MX3_TSTAT		0x08
#define MX3_TSTAT_OF1		(1 << 0)
#define MX3_TCN			0x24
#define MX3_TCMP		0x10
59
60
61
62

static struct clock_event_device clockevent_mxc;
static enum clock_event_mode clockevent_mode = CLOCK_EVT_MODE_UNUSED;

63
static void __iomem *timer_base;
64

65
static inline void gpt_irq_disable(void)
66
{
67
68
	unsigned int tmp;

Sascha Hauer's avatar
Sascha Hauer committed
69
	if (cpu_is_mx3() || cpu_is_mx25())
70
71
72
73
74
75
76
77
78
		__raw_writel(0, timer_base + MX3_IR);
	else {
		tmp = __raw_readl(timer_base + MXC_TCTL);
		__raw_writel(tmp & ~MX1_2_TCTL_IRQEN, timer_base + MXC_TCTL);
	}
}

static inline void gpt_irq_enable(void)
{
Sascha Hauer's avatar
Sascha Hauer committed
79
	if (cpu_is_mx3() || cpu_is_mx25())
80
81
82
83
84
85
86
87
88
89
90
91
92
		__raw_writel(1<<0, timer_base + MX3_IR);
	else {
		__raw_writel(__raw_readl(timer_base + MXC_TCTL) | MX1_2_TCTL_IRQEN,
			timer_base + MXC_TCTL);
	}
}

static void gpt_irq_acknowledge(void)
{
	if (cpu_is_mx1())
		__raw_writel(0, timer_base + MX1_2_TSTAT);
	if (cpu_is_mx2())
		__raw_writel(MX2_TSTAT_CAPT | MX2_TSTAT_COMP, timer_base + MX1_2_TSTAT);
Sascha Hauer's avatar
Sascha Hauer committed
93
	if (cpu_is_mx3() || cpu_is_mx25())
94
95
96
97
98
99
100
101
102
103
104
		__raw_writel(MX3_TSTAT_OF1, timer_base + MX3_TSTAT);
}

static cycle_t mx1_2_get_cycles(struct clocksource *cs)
{
	return __raw_readl(timer_base + MX1_2_TCN);
}

static cycle_t mx3_get_cycles(struct clocksource *cs)
{
	return __raw_readl(timer_base + MX3_TCN);
105
106
107
108
109
}

static struct clocksource clocksource_mxc = {
	.name 		= "mxc_timer1",
	.rating		= 200,
110
	.read		= mx1_2_get_cycles,
111
112
113
114
115
	.mask		= CLOCKSOURCE_MASK(32),
	.shift 		= 20,
	.flags		= CLOCK_SOURCE_IS_CONTINUOUS,
};

116
static int __init mxc_clocksource_init(struct clk *timer_clk)
117
{
118
	unsigned int c = clk_get_rate(timer_clk);
119

Sascha Hauer's avatar
Sascha Hauer committed
120
	if (cpu_is_mx3() || cpu_is_mx25())
121
122
		clocksource_mxc.read = mx3_get_cycles;

123
	clocksource_mxc.mult = clocksource_hz2mult(c,
124
125
126
127
128
129
130
131
					clocksource_mxc.shift);
	clocksource_register(&clocksource_mxc);

	return 0;
}

/* clock event */

132
static int mx1_2_set_next_event(unsigned long evt,
133
134
135
136
			      struct clock_event_device *unused)
{
	unsigned long tcmp;

137
	tcmp = __raw_readl(timer_base + MX1_2_TCN) + evt;
138

139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
	__raw_writel(tcmp, timer_base + MX1_2_TCMP);

	return (int)(tcmp - __raw_readl(timer_base + MX1_2_TCN)) < 0 ?
				-ETIME : 0;
}

static int mx3_set_next_event(unsigned long evt,
			      struct clock_event_device *unused)
{
	unsigned long tcmp;

	tcmp = __raw_readl(timer_base + MX3_TCN) + evt;

	__raw_writel(tcmp, timer_base + MX3_TCMP);

	return (int)(tcmp - __raw_readl(timer_base + MX3_TCN)) < 0 ?
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
				-ETIME : 0;
}

#ifdef DEBUG
static const char *clock_event_mode_label[] = {
	[CLOCK_EVT_MODE_PERIODIC] = "CLOCK_EVT_MODE_PERIODIC",
	[CLOCK_EVT_MODE_ONESHOT]  = "CLOCK_EVT_MODE_ONESHOT",
	[CLOCK_EVT_MODE_SHUTDOWN] = "CLOCK_EVT_MODE_SHUTDOWN",
	[CLOCK_EVT_MODE_UNUSED]   = "CLOCK_EVT_MODE_UNUSED"
};
#endif /* DEBUG */

static void mxc_set_mode(enum clock_event_mode mode,
				struct clock_event_device *evt)
{
	unsigned long flags;

	/*
	 * The timer interrupt generation is disabled at least
	 * for enough time to call mxc_set_next_event()
	 */
	local_irq_save(flags);

	/* Disable interrupt in GPT module */
	gpt_irq_disable();

	if (mode != clockevent_mode) {
		/* Set event time into far-far future */
Sascha Hauer's avatar
Sascha Hauer committed
183
		if (cpu_is_mx3() || cpu_is_mx25())
184
185
186
187
188
189
			__raw_writel(__raw_readl(timer_base + MX3_TCN) - 3,
					timer_base + MX3_TCMP);
		else
			__raw_writel(__raw_readl(timer_base + MX1_2_TCN) - 3,
					timer_base + MX1_2_TCMP);

190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
		/* Clear pending interrupt */
		gpt_irq_acknowledge();
	}

#ifdef DEBUG
	printk(KERN_INFO "mxc_set_mode: changing mode from %s to %s\n",
		clock_event_mode_label[clockevent_mode],
		clock_event_mode_label[mode]);
#endif /* DEBUG */

	/* Remember timer mode */
	clockevent_mode = mode;
	local_irq_restore(flags);

	switch (mode) {
	case CLOCK_EVT_MODE_PERIODIC:
		printk(KERN_ERR"mxc_set_mode: Periodic mode is not "
				"supported for i.MX\n");
		break;
	case CLOCK_EVT_MODE_ONESHOT:
	/*
	 * 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
	 */
		local_irq_save(flags);
		gpt_irq_enable();
		local_irq_restore(flags);
		break;
	case CLOCK_EVT_MODE_SHUTDOWN:
	case CLOCK_EVT_MODE_UNUSED:
	case CLOCK_EVT_MODE_RESUME:
		/* Left event sources disabled, no more interrupts appear */
		break;
	}
}

/*
 * IRQ handler for the timer
 */
static irqreturn_t mxc_timer_interrupt(int irq, void *dev_id)
{
	struct clock_event_device *evt = &clockevent_mxc;
	uint32_t tstat;

Sascha Hauer's avatar
Sascha Hauer committed
236
	if (cpu_is_mx3() || cpu_is_mx25())
237
		tstat = __raw_readl(timer_base + MX3_TSTAT);
238
239
	else
		tstat = __raw_readl(timer_base + MX1_2_TSTAT);
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258

	gpt_irq_acknowledge();

	evt->event_handler(evt);

	return IRQ_HANDLED;
}

static struct irqaction mxc_timer_irq = {
	.name		= "i.MX Timer Tick",
	.flags		= IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,
	.handler	= mxc_timer_interrupt,
};

static struct clock_event_device clockevent_mxc = {
	.name		= "mxc_timer1",
	.features	= CLOCK_EVT_FEAT_ONESHOT,
	.shift		= 32,
	.set_mode	= mxc_set_mode,
259
	.set_next_event	= mx1_2_set_next_event,
260
261
262
	.rating		= 200,
};

263
static int __init mxc_clockevent_init(struct clk *timer_clk)
264
{
265
	unsigned int c = clk_get_rate(timer_clk);
266

Sascha Hauer's avatar
Sascha Hauer committed
267
	if (cpu_is_mx3() || cpu_is_mx25())
268
269
		clockevent_mxc.set_next_event = mx3_set_next_event;

270
	clockevent_mxc.mult = div_sc(c, NSEC_PER_SEC,
271
272
273
274
275
276
					clockevent_mxc.shift);
	clockevent_mxc.max_delta_ns =
			clockevent_delta2ns(0xfffffffe, &clockevent_mxc);
	clockevent_mxc.min_delta_ns =
			clockevent_delta2ns(0xff, &clockevent_mxc);

277
	clockevent_mxc.cpumask = cpumask_of(0);
278
279
280
281
282
283

	clockevents_register_device(&clockevent_mxc);

	return 0;
}

284
void __init mxc_timer_init(struct clk *timer_clk, void __iomem *base, int irq)
285
{
286
287
	uint32_t tctl_val;

288
289
	clk_enable(timer_clk);

290
	timer_base = base;
291

292
293
294
295
	/*
	 * Initialise to a known state (all timers off, and timing reset)
	 */

296
297
298
	__raw_writel(0, timer_base + MXC_TCTL);
	__raw_writel(0, timer_base + MXC_TPRER); /* see datasheet note */

Sascha Hauer's avatar
Sascha Hauer committed
299
	if (cpu_is_mx3() || cpu_is_mx25())
300
301
302
303
304
		tctl_val = MX3_TCTL_CLK_IPG | MX3_TCTL_FRR | MX3_TCTL_WAITEN | MXC_TCTL_TEN;
	else
		tctl_val = MX1_2_TCTL_FRR | MX1_2_TCTL_CLK_PCLK1 | MXC_TCTL_TEN;

	__raw_writel(tctl_val, timer_base + MXC_TCTL);
305
306

	/* init and register the timer to the framework */
307
308
	mxc_clocksource_init(timer_clk);
	mxc_clockevent_init(timer_clk);
309
310

	/* Make irqs happen */
311
	setup_irq(irq, &mxc_timer_irq);
312
}