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