EDAC, MCE: Select extended error code mask
[linux-2.6.git] / drivers / edac / mce_amd.c
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 static u8 nb_err_cpumask = 0xf;
10
11 static bool report_gart_errors;
12 static void (*nb_bus_decoder)(int node_id, struct mce *m, u32 nbcfg);
13
14 void amd_report_gart_errors(bool v)
15 {
16         report_gart_errors = v;
17 }
18 EXPORT_SYMBOL_GPL(amd_report_gart_errors);
19
20 void amd_register_ecc_decoder(void (*f)(int, struct mce *, u32))
21 {
22         nb_bus_decoder = f;
23 }
24 EXPORT_SYMBOL_GPL(amd_register_ecc_decoder);
25
26 void amd_unregister_ecc_decoder(void (*f)(int, struct mce *, u32))
27 {
28         if (nb_bus_decoder) {
29                 WARN_ON(nb_bus_decoder != f);
30
31                 nb_bus_decoder = NULL;
32         }
33 }
34 EXPORT_SYMBOL_GPL(amd_unregister_ecc_decoder);
35
36 /*
37  * string representation for the different MCA reported error types, see F3x48
38  * or MSR0000_0411.
39  */
40
41 /* transaction type */
42 const char *tt_msgs[] = { "INSN", "DATA", "GEN", "RESV" };
43 EXPORT_SYMBOL_GPL(tt_msgs);
44
45 /* cache level */
46 const char *ll_msgs[] = { "RESV", "L1", "L2", "L3/GEN" };
47 EXPORT_SYMBOL_GPL(ll_msgs);
48
49 /* memory transaction type */
50 const char *rrrr_msgs[] = {
51        "GEN", "RD", "WR", "DRD", "DWR", "IRD", "PRF", "EV", "SNP"
52 };
53 EXPORT_SYMBOL_GPL(rrrr_msgs);
54
55 /* participating processor */
56 const char *pp_msgs[] = { "SRC", "RES", "OBS", "GEN" };
57 EXPORT_SYMBOL_GPL(pp_msgs);
58
59 /* request timeout */
60 const char *to_msgs[] = { "no timeout", "timed out" };
61 EXPORT_SYMBOL_GPL(to_msgs);
62
63 /* memory or i/o */
64 const char *ii_msgs[] = { "MEM", "RESV", "IO", "GEN" };
65 EXPORT_SYMBOL_GPL(ii_msgs);
66
67 static const char *f10h_nb_mce_desc[] = {
68         "HT link data error",
69         "Protocol error (link, L3, probe filter, etc.)",
70         "Parity error in NB-internal arrays",
71         "Link Retry due to IO link transmission error",
72         "L3 ECC data cache error",
73         "ECC error in L3 cache tag",
74         "L3 LRU parity bits error",
75         "ECC Error in the Probe Filter directory"
76 };
77
78 static bool f12h_dc_mce(u16 ec)
79 {
80         bool ret = false;
81
82         if (MEM_ERROR(ec)) {
83                 u8 ll = ec & 0x3;
84                 ret = true;
85
86                 if (ll == LL_L2)
87                         pr_cont("during L1 linefill from L2.\n");
88                 else if (ll == LL_L1)
89                         pr_cont("Data/Tag %s error.\n", RRRR_MSG(ec));
90                 else
91                         ret = false;
92         }
93         return ret;
94 }
95
96 static bool f10h_dc_mce(u16 ec)
97 {
98         u8 r4  = (ec >> 4) & 0xf;
99         u8 ll  = ec & 0x3;
100
101         if (r4 == R4_GEN && ll == LL_L1) {
102                 pr_cont("during data scrub.\n");
103                 return true;
104         }
105         return f12h_dc_mce(ec);
106 }
107
108 static bool k8_dc_mce(u16 ec)
109 {
110         if (BUS_ERROR(ec)) {
111                 pr_cont("during system linefill.\n");
112                 return true;
113         }
114
115         return f10h_dc_mce(ec);
116 }
117
118 static bool f14h_dc_mce(u16 ec)
119 {
120         u8 r4    = (ec >> 4) & 0xf;
121         u8 ll    = ec & 0x3;
122         u8 tt    = (ec >> 2) & 0x3;
123         u8 ii    = tt;
124         bool ret = true;
125
126         if (MEM_ERROR(ec)) {
127
128                 if (tt != TT_DATA || ll != LL_L1)
129                         return false;
130
131                 switch (r4) {
132                 case R4_DRD:
133                 case R4_DWR:
134                         pr_cont("Data/Tag parity error due to %s.\n",
135                                 (r4 == R4_DRD ? "load/hw prf" : "store"));
136                         break;
137                 case R4_EVICT:
138                         pr_cont("Copyback parity error on a tag miss.\n");
139                         break;
140                 case R4_SNOOP:
141                         pr_cont("Tag parity error during snoop.\n");
142                         break;
143                 default:
144                         ret = false;
145                 }
146         } else if (BUS_ERROR(ec)) {
147
148                 if ((ii != II_MEM && ii != II_IO) || ll != LL_LG)
149                         return false;
150
151                 pr_cont("System read data error on a ");
152
153                 switch (r4) {
154                 case R4_RD:
155                         pr_cont("TLB reload.\n");
156                         break;
157                 case R4_DWR:
158                         pr_cont("store.\n");
159                         break;
160                 case R4_DRD:
161                         pr_cont("load.\n");
162                         break;
163                 default:
164                         ret = false;
165                 }
166         } else {
167                 ret = false;
168         }
169
170         return ret;
171 }
172
173 static void amd_decode_dc_mce(struct mce *m)
174 {
175         u16 ec = m->status & 0xffff;
176         u8 xec = (m->status >> 16) & xec_mask;
177
178         pr_emerg(HW_ERR "Data Cache Error: ");
179
180         /* TLB error signatures are the same across families */
181         if (TLB_ERROR(ec)) {
182                 u8 tt = (ec >> 2) & 0x3;
183
184                 if (tt == TT_DATA) {
185                         pr_cont("%s TLB %s.\n", LL_MSG(ec),
186                                 (xec ? "multimatch" : "parity error"));
187                         return;
188                 }
189                 else
190                         goto wrong_dc_mce;
191         }
192
193         if (!fam_ops->dc_mce(ec))
194                 goto wrong_dc_mce;
195
196         return;
197
198 wrong_dc_mce:
199         pr_emerg(HW_ERR "Corrupted DC MCE info?\n");
200 }
201
202 static bool k8_ic_mce(u16 ec)
203 {
204         u8 ll    = ec & 0x3;
205         u8 r4    = (ec >> 4) & 0xf;
206         bool ret = true;
207
208         if (!MEM_ERROR(ec))
209                 return false;
210
211         if (ll == 0x2)
212                 pr_cont("during a linefill from L2.\n");
213         else if (ll == 0x1) {
214                 switch (r4) {
215                 case R4_IRD:
216                         pr_cont("Parity error during data load.\n");
217                         break;
218
219                 case R4_EVICT:
220                         pr_cont("Copyback Parity/Victim error.\n");
221                         break;
222
223                 case R4_SNOOP:
224                         pr_cont("Tag Snoop error.\n");
225                         break;
226
227                 default:
228                         ret = false;
229                         break;
230                 }
231         } else
232                 ret = false;
233
234         return ret;
235 }
236
237 static bool f14h_ic_mce(u16 ec)
238 {
239         u8 ll    = ec & 0x3;
240         u8 tt    = (ec >> 2) & 0x3;
241         u8 r4  = (ec >> 4) & 0xf;
242         bool ret = true;
243
244         if (MEM_ERROR(ec)) {
245                 if (tt != 0 || ll != 1)
246                         ret = false;
247
248                 if (r4 == R4_IRD)
249                         pr_cont("Data/tag array parity error for a tag hit.\n");
250                 else if (r4 == R4_SNOOP)
251                         pr_cont("Tag error during snoop/victimization.\n");
252                 else
253                         ret = false;
254         }
255         return ret;
256 }
257
258 static void amd_decode_ic_mce(struct mce *m)
259 {
260         u16 ec = m->status & 0xffff;
261         u8 xec = (m->status >> 16) & xec_mask;
262
263         pr_emerg(HW_ERR "Instruction Cache Error: ");
264
265         if (TLB_ERROR(ec))
266                 pr_cont("%s TLB %s.\n", LL_MSG(ec),
267                         (xec ? "multimatch" : "parity error"));
268         else if (BUS_ERROR(ec)) {
269                 bool k8 = (boot_cpu_data.x86 == 0xf && (m->status & BIT_64(58)));
270
271                 pr_cont("during %s.\n", (k8 ? "system linefill" : "NB data read"));
272         } else if (fam_ops->ic_mce(ec))
273                 ;
274         else
275                 pr_emerg(HW_ERR "Corrupted IC MCE info?\n");
276 }
277
278 static void amd_decode_bu_mce(struct mce *m)
279 {
280         u32 ec = m->status & 0xffff;
281         u32 xec = (m->status >> 16) & xec_mask;
282
283         pr_emerg(HW_ERR "Bus Unit Error");
284
285         if (xec == 0x1)
286                 pr_cont(" in the write data buffers.\n");
287         else if (xec == 0x3)
288                 pr_cont(" in the victim data buffers.\n");
289         else if (xec == 0x2 && MEM_ERROR(ec))
290                 pr_cont(": %s error in the L2 cache tags.\n", RRRR_MSG(ec));
291         else if (xec == 0x0) {
292                 if (TLB_ERROR(ec))
293                         pr_cont(": %s error in a Page Descriptor Cache or "
294                                 "Guest TLB.\n", TT_MSG(ec));
295                 else if (BUS_ERROR(ec))
296                         pr_cont(": %s/ECC error in data read from NB: %s.\n",
297                                 RRRR_MSG(ec), PP_MSG(ec));
298                 else if (MEM_ERROR(ec)) {
299                         u8 rrrr = (ec >> 4) & 0xf;
300
301                         if (rrrr >= 0x7)
302                                 pr_cont(": %s error during data copyback.\n",
303                                         RRRR_MSG(ec));
304                         else if (rrrr <= 0x1)
305                                 pr_cont(": %s parity/ECC error during data "
306                                         "access from L2.\n", RRRR_MSG(ec));
307                         else
308                                 goto wrong_bu_mce;
309                 } else
310                         goto wrong_bu_mce;
311         } else
312                 goto wrong_bu_mce;
313
314         return;
315
316 wrong_bu_mce:
317         pr_emerg(HW_ERR "Corrupted BU MCE info?\n");
318 }
319
320 static void amd_decode_ls_mce(struct mce *m)
321 {
322         u16 ec = m->status & 0xffff;
323         u8 xec = (m->status >> 16) & xec_mask;
324
325         if (boot_cpu_data.x86 == 0x14) {
326                 pr_emerg("You shouldn't be seeing an LS MCE on this cpu family,"
327                          " please report on LKML.\n");
328                 return;
329         }
330
331         pr_emerg(HW_ERR "Load Store Error");
332
333         if (xec == 0x0) {
334                 u8 r4 = (ec >> 4) & 0xf;
335
336                 if (!BUS_ERROR(ec) || (r4 != R4_DRD && r4 != R4_DWR))
337                         goto wrong_ls_mce;
338
339                 pr_cont(" during %s.\n", RRRR_MSG(ec));
340         } else
341                 goto wrong_ls_mce;
342
343         return;
344
345 wrong_ls_mce:
346         pr_emerg(HW_ERR "Corrupted LS MCE info?\n");
347 }
348
349 static bool k8_nb_mce(u16 ec, u8 xec)
350 {
351         bool ret = true;
352
353         switch (xec) {
354         case 0x1:
355                 pr_cont("CRC error detected on HT link.\n");
356                 break;
357
358         case 0x5:
359                 pr_cont("Invalid GART PTE entry during GART table walk.\n");
360                 break;
361
362         case 0x6:
363                 pr_cont("Unsupported atomic RMW received from an IO link.\n");
364                 break;
365
366         case 0x0:
367         case 0x8:
368                 if (boot_cpu_data.x86 == 0x11)
369                         return false;
370
371                 pr_cont("DRAM ECC error detected on the NB.\n");
372                 break;
373
374         case 0xd:
375                 pr_cont("Parity error on the DRAM addr/ctl signals.\n");
376                 break;
377
378         default:
379                 ret = false;
380                 break;
381         }
382
383         return ret;
384 }
385
386 static bool f10h_nb_mce(u16 ec, u8 xec)
387 {
388         bool ret = true;
389         u8 offset = 0;
390
391         if (k8_nb_mce(ec, xec))
392                 return true;
393
394         switch(xec) {
395         case 0xa ... 0xc:
396                 offset = 10;
397                 break;
398
399         case 0xe:
400                 offset = 11;
401                 break;
402
403         case 0xf:
404                 if (TLB_ERROR(ec))
405                         pr_cont("GART Table Walk data error.\n");
406                 else if (BUS_ERROR(ec))
407                         pr_cont("DMA Exclusion Vector Table Walk error.\n");
408                 else
409                         ret = false;
410
411                 goto out;
412                 break;
413
414         case 0x1c ... 0x1f:
415                 offset = 24;
416                 break;
417
418         default:
419                 ret = false;
420
421                 goto out;
422                 break;
423         }
424
425         pr_cont("%s.\n", f10h_nb_mce_desc[xec - offset]);
426
427 out:
428         return ret;
429 }
430
431 static bool nb_noop_mce(u16 ec, u8 xec)
432 {
433         return false;
434 }
435
436 void amd_decode_nb_mce(int node_id, struct mce *m, u32 nbcfg)
437 {
438         u8 xec   = (m->status >> 16) & 0x1f;
439         u16 ec   = m->status & 0xffff;
440         u32 nbsh = (u32)(m->status >> 32);
441
442         pr_emerg(HW_ERR "Northbridge Error, node %d: ", node_id);
443
444         /*
445          * F10h, revD can disable ErrCpu[3:0] so check that first and also the
446          * value encoding has changed so interpret those differently
447          */
448         if ((boot_cpu_data.x86 == 0x10) &&
449             (boot_cpu_data.x86_model > 7)) {
450                 if (nbsh & K8_NBSH_ERR_CPU_VAL)
451                         pr_cont(", core: %u", (u8)(nbsh & nb_err_cpumask));
452         } else {
453                 u8 assoc_cpus = nbsh & nb_err_cpumask;
454
455                 if (assoc_cpus > 0)
456                         pr_cont(", core: %d", fls(assoc_cpus) - 1);
457         }
458
459         switch (xec) {
460         case 0x2:
461                 pr_cont("Sync error (sync packets on HT link detected).\n");
462                 return;
463
464         case 0x3:
465                 pr_cont("HT Master abort.\n");
466                 return;
467
468         case 0x4:
469                 pr_cont("HT Target abort.\n");
470                 return;
471
472         case 0x7:
473                 pr_cont("NB Watchdog timeout.\n");
474                 return;
475
476         case 0x9:
477                 pr_cont("SVM DMA Exclusion Vector error.\n");
478                 return;
479
480         default:
481                 break;
482         }
483
484         if (!fam_ops->nb_mce(ec, xec))
485                 goto wrong_nb_mce;
486
487         if (boot_cpu_data.x86 == 0xf || boot_cpu_data.x86 == 0x10)
488                 if ((xec == 0x8 || xec == 0x0) && nb_bus_decoder)
489                         nb_bus_decoder(node_id, m, nbcfg);
490
491         return;
492
493 wrong_nb_mce:
494         pr_emerg(HW_ERR "Corrupted NB MCE info?\n");
495 }
496 EXPORT_SYMBOL_GPL(amd_decode_nb_mce);
497
498 static void amd_decode_fr_mce(struct mce *m)
499 {
500         if (boot_cpu_data.x86 == 0xf ||
501             boot_cpu_data.x86 == 0x11)
502                 goto wrong_fr_mce;
503
504         /* we have only one error signature so match all fields at once. */
505         if ((m->status & 0xffff) == 0x0f0f) {
506                 pr_emerg(HW_ERR "FR Error: CPU Watchdog timer expire.\n");
507                 return;
508         }
509
510 wrong_fr_mce:
511         pr_emerg(HW_ERR "Corrupted FR MCE info?\n");
512 }
513
514 static inline void amd_decode_err_code(u16 ec)
515 {
516         if (TLB_ERROR(ec)) {
517                 pr_emerg(HW_ERR "Transaction: %s, Cache Level: %s\n",
518                          TT_MSG(ec), LL_MSG(ec));
519         } else if (MEM_ERROR(ec)) {
520                 pr_emerg(HW_ERR "Transaction: %s, Type: %s, Cache Level: %s\n",
521                          RRRR_MSG(ec), TT_MSG(ec), LL_MSG(ec));
522         } else if (BUS_ERROR(ec)) {
523                 pr_emerg(HW_ERR "Transaction: %s (%s), %s, Cache Level: %s, "
524                          "Participating Processor: %s\n",
525                           RRRR_MSG(ec), II_MSG(ec), TO_MSG(ec), LL_MSG(ec),
526                           PP_MSG(ec));
527         } else
528                 pr_emerg(HW_ERR "Huh? Unknown MCE error 0x%x\n", ec);
529 }
530
531 /*
532  * Filter out unwanted MCE signatures here.
533  */
534 static bool amd_filter_mce(struct mce *m)
535 {
536         u8 xec = (m->status >> 16) & 0x1f;
537
538         /*
539          * NB GART TLB error reporting is disabled by default.
540          */
541         if (m->bank == 4 && xec == 0x5 && !report_gart_errors)
542                 return true;
543
544         return false;
545 }
546
547 int amd_decode_mce(struct notifier_block *nb, unsigned long val, void *data)
548 {
549         struct mce *m = (struct mce *)data;
550         int node, ecc;
551
552         if (amd_filter_mce(m))
553                 return NOTIFY_STOP;
554
555         pr_emerg(HW_ERR "MC%d_STATUS: ", m->bank);
556
557         pr_cont("%sorrected error, other errors lost: %s, "
558                  "CPU context corrupt: %s",
559                  ((m->status & MCI_STATUS_UC) ? "Unc"  : "C"),
560                  ((m->status & MCI_STATUS_OVER) ? "yes"  : "no"),
561                  ((m->status & MCI_STATUS_PCC) ? "yes" : "no"));
562
563         /* do the two bits[14:13] together */
564         ecc = (m->status >> 45) & 0x3;
565         if (ecc)
566                 pr_cont(", %sECC Error", ((ecc == 2) ? "C" : "U"));
567
568         pr_cont("\n");
569
570         switch (m->bank) {
571         case 0:
572                 amd_decode_dc_mce(m);
573                 break;
574
575         case 1:
576                 amd_decode_ic_mce(m);
577                 break;
578
579         case 2:
580                 amd_decode_bu_mce(m);
581                 break;
582
583         case 3:
584                 amd_decode_ls_mce(m);
585                 break;
586
587         case 4:
588                 node = amd_get_nb_id(m->extcpu);
589                 amd_decode_nb_mce(node, m, 0);
590                 break;
591
592         case 5:
593                 amd_decode_fr_mce(m);
594                 break;
595
596         default:
597                 break;
598         }
599
600         amd_decode_err_code(m->status & 0xffff);
601
602         return NOTIFY_STOP;
603 }
604 EXPORT_SYMBOL_GPL(amd_decode_mce);
605
606 static struct notifier_block amd_mce_dec_nb = {
607         .notifier_call  = amd_decode_mce,
608 };
609
610 static int __init mce_amd_init(void)
611 {
612         if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD)
613                 return 0;
614
615         if ((boot_cpu_data.x86 < 0xf || boot_cpu_data.x86 > 0x12) &&
616             (boot_cpu_data.x86 != 0x14 || boot_cpu_data.x86_model > 0xf))
617                 return 0;
618
619         fam_ops = kzalloc(sizeof(struct amd_decoder_ops), GFP_KERNEL);
620         if (!fam_ops)
621                 return -ENOMEM;
622
623         switch (boot_cpu_data.x86) {
624         case 0xf:
625                 fam_ops->dc_mce = k8_dc_mce;
626                 fam_ops->ic_mce = k8_ic_mce;
627                 fam_ops->nb_mce = k8_nb_mce;
628                 break;
629
630         case 0x10:
631                 fam_ops->dc_mce = f10h_dc_mce;
632                 fam_ops->ic_mce = k8_ic_mce;
633                 fam_ops->nb_mce = f10h_nb_mce;
634                 break;
635
636         case 0x11:
637                 fam_ops->dc_mce = k8_dc_mce;
638                 fam_ops->ic_mce = k8_ic_mce;
639                 fam_ops->nb_mce = f10h_nb_mce;
640                 break;
641
642         case 0x12:
643                 fam_ops->dc_mce = f12h_dc_mce;
644                 fam_ops->ic_mce = k8_ic_mce;
645                 fam_ops->nb_mce = nb_noop_mce;
646                 break;
647
648         case 0x14:
649                 nb_err_cpumask  = 0x3;
650                 fam_ops->dc_mce = f14h_dc_mce;
651                 fam_ops->ic_mce = f14h_ic_mce;
652                 fam_ops->nb_mce = nb_noop_mce;
653                 break;
654
655         case 0x15:
656                 xec_mask = 0x1f;
657                 break;
658
659         default:
660                 printk(KERN_WARNING "Huh? What family is that: %d?!\n",
661                                     boot_cpu_data.x86);
662                 kfree(fam_ops);
663                 return -EINVAL;
664         }
665
666         pr_info("MCE: In-kernel MCE decoding enabled.\n");
667
668         atomic_notifier_chain_register(&x86_mce_decoder_chain, &amd_mce_dec_nb);
669
670         return 0;
671 }
672 early_initcall(mce_amd_init);
673
674 #ifdef MODULE
675 static void __exit mce_amd_exit(void)
676 {
677         atomic_notifier_chain_unregister(&x86_mce_decoder_chain, &amd_mce_dec_nb);
678         kfree(fam_ops);
679 }
680
681 MODULE_DESCRIPTION("AMD MCE decoder");
682 MODULE_ALIAS("edac-mce-amd");
683 MODULE_LICENSE("GPL");
684 module_exit(mce_amd_exit);
685 #endif