drivers/edac/mce_amd.c

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