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