158cd5fa2146389259fffec1fe1449777ae0a89b
[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 const char * const f15h_ic_mce_desc[] = {
79         "UC during a demand linefill from L2",
80         "Parity error during data load from IC",
81         "Parity error for IC valid bit",
82         "Main tag parity error",
83         "Parity error in prediction queue",
84         "PFB data/address parity error",
85         "Parity error in the branch status reg",
86         "PFB promotion address error",
87         "Tag error during probe/victimization",
88         "Parity error for IC probe tag valid bit",
89         "PFB non-cacheable bit parity error",
90         "PFB valid bit parity error",                   /* xec = 0xd */
91         "patch RAM",                                    /* xec = 010 */
92         "uop queue",
93         "insn buffer",
94         "predecode buffer",
95         "fetch address FIFO"
96 };
97
98 static bool f12h_dc_mce(u16 ec, u8 xec)
99 {
100         bool ret = false;
101
102         if (MEM_ERROR(ec)) {
103                 u8 ll = ec & 0x3;
104                 ret = true;
105
106                 if (ll == LL_L2)
107                         pr_cont("during L1 linefill from L2.\n");
108                 else if (ll == LL_L1)
109                         pr_cont("Data/Tag %s error.\n", RRRR_MSG(ec));
110                 else
111                         ret = false;
112         }
113         return ret;
114 }
115
116 static bool f10h_dc_mce(u16 ec, u8 xec)
117 {
118         u8 r4  = (ec >> 4) & 0xf;
119         u8 ll  = ec & 0x3;
120
121         if (r4 == R4_GEN && ll == LL_L1) {
122                 pr_cont("during data scrub.\n");
123                 return true;
124         }
125         return f12h_dc_mce(ec, xec);
126 }
127
128 static bool k8_dc_mce(u16 ec, u8 xec)
129 {
130         if (BUS_ERROR(ec)) {
131                 pr_cont("during system linefill.\n");
132                 return true;
133         }
134
135         return f10h_dc_mce(ec, xec);
136 }
137
138 static bool f14h_dc_mce(u16 ec, u8 xec)
139 {
140         u8 r4    = (ec >> 4) & 0xf;
141         u8 ll    = ec & 0x3;
142         u8 tt    = (ec >> 2) & 0x3;
143         u8 ii    = tt;
144         bool ret = true;
145
146         if (MEM_ERROR(ec)) {
147
148                 if (tt != TT_DATA || ll != LL_L1)
149                         return false;
150
151                 switch (r4) {
152                 case R4_DRD:
153                 case R4_DWR:
154                         pr_cont("Data/Tag parity error due to %s.\n",
155                                 (r4 == R4_DRD ? "load/hw prf" : "store"));
156                         break;
157                 case R4_EVICT:
158                         pr_cont("Copyback parity error on a tag miss.\n");
159                         break;
160                 case R4_SNOOP:
161                         pr_cont("Tag parity error during snoop.\n");
162                         break;
163                 default:
164                         ret = false;
165                 }
166         } else if (BUS_ERROR(ec)) {
167
168                 if ((ii != II_MEM && ii != II_IO) || ll != LL_LG)
169                         return false;
170
171                 pr_cont("System read data error on a ");
172
173                 switch (r4) {
174                 case R4_RD:
175                         pr_cont("TLB reload.\n");
176                         break;
177                 case R4_DWR:
178                         pr_cont("store.\n");
179                         break;
180                 case R4_DRD:
181                         pr_cont("load.\n");
182                         break;
183                 default:
184                         ret = false;
185                 }
186         } else {
187                 ret = false;
188         }
189
190         return ret;
191 }
192
193 static bool f15h_dc_mce(u16 ec, u8 xec)
194 {
195         bool ret = true;
196
197         if (MEM_ERROR(ec)) {
198
199                 switch (xec) {
200                 case 0x0:
201                         pr_cont("Data Array access error.\n");
202                         break;
203
204                 case 0x1:
205                         pr_cont("UC error during a linefill from L2/NB.\n");
206                         break;
207
208                 case 0x2:
209                 case 0x11:
210                         pr_cont("STQ access error.\n");
211                         break;
212
213                 case 0x3:
214                         pr_cont("SCB access error.\n");
215                         break;
216
217                 case 0x10:
218                         pr_cont("Tag error.\n");
219                         break;
220
221                 case 0x12:
222                         pr_cont("LDQ access error.\n");
223                         break;
224
225                 default:
226                         ret = false;
227                 }
228         } else if (BUS_ERROR(ec)) {
229
230                 if (!xec)
231                         pr_cont("during system linefill.\n");
232                 else
233                         pr_cont(" Internal %s condition.\n",
234                                 ((xec == 1) ? "livelock" : "deadlock"));
235         } else
236                 ret = false;
237
238         return ret;
239 }
240
241 static void amd_decode_dc_mce(struct mce *m)
242 {
243         u16 ec = m->status & 0xffff;
244         u8 xec = (m->status >> 16) & xec_mask;
245
246         pr_emerg(HW_ERR "Data Cache Error: ");
247
248         /* TLB error signatures are the same across families */
249         if (TLB_ERROR(ec)) {
250                 u8 tt = (ec >> 2) & 0x3;
251
252                 if (tt == TT_DATA) {
253                         pr_cont("%s TLB %s.\n", LL_MSG(ec),
254                                 ((xec == 2) ? "locked miss"
255                                             : (xec ? "multimatch" : "parity")));
256                         return;
257                 }
258         } else if (fam_ops->dc_mce(ec, xec))
259                 ;
260         else
261                 pr_emerg(HW_ERR "Corrupted DC MCE info?\n");
262 }
263
264 static bool k8_ic_mce(u16 ec, u8 xec)
265 {
266         u8 ll    = ec & 0x3;
267         u8 r4    = (ec >> 4) & 0xf;
268         bool ret = true;
269
270         if (!MEM_ERROR(ec))
271                 return false;
272
273         if (ll == 0x2)
274                 pr_cont("during a linefill from L2.\n");
275         else if (ll == 0x1) {
276                 switch (r4) {
277                 case R4_IRD:
278                         pr_cont("Parity error during data load.\n");
279                         break;
280
281                 case R4_EVICT:
282                         pr_cont("Copyback Parity/Victim error.\n");
283                         break;
284
285                 case R4_SNOOP:
286                         pr_cont("Tag Snoop error.\n");
287                         break;
288
289                 default:
290                         ret = false;
291                         break;
292                 }
293         } else
294                 ret = false;
295
296         return ret;
297 }
298
299 static bool f14h_ic_mce(u16 ec, u8 xec)
300 {
301         u8 ll    = ec & 0x3;
302         u8 tt    = (ec >> 2) & 0x3;
303         u8 r4  = (ec >> 4) & 0xf;
304         bool ret = true;
305
306         if (MEM_ERROR(ec)) {
307                 if (tt != 0 || ll != 1)
308                         ret = false;
309
310                 if (r4 == R4_IRD)
311                         pr_cont("Data/tag array parity error for a tag hit.\n");
312                 else if (r4 == R4_SNOOP)
313                         pr_cont("Tag error during snoop/victimization.\n");
314                 else
315                         ret = false;
316         }
317         return ret;
318 }
319
320 static bool f15h_ic_mce(u16 ec, u8 xec)
321 {
322         bool ret = true;
323
324         if (!MEM_ERROR(ec))
325                 return false;
326
327         switch (xec) {
328         case 0x0 ... 0xa:
329                 pr_cont("%s.\n", f15h_ic_mce_desc[xec]);
330                 break;
331
332         case 0xd:
333                 pr_cont("%s.\n", f15h_ic_mce_desc[xec-2]);
334                 break;
335
336         case 0x10 ... 0x14:
337                 pr_cont("Decoder %s parity error.\n", f15h_ic_mce_desc[xec-4]);
338                 break;
339
340         default:
341                 ret = false;
342         }
343         return ret;
344 }
345
346 static void amd_decode_ic_mce(struct mce *m)
347 {
348         u16 ec = m->status & 0xffff;
349         u8 xec = (m->status >> 16) & xec_mask;
350
351         pr_emerg(HW_ERR "Instruction Cache Error: ");
352
353         if (TLB_ERROR(ec))
354                 pr_cont("%s TLB %s.\n", LL_MSG(ec),
355                         (xec ? "multimatch" : "parity error"));
356         else if (BUS_ERROR(ec)) {
357                 bool k8 = (boot_cpu_data.x86 == 0xf && (m->status & BIT_64(58)));
358
359                 pr_cont("during %s.\n", (k8 ? "system linefill" : "NB data read"));
360         } else if (fam_ops->ic_mce(ec, xec))
361                 ;
362         else
363                 pr_emerg(HW_ERR "Corrupted IC MCE info?\n");
364 }
365
366 static void amd_decode_bu_mce(struct mce *m)
367 {
368         u32 ec = m->status & 0xffff;
369         u32 xec = (m->status >> 16) & xec_mask;
370
371         pr_emerg(HW_ERR "Bus Unit Error");
372
373         if (xec == 0x1)
374                 pr_cont(" in the write data buffers.\n");
375         else if (xec == 0x3)
376                 pr_cont(" in the victim data buffers.\n");
377         else if (xec == 0x2 && MEM_ERROR(ec))
378                 pr_cont(": %s error in the L2 cache tags.\n", RRRR_MSG(ec));
379         else if (xec == 0x0) {
380                 if (TLB_ERROR(ec))
381                         pr_cont(": %s error in a Page Descriptor Cache or "
382                                 "Guest TLB.\n", TT_MSG(ec));
383                 else if (BUS_ERROR(ec))
384                         pr_cont(": %s/ECC error in data read from NB: %s.\n",
385                                 RRRR_MSG(ec), PP_MSG(ec));
386                 else if (MEM_ERROR(ec)) {
387                         u8 rrrr = (ec >> 4) & 0xf;
388
389                         if (rrrr >= 0x7)
390                                 pr_cont(": %s error during data copyback.\n",
391                                         RRRR_MSG(ec));
392                         else if (rrrr <= 0x1)
393                                 pr_cont(": %s parity/ECC error during data "
394                                         "access from L2.\n", RRRR_MSG(ec));
395                         else
396                                 goto wrong_bu_mce;
397                 } else
398                         goto wrong_bu_mce;
399         } else
400                 goto wrong_bu_mce;
401
402         return;
403
404 wrong_bu_mce:
405         pr_emerg(HW_ERR "Corrupted BU MCE info?\n");
406 }
407
408 static void amd_decode_ls_mce(struct mce *m)
409 {
410         u16 ec = m->status & 0xffff;
411         u8 xec = (m->status >> 16) & xec_mask;
412
413         if (boot_cpu_data.x86 == 0x14) {
414                 pr_emerg("You shouldn't be seeing an LS MCE on this cpu family,"
415                          " please report on LKML.\n");
416                 return;
417         }
418
419         pr_emerg(HW_ERR "Load Store Error");
420
421         if (xec == 0x0) {
422                 u8 r4 = (ec >> 4) & 0xf;
423
424                 if (!BUS_ERROR(ec) || (r4 != R4_DRD && r4 != R4_DWR))
425                         goto wrong_ls_mce;
426
427                 pr_cont(" during %s.\n", RRRR_MSG(ec));
428         } else
429                 goto wrong_ls_mce;
430
431         return;
432
433 wrong_ls_mce:
434         pr_emerg(HW_ERR "Corrupted LS MCE info?\n");
435 }
436
437 static bool k8_nb_mce(u16 ec, u8 xec)
438 {
439         bool ret = true;
440
441         switch (xec) {
442         case 0x1:
443                 pr_cont("CRC error detected on HT link.\n");
444                 break;
445
446         case 0x5:
447                 pr_cont("Invalid GART PTE entry during GART table walk.\n");
448                 break;
449
450         case 0x6:
451                 pr_cont("Unsupported atomic RMW received from an IO link.\n");
452                 break;
453
454         case 0x0:
455         case 0x8:
456                 if (boot_cpu_data.x86 == 0x11)
457                         return false;
458
459                 pr_cont("DRAM ECC error detected on the NB.\n");
460                 break;
461
462         case 0xd:
463                 pr_cont("Parity error on the DRAM addr/ctl signals.\n");
464                 break;
465
466         default:
467                 ret = false;
468                 break;
469         }
470
471         return ret;
472 }
473
474 static bool f10h_nb_mce(u16 ec, u8 xec)
475 {
476         bool ret = true;
477         u8 offset = 0;
478
479         if (k8_nb_mce(ec, xec))
480                 return true;
481
482         switch(xec) {
483         case 0xa ... 0xc:
484                 offset = 10;
485                 break;
486
487         case 0xe:
488                 offset = 11;
489                 break;
490
491         case 0xf:
492                 if (TLB_ERROR(ec))
493                         pr_cont("GART Table Walk data error.\n");
494                 else if (BUS_ERROR(ec))
495                         pr_cont("DMA Exclusion Vector Table Walk error.\n");
496                 else
497                         ret = false;
498
499                 goto out;
500                 break;
501
502         case 0x1c ... 0x1f:
503                 offset = 24;
504                 break;
505
506         default:
507                 ret = false;
508
509                 goto out;
510                 break;
511         }
512
513         pr_cont("%s.\n", f10h_nb_mce_desc[xec - offset]);
514
515 out:
516         return ret;
517 }
518
519 static bool nb_noop_mce(u16 ec, u8 xec)
520 {
521         return false;
522 }
523
524 void amd_decode_nb_mce(int node_id, struct mce *m, u32 nbcfg)
525 {
526         u8 xec   = (m->status >> 16) & 0x1f;
527         u16 ec   = m->status & 0xffff;
528         u32 nbsh = (u32)(m->status >> 32);
529
530         pr_emerg(HW_ERR "Northbridge Error, node %d: ", node_id);
531
532         /*
533          * F10h, revD can disable ErrCpu[3:0] so check that first and also the
534          * value encoding has changed so interpret those differently
535          */
536         if ((boot_cpu_data.x86 == 0x10) &&
537             (boot_cpu_data.x86_model > 7)) {
538                 if (nbsh & K8_NBSH_ERR_CPU_VAL)
539                         pr_cont(", core: %u", (u8)(nbsh & nb_err_cpumask));
540         } else {
541                 u8 assoc_cpus = nbsh & nb_err_cpumask;
542
543                 if (assoc_cpus > 0)
544                         pr_cont(", core: %d", fls(assoc_cpus) - 1);
545         }
546
547         switch (xec) {
548         case 0x2:
549                 pr_cont("Sync error (sync packets on HT link detected).\n");
550                 return;
551
552         case 0x3:
553                 pr_cont("HT Master abort.\n");
554                 return;
555
556         case 0x4:
557                 pr_cont("HT Target abort.\n");
558                 return;
559
560         case 0x7:
561                 pr_cont("NB Watchdog timeout.\n");
562                 return;
563
564         case 0x9:
565                 pr_cont("SVM DMA Exclusion Vector error.\n");
566                 return;
567
568         default:
569                 break;
570         }
571
572         if (!fam_ops->nb_mce(ec, xec))
573                 goto wrong_nb_mce;
574
575         if (boot_cpu_data.x86 == 0xf || boot_cpu_data.x86 == 0x10)
576                 if ((xec == 0x8 || xec == 0x0) && nb_bus_decoder)
577                         nb_bus_decoder(node_id, m, nbcfg);
578
579         return;
580
581 wrong_nb_mce:
582         pr_emerg(HW_ERR "Corrupted NB MCE info?\n");
583 }
584 EXPORT_SYMBOL_GPL(amd_decode_nb_mce);
585
586 static void amd_decode_fr_mce(struct mce *m)
587 {
588         if (boot_cpu_data.x86 == 0xf ||
589             boot_cpu_data.x86 == 0x11)
590                 goto wrong_fr_mce;
591
592         /* we have only one error signature so match all fields at once. */
593         if ((m->status & 0xffff) == 0x0f0f) {
594                 pr_emerg(HW_ERR "FR Error: CPU Watchdog timer expire.\n");
595                 return;
596         }
597
598 wrong_fr_mce:
599         pr_emerg(HW_ERR "Corrupted FR MCE info?\n");
600 }
601
602 static inline void amd_decode_err_code(u16 ec)
603 {
604         if (TLB_ERROR(ec)) {
605                 pr_emerg(HW_ERR "Transaction: %s, Cache Level: %s\n",
606                          TT_MSG(ec), LL_MSG(ec));
607         } else if (MEM_ERROR(ec)) {
608                 pr_emerg(HW_ERR "Transaction: %s, Type: %s, Cache Level: %s\n",
609                          RRRR_MSG(ec), TT_MSG(ec), LL_MSG(ec));
610         } else if (BUS_ERROR(ec)) {
611                 pr_emerg(HW_ERR "Transaction: %s (%s), %s, Cache Level: %s, "
612                          "Participating Processor: %s\n",
613                           RRRR_MSG(ec), II_MSG(ec), TO_MSG(ec), LL_MSG(ec),
614                           PP_MSG(ec));
615         } else
616                 pr_emerg(HW_ERR "Huh? Unknown MCE error 0x%x\n", ec);
617 }
618
619 /*
620  * Filter out unwanted MCE signatures here.
621  */
622 static bool amd_filter_mce(struct mce *m)
623 {
624         u8 xec = (m->status >> 16) & 0x1f;
625
626         /*
627          * NB GART TLB error reporting is disabled by default.
628          */
629         if (m->bank == 4 && xec == 0x5 && !report_gart_errors)
630                 return true;
631
632         return false;
633 }
634
635 int amd_decode_mce(struct notifier_block *nb, unsigned long val, void *data)
636 {
637         struct mce *m = (struct mce *)data;
638         int node, ecc;
639
640         if (amd_filter_mce(m))
641                 return NOTIFY_STOP;
642
643         pr_emerg(HW_ERR "MC%d_STATUS: ", m->bank);
644
645         pr_cont("%sorrected error, other errors lost: %s, "
646                  "CPU context corrupt: %s",
647                  ((m->status & MCI_STATUS_UC) ? "Unc"  : "C"),
648                  ((m->status & MCI_STATUS_OVER) ? "yes"  : "no"),
649                  ((m->status & MCI_STATUS_PCC) ? "yes" : "no"));
650
651         /* do the two bits[14:13] together */
652         ecc = (m->status >> 45) & 0x3;
653         if (ecc)
654                 pr_cont(", %sECC Error", ((ecc == 2) ? "C" : "U"));
655
656         pr_cont("\n");
657
658         switch (m->bank) {
659         case 0:
660                 amd_decode_dc_mce(m);
661                 break;
662
663         case 1:
664                 amd_decode_ic_mce(m);
665                 break;
666
667         case 2:
668                 amd_decode_bu_mce(m);
669                 break;
670
671         case 3:
672                 amd_decode_ls_mce(m);
673                 break;
674
675         case 4:
676                 node = amd_get_nb_id(m->extcpu);
677                 amd_decode_nb_mce(node, m, 0);
678                 break;
679
680         case 5:
681                 amd_decode_fr_mce(m);
682                 break;
683
684         default:
685                 break;
686         }
687
688         amd_decode_err_code(m->status & 0xffff);
689
690         return NOTIFY_STOP;
691 }
692 EXPORT_SYMBOL_GPL(amd_decode_mce);
693
694 static struct notifier_block amd_mce_dec_nb = {
695         .notifier_call  = amd_decode_mce,
696 };
697
698 static int __init mce_amd_init(void)
699 {
700         if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD)
701                 return 0;
702
703         if ((boot_cpu_data.x86 < 0xf || boot_cpu_data.x86 > 0x12) &&
704             (boot_cpu_data.x86 != 0x14 || boot_cpu_data.x86_model > 0xf))
705                 return 0;
706
707         fam_ops = kzalloc(sizeof(struct amd_decoder_ops), GFP_KERNEL);
708         if (!fam_ops)
709                 return -ENOMEM;
710
711         switch (boot_cpu_data.x86) {
712         case 0xf:
713                 fam_ops->dc_mce = k8_dc_mce;
714                 fam_ops->ic_mce = k8_ic_mce;
715                 fam_ops->nb_mce = k8_nb_mce;
716                 break;
717
718         case 0x10:
719                 fam_ops->dc_mce = f10h_dc_mce;
720                 fam_ops->ic_mce = k8_ic_mce;
721                 fam_ops->nb_mce = f10h_nb_mce;
722                 break;
723
724         case 0x11:
725                 fam_ops->dc_mce = k8_dc_mce;
726                 fam_ops->ic_mce = k8_ic_mce;
727                 fam_ops->nb_mce = f10h_nb_mce;
728                 break;
729
730         case 0x12:
731                 fam_ops->dc_mce = f12h_dc_mce;
732                 fam_ops->ic_mce = k8_ic_mce;
733                 fam_ops->nb_mce = nb_noop_mce;
734                 break;
735
736         case 0x14:
737                 nb_err_cpumask  = 0x3;
738                 fam_ops->dc_mce = f14h_dc_mce;
739                 fam_ops->ic_mce = f14h_ic_mce;
740                 fam_ops->nb_mce = nb_noop_mce;
741                 break;
742
743         case 0x15:
744                 xec_mask = 0x1f;
745                 fam_ops->dc_mce = f15h_dc_mce;
746                 fam_ops->ic_mce = f15h_ic_mce;
747                 break;
748
749         default:
750                 printk(KERN_WARNING "Huh? What family is that: %d?!\n",
751                                     boot_cpu_data.x86);
752                 kfree(fam_ops);
753                 return -EINVAL;
754         }
755
756         pr_info("MCE: In-kernel MCE decoding enabled.\n");
757
758         atomic_notifier_chain_register(&x86_mce_decoder_chain, &amd_mce_dec_nb);
759
760         return 0;
761 }
762 early_initcall(mce_amd_init);
763
764 #ifdef MODULE
765 static void __exit mce_amd_exit(void)
766 {
767         atomic_notifier_chain_unregister(&x86_mce_decoder_chain, &amd_mce_dec_nb);
768         kfree(fam_ops);
769 }
770
771 MODULE_DESCRIPTION("AMD MCE decoder");
772 MODULE_ALIAS("edac-mce-amd");
773 MODULE_LICENSE("GPL");
774 module_exit(mce_amd_exit);
775 #endif