2 * linux/drivers/clocksource/arm_arch_timer.c
4 * Copyright (C) 2011 ARM Ltd.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 #include <linux/init.h>
12 #include <linux/kernel.h>
13 #include <linux/device.h>
14 #include <linux/smp.h>
15 #include <linux/cpu.h>
16 #include <linux/clockchips.h>
17 #include <linux/interrupt.h>
18 #include <linux/of_irq.h>
21 #include <asm/arch_timer.h>
23 #include <clocksource/arm_arch_timer.h>
25 static u32 arch_timer_rate;
35 static int arch_timer_ppi[MAX_TIMER_PPI];
37 static struct clock_event_device __percpu *arch_timer_evt;
39 static bool arch_timer_use_virtual = true;
42 * Architected system timer support.
45 static inline irqreturn_t timer_handler(const int access,
46 struct clock_event_device *evt)
49 ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL);
50 if (ctrl & ARCH_TIMER_CTRL_IT_STAT) {
51 ctrl |= ARCH_TIMER_CTRL_IT_MASK;
52 arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl);
53 evt->event_handler(evt);
60 static irqreturn_t arch_timer_handler_virt(int irq, void *dev_id)
62 struct clock_event_device *evt = dev_id;
64 return timer_handler(ARCH_TIMER_VIRT_ACCESS, evt);
67 static irqreturn_t arch_timer_handler_phys(int irq, void *dev_id)
69 struct clock_event_device *evt = dev_id;
71 return timer_handler(ARCH_TIMER_PHYS_ACCESS, evt);
74 static inline void timer_set_mode(const int access, int mode)
78 case CLOCK_EVT_MODE_UNUSED:
79 case CLOCK_EVT_MODE_SHUTDOWN:
80 ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL);
81 ctrl &= ~ARCH_TIMER_CTRL_ENABLE;
82 arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl);
89 static void arch_timer_set_mode_virt(enum clock_event_mode mode,
90 struct clock_event_device *clk)
92 timer_set_mode(ARCH_TIMER_VIRT_ACCESS, mode);
95 static void arch_timer_set_mode_phys(enum clock_event_mode mode,
96 struct clock_event_device *clk)
98 timer_set_mode(ARCH_TIMER_PHYS_ACCESS, mode);
101 static inline void set_next_event(const int access, unsigned long evt)
104 ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL);
105 ctrl |= ARCH_TIMER_CTRL_ENABLE;
106 ctrl &= ~ARCH_TIMER_CTRL_IT_MASK;
107 arch_timer_reg_write(access, ARCH_TIMER_REG_TVAL, evt);
108 arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl);
111 static int arch_timer_set_next_event_virt(unsigned long evt,
112 struct clock_event_device *unused)
114 set_next_event(ARCH_TIMER_VIRT_ACCESS, evt);
118 static int arch_timer_set_next_event_phys(unsigned long evt,
119 struct clock_event_device *unused)
121 set_next_event(ARCH_TIMER_PHYS_ACCESS, evt);
125 static int __cpuinit arch_timer_setup(struct clock_event_device *clk)
127 clk->features = CLOCK_EVT_FEAT_ONESHOT | CLOCK_EVT_FEAT_C3STOP;
128 clk->name = "arch_sys_timer";
130 if (arch_timer_use_virtual) {
131 clk->irq = arch_timer_ppi[VIRT_PPI];
132 clk->set_mode = arch_timer_set_mode_virt;
133 clk->set_next_event = arch_timer_set_next_event_virt;
135 clk->irq = arch_timer_ppi[PHYS_SECURE_PPI];
136 clk->set_mode = arch_timer_set_mode_phys;
137 clk->set_next_event = arch_timer_set_next_event_phys;
140 clk->cpumask = cpumask_of(smp_processor_id());
142 clk->set_mode(CLOCK_EVT_MODE_SHUTDOWN, NULL);
144 clockevents_config_and_register(clk, arch_timer_rate,
147 if (arch_timer_use_virtual)
148 enable_percpu_irq(arch_timer_ppi[VIRT_PPI], 0);
150 enable_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI], 0);
151 if (arch_timer_ppi[PHYS_NONSECURE_PPI])
152 enable_percpu_irq(arch_timer_ppi[PHYS_NONSECURE_PPI], 0);
155 arch_counter_set_user_access();
160 static int arch_timer_available(void)
164 if (arch_timer_rate == 0) {
165 freq = arch_timer_get_cntfrq();
167 /* Check the timer frequency. */
169 pr_warn("Architected timer frequency not available\n");
173 arch_timer_rate = freq;
176 pr_info_once("Architected local timer running at %lu.%02luMHz (%s).\n",
177 (unsigned long)arch_timer_rate / 1000000,
178 (unsigned long)(arch_timer_rate / 10000) % 100,
179 arch_timer_use_virtual ? "virt" : "phys");
183 u32 arch_timer_get_rate(void)
185 return arch_timer_rate;
189 * Some external users of arch_timer_read_counter (e.g. sched_clock) may try to
190 * call it before it has been initialised. Rather than incur a performance
191 * penalty checking for initialisation, provide a default implementation that
192 * won't lead to time appearing to jump backwards.
194 static u64 arch_timer_read_zero(void)
199 u64 (*arch_timer_read_counter)(void) = arch_timer_read_zero;
201 static cycle_t arch_counter_read(struct clocksource *cs)
203 return arch_timer_read_counter();
206 static cycle_t arch_counter_read_cc(const struct cyclecounter *cc)
208 return arch_timer_read_counter();
211 static struct clocksource clocksource_counter = {
212 .name = "arch_sys_counter",
214 .read = arch_counter_read,
215 .mask = CLOCKSOURCE_MASK(56),
216 .flags = CLOCK_SOURCE_IS_CONTINUOUS,
219 static struct cyclecounter cyclecounter = {
220 .read = arch_counter_read_cc,
221 .mask = CLOCKSOURCE_MASK(56),
224 static struct timecounter timecounter;
226 struct timecounter *arch_timer_get_timecounter(void)
231 static void __cpuinit arch_timer_stop(struct clock_event_device *clk)
233 pr_debug("arch_timer_teardown disable IRQ%d cpu #%d\n",
234 clk->irq, smp_processor_id());
236 if (arch_timer_use_virtual)
237 disable_percpu_irq(arch_timer_ppi[VIRT_PPI]);
239 disable_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI]);
240 if (arch_timer_ppi[PHYS_NONSECURE_PPI])
241 disable_percpu_irq(arch_timer_ppi[PHYS_NONSECURE_PPI]);
244 clk->set_mode(CLOCK_EVT_MODE_UNUSED, clk);
247 static int __cpuinit arch_timer_cpu_notify(struct notifier_block *self,
248 unsigned long action, void *hcpu)
250 struct clock_event_device *evt = this_cpu_ptr(arch_timer_evt);
252 switch (action & ~CPU_TASKS_FROZEN) {
254 arch_timer_setup(evt);
257 arch_timer_stop(evt);
264 static struct notifier_block arch_timer_cpu_nb __cpuinitdata = {
265 .notifier_call = arch_timer_cpu_notify,
268 static int __init arch_timer_register(void)
273 err = arch_timer_available();
277 arch_timer_evt = alloc_percpu(struct clock_event_device);
278 if (!arch_timer_evt) {
283 clocksource_register_hz(&clocksource_counter, arch_timer_rate);
284 cyclecounter.mult = clocksource_counter.mult;
285 cyclecounter.shift = clocksource_counter.shift;
286 timecounter_init(&timecounter, &cyclecounter,
287 arch_counter_get_cntpct());
289 if (arch_timer_use_virtual) {
290 ppi = arch_timer_ppi[VIRT_PPI];
291 err = request_percpu_irq(ppi, arch_timer_handler_virt,
292 "arch_timer", arch_timer_evt);
294 ppi = arch_timer_ppi[PHYS_SECURE_PPI];
295 err = request_percpu_irq(ppi, arch_timer_handler_phys,
296 "arch_timer", arch_timer_evt);
297 if (!err && arch_timer_ppi[PHYS_NONSECURE_PPI]) {
298 ppi = arch_timer_ppi[PHYS_NONSECURE_PPI];
299 err = request_percpu_irq(ppi, arch_timer_handler_phys,
300 "arch_timer", arch_timer_evt);
302 free_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI],
308 pr_err("arch_timer: can't register interrupt %d (%d)\n",
313 err = register_cpu_notifier(&arch_timer_cpu_nb);
317 /* Immediately configure the timer on the boot CPU */
318 arch_timer_setup(this_cpu_ptr(arch_timer_evt));
323 if (arch_timer_use_virtual)
324 free_percpu_irq(arch_timer_ppi[VIRT_PPI], arch_timer_evt);
326 free_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI],
328 if (arch_timer_ppi[PHYS_NONSECURE_PPI])
329 free_percpu_irq(arch_timer_ppi[PHYS_NONSECURE_PPI],
334 free_percpu(arch_timer_evt);
339 static const struct of_device_id arch_timer_of_match[] __initconst = {
340 { .compatible = "arm,armv7-timer", },
341 { .compatible = "arm,armv8-timer", },
345 int __init arch_timer_init(void)
347 struct device_node *np;
351 np = of_find_matching_node(NULL, arch_timer_of_match);
353 pr_err("arch_timer: can't find DT node\n");
357 /* Try to determine the frequency from the device tree or CNTFRQ */
358 if (!of_property_read_u32(np, "clock-frequency", &freq))
359 arch_timer_rate = freq;
361 for (i = PHYS_SECURE_PPI; i < MAX_TIMER_PPI; i++)
362 arch_timer_ppi[i] = irq_of_parse_and_map(np, i);
367 * If no interrupt provided for virtual timer, we'll have to
368 * stick to the physical timer. It'd better be accessible...
370 if (!arch_timer_ppi[VIRT_PPI]) {
371 arch_timer_use_virtual = false;
373 if (!arch_timer_ppi[PHYS_SECURE_PPI] ||
374 !arch_timer_ppi[PHYS_NONSECURE_PPI]) {
375 pr_warn("arch_timer: No interrupt available, giving up\n");
380 if (arch_timer_use_virtual)
381 arch_timer_read_counter = arch_counter_get_cntvct;
383 arch_timer_read_counter = arch_counter_get_cntpct;
385 return arch_timer_register();