drivers/edac/amd64_edac.c

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