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