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