xref: /openbmc/linux/drivers/edac/mce_amd.c (revision feac8c8b) 
1 #include <linux/module.h>
2 #include <linux/slab.h>
3 
4 #include <asm/cpu.h>
5 
6 #include "mce_amd.h"
7 
8 static struct amd_decoder_ops *fam_ops;
9 
10 static u8 xec_mask	 = 0xf;
11 
12 static bool report_gart_errors;
13 static void (*decode_dram_ecc)(int node_id, struct mce *m);
14 
15 void amd_report_gart_errors(bool v)
16 {
17 	report_gart_errors = v;
18 }
19 EXPORT_SYMBOL_GPL(amd_report_gart_errors);
20 
21 void amd_register_ecc_decoder(void (*f)(int, struct mce *))
22 {
23 	decode_dram_ecc = f;
24 }
25 EXPORT_SYMBOL_GPL(amd_register_ecc_decoder);
26 
27 void amd_unregister_ecc_decoder(void (*f)(int, struct mce *))
28 {
29 	if (decode_dram_ecc) {
30 		WARN_ON(decode_dram_ecc != f);
31 
32 		decode_dram_ecc = NULL;
33 	}
34 }
35 EXPORT_SYMBOL_GPL(amd_unregister_ecc_decoder);
36 
37 /*
38  * string representation for the different MCA reported error types, see F3x48
39  * or MSR0000_0411.
40  */
41 
42 /* transaction type */
43 static const char * const tt_msgs[] = { "INSN", "DATA", "GEN", "RESV" };
44 
45 /* cache level */
46 static const char * const ll_msgs[] = { "RESV", "L1", "L2", "L3/GEN" };
47 
48 /* memory transaction type */
49 static const char * const rrrr_msgs[] = {
50        "GEN", "RD", "WR", "DRD", "DWR", "IRD", "PRF", "EV", "SNP"
51 };
52 
53 /* participating processor */
54 const char * const pp_msgs[] = { "SRC", "RES", "OBS", "GEN" };
55 EXPORT_SYMBOL_GPL(pp_msgs);
56 
57 /* request timeout */
58 static const char * const to_msgs[] = { "no timeout", "timed out" };
59 
60 /* memory or i/o */
61 static const char * const ii_msgs[] = { "MEM", "RESV", "IO", "GEN" };
62 
63 /* internal error type */
64 static const char * const uu_msgs[] = { "RESV", "RESV", "HWA", "RESV" };
65 
66 static const char * const f15h_mc1_mce_desc[] = {
67 	"UC during a demand linefill from L2",
68 	"Parity error during data load from IC",
69 	"Parity error for IC valid bit",
70 	"Main tag parity error",
71 	"Parity error in prediction queue",
72 	"PFB data/address parity error",
73 	"Parity error in the branch status reg",
74 	"PFB promotion address error",
75 	"Tag error during probe/victimization",
76 	"Parity error for IC probe tag valid bit",
77 	"PFB non-cacheable bit parity error",
78 	"PFB valid bit parity error",			/* xec = 0xd */
79 	"Microcode Patch Buffer",			/* xec = 010 */
80 	"uop queue",
81 	"insn buffer",
82 	"predecode buffer",
83 	"fetch address FIFO",
84 	"dispatch uop queue"
85 };
86 
87 static const char * const f15h_mc2_mce_desc[] = {
88 	"Fill ECC error on data fills",			/* xec = 0x4 */
89 	"Fill parity error on insn fills",
90 	"Prefetcher request FIFO parity error",
91 	"PRQ address parity error",
92 	"PRQ data parity error",
93 	"WCC Tag ECC error",
94 	"WCC Data ECC error",
95 	"WCB Data parity error",
96 	"VB Data ECC or parity error",
97 	"L2 Tag ECC error",				/* xec = 0x10 */
98 	"Hard L2 Tag ECC error",
99 	"Multiple hits on L2 tag",
100 	"XAB parity error",
101 	"PRB address parity error"
102 };
103 
104 static const char * const mc4_mce_desc[] = {
105 	"DRAM ECC error detected on the NB",
106 	"CRC error detected on HT link",
107 	"Link-defined sync error packets detected on HT link",
108 	"HT Master abort",
109 	"HT Target abort",
110 	"Invalid GART PTE entry during GART table walk",
111 	"Unsupported atomic RMW received from an IO link",
112 	"Watchdog timeout due to lack of progress",
113 	"DRAM ECC error detected on the NB",
114 	"SVM DMA Exclusion Vector error",
115 	"HT data error detected on link",
116 	"Protocol error (link, L3, probe filter)",
117 	"NB internal arrays parity error",
118 	"DRAM addr/ctl signals parity error",
119 	"IO link transmission error",
120 	"L3 data cache ECC error",			/* xec = 0x1c */
121 	"L3 cache tag error",
122 	"L3 LRU parity bits error",
123 	"ECC Error in the Probe Filter directory"
124 };
125 
126 static const char * const mc5_mce_desc[] = {
127 	"CPU Watchdog timer expire",
128 	"Wakeup array dest tag",
129 	"AG payload array",
130 	"EX payload array",
131 	"IDRF array",
132 	"Retire dispatch queue",
133 	"Mapper checkpoint array",
134 	"Physical register file EX0 port",
135 	"Physical register file EX1 port",
136 	"Physical register file AG0 port",
137 	"Physical register file AG1 port",
138 	"Flag register file",
139 	"DE error occurred",
140 	"Retire status queue"
141 };
142 
143 static const char * const mc6_mce_desc[] = {
144 	"Hardware Assertion",
145 	"Free List",
146 	"Physical Register File",
147 	"Retire Queue",
148 	"Scheduler table",
149 	"Status Register File",
150 };
151 
152 /* Scalable MCA error strings */
153 static const char * const smca_ls_mce_desc[] = {
154 	"Load queue parity",
155 	"Store queue parity",
156 	"Miss address buffer payload parity",
157 	"L1 TLB parity",
158 	"Reserved",
159 	"DC tag error type 6",
160 	"DC tag error type 1",
161 	"Internal error type 1",
162 	"Internal error type 2",
163 	"Sys Read data error thread 0",
164 	"Sys read data error thread 1",
165 	"DC tag error type 2",
166 	"DC data error type 1 (poison consumption)",
167 	"DC data error type 2",
168 	"DC data error type 3",
169 	"DC tag error type 4",
170 	"L2 TLB parity",
171 	"PDC parity error",
172 	"DC tag error type 3",
173 	"DC tag error type 5",
174 	"L2 fill data error",
175 };
176 
177 static const char * const smca_if_mce_desc[] = {
178 	"microtag probe port parity error",
179 	"IC microtag or full tag multi-hit error",
180 	"IC full tag parity",
181 	"IC data array parity",
182 	"Decoupling queue phys addr parity error",
183 	"L0 ITLB parity error",
184 	"L1 ITLB parity error",
185 	"L2 ITLB parity error",
186 	"BPQ snoop parity on Thread 0",
187 	"BPQ snoop parity on Thread 1",
188 	"L1 BTB multi-match error",
189 	"L2 BTB multi-match error",
190 	"L2 Cache Response Poison error",
191 	"System Read Data error",
192 };
193 
194 static const char * const smca_l2_mce_desc[] = {
195 	"L2M tag multi-way-hit error",
196 	"L2M tag ECC error",
197 	"L2M data ECC error",
198 	"HW assert",
199 };
200 
201 static const char * const smca_de_mce_desc[] = {
202 	"uop cache tag parity error",
203 	"uop cache data parity error",
204 	"Insn buffer parity error",
205 	"uop queue parity error",
206 	"Insn dispatch queue parity error",
207 	"Fetch address FIFO parity",
208 	"Patch RAM data parity",
209 	"Patch RAM sequencer parity",
210 	"uop buffer parity"
211 };
212 
213 static const char * const smca_ex_mce_desc[] = {
214 	"Watchdog timeout error",
215 	"Phy register file parity",
216 	"Flag register file parity",
217 	"Immediate displacement register file parity",
218 	"Address generator payload parity",
219 	"EX payload parity",
220 	"Checkpoint queue parity",
221 	"Retire dispatch queue parity",
222 	"Retire status queue parity error",
223 	"Scheduling queue parity error",
224 	"Branch buffer queue parity error",
225 };
226 
227 static const char * const smca_fp_mce_desc[] = {
228 	"Physical register file parity",
229 	"Freelist parity error",
230 	"Schedule queue parity",
231 	"NSQ parity error",
232 	"Retire queue parity",
233 	"Status register file parity",
234 	"Hardware assertion",
235 };
236 
237 static const char * const smca_l3_mce_desc[] = {
238 	"Shadow tag macro ECC error",
239 	"Shadow tag macro multi-way-hit error",
240 	"L3M tag ECC error",
241 	"L3M tag multi-way-hit error",
242 	"L3M data ECC error",
243 	"XI parity, L3 fill done channel error",
244 	"L3 victim queue parity",
245 	"L3 HW assert",
246 };
247 
248 static const char * const smca_cs_mce_desc[] = {
249 	"Illegal request from transport layer",
250 	"Address violation",
251 	"Security violation",
252 	"Illegal response from transport layer",
253 	"Unexpected response",
254 	"Parity error on incoming request or probe response data",
255 	"Parity error on incoming read response data",
256 	"Atomic request parity",
257 	"ECC error on probe filter access",
258 };
259 
260 static const char * const smca_pie_mce_desc[] = {
261 	"HW assert",
262 	"Internal PIE register security violation",
263 	"Error on GMI link",
264 	"Poison data written to internal PIE register",
265 };
266 
267 static const char * const smca_umc_mce_desc[] = {
268 	"DRAM ECC error",
269 	"Data poison error on DRAM",
270 	"SDP parity error",
271 	"Advanced peripheral bus error",
272 	"Command/address parity error",
273 	"Write data CRC error",
274 };
275 
276 static const char * const smca_pb_mce_desc[] = {
277 	"Parameter Block RAM ECC error",
278 };
279 
280 static const char * const smca_psp_mce_desc[] = {
281 	"PSP RAM ECC or parity error",
282 };
283 
284 static const char * const smca_smu_mce_desc[] = {
285 	"SMU RAM ECC or parity error",
286 };
287 
288 struct smca_mce_desc {
289 	const char * const *descs;
290 	unsigned int num_descs;
291 };
292 
293 static struct smca_mce_desc smca_mce_descs[] = {
294 	[SMCA_LS]	= { smca_ls_mce_desc,	ARRAY_SIZE(smca_ls_mce_desc)	},
295 	[SMCA_IF]	= { smca_if_mce_desc,	ARRAY_SIZE(smca_if_mce_desc)	},
296 	[SMCA_L2_CACHE]	= { smca_l2_mce_desc,	ARRAY_SIZE(smca_l2_mce_desc)	},
297 	[SMCA_DE]	= { smca_de_mce_desc,	ARRAY_SIZE(smca_de_mce_desc)	},
298 	[SMCA_EX]	= { smca_ex_mce_desc,	ARRAY_SIZE(smca_ex_mce_desc)	},
299 	[SMCA_FP]	= { smca_fp_mce_desc,	ARRAY_SIZE(smca_fp_mce_desc)	},
300 	[SMCA_L3_CACHE]	= { smca_l3_mce_desc,	ARRAY_SIZE(smca_l3_mce_desc)	},
301 	[SMCA_CS]	= { smca_cs_mce_desc,	ARRAY_SIZE(smca_cs_mce_desc)	},
302 	[SMCA_PIE]	= { smca_pie_mce_desc,	ARRAY_SIZE(smca_pie_mce_desc)	},
303 	[SMCA_UMC]	= { smca_umc_mce_desc,	ARRAY_SIZE(smca_umc_mce_desc)	},
304 	[SMCA_PB]	= { smca_pb_mce_desc,	ARRAY_SIZE(smca_pb_mce_desc)	},
305 	[SMCA_PSP]	= { smca_psp_mce_desc,	ARRAY_SIZE(smca_psp_mce_desc)	},
306 	[SMCA_SMU]	= { smca_smu_mce_desc,	ARRAY_SIZE(smca_smu_mce_desc)	},
307 };
308 
309 static bool f12h_mc0_mce(u16 ec, u8 xec)
310 {
311 	bool ret = false;
312 
313 	if (MEM_ERROR(ec)) {
314 		u8 ll = LL(ec);
315 		ret = true;
316 
317 		if (ll == LL_L2)
318 			pr_cont("during L1 linefill from L2.\n");
319 		else if (ll == LL_L1)
320 			pr_cont("Data/Tag %s error.\n", R4_MSG(ec));
321 		else
322 			ret = false;
323 	}
324 	return ret;
325 }
326 
327 static bool f10h_mc0_mce(u16 ec, u8 xec)
328 {
329 	if (R4(ec) == R4_GEN && LL(ec) == LL_L1) {
330 		pr_cont("during data scrub.\n");
331 		return true;
332 	}
333 	return f12h_mc0_mce(ec, xec);
334 }
335 
336 static bool k8_mc0_mce(u16 ec, u8 xec)
337 {
338 	if (BUS_ERROR(ec)) {
339 		pr_cont("during system linefill.\n");
340 		return true;
341 	}
342 
343 	return f10h_mc0_mce(ec, xec);
344 }
345 
346 static bool cat_mc0_mce(u16 ec, u8 xec)
347 {
348 	u8 r4	 = R4(ec);
349 	bool ret = true;
350 
351 	if (MEM_ERROR(ec)) {
352 
353 		if (TT(ec) != TT_DATA || LL(ec) != LL_L1)
354 			return false;
355 
356 		switch (r4) {
357 		case R4_DRD:
358 		case R4_DWR:
359 			pr_cont("Data/Tag parity error due to %s.\n",
360 				(r4 == R4_DRD ? "load/hw prf" : "store"));
361 			break;
362 		case R4_EVICT:
363 			pr_cont("Copyback parity error on a tag miss.\n");
364 			break;
365 		case R4_SNOOP:
366 			pr_cont("Tag parity error during snoop.\n");
367 			break;
368 		default:
369 			ret = false;
370 		}
371 	} else if (BUS_ERROR(ec)) {
372 
373 		if ((II(ec) != II_MEM && II(ec) != II_IO) || LL(ec) != LL_LG)
374 			return false;
375 
376 		pr_cont("System read data error on a ");
377 
378 		switch (r4) {
379 		case R4_RD:
380 			pr_cont("TLB reload.\n");
381 			break;
382 		case R4_DWR:
383 			pr_cont("store.\n");
384 			break;
385 		case R4_DRD:
386 			pr_cont("load.\n");
387 			break;
388 		default:
389 			ret = false;
390 		}
391 	} else {
392 		ret = false;
393 	}
394 
395 	return ret;
396 }
397 
398 static bool f15h_mc0_mce(u16 ec, u8 xec)
399 {
400 	bool ret = true;
401 
402 	if (MEM_ERROR(ec)) {
403 
404 		switch (xec) {
405 		case 0x0:
406 			pr_cont("Data Array access error.\n");
407 			break;
408 
409 		case 0x1:
410 			pr_cont("UC error during a linefill from L2/NB.\n");
411 			break;
412 
413 		case 0x2:
414 		case 0x11:
415 			pr_cont("STQ access error.\n");
416 			break;
417 
418 		case 0x3:
419 			pr_cont("SCB access error.\n");
420 			break;
421 
422 		case 0x10:
423 			pr_cont("Tag error.\n");
424 			break;
425 
426 		case 0x12:
427 			pr_cont("LDQ access error.\n");
428 			break;
429 
430 		default:
431 			ret = false;
432 		}
433 	} else if (BUS_ERROR(ec)) {
434 
435 		if (!xec)
436 			pr_cont("System Read Data Error.\n");
437 		else
438 			pr_cont(" Internal error condition type %d.\n", xec);
439 	} else if (INT_ERROR(ec)) {
440 		if (xec <= 0x1f)
441 			pr_cont("Hardware Assert.\n");
442 		else
443 			ret = false;
444 
445 	} else
446 		ret = false;
447 
448 	return ret;
449 }
450 
451 static void decode_mc0_mce(struct mce *m)
452 {
453 	u16 ec = EC(m->status);
454 	u8 xec = XEC(m->status, xec_mask);
455 
456 	pr_emerg(HW_ERR "MC0 Error: ");
457 
458 	/* TLB error signatures are the same across families */
459 	if (TLB_ERROR(ec)) {
460 		if (TT(ec) == TT_DATA) {
461 			pr_cont("%s TLB %s.\n", LL_MSG(ec),
462 				((xec == 2) ? "locked miss"
463 					    : (xec ? "multimatch" : "parity")));
464 			return;
465 		}
466 	} else if (fam_ops->mc0_mce(ec, xec))
467 		;
468 	else
469 		pr_emerg(HW_ERR "Corrupted MC0 MCE info?\n");
470 }
471 
472 static bool k8_mc1_mce(u16 ec, u8 xec)
473 {
474 	u8 ll	 = LL(ec);
475 	bool ret = true;
476 
477 	if (!MEM_ERROR(ec))
478 		return false;
479 
480 	if (ll == 0x2)
481 		pr_cont("during a linefill from L2.\n");
482 	else if (ll == 0x1) {
483 		switch (R4(ec)) {
484 		case R4_IRD:
485 			pr_cont("Parity error during data load.\n");
486 			break;
487 
488 		case R4_EVICT:
489 			pr_cont("Copyback Parity/Victim error.\n");
490 			break;
491 
492 		case R4_SNOOP:
493 			pr_cont("Tag Snoop error.\n");
494 			break;
495 
496 		default:
497 			ret = false;
498 			break;
499 		}
500 	} else
501 		ret = false;
502 
503 	return ret;
504 }
505 
506 static bool cat_mc1_mce(u16 ec, u8 xec)
507 {
508 	u8 r4    = R4(ec);
509 	bool ret = true;
510 
511 	if (!MEM_ERROR(ec))
512 		return false;
513 
514 	if (TT(ec) != TT_INSTR)
515 		return false;
516 
517 	if (r4 == R4_IRD)
518 		pr_cont("Data/tag array parity error for a tag hit.\n");
519 	else if (r4 == R4_SNOOP)
520 		pr_cont("Tag error during snoop/victimization.\n");
521 	else if (xec == 0x0)
522 		pr_cont("Tag parity error from victim castout.\n");
523 	else if (xec == 0x2)
524 		pr_cont("Microcode patch RAM parity error.\n");
525 	else
526 		ret = false;
527 
528 	return ret;
529 }
530 
531 static bool f15h_mc1_mce(u16 ec, u8 xec)
532 {
533 	bool ret = true;
534 
535 	if (!MEM_ERROR(ec))
536 		return false;
537 
538 	switch (xec) {
539 	case 0x0 ... 0xa:
540 		pr_cont("%s.\n", f15h_mc1_mce_desc[xec]);
541 		break;
542 
543 	case 0xd:
544 		pr_cont("%s.\n", f15h_mc1_mce_desc[xec-2]);
545 		break;
546 
547 	case 0x10:
548 		pr_cont("%s.\n", f15h_mc1_mce_desc[xec-4]);
549 		break;
550 
551 	case 0x11 ... 0x15:
552 		pr_cont("Decoder %s parity error.\n", f15h_mc1_mce_desc[xec-4]);
553 		break;
554 
555 	default:
556 		ret = false;
557 	}
558 	return ret;
559 }
560 
561 static void decode_mc1_mce(struct mce *m)
562 {
563 	u16 ec = EC(m->status);
564 	u8 xec = XEC(m->status, xec_mask);
565 
566 	pr_emerg(HW_ERR "MC1 Error: ");
567 
568 	if (TLB_ERROR(ec))
569 		pr_cont("%s TLB %s.\n", LL_MSG(ec),
570 			(xec ? "multimatch" : "parity error"));
571 	else if (BUS_ERROR(ec)) {
572 		bool k8 = (boot_cpu_data.x86 == 0xf && (m->status & BIT_64(58)));
573 
574 		pr_cont("during %s.\n", (k8 ? "system linefill" : "NB data read"));
575 	} else if (INT_ERROR(ec)) {
576 		if (xec <= 0x3f)
577 			pr_cont("Hardware Assert.\n");
578 		else
579 			goto wrong_mc1_mce;
580 	} else if (fam_ops->mc1_mce(ec, xec))
581 		;
582 	else
583 		goto wrong_mc1_mce;
584 
585 	return;
586 
587 wrong_mc1_mce:
588 	pr_emerg(HW_ERR "Corrupted MC1 MCE info?\n");
589 }
590 
591 static bool k8_mc2_mce(u16 ec, u8 xec)
592 {
593 	bool ret = true;
594 
595 	if (xec == 0x1)
596 		pr_cont(" in the write data buffers.\n");
597 	else if (xec == 0x3)
598 		pr_cont(" in the victim data buffers.\n");
599 	else if (xec == 0x2 && MEM_ERROR(ec))
600 		pr_cont(": %s error in the L2 cache tags.\n", R4_MSG(ec));
601 	else if (xec == 0x0) {
602 		if (TLB_ERROR(ec))
603 			pr_cont("%s error in a Page Descriptor Cache or Guest TLB.\n",
604 				TT_MSG(ec));
605 		else if (BUS_ERROR(ec))
606 			pr_cont(": %s/ECC error in data read from NB: %s.\n",
607 				R4_MSG(ec), PP_MSG(ec));
608 		else if (MEM_ERROR(ec)) {
609 			u8 r4 = R4(ec);
610 
611 			if (r4 >= 0x7)
612 				pr_cont(": %s error during data copyback.\n",
613 					R4_MSG(ec));
614 			else if (r4 <= 0x1)
615 				pr_cont(": %s parity/ECC error during data "
616 					"access from L2.\n", R4_MSG(ec));
617 			else
618 				ret = false;
619 		} else
620 			ret = false;
621 	} else
622 		ret = false;
623 
624 	return ret;
625 }
626 
627 static bool f15h_mc2_mce(u16 ec, u8 xec)
628 {
629 	bool ret = true;
630 
631 	if (TLB_ERROR(ec)) {
632 		if (xec == 0x0)
633 			pr_cont("Data parity TLB read error.\n");
634 		else if (xec == 0x1)
635 			pr_cont("Poison data provided for TLB fill.\n");
636 		else
637 			ret = false;
638 	} else if (BUS_ERROR(ec)) {
639 		if (xec > 2)
640 			ret = false;
641 
642 		pr_cont("Error during attempted NB data read.\n");
643 	} else if (MEM_ERROR(ec)) {
644 		switch (xec) {
645 		case 0x4 ... 0xc:
646 			pr_cont("%s.\n", f15h_mc2_mce_desc[xec - 0x4]);
647 			break;
648 
649 		case 0x10 ... 0x14:
650 			pr_cont("%s.\n", f15h_mc2_mce_desc[xec - 0x7]);
651 			break;
652 
653 		default:
654 			ret = false;
655 		}
656 	} else if (INT_ERROR(ec)) {
657 		if (xec <= 0x3f)
658 			pr_cont("Hardware Assert.\n");
659 		else
660 			ret = false;
661 	}
662 
663 	return ret;
664 }
665 
666 static bool f16h_mc2_mce(u16 ec, u8 xec)
667 {
668 	u8 r4 = R4(ec);
669 
670 	if (!MEM_ERROR(ec))
671 		return false;
672 
673 	switch (xec) {
674 	case 0x04 ... 0x05:
675 		pr_cont("%cBUFF parity error.\n", (r4 == R4_RD) ? 'I' : 'O');
676 		break;
677 
678 	case 0x09 ... 0x0b:
679 	case 0x0d ... 0x0f:
680 		pr_cont("ECC error in L2 tag (%s).\n",
681 			((r4 == R4_GEN)   ? "BankReq" :
682 			((r4 == R4_SNOOP) ? "Prb"     : "Fill")));
683 		break;
684 
685 	case 0x10 ... 0x19:
686 	case 0x1b:
687 		pr_cont("ECC error in L2 data array (%s).\n",
688 			(((r4 == R4_RD) && !(xec & 0x3)) ? "Hit"  :
689 			((r4 == R4_GEN)   ? "Attr" :
690 			((r4 == R4_EVICT) ? "Vict" : "Fill"))));
691 		break;
692 
693 	case 0x1c ... 0x1d:
694 	case 0x1f:
695 		pr_cont("Parity error in L2 attribute bits (%s).\n",
696 			((r4 == R4_RD)  ? "Hit"  :
697 			((r4 == R4_GEN) ? "Attr" : "Fill")));
698 		break;
699 
700 	default:
701 		return false;
702 	}
703 
704 	return true;
705 }
706 
707 static void decode_mc2_mce(struct mce *m)
708 {
709 	u16 ec = EC(m->status);
710 	u8 xec = XEC(m->status, xec_mask);
711 
712 	pr_emerg(HW_ERR "MC2 Error: ");
713 
714 	if (!fam_ops->mc2_mce(ec, xec))
715 		pr_cont(HW_ERR "Corrupted MC2 MCE info?\n");
716 }
717 
718 static void decode_mc3_mce(struct mce *m)
719 {
720 	u16 ec = EC(m->status);
721 	u8 xec = XEC(m->status, xec_mask);
722 
723 	if (boot_cpu_data.x86 >= 0x14) {
724 		pr_emerg("You shouldn't be seeing MC3 MCE on this cpu family,"
725 			 " please report on LKML.\n");
726 		return;
727 	}
728 
729 	pr_emerg(HW_ERR "MC3 Error");
730 
731 	if (xec == 0x0) {
732 		u8 r4 = R4(ec);
733 
734 		if (!BUS_ERROR(ec) || (r4 != R4_DRD && r4 != R4_DWR))
735 			goto wrong_mc3_mce;
736 
737 		pr_cont(" during %s.\n", R4_MSG(ec));
738 	} else
739 		goto wrong_mc3_mce;
740 
741 	return;
742 
743  wrong_mc3_mce:
744 	pr_emerg(HW_ERR "Corrupted MC3 MCE info?\n");
745 }
746 
747 static void decode_mc4_mce(struct mce *m)
748 {
749 	unsigned int fam = x86_family(m->cpuid);
750 	int node_id = amd_get_nb_id(m->extcpu);
751 	u16 ec = EC(m->status);
752 	u8 xec = XEC(m->status, 0x1f);
753 	u8 offset = 0;
754 
755 	pr_emerg(HW_ERR "MC4 Error (node %d): ", node_id);
756 
757 	switch (xec) {
758 	case 0x0 ... 0xe:
759 
760 		/* special handling for DRAM ECCs */
761 		if (xec == 0x0 || xec == 0x8) {
762 			/* no ECCs on F11h */
763 			if (fam == 0x11)
764 				goto wrong_mc4_mce;
765 
766 			pr_cont("%s.\n", mc4_mce_desc[xec]);
767 
768 			if (decode_dram_ecc)
769 				decode_dram_ecc(node_id, m);
770 			return;
771 		}
772 		break;
773 
774 	case 0xf:
775 		if (TLB_ERROR(ec))
776 			pr_cont("GART Table Walk data error.\n");
777 		else if (BUS_ERROR(ec))
778 			pr_cont("DMA Exclusion Vector Table Walk error.\n");
779 		else
780 			goto wrong_mc4_mce;
781 		return;
782 
783 	case 0x19:
784 		if (fam == 0x15 || fam == 0x16)
785 			pr_cont("Compute Unit Data Error.\n");
786 		else
787 			goto wrong_mc4_mce;
788 		return;
789 
790 	case 0x1c ... 0x1f:
791 		offset = 13;
792 		break;
793 
794 	default:
795 		goto wrong_mc4_mce;
796 	}
797 
798 	pr_cont("%s.\n", mc4_mce_desc[xec - offset]);
799 	return;
800 
801  wrong_mc4_mce:
802 	pr_emerg(HW_ERR "Corrupted MC4 MCE info?\n");
803 }
804 
805 static void decode_mc5_mce(struct mce *m)
806 {
807 	unsigned int fam = x86_family(m->cpuid);
808 	u16 ec = EC(m->status);
809 	u8 xec = XEC(m->status, xec_mask);
810 
811 	if (fam == 0xf || fam == 0x11)
812 		goto wrong_mc5_mce;
813 
814 	pr_emerg(HW_ERR "MC5 Error: ");
815 
816 	if (INT_ERROR(ec)) {
817 		if (xec <= 0x1f) {
818 			pr_cont("Hardware Assert.\n");
819 			return;
820 		} else
821 			goto wrong_mc5_mce;
822 	}
823 
824 	if (xec == 0x0 || xec == 0xc)
825 		pr_cont("%s.\n", mc5_mce_desc[xec]);
826 	else if (xec <= 0xd)
827 		pr_cont("%s parity error.\n", mc5_mce_desc[xec]);
828 	else
829 		goto wrong_mc5_mce;
830 
831 	return;
832 
833  wrong_mc5_mce:
834 	pr_emerg(HW_ERR "Corrupted MC5 MCE info?\n");
835 }
836 
837 static void decode_mc6_mce(struct mce *m)
838 {
839 	u8 xec = XEC(m->status, xec_mask);
840 
841 	pr_emerg(HW_ERR "MC6 Error: ");
842 
843 	if (xec > 0x5)
844 		goto wrong_mc6_mce;
845 
846 	pr_cont("%s parity error.\n", mc6_mce_desc[xec]);
847 	return;
848 
849  wrong_mc6_mce:
850 	pr_emerg(HW_ERR "Corrupted MC6 MCE info?\n");
851 }
852 
853 /* Decode errors according to Scalable MCA specification */
854 static void decode_smca_error(struct mce *m)
855 {
856 	struct smca_hwid *hwid;
857 	unsigned int bank_type;
858 	const char *ip_name;
859 	u8 xec = XEC(m->status, xec_mask);
860 
861 	if (m->bank >= ARRAY_SIZE(smca_banks))
862 		return;
863 
864 	if (x86_family(m->cpuid) >= 0x17 && m->bank == 4)
865 		pr_emerg(HW_ERR "Bank 4 is reserved on Fam17h.\n");
866 
867 	hwid = smca_banks[m->bank].hwid;
868 	if (!hwid)
869 		return;
870 
871 	bank_type = hwid->bank_type;
872 	ip_name = smca_get_long_name(bank_type);
873 
874 	pr_emerg(HW_ERR "%s Extended Error Code: %d\n", ip_name, xec);
875 
876 	/* Only print the decode of valid error codes */
877 	if (xec < smca_mce_descs[bank_type].num_descs &&
878 			(hwid->xec_bitmap & BIT_ULL(xec))) {
879 		pr_emerg(HW_ERR "%s Error: ", ip_name);
880 		pr_cont("%s.\n", smca_mce_descs[bank_type].descs[xec]);
881 	}
882 
883 	if (bank_type == SMCA_UMC && xec == 0 && decode_dram_ecc)
884 		decode_dram_ecc(cpu_to_node(m->extcpu), m);
885 }
886 
887 static inline void amd_decode_err_code(u16 ec)
888 {
889 	if (INT_ERROR(ec)) {
890 		pr_emerg(HW_ERR "internal: %s\n", UU_MSG(ec));
891 		return;
892 	}
893 
894 	pr_emerg(HW_ERR "cache level: %s", LL_MSG(ec));
895 
896 	if (BUS_ERROR(ec))
897 		pr_cont(", mem/io: %s", II_MSG(ec));
898 	else
899 		pr_cont(", tx: %s", TT_MSG(ec));
900 
901 	if (MEM_ERROR(ec) || BUS_ERROR(ec)) {
902 		pr_cont(", mem-tx: %s", R4_MSG(ec));
903 
904 		if (BUS_ERROR(ec))
905 			pr_cont(", part-proc: %s (%s)", PP_MSG(ec), TO_MSG(ec));
906 	}
907 
908 	pr_cont("\n");
909 }
910 
911 /*
912  * Filter out unwanted MCE signatures here.
913  */
914 static bool amd_filter_mce(struct mce *m)
915 {
916 	/*
917 	 * NB GART TLB error reporting is disabled by default.
918 	 */
919 	if (m->bank == 4 && XEC(m->status, 0x1f) == 0x5 && !report_gart_errors)
920 		return true;
921 
922 	return false;
923 }
924 
925 static const char *decode_error_status(struct mce *m)
926 {
927 	if (m->status & MCI_STATUS_UC) {
928 		if (m->status & MCI_STATUS_PCC)
929 			return "System Fatal error.";
930 		if (m->mcgstatus & MCG_STATUS_RIPV)
931 			return "Uncorrected, software restartable error.";
932 		return "Uncorrected, software containable error.";
933 	}
934 
935 	if (m->status & MCI_STATUS_DEFERRED)
936 		return "Deferred error, no action required.";
937 
938 	return "Corrected error, no action required.";
939 }
940 
941 static int
942 amd_decode_mce(struct notifier_block *nb, unsigned long val, void *data)
943 {
944 	struct mce *m = (struct mce *)data;
945 	unsigned int fam = x86_family(m->cpuid);
946 	int ecc;
947 
948 	if (amd_filter_mce(m))
949 		return NOTIFY_STOP;
950 
951 	pr_emerg(HW_ERR "%s\n", decode_error_status(m));
952 
953 	pr_emerg(HW_ERR "CPU:%d (%x:%x:%x) MC%d_STATUS[%s|%s|%s|%s|%s",
954 		m->extcpu,
955 		fam, x86_model(m->cpuid), x86_stepping(m->cpuid),
956 		m->bank,
957 		((m->status & MCI_STATUS_OVER)	? "Over"  : "-"),
958 		((m->status & MCI_STATUS_UC)	? "UE"	  :
959 		 (m->status & MCI_STATUS_DEFERRED) ? "-"  : "CE"),
960 		((m->status & MCI_STATUS_MISCV)	? "MiscV" : "-"),
961 		((m->status & MCI_STATUS_PCC)	? "PCC"	  : "-"),
962 		((m->status & MCI_STATUS_ADDRV)	? "AddrV" : "-"));
963 
964 	if (fam >= 0x15) {
965 		pr_cont("|%s", (m->status & MCI_STATUS_DEFERRED ? "Deferred" : "-"));
966 
967 		/* F15h, bank4, bit 43 is part of McaStatSubCache. */
968 		if (fam != 0x15 || m->bank != 4)
969 			pr_cont("|%s", (m->status & MCI_STATUS_POISON ? "Poison" : "-"));
970 	}
971 
972 	if (boot_cpu_has(X86_FEATURE_SMCA)) {
973 		u32 low, high;
974 		u32 addr = MSR_AMD64_SMCA_MCx_CONFIG(m->bank);
975 
976 		pr_cont("|%s", ((m->status & MCI_STATUS_SYNDV) ? "SyndV" : "-"));
977 
978 		if (!rdmsr_safe(addr, &low, &high) &&
979 		    (low & MCI_CONFIG_MCAX))
980 			pr_cont("|%s", ((m->status & MCI_STATUS_TCC) ? "TCC" : "-"));
981 	}
982 
983 	/* do the two bits[14:13] together */
984 	ecc = (m->status >> 45) & 0x3;
985 	if (ecc)
986 		pr_cont("|%sECC", ((ecc == 2) ? "C" : "U"));
987 
988 	pr_cont("]: 0x%016llx\n", m->status);
989 
990 	if (m->status & MCI_STATUS_ADDRV)
991 		pr_emerg(HW_ERR "Error Addr: 0x%016llx\n", m->addr);
992 
993 	if (boot_cpu_has(X86_FEATURE_SMCA)) {
994 		pr_emerg(HW_ERR "IPID: 0x%016llx", m->ipid);
995 
996 		if (m->status & MCI_STATUS_SYNDV)
997 			pr_cont(", Syndrome: 0x%016llx", m->synd);
998 
999 		pr_cont("\n");
1000 
1001 		decode_smca_error(m);
1002 		goto err_code;
1003 	}
1004 
1005 	if (m->tsc)
1006 		pr_emerg(HW_ERR "TSC: %llu\n", m->tsc);
1007 
1008 	if (!fam_ops)
1009 		goto err_code;
1010 
1011 	switch (m->bank) {
1012 	case 0:
1013 		decode_mc0_mce(m);
1014 		break;
1015 
1016 	case 1:
1017 		decode_mc1_mce(m);
1018 		break;
1019 
1020 	case 2:
1021 		decode_mc2_mce(m);
1022 		break;
1023 
1024 	case 3:
1025 		decode_mc3_mce(m);
1026 		break;
1027 
1028 	case 4:
1029 		decode_mc4_mce(m);
1030 		break;
1031 
1032 	case 5:
1033 		decode_mc5_mce(m);
1034 		break;
1035 
1036 	case 6:
1037 		decode_mc6_mce(m);
1038 		break;
1039 
1040 	default:
1041 		break;
1042 	}
1043 
1044  err_code:
1045 	amd_decode_err_code(m->status & 0xffff);
1046 
1047 	return NOTIFY_STOP;
1048 }
1049 
1050 static struct notifier_block amd_mce_dec_nb = {
1051 	.notifier_call	= amd_decode_mce,
1052 	.priority	= MCE_PRIO_EDAC,
1053 };
1054 
1055 static int __init mce_amd_init(void)
1056 {
1057 	struct cpuinfo_x86 *c = &boot_cpu_data;
1058 
1059 	if (c->x86_vendor != X86_VENDOR_AMD)
1060 		return -ENODEV;
1061 
1062 	fam_ops = kzalloc(sizeof(struct amd_decoder_ops), GFP_KERNEL);
1063 	if (!fam_ops)
1064 		return -ENOMEM;
1065 
1066 	switch (c->x86) {
1067 	case 0xf:
1068 		fam_ops->mc0_mce = k8_mc0_mce;
1069 		fam_ops->mc1_mce = k8_mc1_mce;
1070 		fam_ops->mc2_mce = k8_mc2_mce;
1071 		break;
1072 
1073 	case 0x10:
1074 		fam_ops->mc0_mce = f10h_mc0_mce;
1075 		fam_ops->mc1_mce = k8_mc1_mce;
1076 		fam_ops->mc2_mce = k8_mc2_mce;
1077 		break;
1078 
1079 	case 0x11:
1080 		fam_ops->mc0_mce = k8_mc0_mce;
1081 		fam_ops->mc1_mce = k8_mc1_mce;
1082 		fam_ops->mc2_mce = k8_mc2_mce;
1083 		break;
1084 
1085 	case 0x12:
1086 		fam_ops->mc0_mce = f12h_mc0_mce;
1087 		fam_ops->mc1_mce = k8_mc1_mce;
1088 		fam_ops->mc2_mce = k8_mc2_mce;
1089 		break;
1090 
1091 	case 0x14:
1092 		fam_ops->mc0_mce = cat_mc0_mce;
1093 		fam_ops->mc1_mce = cat_mc1_mce;
1094 		fam_ops->mc2_mce = k8_mc2_mce;
1095 		break;
1096 
1097 	case 0x15:
1098 		xec_mask = c->x86_model == 0x60 ? 0x3f : 0x1f;
1099 
1100 		fam_ops->mc0_mce = f15h_mc0_mce;
1101 		fam_ops->mc1_mce = f15h_mc1_mce;
1102 		fam_ops->mc2_mce = f15h_mc2_mce;
1103 		break;
1104 
1105 	case 0x16:
1106 		xec_mask = 0x1f;
1107 		fam_ops->mc0_mce = cat_mc0_mce;
1108 		fam_ops->mc1_mce = cat_mc1_mce;
1109 		fam_ops->mc2_mce = f16h_mc2_mce;
1110 		break;
1111 
1112 	case 0x17:
1113 		xec_mask = 0x3f;
1114 		if (!boot_cpu_has(X86_FEATURE_SMCA)) {
1115 			printk(KERN_WARNING "Decoding supported only on Scalable MCA processors.\n");
1116 			goto err_out;
1117 		}
1118 		break;
1119 
1120 	default:
1121 		printk(KERN_WARNING "Huh? What family is it: 0x%x?!\n", c->x86);
1122 		goto err_out;
1123 	}
1124 
1125 	pr_info("MCE: In-kernel MCE decoding enabled.\n");
1126 
1127 	mce_register_decode_chain(&amd_mce_dec_nb);
1128 
1129 	return 0;
1130 
1131 err_out:
1132 	kfree(fam_ops);
1133 	fam_ops = NULL;
1134 	return -EINVAL;
1135 }
1136 early_initcall(mce_amd_init);
1137 
1138 #ifdef MODULE
1139 static void __exit mce_amd_exit(void)
1140 {
1141 	mce_unregister_decode_chain(&amd_mce_dec_nb);
1142 	kfree(fam_ops);
1143 }
1144 
1145 MODULE_DESCRIPTION("AMD MCE decoder");
1146 MODULE_ALIAS("edac-mce-amd");
1147 MODULE_LICENSE("GPL");
1148 module_exit(mce_amd_exit);
1149 #endif
1150