timer.c 19.4 KB
Newer Older
1
/*
2
 * linux/arch/arm/mach-omap2/timer.c
3 4 5
 *
 * OMAP2 GP timer support.
 *
6 7
 * Copyright (C) 2009 Nokia Corporation
 *
8 9 10 11 12
 * Update to use new clocksource/clockevent layers
 * Author: Kevin Hilman, MontaVista Software, Inc. <source@mvista.com>
 * Copyright (C) 2007 MontaVista Software, Inc.
 *
 * Original driver:
13 14
 * Copyright (C) 2005 Nokia Corporation
 * Author: Paul Mundt <paul.mundt@nokia.com>
15
 *         Juha Yrjölä <juha.yrjola@nokia.com>
16
 * OMAP Dual-mode timer framework support by Timo Teras
17 18 19
 *
 * Some parts based off of TI's 24xx code:
 *
20
 * Copyright (C) 2004-2009 Texas Instruments, Inc.
21 22
 *
 * Roughly modelled after the OMAP1 MPU timer code.
23
 * Added OMAP4 support - Santosh Shilimkar <santosh.shilimkar@ti.com>
24 25 26 27 28 29 30 31 32
 *
 * 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.
 */
#include <linux/init.h>
#include <linux/time.h>
#include <linux/interrupt.h>
#include <linux/err.h>
33
#include <linux/clk.h>
34
#include <linux/delay.h>
35
#include <linux/irq.h>
36 37
#include <linux/clocksource.h>
#include <linux/clockchips.h>
38
#include <linux/slab.h>
39
#include <linux/of.h>
40 41
#include <linux/of_address.h>
#include <linux/of_irq.h>
42 43
#include <linux/platform_device.h>
#include <linux/platform_data/dmtimer-omap.h>
44

45
#include <asm/mach/time.h>
46
#include <asm/smp_twd.h>
47
#include <asm/sched_clock.h>
48

49
#include <asm/arch_timer.h>
50
#include "omap_hwmod.h"
51
#include "omap_device.h"
52
#include <plat/counter-32k.h>
53
#include <plat/dmtimer.h>
54
#include "omap-pm.h"
55

56
#include "soc.h"
57
#include "common.h"
58
#include "powerdomain.h"
59

60 61 62 63 64
#define REALTIME_COUNTER_BASE				0x48243200
#define INCREMENTER_NUMERATOR_OFFSET			0x10
#define INCREMENTER_DENUMERATOR_RELOAD_OFFSET		0x14
#define NUMERATOR_DENUMERATOR_MASK			0xfffff000

65 66 67
/* Clockevent code */

static struct omap_dm_timer clkev;
68
static struct clock_event_device clockevent_gpt;
69

70
static irqreturn_t omap2_gp_timer_interrupt(int irq, void *dev_id)
71
{
72 73
	struct clock_event_device *evt = &clockevent_gpt;

74
	__omap_dm_timer_write_status(&clkev, OMAP_TIMER_INT_OVERFLOW);
75

76
	evt->event_handler(evt);
77 78 79 80
	return IRQ_HANDLED;
}

static struct irqaction omap2_gp_timer_irq = {
81
	.name		= "gp_timer",
B
Bernhard Walle 已提交
82
	.flags		= IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,
83 84 85
	.handler	= omap2_gp_timer_interrupt,
};

86 87
static int omap2_gp_timer_set_next_event(unsigned long cycles,
					 struct clock_event_device *evt)
88
{
89
	__omap_dm_timer_load_start(&clkev, OMAP_TIMER_CTRL_ST,
90
				   0xffffffff - cycles, OMAP_TIMER_POSTED);
91 92 93 94 95 96 97 98 99

	return 0;
}

static void omap2_gp_timer_set_mode(enum clock_event_mode mode,
				    struct clock_event_device *evt)
{
	u32 period;

100
	__omap_dm_timer_stop(&clkev, OMAP_TIMER_POSTED, clkev.rate);
101 102 103

	switch (mode) {
	case CLOCK_EVT_MODE_PERIODIC:
104
		period = clkev.rate / HZ;
105
		period -= 1;
106
		/* Looks like we need to first set the load value separately */
107
		__omap_dm_timer_write(&clkev, OMAP_TIMER_LOAD_REG,
108
				      0xffffffff - period, OMAP_TIMER_POSTED);
109
		__omap_dm_timer_load_start(&clkev,
110
					OMAP_TIMER_CTRL_AR | OMAP_TIMER_CTRL_ST,
111
					0xffffffff - period, OMAP_TIMER_POSTED);
112 113 114 115 116 117 118 119 120 121 122 123
		break;
	case CLOCK_EVT_MODE_ONESHOT:
		break;
	case CLOCK_EVT_MODE_UNUSED:
	case CLOCK_EVT_MODE_SHUTDOWN:
	case CLOCK_EVT_MODE_RESUME:
		break;
	}
}

static struct clock_event_device clockevent_gpt = {
	.features       = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,
124
	.rating		= 300,
125 126 127 128
	.set_next_event	= omap2_gp_timer_set_next_event,
	.set_mode	= omap2_gp_timer_set_mode,
};

129 130 131 132 133 134 135
static struct property device_disabled = {
	.name = "status",
	.length = sizeof("disabled"),
	.value = "disabled",
};

static struct of_device_id omap_timer_match[] __initdata = {
136 137 138 139 140 141
	{ .compatible = "ti,omap2420-timer", },
	{ .compatible = "ti,omap3430-timer", },
	{ .compatible = "ti,omap4430-timer", },
	{ .compatible = "ti,omap5430-timer", },
	{ .compatible = "ti,am335x-timer", },
	{ .compatible = "ti,am335x-timer-1ms", },
142 143 144
	{ }
};

145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161
/**
 * omap_get_timer_dt - get a timer using device-tree
 * @match	- device-tree match structure for matching a device type
 * @property	- optional timer property to match
 *
 * Helper function to get a timer during early boot using device-tree for use
 * as kernel system timer. Optionally, the property argument can be used to
 * select a timer with a specific property. Once a timer is found then mark
 * the timer node in device-tree as disabled, to prevent the kernel from
 * registering this timer as a platform device and so no one else can use it.
 */
static struct device_node * __init omap_get_timer_dt(struct of_device_id *match,
						     const char *property)
{
	struct device_node *np;

	for_each_matching_node(np, match) {
162
		if (!of_device_is_available(np))
163 164
			continue;

165
		if (property && !of_get_property(np, property, NULL))
166 167
			continue;

168 169 170 171 172 173
		if (!property && (of_get_property(np, "ti,timer-alwon", NULL) ||
				  of_get_property(np, "ti,timer-dsp", NULL) ||
				  of_get_property(np, "ti,timer-pwm", NULL) ||
				  of_get_property(np, "ti,timer-secure", NULL)))
			continue;

174
		of_add_property(np, &device_disabled);
175 176 177 178 179 180
		return np;
	}

	return NULL;
}

181 182 183 184 185 186 187 188
/**
 * omap_dmtimer_init - initialisation function when device tree is used
 *
 * For secure OMAP3 devices, timers with device type "timer-secure" cannot
 * be used by the kernel as they are reserved. Therefore, to prevent the
 * kernel registering these devices remove them dynamically from the device
 * tree on boot.
 */
189
static void __init omap_dmtimer_init(void)
190 191 192 193 194 195 196 197
{
	struct device_node *np;

	if (!cpu_is_omap34xx())
		return;

	/* If we are a secure device, remove any secure timer nodes */
	if ((omap_type() != OMAP2_DEVICE_TYPE_GP)) {
198 199 200
		np = omap_get_timer_dt(omap_timer_match, "ti,timer-secure");
		if (np)
			of_node_put(np);
201 202 203
	}
}

204 205 206 207 208
/**
 * omap_dm_timer_get_errata - get errata flags for a timer
 *
 * Get the timer errata flags that are specific to the OMAP device being used.
 */
209
static u32 __init omap_dm_timer_get_errata(void)
210 211 212 213 214 215 216
{
	if (cpu_is_omap24xx())
		return 0;

	return OMAP_TIMER_ERRATA_I103_I767;
}

217
static int __init omap_dm_timer_init_one(struct omap_dm_timer *timer,
218 219 220 221
					 const char *fck_source,
					 const char *property,
					 const char **timer_name,
					 int posted)
222
{
223
	char name[10]; /* 10 = sizeof("gptXX_Xck0") */
224 225
	const char *oh_name;
	struct device_node *np;
226
	struct omap_hwmod *oh;
227
	struct resource irq, mem;
228
	struct clk *src;
229
	int r = 0;
230

231
	if (of_have_populated_dt()) {
232
		np = omap_get_timer_dt(omap_timer_match, property);
233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
		if (!np)
			return -ENODEV;

		of_property_read_string_index(np, "ti,hwmods", 0, &oh_name);
		if (!oh_name)
			return -ENODEV;

		timer->irq = irq_of_parse_and_map(np, 0);
		if (!timer->irq)
			return -ENXIO;

		timer->io_base = of_iomap(np, 0);

		of_node_put(np);
	} else {
248
		if (omap_dm_timer_reserve_systimer(timer->id))
249 250
			return -ENODEV;

251
		sprintf(name, "timer%d", timer->id);
252 253 254 255
		oh_name = name;
	}

	oh = omap_hwmod_lookup(oh_name);
256 257 258
	if (!oh)
		return -ENODEV;

259 260
	*timer_name = oh->name;

261 262
	if (!of_have_populated_dt()) {
		r = omap_hwmod_get_resource_byname(oh, IORESOURCE_IRQ, NULL,
263
						   &irq);
264 265
		if (r)
			return -ENXIO;
266
		timer->irq = irq.start;
267 268

		r = omap_hwmod_get_resource_byname(oh, IORESOURCE_MEM, NULL,
269
						   &mem);
270 271 272 273
		if (r)
			return -ENXIO;

		/* Static mapping, never released */
274
		timer->io_base = ioremap(mem.start, mem.end - mem.start);
275
	}
276 277 278 279 280

	if (!timer->io_base)
		return -ENXIO;

	/* After the dmtimer is using hwmod these clocks won't be needed */
281
	timer->fclk = clk_get(NULL, omap_hwmod_get_main_clk(oh));
282
	if (IS_ERR(timer->fclk))
283
		return PTR_ERR(timer->fclk);
284

285 286 287
	src = clk_get(NULL, fck_source);
	if (IS_ERR(src))
		return PTR_ERR(src);
288

289 290 291 292 293
	if (clk_get_parent(timer->fclk) != src) {
		r = clk_set_parent(timer->fclk, src);
		if (r < 0) {
			pr_warn("%s: %s cannot set source\n", __func__,
				oh->name);
294
			clk_put(src);
295
			return r;
296 297
		}
	}
298

299 300
	clk_put(src);

301 302
	omap_hwmod_setup_one(oh_name);
	omap_hwmod_enable(oh);
303
	__omap_dm_timer_init_regs(timer);
304

305 306 307 308 309 310
	if (posted)
		__omap_dm_timer_enable_posted(timer);

	/* Check that the intended posted configuration matches the actual */
	if (posted != timer->posted)
		return -EINVAL;
311

312
	timer->rate = clk_get_rate(timer->fclk);
313
	timer->reserved = 1;
314

315
	return r;
316
}
317

318
static void __init omap2_gp_clockevent_init(int gptimer_id,
319 320
						const char *fck_source,
						const char *property)
321 322
{
	int res;
323

324
	clkev.id = gptimer_id;
325 326 327 328 329 330 331 332 333
	clkev.errata = omap_dm_timer_get_errata();

	/*
	 * For clock-event timers we never read the timer counter and
	 * so we are not impacted by errata i103 and i767. Therefore,
	 * we can safely ignore this errata for clock-event timers.
	 */
	__omap_dm_timer_override_errata(&clkev, OMAP_TIMER_ERRATA_I103_I767);

334
	res = omap_dm_timer_init_one(&clkev, fck_source, property,
335
				     &clockevent_gpt.name, OMAP_TIMER_POSTED);
336
	BUG_ON(res);
337

338
	omap2_gp_timer_irq.dev_id = &clkev;
339
	setup_irq(clkev.irq, &omap2_gp_timer_irq);
340

341
	__omap_dm_timer_int_enable(&clkev, OMAP_TIMER_INT_OVERFLOW);
342

343 344
	clockevent_gpt.cpumask = cpu_possible_mask;
	clockevent_gpt.irq = omap_dm_timer_get_irq(&clkev);
345 346 347
	clockevents_config_and_register(&clockevent_gpt, clkev.rate,
					3, /* Timer internal resynch latency */
					0xffffffff);
348

349 350
	pr_info("OMAP clockevent source: %s at %lu Hz\n", clockevent_gpt.name,
		clkev.rate);
351 352
}

353
/* Clocksource code */
354
static struct omap_dm_timer clksrc;
355
static bool use_gptimer_clksrc;
356

357 358 359
/*
 * clocksource
 */
360
static cycle_t clocksource_read_cycles(struct clocksource *cs)
361
{
362
	return (cycle_t)__omap_dm_timer_read_counter(&clksrc,
363
						     OMAP_TIMER_NONPOSTED);
364 365 366 367 368 369 370 371 372
}

static struct clocksource clocksource_gpt = {
	.rating		= 300,
	.read		= clocksource_read_cycles,
	.mask		= CLOCKSOURCE_MASK(32),
	.flags		= CLOCK_SOURCE_IS_CONTINUOUS,
};

373
static u32 notrace dmtimer_read_sched_clock(void)
374
{
375
	if (clksrc.reserved)
376
		return __omap_dm_timer_read_counter(&clksrc,
377
						    OMAP_TIMER_NONPOSTED);
378

379
	return 0;
380 381
}

382 383 384 385 386
static struct of_device_id omap_counter_match[] __initdata = {
	{ .compatible = "ti,omap-counter32k", },
	{ }
};

387
/* Setup free-running counter for clocksource */
J
Jon Hunter 已提交
388
static int __init __maybe_unused omap2_sync32k_clocksource_init(void)
389 390
{
	int ret;
391
	struct device_node *np = NULL;
392 393 394 395
	struct omap_hwmod *oh;
	void __iomem *vbase;
	const char *oh_name = "counter_32k";

396 397 398 399 400 401 402 403 404 405 406 407 408 409
	/*
	 * If device-tree is present, then search the DT blob
	 * to see if the 32kHz counter is supported.
	 */
	if (of_have_populated_dt()) {
		np = omap_get_timer_dt(omap_counter_match, NULL);
		if (!np)
			return -ENODEV;

		of_property_read_string_index(np, "ti,hwmods", 0, &oh_name);
		if (!oh_name)
			return -ENODEV;
	}

410 411 412 413 414 415 416 417 418
	/*
	 * First check hwmod data is available for sync32k counter
	 */
	oh = omap_hwmod_lookup(oh_name);
	if (!oh || oh->slaves_cnt == 0)
		return -ENODEV;

	omap_hwmod_setup_one(oh_name);

419 420 421 422 423 424 425
	if (np) {
		vbase = of_iomap(np, 0);
		of_node_put(np);
	} else {
		vbase = omap_hwmod_get_mpu_rt_va(oh);
	}

426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
	if (!vbase) {
		pr_warn("%s: failed to get counter_32k resource\n", __func__);
		return -ENXIO;
	}

	ret = omap_hwmod_enable(oh);
	if (ret) {
		pr_warn("%s: failed to enable counter_32k module (%d)\n",
							__func__, ret);
		return ret;
	}

	ret = omap_init_clocksource_32k(vbase);
	if (ret) {
		pr_warn("%s: failed to initialize counter_32k as a clocksource (%d)\n",
							__func__, ret);
		omap_hwmod_idle(oh);
	}

	return ret;
}

static void __init omap2_gptimer_clocksource_init(int gptimer_id,
449 450
						  const char *fck_source,
						  const char *property)
451 452 453
{
	int res;

454
	clksrc.id = gptimer_id;
455 456
	clksrc.errata = omap_dm_timer_get_errata();

457
	res = omap_dm_timer_init_one(&clksrc, fck_source, property,
458
				     &clocksource_gpt.name,
459
				     OMAP_TIMER_NONPOSTED);
460
	BUG_ON(res);
461

462
	__omap_dm_timer_load_start(&clksrc,
463
				   OMAP_TIMER_CTRL_ST | OMAP_TIMER_CTRL_AR, 0,
464
				   OMAP_TIMER_NONPOSTED);
465
	setup_sched_clock(dmtimer_read_sched_clock, 32, clksrc.rate);
466

467 468 469
	if (clocksource_register_hz(&clocksource_gpt, clksrc.rate))
		pr_err("Could not register clocksource %s\n",
			clocksource_gpt.name);
470
	else
471 472
		pr_info("OMAP clocksource: %s at %lu Hz\n",
			clocksource_gpt.name, clksrc.rate);
473 474
}

475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496
#ifdef CONFIG_SOC_HAS_REALTIME_COUNTER
/*
 * The realtime counter also called master counter, is a free-running
 * counter, which is related to real time. It produces the count used
 * by the CPU local timer peripherals in the MPU cluster. The timer counts
 * at a rate of 6.144 MHz. Because the device operates on different clocks
 * in different power modes, the master counter shifts operation between
 * clocks, adjusting the increment per clock in hardware accordingly to
 * maintain a constant count rate.
 */
static void __init realtime_counter_init(void)
{
	void __iomem *base;
	static struct clk *sys_clk;
	unsigned long rate;
	unsigned int reg, num, den;

	base = ioremap(REALTIME_COUNTER_BASE, SZ_32);
	if (!base) {
		pr_err("%s: ioremap failed\n", __func__);
		return;
	}
497
	sys_clk = clk_get(NULL, "sys_clkin");
498
	if (IS_ERR(sys_clk)) {
499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552
		pr_err("%s: failed to get system clock handle\n", __func__);
		iounmap(base);
		return;
	}

	rate = clk_get_rate(sys_clk);
	/* Numerator/denumerator values refer TRM Realtime Counter section */
	switch (rate) {
	case 1200000:
		num = 64;
		den = 125;
		break;
	case 1300000:
		num = 768;
		den = 1625;
		break;
	case 19200000:
		num = 8;
		den = 25;
		break;
	case 2600000:
		num = 384;
		den = 1625;
		break;
	case 2700000:
		num = 256;
		den = 1125;
		break;
	case 38400000:
	default:
		/* Program it for 38.4 MHz */
		num = 4;
		den = 25;
		break;
	}

	/* Program numerator and denumerator registers */
	reg = __raw_readl(base + INCREMENTER_NUMERATOR_OFFSET) &
			NUMERATOR_DENUMERATOR_MASK;
	reg |= num;
	__raw_writel(reg, base + INCREMENTER_NUMERATOR_OFFSET);

	reg = __raw_readl(base + INCREMENTER_NUMERATOR_OFFSET) &
			NUMERATOR_DENUMERATOR_MASK;
	reg |= den;
	__raw_writel(reg, base + INCREMENTER_DENUMERATOR_RELOAD_OFFSET);

	iounmap(base);
}
#else
static inline void __init realtime_counter_init(void)
{}
#endif

553
#define OMAP_SYS_GP_TIMER_INIT(name, clkev_nr, clkev_src, clkev_prop,	\
554
			       clksrc_nr, clksrc_src, clksrc_prop)	\
S
Stephen Warren 已提交
555
void __init omap##name##_gptimer_timer_init(void)			\
556 557 558
{									\
	omap_dmtimer_init();						\
	omap2_gp_clockevent_init((clkev_nr), clkev_src, clkev_prop);	\
559 560
	omap2_gptimer_clocksource_init((clksrc_nr), clksrc_src,		\
					clksrc_prop);			\
561 562 563
}

#define OMAP_SYS_32K_TIMER_INIT(name, clkev_nr, clkev_src, clkev_prop,	\
564
				clksrc_nr, clksrc_src, clksrc_prop)	\
S
Stephen Warren 已提交
565
void __init omap##name##_sync32k_timer_init(void)		\
566
{									\
567
	omap_dmtimer_init();						\
568
	omap2_gp_clockevent_init((clkev_nr), clkev_src, clkev_prop);	\
569 570
	/* Enable the use of clocksource="gp_timer" kernel parameter */	\
	if (use_gptimer_clksrc)						\
571 572
		omap2_gptimer_clocksource_init((clksrc_nr), clksrc_src,	\
						clksrc_prop);		\
573 574
	else								\
		omap2_sync32k_clocksource_init();			\
575 576 577
}

#ifdef CONFIG_ARCH_OMAP2
578
OMAP_SYS_32K_TIMER_INIT(2, 1, "timer_32k_ck", "ti,timer-alwon",
579
			2, "timer_sys_ck", NULL);
580
#endif /* CONFIG_ARCH_OMAP2 */
581 582

#ifdef CONFIG_ARCH_OMAP3
583
OMAP_SYS_32K_TIMER_INIT(3, 1, "timer_32k_ck", "ti,timer-alwon",
584
			2, "timer_sys_ck", NULL);
585
OMAP_SYS_32K_TIMER_INIT(3_secure, 12, "secure_32k_fck", "ti,timer-secure",
586
			2, "timer_sys_ck", NULL);
587
#endif /* CONFIG_ARCH_OMAP3 */
588

589
#if defined(CONFIG_ARCH_OMAP3) || defined(CONFIG_SOC_AM33XX)
590 591
OMAP_SYS_GP_TIMER_INIT(3, 2, "timer_sys_ck", NULL,
		       1, "timer_sys_ck", "ti,timer-alwon");
592
#endif
593

594
#if defined(CONFIG_ARCH_OMAP4) || defined(CONFIG_SOC_OMAP5)
595 596
static OMAP_SYS_32K_TIMER_INIT(4, 1, "timer_32k_ck", "ti,timer-alwon",
			       2, "sys_clkin_ck", NULL);
597
#endif
598

599
#ifdef CONFIG_ARCH_OMAP4
600
#ifdef CONFIG_LOCAL_TIMERS
601
static DEFINE_TWD_LOCAL_TIMER(twd_local_timer, OMAP44XX_LOCAL_TWD_BASE, 29);
S
Stephen Warren 已提交
602
void __init omap4_local_timer_init(void)
603
{
604
	omap4_sync32k_timer_init();
605 606 607 608
	/* Local timers are not supprted on OMAP4430 ES1.0 */
	if (omap_rev() != OMAP4430_REV_ES1_0) {
		int err;

609
		if (of_have_populated_dt()) {
610
			clocksource_of_init();
611 612 613
			return;
		}

614 615 616 617
		err = twd_local_timer_register(&twd_local_timer);
		if (err)
			pr_err("twd_local_timer_register failed %d\n", err);
	}
618
}
619
#else /* CONFIG_LOCAL_TIMERS */
S
Stephen Warren 已提交
620
void __init omap4_local_timer_init(void)
621
{
622
	omap4_sync32k_timer_init();
623 624 625
}
#endif /* CONFIG_LOCAL_TIMERS */
#endif /* CONFIG_ARCH_OMAP4 */
626

627
#ifdef CONFIG_SOC_OMAP5
S
Stephen Warren 已提交
628
void __init omap5_realtime_timer_init(void)
629
{
630 631
	int err;

632
	omap4_sync32k_timer_init();
633
	realtime_counter_init();
634 635 636 637

	err = arch_timer_of_register();
	if (err)
		pr_err("%s: arch_timer_register failed %d\n", __func__, err);
638
}
639
#endif /* CONFIG_SOC_OMAP5 */
640

641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
/**
 * omap_timer_init - build and register timer device with an
 * associated timer hwmod
 * @oh:	timer hwmod pointer to be used to build timer device
 * @user:	parameter that can be passed from calling hwmod API
 *
 * Called by omap_hwmod_for_each_by_class to register each of the timer
 * devices present in the system. The number of timer devices is known
 * by parsing through the hwmod database for a given class name. At the
 * end of function call memory is allocated for timer device and it is
 * registered to the framework ready to be proved by the driver.
 */
static int __init omap_timer_init(struct omap_hwmod *oh, void *unused)
{
	int id;
	int ret = 0;
	char *name = "omap_timer";
	struct dmtimer_platform_data *pdata;
659
	struct platform_device *pdev;
660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687
	struct omap_timer_capability_dev_attr *timer_dev_attr;

	pr_debug("%s: %s\n", __func__, oh->name);

	/* on secure device, do not register secure timer */
	timer_dev_attr = oh->dev_attr;
	if (omap_type() != OMAP2_DEVICE_TYPE_GP && timer_dev_attr)
		if (timer_dev_attr->timer_capability == OMAP_TIMER_SECURE)
			return ret;

	pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
	if (!pdata) {
		pr_err("%s: No memory for [%s]\n", __func__, oh->name);
		return -ENOMEM;
	}

	/*
	 * Extract the IDs from name field in hwmod database
	 * and use the same for constructing ids' for the
	 * timer devices. In a way, we are avoiding usage of
	 * static variable witin the function to do the same.
	 * CAUTION: We have to be careful and make sure the
	 * name in hwmod database does not change in which case
	 * we might either make corresponding change here or
	 * switch back static variable mechanism.
	 */
	sscanf(oh->name, "timer%2d", &id);

688 689
	if (timer_dev_attr)
		pdata->timer_capability = timer_dev_attr->timer_capability;
690

691
	pdata->timer_errata = omap_dm_timer_get_errata();
692 693
	pdata->get_context_loss_count = omap_pm_get_dev_context_loss_count;

694
	pdev = omap_device_build(name, id, oh, pdata, sizeof(*pdata));
695

696
	if (IS_ERR(pdev)) {
697 698 699 700 701 702 703 704 705
		pr_err("%s: Can't build omap_device for %s: %s.\n",
			__func__, name, oh->name);
		ret = -EINVAL;
	}

	kfree(pdata);

	return ret;
}
706 707 708 709 710 711 712 713 714 715 716

/**
 * omap2_dm_timer_init - top level regular device initialization
 *
 * Uses dedicated hwmod api to parse through hwmod database for
 * given class name and then build and register the timer device.
 */
static int __init omap2_dm_timer_init(void)
{
	int ret;

717 718 719 720
	/* If dtb is there, the devices will be created dynamically */
	if (of_have_populated_dt())
		return -ENODEV;

721 722 723 724 725 726 727 728
	ret = omap_hwmod_for_each_by_class("timer", omap_timer_init, NULL);
	if (unlikely(ret)) {
		pr_err("%s: device registration failed.\n", __func__);
		return -EINVAL;
	}

	return 0;
}
T
Tony Lindgren 已提交
729
omap_arch_initcall(omap2_dm_timer_init);
730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754

/**
 * omap2_override_clocksource - clocksource override with user configuration
 *
 * Allows user to override default clocksource, using kernel parameter
 *   clocksource="gp_timer"	(For all OMAP2PLUS architectures)
 *
 * Note that, here we are using same standard kernel parameter "clocksource=",
 * and not introducing any OMAP specific interface.
 */
static int __init omap2_override_clocksource(char *str)
{
	if (!str)
		return 0;
	/*
	 * For OMAP architecture, we only have two options
	 *    - sync_32k (default)
	 *    - gp_timer (sys_clk based)
	 */
	if (!strcmp(str, "gp_timer"))
		use_gptimer_clksrc = true;

	return 0;
}
early_param("clocksource", omap2_override_clocksource);