timer.c 20.1 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
#include <linux/sched_clock.h>
45

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

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

55
#include "soc.h"
56
#include "common.h"
57
#include "control.h"
58
#include "powerdomain.h"
59
#include "omap-secure.h"
60

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

66 67 68
/* Clockevent code */

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

71
#ifdef CONFIG_SOC_HAS_REALTIME_COUNTER
72 73 74 75 76 77
static unsigned long arch_timer_freq;

void set_cntfreq(void)
{
	omap_smc1(OMAP5_DRA7_MON_SET_CNTFRQ_INDEX, arch_timer_freq);
}
78
#endif
79

80
static irqreturn_t omap2_gp_timer_interrupt(int irq, void *dev_id)
81
{
82 83
	struct clock_event_device *evt = &clockevent_gpt;

84
	__omap_dm_timer_write_status(&clkev, OMAP_TIMER_INT_OVERFLOW);
85

86
	evt->event_handler(evt);
87 88 89 90
	return IRQ_HANDLED;
}

static struct irqaction omap2_gp_timer_irq = {
91
	.name		= "gp_timer",
92
	.flags		= IRQF_TIMER | IRQF_IRQPOLL,
93 94 95
	.handler	= omap2_gp_timer_interrupt,
};

96 97
static int omap2_gp_timer_set_next_event(unsigned long cycles,
					 struct clock_event_device *evt)
98
{
99
	__omap_dm_timer_load_start(&clkev, OMAP_TIMER_CTRL_ST,
100
				   0xffffffff - cycles, OMAP_TIMER_POSTED);
101 102 103 104

	return 0;
}

105 106 107 108 109 110 111
static int omap2_gp_timer_shutdown(struct clock_event_device *evt)
{
	__omap_dm_timer_stop(&clkev, OMAP_TIMER_POSTED, clkev.rate);
	return 0;
}

static int omap2_gp_timer_set_periodic(struct clock_event_device *evt)
112 113 114
{
	u32 period;

115
	__omap_dm_timer_stop(&clkev, OMAP_TIMER_POSTED, clkev.rate);
116

117 118 119 120 121 122 123 124 125
	period = clkev.rate / HZ;
	period -= 1;
	/* Looks like we need to first set the load value separately */
	__omap_dm_timer_write(&clkev, OMAP_TIMER_LOAD_REG, 0xffffffff - period,
			      OMAP_TIMER_POSTED);
	__omap_dm_timer_load_start(&clkev,
				   OMAP_TIMER_CTRL_AR | OMAP_TIMER_CTRL_ST,
				   0xffffffff - period, OMAP_TIMER_POSTED);
	return 0;
126 127 128
}

static struct clock_event_device clockevent_gpt = {
129 130 131 132 133 134 135 136
	.features		= CLOCK_EVT_FEAT_PERIODIC |
				  CLOCK_EVT_FEAT_ONESHOT,
	.rating			= 300,
	.set_next_event		= omap2_gp_timer_set_next_event,
	.set_state_shutdown	= omap2_gp_timer_shutdown,
	.set_state_periodic	= omap2_gp_timer_set_periodic,
	.set_state_oneshot	= omap2_gp_timer_shutdown,
	.tick_resume		= omap2_gp_timer_shutdown,
137 138
};

139 140 141 142 143 144
static struct property device_disabled = {
	.name = "status",
	.length = sizeof("disabled"),
	.value = "disabled",
};

145
static const struct of_device_id omap_timer_match[] __initconst = {
146 147 148 149
	{ .compatible = "ti,omap2420-timer", },
	{ .compatible = "ti,omap3430-timer", },
	{ .compatible = "ti,omap4430-timer", },
	{ .compatible = "ti,omap5430-timer", },
150 151
	{ .compatible = "ti,dm814-timer", },
	{ .compatible = "ti,dm816-timer", },
152 153
	{ .compatible = "ti,am335x-timer", },
	{ .compatible = "ti,am335x-timer-1ms", },
154 155 156
	{ }
};

157 158 159 160 161 162 163 164 165 166 167
/**
 * 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.
 */
168
static struct device_node * __init omap_get_timer_dt(const struct of_device_id *match,
169 170 171 172 173
						     const char *property)
{
	struct device_node *np;

	for_each_matching_node(np, match) {
174
		if (!of_device_is_available(np))
175 176
			continue;

177
		if (property && !of_get_property(np, property, NULL))
178 179
			continue;

180 181 182 183 184 185
		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;

186 187
		if (!of_device_is_compatible(np, "ti,omap-counter32k"))
			of_add_property(np, &device_disabled);
188 189 190 191 192 193
		return np;
	}

	return NULL;
}

194 195 196 197 198 199 200 201
/**
 * 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.
 */
202
static void __init omap_dmtimer_init(void)
203 204 205 206 207 208 209 210
{
	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)) {
211
		np = omap_get_timer_dt(omap_timer_match, "ti,timer-secure");
212
		of_node_put(np);
213 214 215
	}
}

216 217 218 219 220
/**
 * 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.
 */
221
static u32 __init omap_dm_timer_get_errata(void)
222 223 224 225 226 227 228
{
	if (cpu_is_omap24xx())
		return 0;

	return OMAP_TIMER_ERRATA_I103_I767;
}

229
static int __init omap_dm_timer_init_one(struct omap_dm_timer *timer,
230 231 232 233
					 const char *fck_source,
					 const char *property,
					 const char **timer_name,
					 int posted)
234
{
235
	char name[10]; /* 10 = sizeof("gptXX_Xck0") */
236
	const char *oh_name = NULL;
237
	struct device_node *np;
238
	struct omap_hwmod *oh;
239
	struct resource irq, mem;
240
	struct clk *src;
241
	int r = 0;
242

243
	if (of_have_populated_dt()) {
244
		np = omap_get_timer_dt(omap_timer_match, property);
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
		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 {
260
		if (omap_dm_timer_reserve_systimer(timer->id))
261 262
			return -ENODEV;

263
		sprintf(name, "timer%d", timer->id);
264 265 266 267
		oh_name = name;
	}

	oh = omap_hwmod_lookup(oh_name);
268 269 270
	if (!oh)
		return -ENODEV;

271 272
	*timer_name = oh->name;

273 274
	if (!of_have_populated_dt()) {
		r = omap_hwmod_get_resource_byname(oh, IORESOURCE_IRQ, NULL,
275
						   &irq);
276 277
		if (r)
			return -ENXIO;
278
		timer->irq = irq.start;
279 280

		r = omap_hwmod_get_resource_byname(oh, IORESOURCE_MEM, NULL,
281
						   &mem);
282 283 284 285
		if (r)
			return -ENXIO;

		/* Static mapping, never released */
286
		timer->io_base = ioremap(mem.start, mem.end - mem.start);
287
	}
288 289 290 291 292

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

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

297 298 299
	src = clk_get(NULL, fck_source);
	if (IS_ERR(src))
		return PTR_ERR(src);
300

301 302
	WARN(clk_set_parent(timer->fclk, src) < 0,
	     "Cannot set timer parent clock, no PLL clock driver?");
303

304 305
	clk_put(src);

306 307
	omap_hwmod_setup_one(oh_name);
	omap_hwmod_enable(oh);
308
	__omap_dm_timer_init_regs(timer);
309

310 311 312 313 314 315
	if (posted)
		__omap_dm_timer_enable_posted(timer);

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

317
	timer->rate = clk_get_rate(timer->fclk);
318
	timer->reserved = 1;
319

320
	return r;
321
}
322

323 324 325 326 327 328
#if !defined(CONFIG_SMP) && defined(CONFIG_GENERIC_CLOCKEVENTS_BROADCAST)
void tick_broadcast(const struct cpumask *mask)
{
}
#endif

329
static void __init omap2_gp_clockevent_init(int gptimer_id,
330 331
						const char *fck_source,
						const char *property)
332 333
{
	int res;
334

335
	clkev.id = gptimer_id;
336 337 338 339 340 341 342 343 344
	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);

345
	res = omap_dm_timer_init_one(&clkev, fck_source, property,
346
				     &clockevent_gpt.name, OMAP_TIMER_POSTED);
347
	BUG_ON(res);
348

349
	omap2_gp_timer_irq.dev_id = &clkev;
350
	setup_irq(clkev.irq, &omap2_gp_timer_irq);
351

352
	__omap_dm_timer_int_enable(&clkev, OMAP_TIMER_INT_OVERFLOW);
353

354 355
	clockevent_gpt.cpumask = cpu_possible_mask;
	clockevent_gpt.irq = omap_dm_timer_get_irq(&clkev);
356 357 358
	clockevents_config_and_register(&clockevent_gpt, clkev.rate,
					3, /* Timer internal resynch latency */
					0xffffffff);
359

360 361
	pr_info("OMAP clockevent source: %s at %lu Hz\n", clockevent_gpt.name,
		clkev.rate);
362 363
}

364
/* Clocksource code */
365
static struct omap_dm_timer clksrc;
366
static bool use_gptimer_clksrc __initdata;
367

368 369 370
/*
 * clocksource
 */
371
static cycle_t clocksource_read_cycles(struct clocksource *cs)
372
{
373
	return (cycle_t)__omap_dm_timer_read_counter(&clksrc,
374
						     OMAP_TIMER_NONPOSTED);
375 376 377 378 379 380 381 382 383
}

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

384
static u64 notrace dmtimer_read_sched_clock(void)
385
{
386
	if (clksrc.reserved)
387
		return __omap_dm_timer_read_counter(&clksrc,
388
						    OMAP_TIMER_NONPOSTED);
389

390
	return 0;
391 392
}

393
static const struct of_device_id omap_counter_match[] __initconst = {
394 395 396 397
	{ .compatible = "ti,omap-counter32k", },
	{ }
};

398
/* Setup free-running counter for clocksource */
J
Jon Hunter 已提交
399
static int __init __maybe_unused omap2_sync32k_clocksource_init(void)
400 401
{
	int ret;
402
	struct device_node *np = NULL;
403 404 405
	struct omap_hwmod *oh;
	const char *oh_name = "counter_32k";

406 407 408 409 410 411 412 413 414 415 416 417 418 419
	/*
	 * 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;
	}

420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
	/*
	 * 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);

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

436 437
	if (!of_have_populated_dt()) {
		void __iomem *vbase;
438

439
		vbase = omap_hwmod_get_mpu_rt_va(oh);
440

441 442 443 444 445 446 447
		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);
		}
	}
448 449 450 451
	return ret;
}

static void __init omap2_gptimer_clocksource_init(int gptimer_id,
452 453
						  const char *fck_source,
						  const char *property)
454 455 456
{
	int res;

457
	clksrc.id = gptimer_id;
458 459
	clksrc.errata = omap_dm_timer_get_errata();

460
	res = omap_dm_timer_init_one(&clksrc, fck_source, property,
461
				     &clocksource_gpt.name,
462
				     OMAP_TIMER_NONPOSTED);
463
	BUG_ON(res);
464

465
	__omap_dm_timer_load_start(&clksrc,
466
				   OMAP_TIMER_CTRL_ST | OMAP_TIMER_CTRL_AR, 0,
467
				   OMAP_TIMER_NONPOSTED);
468
	sched_clock_register(dmtimer_read_sched_clock, 32, clksrc.rate);
469

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

478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
static void __init __omap_sync32k_timer_init(int clkev_nr, const char *clkev_src,
		const char *clkev_prop, int clksrc_nr, const char *clksrc_src,
		const char *clksrc_prop, bool gptimer)
{
	omap_clk_init();
	omap_dmtimer_init();
	omap2_gp_clockevent_init(clkev_nr, clkev_src, clkev_prop);

	/* Enable the use of clocksource="gp_timer" kernel parameter */
	if (use_gptimer_clksrc || gptimer)
		omap2_gptimer_clocksource_init(clksrc_nr, clksrc_src,
						clksrc_prop);
	else
		omap2_sync32k_clocksource_init();
}

494
void __init omap_init_time(void)
495 496 497
{
	__omap_sync32k_timer_init(1, "timer_32k_ck", "ti,timer-alwon",
			2, "timer_sys_ck", NULL, false);
498 499

	if (of_have_populated_dt())
500
		clocksource_probe();
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
}

#if defined(CONFIG_ARCH_OMAP3) || defined(CONFIG_SOC_AM43XX)
void __init omap3_secure_sync32k_timer_init(void)
{
	__omap_sync32k_timer_init(12, "secure_32k_fck", "ti,timer-secure",
			2, "timer_sys_ck", NULL, false);
}
#endif /* CONFIG_ARCH_OMAP3 */

#if defined(CONFIG_ARCH_OMAP3) || defined(CONFIG_SOC_AM33XX)
void __init omap3_gptimer_timer_init(void)
{
	__omap_sync32k_timer_init(2, "timer_sys_ck", NULL,
			1, "timer_sys_ck", "ti,timer-alwon", true);
}
#endif

#if defined(CONFIG_ARCH_OMAP4) || defined(CONFIG_SOC_OMAP5) ||		\
	defined(CONFIG_SOC_DRA7XX) || defined(CONFIG_SOC_AM43XX)
static void __init omap4_sync32k_timer_init(void)
{
	__omap_sync32k_timer_init(1, "timer_32k_ck", "ti,timer-alwon",
			2, "sys_clkin_ck", NULL, false);
}

void __init omap4_local_timer_init(void)
{
	omap4_sync32k_timer_init();
530
	clocksource_probe();
531 532 533 534 535
}
#endif

#if defined(CONFIG_SOC_OMAP5) || defined(CONFIG_SOC_DRA7XX)

536 537 538 539 540 541 542 543 544 545 546
/*
 * 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)
{
547
#ifdef CONFIG_SOC_HAS_REALTIME_COUNTER
548 549 550
	void __iomem *base;
	static struct clk *sys_clk;
	unsigned long rate;
551 552
	unsigned int reg;
	unsigned long long num, den;
553 554 555 556 557 558

	base = ioremap(REALTIME_COUNTER_BASE, SZ_32);
	if (!base) {
		pr_err("%s: ioremap failed\n", __func__);
		return;
	}
559
	sys_clk = clk_get(NULL, "sys_clkin");
560
	if (IS_ERR(sys_clk)) {
561 562 563 564 565 566
		pr_err("%s: failed to get system clock handle\n", __func__);
		iounmap(base);
		return;
	}

	rate = clk_get_rate(sys_clk);
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595

	if (soc_is_dra7xx()) {
		/*
		 * Errata i856 says the 32.768KHz crystal does not start at
		 * power on, so the CPU falls back to an emulated 32KHz clock
		 * based on sysclk / 610 instead. This causes the master counter
		 * frequency to not be 6.144MHz but at sysclk / 610 * 375 / 2
		 * (OR sysclk * 75 / 244)
		 *
		 * This affects at least the DRA7/AM572x 1.0, 1.1 revisions.
		 * Of course any board built without a populated 32.768KHz
		 * crystal would also need this fix even if the CPU is fixed
		 * later.
		 *
		 * Either case can be detected by using the two speedselect bits
		 * If they are not 0, then the 32.768KHz clock driving the
		 * coarse counter that corrects the fine counter every time it
		 * ticks is actually rate/610 rather than 32.768KHz and we
		 * should compensate to avoid the 570ppm (at 20MHz, much worse
		 * at other rates) too fast system time.
		 */
		reg = omap_ctrl_readl(DRA7_CTRL_CORE_BOOTSTRAP);
		if (reg & DRA7_SPEEDSELECT_MASK) {
			num = 75;
			den = 244;
			goto sysclk1_based;
		}
	}

596 597
	/* Numerator/denumerator values refer TRM Realtime Counter section */
	switch (rate) {
598
	case 12000000:
599 600 601
		num = 64;
		den = 125;
		break;
602
	case 13000000:
603 604 605 606 607 608 609
		num = 768;
		den = 1625;
		break;
	case 19200000:
		num = 8;
		den = 25;
		break;
610 611 612 613
	case 20000000:
		num = 192;
		den = 625;
		break;
614
	case 26000000:
615 616 617
		num = 384;
		den = 1625;
		break;
618
	case 27000000:
619 620 621 622 623 624 625 626 627 628 629
		num = 256;
		den = 1125;
		break;
	case 38400000:
	default:
		/* Program it for 38.4 MHz */
		num = 4;
		den = 25;
		break;
	}

630
sysclk1_based:
631
	/* Program numerator and denumerator registers */
632
	reg = readl_relaxed(base + INCREMENTER_NUMERATOR_OFFSET) &
633 634
			NUMERATOR_DENUMERATOR_MASK;
	reg |= num;
635
	writel_relaxed(reg, base + INCREMENTER_NUMERATOR_OFFSET);
636

637
	reg = readl_relaxed(base + INCREMENTER_DENUMERATOR_RELOAD_OFFSET) &
638 639
			NUMERATOR_DENUMERATOR_MASK;
	reg |= den;
640
	writel_relaxed(reg, base + INCREMENTER_DENUMERATOR_RELOAD_OFFSET);
641

642
	arch_timer_freq = DIV_ROUND_UP_ULL(rate * num, den);
643 644
	set_cntfreq();

645 646
	iounmap(base);
#endif
647 648
}

S
Stephen Warren 已提交
649
void __init omap5_realtime_timer_init(void)
650
{
651
	omap4_sync32k_timer_init();
652
	realtime_counter_init();
653

654
	clocksource_probe();
655
}
656
#endif /* CONFIG_SOC_OMAP5 || CONFIG_SOC_DRA7XX */
657

658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675
/**
 * 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;
676
	struct platform_device *pdev;
677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
	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);

705 706
	if (timer_dev_attr)
		pdata->timer_capability = timer_dev_attr->timer_capability;
707

708
	pdata->timer_errata = omap_dm_timer_get_errata();
709 710
	pdata->get_context_loss_count = omap_pm_get_dev_context_loss_count;

711
	pdev = omap_device_build(name, id, oh, pdata, sizeof(*pdata));
712

713
	if (IS_ERR(pdev)) {
714 715 716 717 718 719 720 721 722
		pr_err("%s: Can't build omap_device for %s: %s.\n",
			__func__, name, oh->name);
		ret = -EINVAL;
	}

	kfree(pdata);

	return ret;
}
723 724 725 726 727 728 729 730 731 732 733

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

734 735 736 737
	/* If dtb is there, the devices will be created dynamically */
	if (of_have_populated_dt())
		return -ENODEV;

738 739 740 741 742 743 744 745
	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 已提交
746
omap_arch_initcall(omap2_dm_timer_init);
747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771

/**
 * 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);