Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
2 : : /*
3 : : * linux/drivers/clocksource/arm_arch_timer.c
4 : : *
5 : : * Copyright (C) 2011 ARM Ltd.
6 : : * All Rights Reserved
7 : : */
8 : :
9 : : #define pr_fmt(fmt) "arch_timer: " fmt
10 : :
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/cpu_pm.h>
17 : : #include <linux/clockchips.h>
18 : : #include <linux/clocksource.h>
19 : : #include <linux/interrupt.h>
20 : : #include <linux/of_irq.h>
21 : : #include <linux/of_address.h>
22 : : #include <linux/io.h>
23 : : #include <linux/slab.h>
24 : : #include <linux/sched/clock.h>
25 : : #include <linux/sched_clock.h>
26 : : #include <linux/acpi.h>
27 : :
28 : : #include <asm/arch_timer.h>
29 : : #include <asm/virt.h>
30 : :
31 : : #include <clocksource/arm_arch_timer.h>
32 : :
33 : : #define CNTTIDR 0x08
34 : : #define CNTTIDR_VIRT(n) (BIT(1) << ((n) * 4))
35 : :
36 : : #define CNTACR(n) (0x40 + ((n) * 4))
37 : : #define CNTACR_RPCT BIT(0)
38 : : #define CNTACR_RVCT BIT(1)
39 : : #define CNTACR_RFRQ BIT(2)
40 : : #define CNTACR_RVOFF BIT(3)
41 : : #define CNTACR_RWVT BIT(4)
42 : : #define CNTACR_RWPT BIT(5)
43 : :
44 : : #define CNTVCT_LO 0x08
45 : : #define CNTVCT_HI 0x0c
46 : : #define CNTFRQ 0x10
47 : : #define CNTP_TVAL 0x28
48 : : #define CNTP_CTL 0x2c
49 : : #define CNTV_TVAL 0x38
50 : : #define CNTV_CTL 0x3c
51 : :
52 : : static unsigned arch_timers_present __initdata;
53 : :
54 : : static void __iomem *arch_counter_base;
55 : :
56 : : struct arch_timer {
57 : : void __iomem *base;
58 : : struct clock_event_device evt;
59 : : };
60 : :
61 : : #define to_arch_timer(e) container_of(e, struct arch_timer, evt)
62 : :
63 : : static u32 arch_timer_rate;
64 : : static int arch_timer_ppi[ARCH_TIMER_MAX_TIMER_PPI];
65 : :
66 : : static struct clock_event_device __percpu *arch_timer_evt;
67 : :
68 : : static enum arch_timer_ppi_nr arch_timer_uses_ppi = ARCH_TIMER_VIRT_PPI;
69 : : static bool arch_timer_c3stop;
70 : : static bool arch_timer_mem_use_virtual;
71 : : static bool arch_counter_suspend_stop;
72 : : static enum vdso_arch_clockmode vdso_default = VDSO_CLOCKMODE_ARCHTIMER;
73 : :
74 : : static cpumask_t evtstrm_available = CPU_MASK_NONE;
75 : : static bool evtstrm_enable = IS_ENABLED(CONFIG_ARM_ARCH_TIMER_EVTSTREAM);
76 : :
77 : 0 : static int __init early_evtstrm_cfg(char *buf)
78 : : {
79 : 0 : return strtobool(buf, &evtstrm_enable);
80 : : }
81 : : early_param("clocksource.arm_arch_timer.evtstrm", early_evtstrm_cfg);
82 : :
83 : : /*
84 : : * Architected system timer support.
85 : : */
86 : :
87 : : static __always_inline
88 : : void arch_timer_reg_write(int access, enum arch_timer_reg reg, u32 val,
89 : : struct clock_event_device *clk)
90 : : {
91 : : if (access == ARCH_TIMER_MEM_PHYS_ACCESS) {
92 : : struct arch_timer *timer = to_arch_timer(clk);
93 : : switch (reg) {
94 : : case ARCH_TIMER_REG_CTRL:
95 : 0 : writel_relaxed(val, timer->base + CNTP_CTL);
96 : : break;
97 : : case ARCH_TIMER_REG_TVAL:
98 : 0 : writel_relaxed(val, timer->base + CNTP_TVAL);
99 : : break;
100 : : }
101 : : } else if (access == ARCH_TIMER_MEM_VIRT_ACCESS) {
102 : : struct arch_timer *timer = to_arch_timer(clk);
103 : : switch (reg) {
104 : : case ARCH_TIMER_REG_CTRL:
105 : 0 : writel_relaxed(val, timer->base + CNTV_CTL);
106 : : break;
107 : : case ARCH_TIMER_REG_TVAL:
108 : 0 : writel_relaxed(val, timer->base + CNTV_TVAL);
109 : : break;
110 : : }
111 : : } else {
112 : : arch_timer_reg_write_cp15(access, reg, val);
113 : : }
114 : : }
115 : :
116 : : static __always_inline
117 : : u32 arch_timer_reg_read(int access, enum arch_timer_reg reg,
118 : : struct clock_event_device *clk)
119 : : {
120 : : u32 val;
121 : :
122 : : if (access == ARCH_TIMER_MEM_PHYS_ACCESS) {
123 : : struct arch_timer *timer = to_arch_timer(clk);
124 : : switch (reg) {
125 : : case ARCH_TIMER_REG_CTRL:
126 : 0 : val = readl_relaxed(timer->base + CNTP_CTL);
127 : : break;
128 : : case ARCH_TIMER_REG_TVAL:
129 : : val = readl_relaxed(timer->base + CNTP_TVAL);
130 : : break;
131 : : }
132 : : } else if (access == ARCH_TIMER_MEM_VIRT_ACCESS) {
133 : : struct arch_timer *timer = to_arch_timer(clk);
134 : : switch (reg) {
135 : : case ARCH_TIMER_REG_CTRL:
136 : 0 : val = readl_relaxed(timer->base + CNTV_CTL);
137 : : break;
138 : : case ARCH_TIMER_REG_TVAL:
139 : : val = readl_relaxed(timer->base + CNTV_TVAL);
140 : : break;
141 : : }
142 : : } else {
143 : : val = arch_timer_reg_read_cp15(access, reg);
144 : : }
145 : :
146 : : return val;
147 : : }
148 : :
149 : : static notrace u64 arch_counter_get_cntpct_stable(void)
150 : : {
151 : : return __arch_counter_get_cntpct_stable();
152 : : }
153 : :
154 : 2 : static notrace u64 arch_counter_get_cntpct(void)
155 : : {
156 : 2 : return __arch_counter_get_cntpct();
157 : : }
158 : :
159 : : static notrace u64 arch_counter_get_cntvct_stable(void)
160 : : {
161 : : return __arch_counter_get_cntvct_stable();
162 : : }
163 : :
164 : 1 : static notrace u64 arch_counter_get_cntvct(void)
165 : : {
166 : 1 : return __arch_counter_get_cntvct();
167 : : }
168 : :
169 : : /*
170 : : * Default to cp15 based access because arm64 uses this function for
171 : : * sched_clock() before DT is probed and the cp15 method is guaranteed
172 : : * to exist on arm64. arm doesn't use this before DT is probed so even
173 : : * if we don't have the cp15 accessors we won't have a problem.
174 : : */
175 : : u64 (*arch_timer_read_counter)(void) = arch_counter_get_cntvct;
176 : : EXPORT_SYMBOL_GPL(arch_timer_read_counter);
177 : :
178 : 3 : static u64 arch_counter_read(struct clocksource *cs)
179 : : {
180 : 3 : return arch_timer_read_counter();
181 : : }
182 : :
183 : 3 : static u64 arch_counter_read_cc(const struct cyclecounter *cc)
184 : : {
185 : 3 : return arch_timer_read_counter();
186 : : }
187 : :
188 : : static struct clocksource clocksource_counter = {
189 : : .name = "arch_sys_counter",
190 : : .rating = 400,
191 : : .read = arch_counter_read,
192 : : .mask = CLOCKSOURCE_MASK(56),
193 : : .flags = CLOCK_SOURCE_IS_CONTINUOUS,
194 : : };
195 : :
196 : : static struct cyclecounter cyclecounter __ro_after_init = {
197 : : .read = arch_counter_read_cc,
198 : : .mask = CLOCKSOURCE_MASK(56),
199 : : };
200 : :
201 : : struct ate_acpi_oem_info {
202 : : char oem_id[ACPI_OEM_ID_SIZE + 1];
203 : : char oem_table_id[ACPI_OEM_TABLE_ID_SIZE + 1];
204 : : u32 oem_revision;
205 : : };
206 : :
207 : : #ifdef CONFIG_FSL_ERRATUM_A008585
208 : : /*
209 : : * The number of retries is an arbitrary value well beyond the highest number
210 : : * of iterations the loop has been observed to take.
211 : : */
212 : : #define __fsl_a008585_read_reg(reg) ({ \
213 : : u64 _old, _new; \
214 : : int _retries = 200; \
215 : : \
216 : : do { \
217 : : _old = read_sysreg(reg); \
218 : : _new = read_sysreg(reg); \
219 : : _retries--; \
220 : : } while (unlikely(_old != _new) && _retries); \
221 : : \
222 : : WARN_ON_ONCE(!_retries); \
223 : : _new; \
224 : : })
225 : :
226 : : static u32 notrace fsl_a008585_read_cntp_tval_el0(void)
227 : : {
228 : : return __fsl_a008585_read_reg(cntp_tval_el0);
229 : : }
230 : :
231 : : static u32 notrace fsl_a008585_read_cntv_tval_el0(void)
232 : : {
233 : : return __fsl_a008585_read_reg(cntv_tval_el0);
234 : : }
235 : :
236 : : static u64 notrace fsl_a008585_read_cntpct_el0(void)
237 : : {
238 : : return __fsl_a008585_read_reg(cntpct_el0);
239 : : }
240 : :
241 : : static u64 notrace fsl_a008585_read_cntvct_el0(void)
242 : : {
243 : : return __fsl_a008585_read_reg(cntvct_el0);
244 : : }
245 : : #endif
246 : :
247 : : #ifdef CONFIG_HISILICON_ERRATUM_161010101
248 : : /*
249 : : * Verify whether the value of the second read is larger than the first by
250 : : * less than 32 is the only way to confirm the value is correct, so clear the
251 : : * lower 5 bits to check whether the difference is greater than 32 or not.
252 : : * Theoretically the erratum should not occur more than twice in succession
253 : : * when reading the system counter, but it is possible that some interrupts
254 : : * may lead to more than twice read errors, triggering the warning, so setting
255 : : * the number of retries far beyond the number of iterations the loop has been
256 : : * observed to take.
257 : : */
258 : : #define __hisi_161010101_read_reg(reg) ({ \
259 : : u64 _old, _new; \
260 : : int _retries = 50; \
261 : : \
262 : : do { \
263 : : _old = read_sysreg(reg); \
264 : : _new = read_sysreg(reg); \
265 : : _retries--; \
266 : : } while (unlikely((_new - _old) >> 5) && _retries); \
267 : : \
268 : : WARN_ON_ONCE(!_retries); \
269 : : _new; \
270 : : })
271 : :
272 : : static u32 notrace hisi_161010101_read_cntp_tval_el0(void)
273 : : {
274 : : return __hisi_161010101_read_reg(cntp_tval_el0);
275 : : }
276 : :
277 : : static u32 notrace hisi_161010101_read_cntv_tval_el0(void)
278 : : {
279 : : return __hisi_161010101_read_reg(cntv_tval_el0);
280 : : }
281 : :
282 : : static u64 notrace hisi_161010101_read_cntpct_el0(void)
283 : : {
284 : : return __hisi_161010101_read_reg(cntpct_el0);
285 : : }
286 : :
287 : : static u64 notrace hisi_161010101_read_cntvct_el0(void)
288 : : {
289 : : return __hisi_161010101_read_reg(cntvct_el0);
290 : : }
291 : :
292 : : static struct ate_acpi_oem_info hisi_161010101_oem_info[] = {
293 : : /*
294 : : * Note that trailing spaces are required to properly match
295 : : * the OEM table information.
296 : : */
297 : : {
298 : : .oem_id = "HISI ",
299 : : .oem_table_id = "HIP05 ",
300 : : .oem_revision = 0,
301 : : },
302 : : {
303 : : .oem_id = "HISI ",
304 : : .oem_table_id = "HIP06 ",
305 : : .oem_revision = 0,
306 : : },
307 : : {
308 : : .oem_id = "HISI ",
309 : : .oem_table_id = "HIP07 ",
310 : : .oem_revision = 0,
311 : : },
312 : : { /* Sentinel indicating the end of the OEM array */ },
313 : : };
314 : : #endif
315 : :
316 : : #ifdef CONFIG_ARM64_ERRATUM_858921
317 : : static u64 notrace arm64_858921_read_cntpct_el0(void)
318 : : {
319 : : u64 old, new;
320 : :
321 : : old = read_sysreg(cntpct_el0);
322 : : new = read_sysreg(cntpct_el0);
323 : : return (((old ^ new) >> 32) & 1) ? old : new;
324 : : }
325 : :
326 : : static u64 notrace arm64_858921_read_cntvct_el0(void)
327 : : {
328 : : u64 old, new;
329 : :
330 : : old = read_sysreg(cntvct_el0);
331 : : new = read_sysreg(cntvct_el0);
332 : : return (((old ^ new) >> 32) & 1) ? old : new;
333 : : }
334 : : #endif
335 : :
336 : : #ifdef CONFIG_SUN50I_ERRATUM_UNKNOWN1
337 : : /*
338 : : * The low bits of the counter registers are indeterminate while bit 10 or
339 : : * greater is rolling over. Since the counter value can jump both backward
340 : : * (7ff -> 000 -> 800) and forward (7ff -> fff -> 800), ignore register values
341 : : * with all ones or all zeros in the low bits. Bound the loop by the maximum
342 : : * number of CPU cycles in 3 consecutive 24 MHz counter periods.
343 : : */
344 : : #define __sun50i_a64_read_reg(reg) ({ \
345 : : u64 _val; \
346 : : int _retries = 150; \
347 : : \
348 : : do { \
349 : : _val = read_sysreg(reg); \
350 : : _retries--; \
351 : : } while (((_val + 1) & GENMASK(9, 0)) <= 1 && _retries); \
352 : : \
353 : : WARN_ON_ONCE(!_retries); \
354 : : _val; \
355 : : })
356 : :
357 : : static u64 notrace sun50i_a64_read_cntpct_el0(void)
358 : : {
359 : : return __sun50i_a64_read_reg(cntpct_el0);
360 : : }
361 : :
362 : : static u64 notrace sun50i_a64_read_cntvct_el0(void)
363 : : {
364 : : return __sun50i_a64_read_reg(cntvct_el0);
365 : : }
366 : :
367 : : static u32 notrace sun50i_a64_read_cntp_tval_el0(void)
368 : : {
369 : : return read_sysreg(cntp_cval_el0) - sun50i_a64_read_cntpct_el0();
370 : : }
371 : :
372 : : static u32 notrace sun50i_a64_read_cntv_tval_el0(void)
373 : : {
374 : : return read_sysreg(cntv_cval_el0) - sun50i_a64_read_cntvct_el0();
375 : : }
376 : : #endif
377 : :
378 : : #ifdef CONFIG_ARM_ARCH_TIMER_OOL_WORKAROUND
379 : : DEFINE_PER_CPU(const struct arch_timer_erratum_workaround *, timer_unstable_counter_workaround);
380 : : EXPORT_SYMBOL_GPL(timer_unstable_counter_workaround);
381 : :
382 : : static atomic_t timer_unstable_counter_workaround_in_use = ATOMIC_INIT(0);
383 : :
384 : : static void erratum_set_next_event_tval_generic(const int access, unsigned long evt,
385 : : struct clock_event_device *clk)
386 : : {
387 : : unsigned long ctrl;
388 : : u64 cval;
389 : :
390 : : ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL, clk);
391 : : ctrl |= ARCH_TIMER_CTRL_ENABLE;
392 : : ctrl &= ~ARCH_TIMER_CTRL_IT_MASK;
393 : :
394 : : if (access == ARCH_TIMER_PHYS_ACCESS) {
395 : : cval = evt + arch_counter_get_cntpct();
396 : : write_sysreg(cval, cntp_cval_el0);
397 : : } else {
398 : : cval = evt + arch_counter_get_cntvct();
399 : : write_sysreg(cval, cntv_cval_el0);
400 : : }
401 : :
402 : : arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl, clk);
403 : : }
404 : :
405 : : static __maybe_unused int erratum_set_next_event_tval_virt(unsigned long evt,
406 : : struct clock_event_device *clk)
407 : : {
408 : : erratum_set_next_event_tval_generic(ARCH_TIMER_VIRT_ACCESS, evt, clk);
409 : : return 0;
410 : : }
411 : :
412 : : static __maybe_unused int erratum_set_next_event_tval_phys(unsigned long evt,
413 : : struct clock_event_device *clk)
414 : : {
415 : : erratum_set_next_event_tval_generic(ARCH_TIMER_PHYS_ACCESS, evt, clk);
416 : : return 0;
417 : : }
418 : :
419 : : static const struct arch_timer_erratum_workaround ool_workarounds[] = {
420 : : #ifdef CONFIG_FSL_ERRATUM_A008585
421 : : {
422 : : .match_type = ate_match_dt,
423 : : .id = "fsl,erratum-a008585",
424 : : .desc = "Freescale erratum a005858",
425 : : .read_cntp_tval_el0 = fsl_a008585_read_cntp_tval_el0,
426 : : .read_cntv_tval_el0 = fsl_a008585_read_cntv_tval_el0,
427 : : .read_cntpct_el0 = fsl_a008585_read_cntpct_el0,
428 : : .read_cntvct_el0 = fsl_a008585_read_cntvct_el0,
429 : : .set_next_event_phys = erratum_set_next_event_tval_phys,
430 : : .set_next_event_virt = erratum_set_next_event_tval_virt,
431 : : },
432 : : #endif
433 : : #ifdef CONFIG_HISILICON_ERRATUM_161010101
434 : : {
435 : : .match_type = ate_match_dt,
436 : : .id = "hisilicon,erratum-161010101",
437 : : .desc = "HiSilicon erratum 161010101",
438 : : .read_cntp_tval_el0 = hisi_161010101_read_cntp_tval_el0,
439 : : .read_cntv_tval_el0 = hisi_161010101_read_cntv_tval_el0,
440 : : .read_cntpct_el0 = hisi_161010101_read_cntpct_el0,
441 : : .read_cntvct_el0 = hisi_161010101_read_cntvct_el0,
442 : : .set_next_event_phys = erratum_set_next_event_tval_phys,
443 : : .set_next_event_virt = erratum_set_next_event_tval_virt,
444 : : },
445 : : {
446 : : .match_type = ate_match_acpi_oem_info,
447 : : .id = hisi_161010101_oem_info,
448 : : .desc = "HiSilicon erratum 161010101",
449 : : .read_cntp_tval_el0 = hisi_161010101_read_cntp_tval_el0,
450 : : .read_cntv_tval_el0 = hisi_161010101_read_cntv_tval_el0,
451 : : .read_cntpct_el0 = hisi_161010101_read_cntpct_el0,
452 : : .read_cntvct_el0 = hisi_161010101_read_cntvct_el0,
453 : : .set_next_event_phys = erratum_set_next_event_tval_phys,
454 : : .set_next_event_virt = erratum_set_next_event_tval_virt,
455 : : },
456 : : #endif
457 : : #ifdef CONFIG_ARM64_ERRATUM_858921
458 : : {
459 : : .match_type = ate_match_local_cap_id,
460 : : .id = (void *)ARM64_WORKAROUND_858921,
461 : : .desc = "ARM erratum 858921",
462 : : .read_cntpct_el0 = arm64_858921_read_cntpct_el0,
463 : : .read_cntvct_el0 = arm64_858921_read_cntvct_el0,
464 : : },
465 : : #endif
466 : : #ifdef CONFIG_SUN50I_ERRATUM_UNKNOWN1
467 : : {
468 : : .match_type = ate_match_dt,
469 : : .id = "allwinner,erratum-unknown1",
470 : : .desc = "Allwinner erratum UNKNOWN1",
471 : : .read_cntp_tval_el0 = sun50i_a64_read_cntp_tval_el0,
472 : : .read_cntv_tval_el0 = sun50i_a64_read_cntv_tval_el0,
473 : : .read_cntpct_el0 = sun50i_a64_read_cntpct_el0,
474 : : .read_cntvct_el0 = sun50i_a64_read_cntvct_el0,
475 : : .set_next_event_phys = erratum_set_next_event_tval_phys,
476 : : .set_next_event_virt = erratum_set_next_event_tval_virt,
477 : : },
478 : : #endif
479 : : #ifdef CONFIG_ARM64_ERRATUM_1418040
480 : : {
481 : : .match_type = ate_match_local_cap_id,
482 : : .id = (void *)ARM64_WORKAROUND_1418040,
483 : : .desc = "ARM erratum 1418040",
484 : : .disable_compat_vdso = true,
485 : : },
486 : : #endif
487 : : };
488 : :
489 : : typedef bool (*ate_match_fn_t)(const struct arch_timer_erratum_workaround *,
490 : : const void *);
491 : :
492 : : static
493 : : bool arch_timer_check_dt_erratum(const struct arch_timer_erratum_workaround *wa,
494 : : const void *arg)
495 : : {
496 : : const struct device_node *np = arg;
497 : :
498 : : return of_property_read_bool(np, wa->id);
499 : : }
500 : :
501 : : static
502 : : bool arch_timer_check_local_cap_erratum(const struct arch_timer_erratum_workaround *wa,
503 : : const void *arg)
504 : : {
505 : : return this_cpu_has_cap((uintptr_t)wa->id);
506 : : }
507 : :
508 : :
509 : : static
510 : : bool arch_timer_check_acpi_oem_erratum(const struct arch_timer_erratum_workaround *wa,
511 : : const void *arg)
512 : : {
513 : : static const struct ate_acpi_oem_info empty_oem_info = {};
514 : : const struct ate_acpi_oem_info *info = wa->id;
515 : : const struct acpi_table_header *table = arg;
516 : :
517 : : /* Iterate over the ACPI OEM info array, looking for a match */
518 : : while (memcmp(info, &empty_oem_info, sizeof(*info))) {
519 : : if (!memcmp(info->oem_id, table->oem_id, ACPI_OEM_ID_SIZE) &&
520 : : !memcmp(info->oem_table_id, table->oem_table_id, ACPI_OEM_TABLE_ID_SIZE) &&
521 : : info->oem_revision == table->oem_revision)
522 : : return true;
523 : :
524 : : info++;
525 : : }
526 : :
527 : : return false;
528 : : }
529 : :
530 : : static const struct arch_timer_erratum_workaround *
531 : : arch_timer_iterate_errata(enum arch_timer_erratum_match_type type,
532 : : ate_match_fn_t match_fn,
533 : : void *arg)
534 : : {
535 : : int i;
536 : :
537 : : for (i = 0; i < ARRAY_SIZE(ool_workarounds); i++) {
538 : : if (ool_workarounds[i].match_type != type)
539 : : continue;
540 : :
541 : : if (match_fn(&ool_workarounds[i], arg))
542 : : return &ool_workarounds[i];
543 : : }
544 : :
545 : : return NULL;
546 : : }
547 : :
548 : : static
549 : : void arch_timer_enable_workaround(const struct arch_timer_erratum_workaround *wa,
550 : : bool local)
551 : : {
552 : : int i;
553 : :
554 : : if (local) {
555 : : __this_cpu_write(timer_unstable_counter_workaround, wa);
556 : : } else {
557 : : for_each_possible_cpu(i)
558 : : per_cpu(timer_unstable_counter_workaround, i) = wa;
559 : : }
560 : :
561 : : if (wa->read_cntvct_el0 || wa->read_cntpct_el0)
562 : : atomic_set(&timer_unstable_counter_workaround_in_use, 1);
563 : :
564 : : /*
565 : : * Don't use the vdso fastpath if errata require using the
566 : : * out-of-line counter accessor. We may change our mind pretty
567 : : * late in the game (with a per-CPU erratum, for example), so
568 : : * change both the default value and the vdso itself.
569 : : */
570 : : if (wa->read_cntvct_el0) {
571 : : clocksource_counter.archdata.clock_mode = VDSO_CLOCKMODE_NONE;
572 : : vdso_default = VDSO_CLOCKMODE_NONE;
573 : : } else if (wa->disable_compat_vdso && vdso_default != VDSO_CLOCKMODE_NONE) {
574 : : vdso_default = VDSO_CLOCKMODE_ARCHTIMER_NOCOMPAT;
575 : : clocksource_counter.archdata.clock_mode = vdso_default;
576 : : }
577 : : }
578 : :
579 : : static void arch_timer_check_ool_workaround(enum arch_timer_erratum_match_type type,
580 : : void *arg)
581 : : {
582 : : const struct arch_timer_erratum_workaround *wa, *__wa;
583 : : ate_match_fn_t match_fn = NULL;
584 : : bool local = false;
585 : :
586 : : switch (type) {
587 : : case ate_match_dt:
588 : : match_fn = arch_timer_check_dt_erratum;
589 : : break;
590 : : case ate_match_local_cap_id:
591 : : match_fn = arch_timer_check_local_cap_erratum;
592 : : local = true;
593 : : break;
594 : : case ate_match_acpi_oem_info:
595 : : match_fn = arch_timer_check_acpi_oem_erratum;
596 : : break;
597 : : default:
598 : : WARN_ON(1);
599 : : return;
600 : : }
601 : :
602 : : wa = arch_timer_iterate_errata(type, match_fn, arg);
603 : : if (!wa)
604 : : return;
605 : :
606 : : __wa = __this_cpu_read(timer_unstable_counter_workaround);
607 : : if (__wa && wa != __wa)
608 : : pr_warn("Can't enable workaround for %s (clashes with %s\n)",
609 : : wa->desc, __wa->desc);
610 : :
611 : : if (__wa)
612 : : return;
613 : :
614 : : arch_timer_enable_workaround(wa, local);
615 : : pr_info("Enabling %s workaround for %s\n",
616 : : local ? "local" : "global", wa->desc);
617 : : }
618 : :
619 : : static bool arch_timer_this_cpu_has_cntvct_wa(void)
620 : : {
621 : : return has_erratum_handler(read_cntvct_el0);
622 : : }
623 : :
624 : : static bool arch_timer_counter_has_wa(void)
625 : : {
626 : : return atomic_read(&timer_unstable_counter_workaround_in_use);
627 : : }
628 : : #else
629 : : #define arch_timer_check_ool_workaround(t,a) do { } while(0)
630 : : #define arch_timer_this_cpu_has_cntvct_wa() ({false;})
631 : : #define arch_timer_counter_has_wa() ({false;})
632 : : #endif /* CONFIG_ARM_ARCH_TIMER_OOL_WORKAROUND */
633 : :
634 : : static __always_inline irqreturn_t timer_handler(const int access,
635 : : struct clock_event_device *evt)
636 : : {
637 : : unsigned long ctrl;
638 : :
639 : : ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL, evt);
640 : 3 : if (ctrl & ARCH_TIMER_CTRL_IT_STAT) {
641 : 3 : ctrl |= ARCH_TIMER_CTRL_IT_MASK;
642 : : arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl, evt);
643 : 3 : evt->event_handler(evt);
644 : : return IRQ_HANDLED;
645 : : }
646 : :
647 : : return IRQ_NONE;
648 : : }
649 : :
650 : 1 : static irqreturn_t arch_timer_handler_virt(int irq, void *dev_id)
651 : : {
652 : : struct clock_event_device *evt = dev_id;
653 : :
654 : 1 : return timer_handler(ARCH_TIMER_VIRT_ACCESS, evt);
655 : : }
656 : :
657 : 2 : static irqreturn_t arch_timer_handler_phys(int irq, void *dev_id)
658 : : {
659 : : struct clock_event_device *evt = dev_id;
660 : :
661 : 2 : return timer_handler(ARCH_TIMER_PHYS_ACCESS, evt);
662 : : }
663 : :
664 : 0 : static irqreturn_t arch_timer_handler_phys_mem(int irq, void *dev_id)
665 : : {
666 : : struct clock_event_device *evt = dev_id;
667 : :
668 : 0 : return timer_handler(ARCH_TIMER_MEM_PHYS_ACCESS, evt);
669 : : }
670 : :
671 : 0 : static irqreturn_t arch_timer_handler_virt_mem(int irq, void *dev_id)
672 : : {
673 : : struct clock_event_device *evt = dev_id;
674 : :
675 : 0 : return timer_handler(ARCH_TIMER_MEM_VIRT_ACCESS, evt);
676 : : }
677 : :
678 : : static __always_inline int timer_shutdown(const int access,
679 : : struct clock_event_device *clk)
680 : : {
681 : : unsigned long ctrl;
682 : :
683 : : ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL, clk);
684 : 3 : ctrl &= ~ARCH_TIMER_CTRL_ENABLE;
685 : : arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl, clk);
686 : :
687 : : return 0;
688 : : }
689 : :
690 : 1 : static int arch_timer_shutdown_virt(struct clock_event_device *clk)
691 : : {
692 : 1 : return timer_shutdown(ARCH_TIMER_VIRT_ACCESS, clk);
693 : : }
694 : :
695 : 2 : static int arch_timer_shutdown_phys(struct clock_event_device *clk)
696 : : {
697 : 2 : return timer_shutdown(ARCH_TIMER_PHYS_ACCESS, clk);
698 : : }
699 : :
700 : 0 : static int arch_timer_shutdown_virt_mem(struct clock_event_device *clk)
701 : : {
702 : 0 : return timer_shutdown(ARCH_TIMER_MEM_VIRT_ACCESS, clk);
703 : : }
704 : :
705 : 0 : static int arch_timer_shutdown_phys_mem(struct clock_event_device *clk)
706 : : {
707 : 0 : return timer_shutdown(ARCH_TIMER_MEM_PHYS_ACCESS, clk);
708 : : }
709 : :
710 : : static __always_inline void set_next_event(const int access, unsigned long evt,
711 : : struct clock_event_device *clk)
712 : : {
713 : : unsigned long ctrl;
714 : : ctrl = arch_timer_reg_read(access, ARCH_TIMER_REG_CTRL, clk);
715 : : ctrl |= ARCH_TIMER_CTRL_ENABLE;
716 : 3 : ctrl &= ~ARCH_TIMER_CTRL_IT_MASK;
717 : : arch_timer_reg_write(access, ARCH_TIMER_REG_TVAL, evt, clk);
718 : : arch_timer_reg_write(access, ARCH_TIMER_REG_CTRL, ctrl, clk);
719 : : }
720 : :
721 : 1 : static int arch_timer_set_next_event_virt(unsigned long evt,
722 : : struct clock_event_device *clk)
723 : : {
724 : : set_next_event(ARCH_TIMER_VIRT_ACCESS, evt, clk);
725 : 1 : return 0;
726 : : }
727 : :
728 : 2 : static int arch_timer_set_next_event_phys(unsigned long evt,
729 : : struct clock_event_device *clk)
730 : : {
731 : : set_next_event(ARCH_TIMER_PHYS_ACCESS, evt, clk);
732 : 2 : return 0;
733 : : }
734 : :
735 : 0 : static int arch_timer_set_next_event_virt_mem(unsigned long evt,
736 : : struct clock_event_device *clk)
737 : : {
738 : : set_next_event(ARCH_TIMER_MEM_VIRT_ACCESS, evt, clk);
739 : 0 : return 0;
740 : : }
741 : :
742 : 0 : static int arch_timer_set_next_event_phys_mem(unsigned long evt,
743 : : struct clock_event_device *clk)
744 : : {
745 : : set_next_event(ARCH_TIMER_MEM_PHYS_ACCESS, evt, clk);
746 : 0 : return 0;
747 : : }
748 : :
749 : 3 : static void __arch_timer_setup(unsigned type,
750 : : struct clock_event_device *clk)
751 : : {
752 : 3 : clk->features = CLOCK_EVT_FEAT_ONESHOT;
753 : :
754 : 3 : if (type == ARCH_TIMER_TYPE_CP15) {
755 : : typeof(clk->set_next_event) sne;
756 : :
757 : : arch_timer_check_ool_workaround(ate_match_local_cap_id, NULL);
758 : :
759 : 3 : if (arch_timer_c3stop)
760 : 0 : clk->features |= CLOCK_EVT_FEAT_C3STOP;
761 : 3 : clk->name = "arch_sys_timer";
762 : 3 : clk->rating = 450;
763 : 3 : clk->cpumask = cpumask_of(smp_processor_id());
764 : 3 : clk->irq = arch_timer_ppi[arch_timer_uses_ppi];
765 : 3 : switch (arch_timer_uses_ppi) {
766 : : case ARCH_TIMER_VIRT_PPI:
767 : 1 : clk->set_state_shutdown = arch_timer_shutdown_virt;
768 : 1 : clk->set_state_oneshot_stopped = arch_timer_shutdown_virt;
769 : : sne = erratum_handler(set_next_event_virt);
770 : 1 : break;
771 : : case ARCH_TIMER_PHYS_SECURE_PPI:
772 : : case ARCH_TIMER_PHYS_NONSECURE_PPI:
773 : : case ARCH_TIMER_HYP_PPI:
774 : 2 : clk->set_state_shutdown = arch_timer_shutdown_phys;
775 : 2 : clk->set_state_oneshot_stopped = arch_timer_shutdown_phys;
776 : : sne = erratum_handler(set_next_event_phys);
777 : 2 : break;
778 : : default:
779 : 0 : BUG();
780 : : }
781 : :
782 : 3 : clk->set_next_event = sne;
783 : : } else {
784 : 0 : clk->features |= CLOCK_EVT_FEAT_DYNIRQ;
785 : 0 : clk->name = "arch_mem_timer";
786 : 0 : clk->rating = 400;
787 : 0 : clk->cpumask = cpu_possible_mask;
788 : 0 : if (arch_timer_mem_use_virtual) {
789 : 0 : clk->set_state_shutdown = arch_timer_shutdown_virt_mem;
790 : 0 : clk->set_state_oneshot_stopped = arch_timer_shutdown_virt_mem;
791 : 0 : clk->set_next_event =
792 : : arch_timer_set_next_event_virt_mem;
793 : : } else {
794 : 0 : clk->set_state_shutdown = arch_timer_shutdown_phys_mem;
795 : 0 : clk->set_state_oneshot_stopped = arch_timer_shutdown_phys_mem;
796 : 0 : clk->set_next_event =
797 : : arch_timer_set_next_event_phys_mem;
798 : : }
799 : : }
800 : :
801 : 3 : clk->set_state_shutdown(clk);
802 : :
803 : 3 : clockevents_config_and_register(clk, arch_timer_rate, 0xf, 0x7fffffff);
804 : 3 : }
805 : :
806 : 3 : static void arch_timer_evtstrm_enable(int divider)
807 : : {
808 : : u32 cntkctl = arch_timer_get_cntkctl();
809 : :
810 : 3 : cntkctl &= ~ARCH_TIMER_EVT_TRIGGER_MASK;
811 : : /* Set the divider and enable virtual event stream */
812 : 3 : cntkctl |= (divider << ARCH_TIMER_EVT_TRIGGER_SHIFT)
813 : : | ARCH_TIMER_VIRT_EVT_EN;
814 : : arch_timer_set_cntkctl(cntkctl);
815 : : arch_timer_set_evtstrm_feature();
816 : 3 : cpumask_set_cpu(smp_processor_id(), &evtstrm_available);
817 : 3 : }
818 : :
819 : 3 : static void arch_timer_configure_evtstream(void)
820 : : {
821 : : int evt_stream_div, pos;
822 : :
823 : : /* Find the closest power of two to the divisor */
824 : 3 : evt_stream_div = arch_timer_rate / ARCH_TIMER_EVT_STREAM_FREQ;
825 : : pos = fls(evt_stream_div);
826 : 3 : if (pos > 1 && !(evt_stream_div & (1 << (pos - 2))))
827 : 0 : pos--;
828 : : /* enable event stream */
829 : 3 : arch_timer_evtstrm_enable(min(pos, 15));
830 : 3 : }
831 : :
832 : : static void arch_counter_set_user_access(void)
833 : : {
834 : : u32 cntkctl = arch_timer_get_cntkctl();
835 : :
836 : : /* Disable user access to the timers and both counters */
837 : : /* Also disable virtual event stream */
838 : 3 : cntkctl &= ~(ARCH_TIMER_USR_PT_ACCESS_EN
839 : : | ARCH_TIMER_USR_VT_ACCESS_EN
840 : : | ARCH_TIMER_USR_VCT_ACCESS_EN
841 : : | ARCH_TIMER_VIRT_EVT_EN
842 : : | ARCH_TIMER_USR_PCT_ACCESS_EN);
843 : :
844 : : /*
845 : : * Enable user access to the virtual counter if it doesn't
846 : : * need to be workaround. The vdso may have been already
847 : : * disabled though.
848 : : */
849 : : if (arch_timer_this_cpu_has_cntvct_wa())
850 : : pr_info("CPU%d: Trapping CNTVCT access\n", smp_processor_id());
851 : : else
852 : 3 : cntkctl |= ARCH_TIMER_USR_VCT_ACCESS_EN;
853 : :
854 : : arch_timer_set_cntkctl(cntkctl);
855 : : }
856 : :
857 : : static bool arch_timer_has_nonsecure_ppi(void)
858 : : {
859 : 3 : return (arch_timer_uses_ppi == ARCH_TIMER_PHYS_SECURE_PPI &&
860 : 2 : arch_timer_ppi[ARCH_TIMER_PHYS_NONSECURE_PPI]);
861 : : }
862 : :
863 : 3 : static u32 check_ppi_trigger(int irq)
864 : : {
865 : 3 : u32 flags = irq_get_trigger_type(irq);
866 : :
867 : 3 : if (flags != IRQF_TRIGGER_HIGH && flags != IRQF_TRIGGER_LOW) {
868 : 0 : pr_warn("WARNING: Invalid trigger for IRQ%d, assuming level low\n", irq);
869 : 0 : pr_warn("WARNING: Please fix your firmware\n");
870 : : flags = IRQF_TRIGGER_LOW;
871 : : }
872 : :
873 : 3 : return flags;
874 : : }
875 : :
876 : 3 : static int arch_timer_starting_cpu(unsigned int cpu)
877 : : {
878 : 3 : struct clock_event_device *clk = this_cpu_ptr(arch_timer_evt);
879 : : u32 flags;
880 : :
881 : 3 : __arch_timer_setup(ARCH_TIMER_TYPE_CP15, clk);
882 : :
883 : 3 : flags = check_ppi_trigger(arch_timer_ppi[arch_timer_uses_ppi]);
884 : 3 : enable_percpu_irq(arch_timer_ppi[arch_timer_uses_ppi], flags);
885 : :
886 : 3 : if (arch_timer_has_nonsecure_ppi()) {
887 : 2 : flags = check_ppi_trigger(arch_timer_ppi[ARCH_TIMER_PHYS_NONSECURE_PPI]);
888 : 2 : enable_percpu_irq(arch_timer_ppi[ARCH_TIMER_PHYS_NONSECURE_PPI],
889 : : flags);
890 : : }
891 : :
892 : : arch_counter_set_user_access();
893 : 3 : if (evtstrm_enable)
894 : 3 : arch_timer_configure_evtstream();
895 : :
896 : 3 : return 0;
897 : : }
898 : :
899 : : /*
900 : : * For historical reasons, when probing with DT we use whichever (non-zero)
901 : : * rate was probed first, and don't verify that others match. If the first node
902 : : * probed has a clock-frequency property, this overrides the HW register.
903 : : */
904 : 3 : static void arch_timer_of_configure_rate(u32 rate, struct device_node *np)
905 : : {
906 : : /* Who has more than one independent system counter? */
907 : 3 : if (arch_timer_rate)
908 : 3 : return;
909 : :
910 : 3 : if (of_property_read_u32(np, "clock-frequency", &arch_timer_rate))
911 : 3 : arch_timer_rate = rate;
912 : :
913 : : /* Check the timer frequency. */
914 : 3 : if (arch_timer_rate == 0)
915 : 0 : pr_warn("frequency not available\n");
916 : : }
917 : :
918 : 3 : static void arch_timer_banner(unsigned type)
919 : : {
920 : 3 : pr_info("%s%s%s timer(s) running at %lu.%02luMHz (%s%s%s).\n",
921 : : type & ARCH_TIMER_TYPE_CP15 ? "cp15" : "",
922 : : type == (ARCH_TIMER_TYPE_CP15 | ARCH_TIMER_TYPE_MEM) ?
923 : : " and " : "",
924 : : type & ARCH_TIMER_TYPE_MEM ? "mmio" : "",
925 : : (unsigned long)arch_timer_rate / 1000000,
926 : : (unsigned long)(arch_timer_rate / 10000) % 100,
927 : : type & ARCH_TIMER_TYPE_CP15 ?
928 : : (arch_timer_uses_ppi == ARCH_TIMER_VIRT_PPI) ? "virt" : "phys" :
929 : : "",
930 : : type == (ARCH_TIMER_TYPE_CP15 | ARCH_TIMER_TYPE_MEM) ? "/" : "",
931 : : type & ARCH_TIMER_TYPE_MEM ?
932 : : arch_timer_mem_use_virtual ? "virt" : "phys" :
933 : : "");
934 : 3 : }
935 : :
936 : 3 : u32 arch_timer_get_rate(void)
937 : : {
938 : 3 : return arch_timer_rate;
939 : : }
940 : :
941 : 0 : bool arch_timer_evtstrm_available(void)
942 : : {
943 : : /*
944 : : * We might get called from a preemptible context. This is fine
945 : : * because availability of the event stream should be always the same
946 : : * for a preemptible context and context where we might resume a task.
947 : : */
948 : 0 : return cpumask_test_cpu(raw_smp_processor_id(), &evtstrm_available);
949 : : }
950 : :
951 : 0 : static u64 arch_counter_get_cntvct_mem(void)
952 : : {
953 : : u32 vct_lo, vct_hi, tmp_hi;
954 : :
955 : : do {
956 : 0 : vct_hi = readl_relaxed(arch_counter_base + CNTVCT_HI);
957 : 0 : vct_lo = readl_relaxed(arch_counter_base + CNTVCT_LO);
958 : : tmp_hi = readl_relaxed(arch_counter_base + CNTVCT_HI);
959 : 0 : } while (vct_hi != tmp_hi);
960 : :
961 : 0 : return ((u64) vct_hi << 32) | vct_lo;
962 : : }
963 : :
964 : : static struct arch_timer_kvm_info arch_timer_kvm_info;
965 : :
966 : 0 : struct arch_timer_kvm_info *arch_timer_get_kvm_info(void)
967 : : {
968 : 0 : return &arch_timer_kvm_info;
969 : : }
970 : :
971 : 3 : static void __init arch_counter_register(unsigned type)
972 : : {
973 : : u64 start_count;
974 : :
975 : : /* Register the CP15 based counter if we have one */
976 : 3 : if (type & ARCH_TIMER_TYPE_CP15) {
977 : : u64 (*rd)(void);
978 : :
979 : 3 : if ((IS_ENABLED(CONFIG_ARM64) && !is_hyp_mode_available()) ||
980 : : arch_timer_uses_ppi == ARCH_TIMER_VIRT_PPI) {
981 : : if (arch_timer_counter_has_wa())
982 : : rd = arch_counter_get_cntvct_stable;
983 : : else
984 : : rd = arch_counter_get_cntvct;
985 : : } else {
986 : : if (arch_timer_counter_has_wa())
987 : : rd = arch_counter_get_cntpct_stable;
988 : : else
989 : : rd = arch_counter_get_cntpct;
990 : : }
991 : :
992 : 3 : arch_timer_read_counter = rd;
993 : 3 : clocksource_counter.archdata.clock_mode = vdso_default;
994 : : } else {
995 : 0 : arch_timer_read_counter = arch_counter_get_cntvct_mem;
996 : : }
997 : :
998 : 3 : if (!arch_counter_suspend_stop)
999 : 3 : clocksource_counter.flags |= CLOCK_SOURCE_SUSPEND_NONSTOP;
1000 : 3 : start_count = arch_timer_read_counter();
1001 : 3 : clocksource_register_hz(&clocksource_counter, arch_timer_rate);
1002 : 3 : cyclecounter.mult = clocksource_counter.mult;
1003 : 3 : cyclecounter.shift = clocksource_counter.shift;
1004 : 3 : timecounter_init(&arch_timer_kvm_info.timecounter,
1005 : : &cyclecounter, start_count);
1006 : :
1007 : : /* 56 bits minimum, so we assume worst case rollover */
1008 : 3 : sched_clock_register(arch_timer_read_counter, 56, arch_timer_rate);
1009 : 3 : }
1010 : :
1011 : 0 : static void arch_timer_stop(struct clock_event_device *clk)
1012 : : {
1013 : : pr_debug("disable IRQ%d cpu #%d\n", clk->irq, smp_processor_id());
1014 : :
1015 : 0 : disable_percpu_irq(arch_timer_ppi[arch_timer_uses_ppi]);
1016 : 0 : if (arch_timer_has_nonsecure_ppi())
1017 : 0 : disable_percpu_irq(arch_timer_ppi[ARCH_TIMER_PHYS_NONSECURE_PPI]);
1018 : :
1019 : 0 : clk->set_state_shutdown(clk);
1020 : 0 : }
1021 : :
1022 : 0 : static int arch_timer_dying_cpu(unsigned int cpu)
1023 : : {
1024 : 0 : struct clock_event_device *clk = this_cpu_ptr(arch_timer_evt);
1025 : :
1026 : 0 : cpumask_clear_cpu(smp_processor_id(), &evtstrm_available);
1027 : :
1028 : 0 : arch_timer_stop(clk);
1029 : 0 : return 0;
1030 : : }
1031 : :
1032 : : #ifdef CONFIG_CPU_PM
1033 : : static DEFINE_PER_CPU(unsigned long, saved_cntkctl);
1034 : : static int arch_timer_cpu_pm_notify(struct notifier_block *self,
1035 : : unsigned long action, void *hcpu)
1036 : : {
1037 : : if (action == CPU_PM_ENTER) {
1038 : : __this_cpu_write(saved_cntkctl, arch_timer_get_cntkctl());
1039 : :
1040 : : cpumask_clear_cpu(smp_processor_id(), &evtstrm_available);
1041 : : } else if (action == CPU_PM_ENTER_FAILED || action == CPU_PM_EXIT) {
1042 : : arch_timer_set_cntkctl(__this_cpu_read(saved_cntkctl));
1043 : :
1044 : : if (arch_timer_have_evtstrm_feature())
1045 : : cpumask_set_cpu(smp_processor_id(), &evtstrm_available);
1046 : : }
1047 : : return NOTIFY_OK;
1048 : : }
1049 : :
1050 : : static struct notifier_block arch_timer_cpu_pm_notifier = {
1051 : : .notifier_call = arch_timer_cpu_pm_notify,
1052 : : };
1053 : :
1054 : : static int __init arch_timer_cpu_pm_init(void)
1055 : : {
1056 : : return cpu_pm_register_notifier(&arch_timer_cpu_pm_notifier);
1057 : : }
1058 : :
1059 : : static void __init arch_timer_cpu_pm_deinit(void)
1060 : : {
1061 : : WARN_ON(cpu_pm_unregister_notifier(&arch_timer_cpu_pm_notifier));
1062 : : }
1063 : :
1064 : : #else
1065 : : static int __init arch_timer_cpu_pm_init(void)
1066 : : {
1067 : : return 0;
1068 : : }
1069 : :
1070 : : static void __init arch_timer_cpu_pm_deinit(void)
1071 : : {
1072 : : }
1073 : : #endif
1074 : :
1075 : 3 : static int __init arch_timer_register(void)
1076 : : {
1077 : : int err;
1078 : : int ppi;
1079 : :
1080 : 3 : arch_timer_evt = alloc_percpu(struct clock_event_device);
1081 : 3 : if (!arch_timer_evt) {
1082 : : err = -ENOMEM;
1083 : : goto out;
1084 : : }
1085 : :
1086 : 3 : ppi = arch_timer_ppi[arch_timer_uses_ppi];
1087 : 3 : switch (arch_timer_uses_ppi) {
1088 : : case ARCH_TIMER_VIRT_PPI:
1089 : 1 : err = request_percpu_irq(ppi, arch_timer_handler_virt,
1090 : : "arch_timer", arch_timer_evt);
1091 : 1 : break;
1092 : : case ARCH_TIMER_PHYS_SECURE_PPI:
1093 : : case ARCH_TIMER_PHYS_NONSECURE_PPI:
1094 : 2 : err = request_percpu_irq(ppi, arch_timer_handler_phys,
1095 : : "arch_timer", arch_timer_evt);
1096 : 2 : if (!err && arch_timer_has_nonsecure_ppi()) {
1097 : 2 : ppi = arch_timer_ppi[ARCH_TIMER_PHYS_NONSECURE_PPI];
1098 : 2 : err = request_percpu_irq(ppi, arch_timer_handler_phys,
1099 : : "arch_timer", arch_timer_evt);
1100 : 2 : if (err)
1101 : 0 : free_percpu_irq(arch_timer_ppi[ARCH_TIMER_PHYS_SECURE_PPI],
1102 : : arch_timer_evt);
1103 : : }
1104 : : break;
1105 : : case ARCH_TIMER_HYP_PPI:
1106 : 0 : err = request_percpu_irq(ppi, arch_timer_handler_phys,
1107 : : "arch_timer", arch_timer_evt);
1108 : 0 : break;
1109 : : default:
1110 : 0 : BUG();
1111 : : }
1112 : :
1113 : 3 : if (err) {
1114 : 0 : pr_err("can't register interrupt %d (%d)\n", ppi, err);
1115 : 0 : goto out_free;
1116 : : }
1117 : :
1118 : : err = arch_timer_cpu_pm_init();
1119 : : if (err)
1120 : : goto out_unreg_notify;
1121 : :
1122 : : /* Register and immediately configure the timer on the boot CPU */
1123 : : err = cpuhp_setup_state(CPUHP_AP_ARM_ARCH_TIMER_STARTING,
1124 : : "clockevents/arm/arch_timer:starting",
1125 : : arch_timer_starting_cpu, arch_timer_dying_cpu);
1126 : 3 : if (err)
1127 : : goto out_unreg_cpupm;
1128 : : return 0;
1129 : :
1130 : : out_unreg_cpupm:
1131 : : arch_timer_cpu_pm_deinit();
1132 : :
1133 : : out_unreg_notify:
1134 : 0 : free_percpu_irq(arch_timer_ppi[arch_timer_uses_ppi], arch_timer_evt);
1135 : 0 : if (arch_timer_has_nonsecure_ppi())
1136 : 0 : free_percpu_irq(arch_timer_ppi[ARCH_TIMER_PHYS_NONSECURE_PPI],
1137 : : arch_timer_evt);
1138 : :
1139 : : out_free:
1140 : 0 : free_percpu(arch_timer_evt);
1141 : : out:
1142 : 0 : return err;
1143 : : }
1144 : :
1145 : 0 : static int __init arch_timer_mem_register(void __iomem *base, unsigned int irq)
1146 : : {
1147 : : int ret;
1148 : : irq_handler_t func;
1149 : : struct arch_timer *t;
1150 : :
1151 : 0 : t = kzalloc(sizeof(*t), GFP_KERNEL);
1152 : 0 : if (!t)
1153 : : return -ENOMEM;
1154 : :
1155 : 0 : t->base = base;
1156 : 0 : t->evt.irq = irq;
1157 : 0 : __arch_timer_setup(ARCH_TIMER_TYPE_MEM, &t->evt);
1158 : :
1159 : 0 : if (arch_timer_mem_use_virtual)
1160 : : func = arch_timer_handler_virt_mem;
1161 : : else
1162 : : func = arch_timer_handler_phys_mem;
1163 : :
1164 : : ret = request_irq(irq, func, IRQF_TIMER, "arch_mem_timer", &t->evt);
1165 : 0 : if (ret) {
1166 : 0 : pr_err("Failed to request mem timer irq\n");
1167 : 0 : kfree(t);
1168 : : }
1169 : :
1170 : 0 : return ret;
1171 : : }
1172 : :
1173 : : static const struct of_device_id arch_timer_of_match[] __initconst = {
1174 : : { .compatible = "arm,armv7-timer", },
1175 : : { .compatible = "arm,armv8-timer", },
1176 : : {},
1177 : : };
1178 : :
1179 : : static const struct of_device_id arch_timer_mem_of_match[] __initconst = {
1180 : : { .compatible = "arm,armv7-timer-mem", },
1181 : : {},
1182 : : };
1183 : :
1184 : 3 : static bool __init arch_timer_needs_of_probing(void)
1185 : : {
1186 : : struct device_node *dn;
1187 : : bool needs_probing = false;
1188 : : unsigned int mask = ARCH_TIMER_TYPE_CP15 | ARCH_TIMER_TYPE_MEM;
1189 : :
1190 : : /* We have two timers, and both device-tree nodes are probed. */
1191 : 3 : if ((arch_timers_present & mask) == mask)
1192 : : return false;
1193 : :
1194 : : /*
1195 : : * Only one type of timer is probed,
1196 : : * check if we have another type of timer node in device-tree.
1197 : : */
1198 : 3 : if (arch_timers_present & ARCH_TIMER_TYPE_CP15)
1199 : : dn = of_find_matching_node(NULL, arch_timer_mem_of_match);
1200 : : else
1201 : : dn = of_find_matching_node(NULL, arch_timer_of_match);
1202 : :
1203 : 3 : if (dn && of_device_is_available(dn))
1204 : : needs_probing = true;
1205 : :
1206 : 3 : of_node_put(dn);
1207 : :
1208 : 3 : return needs_probing;
1209 : : }
1210 : :
1211 : 3 : static int __init arch_timer_common_init(void)
1212 : : {
1213 : 3 : arch_timer_banner(arch_timers_present);
1214 : 3 : arch_counter_register(arch_timers_present);
1215 : 3 : return arch_timer_arch_init();
1216 : : }
1217 : :
1218 : : /**
1219 : : * arch_timer_select_ppi() - Select suitable PPI for the current system.
1220 : : *
1221 : : * If HYP mode is available, we know that the physical timer
1222 : : * has been configured to be accessible from PL1. Use it, so
1223 : : * that a guest can use the virtual timer instead.
1224 : : *
1225 : : * On ARMv8.1 with VH extensions, the kernel runs in HYP. VHE
1226 : : * accesses to CNTP_*_EL1 registers are silently redirected to
1227 : : * their CNTHP_*_EL2 counterparts, and use a different PPI
1228 : : * number.
1229 : : *
1230 : : * If no interrupt provided for virtual timer, we'll have to
1231 : : * stick to the physical timer. It'd better be accessible...
1232 : : * For arm64 we never use the secure interrupt.
1233 : : *
1234 : : * Return: a suitable PPI type for the current system.
1235 : : */
1236 : 3 : static enum arch_timer_ppi_nr __init arch_timer_select_ppi(void)
1237 : : {
1238 : : if (is_kernel_in_hyp_mode())
1239 : : return ARCH_TIMER_HYP_PPI;
1240 : :
1241 : 3 : if (!is_hyp_mode_available() && arch_timer_ppi[ARCH_TIMER_VIRT_PPI])
1242 : : return ARCH_TIMER_VIRT_PPI;
1243 : :
1244 : : if (IS_ENABLED(CONFIG_ARM64))
1245 : : return ARCH_TIMER_PHYS_NONSECURE_PPI;
1246 : :
1247 : 2 : return ARCH_TIMER_PHYS_SECURE_PPI;
1248 : : }
1249 : :
1250 : 3 : static void __init arch_timer_populate_kvm_info(void)
1251 : : {
1252 : 3 : arch_timer_kvm_info.virtual_irq = arch_timer_ppi[ARCH_TIMER_VIRT_PPI];
1253 : : if (is_kernel_in_hyp_mode())
1254 : : arch_timer_kvm_info.physical_irq = arch_timer_ppi[ARCH_TIMER_PHYS_NONSECURE_PPI];
1255 : 3 : }
1256 : :
1257 : 3 : static int __init arch_timer_of_init(struct device_node *np)
1258 : : {
1259 : : int i, ret;
1260 : : u32 rate;
1261 : :
1262 : 3 : if (arch_timers_present & ARCH_TIMER_TYPE_CP15) {
1263 : 0 : pr_warn("multiple nodes in dt, skipping\n");
1264 : 0 : return 0;
1265 : : }
1266 : :
1267 : 3 : arch_timers_present |= ARCH_TIMER_TYPE_CP15;
1268 : 3 : for (i = ARCH_TIMER_PHYS_SECURE_PPI; i < ARCH_TIMER_MAX_TIMER_PPI; i++)
1269 : 3 : arch_timer_ppi[i] = irq_of_parse_and_map(np, i);
1270 : :
1271 : 3 : arch_timer_populate_kvm_info();
1272 : :
1273 : : rate = arch_timer_get_cntfrq();
1274 : 3 : arch_timer_of_configure_rate(rate, np);
1275 : :
1276 : 3 : arch_timer_c3stop = !of_property_read_bool(np, "always-on");
1277 : :
1278 : : /* Check for globally applicable workarounds */
1279 : : arch_timer_check_ool_workaround(ate_match_dt, np);
1280 : :
1281 : : /*
1282 : : * If we cannot rely on firmware initializing the timer registers then
1283 : : * we should use the physical timers instead.
1284 : : */
1285 : 3 : if (IS_ENABLED(CONFIG_ARM) &&
1286 : : of_property_read_bool(np, "arm,cpu-registers-not-fw-configured"))
1287 : 0 : arch_timer_uses_ppi = ARCH_TIMER_PHYS_SECURE_PPI;
1288 : : else
1289 : 3 : arch_timer_uses_ppi = arch_timer_select_ppi();
1290 : :
1291 : 3 : if (!arch_timer_ppi[arch_timer_uses_ppi]) {
1292 : 0 : pr_err("No interrupt available, giving up\n");
1293 : 0 : return -EINVAL;
1294 : : }
1295 : :
1296 : : /* On some systems, the counter stops ticking when in suspend. */
1297 : 3 : arch_counter_suspend_stop = of_property_read_bool(np,
1298 : : "arm,no-tick-in-suspend");
1299 : :
1300 : 3 : ret = arch_timer_register();
1301 : 3 : if (ret)
1302 : : return ret;
1303 : :
1304 : 3 : if (arch_timer_needs_of_probing())
1305 : : return 0;
1306 : :
1307 : 3 : return arch_timer_common_init();
1308 : : }
1309 : : TIMER_OF_DECLARE(armv7_arch_timer, "arm,armv7-timer", arch_timer_of_init);
1310 : : TIMER_OF_DECLARE(armv8_arch_timer, "arm,armv8-timer", arch_timer_of_init);
1311 : :
1312 : : static u32 __init
1313 : 0 : arch_timer_mem_frame_get_cntfrq(struct arch_timer_mem_frame *frame)
1314 : : {
1315 : : void __iomem *base;
1316 : : u32 rate;
1317 : :
1318 : 0 : base = ioremap(frame->cntbase, frame->size);
1319 : 0 : if (!base) {
1320 : 0 : pr_err("Unable to map frame @ %pa\n", &frame->cntbase);
1321 : 0 : return 0;
1322 : : }
1323 : :
1324 : 0 : rate = readl_relaxed(base + CNTFRQ);
1325 : :
1326 : 0 : iounmap(base);
1327 : :
1328 : 0 : return rate;
1329 : : }
1330 : :
1331 : : static struct arch_timer_mem_frame * __init
1332 : 0 : arch_timer_mem_find_best_frame(struct arch_timer_mem *timer_mem)
1333 : : {
1334 : : struct arch_timer_mem_frame *frame, *best_frame = NULL;
1335 : : void __iomem *cntctlbase;
1336 : : u32 cnttidr;
1337 : : int i;
1338 : :
1339 : 0 : cntctlbase = ioremap(timer_mem->cntctlbase, timer_mem->size);
1340 : 0 : if (!cntctlbase) {
1341 : 0 : pr_err("Can't map CNTCTLBase @ %pa\n",
1342 : : &timer_mem->cntctlbase);
1343 : 0 : return NULL;
1344 : : }
1345 : :
1346 : 0 : cnttidr = readl_relaxed(cntctlbase + CNTTIDR);
1347 : :
1348 : : /*
1349 : : * Try to find a virtual capable frame. Otherwise fall back to a
1350 : : * physical capable frame.
1351 : : */
1352 : 0 : for (i = 0; i < ARCH_TIMER_MEM_MAX_FRAMES; i++) {
1353 : : u32 cntacr = CNTACR_RFRQ | CNTACR_RWPT | CNTACR_RPCT |
1354 : : CNTACR_RWVT | CNTACR_RVOFF | CNTACR_RVCT;
1355 : :
1356 : 0 : frame = &timer_mem->frame[i];
1357 : 0 : if (!frame->valid)
1358 : 0 : continue;
1359 : :
1360 : : /* Try enabling everything, and see what sticks */
1361 : 0 : writel_relaxed(cntacr, cntctlbase + CNTACR(i));
1362 : : cntacr = readl_relaxed(cntctlbase + CNTACR(i));
1363 : :
1364 : 0 : if ((cnttidr & CNTTIDR_VIRT(i)) &&
1365 : 0 : !(~cntacr & (CNTACR_RWVT | CNTACR_RVCT))) {
1366 : 0 : best_frame = frame;
1367 : 0 : arch_timer_mem_use_virtual = true;
1368 : 0 : break;
1369 : : }
1370 : :
1371 : 0 : if (~cntacr & (CNTACR_RWPT | CNTACR_RPCT))
1372 : 0 : continue;
1373 : :
1374 : : best_frame = frame;
1375 : : }
1376 : :
1377 : 0 : iounmap(cntctlbase);
1378 : :
1379 : 0 : return best_frame;
1380 : : }
1381 : :
1382 : : static int __init
1383 : 0 : arch_timer_mem_frame_register(struct arch_timer_mem_frame *frame)
1384 : : {
1385 : : void __iomem *base;
1386 : : int ret, irq = 0;
1387 : :
1388 : 0 : if (arch_timer_mem_use_virtual)
1389 : 0 : irq = frame->virt_irq;
1390 : : else
1391 : 0 : irq = frame->phys_irq;
1392 : :
1393 : 0 : if (!irq) {
1394 : 0 : pr_err("Frame missing %s irq.\n",
1395 : : arch_timer_mem_use_virtual ? "virt" : "phys");
1396 : 0 : return -EINVAL;
1397 : : }
1398 : :
1399 : 0 : if (!request_mem_region(frame->cntbase, frame->size,
1400 : : "arch_mem_timer"))
1401 : : return -EBUSY;
1402 : :
1403 : 0 : base = ioremap(frame->cntbase, frame->size);
1404 : 0 : if (!base) {
1405 : 0 : pr_err("Can't map frame's registers\n");
1406 : 0 : return -ENXIO;
1407 : : }
1408 : :
1409 : 0 : ret = arch_timer_mem_register(base, irq);
1410 : 0 : if (ret) {
1411 : 0 : iounmap(base);
1412 : 0 : return ret;
1413 : : }
1414 : :
1415 : 0 : arch_counter_base = base;
1416 : 0 : arch_timers_present |= ARCH_TIMER_TYPE_MEM;
1417 : :
1418 : 0 : return 0;
1419 : : }
1420 : :
1421 : 0 : static int __init arch_timer_mem_of_init(struct device_node *np)
1422 : : {
1423 : : struct arch_timer_mem *timer_mem;
1424 : : struct arch_timer_mem_frame *frame;
1425 : : struct device_node *frame_node;
1426 : : struct resource res;
1427 : : int ret = -EINVAL;
1428 : : u32 rate;
1429 : :
1430 : 0 : timer_mem = kzalloc(sizeof(*timer_mem), GFP_KERNEL);
1431 : 0 : if (!timer_mem)
1432 : : return -ENOMEM;
1433 : :
1434 : 0 : if (of_address_to_resource(np, 0, &res))
1435 : : goto out;
1436 : 0 : timer_mem->cntctlbase = res.start;
1437 : 0 : timer_mem->size = resource_size(&res);
1438 : :
1439 : 0 : for_each_available_child_of_node(np, frame_node) {
1440 : : u32 n;
1441 : : struct arch_timer_mem_frame *frame;
1442 : :
1443 : 0 : if (of_property_read_u32(frame_node, "frame-number", &n)) {
1444 : 0 : pr_err(FW_BUG "Missing frame-number.\n");
1445 : 0 : of_node_put(frame_node);
1446 : 0 : goto out;
1447 : : }
1448 : 0 : if (n >= ARCH_TIMER_MEM_MAX_FRAMES) {
1449 : 0 : pr_err(FW_BUG "Wrong frame-number, only 0-%u are permitted.\n",
1450 : : ARCH_TIMER_MEM_MAX_FRAMES - 1);
1451 : 0 : of_node_put(frame_node);
1452 : 0 : goto out;
1453 : : }
1454 : : frame = &timer_mem->frame[n];
1455 : :
1456 : 0 : if (frame->valid) {
1457 : 0 : pr_err(FW_BUG "Duplicated frame-number.\n");
1458 : 0 : of_node_put(frame_node);
1459 : 0 : goto out;
1460 : : }
1461 : :
1462 : 0 : if (of_address_to_resource(frame_node, 0, &res)) {
1463 : 0 : of_node_put(frame_node);
1464 : 0 : goto out;
1465 : : }
1466 : 0 : frame->cntbase = res.start;
1467 : 0 : frame->size = resource_size(&res);
1468 : :
1469 : 0 : frame->virt_irq = irq_of_parse_and_map(frame_node,
1470 : : ARCH_TIMER_VIRT_SPI);
1471 : 0 : frame->phys_irq = irq_of_parse_and_map(frame_node,
1472 : : ARCH_TIMER_PHYS_SPI);
1473 : :
1474 : 0 : frame->valid = true;
1475 : : }
1476 : :
1477 : 0 : frame = arch_timer_mem_find_best_frame(timer_mem);
1478 : 0 : if (!frame) {
1479 : 0 : pr_err("Unable to find a suitable frame in timer @ %pa\n",
1480 : : &timer_mem->cntctlbase);
1481 : : ret = -EINVAL;
1482 : 0 : goto out;
1483 : : }
1484 : :
1485 : 0 : rate = arch_timer_mem_frame_get_cntfrq(frame);
1486 : 0 : arch_timer_of_configure_rate(rate, np);
1487 : :
1488 : 0 : ret = arch_timer_mem_frame_register(frame);
1489 : 0 : if (!ret && !arch_timer_needs_of_probing())
1490 : 0 : ret = arch_timer_common_init();
1491 : : out:
1492 : 0 : kfree(timer_mem);
1493 : 0 : return ret;
1494 : : }
1495 : : TIMER_OF_DECLARE(armv7_arch_timer_mem, "arm,armv7-timer-mem",
1496 : : arch_timer_mem_of_init);
1497 : :
1498 : : #ifdef CONFIG_ACPI_GTDT
1499 : : static int __init
1500 : : arch_timer_mem_verify_cntfrq(struct arch_timer_mem *timer_mem)
1501 : : {
1502 : : struct arch_timer_mem_frame *frame;
1503 : : u32 rate;
1504 : : int i;
1505 : :
1506 : : for (i = 0; i < ARCH_TIMER_MEM_MAX_FRAMES; i++) {
1507 : : frame = &timer_mem->frame[i];
1508 : :
1509 : : if (!frame->valid)
1510 : : continue;
1511 : :
1512 : : rate = arch_timer_mem_frame_get_cntfrq(frame);
1513 : : if (rate == arch_timer_rate)
1514 : : continue;
1515 : :
1516 : : pr_err(FW_BUG "CNTFRQ mismatch: frame @ %pa: (0x%08lx), CPU: (0x%08lx)\n",
1517 : : &frame->cntbase,
1518 : : (unsigned long)rate, (unsigned long)arch_timer_rate);
1519 : :
1520 : : return -EINVAL;
1521 : : }
1522 : :
1523 : : return 0;
1524 : : }
1525 : :
1526 : : static int __init arch_timer_mem_acpi_init(int platform_timer_count)
1527 : : {
1528 : : struct arch_timer_mem *timers, *timer;
1529 : : struct arch_timer_mem_frame *frame, *best_frame = NULL;
1530 : : int timer_count, i, ret = 0;
1531 : :
1532 : : timers = kcalloc(platform_timer_count, sizeof(*timers),
1533 : : GFP_KERNEL);
1534 : : if (!timers)
1535 : : return -ENOMEM;
1536 : :
1537 : : ret = acpi_arch_timer_mem_init(timers, &timer_count);
1538 : : if (ret || !timer_count)
1539 : : goto out;
1540 : :
1541 : : /*
1542 : : * While unlikely, it's theoretically possible that none of the frames
1543 : : * in a timer expose the combination of feature we want.
1544 : : */
1545 : : for (i = 0; i < timer_count; i++) {
1546 : : timer = &timers[i];
1547 : :
1548 : : frame = arch_timer_mem_find_best_frame(timer);
1549 : : if (!best_frame)
1550 : : best_frame = frame;
1551 : :
1552 : : ret = arch_timer_mem_verify_cntfrq(timer);
1553 : : if (ret) {
1554 : : pr_err("Disabling MMIO timers due to CNTFRQ mismatch\n");
1555 : : goto out;
1556 : : }
1557 : :
1558 : : if (!best_frame) /* implies !frame */
1559 : : /*
1560 : : * Only complain about missing suitable frames if we
1561 : : * haven't already found one in a previous iteration.
1562 : : */
1563 : : pr_err("Unable to find a suitable frame in timer @ %pa\n",
1564 : : &timer->cntctlbase);
1565 : : }
1566 : :
1567 : : if (best_frame)
1568 : : ret = arch_timer_mem_frame_register(best_frame);
1569 : : out:
1570 : : kfree(timers);
1571 : : return ret;
1572 : : }
1573 : :
1574 : : /* Initialize per-processor generic timer and memory-mapped timer(if present) */
1575 : : static int __init arch_timer_acpi_init(struct acpi_table_header *table)
1576 : : {
1577 : : int ret, platform_timer_count;
1578 : :
1579 : : if (arch_timers_present & ARCH_TIMER_TYPE_CP15) {
1580 : : pr_warn("already initialized, skipping\n");
1581 : : return -EINVAL;
1582 : : }
1583 : :
1584 : : arch_timers_present |= ARCH_TIMER_TYPE_CP15;
1585 : :
1586 : : ret = acpi_gtdt_init(table, &platform_timer_count);
1587 : : if (ret) {
1588 : : pr_err("Failed to init GTDT table.\n");
1589 : : return ret;
1590 : : }
1591 : :
1592 : : arch_timer_ppi[ARCH_TIMER_PHYS_NONSECURE_PPI] =
1593 : : acpi_gtdt_map_ppi(ARCH_TIMER_PHYS_NONSECURE_PPI);
1594 : :
1595 : : arch_timer_ppi[ARCH_TIMER_VIRT_PPI] =
1596 : : acpi_gtdt_map_ppi(ARCH_TIMER_VIRT_PPI);
1597 : :
1598 : : arch_timer_ppi[ARCH_TIMER_HYP_PPI] =
1599 : : acpi_gtdt_map_ppi(ARCH_TIMER_HYP_PPI);
1600 : :
1601 : : arch_timer_populate_kvm_info();
1602 : :
1603 : : /*
1604 : : * When probing via ACPI, we have no mechanism to override the sysreg
1605 : : * CNTFRQ value. This *must* be correct.
1606 : : */
1607 : : arch_timer_rate = arch_timer_get_cntfrq();
1608 : : if (!arch_timer_rate) {
1609 : : pr_err(FW_BUG "frequency not available.\n");
1610 : : return -EINVAL;
1611 : : }
1612 : :
1613 : : arch_timer_uses_ppi = arch_timer_select_ppi();
1614 : : if (!arch_timer_ppi[arch_timer_uses_ppi]) {
1615 : : pr_err("No interrupt available, giving up\n");
1616 : : return -EINVAL;
1617 : : }
1618 : :
1619 : : /* Always-on capability */
1620 : : arch_timer_c3stop = acpi_gtdt_c3stop(arch_timer_uses_ppi);
1621 : :
1622 : : /* Check for globally applicable workarounds */
1623 : : arch_timer_check_ool_workaround(ate_match_acpi_oem_info, table);
1624 : :
1625 : : ret = arch_timer_register();
1626 : : if (ret)
1627 : : return ret;
1628 : :
1629 : : if (platform_timer_count &&
1630 : : arch_timer_mem_acpi_init(platform_timer_count))
1631 : : pr_err("Failed to initialize memory-mapped timer.\n");
1632 : :
1633 : : return arch_timer_common_init();
1634 : : }
1635 : : TIMER_ACPI_DECLARE(arch_timer, ACPI_SIG_GTDT, arch_timer_acpi_init);
1636 : : #endif
|
