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