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, K8_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, K8_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 static u16 extract_syndrome(struct err_regs *err)
 792 {
 793         return ((err->nbsh >> 15) & 0xff) | ((err->nbsl >> 16) & 0xff00);
 794 }
 795
 796 /*
 797  * Determine if the DIMMs have ECC enabled. ECC is enabled ONLY if all the DIMMs
 798  * are ECC capable.
 799  */
 800 static enum edac_type amd64_determine_edac_cap(struct amd64_pvt *pvt)
 801 {
 802         int bit;
 803         enum dev_type edac_cap = EDAC_FLAG_NONE;
 804
 805         bit = (boot_cpu_data.x86 > 0xf || pvt->ext_model >= K8_REV_F)
 806                 ? 19
 807                 : 17;
 808
 809         if (pvt->dclr0 & BIT(bit))
 810                 edac_cap = EDAC_FLAG_SECDED;
 811
 812         return edac_cap;
 813 }
 814
 815
 816 static void amd64_debug_display_dimm_sizes(int ctrl, struct amd64_pvt *pvt);
 817
 818 static void amd64_dump_dramcfg_low(u32 dclr, int chan)
 819 {
 820         debugf1("F2x%d90 (DRAM Cfg Low): 0x%08x\n", chan, dclr);
 821
 822         debugf1("  DIMM type: %sbuffered; all DIMMs support ECC: %s\n",
 823                 (dclr & BIT(16)) ?  "un" : "",
 824                 (dclr & BIT(19)) ? "yes" : "no");
 825
 826         debugf1("  PAR/ERR parity: %s\n",
 827                 (dclr & BIT(8)) ?  "enabled" : "disabled");
 828
 829         debugf1("  DCT 128bit mode width: %s\n",
 830                 (dclr & BIT(11)) ?  "128b" : "64b");
 831
 832         debugf1("  x4 logical DIMMs present: L0: %s L1: %s L2: %s L3: %s\n",
 833                 (dclr & BIT(12)) ?  "yes" : "no",
 834                 (dclr & BIT(13)) ?  "yes" : "no",
 835                 (dclr & BIT(14)) ?  "yes" : "no",
 836                 (dclr & BIT(15)) ?  "yes" : "no");
 837 }
 838
 839 /* Display and decode various NB registers for debug purposes. */
 840 static void dump_misc_regs(struct amd64_pvt *pvt)
 841 {
 842         debugf1("F3xE8 (NB Cap): 0x%08x\n", pvt->nbcap);
 843
 844         debugf1("  NB two channel DRAM capable: %s\n",
 845                 (pvt->nbcap & K8_NBCAP_DCT_DUAL) ? "yes" : "no");
 846
 847         debugf1("  ECC capable: %s, ChipKill ECC capable: %s\n",
 848                 (pvt->nbcap & K8_NBCAP_SECDED) ? "yes" : "no",
 849                 (pvt->nbcap & K8_NBCAP_CHIPKILL) ? "yes" : "no");
 850
 851         amd64_dump_dramcfg_low(pvt->dclr0, 0);
 852
 853         debugf1("F3xB0 (Online Spare): 0x%08x\n", pvt->online_spare);
 854
 855         debugf1("F1xF0 (DRAM Hole Address): 0x%08x, base: 0x%08x, "
 856                         "offset: 0x%08x\n",
 857                         pvt->dhar, dhar_base(pvt),
 858                         (boot_cpu_data.x86 == 0xf) ? k8_dhar_offset(pvt)
 859                                                    : f10_dhar_offset(pvt));
 860
 861         debugf1("  DramHoleValid: %s\n", dhar_valid(pvt) ? "yes" : "no");
 862
 863         amd64_debug_display_dimm_sizes(0, pvt);
 864
 865         /* everything below this point is Fam10h and above */
 866         if (boot_cpu_data.x86 == 0xf)
 867                 return;
 868
 869         amd64_debug_display_dimm_sizes(1, pvt);
 870
 871         amd64_info("using %s syndromes.\n", ((pvt->syn_type == 8) ? "x8" : "x4"));
 872
 873         /* Only if NOT ganged does dclr1 have valid info */
 874         if (!dct_ganging_enabled(pvt))
 875                 amd64_dump_dramcfg_low(pvt->dclr1, 1);
 876 }
 877
 878 /*
 879  * see BKDG, F2x[1,0][5C:40], F2[1,0][6C:60]
 880  */
 881 static void prep_chip_selects(struct amd64_pvt *pvt)
 882 {
 883         if (boot_cpu_data.x86 == 0xf && pvt->ext_model < K8_REV_F) {
 884                 pvt->csels[0].b_cnt = pvt->csels[1].b_cnt = 8;
 885                 pvt->csels[0].m_cnt = pvt->csels[1].m_cnt = 8;
 886         } else {
 887                 pvt->csels[0].b_cnt = pvt->csels[1].b_cnt = 8;
 888                 pvt->csels[0].m_cnt = pvt->csels[1].m_cnt = 4;
 889         }
 890 }
 891
 892 /*
 893  * Function 2 Offset F10_DCSB0; read in the DCS Base and DCS Mask registers
 894  */
 895 static void read_dct_base_mask(struct amd64_pvt *pvt)
 896 {
 897         int cs;
 898
 899         prep_chip_selects(pvt);
 900
 901         for_each_chip_select(cs, 0, pvt) {
 902                 u32 reg0   = DCSB0 + (cs * 4);
 903                 u32 reg1   = DCSB1 + (cs * 4);
 904                 u32 *base0 = &pvt->csels[0].csbases[cs];
 905                 u32 *base1 = &pvt->csels[1].csbases[cs];
 906
 907                 if (!amd64_read_dct_pci_cfg(pvt, reg0, base0))
 908                         debugf0("  DCSB0[%d]=0x%08x reg: F2x%x\n",
 909                                 cs, *base0, reg0);
 910
 911                 if (boot_cpu_data.x86 == 0xf || dct_ganging_enabled(pvt))
 912                         continue;
 913
 914                 if (!amd64_read_dct_pci_cfg(pvt, reg1, base1))
 915                         debugf0("  DCSB1[%d]=0x%08x reg: F2x%x\n",
 916                                 cs, *base1, reg1);
 917         }
 918
 919         for_each_chip_select_mask(cs, 0, pvt) {
 920                 u32 reg0   = DCSM0 + (cs * 4);
 921                 u32 reg1   = DCSM1 + (cs * 4);
 922                 u32 *mask0 = &pvt->csels[0].csmasks[cs];
 923                 u32 *mask1 = &pvt->csels[1].csmasks[cs];
 924
 925                 if (!amd64_read_dct_pci_cfg(pvt, reg0, mask0))
 926                         debugf0("    DCSM0[%d]=0x%08x reg: F2x%x\n",
 927                                 cs, *mask0, reg0);
 928
 929                 if (boot_cpu_data.x86 == 0xf || dct_ganging_enabled(pvt))
 930                         continue;
 931
 932                 if (!amd64_read_dct_pci_cfg(pvt, reg1, mask1))
 933                         debugf0("    DCSM1[%d]=0x%08x reg: F2x%x\n",
 934                                 cs, *mask1, reg1);
 935         }
 936 }
 937
 938 static enum mem_type amd64_determine_memory_type(struct amd64_pvt *pvt, int cs)
 939 {
 940         enum mem_type type;
 941
 942         if (boot_cpu_data.x86 >= 0x10 || pvt->ext_model >= K8_REV_F) {
 943                 if (pvt->dchr0 & DDR3_MODE)
 944                         type = (pvt->dclr0 & BIT(16)) ? MEM_DDR3 : MEM_RDDR3;
 945                 else
 946                         type = (pvt->dclr0 & BIT(16)) ? MEM_DDR2 : MEM_RDDR2;
 947         } else {
 948                 type = (pvt->dclr0 & BIT(18)) ? MEM_DDR : MEM_RDDR;
 949         }
 950
 951         amd64_info("CS%d: %s\n", cs, edac_mem_types[type]);
 952
 953         return type;
 954 }
 955
 956 /*
 957  * Read the DRAM Configuration Low register. It differs between CG, D & E revs
 958  * and the later RevF memory controllers (DDR vs DDR2)
 959  *
 960  * Return:
 961  *      number of memory channels in operation
 962  * Pass back:
 963  *      contents of the DCL0_LOW register
 964  */
 965 static int k8_early_channel_count(struct amd64_pvt *pvt)
 966 {
 967         int flag, err = 0;
 968
 969         err = amd64_read_dct_pci_cfg(pvt, F10_DCLR_0, &pvt->dclr0);
 970         if (err)
 971                 return err;
 972
 973         if (pvt->ext_model >= K8_REV_F)
 974                 /* RevF (NPT) and later */
 975                 flag = pvt->dclr0 & F10_WIDTH_128;
 976         else
 977                 /* RevE and earlier */
 978                 flag = pvt->dclr0 & REVE_WIDTH_128;
 979
 980         /* not used */
 981         pvt->dclr1 = 0;
 982
 983         return (flag) ? 2 : 1;
 984 }
 985
 986 /* extract the ERROR ADDRESS for the K8 CPUs */
 987 static u64 k8_get_error_address(struct mem_ctl_info *mci,
 988                                 struct err_regs *info)
 989 {
 990         return (((u64) (info->nbeah & 0xff)) << 32) +
 991                         (info->nbeal & ~0x03);
 992 }
 993
 994 static void read_dram_base_limit_regs(struct amd64_pvt *pvt, unsigned range)
 995 {
 996         u32 off = range << 3;
 997
 998         amd64_read_pci_cfg(pvt->F1, DRAM_BASE_LO + off,  &pvt->ranges[range].base.lo);
 999         amd64_read_pci_cfg(pvt->F1, DRAM_LIMIT_LO + off, &pvt->ranges[range].lim.lo);
1000
1001         if (boot_cpu_data.x86 == 0xf)
1002                 return;
1003
1004         if (!dram_rw(pvt, range))
1005                 return;
1006
1007         amd64_read_pci_cfg(pvt->F1, DRAM_BASE_HI + off,  &pvt->ranges[range].base.hi);
1008         amd64_read_pci_cfg(pvt->F1, DRAM_LIMIT_HI + off, &pvt->ranges[range].lim.hi);
1009 }
1010
1011 static void k8_map_sysaddr_to_csrow(struct mem_ctl_info *mci,
1012                                     struct err_regs *err_info, u64 sys_addr)
1013 {
1014         struct mem_ctl_info *src_mci;
1015         int channel, csrow;
1016         u32 page, offset;
1017         u16 syndrome;
1018
1019         syndrome = extract_syndrome(err_info);
1020
1021         /* CHIPKILL enabled */
1022         if (err_info->nbcfg & K8_NBCFG_CHIPKILL) {
1023                 channel = get_channel_from_ecc_syndrome(mci, syndrome);
1024                 if (channel < 0) {
1025                         /*
1026                          * Syndrome didn't map, so we don't know which of the
1027                          * 2 DIMMs is in error. So we need to ID 'both' of them
1028                          * as suspect.
1029                          */
1030                         amd64_mc_warn(mci, "unknown syndrome 0x%04x - possible "
1031                                            "error reporting race\n", syndrome);
1032                         edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR);
1033                         return;
1034                 }
1035         } else {
1036                 /*
1037                  * non-chipkill ecc mode
1038                  *
1039                  * The k8 documentation is unclear about how to determine the
1040                  * channel number when using non-chipkill memory.  This method
1041                  * was obtained from email communication with someone at AMD.
1042                  * (Wish the email was placed in this comment - norsk)
1043                  */
1044                 channel = ((sys_addr & BIT(3)) != 0);
1045         }
1046
1047         /*
1048          * Find out which node the error address belongs to. This may be
1049          * different from the node that detected the error.
1050          */
1051         src_mci = find_mc_by_sys_addr(mci, sys_addr);
1052         if (!src_mci) {
1053                 amd64_mc_err(mci, "failed to map error addr 0x%lx to a node\n",
1054                              (unsigned long)sys_addr);
1055                 edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR);
1056                 return;
1057         }
1058
1059         /* Now map the sys_addr to a CSROW */
1060         csrow = sys_addr_to_csrow(src_mci, sys_addr);
1061         if (csrow < 0) {
1062                 edac_mc_handle_ce_no_info(src_mci, EDAC_MOD_STR);
1063         } else {
1064                 error_address_to_page_and_offset(sys_addr, &page, &offset);
1065
1066                 edac_mc_handle_ce(src_mci, page, offset, syndrome, csrow,
1067                                   channel, EDAC_MOD_STR);
1068         }
1069 }
1070
1071 static int k8_dbam_to_chip_select(struct amd64_pvt *pvt, int cs_mode)
1072 {
1073         int *dbam_map;
1074
1075         if (pvt->ext_model >= K8_REV_F)
1076                 dbam_map = ddr2_dbam;
1077         else if (pvt->ext_model >= K8_REV_D)
1078                 dbam_map = ddr2_dbam_revD;
1079         else
1080                 dbam_map = ddr2_dbam_revCG;
1081
1082         return dbam_map[cs_mode];
1083 }
1084
1085 /*
1086  * Get the number of DCT channels in use.
1087  *
1088  * Return:
1089  *      number of Memory Channels in operation
1090  * Pass back:
1091  *      contents of the DCL0_LOW register
1092  */
1093 static int f10_early_channel_count(struct amd64_pvt *pvt)
1094 {
1095         int i, j, channels = 0;
1096
1097         /* If we are in 128 bit mode, then we are using 2 channels */
1098         if (pvt->dclr0 & F10_WIDTH_128) {
1099                 channels = 2;
1100                 return channels;
1101         }
1102
1103         /*
1104          * Need to check if in unganged mode: In such, there are 2 channels,
1105          * but they are not in 128 bit mode and thus the above 'dclr0' status
1106          * bit will be OFF.
1107          *
1108          * Need to check DCT0[0] and DCT1[0] to see if only one of them has
1109          * their CSEnable bit on. If so, then SINGLE DIMM case.
1110          */
1111         debugf0("Data width is not 128 bits - need more decoding\n");
1112
1113         /*
1114          * Check DRAM Bank Address Mapping values for each DIMM to see if there
1115          * is more than just one DIMM present in unganged mode. Need to check
1116          * both controllers since DIMMs can be placed in either one.
1117          */
1118         for (i = 0; i < 2; i++) {
1119                 u32 dbam = (i ? pvt->dbam1 : pvt->dbam0);
1120
1121                 for (j = 0; j < 4; j++) {
1122                         if (DBAM_DIMM(j, dbam) > 0) {
1123                                 channels++;
1124                                 break;
1125                         }
1126                 }
1127         }
1128
1129         if (channels > 2)
1130                 channels = 2;
1131
1132         amd64_info("MCT channel count: %d\n", channels);
1133
1134         return channels;
1135 }
1136
1137 static int f10_dbam_to_chip_select(struct amd64_pvt *pvt, int cs_mode)
1138 {
1139         int *dbam_map;
1140
1141         if (pvt->dchr0 & DDR3_MODE || pvt->dchr1 & DDR3_MODE)
1142                 dbam_map = ddr3_dbam;
1143         else
1144                 dbam_map = ddr2_dbam;
1145
1146         return dbam_map[cs_mode];
1147 }
1148
1149 static u64 f10_get_error_address(struct mem_ctl_info *mci,
1150                         struct err_regs *info)
1151 {
1152         return (((u64) (info->nbeah & 0xffff)) << 32) +
1153                         (info->nbeal & ~0x01);
1154 }
1155
1156 static void f10_read_dram_ctl_register(struct amd64_pvt *pvt)
1157 {
1158
1159         if (!amd64_read_dct_pci_cfg(pvt, F10_DCTL_SEL_LOW, &pvt->dct_sel_low)) {
1160                 debugf0("F2x110 (DCTL Sel. Low): 0x%08x, High range addrs at: 0x%x\n",
1161                         pvt->dct_sel_low, dct_sel_baseaddr(pvt));
1162
1163                 debugf0("  DCT mode: %s, All DCTs on: %s\n",
1164                         (dct_ganging_enabled(pvt) ? "ganged" : "unganged"),
1165                         (dct_dram_enabled(pvt) ? "yes"   : "no"));
1166
1167                 if (!dct_ganging_enabled(pvt))
1168                         debugf0("  Address range split per DCT: %s\n",
1169                                 (dct_high_range_enabled(pvt) ? "yes" : "no"));
1170
1171                 debugf0("  DCT data interleave for ECC: %s, "
1172                         "DRAM cleared since last warm reset: %s\n",
1173                         (dct_data_intlv_enabled(pvt) ? "enabled" : "disabled"),
1174                         (dct_memory_cleared(pvt) ? "yes" : "no"));
1175
1176                 debugf0("  DCT channel interleave: %s, "
1177                         "DCT interleave bits selector: 0x%x\n",
1178                         (dct_interleave_enabled(pvt) ? "enabled" : "disabled"),
1179                         dct_sel_interleave_addr(pvt));
1180         }
1181
1182         amd64_read_dct_pci_cfg(pvt, F10_DCTL_SEL_HIGH, &pvt->dct_sel_hi);
1183 }
1184
1185 /*
1186  * Determine channel (DCT) based on the interleaving mode: F10h BKDG, 2.8.9 Memory
1187  * Interleaving Modes.
1188  */
1189 static u8 f10_determine_channel(struct amd64_pvt *pvt, u64 sys_addr,
1190                                 bool hi_range_sel, u8 intlv_en)
1191 {
1192         u32 dct_sel_high = (pvt->dct_sel_low >> 1) & 1;
1193
1194         if (dct_ganging_enabled(pvt))
1195                 return 0;
1196
1197         if (hi_range_sel)
1198                 return dct_sel_high;
1199
1200         /*
1201          * see F2x110[DctSelIntLvAddr] - channel interleave mode
1202          */
1203         if (dct_interleave_enabled(pvt)) {
1204                 u8 intlv_addr = dct_sel_interleave_addr(pvt);
1205
1206                 /* return DCT select function: 0=DCT0, 1=DCT1 */
1207                 if (!intlv_addr)
1208                         return sys_addr >> 6 & 1;
1209
1210                 if (intlv_addr & 0x2) {
1211                         u8 shift = intlv_addr & 0x1 ? 9 : 6;
1212                         u32 temp = hweight_long((u32) ((sys_addr >> 16) & 0x1F)) % 2;
1213
1214                         return ((sys_addr >> shift) & 1) ^ temp;
1215                 }
1216
1217                 return (sys_addr >> (12 + hweight8(intlv_en))) & 1;
1218         }
1219
1220         if (dct_high_range_enabled(pvt))
1221                 return ~dct_sel_high & 1;
1222
1223         return 0;
1224 }
1225
1226 /* Convert the sys_addr to the normalized DCT address */
1227 static u64 f10_get_norm_dct_addr(struct amd64_pvt *pvt, int range,
1228                                  u64 sys_addr, bool hi_rng,
1229                                  u32 dct_sel_base_addr)
1230 {
1231         u64 chan_off;
1232         u64 dram_base           = get_dram_base(pvt, range);
1233         u64 hole_off            = f10_dhar_offset(pvt);
1234         u32 hole_valid          = dhar_valid(pvt);
1235         u64 dct_sel_base_off    = (pvt->dct_sel_hi & 0xFFFFFC00) << 16;
1236
1237         if (hi_rng) {
1238                 /*
1239                  * if
1240                  * base address of high range is below 4Gb
1241                  * (bits [47:27] at [31:11])
1242                  * DRAM address space on this DCT is hoisted above 4Gb  &&
1243                  * sys_addr > 4Gb
1244                  *
1245                  *      remove hole offset from sys_addr
1246                  * else
1247                  *      remove high range offset from sys_addr
1248                  */
1249                 if ((!(dct_sel_base_addr >> 16) ||
1250                      dct_sel_base_addr < dhar_base(pvt)) &&
1251                     hole_valid &&
1252                     (sys_addr >= BIT_64(32)))
1253                         chan_off = hole_off;
1254                 else
1255                         chan_off = dct_sel_base_off;
1256         } else {
1257                 /*
1258                  * if
1259                  * we have a valid hole         &&
1260                  * sys_addr > 4Gb
1261                  *
1262                  *      remove hole
1263                  * else
1264                  *      remove dram base to normalize to DCT address
1265                  */
1266                 if (hole_valid && (sys_addr >= BIT_64(32)))
1267                         chan_off = hole_off;
1268                 else
1269                         chan_off = dram_base;
1270         }
1271
1272         return (sys_addr & GENMASK(6,47)) - (chan_off & GENMASK(23,47));
1273 }
1274
1275 /* Hack for the time being - Can we get this from BIOS?? */
1276 #define CH0SPARE_RANK   0
1277 #define CH1SPARE_RANK   1
1278
1279 /*
1280  * checks if the csrow passed in is marked as SPARED, if so returns the new
1281  * spare row
1282  */
1283 static int f10_process_possible_spare(struct amd64_pvt *pvt, u8 dct, int csrow)
1284 {
1285         u32 swap_done;
1286         u32 bad_dram_cs;
1287
1288         /* Depending on channel, isolate respective SPARING info */
1289         if (dct) {
1290                 swap_done = F10_ONLINE_SPARE_SWAPDONE1(pvt->online_spare);
1291                 bad_dram_cs = F10_ONLINE_SPARE_BADDRAM_CS1(pvt->online_spare);
1292                 if (swap_done && (csrow == bad_dram_cs))
1293                         csrow = CH1SPARE_RANK;
1294         } else {
1295                 swap_done = F10_ONLINE_SPARE_SWAPDONE0(pvt->online_spare);
1296                 bad_dram_cs = F10_ONLINE_SPARE_BADDRAM_CS0(pvt->online_spare);
1297                 if (swap_done && (csrow == bad_dram_cs))
1298                         csrow = CH0SPARE_RANK;
1299         }
1300         return csrow;
1301 }
1302
1303 /*
1304  * Iterate over the DRAM DCT "base" and "mask" registers looking for a
1305  * SystemAddr match on the specified 'ChannelSelect' and 'NodeID'
1306  *
1307  * Return:
1308  *      -EINVAL:  NOT FOUND
1309  *      0..csrow = Chip-Select Row
1310  */
1311 static int f10_lookup_addr_in_dct(u64 in_addr, u32 nid, u8 dct)
1312 {
1313         struct mem_ctl_info *mci;
1314         struct amd64_pvt *pvt;
1315         u64 cs_base, cs_mask;
1316         int cs_found = -EINVAL;
1317         int csrow;
1318
1319         mci = mcis[nid];
1320         if (!mci)
1321                 return cs_found;
1322
1323         pvt = mci->pvt_info;
1324
1325         debugf1("input addr: 0x%llx, DCT: %d\n", in_addr, dct);
1326
1327         for_each_chip_select(csrow, dct, pvt) {
1328                 if (!csrow_enabled(csrow, dct, pvt))
1329                         continue;
1330
1331                 get_cs_base_and_mask(pvt, csrow, dct, &cs_base, &cs_mask);
1332
1333                 debugf1("    CSROW=%d CSBase=0x%llx CSMask=0x%llx\n",
1334                         csrow, cs_base, cs_mask);
1335
1336                 cs_mask = ~cs_mask;
1337
1338                 debugf1("    (InputAddr & ~CSMask)=0x%llx "
1339                         "(CSBase & ~CSMask)=0x%llx\n",
1340                         (in_addr & cs_mask), (cs_base & cs_mask));
1341
1342                 if ((in_addr & cs_mask) == (cs_base & cs_mask)) {
1343                         cs_found = f10_process_possible_spare(pvt, dct, csrow);
1344
1345                         debugf1(" MATCH csrow=%d\n", cs_found);
1346                         break;
1347                 }
1348         }
1349         return cs_found;
1350 }
1351
1352 /* For a given @dram_range, check if @sys_addr falls within it. */
1353 static int f10_match_to_this_node(struct amd64_pvt *pvt, int range,
1354                                   u64 sys_addr, int *nid, int *chan_sel)
1355 {
1356         int cs_found = -EINVAL;
1357         u64 chan_addr;
1358         u32 tmp, dct_sel_base;
1359         u8 channel;
1360         bool high_range = false;
1361
1362         u8 node_id    = dram_dst_node(pvt, range);
1363         u8 intlv_en   = dram_intlv_en(pvt, range);
1364         u32 intlv_sel = dram_intlv_sel(pvt, range);
1365
1366         debugf1("(range %d) SystemAddr= 0x%llx Limit=0x%llx\n",
1367                 range, sys_addr, get_dram_limit(pvt, range));
1368
1369         if (intlv_en &&
1370             (intlv_sel != ((sys_addr >> 12) & intlv_en)))
1371                 return -EINVAL;
1372
1373         dct_sel_base = dct_sel_baseaddr(pvt);
1374
1375         /*
1376          * check whether addresses >= DctSelBaseAddr[47:27] are to be used to
1377          * select between DCT0 and DCT1.
1378          */
1379         if (dct_high_range_enabled(pvt) &&
1380            !dct_ganging_enabled(pvt) &&
1381            ((sys_addr >> 27) >= (dct_sel_base >> 11)))
1382                 high_range = true;
1383
1384         channel = f10_determine_channel(pvt, sys_addr, high_range, intlv_en);
1385
1386         chan_addr = f10_get_norm_dct_addr(pvt, range, sys_addr,
1387                                           high_range, dct_sel_base);
1388
1389         /* remove Node ID (in case of node interleaving) */
1390         tmp = chan_addr & 0xFC0;
1391
1392         chan_addr = ((chan_addr >> hweight8(intlv_en)) & GENMASK(12, 47)) | tmp;
1393
1394         /* remove channel interleave and hash */
1395         if (dct_interleave_enabled(pvt) &&
1396            !dct_high_range_enabled(pvt) &&
1397            !dct_ganging_enabled(pvt)) {
1398                 if (dct_sel_interleave_addr(pvt) != 1)
1399                         chan_addr = (chan_addr >> 1) & GENMASK(6, 63);
1400                 else {
1401                         tmp = chan_addr & 0xFC0;
1402                         chan_addr = ((chan_addr & GENMASK(14, 63)) >> 1) | tmp;
1403                 }
1404         }
1405
1406         debugf1("   (ChannelAddrLong=0x%llx)\n", chan_addr);
1407
1408         cs_found = f10_lookup_addr_in_dct(chan_addr, node_id, channel);
1409
1410         if (cs_found >= 0) {
1411                 *nid = node_id;
1412                 *chan_sel = channel;
1413         }
1414         return cs_found;
1415 }
1416
1417 static int f10_translate_sysaddr_to_cs(struct amd64_pvt *pvt, u64 sys_addr,
1418                                        int *node, int *chan_sel)
1419 {
1420         int range, cs_found = -EINVAL;
1421
1422         for (range = 0; range < DRAM_RANGES; range++) {
1423
1424                 if (!dram_rw(pvt, range))
1425                         continue;
1426
1427                 if ((get_dram_base(pvt, range)  <= sys_addr) &&
1428                     (get_dram_limit(pvt, range) >= sys_addr)) {
1429
1430                         cs_found = f10_match_to_this_node(pvt, range,
1431                                                           sys_addr, node,
1432                                                           chan_sel);
1433                         if (cs_found >= 0)
1434                                 break;
1435                 }
1436         }
1437         return cs_found;
1438 }
1439
1440 /*
1441  * For reference see "2.8.5 Routing DRAM Requests" in F10 BKDG. This code maps
1442  * a @sys_addr to NodeID, DCT (channel) and chip select (CSROW).
1443  *
1444  * The @sys_addr is usually an error address received from the hardware
1445  * (MCX_ADDR).
1446  */
1447 static void f10_map_sysaddr_to_csrow(struct mem_ctl_info *mci,
1448                                      struct err_regs *err_info,
1449                                      u64 sys_addr)
1450 {
1451         struct amd64_pvt *pvt = mci->pvt_info;
1452         u32 page, offset;
1453         int nid, csrow, chan = 0;
1454         u16 syndrome;
1455
1456         csrow = f10_translate_sysaddr_to_cs(pvt, sys_addr, &nid, &chan);
1457
1458         if (csrow < 0) {
1459                 edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR);
1460                 return;
1461         }
1462
1463         error_address_to_page_and_offset(sys_addr, &page, &offset);
1464
1465         syndrome = extract_syndrome(err_info);
1466
1467         /*
1468          * We need the syndromes for channel detection only when we're
1469          * ganged. Otherwise @chan should already contain the channel at
1470          * this point.
1471          */
1472         if (dct_ganging_enabled(pvt) && (pvt->nbcfg & K8_NBCFG_CHIPKILL))
1473                 chan = get_channel_from_ecc_syndrome(mci, syndrome);
1474
1475         if (chan >= 0)
1476                 edac_mc_handle_ce(mci, page, offset, syndrome, csrow, chan,
1477                                   EDAC_MOD_STR);
1478         else
1479                 /*
1480                  * Channel unknown, report all channels on this CSROW as failed.
1481                  */
1482                 for (chan = 0; chan < mci->csrows[csrow].nr_channels; chan++)
1483                         edac_mc_handle_ce(mci, page, offset, syndrome,
1484                                           csrow, chan, EDAC_MOD_STR);
1485 }
1486
1487 /*
1488  * debug routine to display the memory sizes of all logical DIMMs and its
1489  * CSROWs as well
1490  */
1491 static void amd64_debug_display_dimm_sizes(int ctrl, struct amd64_pvt *pvt)
1492 {
1493         int dimm, size0, size1, factor = 0;
1494         u32 *dcsb = ctrl ? pvt->csels[1].csbases : pvt->csels[0].csbases;
1495         u32 dbam  = ctrl ? pvt->dbam1 : pvt->dbam0;
1496
1497         if (boot_cpu_data.x86 == 0xf) {
1498                 if (pvt->dclr0 & F10_WIDTH_128)
1499                         factor = 1;
1500
1501                 /* K8 families < revF not supported yet */
1502                if (pvt->ext_model < K8_REV_F)
1503                         return;
1504                else
1505                        WARN_ON(ctrl != 0);
1506         }
1507
1508         dbam = (ctrl && !dct_ganging_enabled(pvt)) ? pvt->dbam1 : pvt->dbam0;
1509         dcsb = (ctrl && !dct_ganging_enabled(pvt)) ? pvt->csels[1].csbases
1510                                                    : pvt->csels[0].csbases;
1511
1512         debugf1("F2x%d80 (DRAM Bank Address Mapping): 0x%08x\n", ctrl, dbam);
1513
1514         edac_printk(KERN_DEBUG, EDAC_MC, "DCT%d chip selects:\n", ctrl);
1515
1516         /* Dump memory sizes for DIMM and its CSROWs */
1517         for (dimm = 0; dimm < 4; dimm++) {
1518
1519                 size0 = 0;
1520                 if (dcsb[dimm*2] & DCSB_CS_ENABLE)
1521                         size0 = pvt->ops->dbam_to_cs(pvt, DBAM_DIMM(dimm, dbam));
1522
1523                 size1 = 0;
1524                 if (dcsb[dimm*2 + 1] & DCSB_CS_ENABLE)
1525                         size1 = pvt->ops->dbam_to_cs(pvt, DBAM_DIMM(dimm, dbam));
1526
1527                 amd64_info(EDAC_MC ": %d: %5dMB %d: %5dMB\n",
1528                                 dimm * 2,     size0 << factor,
1529                                 dimm * 2 + 1, size1 << factor);
1530         }
1531 }
1532
1533 static struct amd64_family_type amd64_family_types[] = {
1534         [K8_CPUS] = {
1535                 .ctl_name = "K8",
1536                 .f1_id = PCI_DEVICE_ID_AMD_K8_NB_ADDRMAP,
1537                 .f3_id = PCI_DEVICE_ID_AMD_K8_NB_MISC,
1538                 .ops = {
1539                         .early_channel_count    = k8_early_channel_count,
1540                         .get_error_address      = k8_get_error_address,
1541                         .map_sysaddr_to_csrow   = k8_map_sysaddr_to_csrow,
1542                         .dbam_to_cs             = k8_dbam_to_chip_select,
1543                         .read_dct_pci_cfg       = k8_read_dct_pci_cfg,
1544                 }
1545         },
1546         [F10_CPUS] = {
1547                 .ctl_name = "F10h",
1548                 .f1_id = PCI_DEVICE_ID_AMD_10H_NB_MAP,
1549                 .f3_id = PCI_DEVICE_ID_AMD_10H_NB_MISC,
1550                 .ops = {
1551                         .early_channel_count    = f10_early_channel_count,
1552                         .get_error_address      = f10_get_error_address,
1553                         .read_dram_ctl_register = f10_read_dram_ctl_register,
1554                         .map_sysaddr_to_csrow   = f10_map_sysaddr_to_csrow,
1555                         .dbam_to_cs             = f10_dbam_to_chip_select,
1556                         .read_dct_pci_cfg       = f10_read_dct_pci_cfg,
1557                 }
1558         },
1559         [F15_CPUS] = {
1560                 .ctl_name = "F15h",
1561                 .ops = {
1562                         .read_dct_pci_cfg       = f15_read_dct_pci_cfg,
1563                 }
1564         },
1565 };
1566
1567 static struct pci_dev *pci_get_related_function(unsigned int vendor,
1568                                                 unsigned int device,
1569                                                 struct pci_dev *related)
1570 {
1571         struct pci_dev *dev = NULL;
1572
1573         dev = pci_get_device(vendor, device, dev);
1574         while (dev) {
1575                 if ((dev->bus->number == related->bus->number) &&
1576                     (PCI_SLOT(dev->devfn) == PCI_SLOT(related->devfn)))
1577                         break;
1578                 dev = pci_get_device(vendor, device, dev);
1579         }
1580
1581         return dev;
1582 }
1583
1584 /*
1585  * These are tables of eigenvectors (one per line) which can be used for the
1586  * construction of the syndrome tables. The modified syndrome search algorithm
1587  * uses those to find the symbol in error and thus the DIMM.
1588  *
1589  * Algorithm courtesy of Ross LaFetra from AMD.
1590  */
1591 static u16 x4_vectors[] = {
1592         0x2f57, 0x1afe, 0x66cc, 0xdd88,
1593         0x11eb, 0x3396, 0x7f4c, 0xeac8,
1594         0x0001, 0x0002, 0x0004, 0x0008,
1595         0x1013, 0x3032, 0x4044, 0x8088,
1596         0x106b, 0x30d6, 0x70fc, 0xe0a8,
1597         0x4857, 0xc4fe, 0x13cc, 0x3288,
1598         0x1ac5, 0x2f4a, 0x5394, 0xa1e8,
1599         0x1f39, 0x251e, 0xbd6c, 0x6bd8,
1600         0x15c1, 0x2a42, 0x89ac, 0x4758,
1601         0x2b03, 0x1602, 0x4f0c, 0xca08,
1602         0x1f07, 0x3a0e, 0x6b04, 0xbd08,
1603         0x8ba7, 0x465e, 0x244c, 0x1cc8,
1604         0x2b87, 0x164e, 0x642c, 0xdc18,
1605         0x40b9, 0x80de, 0x1094, 0x20e8,
1606         0x27db, 0x1eb6, 0x9dac, 0x7b58,
1607         0x11c1, 0x2242, 0x84ac, 0x4c58,
1608         0x1be5, 0x2d7a, 0x5e34, 0xa718,
1609         0x4b39, 0x8d1e, 0x14b4, 0x28d8,
1610         0x4c97, 0xc87e, 0x11fc, 0x33a8,
1611         0x8e97, 0x497e, 0x2ffc, 0x1aa8,
1612         0x16b3, 0x3d62, 0x4f34, 0x8518,
1613         0x1e2f, 0x391a, 0x5cac, 0xf858,
1614         0x1d9f, 0x3b7a, 0x572c, 0xfe18,
1615         0x15f5, 0x2a5a, 0x5264, 0xa3b8,
1616         0x1dbb, 0x3b66, 0x715c, 0xe3f8,
1617         0x4397, 0xc27e, 0x17fc, 0x3ea8,
1618         0x1617, 0x3d3e, 0x6464, 0xb8b8,
1619         0x23ff, 0x12aa, 0xab6c, 0x56d8,
1620         0x2dfb, 0x1ba6, 0x913c, 0x7328,
1621         0x185d, 0x2ca6, 0x7914, 0x9e28,
1622         0x171b, 0x3e36, 0x7d7c, 0xebe8,
1623         0x4199, 0x82ee, 0x19f4, 0x2e58,
1624         0x4807, 0xc40e, 0x130c, 0x3208,
1625         0x1905, 0x2e0a, 0x5804, 0xac08,
1626         0x213f, 0x132a, 0xadfc, 0x5ba8,
1627         0x19a9, 0x2efe, 0xb5cc, 0x6f88,
1628 };
1629
1630 static u16 x8_vectors[] = {
1631         0x0145, 0x028a, 0x2374, 0x43c8, 0xa1f0, 0x0520, 0x0a40, 0x1480,
1632         0x0211, 0x0422, 0x0844, 0x1088, 0x01b0, 0x44e0, 0x23c0, 0xed80,
1633         0x1011, 0x0116, 0x022c, 0x0458, 0x08b0, 0x8c60, 0x2740, 0x4e80,
1634         0x0411, 0x0822, 0x1044, 0x0158, 0x02b0, 0x2360, 0x46c0, 0xab80,
1635         0x0811, 0x1022, 0x012c, 0x0258, 0x04b0, 0x4660, 0x8cc0, 0x2780,
1636         0x2071, 0x40e2, 0xa0c4, 0x0108, 0x0210, 0x0420, 0x0840, 0x1080,
1637         0x4071, 0x80e2, 0x0104, 0x0208, 0x0410, 0x0820, 0x1040, 0x2080,
1638         0x8071, 0x0102, 0x0204, 0x0408, 0x0810, 0x1020, 0x2040, 0x4080,
1639         0x019d, 0x03d6, 0x136c, 0x2198, 0x50b0, 0xb2e0, 0x0740, 0x0e80,
1640         0x0189, 0x03ea, 0x072c, 0x0e58, 0x1cb0, 0x56e0, 0x37c0, 0xf580,
1641         0x01fd, 0x0376, 0x06ec, 0x0bb8, 0x1110, 0x2220, 0x4440, 0x8880,
1642         0x0163, 0x02c6, 0x1104, 0x0758, 0x0eb0, 0x2be0, 0x6140, 0xc280,
1643         0x02fd, 0x01c6, 0x0b5c, 0x1108, 0x07b0, 0x25a0, 0x8840, 0x6180,
1644         0x0801, 0x012e, 0x025c, 0x04b8, 0x1370, 0x26e0, 0x57c0, 0xb580,
1645         0x0401, 0x0802, 0x015c, 0x02b8, 0x22b0, 0x13e0, 0x7140, 0xe280,
1646         0x0201, 0x0402, 0x0804, 0x01b8, 0x11b0, 0x31a0, 0x8040, 0x7180,
1647         0x0101, 0x0202, 0x0404, 0x0808, 0x1010, 0x2020, 0x4040, 0x8080,
1648         0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
1649         0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x8000,
1650 };
1651
1652 static int decode_syndrome(u16 syndrome, u16 *vectors, int num_vecs,
1653                            int v_dim)
1654 {
1655         unsigned int i, err_sym;
1656
1657         for (err_sym = 0; err_sym < num_vecs / v_dim; err_sym++) {
1658                 u16 s = syndrome;
1659                 int v_idx =  err_sym * v_dim;
1660                 int v_end = (err_sym + 1) * v_dim;
1661
1662                 /* walk over all 16 bits of the syndrome */
1663                 for (i = 1; i < (1U << 16); i <<= 1) {
1664
1665                         /* if bit is set in that eigenvector... */
1666                         if (v_idx < v_end && vectors[v_idx] & i) {
1667                                 u16 ev_comp = vectors[v_idx++];
1668
1669                                 /* ... and bit set in the modified syndrome, */
1670                                 if (s & i) {
1671                                         /* remove it. */
1672                                         s ^= ev_comp;
1673
1674                                         if (!s)
1675                                                 return err_sym;
1676                                 }
1677
1678                         } else if (s & i)
1679                                 /* can't get to zero, move to next symbol */
1680                                 break;
1681                 }
1682         }
1683
1684         debugf0("syndrome(%x) not found\n", syndrome);
1685         return -1;
1686 }
1687
1688 static int map_err_sym_to_channel(int err_sym, int sym_size)
1689 {
1690         if (sym_size == 4)
1691                 switch (err_sym) {
1692                 case 0x20:
1693                 case 0x21:
1694                         return 0;
1695                         break;
1696                 case 0x22:
1697                 case 0x23:
1698                         return 1;
1699                         break;
1700                 default:
1701                         return err_sym >> 4;
1702                         break;
1703                 }
1704         /* x8 symbols */
1705         else
1706                 switch (err_sym) {
1707                 /* imaginary bits not in a DIMM */
1708                 case 0x10:
1709                         WARN(1, KERN_ERR "Invalid error symbol: 0x%x\n",
1710                                           err_sym);
1711                         return -1;
1712                         break;
1713
1714                 case 0x11:
1715                         return 0;
1716                         break;
1717                 case 0x12:
1718                         return 1;
1719                         break;
1720                 default:
1721                         return err_sym >> 3;
1722                         break;
1723                 }
1724         return -1;
1725 }
1726
1727 static int get_channel_from_ecc_syndrome(struct mem_ctl_info *mci, u16 syndrome)
1728 {
1729         struct amd64_pvt *pvt = mci->pvt_info;
1730         int err_sym = -1;
1731
1732         if (pvt->syn_type == 8)
1733                 err_sym = decode_syndrome(syndrome, x8_vectors,
1734                                           ARRAY_SIZE(x8_vectors),
1735                                           pvt->syn_type);
1736         else if (pvt->syn_type == 4)
1737                 err_sym = decode_syndrome(syndrome, x4_vectors,
1738                                           ARRAY_SIZE(x4_vectors),
1739                                           pvt->syn_type);
1740         else {
1741                 amd64_warn("Illegal syndrome type: %u\n", pvt->syn_type);
1742                 return err_sym;
1743         }
1744
1745         return map_err_sym_to_channel(err_sym, pvt->syn_type);
1746 }
1747
1748 /*
1749  * Handle any Correctable Errors (CEs) that have occurred. Check for valid ERROR
1750  * ADDRESS and process.
1751  */
1752 static void amd64_handle_ce(struct mem_ctl_info *mci,
1753                             struct err_regs *info)
1754 {
1755         struct amd64_pvt *pvt = mci->pvt_info;
1756         u64 sys_addr;
1757
1758         /* Ensure that the Error Address is VALID */
1759         if (!(info->nbsh & K8_NBSH_VALID_ERROR_ADDR)) {
1760                 amd64_mc_err(mci, "HW has no ERROR_ADDRESS available\n");
1761                 edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR);
1762                 return;
1763         }
1764
1765         sys_addr = pvt->ops->get_error_address(mci, info);
1766
1767         amd64_mc_err(mci, "CE ERROR_ADDRESS= 0x%llx\n", sys_addr);
1768
1769         pvt->ops->map_sysaddr_to_csrow(mci, info, sys_addr);
1770 }
1771
1772 /* Handle any Un-correctable Errors (UEs) */
1773 static void amd64_handle_ue(struct mem_ctl_info *mci,
1774                             struct err_regs *info)
1775 {
1776         struct amd64_pvt *pvt = mci->pvt_info;
1777         struct mem_ctl_info *log_mci, *src_mci = NULL;
1778         int csrow;
1779         u64 sys_addr;
1780         u32 page, offset;
1781
1782         log_mci = mci;
1783
1784         if (!(info->nbsh & K8_NBSH_VALID_ERROR_ADDR)) {
1785                 amd64_mc_err(mci, "HW has no ERROR_ADDRESS available\n");
1786                 edac_mc_handle_ue_no_info(log_mci, EDAC_MOD_STR);
1787                 return;
1788         }
1789
1790         sys_addr = pvt->ops->get_error_address(mci, info);
1791
1792         /*
1793          * Find out which node the error address belongs to. This may be
1794          * different from the node that detected the error.
1795          */
1796         src_mci = find_mc_by_sys_addr(mci, sys_addr);
1797         if (!src_mci) {
1798                 amd64_mc_err(mci, "ERROR ADDRESS (0x%lx) NOT mapped to a MC\n",
1799                                   (unsigned long)sys_addr);
1800                 edac_mc_handle_ue_no_info(log_mci, EDAC_MOD_STR);
1801                 return;
1802         }
1803
1804         log_mci = src_mci;
1805
1806         csrow = sys_addr_to_csrow(log_mci, sys_addr);
1807         if (csrow < 0) {
1808                 amd64_mc_err(mci, "ERROR_ADDRESS (0x%lx) NOT mapped to CS\n",
1809                                   (unsigned long)sys_addr);
1810                 edac_mc_handle_ue_no_info(log_mci, EDAC_MOD_STR);
1811         } else {
1812                 error_address_to_page_and_offset(sys_addr, &page, &offset);
1813                 edac_mc_handle_ue(log_mci, page, offset, csrow, EDAC_MOD_STR);
1814         }
1815 }
1816
1817 static inline void __amd64_decode_bus_error(struct mem_ctl_info *mci,
1818                                             struct err_regs *info)
1819 {
1820         u16 ec = EC(info->nbsl);
1821         u8 xec = XEC(info->nbsl, 0x1f);
1822         int ecc_type = (info->nbsh >> 13) & 0x3;
1823
1824         /* Bail early out if this was an 'observed' error */
1825         if (PP(ec) == K8_NBSL_PP_OBS)
1826                 return;
1827
1828         /* Do only ECC errors */
1829         if (xec && xec != F10_NBSL_EXT_ERR_ECC)
1830                 return;
1831
1832         if (ecc_type == 2)
1833                 amd64_handle_ce(mci, info);
1834         else if (ecc_type == 1)
1835                 amd64_handle_ue(mci, info);
1836 }
1837
1838 void amd64_decode_bus_error(int node_id, struct mce *m, u32 nbcfg)
1839 {
1840         struct mem_ctl_info *mci = mcis[node_id];
1841         struct err_regs regs;
1842
1843         regs.nbsl  = (u32) m->status;
1844         regs.nbsh  = (u32)(m->status >> 32);
1845         regs.nbeal = (u32) m->addr;
1846         regs.nbeah = (u32)(m->addr >> 32);
1847         regs.nbcfg = nbcfg;
1848
1849         __amd64_decode_bus_error(mci, &regs);
1850
1851         /*
1852          * Check the UE bit of the NB status high register, if set generate some
1853          * logs. If NOT a GART error, then process the event as a NO-INFO event.
1854          * If it was a GART error, skip that process.
1855          *
1856          * FIXME: this should go somewhere else, if at all.
1857          */
1858         if (regs.nbsh & K8_NBSH_UC_ERR && !report_gart_errors)
1859                 edac_mc_handle_ue_no_info(mci, "UE bit is set");
1860
1861 }
1862
1863 /*
1864  * Use pvt->F2 which contains the F2 CPU PCI device to get the related
1865  * F1 (AddrMap) and F3 (Misc) devices. Return negative value on error.
1866  */
1867 static int reserve_mc_sibling_devs(struct amd64_pvt *pvt, u16 f1_id, u16 f3_id)
1868 {
1869         /* Reserve the ADDRESS MAP Device */
1870         pvt->F1 = pci_get_related_function(pvt->F2->vendor, f1_id, pvt->F2);
1871         if (!pvt->F1) {
1872                 amd64_err("error address map device not found: "
1873                           "vendor %x device 0x%x (broken BIOS?)\n",
1874                           PCI_VENDOR_ID_AMD, f1_id);
1875                 return -ENODEV;
1876         }
1877
1878         /* Reserve the MISC Device */
1879         pvt->F3 = pci_get_related_function(pvt->F2->vendor, f3_id, pvt->F2);
1880         if (!pvt->F3) {
1881                 pci_dev_put(pvt->F1);
1882                 pvt->F1 = NULL;
1883
1884                 amd64_err("error F3 device not found: "
1885                           "vendor %x device 0x%x (broken BIOS?)\n",
1886                           PCI_VENDOR_ID_AMD, f3_id);
1887
1888                 return -ENODEV;
1889         }
1890         debugf1("F1: %s\n", pci_name(pvt->F1));
1891         debugf1("F2: %s\n", pci_name(pvt->F2));
1892         debugf1("F3: %s\n", pci_name(pvt->F3));
1893
1894         return 0;
1895 }
1896
1897 static void free_mc_sibling_devs(struct amd64_pvt *pvt)
1898 {
1899         pci_dev_put(pvt->F1);
1900         pci_dev_put(pvt->F3);
1901 }
1902
1903 /*
1904  * Retrieve the hardware registers of the memory controller (this includes the
1905  * 'Address Map' and 'Misc' device regs)
1906  */
1907 static void read_mc_regs(struct amd64_pvt *pvt)
1908 {
1909         u64 msr_val;
1910         u32 tmp;
1911         int range;
1912
1913         /*
1914          * Retrieve TOP_MEM and TOP_MEM2; no masking off of reserved bits since
1915          * those are Read-As-Zero
1916          */
1917         rdmsrl(MSR_K8_TOP_MEM1, pvt->top_mem);
1918         debugf0("  TOP_MEM:  0x%016llx\n", pvt->top_mem);
1919
1920         /* check first whether TOP_MEM2 is enabled */
1921         rdmsrl(MSR_K8_SYSCFG, msr_val);
1922         if (msr_val & (1U << 21)) {
1923                 rdmsrl(MSR_K8_TOP_MEM2, pvt->top_mem2);
1924                 debugf0("  TOP_MEM2: 0x%016llx\n", pvt->top_mem2);
1925         } else
1926                 debugf0("  TOP_MEM2 disabled.\n");
1927
1928         amd64_read_pci_cfg(pvt->F3, K8_NBCAP, &pvt->nbcap);
1929
1930         if (pvt->ops->read_dram_ctl_register)
1931                 pvt->ops->read_dram_ctl_register(pvt);
1932
1933         for (range = 0; range < DRAM_RANGES; range++) {
1934                 u8 rw;
1935
1936                 /* read settings for this DRAM range */
1937                 read_dram_base_limit_regs(pvt, range);
1938
1939                 rw = dram_rw(pvt, range);
1940                 if (!rw)
1941                         continue;
1942
1943                 debugf1("  DRAM range[%d], base: 0x%016llx; limit: 0x%016llx\n",
1944                         range,
1945                         get_dram_base(pvt, range),
1946                         get_dram_limit(pvt, range));
1947
1948                 debugf1("   IntlvEn=%s; Range access: %s%s IntlvSel=%d DstNode=%d\n",
1949                         dram_intlv_en(pvt, range) ? "Enabled" : "Disabled",
1950                         (rw & 0x1) ? "R" : "-",
1951                         (rw & 0x2) ? "W" : "-",
1952                         dram_intlv_sel(pvt, range),
1953                         dram_dst_node(pvt, range));
1954         }
1955
1956         read_dct_base_mask(pvt);
1957
1958         amd64_read_pci_cfg(pvt->F1, DHAR, &pvt->dhar);
1959         amd64_read_dct_pci_cfg(pvt, DBAM0, &pvt->dbam0);
1960
1961         amd64_read_pci_cfg(pvt->F3, F10_ONLINE_SPARE, &pvt->online_spare);
1962
1963         amd64_read_dct_pci_cfg(pvt, F10_DCLR_0, &pvt->dclr0);
1964         amd64_read_dct_pci_cfg(pvt, F10_DCHR_0, &pvt->dchr0);
1965
1966         if (!dct_ganging_enabled(pvt)) {
1967                 amd64_read_dct_pci_cfg(pvt, F10_DCLR_1, &pvt->dclr1);
1968                 amd64_read_dct_pci_cfg(pvt, F10_DCHR_1, &pvt->dchr1);
1969         }
1970
1971         if (boot_cpu_data.x86 >= 0x10) {
1972                 amd64_read_pci_cfg(pvt->F3, EXT_NB_MCA_CFG, &tmp);
1973                 amd64_read_dct_pci_cfg(pvt, DBAM1, &pvt->dbam1);
1974         }
1975
1976         if (boot_cpu_data.x86 == 0x10 &&
1977             boot_cpu_data.x86_model > 7 &&
1978             /* F3x180[EccSymbolSize]=1 => x8 symbols */
1979             tmp & BIT(25))
1980                 pvt->syn_type = 8;
1981         else
1982                 pvt->syn_type = 4;
1983
1984         dump_misc_regs(pvt);
1985 }
1986
1987 /*
1988  * NOTE: CPU Revision Dependent code
1989  *
1990  * Input:
1991  *      @csrow_nr ChipSelect Row Number (0..NUM_CHIPSELECTS-1)
1992  *      k8 private pointer to -->
1993  *                      DRAM Bank Address mapping register
1994  *                      node_id
1995  *                      DCL register where dual_channel_active is
1996  *
1997  * The DBAM register consists of 4 sets of 4 bits each definitions:
1998  *
1999  * Bits:        CSROWs
2000  * 0-3          CSROWs 0 and 1
2001  * 4-7          CSROWs 2 and 3
2002  * 8-11         CSROWs 4 and 5
2003  * 12-15        CSROWs 6 and 7
2004  *
2005  * Values range from: 0 to 15
2006  * The meaning of the values depends on CPU revision and dual-channel state,
2007  * see relevant BKDG more info.
2008  *
2009  * The memory controller provides for total of only 8 CSROWs in its current
2010  * architecture. Each "pair" of CSROWs normally represents just one DIMM in
2011  * single channel or two (2) DIMMs in dual channel mode.
2012  *
2013  * The following code logic collapses the various tables for CSROW based on CPU
2014  * revision.
2015  *
2016  * Returns:
2017  *      The number of PAGE_SIZE pages on the specified CSROW number it
2018  *      encompasses
2019  *
2020  */
2021 static u32 amd64_csrow_nr_pages(int csrow_nr, struct amd64_pvt *pvt)
2022 {
2023         u32 cs_mode, nr_pages;
2024
2025         /*
2026          * The math on this doesn't look right on the surface because x/2*4 can
2027          * be simplified to x*2 but this expression makes use of the fact that
2028          * it is integral math where 1/2=0. This intermediate value becomes the
2029          * number of bits to shift the DBAM register to extract the proper CSROW
2030          * field.
2031          */
2032         cs_mode = (pvt->dbam0 >> ((csrow_nr / 2) * 4)) & 0xF;
2033
2034         nr_pages = pvt->ops->dbam_to_cs(pvt, cs_mode) << (20 - PAGE_SHIFT);
2035
2036         /*
2037          * If dual channel then double the memory size of single channel.
2038          * Channel count is 1 or 2
2039          */
2040         nr_pages <<= (pvt->channel_count - 1);
2041
2042         debugf0("  (csrow=%d) DBAM map index= %d\n", csrow_nr, cs_mode);
2043         debugf0("    nr_pages= %u  channel-count = %d\n",
2044                 nr_pages, pvt->channel_count);
2045
2046         return nr_pages;
2047 }
2048
2049 /*
2050  * Initialize the array of csrow attribute instances, based on the values
2051  * from pci config hardware registers.
2052  */
2053 static int init_csrows(struct mem_ctl_info *mci)
2054 {
2055         struct csrow_info *csrow;
2056         struct amd64_pvt *pvt = mci->pvt_info;
2057         u64 input_addr_min, input_addr_max, sys_addr, base, mask;
2058         u32 val;
2059         int i, empty = 1;
2060
2061         amd64_read_pci_cfg(pvt->F3, K8_NBCFG, &val);
2062
2063         pvt->nbcfg = val;
2064         pvt->ctl_error_info.nbcfg = val;
2065
2066         debugf0("node %d, NBCFG=0x%08x[ChipKillEccCap: %d|DramEccEn: %d]\n",
2067                 pvt->mc_node_id, val,
2068                 !!(val & K8_NBCFG_CHIPKILL), !!(val & K8_NBCFG_ECC_ENABLE));
2069
2070         for_each_chip_select(i, 0, pvt) {
2071                 csrow = &mci->csrows[i];
2072
2073                 if (!csrow_enabled(i, 0, pvt)) {
2074                         debugf1("----CSROW %d EMPTY for node %d\n", i,
2075                                 pvt->mc_node_id);
2076                         continue;
2077                 }
2078
2079                 debugf1("----CSROW %d VALID for MC node %d\n",
2080                         i, pvt->mc_node_id);
2081
2082                 empty = 0;
2083                 csrow->nr_pages = amd64_csrow_nr_pages(i, pvt);
2084                 find_csrow_limits(mci, i, &input_addr_min, &input_addr_max);
2085                 sys_addr = input_addr_to_sys_addr(mci, input_addr_min);
2086                 csrow->first_page = (u32) (sys_addr >> PAGE_SHIFT);
2087                 sys_addr = input_addr_to_sys_addr(mci, input_addr_max);
2088                 csrow->last_page = (u32) (sys_addr >> PAGE_SHIFT);
2089
2090                 get_cs_base_and_mask(pvt, i, 0, &base, &mask);
2091                 csrow->page_mask = ~mask;
2092                 /* 8 bytes of resolution */
2093
2094                 csrow->mtype = amd64_determine_memory_type(pvt, i);
2095
2096                 debugf1("  for MC node %d csrow %d:\n", pvt->mc_node_id, i);
2097                 debugf1("    input_addr_min: 0x%lx input_addr_max: 0x%lx\n",
2098                         (unsigned long)input_addr_min,
2099                         (unsigned long)input_addr_max);
2100                 debugf1("    sys_addr: 0x%lx  page_mask: 0x%lx\n",
2101                         (unsigned long)sys_addr, csrow->page_mask);
2102                 debugf1("    nr_pages: %u  first_page: 0x%lx "
2103                         "last_page: 0x%lx\n",
2104                         (unsigned)csrow->nr_pages,
2105                         csrow->first_page, csrow->last_page);
2106
2107                 /*
2108                  * determine whether CHIPKILL or JUST ECC or NO ECC is operating
2109                  */
2110                 if (pvt->nbcfg & K8_NBCFG_ECC_ENABLE)
2111                         csrow->edac_mode =
2112                             (pvt->nbcfg & K8_NBCFG_CHIPKILL) ?
2113                             EDAC_S4ECD4ED : EDAC_SECDED;
2114                 else
2115                         csrow->edac_mode = EDAC_NONE;
2116         }
2117
2118         return empty;
2119 }
2120
2121 /* get all cores on this DCT */
2122 static void get_cpus_on_this_dct_cpumask(struct cpumask *mask, int nid)
2123 {
2124         int cpu;
2125
2126         for_each_online_cpu(cpu)
2127                 if (amd_get_nb_id(cpu) == nid)
2128                         cpumask_set_cpu(cpu, mask);
2129 }
2130
2131 /* check MCG_CTL on all the cpus on this node */
2132 static bool amd64_nb_mce_bank_enabled_on_node(int nid)
2133 {
2134         cpumask_var_t mask;
2135         int cpu, nbe;
2136         bool ret = false;
2137
2138         if (!zalloc_cpumask_var(&mask, GFP_KERNEL)) {
2139                 amd64_warn("%s: Error allocating mask\n", __func__);
2140                 return false;
2141         }
2142
2143         get_cpus_on_this_dct_cpumask(mask, nid);
2144
2145         rdmsr_on_cpus(mask, MSR_IA32_MCG_CTL, msrs);
2146
2147         for_each_cpu(cpu, mask) {
2148                 struct msr *reg = per_cpu_ptr(msrs, cpu);
2149                 nbe = reg->l & K8_MSR_MCGCTL_NBE;
2150
2151                 debugf0("core: %u, MCG_CTL: 0x%llx, NB MSR is %s\n",
2152                         cpu, reg->q,
2153                         (nbe ? "enabled" : "disabled"));
2154
2155                 if (!nbe)
2156                         goto out;
2157         }
2158         ret = true;
2159
2160 out:
2161         free_cpumask_var(mask);
2162         return ret;
2163 }
2164
2165 static int toggle_ecc_err_reporting(struct ecc_settings *s, u8 nid, bool on)
2166 {
2167         cpumask_var_t cmask;
2168         int cpu;
2169
2170         if (!zalloc_cpumask_var(&cmask, GFP_KERNEL)) {
2171                 amd64_warn("%s: error allocating mask\n", __func__);
2172                 return false;
2173         }
2174
2175         get_cpus_on_this_dct_cpumask(cmask, nid);
2176
2177         rdmsr_on_cpus(cmask, MSR_IA32_MCG_CTL, msrs);
2178
2179         for_each_cpu(cpu, cmask) {
2180
2181                 struct msr *reg = per_cpu_ptr(msrs, cpu);
2182
2183                 if (on) {
2184                         if (reg->l & K8_MSR_MCGCTL_NBE)
2185                                 s->flags.nb_mce_enable = 1;
2186
2187                         reg->l |= K8_MSR_MCGCTL_NBE;
2188                 } else {
2189                         /*
2190                          * Turn off NB MCE reporting only when it was off before
2191                          */
2192                         if (!s->flags.nb_mce_enable)
2193                                 reg->l &= ~K8_MSR_MCGCTL_NBE;
2194                 }
2195         }
2196         wrmsr_on_cpus(cmask, MSR_IA32_MCG_CTL, msrs);
2197
2198         free_cpumask_var(cmask);
2199
2200         return 0;
2201 }
2202
2203 static bool enable_ecc_error_reporting(struct ecc_settings *s, u8 nid,
2204                                        struct pci_dev *F3)
2205 {
2206         bool ret = true;
2207         u32 value, mask = K8_NBCTL_CECCEn | K8_NBCTL_UECCEn;
2208
2209         if (toggle_ecc_err_reporting(s, nid, ON)) {
2210                 amd64_warn("Error enabling ECC reporting over MCGCTL!\n");
2211                 return false;
2212         }
2213
2214         amd64_read_pci_cfg(F3, K8_NBCTL, &value);
2215
2216         /* turn on UECCEn and CECCEn bits */
2217         s->old_nbctl   = value & mask;
2218         s->nbctl_valid = true;
2219
2220         value |= mask;
2221         amd64_write_pci_cfg(F3, K8_NBCTL, value);
2222
2223         amd64_read_pci_cfg(F3, K8_NBCFG, &value);
2224
2225         debugf0("1: node %d, NBCFG=0x%08x[ChipKillEccCap: %d|DramEccEn: %d]\n",
2226                 nid, value,
2227                 !!(value & K8_NBCFG_CHIPKILL), !!(value & K8_NBCFG_ECC_ENABLE));
2228
2229         if (!(value & K8_NBCFG_ECC_ENABLE)) {
2230                 amd64_warn("DRAM ECC disabled on this node, enabling...\n");
2231
2232                 s->flags.nb_ecc_prev = 0;
2233
2234                 /* Attempt to turn on DRAM ECC Enable */
2235                 value |= K8_NBCFG_ECC_ENABLE;
2236                 amd64_write_pci_cfg(F3, K8_NBCFG, value);
2237
2238                 amd64_read_pci_cfg(F3, K8_NBCFG, &value);
2239
2240                 if (!(value & K8_NBCFG_ECC_ENABLE)) {
2241                         amd64_warn("Hardware rejected DRAM ECC enable,"
2242                                    "check memory DIMM configuration.\n");
2243                         ret = false;
2244                 } else {
2245                         amd64_info("Hardware accepted DRAM ECC Enable\n");
2246                 }
2247         } else {
2248                 s->flags.nb_ecc_prev = 1;
2249         }
2250
2251         debugf0("2: node %d, NBCFG=0x%08x[ChipKillEccCap: %d|DramEccEn: %d]\n",
2252                 nid, value,
2253                 !!(value & K8_NBCFG_CHIPKILL), !!(value & K8_NBCFG_ECC_ENABLE));
2254
2255         return ret;
2256 }
2257
2258 static void restore_ecc_error_reporting(struct ecc_settings *s, u8 nid,
2259                                         struct pci_dev *F3)
2260 {
2261         u32 value, mask = K8_NBCTL_CECCEn | K8_NBCTL_UECCEn;
2262
2263         if (!s->nbctl_valid)
2264                 return;
2265
2266         amd64_read_pci_cfg(F3, K8_NBCTL, &value);
2267         value &= ~mask;
2268         value |= s->old_nbctl;
2269
2270         amd64_write_pci_cfg(F3, K8_NBCTL, value);
2271
2272         /* restore previous BIOS DRAM ECC "off" setting we force-enabled */
2273         if (!s->flags.nb_ecc_prev) {
2274                 amd64_read_pci_cfg(F3, K8_NBCFG, &value);
2275                 value &= ~K8_NBCFG_ECC_ENABLE;
2276                 amd64_write_pci_cfg(F3, K8_NBCFG, value);
2277         }
2278
2279         /* restore the NB Enable MCGCTL bit */
2280         if (toggle_ecc_err_reporting(s, nid, OFF))
2281                 amd64_warn("Error restoring NB MCGCTL settings!\n");
2282 }
2283
2284 /*
2285  * EDAC requires that the BIOS have ECC enabled before
2286  * taking over the processing of ECC errors. A command line
2287  * option allows to force-enable hardware ECC later in
2288  * enable_ecc_error_reporting().
2289  */
2290 static const char *ecc_msg =
2291         "ECC disabled in the BIOS or no ECC capability, module will not load.\n"
2292         " Either enable ECC checking or force module loading by setting "
2293         "'ecc_enable_override'.\n"
2294         " (Note that use of the override may cause unknown side effects.)\n";
2295
2296 static bool ecc_enabled(struct pci_dev *F3, u8 nid)
2297 {
2298         u32 value;
2299         u8 ecc_en = 0;
2300         bool nb_mce_en = false;
2301
2302         amd64_read_pci_cfg(F3, K8_NBCFG, &value);
2303
2304         ecc_en = !!(value & K8_NBCFG_ECC_ENABLE);
2305         amd64_info("DRAM ECC %s.\n", (ecc_en ? "enabled" : "disabled"));
2306
2307         nb_mce_en = amd64_nb_mce_bank_enabled_on_node(nid);
2308         if (!nb_mce_en)
2309                 amd64_notice("NB MCE bank disabled, set MSR "
2310                              "0x%08x[4] on node %d to enable.\n",
2311                              MSR_IA32_MCG_CTL, nid);
2312
2313         if (!ecc_en || !nb_mce_en) {
2314                 amd64_notice("%s", ecc_msg);
2315                 return false;
2316         }
2317         return true;
2318 }
2319
2320 struct mcidev_sysfs_attribute sysfs_attrs[ARRAY_SIZE(amd64_dbg_attrs) +
2321                                           ARRAY_SIZE(amd64_inj_attrs) +
2322                                           1];
2323
2324 struct mcidev_sysfs_attribute terminator = { .attr = { .name = NULL } };
2325
2326 static void set_mc_sysfs_attrs(struct mem_ctl_info *mci)
2327 {
2328         unsigned int i = 0, j = 0;
2329
2330         for (; i < ARRAY_SIZE(amd64_dbg_attrs); i++)
2331                 sysfs_attrs[i] = amd64_dbg_attrs[i];
2332
2333         if (boot_cpu_data.x86 >= 0x10)
2334                 for (j = 0; j < ARRAY_SIZE(amd64_inj_attrs); j++, i++)
2335                         sysfs_attrs[i] = amd64_inj_attrs[j];
2336
2337         sysfs_attrs[i] = terminator;
2338
2339         mci->mc_driver_sysfs_attributes = sysfs_attrs;
2340 }
2341
2342 static void setup_mci_misc_attrs(struct mem_ctl_info *mci)
2343 {
2344         struct amd64_pvt *pvt = mci->pvt_info;
2345
2346         mci->mtype_cap          = MEM_FLAG_DDR2 | MEM_FLAG_RDDR2;
2347         mci->edac_ctl_cap       = EDAC_FLAG_NONE;
2348
2349         if (pvt->nbcap & K8_NBCAP_SECDED)
2350                 mci->edac_ctl_cap |= EDAC_FLAG_SECDED;
2351
2352         if (pvt->nbcap & K8_NBCAP_CHIPKILL)
2353                 mci->edac_ctl_cap |= EDAC_FLAG_S4ECD4ED;
2354
2355         mci->edac_cap           = amd64_determine_edac_cap(pvt);
2356         mci->mod_name           = EDAC_MOD_STR;
2357         mci->mod_ver            = EDAC_AMD64_VERSION;
2358         mci->ctl_name           = pvt->ctl_name;
2359         mci->dev_name           = pci_name(pvt->F2);
2360         mci->ctl_page_to_phys   = NULL;
2361
2362         /* memory scrubber interface */
2363         mci->set_sdram_scrub_rate = amd64_set_scrub_rate;
2364         mci->get_sdram_scrub_rate = amd64_get_scrub_rate;
2365 }
2366
2367 /*
2368  * returns a pointer to the family descriptor on success, NULL otherwise.
2369  */
2370 static struct amd64_family_type *amd64_per_family_init(struct amd64_pvt *pvt)
2371 {
2372         u8 fam = boot_cpu_data.x86;
2373         struct amd64_family_type *fam_type = NULL;
2374
2375         switch (fam) {
2376         case 0xf:
2377                 fam_type                = &amd64_family_types[K8_CPUS];
2378                 pvt->ops                = &amd64_family_types[K8_CPUS].ops;
2379                 pvt->ctl_name           = fam_type->ctl_name;
2380                 pvt->min_scrubrate      = K8_MIN_SCRUB_RATE_BITS;
2381                 break;
2382         case 0x10:
2383                 fam_type                = &amd64_family_types[F10_CPUS];
2384                 pvt->ops                = &amd64_family_types[F10_CPUS].ops;
2385                 pvt->ctl_name           = fam_type->ctl_name;
2386                 pvt->min_scrubrate      = F10_MIN_SCRUB_RATE_BITS;
2387                 break;
2388
2389         default:
2390                 amd64_err("Unsupported family!\n");
2391                 return NULL;
2392         }
2393
2394         pvt->ext_model = boot_cpu_data.x86_model >> 4;
2395
2396         amd64_info("%s %sdetected (node %d).\n", pvt->ctl_name,
2397                      (fam == 0xf ?
2398                                 (pvt->ext_model >= K8_REV_F  ? "revF or later "
2399                                                              : "revE or earlier ")
2400                                  : ""), pvt->mc_node_id);
2401         return fam_type;
2402 }
2403
2404 static int amd64_init_one_instance(struct pci_dev *F2)
2405 {
2406         struct amd64_pvt *pvt = NULL;
2407         struct amd64_family_type *fam_type = NULL;
2408         struct mem_ctl_info *mci = NULL;
2409         int err = 0, ret;
2410         u8 nid = get_node_id(F2);
2411
2412         ret = -ENOMEM;
2413         pvt = kzalloc(sizeof(struct amd64_pvt), GFP_KERNEL);
2414         if (!pvt)
2415                 goto err_ret;
2416
2417         pvt->mc_node_id = nid;
2418         pvt->F2 = F2;
2419
2420         ret = -EINVAL;
2421         fam_type = amd64_per_family_init(pvt);
2422         if (!fam_type)
2423                 goto err_free;
2424
2425         ret = -ENODEV;
2426         err = reserve_mc_sibling_devs(pvt, fam_type->f1_id, fam_type->f3_id);
2427         if (err)
2428                 goto err_free;
2429
2430         read_mc_regs(pvt);
2431
2432         /*
2433          * We need to determine how many memory channels there are. Then use
2434          * that information for calculating the size of the dynamic instance
2435          * tables in the 'mci' structure.
2436          */
2437         ret = -EINVAL;
2438         pvt->channel_count = pvt->ops->early_channel_count(pvt);
2439         if (pvt->channel_count < 0)
2440                 goto err_siblings;
2441
2442         ret = -ENOMEM;
2443         mci = edac_mc_alloc(0, pvt->csels[0].b_cnt, pvt->channel_count, nid);
2444         if (!mci)
2445                 goto err_siblings;
2446
2447         mci->pvt_info = pvt;
2448         mci->dev = &pvt->F2->dev;
2449
2450         setup_mci_misc_attrs(mci);
2451
2452         if (init_csrows(mci))
2453                 mci->edac_cap = EDAC_FLAG_NONE;
2454
2455         set_mc_sysfs_attrs(mci);
2456
2457         ret = -ENODEV;
2458         if (edac_mc_add_mc(mci)) {
2459                 debugf1("failed edac_mc_add_mc()\n");
2460                 goto err_add_mc;
2461         }
2462
2463         /* register stuff with EDAC MCE */
2464         if (report_gart_errors)
2465                 amd_report_gart_errors(true);
2466
2467         amd_register_ecc_decoder(amd64_decode_bus_error);
2468
2469         mcis[nid] = mci;
2470
2471         atomic_inc(&drv_instances);
2472
2473         return 0;
2474
2475 err_add_mc:
2476         edac_mc_free(mci);
2477
2478 err_siblings:
2479         free_mc_sibling_devs(pvt);
2480
2481 err_free:
2482         kfree(pvt);
2483
2484 err_ret:
2485         return ret;
2486 }
2487
2488 static int __devinit amd64_probe_one_instance(struct pci_dev *pdev,
2489                                              const struct pci_device_id *mc_type)
2490 {
2491         u8 nid = get_node_id(pdev);
2492         struct pci_dev *F3 = node_to_amd_nb(nid)->misc;
2493         struct ecc_settings *s;
2494         int ret = 0;
2495
2496         ret = pci_enable_device(pdev);
2497         if (ret < 0) {
2498                 debugf0("ret=%d\n", ret);
2499                 return -EIO;
2500         }
2501
2502         ret = -ENOMEM;
2503         s = kzalloc(sizeof(struct ecc_settings), GFP_KERNEL);
2504         if (!s)
2505                 goto err_out;
2506
2507         ecc_stngs[nid] = s;
2508
2509         if (!ecc_enabled(F3, nid)) {
2510                 ret = -ENODEV;
2511
2512                 if (!ecc_enable_override)
2513                         goto err_enable;
2514
2515                 amd64_warn("Forcing ECC on!\n");
2516
2517                 if (!enable_ecc_error_reporting(s, nid, F3))
2518                         goto err_enable;
2519         }
2520
2521         ret = amd64_init_one_instance(pdev);
2522         if (ret < 0) {
2523                 amd64_err("Error probing instance: %d\n", nid);
2524                 restore_ecc_error_reporting(s, nid, F3);
2525         }
2526
2527         return ret;
2528
2529 err_enable:
2530         kfree(s);
2531         ecc_stngs[nid] = NULL;
2532
2533 err_out:
2534         return ret;
2535 }
2536
2537 static void __devexit amd64_remove_one_instance(struct pci_dev *pdev)
2538 {
2539         struct mem_ctl_info *mci;
2540         struct amd64_pvt *pvt;
2541         u8 nid = get_node_id(pdev);
2542         struct pci_dev *F3 = node_to_amd_nb(nid)->misc;
2543         struct ecc_settings *s = ecc_stngs[nid];
2544
2545         /* Remove from EDAC CORE tracking list */
2546         mci = edac_mc_del_mc(&pdev->dev);
2547         if (!mci)
2548                 return;
2549
2550         pvt = mci->pvt_info;
2551
2552         restore_ecc_error_reporting(s, nid, F3);
2553
2554         free_mc_sibling_devs(pvt);
2555
2556         /* unregister from EDAC MCE */
2557         amd_report_gart_errors(false);
2558         amd_unregister_ecc_decoder(amd64_decode_bus_error);
2559
2560         kfree(ecc_stngs[nid]);
2561         ecc_stngs[nid] = NULL;
2562
2563         /* Free the EDAC CORE resources */
2564         mci->pvt_info = NULL;
2565         mcis[nid] = NULL;
2566
2567         kfree(pvt);
2568         edac_mc_free(mci);
2569 }
2570
2571 /*
2572  * This table is part of the interface for loading drivers for PCI devices. The
2573  * PCI core identifies what devices are on a system during boot, and then
2574  * inquiry this table to see if this driver is for a given device found.
2575  */
2576 static const struct pci_device_id amd64_pci_table[] __devinitdata = {
2577         {
2578                 .vendor         = PCI_VENDOR_ID_AMD,
2579                 .device         = PCI_DEVICE_ID_AMD_K8_NB_MEMCTL,
2580                 .subvendor      = PCI_ANY_ID,
2581                 .subdevice      = PCI_ANY_ID,
2582                 .class          = 0,
2583                 .class_mask     = 0,
2584         },
2585         {
2586                 .vendor         = PCI_VENDOR_ID_AMD,
2587                 .device         = PCI_DEVICE_ID_AMD_10H_NB_DRAM,
2588                 .subvendor      = PCI_ANY_ID,
2589                 .subdevice      = PCI_ANY_ID,
2590                 .class          = 0,
2591                 .class_mask     = 0,
2592         },
2593         {0, }
2594 };
2595 MODULE_DEVICE_TABLE(pci, amd64_pci_table);
2596
2597 static struct pci_driver amd64_pci_driver = {
2598         .name           = EDAC_MOD_STR,
2599         .probe          = amd64_probe_one_instance,
2600         .remove         = __devexit_p(amd64_remove_one_instance),
2601         .id_table       = amd64_pci_table,
2602 };
2603
2604 static void setup_pci_device(void)
2605 {
2606         struct mem_ctl_info *mci;
2607         struct amd64_pvt *pvt;
2608
2609         if (amd64_ctl_pci)
2610                 return;
2611
2612         mci = mcis[0];
2613         if (mci) {
2614
2615                 pvt = mci->pvt_info;
2616                 amd64_ctl_pci =
2617                         edac_pci_create_generic_ctl(&pvt->F2->dev, EDAC_MOD_STR);
2618
2619                 if (!amd64_ctl_pci) {
2620                         pr_warning("%s(): Unable to create PCI control\n",
2621                                    __func__);
2622
2623                         pr_warning("%s(): PCI error report via EDAC not set\n",
2624                                    __func__);
2625                         }
2626         }
2627 }
2628
2629 static int __init amd64_edac_init(void)
2630 {
2631         int err = -ENODEV;
2632
2633         edac_printk(KERN_INFO, EDAC_MOD_STR, EDAC_AMD64_VERSION "\n");
2634
2635         opstate_init();
2636
2637         if (amd_cache_northbridges() < 0)
2638                 goto err_ret;
2639
2640         err = -ENOMEM;
2641         mcis      = kzalloc(amd_nb_num() * sizeof(mcis[0]), GFP_KERNEL);
2642         ecc_stngs = kzalloc(amd_nb_num() * sizeof(ecc_stngs[0]), GFP_KERNEL);
2643         if (!(mcis && ecc_stngs))
2644                 goto err_ret;
2645
2646         msrs = msrs_alloc();
2647         if (!msrs)
2648                 goto err_free;
2649
2650         err = pci_register_driver(&amd64_pci_driver);
2651         if (err)
2652                 goto err_pci;
2653
2654         err = -ENODEV;
2655         if (!atomic_read(&drv_instances))
2656                 goto err_no_instances;
2657
2658         setup_pci_device();
2659         return 0;
2660
2661 err_no_instances:
2662         pci_unregister_driver(&amd64_pci_driver);
2663
2664 err_pci:
2665         msrs_free(msrs);
2666         msrs = NULL;
2667
2668 err_free:
2669         kfree(mcis);
2670         mcis = NULL;
2671
2672         kfree(ecc_stngs);
2673         ecc_stngs = NULL;
2674
2675 err_ret:
2676         return err;
2677 }
2678
2679 static void __exit amd64_edac_exit(void)
2680 {
2681         if (amd64_ctl_pci)
2682                 edac_pci_release_generic_ctl(amd64_ctl_pci);
2683
2684         pci_unregister_driver(&amd64_pci_driver);
2685
2686         kfree(ecc_stngs);
2687         ecc_stngs = NULL;
2688
2689         kfree(mcis);
2690         mcis = NULL;
2691
2692         msrs_free(msrs);
2693         msrs = NULL;
2694 }
2695
2696 module_init(amd64_edac_init);
2697 module_exit(amd64_edac_exit);
2698
2699 MODULE_LICENSE("GPL");
2700 MODULE_AUTHOR("SoftwareBitMaker: Doug Thompson, "
2701                 "Dave Peterson, Thayne Harbaugh");
2702 MODULE_DESCRIPTION("MC support for AMD64 memory controllers - "
2703                 EDAC_AMD64_VERSION);
2704
2705 module_param(edac_op_state, int, 0444);
2706 MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");