amd64_edac: Cleanup NBCTL code
[linux-2.6.git] / drivers / edac / amd64_edac.h
1 /*
2  * AMD64 class Memory Controller kernel module
3  *
4  * Copyright (c) 2009 SoftwareBitMaker.
5  * Copyright (c) 2009 Advanced Micro Devices, Inc.
6  *
7  * This file may be distributed under the terms of the
8  * GNU General Public License.
9  *
10  *      Originally Written by Thayne Harbaugh
11  *
12  *      Changes by Douglas "norsk" Thompson  <dougthompson@xmission.com>:
13  *              - K8 CPU Revision D and greater support
14  *
15  *      Changes by Dave Peterson <dsp@llnl.gov> <dave_peterson@pobox.com>:
16  *              - Module largely rewritten, with new (and hopefully correct)
17  *              code for dealing with node and chip select interleaving,
18  *              various code cleanup, and bug fixes
19  *              - Added support for memory hoisting using DRAM hole address
20  *              register
21  *
22  *      Changes by Douglas "norsk" Thompson <dougthompson@xmission.com>:
23  *              -K8 Rev (1207) revision support added, required Revision
24  *              specific mini-driver code to support Rev F as well as
25  *              prior revisions
26  *
27  *      Changes by Douglas "norsk" Thompson <dougthompson@xmission.com>:
28  *              -Family 10h revision support added. New PCI Device IDs,
29  *              indicating new changes. Actual registers modified
30  *              were slight, less than the Rev E to Rev F transition
31  *              but changing the PCI Device ID was the proper thing to
32  *              do, as it provides for almost automactic family
33  *              detection. The mods to Rev F required more family
34  *              information detection.
35  *
36  *      Changes/Fixes by Borislav Petkov <borislav.petkov@amd.com>:
37  *              - misc fixes and code cleanups
38  *
39  * This module is based on the following documents
40  * (available from http://www.amd.com/):
41  *
42  *      Title:  BIOS and Kernel Developer's Guide for AMD Athlon 64 and AMD
43  *              Opteron Processors
44  *      AMD publication #: 26094
45  *`     Revision: 3.26
46  *
47  *      Title:  BIOS and Kernel Developer's Guide for AMD NPT Family 0Fh
48  *              Processors
49  *      AMD publication #: 32559
50  *      Revision: 3.00
51  *      Issue Date: May 2006
52  *
53  *      Title:  BIOS and Kernel Developer's Guide (BKDG) For AMD Family 10h
54  *              Processors
55  *      AMD publication #: 31116
56  *      Revision: 3.00
57  *      Issue Date: September 07, 2007
58  *
59  * Sections in the first 2 documents are no longer in sync with each other.
60  * The Family 10h BKDG was totally re-written from scratch with a new
61  * presentation model.
62  * Therefore, comments that refer to a Document section might be off.
63  */
64
65 #include <linux/module.h>
66 #include <linux/ctype.h>
67 #include <linux/init.h>
68 #include <linux/pci.h>
69 #include <linux/pci_ids.h>
70 #include <linux/slab.h>
71 #include <linux/mmzone.h>
72 #include <linux/edac.h>
73 #include <asm/msr.h>
74 #include "edac_core.h"
75 #include "mce_amd.h"
76
77 #define amd64_debug(fmt, arg...) \
78         edac_printk(KERN_DEBUG, "amd64", fmt, ##arg)
79
80 #define amd64_info(fmt, arg...) \
81         edac_printk(KERN_INFO, "amd64", fmt, ##arg)
82
83 #define amd64_notice(fmt, arg...) \
84         edac_printk(KERN_NOTICE, "amd64", fmt, ##arg)
85
86 #define amd64_warn(fmt, arg...) \
87         edac_printk(KERN_WARNING, "amd64", fmt, ##arg)
88
89 #define amd64_err(fmt, arg...) \
90         edac_printk(KERN_ERR, "amd64", fmt, ##arg)
91
92 #define amd64_mc_warn(mci, fmt, arg...) \
93         edac_mc_chipset_printk(mci, KERN_WARNING, "amd64", fmt, ##arg)
94
95 #define amd64_mc_err(mci, fmt, arg...) \
96         edac_mc_chipset_printk(mci, KERN_ERR, "amd64", fmt, ##arg)
97
98 /*
99  * Throughout the comments in this code, the following terms are used:
100  *
101  *      SysAddr, DramAddr, and InputAddr
102  *
103  *  These terms come directly from the amd64 documentation
104  * (AMD publication #26094).  They are defined as follows:
105  *
106  *     SysAddr:
107  *         This is a physical address generated by a CPU core or a device
108  *         doing DMA.  If generated by a CPU core, a SysAddr is the result of
109  *         a virtual to physical address translation by the CPU core's address
110  *         translation mechanism (MMU).
111  *
112  *     DramAddr:
113  *         A DramAddr is derived from a SysAddr by subtracting an offset that
114  *         depends on which node the SysAddr maps to and whether the SysAddr
115  *         is within a range affected by memory hoisting.  The DRAM Base
116  *         (section 3.4.4.1) and DRAM Limit (section 3.4.4.2) registers
117  *         determine which node a SysAddr maps to.
118  *
119  *         If the DRAM Hole Address Register (DHAR) is enabled and the SysAddr
120  *         is within the range of addresses specified by this register, then
121  *         a value x from the DHAR is subtracted from the SysAddr to produce a
122  *         DramAddr.  Here, x represents the base address for the node that
123  *         the SysAddr maps to plus an offset due to memory hoisting.  See
124  *         section 3.4.8 and the comments in amd64_get_dram_hole_info() and
125  *         sys_addr_to_dram_addr() below for more information.
126  *
127  *         If the SysAddr is not affected by the DHAR then a value y is
128  *         subtracted from the SysAddr to produce a DramAddr.  Here, y is the
129  *         base address for the node that the SysAddr maps to.  See section
130  *         3.4.4 and the comments in sys_addr_to_dram_addr() below for more
131  *         information.
132  *
133  *     InputAddr:
134  *         A DramAddr is translated to an InputAddr before being passed to the
135  *         memory controller for the node that the DramAddr is associated
136  *         with.  The memory controller then maps the InputAddr to a csrow.
137  *         If node interleaving is not in use, then the InputAddr has the same
138  *         value as the DramAddr.  Otherwise, the InputAddr is produced by
139  *         discarding the bits used for node interleaving from the DramAddr.
140  *         See section 3.4.4 for more information.
141  *
142  *         The memory controller for a given node uses its DRAM CS Base and
143  *         DRAM CS Mask registers to map an InputAddr to a csrow.  See
144  *         sections 3.5.4 and 3.5.5 for more information.
145  */
146
147 #define EDAC_AMD64_VERSION              "v3.3.0"
148 #define EDAC_MOD_STR                    "amd64_edac"
149
150 /* Extended Model from CPUID, for CPU Revision numbers */
151 #define K8_REV_D                        1
152 #define K8_REV_E                        2
153 #define K8_REV_F                        4
154
155 /* Hardware limit on ChipSelect rows per MC and processors per system */
156 #define NUM_CHIPSELECTS                 8
157 #define DRAM_RANGES                     8
158
159 #define ON true
160 #define OFF false
161
162 /*
163  * Create a contiguous bitmask starting at bit position @lo and ending at
164  * position @hi. For example
165  *
166  * GENMASK(21, 39) gives us the 64bit vector 0x000000ffffe00000.
167  */
168 #define GENMASK(lo, hi)                 (((1ULL << ((hi) - (lo) + 1)) - 1) << (lo))
169
170 /*
171  * PCI-defined configuration space registers
172  */
173
174
175 /*
176  * Function 1 - Address Map
177  */
178 #define DRAM_BASE_LO                    0x40
179 #define DRAM_LIMIT_LO                   0x44
180
181 #define dram_intlv_en(pvt, i)           ((pvt->ranges[i].base.lo >> 8) & 0x7)
182 #define dram_rw(pvt, i)                 (pvt->ranges[i].base.lo & 0x3)
183 #define dram_intlv_sel(pvt, i)          ((pvt->ranges[i].lim.lo >> 8) & 0x7)
184 #define dram_dst_node(pvt, i)           (pvt->ranges[i].lim.lo & 0x7)
185
186 #define DHAR                            0xf0
187 #define dhar_valid(pvt)                 ((pvt)->dhar & BIT(0))
188 #define dhar_mem_hoist_valid(pvt)       ((pvt)->dhar & BIT(1))
189 #define dhar_base(pvt)                  ((pvt)->dhar & 0xff000000)
190 #define k8_dhar_offset(pvt)             (((pvt)->dhar & 0x0000ff00) << 16)
191
192                                         /* NOTE: Extra mask bit vs K8 */
193 #define f10_dhar_offset(pvt)            (((pvt)->dhar & 0x0000ff80) << 16)
194
195 #define DCT_CFG_SEL                     0x10C
196
197 #define DRAM_BASE_HI                    0x140
198 #define DRAM_LIMIT_HI                   0x144
199
200
201 /*
202  * Function 2 - DRAM controller
203  */
204 #define DCSB0                           0x40
205 #define DCSB1                           0x140
206 #define DCSB_CS_ENABLE                  BIT(0)
207
208 #define DCSM0                           0x60
209 #define DCSM1                           0x160
210
211 #define csrow_enabled(i, dct, pvt)      ((pvt)->csels[(dct)].csbases[(i)] & DCSB_CS_ENABLE)
212
213 #define DBAM0                           0x80
214 #define DBAM1                           0x180
215
216 /* Extract the DIMM 'type' on the i'th DIMM from the DBAM reg value passed */
217 #define DBAM_DIMM(i, reg)               ((((reg) >> (4*i))) & 0xF)
218
219 #define DBAM_MAX_VALUE                  11
220
221 #define DCLR0                           0x90
222 #define DCLR1                           0x190
223 #define REVE_WIDTH_128                  BIT(16)
224 #define F10_WIDTH_128                   BIT(11)
225
226 #define DCHR0                           0x94
227 #define DCHR1                           0x194
228 #define DDR3_MODE                       BIT(8)
229
230 #define DCT_SEL_LO                      0x110
231 #define dct_sel_baseaddr(pvt)           ((pvt)->dct_sel_lo & 0xFFFFF800)
232 #define dct_sel_interleave_addr(pvt)    (((pvt)->dct_sel_lo >> 6) & 0x3)
233 #define dct_high_range_enabled(pvt)     ((pvt)->dct_sel_lo & BIT(0))
234 #define dct_interleave_enabled(pvt)     ((pvt)->dct_sel_lo & BIT(2))
235
236 #define dct_ganging_enabled(pvt)        ((boot_cpu_data.x86 == 0x10) && ((pvt)->dct_sel_lo & BIT(4)))
237
238 #define dct_data_intlv_enabled(pvt)     ((pvt)->dct_sel_lo & BIT(5))
239 #define dct_dram_enabled(pvt)           ((pvt)->dct_sel_lo & BIT(8))
240 #define dct_memory_cleared(pvt)         ((pvt)->dct_sel_lo & BIT(10))
241
242 #define DCT_SEL_HI                      0x114
243
244 /*
245  * Function 3 - Misc Control
246  */
247 #define NBCTL                           0x40
248
249 #define K8_NBCFG                        0x44
250 #define K8_NBCFG_CHIPKILL               BIT(23)
251 #define K8_NBCFG_ECC_ENABLE             BIT(22)
252
253 #define K8_NBSL                         0x48
254
255 /* Family F10h: Normalized Extended Error Codes */
256 #define F10_NBSL_EXT_ERR_RES            0x0
257 #define F10_NBSL_EXT_ERR_ECC            0x8
258
259 /* Next two are overloaded values */
260 #define F10_NBSL_EXT_ERR_LINK_PROTO     0xB
261 #define F10_NBSL_EXT_ERR_L3_PROTO       0xB
262
263 #define F10_NBSL_EXT_ERR_NB_ARRAY       0xC
264 #define F10_NBSL_EXT_ERR_DRAM_PARITY    0xD
265 #define F10_NBSL_EXT_ERR_LINK_RETRY     0xE
266
267 /* Next two are overloaded values */
268 #define F10_NBSL_EXT_ERR_GART_WALK      0xF
269 #define F10_NBSL_EXT_ERR_DEV_WALK       0xF
270
271 /* 0x10 to 0x1B: Reserved */
272 #define F10_NBSL_EXT_ERR_L3_DATA        0x1C
273 #define F10_NBSL_EXT_ERR_L3_TAG         0x1D
274 #define F10_NBSL_EXT_ERR_L3_LRU         0x1E
275
276 /* K8: Normalized Extended Error Codes */
277 #define K8_NBSL_EXT_ERR_ECC             0x0
278 #define K8_NBSL_EXT_ERR_CRC             0x1
279 #define K8_NBSL_EXT_ERR_SYNC            0x2
280 #define K8_NBSL_EXT_ERR_MST             0x3
281 #define K8_NBSL_EXT_ERR_TGT             0x4
282 #define K8_NBSL_EXT_ERR_GART            0x5
283 #define K8_NBSL_EXT_ERR_RMW             0x6
284 #define K8_NBSL_EXT_ERR_WDT             0x7
285 #define K8_NBSL_EXT_ERR_CHIPKILL_ECC    0x8
286 #define K8_NBSL_EXT_ERR_DRAM_PARITY     0xD
287
288 /*
289  * The following are for BUS type errors AFTER values have been normalized by
290  * shifting right
291  */
292 #define K8_NBSL_PP_SRC                  0x0
293 #define K8_NBSL_PP_RES                  0x1
294 #define K8_NBSL_PP_OBS                  0x2
295 #define K8_NBSL_PP_GENERIC              0x3
296
297 #define EXTRACT_ERR_CPU_MAP(x)          ((x) & 0xF)
298
299 #define K8_NBEAL                        0x50
300 #define K8_NBEAH                        0x54
301 #define K8_SCRCTRL                      0x58
302
303 #define F10_NB_CFG_LOW                  0x88
304
305 #define F10_ONLINE_SPARE                0xB0
306 #define F10_ONLINE_SPARE_SWAPDONE0(x)   ((x) & BIT(1))
307 #define F10_ONLINE_SPARE_SWAPDONE1(x)   ((x) & BIT(3))
308 #define F10_ONLINE_SPARE_BADDRAM_CS0(x) (((x) >> 4) & 0x00000007)
309 #define F10_ONLINE_SPARE_BADDRAM_CS1(x) (((x) >> 8) & 0x00000007)
310
311 #define F10_NB_ARRAY_ADDR               0xB8
312
313 #define F10_NB_ARRAY_DRAM_ECC           0x80000000
314
315 /* Bits [2:1] are used to select 16-byte section within a 64-byte cacheline  */
316 #define SET_NB_ARRAY_ADDRESS(section)   (((section) & 0x3) << 1)
317
318 #define F10_NB_ARRAY_DATA               0xBC
319
320 #define SET_NB_DRAM_INJECTION_WRITE(word, bits)  \
321                                         (BIT(((word) & 0xF) + 20) | \
322                                         BIT(17) | bits)
323
324 #define SET_NB_DRAM_INJECTION_READ(word, bits)  \
325                                         (BIT(((word) & 0xF) + 20) | \
326                                         BIT(16) |  bits)
327
328 #define K8_NBCAP                        0xE8
329 #define K8_NBCAP_CORES                  (BIT(12)|BIT(13))
330 #define K8_NBCAP_CHIPKILL               BIT(4)
331 #define K8_NBCAP_SECDED                 BIT(3)
332 #define K8_NBCAP_DCT_DUAL               BIT(0)
333
334 #define EXT_NB_MCA_CFG                  0x180
335
336 /* MSRs */
337 #define K8_MSR_MCGCTL_NBE               BIT(4)
338
339 #define K8_MSR_MC4CTL                   0x0410
340 #define K8_MSR_MC4STAT                  0x0411
341 #define K8_MSR_MC4ADDR                  0x0412
342
343 /* AMD sets the first MC device at device ID 0x18. */
344 static inline int get_node_id(struct pci_dev *pdev)
345 {
346         return PCI_SLOT(pdev->devfn) - 0x18;
347 }
348
349 enum amd_families {
350         K8_CPUS = 0,
351         F10_CPUS,
352         F15_CPUS,
353         NUM_FAMILIES,
354 };
355
356 /* Error injection control structure */
357 struct error_injection {
358         u32     section;
359         u32     word;
360         u32     bit_map;
361 };
362
363 /* low and high part of PCI config space regs */
364 struct reg_pair {
365         u32 lo, hi;
366 };
367
368 /*
369  * See F1x[1, 0][7C:40] DRAM Base/Limit Registers
370  */
371 struct dram_range {
372         struct reg_pair base;
373         struct reg_pair lim;
374 };
375
376 /* A DCT chip selects collection */
377 struct chip_select {
378         u32 csbases[NUM_CHIPSELECTS];
379         u8 b_cnt;
380
381         u32 csmasks[NUM_CHIPSELECTS];
382         u8 m_cnt;
383 };
384
385 struct amd64_pvt {
386         struct low_ops *ops;
387
388         /* pci_device handles which we utilize */
389         struct pci_dev *F1, *F2, *F3;
390
391         int mc_node_id;         /* MC index of this MC node */
392         int ext_model;          /* extended model value of this node */
393         int channel_count;
394
395         /* Raw registers */
396         u32 dclr0;              /* DRAM Configuration Low DCT0 reg */
397         u32 dclr1;              /* DRAM Configuration Low DCT1 reg */
398         u32 dchr0;              /* DRAM Configuration High DCT0 reg */
399         u32 dchr1;              /* DRAM Configuration High DCT1 reg */
400         u32 nbcap;              /* North Bridge Capabilities */
401         u32 nbcfg;              /* F10 North Bridge Configuration */
402         u32 ext_nbcfg;          /* Extended F10 North Bridge Configuration */
403         u32 dhar;               /* DRAM Hoist reg */
404         u32 dbam0;              /* DRAM Base Address Mapping reg for DCT0 */
405         u32 dbam1;              /* DRAM Base Address Mapping reg for DCT1 */
406
407         /* one for each DCT */
408         struct chip_select csels[2];
409
410         /* DRAM base and limit pairs F1x[78,70,68,60,58,50,48,40] */
411         struct dram_range ranges[DRAM_RANGES];
412
413         u64 top_mem;            /* top of memory below 4GB */
414         u64 top_mem2;           /* top of memory above 4GB */
415
416         u32 dct_sel_lo;         /* DRAM Controller Select Low */
417         u32 dct_sel_hi;         /* DRAM Controller Select High */
418         u32 online_spare;       /* On-Line spare Reg */
419
420         /* x4 or x8 syndromes in use */
421         u8 syn_type;
422
423         /* temp storage for when input is received from sysfs */
424         struct err_regs ctl_error_info;
425
426         /* place to store error injection parameters prior to issue */
427         struct error_injection injection;
428
429         /* DCT per-family scrubrate setting */
430         u32 min_scrubrate;
431
432         /* family name this instance is running on */
433         const char *ctl_name;
434
435 };
436
437 static inline u64 get_dram_base(struct amd64_pvt *pvt, unsigned i)
438 {
439         u64 addr = ((u64)pvt->ranges[i].base.lo & 0xffff0000) << 8;
440
441         if (boot_cpu_data.x86 == 0xf)
442                 return addr;
443
444         return (((u64)pvt->ranges[i].base.hi & 0x000000ff) << 40) | addr;
445 }
446
447 static inline u64 get_dram_limit(struct amd64_pvt *pvt, unsigned i)
448 {
449         u64 lim = (((u64)pvt->ranges[i].lim.lo & 0xffff0000) << 8) | 0x00ffffff;
450
451         if (boot_cpu_data.x86 == 0xf)
452                 return lim;
453
454         return (((u64)pvt->ranges[i].lim.hi & 0x000000ff) << 40) | lim;
455 }
456
457 /*
458  * per-node ECC settings descriptor
459  */
460 struct ecc_settings {
461         u32 old_nbctl;
462         bool nbctl_valid;
463
464         struct flags {
465                 unsigned long nb_mce_enable:1;
466                 unsigned long nb_ecc_prev:1;
467         } flags;
468 };
469
470 extern const char *tt_msgs[4];
471 extern const char *ll_msgs[4];
472 extern const char *rrrr_msgs[16];
473 extern const char *to_msgs[2];
474 extern const char *pp_msgs[4];
475 extern const char *ii_msgs[4];
476 extern const char *htlink_msgs[8];
477
478 #ifdef CONFIG_EDAC_DEBUG
479 #define NUM_DBG_ATTRS 5
480 #else
481 #define NUM_DBG_ATTRS 0
482 #endif
483
484 #ifdef CONFIG_EDAC_AMD64_ERROR_INJECTION
485 #define NUM_INJ_ATTRS 5
486 #else
487 #define NUM_INJ_ATTRS 0
488 #endif
489
490 extern struct mcidev_sysfs_attribute amd64_dbg_attrs[NUM_DBG_ATTRS],
491                                      amd64_inj_attrs[NUM_INJ_ATTRS];
492
493 /*
494  * Each of the PCI Device IDs types have their own set of hardware accessor
495  * functions and per device encoding/decoding logic.
496  */
497 struct low_ops {
498         int (*early_channel_count)      (struct amd64_pvt *pvt);
499
500         u64 (*get_error_address)        (struct mem_ctl_info *mci,
501                                          struct err_regs *info);
502         void (*read_dram_ctl_register)  (struct amd64_pvt *pvt);
503         void (*map_sysaddr_to_csrow)    (struct mem_ctl_info *mci,
504                                          struct err_regs *info, u64 SystemAddr);
505         int (*dbam_to_cs)               (struct amd64_pvt *pvt, int cs_mode);
506         int (*read_dct_pci_cfg)         (struct amd64_pvt *pvt, int offset,
507                                          u32 *val, const char *func);
508 };
509
510 struct amd64_family_type {
511         const char *ctl_name;
512         u16 f1_id, f3_id;
513         struct low_ops ops;
514 };
515
516 int __amd64_write_pci_cfg_dword(struct pci_dev *pdev, int offset,
517                                 u32 val, const char *func);
518
519 #define amd64_read_pci_cfg(pdev, offset, val)   \
520         __amd64_read_pci_cfg_dword(pdev, offset, val, __func__)
521
522 #define amd64_write_pci_cfg(pdev, offset, val)  \
523         __amd64_write_pci_cfg_dword(pdev, offset, val, __func__)
524
525 #define amd64_read_dct_pci_cfg(pvt, offset, val) \
526         pvt->ops->read_dct_pci_cfg(pvt, offset, val, __func__)
527
528 /*
529  * For future CPU versions, verify the following as new 'slow' rates appear and
530  * modify the necessary skip values for the supported CPU.
531  */
532 #define K8_MIN_SCRUB_RATE_BITS  0x0
533 #define F10_MIN_SCRUB_RATE_BITS 0x5
534
535 int amd64_get_dram_hole_info(struct mem_ctl_info *mci, u64 *hole_base,
536                              u64 *hole_offset, u64 *hole_size);