smp_twd.c 8.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
/*
 *  linux/arch/arm/kernel/smp_twd.c
 *
 *  Copyright (C) 2002 ARM Ltd.
 *  All Rights Reserved
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <linux/init.h>
#include <linux/kernel.h>
13
#include <linux/clk.h>
14 15
#include <linux/delay.h>
#include <linux/device.h>
16
#include <linux/err.h>
17 18 19
#include <linux/smp.h>
#include <linux/jiffies.h>
#include <linux/clockchips.h>
20
#include <linux/interrupt.h>
21
#include <linux/io.h>
22 23
#include <linux/of_irq.h>
#include <linux/of_address.h>
24

25
#include <asm/smp_plat.h>
26
#include <asm/smp_twd.h>
27
#include <asm/localtimer.h>
28 29

/* set up by the platform code */
30
static void __iomem *twd_base;
31

32
static struct clk *twd_clk;
33
static unsigned long twd_timer_rate;
34
static DEFINE_PER_CPU(bool, percpu_setup_called);
35

36
static struct clock_event_device __percpu **twd_evt;
37
static int twd_ppi;
38

39 40 41 42 43
static void twd_set_mode(enum clock_event_mode mode,
			struct clock_event_device *clk)
{
	unsigned long ctrl;

44
	switch (mode) {
45 46 47
	case CLOCK_EVT_MODE_PERIODIC:
		ctrl = TWD_TIMER_CONTROL_ENABLE | TWD_TIMER_CONTROL_IT_ENABLE
			| TWD_TIMER_CONTROL_PERIODIC;
48 49
		__raw_writel(DIV_ROUND_CLOSEST(twd_timer_rate, HZ),
			twd_base + TWD_TIMER_LOAD);
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
		break;
	case CLOCK_EVT_MODE_ONESHOT:
		/* period set, and timer enabled in 'next_event' hook */
		ctrl = TWD_TIMER_CONTROL_IT_ENABLE | TWD_TIMER_CONTROL_ONESHOT;
		break;
	case CLOCK_EVT_MODE_UNUSED:
	case CLOCK_EVT_MODE_SHUTDOWN:
	default:
		ctrl = 0;
	}

	__raw_writel(ctrl, twd_base + TWD_TIMER_CONTROL);
}

static int twd_set_next_event(unsigned long evt,
			struct clock_event_device *unused)
{
	unsigned long ctrl = __raw_readl(twd_base + TWD_TIMER_CONTROL);

69 70
	ctrl |= TWD_TIMER_CONTROL_ENABLE;

71
	__raw_writel(evt, twd_base + TWD_TIMER_COUNTER);
72
	__raw_writel(ctrl, twd_base + TWD_TIMER_CONTROL);
73 74 75 76 77 78 79 80 81 82

	return 0;
}

/*
 * local_timer_ack: checks for a local timer interrupt.
 *
 * If a local timer interrupt has occurred, acknowledge and return 1.
 * Otherwise, return 0.
 */
83
static int twd_timer_ack(void)
84 85 86 87 88 89 90 91 92
{
	if (__raw_readl(twd_base + TWD_TIMER_INTSTAT)) {
		__raw_writel(1, twd_base + TWD_TIMER_INTSTAT);
		return 1;
	}

	return 0;
}

93
static void twd_timer_stop(struct clock_event_device *clk)
94 95 96 97 98
{
	twd_set_mode(CLOCK_EVT_MODE_UNUSED, clk);
	disable_percpu_irq(clk->irq);
}

99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 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
#ifdef CONFIG_COMMON_CLK

/*
 * Updates clockevent frequency when the cpu frequency changes.
 * Called on the cpu that is changing frequency with interrupts disabled.
 */
static void twd_update_frequency(void *new_rate)
{
	twd_timer_rate = *((unsigned long *) new_rate);

	clockevents_update_freq(*__this_cpu_ptr(twd_evt), twd_timer_rate);
}

static int twd_rate_change(struct notifier_block *nb,
	unsigned long flags, void *data)
{
	struct clk_notifier_data *cnd = data;

	/*
	 * The twd clock events must be reprogrammed to account for the new
	 * frequency.  The timer is local to a cpu, so cross-call to the
	 * changing cpu.
	 */
	if (flags == POST_RATE_CHANGE)
		smp_call_function(twd_update_frequency,
				  (void *)&cnd->new_rate, 1);

	return NOTIFY_OK;
}

static struct notifier_block twd_clk_nb = {
	.notifier_call = twd_rate_change,
};

static int twd_clk_init(void)
{
	if (twd_evt && *__this_cpu_ptr(twd_evt) && !IS_ERR(twd_clk))
		return clk_notifier_register(twd_clk, &twd_clk_nb);

	return 0;
}
core_initcall(twd_clk_init);

#elif defined (CONFIG_CPU_FREQ)

#include <linux/cpufreq.h>
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168

/*
 * Updates clockevent frequency when the cpu frequency changes.
 * Called on the cpu that is changing frequency with interrupts disabled.
 */
static void twd_update_frequency(void *data)
{
	twd_timer_rate = clk_get_rate(twd_clk);

	clockevents_update_freq(*__this_cpu_ptr(twd_evt), twd_timer_rate);
}

static int twd_cpufreq_transition(struct notifier_block *nb,
	unsigned long state, void *data)
{
	struct cpufreq_freqs *freqs = data;

	/*
	 * The twd clock events must be reprogrammed to account for the new
	 * frequency.  The timer is local to a cpu, so cross-call to the
	 * changing cpu.
	 */
	if (state == CPUFREQ_POSTCHANGE || state == CPUFREQ_RESUMECHANGE)
		smp_call_function_single(freqs->cpu, twd_update_frequency,
169
			NULL, 1);
170 171 172 173 174 175 176 177 178 179

	return NOTIFY_OK;
}

static struct notifier_block twd_cpufreq_nb = {
	.notifier_call = twd_cpufreq_transition,
};

static int twd_cpufreq_init(void)
{
180
	if (twd_evt && *__this_cpu_ptr(twd_evt) && !IS_ERR(twd_clk))
181 182 183 184 185 186 187 188 189
		return cpufreq_register_notifier(&twd_cpufreq_nb,
			CPUFREQ_TRANSITION_NOTIFIER);

	return 0;
}
core_initcall(twd_cpufreq_init);

#endif

190 191
static void __cpuinit twd_calibrate_rate(void)
{
192
	unsigned long count;
193 194 195 196 197 198 199
	u64 waitjiffies;

	/*
	 * If this is the first time round, we need to work out how fast
	 * the timer ticks
	 */
	if (twd_timer_rate == 0) {
200
		printk(KERN_INFO "Calibrating local timer... ");
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224

		/* Wait for a tick to start */
		waitjiffies = get_jiffies_64() + 1;

		while (get_jiffies_64() < waitjiffies)
			udelay(10);

		/* OK, now the tick has started, let's get the timer going */
		waitjiffies += 5;

				 /* enable, no interrupt or reload */
		__raw_writel(0x1, twd_base + TWD_TIMER_CONTROL);

				 /* maximum value */
		__raw_writel(0xFFFFFFFFU, twd_base + TWD_TIMER_COUNTER);

		while (get_jiffies_64() < waitjiffies)
			udelay(10);

		count = __raw_readl(twd_base + TWD_TIMER_COUNTER);

		twd_timer_rate = (0xFFFFFFFFU - count) * (HZ / 5);

		printk("%lu.%02luMHz.\n", twd_timer_rate / 1000000,
225
			(twd_timer_rate / 10000) % 100);
226 227 228
	}
}

229 230 231 232 233 234 235 236 237 238 239 240
static irqreturn_t twd_handler(int irq, void *dev_id)
{
	struct clock_event_device *evt = *(struct clock_event_device **)dev_id;

	if (twd_timer_ack()) {
		evt->event_handler(evt);
		return IRQ_HANDLED;
	}

	return IRQ_NONE;
}

241
static void twd_get_clock(struct device_node *np)
242 243 244
{
	int err;

245 246 247 248 249 250 251 252
	if (np)
		twd_clk = of_clk_get(np, 0);
	else
		twd_clk = clk_get_sys("smp_twd", NULL);

	if (IS_ERR(twd_clk)) {
		pr_err("smp_twd: clock not found %d\n", (int) PTR_ERR(twd_clk));
		return;
253 254
	}

255
	err = clk_prepare_enable(twd_clk);
256
	if (err) {
257
		pr_err("smp_twd: clock failed to prepare+enable: %d\n", err);
258 259
		clk_put(twd_clk);
		return;
260 261
	}

262
	twd_timer_rate = clk_get_rate(twd_clk);
263 264
}

265 266 267
/*
 * Setup the local clock events for a CPU.
 */
268
static int __cpuinit twd_timer_setup(struct clock_event_device *clk)
269
{
270
	struct clock_event_device **this_cpu_clk;
271
	int cpu = smp_processor_id();
272

273 274 275 276 277 278 279 280 281 282 283
	/*
	 * If the basic setup for this CPU has been done before don't
	 * bother with the below.
	 */
	if (per_cpu(percpu_setup_called, cpu)) {
		__raw_writel(0, twd_base + TWD_TIMER_CONTROL);
		clockevents_register_device(*__this_cpu_ptr(twd_evt));
		enable_percpu_irq(clk->irq, 0);
		return 0;
	}
	per_cpu(percpu_setup_called, cpu) = true;
284

285
	twd_calibrate_rate();
286

287 288 289 290
	/*
	 * The following is done once per CPU the first time .setup() is
	 * called.
	 */
291 292
	__raw_writel(0, twd_base + TWD_TIMER_CONTROL);

293
	clk->name = "local_timer";
294 295
	clk->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT |
			CLOCK_EVT_FEAT_C3STOP;
296 297 298
	clk->rating = 350;
	clk->set_mode = twd_set_mode;
	clk->set_next_event = twd_set_next_event;
299
	clk->irq = twd_ppi;
300

301 302 303
	this_cpu_clk = __this_cpu_ptr(twd_evt);
	*this_cpu_clk = clk;

304 305
	clockevents_config_and_register(clk, twd_timer_rate,
					0xf, 0xffffffff);
306
	enable_percpu_irq(clk->irq, 0);
307 308 309 310 311 312 313 314 315

	return 0;
}

static struct local_timer_ops twd_lt_ops __cpuinitdata = {
	.setup	= twd_timer_setup,
	.stop	= twd_timer_stop,
};

316
static int __init twd_local_timer_common_register(struct device_node *np)
317 318 319 320
{
	int err;

	twd_evt = alloc_percpu(struct clock_event_device *);
321
	if (!twd_evt) {
322
		err = -ENOMEM;
323
		goto out_free;
324 325 326 327 328
	}

	err = request_percpu_irq(twd_ppi, twd_handler, "twd", twd_evt);
	if (err) {
		pr_err("twd: can't register interrupt %d (%d)\n", twd_ppi, err);
329
		goto out_free;
330 331 332 333
	}

	err = local_timer_register(&twd_lt_ops);
	if (err)
334
		goto out_irq;
335

336 337
	twd_get_clock(np);

338 339
	return 0;

340 341 342
out_irq:
	free_percpu_irq(twd_ppi, twd_evt);
out_free:
343
	iounmap(twd_base);
344
	twd_base = NULL;
345
	free_percpu(twd_evt);
346

347
	return err;
348
}
349 350 351 352 353 354 355 356 357 358 359 360

int __init twd_local_timer_register(struct twd_local_timer *tlt)
{
	if (twd_base || twd_evt)
		return -EBUSY;

	twd_ppi	= tlt->res[1].start;

	twd_base = ioremap(tlt->res[0].start, resource_size(&tlt->res[0]));
	if (!twd_base)
		return -ENOMEM;

361
	return twd_local_timer_common_register(NULL);
362 363 364
}

#ifdef CONFIG_OF
365
static void __init twd_local_timer_of_register(struct device_node *np)
366 367 368
{
	int err;

369 370 371
	if (!is_smp() || !setup_max_cpus)
		return;

372 373 374 375 376 377 378 379 380 381 382 383
	twd_ppi = irq_of_parse_and_map(np, 0);
	if (!twd_ppi) {
		err = -EINVAL;
		goto out;
	}

	twd_base = of_iomap(np, 0);
	if (!twd_base) {
		err = -ENOMEM;
		goto out;
	}

384
	err = twd_local_timer_common_register(np);
385 386 387 388

out:
	WARN(err, "twd_local_timer_of_register failed (%d)\n", err);
}
389 390 391
CLOCKSOURCE_OF_DECLARE(arm_twd_a9, "arm,cortex-a9-twd-timer", twd_local_timer_of_register);
CLOCKSOURCE_OF_DECLARE(arm_twd_a5, "arm,cortex-a5-twd-timer", twd_local_timer_of_register);
CLOCKSOURCE_OF_DECLARE(arm_twd_11mp, "arm,arm11mp-twd-timer", twd_local_timer_of_register);
392
#endif