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);
  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 *))
  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 *))
  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 * const tt_msgs[] = { "INSN", "DATA", "GEN", "RESV" };
  43 EXPORT_SYMBOL_GPL(tt_msgs);
  44
  45 /* cache level */
  46 const char * const ll_msgs[] = { "RESV", "L1", "L2", "L3/GEN" };
  47 EXPORT_SYMBOL_GPL(ll_msgs);
  48
  49 /* memory transaction type */
  50 const char * const 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 * const pp_msgs[] = { "SRC", "RES", "OBS", "GEN" };
  57 EXPORT_SYMBOL_GPL(pp_msgs);
  58
  59 /* request timeout */
  60 const char * const to_msgs[] = { "no timeout", "timed out" };
  61 EXPORT_SYMBOL_GPL(to_msgs);
  62
  63 /* memory or i/o */
  64 const char * const ii_msgs[] = { "MEM", "RESV", "IO", "GEN" };
  65 EXPORT_SYMBOL_GPL(ii_msgs);
  66
  67 static const char * const f15h_mc1_mce_desc[] = {
  68         "UC during a demand linefill from L2",
  69         "Parity error during data load from IC",
  70         "Parity error for IC valid bit",
  71         "Main tag parity error",
  72         "Parity error in prediction queue",
  73         "PFB data/address parity error",
  74         "Parity error in the branch status reg",
  75         "PFB promotion address error",
  76         "Tag error during probe/victimization",
  77         "Parity error for IC probe tag valid bit",
  78         "PFB non-cacheable bit parity error",
  79         "PFB valid bit parity error",                   /* xec = 0xd */
  80         "Microcode Patch Buffer",                       /* xec = 010 */
  81         "uop queue",
  82         "insn buffer",
  83         "predecode buffer",
  84         "fetch address FIFO"
  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 };
 141
 142 static bool f12h_mc0_mce(u16 ec, u8 xec)
 143 {
 144         bool ret = false;
 145
 146         if (MEM_ERROR(ec)) {
 147                 u8 ll = LL(ec);
 148                 ret = true;
 149
 150                 if (ll == LL_L2)
 151                         pr_cont("during L1 linefill from L2.\n");
 152                 else if (ll == LL_L1)
 153                         pr_cont("Data/Tag %s error.\n", R4_MSG(ec));
 154                 else
 155                         ret = false;
 156         }
 157         return ret;
 158 }
 159
 160 static bool f10h_mc0_mce(u16 ec, u8 xec)
 161 {
 162         if (R4(ec) == R4_GEN && LL(ec) == LL_L1) {
 163                 pr_cont("during data scrub.\n");
 164                 return true;
 165         }
 166         return f12h_mc0_mce(ec, xec);
 167 }
 168
 169 static bool k8_mc0_mce(u16 ec, u8 xec)
 170 {
 171         if (BUS_ERROR(ec)) {
 172                 pr_cont("during system linefill.\n");
 173                 return true;
 174         }
 175
 176         return f10h_mc0_mce(ec, xec);
 177 }
 178
 179 static bool f14h_mc0_mce(u16 ec, u8 xec)
 180 {
 181         u8 r4    = R4(ec);
 182         bool ret = true;
 183
 184         if (MEM_ERROR(ec)) {
 185
 186                 if (TT(ec) != TT_DATA || LL(ec) != LL_L1)
 187                         return false;
 188
 189                 switch (r4) {
 190                 case R4_DRD:
 191                 case R4_DWR:
 192                         pr_cont("Data/Tag parity error due to %s.\n",
 193                                 (r4 == R4_DRD ? "load/hw prf" : "store"));
 194                         break;
 195                 case R4_EVICT:
 196                         pr_cont("Copyback parity error on a tag miss.\n");
 197                         break;
 198                 case R4_SNOOP:
 199                         pr_cont("Tag parity error during snoop.\n");
 200                         break;
 201                 default:
 202                         ret = false;
 203                 }
 204         } else if (BUS_ERROR(ec)) {
 205
 206                 if ((II(ec) != II_MEM && II(ec) != II_IO) || LL(ec) != LL_LG)
 207                         return false;
 208
 209                 pr_cont("System read data error on a ");
 210
 211                 switch (r4) {
 212                 case R4_RD:
 213                         pr_cont("TLB reload.\n");
 214                         break;
 215                 case R4_DWR:
 216                         pr_cont("store.\n");
 217                         break;
 218                 case R4_DRD:
 219                         pr_cont("load.\n");
 220                         break;
 221                 default:
 222                         ret = false;
 223                 }
 224         } else {
 225                 ret = false;
 226         }
 227
 228         return ret;
 229 }
 230
 231 static bool f15h_mc0_mce(u16 ec, u8 xec)
 232 {
 233         bool ret = true;
 234
 235         if (MEM_ERROR(ec)) {
 236
 237                 switch (xec) {
 238                 case 0x0:
 239                         pr_cont("Data Array access error.\n");
 240                         break;
 241
 242                 case 0x1:
 243                         pr_cont("UC error during a linefill from L2/NB.\n");
 244                         break;
 245
 246                 case 0x2:
 247                 case 0x11:
 248                         pr_cont("STQ access error.\n");
 249                         break;
 250
 251                 case 0x3:
 252                         pr_cont("SCB access error.\n");
 253                         break;
 254
 255                 case 0x10:
 256                         pr_cont("Tag error.\n");
 257                         break;
 258
 259                 case 0x12:
 260                         pr_cont("LDQ access error.\n");
 261                         break;
 262
 263                 default:
 264                         ret = false;
 265                 }
 266         } else if (BUS_ERROR(ec)) {
 267
 268                 if (!xec)
 269                         pr_cont("System Read Data Error.\n");
 270                 else
 271                         pr_cont(" Internal error condition type %d.\n", xec);
 272         } else
 273                 ret = false;
 274
 275         return ret;
 276 }
 277
 278 static void decode_mc0_mce(struct mce *m)
 279 {
 280         u16 ec = EC(m->status);
 281         u8 xec = XEC(m->status, xec_mask);
 282
 283         pr_emerg(HW_ERR "MC0 Error: ");
 284
 285         /* TLB error signatures are the same across families */
 286         if (TLB_ERROR(ec)) {
 287                 if (TT(ec) == TT_DATA) {
 288                         pr_cont("%s TLB %s.\n", LL_MSG(ec),
 289                                 ((xec == 2) ? "locked miss"
 290                                             : (xec ? "multimatch" : "parity")));
 291                         return;
 292                 }
 293         } else if (fam_ops->mc0_mce(ec, xec))
 294                 ;
 295         else
 296                 pr_emerg(HW_ERR "Corrupted MC0 MCE info?\n");
 297 }
 298
 299 static bool k8_mc1_mce(u16 ec, u8 xec)
 300 {
 301         u8 ll    = LL(ec);
 302         bool ret = true;
 303
 304         if (!MEM_ERROR(ec))
 305                 return false;
 306
 307         if (ll == 0x2)
 308                 pr_cont("during a linefill from L2.\n");
 309         else if (ll == 0x1) {
 310                 switch (R4(ec)) {
 311                 case R4_IRD:
 312                         pr_cont("Parity error during data load.\n");
 313                         break;
 314
 315                 case R4_EVICT:
 316                         pr_cont("Copyback Parity/Victim error.\n");
 317                         break;
 318
 319                 case R4_SNOOP:
 320                         pr_cont("Tag Snoop error.\n");
 321                         break;
 322
 323                 default:
 324                         ret = false;
 325                         break;
 326                 }
 327         } else
 328                 ret = false;
 329
 330         return ret;
 331 }
 332
 333 static bool f14h_mc1_mce(u16 ec, u8 xec)
 334 {
 335         u8 r4    = R4(ec);
 336         bool ret = true;
 337
 338         if (MEM_ERROR(ec)) {
 339                 if (TT(ec) != 0 || LL(ec) != 1)
 340                         ret = false;
 341
 342                 if (r4 == R4_IRD)
 343                         pr_cont("Data/tag array parity error for a tag hit.\n");
 344                 else if (r4 == R4_SNOOP)
 345                         pr_cont("Tag error during snoop/victimization.\n");
 346                 else
 347                         ret = false;
 348         }
 349         return ret;
 350 }
 351
 352 static bool f15h_mc1_mce(u16 ec, u8 xec)
 353 {
 354         bool ret = true;
 355
 356         if (!MEM_ERROR(ec))
 357                 return false;
 358
 359         switch (xec) {
 360         case 0x0 ... 0xa:
 361                 pr_cont("%s.\n", f15h_mc1_mce_desc[xec]);
 362                 break;
 363
 364         case 0xd:
 365                 pr_cont("%s.\n", f15h_mc1_mce_desc[xec-2]);
 366                 break;
 367
 368         case 0x10:
 369                 pr_cont("%s.\n", f15h_mc1_mce_desc[xec-4]);
 370                 break;
 371
 372         case 0x11 ... 0x14:
 373                 pr_cont("Decoder %s parity error.\n", f15h_mc1_mce_desc[xec-4]);
 374                 break;
 375
 376         default:
 377                 ret = false;
 378         }
 379         return ret;
 380 }
 381
 382 static void decode_mc1_mce(struct mce *m)
 383 {
 384         u16 ec = EC(m->status);
 385         u8 xec = XEC(m->status, xec_mask);
 386
 387         pr_emerg(HW_ERR "MC1 Error: ");
 388
 389         if (TLB_ERROR(ec))
 390                 pr_cont("%s TLB %s.\n", LL_MSG(ec),
 391                         (xec ? "multimatch" : "parity error"));
 392         else if (BUS_ERROR(ec)) {
 393                 bool k8 = (boot_cpu_data.x86 == 0xf && (m->status & BIT_64(58)));
 394
 395                 pr_cont("during %s.\n", (k8 ? "system linefill" : "NB data read"));
 396         } else if (fam_ops->mc1_mce(ec, xec))
 397                 ;
 398         else
 399                 pr_emerg(HW_ERR "Corrupted MC1 MCE info?\n");
 400 }
 401
 402 static bool k8_mc2_mce(u16 ec, u8 xec)
 403 {
 404         bool ret = true;
 405
 406         if (xec == 0x1)
 407                 pr_cont(" in the write data buffers.\n");
 408         else if (xec == 0x3)
 409                 pr_cont(" in the victim data buffers.\n");
 410         else if (xec == 0x2 && MEM_ERROR(ec))
 411                 pr_cont(": %s error in the L2 cache tags.\n", R4_MSG(ec));
 412         else if (xec == 0x0) {
 413                 if (TLB_ERROR(ec))
 414                         pr_cont(": %s error in a Page Descriptor Cache or "
 415                                 "Guest TLB.\n", TT_MSG(ec));
 416                 else if (BUS_ERROR(ec))
 417                         pr_cont(": %s/ECC error in data read from NB: %s.\n",
 418                                 R4_MSG(ec), PP_MSG(ec));
 419                 else if (MEM_ERROR(ec)) {
 420                         u8 r4 = R4(ec);
 421
 422                         if (r4 >= 0x7)
 423                                 pr_cont(": %s error during data copyback.\n",
 424                                         R4_MSG(ec));
 425                         else if (r4 <= 0x1)
 426                                 pr_cont(": %s parity/ECC error during data "
 427                                         "access from L2.\n", R4_MSG(ec));
 428                         else
 429                                 ret = false;
 430                 } else
 431                         ret = false;
 432         } else
 433                 ret = false;
 434
 435         return ret;
 436 }
 437
 438 static bool f15h_mc2_mce(u16 ec, u8 xec)
 439 {
 440         bool ret = true;
 441
 442         if (TLB_ERROR(ec)) {
 443                 if (xec == 0x0)
 444                         pr_cont("Data parity TLB read error.\n");
 445                 else if (xec == 0x1)
 446                         pr_cont("Poison data provided for TLB fill.\n");
 447                 else
 448                         ret = false;
 449         } else if (BUS_ERROR(ec)) {
 450                 if (xec > 2)
 451                         ret = false;
 452
 453                 pr_cont("Error during attempted NB data read.\n");
 454         } else if (MEM_ERROR(ec)) {
 455                 switch (xec) {
 456                 case 0x4 ... 0xc:
 457                         pr_cont("%s.\n", f15h_mc2_mce_desc[xec - 0x4]);
 458                         break;
 459
 460                 case 0x10 ... 0x14:
 461                         pr_cont("%s.\n", f15h_mc2_mce_desc[xec - 0x7]);
 462                         break;
 463
 464                 default:
 465                         ret = false;
 466                 }
 467         }
 468
 469         return ret;
 470 }
 471
 472 static void decode_mc2_mce(struct mce *m)
 473 {
 474         u16 ec = EC(m->status);
 475         u8 xec = XEC(m->status, xec_mask);
 476
 477         pr_emerg(HW_ERR "MC2 Error: ");
 478
 479         if (!fam_ops->mc2_mce(ec, xec))
 480                 pr_cont(HW_ERR "Corrupted MC2 MCE info?\n");
 481 }
 482
 483 static void decode_mc3_mce(struct mce *m)
 484 {
 485         u16 ec = EC(m->status);
 486         u8 xec = XEC(m->status, xec_mask);
 487
 488         if (boot_cpu_data.x86 >= 0x14) {
 489                 pr_emerg("You shouldn't be seeing MC3 MCE on this cpu family,"
 490                          " please report on LKML.\n");
 491                 return;
 492         }
 493
 494         pr_emerg(HW_ERR "MC3 Error");
 495
 496         if (xec == 0x0) {
 497                 u8 r4 = R4(ec);
 498
 499                 if (!BUS_ERROR(ec) || (r4 != R4_DRD && r4 != R4_DWR))
 500                         goto wrong_mc3_mce;
 501
 502                 pr_cont(" during %s.\n", R4_MSG(ec));
 503         } else
 504                 goto wrong_mc3_mce;
 505
 506         return;
 507
 508  wrong_mc3_mce:
 509         pr_emerg(HW_ERR "Corrupted MC3 MCE info?\n");
 510 }
 511
 512 static void decode_mc4_mce(struct mce *m)
 513 {
 514         struct cpuinfo_x86 *c = &boot_cpu_data;
 515         int node_id = amd_get_nb_id(m->extcpu);
 516         u16 ec = EC(m->status);
 517         u8 xec = XEC(m->status, 0x1f);
 518         u8 offset = 0;
 519
 520         pr_emerg(HW_ERR "MC4 Error (node %d): ", node_id);
 521
 522         switch (xec) {
 523         case 0x0 ... 0xe:
 524
 525                 /* special handling for DRAM ECCs */
 526                 if (xec == 0x0 || xec == 0x8) {
 527                         /* no ECCs on F11h */
 528                         if (c->x86 == 0x11)
 529                                 goto wrong_mc4_mce;
 530
 531                         pr_cont("%s.\n", mc4_mce_desc[xec]);
 532
 533                         if (nb_bus_decoder)
 534                                 nb_bus_decoder(node_id, m);
 535                         return;
 536                 }
 537                 break;
 538
 539         case 0xf:
 540                 if (TLB_ERROR(ec))
 541                         pr_cont("GART Table Walk data error.\n");
 542                 else if (BUS_ERROR(ec))
 543                         pr_cont("DMA Exclusion Vector Table Walk error.\n");
 544                 else
 545                         goto wrong_mc4_mce;
 546                 return;
 547
 548         case 0x19:
 549                 if (boot_cpu_data.x86 == 0x15)
 550                         pr_cont("Compute Unit Data Error.\n");
 551                 else
 552                         goto wrong_mc4_mce;
 553                 return;
 554
 555         case 0x1c ... 0x1f:
 556                 offset = 13;
 557                 break;
 558
 559         default:
 560                 goto wrong_mc4_mce;
 561         }
 562
 563         pr_cont("%s.\n", mc4_mce_desc[xec - offset]);
 564         return;
 565
 566  wrong_mc4_mce:
 567         pr_emerg(HW_ERR "Corrupted MC4 MCE info?\n");
 568 }
 569
 570 static void decode_mc5_mce(struct mce *m)
 571 {
 572         struct cpuinfo_x86 *c = &boot_cpu_data;
 573         u8 xec = XEC(m->status, xec_mask);
 574
 575         if (c->x86 == 0xf || c->x86 == 0x11)
 576                 goto wrong_mc5_mce;
 577
 578         pr_emerg(HW_ERR "MC5 Error: ");
 579
 580         if (xec == 0x0 || xec == 0xc)
 581                 pr_cont("%s.\n", mc5_mce_desc[xec]);
 582         else if (xec < 0xd)
 583                 pr_cont("%s parity error.\n", mc5_mce_desc[xec]);
 584         else
 585                 goto wrong_mc5_mce;
 586
 587         return;
 588
 589  wrong_mc5_mce:
 590         pr_emerg(HW_ERR "Corrupted MC5 MCE info?\n");
 591 }
 592
 593 static void decode_mc6_mce(struct mce *m)
 594 {
 595         u8 xec = XEC(m->status, xec_mask);
 596
 597         pr_emerg(HW_ERR "MC6 Error: ");
 598
 599         switch (xec) {
 600         case 0x1:
 601                 pr_cont("Free List");
 602                 break;
 603
 604         case 0x2:
 605                 pr_cont("Physical Register File");
 606                 break;
 607
 608         case 0x3:
 609                 pr_cont("Retire Queue");
 610                 break;
 611
 612         case 0x4:
 613                 pr_cont("Scheduler table");
 614                 break;
 615
 616         case 0x5:
 617                 pr_cont("Status Register File");
 618                 break;
 619
 620         default:
 621                 goto wrong_mc6_mce;
 622                 break;
 623         }
 624
 625         pr_cont(" parity error.\n");
 626
 627         return;
 628
 629  wrong_mc6_mce:
 630         pr_emerg(HW_ERR "Corrupted MC6 MCE info?\n");
 631 }
 632
 633 static inline void amd_decode_err_code(u16 ec)
 634 {
 635
 636         pr_emerg(HW_ERR "cache level: %s", LL_MSG(ec));
 637
 638         if (BUS_ERROR(ec))
 639                 pr_cont(", mem/io: %s", II_MSG(ec));
 640         else
 641                 pr_cont(", tx: %s", TT_MSG(ec));
 642
 643         if (MEM_ERROR(ec) || BUS_ERROR(ec)) {
 644                 pr_cont(", mem-tx: %s", R4_MSG(ec));
 645
 646                 if (BUS_ERROR(ec))
 647                         pr_cont(", part-proc: %s (%s)", PP_MSG(ec), TO_MSG(ec));
 648         }
 649
 650         pr_cont("\n");
 651 }
 652
 653 /*
 654  * Filter out unwanted MCE signatures here.
 655  */
 656 static bool amd_filter_mce(struct mce *m)
 657 {
 658         u8 xec = (m->status >> 16) & 0x1f;
 659
 660         /*
 661          * NB GART TLB error reporting is disabled by default.
 662          */
 663         if (m->bank == 4 && xec == 0x5 && !report_gart_errors)
 664                 return true;
 665
 666         return false;
 667 }
 668
 669 static const char *decode_error_status(struct mce *m)
 670 {
 671         if (m->status & MCI_STATUS_UC) {
 672                 if (m->status & MCI_STATUS_PCC)
 673                         return "System Fatal error.";
 674                 if (m->mcgstatus & MCG_STATUS_RIPV)
 675                         return "Uncorrected, software restartable error.";
 676                 return "Uncorrected, software containable error.";
 677         }
 678
 679         if (m->status & MCI_STATUS_DEFERRED)
 680                 return "Deferred error.";
 681
 682         return "Corrected error, no action required.";
 683 }
 684
 685 int amd_decode_mce(struct notifier_block *nb, unsigned long val, void *data)
 686 {
 687         struct mce *m = (struct mce *)data;
 688         struct cpuinfo_x86 *c = &cpu_data(m->extcpu);
 689         int ecc;
 690
 691         if (amd_filter_mce(m))
 692                 return NOTIFY_STOP;
 693
 694         switch (m->bank) {
 695         case 0:
 696                 decode_mc0_mce(m);
 697                 break;
 698
 699         case 1:
 700                 decode_mc1_mce(m);
 701                 break;
 702
 703         case 2:
 704                 decode_mc2_mce(m);
 705                 break;
 706
 707         case 3:
 708                 decode_mc3_mce(m);
 709                 break;
 710
 711         case 4:
 712                 decode_mc4_mce(m);
 713                 break;
 714
 715         case 5:
 716                 decode_mc5_mce(m);
 717                 break;
 718
 719         case 6:
 720                 decode_mc6_mce(m);
 721                 break;
 722
 723         default:
 724                 break;
 725         }
 726
 727         pr_emerg(HW_ERR "Error Status: %s\n", decode_error_status(m));
 728
 729         pr_emerg(HW_ERR "CPU:%d (%x:%x:%x) MC%d_STATUS[%s|%s|%s|%s|%s",
 730                 m->extcpu,
 731                 c->x86, c->x86_model, c->x86_mask,
 732                 m->bank,
 733                 ((m->status & MCI_STATUS_OVER)  ? "Over"  : "-"),
 734                 ((m->status & MCI_STATUS_UC)    ? "UE"    : "CE"),
 735                 ((m->status & MCI_STATUS_MISCV) ? "MiscV" : "-"),
 736                 ((m->status & MCI_STATUS_PCC)   ? "PCC"   : "-"),
 737                 ((m->status & MCI_STATUS_ADDRV) ? "AddrV" : "-"));
 738
 739         if (c->x86 == 0x15)
 740                 pr_cont("|%s|%s",
 741                         ((m->status & MCI_STATUS_DEFERRED) ? "Deferred" : "-"),
 742                         ((m->status & MCI_STATUS_POISON)   ? "Poison"   : "-"));
 743
 744         /* do the two bits[14:13] together */
 745         ecc = (m->status >> 45) & 0x3;
 746         if (ecc)
 747                 pr_cont("|%sECC", ((ecc == 2) ? "C" : "U"));
 748
 749         pr_cont("]: 0x%016llx\n", m->status);
 750
 751         if (m->status & MCI_STATUS_ADDRV)
 752                 pr_emerg(HW_ERR "MC%d_ADDR: 0x%016llx\n", m->bank, m->addr);
 753
 754         amd_decode_err_code(m->status & 0xffff);
 755
 756         return NOTIFY_STOP;
 757 }
 758 EXPORT_SYMBOL_GPL(amd_decode_mce);
 759
 760 static struct notifier_block amd_mce_dec_nb = {
 761         .notifier_call  = amd_decode_mce,
 762 };
 763
 764 static int __init mce_amd_init(void)
 765 {
 766         struct cpuinfo_x86 *c = &boot_cpu_data;
 767
 768         if (c->x86_vendor != X86_VENDOR_AMD)
 769                 return 0;
 770
 771         if (c->x86 < 0xf || c->x86 > 0x15)
 772                 return 0;
 773
 774         fam_ops = kzalloc(sizeof(struct amd_decoder_ops), GFP_KERNEL);
 775         if (!fam_ops)
 776                 return -ENOMEM;
 777
 778         switch (c->x86) {
 779         case 0xf:
 780                 fam_ops->mc0_mce = k8_mc0_mce;
 781                 fam_ops->mc1_mce = k8_mc1_mce;
 782                 fam_ops->mc2_mce = k8_mc2_mce;
 783                 break;
 784
 785         case 0x10:
 786                 fam_ops->mc0_mce = f10h_mc0_mce;
 787                 fam_ops->mc1_mce = k8_mc1_mce;
 788                 fam_ops->mc2_mce = k8_mc2_mce;
 789                 break;
 790
 791         case 0x11:
 792                 fam_ops->mc0_mce = k8_mc0_mce;
 793                 fam_ops->mc1_mce = k8_mc1_mce;
 794                 fam_ops->mc2_mce = k8_mc2_mce;
 795                 break;
 796
 797         case 0x12:
 798                 fam_ops->mc0_mce = f12h_mc0_mce;
 799                 fam_ops->mc1_mce = k8_mc1_mce;
 800                 fam_ops->mc2_mce = k8_mc2_mce;
 801                 break;
 802
 803         case 0x14:
 804                 nb_err_cpumask  = 0x3;
 805                 fam_ops->mc0_mce = f14h_mc0_mce;
 806                 fam_ops->mc1_mce = f14h_mc1_mce;
 807                 fam_ops->mc2_mce = k8_mc2_mce;
 808                 break;
 809
 810         case 0x15:
 811                 xec_mask = 0x1f;
 812                 fam_ops->mc0_mce = f15h_mc0_mce;
 813                 fam_ops->mc1_mce = f15h_mc1_mce;
 814                 fam_ops->mc2_mce = f15h_mc2_mce;
 815                 break;
 816
 817         default:
 818                 printk(KERN_WARNING "Huh? What family is it: 0x%x?!\n", c->x86);
 819                 kfree(fam_ops);
 820                 return -EINVAL;
 821         }
 822
 823         pr_info("MCE: In-kernel MCE decoding enabled.\n");
 824
 825         mce_register_decode_chain(&amd_mce_dec_nb);
 826
 827         return 0;
 828 }
 829 early_initcall(mce_amd_init);
 830
 831 #ifdef MODULE
 832 static void __exit mce_amd_exit(void)
 833 {
 834         mce_unregister_decode_chain(&amd_mce_dec_nb);
 835         kfree(fam_ops);
 836 }
 837
 838 MODULE_DESCRIPTION("AMD MCE decoder");
 839 MODULE_ALIAS("edac-mce-amd");
 840 MODULE_LICENSE("GPL");
 841 module_exit(mce_amd_exit);
 842 #endif