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