2 * Contains CPU specific errata definitions
4 * Copyright (C) 2014 ARM Ltd.
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
19 #include <linux/types.h>
21 #include <asm/cputype.h>
22 #include <asm/cpufeature.h>
24 static bool __maybe_unused
25 is_affected_midr_range(const struct arm64_cpu_capabilities *entry, int scope)
27 WARN_ON(scope != SCOPE_LOCAL_CPU || preemptible());
28 return MIDR_IS_CPU_MODEL_RANGE(read_cpuid_id(), entry->midr_model,
29 entry->midr_range_min,
30 entry->midr_range_max);
33 static bool __maybe_unused
34 is_kryo_midr(const struct arm64_cpu_capabilities *entry, int scope)
38 WARN_ON(scope != SCOPE_LOCAL_CPU || preemptible());
40 model = read_cpuid_id();
41 model &= MIDR_IMPLEMENTOR_MASK | (0xf00 << MIDR_PARTNUM_SHIFT) |
42 MIDR_ARCHITECTURE_MASK;
44 return model == entry->midr_model;
48 has_mismatched_cache_line_size(const struct arm64_cpu_capabilities *entry,
51 WARN_ON(scope != SCOPE_LOCAL_CPU || preemptible());
52 return (read_cpuid_cachetype() & arm64_ftr_reg_ctrel0.strict_mask) !=
53 (arm64_ftr_reg_ctrel0.sys_val & arm64_ftr_reg_ctrel0.strict_mask);
56 static int cpu_enable_trap_ctr_access(void *__unused)
58 /* Clear SCTLR_EL1.UCT */
59 config_sctlr_el1(SCTLR_EL1_UCT, 0);
63 #ifdef CONFIG_HARDEN_BRANCH_PREDICTOR
64 #include <asm/mmu_context.h>
65 #include <asm/cacheflush.h>
67 DEFINE_PER_CPU_READ_MOSTLY(struct bp_hardening_data, bp_hardening_data);
70 extern char __psci_hyp_bp_inval_start[], __psci_hyp_bp_inval_end[];
71 extern char __qcom_hyp_sanitize_link_stack_start[];
72 extern char __qcom_hyp_sanitize_link_stack_end[];
74 static void __copy_hyp_vect_bpi(int slot, const char *hyp_vecs_start,
75 const char *hyp_vecs_end)
77 void *dst = lm_alias(__bp_harden_hyp_vecs_start + slot * SZ_2K);
80 for (i = 0; i < SZ_2K; i += 0x80)
81 memcpy(dst + i, hyp_vecs_start, hyp_vecs_end - hyp_vecs_start);
83 flush_icache_range((uintptr_t)dst, (uintptr_t)dst + SZ_2K);
86 static void __install_bp_hardening_cb(bp_hardening_cb_t fn,
87 const char *hyp_vecs_start,
88 const char *hyp_vecs_end)
90 static int last_slot = -1;
91 static DEFINE_SPINLOCK(bp_lock);
95 for_each_possible_cpu(cpu) {
96 if (per_cpu(bp_hardening_data.fn, cpu) == fn) {
97 slot = per_cpu(bp_hardening_data.hyp_vectors_slot, cpu);
104 BUG_ON(((__bp_harden_hyp_vecs_end - __bp_harden_hyp_vecs_start)
105 / SZ_2K) <= last_slot);
107 __copy_hyp_vect_bpi(slot, hyp_vecs_start, hyp_vecs_end);
110 __this_cpu_write(bp_hardening_data.hyp_vectors_slot, slot);
111 __this_cpu_write(bp_hardening_data.fn, fn);
112 spin_unlock(&bp_lock);
115 #define __psci_hyp_bp_inval_start NULL
116 #define __psci_hyp_bp_inval_end NULL
117 #define __qcom_hyp_sanitize_link_stack_start NULL
118 #define __qcom_hyp_sanitize_link_stack_end NULL
120 static void __install_bp_hardening_cb(bp_hardening_cb_t fn,
121 const char *hyp_vecs_start,
122 const char *hyp_vecs_end)
124 __this_cpu_write(bp_hardening_data.fn, fn);
126 #endif /* CONFIG_KVM */
128 static void install_bp_hardening_cb(const struct arm64_cpu_capabilities *entry,
129 bp_hardening_cb_t fn,
130 const char *hyp_vecs_start,
131 const char *hyp_vecs_end)
135 if (!entry->matches(entry, SCOPE_LOCAL_CPU))
138 pfr0 = read_cpuid(ID_AA64PFR0_EL1);
139 if (cpuid_feature_extract_unsigned_field(pfr0, ID_AA64PFR0_CSV2_SHIFT))
142 __install_bp_hardening_cb(fn, hyp_vecs_start, hyp_vecs_end);
145 #include <linux/psci.h>
147 static int enable_psci_bp_hardening(void *data)
149 const struct arm64_cpu_capabilities *entry = data;
151 if (psci_ops.get_version)
152 install_bp_hardening_cb(entry,
153 (bp_hardening_cb_t)psci_ops.get_version,
154 __psci_hyp_bp_inval_start,
155 __psci_hyp_bp_inval_end);
160 static void qcom_link_stack_sanitization(void)
164 asm volatile("mov %0, x30 \n"
172 static int qcom_enable_link_stack_sanitization(void *data)
174 const struct arm64_cpu_capabilities *entry = data;
176 install_bp_hardening_cb(entry, qcom_link_stack_sanitization,
177 __qcom_hyp_sanitize_link_stack_start,
178 __qcom_hyp_sanitize_link_stack_end);
182 #endif /* CONFIG_HARDEN_BRANCH_PREDICTOR */
184 #define MIDR_RANGE(model, min, max) \
185 .def_scope = SCOPE_LOCAL_CPU, \
186 .matches = is_affected_midr_range, \
187 .midr_model = model, \
188 .midr_range_min = min, \
189 .midr_range_max = max
191 #define MIDR_ALL_VERSIONS(model) \
192 .def_scope = SCOPE_LOCAL_CPU, \
193 .matches = is_affected_midr_range, \
194 .midr_model = model, \
195 .midr_range_min = 0, \
196 .midr_range_max = (MIDR_VARIANT_MASK | MIDR_REVISION_MASK)
198 const struct arm64_cpu_capabilities arm64_errata[] = {
199 #if defined(CONFIG_ARM64_ERRATUM_826319) || \
200 defined(CONFIG_ARM64_ERRATUM_827319) || \
201 defined(CONFIG_ARM64_ERRATUM_824069)
203 /* Cortex-A53 r0p[012] */
204 .desc = "ARM errata 826319, 827319, 824069",
205 .capability = ARM64_WORKAROUND_CLEAN_CACHE,
206 MIDR_RANGE(MIDR_CORTEX_A53, 0x00, 0x02),
207 .enable = cpu_enable_cache_maint_trap,
210 #ifdef CONFIG_ARM64_ERRATUM_819472
212 /* Cortex-A53 r0p[01] */
213 .desc = "ARM errata 819472",
214 .capability = ARM64_WORKAROUND_CLEAN_CACHE,
215 MIDR_RANGE(MIDR_CORTEX_A53, 0x00, 0x01),
216 .enable = cpu_enable_cache_maint_trap,
219 #ifdef CONFIG_ARM64_ERRATUM_832075
221 /* Cortex-A57 r0p0 - r1p2 */
222 .desc = "ARM erratum 832075",
223 .capability = ARM64_WORKAROUND_DEVICE_LOAD_ACQUIRE,
224 MIDR_RANGE(MIDR_CORTEX_A57,
225 MIDR_CPU_VAR_REV(0, 0),
226 MIDR_CPU_VAR_REV(1, 2)),
229 #ifdef CONFIG_ARM64_ERRATUM_834220
231 /* Cortex-A57 r0p0 - r1p2 */
232 .desc = "ARM erratum 834220",
233 .capability = ARM64_WORKAROUND_834220,
234 MIDR_RANGE(MIDR_CORTEX_A57,
235 MIDR_CPU_VAR_REV(0, 0),
236 MIDR_CPU_VAR_REV(1, 2)),
239 #ifdef CONFIG_ARM64_ERRATUM_845719
241 /* Cortex-A53 r0p[01234] */
242 .desc = "ARM erratum 845719",
243 .capability = ARM64_WORKAROUND_845719,
244 MIDR_RANGE(MIDR_CORTEX_A53, 0x00, 0x04),
247 #ifdef CONFIG_CAVIUM_ERRATUM_23154
249 /* Cavium ThunderX, pass 1.x */
250 .desc = "Cavium erratum 23154",
251 .capability = ARM64_WORKAROUND_CAVIUM_23154,
252 MIDR_RANGE(MIDR_THUNDERX, 0x00, 0x01),
255 #ifdef CONFIG_CAVIUM_ERRATUM_27456
257 /* Cavium ThunderX, T88 pass 1.x - 2.1 */
258 .desc = "Cavium erratum 27456",
259 .capability = ARM64_WORKAROUND_CAVIUM_27456,
260 MIDR_RANGE(MIDR_THUNDERX,
261 MIDR_CPU_VAR_REV(0, 0),
262 MIDR_CPU_VAR_REV(1, 1)),
265 /* Cavium ThunderX, T81 pass 1.0 */
266 .desc = "Cavium erratum 27456",
267 .capability = ARM64_WORKAROUND_CAVIUM_27456,
268 MIDR_RANGE(MIDR_THUNDERX_81XX, 0x00, 0x00),
271 #ifdef CONFIG_CAVIUM_ERRATUM_30115
273 /* Cavium ThunderX, T88 pass 1.x - 2.2 */
274 .desc = "Cavium erratum 30115",
275 .capability = ARM64_WORKAROUND_CAVIUM_30115,
276 MIDR_RANGE(MIDR_THUNDERX, 0x00,
277 (1 << MIDR_VARIANT_SHIFT) | 2),
280 /* Cavium ThunderX, T81 pass 1.0 - 1.2 */
281 .desc = "Cavium erratum 30115",
282 .capability = ARM64_WORKAROUND_CAVIUM_30115,
283 MIDR_RANGE(MIDR_THUNDERX_81XX, 0x00, 0x02),
286 /* Cavium ThunderX, T83 pass 1.0 */
287 .desc = "Cavium erratum 30115",
288 .capability = ARM64_WORKAROUND_CAVIUM_30115,
289 MIDR_RANGE(MIDR_THUNDERX_83XX, 0x00, 0x00),
293 .desc = "Mismatched cache line size",
294 .capability = ARM64_MISMATCHED_CACHE_LINE_SIZE,
295 .matches = has_mismatched_cache_line_size,
296 .def_scope = SCOPE_LOCAL_CPU,
297 .enable = cpu_enable_trap_ctr_access,
299 #ifdef CONFIG_QCOM_FALKOR_ERRATUM_1003
301 .desc = "Qualcomm Technologies Falkor erratum 1003",
302 .capability = ARM64_WORKAROUND_QCOM_FALKOR_E1003,
303 MIDR_RANGE(MIDR_QCOM_FALKOR_V1,
304 MIDR_CPU_VAR_REV(0, 0),
305 MIDR_CPU_VAR_REV(0, 0)),
308 .desc = "Qualcomm Technologies Kryo erratum 1003",
309 .capability = ARM64_WORKAROUND_QCOM_FALKOR_E1003,
310 .def_scope = SCOPE_LOCAL_CPU,
311 .midr_model = MIDR_QCOM_KRYO,
312 .matches = is_kryo_midr,
315 #ifdef CONFIG_QCOM_FALKOR_ERRATUM_1009
317 .desc = "Qualcomm Technologies Falkor erratum 1009",
318 .capability = ARM64_WORKAROUND_REPEAT_TLBI,
319 MIDR_RANGE(MIDR_QCOM_FALKOR_V1,
320 MIDR_CPU_VAR_REV(0, 0),
321 MIDR_CPU_VAR_REV(0, 0)),
324 #ifdef CONFIG_ARM64_ERRATUM_858921
326 /* Cortex-A73 all versions */
327 .desc = "ARM erratum 858921",
328 .capability = ARM64_WORKAROUND_858921,
329 MIDR_ALL_VERSIONS(MIDR_CORTEX_A73),
332 #ifdef CONFIG_HARDEN_BRANCH_PREDICTOR
334 .capability = ARM64_HARDEN_BRANCH_PREDICTOR,
335 MIDR_ALL_VERSIONS(MIDR_CORTEX_A57),
336 .enable = enable_psci_bp_hardening,
339 .capability = ARM64_HARDEN_BRANCH_PREDICTOR,
340 MIDR_ALL_VERSIONS(MIDR_CORTEX_A72),
341 .enable = enable_psci_bp_hardening,
344 .capability = ARM64_HARDEN_BRANCH_PREDICTOR,
345 MIDR_ALL_VERSIONS(MIDR_CORTEX_A73),
346 .enable = enable_psci_bp_hardening,
349 .capability = ARM64_HARDEN_BRANCH_PREDICTOR,
350 MIDR_ALL_VERSIONS(MIDR_CORTEX_A75),
351 .enable = enable_psci_bp_hardening,
354 .capability = ARM64_HARDEN_BRANCH_PREDICTOR,
355 MIDR_ALL_VERSIONS(MIDR_QCOM_FALKOR_V1),
356 .enable = qcom_enable_link_stack_sanitization,
359 .capability = ARM64_HARDEN_BP_POST_GUEST_EXIT,
360 MIDR_ALL_VERSIONS(MIDR_QCOM_FALKOR_V1),
363 .capability = ARM64_HARDEN_BRANCH_PREDICTOR,
364 MIDR_ALL_VERSIONS(MIDR_BRCM_VULCAN),
365 .enable = enable_psci_bp_hardening,
368 .capability = ARM64_HARDEN_BRANCH_PREDICTOR,
369 MIDR_ALL_VERSIONS(MIDR_CAVIUM_THUNDERX2),
370 .enable = enable_psci_bp_hardening,
378 * The CPU Errata work arounds are detected and applied at boot time
379 * and the related information is freed soon after. If the new CPU requires
380 * an errata not detected at boot, fail this CPU.
382 void verify_local_cpu_errata_workarounds(void)
384 const struct arm64_cpu_capabilities *caps = arm64_errata;
386 for (; caps->matches; caps++) {
387 if (cpus_have_cap(caps->capability)) {
389 caps->enable((void *)caps);
390 } else if (caps->matches(caps, SCOPE_LOCAL_CPU)) {
391 pr_crit("CPU%d: Requires work around for %s, not detected"
394 caps->desc ? : "an erratum");
400 void update_cpu_errata_workarounds(void)
402 update_cpu_capabilities(arm64_errata, "enabling workaround for");
405 void __init enable_errata_workarounds(void)
407 enable_cpu_capabilities(arm64_errata);