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