projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-3.6' of git://gitorious.org/linux-pwm/linux-pwm
[deliverable/linux.git] / drivers / edac / i7core_edac.c
1 /* Intel i7 core/Nehalem Memory Controller kernel module
2 *
3 * This driver supports the memory controllers found on the Intel
4 * processor families i7core, i7core 7xx/8xx, i5core, Xeon 35xx,
5 * Xeon 55xx and Xeon 56xx also known as Nehalem, Nehalem-EP, Lynnfield
6 * and Westmere-EP.
7 *
8 * This file may be distributed under the terms of the
9 * GNU General Public License version 2 only.
10 *
11 * Copyright (c) 2009-2010 by:
12 * Mauro Carvalho Chehab <mchehab@redhat.com>
13 *
14 * Red Hat Inc. http://www.redhat.com
15 *
16 * Forked and adapted from the i5400_edac driver
17 *
18 * Based on the following public Intel datasheets:
19 * Intel Core i7 Processor Extreme Edition and Intel Core i7 Processor
20 * Datasheet, Volume 2:
21 * http://download.intel.com/design/processor/datashts/320835.pdf
22 * Intel Xeon Processor 5500 Series Datasheet Volume 2
23 * http://www.intel.com/Assets/PDF/datasheet/321322.pdf
24 * also available at:
25 * http://www.arrownac.com/manufacturers/intel/s/nehalem/5500-datasheet-v2.pdf
26 */
27
28 #include <linux/module.h>
29 #include <linux/init.h>
30 #include <linux/pci.h>
31 #include <linux/pci_ids.h>
32 #include <linux/slab.h>
33 #include <linux/delay.h>
34 #include <linux/dmi.h>
35 #include <linux/edac.h>
36 #include <linux/mmzone.h>
37 #include <linux/smp.h>
38 #include <asm/mce.h>
39 #include <asm/processor.h>
40 #include <asm/div64.h>
41
42 #include "edac_core.h"
43
44 /* Static vars */
45 static LIST_HEAD(i7core_edac_list);
46 static DEFINE_MUTEX(i7core_edac_lock);
47 static int probed;
48
49 static int use_pci_fixup;
50 module_param(use_pci_fixup, int, 0444);
51 MODULE_PARM_DESC(use_pci_fixup, "Enable PCI fixup to seek for hidden devices");
52 /*
53 * This is used for Nehalem-EP and Nehalem-EX devices, where the non-core
54 * registers start at bus 255, and are not reported by BIOS.
55 * We currently find devices with only 2 sockets. In order to support more QPI
56 * Quick Path Interconnect, just increment this number.
57 */
58 #define MAX_SOCKET_BUSES 2
59
60
61 /*
62 * Alter this version for the module when modifications are made
63 */
64 #define I7CORE_REVISION " Ver: 1.0.0"
65 #define EDAC_MOD_STR "i7core_edac"
66
67 /*
68 * Debug macros
69 */
70 #define i7core_printk(level, fmt, arg...) \
71 edac_printk(level, "i7core", fmt, ##arg)
72
73 #define i7core_mc_printk(mci, level, fmt, arg...) \
74 edac_mc_chipset_printk(mci, level, "i7core", fmt, ##arg)
75
76 /*
77 * i7core Memory Controller Registers
78 */
79
80 /* OFFSETS for Device 0 Function 0 */
81
82 #define MC_CFG_CONTROL 0x90
83 #define MC_CFG_UNLOCK 0x02
84 #define MC_CFG_LOCK 0x00
85
86 /* OFFSETS for Device 3 Function 0 */
87
88 #define MC_CONTROL 0x48
89 #define MC_STATUS 0x4c
90 #define MC_MAX_DOD 0x64
91
92 /*
93 * OFFSETS for Device 3 Function 4, as indicated on Xeon 5500 datasheet:
94 * http://www.arrownac.com/manufacturers/intel/s/nehalem/5500-datasheet-v2.pdf
95 */
96
97 #define MC_TEST_ERR_RCV1 0x60
98 #define DIMM2_COR_ERR(r) ((r) & 0x7fff)
99
100 #define MC_TEST_ERR_RCV0 0x64
101 #define DIMM1_COR_ERR(r) (((r) >> 16) & 0x7fff)
102 #define DIMM0_COR_ERR(r) ((r) & 0x7fff)
103
104 /* OFFSETS for Device 3 Function 2, as indicated on Xeon 5500 datasheet */
105 #define MC_SSRCONTROL 0x48
106 #define SSR_MODE_DISABLE 0x00
107 #define SSR_MODE_ENABLE 0x01
108 #define SSR_MODE_MASK 0x03
109
110 #define MC_SCRUB_CONTROL 0x4c
111 #define STARTSCRUB (1 << 24)
112 #define SCRUBINTERVAL_MASK 0xffffff
113
114 #define MC_COR_ECC_CNT_0 0x80
115 #define MC_COR_ECC_CNT_1 0x84
116 #define MC_COR_ECC_CNT_2 0x88
117 #define MC_COR_ECC_CNT_3 0x8c
118 #define MC_COR_ECC_CNT_4 0x90
119 #define MC_COR_ECC_CNT_5 0x94
120
121 #define DIMM_TOP_COR_ERR(r) (((r) >> 16) & 0x7fff)
122 #define DIMM_BOT_COR_ERR(r) ((r) & 0x7fff)
123
124
125 /* OFFSETS for Devices 4,5 and 6 Function 0 */
126
127 #define MC_CHANNEL_DIMM_INIT_PARAMS 0x58
128 #define THREE_DIMMS_PRESENT (1 << 24)
129 #define SINGLE_QUAD_RANK_PRESENT (1 << 23)
130 #define QUAD_RANK_PRESENT (1 << 22)
131 #define REGISTERED_DIMM (1 << 15)
132
133 #define MC_CHANNEL_MAPPER 0x60
134 #define RDLCH(r, ch) ((((r) >> (3 + (ch * 6))) & 0x07) - 1)
135 #define WRLCH(r, ch) ((((r) >> (ch * 6)) & 0x07) - 1)
136
137 #define MC_CHANNEL_RANK_PRESENT 0x7c
138 #define RANK_PRESENT_MASK 0xffff
139
140 #define MC_CHANNEL_ADDR_MATCH 0xf0
141 #define MC_CHANNEL_ERROR_MASK 0xf8
142 #define MC_CHANNEL_ERROR_INJECT 0xfc
143 #define INJECT_ADDR_PARITY 0x10
144 #define INJECT_ECC 0x08
145 #define MASK_CACHELINE 0x06
146 #define MASK_FULL_CACHELINE 0x06
147 #define MASK_MSB32_CACHELINE 0x04
148 #define MASK_LSB32_CACHELINE 0x02
149 #define NO_MASK_CACHELINE 0x00
150 #define REPEAT_EN 0x01
151
152 /* OFFSETS for Devices 4,5 and 6 Function 1 */
153
154 #define MC_DOD_CH_DIMM0 0x48
155 #define MC_DOD_CH_DIMM1 0x4c
156 #define MC_DOD_CH_DIMM2 0x50
157 #define RANKOFFSET_MASK ((1 << 12) | (1 << 11) | (1 << 10))
158 #define RANKOFFSET(x) ((x & RANKOFFSET_MASK) >> 10)
159 #define DIMM_PRESENT_MASK (1 << 9)
160 #define DIMM_PRESENT(x) (((x) & DIMM_PRESENT_MASK) >> 9)
161 #define MC_DOD_NUMBANK_MASK ((1 << 8) | (1 << 7))
162 #define MC_DOD_NUMBANK(x) (((x) & MC_DOD_NUMBANK_MASK) >> 7)
163 #define MC_DOD_NUMRANK_MASK ((1 << 6) | (1 << 5))
164 #define MC_DOD_NUMRANK(x) (((x) & MC_DOD_NUMRANK_MASK) >> 5)
165 #define MC_DOD_NUMROW_MASK ((1 << 4) | (1 << 3) | (1 << 2))
166 #define MC_DOD_NUMROW(x) (((x) & MC_DOD_NUMROW_MASK) >> 2)
167 #define MC_DOD_NUMCOL_MASK 3
168 #define MC_DOD_NUMCOL(x) ((x) & MC_DOD_NUMCOL_MASK)
169
170 #define MC_RANK_PRESENT 0x7c
171
172 #define MC_SAG_CH_0 0x80
173 #define MC_SAG_CH_1 0x84
174 #define MC_SAG_CH_2 0x88
175 #define MC_SAG_CH_3 0x8c
176 #define MC_SAG_CH_4 0x90
177 #define MC_SAG_CH_5 0x94
178 #define MC_SAG_CH_6 0x98
179 #define MC_SAG_CH_7 0x9c
180
181 #define MC_RIR_LIMIT_CH_0 0x40
182 #define MC_RIR_LIMIT_CH_1 0x44
183 #define MC_RIR_LIMIT_CH_2 0x48
184 #define MC_RIR_LIMIT_CH_3 0x4C
185 #define MC_RIR_LIMIT_CH_4 0x50
186 #define MC_RIR_LIMIT_CH_5 0x54
187 #define MC_RIR_LIMIT_CH_6 0x58
188 #define MC_RIR_LIMIT_CH_7 0x5C
189 #define MC_RIR_LIMIT_MASK ((1 << 10) - 1)
190
191 #define MC_RIR_WAY_CH 0x80
192 #define MC_RIR_WAY_OFFSET_MASK (((1 << 14) - 1) & ~0x7)
193 #define MC_RIR_WAY_RANK_MASK 0x7
194
195 /*
196 * i7core structs
197 */
198
199 #define NUM_CHANS 3
200 #define MAX_DIMMS 3 /* Max DIMMS per channel */
201 #define MAX_MCR_FUNC 4
202 #define MAX_CHAN_FUNC 3
203
204 struct i7core_info {
205 u32 mc_control;
206 u32 mc_status;
207 u32 max_dod;
208 u32 ch_map;
209 };
210
211
212 struct i7core_inject {
213 int enable;
214
215 u32 section;
216 u32 type;
217 u32 eccmask;
218
219 /* Error address mask */
220 int channel, dimm, rank, bank, page, col;
221 };
222
223 struct i7core_channel {
224 bool is_3dimms_present;
225 bool is_single_4rank;
226 bool has_4rank;
227 u32 dimms;
228 };
229
230 struct pci_id_descr {
231 int dev;
232 int func;
233 int dev_id;
234 int optional;
235 };
236
237 struct pci_id_table {
238 const struct pci_id_descr *descr;
239 int n_devs;
240 };
241
242 struct i7core_dev {
243 struct list_head list;
244 u8 socket;
245 struct pci_dev **pdev;
246 int n_devs;
247 struct mem_ctl_info *mci;
248 };
249
250 struct i7core_pvt {
251 struct pci_dev *pci_noncore;
252 struct pci_dev *pci_mcr[MAX_MCR_FUNC + 1];
253 struct pci_dev *pci_ch[NUM_CHANS][MAX_CHAN_FUNC + 1];
254
255 struct i7core_dev *i7core_dev;
256
257 struct i7core_info info;
258 struct i7core_inject inject;
259 struct i7core_channel channel[NUM_CHANS];
260
261 int ce_count_available;
262
263 /* ECC corrected errors counts per udimm */
264 unsigned long udimm_ce_count[MAX_DIMMS];
265 int udimm_last_ce_count[MAX_DIMMS];
266 /* ECC corrected errors counts per rdimm */
267 unsigned long rdimm_ce_count[NUM_CHANS][MAX_DIMMS];
268 int rdimm_last_ce_count[NUM_CHANS][MAX_DIMMS];
269
270 bool is_registered, enable_scrub;
271
272 /* Fifo double buffers */
273 struct mce mce_entry[MCE_LOG_LEN];
274 struct mce mce_outentry[MCE_LOG_LEN];
275
276 /* Fifo in/out counters */
277 unsigned mce_in, mce_out;
278
279 /* Count indicator to show errors not got */
280 unsigned mce_overrun;
281
282 /* DCLK Frequency used for computing scrub rate */
283 int dclk_freq;
284
285 /* Struct to control EDAC polling */
286 struct edac_pci_ctl_info *i7core_pci;
287 };
288
289 #define PCI_DESCR(device, function, device_id) \
290 .dev = (device), \
291 .func = (function), \
292 .dev_id = (device_id)
293
294 static const struct pci_id_descr pci_dev_descr_i7core_nehalem[] = {
295 /* Memory controller */
296 { PCI_DESCR(3, 0, PCI_DEVICE_ID_INTEL_I7_MCR) },
297 { PCI_DESCR(3, 1, PCI_DEVICE_ID_INTEL_I7_MC_TAD) },
298 /* Exists only for RDIMM */
299 { PCI_DESCR(3, 2, PCI_DEVICE_ID_INTEL_I7_MC_RAS), .optional = 1 },
300 { PCI_DESCR(3, 4, PCI_DEVICE_ID_INTEL_I7_MC_TEST) },
301
302 /* Channel 0 */
303 { PCI_DESCR(4, 0, PCI_DEVICE_ID_INTEL_I7_MC_CH0_CTRL) },
304 { PCI_DESCR(4, 1, PCI_DEVICE_ID_INTEL_I7_MC_CH0_ADDR) },
305 { PCI_DESCR(4, 2, PCI_DEVICE_ID_INTEL_I7_MC_CH0_RANK) },
306 { PCI_DESCR(4, 3, PCI_DEVICE_ID_INTEL_I7_MC_CH0_TC) },
307
308 /* Channel 1 */
309 { PCI_DESCR(5, 0, PCI_DEVICE_ID_INTEL_I7_MC_CH1_CTRL) },
310 { PCI_DESCR(5, 1, PCI_DEVICE_ID_INTEL_I7_MC_CH1_ADDR) },
311 { PCI_DESCR(5, 2, PCI_DEVICE_ID_INTEL_I7_MC_CH1_RANK) },
312 { PCI_DESCR(5, 3, PCI_DEVICE_ID_INTEL_I7_MC_CH1_TC) },
313
314 /* Channel 2 */
315 { PCI_DESCR(6, 0, PCI_DEVICE_ID_INTEL_I7_MC_CH2_CTRL) },
316 { PCI_DESCR(6, 1, PCI_DEVICE_ID_INTEL_I7_MC_CH2_ADDR) },
317 { PCI_DESCR(6, 2, PCI_DEVICE_ID_INTEL_I7_MC_CH2_RANK) },
318 { PCI_DESCR(6, 3, PCI_DEVICE_ID_INTEL_I7_MC_CH2_TC) },
319
320 /* Generic Non-core registers */
321 /*
322 * This is the PCI device on i7core and on Xeon 35xx (8086:2c41)
323 * On Xeon 55xx, however, it has a different id (8086:2c40). So,
324 * the probing code needs to test for the other address in case of
325 * failure of this one
326 */
327 { PCI_DESCR(0, 0, PCI_DEVICE_ID_INTEL_I7_NONCORE) },
328
329 };
330
331 static const struct pci_id_descr pci_dev_descr_lynnfield[] = {
332 { PCI_DESCR( 3, 0, PCI_DEVICE_ID_INTEL_LYNNFIELD_MCR) },
333 { PCI_DESCR( 3, 1, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_TAD) },
334 { PCI_DESCR( 3, 4, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_TEST) },
335
336 { PCI_DESCR( 4, 0, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH0_CTRL) },
337 { PCI_DESCR( 4, 1, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH0_ADDR) },
338 { PCI_DESCR( 4, 2, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH0_RANK) },
339 { PCI_DESCR( 4, 3, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH0_TC) },
340
341 { PCI_DESCR( 5, 0, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH1_CTRL) },
342 { PCI_DESCR( 5, 1, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH1_ADDR) },
343 { PCI_DESCR( 5, 2, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH1_RANK) },
344 { PCI_DESCR( 5, 3, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH1_TC) },
345
346 /*
347 * This is the PCI device has an alternate address on some
348 * processors like Core i7 860
349 */
350 { PCI_DESCR( 0, 0, PCI_DEVICE_ID_INTEL_LYNNFIELD_NONCORE) },
351 };
352
353 static const struct pci_id_descr pci_dev_descr_i7core_westmere[] = {
354 /* Memory controller */
355 { PCI_DESCR(3, 0, PCI_DEVICE_ID_INTEL_LYNNFIELD_MCR_REV2) },
356 { PCI_DESCR(3, 1, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_TAD_REV2) },
357 /* Exists only for RDIMM */
358 { PCI_DESCR(3, 2, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_RAS_REV2), .optional = 1 },
359 { PCI_DESCR(3, 4, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_TEST_REV2) },
360
361 /* Channel 0 */
362 { PCI_DESCR(4, 0, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH0_CTRL_REV2) },
363 { PCI_DESCR(4, 1, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH0_ADDR_REV2) },
364 { PCI_DESCR(4, 2, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH0_RANK_REV2) },
365 { PCI_DESCR(4, 3, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH0_TC_REV2) },
366
367 /* Channel 1 */
368 { PCI_DESCR(5, 0, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH1_CTRL_REV2) },
369 { PCI_DESCR(5, 1, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH1_ADDR_REV2) },
370 { PCI_DESCR(5, 2, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH1_RANK_REV2) },
371 { PCI_DESCR(5, 3, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH1_TC_REV2) },
372
373 /* Channel 2 */
374 { PCI_DESCR(6, 0, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH2_CTRL_REV2) },
375 { PCI_DESCR(6, 1, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH2_ADDR_REV2) },
376 { PCI_DESCR(6, 2, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH2_RANK_REV2) },
377 { PCI_DESCR(6, 3, PCI_DEVICE_ID_INTEL_LYNNFIELD_MC_CH2_TC_REV2) },
378
379 /* Generic Non-core registers */
380 { PCI_DESCR(0, 0, PCI_DEVICE_ID_INTEL_LYNNFIELD_NONCORE_REV2) },
381
382 };
383
384 #define PCI_ID_TABLE_ENTRY(A) { .descr=A, .n_devs = ARRAY_SIZE(A) }
385 static const struct pci_id_table pci_dev_table[] = {
386 PCI_ID_TABLE_ENTRY(pci_dev_descr_i7core_nehalem),
387 PCI_ID_TABLE_ENTRY(pci_dev_descr_lynnfield),
388 PCI_ID_TABLE_ENTRY(pci_dev_descr_i7core_westmere),
389 {0,} /* 0 terminated list. */
390 };
391
392 /*
393 * pci_device_id table for which devices we are looking for
394 */
395 static DEFINE_PCI_DEVICE_TABLE(i7core_pci_tbl) = {
396 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_X58_HUB_MGMT)},
397 {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_LYNNFIELD_QPI_LINK0)},
398 {0,} /* 0 terminated list. */
399 };
400
401 /****************************************************************************
402 Ancillary status routines
403 ****************************************************************************/
404
405 /* MC_CONTROL bits */
406 #define CH_ACTIVE(pvt, ch) ((pvt)->info.mc_control & (1 << (8 + ch)))
407 #define ECCx8(pvt) ((pvt)->info.mc_control & (1 << 1))
408
409 /* MC_STATUS bits */
410 #define ECC_ENABLED(pvt) ((pvt)->info.mc_status & (1 << 4))
411 #define CH_DISABLED(pvt, ch) ((pvt)->info.mc_status & (1 << ch))
412
413 /* MC_MAX_DOD read functions */
414 static inline int numdimms(u32 dimms)
415 {
416 return (dimms & 0x3) + 1;
417 }
418
419 static inline int numrank(u32 rank)
420 {
421 static int ranks[4] = { 1, 2, 4, -EINVAL };
422
423 return ranks[rank & 0x3];
424 }
425
426 static inline int numbank(u32 bank)
427 {
428 static int banks[4] = { 4, 8, 16, -EINVAL };
429
430 return banks[bank & 0x3];
431 }
432
433 static inline int numrow(u32 row)
434 {
435 static int rows[8] = {
436 1 << 12, 1 << 13, 1 << 14, 1 << 15,
437 1 << 16, -EINVAL, -EINVAL, -EINVAL,
438 };
439
440 return rows[row & 0x7];
441 }
442
443 static inline int numcol(u32 col)
444 {
445 static int cols[8] = {
446 1 << 10, 1 << 11, 1 << 12, -EINVAL,
447 };
448 return cols[col & 0x3];
449 }
450
451 static struct i7core_dev *get_i7core_dev(u8 socket)
452 {
453 struct i7core_dev *i7core_dev;
454
455 list_for_each_entry(i7core_dev, &i7core_edac_list, list) {
456 if (i7core_dev->socket == socket)
457 return i7core_dev;
458 }
459
460 return NULL;
461 }
462
463 static struct i7core_dev *alloc_i7core_dev(u8 socket,
464 const struct pci_id_table *table)
465 {
466 struct i7core_dev *i7core_dev;
467
468 i7core_dev = kzalloc(sizeof(*i7core_dev), GFP_KERNEL);
469 if (!i7core_dev)
470 return NULL;
471
472 i7core_dev->pdev = kzalloc(sizeof(*i7core_dev->pdev) * table->n_devs,
473 GFP_KERNEL);
474 if (!i7core_dev->pdev) {
475 kfree(i7core_dev);
476 return NULL;
477 }
478
479 i7core_dev->socket = socket;
480 i7core_dev->n_devs = table->n_devs;
481 list_add_tail(&i7core_dev->list, &i7core_edac_list);
482
483 return i7core_dev;
484 }
485
486 static void free_i7core_dev(struct i7core_dev *i7core_dev)
487 {
488 list_del(&i7core_dev->list);
489 kfree(i7core_dev->pdev);
490 kfree(i7core_dev);
491 }
492
493 /****************************************************************************
494 Memory check routines
495 ****************************************************************************/
496
497 static int get_dimm_config(struct mem_ctl_info *mci)
498 {
499 struct i7core_pvt *pvt = mci->pvt_info;
500 struct pci_dev *pdev;
501 int i, j;
502 enum edac_type mode;
503 enum mem_type mtype;
504 struct dimm_info *dimm;
505
506 /* Get data from the MC register, function 0 */
507 pdev = pvt->pci_mcr[0];
508 if (!pdev)
509 return -ENODEV;
510
511 /* Device 3 function 0 reads */
512 pci_read_config_dword(pdev, MC_CONTROL, &pvt->info.mc_control);
513 pci_read_config_dword(pdev, MC_STATUS, &pvt->info.mc_status);
514 pci_read_config_dword(pdev, MC_MAX_DOD, &pvt->info.max_dod);
515 pci_read_config_dword(pdev, MC_CHANNEL_MAPPER, &pvt->info.ch_map);
516
517 debugf0("QPI %d control=0x%08x status=0x%08x dod=0x%08x map=0x%08x\n",
518 pvt->i7core_dev->socket, pvt->info.mc_control, pvt->info.mc_status,
519 pvt->info.max_dod, pvt->info.ch_map);
520
521 if (ECC_ENABLED(pvt)) {
522 debugf0("ECC enabled with x%d SDCC\n", ECCx8(pvt) ? 8 : 4);
523 if (ECCx8(pvt))
524 mode = EDAC_S8ECD8ED;
525 else
526 mode = EDAC_S4ECD4ED;
527 } else {
528 debugf0("ECC disabled\n");
529 mode = EDAC_NONE;
530 }
531
532 /* FIXME: need to handle the error codes */
533 debugf0("DOD Max limits: DIMMS: %d, %d-ranked, %d-banked "
534 "x%x x 0x%x\n",
535 numdimms(pvt->info.max_dod),
536 numrank(pvt->info.max_dod >> 2),
537 numbank(pvt->info.max_dod >> 4),
538 numrow(pvt->info.max_dod >> 6),
539 numcol(pvt->info.max_dod >> 9));
540
541 for (i = 0; i < NUM_CHANS; i++) {
542 u32 data, dimm_dod[3], value[8];
543
544 if (!pvt->pci_ch[i][0])
545 continue;
546
547 if (!CH_ACTIVE(pvt, i)) {
548 debugf0("Channel %i is not active\n", i);
549 continue;
550 }
551 if (CH_DISABLED(pvt, i)) {
552 debugf0("Channel %i is disabled\n", i);
553 continue;
554 }
555
556 /* Devices 4-6 function 0 */
557 pci_read_config_dword(pvt->pci_ch[i][0],
558 MC_CHANNEL_DIMM_INIT_PARAMS, &data);
559
560
561 if (data & THREE_DIMMS_PRESENT)
562 pvt->channel[i].is_3dimms_present = true;
563
564 if (data & SINGLE_QUAD_RANK_PRESENT)
565 pvt->channel[i].is_single_4rank = true;
566
567 if (data & QUAD_RANK_PRESENT)
568 pvt->channel[i].has_4rank = true;
569
570 if (data & REGISTERED_DIMM)
571 mtype = MEM_RDDR3;
572 else
573 mtype = MEM_DDR3;
574
575 /* Devices 4-6 function 1 */
576 pci_read_config_dword(pvt->pci_ch[i][1],
577 MC_DOD_CH_DIMM0, &dimm_dod[0]);
578 pci_read_config_dword(pvt->pci_ch[i][1],
579 MC_DOD_CH_DIMM1, &dimm_dod[1]);
580 pci_read_config_dword(pvt->pci_ch[i][1],
581 MC_DOD_CH_DIMM2, &dimm_dod[2]);
582
583 debugf0("Ch%d phy rd%d, wr%d (0x%08x): "
584 "%s%s%s%cDIMMs\n",
585 i,
586 RDLCH(pvt->info.ch_map, i), WRLCH(pvt->info.ch_map, i),
587 data,
588 pvt->channel[i].is_3dimms_present ? "3DIMMS " : "",
589 pvt->channel[i].is_3dimms_present ? "SINGLE_4R " : "",
590 pvt->channel[i].has_4rank ? "HAS_4R " : "",
591 (data & REGISTERED_DIMM) ? 'R' : 'U');
592
593 for (j = 0; j < 3; j++) {
594 u32 banks, ranks, rows, cols;
595 u32 size, npages;
596
597 if (!DIMM_PRESENT(dimm_dod[j]))
598 continue;
599
600 dimm = EDAC_DIMM_PTR(mci->layers, mci->dimms, mci->n_layers,
601 i, j, 0);
602 banks = numbank(MC_DOD_NUMBANK(dimm_dod[j]));
603 ranks = numrank(MC_DOD_NUMRANK(dimm_dod[j]));
604 rows = numrow(MC_DOD_NUMROW(dimm_dod[j]));
605 cols = numcol(MC_DOD_NUMCOL(dimm_dod[j]));
606
607 /* DDR3 has 8 I/O banks */
608 size = (rows * cols * banks * ranks) >> (20 - 3);
609
610 debugf0("\tdimm %d %d Mb offset: %x, "
611 "bank: %d, rank: %d, row: %#x, col: %#x\n",
612 j, size,
613 RANKOFFSET(dimm_dod[j]),
614 banks, ranks, rows, cols);
615
616 npages = MiB_TO_PAGES(size);
617
618 dimm->nr_pages = npages;
619
620 switch (banks) {
621 case 4:
622 dimm->dtype = DEV_X4;
623 break;
624 case 8:
625 dimm->dtype = DEV_X8;
626 break;
627 case 16:
628 dimm->dtype = DEV_X16;
629 break;
630 default:
631 dimm->dtype = DEV_UNKNOWN;
632 }
633
634 snprintf(dimm->label, sizeof(dimm->label),
635 "CPU#%uChannel#%u_DIMM#%u",
636 pvt->i7core_dev->socket, i, j);
637 dimm->grain = 8;
638 dimm->edac_mode = mode;
639 dimm->mtype = mtype;
640 }
641
642 pci_read_config_dword(pdev, MC_SAG_CH_0, &value[0]);
643 pci_read_config_dword(pdev, MC_SAG_CH_1, &value[1]);
644 pci_read_config_dword(pdev, MC_SAG_CH_2, &value[2]);
645 pci_read_config_dword(pdev, MC_SAG_CH_3, &value[3]);
646 pci_read_config_dword(pdev, MC_SAG_CH_4, &value[4]);
647 pci_read_config_dword(pdev, MC_SAG_CH_5, &value[5]);
648 pci_read_config_dword(pdev, MC_SAG_CH_6, &value[6]);
649 pci_read_config_dword(pdev, MC_SAG_CH_7, &value[7]);
650 debugf1("\t[%i] DIVBY3\tREMOVED\tOFFSET\n", i);
651 for (j = 0; j < 8; j++)
652 debugf1("\t\t%#x\t%#x\t%#x\n",
653 (value[j] >> 27) & 0x1,
654 (value[j] >> 24) & 0x7,
655 (value[j] & ((1 << 24) - 1)));
656 }
657
658 return 0;
659 }
660
661 /****************************************************************************
662 Error insertion routines
663 ****************************************************************************/
664
665 /* The i7core has independent error injection features per channel.
666 However, to have a simpler code, we don't allow enabling error injection
667 on more than one channel.
668 Also, since a change at an inject parameter will be applied only at enable,
669 we're disabling error injection on all write calls to the sysfs nodes that
670 controls the error code injection.
671 */
672 static int disable_inject(const struct mem_ctl_info *mci)
673 {
674 struct i7core_pvt *pvt = mci->pvt_info;
675
676 pvt->inject.enable = 0;
677
678 if (!pvt->pci_ch[pvt->inject.channel][0])
679 return -ENODEV;
680
681 pci_write_config_dword(pvt->pci_ch[pvt->inject.channel][0],
682 MC_CHANNEL_ERROR_INJECT, 0);
683
684 return 0;
685 }
686
687 /*
688 * i7core inject inject.section
689 *
690 * accept and store error injection inject.section value
691 * bit 0 - refers to the lower 32-byte half cacheline
692 * bit 1 - refers to the upper 32-byte half cacheline
693 */
694 static ssize_t i7core_inject_section_store(struct mem_ctl_info *mci,
695 const char *data, size_t count)
696 {
697 struct i7core_pvt *pvt = mci->pvt_info;
698 unsigned long value;
699 int rc;
700
701 if (pvt->inject.enable)
702 disable_inject(mci);
703
704 rc = strict_strtoul(data, 10, &value);
705 if ((rc < 0) || (value > 3))
706 return -EIO;
707
708 pvt->inject.section = (u32) value;
709 return count;
710 }
711
712 static ssize_t i7core_inject_section_show(struct mem_ctl_info *mci,
713 char *data)
714 {
715 struct i7core_pvt *pvt = mci->pvt_info;
716 return sprintf(data, "0x%08x\n", pvt->inject.section);
717 }
718
719 /*
720 * i7core inject.type
721 *
722 * accept and store error injection inject.section value
723 * bit 0 - repeat enable - Enable error repetition
724 * bit 1 - inject ECC error
725 * bit 2 - inject parity error
726 */
727 static ssize_t i7core_inject_type_store(struct mem_ctl_info *mci,
728 const char *data, size_t count)
729 {
730 struct i7core_pvt *pvt = mci->pvt_info;
731 unsigned long value;
732 int rc;
733
734 if (pvt->inject.enable)
735 disable_inject(mci);
736
737 rc = strict_strtoul(data, 10, &value);
738 if ((rc < 0) || (value > 7))
739 return -EIO;
740
741 pvt->inject.type = (u32) value;
742 return count;
743 }
744
745 static ssize_t i7core_inject_type_show(struct mem_ctl_info *mci,
746 char *data)
747 {
748 struct i7core_pvt *pvt = mci->pvt_info;
749 return sprintf(data, "0x%08x\n", pvt->inject.type);
750 }
751
752 /*
753 * i7core_inject_inject.eccmask_store
754 *
755 * The type of error (UE/CE) will depend on the inject.eccmask value:
756 * Any bits set to a 1 will flip the corresponding ECC bit
757 * Correctable errors can be injected by flipping 1 bit or the bits within
758 * a symbol pair (2 consecutive aligned 8-bit pairs - i.e. 7:0 and 15:8 or
759 * 23:16 and 31:24). Flipping bits in two symbol pairs will cause an
760 * uncorrectable error to be injected.
761 */
762 static ssize_t i7core_inject_eccmask_store(struct mem_ctl_info *mci,
763 const char *data, size_t count)
764 {
765 struct i7core_pvt *pvt = mci->pvt_info;
766 unsigned long value;
767 int rc;
768
769 if (pvt->inject.enable)
770 disable_inject(mci);
771
772 rc = strict_strtoul(data, 10, &value);
773 if (rc < 0)
774 return -EIO;
775
776 pvt->inject.eccmask = (u32) value;
777 return count;
778 }
779
780 static ssize_t i7core_inject_eccmask_show(struct mem_ctl_info *mci,
781 char *data)
782 {
783 struct i7core_pvt *pvt = mci->pvt_info;
784 return sprintf(data, "0x%08x\n", pvt->inject.eccmask);
785 }
786
787 /*
788 * i7core_addrmatch
789 *
790 * The type of error (UE/CE) will depend on the inject.eccmask value:
791 * Any bits set to a 1 will flip the corresponding ECC bit
792 * Correctable errors can be injected by flipping 1 bit or the bits within
793 * a symbol pair (2 consecutive aligned 8-bit pairs - i.e. 7:0 and 15:8 or
794 * 23:16 and 31:24). Flipping bits in two symbol pairs will cause an
795 * uncorrectable error to be injected.
796 */
797
798 #define DECLARE_ADDR_MATCH(param, limit) \
799 static ssize_t i7core_inject_store_##param( \
800 struct mem_ctl_info *mci, \
801 const char *data, size_t count) \
802 { \
803 struct i7core_pvt *pvt; \
804 long value; \
805 int rc; \
806 \
807 debugf1("%s()\n", __func__); \
808 pvt = mci->pvt_info; \
809 \
810 if (pvt->inject.enable) \
811 disable_inject(mci); \
812 \
813 if (!strcasecmp(data, "any") || !strcasecmp(data, "any\n"))\
814 value = -1; \
815 else { \
816 rc = strict_strtoul(data, 10, &value); \
817 if ((rc < 0) || (value >= limit)) \
818 return -EIO; \
819 } \
820 \
821 pvt->inject.param = value; \
822 \
823 return count; \
824 } \
825 \
826 static ssize_t i7core_inject_show_##param( \
827 struct mem_ctl_info *mci, \
828 char *data) \
829 { \
830 struct i7core_pvt *pvt; \
831 \
832 pvt = mci->pvt_info; \
833 debugf1("%s() pvt=%p\n", __func__, pvt); \
834 if (pvt->inject.param < 0) \
835 return sprintf(data, "any\n"); \
836 else \
837 return sprintf(data, "%d\n", pvt->inject.param);\
838 }
839
840 #define ATTR_ADDR_MATCH(param) \
841 { \
842 .attr = { \
843 .name = #param, \
844 .mode = (S_IRUGO | S_IWUSR) \
845 }, \
846 .show = i7core_inject_show_##param, \
847 .store = i7core_inject_store_##param, \
848 }
849
850 DECLARE_ADDR_MATCH(channel, 3);
851 DECLARE_ADDR_MATCH(dimm, 3);
852 DECLARE_ADDR_MATCH(rank, 4);
853 DECLARE_ADDR_MATCH(bank, 32);
854 DECLARE_ADDR_MATCH(page, 0x10000);
855 DECLARE_ADDR_MATCH(col, 0x4000);
856
857 static int write_and_test(struct pci_dev *dev, const int where, const u32 val)
858 {
859 u32 read;
860 int count;
861
862 debugf0("setting pci %02x:%02x.%x reg=%02x value=%08x\n",
863 dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
864 where, val);
865
866 for (count = 0; count < 10; count++) {
867 if (count)
868 msleep(100);
869 pci_write_config_dword(dev, where, val);
870 pci_read_config_dword(dev, where, &read);
871
872 if (read == val)
873 return 0;
874 }
875
876 i7core_printk(KERN_ERR, "Error during set pci %02x:%02x.%x reg=%02x "
877 "write=%08x. Read=%08x\n",
878 dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
879 where, val, read);
880
881 return -EINVAL;
882 }
883
884 /*
885 * This routine prepares the Memory Controller for error injection.
886 * The error will be injected when some process tries to write to the
887 * memory that matches the given criteria.
888 * The criteria can be set in terms of a mask where dimm, rank, bank, page
889 * and col can be specified.
890 * A -1 value for any of the mask items will make the MCU to ignore
891 * that matching criteria for error injection.
892 *
893 * It should be noticed that the error will only happen after a write operation
894 * on a memory that matches the condition. if REPEAT_EN is not enabled at
895 * inject mask, then it will produce just one error. Otherwise, it will repeat
896 * until the injectmask would be cleaned.
897 *
898 * FIXME: This routine assumes that MAXNUMDIMMS value of MC_MAX_DOD
899 * is reliable enough to check if the MC is using the
900 * three channels. However, this is not clear at the datasheet.
901 */
902 static ssize_t i7core_inject_enable_store(struct mem_ctl_info *mci,
903 const char *data, size_t count)
904 {
905 struct i7core_pvt *pvt = mci->pvt_info;
906 u32 injectmask;
907 u64 mask = 0;
908 int rc;
909 long enable;
910
911 if (!pvt->pci_ch[pvt->inject.channel][0])
912 return 0;
913
914 rc = strict_strtoul(data, 10, &enable);
915 if ((rc < 0))
916 return 0;
917
918 if (enable) {
919 pvt->inject.enable = 1;
920 } else {
921 disable_inject(mci);
922 return count;
923 }
924
925 /* Sets pvt->inject.dimm mask */
926 if (pvt->inject.dimm < 0)
927 mask |= 1LL << 41;
928 else {
929 if (pvt->channel[pvt->inject.channel].dimms > 2)
930 mask |= (pvt->inject.dimm & 0x3LL) << 35;
931 else
932 mask |= (pvt->inject.dimm & 0x1LL) << 36;
933 }
934
935 /* Sets pvt->inject.rank mask */
936 if (pvt->inject.rank < 0)
937 mask |= 1LL << 40;
938 else {
939 if (pvt->channel[pvt->inject.channel].dimms > 2)
940 mask |= (pvt->inject.rank & 0x1LL) << 34;
941 else
942 mask |= (pvt->inject.rank & 0x3LL) << 34;
943 }
944
945 /* Sets pvt->inject.bank mask */
946 if (pvt->inject.bank < 0)
947 mask |= 1LL << 39;
948 else
949 mask |= (pvt->inject.bank & 0x15LL) << 30;
950
951 /* Sets pvt->inject.page mask */
952 if (pvt->inject.page < 0)
953 mask |= 1LL << 38;
954 else
955 mask |= (pvt->inject.page & 0xffff) << 14;
956
957 /* Sets pvt->inject.column mask */
958 if (pvt->inject.col < 0)
959 mask |= 1LL << 37;
960 else
961 mask |= (pvt->inject.col & 0x3fff);
962
963 /*
964 * bit 0: REPEAT_EN
965 * bits 1-2: MASK_HALF_CACHELINE
966 * bit 3: INJECT_ECC
967 * bit 4: INJECT_ADDR_PARITY
968 */
969
970 injectmask = (pvt->inject.type & 1) |
971 (pvt->inject.section & 0x3) << 1 |
972 (pvt->inject.type & 0x6) << (3 - 1);
973
974 /* Unlock writes to registers - this register is write only */
975 pci_write_config_dword(pvt->pci_noncore,
976 MC_CFG_CONTROL, 0x2);
977
978 write_and_test(pvt->pci_ch[pvt->inject.channel][0],
979 MC_CHANNEL_ADDR_MATCH, mask);
980 write_and_test(pvt->pci_ch[pvt->inject.channel][0],
981 MC_CHANNEL_ADDR_MATCH + 4, mask >> 32L);
982
983 write_and_test(pvt->pci_ch[pvt->inject.channel][0],
984 MC_CHANNEL_ERROR_MASK, pvt->inject.eccmask);
985
986 write_and_test(pvt->pci_ch[pvt->inject.channel][0],
987 MC_CHANNEL_ERROR_INJECT, injectmask);
988
989 /*
990 * This is something undocumented, based on my tests
991 * Without writing 8 to this register, errors aren't injected. Not sure
992 * why.
993 */
994 pci_write_config_dword(pvt->pci_noncore,
995 MC_CFG_CONTROL, 8);
996
997 debugf0("Error inject addr match 0x%016llx, ecc 0x%08x,"
998 " inject 0x%08x\n",
999 mask, pvt->inject.eccmask, injectmask);
1000
1001
1002 return count;
1003 }
1004
1005 static ssize_t i7core_inject_enable_show(struct mem_ctl_info *mci,
1006 char *data)
1007 {
1008 struct i7core_pvt *pvt = mci->pvt_info;
1009 u32 injectmask;
1010
1011 if (!pvt->pci_ch[pvt->inject.channel][0])
1012 return 0;
1013
1014 pci_read_config_dword(pvt->pci_ch[pvt->inject.channel][0],
1015 MC_CHANNEL_ERROR_INJECT, &injectmask);
1016
1017 debugf0("Inject error read: 0x%018x\n", injectmask);
1018
1019 if (injectmask & 0x0c)
1020 pvt->inject.enable = 1;
1021
1022 return sprintf(data, "%d\n", pvt->inject.enable);
1023 }
1024
1025 #define DECLARE_COUNTER(param) \
1026 static ssize_t i7core_show_counter_##param( \
1027 struct mem_ctl_info *mci, \
1028 char *data) \
1029 { \
1030 struct i7core_pvt *pvt = mci->pvt_info; \
1031 \
1032 debugf1("%s() \n", __func__); \
1033 if (!pvt->ce_count_available || (pvt->is_registered)) \
1034 return sprintf(data, "data unavailable\n"); \
1035 return sprintf(data, "%lu\n", \
1036 pvt->udimm_ce_count[param]); \
1037 }
1038
1039 #define ATTR_COUNTER(param) \
1040 { \
1041 .attr = { \
1042 .name = __stringify(udimm##param), \
1043 .mode = (S_IRUGO | S_IWUSR) \
1044 }, \
1045 .show = i7core_show_counter_##param \
1046 }
1047
1048 DECLARE_COUNTER(0);
1049 DECLARE_COUNTER(1);
1050 DECLARE_COUNTER(2);
1051
1052 /*
1053 * Sysfs struct
1054 */
1055
1056 static const struct mcidev_sysfs_attribute i7core_addrmatch_attrs[] = {
1057 ATTR_ADDR_MATCH(channel),
1058 ATTR_ADDR_MATCH(dimm),
1059 ATTR_ADDR_MATCH(rank),
1060 ATTR_ADDR_MATCH(bank),
1061 ATTR_ADDR_MATCH(page),
1062 ATTR_ADDR_MATCH(col),
1063 { } /* End of list */
1064 };
1065
1066 static const struct mcidev_sysfs_group i7core_inject_addrmatch = {
1067 .name = "inject_addrmatch",
1068 .mcidev_attr = i7core_addrmatch_attrs,
1069 };
1070
1071 static const struct mcidev_sysfs_attribute i7core_udimm_counters_attrs[] = {
1072 ATTR_COUNTER(0),
1073 ATTR_COUNTER(1),
1074 ATTR_COUNTER(2),
1075 { .attr = { .name = NULL } }
1076 };
1077
1078 static const struct mcidev_sysfs_group i7core_udimm_counters = {
1079 .name = "all_channel_counts",
1080 .mcidev_attr = i7core_udimm_counters_attrs,
1081 };
1082
1083 static const struct mcidev_sysfs_attribute i7core_sysfs_rdimm_attrs[] = {
1084 {
1085 .attr = {
1086 .name = "inject_section",
1087 .mode = (S_IRUGO | S_IWUSR)
1088 },
1089 .show = i7core_inject_section_show,
1090 .store = i7core_inject_section_store,
1091 }, {
1092 .attr = {
1093 .name = "inject_type",
1094 .mode = (S_IRUGO | S_IWUSR)
1095 },
1096 .show = i7core_inject_type_show,
1097 .store = i7core_inject_type_store,
1098 }, {
1099 .attr = {
1100 .name = "inject_eccmask",
1101 .mode = (S_IRUGO | S_IWUSR)
1102 },
1103 .show = i7core_inject_eccmask_show,
1104 .store = i7core_inject_eccmask_store,
1105 }, {
1106 .grp = &i7core_inject_addrmatch,
1107 }, {
1108 .attr = {
1109 .name = "inject_enable",
1110 .mode = (S_IRUGO | S_IWUSR)
1111 },
1112 .show = i7core_inject_enable_show,
1113 .store = i7core_inject_enable_store,
1114 },
1115 { } /* End of list */
1116 };
1117
1118 static const struct mcidev_sysfs_attribute i7core_sysfs_udimm_attrs[] = {
1119 {
1120 .attr = {
1121 .name = "inject_section",
1122 .mode = (S_IRUGO | S_IWUSR)
1123 },
1124 .show = i7core_inject_section_show,
1125 .store = i7core_inject_section_store,
1126 }, {
1127 .attr = {
1128 .name = "inject_type",
1129 .mode = (S_IRUGO | S_IWUSR)
1130 },
1131 .show = i7core_inject_type_show,
1132 .store = i7core_inject_type_store,
1133 }, {
1134 .attr = {
1135 .name = "inject_eccmask",
1136 .mode = (S_IRUGO | S_IWUSR)
1137 },
1138 .show = i7core_inject_eccmask_show,
1139 .store = i7core_inject_eccmask_store,
1140 }, {
1141 .grp = &i7core_inject_addrmatch,
1142 }, {
1143 .attr = {
1144 .name = "inject_enable",
1145 .mode = (S_IRUGO | S_IWUSR)
1146 },
1147 .show = i7core_inject_enable_show,
1148 .store = i7core_inject_enable_store,
1149 }, {
1150 .grp = &i7core_udimm_counters,
1151 },
1152 { } /* End of list */
1153 };
1154
1155 /****************************************************************************
1156 Device initialization routines: put/get, init/exit
1157 ****************************************************************************/
1158
1159 /*
1160 * i7core_put_all_devices 'put' all the devices that we have
1161 * reserved via 'get'
1162 */
1163 static void i7core_put_devices(struct i7core_dev *i7core_dev)
1164 {
1165 int i;
1166
1167 debugf0(__FILE__ ": %s()\n", __func__);
1168 for (i = 0; i < i7core_dev->n_devs; i++) {
1169 struct pci_dev *pdev = i7core_dev->pdev[i];
1170 if (!pdev)
1171 continue;
1172 debugf0("Removing dev %02x:%02x.%d\n",
1173 pdev->bus->number,
1174 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
1175 pci_dev_put(pdev);
1176 }
1177 }
1178
1179 static void i7core_put_all_devices(void)
1180 {
1181 struct i7core_dev *i7core_dev, *tmp;
1182
1183 list_for_each_entry_safe(i7core_dev, tmp, &i7core_edac_list, list) {
1184 i7core_put_devices(i7core_dev);
1185 free_i7core_dev(i7core_dev);
1186 }
1187 }
1188
1189 static void __init i7core_xeon_pci_fixup(const struct pci_id_table *table)
1190 {
1191 struct pci_dev *pdev = NULL;
1192 int i;
1193
1194 /*
1195 * On Xeon 55xx, the Intel Quick Path Arch Generic Non-core pci buses
1196 * aren't announced by acpi. So, we need to use a legacy scan probing
1197 * to detect them
1198 */
1199 while (table && table->descr) {
1200 pdev = pci_get_device(PCI_VENDOR_ID_INTEL, table->descr[0].dev_id, NULL);
1201 if (unlikely(!pdev)) {
1202 for (i = 0; i < MAX_SOCKET_BUSES; i++)
1203 pcibios_scan_specific_bus(255-i);
1204 }
1205 pci_dev_put(pdev);
1206 table++;
1207 }
1208 }
1209
1210 static unsigned i7core_pci_lastbus(void)
1211 {
1212 int last_bus = 0, bus;
1213 struct pci_bus *b = NULL;
1214
1215 while ((b = pci_find_next_bus(b)) != NULL) {
1216 bus = b->number;
1217 debugf0("Found bus %d\n", bus);
1218 if (bus > last_bus)
1219 last_bus = bus;
1220 }
1221
1222 debugf0("Last bus %d\n", last_bus);
1223
1224 return last_bus;
1225 }
1226
1227 /*
1228 * i7core_get_all_devices Find and perform 'get' operation on the MCH's
1229 * device/functions we want to reference for this driver
1230 *
1231 * Need to 'get' device 16 func 1 and func 2
1232 */
1233 static int i7core_get_onedevice(struct pci_dev **prev,
1234 const struct pci_id_table *table,
1235 const unsigned devno,
1236 const unsigned last_bus)
1237 {
1238 struct i7core_dev *i7core_dev;
1239 const struct pci_id_descr *dev_descr = &table->descr[devno];
1240
1241 struct pci_dev *pdev = NULL;
1242 u8 bus = 0;
1243 u8 socket = 0;
1244
1245 pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
1246 dev_descr->dev_id, *prev);
1247
1248 /*
1249 * On Xeon 55xx, the Intel QuickPath Arch Generic Non-core regs
1250 * is at addr 8086:2c40, instead of 8086:2c41. So, we need
1251 * to probe for the alternate address in case of failure
1252 */
1253 if (dev_descr->dev_id == PCI_DEVICE_ID_INTEL_I7_NONCORE && !pdev)
1254 pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
1255 PCI_DEVICE_ID_INTEL_I7_NONCORE_ALT, *prev);
1256
1257 if (dev_descr->dev_id == PCI_DEVICE_ID_INTEL_LYNNFIELD_NONCORE && !pdev)
1258 pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
1259 PCI_DEVICE_ID_INTEL_LYNNFIELD_NONCORE_ALT,
1260 *prev);
1261
1262 if (!pdev) {
1263 if (*prev) {
1264 *prev = pdev;
1265 return 0;
1266 }
1267
1268 if (dev_descr->optional)
1269 return 0;
1270
1271 if (devno == 0)
1272 return -ENODEV;
1273
1274 i7core_printk(KERN_INFO,
1275 "Device not found: dev %02x.%d PCI ID %04x:%04x\n",
1276 dev_descr->dev, dev_descr->func,
1277 PCI_VENDOR_ID_INTEL, dev_descr->dev_id);
1278
1279 /* End of list, leave */
1280 return -ENODEV;
1281 }
1282 bus = pdev->bus->number;
1283
1284 socket = last_bus - bus;
1285
1286 i7core_dev = get_i7core_dev(socket);
1287 if (!i7core_dev) {
1288 i7core_dev = alloc_i7core_dev(socket, table);
1289 if (!i7core_dev) {
1290 pci_dev_put(pdev);
1291 return -ENOMEM;
1292 }
1293 }
1294
1295 if (i7core_dev->pdev[devno]) {
1296 i7core_printk(KERN_ERR,
1297 "Duplicated device for "
1298 "dev %02x:%02x.%d PCI ID %04x:%04x\n",
1299 bus, dev_descr->dev, dev_descr->func,
1300 PCI_VENDOR_ID_INTEL, dev_descr->dev_id);
1301 pci_dev_put(pdev);
1302 return -ENODEV;
1303 }
1304
1305 i7core_dev->pdev[devno] = pdev;
1306
1307 /* Sanity check */
1308 if (unlikely(PCI_SLOT(pdev->devfn) != dev_descr->dev ||
1309 PCI_FUNC(pdev->devfn) != dev_descr->func)) {
1310 i7core_printk(KERN_ERR,
1311 "Device PCI ID %04x:%04x "
1312 "has dev %02x:%02x.%d instead of dev %02x:%02x.%d\n",
1313 PCI_VENDOR_ID_INTEL, dev_descr->dev_id,
1314 bus, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
1315 bus, dev_descr->dev, dev_descr->func);
1316 return -ENODEV;
1317 }
1318
1319 /* Be sure that the device is enabled */
1320 if (unlikely(pci_enable_device(pdev) < 0)) {
1321 i7core_printk(KERN_ERR,
1322 "Couldn't enable "
1323 "dev %02x:%02x.%d PCI ID %04x:%04x\n",
1324 bus, dev_descr->dev, dev_descr->func,
1325 PCI_VENDOR_ID_INTEL, dev_descr->dev_id);
1326 return -ENODEV;
1327 }
1328
1329 debugf0("Detected socket %d dev %02x:%02x.%d PCI ID %04x:%04x\n",
1330 socket, bus, dev_descr->dev,
1331 dev_descr->func,
1332 PCI_VENDOR_ID_INTEL, dev_descr->dev_id);
1333
1334 /*
1335 * As stated on drivers/pci/search.c, the reference count for
1336 * @from is always decremented if it is not %NULL. So, as we need
1337 * to get all devices up to null, we need to do a get for the device
1338 */
1339 pci_dev_get(pdev);
1340
1341 *prev = pdev;
1342
1343 return 0;
1344 }
1345
1346 static int i7core_get_all_devices(void)
1347 {
1348 int i, rc, last_bus;
1349 struct pci_dev *pdev = NULL;
1350 const struct pci_id_table *table = pci_dev_table;
1351
1352 last_bus = i7core_pci_lastbus();
1353
1354 while (table && table->descr) {
1355 for (i = 0; i < table->n_devs; i++) {
1356 pdev = NULL;
1357 do {
1358 rc = i7core_get_onedevice(&pdev, table, i,
1359 last_bus);
1360 if (rc < 0) {
1361 if (i == 0) {
1362 i = table->n_devs;
1363 break;
1364 }
1365 i7core_put_all_devices();
1366 return -ENODEV;
1367 }
1368 } while (pdev);
1369 }
1370 table++;
1371 }
1372
1373 return 0;
1374 }
1375
1376 static int mci_bind_devs(struct mem_ctl_info *mci,
1377 struct i7core_dev *i7core_dev)
1378 {
1379 struct i7core_pvt *pvt = mci->pvt_info;
1380 struct pci_dev *pdev;
1381 int i, func, slot;
1382 char *family;
1383
1384 pvt->is_registered = false;
1385 pvt->enable_scrub = false;
1386 for (i = 0; i < i7core_dev->n_devs; i++) {
1387 pdev = i7core_dev->pdev[i];
1388 if (!pdev)
1389 continue;
1390
1391 func = PCI_FUNC(pdev->devfn);
1392 slot = PCI_SLOT(pdev->devfn);
1393 if (slot == 3) {
1394 if (unlikely(func > MAX_MCR_FUNC))
1395 goto error;
1396 pvt->pci_mcr[func] = pdev;
1397 } else if (likely(slot >= 4 && slot < 4 + NUM_CHANS)) {
1398 if (unlikely(func > MAX_CHAN_FUNC))
1399 goto error;
1400 pvt->pci_ch[slot - 4][func] = pdev;
1401 } else if (!slot && !func) {
1402 pvt->pci_noncore = pdev;
1403
1404 /* Detect the processor family */
1405 switch (pdev->device) {
1406 case PCI_DEVICE_ID_INTEL_I7_NONCORE:
1407 family = "Xeon 35xx/ i7core";
1408 pvt->enable_scrub = false;
1409 break;
1410 case PCI_DEVICE_ID_INTEL_LYNNFIELD_NONCORE_ALT:
1411 family = "i7-800/i5-700";
1412 pvt->enable_scrub = false;
1413 break;
1414 case PCI_DEVICE_ID_INTEL_LYNNFIELD_NONCORE:
1415 family = "Xeon 34xx";
1416 pvt->enable_scrub = false;
1417 break;
1418 case PCI_DEVICE_ID_INTEL_I7_NONCORE_ALT:
1419 family = "Xeon 55xx";
1420 pvt->enable_scrub = true;
1421 break;
1422 case PCI_DEVICE_ID_INTEL_LYNNFIELD_NONCORE_REV2:
1423 family = "Xeon 56xx / i7-900";
1424 pvt->enable_scrub = true;
1425 break;
1426 default:
1427 family = "unknown";
1428 pvt->enable_scrub = false;
1429 }
1430 debugf0("Detected a processor type %s\n", family);
1431 } else
1432 goto error;
1433
1434 debugf0("Associated fn %d.%d, dev = %p, socket %d\n",
1435 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
1436 pdev, i7core_dev->socket);
1437
1438 if (PCI_SLOT(pdev->devfn) == 3 &&
1439 PCI_FUNC(pdev->devfn) == 2)
1440 pvt->is_registered = true;
1441 }
1442
1443 return 0;
1444
1445 error:
1446 i7core_printk(KERN_ERR, "Device %d, function %d "
1447 "is out of the expected range\n",
1448 slot, func);
1449 return -EINVAL;
1450 }
1451
1452 /****************************************************************************
1453 Error check routines
1454 ****************************************************************************/
1455 static void i7core_rdimm_update_errcount(struct mem_ctl_info *mci,
1456 const int chan,
1457 const int dimm,
1458 const int add)
1459 {
1460 int i;
1461
1462 for (i = 0; i < add; i++) {
1463 edac_mc_handle_error(HW_EVENT_ERR_CORRECTED, mci, 0, 0, 0,
1464 chan, dimm, -1, "error", "", NULL);
1465 }
1466 }
1467
1468 static void i7core_rdimm_update_ce_count(struct mem_ctl_info *mci,
1469 const int chan,
1470 const int new0,
1471 const int new1,
1472 const int new2)
1473 {
1474 struct i7core_pvt *pvt = mci->pvt_info;
1475 int add0 = 0, add1 = 0, add2 = 0;
1476 /* Updates CE counters if it is not the first time here */
1477 if (pvt->ce_count_available) {
1478 /* Updates CE counters */
1479
1480 add2 = new2 - pvt->rdimm_last_ce_count[chan][2];
1481 add1 = new1 - pvt->rdimm_last_ce_count[chan][1];
1482 add0 = new0 - pvt->rdimm_last_ce_count[chan][0];
1483
1484 if (add2 < 0)
1485 add2 += 0x7fff;
1486 pvt->rdimm_ce_count[chan][2] += add2;
1487
1488 if (add1 < 0)
1489 add1 += 0x7fff;
1490 pvt->rdimm_ce_count[chan][1] += add1;
1491
1492 if (add0 < 0)
1493 add0 += 0x7fff;
1494 pvt->rdimm_ce_count[chan][0] += add0;
1495 } else
1496 pvt->ce_count_available = 1;
1497
1498 /* Store the new values */
1499 pvt->rdimm_last_ce_count[chan][2] = new2;
1500 pvt->rdimm_last_ce_count[chan][1] = new1;
1501 pvt->rdimm_last_ce_count[chan][0] = new0;
1502
1503 /*updated the edac core */
1504 if (add0 != 0)
1505 i7core_rdimm_update_errcount(mci, chan, 0, add0);
1506 if (add1 != 0)
1507 i7core_rdimm_update_errcount(mci, chan, 1, add1);
1508 if (add2 != 0)
1509 i7core_rdimm_update_errcount(mci, chan, 2, add2);
1510
1511 }
1512
1513 static void i7core_rdimm_check_mc_ecc_err(struct mem_ctl_info *mci)
1514 {
1515 struct i7core_pvt *pvt = mci->pvt_info;
1516 u32 rcv[3][2];
1517 int i, new0, new1, new2;
1518
1519 /*Read DEV 3: FUN 2: MC_COR_ECC_CNT regs directly*/
1520 pci_read_config_dword(pvt->pci_mcr[2], MC_COR_ECC_CNT_0,
1521 &rcv[0][0]);
1522 pci_read_config_dword(pvt->pci_mcr[2], MC_COR_ECC_CNT_1,
1523 &rcv[0][1]);
1524 pci_read_config_dword(pvt->pci_mcr[2], MC_COR_ECC_CNT_2,
1525 &rcv[1][0]);
1526 pci_read_config_dword(pvt->pci_mcr[2], MC_COR_ECC_CNT_3,
1527 &rcv[1][1]);
1528 pci_read_config_dword(pvt->pci_mcr[2], MC_COR_ECC_CNT_4,
1529 &rcv[2][0]);
1530 pci_read_config_dword(pvt->pci_mcr[2], MC_COR_ECC_CNT_5,
1531 &rcv[2][1]);
1532 for (i = 0 ; i < 3; i++) {
1533 debugf3("MC_COR_ECC_CNT%d = 0x%x; MC_COR_ECC_CNT%d = 0x%x\n",
1534 (i * 2), rcv[i][0], (i * 2) + 1, rcv[i][1]);
1535 /*if the channel has 3 dimms*/
1536 if (pvt->channel[i].dimms > 2) {
1537 new0 = DIMM_BOT_COR_ERR(rcv[i][0]);
1538 new1 = DIMM_TOP_COR_ERR(rcv[i][0]);
1539 new2 = DIMM_BOT_COR_ERR(rcv[i][1]);
1540 } else {
1541 new0 = DIMM_TOP_COR_ERR(rcv[i][0]) +
1542 DIMM_BOT_COR_ERR(rcv[i][0]);
1543 new1 = DIMM_TOP_COR_ERR(rcv[i][1]) +
1544 DIMM_BOT_COR_ERR(rcv[i][1]);
1545 new2 = 0;
1546 }
1547
1548 i7core_rdimm_update_ce_count(mci, i, new0, new1, new2);
1549 }
1550 }
1551
1552 /* This function is based on the device 3 function 4 registers as described on:
1553 * Intel Xeon Processor 5500 Series Datasheet Volume 2
1554 * http://www.intel.com/Assets/PDF/datasheet/321322.pdf
1555 * also available at:
1556 * http://www.arrownac.com/manufacturers/intel/s/nehalem/5500-datasheet-v2.pdf
1557 */
1558 static void i7core_udimm_check_mc_ecc_err(struct mem_ctl_info *mci)
1559 {
1560 struct i7core_pvt *pvt = mci->pvt_info;
1561 u32 rcv1, rcv0;
1562 int new0, new1, new2;
1563
1564 if (!pvt->pci_mcr[4]) {
1565 debugf0("%s MCR registers not found\n", __func__);
1566 return;
1567 }
1568
1569 /* Corrected test errors */
1570 pci_read_config_dword(pvt->pci_mcr[4], MC_TEST_ERR_RCV1, &rcv1);
1571 pci_read_config_dword(pvt->pci_mcr[4], MC_TEST_ERR_RCV0, &rcv0);
1572
1573 /* Store the new values */
1574 new2 = DIMM2_COR_ERR(rcv1);
1575 new1 = DIMM1_COR_ERR(rcv0);
1576 new0 = DIMM0_COR_ERR(rcv0);
1577
1578 /* Updates CE counters if it is not the first time here */
1579 if (pvt->ce_count_available) {
1580 /* Updates CE counters */
1581 int add0, add1, add2;
1582
1583 add2 = new2 - pvt->udimm_last_ce_count[2];
1584 add1 = new1 - pvt->udimm_last_ce_count[1];
1585 add0 = new0 - pvt->udimm_last_ce_count[0];
1586
1587 if (add2 < 0)
1588 add2 += 0x7fff;
1589 pvt->udimm_ce_count[2] += add2;
1590
1591 if (add1 < 0)
1592 add1 += 0x7fff;
1593 pvt->udimm_ce_count[1] += add1;
1594
1595 if (add0 < 0)
1596 add0 += 0x7fff;
1597 pvt->udimm_ce_count[0] += add0;
1598
1599 if (add0 | add1 | add2)
1600 i7core_printk(KERN_ERR, "New Corrected error(s): "
1601 "dimm0: +%d, dimm1: +%d, dimm2 +%d\n",
1602 add0, add1, add2);
1603 } else
1604 pvt->ce_count_available = 1;
1605
1606 /* Store the new values */
1607 pvt->udimm_last_ce_count[2] = new2;
1608 pvt->udimm_last_ce_count[1] = new1;
1609 pvt->udimm_last_ce_count[0] = new0;
1610 }
1611
1612 /*
1613 * According with tables E-11 and E-12 of chapter E.3.3 of Intel 64 and IA-32
1614 * Architectures Software Developer’s Manual Volume 3B.
1615 * Nehalem are defined as family 0x06, model 0x1a
1616 *
1617 * The MCA registers used here are the following ones:
1618 * struct mce field MCA Register
1619 * m->status MSR_IA32_MC8_STATUS
1620 * m->addr MSR_IA32_MC8_ADDR
1621 * m->misc MSR_IA32_MC8_MISC
1622 * In the case of Nehalem, the error information is masked at .status and .misc
1623 * fields
1624 */
1625 static void i7core_mce_output_error(struct mem_ctl_info *mci,
1626 const struct mce *m)
1627 {
1628 struct i7core_pvt *pvt = mci->pvt_info;
1629 char *type, *optype, *err, msg[80];
1630 enum hw_event_mc_err_type tp_event;
1631 unsigned long error = m->status & 0x1ff0000l;
1632 bool uncorrected_error = m->mcgstatus & 1ll << 61;
1633 bool ripv = m->mcgstatus & 1;
1634 u32 optypenum = (m->status >> 4) & 0x07;
1635 u32 core_err_cnt = (m->status >> 38) & 0x7fff;
1636 u32 dimm = (m->misc >> 16) & 0x3;
1637 u32 channel = (m->misc >> 18) & 0x3;
1638 u32 syndrome = m->misc >> 32;
1639 u32 errnum = find_first_bit(&error, 32);
1640
1641 if (uncorrected_error) {
1642 if (ripv) {
1643 type = "FATAL";
1644 tp_event = HW_EVENT_ERR_FATAL;
1645 } else {
1646 type = "NON_FATAL";
1647 tp_event = HW_EVENT_ERR_UNCORRECTED;
1648 }
1649 } else {
1650 type = "CORRECTED";
1651 tp_event = HW_EVENT_ERR_CORRECTED;
1652 }
1653
1654 switch (optypenum) {
1655 case 0:
1656 optype = "generic undef request";
1657 break;
1658 case 1:
1659 optype = "read error";
1660 break;
1661 case 2:
1662 optype = "write error";
1663 break;
1664 case 3:
1665 optype = "addr/cmd error";
1666 break;
1667 case 4:
1668 optype = "scrubbing error";
1669 break;
1670 default:
1671 optype = "reserved";
1672 break;
1673 }
1674
1675 switch (errnum) {
1676 case 16:
1677 err = "read ECC error";
1678 break;
1679 case 17:
1680 err = "RAS ECC error";
1681 break;
1682 case 18:
1683 err = "write parity error";
1684 break;
1685 case 19:
1686 err = "redundacy loss";
1687 break;
1688 case 20:
1689 err = "reserved";
1690 break;
1691 case 21:
1692 err = "memory range error";
1693 break;
1694 case 22:
1695 err = "RTID out of range";
1696 break;
1697 case 23:
1698 err = "address parity error";
1699 break;
1700 case 24:
1701 err = "byte enable parity error";
1702 break;
1703 default:
1704 err = "unknown";
1705 }
1706
1707 snprintf(msg, sizeof(msg), "count=%d %s", core_err_cnt, optype);
1708
1709 /*
1710 * Call the helper to output message
1711 * FIXME: what to do if core_err_cnt > 1? Currently, it generates
1712 * only one event
1713 */
1714 if (uncorrected_error || !pvt->is_registered)
1715 edac_mc_handle_error(tp_event, mci,
1716 m->addr >> PAGE_SHIFT,
1717 m->addr & ~PAGE_MASK,
1718 syndrome,
1719 channel, dimm, -1,
1720 err, msg, m);
1721 }
1722
1723 /*
1724 * i7core_check_error Retrieve and process errors reported by the
1725 * hardware. Called by the Core module.
1726 */
1727 static void i7core_check_error(struct mem_ctl_info *mci)
1728 {
1729 struct i7core_pvt *pvt = mci->pvt_info;
1730 int i;
1731 unsigned count = 0;
1732 struct mce *m;
1733
1734 /*
1735 * MCE first step: Copy all mce errors into a temporary buffer
1736 * We use a double buffering here, to reduce the risk of
1737 * losing an error.
1738 */
1739 smp_rmb();
1740 count = (pvt->mce_out + MCE_LOG_LEN - pvt->mce_in)
1741 % MCE_LOG_LEN;
1742 if (!count)
1743 goto check_ce_error;
1744
1745 m = pvt->mce_outentry;
1746 if (pvt->mce_in + count > MCE_LOG_LEN) {
1747 unsigned l = MCE_LOG_LEN - pvt->mce_in;
1748
1749 memcpy(m, &pvt->mce_entry[pvt->mce_in], sizeof(*m) * l);
1750 smp_wmb();
1751 pvt->mce_in = 0;
1752 count -= l;
1753 m += l;
1754 }
1755 memcpy(m, &pvt->mce_entry[pvt->mce_in], sizeof(*m) * count);
1756 smp_wmb();
1757 pvt->mce_in += count;
1758
1759 smp_rmb();
1760 if (pvt->mce_overrun) {
1761 i7core_printk(KERN_ERR, "Lost %d memory errors\n",
1762 pvt->mce_overrun);
1763 smp_wmb();
1764 pvt->mce_overrun = 0;
1765 }
1766
1767 /*
1768 * MCE second step: parse errors and display
1769 */
1770 for (i = 0; i < count; i++)
1771 i7core_mce_output_error(mci, &pvt->mce_outentry[i]);
1772
1773 /*
1774 * Now, let's increment CE error counts
1775 */
1776 check_ce_error:
1777 if (!pvt->is_registered)
1778 i7core_udimm_check_mc_ecc_err(mci);
1779 else
1780 i7core_rdimm_check_mc_ecc_err(mci);
1781 }
1782
1783 /*
1784 * i7core_mce_check_error Replicates mcelog routine to get errors
1785 * This routine simply queues mcelog errors, and
1786 * return. The error itself should be handled later
1787 * by i7core_check_error.
1788 * WARNING: As this routine should be called at NMI time, extra care should
1789 * be taken to avoid deadlocks, and to be as fast as possible.
1790 */
1791 static int i7core_mce_check_error(struct notifier_block *nb, unsigned long val,
1792 void *data)
1793 {
1794 struct mce *mce = (struct mce *)data;
1795 struct i7core_dev *i7_dev;
1796 struct mem_ctl_info *mci;
1797 struct i7core_pvt *pvt;
1798
1799 i7_dev = get_i7core_dev(mce->socketid);
1800 if (!i7_dev)
1801 return NOTIFY_BAD;
1802
1803 mci = i7_dev->mci;
1804 pvt = mci->pvt_info;
1805
1806 /*
1807 * Just let mcelog handle it if the error is
1808 * outside the memory controller
1809 */
1810 if (((mce->status & 0xffff) >> 7) != 1)
1811 return NOTIFY_DONE;
1812
1813 /* Bank 8 registers are the only ones that we know how to handle */
1814 if (mce->bank != 8)
1815 return NOTIFY_DONE;
1816
1817 smp_rmb();
1818 if ((pvt->mce_out + 1) % MCE_LOG_LEN == pvt->mce_in) {
1819 smp_wmb();
1820 pvt->mce_overrun++;
1821 return NOTIFY_DONE;
1822 }
1823
1824 /* Copy memory error at the ringbuffer */
1825 memcpy(&pvt->mce_entry[pvt->mce_out], mce, sizeof(*mce));
1826 smp_wmb();
1827 pvt->mce_out = (pvt->mce_out + 1) % MCE_LOG_LEN;
1828
1829 /* Handle fatal errors immediately */
1830 if (mce->mcgstatus & 1)
1831 i7core_check_error(mci);
1832
1833 /* Advise mcelog that the errors were handled */
1834 return NOTIFY_STOP;
1835 }
1836
1837 static struct notifier_block i7_mce_dec = {
1838 .notifier_call = i7core_mce_check_error,
1839 };
1840
1841 struct memdev_dmi_entry {
1842 u8 type;
1843 u8 length;
1844 u16 handle;
1845 u16 phys_mem_array_handle;
1846 u16 mem_err_info_handle;
1847 u16 total_width;
1848 u16 data_width;
1849 u16 size;
1850 u8 form;
1851 u8 device_set;
1852 u8 device_locator;
1853 u8 bank_locator;
1854 u8 memory_type;
1855 u16 type_detail;
1856 u16 speed;
1857 u8 manufacturer;
1858 u8 serial_number;
1859 u8 asset_tag;
1860 u8 part_number;
1861 u8 attributes;
1862 u32 extended_size;
1863 u16 conf_mem_clk_speed;
1864 } __attribute__((__packed__));
1865
1866
1867 /*
1868 * Decode the DRAM Clock Frequency, be paranoid, make sure that all
1869 * memory devices show the same speed, and if they don't then consider
1870 * all speeds to be invalid.
1871 */
1872 static void decode_dclk(const struct dmi_header *dh, void *_dclk_freq)
1873 {
1874 int *dclk_freq = _dclk_freq;
1875 u16 dmi_mem_clk_speed;
1876
1877 if (*dclk_freq == -1)
1878 return;
1879
1880 if (dh->type == DMI_ENTRY_MEM_DEVICE) {
1881 struct memdev_dmi_entry *memdev_dmi_entry =
1882 (struct memdev_dmi_entry *)dh;
1883 unsigned long conf_mem_clk_speed_offset =
1884 (unsigned long)&memdev_dmi_entry->conf_mem_clk_speed -
1885 (unsigned long)&memdev_dmi_entry->type;
1886 unsigned long speed_offset =
1887 (unsigned long)&memdev_dmi_entry->speed -
1888 (unsigned long)&memdev_dmi_entry->type;
1889
1890 /* Check that a DIMM is present */
1891 if (memdev_dmi_entry->size == 0)
1892 return;
1893
1894 /*
1895 * Pick the configured speed if it's available, otherwise
1896 * pick the DIMM speed, or we don't have a speed.
1897 */
1898 if (memdev_dmi_entry->length > conf_mem_clk_speed_offset) {
1899 dmi_mem_clk_speed =
1900 memdev_dmi_entry->conf_mem_clk_speed;
1901 } else if (memdev_dmi_entry->length > speed_offset) {
1902 dmi_mem_clk_speed = memdev_dmi_entry->speed;
1903 } else {
1904 *dclk_freq = -1;
1905 return;
1906 }
1907
1908 if (*dclk_freq == 0) {
1909 /* First pass, speed was 0 */
1910 if (dmi_mem_clk_speed > 0) {
1911 /* Set speed if a valid speed is read */
1912 *dclk_freq = dmi_mem_clk_speed;
1913 } else {
1914 /* Otherwise we don't have a valid speed */
1915 *dclk_freq = -1;
1916 }
1917 } else if (*dclk_freq > 0 &&
1918 *dclk_freq != dmi_mem_clk_speed) {
1919 /*
1920 * If we have a speed, check that all DIMMS are the same
1921 * speed, otherwise set the speed as invalid.
1922 */
1923 *dclk_freq = -1;
1924 }
1925 }
1926 }
1927
1928 /*
1929 * The default DCLK frequency is used as a fallback if we
1930 * fail to find anything reliable in the DMI. The value
1931 * is taken straight from the datasheet.
1932 */
1933 #define DEFAULT_DCLK_FREQ 800
1934
1935 static int get_dclk_freq(void)
1936 {
1937 int dclk_freq = 0;
1938
1939 dmi_walk(decode_dclk, (void *)&dclk_freq);
1940
1941 if (dclk_freq < 1)
1942 return DEFAULT_DCLK_FREQ;
1943
1944 return dclk_freq;
1945 }
1946
1947 /*
1948 * set_sdram_scrub_rate This routine sets byte/sec bandwidth scrub rate
1949 * to hardware according to SCRUBINTERVAL formula
1950 * found in datasheet.
1951 */
1952 static int set_sdram_scrub_rate(struct mem_ctl_info *mci, u32 new_bw)
1953 {
1954 struct i7core_pvt *pvt = mci->pvt_info;
1955 struct pci_dev *pdev;
1956 u32 dw_scrub;
1957 u32 dw_ssr;
1958
1959 /* Get data from the MC register, function 2 */
1960 pdev = pvt->pci_mcr[2];
1961 if (!pdev)
1962 return -ENODEV;
1963
1964 pci_read_config_dword(pdev, MC_SCRUB_CONTROL, &dw_scrub);
1965
1966 if (new_bw == 0) {
1967 /* Prepare to disable petrol scrub */
1968 dw_scrub &= ~STARTSCRUB;
1969 /* Stop the patrol scrub engine */
1970 write_and_test(pdev, MC_SCRUB_CONTROL,
1971 dw_scrub & ~SCRUBINTERVAL_MASK);
1972
1973 /* Get current status of scrub rate and set bit to disable */
1974 pci_read_config_dword(pdev, MC_SSRCONTROL, &dw_ssr);
1975 dw_ssr &= ~SSR_MODE_MASK;
1976 dw_ssr |= SSR_MODE_DISABLE;
1977 } else {
1978 const int cache_line_size = 64;
1979 const u32 freq_dclk_mhz = pvt->dclk_freq;
1980 unsigned long long scrub_interval;
1981 /*
1982 * Translate the desired scrub rate to a register value and
1983 * program the corresponding register value.
1984 */
1985 scrub_interval = (unsigned long long)freq_dclk_mhz *
1986 cache_line_size * 1000000;
1987 do_div(scrub_interval, new_bw);
1988
1989 if (!scrub_interval || scrub_interval > SCRUBINTERVAL_MASK)
1990 return -EINVAL;
1991
1992 dw_scrub = SCRUBINTERVAL_MASK & scrub_interval;
1993
1994 /* Start the patrol scrub engine */
1995 pci_write_config_dword(pdev, MC_SCRUB_CONTROL,
1996 STARTSCRUB | dw_scrub);
1997
1998 /* Get current status of scrub rate and set bit to enable */
1999 pci_read_config_dword(pdev, MC_SSRCONTROL, &dw_ssr);
2000 dw_ssr &= ~SSR_MODE_MASK;
2001 dw_ssr |= SSR_MODE_ENABLE;
2002 }
2003 /* Disable or enable scrubbing */
2004 pci_write_config_dword(pdev, MC_SSRCONTROL, dw_ssr);
2005
2006 return new_bw;
2007 }
2008
2009 /*
2010 * get_sdram_scrub_rate This routine convert current scrub rate value
2011 * into byte/sec bandwidth according to
2012 * SCRUBINTERVAL formula found in datasheet.
2013 */
2014 static int get_sdram_scrub_rate(struct mem_ctl_info *mci)
2015 {
2016 struct i7core_pvt *pvt = mci->pvt_info;
2017 struct pci_dev *pdev;
2018 const u32 cache_line_size = 64;
2019 const u32 freq_dclk_mhz = pvt->dclk_freq;
2020 unsigned long long scrub_rate;
2021 u32 scrubval;
2022
2023 /* Get data from the MC register, function 2 */
2024 pdev = pvt->pci_mcr[2];
2025 if (!pdev)
2026 return -ENODEV;
2027
2028 /* Get current scrub control data */
2029 pci_read_config_dword(pdev, MC_SCRUB_CONTROL, &scrubval);
2030
2031 /* Mask highest 8-bits to 0 */
2032 scrubval &= SCRUBINTERVAL_MASK;
2033 if (!scrubval)
2034 return 0;
2035
2036 /* Calculate scrub rate value into byte/sec bandwidth */
2037 scrub_rate = (unsigned long long)freq_dclk_mhz *
2038 1000000 * cache_line_size;
2039 do_div(scrub_rate, scrubval);
2040 return (int)scrub_rate;
2041 }
2042
2043 static void enable_sdram_scrub_setting(struct mem_ctl_info *mci)
2044 {
2045 struct i7core_pvt *pvt = mci->pvt_info;
2046 u32 pci_lock;
2047
2048 /* Unlock writes to pci registers */
2049 pci_read_config_dword(pvt->pci_noncore, MC_CFG_CONTROL, &pci_lock);
2050 pci_lock &= ~0x3;
2051 pci_write_config_dword(pvt->pci_noncore, MC_CFG_CONTROL,
2052 pci_lock | MC_CFG_UNLOCK);
2053
2054 mci->set_sdram_scrub_rate = set_sdram_scrub_rate;
2055 mci->get_sdram_scrub_rate = get_sdram_scrub_rate;
2056 }
2057
2058 static void disable_sdram_scrub_setting(struct mem_ctl_info *mci)
2059 {
2060 struct i7core_pvt *pvt = mci->pvt_info;
2061 u32 pci_lock;
2062
2063 /* Lock writes to pci registers */
2064 pci_read_config_dword(pvt->pci_noncore, MC_CFG_CONTROL, &pci_lock);
2065 pci_lock &= ~0x3;
2066 pci_write_config_dword(pvt->pci_noncore, MC_CFG_CONTROL,
2067 pci_lock | MC_CFG_LOCK);
2068 }
2069
2070 static void i7core_pci_ctl_create(struct i7core_pvt *pvt)
2071 {
2072 pvt->i7core_pci = edac_pci_create_generic_ctl(
2073 &pvt->i7core_dev->pdev[0]->dev,
2074 EDAC_MOD_STR);
2075 if (unlikely(!pvt->i7core_pci))
2076 i7core_printk(KERN_WARNING,
2077 "Unable to setup PCI error report via EDAC\n");
2078 }
2079
2080 static void i7core_pci_ctl_release(struct i7core_pvt *pvt)
2081 {
2082 if (likely(pvt->i7core_pci))
2083 edac_pci_release_generic_ctl(pvt->i7core_pci);
2084 else
2085 i7core_printk(KERN_ERR,
2086 "Couldn't find mem_ctl_info for socket %d\n",
2087 pvt->i7core_dev->socket);
2088 pvt->i7core_pci = NULL;
2089 }
2090
2091 static void i7core_unregister_mci(struct i7core_dev *i7core_dev)
2092 {
2093 struct mem_ctl_info *mci = i7core_dev->mci;
2094 struct i7core_pvt *pvt;
2095
2096 if (unlikely(!mci || !mci->pvt_info)) {
2097 debugf0("MC: " __FILE__ ": %s(): dev = %p\n",
2098 __func__, &i7core_dev->pdev[0]->dev);
2099
2100 i7core_printk(KERN_ERR, "Couldn't find mci handler\n");
2101 return;
2102 }
2103
2104 pvt = mci->pvt_info;
2105
2106 debugf0("MC: " __FILE__ ": %s(): mci = %p, dev = %p\n",
2107 __func__, mci, &i7core_dev->pdev[0]->dev);
2108
2109 /* Disable scrubrate setting */
2110 if (pvt->enable_scrub)
2111 disable_sdram_scrub_setting(mci);
2112
2113 /* Disable EDAC polling */
2114 i7core_pci_ctl_release(pvt);
2115
2116 /* Remove MC sysfs nodes */
2117 edac_mc_del_mc(mci->dev);
2118
2119 debugf1("%s: free mci struct\n", mci->ctl_name);
2120 kfree(mci->ctl_name);
2121 edac_mc_free(mci);
2122 i7core_dev->mci = NULL;
2123 }
2124
2125 static int i7core_register_mci(struct i7core_dev *i7core_dev)
2126 {
2127 struct mem_ctl_info *mci;
2128 struct i7core_pvt *pvt;
2129 int rc;
2130 struct edac_mc_layer layers[2];
2131
2132 /* allocate a new MC control structure */
2133
2134 layers[0].type = EDAC_MC_LAYER_CHANNEL;
2135 layers[0].size = NUM_CHANS;
2136 layers[0].is_virt_csrow = false;
2137 layers[1].type = EDAC_MC_LAYER_SLOT;
2138 layers[1].size = MAX_DIMMS;
2139 layers[1].is_virt_csrow = true;
2140 mci = edac_mc_alloc(i7core_dev->socket, ARRAY_SIZE(layers), layers,
2141 sizeof(*pvt));
2142 if (unlikely(!mci))
2143 return -ENOMEM;
2144
2145 debugf0("MC: " __FILE__ ": %s(): mci = %p, dev = %p\n",
2146 __func__, mci, &i7core_dev->pdev[0]->dev);
2147
2148 pvt = mci->pvt_info;
2149 memset(pvt, 0, sizeof(*pvt));
2150
2151 /* Associates i7core_dev and mci for future usage */
2152 pvt->i7core_dev = i7core_dev;
2153 i7core_dev->mci = mci;
2154
2155 /*
2156 * FIXME: how to handle RDDR3 at MCI level? It is possible to have
2157 * Mixed RDDR3/UDDR3 with Nehalem, provided that they are on different
2158 * memory channels
2159 */
2160 mci->mtype_cap = MEM_FLAG_DDR3;
2161 mci->edac_ctl_cap = EDAC_FLAG_NONE;
2162 mci->edac_cap = EDAC_FLAG_NONE;
2163 mci->mod_name = "i7core_edac.c";
2164 mci->mod_ver = I7CORE_REVISION;
2165 mci->ctl_name = kasprintf(GFP_KERNEL, "i7 core #%d",
2166 i7core_dev->socket);
2167 mci->dev_name = pci_name(i7core_dev->pdev[0]);
2168 mci->ctl_page_to_phys = NULL;
2169
2170 /* Store pci devices at mci for faster access */
2171 rc = mci_bind_devs(mci, i7core_dev);
2172 if (unlikely(rc < 0))
2173 goto fail0;
2174
2175 if (pvt->is_registered)
2176 mci->mc_driver_sysfs_attributes = i7core_sysfs_rdimm_attrs;
2177 else
2178 mci->mc_driver_sysfs_attributes = i7core_sysfs_udimm_attrs;
2179
2180 /* Get dimm basic config */
2181 get_dimm_config(mci);
2182 /* record ptr to the generic device */
2183 mci->dev = &i7core_dev->pdev[0]->dev;
2184 /* Set the function pointer to an actual operation function */
2185 mci->edac_check = i7core_check_error;
2186
2187 /* Enable scrubrate setting */
2188 if (pvt->enable_scrub)
2189 enable_sdram_scrub_setting(mci);
2190
2191 /* add this new MC control structure to EDAC's list of MCs */
2192 if (unlikely(edac_mc_add_mc(mci))) {
2193 debugf0("MC: " __FILE__
2194 ": %s(): failed edac_mc_add_mc()\n", __func__);
2195 /* FIXME: perhaps some code should go here that disables error
2196 * reporting if we just enabled it
2197 */
2198
2199 rc = -EINVAL;
2200 goto fail0;
2201 }
2202
2203 /* Default error mask is any memory */
2204 pvt->inject.channel = 0;
2205 pvt->inject.dimm = -1;
2206 pvt->inject.rank = -1;
2207 pvt->inject.bank = -1;
2208 pvt->inject.page = -1;
2209 pvt->inject.col = -1;
2210
2211 /* allocating generic PCI control info */
2212 i7core_pci_ctl_create(pvt);
2213
2214 /* DCLK for scrub rate setting */
2215 pvt->dclk_freq = get_dclk_freq();
2216
2217 return 0;
2218
2219 fail0:
2220 kfree(mci->ctl_name);
2221 edac_mc_free(mci);
2222 i7core_dev->mci = NULL;
2223 return rc;
2224 }
2225
2226 /*
2227 * i7core_probe Probe for ONE instance of device to see if it is
2228 * present.
2229 * return:
2230 * 0 for FOUND a device
2231 * < 0 for error code
2232 */
2233
2234 static int __devinit i7core_probe(struct pci_dev *pdev,
2235 const struct pci_device_id *id)
2236 {
2237 int rc, count = 0;
2238 struct i7core_dev *i7core_dev;
2239
2240 /* get the pci devices we want to reserve for our use */
2241 mutex_lock(&i7core_edac_lock);
2242
2243 /*
2244 * All memory controllers are allocated at the first pass.
2245 */
2246 if (unlikely(probed >= 1)) {
2247 mutex_unlock(&i7core_edac_lock);
2248 return -ENODEV;
2249 }
2250 probed++;
2251
2252 rc = i7core_get_all_devices();
2253 if (unlikely(rc < 0))
2254 goto fail0;
2255
2256 list_for_each_entry(i7core_dev, &i7core_edac_list, list) {
2257 count++;
2258 rc = i7core_register_mci(i7core_dev);
2259 if (unlikely(rc < 0))
2260 goto fail1;
2261 }
2262
2263 /*
2264 * Nehalem-EX uses a different memory controller. However, as the
2265 * memory controller is not visible on some Nehalem/Nehalem-EP, we
2266 * need to indirectly probe via a X58 PCI device. The same devices
2267 * are found on (some) Nehalem-EX. So, on those machines, the
2268 * probe routine needs to return -ENODEV, as the actual Memory
2269 * Controller registers won't be detected.
2270 */
2271 if (!count) {
2272 rc = -ENODEV;
2273 goto fail1;
2274 }
2275
2276 i7core_printk(KERN_INFO,
2277 "Driver loaded, %d memory controller(s) found.\n",
2278 count);
2279
2280 mutex_unlock(&i7core_edac_lock);
2281 return 0;
2282
2283 fail1:
2284 list_for_each_entry(i7core_dev, &i7core_edac_list, list)
2285 i7core_unregister_mci(i7core_dev);
2286
2287 i7core_put_all_devices();
2288 fail0:
2289 mutex_unlock(&i7core_edac_lock);
2290 return rc;
2291 }
2292
2293 /*
2294 * i7core_remove destructor for one instance of device
2295 *
2296 */
2297 static void __devexit i7core_remove(struct pci_dev *pdev)
2298 {
2299 struct i7core_dev *i7core_dev;
2300
2301 debugf0(__FILE__ ": %s()\n", __func__);
2302
2303 /*
2304 * we have a trouble here: pdev value for removal will be wrong, since
2305 * it will point to the X58 register used to detect that the machine
2306 * is a Nehalem or upper design. However, due to the way several PCI
2307 * devices are grouped together to provide MC functionality, we need
2308 * to use a different method for releasing the devices
2309 */
2310
2311 mutex_lock(&i7core_edac_lock);
2312
2313 if (unlikely(!probed)) {
2314 mutex_unlock(&i7core_edac_lock);
2315 return;
2316 }
2317
2318 list_for_each_entry(i7core_dev, &i7core_edac_list, list)
2319 i7core_unregister_mci(i7core_dev);
2320
2321 /* Release PCI resources */
2322 i7core_put_all_devices();
2323
2324 probed--;
2325
2326 mutex_unlock(&i7core_edac_lock);
2327 }
2328
2329 MODULE_DEVICE_TABLE(pci, i7core_pci_tbl);
2330
2331 /*
2332 * i7core_driver pci_driver structure for this module
2333 *
2334 */
2335 static struct pci_driver i7core_driver = {
2336 .name = "i7core_edac",
2337 .probe = i7core_probe,
2338 .remove = __devexit_p(i7core_remove),
2339 .id_table = i7core_pci_tbl,
2340 };
2341
2342 /*
2343 * i7core_init Module entry function
2344 * Try to initialize this module for its devices
2345 */
2346 static int __init i7core_init(void)
2347 {
2348 int pci_rc;
2349
2350 debugf2("MC: " __FILE__ ": %s()\n", __func__);
2351
2352 /* Ensure that the OPSTATE is set correctly for POLL or NMI */
2353 opstate_init();
2354
2355 if (use_pci_fixup)
2356 i7core_xeon_pci_fixup(pci_dev_table);
2357
2358 pci_rc = pci_register_driver(&i7core_driver);
2359
2360 if (pci_rc >= 0) {
2361 mce_register_decode_chain(&i7_mce_dec);
2362 return 0;
2363 }
2364
2365 i7core_printk(KERN_ERR, "Failed to register device with error %d.\n",
2366 pci_rc);
2367
2368 return pci_rc;
2369 }
2370
2371 /*
2372 * i7core_exit() Module exit function
2373 * Unregister the driver
2374 */
2375 static void __exit i7core_exit(void)
2376 {
2377 debugf2("MC: " __FILE__ ": %s()\n", __func__);
2378 pci_unregister_driver(&i7core_driver);
2379 mce_unregister_decode_chain(&i7_mce_dec);
2380 }
2381
2382 module_init(i7core_init);
2383 module_exit(i7core_exit);
2384
2385 MODULE_LICENSE("GPL");
2386 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
2387 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com)");
2388 MODULE_DESCRIPTION("MC Driver for Intel i7 Core memory controllers - "
2389 I7CORE_REVISION);
2390
2391 module_param(edac_op_state, int, 0444);
2392 MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");
Linux kernel - Deliverables
This page took 0.123053 seconds and 5 git commands to generate.