Blame view
drivers/clocksource/arm_arch_timer.c
22 KB
8a4da6e36
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
/* * linux/drivers/clocksource/arm_arch_timer.c * * Copyright (C) 2011 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> #include <linux/device.h> #include <linux/smp.h> #include <linux/cpu.h> |
346e7480f
|
16 |
#include <linux/cpu_pm.h> |
8a4da6e36
|
17 |
#include <linux/clockchips.h> |
7c8f1e786
|
18 |
#include <linux/clocksource.h> |
8a4da6e36
|
19 20 |
#include <linux/interrupt.h> #include <linux/of_irq.h> |
220069945
|
21 |
#include <linux/of_address.h> |
8a4da6e36
|
22 |
#include <linux/io.h> |
220069945
|
23 |
#include <linux/slab.h> |
65cd4f6c9
|
24 |
#include <linux/sched_clock.h> |
b09ca1ecf
|
25 |
#include <linux/acpi.h> |
8a4da6e36
|
26 27 |
#include <asm/arch_timer.h> |
8266891e2
|
28 |
#include <asm/virt.h> |
8a4da6e36
|
29 30 |
#include <clocksource/arm_arch_timer.h> |
220069945
|
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
#define CNTTIDR 0x08 #define CNTTIDR_VIRT(n) (BIT(1) << ((n) * 4)) #define CNTVCT_LO 0x08 #define CNTVCT_HI 0x0c #define CNTFRQ 0x10 #define CNTP_TVAL 0x28 #define CNTP_CTL 0x2c #define CNTV_TVAL 0x38 #define CNTV_CTL 0x3c #define ARCH_CP15_TIMER BIT(0) #define ARCH_MEM_TIMER BIT(1) static unsigned arch_timers_present __initdata; static void __iomem *arch_counter_base; struct arch_timer { void __iomem *base; struct clock_event_device evt; }; #define to_arch_timer(e) container_of(e, struct arch_timer, evt) |
8a4da6e36
|
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 |
static u32 arch_timer_rate; enum ppi_nr { PHYS_SECURE_PPI, PHYS_NONSECURE_PPI, VIRT_PPI, HYP_PPI, MAX_TIMER_PPI }; static int arch_timer_ppi[MAX_TIMER_PPI]; static struct clock_event_device __percpu *arch_timer_evt; static bool arch_timer_use_virtual = true; |
82a561941
|
69 |
static bool arch_timer_c3stop; |
220069945
|
70 |
static bool arch_timer_mem_use_virtual; |
8a4da6e36
|
71 72 73 74 |
/* * Architected system timer support. */ |
60faddf6e
|
75 76 |
static __always_inline void arch_timer_reg_write(int access, enum arch_timer_reg reg, u32 val, |
cfb6d656d
|
77 |
struct clock_event_device *clk) |
60faddf6e
|
78 |
{ |
220069945
|
79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 |
if (access == ARCH_TIMER_MEM_PHYS_ACCESS) { struct arch_timer *timer = to_arch_timer(clk); switch (reg) { case ARCH_TIMER_REG_CTRL: writel_relaxed(val, timer->base + CNTP_CTL); break; case ARCH_TIMER_REG_TVAL: writel_relaxed(val, timer->base + CNTP_TVAL); break; } } else if (access == ARCH_TIMER_MEM_VIRT_ACCESS) { struct arch_timer *timer = to_arch_timer(clk); switch (reg) { case ARCH_TIMER_REG_CTRL: writel_relaxed(val, timer->base + CNTV_CTL); break; case ARCH_TIMER_REG_TVAL: writel_relaxed(val, timer->base + CNTV_TVAL); break; } } else { arch_timer_reg_write_cp15(access, reg, val); } |
60faddf6e
|
102 103 104 105 |
} static __always_inline u32 arch_timer_reg_read(int access, enum arch_timer_reg reg, |
cfb6d656d
|
106 |
struct clock_event_device *clk) |
60faddf6e
|
107 |
{ |
220069945
|
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 |
u32 val; if (access == ARCH_TIMER_MEM_PHYS_ACCESS) { struct arch_timer *timer = to_arch_timer(clk); switch (reg) { case ARCH_TIMER_REG_CTRL: val = readl_relaxed(timer->base + CNTP_CTL); break; case ARCH_TIMER_REG_TVAL: val = readl_relaxed(timer->base + CNTP_TVAL); break; } } else if (access == ARCH_TIMER_MEM_VIRT_ACCESS) { struct arch_timer *timer = to_arch_timer(clk); switch (reg) { case ARCH_TIMER_REG_CTRL: val = readl_relaxed(timer->base + CNTV_CTL); break; case ARCH_TIMER_REG_TVAL: val = readl_relaxed(timer->base + CNTV_TVAL); break; } } else { val = arch_timer_reg_read_cp15(access, reg); } return val; |
60faddf6e
|
135 |
} |
e09f3cc01
|
136 |
static __always_inline irqreturn_t timer_handler(const int access, |
8a4da6e36
|
137 138 139 |
struct clock_event_device *evt) { unsigned long ctrl; |
cfb6d656d
|
140 |
|
60faddf6e
|
141 |
ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL, evt); |
8a4da6e36
|
142 143 |
if (ctrl & ARCH_TIMER_CTRL_IT_STAT) { ctrl |= ARCH_TIMER_CTRL_IT_MASK; |
60faddf6e
|
144 |
arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl, evt); |
8a4da6e36
|
145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 |
evt->event_handler(evt); return IRQ_HANDLED; } return IRQ_NONE; } static irqreturn_t arch_timer_handler_virt(int irq, void *dev_id) { struct clock_event_device *evt = dev_id; return timer_handler(ARCH_TIMER_VIRT_ACCESS, evt); } static irqreturn_t arch_timer_handler_phys(int irq, void *dev_id) { struct clock_event_device *evt = dev_id; return timer_handler(ARCH_TIMER_PHYS_ACCESS, evt); } |
220069945
|
165 166 167 168 169 170 171 172 173 174 175 176 177 |
static irqreturn_t arch_timer_handler_phys_mem(int irq, void *dev_id) { struct clock_event_device *evt = dev_id; return timer_handler(ARCH_TIMER_MEM_PHYS_ACCESS, evt); } static irqreturn_t arch_timer_handler_virt_mem(int irq, void *dev_id) { struct clock_event_device *evt = dev_id; return timer_handler(ARCH_TIMER_MEM_VIRT_ACCESS, evt); } |
46c5bfdda
|
178 179 |
static __always_inline int timer_shutdown(const int access, struct clock_event_device *clk) |
8a4da6e36
|
180 181 |
{ unsigned long ctrl; |
46c5bfdda
|
182 183 184 185 186 187 |
ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL, clk); ctrl &= ~ARCH_TIMER_CTRL_ENABLE; arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl, clk); return 0; |
8a4da6e36
|
188 |
} |
46c5bfdda
|
189 |
static int arch_timer_shutdown_virt(struct clock_event_device *clk) |
8a4da6e36
|
190 |
{ |
46c5bfdda
|
191 |
return timer_shutdown(ARCH_TIMER_VIRT_ACCESS, clk); |
8a4da6e36
|
192 |
} |
46c5bfdda
|
193 |
static int arch_timer_shutdown_phys(struct clock_event_device *clk) |
8a4da6e36
|
194 |
{ |
46c5bfdda
|
195 |
return timer_shutdown(ARCH_TIMER_PHYS_ACCESS, clk); |
8a4da6e36
|
196 |
} |
46c5bfdda
|
197 |
static int arch_timer_shutdown_virt_mem(struct clock_event_device *clk) |
220069945
|
198 |
{ |
46c5bfdda
|
199 |
return timer_shutdown(ARCH_TIMER_MEM_VIRT_ACCESS, clk); |
8a4da6e36
|
200 |
} |
46c5bfdda
|
201 |
static int arch_timer_shutdown_phys_mem(struct clock_event_device *clk) |
220069945
|
202 |
{ |
46c5bfdda
|
203 |
return timer_shutdown(ARCH_TIMER_MEM_PHYS_ACCESS, clk); |
220069945
|
204 |
} |
60faddf6e
|
205 |
static __always_inline void set_next_event(const int access, unsigned long evt, |
cfb6d656d
|
206 |
struct clock_event_device *clk) |
8a4da6e36
|
207 208 |
{ unsigned long ctrl; |
60faddf6e
|
209 |
ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL, clk); |
8a4da6e36
|
210 211 |
ctrl |= ARCH_TIMER_CTRL_ENABLE; ctrl &= ~ARCH_TIMER_CTRL_IT_MASK; |
60faddf6e
|
212 213 |
arch_timer_reg_write(access, ARCH_TIMER_REG_TVAL, evt, clk); arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl, clk); |
8a4da6e36
|
214 215 216 |
} static int arch_timer_set_next_event_virt(unsigned long evt, |
60faddf6e
|
217 |
struct clock_event_device *clk) |
8a4da6e36
|
218 |
{ |
60faddf6e
|
219 |
set_next_event(ARCH_TIMER_VIRT_ACCESS, evt, clk); |
8a4da6e36
|
220 221 222 223 |
return 0; } static int arch_timer_set_next_event_phys(unsigned long evt, |
60faddf6e
|
224 |
struct clock_event_device *clk) |
8a4da6e36
|
225 |
{ |
60faddf6e
|
226 |
set_next_event(ARCH_TIMER_PHYS_ACCESS, evt, clk); |
8a4da6e36
|
227 228 |
return 0; } |
220069945
|
229 230 |
static int arch_timer_set_next_event_virt_mem(unsigned long evt, struct clock_event_device *clk) |
8a4da6e36
|
231 |
{ |
220069945
|
232 233 234 235 236 237 238 239 240 241 |
set_next_event(ARCH_TIMER_MEM_VIRT_ACCESS, evt, clk); return 0; } static int arch_timer_set_next_event_phys_mem(unsigned long evt, struct clock_event_device *clk) { set_next_event(ARCH_TIMER_MEM_PHYS_ACCESS, evt, clk); return 0; } |
cfb6d656d
|
242 243 |
static void __arch_timer_setup(unsigned type, struct clock_event_device *clk) |
220069945
|
244 245 246 247 |
{ clk->features = CLOCK_EVT_FEAT_ONESHOT; if (type == ARCH_CP15_TIMER) { |
82a561941
|
248 249 |
if (arch_timer_c3stop) clk->features |= CLOCK_EVT_FEAT_C3STOP; |
220069945
|
250 251 252 253 254 |
clk->name = "arch_sys_timer"; clk->rating = 450; clk->cpumask = cpumask_of(smp_processor_id()); if (arch_timer_use_virtual) { clk->irq = arch_timer_ppi[VIRT_PPI]; |
46c5bfdda
|
255 |
clk->set_state_shutdown = arch_timer_shutdown_virt; |
220069945
|
256 257 258 |
clk->set_next_event = arch_timer_set_next_event_virt; } else { clk->irq = arch_timer_ppi[PHYS_SECURE_PPI]; |
46c5bfdda
|
259 |
clk->set_state_shutdown = arch_timer_shutdown_phys; |
220069945
|
260 261 |
clk->set_next_event = arch_timer_set_next_event_phys; } |
8a4da6e36
|
262 |
} else { |
7b52ad2ef
|
263 |
clk->features |= CLOCK_EVT_FEAT_DYNIRQ; |
220069945
|
264 265 266 267 |
clk->name = "arch_mem_timer"; clk->rating = 400; clk->cpumask = cpu_all_mask; if (arch_timer_mem_use_virtual) { |
46c5bfdda
|
268 |
clk->set_state_shutdown = arch_timer_shutdown_virt_mem; |
220069945
|
269 270 271 |
clk->set_next_event = arch_timer_set_next_event_virt_mem; } else { |
46c5bfdda
|
272 |
clk->set_state_shutdown = arch_timer_shutdown_phys_mem; |
220069945
|
273 274 275 |
clk->set_next_event = arch_timer_set_next_event_phys_mem; } |
8a4da6e36
|
276 |
} |
46c5bfdda
|
277 |
clk->set_state_shutdown(clk); |
8a4da6e36
|
278 |
|
220069945
|
279 280 |
clockevents_config_and_register(clk, arch_timer_rate, 0xf, 0x7fffffff); } |
8a4da6e36
|
281 |
|
e1ce5c7ad
|
282 283 284 285 286 287 288 289 290 291 292 293 294 295 |
static void arch_timer_evtstrm_enable(int divider) { u32 cntkctl = arch_timer_get_cntkctl(); cntkctl &= ~ARCH_TIMER_EVT_TRIGGER_MASK; /* Set the divider and enable virtual event stream */ cntkctl |= (divider << ARCH_TIMER_EVT_TRIGGER_SHIFT) | ARCH_TIMER_VIRT_EVT_EN; arch_timer_set_cntkctl(cntkctl); elf_hwcap |= HWCAP_EVTSTRM; #ifdef CONFIG_COMPAT compat_elf_hwcap |= COMPAT_HWCAP_EVTSTRM; #endif } |
037f63776
|
296 297 298 299 300 301 302 303 304 305 306 307 |
static void arch_timer_configure_evtstream(void) { int evt_stream_div, pos; /* Find the closest power of two to the divisor */ evt_stream_div = arch_timer_rate / ARCH_TIMER_EVT_STREAM_FREQ; pos = fls(evt_stream_div); if (pos > 1 && !(evt_stream_div & (1 << (pos - 2)))) pos--; /* enable event stream */ arch_timer_evtstrm_enable(min(pos, 15)); } |
8b8dde003
|
308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 |
static void arch_counter_set_user_access(void) { u32 cntkctl = arch_timer_get_cntkctl(); /* Disable user access to the timers and the physical counter */ /* Also disable virtual event stream */ cntkctl &= ~(ARCH_TIMER_USR_PT_ACCESS_EN | ARCH_TIMER_USR_VT_ACCESS_EN | ARCH_TIMER_VIRT_EVT_EN | ARCH_TIMER_USR_PCT_ACCESS_EN); /* Enable user access to the virtual counter */ cntkctl |= ARCH_TIMER_USR_VCT_ACCESS_EN; arch_timer_set_cntkctl(cntkctl); } |
cfb6d656d
|
324 |
static int arch_timer_setup(struct clock_event_device *clk) |
220069945
|
325 326 |
{ __arch_timer_setup(ARCH_CP15_TIMER, clk); |
8a4da6e36
|
327 328 329 330 331 332 333 334 335 336 |
if (arch_timer_use_virtual) enable_percpu_irq(arch_timer_ppi[VIRT_PPI], 0); else { enable_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI], 0); if (arch_timer_ppi[PHYS_NONSECURE_PPI]) enable_percpu_irq(arch_timer_ppi[PHYS_NONSECURE_PPI], 0); } arch_counter_set_user_access(); |
037f63776
|
337 338 |
if (IS_ENABLED(CONFIG_ARM_ARCH_TIMER_EVTSTREAM)) arch_timer_configure_evtstream(); |
8a4da6e36
|
339 340 341 |
return 0; } |
220069945
|
342 343 |
static void arch_timer_detect_rate(void __iomem *cntbase, struct device_node *np) |
8a4da6e36
|
344 |
{ |
220069945
|
345 346 347 |
/* Who has more than one independent system counter? */ if (arch_timer_rate) return; |
8a4da6e36
|
348 |
|
b09ca1ecf
|
349 350 351 352 353 354 |
/* * Try to determine the frequency from the device tree or CNTFRQ, * if ACPI is enabled, get the frequency from CNTFRQ ONLY. */ if (!acpi_disabled || of_property_read_u32(np, "clock-frequency", &arch_timer_rate)) { |
220069945
|
355 356 357 358 |
if (cntbase) arch_timer_rate = readl_relaxed(cntbase + CNTFRQ); else arch_timer_rate = arch_timer_get_cntfrq(); |
8a4da6e36
|
359 |
} |
220069945
|
360 361 362 363 364 365 366 367 368 369 370 371 372 |
/* Check the timer frequency. */ if (arch_timer_rate == 0) pr_warn("Architected timer frequency not available "); } static void arch_timer_banner(unsigned type) { pr_info("Architected %s%s%s timer(s) running at %lu.%02luMHz (%s%s%s). ", type & ARCH_CP15_TIMER ? "cp15" : "", type == (ARCH_CP15_TIMER | ARCH_MEM_TIMER) ? " and " : "", type & ARCH_MEM_TIMER ? "mmio" : "", |
8a4da6e36
|
373 374 |
(unsigned long)arch_timer_rate / 1000000, (unsigned long)(arch_timer_rate / 10000) % 100, |
220069945
|
375 376 377 378 379 380 381 |
type & ARCH_CP15_TIMER ? arch_timer_use_virtual ? "virt" : "phys" : "", type == (ARCH_CP15_TIMER | ARCH_MEM_TIMER) ? "/" : "", type & ARCH_MEM_TIMER ? arch_timer_mem_use_virtual ? "virt" : "phys" : ""); |
8a4da6e36
|
382 383 384 385 386 387 |
} u32 arch_timer_get_rate(void) { return arch_timer_rate; } |
220069945
|
388 |
static u64 arch_counter_get_cntvct_mem(void) |
8a4da6e36
|
389 |
{ |
220069945
|
390 391 392 393 394 395 396 397 398 |
u32 vct_lo, vct_hi, tmp_hi; do { vct_hi = readl_relaxed(arch_counter_base + CNTVCT_HI); vct_lo = readl_relaxed(arch_counter_base + CNTVCT_LO); tmp_hi = readl_relaxed(arch_counter_base + CNTVCT_HI); } while (vct_hi != tmp_hi); return ((u64) vct_hi << 32) | vct_lo; |
8a4da6e36
|
399 |
} |
220069945
|
400 401 402 403 404 405 406 |
/* * Default to cp15 based access because arm64 uses this function for * sched_clock() before DT is probed and the cp15 method is guaranteed * to exist on arm64. arm doesn't use this before DT is probed so even * if we don't have the cp15 accessors we won't have a problem. */ u64 (*arch_timer_read_counter)(void) = arch_counter_get_cntvct; |
8a4da6e36
|
407 408 |
static cycle_t arch_counter_read(struct clocksource *cs) { |
220069945
|
409 |
return arch_timer_read_counter(); |
8a4da6e36
|
410 411 412 413 |
} static cycle_t arch_counter_read_cc(const struct cyclecounter *cc) { |
220069945
|
414 |
return arch_timer_read_counter(); |
8a4da6e36
|
415 416 417 418 419 420 421 |
} static struct clocksource clocksource_counter = { .name = "arch_sys_counter", .rating = 400, .read = arch_counter_read, .mask = CLOCKSOURCE_MASK(56), |
4fbcdc813
|
422 |
.flags = CLOCK_SOURCE_IS_CONTINUOUS | CLOCK_SOURCE_SUSPEND_NONSTOP, |
8a4da6e36
|
423 424 425 426 427 428 429 430 431 432 433 434 435 |
}; static struct cyclecounter cyclecounter = { .read = arch_counter_read_cc, .mask = CLOCKSOURCE_MASK(56), }; static struct timecounter timecounter; struct timecounter *arch_timer_get_timecounter(void) { return &timecounter; } |
220069945
|
436 437 438 439 440 |
static void __init arch_counter_register(unsigned type) { u64 start_count; /* Register the CP15 based counter if we have one */ |
423bd69e6
|
441 |
if (type & ARCH_CP15_TIMER) { |
d6ad36913
|
442 |
if (IS_ENABLED(CONFIG_ARM64) || arch_timer_use_virtual) |
0b46b8a71
|
443 444 445 |
arch_timer_read_counter = arch_counter_get_cntvct; else arch_timer_read_counter = arch_counter_get_cntpct; |
423bd69e6
|
446 |
} else { |
220069945
|
447 |
arch_timer_read_counter = arch_counter_get_cntvct_mem; |
423bd69e6
|
448 449 450 451 452 453 454 |
/* If the clocksource name is "arch_sys_counter" the * VDSO will attempt to read the CP15-based counter. * Ensure this does not happen when CP15-based * counter is not available. */ clocksource_counter.name = "arch_mem_counter"; } |
220069945
|
455 456 457 458 459 |
start_count = arch_timer_read_counter(); clocksource_register_hz(&clocksource_counter, arch_timer_rate); cyclecounter.mult = clocksource_counter.mult; cyclecounter.shift = clocksource_counter.shift; timecounter_init(&timecounter, &cyclecounter, start_count); |
4a7d3e8a9
|
460 461 462 |
/* 56 bits minimum, so we assume worst case rollover */ sched_clock_register(arch_timer_read_counter, 56, arch_timer_rate); |
220069945
|
463 |
} |
8c37bb3ac
|
464 |
static void arch_timer_stop(struct clock_event_device *clk) |
8a4da6e36
|
465 466 467 468 469 470 471 472 473 474 475 476 |
{ pr_debug("arch_timer_teardown disable IRQ%d cpu #%d ", clk->irq, smp_processor_id()); if (arch_timer_use_virtual) disable_percpu_irq(arch_timer_ppi[VIRT_PPI]); else { disable_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI]); if (arch_timer_ppi[PHYS_NONSECURE_PPI]) disable_percpu_irq(arch_timer_ppi[PHYS_NONSECURE_PPI]); } |
46c5bfdda
|
477 |
clk->set_state_shutdown(clk); |
8a4da6e36
|
478 |
} |
8c37bb3ac
|
479 |
static int arch_timer_cpu_notify(struct notifier_block *self, |
8a4da6e36
|
480 481 |
unsigned long action, void *hcpu) { |
f31c2f1c6
|
482 483 484 485 |
/* * Grab cpu pointer in each case to avoid spurious * preemptible warnings */ |
8a4da6e36
|
486 487 |
switch (action & ~CPU_TASKS_FROZEN) { case CPU_STARTING: |
f31c2f1c6
|
488 |
arch_timer_setup(this_cpu_ptr(arch_timer_evt)); |
8a4da6e36
|
489 490 |
break; case CPU_DYING: |
f31c2f1c6
|
491 |
arch_timer_stop(this_cpu_ptr(arch_timer_evt)); |
8a4da6e36
|
492 493 494 495 496 |
break; } return NOTIFY_OK; } |
8c37bb3ac
|
497 |
static struct notifier_block arch_timer_cpu_nb = { |
8a4da6e36
|
498 499 |
.notifier_call = arch_timer_cpu_notify, }; |
346e7480f
|
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 |
#ifdef CONFIG_CPU_PM static unsigned int saved_cntkctl; static int arch_timer_cpu_pm_notify(struct notifier_block *self, unsigned long action, void *hcpu) { if (action == CPU_PM_ENTER) saved_cntkctl = arch_timer_get_cntkctl(); else if (action == CPU_PM_ENTER_FAILED || action == CPU_PM_EXIT) arch_timer_set_cntkctl(saved_cntkctl); return NOTIFY_OK; } static struct notifier_block arch_timer_cpu_pm_notifier = { .notifier_call = arch_timer_cpu_pm_notify, }; static int __init arch_timer_cpu_pm_init(void) { return cpu_pm_register_notifier(&arch_timer_cpu_pm_notifier); } #else static int __init arch_timer_cpu_pm_init(void) { return 0; } #endif |
8a4da6e36
|
526 527 528 529 |
static int __init arch_timer_register(void) { int err; int ppi; |
8a4da6e36
|
530 531 532 533 534 |
arch_timer_evt = alloc_percpu(struct clock_event_device); if (!arch_timer_evt) { err = -ENOMEM; goto out; } |
8a4da6e36
|
535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 |
if (arch_timer_use_virtual) { ppi = arch_timer_ppi[VIRT_PPI]; err = request_percpu_irq(ppi, arch_timer_handler_virt, "arch_timer", arch_timer_evt); } else { ppi = arch_timer_ppi[PHYS_SECURE_PPI]; err = request_percpu_irq(ppi, arch_timer_handler_phys, "arch_timer", arch_timer_evt); if (!err && arch_timer_ppi[PHYS_NONSECURE_PPI]) { ppi = arch_timer_ppi[PHYS_NONSECURE_PPI]; err = request_percpu_irq(ppi, arch_timer_handler_phys, "arch_timer", arch_timer_evt); if (err) free_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI], arch_timer_evt); } } if (err) { pr_err("arch_timer: can't register interrupt %d (%d) ", ppi, err); goto out_free; } err = register_cpu_notifier(&arch_timer_cpu_nb); if (err) goto out_free_irq; |
346e7480f
|
563 564 565 |
err = arch_timer_cpu_pm_init(); if (err) goto out_unreg_notify; |
8a4da6e36
|
566 567 568 569 |
/* Immediately configure the timer on the boot CPU */ arch_timer_setup(this_cpu_ptr(arch_timer_evt)); return 0; |
346e7480f
|
570 571 |
out_unreg_notify: unregister_cpu_notifier(&arch_timer_cpu_nb); |
8a4da6e36
|
572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 |
out_free_irq: if (arch_timer_use_virtual) free_percpu_irq(arch_timer_ppi[VIRT_PPI], arch_timer_evt); else { free_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI], arch_timer_evt); if (arch_timer_ppi[PHYS_NONSECURE_PPI]) free_percpu_irq(arch_timer_ppi[PHYS_NONSECURE_PPI], arch_timer_evt); } out_free: free_percpu(arch_timer_evt); out: return err; } |
220069945
|
588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 |
static int __init arch_timer_mem_register(void __iomem *base, unsigned int irq) { int ret; irq_handler_t func; struct arch_timer *t; t = kzalloc(sizeof(*t), GFP_KERNEL); if (!t) return -ENOMEM; t->base = base; t->evt.irq = irq; __arch_timer_setup(ARCH_MEM_TIMER, &t->evt); if (arch_timer_mem_use_virtual) func = arch_timer_handler_virt_mem; else func = arch_timer_handler_phys_mem; ret = request_irq(irq, func, IRQF_TIMER, "arch_mem_timer", &t->evt); if (ret) { pr_err("arch_timer: Failed to request mem timer irq "); kfree(t); } return ret; } static const struct of_device_id arch_timer_of_match[] __initconst = { { .compatible = "arm,armv7-timer", }, { .compatible = "arm,armv8-timer", }, {}, }; static const struct of_device_id arch_timer_mem_of_match[] __initconst = { { .compatible = "arm,armv7-timer-mem", }, {}, }; |
c387f07e6
|
627 |
static bool __init |
566e6dfad
|
628 |
arch_timer_needs_probing(int type, const struct of_device_id *matches) |
c387f07e6
|
629 630 |
{ struct device_node *dn; |
566e6dfad
|
631 |
bool needs_probing = false; |
c387f07e6
|
632 633 |
dn = of_find_matching_node(NULL, matches); |
59aa896db
|
634 |
if (dn && of_device_is_available(dn) && !(arch_timers_present & type)) |
566e6dfad
|
635 |
needs_probing = true; |
c387f07e6
|
636 |
of_node_put(dn); |
566e6dfad
|
637 |
return needs_probing; |
c387f07e6
|
638 |
} |
220069945
|
639 640 641 642 643 644 |
static void __init arch_timer_common_init(void) { unsigned mask = ARCH_CP15_TIMER | ARCH_MEM_TIMER; /* Wait until both nodes are probed if we have two timers */ if ((arch_timers_present & mask) != mask) { |
566e6dfad
|
645 |
if (arch_timer_needs_probing(ARCH_MEM_TIMER, arch_timer_mem_of_match)) |
220069945
|
646 |
return; |
566e6dfad
|
647 |
if (arch_timer_needs_probing(ARCH_CP15_TIMER, arch_timer_of_match)) |
220069945
|
648 649 650 651 652 653 654 |
return; } arch_timer_banner(arch_timers_present); arch_counter_register(arch_timers_present); arch_timer_arch_init(); } |
b09ca1ecf
|
655 |
static void __init arch_timer_init(void) |
8a4da6e36
|
656 |
{ |
65b5732d2
|
657 |
/* |
8266891e2
|
658 659 660 661 |
* If HYP mode is available, we know that the physical timer * has been configured to be accessible from PL1. Use it, so * that a guest can use the virtual timer instead. * |
8a4da6e36
|
662 663 664 |
* If no interrupt provided for virtual timer, we'll have to * stick to the physical timer. It'd better be accessible... */ |
8266891e2
|
665 |
if (is_hyp_mode_available() || !arch_timer_ppi[VIRT_PPI]) { |
8a4da6e36
|
666 667 668 669 670 671 |
arch_timer_use_virtual = false; if (!arch_timer_ppi[PHYS_SECURE_PPI] || !arch_timer_ppi[PHYS_NONSECURE_PPI]) { pr_warn("arch_timer: No interrupt available, giving up "); |
0583fe478
|
672 |
return; |
8a4da6e36
|
673 674 |
} } |
0583fe478
|
675 |
arch_timer_register(); |
220069945
|
676 |
arch_timer_common_init(); |
8a4da6e36
|
677 |
} |
b09ca1ecf
|
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 705 706 707 708 |
static void __init arch_timer_of_init(struct device_node *np) { int i; if (arch_timers_present & ARCH_CP15_TIMER) { pr_warn("arch_timer: multiple nodes in dt, skipping "); return; } arch_timers_present |= ARCH_CP15_TIMER; for (i = PHYS_SECURE_PPI; i < MAX_TIMER_PPI; i++) arch_timer_ppi[i] = irq_of_parse_and_map(np, i); arch_timer_detect_rate(NULL, np); arch_timer_c3stop = !of_property_read_bool(np, "always-on"); /* * If we cannot rely on firmware initializing the timer registers then * we should use the physical timers instead. */ if (IS_ENABLED(CONFIG_ARM) && of_property_read_bool(np, "arm,cpu-registers-not-fw-configured")) arch_timer_use_virtual = false; arch_timer_init(); } CLOCKSOURCE_OF_DECLARE(armv7_arch_timer, "arm,armv7-timer", arch_timer_of_init); CLOCKSOURCE_OF_DECLARE(armv8_arch_timer, "arm,armv8-timer", arch_timer_of_init); |
220069945
|
709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 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 755 756 757 758 759 760 761 762 763 764 765 766 767 |
static void __init arch_timer_mem_init(struct device_node *np) { struct device_node *frame, *best_frame = NULL; void __iomem *cntctlbase, *base; unsigned int irq; u32 cnttidr; arch_timers_present |= ARCH_MEM_TIMER; cntctlbase = of_iomap(np, 0); if (!cntctlbase) { pr_err("arch_timer: Can't find CNTCTLBase "); return; } cnttidr = readl_relaxed(cntctlbase + CNTTIDR); iounmap(cntctlbase); /* * Try to find a virtual capable frame. Otherwise fall back to a * physical capable frame. */ for_each_available_child_of_node(np, frame) { int n; if (of_property_read_u32(frame, "frame-number", &n)) { pr_err("arch_timer: Missing frame-number "); of_node_put(best_frame); of_node_put(frame); return; } if (cnttidr & CNTTIDR_VIRT(n)) { of_node_put(best_frame); best_frame = frame; arch_timer_mem_use_virtual = true; break; } of_node_put(best_frame); best_frame = of_node_get(frame); } base = arch_counter_base = of_iomap(best_frame, 0); if (!base) { pr_err("arch_timer: Can't map frame's registers "); of_node_put(best_frame); return; } if (arch_timer_mem_use_virtual) irq = irq_of_parse_and_map(best_frame, 1); else irq = irq_of_parse_and_map(best_frame, 0); of_node_put(best_frame); if (!irq) { pr_err("arch_timer: Frame missing %s irq", |
cfb6d656d
|
768 |
arch_timer_mem_use_virtual ? "virt" : "phys"); |
220069945
|
769 770 771 772 773 774 775 776 777 |
return; } arch_timer_detect_rate(base, np); arch_timer_mem_register(base, irq); arch_timer_common_init(); } CLOCKSOURCE_OF_DECLARE(armv7_arch_timer_mem, "arm,armv7-timer-mem", arch_timer_mem_init); |
b09ca1ecf
|
778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 |
#ifdef CONFIG_ACPI static int __init map_generic_timer_interrupt(u32 interrupt, u32 flags) { int trigger, polarity; if (!interrupt) return 0; trigger = (flags & ACPI_GTDT_INTERRUPT_MODE) ? ACPI_EDGE_SENSITIVE : ACPI_LEVEL_SENSITIVE; polarity = (flags & ACPI_GTDT_INTERRUPT_POLARITY) ? ACPI_ACTIVE_LOW : ACPI_ACTIVE_HIGH; return acpi_register_gsi(NULL, interrupt, trigger, polarity); } /* Initialize per-processor generic timer */ static int __init arch_timer_acpi_init(struct acpi_table_header *table) { struct acpi_table_gtdt *gtdt; if (arch_timers_present & ARCH_CP15_TIMER) { pr_warn("arch_timer: already initialized, skipping "); return -EINVAL; } gtdt = container_of(table, struct acpi_table_gtdt, header); arch_timers_present |= ARCH_CP15_TIMER; arch_timer_ppi[PHYS_SECURE_PPI] = map_generic_timer_interrupt(gtdt->secure_el1_interrupt, gtdt->secure_el1_flags); arch_timer_ppi[PHYS_NONSECURE_PPI] = map_generic_timer_interrupt(gtdt->non_secure_el1_interrupt, gtdt->non_secure_el1_flags); arch_timer_ppi[VIRT_PPI] = map_generic_timer_interrupt(gtdt->virtual_timer_interrupt, gtdt->virtual_timer_flags); arch_timer_ppi[HYP_PPI] = map_generic_timer_interrupt(gtdt->non_secure_el2_interrupt, gtdt->non_secure_el2_flags); /* Get the frequency from CNTFRQ */ arch_timer_detect_rate(NULL, NULL); /* Always-on capability */ arch_timer_c3stop = !(gtdt->non_secure_el1_flags & ACPI_GTDT_ALWAYS_ON); arch_timer_init(); return 0; } |
ae281cbd2
|
836 |
CLOCKSOURCE_ACPI_DECLARE(arch_timer, ACPI_SIG_GTDT, arch_timer_acpi_init); |
b09ca1ecf
|
837 |
#endif |