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