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