drivers/edac/amd64_edac.c

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