drivers/edac/amd64_edac.c

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