LCOV - code coverage report
Current view: top level - drivers/clocksource - arm_arch_timer.c (source / functions) Hit Total Coverage
Test: Real Lines: 144 314 45.9 %
Date: 2020-10-17 15:46:43 Functions: 5 42 11.9 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           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
    

Generated by: LCOV version 1.14