1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * UEFI Common Platform Error Record (CPER) support
4 *
5 * Copyright (C) 2017, The Linux Foundation. All rights reserved.
6 */
7
8 #include <linux/kernel.h>
9 #include <linux/module.h>
10 #include <linux/time.h>
11 #include <linux/cper.h>
12 #include <linux/dmi.h>
13 #include <linux/acpi.h>
14 #include <linux/pci.h>
15 #include <linux/printk.h>
16 #include <linux/bcd.h>
17 #include <acpi/ghes.h>
18 #include <ras/ras_event.h>
19
20 static const char * const arm_reg_ctx_strs[] = {
21 "AArch32 general purpose registers",
22 "AArch32 EL1 context registers",
23 "AArch32 EL2 context registers",
24 "AArch32 secure context registers",
25 "AArch64 general purpose registers",
26 "AArch64 EL1 context registers",
27 "AArch64 EL2 context registers",
28 "AArch64 EL3 context registers",
29 "Misc. system register structure",
30 };
31
32 static const char * const arm_err_trans_type_strs[] = {
33 "Instruction",
34 "Data Access",
35 "Generic",
36 };
37
38 static const char * const arm_bus_err_op_strs[] = {
39 "Generic error (type cannot be determined)",
40 "Generic read (type of instruction or data request cannot be determined)",
41 "Generic write (type of instruction of data request cannot be determined)",
42 "Data read",
43 "Data write",
44 "Instruction fetch",
45 "Prefetch",
46 };
47
48 static const char * const arm_cache_err_op_strs[] = {
49 "Generic error (type cannot be determined)",
50 "Generic read (type of instruction or data request cannot be determined)",
51 "Generic write (type of instruction of data request cannot be determined)",
52 "Data read",
53 "Data write",
54 "Instruction fetch",
55 "Prefetch",
56 "Eviction",
57 "Snooping (processor initiated a cache snoop that resulted in an error)",
58 "Snooped (processor raised a cache error caused by another processor or device snooping its cache)",
59 "Management",
60 };
61
62 static const char * const arm_tlb_err_op_strs[] = {
63 "Generic error (type cannot be determined)",
64 "Generic read (type of instruction or data request cannot be determined)",
65 "Generic write (type of instruction of data request cannot be determined)",
66 "Data read",
67 "Data write",
68 "Instruction fetch",
69 "Prefetch",
70 "Local management operation (processor initiated a TLB management operation that resulted in an error)",
71 "External management operation (processor raised a TLB error caused by another processor or device broadcasting TLB operations)",
72 };
73
74 static const char * const arm_bus_err_part_type_strs[] = {
75 "Local processor originated request",
76 "Local processor responded to request",
77 "Local processor observed",
78 "Generic",
79 };
80
81 static const char * const arm_bus_err_addr_space_strs[] = {
82 "External Memory Access",
83 "Internal Memory Access",
84 "Unknown",
85 "Device Memory Access",
86 };
87
cper_print_arm_err_info(const char * pfx,u32 type,u64 error_info)88 static void cper_print_arm_err_info(const char *pfx, u32 type,
89 u64 error_info)
90 {
91 u8 trans_type, op_type, level, participation_type, address_space;
92 u16 mem_attributes;
93 bool proc_context_corrupt, corrected, precise_pc, restartable_pc;
94 bool time_out, access_mode;
95
96 /* If the type is unknown, bail. */
97 if (type > CPER_ARM_MAX_TYPE)
98 return;
99
100 /*
101 * Vendor type errors have error information values that are vendor
102 * specific.
103 */
104 if (type == CPER_ARM_VENDOR_ERROR)
105 return;
106
107 if (error_info & CPER_ARM_ERR_VALID_TRANSACTION_TYPE) {
108 trans_type = ((error_info >> CPER_ARM_ERR_TRANSACTION_SHIFT)
109 & CPER_ARM_ERR_TRANSACTION_MASK);
110 if (trans_type < ARRAY_SIZE(arm_err_trans_type_strs)) {
111 printk("%stransaction type: %s\n", pfx,
112 arm_err_trans_type_strs[trans_type]);
113 }
114 }
115
116 if (error_info & CPER_ARM_ERR_VALID_OPERATION_TYPE) {
117 op_type = ((error_info >> CPER_ARM_ERR_OPERATION_SHIFT)
118 & CPER_ARM_ERR_OPERATION_MASK);
119 switch (type) {
120 case CPER_ARM_CACHE_ERROR:
121 if (op_type < ARRAY_SIZE(arm_cache_err_op_strs)) {
122 printk("%soperation type: %s\n", pfx,
123 arm_cache_err_op_strs[op_type]);
124 }
125 break;
126 case CPER_ARM_TLB_ERROR:
127 if (op_type < ARRAY_SIZE(arm_tlb_err_op_strs)) {
128 printk("%soperation type: %s\n", pfx,
129 arm_tlb_err_op_strs[op_type]);
130 }
131 break;
132 case CPER_ARM_BUS_ERROR:
133 if (op_type < ARRAY_SIZE(arm_bus_err_op_strs)) {
134 printk("%soperation type: %s\n", pfx,
135 arm_bus_err_op_strs[op_type]);
136 }
137 break;
138 }
139 }
140
141 if (error_info & CPER_ARM_ERR_VALID_LEVEL) {
142 level = ((error_info >> CPER_ARM_ERR_LEVEL_SHIFT)
143 & CPER_ARM_ERR_LEVEL_MASK);
144 switch (type) {
145 case CPER_ARM_CACHE_ERROR:
146 printk("%scache level: %d\n", pfx, level);
147 break;
148 case CPER_ARM_TLB_ERROR:
149 printk("%sTLB level: %d\n", pfx, level);
150 break;
151 case CPER_ARM_BUS_ERROR:
152 printk("%saffinity level at which the bus error occurred: %d\n",
153 pfx, level);
154 break;
155 }
156 }
157
158 if (error_info & CPER_ARM_ERR_VALID_PROC_CONTEXT_CORRUPT) {
159 proc_context_corrupt = ((error_info >> CPER_ARM_ERR_PC_CORRUPT_SHIFT)
160 & CPER_ARM_ERR_PC_CORRUPT_MASK);
161 if (proc_context_corrupt)
162 printk("%sprocessor context corrupted\n", pfx);
163 else
164 printk("%sprocessor context not corrupted\n", pfx);
165 }
166
167 if (error_info & CPER_ARM_ERR_VALID_CORRECTED) {
168 corrected = ((error_info >> CPER_ARM_ERR_CORRECTED_SHIFT)
169 & CPER_ARM_ERR_CORRECTED_MASK);
170 if (corrected)
171 printk("%sthe error has been corrected\n", pfx);
172 else
173 printk("%sthe error has not been corrected\n", pfx);
174 }
175
176 if (error_info & CPER_ARM_ERR_VALID_PRECISE_PC) {
177 precise_pc = ((error_info >> CPER_ARM_ERR_PRECISE_PC_SHIFT)
178 & CPER_ARM_ERR_PRECISE_PC_MASK);
179 if (precise_pc)
180 printk("%sPC is precise\n", pfx);
181 else
182 printk("%sPC is imprecise\n", pfx);
183 }
184
185 if (error_info & CPER_ARM_ERR_VALID_RESTARTABLE_PC) {
186 restartable_pc = ((error_info >> CPER_ARM_ERR_RESTARTABLE_PC_SHIFT)
187 & CPER_ARM_ERR_RESTARTABLE_PC_MASK);
188 if (restartable_pc)
189 printk("%sProgram execution can be restarted reliably at the PC associated with the error.\n", pfx);
190 }
191
192 /* The rest of the fields are specific to bus errors */
193 if (type != CPER_ARM_BUS_ERROR)
194 return;
195
196 if (error_info & CPER_ARM_ERR_VALID_PARTICIPATION_TYPE) {
197 participation_type = ((error_info >> CPER_ARM_ERR_PARTICIPATION_TYPE_SHIFT)
198 & CPER_ARM_ERR_PARTICIPATION_TYPE_MASK);
199 if (participation_type < ARRAY_SIZE(arm_bus_err_part_type_strs)) {
200 printk("%sparticipation type: %s\n", pfx,
201 arm_bus_err_part_type_strs[participation_type]);
202 }
203 }
204
205 if (error_info & CPER_ARM_ERR_VALID_TIME_OUT) {
206 time_out = ((error_info >> CPER_ARM_ERR_TIME_OUT_SHIFT)
207 & CPER_ARM_ERR_TIME_OUT_MASK);
208 if (time_out)
209 printk("%srequest timed out\n", pfx);
210 }
211
212 if (error_info & CPER_ARM_ERR_VALID_ADDRESS_SPACE) {
213 address_space = ((error_info >> CPER_ARM_ERR_ADDRESS_SPACE_SHIFT)
214 & CPER_ARM_ERR_ADDRESS_SPACE_MASK);
215 if (address_space < ARRAY_SIZE(arm_bus_err_addr_space_strs)) {
216 printk("%saddress space: %s\n", pfx,
217 arm_bus_err_addr_space_strs[address_space]);
218 }
219 }
220
221 if (error_info & CPER_ARM_ERR_VALID_MEM_ATTRIBUTES) {
222 mem_attributes = ((error_info >> CPER_ARM_ERR_MEM_ATTRIBUTES_SHIFT)
223 & CPER_ARM_ERR_MEM_ATTRIBUTES_MASK);
224 printk("%smemory access attributes:0x%x\n", pfx, mem_attributes);
225 }
226
227 if (error_info & CPER_ARM_ERR_VALID_ACCESS_MODE) {
228 access_mode = ((error_info >> CPER_ARM_ERR_ACCESS_MODE_SHIFT)
229 & CPER_ARM_ERR_ACCESS_MODE_MASK);
230 if (access_mode)
231 printk("%saccess mode: normal\n", pfx);
232 else
233 printk("%saccess mode: secure\n", pfx);
234 }
235 }
236
cper_print_proc_arm(const char * pfx,const struct cper_sec_proc_arm * proc)237 void cper_print_proc_arm(const char *pfx,
238 const struct cper_sec_proc_arm *proc)
239 {
240 int i, len, max_ctx_type;
241 struct cper_arm_err_info *err_info;
242 struct cper_arm_ctx_info *ctx_info;
243 char newpfx[64], infopfx[64];
244
245 printk("%sMIDR: 0x%016llx\n", pfx, proc->midr);
246
247 len = proc->section_length - (sizeof(*proc) +
248 proc->err_info_num * (sizeof(*err_info)));
249 if (len < 0) {
250 printk("%ssection length: %d\n", pfx, proc->section_length);
251 printk("%ssection length is too small\n", pfx);
252 printk("%sfirmware-generated error record is incorrect\n", pfx);
253 printk("%sERR_INFO_NUM is %d\n", pfx, proc->err_info_num);
254 return;
255 }
256
257 if (proc->validation_bits & CPER_ARM_VALID_MPIDR)
258 printk("%sMultiprocessor Affinity Register (MPIDR): 0x%016llx\n",
259 pfx, proc->mpidr);
260
261 if (proc->validation_bits & CPER_ARM_VALID_AFFINITY_LEVEL)
262 printk("%serror affinity level: %d\n", pfx,
263 proc->affinity_level);
264
265 if (proc->validation_bits & CPER_ARM_VALID_RUNNING_STATE) {
266 printk("%srunning state: 0x%x\n", pfx, proc->running_state);
267 printk("%sPower State Coordination Interface state: %d\n",
268 pfx, proc->psci_state);
269 }
270
271 snprintf(newpfx, sizeof(newpfx), "%s ", pfx);
272
273 err_info = (struct cper_arm_err_info *)(proc + 1);
274 for (i = 0; i < proc->err_info_num; i++) {
275 printk("%sError info structure %d:\n", pfx, i);
276
277 printk("%snum errors: %d\n", pfx, err_info->multiple_error + 1);
278
279 if (err_info->validation_bits & CPER_ARM_INFO_VALID_FLAGS) {
280 if (err_info->flags & CPER_ARM_INFO_FLAGS_FIRST)
281 printk("%sfirst error captured\n", newpfx);
282 if (err_info->flags & CPER_ARM_INFO_FLAGS_LAST)
283 printk("%slast error captured\n", newpfx);
284 if (err_info->flags & CPER_ARM_INFO_FLAGS_PROPAGATED)
285 printk("%spropagated error captured\n",
286 newpfx);
287 if (err_info->flags & CPER_ARM_INFO_FLAGS_OVERFLOW)
288 printk("%soverflow occurred, error info is incomplete\n",
289 newpfx);
290 }
291
292 printk("%serror_type: %d, %s\n", newpfx, err_info->type,
293 err_info->type < ARRAY_SIZE(cper_proc_error_type_strs) ?
294 cper_proc_error_type_strs[err_info->type] : "unknown");
295 if (err_info->validation_bits & CPER_ARM_INFO_VALID_ERR_INFO) {
296 printk("%serror_info: 0x%016llx\n", newpfx,
297 err_info->error_info);
298 snprintf(infopfx, sizeof(infopfx), "%s ", newpfx);
299 cper_print_arm_err_info(infopfx, err_info->type,
300 err_info->error_info);
301 }
302 if (err_info->validation_bits & CPER_ARM_INFO_VALID_VIRT_ADDR)
303 printk("%svirtual fault address: 0x%016llx\n",
304 newpfx, err_info->virt_fault_addr);
305 if (err_info->validation_bits & CPER_ARM_INFO_VALID_PHYSICAL_ADDR)
306 printk("%sphysical fault address: 0x%016llx\n",
307 newpfx, err_info->physical_fault_addr);
308 err_info += 1;
309 }
310
311 ctx_info = (struct cper_arm_ctx_info *)err_info;
312 max_ctx_type = ARRAY_SIZE(arm_reg_ctx_strs) - 1;
313 for (i = 0; i < proc->context_info_num; i++) {
314 int size = sizeof(*ctx_info) + ctx_info->size;
315
316 printk("%sContext info structure %d:\n", pfx, i);
317 if (len < size) {
318 printk("%ssection length is too small\n", newpfx);
319 printk("%sfirmware-generated error record is incorrect\n", pfx);
320 return;
321 }
322 if (ctx_info->type > max_ctx_type) {
323 printk("%sInvalid context type: %d (max: %d)\n",
324 newpfx, ctx_info->type, max_ctx_type);
325 return;
326 }
327 printk("%sregister context type: %s\n", newpfx,
328 arm_reg_ctx_strs[ctx_info->type]);
329 print_hex_dump(newpfx, "", DUMP_PREFIX_OFFSET, 16, 4,
330 (ctx_info + 1), ctx_info->size, 0);
331 len -= size;
332 ctx_info = (struct cper_arm_ctx_info *)((long)ctx_info + size);
333 }
334
335 if (len > 0) {
336 printk("%sVendor specific error info has %u bytes:\n", pfx,
337 len);
338 print_hex_dump(newpfx, "", DUMP_PREFIX_OFFSET, 16, 4, ctx_info,
339 len, true);
340 }
341 }
342