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