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