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