arm64: capabilities: Group handling of features and errata workarounds

[ Upstream commit ed478b3f9e4ac97fdbe07007fb2662415de8fe25 ]

Now that the features and errata workarounds have the same
rules and flow, group the handling of the tables.

Reviewed-by: Dave Martin <dave.martin@arm.com>
Signed-off-by: Suzuki K Poulose <suzuki.poulose@arm.com>
Signed-off-by: Will Deacon <will.deacon@arm.com>
Signed-off-by: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/arch/arm64/kernel/cpufeature.c b/arch/arm64/kernel/cpufeature.c
index dda06f3436c25d561f39fad4de64ecfa9ff2bf8b..f4d640dc7f8b955b28cd72aa9925e8bcfe54cc24 100644 (file)
--- a/arch/arm64/kernel/cpufeature.c
+++ b/arch/arm64/kernel/cpufeature.c
@@ -485,9 +485,7 @@ static void __init init_cpu_ftr_reg(u32 sys_reg, u64 new)
 }
 
 extern const struct arm64_cpu_capabilities arm64_errata[];
-static const struct arm64_cpu_capabilities arm64_features[];
-static void update_cpu_capabilities(const struct arm64_cpu_capabilities *caps,
-                                   u16 scope_mask, const char *info);
+static void update_cpu_capabilities(u16 scope_mask);
 
 void __init init_cpu_features(struct cpuinfo_arm64 *info)
 {
@@ -530,9 +528,7 @@ void __init init_cpu_features(struct cpuinfo_arm64 *info)
         * Run the errata work around and local feature checks on the
         * boot CPU, once we have initialised the cpu feature infrastructure.
         */
-       update_cpu_capabilities(arm64_errata, SCOPE_LOCAL_CPU,
-                               "enabling workaround for");
-       update_cpu_capabilities(arm64_features, SCOPE_LOCAL_CPU, "detected:");
+       update_cpu_capabilities(SCOPE_LOCAL_CPU);
 }
 
 static void update_cpu_ftr_reg(struct arm64_ftr_reg *reg, u64 new)
@@ -1167,8 +1163,8 @@ static bool __this_cpu_has_cap(const struct arm64_cpu_capabilities *cap_array,
        return false;
 }
 
-static void update_cpu_capabilities(const struct arm64_cpu_capabilities *caps,
-                                   u16 scope_mask, const char *info)
+static void __update_cpu_capabilities(const struct arm64_cpu_capabilities *caps,
+                                     u16 scope_mask, const char *info)
 {
        scope_mask &= ARM64_CPUCAP_SCOPE_MASK;
        for (; caps->matches; caps++) {
@@ -1182,6 +1178,13 @@ static void update_cpu_capabilities(const struct arm64_cpu_capabilities *caps,
        }
 }
 
+static void update_cpu_capabilities(u16 scope_mask)
+{
+       __update_cpu_capabilities(arm64_features, scope_mask, "detected:");
+       __update_cpu_capabilities(arm64_errata, scope_mask,
+                                 "enabling workaround for");
+}
+
 static int __enable_cpu_capability(void *arg)
 {
        const struct arm64_cpu_capabilities *cap = arg;
@@ -1195,8 +1198,8 @@ static int __enable_cpu_capability(void *arg)
  * CPUs
  */
 static void __init
-enable_cpu_capabilities(const struct arm64_cpu_capabilities *caps,
-                       u16 scope_mask)
+__enable_cpu_capabilities(const struct arm64_cpu_capabilities *caps,
+                         u16 scope_mask)
 {
        scope_mask &= ARM64_CPUCAP_SCOPE_MASK;
        for (; caps->matches; caps++) {
@@ -1221,6 +1224,12 @@ enable_cpu_capabilities(const struct arm64_cpu_capabilities *caps,
        }
 }
 
+static void __init enable_cpu_capabilities(u16 scope_mask)
+{
+       __enable_cpu_capabilities(arm64_features, scope_mask);
+       __enable_cpu_capabilities(arm64_errata, scope_mask);
+}
+
 /*
  * Flag to indicate if we have computed the system wide
  * capabilities based on the boot time active CPUs. This
@@ -1294,6 +1303,12 @@ __verify_local_cpu_caps(const struct arm64_cpu_capabilities *caps_list,
        return true;
 }
 
+static bool verify_local_cpu_caps(u16 scope_mask)
+{
+       return __verify_local_cpu_caps(arm64_errata, scope_mask) &&
+              __verify_local_cpu_caps(arm64_features, scope_mask);
+}
+
 /*
  * Check for CPU features that are used in early boot
  * based on the Boot CPU value.
@@ -1327,15 +1342,9 @@ verify_local_elf_hwcaps(const struct arm64_cpu_capabilities *caps)
  */
 static void verify_local_cpu_capabilities(void)
 {
-       /*
-        * The CPU Errata work arounds are detected and applied at boot time
-        * and the related information is freed soon after. If the new CPU
-        * requires an errata not detected at boot, fail this CPU.
-        */
-       if (!__verify_local_cpu_caps(arm64_errata, SCOPE_ALL))
-               cpu_die_early();
-       if (!__verify_local_cpu_caps(arm64_features, SCOPE_ALL))
+       if (!verify_local_cpu_caps(SCOPE_ALL))
                cpu_die_early();
+
        verify_local_elf_hwcaps(arm64_elf_hwcaps);
        if (system_supports_32bit_el0())
                verify_local_elf_hwcaps(compat_elf_hwcaps);
@@ -1355,14 +1364,10 @@ void check_local_cpu_capabilities(void)
         * Otherwise, this CPU should verify that it has all the system
         * advertised capabilities.
         */
-       if (!sys_caps_initialised) {
-               update_cpu_capabilities(arm64_errata, SCOPE_LOCAL_CPU,
-                                       "enabling workaround for");
-               update_cpu_capabilities(arm64_features, SCOPE_LOCAL_CPU,
-                                       "detected:");
-       } else {
+       if (!sys_caps_initialised)
+               update_cpu_capabilities(SCOPE_LOCAL_CPU);
+       else
                verify_local_cpu_capabilities();
-       }
 }
 
 DEFINE_STATIC_KEY_FALSE(arm64_const_caps_ready);
@@ -1381,17 +1386,23 @@ bool this_cpu_has_cap(unsigned int cap)
                __this_cpu_has_cap(arm64_errata, cap));
 }
 
+static void __init setup_system_capabilities(void)
+{
+       /*
+        * We have finalised the system-wide safe feature
+        * registers, finalise the capabilities that depend
+        * on it. Also enable all the available capabilities.
+        */
+       update_cpu_capabilities(SCOPE_SYSTEM);
+       enable_cpu_capabilities(SCOPE_ALL);
+}
+
 void __init setup_cpu_features(void)
 {
        u32 cwg;
        int cls;
 
-       /* Set the CPU feature capabilies */
-       update_cpu_capabilities(arm64_features, SCOPE_SYSTEM, "detected:");
-       update_cpu_capabilities(arm64_errata, SCOPE_SYSTEM,
-                               "enabling workaround for");
-       enable_cpu_capabilities(arm64_features, SCOPE_ALL);
-       enable_cpu_capabilities(arm64_errata, SCOPE_ALL);
+       setup_system_capabilities();
        mark_const_caps_ready();
        setup_elf_hwcaps(arm64_elf_hwcaps);