1 #include "amd64_edac.h"
2 #include <asm/amd_nb.h>
4 static struct edac_pci_ctl_info *amd64_ctl_pci;
6 static int report_gart_errors;
7 module_param(report_gart_errors, int, 0644);
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.
13 static int ecc_enable_override;
14 module_param(ecc_enable_override, int, 0644);
16 static struct msr __percpu *msrs;
19 * count successfully initialized driver instances for setup_pci_device()
21 static atomic_t drv_instances = ATOMIC_INIT(0);
23 /* Per-node driver instances */
24 static struct mem_ctl_info **mcis;
25 static struct ecc_settings **ecc_stngs;
28 * Address to DRAM bank mapping: see F2x80 for K8 and F2x[1,0]80 for Fam10 and
31 static int ddr2_dbam_revCG[] = {
41 static int ddr2_dbam_revD[] = {
53 static int ddr2_dbam[] = { [0] = 128,
62 static int ddr3_dbam[] = { [0] = -1,
73 * Valid scrub rates for the K8 hardware memory scrubber. We map the scrubbing
74 * bandwidth to a valid bit pattern. The 'set' operation finds the 'matching-
77 *FIXME: Produce a better mapping/linearisation.
82 u32 scrubval; /* bit pattern for scrub rate */
83 u32 bandwidth; /* bandwidth consumed (bytes/sec) */
85 { 0x01, 1600000000UL},
107 { 0x00, 0UL}, /* scrubbing off */
110 static int __amd64_read_pci_cfg_dword(struct pci_dev *pdev, int offset,
111 u32 *val, const char *func)
115 err = pci_read_config_dword(pdev, offset, val);
117 amd64_warn("%s: error reading F%dx%03x.\n",
118 func, PCI_FUNC(pdev->devfn), offset);
123 int __amd64_write_pci_cfg_dword(struct pci_dev *pdev, int offset,
124 u32 val, const char *func)
128 err = pci_write_config_dword(pdev, offset, val);
130 amd64_warn("%s: error writing to F%dx%03x.\n",
131 func, PCI_FUNC(pdev->devfn), offset);
138 * Depending on the family, F2 DCT reads need special handling:
140 * K8: has a single DCT only
142 * F10h: each DCT has its own set of regs
146 * F15h: we select which DCT we access using F1x10C[DctCfgSel]
149 static int k8_read_dct_pci_cfg(struct amd64_pvt *pvt, int addr, u32 *val,
155 return __amd64_read_pci_cfg_dword(pvt->F2, addr, val, func);
158 static int f10_read_dct_pci_cfg(struct amd64_pvt *pvt, int addr, u32 *val,
161 return __amd64_read_pci_cfg_dword(pvt->F2, addr, val, func);
164 static int f15_read_dct_pci_cfg(struct amd64_pvt *pvt, int addr, u32 *val,
170 if (addr >= 0x140 && addr <= 0x1a0) {
175 amd64_read_pci_cfg(pvt->F1, DCT_CFG_SEL, ®);
178 amd64_write_pci_cfg(pvt->F1, DCT_CFG_SEL, reg);
180 return __amd64_read_pci_cfg_dword(pvt->F2, addr, val, func);
184 * Memory scrubber control interface. For K8, memory scrubbing is handled by
185 * hardware and can involve L2 cache, dcache as well as the main memory. With
186 * F10, this is extended to L3 cache scrubbing on CPU models sporting that
189 * This causes the "units" for the scrubbing speed to vary from 64 byte blocks
190 * (dram) over to cache lines. This is nasty, so we will use bandwidth in
191 * bytes/sec for the setting.
193 * Currently, we only do dram scrubbing. If the scrubbing is done in software on
194 * other archs, we might not have access to the caches directly.
198 * scan the scrub rate mapping table for a close or matching bandwidth value to
199 * issue. If requested is too big, then use last maximum value found.
201 static int __amd64_set_scrub_rate(struct pci_dev *ctl, u32 new_bw, u32 min_rate)
207 * map the configured rate (new_bw) to a value specific to the AMD64
208 * memory controller and apply to register. Search for the first
209 * bandwidth entry that is greater or equal than the setting requested
210 * and program that. If at last entry, turn off DRAM scrubbing.
212 for (i = 0; i < ARRAY_SIZE(scrubrates); i++) {
214 * skip scrub rates which aren't recommended
215 * (see F10 BKDG, F3x58)
217 if (scrubrates[i].scrubval < min_rate)
220 if (scrubrates[i].bandwidth <= new_bw)
224 * if no suitable bandwidth found, turn off DRAM scrubbing
225 * entirely by falling back to the last element in the
230 scrubval = scrubrates[i].scrubval;
232 pci_write_bits32(ctl, SCRCTRL, scrubval, 0x001F);
235 return scrubrates[i].bandwidth;
240 static int amd64_set_scrub_rate(struct mem_ctl_info *mci, u32 bw)
242 struct amd64_pvt *pvt = mci->pvt_info;
244 return __amd64_set_scrub_rate(pvt->F3, bw, pvt->min_scrubrate);
247 static int amd64_get_scrub_rate(struct mem_ctl_info *mci)
249 struct amd64_pvt *pvt = mci->pvt_info;
251 int i, retval = -EINVAL;
253 amd64_read_pci_cfg(pvt->F3, SCRCTRL, &scrubval);
255 scrubval = scrubval & 0x001F;
257 amd64_debug("pci-read, sdram scrub control value: %d\n", scrubval);
259 for (i = 0; i < ARRAY_SIZE(scrubrates); i++) {
260 if (scrubrates[i].scrubval == scrubval) {
261 retval = scrubrates[i].bandwidth;
269 * returns true if the SysAddr given by sys_addr matches the
270 * DRAM base/limit associated with node_id
272 static bool amd64_base_limit_match(struct amd64_pvt *pvt, u64 sys_addr, int nid)
276 /* The K8 treats this as a 40-bit value. However, bits 63-40 will be
277 * all ones if the most significant implemented address bit is 1.
278 * Here we discard bits 63-40. See section 3.4.2 of AMD publication
279 * 24592: AMD x86-64 Architecture Programmer's Manual Volume 1
280 * Application Programming.
282 addr = sys_addr & 0x000000ffffffffffull;
284 return ((addr >= get_dram_base(pvt, nid)) &&
285 (addr <= get_dram_limit(pvt, nid)));
289 * Attempt to map a SysAddr to a node. On success, return a pointer to the
290 * mem_ctl_info structure for the node that the SysAddr maps to.
292 * On failure, return NULL.
294 static struct mem_ctl_info *find_mc_by_sys_addr(struct mem_ctl_info *mci,
297 struct amd64_pvt *pvt;
302 * Here we use the DRAM Base (section 3.4.4.1) and DRAM Limit (section
303 * 3.4.4.2) registers to map the SysAddr to a node ID.
308 * The value of this field should be the same for all DRAM Base
309 * registers. Therefore we arbitrarily choose to read it from the
310 * register for node 0.
312 intlv_en = dram_intlv_en(pvt, 0);
315 for (node_id = 0; node_id < DRAM_RANGES; node_id++) {
316 if (amd64_base_limit_match(pvt, sys_addr, node_id))
322 if (unlikely((intlv_en != 0x01) &&
323 (intlv_en != 0x03) &&
324 (intlv_en != 0x07))) {
325 amd64_warn("DRAM Base[IntlvEn] junk value: 0x%x, BIOS bug?\n", intlv_en);
329 bits = (((u32) sys_addr) >> 12) & intlv_en;
331 for (node_id = 0; ; ) {
332 if ((dram_intlv_sel(pvt, node_id) & intlv_en) == bits)
333 break; /* intlv_sel field matches */
335 if (++node_id >= DRAM_RANGES)
339 /* sanity test for sys_addr */
340 if (unlikely(!amd64_base_limit_match(pvt, sys_addr, node_id))) {
341 amd64_warn("%s: sys_addr 0x%llx falls outside base/limit address"
342 "range for node %d with node interleaving enabled.\n",
343 __func__, sys_addr, node_id);
348 return edac_mc_find(node_id);
351 debugf2("sys_addr 0x%lx doesn't match any node\n",
352 (unsigned long)sys_addr);
358 * compute the CS base address of the @csrow on the DRAM controller @dct.
359 * For details see F2x[5C:40] in the processor's BKDG
361 static void get_cs_base_and_mask(struct amd64_pvt *pvt, int csrow, u8 dct,
362 u64 *base, u64 *mask)
364 u64 csbase, csmask, base_bits, mask_bits;
367 if (boot_cpu_data.x86 == 0xf && pvt->ext_model < K8_REV_F) {
368 csbase = pvt->csels[dct].csbases[csrow];
369 csmask = pvt->csels[dct].csmasks[csrow];
370 base_bits = GENMASK(21, 31) | GENMASK(9, 15);
371 mask_bits = GENMASK(21, 29) | GENMASK(9, 15);
374 csbase = pvt->csels[dct].csbases[csrow];
375 csmask = pvt->csels[dct].csmasks[csrow >> 1];
378 if (boot_cpu_data.x86 == 0x15)
379 base_bits = mask_bits = GENMASK(19,30) | GENMASK(5,13);
381 base_bits = mask_bits = GENMASK(19,28) | GENMASK(5,13);
384 *base = (csbase & base_bits) << addr_shift;
387 /* poke holes for the csmask */
388 *mask &= ~(mask_bits << addr_shift);
390 *mask |= (csmask & mask_bits) << addr_shift;
393 #define for_each_chip_select(i, dct, pvt) \
394 for (i = 0; i < pvt->csels[dct].b_cnt; i++)
396 #define chip_select_base(i, dct, pvt) \
397 pvt->csels[dct].csbases[i]
399 #define for_each_chip_select_mask(i, dct, pvt) \
400 for (i = 0; i < pvt->csels[dct].m_cnt; i++)
403 * @input_addr is an InputAddr associated with the node given by mci. Return the
404 * csrow that input_addr maps to, or -1 on failure (no csrow claims input_addr).
406 static int input_addr_to_csrow(struct mem_ctl_info *mci, u64 input_addr)
408 struct amd64_pvt *pvt;
414 for_each_chip_select(csrow, 0, pvt) {
415 if (!csrow_enabled(csrow, 0, pvt))
418 get_cs_base_and_mask(pvt, csrow, 0, &base, &mask);
422 if ((input_addr & mask) == (base & mask)) {
423 debugf2("InputAddr 0x%lx matches csrow %d (node %d)\n",
424 (unsigned long)input_addr, csrow,
430 debugf2("no matching csrow for InputAddr 0x%lx (MC node %d)\n",
431 (unsigned long)input_addr, pvt->mc_node_id);
437 * Obtain info from the DRAM Hole Address Register (section 3.4.8, pub #26094)
438 * for the node represented by mci. Info is passed back in *hole_base,
439 * *hole_offset, and *hole_size. Function returns 0 if info is valid or 1 if
440 * info is invalid. Info may be invalid for either of the following reasons:
442 * - The revision of the node is not E or greater. In this case, the DRAM Hole
443 * Address Register does not exist.
445 * - The DramHoleValid bit is cleared in the DRAM Hole Address Register,
446 * indicating that its contents are not valid.
448 * The values passed back in *hole_base, *hole_offset, and *hole_size are
449 * complete 32-bit values despite the fact that the bitfields in the DHAR
450 * only represent bits 31-24 of the base and offset values.
452 int amd64_get_dram_hole_info(struct mem_ctl_info *mci, u64 *hole_base,
453 u64 *hole_offset, u64 *hole_size)
455 struct amd64_pvt *pvt = mci->pvt_info;
458 /* only revE and later have the DRAM Hole Address Register */
459 if (boot_cpu_data.x86 == 0xf && pvt->ext_model < K8_REV_E) {
460 debugf1(" revision %d for node %d does not support DHAR\n",
461 pvt->ext_model, pvt->mc_node_id);
465 /* valid for Fam10h and above */
466 if (boot_cpu_data.x86 >= 0x10 && !dhar_mem_hoist_valid(pvt)) {
467 debugf1(" Dram Memory Hoisting is DISABLED on this system\n");
471 if (!dhar_valid(pvt)) {
472 debugf1(" Dram Memory Hoisting is DISABLED on this node %d\n",
477 /* This node has Memory Hoisting */
479 /* +------------------+--------------------+--------------------+-----
480 * | memory | DRAM hole | relocated |
481 * | [0, (x - 1)] | [x, 0xffffffff] | addresses from |
483 * | | | [0x100000000, |
484 * | | | (0x100000000+ |
485 * | | | (0xffffffff-x))] |
486 * +------------------+--------------------+--------------------+-----
488 * Above is a diagram of physical memory showing the DRAM hole and the
489 * relocated addresses from the DRAM hole. As shown, the DRAM hole
490 * starts at address x (the base address) and extends through address
491 * 0xffffffff. The DRAM Hole Address Register (DHAR) relocates the
492 * addresses in the hole so that they start at 0x100000000.
495 base = dhar_base(pvt);
498 *hole_size = (0x1ull << 32) - base;
500 if (boot_cpu_data.x86 > 0xf)
501 *hole_offset = f10_dhar_offset(pvt);
503 *hole_offset = k8_dhar_offset(pvt);
505 debugf1(" DHAR info for node %d base 0x%lx offset 0x%lx size 0x%lx\n",
506 pvt->mc_node_id, (unsigned long)*hole_base,
507 (unsigned long)*hole_offset, (unsigned long)*hole_size);
511 EXPORT_SYMBOL_GPL(amd64_get_dram_hole_info);
514 * Return the DramAddr that the SysAddr given by @sys_addr maps to. It is
515 * assumed that sys_addr maps to the node given by mci.
517 * The first part of section 3.4.4 (p. 70) shows how the DRAM Base (section
518 * 3.4.4.1) and DRAM Limit (section 3.4.4.2) registers are used to translate a
519 * SysAddr to a DramAddr. If the DRAM Hole Address Register (DHAR) is enabled,
520 * then it is also involved in translating a SysAddr to a DramAddr. Sections
521 * 3.4.8 and 3.5.8.2 describe the DHAR and how it is used for memory hoisting.
522 * These parts of the documentation are unclear. I interpret them as follows:
524 * When node n receives a SysAddr, it processes the SysAddr as follows:
526 * 1. It extracts the DRAMBase and DRAMLimit values from the DRAM Base and DRAM
527 * Limit registers for node n. If the SysAddr is not within the range
528 * specified by the base and limit values, then node n ignores the Sysaddr
529 * (since it does not map to node n). Otherwise continue to step 2 below.
531 * 2. If the DramHoleValid bit of the DHAR for node n is clear, the DHAR is
532 * disabled so skip to step 3 below. Otherwise see if the SysAddr is within
533 * the range of relocated addresses (starting at 0x100000000) from the DRAM
534 * hole. If not, skip to step 3 below. Else get the value of the
535 * DramHoleOffset field from the DHAR. To obtain the DramAddr, subtract the
536 * offset defined by this value from the SysAddr.
538 * 3. Obtain the base address for node n from the DRAMBase field of the DRAM
539 * Base register for node n. To obtain the DramAddr, subtract the base
540 * address from the SysAddr, as shown near the start of section 3.4.4 (p.70).
542 static u64 sys_addr_to_dram_addr(struct mem_ctl_info *mci, u64 sys_addr)
544 struct amd64_pvt *pvt = mci->pvt_info;
545 u64 dram_base, hole_base, hole_offset, hole_size, dram_addr;
548 dram_base = get_dram_base(pvt, pvt->mc_node_id);
550 ret = amd64_get_dram_hole_info(mci, &hole_base, &hole_offset,
553 if ((sys_addr >= (1ull << 32)) &&
554 (sys_addr < ((1ull << 32) + hole_size))) {
555 /* use DHAR to translate SysAddr to DramAddr */
556 dram_addr = sys_addr - hole_offset;
558 debugf2("using DHAR to translate SysAddr 0x%lx to "
560 (unsigned long)sys_addr,
561 (unsigned long)dram_addr);
568 * Translate the SysAddr to a DramAddr as shown near the start of
569 * section 3.4.4 (p. 70). Although sys_addr is a 64-bit value, the k8
570 * only deals with 40-bit values. Therefore we discard bits 63-40 of
571 * sys_addr below. If bit 39 of sys_addr is 1 then the bits we
572 * discard are all 1s. Otherwise the bits we discard are all 0s. See
573 * section 3.4.2 of AMD publication 24592: AMD x86-64 Architecture
574 * Programmer's Manual Volume 1 Application Programming.
576 dram_addr = (sys_addr & GENMASK(0, 39)) - dram_base;
578 debugf2("using DRAM Base register to translate SysAddr 0x%lx to "
579 "DramAddr 0x%lx\n", (unsigned long)sys_addr,
580 (unsigned long)dram_addr);
585 * @intlv_en is the value of the IntlvEn field from a DRAM Base register
586 * (section 3.4.4.1). Return the number of bits from a SysAddr that are used
587 * for node interleaving.
589 static int num_node_interleave_bits(unsigned intlv_en)
591 static const int intlv_shift_table[] = { 0, 1, 0, 2, 0, 0, 0, 3 };
594 BUG_ON(intlv_en > 7);
595 n = intlv_shift_table[intlv_en];
599 /* Translate the DramAddr given by @dram_addr to an InputAddr. */
600 static u64 dram_addr_to_input_addr(struct mem_ctl_info *mci, u64 dram_addr)
602 struct amd64_pvt *pvt;
609 * See the start of section 3.4.4 (p. 70, BKDG #26094, K8, revA-E)
610 * concerning translating a DramAddr to an InputAddr.
612 intlv_shift = num_node_interleave_bits(dram_intlv_en(pvt, 0));
613 input_addr = ((dram_addr >> intlv_shift) & GENMASK(12, 35)) +
616 debugf2(" Intlv Shift=%d DramAddr=0x%lx maps to InputAddr=0x%lx\n",
617 intlv_shift, (unsigned long)dram_addr,
618 (unsigned long)input_addr);
624 * Translate the SysAddr represented by @sys_addr to an InputAddr. It is
625 * assumed that @sys_addr maps to the node given by mci.
627 static u64 sys_addr_to_input_addr(struct mem_ctl_info *mci, u64 sys_addr)
632 dram_addr_to_input_addr(mci, sys_addr_to_dram_addr(mci, sys_addr));
634 debugf2("SysAdddr 0x%lx translates to InputAddr 0x%lx\n",
635 (unsigned long)sys_addr, (unsigned long)input_addr);
642 * @input_addr is an InputAddr associated with the node represented by mci.
643 * Translate @input_addr to a DramAddr and return the result.
645 static u64 input_addr_to_dram_addr(struct mem_ctl_info *mci, u64 input_addr)
647 struct amd64_pvt *pvt;
648 int node_id, intlv_shift;
653 * Near the start of section 3.4.4 (p. 70, BKDG #26094, K8, revA-E)
654 * shows how to translate a DramAddr to an InputAddr. Here we reverse
655 * this procedure. When translating from a DramAddr to an InputAddr, the
656 * bits used for node interleaving are discarded. Here we recover these
657 * bits from the IntlvSel field of the DRAM Limit register (section
658 * 3.4.4.2) for the node that input_addr is associated with.
661 node_id = pvt->mc_node_id;
662 BUG_ON((node_id < 0) || (node_id > 7));
664 intlv_shift = num_node_interleave_bits(dram_intlv_en(pvt, 0));
666 if (intlv_shift == 0) {
667 debugf1(" InputAddr 0x%lx translates to DramAddr of "
668 "same value\n", (unsigned long)input_addr);
673 bits = ((input_addr & GENMASK(12, 35)) << intlv_shift) +
674 (input_addr & 0xfff);
676 intlv_sel = dram_intlv_sel(pvt, node_id) & ((1 << intlv_shift) - 1);
677 dram_addr = bits + (intlv_sel << 12);
679 debugf1("InputAddr 0x%lx translates to DramAddr 0x%lx "
680 "(%d node interleave bits)\n", (unsigned long)input_addr,
681 (unsigned long)dram_addr, intlv_shift);
687 * @dram_addr is a DramAddr that maps to the node represented by mci. Convert
688 * @dram_addr to a SysAddr.
690 static u64 dram_addr_to_sys_addr(struct mem_ctl_info *mci, u64 dram_addr)
692 struct amd64_pvt *pvt = mci->pvt_info;
693 u64 hole_base, hole_offset, hole_size, base, sys_addr;
696 ret = amd64_get_dram_hole_info(mci, &hole_base, &hole_offset,
699 if ((dram_addr >= hole_base) &&
700 (dram_addr < (hole_base + hole_size))) {
701 sys_addr = dram_addr + hole_offset;
703 debugf1("using DHAR to translate DramAddr 0x%lx to "
704 "SysAddr 0x%lx\n", (unsigned long)dram_addr,
705 (unsigned long)sys_addr);
711 base = get_dram_base(pvt, pvt->mc_node_id);
712 sys_addr = dram_addr + base;
715 * The sys_addr we have computed up to this point is a 40-bit value
716 * because the k8 deals with 40-bit values. However, the value we are
717 * supposed to return is a full 64-bit physical address. The AMD
718 * x86-64 architecture specifies that the most significant implemented
719 * address bit through bit 63 of a physical address must be either all
720 * 0s or all 1s. Therefore we sign-extend the 40-bit sys_addr to a
721 * 64-bit value below. See section 3.4.2 of AMD publication 24592:
722 * AMD x86-64 Architecture Programmer's Manual Volume 1 Application
725 sys_addr |= ~((sys_addr & (1ull << 39)) - 1);
727 debugf1(" Node %d, DramAddr 0x%lx to SysAddr 0x%lx\n",
728 pvt->mc_node_id, (unsigned long)dram_addr,
729 (unsigned long)sys_addr);
735 * @input_addr is an InputAddr associated with the node given by mci. Translate
736 * @input_addr to a SysAddr.
738 static inline u64 input_addr_to_sys_addr(struct mem_ctl_info *mci,
741 return dram_addr_to_sys_addr(mci,
742 input_addr_to_dram_addr(mci, input_addr));
746 * Find the minimum and maximum InputAddr values that map to the given @csrow.
747 * Pass back these values in *input_addr_min and *input_addr_max.
749 static void find_csrow_limits(struct mem_ctl_info *mci, int csrow,
750 u64 *input_addr_min, u64 *input_addr_max)
752 struct amd64_pvt *pvt;
756 BUG_ON((csrow < 0) || (csrow >= pvt->csels[0].b_cnt));
758 get_cs_base_and_mask(pvt, csrow, 0, &base, &mask);
760 *input_addr_min = base & ~mask;
761 *input_addr_max = base | mask;
764 /* Map the Error address to a PAGE and PAGE OFFSET. */
765 static inline void error_address_to_page_and_offset(u64 error_address,
766 u32 *page, u32 *offset)
768 *page = (u32) (error_address >> PAGE_SHIFT);
769 *offset = ((u32) error_address) & ~PAGE_MASK;
773 * @sys_addr is an error address (a SysAddr) extracted from the MCA NB Address
774 * Low (section 3.6.4.5) and MCA NB Address High (section 3.6.4.6) registers
775 * of a node that detected an ECC memory error. mci represents the node that
776 * the error address maps to (possibly different from the node that detected
777 * the error). Return the number of the csrow that sys_addr maps to, or -1 on
780 static int sys_addr_to_csrow(struct mem_ctl_info *mci, u64 sys_addr)
784 csrow = input_addr_to_csrow(mci, sys_addr_to_input_addr(mci, sys_addr));
787 amd64_mc_err(mci, "Failed to translate InputAddr to csrow for "
788 "address 0x%lx\n", (unsigned long)sys_addr);
792 static int get_channel_from_ecc_syndrome(struct mem_ctl_info *, u16);
795 * Determine if the DIMMs have ECC enabled. ECC is enabled ONLY if all the DIMMs
798 static enum edac_type amd64_determine_edac_cap(struct amd64_pvt *pvt)
801 enum dev_type edac_cap = EDAC_FLAG_NONE;
803 bit = (boot_cpu_data.x86 > 0xf || pvt->ext_model >= K8_REV_F)
807 if (pvt->dclr0 & BIT(bit))
808 edac_cap = EDAC_FLAG_SECDED;
814 static void amd64_debug_display_dimm_sizes(int ctrl, struct amd64_pvt *pvt);
816 static void amd64_dump_dramcfg_low(u32 dclr, int chan)
818 debugf1("F2x%d90 (DRAM Cfg Low): 0x%08x\n", chan, dclr);
820 debugf1(" DIMM type: %sbuffered; all DIMMs support ECC: %s\n",
821 (dclr & BIT(16)) ? "un" : "",
822 (dclr & BIT(19)) ? "yes" : "no");
824 debugf1(" PAR/ERR parity: %s\n",
825 (dclr & BIT(8)) ? "enabled" : "disabled");
827 if (boot_cpu_data.x86 == 0x10)
828 debugf1(" DCT 128bit mode width: %s\n",
829 (dclr & BIT(11)) ? "128b" : "64b");
831 debugf1(" x4 logical DIMMs present: L0: %s L1: %s L2: %s L3: %s\n",
832 (dclr & BIT(12)) ? "yes" : "no",
833 (dclr & BIT(13)) ? "yes" : "no",
834 (dclr & BIT(14)) ? "yes" : "no",
835 (dclr & BIT(15)) ? "yes" : "no");
838 /* Display and decode various NB registers for debug purposes. */
839 static void dump_misc_regs(struct amd64_pvt *pvt)
841 debugf1("F3xE8 (NB Cap): 0x%08x\n", pvt->nbcap);
843 debugf1(" NB two channel DRAM capable: %s\n",
844 (pvt->nbcap & NBCAP_DCT_DUAL) ? "yes" : "no");
846 debugf1(" ECC capable: %s, ChipKill ECC capable: %s\n",
847 (pvt->nbcap & NBCAP_SECDED) ? "yes" : "no",
848 (pvt->nbcap & NBCAP_CHIPKILL) ? "yes" : "no");
850 amd64_dump_dramcfg_low(pvt->dclr0, 0);
852 debugf1("F3xB0 (Online Spare): 0x%08x\n", pvt->online_spare);
854 debugf1("F1xF0 (DRAM Hole Address): 0x%08x, base: 0x%08x, "
856 pvt->dhar, dhar_base(pvt),
857 (boot_cpu_data.x86 == 0xf) ? k8_dhar_offset(pvt)
858 : f10_dhar_offset(pvt));
860 debugf1(" DramHoleValid: %s\n", dhar_valid(pvt) ? "yes" : "no");
862 amd64_debug_display_dimm_sizes(0, pvt);
864 /* everything below this point is Fam10h and above */
865 if (boot_cpu_data.x86 == 0xf)
868 amd64_debug_display_dimm_sizes(1, pvt);
870 amd64_info("using %s syndromes.\n", ((pvt->syn_type == 8) ? "x8" : "x4"));
872 /* Only if NOT ganged does dclr1 have valid info */
873 if (!dct_ganging_enabled(pvt))
874 amd64_dump_dramcfg_low(pvt->dclr1, 1);
878 * see BKDG, F2x[1,0][5C:40], F2[1,0][6C:60]
880 static void prep_chip_selects(struct amd64_pvt *pvt)
882 if (boot_cpu_data.x86 == 0xf && pvt->ext_model < K8_REV_F) {
883 pvt->csels[0].b_cnt = pvt->csels[1].b_cnt = 8;
884 pvt->csels[0].m_cnt = pvt->csels[1].m_cnt = 8;
886 pvt->csels[0].b_cnt = pvt->csels[1].b_cnt = 8;
887 pvt->csels[0].m_cnt = pvt->csels[1].m_cnt = 4;
892 * Function 2 Offset F10_DCSB0; read in the DCS Base and DCS Mask registers
894 static void read_dct_base_mask(struct amd64_pvt *pvt)
898 prep_chip_selects(pvt);
900 for_each_chip_select(cs, 0, pvt) {
901 u32 reg0 = DCSB0 + (cs * 4);
902 u32 reg1 = DCSB1 + (cs * 4);
903 u32 *base0 = &pvt->csels[0].csbases[cs];
904 u32 *base1 = &pvt->csels[1].csbases[cs];
906 if (!amd64_read_dct_pci_cfg(pvt, reg0, base0))
907 debugf0(" DCSB0[%d]=0x%08x reg: F2x%x\n",
910 if (boot_cpu_data.x86 == 0xf || dct_ganging_enabled(pvt))
913 if (!amd64_read_dct_pci_cfg(pvt, reg1, base1))
914 debugf0(" DCSB1[%d]=0x%08x reg: F2x%x\n",
918 for_each_chip_select_mask(cs, 0, pvt) {
919 u32 reg0 = DCSM0 + (cs * 4);
920 u32 reg1 = DCSM1 + (cs * 4);
921 u32 *mask0 = &pvt->csels[0].csmasks[cs];
922 u32 *mask1 = &pvt->csels[1].csmasks[cs];
924 if (!amd64_read_dct_pci_cfg(pvt, reg0, mask0))
925 debugf0(" DCSM0[%d]=0x%08x reg: F2x%x\n",
928 if (boot_cpu_data.x86 == 0xf || dct_ganging_enabled(pvt))
931 if (!amd64_read_dct_pci_cfg(pvt, reg1, mask1))
932 debugf0(" DCSM1[%d]=0x%08x reg: F2x%x\n",
937 static enum mem_type amd64_determine_memory_type(struct amd64_pvt *pvt, int cs)
941 /* F15h supports only DDR3 */
942 if (boot_cpu_data.x86 >= 0x15)
943 type = (pvt->dclr0 & BIT(16)) ? MEM_DDR3 : MEM_RDDR3;
944 else if (boot_cpu_data.x86 == 0x10 || pvt->ext_model >= K8_REV_F) {
945 if (pvt->dchr0 & DDR3_MODE)
946 type = (pvt->dclr0 & BIT(16)) ? MEM_DDR3 : MEM_RDDR3;
948 type = (pvt->dclr0 & BIT(16)) ? MEM_DDR2 : MEM_RDDR2;
950 type = (pvt->dclr0 & BIT(18)) ? MEM_DDR : MEM_RDDR;
953 amd64_info("CS%d: %s\n", cs, edac_mem_types[type]);
958 /* Get the number of DCT channels the memory controller is using. */
959 static int k8_early_channel_count(struct amd64_pvt *pvt)
963 if (pvt->ext_model >= K8_REV_F)
964 /* RevF (NPT) and later */
965 flag = pvt->dclr0 & F10_WIDTH_128;
967 /* RevE and earlier */
968 flag = pvt->dclr0 & REVE_WIDTH_128;
973 return (flag) ? 2 : 1;
976 /* On F10h and later ErrAddr is MC4_ADDR[47:1] */
977 static u64 get_error_address(struct mce *m)
982 if (boot_cpu_data.x86 == 0xf) {
987 return m->addr & GENMASK(start_bit, end_bit);
990 static void read_dram_base_limit_regs(struct amd64_pvt *pvt, unsigned range)
992 u32 off = range << 3;
994 amd64_read_pci_cfg(pvt->F1, DRAM_BASE_LO + off, &pvt->ranges[range].base.lo);
995 amd64_read_pci_cfg(pvt->F1, DRAM_LIMIT_LO + off, &pvt->ranges[range].lim.lo);
997 if (boot_cpu_data.x86 == 0xf)
1000 if (!dram_rw(pvt, range))
1003 amd64_read_pci_cfg(pvt->F1, DRAM_BASE_HI + off, &pvt->ranges[range].base.hi);
1004 amd64_read_pci_cfg(pvt->F1, DRAM_LIMIT_HI + off, &pvt->ranges[range].lim.hi);
1007 static void k8_map_sysaddr_to_csrow(struct mem_ctl_info *mci, u64 sys_addr,
1010 struct mem_ctl_info *src_mci;
1011 struct amd64_pvt *pvt = mci->pvt_info;
1015 /* CHIPKILL enabled */
1016 if (pvt->nbcfg & NBCFG_CHIPKILL) {
1017 channel = get_channel_from_ecc_syndrome(mci, syndrome);
1020 * Syndrome didn't map, so we don't know which of the
1021 * 2 DIMMs is in error. So we need to ID 'both' of them
1024 amd64_mc_warn(mci, "unknown syndrome 0x%04x - possible "
1025 "error reporting race\n", syndrome);
1026 edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR);
1031 * non-chipkill ecc mode
1033 * The k8 documentation is unclear about how to determine the
1034 * channel number when using non-chipkill memory. This method
1035 * was obtained from email communication with someone at AMD.
1036 * (Wish the email was placed in this comment - norsk)
1038 channel = ((sys_addr & BIT(3)) != 0);
1042 * Find out which node the error address belongs to. This may be
1043 * different from the node that detected the error.
1045 src_mci = find_mc_by_sys_addr(mci, sys_addr);
1047 amd64_mc_err(mci, "failed to map error addr 0x%lx to a node\n",
1048 (unsigned long)sys_addr);
1049 edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR);
1053 /* Now map the sys_addr to a CSROW */
1054 csrow = sys_addr_to_csrow(src_mci, sys_addr);
1056 edac_mc_handle_ce_no_info(src_mci, EDAC_MOD_STR);
1058 error_address_to_page_and_offset(sys_addr, &page, &offset);
1060 edac_mc_handle_ce(src_mci, page, offset, syndrome, csrow,
1061 channel, EDAC_MOD_STR);
1065 static int k8_dbam_to_chip_select(struct amd64_pvt *pvt, int cs_mode)
1069 if (pvt->ext_model >= K8_REV_F)
1070 dbam_map = ddr2_dbam;
1071 else if (pvt->ext_model >= K8_REV_D)
1072 dbam_map = ddr2_dbam_revD;
1074 dbam_map = ddr2_dbam_revCG;
1076 return dbam_map[cs_mode];
1080 * Get the number of DCT channels in use.
1083 * number of Memory Channels in operation
1085 * contents of the DCL0_LOW register
1087 static int f1x_early_channel_count(struct amd64_pvt *pvt)
1089 int i, j, channels = 0;
1091 /* On F10h, if we are in 128 bit mode, then we are using 2 channels */
1092 if (boot_cpu_data.x86 == 0x10 && (pvt->dclr0 & F10_WIDTH_128))
1096 * Need to check if in unganged mode: In such, there are 2 channels,
1097 * but they are not in 128 bit mode and thus the above 'dclr0' status
1100 * Need to check DCT0[0] and DCT1[0] to see if only one of them has
1101 * their CSEnable bit on. If so, then SINGLE DIMM case.
1103 debugf0("Data width is not 128 bits - need more decoding\n");
1106 * Check DRAM Bank Address Mapping values for each DIMM to see if there
1107 * is more than just one DIMM present in unganged mode. Need to check
1108 * both controllers since DIMMs can be placed in either one.
1110 for (i = 0; i < 2; i++) {
1111 u32 dbam = (i ? pvt->dbam1 : pvt->dbam0);
1113 for (j = 0; j < 4; j++) {
1114 if (DBAM_DIMM(j, dbam) > 0) {
1124 amd64_info("MCT channel count: %d\n", channels);
1129 static int f10_dbam_to_chip_select(struct amd64_pvt *pvt, int cs_mode)
1133 if (pvt->dchr0 & DDR3_MODE || pvt->dchr1 & DDR3_MODE)
1134 dbam_map = ddr3_dbam;
1136 dbam_map = ddr2_dbam;
1138 return dbam_map[cs_mode];
1141 static void f10_read_dram_ctl_register(struct amd64_pvt *pvt)
1144 if (!amd64_read_dct_pci_cfg(pvt, DCT_SEL_LO, &pvt->dct_sel_lo)) {
1145 debugf0("F2x110 (DCTSelLow): 0x%08x, High range addrs at: 0x%x\n",
1146 pvt->dct_sel_lo, dct_sel_baseaddr(pvt));
1148 debugf0(" mode: %s, All DCTs on: %s\n",
1149 (dct_ganging_enabled(pvt) ? "ganged" : "unganged"),
1150 (dct_dram_enabled(pvt) ? "yes" : "no"));
1152 if (!dct_ganging_enabled(pvt))
1153 debugf0(" Address range split per DCT: %s\n",
1154 (dct_high_range_enabled(pvt) ? "yes" : "no"));
1156 debugf0(" data interleave for ECC: %s, "
1157 "DRAM cleared since last warm reset: %s\n",
1158 (dct_data_intlv_enabled(pvt) ? "enabled" : "disabled"),
1159 (dct_memory_cleared(pvt) ? "yes" : "no"));
1161 debugf0(" channel interleave: %s, "
1162 "interleave bits selector: 0x%x\n",
1163 (dct_interleave_enabled(pvt) ? "enabled" : "disabled"),
1164 dct_sel_interleave_addr(pvt));
1167 amd64_read_dct_pci_cfg(pvt, DCT_SEL_HI, &pvt->dct_sel_hi);
1171 * Determine channel (DCT) based on the interleaving mode: F10h BKDG, 2.8.9 Memory
1172 * Interleaving Modes.
1174 static u8 f10_determine_channel(struct amd64_pvt *pvt, u64 sys_addr,
1175 bool hi_range_sel, u8 intlv_en)
1177 u32 dct_sel_high = (pvt->dct_sel_lo >> 1) & 1;
1179 if (dct_ganging_enabled(pvt))
1183 return dct_sel_high;
1186 * see F2x110[DctSelIntLvAddr] - channel interleave mode
1188 if (dct_interleave_enabled(pvt)) {
1189 u8 intlv_addr = dct_sel_interleave_addr(pvt);
1191 /* return DCT select function: 0=DCT0, 1=DCT1 */
1193 return sys_addr >> 6 & 1;
1195 if (intlv_addr & 0x2) {
1196 u8 shift = intlv_addr & 0x1 ? 9 : 6;
1197 u32 temp = hweight_long((u32) ((sys_addr >> 16) & 0x1F)) % 2;
1199 return ((sys_addr >> shift) & 1) ^ temp;
1202 return (sys_addr >> (12 + hweight8(intlv_en))) & 1;
1205 if (dct_high_range_enabled(pvt))
1206 return ~dct_sel_high & 1;
1211 /* Convert the sys_addr to the normalized DCT address */
1212 static u64 f10_get_norm_dct_addr(struct amd64_pvt *pvt, int range,
1213 u64 sys_addr, bool hi_rng,
1214 u32 dct_sel_base_addr)
1217 u64 dram_base = get_dram_base(pvt, range);
1218 u64 hole_off = f10_dhar_offset(pvt);
1219 u32 hole_valid = dhar_valid(pvt);
1220 u64 dct_sel_base_off = (pvt->dct_sel_hi & 0xFFFFFC00) << 16;
1225 * base address of high range is below 4Gb
1226 * (bits [47:27] at [31:11])
1227 * DRAM address space on this DCT is hoisted above 4Gb &&
1230 * remove hole offset from sys_addr
1232 * remove high range offset from sys_addr
1234 if ((!(dct_sel_base_addr >> 16) ||
1235 dct_sel_base_addr < dhar_base(pvt)) &&
1237 (sys_addr >= BIT_64(32)))
1238 chan_off = hole_off;
1240 chan_off = dct_sel_base_off;
1244 * we have a valid hole &&
1249 * remove dram base to normalize to DCT address
1251 if (hole_valid && (sys_addr >= BIT_64(32)))
1252 chan_off = hole_off;
1254 chan_off = dram_base;
1257 return (sys_addr & GENMASK(6,47)) - (chan_off & GENMASK(23,47));
1261 * checks if the csrow passed in is marked as SPARED, if so returns the new
1264 static int f10_process_possible_spare(struct amd64_pvt *pvt, u8 dct, int csrow)
1268 if (online_spare_swap_done(pvt, dct) &&
1269 csrow == online_spare_bad_dramcs(pvt, dct)) {
1271 for_each_chip_select(tmp_cs, dct, pvt) {
1272 if (chip_select_base(tmp_cs, dct, pvt) & 0x2) {
1282 * Iterate over the DRAM DCT "base" and "mask" registers looking for a
1283 * SystemAddr match on the specified 'ChannelSelect' and 'NodeID'
1286 * -EINVAL: NOT FOUND
1287 * 0..csrow = Chip-Select Row
1289 static int f10_lookup_addr_in_dct(u64 in_addr, u32 nid, u8 dct)
1291 struct mem_ctl_info *mci;
1292 struct amd64_pvt *pvt;
1293 u64 cs_base, cs_mask;
1294 int cs_found = -EINVAL;
1301 pvt = mci->pvt_info;
1303 debugf1("input addr: 0x%llx, DCT: %d\n", in_addr, dct);
1305 for_each_chip_select(csrow, dct, pvt) {
1306 if (!csrow_enabled(csrow, dct, pvt))
1309 get_cs_base_and_mask(pvt, csrow, dct, &cs_base, &cs_mask);
1311 debugf1(" CSROW=%d CSBase=0x%llx CSMask=0x%llx\n",
1312 csrow, cs_base, cs_mask);
1316 debugf1(" (InputAddr & ~CSMask)=0x%llx "
1317 "(CSBase & ~CSMask)=0x%llx\n",
1318 (in_addr & cs_mask), (cs_base & cs_mask));
1320 if ((in_addr & cs_mask) == (cs_base & cs_mask)) {
1321 cs_found = f10_process_possible_spare(pvt, dct, csrow);
1323 debugf1(" MATCH csrow=%d\n", cs_found);
1331 * See F2x10C. Non-interleaved graphics framebuffer memory under the 16G is
1332 * swapped with a region located at the bottom of memory so that the GPU can use
1333 * the interleaved region and thus two channels.
1335 static u64 f10_swap_interleaved_region(struct amd64_pvt *pvt, u64 sys_addr)
1337 u32 swap_reg, swap_base, swap_limit, rgn_size, tmp_addr;
1339 if (boot_cpu_data.x86 == 0x10) {
1340 /* only revC3 and revE have that feature */
1341 if (boot_cpu_data.x86_model < 4 ||
1342 (boot_cpu_data.x86_model < 0xa &&
1343 boot_cpu_data.x86_mask < 3))
1347 amd64_read_dct_pci_cfg(pvt, SWAP_INTLV_REG, &swap_reg);
1349 if (!(swap_reg & 0x1))
1352 swap_base = (swap_reg >> 3) & 0x7f;
1353 swap_limit = (swap_reg >> 11) & 0x7f;
1354 rgn_size = (swap_reg >> 20) & 0x7f;
1355 tmp_addr = sys_addr >> 27;
1357 if (!(sys_addr >> 34) &&
1358 (((tmp_addr >= swap_base) &&
1359 (tmp_addr <= swap_limit)) ||
1360 (tmp_addr < rgn_size)))
1361 return sys_addr ^ (u64)swap_base << 27;
1366 /* For a given @dram_range, check if @sys_addr falls within it. */
1367 static int f10_match_to_this_node(struct amd64_pvt *pvt, int range,
1368 u64 sys_addr, int *nid, int *chan_sel)
1370 int cs_found = -EINVAL;
1374 bool high_range = false;
1376 u8 node_id = dram_dst_node(pvt, range);
1377 u8 intlv_en = dram_intlv_en(pvt, range);
1378 u32 intlv_sel = dram_intlv_sel(pvt, range);
1380 debugf1("(range %d) SystemAddr= 0x%llx Limit=0x%llx\n",
1381 range, sys_addr, get_dram_limit(pvt, range));
1383 if (dhar_valid(pvt) &&
1384 dhar_base(pvt) <= sys_addr &&
1385 sys_addr < BIT_64(32)) {
1386 amd64_warn("Huh? Address is in the MMIO hole: 0x%016llx\n",
1392 (intlv_sel != ((sys_addr >> 12) & intlv_en))) {
1393 amd64_warn("Botched intlv bits, en: 0x%x, sel: 0x%x\n",
1394 intlv_en, intlv_sel);
1398 sys_addr = f10_swap_interleaved_region(pvt, sys_addr);
1400 dct_sel_base = dct_sel_baseaddr(pvt);
1403 * check whether addresses >= DctSelBaseAddr[47:27] are to be used to
1404 * select between DCT0 and DCT1.
1406 if (dct_high_range_enabled(pvt) &&
1407 !dct_ganging_enabled(pvt) &&
1408 ((sys_addr >> 27) >= (dct_sel_base >> 11)))
1411 channel = f10_determine_channel(pvt, sys_addr, high_range, intlv_en);
1413 chan_addr = f10_get_norm_dct_addr(pvt, range, sys_addr,
1414 high_range, dct_sel_base);
1416 /* Remove node interleaving, see F1x120 */
1418 chan_addr = ((chan_addr >> (12 + hweight8(intlv_en))) << 12) |
1419 (chan_addr & 0xfff);
1421 /* remove channel interleave */
1422 if (dct_interleave_enabled(pvt) &&
1423 !dct_high_range_enabled(pvt) &&
1424 !dct_ganging_enabled(pvt)) {
1426 if (dct_sel_interleave_addr(pvt) != 1) {
1427 if (dct_sel_interleave_addr(pvt) == 0x3)
1429 chan_addr = ((chan_addr >> 10) << 9) |
1430 (chan_addr & 0x1ff);
1432 /* A[6] or hash 6 */
1433 chan_addr = ((chan_addr >> 7) << 6) |
1437 chan_addr = ((chan_addr >> 13) << 12) |
1438 (chan_addr & 0xfff);
1441 debugf1(" Normalized DCT addr: 0x%llx\n", chan_addr);
1443 cs_found = f10_lookup_addr_in_dct(chan_addr, node_id, channel);
1445 if (cs_found >= 0) {
1447 *chan_sel = channel;
1452 static int f10_translate_sysaddr_to_cs(struct amd64_pvt *pvt, u64 sys_addr,
1453 int *node, int *chan_sel)
1455 int range, cs_found = -EINVAL;
1457 for (range = 0; range < DRAM_RANGES; range++) {
1459 if (!dram_rw(pvt, range))
1462 if ((get_dram_base(pvt, range) <= sys_addr) &&
1463 (get_dram_limit(pvt, range) >= sys_addr)) {
1465 cs_found = f10_match_to_this_node(pvt, range,
1476 * For reference see "2.8.5 Routing DRAM Requests" in F10 BKDG. This code maps
1477 * a @sys_addr to NodeID, DCT (channel) and chip select (CSROW).
1479 * The @sys_addr is usually an error address received from the hardware
1482 static void f10_map_sysaddr_to_csrow(struct mem_ctl_info *mci, u64 sys_addr,
1485 struct amd64_pvt *pvt = mci->pvt_info;
1487 int nid, csrow, chan = 0;
1489 csrow = f10_translate_sysaddr_to_cs(pvt, sys_addr, &nid, &chan);
1492 edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR);
1496 error_address_to_page_and_offset(sys_addr, &page, &offset);
1499 * We need the syndromes for channel detection only when we're
1500 * ganged. Otherwise @chan should already contain the channel at
1503 if (dct_ganging_enabled(pvt))
1504 chan = get_channel_from_ecc_syndrome(mci, syndrome);
1507 edac_mc_handle_ce(mci, page, offset, syndrome, csrow, chan,
1511 * Channel unknown, report all channels on this CSROW as failed.
1513 for (chan = 0; chan < mci->csrows[csrow].nr_channels; chan++)
1514 edac_mc_handle_ce(mci, page, offset, syndrome,
1515 csrow, chan, EDAC_MOD_STR);
1519 * debug routine to display the memory sizes of all logical DIMMs and its
1522 static void amd64_debug_display_dimm_sizes(int ctrl, struct amd64_pvt *pvt)
1524 int dimm, size0, size1, factor = 0;
1525 u32 *dcsb = ctrl ? pvt->csels[1].csbases : pvt->csels[0].csbases;
1526 u32 dbam = ctrl ? pvt->dbam1 : pvt->dbam0;
1528 if (boot_cpu_data.x86 == 0xf) {
1529 if (pvt->dclr0 & F10_WIDTH_128)
1532 /* K8 families < revF not supported yet */
1533 if (pvt->ext_model < K8_REV_F)
1539 dbam = (ctrl && !dct_ganging_enabled(pvt)) ? pvt->dbam1 : pvt->dbam0;
1540 dcsb = (ctrl && !dct_ganging_enabled(pvt)) ? pvt->csels[1].csbases
1541 : pvt->csels[0].csbases;
1543 debugf1("F2x%d80 (DRAM Bank Address Mapping): 0x%08x\n", ctrl, dbam);
1545 edac_printk(KERN_DEBUG, EDAC_MC, "DCT%d chip selects:\n", ctrl);
1547 /* Dump memory sizes for DIMM and its CSROWs */
1548 for (dimm = 0; dimm < 4; dimm++) {
1551 if (dcsb[dimm*2] & DCSB_CS_ENABLE)
1552 size0 = pvt->ops->dbam_to_cs(pvt, DBAM_DIMM(dimm, dbam));
1555 if (dcsb[dimm*2 + 1] & DCSB_CS_ENABLE)
1556 size1 = pvt->ops->dbam_to_cs(pvt, DBAM_DIMM(dimm, dbam));
1558 amd64_info(EDAC_MC ": %d: %5dMB %d: %5dMB\n",
1559 dimm * 2, size0 << factor,
1560 dimm * 2 + 1, size1 << factor);
1564 static struct amd64_family_type amd64_family_types[] = {
1567 .f1_id = PCI_DEVICE_ID_AMD_K8_NB_ADDRMAP,
1568 .f3_id = PCI_DEVICE_ID_AMD_K8_NB_MISC,
1570 .early_channel_count = k8_early_channel_count,
1571 .map_sysaddr_to_csrow = k8_map_sysaddr_to_csrow,
1572 .dbam_to_cs = k8_dbam_to_chip_select,
1573 .read_dct_pci_cfg = k8_read_dct_pci_cfg,
1578 .f1_id = PCI_DEVICE_ID_AMD_10H_NB_MAP,
1579 .f3_id = PCI_DEVICE_ID_AMD_10H_NB_MISC,
1581 .early_channel_count = f1x_early_channel_count,
1582 .read_dram_ctl_register = f10_read_dram_ctl_register,
1583 .map_sysaddr_to_csrow = f10_map_sysaddr_to_csrow,
1584 .dbam_to_cs = f10_dbam_to_chip_select,
1585 .read_dct_pci_cfg = f10_read_dct_pci_cfg,
1591 .early_channel_count = f1x_early_channel_count,
1592 .read_dct_pci_cfg = f15_read_dct_pci_cfg,
1597 static struct pci_dev *pci_get_related_function(unsigned int vendor,
1598 unsigned int device,
1599 struct pci_dev *related)
1601 struct pci_dev *dev = NULL;
1603 dev = pci_get_device(vendor, device, dev);
1605 if ((dev->bus->number == related->bus->number) &&
1606 (PCI_SLOT(dev->devfn) == PCI_SLOT(related->devfn)))
1608 dev = pci_get_device(vendor, device, dev);
1615 * These are tables of eigenvectors (one per line) which can be used for the
1616 * construction of the syndrome tables. The modified syndrome search algorithm
1617 * uses those to find the symbol in error and thus the DIMM.
1619 * Algorithm courtesy of Ross LaFetra from AMD.
1621 static u16 x4_vectors[] = {
1622 0x2f57, 0x1afe, 0x66cc, 0xdd88,
1623 0x11eb, 0x3396, 0x7f4c, 0xeac8,
1624 0x0001, 0x0002, 0x0004, 0x0008,
1625 0x1013, 0x3032, 0x4044, 0x8088,
1626 0x106b, 0x30d6, 0x70fc, 0xe0a8,
1627 0x4857, 0xc4fe, 0x13cc, 0x3288,
1628 0x1ac5, 0x2f4a, 0x5394, 0xa1e8,
1629 0x1f39, 0x251e, 0xbd6c, 0x6bd8,
1630 0x15c1, 0x2a42, 0x89ac, 0x4758,
1631 0x2b03, 0x1602, 0x4f0c, 0xca08,
1632 0x1f07, 0x3a0e, 0x6b04, 0xbd08,
1633 0x8ba7, 0x465e, 0x244c, 0x1cc8,
1634 0x2b87, 0x164e, 0x642c, 0xdc18,
1635 0x40b9, 0x80de, 0x1094, 0x20e8,
1636 0x27db, 0x1eb6, 0x9dac, 0x7b58,
1637 0x11c1, 0x2242, 0x84ac, 0x4c58,
1638 0x1be5, 0x2d7a, 0x5e34, 0xa718,
1639 0x4b39, 0x8d1e, 0x14b4, 0x28d8,
1640 0x4c97, 0xc87e, 0x11fc, 0x33a8,
1641 0x8e97, 0x497e, 0x2ffc, 0x1aa8,
1642 0x16b3, 0x3d62, 0x4f34, 0x8518,
1643 0x1e2f, 0x391a, 0x5cac, 0xf858,
1644 0x1d9f, 0x3b7a, 0x572c, 0xfe18,
1645 0x15f5, 0x2a5a, 0x5264, 0xa3b8,
1646 0x1dbb, 0x3b66, 0x715c, 0xe3f8,
1647 0x4397, 0xc27e, 0x17fc, 0x3ea8,
1648 0x1617, 0x3d3e, 0x6464, 0xb8b8,
1649 0x23ff, 0x12aa, 0xab6c, 0x56d8,
1650 0x2dfb, 0x1ba6, 0x913c, 0x7328,
1651 0x185d, 0x2ca6, 0x7914, 0x9e28,
1652 0x171b, 0x3e36, 0x7d7c, 0xebe8,
1653 0x4199, 0x82ee, 0x19f4, 0x2e58,
1654 0x4807, 0xc40e, 0x130c, 0x3208,
1655 0x1905, 0x2e0a, 0x5804, 0xac08,
1656 0x213f, 0x132a, 0xadfc, 0x5ba8,
1657 0x19a9, 0x2efe, 0xb5cc, 0x6f88,
1660 static u16 x8_vectors[] = {
1661 0x0145, 0x028a, 0x2374, 0x43c8, 0xa1f0, 0x0520, 0x0a40, 0x1480,
1662 0x0211, 0x0422, 0x0844, 0x1088, 0x01b0, 0x44e0, 0x23c0, 0xed80,
1663 0x1011, 0x0116, 0x022c, 0x0458, 0x08b0, 0x8c60, 0x2740, 0x4e80,
1664 0x0411, 0x0822, 0x1044, 0x0158, 0x02b0, 0x2360, 0x46c0, 0xab80,
1665 0x0811, 0x1022, 0x012c, 0x0258, 0x04b0, 0x4660, 0x8cc0, 0x2780,
1666 0x2071, 0x40e2, 0xa0c4, 0x0108, 0x0210, 0x0420, 0x0840, 0x1080,
1667 0x4071, 0x80e2, 0x0104, 0x0208, 0x0410, 0x0820, 0x1040, 0x2080,
1668 0x8071, 0x0102, 0x0204, 0x0408, 0x0810, 0x1020, 0x2040, 0x4080,
1669 0x019d, 0x03d6, 0x136c, 0x2198, 0x50b0, 0xb2e0, 0x0740, 0x0e80,
1670 0x0189, 0x03ea, 0x072c, 0x0e58, 0x1cb0, 0x56e0, 0x37c0, 0xf580,
1671 0x01fd, 0x0376, 0x06ec, 0x0bb8, 0x1110, 0x2220, 0x4440, 0x8880,
1672 0x0163, 0x02c6, 0x1104, 0x0758, 0x0eb0, 0x2be0, 0x6140, 0xc280,
1673 0x02fd, 0x01c6, 0x0b5c, 0x1108, 0x07b0, 0x25a0, 0x8840, 0x6180,
1674 0x0801, 0x012e, 0x025c, 0x04b8, 0x1370, 0x26e0, 0x57c0, 0xb580,
1675 0x0401, 0x0802, 0x015c, 0x02b8, 0x22b0, 0x13e0, 0x7140, 0xe280,
1676 0x0201, 0x0402, 0x0804, 0x01b8, 0x11b0, 0x31a0, 0x8040, 0x7180,
1677 0x0101, 0x0202, 0x0404, 0x0808, 0x1010, 0x2020, 0x4040, 0x8080,
1678 0x0001, 0x0002, 0x0004, 0x0008, 0x0010, 0x0020, 0x0040, 0x0080,
1679 0x0100, 0x0200, 0x0400, 0x0800, 0x1000, 0x2000, 0x4000, 0x8000,
1682 static int decode_syndrome(u16 syndrome, u16 *vectors, int num_vecs,
1685 unsigned int i, err_sym;
1687 for (err_sym = 0; err_sym < num_vecs / v_dim; err_sym++) {
1689 int v_idx = err_sym * v_dim;
1690 int v_end = (err_sym + 1) * v_dim;
1692 /* walk over all 16 bits of the syndrome */
1693 for (i = 1; i < (1U << 16); i <<= 1) {
1695 /* if bit is set in that eigenvector... */
1696 if (v_idx < v_end && vectors[v_idx] & i) {
1697 u16 ev_comp = vectors[v_idx++];
1699 /* ... and bit set in the modified syndrome, */
1709 /* can't get to zero, move to next symbol */
1714 debugf0("syndrome(%x) not found\n", syndrome);
1718 static int map_err_sym_to_channel(int err_sym, int sym_size)
1731 return err_sym >> 4;
1737 /* imaginary bits not in a DIMM */
1739 WARN(1, KERN_ERR "Invalid error symbol: 0x%x\n",
1751 return err_sym >> 3;
1757 static int get_channel_from_ecc_syndrome(struct mem_ctl_info *mci, u16 syndrome)
1759 struct amd64_pvt *pvt = mci->pvt_info;
1762 if (pvt->syn_type == 8)
1763 err_sym = decode_syndrome(syndrome, x8_vectors,
1764 ARRAY_SIZE(x8_vectors),
1766 else if (pvt->syn_type == 4)
1767 err_sym = decode_syndrome(syndrome, x4_vectors,
1768 ARRAY_SIZE(x4_vectors),
1771 amd64_warn("Illegal syndrome type: %u\n", pvt->syn_type);
1775 return map_err_sym_to_channel(err_sym, pvt->syn_type);
1779 * Handle any Correctable Errors (CEs) that have occurred. Check for valid ERROR
1780 * ADDRESS and process.
1782 static void amd64_handle_ce(struct mem_ctl_info *mci, struct mce *m)
1784 struct amd64_pvt *pvt = mci->pvt_info;
1788 /* Ensure that the Error Address is VALID */
1789 if (!(m->status & MCI_STATUS_ADDRV)) {
1790 amd64_mc_err(mci, "HW has no ERROR_ADDRESS available\n");
1791 edac_mc_handle_ce_no_info(mci, EDAC_MOD_STR);
1795 sys_addr = get_error_address(m);
1796 syndrome = extract_syndrome(m->status);
1798 amd64_mc_err(mci, "CE ERROR_ADDRESS= 0x%llx\n", sys_addr);
1800 pvt->ops->map_sysaddr_to_csrow(mci, sys_addr, syndrome);
1803 /* Handle any Un-correctable Errors (UEs) */
1804 static void amd64_handle_ue(struct mem_ctl_info *mci, struct mce *m)
1806 struct mem_ctl_info *log_mci, *src_mci = NULL;
1813 if (!(m->status & MCI_STATUS_ADDRV)) {
1814 amd64_mc_err(mci, "HW has no ERROR_ADDRESS available\n");
1815 edac_mc_handle_ue_no_info(log_mci, EDAC_MOD_STR);
1819 sys_addr = get_error_address(m);
1822 * Find out which node the error address belongs to. This may be
1823 * different from the node that detected the error.
1825 src_mci = find_mc_by_sys_addr(mci, sys_addr);
1827 amd64_mc_err(mci, "ERROR ADDRESS (0x%lx) NOT mapped to a MC\n",
1828 (unsigned long)sys_addr);
1829 edac_mc_handle_ue_no_info(log_mci, EDAC_MOD_STR);
1835 csrow = sys_addr_to_csrow(log_mci, sys_addr);
1837 amd64_mc_err(mci, "ERROR_ADDRESS (0x%lx) NOT mapped to CS\n",
1838 (unsigned long)sys_addr);
1839 edac_mc_handle_ue_no_info(log_mci, EDAC_MOD_STR);
1841 error_address_to_page_and_offset(sys_addr, &page, &offset);
1842 edac_mc_handle_ue(log_mci, page, offset, csrow, EDAC_MOD_STR);
1846 static inline void __amd64_decode_bus_error(struct mem_ctl_info *mci,
1849 u16 ec = EC(m->status);
1850 u8 xec = XEC(m->status, 0x1f);
1851 u8 ecc_type = (m->status >> 45) & 0x3;
1853 /* Bail early out if this was an 'observed' error */
1854 if (PP(ec) == NBSL_PP_OBS)
1857 /* Do only ECC errors */
1858 if (xec && xec != F10_NBSL_EXT_ERR_ECC)
1862 amd64_handle_ce(mci, m);
1863 else if (ecc_type == 1)
1864 amd64_handle_ue(mci, m);
1867 void amd64_decode_bus_error(int node_id, struct mce *m, u32 nbcfg)
1869 struct mem_ctl_info *mci = mcis[node_id];
1871 __amd64_decode_bus_error(mci, m);
1875 * Use pvt->F2 which contains the F2 CPU PCI device to get the related
1876 * F1 (AddrMap) and F3 (Misc) devices. Return negative value on error.
1878 static int reserve_mc_sibling_devs(struct amd64_pvt *pvt, u16 f1_id, u16 f3_id)
1880 /* Reserve the ADDRESS MAP Device */
1881 pvt->F1 = pci_get_related_function(pvt->F2->vendor, f1_id, pvt->F2);
1883 amd64_err("error address map device not found: "
1884 "vendor %x device 0x%x (broken BIOS?)\n",
1885 PCI_VENDOR_ID_AMD, f1_id);
1889 /* Reserve the MISC Device */
1890 pvt->F3 = pci_get_related_function(pvt->F2->vendor, f3_id, pvt->F2);
1892 pci_dev_put(pvt->F1);
1895 amd64_err("error F3 device not found: "
1896 "vendor %x device 0x%x (broken BIOS?)\n",
1897 PCI_VENDOR_ID_AMD, f3_id);
1901 debugf1("F1: %s\n", pci_name(pvt->F1));
1902 debugf1("F2: %s\n", pci_name(pvt->F2));
1903 debugf1("F3: %s\n", pci_name(pvt->F3));
1908 static void free_mc_sibling_devs(struct amd64_pvt *pvt)
1910 pci_dev_put(pvt->F1);
1911 pci_dev_put(pvt->F3);
1915 * Retrieve the hardware registers of the memory controller (this includes the
1916 * 'Address Map' and 'Misc' device regs)
1918 static void read_mc_regs(struct amd64_pvt *pvt)
1925 * Retrieve TOP_MEM and TOP_MEM2; no masking off of reserved bits since
1926 * those are Read-As-Zero
1928 rdmsrl(MSR_K8_TOP_MEM1, pvt->top_mem);
1929 debugf0(" TOP_MEM: 0x%016llx\n", pvt->top_mem);
1931 /* check first whether TOP_MEM2 is enabled */
1932 rdmsrl(MSR_K8_SYSCFG, msr_val);
1933 if (msr_val & (1U << 21)) {
1934 rdmsrl(MSR_K8_TOP_MEM2, pvt->top_mem2);
1935 debugf0(" TOP_MEM2: 0x%016llx\n", pvt->top_mem2);
1937 debugf0(" TOP_MEM2 disabled.\n");
1939 amd64_read_pci_cfg(pvt->F3, NBCAP, &pvt->nbcap);
1941 if (pvt->ops->read_dram_ctl_register)
1942 pvt->ops->read_dram_ctl_register(pvt);
1944 for (range = 0; range < DRAM_RANGES; range++) {
1947 /* read settings for this DRAM range */
1948 read_dram_base_limit_regs(pvt, range);
1950 rw = dram_rw(pvt, range);
1954 debugf1(" DRAM range[%d], base: 0x%016llx; limit: 0x%016llx\n",
1956 get_dram_base(pvt, range),
1957 get_dram_limit(pvt, range));
1959 debugf1(" IntlvEn=%s; Range access: %s%s IntlvSel=%d DstNode=%d\n",
1960 dram_intlv_en(pvt, range) ? "Enabled" : "Disabled",
1961 (rw & 0x1) ? "R" : "-",
1962 (rw & 0x2) ? "W" : "-",
1963 dram_intlv_sel(pvt, range),
1964 dram_dst_node(pvt, range));
1967 read_dct_base_mask(pvt);
1969 amd64_read_pci_cfg(pvt->F1, DHAR, &pvt->dhar);
1970 amd64_read_dct_pci_cfg(pvt, DBAM0, &pvt->dbam0);
1972 amd64_read_pci_cfg(pvt->F3, F10_ONLINE_SPARE, &pvt->online_spare);
1974 amd64_read_dct_pci_cfg(pvt, DCLR0, &pvt->dclr0);
1975 amd64_read_dct_pci_cfg(pvt, DCHR0, &pvt->dchr0);
1977 if (!dct_ganging_enabled(pvt)) {
1978 amd64_read_dct_pci_cfg(pvt, DCLR1, &pvt->dclr1);
1979 amd64_read_dct_pci_cfg(pvt, DCHR1, &pvt->dchr1);
1982 if (boot_cpu_data.x86 >= 0x10) {
1983 amd64_read_pci_cfg(pvt->F3, EXT_NB_MCA_CFG, &tmp);
1984 amd64_read_dct_pci_cfg(pvt, DBAM1, &pvt->dbam1);
1987 if (boot_cpu_data.x86 == 0x10 &&
1988 boot_cpu_data.x86_model > 7 &&
1989 /* F3x180[EccSymbolSize]=1 => x8 symbols */
1995 dump_misc_regs(pvt);
1999 * NOTE: CPU Revision Dependent code
2002 * @csrow_nr ChipSelect Row Number (0..NUM_CHIPSELECTS-1)
2003 * k8 private pointer to -->
2004 * DRAM Bank Address mapping register
2006 * DCL register where dual_channel_active is
2008 * The DBAM register consists of 4 sets of 4 bits each definitions:
2011 * 0-3 CSROWs 0 and 1
2012 * 4-7 CSROWs 2 and 3
2013 * 8-11 CSROWs 4 and 5
2014 * 12-15 CSROWs 6 and 7
2016 * Values range from: 0 to 15
2017 * The meaning of the values depends on CPU revision and dual-channel state,
2018 * see relevant BKDG more info.
2020 * The memory controller provides for total of only 8 CSROWs in its current
2021 * architecture. Each "pair" of CSROWs normally represents just one DIMM in
2022 * single channel or two (2) DIMMs in dual channel mode.
2024 * The following code logic collapses the various tables for CSROW based on CPU
2028 * The number of PAGE_SIZE pages on the specified CSROW number it
2032 static u32 amd64_csrow_nr_pages(int csrow_nr, struct amd64_pvt *pvt)
2034 u32 cs_mode, nr_pages;
2037 * The math on this doesn't look right on the surface because x/2*4 can
2038 * be simplified to x*2 but this expression makes use of the fact that
2039 * it is integral math where 1/2=0. This intermediate value becomes the
2040 * number of bits to shift the DBAM register to extract the proper CSROW
2043 cs_mode = (pvt->dbam0 >> ((csrow_nr / 2) * 4)) & 0xF;
2045 nr_pages = pvt->ops->dbam_to_cs(pvt, cs_mode) << (20 - PAGE_SHIFT);
2048 * If dual channel then double the memory size of single channel.
2049 * Channel count is 1 or 2
2051 nr_pages <<= (pvt->channel_count - 1);
2053 debugf0(" (csrow=%d) DBAM map index= %d\n", csrow_nr, cs_mode);
2054 debugf0(" nr_pages= %u channel-count = %d\n",
2055 nr_pages, pvt->channel_count);
2061 * Initialize the array of csrow attribute instances, based on the values
2062 * from pci config hardware registers.
2064 static int init_csrows(struct mem_ctl_info *mci)
2066 struct csrow_info *csrow;
2067 struct amd64_pvt *pvt = mci->pvt_info;
2068 u64 input_addr_min, input_addr_max, sys_addr, base, mask;
2072 amd64_read_pci_cfg(pvt->F3, NBCFG, &val);
2076 debugf0("node %d, NBCFG=0x%08x[ChipKillEccCap: %d|DramEccEn: %d]\n",
2077 pvt->mc_node_id, val,
2078 !!(val & NBCFG_CHIPKILL), !!(val & NBCFG_ECC_ENABLE));
2080 for_each_chip_select(i, 0, pvt) {
2081 csrow = &mci->csrows[i];
2083 if (!csrow_enabled(i, 0, pvt)) {
2084 debugf1("----CSROW %d EMPTY for node %d\n", i,
2089 debugf1("----CSROW %d VALID for MC node %d\n",
2090 i, pvt->mc_node_id);
2093 csrow->nr_pages = amd64_csrow_nr_pages(i, pvt);
2094 find_csrow_limits(mci, i, &input_addr_min, &input_addr_max);
2095 sys_addr = input_addr_to_sys_addr(mci, input_addr_min);
2096 csrow->first_page = (u32) (sys_addr >> PAGE_SHIFT);
2097 sys_addr = input_addr_to_sys_addr(mci, input_addr_max);
2098 csrow->last_page = (u32) (sys_addr >> PAGE_SHIFT);
2100 get_cs_base_and_mask(pvt, i, 0, &base, &mask);
2101 csrow->page_mask = ~mask;
2102 /* 8 bytes of resolution */
2104 csrow->mtype = amd64_determine_memory_type(pvt, i);
2106 debugf1(" for MC node %d csrow %d:\n", pvt->mc_node_id, i);
2107 debugf1(" input_addr_min: 0x%lx input_addr_max: 0x%lx\n",
2108 (unsigned long)input_addr_min,
2109 (unsigned long)input_addr_max);
2110 debugf1(" sys_addr: 0x%lx page_mask: 0x%lx\n",
2111 (unsigned long)sys_addr, csrow->page_mask);
2112 debugf1(" nr_pages: %u first_page: 0x%lx "
2113 "last_page: 0x%lx\n",
2114 (unsigned)csrow->nr_pages,
2115 csrow->first_page, csrow->last_page);
2118 * determine whether CHIPKILL or JUST ECC or NO ECC is operating
2120 if (pvt->nbcfg & NBCFG_ECC_ENABLE)
2122 (pvt->nbcfg & NBCFG_CHIPKILL) ?
2123 EDAC_S4ECD4ED : EDAC_SECDED;
2125 csrow->edac_mode = EDAC_NONE;
2131 /* get all cores on this DCT */
2132 static void get_cpus_on_this_dct_cpumask(struct cpumask *mask, int nid)
2136 for_each_online_cpu(cpu)
2137 if (amd_get_nb_id(cpu) == nid)
2138 cpumask_set_cpu(cpu, mask);
2141 /* check MCG_CTL on all the cpus on this node */
2142 static bool amd64_nb_mce_bank_enabled_on_node(int nid)
2148 if (!zalloc_cpumask_var(&mask, GFP_KERNEL)) {
2149 amd64_warn("%s: Error allocating mask\n", __func__);
2153 get_cpus_on_this_dct_cpumask(mask, nid);
2155 rdmsr_on_cpus(mask, MSR_IA32_MCG_CTL, msrs);
2157 for_each_cpu(cpu, mask) {
2158 struct msr *reg = per_cpu_ptr(msrs, cpu);
2159 nbe = reg->l & MSR_MCGCTL_NBE;
2161 debugf0("core: %u, MCG_CTL: 0x%llx, NB MSR is %s\n",
2163 (nbe ? "enabled" : "disabled"));
2171 free_cpumask_var(mask);
2175 static int toggle_ecc_err_reporting(struct ecc_settings *s, u8 nid, bool on)
2177 cpumask_var_t cmask;
2180 if (!zalloc_cpumask_var(&cmask, GFP_KERNEL)) {
2181 amd64_warn("%s: error allocating mask\n", __func__);
2185 get_cpus_on_this_dct_cpumask(cmask, nid);
2187 rdmsr_on_cpus(cmask, MSR_IA32_MCG_CTL, msrs);
2189 for_each_cpu(cpu, cmask) {
2191 struct msr *reg = per_cpu_ptr(msrs, cpu);
2194 if (reg->l & MSR_MCGCTL_NBE)
2195 s->flags.nb_mce_enable = 1;
2197 reg->l |= MSR_MCGCTL_NBE;
2200 * Turn off NB MCE reporting only when it was off before
2202 if (!s->flags.nb_mce_enable)
2203 reg->l &= ~MSR_MCGCTL_NBE;
2206 wrmsr_on_cpus(cmask, MSR_IA32_MCG_CTL, msrs);
2208 free_cpumask_var(cmask);
2213 static bool enable_ecc_error_reporting(struct ecc_settings *s, u8 nid,
2217 u32 value, mask = 0x3; /* UECC/CECC enable */
2219 if (toggle_ecc_err_reporting(s, nid, ON)) {
2220 amd64_warn("Error enabling ECC reporting over MCGCTL!\n");
2224 amd64_read_pci_cfg(F3, NBCTL, &value);
2226 s->old_nbctl = value & mask;
2227 s->nbctl_valid = true;
2230 amd64_write_pci_cfg(F3, NBCTL, value);
2232 amd64_read_pci_cfg(F3, NBCFG, &value);
2234 debugf0("1: node %d, NBCFG=0x%08x[DramEccEn: %d]\n",
2235 nid, value, !!(value & NBCFG_ECC_ENABLE));
2237 if (!(value & NBCFG_ECC_ENABLE)) {
2238 amd64_warn("DRAM ECC disabled on this node, enabling...\n");
2240 s->flags.nb_ecc_prev = 0;
2242 /* Attempt to turn on DRAM ECC Enable */
2243 value |= NBCFG_ECC_ENABLE;
2244 amd64_write_pci_cfg(F3, NBCFG, value);
2246 amd64_read_pci_cfg(F3, NBCFG, &value);
2248 if (!(value & NBCFG_ECC_ENABLE)) {
2249 amd64_warn("Hardware rejected DRAM ECC enable,"
2250 "check memory DIMM configuration.\n");
2253 amd64_info("Hardware accepted DRAM ECC Enable\n");
2256 s->flags.nb_ecc_prev = 1;
2259 debugf0("2: node %d, NBCFG=0x%08x[DramEccEn: %d]\n",
2260 nid, value, !!(value & NBCFG_ECC_ENABLE));
2265 static void restore_ecc_error_reporting(struct ecc_settings *s, u8 nid,
2268 u32 value, mask = 0x3; /* UECC/CECC enable */
2271 if (!s->nbctl_valid)
2274 amd64_read_pci_cfg(F3, NBCTL, &value);
2276 value |= s->old_nbctl;
2278 amd64_write_pci_cfg(F3, NBCTL, value);
2280 /* restore previous BIOS DRAM ECC "off" setting we force-enabled */
2281 if (!s->flags.nb_ecc_prev) {
2282 amd64_read_pci_cfg(F3, NBCFG, &value);
2283 value &= ~NBCFG_ECC_ENABLE;
2284 amd64_write_pci_cfg(F3, NBCFG, value);
2287 /* restore the NB Enable MCGCTL bit */
2288 if (toggle_ecc_err_reporting(s, nid, OFF))
2289 amd64_warn("Error restoring NB MCGCTL settings!\n");
2293 * EDAC requires that the BIOS have ECC enabled before
2294 * taking over the processing of ECC errors. A command line
2295 * option allows to force-enable hardware ECC later in
2296 * enable_ecc_error_reporting().
2298 static const char *ecc_msg =
2299 "ECC disabled in the BIOS or no ECC capability, module will not load.\n"
2300 " Either enable ECC checking or force module loading by setting "
2301 "'ecc_enable_override'.\n"
2302 " (Note that use of the override may cause unknown side effects.)\n";
2304 static bool ecc_enabled(struct pci_dev *F3, u8 nid)
2308 bool nb_mce_en = false;
2310 amd64_read_pci_cfg(F3, NBCFG, &value);
2312 ecc_en = !!(value & NBCFG_ECC_ENABLE);
2313 amd64_info("DRAM ECC %s.\n", (ecc_en ? "enabled" : "disabled"));
2315 nb_mce_en = amd64_nb_mce_bank_enabled_on_node(nid);
2317 amd64_notice("NB MCE bank disabled, set MSR "
2318 "0x%08x[4] on node %d to enable.\n",
2319 MSR_IA32_MCG_CTL, nid);
2321 if (!ecc_en || !nb_mce_en) {
2322 amd64_notice("%s", ecc_msg);
2328 struct mcidev_sysfs_attribute sysfs_attrs[ARRAY_SIZE(amd64_dbg_attrs) +
2329 ARRAY_SIZE(amd64_inj_attrs) +
2332 struct mcidev_sysfs_attribute terminator = { .attr = { .name = NULL } };
2334 static void set_mc_sysfs_attrs(struct mem_ctl_info *mci)
2336 unsigned int i = 0, j = 0;
2338 for (; i < ARRAY_SIZE(amd64_dbg_attrs); i++)
2339 sysfs_attrs[i] = amd64_dbg_attrs[i];
2341 if (boot_cpu_data.x86 >= 0x10)
2342 for (j = 0; j < ARRAY_SIZE(amd64_inj_attrs); j++, i++)
2343 sysfs_attrs[i] = amd64_inj_attrs[j];
2345 sysfs_attrs[i] = terminator;
2347 mci->mc_driver_sysfs_attributes = sysfs_attrs;
2350 static void setup_mci_misc_attrs(struct mem_ctl_info *mci)
2352 struct amd64_pvt *pvt = mci->pvt_info;
2354 mci->mtype_cap = MEM_FLAG_DDR2 | MEM_FLAG_RDDR2;
2355 mci->edac_ctl_cap = EDAC_FLAG_NONE;
2357 if (pvt->nbcap & NBCAP_SECDED)
2358 mci->edac_ctl_cap |= EDAC_FLAG_SECDED;
2360 if (pvt->nbcap & NBCAP_CHIPKILL)
2361 mci->edac_ctl_cap |= EDAC_FLAG_S4ECD4ED;
2363 mci->edac_cap = amd64_determine_edac_cap(pvt);
2364 mci->mod_name = EDAC_MOD_STR;
2365 mci->mod_ver = EDAC_AMD64_VERSION;
2366 mci->ctl_name = pvt->ctl_name;
2367 mci->dev_name = pci_name(pvt->F2);
2368 mci->ctl_page_to_phys = NULL;
2370 /* memory scrubber interface */
2371 mci->set_sdram_scrub_rate = amd64_set_scrub_rate;
2372 mci->get_sdram_scrub_rate = amd64_get_scrub_rate;
2376 * returns a pointer to the family descriptor on success, NULL otherwise.
2378 static struct amd64_family_type *amd64_per_family_init(struct amd64_pvt *pvt)
2380 u8 fam = boot_cpu_data.x86;
2381 struct amd64_family_type *fam_type = NULL;
2385 fam_type = &amd64_family_types[K8_CPUS];
2386 pvt->ops = &amd64_family_types[K8_CPUS].ops;
2387 pvt->ctl_name = fam_type->ctl_name;
2388 pvt->min_scrubrate = K8_MIN_SCRUB_RATE_BITS;
2391 fam_type = &amd64_family_types[F10_CPUS];
2392 pvt->ops = &amd64_family_types[F10_CPUS].ops;
2393 pvt->ctl_name = fam_type->ctl_name;
2394 pvt->min_scrubrate = F10_MIN_SCRUB_RATE_BITS;
2398 amd64_err("Unsupported family!\n");
2402 pvt->ext_model = boot_cpu_data.x86_model >> 4;
2404 amd64_info("%s %sdetected (node %d).\n", pvt->ctl_name,
2406 (pvt->ext_model >= K8_REV_F ? "revF or later "
2407 : "revE or earlier ")
2408 : ""), pvt->mc_node_id);
2412 static int amd64_init_one_instance(struct pci_dev *F2)
2414 struct amd64_pvt *pvt = NULL;
2415 struct amd64_family_type *fam_type = NULL;
2416 struct mem_ctl_info *mci = NULL;
2418 u8 nid = get_node_id(F2);
2421 pvt = kzalloc(sizeof(struct amd64_pvt), GFP_KERNEL);
2425 pvt->mc_node_id = nid;
2429 fam_type = amd64_per_family_init(pvt);
2434 err = reserve_mc_sibling_devs(pvt, fam_type->f1_id, fam_type->f3_id);
2441 * We need to determine how many memory channels there are. Then use
2442 * that information for calculating the size of the dynamic instance
2443 * tables in the 'mci' structure.
2446 pvt->channel_count = pvt->ops->early_channel_count(pvt);
2447 if (pvt->channel_count < 0)
2451 mci = edac_mc_alloc(0, pvt->csels[0].b_cnt, pvt->channel_count, nid);
2455 mci->pvt_info = pvt;
2456 mci->dev = &pvt->F2->dev;
2458 setup_mci_misc_attrs(mci);
2460 if (init_csrows(mci))
2461 mci->edac_cap = EDAC_FLAG_NONE;
2463 set_mc_sysfs_attrs(mci);
2466 if (edac_mc_add_mc(mci)) {
2467 debugf1("failed edac_mc_add_mc()\n");
2471 /* register stuff with EDAC MCE */
2472 if (report_gart_errors)
2473 amd_report_gart_errors(true);
2475 amd_register_ecc_decoder(amd64_decode_bus_error);
2479 atomic_inc(&drv_instances);
2487 free_mc_sibling_devs(pvt);
2496 static int __devinit amd64_probe_one_instance(struct pci_dev *pdev,
2497 const struct pci_device_id *mc_type)
2499 u8 nid = get_node_id(pdev);
2500 struct pci_dev *F3 = node_to_amd_nb(nid)->misc;
2501 struct ecc_settings *s;
2504 ret = pci_enable_device(pdev);
2506 debugf0("ret=%d\n", ret);
2511 s = kzalloc(sizeof(struct ecc_settings), GFP_KERNEL);
2517 if (!ecc_enabled(F3, nid)) {
2520 if (!ecc_enable_override)
2523 amd64_warn("Forcing ECC on!\n");
2525 if (!enable_ecc_error_reporting(s, nid, F3))
2529 ret = amd64_init_one_instance(pdev);
2531 amd64_err("Error probing instance: %d\n", nid);
2532 restore_ecc_error_reporting(s, nid, F3);
2539 ecc_stngs[nid] = NULL;
2545 static void __devexit amd64_remove_one_instance(struct pci_dev *pdev)
2547 struct mem_ctl_info *mci;
2548 struct amd64_pvt *pvt;
2549 u8 nid = get_node_id(pdev);
2550 struct pci_dev *F3 = node_to_amd_nb(nid)->misc;
2551 struct ecc_settings *s = ecc_stngs[nid];
2553 /* Remove from EDAC CORE tracking list */
2554 mci = edac_mc_del_mc(&pdev->dev);
2558 pvt = mci->pvt_info;
2560 restore_ecc_error_reporting(s, nid, F3);
2562 free_mc_sibling_devs(pvt);
2564 /* unregister from EDAC MCE */
2565 amd_report_gart_errors(false);
2566 amd_unregister_ecc_decoder(amd64_decode_bus_error);
2568 kfree(ecc_stngs[nid]);
2569 ecc_stngs[nid] = NULL;
2571 /* Free the EDAC CORE resources */
2572 mci->pvt_info = NULL;
2580 * This table is part of the interface for loading drivers for PCI devices. The
2581 * PCI core identifies what devices are on a system during boot, and then
2582 * inquiry this table to see if this driver is for a given device found.
2584 static const struct pci_device_id amd64_pci_table[] __devinitdata = {
2586 .vendor = PCI_VENDOR_ID_AMD,
2587 .device = PCI_DEVICE_ID_AMD_K8_NB_MEMCTL,
2588 .subvendor = PCI_ANY_ID,
2589 .subdevice = PCI_ANY_ID,
2594 .vendor = PCI_VENDOR_ID_AMD,
2595 .device = PCI_DEVICE_ID_AMD_10H_NB_DRAM,
2596 .subvendor = PCI_ANY_ID,
2597 .subdevice = PCI_ANY_ID,
2603 MODULE_DEVICE_TABLE(pci, amd64_pci_table);
2605 static struct pci_driver amd64_pci_driver = {
2606 .name = EDAC_MOD_STR,
2607 .probe = amd64_probe_one_instance,
2608 .remove = __devexit_p(amd64_remove_one_instance),
2609 .id_table = amd64_pci_table,
2612 static void setup_pci_device(void)
2614 struct mem_ctl_info *mci;
2615 struct amd64_pvt *pvt;
2623 pvt = mci->pvt_info;
2625 edac_pci_create_generic_ctl(&pvt->F2->dev, EDAC_MOD_STR);
2627 if (!amd64_ctl_pci) {
2628 pr_warning("%s(): Unable to create PCI control\n",
2631 pr_warning("%s(): PCI error report via EDAC not set\n",
2637 static int __init amd64_edac_init(void)
2641 edac_printk(KERN_INFO, EDAC_MOD_STR, EDAC_AMD64_VERSION "\n");
2645 if (amd_cache_northbridges() < 0)
2649 mcis = kzalloc(amd_nb_num() * sizeof(mcis[0]), GFP_KERNEL);
2650 ecc_stngs = kzalloc(amd_nb_num() * sizeof(ecc_stngs[0]), GFP_KERNEL);
2651 if (!(mcis && ecc_stngs))
2654 msrs = msrs_alloc();
2658 err = pci_register_driver(&amd64_pci_driver);
2663 if (!atomic_read(&drv_instances))
2664 goto err_no_instances;
2670 pci_unregister_driver(&amd64_pci_driver);
2687 static void __exit amd64_edac_exit(void)
2690 edac_pci_release_generic_ctl(amd64_ctl_pci);
2692 pci_unregister_driver(&amd64_pci_driver);
2704 module_init(amd64_edac_init);
2705 module_exit(amd64_edac_exit);
2707 MODULE_LICENSE("GPL");
2708 MODULE_AUTHOR("SoftwareBitMaker: Doug Thompson, "
2709 "Dave Peterson, Thayne Harbaugh");
2710 MODULE_DESCRIPTION("MC support for AMD64 memory controllers - "
2711 EDAC_AMD64_VERSION);
2713 module_param(edac_op_state, int, 0444);
2714 MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");