time.c 9.85 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/*
 * DaVinci timer subsystem
 *
 * Author: Kevin Hilman, MontaVista Software, Inc. <source@mvista.com>
 *
 * 2007 (c) MontaVista Software, Inc. This file is licensed under
 * the terms of the GNU General Public License version 2. This program
 * is licensed "as is" without any warranty of any kind, whether express
 * or implied.
 */
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/interrupt.h>
#include <linux/clocksource.h>
#include <linux/clockchips.h>
17
#include <linux/io.h>
18
19
#include <linux/clk.h>
#include <linux/err.h>
20
#include <linux/of.h>
21
#include <linux/platform_device.h>
22
#include <linux/sched_clock.h>
23
24
25

#include <asm/mach/irq.h>
#include <asm/mach/time.h>
26

27
#include <mach/cputype.h>
28
#include <mach/hardware.h>
29
#include <mach/time.h>
30

31
static struct clock_event_device clockevent_davinci;
32
static unsigned int davinci_clock_tick_rate;
33
34
35
36
37

/*
 * This driver configures the 2 64-bit count-up timers as 4 independent
 * 32-bit count-up timers used as follows:
 */
38
39
40
41
42

enum {
	TID_CLOCKEVENT,
	TID_CLOCKSOURCE,
};
43
44

/* Timer register offsets */
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
#define PID12			0x0
#define TIM12			0x10
#define TIM34			0x14
#define PRD12			0x18
#define PRD34			0x1c
#define TCR			0x20
#define TGCR			0x24
#define WDTCR			0x28

/* Offsets of the 8 compare registers */
#define	CMP12_0			0x60
#define	CMP12_1			0x64
#define	CMP12_2			0x68
#define	CMP12_3			0x6c
#define	CMP12_4			0x70
#define	CMP12_5			0x74
#define	CMP12_6			0x78
#define	CMP12_7			0x7c
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

/* Timer register bitfields */
#define TCR_ENAMODE_DISABLE          0x0
#define TCR_ENAMODE_ONESHOT          0x1
#define TCR_ENAMODE_PERIODIC         0x2
#define TCR_ENAMODE_MASK             0x3

#define TGCR_TIMMODE_SHIFT           2
#define TGCR_TIMMODE_64BIT_GP        0x0
#define TGCR_TIMMODE_32BIT_UNCHAINED 0x1
#define TGCR_TIMMODE_64BIT_WDOG      0x2
#define TGCR_TIMMODE_32BIT_CHAINED   0x3

#define TGCR_TIM12RS_SHIFT           0
#define TGCR_TIM34RS_SHIFT           1
#define TGCR_RESET                   0x0
#define TGCR_UNRESET                 0x1
#define TGCR_RESET_MASK              0x3

struct timer_s {
	char *name;
	unsigned int id;
	unsigned long period;
	unsigned long opts;
87
	unsigned long flags;
88
89
90
	void __iomem *base;
	unsigned long tim_off;
	unsigned long prd_off;
91
92
93
94
95
96
	unsigned long enamode_shift;
	struct irqaction irqaction;
};
static struct timer_s timers[];

/* values for 'opts' field of struct timer_s */
97
98
99
100
101
102
103
#define TIMER_OPTS_DISABLED		0x01
#define TIMER_OPTS_ONESHOT		0x02
#define TIMER_OPTS_PERIODIC		0x04
#define TIMER_OPTS_STATE_MASK		0x07

#define TIMER_OPTS_USE_COMPARE		0x80000000
#define USING_COMPARE(t)		((t)->opts & TIMER_OPTS_USE_COMPARE)
104

105
106
107
108
109
110
111
static char *id_to_name[] = {
	[T0_BOT]	= "timer0_0",
	[T0_TOP]	= "timer0_1",
	[T1_BOT]	= "timer1_0",
	[T1_TOP]	= "timer1_1",
};

112
113
static int timer32_config(struct timer_s *t)
{
114
	u32 tcr;
115
	struct davinci_soc_info *soc_info = &davinci_soc_info;
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

	if (USING_COMPARE(t)) {
		struct davinci_timer_instance *dtip =
				soc_info->timer_info->timers;
		int event_timer = ID_TO_TIMER(timers[TID_CLOCKEVENT].id);

		/*
		 * Next interrupt should be the current time reg value plus
		 * the new period (using 32-bit unsigned addition/wrapping
		 * to 0 on overflow).  This assumes that the clocksource
		 * is setup to count to 2^32-1 before wrapping around to 0.
		 */
		__raw_writel(__raw_readl(t->base + t->tim_off) + t->period,
			t->base + dtip[event_timer].cmp_off);
	} else {
		tcr = __raw_readl(t->base + TCR);

		/* disable timer */
		tcr &= ~(TCR_ENAMODE_MASK << t->enamode_shift);
		__raw_writel(tcr, t->base + TCR);

		/* reset counter to zero, set new period */
		__raw_writel(0, t->base + t->tim_off);
		__raw_writel(t->period, t->base + t->prd_off);

		/* Set enable mode */
		if (t->opts & TIMER_OPTS_ONESHOT)
			tcr |= TCR_ENAMODE_ONESHOT << t->enamode_shift;
		else if (t->opts & TIMER_OPTS_PERIODIC)
			tcr |= TCR_ENAMODE_PERIODIC << t->enamode_shift;

		__raw_writel(tcr, t->base + TCR);
148
149
150
151
152
153
	}
	return 0;
}

static inline u32 timer32_read(struct timer_s *t)
{
154
	return __raw_readl(t->base + t->tim_off);
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
}

static irqreturn_t timer_interrupt(int irq, void *dev_id)
{
	struct clock_event_device *evt = &clockevent_davinci;

	evt->event_handler(evt);
	return IRQ_HANDLED;
}

/* called when 32-bit counter wraps */
static irqreturn_t freerun_interrupt(int irq, void *dev_id)
{
	return IRQ_HANDLED;
}

static struct timer_s timers[] = {
	[TID_CLOCKEVENT] = {
		.name      = "clockevent",
		.opts      = TIMER_OPTS_DISABLED,
		.irqaction = {
176
			.flags   = IRQF_TIMER,
177
178
179
180
181
182
183
184
			.handler = timer_interrupt,
		}
	},
	[TID_CLOCKSOURCE] = {
		.name       = "free-run counter",
		.period     = ~0,
		.opts       = TIMER_OPTS_PERIODIC,
		.irqaction = {
185
			.flags   = IRQF_TIMER,
186
187
188
189
190
191
192
			.handler = freerun_interrupt,
		}
	},
};

static void __init timer_init(void)
{
193
194
	struct davinci_soc_info *soc_info = &davinci_soc_info;
	struct davinci_timer_instance *dtip = soc_info->timer_info->timers;
195
	void __iomem *base[2];
196
197
198
199
	int i;

	/* Global init of each 64-bit timer as a whole */
	for(i=0; i<2; i++) {
200
		u32 tgcr;
201
202
203
204

		base[i] = ioremap(dtip[i].base, SZ_4K);
		if (WARN_ON(!base[i]))
			continue;
205
206

		/* Disabled, Internal clock source */
207
		__raw_writel(0, base[i] + TCR);
208
209
210

		/* reset both timers, no pre-scaler for timer34 */
		tgcr = 0;
211
		__raw_writel(tgcr, base[i] + TGCR);
212
213
214

		/* Set both timers to unchained 32-bit */
		tgcr = TGCR_TIMMODE_32BIT_UNCHAINED << TGCR_TIMMODE_SHIFT;
215
		__raw_writel(tgcr, base[i] + TGCR);
216
217
218
219

		/* Unreset timers */
		tgcr |= (TGCR_UNRESET << TGCR_TIM12RS_SHIFT) |
			(TGCR_UNRESET << TGCR_TIM34RS_SHIFT);
220
		__raw_writel(tgcr, base[i] + TGCR);
221
222

		/* Init both counters to zero */
223
224
		__raw_writel(0, base[i] + TIM12);
		__raw_writel(0, base[i] + TIM34);
225
226
227
228
229
	}

	/* Init of each timer as a 32-bit timer */
	for (i=0; i< ARRAY_SIZE(timers); i++) {
		struct timer_s *t = &timers[i];
230
231
232
		int timer = ID_TO_TIMER(t->id);
		u32 irq;

233
234
235
		t->base = base[timer];
		if (!t->base)
			continue;
236
237
238
239
240
241
242
243
244
245
246

		if (IS_TIMER_BOT(t->id)) {
			t->enamode_shift = 6;
			t->tim_off = TIM12;
			t->prd_off = PRD12;
			irq = dtip[timer].bottom_irq;
		} else {
			t->enamode_shift = 22;
			t->tim_off = TIM34;
			t->prd_off = PRD34;
			irq = dtip[timer].top_irq;
247
		}
248
249
250
251

		/* Register interrupt */
		t->irqaction.name = t->name;
		t->irqaction.dev_id = (void *)t;
252
253
254

		if (t->irqaction.handler != NULL) {
			irq = USING_COMPARE(t) ? dtip[i].cmp_irq : irq;
255
			setup_irq(irq, &t->irqaction);
256
		}
257
258
259
260
261
262
	}
}

/*
 * clocksource
 */
263
static u64 read_cycles(struct clocksource *cs)
264
265
266
267
268
269
270
271
{
	struct timer_s *t = &timers[TID_CLOCKSOURCE];

	return (cycles_t)timer32_read(t);
}

static struct clocksource clocksource_davinci = {
	.rating		= 300,
272
	.read		= read_cycles,
273
274
275
276
	.mask		= CLOCKSOURCE_MASK(32),
	.flags		= CLOCK_SOURCE_IS_CONTINUOUS,
};

277
278
279
/*
 * Overwrite weak default sched_clock with something more precise
 */
280
static u64 notrace davinci_read_sched_clock(void)
281
{
282
	return timer32_read(&timers[TID_CLOCKSOURCE]);
283
284
}

285
286
287
288
289
290
291
292
293
294
295
296
297
/*
 * clockevent
 */
static int davinci_set_next_event(unsigned long cycles,
				  struct clock_event_device *evt)
{
	struct timer_s *t = &timers[TID_CLOCKEVENT];

	t->period = cycles;
	timer32_config(t);
	return 0;
}

298
static int davinci_shutdown(struct clock_event_device *evt)
299
300
301
{
	struct timer_s *t = &timers[TID_CLOCKEVENT];

302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
	t->opts &= ~TIMER_OPTS_STATE_MASK;
	t->opts |= TIMER_OPTS_DISABLED;
	return 0;
}

static int davinci_set_oneshot(struct clock_event_device *evt)
{
	struct timer_s *t = &timers[TID_CLOCKEVENT];

	t->opts &= ~TIMER_OPTS_STATE_MASK;
	t->opts |= TIMER_OPTS_ONESHOT;
	return 0;
}

static int davinci_set_periodic(struct clock_event_device *evt)
{
	struct timer_s *t = &timers[TID_CLOCKEVENT];

	t->period = davinci_clock_tick_rate / (HZ);
	t->opts &= ~TIMER_OPTS_STATE_MASK;
	t->opts |= TIMER_OPTS_PERIODIC;
	timer32_config(t);
	return 0;
325
326
327
}

static struct clock_event_device clockevent_davinci = {
328
329
330
331
332
333
	.features		= CLOCK_EVT_FEAT_PERIODIC |
				  CLOCK_EVT_FEAT_ONESHOT,
	.set_next_event		= davinci_set_next_event,
	.set_state_shutdown	= davinci_shutdown,
	.set_state_periodic	= davinci_set_periodic,
	.set_state_oneshot	= davinci_set_oneshot,
334
335
};

336
void __init davinci_timer_init(struct clk *timer_clk)
337
{
338
	struct davinci_soc_info *soc_info = &davinci_soc_info;
339
340
	unsigned int clockevent_id;
	unsigned int clocksource_id;
341
	int i;
342

343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
	clockevent_id = soc_info->timer_info->clockevent_id;
	clocksource_id = soc_info->timer_info->clocksource_id;

	timers[TID_CLOCKEVENT].id = clockevent_id;
	timers[TID_CLOCKSOURCE].id = clocksource_id;

	/*
	 * If using same timer for both clock events & clocksource,
	 * a compare register must be used to generate an event interrupt.
	 * This is equivalent to a oneshot timer only (not periodic).
	 */
	if (clockevent_id == clocksource_id) {
		struct davinci_timer_instance *dtip =
				soc_info->timer_info->timers;
		int event_timer = ID_TO_TIMER(clockevent_id);

		/* Only bottom timers can use compare regs */
		if (IS_TIMER_TOP(clockevent_id))
361
362
			pr_warn("%s: Invalid use of system timers.  Results unpredictable.\n",
				__func__);
363
364
		else if ((dtip[event_timer].cmp_off == 0)
				|| (dtip[event_timer].cmp_irq == 0))
365
366
			pr_warn("%s: Invalid timer instance setup.  Results unpredictable.\n",
				__func__);
367
368
369
370
371
		else {
			timers[TID_CLOCKEVENT].opts |= TIMER_OPTS_USE_COMPARE;
			clockevent_davinci.features = CLOCK_EVT_FEAT_ONESHOT;
		}
	}
372

373
	BUG_ON(IS_ERR(timer_clk));
374
	clk_prepare_enable(timer_clk);
375

376
377
378
	/* init timer hw */
	timer_init();

379
380
	davinci_clock_tick_rate = clk_get_rate(timer_clk);

381
	/* setup clocksource */
382
	clocksource_davinci.name = id_to_name[clocksource_id];
383
384
	if (clocksource_register_hz(&clocksource_davinci,
				    davinci_clock_tick_rate))
385
386
		pr_err("%s: can't register clocksource!\n",
		       clocksource_davinci.name);
387

388
	sched_clock_register(davinci_read_sched_clock, 32,
389
390
			  davinci_clock_tick_rate);

391
	/* setup clockevent */
392
	clockevent_davinci.name = id_to_name[timers[TID_CLOCKEVENT].id];
393

394
	clockevent_davinci.cpumask = cpumask_of(0);
395
396
	clockevents_config_and_register(&clockevent_davinci,
					davinci_clock_tick_rate, 1, 0xfffffffe);
397
398
399

	for (i=0; i< ARRAY_SIZE(timers); i++)
		timer32_config(&timers[i]);
400
}