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