drivers/edac/amd64_edac.c

   1 #include "amd64_edac.h"
   2 #include <asm/amd_nb.h>
   3
   4 static struct edac_pci_ctl_info *pci_ctl;
   5
   6 static int report_gart_errors;
   7 module_param(report_gart_errors, int, 0644);
   8
   9 /*
  10  * Set by command line parameter. If BIOS has enabled the ECC, this override is
  11  * cleared to prevent re-enabling the hardware by this driver.
  12  */
  13 static int ecc_enable_override;
  14 module_param(ecc_enable_override, int, 0644);
  15
  16 static struct msr __percpu *msrs;
  17
  18 /* Per-node stuff */
  19 static struct ecc_settings **ecc_stngs;
  20
  21 /*
  22  * Valid scrub rates for the K8 hardware memory scrubber. We map the scrubbing
  23  * bandwidth to a valid bit pattern. The 'set' operation finds the 'matching-
  24  * or higher value'.
  25  *
  26  *FIXME: Produce a better mapping/linearisation.
  27  */
  28 static const struct scrubrate {
  29        u32 scrubval;           /* bit pattern for scrub rate */
  30        u32 bandwidth;          /* bandwidth consumed (bytes/sec) */
  31 } scrubrates[] = {
  32         { 0x01, 1600000000UL},
  33         { 0x02, 800000000UL},
  34         { 0x03, 400000000UL},
  35         { 0x04, 200000000UL},
  36         { 0x05, 100000000UL},
  37         { 0x06, 50000000UL},
  38         { 0x07, 25000000UL},
  39         { 0x08, 12284069UL},
  40         { 0x09, 6274509UL},
  41         { 0x0A, 3121951UL},
  42         { 0x0B, 1560975UL},
  43         { 0x0C, 781440UL},
  44         { 0x0D, 390720UL},
  45         { 0x0E, 195300UL},
  46         { 0x0F, 97650UL},
  47         { 0x10, 48854UL},
  48         { 0x11, 24427UL},
  49         { 0x12, 12213UL},
  50         { 0x13, 6101UL},
  51         { 0x14, 3051UL},
  52         { 0x15, 1523UL},
  53         { 0x16, 761UL},
  54         { 0x00, 0UL},        /* scrubbing off */
  55 };
  56
  57 int __amd64_read_pci_cfg_dword(struct pci_dev *pdev, int offset,
  58                                u32 *val, const char *func)
  59 {
  60         int err = 0;
  61
  62         err = pci_read_config_dword(pdev, offset, val);
  63         if (err)
  64                 amd64_warn("%s: error reading F%dx%03x.\n",
  65                            func, PCI_FUNC(pdev->devfn), offset);
  66
  67         return err;
  68 }
  69
  70 int __amd64_write_pci_cfg_dword(struct pci_dev *pdev, int offset,
  71                                 u32 val, const char *func)
  72 {
  73         int err = 0;
  74
  75         err = pci_write_config_dword(pdev, offset, val);
  76         if (err)
  77                 amd64_warn("%s: error writing to F%dx%03x.\n",
  78                            func, PCI_FUNC(pdev->devfn), offset);
  79
  80         return err;
  81 }
  82
  83 /*
  84  * Select DCT to which PCI cfg accesses are routed
  85  */
  86 static void f15h_select_dct(struct amd64_pvt *pvt, u8 dct)
  87 {
  88         u32 reg = 0;
  89
  90         amd64_read_pci_cfg(pvt->F1, DCT_CFG_SEL, &reg);
  91         reg &= (pvt->model == 0x30) ? ~3 : ~1;
  92         reg |= dct;
  93         amd64_write_pci_cfg(pvt->F1, DCT_CFG_SEL, reg);
  94 }
  95
  96 /*
  97  *
  98  * Depending on the family, F2 DCT reads need special handling:
  99  *
 100  * K8: has a single DCT only and no address offsets >= 0x100
 101  *
 102  * F10h: each DCT has its own set of regs
 103  *      DCT0 -> F2x040..
 104  *      DCT1 -> F2x140..
 105  *
 106  * F16h: has only 1 DCT
 107  *
 108  * F15h: we select which DCT we access using F1x10C[DctCfgSel]
 109  */
 110 static inline int amd64_read_dct_pci_cfg(struct amd64_pvt *pvt, u8 dct,
 111                                          int offset, u32 *val)
 112 {
 113         switch (pvt->fam) {
 114         case 0xf:
 115                 if (dct || offset >= 0x100)
 116                         return -EINVAL;
 117                 break;
 118
 119         case 0x10:
 120                 if (dct) {
 121                         /*
 122                          * Note: If ganging is enabled, barring the regs
 123                          * F2x[1,0]98 and F2x[1,0]9C; reads reads to F2x1xx
 124                          * return 0. (cf. Section 2.8.1 F10h BKDG)
 125                          */
 126                         if (dct_ganging_enabled(pvt))
 127                                 return 0;
 128
 129                         offset += 0x100;
 130                 }
 131                 break;
 132
 133         case 0x15:
 134                 /*
 135                  * F15h: F2x1xx addresses do not map explicitly to DCT1.
 136                  * We should select which DCT we access using F1x10C[DctCfgSel]
 137                  */
 138                 dct = (dct && pvt->model == 0x30) ? 3 : dct;
 139                 f15h_select_dct(pvt, dct);
 140                 break;
 141
 142         case 0x16:
 143                 if (dct)
 144                         return -EINVAL;
 145                 break;
 146
 147         default:
 148                 break;
 149         }
 150         return amd64_read_pci_cfg(pvt->F2, offset, val);
 151 }
 152
 153 /*
 154  * Memory scrubber control interface. For K8, memory scrubbing is handled by
 155  * hardware and can involve L2 cache, dcache as well as the main memory. With
 156  * F10, this is extended to L3 cache scrubbing on CPU models sporting that
 157  * functionality.
 158  *
 159  * This causes the "units" for the scrubbing speed to vary from 64 byte blocks
 160  * (dram) over to cache lines. This is nasty, so we will use bandwidth in
 161  * bytes/sec for the setting.
 162  *
 163  * Currently, we only do dram scrubbing. If the scrubbing is done in software on
 164  * other archs, we might not have access to the caches directly.
 165  */
 166
 167 static inline void __f17h_set_scrubval(struct amd64_pvt *pvt, u32 scrubval)
 168 {
 169         /*
 170          * Fam17h supports scrub values between 0x5 and 0x14. Also, the values
 171          * are shifted down by 0x5, so scrubval 0x5 is written to the register
 172          * as 0x0, scrubval 0x6 as 0x1, etc.
 173          */
 174         if (scrubval >= 0x5 && scrubval <= 0x14) {
 175                 scrubval -= 0x5;
 176                 pci_write_bits32(pvt->F6, F17H_SCR_LIMIT_ADDR, scrubval, 0xF);
 177                 pci_write_bits32(pvt->F6, F17H_SCR_BASE_ADDR, 1, 0x1);
 178         } else {
 179                 pci_write_bits32(pvt->F6, F17H_SCR_BASE_ADDR, 0, 0x1);
 180         }
 181 }
 182 /*
 183  * Scan the scrub rate mapping table for a close or matching bandwidth value to
 184  * issue. If requested is too big, then use last maximum value found.
 185  */
 186 static int __set_scrub_rate(struct amd64_pvt *pvt, u32 new_bw, u32 min_rate)
 187 {
 188         u32 scrubval;
 189         int i;
 190
 191         /*
 192          * map the configured rate (new_bw) to a value specific to the AMD64
 193          * memory controller and apply to register. Search for the first
 194          * bandwidth entry that is greater or equal than the setting requested
 195          * and program that. If at last entry, turn off DRAM scrubbing.
 196          *
 197          * If no suitable bandwidth is found, turn off DRAM scrubbing entirely
 198          * by falling back to the last element in scrubrates[].
 199          */
 200         for (i = 0; i < ARRAY_SIZE(scrubrates) - 1; i++) {
 201                 /*
 202                  * skip scrub rates which aren't recommended
 203                  * (see F10 BKDG, F3x58)
 204                  */
 205                 if (scrubrates[i].scrubval < min_rate)
 206                         continue;
 207
 208                 if (scrubrates[i].bandwidth <= new_bw)
 209                         break;
 210         }
 211
 212         scrubval = scrubrates[i].scrubval;
 213
 214         if (pvt->fam == 0x17 || pvt->fam == 0x18) {
 215                 __f17h_set_scrubval(pvt, scrubval);
 216         } else if (pvt->fam == 0x15 && pvt->model == 0x60) {
 217                 f15h_select_dct(pvt, 0);
 218                 pci_write_bits32(pvt->F2, F15H_M60H_SCRCTRL, scrubval, 0x001F);
 219                 f15h_select_dct(pvt, 1);
 220                 pci_write_bits32(pvt->F2, F15H_M60H_SCRCTRL, scrubval, 0x001F);
 221         } else {
 222                 pci_write_bits32(pvt->F3, SCRCTRL, scrubval, 0x001F);
 223         }
 224
 225         if (scrubval)
 226                 return scrubrates[i].bandwidth;
 227
 228         return 0;
 229 }
 230
 231 static int set_scrub_rate(struct mem_ctl_info *mci, u32 bw)
 232 {
 233         struct amd64_pvt *pvt = mci->pvt_info;
 234         u32 min_scrubrate = 0x5;
 235
 236         if (pvt->fam == 0xf)
 237                 min_scrubrate = 0x0;
 238
 239         if (pvt->fam == 0x15) {
 240                 /* Erratum #505 */
 241                 if (pvt->model < 0x10)
 242                         f15h_select_dct(pvt, 0);
 243
 244                 if (pvt->model == 0x60)
 245                         min_scrubrate = 0x6;
 246         }
 247         return __set_scrub_rate(pvt, bw, min_scrubrate);
 248 }
 249
 250 static int get_scrub_rate(struct mem_ctl_info *mci)
 251 {
 252         struct amd64_pvt *pvt = mci->pvt_info;
 253         int i, retval = -EINVAL;
 254         u32 scrubval = 0;
 255
 256         switch (pvt->fam) {
 257         case 0x15:
 258                 /* Erratum #505 */
 259                 if (pvt->model < 0x10)
 260                         f15h_select_dct(pvt, 0);
 261
 262                 if (pvt->model == 0x60)
 263                         amd64_read_pci_cfg(pvt->F2, F15H_M60H_SCRCTRL, &scrubval);
 264                 break;
 265
 266         case 0x17:
 267         case 0x18:
 268                 amd64_read_pci_cfg(pvt->F6, F17H_SCR_BASE_ADDR, &scrubval);
 269                 if (scrubval & BIT(0)) {
 270                         amd64_read_pci_cfg(pvt->F6, F17H_SCR_LIMIT_ADDR, &scrubval);
 271                         scrubval &= 0xF;
 272                         scrubval += 0x5;
 273                 } else {
 274                         scrubval = 0;
 275                 }
 276                 break;
 277
 278         default:
 279                 amd64_read_pci_cfg(pvt->F3, SCRCTRL, &scrubval);
 280                 break;
 281         }
 282
 283         scrubval = scrubval & 0x001F;
 284
 285         for (i = 0; i < ARRAY_SIZE(scrubrates); i++) {
 286                 if (scrubrates[i].scrubval == scrubval) {
 287                         retval = scrubrates[i].bandwidth;
 288                         break;
 289                 }
 290         }
 291         return retval;
 292 }
 293
 294 /*
 295  * returns true if the SysAddr given by sys_addr matches the
 296  * DRAM base/limit associated with node_id
 297  */
 298 static bool base_limit_match(struct amd64_pvt *pvt, u64 sys_addr, u8 nid)
 299 {
 300         u64 addr;
 301
 302         /* The K8 treats this as a 40-bit value.  However, bits 63-40 will be
 303          * all ones if the most significant implemented address bit is 1.
 304          * Here we discard bits 63-40.  See section 3.4.2 of AMD publication
 305          * 24592: AMD x86-64 Architecture Programmer's Manual Volume 1
 306          * Application Programming.
 307          */
 308         addr = sys_addr & 0x000000ffffffffffull;
 309
 310         return ((addr >= get_dram_base(pvt, nid)) &&
 311                 (addr <= get_dram_limit(pvt, nid)));
 312 }
 313
 314 /*
 315  * Attempt to map a SysAddr to a node. On success, return a pointer to the
 316  * mem_ctl_info structure for the node that the SysAddr maps to.
 317  *
 318  * On failure, return NULL.
 319  */
 320 static struct mem_ctl_info *find_mc_by_sys_addr(struct mem_ctl_info *mci,
 321                                                 u64 sys_addr)
 322 {
 323         struct amd64_pvt *pvt;
 324         u8 node_id;
 325         u32 intlv_en, bits;
 326
 327         /*
 328          * Here we use the DRAM Base (section 3.4.4.1) and DRAM Limit (section
 329          * 3.4.4.2) registers to map the SysAddr to a node ID.
 330          */
 331         pvt = mci->pvt_info;
 332
 333         /*
 334          * The value of this field should be the same for all DRAM Base
 335          * registers.  Therefore we arbitrarily choose to read it from the
 336          * register for node 0.
 337          */
 338         intlv_en = dram_intlv_en(pvt, 0);
 339
 340         if (intlv_en == 0) {
 341                 for (node_id = 0; node_id < DRAM_RANGES; node_id++) {
 342                         if (base_limit_match(pvt, sys_addr, node_id))
 343                                 goto found;
 344                 }
 345                 goto err_no_match;
 346         }
 347
 348         if (unlikely((intlv_en != 0x01) &&
 349                      (intlv_en != 0x03) &&
 350                      (intlv_en != 0x07))) {
 351                 amd64_warn("DRAM Base[IntlvEn] junk value: 0x%x, BIOS bug?\n", intlv_en);
 352                 return NULL;
 353         }
 354
 355         bits = (((u32) sys_addr) >> 12) & intlv_en;
 356
 357         for (node_id = 0; ; ) {
 358                 if ((dram_intlv_sel(pvt, node_id) & intlv_en) == bits)
 359                         break;  /* intlv_sel field matches */
 360
 361                 if (++node_id >= DRAM_RANGES)
 362                         goto err_no_match;
 363         }
 364
 365         /* sanity test for sys_addr */
 366         if (unlikely(!base_limit_match(pvt, sys_addr, node_id))) {
 367                 amd64_warn("%s: sys_addr 0x%llx falls outside base/limit address"
 368                            "range for node %d with node interleaving enabled.\n",
 369                            __func__, sys_addr, node_id);
 370                 return NULL;
 371         }
 372
 373 found:
 374         return edac_mc_find((int)node_id);
 375
 376 err_no_match:
 377         edac_dbg(2, "sys_addr 0x%lx doesn't match any node\n",
 378                  (unsigned long)sys_addr);
 379
 380         return NULL;
 381 }
 382
 383 /*
 384  * compute the CS base address of the @csrow on the DRAM controller @dct.
 385  * For details see F2x[5C:40] in the processor's BKDG
 386  */
 387 static void get_cs_base_and_mask(struct amd64_pvt *pvt, int csrow, u8 dct,
 388                                  u64 *base, u64 *mask)
 389 {
 390         u64 csbase, csmask, base_bits, mask_bits;
 391         u8 addr_shift;
 392
 393         if (pvt->fam == 0xf && pvt->ext_model < K8_REV_F) {
 394                 csbase          = pvt->csels[dct].csbases[csrow];
 395                 csmask          = pvt->csels[dct].csmasks[csrow];
 396                 base_bits       = GENMASK_ULL(31, 21) | GENMASK_ULL(15, 9);
 397                 mask_bits       = GENMASK_ULL(29, 21) | GENMASK_ULL(15, 9);
 398                 addr_shift      = 4;
 399
 400         /*
 401          * F16h and F15h, models 30h and later need two addr_shift values:
 402          * 8 for high and 6 for low (cf. F16h BKDG).
 403          */
 404         } else if (pvt->fam == 0x16 ||
 405                   (pvt->fam == 0x15 && pvt->model >= 0x30)) {
 406                 csbase          = pvt->csels[dct].csbases[csrow];
 407                 csmask          = pvt->csels[dct].csmasks[csrow >> 1];
 408
 409                 *base  = (csbase & GENMASK_ULL(15,  5)) << 6;
 410                 *base |= (csbase & GENMASK_ULL(30, 19)) << 8;
 411
 412                 *mask = ~0ULL;
 413                 /* poke holes for the csmask */
 414                 *mask &= ~((GENMASK_ULL(15, 5)  << 6) |
 415                            (GENMASK_ULL(30, 19) << 8));
 416
 417                 *mask |= (csmask & GENMASK_ULL(15, 5))  << 6;
 418                 *mask |= (csmask & GENMASK_ULL(30, 19)) << 8;
 419
 420                 return;
 421         } else {
 422                 csbase          = pvt->csels[dct].csbases[csrow];
 423                 csmask          = pvt->csels[dct].csmasks[csrow >> 1];
 424                 addr_shift      = 8;
 425
 426                 if (pvt->fam == 0x15)
 427                         base_bits = mask_bits =
 428                                 GENMASK_ULL(30,19) | GENMASK_ULL(13,5);
 429                 else
 430                         base_bits = mask_bits =
 431                                 GENMASK_ULL(28,19) | GENMASK_ULL(13,5);
 432         }
 433
 434         *base  = (csbase & base_bits) << addr_shift;
 435
 436         *mask  = ~0ULL;
 437         /* poke holes for the csmask */
 438         *mask &= ~(mask_bits << addr_shift);
 439         /* OR them in */
 440         *mask |= (csmask & mask_bits) << addr_shift;
 441 }
 442
 443 #define for_each_chip_select(i, dct, pvt) \
 444         for (i = 0; i < pvt->csels[dct].b_cnt; i++)
 445
 446 #define chip_select_base(i, dct, pvt) \
 447         pvt->csels[dct].csbases[i]
 448
 449 #define for_each_chip_select_mask(i, dct, pvt) \
 450         for (i = 0; i < pvt->csels[dct].m_cnt; i++)
 451
 452 /*
 453  * @input_addr is an InputAddr associated with the node given by mci. Return the
 454  * csrow that input_addr maps to, or -1 on failure (no csrow claims input_addr).
 455  */
 456 static int input_addr_to_csrow(struct mem_ctl_info *mci, u64 input_addr)
 457 {
 458         struct amd64_pvt *pvt;
 459         int csrow;
 460         u64 base, mask;
 461
 462         pvt = mci->pvt_info;
 463
 464         for_each_chip_select(csrow, 0, pvt) {
 465                 if (!csrow_enabled(csrow, 0, pvt))
 466                         continue;
 467
 468                 get_cs_base_and_mask(pvt, csrow, 0, &base, &mask);
 469
 470                 mask = ~mask;
 471
 472                 if ((input_addr & mask) == (base & mask)) {
 473                         edac_dbg(2, "InputAddr 0x%lx matches csrow %d (node %d)\n",
 474                                  (unsigned long)input_addr, csrow,
 475                                  pvt->mc_node_id);
 476
 477                         return csrow;
 478                 }
 479         }
 480         edac_dbg(2, "no matching csrow for InputAddr 0x%lx (MC node %d)\n",
 481                  (unsigned long)input_addr, pvt->mc_node_id);
 482
 483         return -1;
 484 }
 485
 486 /*
 487  * Obtain info from the DRAM Hole Address Register (section 3.4.8, pub #26094)
 488  * for the node represented by mci. Info is passed back in *hole_base,
 489  * *hole_offset, and *hole_size.  Function returns 0 if info is valid or 1 if
 490  * info is invalid. Info may be invalid for either of the following reasons:
 491  *
 492  * - The revision of the node is not E or greater.  In this case, the DRAM Hole
 493  *   Address Register does not exist.
 494  *
 495  * - The DramHoleValid bit is cleared in the DRAM Hole Address Register,
 496  *   indicating that its contents are not valid.
 497  *
 498  * The values passed back in *hole_base, *hole_offset, and *hole_size are
 499  * complete 32-bit values despite the fact that the bitfields in the DHAR
 500  * only represent bits 31-24 of the base and offset values.
 501  */
 502 int amd64_get_dram_hole_info(struct mem_ctl_info *mci, u64 *hole_base,
 503                              u64 *hole_offset, u64 *hole_size)
 504 {
 505         struct amd64_pvt *pvt = mci->pvt_info;
 506
 507         /* only revE and later have the DRAM Hole Address Register */
 508         if (pvt->fam == 0xf && pvt->ext_model < K8_REV_E) {
 509                 edac_dbg(1, "  revision %d for node %d does not support DHAR\n",
 510                          pvt->ext_model, pvt->mc_node_id);
 511                 return 1;
 512         }
 513
 514         /* valid for Fam10h and above */
 515         if (pvt->fam >= 0x10 && !dhar_mem_hoist_valid(pvt)) {
 516                 edac_dbg(1, "  Dram Memory Hoisting is DISABLED on this system\n");
 517                 return 1;
 518         }
 519
 520         if (!dhar_valid(pvt)) {
 521                 edac_dbg(1, "  Dram Memory Hoisting is DISABLED on this node %d\n",
 522                          pvt->mc_node_id);
 523                 return 1;
 524         }
 525
 526         /* This node has Memory Hoisting */
 527
 528         /* +------------------+--------------------+--------------------+-----
 529          * | memory           | DRAM hole          | relocated          |
 530          * | [0, (x - 1)]     | [x, 0xffffffff]    | addresses from     |
 531          * |                  |                    | DRAM hole          |
 532          * |                  |                    | [0x100000000,      |
 533          * |                  |                    |  (0x100000000+     |
 534          * |                  |                    |   (0xffffffff-x))] |
 535          * +------------------+--------------------+--------------------+-----
 536          *
 537          * Above is a diagram of physical memory showing the DRAM hole and the
 538          * relocated addresses from the DRAM hole.  As shown, the DRAM hole
 539          * starts at address x (the base address) and extends through address
 540          * 0xffffffff.  The DRAM Hole Address Register (DHAR) relocates the
 541          * addresses in the hole so that they start at 0x100000000.
 542          */
 543
 544         *hole_base = dhar_base(pvt);
 545         *hole_size = (1ULL << 32) - *hole_base;
 546
 547         *hole_offset = (pvt->fam > 0xf) ? f10_dhar_offset(pvt)
 548                                         : k8_dhar_offset(pvt);
 549
 550         edac_dbg(1, "  DHAR info for node %d base 0x%lx offset 0x%lx size 0x%lx\n",
 551                  pvt->mc_node_id, (unsigned long)*hole_base,
 552                  (unsigned long)*hole_offset, (unsigned long)*hole_size);
 553
 554         return 0;
 555 }
 556 EXPORT_SYMBOL_GPL(amd64_get_dram_hole_info);
 557
 558 /*
 559  * Return the DramAddr that the SysAddr given by @sys_addr maps to.  It is
 560  * assumed that sys_addr maps to the node given by mci.
 561  *
 562  * The first part of section 3.4.4 (p. 70) shows how the DRAM Base (section
 563  * 3.4.4.1) and DRAM Limit (section 3.4.4.2) registers are used to translate a
 564  * SysAddr to a DramAddr. If the DRAM Hole Address Register (DHAR) is enabled,
 565  * then it is also involved in translating a SysAddr to a DramAddr. Sections
 566  * 3.4.8 and 3.5.8.2 describe the DHAR and how it is used for memory hoisting.
 567  * These parts of the documentation are unclear. I interpret them as follows:
 568  *
 569  * When node n receives a SysAddr, it processes the SysAddr as follows:
 570  *
 571  * 1. It extracts the DRAMBase and DRAMLimit values from the DRAM Base and DRAM
 572  *    Limit registers for node n. If the SysAddr is not within the range
 573  *    specified by the base and limit values, then node n ignores the Sysaddr
 574  *    (since it does not map to node n). Otherwise continue to step 2 below.
 575  *
 576  * 2. If the DramHoleValid bit of the DHAR for node n is clear, the DHAR is
 577  *    disabled so skip to step 3 below. Otherwise see if the SysAddr is within
 578  *    the range of relocated addresses (starting at 0x100000000) from the DRAM
 579  *    hole. If not, skip to step 3 below. Else get the value of the
 580  *    DramHoleOffset field from the DHAR. To obtain the DramAddr, subtract the
 581  *    offset defined by this value from the SysAddr.
 582  *
 583  * 3. Obtain the base address for node n from the DRAMBase field of the DRAM
 584  *    Base register for node n. To obtain the DramAddr, subtract the base
 585  *    address from the SysAddr, as shown near the start of section 3.4.4 (p.70).
 586  */
 587 static u64 sys_addr_to_dram_addr(struct mem_ctl_info *mci, u64 sys_addr)
 588 {
 589         struct amd64_pvt *pvt = mci->pvt_info;
 590         u64 dram_base, hole_base, hole_offset, hole_size, dram_addr;
 591         int ret;
 592
 593         dram_base = get_dram_base(pvt, pvt->mc_node_id);
 594
 595         ret = amd64_get_dram_hole_info(mci, &hole_base, &hole_offset,
 596                                       &hole_size);
 597         if (!ret) {
 598                 if ((sys_addr >= (1ULL << 32)) &&
 599                     (sys_addr < ((1ULL << 32) + hole_size))) {
 600                         /* use DHAR to translate SysAddr to DramAddr */
 601                         dram_addr = sys_addr - hole_offset;
 602
 603                         edac_dbg(2, "using DHAR to translate SysAddr 0x%lx to DramAddr 0x%lx\n",
 604                                  (unsigned long)sys_addr,
 605                                  (unsigned long)dram_addr);
 606
 607                         return dram_addr;
 608                 }
 609         }
 610
 611         /*
 612          * Translate the SysAddr to a DramAddr as shown near the start of
 613          * section 3.4.4 (p. 70).  Although sys_addr is a 64-bit value, the k8
 614          * only deals with 40-bit values.  Therefore we discard bits 63-40 of
 615          * sys_addr below.  If bit 39 of sys_addr is 1 then the bits we
 616          * discard are all 1s.  Otherwise the bits we discard are all 0s.  See
 617          * section 3.4.2 of AMD publication 24592: AMD x86-64 Architecture
 618          * Programmer's Manual Volume 1 Application Programming.
 619          */
 620         dram_addr = (sys_addr & GENMASK_ULL(39, 0)) - dram_base;
 621
 622         edac_dbg(2, "using DRAM Base register to translate SysAddr 0x%lx to DramAddr 0x%lx\n",
 623                  (unsigned long)sys_addr, (unsigned long)dram_addr);
 624         return dram_addr;
 625 }
 626
 627 /*
 628  * @intlv_en is the value of the IntlvEn field from a DRAM Base register
 629  * (section 3.4.4.1).  Return the number of bits from a SysAddr that are used
 630  * for node interleaving.
 631  */
 632 static int num_node_interleave_bits(unsigned intlv_en)
 633 {
 634         static const int intlv_shift_table[] = { 0, 1, 0, 2, 0, 0, 0, 3 };
 635         int n;
 636
 637         BUG_ON(intlv_en > 7);
 638         n = intlv_shift_table[intlv_en];
 639         return n;
 640 }
 641
 642 /* Translate the DramAddr given by @dram_addr to an InputAddr. */
 643 static u64 dram_addr_to_input_addr(struct mem_ctl_info *mci, u64 dram_addr)
 644 {
 645         struct amd64_pvt *pvt;
 646         int intlv_shift;
 647         u64 input_addr;
 648
 649         pvt = mci->pvt_info;
 650
 651         /*
 652          * See the start of section 3.4.4 (p. 70, BKDG #26094, K8, revA-E)
 653          * concerning translating a DramAddr to an InputAddr.
 654          */
 655         intlv_shift = num_node_interleave_bits(dram_intlv_en(pvt, 0));
 656         input_addr = ((dram_addr >> intlv_shift) & GENMASK_ULL(35, 12)) +
 657                       (dram_addr & 0xfff);
 658
 659         edac_dbg(2, "  Intlv Shift=%d DramAddr=0x%lx maps to InputAddr=0x%lx\n",
 660                  intlv_shift, (unsigned long)dram_addr,
 661                  (unsigned long)input_addr);
 662
 663         return input_addr;
 664 }
 665
 666 /*
 667  * Translate the SysAddr represented by @sys_addr to an InputAddr.  It is
 668  * assumed that @sys_addr maps to the node given by mci.
 669  */
 670 static u64 sys_addr_to_input_addr(struct mem_ctl_info *mci, u64 sys_addr)
 671 {
 672         u64 input_addr;
 673
 674         input_addr =
 675             dram_addr_to_input_addr(mci, sys_addr_to_dram_addr(mci, sys_addr));
 676
 677         edac_dbg(2, "SysAddr 0x%lx translates to InputAddr 0x%lx\n",
 678                  (unsigned long)sys_addr, (unsigned long)input_addr);
 679
 680         return input_addr;
 681 }
 682
 683 /* Map the Error address to a PAGE and PAGE OFFSET. */
 684 static inline void error_address_to_page_and_offset(u64 error_address,
 685                                                     struct err_info *err)
 686 {
 687         err->page = (u32) (error_address >> PAGE_SHIFT);
 688         err->offset = ((u32) error_address) & ~PAGE_MASK;
 689 }
 690
 691 /*
 692  * @sys_addr is an error address (a SysAddr) extracted from the MCA NB Address
 693  * Low (section 3.6.4.5) and MCA NB Address High (section 3.6.4.6) registers
 694  * of a node that detected an ECC memory error.  mci represents the node that
 695  * the error address maps to (possibly different from the node that detected
 696  * the error).  Return the number of the csrow that sys_addr maps to, or -1 on
 697  * error.
 698  */
 699 static int sys_addr_to_csrow(struct mem_ctl_info *mci, u64 sys_addr)
 700 {
 701         int csrow;
 702
 703         csrow = input_addr_to_csrow(mci, sys_addr_to_input_addr(mci, sys_addr));
 704
 705         if (csrow == -1)
 706                 amd64_mc_err(mci, "Failed to translate InputAddr to csrow for "
 707                                   "address 0x%lx\n", (unsigned long)sys_addr);
 708         return csrow;
 709 }
 710
 711 static int get_channel_from_ecc_syndrome(struct mem_ctl_info *, u16);
 712
 713 /*
 714  * Determine if the DIMMs have ECC enabled. ECC is enabled ONLY if all the DIMMs
 715  * are ECC capable.
 716  */
 717 static unsigned long determine_edac_cap(struct amd64_pvt *pvt)
 718 {
 719         unsigned long edac_cap = EDAC_FLAG_NONE;
 720         u8 bit;
 721
 722         if (pvt->umc) {
 723                 u8 i, umc_en_mask = 0, dimm_ecc_en_mask = 0;
 724
 725                 for (i = 0; i < NUM_UMCS; i++) {
 726                         if (!(pvt->umc[i].sdp_ctrl & UMC_SDP_INIT))
 727                                 continue;
 728
 729                         umc_en_mask |= BIT(i);
 730
 731                         /* UMC Configuration bit 12 (DimmEccEn) */
 732                         if (pvt->umc[i].umc_cfg & BIT(12))
 733                                 dimm_ecc_en_mask |= BIT(i);
 734                 }
 735
 736                 if (umc_en_mask == dimm_ecc_en_mask)
 737                         edac_cap = EDAC_FLAG_SECDED;
 738         } else {
 739                 bit = (pvt->fam > 0xf || pvt->ext_model >= K8_REV_F)
 740                         ? 19
 741                         : 17;
 742
 743                 if (pvt->dclr0 & BIT(bit))
 744                         edac_cap = EDAC_FLAG_SECDED;
 745         }
 746
 747         return edac_cap;
 748 }
 749
 750 static void debug_display_dimm_sizes(struct amd64_pvt *, u8);
 751
 752 static void debug_dump_dramcfg_low(struct amd64_pvt *pvt, u32 dclr, int chan)
 753 {
 754         edac_dbg(1, "F2x%d90 (DRAM Cfg Low): 0x%08x\n", chan, dclr);
 755
 756         if (pvt->dram_type == MEM_LRDDR3) {
 757                 u32 dcsm = pvt->csels[chan].csmasks[0];
 758                 /*
 759                  * It's assumed all LRDIMMs in a DCT are going to be of
 760                  * same 'type' until proven otherwise. So, use a cs
 761                  * value of '0' here to get dcsm value.
 762                  */
 763                 edac_dbg(1, " LRDIMM %dx rank multiply\n", (dcsm & 0x3));
 764         }
 765
 766         edac_dbg(1, "All DIMMs support ECC:%s\n",
 767                     (dclr & BIT(19)) ? "yes" : "no");
 768
 769
 770         edac_dbg(1, "  PAR/ERR parity: %s\n",
 771                  (dclr & BIT(8)) ?  "enabled" : "disabled");
 772
 773         if (pvt->fam == 0x10)
 774                 edac_dbg(1, "  DCT 128bit mode width: %s\n",
 775                          (dclr & BIT(11)) ?  "128b" : "64b");
 776
 777         edac_dbg(1, "  x4 logical DIMMs present: L0: %s L1: %s L2: %s L3: %s\n",
 778                  (dclr & BIT(12)) ?  "yes" : "no",
 779                  (dclr & BIT(13)) ?  "yes" : "no",
 780                  (dclr & BIT(14)) ?  "yes" : "no",
 781                  (dclr & BIT(15)) ?  "yes" : "no");
 782 }
 783
 784 static void debug_display_dimm_sizes_df(struct amd64_pvt *pvt, u8 ctrl)
 785 {
 786         int dimm, size0, size1, cs0, cs1;
 787
 788         edac_printk(KERN_DEBUG, EDAC_MC, "UMC%d chip selects:\n", ctrl);
 789
 790         for (dimm = 0; dimm < 4; dimm++) {
 791                 size0 = 0;
 792                 cs0 = dimm * 2;
 793
 794                 if (csrow_enabled(cs0, ctrl, pvt))
 795                         size0 = pvt->ops->dbam_to_cs(pvt, ctrl, 0, cs0);
 796
 797                 size1 = 0;
 798                 cs1 = dimm * 2 + 1;
 799
 800                 if (csrow_enabled(cs1, ctrl, pvt))
 801                         size1 = pvt->ops->dbam_to_cs(pvt, ctrl, 0, cs1);
 802
 803                 amd64_info(EDAC_MC ": %d: %5dMB %d: %5dMB\n",
 804                                 cs0,    size0,
 805                                 cs1,    size1);
 806         }
 807 }
 808
 809 static void __dump_misc_regs_df(struct amd64_pvt *pvt)
 810 {
 811         struct amd64_umc *umc;
 812         u32 i, tmp, umc_base;
 813
 814         for (i = 0; i < NUM_UMCS; i++) {
 815                 umc_base = get_umc_base(i);
 816                 umc = &pvt->umc[i];
 817
 818                 edac_dbg(1, "UMC%d DIMM cfg: 0x%x\n", i, umc->dimm_cfg);
 819                 edac_dbg(1, "UMC%d UMC cfg: 0x%x\n", i, umc->umc_cfg);
 820                 edac_dbg(1, "UMC%d SDP ctrl: 0x%x\n", i, umc->sdp_ctrl);
 821                 edac_dbg(1, "UMC%d ECC ctrl: 0x%x\n", i, umc->ecc_ctrl);
 822
 823                 amd_smn_read(pvt->mc_node_id, umc_base + UMCCH_ECC_BAD_SYMBOL, &tmp);
 824                 edac_dbg(1, "UMC%d ECC bad symbol: 0x%x\n", i, tmp);
 825
 826                 amd_smn_read(pvt->mc_node_id, umc_base + UMCCH_UMC_CAP, &tmp);
 827                 edac_dbg(1, "UMC%d UMC cap: 0x%x\n", i, tmp);
 828                 edac_dbg(1, "UMC%d UMC cap high: 0x%x\n", i, umc->umc_cap_hi);
 829
 830                 edac_dbg(1, "UMC%d ECC capable: %s, ChipKill ECC capable: %s\n",
 831                                 i, (umc->umc_cap_hi & BIT(30)) ? "yes" : "no",
 832                                     (umc->umc_cap_hi & BIT(31)) ? "yes" : "no");
 833                 edac_dbg(1, "UMC%d All DIMMs support ECC: %s\n",
 834                                 i, (umc->umc_cfg & BIT(12)) ? "yes" : "no");
 835                 edac_dbg(1, "UMC%d x4 DIMMs present: %s\n",
 836                                 i, (umc->dimm_cfg & BIT(6)) ? "yes" : "no");
 837                 edac_dbg(1, "UMC%d x16 DIMMs present: %s\n",
 838                                 i, (umc->dimm_cfg & BIT(7)) ? "yes" : "no");
 839
 840                 if (pvt->dram_type == MEM_LRDDR4) {
 841                         amd_smn_read(pvt->mc_node_id, umc_base + UMCCH_ADDR_CFG, &tmp);
 842                         edac_dbg(1, "UMC%d LRDIMM %dx rank multiply\n",
 843                                         i, 1 << ((tmp >> 4) & 0x3));
 844                 }
 845
 846                 debug_display_dimm_sizes_df(pvt, i);
 847         }
 848
 849         edac_dbg(1, "F0x104 (DRAM Hole Address): 0x%08x, base: 0x%08x\n",
 850                  pvt->dhar, dhar_base(pvt));
 851 }
 852
 853 /* Display and decode various NB registers for debug purposes. */
 854 static void __dump_misc_regs(struct amd64_pvt *pvt)
 855 {
 856         edac_dbg(1, "F3xE8 (NB Cap): 0x%08x\n", pvt->nbcap);
 857
 858         edac_dbg(1, "  NB two channel DRAM capable: %s\n",
 859                  (pvt->nbcap & NBCAP_DCT_DUAL) ? "yes" : "no");
 860
 861         edac_dbg(1, "  ECC capable: %s, ChipKill ECC capable: %s\n",
 862                  (pvt->nbcap & NBCAP_SECDED) ? "yes" : "no",
 863                  (pvt->nbcap & NBCAP_CHIPKILL) ? "yes" : "no");
 864
 865         debug_dump_dramcfg_low(pvt, pvt->dclr0, 0);
 866
 867         edac_dbg(1, "F3xB0 (Online Spare): 0x%08x\n", pvt->online_spare);
 868
 869         edac_dbg(1, "F1xF0 (DRAM Hole Address): 0x%08x, base: 0x%08x, offset: 0x%08x\n",
 870                  pvt->dhar, dhar_base(pvt),
 871                  (pvt->fam == 0xf) ? k8_dhar_offset(pvt)
 872                                    : f10_dhar_offset(pvt));
 873
 874         debug_display_dimm_sizes(pvt, 0);
 875
 876         /* everything below this point is Fam10h and above */
 877         if (pvt->fam == 0xf)
 878                 return;
 879
 880         debug_display_dimm_sizes(pvt, 1);
 881
 882         /* Only if NOT ganged does dclr1 have valid info */
 883         if (!dct_ganging_enabled(pvt))
 884                 debug_dump_dramcfg_low(pvt, pvt->dclr1, 1);
 885 }
 886
 887 /* Display and decode various NB registers for debug purposes. */
 888 static void dump_misc_regs(struct amd64_pvt *pvt)
 889 {
 890         if (pvt->umc)
 891                 __dump_misc_regs_df(pvt);
 892         else
 893                 __dump_misc_regs(pvt);
 894
 895         edac_dbg(1, "  DramHoleValid: %s\n", dhar_valid(pvt) ? "yes" : "no");
 896
 897         amd64_info("using %s syndromes.\n",
 898                         ((pvt->ecc_sym_sz == 8) ? "x8" : "x4"));
 899 }
 900
 901 /*
 902  * See BKDG, F2x[1,0][5C:40], F2[1,0][6C:60]
 903  */
 904 static void prep_chip_selects(struct amd64_pvt *pvt)
 905 {
 906         if (pvt->fam == 0xf && pvt->ext_model < K8_REV_F) {
 907                 pvt->csels[0].b_cnt = pvt->csels[1].b_cnt = 8;
 908                 pvt->csels[0].m_cnt = pvt->csels[1].m_cnt = 8;
 909         } else if (pvt->fam == 0x15 && pvt->model == 0x30) {
 910                 pvt->csels[0].b_cnt = pvt->csels[1].b_cnt = 4;
 911                 pvt->csels[0].m_cnt = pvt->csels[1].m_cnt = 2;
 912         } else {
 913                 pvt->csels[0].b_cnt = pvt->csels[1].b_cnt = 8;
 914                 pvt->csels[0].m_cnt = pvt->csels[1].m_cnt = 4;
 915         }
 916 }
 917
 918 /*
 919  * Function 2 Offset F10_DCSB0; read in the DCS Base and DCS Mask registers
 920  */
 921 static void read_dct_base_mask(struct amd64_pvt *pvt)
 922 {
 923         int base_reg0, base_reg1, mask_reg0, mask_reg1, cs;
 924
 925         prep_chip_selects(pvt);
 926
 927         if (pvt->umc) {
 928                 base_reg0 = get_umc_base(0) + UMCCH_BASE_ADDR;
 929                 base_reg1 = get_umc_base(1) + UMCCH_BASE_ADDR;
 930                 mask_reg0 = get_umc_base(0) + UMCCH_ADDR_MASK;
 931                 mask_reg1 = get_umc_base(1) + UMCCH_ADDR_MASK;
 932         } else {
 933                 base_reg0 = DCSB0;
 934                 base_reg1 = DCSB1;
 935                 mask_reg0 = DCSM0;
 936                 mask_reg1 = DCSM1;
 937         }
 938
 939         for_each_chip_select(cs, 0, pvt) {
 940                 int reg0   = base_reg0 + (cs * 4);
 941                 int reg1   = base_reg1 + (cs * 4);
 942                 u32 *base0 = &pvt->csels[0].csbases[cs];
 943                 u32 *base1 = &pvt->csels[1].csbases[cs];
 944
 945                 if (pvt->umc) {
 946                         if (!amd_smn_read(pvt->mc_node_id, reg0, base0))
 947                                 edac_dbg(0, "  DCSB0[%d]=0x%08x reg: 0x%x\n",
 948                                          cs, *base0, reg0);
 949
 950                         if (!amd_smn_read(pvt->mc_node_id, reg1, base1))
 951                                 edac_dbg(0, "  DCSB1[%d]=0x%08x reg: 0x%x\n",
 952                                          cs, *base1, reg1);
 953                 } else {
 954                         if (!amd64_read_dct_pci_cfg(pvt, 0, reg0, base0))
 955                                 edac_dbg(0, "  DCSB0[%d]=0x%08x reg: F2x%x\n",
 956                                          cs, *base0, reg0);
 957
 958                         if (pvt->fam == 0xf)
 959                                 continue;
 960
 961                         if (!amd64_read_dct_pci_cfg(pvt, 1, reg0, base1))
 962                                 edac_dbg(0, "  DCSB1[%d]=0x%08x reg: F2x%x\n",
 963                                          cs, *base1, (pvt->fam == 0x10) ? reg1
 964                                                                 : reg0);
 965                 }
 966         }
 967
 968         for_each_chip_select_mask(cs, 0, pvt) {
 969                 int reg0   = mask_reg0 + (cs * 4);
 970                 int reg1   = mask_reg1 + (cs * 4);
 971                 u32 *mask0 = &pvt->csels[0].csmasks[cs];
 972                 u32 *mask1 = &pvt->csels[1].csmasks[cs];
 973
 974                 if (pvt->umc) {
 975                         if (!amd_smn_read(pvt->mc_node_id, reg0, mask0))
 976                                 edac_dbg(0, "    DCSM0[%d]=0x%08x reg: 0x%x\n",
 977                                          cs, *mask0, reg0);
 978
 979                         if (!amd_smn_read(pvt->mc_node_id, reg1, mask1))
 980                                 edac_dbg(0, "    DCSM1[%d]=0x%08x reg: 0x%x\n",
 981                                          cs, *mask1, reg1);
 982                 } else {
 983                         if (!amd64_read_dct_pci_cfg(pvt, 0, reg0, mask0))
 984                                 edac_dbg(0, "    DCSM0[%d]=0x%08x reg: F2x%x\n",
 985                                          cs, *mask0, reg0);
 986
 987                         if (pvt->fam == 0xf)
 988                                 continue;
 989
 990                         if (!amd64_read_dct_pci_cfg(pvt, 1, reg0, mask1))
 991                                 edac_dbg(0, "    DCSM1[%d]=0x%08x reg: F2x%x\n",
 992                                          cs, *mask1, (pvt->fam == 0x10) ? reg1
 993                                                                 : reg0);
 994                 }
 995         }
 996 }
 997
 998 static void determine_memory_type(struct amd64_pvt *pvt)
 999 {
1000         u32 dram_ctrl, dcsm;
1001
1002         switch (pvt->fam) {
1003         case 0xf:
1004                 if (pvt->ext_model >= K8_REV_F)
1005                         goto ddr3;
1006
1007                 pvt->dram_type = (pvt->dclr0 & BIT(18)) ? MEM_DDR : MEM_RDDR;
1008                 return;
1009
1010         case 0x10:
1011                 if (pvt->dchr0 & DDR3_MODE)
1012                         goto ddr3;
1013
1014                 pvt->dram_type = (pvt->dclr0 & BIT(16)) ? MEM_DDR2 : MEM_RDDR2;
1015                 return;
1016
1017         case 0x15:
1018                 if (pvt->model < 0x60)
1019                         goto ddr3;
1020
1021                 /*
1022                  * Model 0x60h needs special handling:
1023                  *
1024                  * We use a Chip Select value of '0' to obtain dcsm.
1025                  * Theoretically, it is possible to populate LRDIMMs of different
1026                  * 'Rank' value on a DCT. But this is not the common case. So,
1027                  * it's reasonable to assume all DIMMs are going to be of same
1028                  * 'type' until proven otherwise.
1029                  */
1030                 amd64_read_dct_pci_cfg(pvt, 0, DRAM_CONTROL, &dram_ctrl);
1031                 dcsm = pvt->csels[0].csmasks[0];
1032
1033                 if (((dram_ctrl >> 8) & 0x7) == 0x2)
1034                         pvt->dram_type = MEM_DDR4;
1035                 else if (pvt->dclr0 & BIT(16))
1036                         pvt->dram_type = MEM_DDR3;
1037                 else if (dcsm & 0x3)
1038                         pvt->dram_type = MEM_LRDDR3;
1039                 else
1040                         pvt->dram_type = MEM_RDDR3;
1041
1042                 return;
1043
1044         case 0x16:
1045                 goto ddr3;
1046
1047         case 0x17:
1048         case 0x18:
1049                 if ((pvt->umc[0].dimm_cfg | pvt->umc[1].dimm_cfg) & BIT(5))
1050                         pvt->dram_type = MEM_LRDDR4;
1051                 else if ((pvt->umc[0].dimm_cfg | pvt->umc[1].dimm_cfg) & BIT(4))
1052                         pvt->dram_type = MEM_RDDR4;
1053                 else
1054                         pvt->dram_type = MEM_DDR4;
1055                 return;
1056
1057         default:
1058                 WARN(1, KERN_ERR "%s: Family??? 0x%x\n", __func__, pvt->fam);
1059                 pvt->dram_type = MEM_EMPTY;
1060         }
1061         return;
1062
1063 ddr3:
1064         pvt->dram_type = (pvt->dclr0 & BIT(16)) ? MEM_DDR3 : MEM_RDDR3;
1065 }
1066
1067 /* Get the number of DCT channels the memory controller is using. */
1068 static int k8_early_channel_count(struct amd64_pvt *pvt)
1069 {
1070         int flag;
1071
1072         if (pvt->ext_model >= K8_REV_F)
1073                 /* RevF (NPT) and later */
1074                 flag = pvt->dclr0 & WIDTH_128;
1075         else
1076                 /* RevE and earlier */
1077                 flag = pvt->dclr0 & REVE_WIDTH_128;
1078
1079         /* not used */
1080         pvt->dclr1 = 0;
1081
1082         return (flag) ? 2 : 1;
1083 }
1084
1085 /* On F10h and later ErrAddr is MC4_ADDR[47:1] */
1086 static u64 get_error_address(struct amd64_pvt *pvt, struct mce *m)
1087 {
1088         u16 mce_nid = amd_get_nb_id(m->extcpu);
1089         struct mem_ctl_info *mci;
1090         u8 start_bit = 1;
1091         u8 end_bit   = 47;
1092         u64 addr;
1093
1094         mci = edac_mc_find(mce_nid);
1095         if (!mci)
1096                 return 0;
1097
1098         pvt = mci->pvt_info;
1099
1100         if (pvt->fam == 0xf) {
1101                 start_bit = 3;
1102                 end_bit   = 39;
1103         }
1104
1105         addr = m->addr & GENMASK_ULL(end_bit, start_bit);
1106
1107         /*
1108          * Erratum 637 workaround
1109          */
1110         if (pvt->fam == 0x15) {
1111                 u64 cc6_base, tmp_addr;
1112                 u32 tmp;
1113                 u8 intlv_en;
1114
1115                 if ((addr & GENMASK_ULL(47, 24)) >> 24 != 0x00fdf7)
1116                         return addr;
1117
1118
1119                 amd64_read_pci_cfg(pvt->F1, DRAM_LOCAL_NODE_LIM, &tmp);
1120                 intlv_en = tmp >> 21 & 0x7;
1121
1122                 /* add [47:27] + 3 trailing bits */
1123                 cc6_base  = (tmp & GENMASK_ULL(20, 0)) << 3;
1124
1125                 /* reverse and add DramIntlvEn */
1126                 cc6_base |= intlv_en ^ 0x7;
1127
1128                 /* pin at [47:24] */
1129                 cc6_base <<= 24;
1130
1131                 if (!intlv_en)
1132                         return cc6_base | (addr & GENMASK_ULL(23, 0));
1133
1134                 amd64_read_pci_cfg(pvt->F1, DRAM_LOCAL_NODE_BASE, &tmp);
1135
1136                                                         /* faster log2 */
1137                 tmp_addr  = (addr & GENMASK_ULL(23, 12)) << __fls(intlv_en + 1);
1138
1139                 /* OR DramIntlvSel into bits [14:12] */
1140                 tmp_addr |= (tmp & GENMASK_ULL(23, 21)) >> 9;
1141
1142                 /* add remaining [11:0] bits from original MC4_ADDR */
1143                 tmp_addr |= addr & GENMASK_ULL(11, 0);
1144
1145                 return cc6_base | tmp_addr;
1146         }
1147
1148         return addr;
1149 }
1150
1151 static struct pci_dev *pci_get_related_function(unsigned int vendor,
1152                                                 unsigned int device,
1153                                                 struct pci_dev *related)
1154 {
1155         struct pci_dev *dev = NULL;
1156
1157         while ((dev = pci_get_device(vendor, device, dev))) {
1158                 if (pci_domain_nr(dev->bus) == pci_domain_nr(related->bus) &&
1159                     (dev->bus->number == related->bus->number) &&
1160                     (PCI_SLOT(dev->devfn) == PCI_SLOT(related->devfn)))
1161                         break;
1162         }
1163
1164         return dev;
1165 }
1166
1167 static void read_dram_base_limit_regs(struct amd64_pvt *pvt, unsigned range)
1168 {
1169         struct amd_northbridge *nb;
1170         struct pci_dev *f1 = NULL;
1171         unsigned int pci_func;
1172         int off = range << 3;
1173         u32 llim;
1174
1175         amd64_read_pci_cfg(pvt->F1, DRAM_BASE_LO + off,  &pvt->ranges[range].base.lo);
1176         amd64_read_pci_cfg(pvt->F1, DRAM_LIMIT_LO + off, &pvt->ranges[range].lim.lo);
1177
1178         if (pvt->fam == 0xf)
1179                 return;
1180
1181         if (!dram_rw(pvt, range))
1182                 return;
1183
1184         amd64_read_pci_cfg(pvt->F1, DRAM_BASE_HI + off,  &pvt->ranges[range].base.hi);
1185         amd64_read_pci_cfg(pvt->F1, DRAM_LIMIT_HI + off, &pvt->ranges[range].lim.hi);
1186
1187         /* F15h: factor in CC6 save area by reading dst node's limit reg */
1188         if (pvt->fam != 0x15)
1189                 return;
1190
1191         nb = node_to_amd_nb(dram_dst_node(pvt, range));
1192         if (WARN_ON(!nb))
1193                 return;
1194
1195         if (pvt->model == 0x60)
1196                 pci_func = PCI_DEVICE_ID_AMD_15H_M60H_NB_F1;
1197         else if (pvt->model == 0x30)
1198                 pci_func = PCI_DEVICE_ID_AMD_15H_M30H_NB_F1;
1199         else
1200                 pci_func = PCI_DEVICE_ID_AMD_15H_NB_F1;
1201
1202         f1 = pci_get_related_function(nb->misc->vendor, pci_func, nb->misc);
1203         if (WARN_ON(!f1))
1204                 return;
1205
1206         amd64_read_pci_cfg(f1, DRAM_LOCAL_NODE_LIM, &llim);
1207
1208         pvt->ranges[range].lim.lo &= GENMASK_ULL(15, 0);
1209
1210                                     /* {[39:27],111b} */
1211         pvt->ranges[range].lim.lo |= ((llim & 0x1fff) << 3 | 0x7) << 16;
1212
1213         pvt->ranges[range].lim.hi &= GENMASK_ULL(7, 0);
1214
1215                                     /* [47:40] */
1216         pvt->ranges[range].lim.hi |= llim >> 13;
1217
1218         pci_dev_put(f1);
1219 }
1220
1221 static void k8_map_sysaddr_to_csrow(struct mem_ctl_info *mci, u64 sys_addr,
1222                                     struct err_info *err)
1223 {
1224         struct amd64_pvt *pvt = mci->pvt_info;
1225
1226         error_address_to_page_and_offset(sys_addr, err);
1227
1228         /*
1229          * Find out which node the error address belongs to. This may be
1230          * different from the node that detected the error.
1231          */
1232         err->src_mci = find_mc_by_sys_addr(mci, sys_addr);
1233         if (!err->src_mci) {
1234                 amd64_mc_err(mci, "failed to map error addr 0x%lx to a node\n",
1235                              (unsigned long)sys_addr);
1236                 err->err_code = ERR_NODE;
1237                 return;
1238         }
1239
1240         /* Now map the sys_addr to a CSROW */
1241         err->csrow = sys_addr_to_csrow(err->src_mci, sys_addr);
1242         if (err->csrow < 0) {
1243                 err->err_code = ERR_CSROW;
1244                 return;
1245         }
1246
1247         /* CHIPKILL enabled */
1248         if (pvt->nbcfg & NBCFG_CHIPKILL) {
1249                 err->channel = get_channel_from_ecc_syndrome(mci, err->syndrome);
1250                 if (err->channel < 0) {
1251                         /*
1252                          * Syndrome didn't map, so we don't know which of the
1253                          * 2 DIMMs is in error. So we need to ID 'both' of them
1254                          * as suspect.
1255                          */
1256                         amd64_mc_warn(err->src_mci, "unknown syndrome 0x%04x - "
1257                                       "possible error reporting race\n",
1258                                       err->syndrome);
1259                         err->err_code = ERR_CHANNEL;
1260                         return;
1261                 }
1262         } else {
1263                 /*
1264                  * non-chipkill ecc mode
1265                  *
1266                  * The k8 documentation is unclear about how to determine the
1267                  * channel number when using non-chipkill memory.  This method
1268                  * was obtained from email communication with someone at AMD.
1269                  * (Wish the email was placed in this comment - norsk)
1270                  */
1271                 err->channel = ((sys_addr & BIT(3)) != 0);
1272         }
1273 }
1274
1275 static int ddr2_cs_size(unsigned i, bool dct_width)
1276 {
1277         unsigned shift = 0;
1278
1279         if (i <= 2)
1280                 shift = i;
1281         else if (!(i & 0x1))
1282                 shift = i >> 1;
1283         else
1284                 shift = (i + 1) >> 1;
1285
1286         return 128 << (shift + !!dct_width);
1287 }
1288
1289 static int k8_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
1290                                   unsigned cs_mode, int cs_mask_nr)
1291 {
1292         u32 dclr = dct ? pvt->dclr1 : pvt->dclr0;
1293
1294         if (pvt->ext_model >= K8_REV_F) {
1295                 WARN_ON(cs_mode > 11);
1296                 return ddr2_cs_size(cs_mode, dclr & WIDTH_128);
1297         }
1298         else if (pvt->ext_model >= K8_REV_D) {
1299                 unsigned diff;
1300                 WARN_ON(cs_mode > 10);
1301
1302                 /*
1303                  * the below calculation, besides trying to win an obfuscated C
1304                  * contest, maps cs_mode values to DIMM chip select sizes. The
1305                  * mappings are:
1306                  *
1307                  * cs_mode      CS size (mb)
1308                  * =======      ============
1309                  * 0            32
1310                  * 1            64
1311                  * 2            128
1312                  * 3            128
1313                  * 4            256
1314                  * 5            512
1315                  * 6            256
1316                  * 7            512
1317                  * 8            1024
1318                  * 9            1024
1319                  * 10           2048
1320                  *
1321                  * Basically, it calculates a value with which to shift the
1322                  * smallest CS size of 32MB.
1323                  *
1324                  * ddr[23]_cs_size have a similar purpose.
1325                  */
1326                 diff = cs_mode/3 + (unsigned)(cs_mode > 5);
1327
1328                 return 32 << (cs_mode - diff);
1329         }
1330         else {
1331                 WARN_ON(cs_mode > 6);
1332                 return 32 << cs_mode;
1333         }
1334 }
1335
1336 /*
1337  * Get the number of DCT channels in use.
1338  *
1339  * Return:
1340  *      number of Memory Channels in operation
1341  * Pass back:
1342  *      contents of the DCL0_LOW register
1343  */
1344 static int f1x_early_channel_count(struct amd64_pvt *pvt)
1345 {
1346         int i, j, channels = 0;
1347
1348         /* On F10h, if we are in 128 bit mode, then we are using 2 channels */
1349         if (pvt->fam == 0x10 && (pvt->dclr0 & WIDTH_128))
1350                 return 2;
1351
1352         /*
1353          * Need to check if in unganged mode: In such, there are 2 channels,
1354          * but they are not in 128 bit mode and thus the above 'dclr0' status
1355          * bit will be OFF.
1356          *
1357          * Need to check DCT0[0] and DCT1[0] to see if only one of them has
1358          * their CSEnable bit on. If so, then SINGLE DIMM case.
1359          */
1360         edac_dbg(0, "Data width is not 128 bits - need more decoding\n");
1361
1362         /*
1363          * Check DRAM Bank Address Mapping values for each DIMM to see if there
1364          * is more than just one DIMM present in unganged mode. Need to check
1365          * both controllers since DIMMs can be placed in either one.
1366          */
1367         for (i = 0; i < 2; i++) {
1368                 u32 dbam = (i ? pvt->dbam1 : pvt->dbam0);
1369
1370                 for (j = 0; j < 4; j++) {
1371                         if (DBAM_DIMM(j, dbam) > 0) {
1372                                 channels++;
1373                                 break;
1374                         }
1375                 }
1376         }
1377
1378         if (channels > 2)
1379                 channels = 2;
1380
1381         amd64_info("MCT channel count: %d\n", channels);
1382
1383         return channels;
1384 }
1385
1386 static int f17_early_channel_count(struct amd64_pvt *pvt)
1387 {
1388         int i, channels = 0;
1389
1390         /* SDP Control bit 31 (SdpInit) is clear for unused UMC channels */
1391         for (i = 0; i < NUM_UMCS; i++)
1392                 channels += !!(pvt->umc[i].sdp_ctrl & UMC_SDP_INIT);
1393
1394         amd64_info("MCT channel count: %d\n", channels);
1395
1396         return channels;
1397 }
1398
1399 static int ddr3_cs_size(unsigned i, bool dct_width)
1400 {
1401         unsigned shift = 0;
1402         int cs_size = 0;
1403
1404         if (i == 0 || i == 3 || i == 4)
1405                 cs_size = -1;
1406         else if (i <= 2)
1407                 shift = i;
1408         else if (i == 12)
1409                 shift = 7;
1410         else if (!(i & 0x1))
1411                 shift = i >> 1;
1412         else
1413                 shift = (i + 1) >> 1;
1414
1415         if (cs_size != -1)
1416                 cs_size = (128 * (1 << !!dct_width)) << shift;
1417
1418         return cs_size;
1419 }
1420
1421 static int ddr3_lrdimm_cs_size(unsigned i, unsigned rank_multiply)
1422 {
1423         unsigned shift = 0;
1424         int cs_size = 0;
1425
1426         if (i < 4 || i == 6)
1427                 cs_size = -1;
1428         else if (i == 12)
1429                 shift = 7;
1430         else if (!(i & 0x1))
1431                 shift = i >> 1;
1432         else
1433                 shift = (i + 1) >> 1;
1434
1435         if (cs_size != -1)
1436                 cs_size = rank_multiply * (128 << shift);
1437
1438         return cs_size;
1439 }
1440
1441 static int ddr4_cs_size(unsigned i)
1442 {
1443         int cs_size = 0;
1444
1445         if (i == 0)
1446                 cs_size = -1;
1447         else if (i == 1)
1448                 cs_size = 1024;
1449         else
1450                 /* Min cs_size = 1G */
1451                 cs_size = 1024 * (1 << (i >> 1));
1452
1453         return cs_size;
1454 }
1455
1456 static int f10_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
1457                                    unsigned cs_mode, int cs_mask_nr)
1458 {
1459         u32 dclr = dct ? pvt->dclr1 : pvt->dclr0;
1460
1461         WARN_ON(cs_mode > 11);
1462
1463         if (pvt->dchr0 & DDR3_MODE || pvt->dchr1 & DDR3_MODE)
1464                 return ddr3_cs_size(cs_mode, dclr & WIDTH_128);
1465         else
1466                 return ddr2_cs_size(cs_mode, dclr & WIDTH_128);
1467 }
1468
1469 /*
1470  * F15h supports only 64bit DCT interfaces
1471  */
1472 static int f15_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
1473                                    unsigned cs_mode, int cs_mask_nr)
1474 {
1475         WARN_ON(cs_mode > 12);
1476
1477         return ddr3_cs_size(cs_mode, false);
1478 }
1479
1480 /* F15h M60h supports DDR4 mapping as well.. */
1481 static int f15_m60h_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
1482                                         unsigned cs_mode, int cs_mask_nr)
1483 {
1484         int cs_size;
1485         u32 dcsm = pvt->csels[dct].csmasks[cs_mask_nr];
1486
1487         WARN_ON(cs_mode > 12);
1488
1489         if (pvt->dram_type == MEM_DDR4) {
1490                 if (cs_mode > 9)
1491                         return -1;
1492
1493                 cs_size = ddr4_cs_size(cs_mode);
1494         } else if (pvt->dram_type == MEM_LRDDR3) {
1495                 unsigned rank_multiply = dcsm & 0xf;
1496
1497                 if (rank_multiply == 3)
1498                         rank_multiply = 4;
1499                 cs_size = ddr3_lrdimm_cs_size(cs_mode, rank_multiply);
1500         } else {
1501                 /* Minimum cs size is 512mb for F15hM60h*/
1502                 if (cs_mode == 0x1)
1503                         return -1;
1504
1505                 cs_size = ddr3_cs_size(cs_mode, false);
1506         }
1507
1508         return cs_size;
1509 }
1510
1511 /*
1512  * F16h and F15h model 30h have only limited cs_modes.
1513  */
1514 static int f16_dbam_to_chip_select(struct amd64_pvt *pvt, u8 dct,
1515                                 unsigned cs_mode, int cs_mask_nr)
1516 {
1517         WARN_ON(cs_mode > 12);
1518
1519         if (cs_mode == 6 || cs_mode == 8 ||
1520             cs_mode == 9 || cs_mode == 12)
1521                 return -1;
1522         else
1523                 return ddr3_cs_size(cs_mode, false);
1524 }
1525
1526 static int f17_base_addr_to_cs_size(struct amd64_pvt *pvt, u8 umc,
1527                                     unsigned int cs_mode, int csrow_nr)
1528 {
1529         u32 base_addr = pvt->csels[umc].csbases[csrow_nr];
1530
1531         /*  Each mask is used for every two base addresses. */
1532         u32 addr_mask = pvt->csels[umc].csmasks[csrow_nr >> 1];
1533
1534         /*  Register [31:1] = Address [39:9]. Size is in kBs here. */
1535         u32 size = ((addr_mask >> 1) - (base_addr >> 1) + 1) >> 1;
1536
1537         edac_dbg(1, "BaseAddr: 0x%x, AddrMask: 0x%x\n", base_addr, addr_mask);
1538
1539         /* Return size in MBs. */
1540         return size >> 10;
1541 }
1542
1543 static void read_dram_ctl_register(struct amd64_pvt *pvt)
1544 {
1545
1546         if (pvt->fam == 0xf)
1547                 return;
1548
1549         if (!amd64_read_pci_cfg(pvt->F2, DCT_SEL_LO, &pvt->dct_sel_lo)) {
1550                 edac_dbg(0, "F2x110 (DCTSelLow): 0x%08x, High range addrs at: 0x%x\n",
1551                          pvt->dct_sel_lo, dct_sel_baseaddr(pvt));
1552
1553                 edac_dbg(0, "  DCTs operate in %s mode\n",
1554                          (dct_ganging_enabled(pvt) ? "ganged" : "unganged"));
1555
1556                 if (!dct_ganging_enabled(pvt))
1557                         edac_dbg(0, "  Address range split per DCT: %s\n",
1558                                  (dct_high_range_enabled(pvt) ? "yes" : "no"));
1559
1560                 edac_dbg(0, "  data interleave for ECC: %s, DRAM cleared since last warm reset: %s\n",
1561                          (dct_data_intlv_enabled(pvt) ? "enabled" : "disabled"),
1562                          (dct_memory_cleared(pvt) ? "yes" : "no"));
1563
1564                 edac_dbg(0, "  channel interleave: %s, "
1565                          "interleave bits selector: 0x%x\n",
1566                          (dct_interleave_enabled(pvt) ? "enabled" : "disabled"),
1567                          dct_sel_interleave_addr(pvt));
1568         }
1569
1570         amd64_read_pci_cfg(pvt->F2, DCT_SEL_HI, &pvt->dct_sel_hi);
1571 }
1572
1573 /*
1574  * Determine channel (DCT) based on the interleaving mode (see F15h M30h BKDG,
1575  * 2.10.12 Memory Interleaving Modes).
1576  */
1577 static u8 f15_m30h_determine_channel(struct amd64_pvt *pvt, u64 sys_addr,
1578                                      u8 intlv_en, int num_dcts_intlv,
1579                                      u32 dct_sel)
1580 {
1581         u8 channel = 0;
1582         u8 select;
1583
1584         if (!(intlv_en))
1585                 return (u8)(dct_sel);
1586
1587         if (num_dcts_intlv == 2) {
1588                 select = (sys_addr >> 8) & 0x3;
1589                 channel = select ? 0x3 : 0;
1590         } else if (num_dcts_intlv == 4) {
1591                 u8 intlv_addr = dct_sel_interleave_addr(pvt);
1592                 switch (intlv_addr) {
1593                 case 0x4:
1594                         channel = (sys_addr >> 8) & 0x3;
1595                         break;
1596                 case 0x5:
1597                         channel = (sys_addr >> 9) & 0x3;
1598                         break;
1599                 }
1600         }
1601         return channel;
1602 }
1603
1604 /*
1605  * Determine channel (DCT) based on the interleaving mode: F10h BKDG, 2.8.9 Memory
1606  * Interleaving Modes.
1607  */
1608 static u8 f1x_determine_channel(struct amd64_pvt *pvt, u64 sys_addr,
1609                                 bool hi_range_sel, u8 intlv_en)
1610 {
1611         u8 dct_sel_high = (pvt->dct_sel_lo >> 1) & 1;
1612
1613         if (dct_ganging_enabled(pvt))
1614                 return 0;
1615
1616         if (hi_range_sel)
1617                 return dct_sel_high;
1618
1619         /*
1620          * see F2x110[DctSelIntLvAddr] - channel interleave mode
1621          */
1622         if (dct_interleave_enabled(pvt)) {
1623                 u8 intlv_addr = dct_sel_interleave_addr(pvt);
1624
1625                 /* return DCT select function: 0=DCT0, 1=DCT1 */
1626                 if (!intlv_addr)
1627                         return sys_addr >> 6 & 1;
1628
1629                 if (intlv_addr & 0x2) {
1630                         u8 shift = intlv_addr & 0x1 ? 9 : 6;
1631                         u32 temp = hweight_long((u32) ((sys_addr >> 16) & 0x1F)) & 1;
1632
1633                         return ((sys_addr >> shift) & 1) ^ temp;
1634                 }
1635
1636                 if (intlv_addr & 0x4) {
1637                         u8 shift = intlv_addr & 0x1 ? 9 : 8;
1638
1639                         return (sys_addr >> shift) & 1;
1640                 }
1641
1642                 return (sys_addr >> (12 + hweight8(intlv_en))) & 1;
1643         }
1644
1645         if (dct_high_range_enabled(pvt))
1646                 return ~dct_sel_high & 1;
1647
1648         return 0;
1649 }
1650
1651 /* Convert the sys_addr to the normalized DCT address */
1652 static u64 f1x_get_norm_dct_addr(struct amd64_pvt *pvt, u8 range,
1653                                  u64 sys_addr, bool hi_rng,
1654                                  u32 dct_sel_base_addr)
1655 {
1656         u64 chan_off;
1657         u64 dram_base           = get_dram_base(pvt, range);
1658         u64 hole_off            = f10_dhar_offset(pvt);
1659         u64 dct_sel_base_off    = (u64)(pvt->dct_sel_hi & 0xFFFFFC00) << 16;
1660
1661         if (hi_rng) {
1662                 /*
1663                  * if
1664                  * base address of high range is below 4Gb
1665                  * (bits [47:27] at [31:11])
1666                  * DRAM address space on this DCT is hoisted above 4Gb  &&
1667                  * sys_addr > 4Gb
1668                  *
1669                  *      remove hole offset from sys_addr
1670                  * else
1671                  *      remove high range offset from sys_addr
1672                  */
1673                 if ((!(dct_sel_base_addr >> 16) ||
1674                      dct_sel_base_addr < dhar_base(pvt)) &&
1675                     dhar_valid(pvt) &&
1676                     (sys_addr >= BIT_64(32)))
1677                         chan_off = hole_off;
1678                 else
1679                         chan_off = dct_sel_base_off;
1680         } else {
1681                 /*
1682                  * if
1683                  * we have a valid hole         &&
1684                  * sys_addr > 4Gb
1685                  *
1686                  *      remove hole
1687                  * else
1688                  *      remove dram base to normalize to DCT address
1689                  */
1690                 if (dhar_valid(pvt) && (sys_addr >= BIT_64(32)))
1691                         chan_off = hole_off;
1692                 else
1693                         chan_off = dram_base;
1694         }
1695
1696         return (sys_addr & GENMASK_ULL(47,6)) - (chan_off & GENMASK_ULL(47,23));
1697 }
1698
1699 /*
1700  * checks if the csrow passed in is marked as SPARED, if so returns the new
1701  * spare row
1702  */
1703 static int f10_process_possible_spare(struct amd64_pvt *pvt, u8 dct, int csrow)
1704 {
1705         int tmp_cs;
1706
1707         if (online_spare_swap_done(pvt, dct) &&
1708             csrow == online_spare_bad_dramcs(pvt, dct)) {
1709
1710                 for_each_chip_select(tmp_cs, dct, pvt) {
1711                         if (chip_select_base(tmp_cs, dct, pvt) & 0x2) {
1712                                 csrow = tmp_cs;
1713                                 break;
1714                         }
1715                 }
1716         }
1717         return csrow;
1718 }
1719
1720 /*
1721  * Iterate over the DRAM DCT "base" and "mask" registers looking for a
1722  * SystemAddr match on the specified 'ChannelSelect' and 'NodeID'
1723  *
1724  * Return:
1725  *      -EINVAL:  NOT FOUND
1726  *      0..csrow = Chip-Select Row
1727  */
1728 static int f1x_lookup_addr_in_dct(u64 in_addr, u8 nid, u8 dct)
1729 {
1730         struct mem_ctl_info *mci;
1731         struct amd64_pvt *pvt;
1732         u64 cs_base, cs_mask;
1733         int cs_found = -EINVAL;
1734         int csrow;
1735
1736         mci = edac_mc_find(nid);
1737         if (!mci)
1738                 return cs_found;
1739
1740         pvt = mci->pvt_info;
1741
1742         edac_dbg(1, "input addr: 0x%llx, DCT: %d\n", in_addr, dct);
1743
1744         for_each_chip_select(csrow, dct, pvt) {
1745                 if (!csrow_enabled(csrow, dct, pvt))
1746                         continue;
1747
1748                 get_cs_base_and_mask(pvt, csrow, dct, &cs_base, &cs_mask);
1749
1750                 edac_dbg(1, "    CSROW=%d CSBase=0x%llx CSMask=0x%llx\n",
1751                          csrow, cs_base, cs_mask);
1752
1753                 cs_mask = ~cs_mask;
1754
1755                 edac_dbg(1, "    (InputAddr & ~CSMask)=0x%llx (CSBase & ~CSMask)=0x%llx\n",
1756                          (in_addr & cs_mask), (cs_base & cs_mask));
1757
1758                 if ((in_addr & cs_mask) == (cs_base & cs_mask)) {
1759                         if (pvt->fam == 0x15 && pvt->model >= 0x30) {
1760                                 cs_found =  csrow;
1761                                 break;
1762                         }
1763                         cs_found = f10_process_possible_spare(pvt, dct, csrow);
1764
1765                         edac_dbg(1, " MATCH csrow=%d\n", cs_found);
1766                         break;
1767                 }
1768         }
1769         return cs_found;
1770 }
1771
1772 /*
1773  * See F2x10C. Non-interleaved graphics framebuffer memory under the 16G is
1774  * swapped with a region located at the bottom of memory so that the GPU can use
1775  * the interleaved region and thus two channels.
1776  */
1777 static u64 f1x_swap_interleaved_region(struct amd64_pvt *pvt, u64 sys_addr)
1778 {
1779         u32 swap_reg, swap_base, swap_limit, rgn_size, tmp_addr;
1780
1781         if (pvt->fam == 0x10) {
1782                 /* only revC3 and revE have that feature */
1783                 if (pvt->model < 4 || (pvt->model < 0xa && pvt->stepping < 3))
1784                         return sys_addr;
1785         }
1786
1787         amd64_read_pci_cfg(pvt->F2, SWAP_INTLV_REG, &swap_reg);
1788
1789         if (!(swap_reg & 0x1))
1790                 return sys_addr;
1791
1792         swap_base       = (swap_reg >> 3) & 0x7f;
1793         swap_limit      = (swap_reg >> 11) & 0x7f;
1794         rgn_size        = (swap_reg >> 20) & 0x7f;
1795         tmp_addr        = sys_addr >> 27;
1796
1797         if (!(sys_addr >> 34) &&
1798             (((tmp_addr >= swap_base) &&
1799              (tmp_addr <= swap_limit)) ||
1800              (tmp_addr < rgn_size)))
1801                 return sys_addr ^ (u64)swap_base << 27;
1802
1803         return sys_addr;
1804 }
1805
1806 /* For a given @dram_range, check if @sys_addr falls within it. */
1807 static int f1x_match_to_this_node(struct amd64_pvt *pvt, unsigned range,
1808                                   u64 sys_addr, int *chan_sel)
1809 {
1810         int cs_found = -EINVAL;
1811         u64 chan_addr;
1812         u32 dct_sel_base;
1813         u8 channel;
1814         bool high_range = false;
1815
1816         u8 node_id    = dram_dst_node(pvt, range);
1817         u8 intlv_en   = dram_intlv_en(pvt, range);
1818         u32 intlv_sel = dram_intlv_sel(pvt, range);
1819
1820         edac_dbg(1, "(range %d) SystemAddr= 0x%llx Limit=0x%llx\n",
1821                  range, sys_addr, get_dram_limit(pvt, range));
1822
1823         if (dhar_valid(pvt) &&
1824             dhar_base(pvt) <= sys_addr &&
1825             sys_addr < BIT_64(32)) {
1826                 amd64_warn("Huh? Address is in the MMIO hole: 0x%016llx\n",
1827                             sys_addr);
1828                 return -EINVAL;
1829         }
1830
1831         if (intlv_en && (intlv_sel != ((sys_addr >> 12) & intlv_en)))
1832                 return -EINVAL;
1833
1834         sys_addr = f1x_swap_interleaved_region(pvt, sys_addr);
1835
1836         dct_sel_base = dct_sel_baseaddr(pvt);
1837
1838         /*
1839          * check whether addresses >= DctSelBaseAddr[47:27] are to be used to
1840          * select between DCT0 and DCT1.
1841          */
1842         if (dct_high_range_enabled(pvt) &&
1843            !dct_ganging_enabled(pvt) &&
1844            ((sys_addr >> 27) >= (dct_sel_base >> 11)))
1845                 high_range = true;
1846
1847         channel = f1x_determine_channel(pvt, sys_addr, high_range, intlv_en);
1848
1849         chan_addr = f1x_get_norm_dct_addr(pvt, range, sys_addr,
1850                                           high_range, dct_sel_base);
1851
1852         /* Remove node interleaving, see F1x120 */
1853         if (intlv_en)
1854                 chan_addr = ((chan_addr >> (12 + hweight8(intlv_en))) << 12) |
1855                             (chan_addr & 0xfff);
1856
1857         /* remove channel interleave */
1858         if (dct_interleave_enabled(pvt) &&
1859            !dct_high_range_enabled(pvt) &&
1860            !dct_ganging_enabled(pvt)) {
1861
1862                 if (dct_sel_interleave_addr(pvt) != 1) {
1863                         if (dct_sel_interleave_addr(pvt) == 0x3)
1864                                 /* hash 9 */
1865                                 chan_addr = ((chan_addr >> 10) << 9) |
1866                                              (chan_addr & 0x1ff);
1867                         else
1868                                 /* A[6] or hash 6 */
1869                                 chan_addr = ((chan_addr >> 7) << 6) |
1870                                              (chan_addr & 0x3f);
1871                 } else
1872                         /* A[12] */
1873                         chan_addr = ((chan_addr >> 13) << 12) |
1874                                      (chan_addr & 0xfff);
1875         }
1876
1877         edac_dbg(1, "   Normalized DCT addr: 0x%llx\n", chan_addr);
1878
1879         cs_found = f1x_lookup_addr_in_dct(chan_addr, node_id, channel);
1880
1881         if (cs_found >= 0)
1882                 *chan_sel = channel;
1883
1884         return cs_found;
1885 }
1886
1887 static int f15_m30h_match_to_this_node(struct amd64_pvt *pvt, unsigned range,
1888                                         u64 sys_addr, int *chan_sel)
1889 {
1890         int cs_found = -EINVAL;
1891         int num_dcts_intlv = 0;
1892         u64 chan_addr, chan_offset;
1893         u64 dct_base, dct_limit;
1894         u32 dct_cont_base_reg, dct_cont_limit_reg, tmp;
1895         u8 channel, alias_channel, leg_mmio_hole, dct_sel, dct_offset_en;
1896
1897         u64 dhar_offset         = f10_dhar_offset(pvt);
1898         u8 intlv_addr           = dct_sel_interleave_addr(pvt);
1899         u8 node_id              = dram_dst_node(pvt, range);
1900         u8 intlv_en             = dram_intlv_en(pvt, range);
1901
1902         amd64_read_pci_cfg(pvt->F1, DRAM_CONT_BASE, &dct_cont_base_reg);
1903         amd64_read_pci_cfg(pvt->F1, DRAM_CONT_LIMIT, &dct_cont_limit_reg);
1904
1905         dct_offset_en           = (u8) ((dct_cont_base_reg >> 3) & BIT(0));
1906         dct_sel                 = (u8) ((dct_cont_base_reg >> 4) & 0x7);
1907
1908         edac_dbg(1, "(range %d) SystemAddr= 0x%llx Limit=0x%llx\n",
1909                  range, sys_addr, get_dram_limit(pvt, range));
1910
1911         if (!(get_dram_base(pvt, range)  <= sys_addr) &&
1912             !(get_dram_limit(pvt, range) >= sys_addr))
1913                 return -EINVAL;
1914
1915         if (dhar_valid(pvt) &&
1916             dhar_base(pvt) <= sys_addr &&
1917             sys_addr < BIT_64(32)) {
1918                 amd64_warn("Huh? Address is in the MMIO hole: 0x%016llx\n",
1919                             sys_addr);
1920                 return -EINVAL;
1921         }
1922
1923         /* Verify sys_addr is within DCT Range. */
1924         dct_base = (u64) dct_sel_baseaddr(pvt);
1925         dct_limit = (dct_cont_limit_reg >> 11) & 0x1FFF;
1926
1927         if (!(dct_cont_base_reg & BIT(0)) &&
1928             !(dct_base <= (sys_addr >> 27) &&
1929               dct_limit >= (sys_addr >> 27)))
1930                 return -EINVAL;
1931
1932         /* Verify number of dct's that participate in channel interleaving. */
1933         num_dcts_intlv = (int) hweight8(intlv_en);
1934
1935         if (!(num_dcts_intlv % 2 == 0) || (num_dcts_intlv > 4))
1936                 return -EINVAL;
1937
1938         if (pvt->model >= 0x60)
1939                 channel = f1x_determine_channel(pvt, sys_addr, false, intlv_en);
1940         else
1941                 channel = f15_m30h_determine_channel(pvt, sys_addr, intlv_en,
1942                                                      num_dcts_intlv, dct_sel);
1943
1944         /* Verify we stay within the MAX number of channels allowed */
1945         if (channel > 3)
1946                 return -EINVAL;
1947
1948         leg_mmio_hole = (u8) (dct_cont_base_reg >> 1 & BIT(0));
1949
1950         /* Get normalized DCT addr */
1951         if (leg_mmio_hole && (sys_addr >= BIT_64(32)))
1952                 chan_offset = dhar_offset;
1953         else
1954                 chan_offset = dct_base << 27;
1955
1956         chan_addr = sys_addr - chan_offset;
1957
1958         /* remove channel interleave */
1959         if (num_dcts_intlv == 2) {
1960                 if (intlv_addr == 0x4)
1961                         chan_addr = ((chan_addr >> 9) << 8) |
1962                                                 (chan_addr & 0xff);
1963                 else if (intlv_addr == 0x5)
1964                         chan_addr = ((chan_addr >> 10) << 9) |
1965                                                 (chan_addr & 0x1ff);
1966                 else
1967                         return -EINVAL;
1968
1969         } else if (num_dcts_intlv == 4) {
1970                 if (intlv_addr == 0x4)
1971                         chan_addr = ((chan_addr >> 10) << 8) |
1972                                                         (chan_addr & 0xff);
1973                 else if (intlv_addr == 0x5)
1974                         chan_addr = ((chan_addr >> 11) << 9) |
1975                                                         (chan_addr & 0x1ff);
1976                 else
1977                         return -EINVAL;
1978         }
1979
1980         if (dct_offset_en) {
1981                 amd64_read_pci_cfg(pvt->F1,
1982                                    DRAM_CONT_HIGH_OFF + (int) channel * 4,
1983                                    &tmp);
1984                 chan_addr +=  (u64) ((tmp >> 11) & 0xfff) << 27;
1985         }
1986
1987         f15h_select_dct(pvt, channel);
1988
1989         edac_dbg(1, "   Normalized DCT addr: 0x%llx\n", chan_addr);
1990
1991         /*
1992          * Find Chip select:
1993          * if channel = 3, then alias it to 1. This is because, in F15 M30h,
1994          * there is support for 4 DCT's, but only 2 are currently functional.
1995          * They are DCT0 and DCT3. But we have read all registers of DCT3 into
1996          * pvt->csels[1]. So we need to use '1' here to get correct info.
1997          * Refer F15 M30h BKDG Section 2.10 and 2.10.3 for clarifications.
1998          */
1999         alias_channel =  (channel == 3) ? 1 : channel;
2000
2001         cs_found = f1x_lookup_addr_in_dct(chan_addr, node_id, alias_channel);
2002
2003         if (cs_found >= 0)
2004                 *chan_sel = alias_channel;
2005
2006         return cs_found;
2007 }
2008
2009 static int f1x_translate_sysaddr_to_cs(struct amd64_pvt *pvt,
2010                                         u64 sys_addr,
2011                                         int *chan_sel)
2012 {
2013         int cs_found = -EINVAL;
2014         unsigned range;
2015
2016         for (range = 0; range < DRAM_RANGES; range++) {
2017                 if (!dram_rw(pvt, range))
2018                         continue;
2019
2020                 if (pvt->fam == 0x15 && pvt->model >= 0x30)
2021                         cs_found = f15_m30h_match_to_this_node(pvt, range,
2022                                                                sys_addr,
2023                                                                chan_sel);
2024
2025                 else if ((get_dram_base(pvt, range)  <= sys_addr) &&
2026                          (get_dram_limit(pvt, range) >= sys_addr)) {
2027                         cs_found = f1x_match_to_this_node(pvt, range,
2028                                                           sys_addr, chan_sel);
2029                         if (cs_found >= 0)
2030                                 break;
2031                 }
2032         }
2033         return cs_found;
2034 }
2035
2036 /*
2037  * For reference see "2.8.5 Routing DRAM Requests" in F10 BKDG. This code maps
2038  * a @sys_addr to NodeID, DCT (channel) and chip select (CSROW).
2039  *
2040  * The @sys_addr is usually an error address received from the hardware
2041  * (MCX_ADDR).
2042  */
2043 static void f1x_map_sysaddr_to_csrow(struct mem_ctl_info *mci, u64 sys_addr,
2044                                      struct err_info *err)
2045 {
2046         struct amd64_pvt *pvt = mci->pvt_info;
2047
2048         error_address_to_page_and_offset(sys_addr, err);
2049
2050         err->csrow = f1x_translate_sysaddr_to_cs(pvt, sys_addr, &err->channel);
2051         if (err->csrow < 0) {
2052                 err->err_code = ERR_CSROW;
2053                 return;
2054         }
2055
2056         /*
2057          * We need the syndromes for channel detection only when we're
2058          * ganged. Otherwise @chan should already contain the channel at
2059          * this point.
2060          */
2061         if (dct_ganging_enabled(pvt))
2062                 err->channel = get_channel_from_ecc_syndrome(mci, err->syndrome);
2063 }
2064
2065 /*
2066  * debug routine to display the memory sizes of all logical DIMMs and its
2067  * CSROWs
2068  */
2069 static void debug_display_dimm_sizes(struct amd64_pvt *pvt, u8 ctrl)
2070 {
2071         int dimm, size0, size1;
2072         u32 *dcsb = ctrl ? pvt->csels[1].csbases : pvt->csels[0].csbases;
2073         u32 dbam  = ctrl ? pvt->dbam1 : pvt->dbam0;
2074
2075         if (pvt->fam == 0xf) {
2076                 /* K8 families < revF not supported yet */
2077                if (pvt->ext_model < K8_REV_F)
2078                         return;
2079                else
2080                        WARN_ON(ctrl != 0);
2081         }
2082
2083         if (pvt->fam == 0x10) {
2084                 dbam = (ctrl && !dct_ganging_enabled(pvt)) ? pvt->dbam1
2085                                                            : pvt->dbam0;
2086                 dcsb = (ctrl && !dct_ganging_enabled(pvt)) ?
2087                                  pvt->csels[1].csbases :
2088                                  pvt->csels[0].csbases;
2089         } else if (ctrl) {
2090                 dbam = pvt->dbam0;
2091                 dcsb = pvt->csels[1].csbases;
2092         }
2093         edac_dbg(1, "F2x%d80 (DRAM Bank Address Mapping): 0x%08x\n",
2094                  ctrl, dbam);
2095
2096         edac_printk(KERN_DEBUG, EDAC_MC, "DCT%d chip selects:\n", ctrl);
2097
2098         /* Dump memory sizes for DIMM and its CSROWs */
2099         for (dimm = 0; dimm < 4; dimm++) {
2100
2101                 size0 = 0;
2102                 if (dcsb[dimm*2] & DCSB_CS_ENABLE)
2103                         /*
2104                          * For F15m60h, we need multiplier for LRDIMM cs_size
2105                          * calculation. We pass dimm value to the dbam_to_cs
2106                          * mapper so we can find the multiplier from the
2107                          * corresponding DCSM.
2108                          */
2109                         size0 = pvt->ops->dbam_to_cs(pvt, ctrl,
2110                                                      DBAM_DIMM(dimm, dbam),
2111                                                      dimm);
2112
2113                 size1 = 0;
2114                 if (dcsb[dimm*2 + 1] & DCSB_CS_ENABLE)
2115                         size1 = pvt->ops->dbam_to_cs(pvt, ctrl,
2116                                                      DBAM_DIMM(dimm, dbam),
2117                                                      dimm);
2118
2119                 amd64_info(EDAC_MC ": %d: %5dMB %d: %5dMB\n",
2120                                 dimm * 2,     size0,
2121                                 dimm * 2 + 1, size1);
2122         }
2123 }
2124
2125 static struct amd64_family_type family_types[] = {
2126         [K8_CPUS] = {
2127                 .ctl_name = "K8",
2128                 .f1_id = PCI_DEVICE_ID_AMD_K8_NB_ADDRMAP,
2129                 .f2_id = PCI_DEVICE_ID_AMD_K8_NB_MEMCTL,
2130                 .ops = {
2131                         .early_channel_count    = k8_early_channel_count,
2132                         .map_sysaddr_to_csrow   = k8_map_sysaddr_to_csrow,
2133                         .dbam_to_cs             = k8_dbam_to_chip_select,
2134                 }
2135         },
2136         [F10_CPUS] = {
2137                 .ctl_name = "F10h",
2138                 .f1_id = PCI_DEVICE_ID_AMD_10H_NB_MAP,
2139                 .f2_id = PCI_DEVICE_ID_AMD_10H_NB_DRAM,
2140                 .ops = {
2141                         .early_channel_count    = f1x_early_channel_count,
2142                         .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
2143                         .dbam_to_cs             = f10_dbam_to_chip_select,
2144                 }
2145         },
2146         [F15_CPUS] = {
2147                 .ctl_name = "F15h",
2148                 .f1_id = PCI_DEVICE_ID_AMD_15H_NB_F1,
2149                 .f2_id = PCI_DEVICE_ID_AMD_15H_NB_F2,
2150                 .ops = {
2151                         .early_channel_count    = f1x_early_channel_count,
2152                         .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
2153                         .dbam_to_cs             = f15_dbam_to_chip_select,
2154                 }
2155         },
2156         [F15_M30H_CPUS] = {
2157                 .ctl_name = "F15h_M30h",
2158                 .f1_id = PCI_DEVICE_ID_AMD_15H_M30H_NB_F1,
2159                 .f2_id = PCI_DEVICE_ID_AMD_15H_M30H_NB_F2,
2160                 .ops = {
2161                         .early_channel_count    = f1x_early_channel_count,
2162                         .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
2163                         .dbam_to_cs             = f16_dbam_to_chip_select,
2164                 }
2165         },
2166         [F15_M60H_CPUS] = {
2167                 .ctl_name = "F15h_M60h",
2168                 .f1_id = PCI_DEVICE_ID_AMD_15H_M60H_NB_F1,
2169                 .f2_id = PCI_DEVICE_ID_AMD_15H_M60H_NB_F2,
2170                 .ops = {
2171                         .early_channel_count    = f1x_early_channel_count,
2172                         .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
2173                         .dbam_to_cs             = f15_m60h_dbam_to_chip_select,
2174                 }
2175         },
2176         [F16_CPUS] = {
2177                 .ctl_name = "F16h",
2178                 .f1_id = PCI_DEVICE_ID_AMD_16H_NB_F1,
2179                 .f2_id = PCI_DEVICE_ID_AMD_16H_NB_F2,
2180                 .ops = {
2181                         .early_channel_count    = f1x_early_channel_count,
2182                         .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
2183                         .dbam_to_cs             = f16_dbam_to_chip_select,
2184                 }
2185         },
2186         [F16_M30H_CPUS] = {
2187                 .ctl_name = "F16h_M30h",
2188                 .f1_id = PCI_DEVICE_ID_AMD_16H_M30H_NB_F1,
2189                 .f2_id = PCI_DEVICE_ID_AMD_16H_M30H_NB_F2,
2190                 .ops = {
2191                         .early_channel_count    = f1x_early_channel_count,
2192                         .map_sysaddr_to_csrow   = f1x_map_sysaddr_to_csrow,
2193                         .dbam_to_cs             = f16_dbam_to_chip_select,
2194                 }
2195         },
2196         [F17_CPUS] = {
2197                 .ctl_name = "F17h",
2198                 .f0_id = PCI_DEVICE_ID_AMD_17H_DF_F0,
2199                 .f6_id = PCI_DEVICE_ID_AMD_17H_DF_F6,
2200                 .ops = {
2201                         .early_channel_count    = f17_early_channel_count,
2202                         .dbam_to_cs             = f17_base_addr_to_cs_size,
2203                 }
2204         },
2205         [F17_M10H_CPUS] = {
2206                 .ctl_name = "F17h_M10h",
2207                 .f0_id = PCI_DEVICE_ID_AMD_17H_M10H_DF_F0,
2208                 .f6_id = PCI_DEVICE_ID_AMD_17H_M10H_DF_F6,
2209                 .ops = {
2210                         .early_channel_count    = f17_early_channel_count,
2211                         .dbam_to_cs             = f17_base_addr_to_cs_size,
2212                 }
2213         },
2214         [F17_M30H_CPUS] = {
2215                 .ctl_name = "F17h_M30h",
2216                 .f0_id = PCI_DEVICE_ID_AMD_17H_M30H_DF_F0,
2217                 .f6_id = PCI_DEVICE_ID_AMD_17H_M30H_DF_F6,
2218                 .ops = {
2219                         .early_channel_count    = f17_early_channel_count,
2220                         .dbam_to_cs             = f17_base_addr_to_cs_size,
2221                 }
2222         },
2223 };
2224
2225 /*
2226  * These are tables of eigenvectors (one per line) which can be used for the
2227  * construction of the syndrome tables. The modified syndrome search algorithm
2228  * uses those to find the symbol in error and thus the DIMM.
2229  *
2230  * Algorithm courtesy of Ross LaFetra from AMD.
2231  */
2232 static const u16 x4_vectors[] = {
2233         0x2f57, 0x1afe, 0x66cc, 0xdd88,
2234         0x11eb, 0x3396, 0x7f4c, 0xeac8,
2235         0x0001, 0x0002, 0x0004, 0x0008,
2236         0x1013, 0x3032, 0x4044, 0x8088,
2237         0x106b, 0x30d6, 0x70fc, 0xe0a8,
2238         0x4857, 0xc4fe, 0x13cc, 0x3288,
2239         0x1ac5, 0x2f4a, 0x5394, 0xa1e8,
2240         0x1f39, 0x251e, 0xbd6c, 0x6bd8,
2241         0x15c1, 0x2a42, 0x89ac, 0x4758,
2242         0x2b03, 0x1602, 0x4f0c, 0xca08,
2243         0x1f07, 0x3a0e, 0x6b04, 0xbd08,
2244         0x8ba7, 0x465e, 0x244c, 0x1cc8,
2245         0x2b87, 0x164e, 0x642c, 0xdc18,
2246         0x40b9, 0x80de, 0x1094, 0x20e8,
2247         0x27db, 0x1eb6, 0x9dac, 0x7b58,
2248         0x11c1, 0x2242, 0x84ac, 0x4c58,
2249         0x1be5, 0x2d7a, 0x5e34, 0xa718,
2250         0x4b39, 0x8d1e, 0x14b4, 0x28d8,
2251         0x4c97, 0xc87e, 0x11fc, 0x33a8,
2252         0x8e97, 0x497e, 0x2ffc, 0x1aa8,
2253         0x16b3, 0x3d62, 0x4f34, 0x8518,
2254         0x1e2f, 0x391a, 0x5cac, 0xf858,
2255         0x1d9f, 0x3b7a, 0x572c, 0xfe18,
2256         0x15f5, 0x2a5a, 0x5264, 0xa3b8,
2257         0x1dbb, 0x3b66, 0x715c, 0xe3f8,
2258         0x4397, 0xc27e, 0x17fc, 0x3ea8,
2259         0x1617, 0x3d3e, 0x6464, 0xb8b8,
2260         0x23ff, 0x12aa, 0xab6c, 0x56d8,
2261         0x2dfb, 0x1ba6, 0x913c, 0x7328,
2262         0x185d, 0x2ca6, 0x7914, 0x9e28,
2263         0x171b, 0x3e36, 0x7d7c, 0xebe8,
2264         0x4199, 0x82ee, 0x19f4, 0x2e58,
2265         0x4807, 0xc40e, 0x130c, 0x3208,
2266         0x1905, 0x2e0a, 0x5804, 0xac08,
2267         0x213f, 0x132a, 0xadfc, 0x5ba8,
2268         0x19a9, 0x2efe, 0xb5cc, 0x6f88,
2269 };
2270
2271 static const u16 x8_vectors[] = {
2272         0x0145, 0x028a, 0x2374, 0x43c8, 0xa1f0, 0x0520, 0x0a40, 0x1480,
2273         0x0211, 0x0422, 0x0844, 0x1088, 0x01b0, 0x44e0, 0x23c0, 0xed80,
2274         0x1011, 0x0116, 0x022c, 0x0458, 0x08b0, 0x8c60, 0x2740, 0x4e80,
2275         0x0411, 0x0822, 0x1044, 0x0158, 0x02b0, 0x2360, 0x46c0, 0xab80,
2276         0x0811, 0x1022, 0x012c, 0x0258, 0x04b0, 0x4660, 0x8cc0, 0x2780,
2277         0x2071, 0x40e2, 0xa0c4, 0x0108, 0x0210, 0x0420, 0x0840, 0x1080,
2278         0x4071, 0x80e2, 0x0104, 0x0208, 0x0410, 0x0820, 0x1040, 0x2080,
2279         0x8071, 0x0102, 0x0204, 0x0408, 0x0810, 0x1020, 0x2040, 0x4080,
2280         0x019d, 0x03d6, 0x136c, 0x2198, 0x50b0, 0xb2e0, 0x0740, 0x0e80,
2281         0x0189, 0x03ea, 0x072c, 0x0e58, 0x1cb0, 0x56e0, 0x37c0, 0xf580,
2282         0x01fd, 0x0376, 0x06ec, 0x0bb8, 0x1110, 0x2220, 0x4440, 0x8880,
2283         0x0163, 0x02c6, 0x1104, 0x0758, 0x0eb0, 0x2be0, 0x6140, 0xc280,
2284         0x02fd, 0x01c6, 0x0b5c, 0x1108, 0x07b0, 0x25a0, 0x8840, 0x6180,
2285         0x0801, 0x012e, 0x025c, 0x04b8, 0x1370, 0x26e0, 0x57c0, 0xb580,
2286         0x0401, 0x0802, 0x015c, 0x02b8, 0x22b0, 0x13e0, 0x7140, 0xe280,
2287         0x0201, 0x0402, 0x0804, 0x01b8, 0x11b0, 0x31a0, 0x8040, 0x7180,
2288         0x0101, 0x0202, 0x0404, 0x0808, 0x1010, 0x2020, 0x4040, 0x8080,
2289         0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
2290         0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x8000,
2291 };
2292
2293 static int decode_syndrome(u16 syndrome, const u16 *vectors, unsigned num_vecs,
2294                            unsigned v_dim)
2295 {
2296         unsigned int i, err_sym;
2297
2298         for (err_sym = 0; err_sym < num_vecs / v_dim; err_sym++) {
2299                 u16 s = syndrome;
2300                 unsigned v_idx =  err_sym * v_dim;
2301                 unsigned v_end = (err_sym + 1) * v_dim;
2302
2303                 /* walk over all 16 bits of the syndrome */
2304                 for (i = 1; i < (1U << 16); i <<= 1) {
2305
2306                         /* if bit is set in that eigenvector... */
2307                         if (v_idx < v_end && vectors[v_idx] & i) {
2308                                 u16 ev_comp = vectors[v_idx++];
2309
2310                                 /* ... and bit set in the modified syndrome, */
2311                                 if (s & i) {
2312                                         /* remove it. */
2313                                         s ^= ev_comp;
2314
2315                                         if (!s)
2316                                                 return err_sym;
2317                                 }
2318
2319                         } else if (s & i)
2320                                 /* can't get to zero, move to next symbol */
2321                                 break;
2322                 }
2323         }
2324
2325         edac_dbg(0, "syndrome(%x) not found\n", syndrome);
2326         return -1;
2327 }
2328
2329 static int map_err_sym_to_channel(int err_sym, int sym_size)
2330 {
2331         if (sym_size == 4)
2332                 switch (err_sym) {
2333                 case 0x20:
2334                 case 0x21:
2335                         return 0;
2336                         break;
2337                 case 0x22:
2338                 case 0x23:
2339                         return 1;
2340                         break;
2341                 default:
2342                         return err_sym >> 4;
2343                         break;
2344                 }
2345         /* x8 symbols */
2346         else
2347                 switch (err_sym) {
2348                 /* imaginary bits not in a DIMM */
2349                 case 0x10:
2350                         WARN(1, KERN_ERR "Invalid error symbol: 0x%x\n",
2351                                           err_sym);
2352                         return -1;
2353                         break;
2354
2355                 case 0x11:
2356                         return 0;
2357                         break;
2358                 case 0x12:
2359                         return 1;
2360                         break;
2361                 default:
2362                         return err_sym >> 3;
2363                         break;
2364                 }
2365         return -1;
2366 }
2367
2368 static int get_channel_from_ecc_syndrome(struct mem_ctl_info *mci, u16 syndrome)
2369 {
2370         struct amd64_pvt *pvt = mci->pvt_info;
2371         int err_sym = -1;
2372
2373         if (pvt->ecc_sym_sz == 8)
2374                 err_sym = decode_syndrome(syndrome, x8_vectors,
2375                                           ARRAY_SIZE(x8_vectors),
2376                                           pvt->ecc_sym_sz);
2377         else if (pvt->ecc_sym_sz == 4)
2378                 err_sym = decode_syndrome(syndrome, x4_vectors,
2379                                           ARRAY_SIZE(x4_vectors),
2380                                           pvt->ecc_sym_sz);
2381         else {
2382                 amd64_warn("Illegal syndrome type: %u\n", pvt->ecc_sym_sz);
2383                 return err_sym;
2384         }
2385
2386         return map_err_sym_to_channel(err_sym, pvt->ecc_sym_sz);
2387 }
2388
2389 static void __log_ecc_error(struct mem_ctl_info *mci, struct err_info *err,
2390                             u8 ecc_type)
2391 {
2392         enum hw_event_mc_err_type err_type;
2393         const char *string;
2394
2395         if (ecc_type == 2)
2396                 err_type = HW_EVENT_ERR_CORRECTED;
2397         else if (ecc_type == 1)
2398                 err_type = HW_EVENT_ERR_UNCORRECTED;
2399         else if (ecc_type == 3)
2400                 err_type = HW_EVENT_ERR_DEFERRED;
2401         else {
2402                 WARN(1, "Something is rotten in the state of Denmark.\n");
2403                 return;
2404         }
2405
2406         switch (err->err_code) {
2407         case DECODE_OK:
2408                 string = "";
2409                 break;
2410         case ERR_NODE:
2411                 string = "Failed to map error addr to a node";
2412                 break;
2413         case ERR_CSROW:
2414                 string = "Failed to map error addr to a csrow";
2415                 break;
2416         case ERR_CHANNEL:
2417                 string = "Unknown syndrome - possible error reporting race";
2418                 break;
2419         case ERR_SYND:
2420                 string = "MCA_SYND not valid - unknown syndrome and csrow";
2421                 break;
2422         case ERR_NORM_ADDR:
2423                 string = "Cannot decode normalized address";
2424                 break;
2425         default:
2426                 string = "WTF error";
2427                 break;
2428         }
2429
2430         edac_mc_handle_error(err_type, mci, 1,
2431                              err->page, err->offset, err->syndrome,
2432                              err->csrow, err->channel, -1,
2433                              string, "");
2434 }
2435
2436 static inline void decode_bus_error(int node_id, struct mce *m)
2437 {
2438         struct mem_ctl_info *mci;
2439         struct amd64_pvt *pvt;
2440         u8 ecc_type = (m->status >> 45) & 0x3;
2441         u8 xec = XEC(m->status, 0x1f);
2442         u16 ec = EC(m->status);
2443         u64 sys_addr;
2444         struct err_info err;
2445
2446         mci = edac_mc_find(node_id);
2447         if (!mci)
2448                 return;
2449
2450         pvt = mci->pvt_info;
2451
2452         /* Bail out early if this was an 'observed' error */
2453         if (PP(ec) == NBSL_PP_OBS)
2454                 return;
2455
2456         /* Do only ECC errors */
2457         if (xec && xec != F10_NBSL_EXT_ERR_ECC)
2458                 return;
2459
2460         memset(&err, 0, sizeof(err));
2461
2462         sys_addr = get_error_address(pvt, m);
2463
2464         if (ecc_type == 2)
2465                 err.syndrome = extract_syndrome(m->status);
2466
2467         pvt->ops->map_sysaddr_to_csrow(mci, sys_addr, &err);
2468
2469         __log_ecc_error(mci, &err, ecc_type);
2470 }
2471
2472 /*
2473  * To find the UMC channel represented by this bank we need to match on its
2474  * instance_id. The instance_id of a bank is held in the lower 32 bits of its
2475  * IPID.
2476  */
2477 static int find_umc_channel(struct amd64_pvt *pvt, struct mce *m)
2478 {
2479         u32 umc_instance_id[] = {0x50f00, 0x150f00};
2480         u32 instance_id = m->ipid & GENMASK(31, 0);
2481         int i, channel = -1;
2482
2483         for (i = 0; i < ARRAY_SIZE(umc_instance_id); i++)
2484                 if (umc_instance_id[i] == instance_id)
2485                         channel = i;
2486
2487         return channel;
2488 }
2489
2490 static void decode_umc_error(int node_id, struct mce *m)
2491 {
2492         u8 ecc_type = (m->status >> 45) & 0x3;
2493         struct mem_ctl_info *mci;
2494         struct amd64_pvt *pvt;
2495         struct err_info err;
2496         u64 sys_addr;
2497
2498         mci = edac_mc_find(node_id);
2499         if (!mci)
2500                 return;
2501
2502         pvt = mci->pvt_info;
2503
2504         memset(&err, 0, sizeof(err));
2505
2506         if (m->status & MCI_STATUS_DEFERRED)
2507                 ecc_type = 3;
2508
2509         err.channel = find_umc_channel(pvt, m);
2510         if (err.channel < 0) {
2511                 err.err_code = ERR_CHANNEL;
2512                 goto log_error;
2513         }
2514
2515         if (umc_normaddr_to_sysaddr(m->addr, pvt->mc_node_id, err.channel, &sys_addr)) {
2516                 err.err_code = ERR_NORM_ADDR;
2517                 goto log_error;
2518         }
2519
2520         error_address_to_page_and_offset(sys_addr, &err);
2521
2522         if (!(m->status & MCI_STATUS_SYNDV)) {
2523                 err.err_code = ERR_SYND;
2524                 goto log_error;
2525         }
2526
2527         if (ecc_type == 2) {
2528                 u8 length = (m->synd >> 18) & 0x3f;
2529
2530                 if (length)
2531                         err.syndrome = (m->synd >> 32) & GENMASK(length - 1, 0);
2532                 else
2533                         err.err_code = ERR_CHANNEL;
2534         }
2535
2536         err.csrow = m->synd & 0x7;
2537
2538 log_error:
2539         __log_ecc_error(mci, &err, ecc_type);
2540 }
2541
2542 /*
2543  * Use pvt->F3 which contains the F3 CPU PCI device to get the related
2544  * F1 (AddrMap) and F2 (Dct) devices. Return negative value on error.
2545  * Reserve F0 and F6 on systems with a UMC.
2546  */
2547 static int
2548 reserve_mc_sibling_devs(struct amd64_pvt *pvt, u16 pci_id1, u16 pci_id2)
2549 {
2550         if (pvt->umc) {
2551                 pvt->F0 = pci_get_related_function(pvt->F3->vendor, pci_id1, pvt->F3);
2552                 if (!pvt->F0) {
2553                         amd64_err("F0 not found, device 0x%x (broken BIOS?)\n", pci_id1);
2554                         return -ENODEV;
2555                 }
2556
2557                 pvt->F6 = pci_get_related_function(pvt->F3->vendor, pci_id2, pvt->F3);
2558                 if (!pvt->F6) {
2559                         pci_dev_put(pvt->F0);
2560                         pvt->F0 = NULL;
2561
2562                         amd64_err("F6 not found: device 0x%x (broken BIOS?)\n", pci_id2);
2563                         return -ENODEV;
2564                 }
2565
2566                 edac_dbg(1, "F0: %s\n", pci_name(pvt->F0));
2567                 edac_dbg(1, "F3: %s\n", pci_name(pvt->F3));
2568                 edac_dbg(1, "F6: %s\n", pci_name(pvt->F6));
2569
2570                 return 0;
2571         }
2572
2573         /* Reserve the ADDRESS MAP Device */
2574         pvt->F1 = pci_get_related_function(pvt->F3->vendor, pci_id1, pvt->F3);
2575         if (!pvt->F1) {
2576                 amd64_err("F1 not found: device 0x%x (broken BIOS?)\n", pci_id1);
2577                 return -ENODEV;
2578         }
2579
2580         /* Reserve the DCT Device */
2581         pvt->F2 = pci_get_related_function(pvt->F3->vendor, pci_id2, pvt->F3);
2582         if (!pvt->F2) {
2583                 pci_dev_put(pvt->F1);
2584                 pvt->F1 = NULL;
2585
2586                 amd64_err("F2 not found: device 0x%x (broken BIOS?)\n", pci_id2);
2587                 return -ENODEV;
2588         }
2589
2590         edac_dbg(1, "F1: %s\n", pci_name(pvt->F1));
2591         edac_dbg(1, "F2: %s\n", pci_name(pvt->F2));
2592         edac_dbg(1, "F3: %s\n", pci_name(pvt->F3));
2593
2594         return 0;
2595 }
2596
2597 static void free_mc_sibling_devs(struct amd64_pvt *pvt)
2598 {
2599         if (pvt->umc) {
2600                 pci_dev_put(pvt->F0);
2601                 pci_dev_put(pvt->F6);
2602         } else {
2603                 pci_dev_put(pvt->F1);
2604                 pci_dev_put(pvt->F2);
2605         }
2606 }
2607
2608 static void determine_ecc_sym_sz(struct amd64_pvt *pvt)
2609 {
2610         pvt->ecc_sym_sz = 4;
2611
2612         if (pvt->umc) {
2613                 u8 i;
2614
2615                 for (i = 0; i < NUM_UMCS; i++) {
2616                         /* Check enabled channels only: */
2617                         if ((pvt->umc[i].sdp_ctrl & UMC_SDP_INIT) &&
2618                             (pvt->umc[i].ecc_ctrl & BIT(7))) {
2619                                 pvt->ecc_sym_sz = 8;
2620                                 break;
2621                         }
2622                 }
2623
2624                 return;
2625         }
2626
2627         if (pvt->fam >= 0x10) {
2628                 u32 tmp;
2629
2630                 amd64_read_pci_cfg(pvt->F3, EXT_NB_MCA_CFG, &tmp);
2631                 /* F16h has only DCT0, so no need to read dbam1. */
2632                 if (pvt->fam != 0x16)
2633                         amd64_read_dct_pci_cfg(pvt, 1, DBAM0, &pvt->dbam1);
2634
2635                 /* F10h, revD and later can do x8 ECC too. */
2636                 if ((pvt->fam > 0x10 || pvt->model > 7) && tmp & BIT(25))
2637                         pvt->ecc_sym_sz = 8;
2638         }
2639 }
2640
2641 /*
2642  * Retrieve the hardware registers of the memory controller.
2643  */
2644 static void __read_mc_regs_df(struct amd64_pvt *pvt)
2645 {
2646         u8 nid = pvt->mc_node_id;
2647         struct amd64_umc *umc;
2648         u32 i, umc_base;
2649
2650         /* Read registers from each UMC */
2651         for (i = 0; i < NUM_UMCS; i++) {
2652
2653                 umc_base = get_umc_base(i);
2654                 umc = &pvt->umc[i];
2655
2656                 amd_smn_read(nid, umc_base + UMCCH_DIMM_CFG, &umc->dimm_cfg);
2657                 amd_smn_read(nid, umc_base + UMCCH_UMC_CFG, &umc->umc_cfg);
2658                 amd_smn_read(nid, umc_base + UMCCH_SDP_CTRL, &umc->sdp_ctrl);
2659                 amd_smn_read(nid, umc_base + UMCCH_ECC_CTRL, &umc->ecc_ctrl);
2660                 amd_smn_read(nid, umc_base + UMCCH_UMC_CAP_HI, &umc->umc_cap_hi);
2661         }
2662 }
2663
2664 /*
2665  * Retrieve the hardware registers of the memory controller (this includes the
2666  * 'Address Map' and 'Misc' device regs)
2667  */
2668 static void read_mc_regs(struct amd64_pvt *pvt)
2669 {
2670         unsigned int range;
2671         u64 msr_val;
2672
2673         /*
2674          * Retrieve TOP_MEM and TOP_MEM2; no masking off of reserved bits since
2675          * those are Read-As-Zero.
2676          */
2677         rdmsrl(MSR_K8_TOP_MEM1, pvt->top_mem);
2678         edac_dbg(0, "  TOP_MEM:  0x%016llx\n", pvt->top_mem);
2679
2680         /* Check first whether TOP_MEM2 is enabled: */
2681         rdmsrl(MSR_K8_SYSCFG, msr_val);
2682         if (msr_val & BIT(21)) {
2683                 rdmsrl(MSR_K8_TOP_MEM2, pvt->top_mem2);
2684                 edac_dbg(0, "  TOP_MEM2: 0x%016llx\n", pvt->top_mem2);
2685         } else {
2686                 edac_dbg(0, "  TOP_MEM2 disabled\n");
2687         }
2688
2689         if (pvt->umc) {
2690                 __read_mc_regs_df(pvt);
2691                 amd64_read_pci_cfg(pvt->F0, DF_DHAR, &pvt->dhar);
2692
2693                 goto skip;
2694         }
2695
2696         amd64_read_pci_cfg(pvt->F3, NBCAP, &pvt->nbcap);
2697
2698         read_dram_ctl_register(pvt);
2699
2700         for (range = 0; range < DRAM_RANGES; range++) {
2701                 u8 rw;
2702
2703                 /* read settings for this DRAM range */
2704                 read_dram_base_limit_regs(pvt, range);
2705
2706                 rw = dram_rw(pvt, range);
2707                 if (!rw)
2708                         continue;
2709
2710                 edac_dbg(1, "  DRAM range[%d], base: 0x%016llx; limit: 0x%016llx\n",
2711                          range,
2712                          get_dram_base(pvt, range),
2713                          get_dram_limit(pvt, range));
2714
2715                 edac_dbg(1, "   IntlvEn=%s; Range access: %s%s IntlvSel=%d DstNode=%d\n",
2716                          dram_intlv_en(pvt, range) ? "Enabled" : "Disabled",
2717                          (rw & 0x1) ? "R" : "-",
2718                          (rw & 0x2) ? "W" : "-",
2719                          dram_intlv_sel(pvt, range),
2720                          dram_dst_node(pvt, range));
2721         }
2722
2723         amd64_read_pci_cfg(pvt->F1, DHAR, &pvt->dhar);
2724         amd64_read_dct_pci_cfg(pvt, 0, DBAM0, &pvt->dbam0);
2725
2726         amd64_read_pci_cfg(pvt->F3, F10_ONLINE_SPARE, &pvt->online_spare);
2727
2728         amd64_read_dct_pci_cfg(pvt, 0, DCLR0, &pvt->dclr0);
2729         amd64_read_dct_pci_cfg(pvt, 0, DCHR0, &pvt->dchr0);
2730
2731         if (!dct_ganging_enabled(pvt)) {
2732                 amd64_read_dct_pci_cfg(pvt, 1, DCLR0, &pvt->dclr1);
2733                 amd64_read_dct_pci_cfg(pvt, 1, DCHR0, &pvt->dchr1);
2734         }
2735
2736 skip:
2737         read_dct_base_mask(pvt);
2738
2739         determine_memory_type(pvt);
2740         edac_dbg(1, "  DIMM type: %s\n", edac_mem_types[pvt->dram_type]);
2741
2742         determine_ecc_sym_sz(pvt);
2743
2744         dump_misc_regs(pvt);
2745 }
2746
2747 /*
2748  * NOTE: CPU Revision Dependent code
2749  *
2750  * Input:
2751  *      @csrow_nr ChipSelect Row Number (0..NUM_CHIPSELECTS-1)
2752  *      k8 private pointer to -->
2753  *                      DRAM Bank Address mapping register
2754  *                      node_id
2755  *                      DCL register where dual_channel_active is
2756  *
2757  * The DBAM register consists of 4 sets of 4 bits each definitions:
2758  *
2759  * Bits:        CSROWs
2760  * 0-3          CSROWs 0 and 1
2761  * 4-7          CSROWs 2 and 3
2762  * 8-11         CSROWs 4 and 5
2763  * 12-15        CSROWs 6 and 7
2764  *
2765  * Values range from: 0 to 15
2766  * The meaning of the values depends on CPU revision and dual-channel state,
2767  * see relevant BKDG more info.
2768  *
2769  * The memory controller provides for total of only 8 CSROWs in its current
2770  * architecture. Each "pair" of CSROWs normally represents just one DIMM in
2771  * single channel or two (2) DIMMs in dual channel mode.
2772  *
2773  * The following code logic collapses the various tables for CSROW based on CPU
2774  * revision.
2775  *
2776  * Returns:
2777  *      The number of PAGE_SIZE pages on the specified CSROW number it
2778  *      encompasses
2779  *
2780  */
2781 static u32 get_csrow_nr_pages(struct amd64_pvt *pvt, u8 dct, int csrow_nr_orig)
2782 {
2783         u32 dbam = dct ? pvt->dbam1 : pvt->dbam0;
2784         int csrow_nr = csrow_nr_orig;
2785         u32 cs_mode, nr_pages;
2786
2787         if (!pvt->umc)
2788                 csrow_nr >>= 1;
2789
2790         cs_mode = DBAM_DIMM(csrow_nr, dbam);
2791
2792         nr_pages   = pvt->ops->dbam_to_cs(pvt, dct, cs_mode, csrow_nr);
2793         nr_pages <<= 20 - PAGE_SHIFT;
2794
2795         edac_dbg(0, "csrow: %d, channel: %d, DBAM idx: %d\n",
2796                     csrow_nr_orig, dct,  cs_mode);
2797         edac_dbg(0, "nr_pages/channel: %u\n", nr_pages);
2798
2799         return nr_pages;
2800 }
2801
2802 /*
2803  * Initialize the array of csrow attribute instances, based on the values
2804  * from pci config hardware registers.
2805  */
2806 static int init_csrows(struct mem_ctl_info *mci)
2807 {
2808         struct amd64_pvt *pvt = mci->pvt_info;
2809         enum edac_type edac_mode = EDAC_NONE;
2810         struct csrow_info *csrow;
2811         struct dimm_info *dimm;
2812         int i, j, empty = 1;
2813         int nr_pages = 0;
2814         u32 val;
2815
2816         if (!pvt->umc) {
2817                 amd64_read_pci_cfg(pvt->F3, NBCFG, &val);
2818
2819                 pvt->nbcfg = val;
2820
2821                 edac_dbg(0, "node %d, NBCFG=0x%08x[ChipKillEccCap: %d|DramEccEn: %d]\n",
2822                          pvt->mc_node_id, val,
2823                          !!(val & NBCFG_CHIPKILL), !!(val & NBCFG_ECC_ENABLE));
2824         }
2825
2826         /*
2827          * We iterate over DCT0 here but we look at DCT1 in parallel, if needed.
2828          */
2829         for_each_chip_select(i, 0, pvt) {
2830                 bool row_dct0 = !!csrow_enabled(i, 0, pvt);
2831                 bool row_dct1 = false;
2832
2833                 if (pvt->fam != 0xf)
2834                         row_dct1 = !!csrow_enabled(i, 1, pvt);
2835
2836                 if (!row_dct0 && !row_dct1)
2837                         continue;
2838
2839                 csrow = mci->csrows[i];
2840                 empty = 0;
2841
2842                 edac_dbg(1, "MC node: %d, csrow: %d\n",
2843                             pvt->mc_node_id, i);
2844
2845                 if (row_dct0) {
2846                         nr_pages = get_csrow_nr_pages(pvt, 0, i);
2847                         csrow->channels[0]->dimm->nr_pages = nr_pages;
2848                 }
2849
2850                 /* K8 has only one DCT */
2851                 if (pvt->fam != 0xf && row_dct1) {
2852                         int row_dct1_pages = get_csrow_nr_pages(pvt, 1, i);
2853
2854                         csrow->channels[1]->dimm->nr_pages = row_dct1_pages;
2855                         nr_pages += row_dct1_pages;
2856                 }
2857
2858                 edac_dbg(1, "Total csrow%d pages: %u\n", i, nr_pages);
2859
2860                 /* Determine DIMM ECC mode: */
2861                 if (pvt->umc) {
2862                         if (mci->edac_ctl_cap & EDAC_FLAG_S4ECD4ED)
2863                                 edac_mode = EDAC_S4ECD4ED;
2864                         else if (mci->edac_ctl_cap & EDAC_FLAG_SECDED)
2865                                 edac_mode = EDAC_SECDED;
2866
2867                 } else if (pvt->nbcfg & NBCFG_ECC_ENABLE) {
2868                         edac_mode = (pvt->nbcfg & NBCFG_CHIPKILL)
2869                                         ? EDAC_S4ECD4ED
2870                                         : EDAC_SECDED;
2871                 }
2872
2873                 for (j = 0; j < pvt->channel_count; j++) {
2874                         dimm = csrow->channels[j]->dimm;
2875                         dimm->mtype = pvt->dram_type;
2876                         dimm->edac_mode = edac_mode;
2877                 }
2878         }
2879
2880         return empty;
2881 }
2882
2883 /* get all cores on this DCT */
2884 static void get_cpus_on_this_dct_cpumask(struct cpumask *mask, u16 nid)
2885 {
2886         int cpu;
2887
2888         for_each_online_cpu(cpu)
2889                 if (amd_get_nb_id(cpu) == nid)
2890                         cpumask_set_cpu(cpu, mask);
2891 }
2892
2893 /* check MCG_CTL on all the cpus on this node */
2894 static bool nb_mce_bank_enabled_on_node(u16 nid)
2895 {
2896         cpumask_var_t mask;
2897         int cpu, nbe;
2898         bool ret = false;
2899
2900         if (!zalloc_cpumask_var(&mask, GFP_KERNEL)) {
2901                 amd64_warn("%s: Error allocating mask\n", __func__);
2902                 return false;
2903         }
2904
2905         get_cpus_on_this_dct_cpumask(mask, nid);
2906
2907         rdmsr_on_cpus(mask, MSR_IA32_MCG_CTL, msrs);
2908
2909         for_each_cpu(cpu, mask) {
2910                 struct msr *reg = per_cpu_ptr(msrs, cpu);
2911                 nbe = reg->l & MSR_MCGCTL_NBE;
2912
2913                 edac_dbg(0, "core: %u, MCG_CTL: 0x%llx, NB MSR is %s\n",
2914                          cpu, reg->q,
2915                          (nbe ? "enabled" : "disabled"));
2916
2917                 if (!nbe)
2918                         goto out;
2919         }
2920         ret = true;
2921
2922 out:
2923         free_cpumask_var(mask);
2924         return ret;
2925 }
2926
2927 static int toggle_ecc_err_reporting(struct ecc_settings *s, u16 nid, bool on)
2928 {
2929         cpumask_var_t cmask;
2930         int cpu;
2931
2932         if (!zalloc_cpumask_var(&cmask, GFP_KERNEL)) {
2933                 amd64_warn("%s: error allocating mask\n", __func__);
2934                 return -ENOMEM;
2935         }
2936
2937         get_cpus_on_this_dct_cpumask(cmask, nid);
2938
2939         rdmsr_on_cpus(cmask, MSR_IA32_MCG_CTL, msrs);
2940
2941         for_each_cpu(cpu, cmask) {
2942
2943                 struct msr *reg = per_cpu_ptr(msrs, cpu);
2944
2945                 if (on) {
2946                         if (reg->l & MSR_MCGCTL_NBE)
2947                                 s->flags.nb_mce_enable = 1;
2948
2949                         reg->l |= MSR_MCGCTL_NBE;
2950                 } else {
2951                         /*
2952                          * Turn off NB MCE reporting only when it was off before
2953                          */
2954                         if (!s->flags.nb_mce_enable)
2955                                 reg->l &= ~MSR_MCGCTL_NBE;
2956                 }
2957         }
2958         wrmsr_on_cpus(cmask, MSR_IA32_MCG_CTL, msrs);
2959
2960         free_cpumask_var(cmask);
2961
2962         return 0;
2963 }
2964
2965 static bool enable_ecc_error_reporting(struct ecc_settings *s, u16 nid,
2966                                        struct pci_dev *F3)
2967 {
2968         bool ret = true;
2969         u32 value, mask = 0x3;          /* UECC/CECC enable */
2970
2971         if (toggle_ecc_err_reporting(s, nid, ON)) {
2972                 amd64_warn("Error enabling ECC reporting over MCGCTL!\n");
2973                 return false;
2974         }
2975
2976         amd64_read_pci_cfg(F3, NBCTL, &value);
2977
2978         s->old_nbctl   = value & mask;
2979         s->nbctl_valid = true;
2980
2981         value |= mask;
2982         amd64_write_pci_cfg(F3, NBCTL, value);
2983
2984         amd64_read_pci_cfg(F3, NBCFG, &value);
2985
2986         edac_dbg(0, "1: node %d, NBCFG=0x%08x[DramEccEn: %d]\n",
2987                  nid, value, !!(value & NBCFG_ECC_ENABLE));
2988
2989         if (!(value & NBCFG_ECC_ENABLE)) {
2990                 amd64_warn("DRAM ECC disabled on this node, enabling...\n");
2991
2992                 s->flags.nb_ecc_prev = 0;
2993
2994                 /* Attempt to turn on DRAM ECC Enable */
2995                 value |= NBCFG_ECC_ENABLE;
2996                 amd64_write_pci_cfg(F3, NBCFG, value);
2997
2998                 amd64_read_pci_cfg(F3, NBCFG, &value);
2999
3000                 if (!(value & NBCFG_ECC_ENABLE)) {
3001                         amd64_warn("Hardware rejected DRAM ECC enable,"
3002                                    "check memory DIMM configuration.\n");
3003                         ret = false;
3004                 } else {
3005                         amd64_info("Hardware accepted DRAM ECC Enable\n");
3006                 }
3007         } else {
3008                 s->flags.nb_ecc_prev = 1;
3009         }
3010
3011         edac_dbg(0, "2: node %d, NBCFG=0x%08x[DramEccEn: %d]\n",
3012                  nid, value, !!(value & NBCFG_ECC_ENABLE));
3013
3014         return ret;
3015 }
3016
3017 static void restore_ecc_error_reporting(struct ecc_settings *s, u16 nid,
3018                                         struct pci_dev *F3)
3019 {
3020         u32 value, mask = 0x3;          /* UECC/CECC enable */
3021
3022         if (!s->nbctl_valid)
3023                 return;
3024
3025         amd64_read_pci_cfg(F3, NBCTL, &value);
3026         value &= ~mask;
3027         value |= s->old_nbctl;
3028
3029         amd64_write_pci_cfg(F3, NBCTL, value);
3030
3031         /* restore previous BIOS DRAM ECC "off" setting we force-enabled */
3032         if (!s->flags.nb_ecc_prev) {
3033                 amd64_read_pci_cfg(F3, NBCFG, &value);
3034                 value &= ~NBCFG_ECC_ENABLE;
3035                 amd64_write_pci_cfg(F3, NBCFG, value);
3036         }
3037
3038         /* restore the NB Enable MCGCTL bit */
3039         if (toggle_ecc_err_reporting(s, nid, OFF))
3040                 amd64_warn("Error restoring NB MCGCTL settings!\n");
3041 }
3042
3043 /*
3044  * EDAC requires that the BIOS have ECC enabled before
3045  * taking over the processing of ECC errors. A command line
3046  * option allows to force-enable hardware ECC later in
3047  * enable_ecc_error_reporting().
3048  */
3049 static const char *ecc_msg =
3050         "ECC disabled in the BIOS or no ECC capability, module will not load.\n"
3051         " Either enable ECC checking or force module loading by setting "
3052         "'ecc_enable_override'.\n"
3053         " (Note that use of the override may cause unknown side effects.)\n";
3054
3055 static bool ecc_enabled(struct pci_dev *F3, u16 nid)
3056 {
3057         bool nb_mce_en = false;
3058         u8 ecc_en = 0, i;
3059         u32 value;
3060
3061         if (boot_cpu_data.x86 >= 0x17) {
3062                 u8 umc_en_mask = 0, ecc_en_mask = 0;
3063
3064                 for (i = 0; i < NUM_UMCS; i++) {
3065                         u32 base = get_umc_base(i);
3066
3067                         /* Only check enabled UMCs. */
3068                         if (amd_smn_read(nid, base + UMCCH_SDP_CTRL, &value))
3069                                 continue;
3070
3071                         if (!(value & UMC_SDP_INIT))
3072                                 continue;
3073
3074                         umc_en_mask |= BIT(i);
3075
3076                         if (amd_smn_read(nid, base + UMCCH_UMC_CAP_HI, &value))
3077                                 continue;
3078
3079                         if (value & UMC_ECC_ENABLED)
3080                                 ecc_en_mask |= BIT(i);
3081                 }
3082
3083                 /* Check whether at least one UMC is enabled: */
3084                 if (umc_en_mask)
3085                         ecc_en = umc_en_mask == ecc_en_mask;
3086                 else
3087                         edac_dbg(0, "Node %d: No enabled UMCs.\n", nid);
3088
3089                 /* Assume UMC MCA banks are enabled. */
3090                 nb_mce_en = true;
3091         } else {
3092                 amd64_read_pci_cfg(F3, NBCFG, &value);
3093
3094                 ecc_en = !!(value & NBCFG_ECC_ENABLE);
3095
3096                 nb_mce_en = nb_mce_bank_enabled_on_node(nid);
3097                 if (!nb_mce_en)
3098                         edac_dbg(0, "NB MCE bank disabled, set MSR 0x%08x[4] on node %d to enable.\n",
3099                                      MSR_IA32_MCG_CTL, nid);
3100         }
3101
3102         amd64_info("Node %d: DRAM ECC %s.\n",
3103                    nid, (ecc_en ? "enabled" : "disabled"));
3104
3105         if (!ecc_en || !nb_mce_en) {
3106                 amd64_info("%s", ecc_msg);
3107                 return false;
3108         }
3109         return true;
3110 }
3111
3112 static inline void
3113 f17h_determine_edac_ctl_cap(struct mem_ctl_info *mci, struct amd64_pvt *pvt)
3114 {
3115         u8 i, ecc_en = 1, cpk_en = 1;
3116
3117         for (i = 0; i < NUM_UMCS; i++) {
3118                 if (pvt->umc[i].sdp_ctrl & UMC_SDP_INIT) {
3119                         ecc_en &= !!(pvt->umc[i].umc_cap_hi & UMC_ECC_ENABLED);
3120                         cpk_en &= !!(pvt->umc[i].umc_cap_hi & UMC_ECC_CHIPKILL_CAP);
3121                 }
3122         }
3123
3124         /* Set chipkill only if ECC is enabled: */
3125         if (ecc_en) {
3126                 mci->edac_ctl_cap |= EDAC_FLAG_SECDED;
3127
3128                 if (cpk_en)
3129                         mci->edac_ctl_cap |= EDAC_FLAG_S4ECD4ED;
3130         }
3131 }
3132
3133 static void setup_mci_misc_attrs(struct mem_ctl_info *mci,
3134                                  struct amd64_family_type *fam)
3135 {
3136         struct amd64_pvt *pvt = mci->pvt_info;
3137
3138         mci->mtype_cap          = MEM_FLAG_DDR2 | MEM_FLAG_RDDR2;
3139         mci->edac_ctl_cap       = EDAC_FLAG_NONE;
3140
3141         if (pvt->umc) {
3142                 f17h_determine_edac_ctl_cap(mci, pvt);
3143         } else {
3144                 if (pvt->nbcap & NBCAP_SECDED)
3145                         mci->edac_ctl_cap |= EDAC_FLAG_SECDED;
3146
3147                 if (pvt->nbcap & NBCAP_CHIPKILL)
3148                         mci->edac_ctl_cap |= EDAC_FLAG_S4ECD4ED;
3149         }
3150
3151         mci->edac_cap           = determine_edac_cap(pvt);
3152         mci->mod_name           = EDAC_MOD_STR;
3153         mci->ctl_name           = fam->ctl_name;
3154         mci->dev_name           = pci_name(pvt->F3);
3155         mci->ctl_page_to_phys   = NULL;
3156
3157         /* memory scrubber interface */
3158         mci->set_sdram_scrub_rate = set_scrub_rate;
3159         mci->get_sdram_scrub_rate = get_scrub_rate;
3160 }
3161
3162 /*
3163  * returns a pointer to the family descriptor on success, NULL otherwise.
3164  */
3165 static struct amd64_family_type *per_family_init(struct amd64_pvt *pvt)
3166 {
3167         struct amd64_family_type *fam_type = NULL;
3168
3169         pvt->ext_model  = boot_cpu_data.x86_model >> 4;
3170         pvt->stepping   = boot_cpu_data.x86_stepping;
3171         pvt->model      = boot_cpu_data.x86_model;
3172         pvt->fam        = boot_cpu_data.x86;
3173
3174         switch (pvt->fam) {
3175         case 0xf:
3176                 fam_type        = &family_types[K8_CPUS];
3177                 pvt->ops        = &family_types[K8_CPUS].ops;
3178                 break;
3179
3180         case 0x10:
3181                 fam_type        = &family_types[F10_CPUS];
3182                 pvt->ops        = &family_types[F10_CPUS].ops;
3183                 break;
3184
3185         case 0x15:
3186                 if (pvt->model == 0x30) {
3187                         fam_type = &family_types[F15_M30H_CPUS];
3188                         pvt->ops = &family_types[F15_M30H_CPUS].ops;
3189                         break;
3190                 } else if (pvt->model == 0x60) {
3191                         fam_type = &family_types[F15_M60H_CPUS];
3192                         pvt->ops = &family_types[F15_M60H_CPUS].ops;
3193                         break;
3194                 }
3195
3196                 fam_type        = &family_types[F15_CPUS];
3197                 pvt->ops        = &family_types[F15_CPUS].ops;
3198                 break;
3199
3200         case 0x16:
3201                 if (pvt->model == 0x30) {
3202                         fam_type = &family_types[F16_M30H_CPUS];
3203                         pvt->ops = &family_types[F16_M30H_CPUS].ops;
3204                         break;
3205                 }
3206                 fam_type        = &family_types[F16_CPUS];
3207                 pvt->ops        = &family_types[F16_CPUS].ops;
3208                 break;
3209
3210         case 0x17:
3211                 if (pvt->model >= 0x10 && pvt->model <= 0x2f) {
3212                         fam_type = &family_types[F17_M10H_CPUS];
3213                         pvt->ops = &family_types[F17_M10H_CPUS].ops;
3214                         break;
3215                 } else if (pvt->model >= 0x30 && pvt->model <= 0x3f) {
3216                         fam_type = &family_types[F17_M30H_CPUS];
3217                         pvt->ops = &family_types[F17_M30H_CPUS].ops;
3218                         break;
3219                 }
3220                 /* fall through */
3221         case 0x18:
3222                 fam_type        = &family_types[F17_CPUS];
3223                 pvt->ops        = &family_types[F17_CPUS].ops;
3224
3225                 if (pvt->fam == 0x18)
3226                         family_types[F17_CPUS].ctl_name = "F18h";
3227                 break;
3228
3229         default:
3230                 amd64_err("Unsupported family!\n");
3231                 return NULL;
3232         }
3233
3234         amd64_info("%s %sdetected (node %d).\n", fam_type->ctl_name,
3235                      (pvt->fam == 0xf ?
3236                                 (pvt->ext_model >= K8_REV_F  ? "revF or later "
3237                                                              : "revE or earlier ")
3238                                  : ""), pvt->mc_node_id);
3239         return fam_type;
3240 }
3241
3242 static const struct attribute_group *amd64_edac_attr_groups[] = {
3243 #ifdef CONFIG_EDAC_DEBUG
3244         &amd64_edac_dbg_group,
3245 #endif
3246 #ifdef CONFIG_EDAC_AMD64_ERROR_INJECTION
3247         &amd64_edac_inj_group,
3248 #endif
3249         NULL
3250 };
3251
3252 static int init_one_instance(unsigned int nid)
3253 {
3254         struct pci_dev *F3 = node_to_amd_nb(nid)->misc;
3255         struct amd64_family_type *fam_type = NULL;
3256         struct mem_ctl_info *mci = NULL;
3257         struct edac_mc_layer layers[2];
3258         struct amd64_pvt *pvt = NULL;
3259         u16 pci_id1, pci_id2;
3260         int err = 0, ret;
3261
3262         ret = -ENOMEM;
3263         pvt = kzalloc(sizeof(struct amd64_pvt), GFP_KERNEL);
3264         if (!pvt)
3265                 goto err_ret;
3266
3267         pvt->mc_node_id = nid;
3268         pvt->F3 = F3;
3269
3270         ret = -EINVAL;
3271         fam_type = per_family_init(pvt);
3272         if (!fam_type)
3273                 goto err_free;
3274
3275         if (pvt->fam >= 0x17) {
3276                 pvt->umc = kcalloc(NUM_UMCS, sizeof(struct amd64_umc), GFP_KERNEL);
3277                 if (!pvt->umc) {
3278                         ret = -ENOMEM;
3279                         goto err_free;
3280                 }
3281
3282                 pci_id1 = fam_type->f0_id;
3283                 pci_id2 = fam_type->f6_id;
3284         } else {
3285                 pci_id1 = fam_type->f1_id;
3286                 pci_id2 = fam_type->f2_id;
3287         }
3288
3289         err = reserve_mc_sibling_devs(pvt, pci_id1, pci_id2);
3290         if (err)
3291                 goto err_post_init;
3292
3293         read_mc_regs(pvt);
3294
3295         /*
3296          * We need to determine how many memory channels there are. Then use
3297          * that information for calculating the size of the dynamic instance
3298          * tables in the 'mci' structure.
3299          */
3300         ret = -EINVAL;
3301         pvt->channel_count = pvt->ops->early_channel_count(pvt);
3302         if (pvt->channel_count < 0)
3303                 goto err_siblings;
3304
3305         ret = -ENOMEM;
3306         layers[0].type = EDAC_MC_LAYER_CHIP_SELECT;
3307         layers[0].size = pvt->csels[0].b_cnt;
3308         layers[0].is_virt_csrow = true;
3309         layers[1].type = EDAC_MC_LAYER_CHANNEL;
3310
3311         /*
3312          * Always allocate two channels since we can have setups with DIMMs on
3313          * only one channel. Also, this simplifies handling later for the price
3314          * of a couple of KBs tops.
3315          */
3316         layers[1].size = 2;
3317         layers[1].is_virt_csrow = false;
3318
3319         mci = edac_mc_alloc(nid, ARRAY_SIZE(layers), layers, 0);
3320         if (!mci)
3321                 goto err_siblings;
3322
3323         mci->pvt_info = pvt;
3324         mci->pdev = &pvt->F3->dev;
3325
3326         setup_mci_misc_attrs(mci, fam_type);
3327
3328         if (init_csrows(mci))
3329                 mci->edac_cap = EDAC_FLAG_NONE;
3330
3331         ret = -ENODEV;
3332         if (edac_mc_add_mc_with_groups(mci, amd64_edac_attr_groups)) {
3333                 edac_dbg(1, "failed edac_mc_add_mc()\n");
3334                 goto err_add_mc;
3335         }
3336
3337         return 0;
3338
3339 err_add_mc:
3340         edac_mc_free(mci);
3341
3342 err_siblings:
3343         free_mc_sibling_devs(pvt);
3344
3345 err_post_init:
3346         if (pvt->fam >= 0x17)
3347                 kfree(pvt->umc);
3348
3349 err_free:
3350         kfree(pvt);
3351
3352 err_ret:
3353         return ret;
3354 }
3355
3356 static int probe_one_instance(unsigned int nid)
3357 {
3358         struct pci_dev *F3 = node_to_amd_nb(nid)->misc;
3359         struct ecc_settings *s;
3360         int ret;
3361
3362         ret = -ENOMEM;
3363         s = kzalloc(sizeof(struct ecc_settings), GFP_KERNEL);
3364         if (!s)
3365                 goto err_out;
3366
3367         ecc_stngs[nid] = s;
3368
3369         if (!ecc_enabled(F3, nid)) {
3370                 ret = 0;
3371
3372                 if (!ecc_enable_override)
3373                         goto err_enable;
3374
3375                 if (boot_cpu_data.x86 >= 0x17) {
3376                         amd64_warn("Forcing ECC on is not recommended on newer systems. Please enable ECC in BIOS.");
3377                         goto err_enable;
3378                 } else
3379                         amd64_warn("Forcing ECC on!\n");
3380
3381                 if (!enable_ecc_error_reporting(s, nid, F3))
3382                         goto err_enable;
3383         }
3384
3385         ret = init_one_instance(nid);
3386         if (ret < 0) {
3387                 amd64_err("Error probing instance: %d\n", nid);
3388
3389                 if (boot_cpu_data.x86 < 0x17)
3390                         restore_ecc_error_reporting(s, nid, F3);
3391
3392                 goto err_enable;
3393         }
3394
3395         return ret;
3396
3397 err_enable:
3398         kfree(s);
3399         ecc_stngs[nid] = NULL;
3400
3401 err_out:
3402         return ret;
3403 }
3404
3405 static void remove_one_instance(unsigned int nid)
3406 {
3407         struct pci_dev *F3 = node_to_amd_nb(nid)->misc;
3408         struct ecc_settings *s = ecc_stngs[nid];
3409         struct mem_ctl_info *mci;
3410         struct amd64_pvt *pvt;
3411
3412         mci = find_mci_by_dev(&F3->dev);
3413         WARN_ON(!mci);
3414
3415         /* Remove from EDAC CORE tracking list */
3416         mci = edac_mc_del_mc(&F3->dev);
3417         if (!mci)
3418                 return;
3419
3420         pvt = mci->pvt_info;
3421
3422         restore_ecc_error_reporting(s, nid, F3);
3423
3424         free_mc_sibling_devs(pvt);
3425
3426         kfree(ecc_stngs[nid]);
3427         ecc_stngs[nid] = NULL;
3428
3429         /* Free the EDAC CORE resources */
3430         mci->pvt_info = NULL;
3431
3432         kfree(pvt);
3433         edac_mc_free(mci);
3434 }
3435
3436 static void setup_pci_device(void)
3437 {
3438         struct mem_ctl_info *mci;
3439         struct amd64_pvt *pvt;
3440
3441         if (pci_ctl)
3442                 return;
3443
3444         mci = edac_mc_find(0);
3445         if (!mci)
3446                 return;
3447
3448         pvt = mci->pvt_info;
3449         if (pvt->umc)
3450                 pci_ctl = edac_pci_create_generic_ctl(&pvt->F0->dev, EDAC_MOD_STR);
3451         else
3452                 pci_ctl = edac_pci_create_generic_ctl(&pvt->F2->dev, EDAC_MOD_STR);
3453         if (!pci_ctl) {
3454                 pr_warn("%s(): Unable to create PCI control\n", __func__);
3455                 pr_warn("%s(): PCI error report via EDAC not set\n", __func__);
3456         }
3457 }
3458
3459 static const struct x86_cpu_id amd64_cpuids[] = {
3460         { X86_VENDOR_AMD, 0xF,  X86_MODEL_ANY,  X86_FEATURE_ANY, 0 },
3461         { X86_VENDOR_AMD, 0x10, X86_MODEL_ANY,  X86_FEATURE_ANY, 0 },
3462         { X86_VENDOR_AMD, 0x15, X86_MODEL_ANY,  X86_FEATURE_ANY, 0 },
3463         { X86_VENDOR_AMD, 0x16, X86_MODEL_ANY,  X86_FEATURE_ANY, 0 },
3464         { X86_VENDOR_AMD, 0x17, X86_MODEL_ANY,  X86_FEATURE_ANY, 0 },
3465         { X86_VENDOR_HYGON, 0x18, X86_MODEL_ANY, X86_FEATURE_ANY, 0 },
3466         { }
3467 };
3468 MODULE_DEVICE_TABLE(x86cpu, amd64_cpuids);
3469
3470 static int __init amd64_edac_init(void)
3471 {
3472         const char *owner;
3473         int err = -ENODEV;
3474         int i;
3475
3476         owner = edac_get_owner();
3477         if (owner && strncmp(owner, EDAC_MOD_STR, sizeof(EDAC_MOD_STR)))
3478                 return -EBUSY;
3479
3480         if (!x86_match_cpu(amd64_cpuids))
3481                 return -ENODEV;
3482
3483         if (amd_cache_northbridges() < 0)
3484                 return -ENODEV;
3485
3486         opstate_init();
3487
3488         err = -ENOMEM;
3489         ecc_stngs = kcalloc(amd_nb_num(), sizeof(ecc_stngs[0]), GFP_KERNEL);
3490         if (!ecc_stngs)
3491                 goto err_free;
3492
3493         msrs = msrs_alloc();
3494         if (!msrs)
3495                 goto err_free;
3496
3497         for (i = 0; i < amd_nb_num(); i++) {
3498                 err = probe_one_instance(i);
3499                 if (err) {
3500                         /* unwind properly */
3501                         while (--i >= 0)
3502                                 remove_one_instance(i);
3503
3504                         goto err_pci;
3505                 }
3506         }
3507
3508         if (!edac_has_mcs()) {
3509                 err = -ENODEV;
3510                 goto err_pci;
3511         }
3512
3513         /* register stuff with EDAC MCE */
3514         if (report_gart_errors)
3515                 amd_report_gart_errors(true);
3516
3517         if (boot_cpu_data.x86 >= 0x17)
3518                 amd_register_ecc_decoder(decode_umc_error);
3519         else
3520                 amd_register_ecc_decoder(decode_bus_error);
3521
3522         setup_pci_device();
3523
3524 #ifdef CONFIG_X86_32
3525         amd64_err("%s on 32-bit is unsupported. USE AT YOUR OWN RISK!\n", EDAC_MOD_STR);
3526 #endif
3527
3528         printk(KERN_INFO "AMD64 EDAC driver v%s\n", EDAC_AMD64_VERSION);
3529
3530         return 0;
3531
3532 err_pci:
3533         msrs_free(msrs);
3534         msrs = NULL;
3535
3536 err_free:
3537         kfree(ecc_stngs);
3538         ecc_stngs = NULL;
3539
3540         return err;
3541 }
3542
3543 static void __exit amd64_edac_exit(void)
3544 {
3545         int i;
3546
3547         if (pci_ctl)
3548                 edac_pci_release_generic_ctl(pci_ctl);
3549
3550         /* unregister from EDAC MCE */
3551         amd_report_gart_errors(false);
3552
3553         if (boot_cpu_data.x86 >= 0x17)
3554                 amd_unregister_ecc_decoder(decode_umc_error);
3555         else
3556                 amd_unregister_ecc_decoder(decode_bus_error);
3557
3558         for (i = 0; i < amd_nb_num(); i++)
3559                 remove_one_instance(i);
3560
3561         kfree(ecc_stngs);
3562         ecc_stngs = NULL;
3563
3564         msrs_free(msrs);
3565         msrs = NULL;
3566 }
3567
3568 module_init(amd64_edac_init);
3569 module_exit(amd64_edac_exit);
3570
3571 MODULE_LICENSE("GPL");
3572 MODULE_AUTHOR("SoftwareBitMaker: Doug Thompson, "
3573                 "Dave Peterson, Thayne Harbaugh");
3574 MODULE_DESCRIPTION("MC support for AMD64 memory controllers - "
3575                 EDAC_AMD64_VERSION);
3576
3577 module_param(edac_op_state, int, 0444);
3578 MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");