drivers/edac/i7core_edac.c

   1 /* Intel 7 core  Memory Controller kernel module (Nehalem)
   2  *
   3  * This file may be distributed under the terms of the
   4  * GNU General Public License version 2 only.
   5  *
   6  * Copyright (c) 2009 by:
   7  *       Mauro Carvalho Chehab <mchehab@redhat.com>
   8  *
   9  * Red Hat Inc. http://www.redhat.com
  10  *
  11  * Forked and adapted from the i5400_edac driver
  12  *
  13  * Based on the following public Intel datasheets:
  14  * Intel Core i7 Processor Extreme Edition and Intel Core i7 Processor
  15  * Datasheet, Volume 2:
  16  *      http://download.intel.com/design/processor/datashts/320835.pdf
  17  * Intel Xeon Processor 5500 Series Datasheet Volume 2
  18  *      http://www.intel.com/Assets/PDF/datasheet/321322.pdf
  19  * also available at:
  20  *      http://www.arrownac.com/manufacturers/intel/s/nehalem/5500-datasheet-v2.pdf
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/init.h>
  25 #include <linux/pci.h>
  26 #include <linux/pci_ids.h>
  27 #include <linux/slab.h>
  28 #include <linux/edac.h>
  29 #include <linux/mmzone.h>
  30 #include <linux/edac_mce.h>
  31 #include <linux/spinlock.h>
  32 #include <asm/processor.h>
  33
  34 #include "edac_core.h"
  35
  36 /*
  37  * Alter this version for the module when modifications are made
  38  */
  39 #define I7CORE_REVISION    " Ver: 1.0.0 " __DATE__
  40 #define EDAC_MOD_STR      "i7core_edac"
  41
  42 /*
  43  * Debug macros
  44  */
  45 #define i7core_printk(level, fmt, arg...)                       \
  46         edac_printk(level, "i7core", fmt, ##arg)
  47
  48 #define i7core_mc_printk(mci, level, fmt, arg...)               \
  49         edac_mc_chipset_printk(mci, level, "i7core", fmt, ##arg)
  50
  51 /*
  52  * i7core Memory Controller Registers
  53  */
  54
  55         /* OFFSETS for Device 0 Function 0 */
  56
  57 #define MC_CFG_CONTROL  0x90
  58
  59         /* OFFSETS for Device 3 Function 0 */
  60
  61 #define MC_CONTROL      0x48
  62 #define MC_STATUS       0x4c
  63 #define MC_MAX_DOD      0x64
  64
  65 /*
  66  * OFFSETS for Device 3 Function 4, as inicated on Xeon 5500 datasheet:
  67  * http://www.arrownac.com/manufacturers/intel/s/nehalem/5500-datasheet-v2.pdf
  68  */
  69
  70 #define MC_TEST_ERR_RCV1        0x60
  71   #define DIMM2_COR_ERR(r)                      ((r) & 0x7fff)
  72
  73 #define MC_TEST_ERR_RCV0        0x64
  74   #define DIMM1_COR_ERR(r)                      (((r) >> 16) & 0x7fff)
  75   #define DIMM0_COR_ERR(r)                      ((r) & 0x7fff)
  76
  77 /* OFFSETS for Device 3 Function 2, as inicated on Xeon 5500 datasheet */
  78 #define MC_COR_ECC_CNT_0        0x80
  79 #define MC_COR_ECC_CNT_1        0x84
  80 #define MC_COR_ECC_CNT_2        0x88
  81 #define MC_COR_ECC_CNT_3        0x8c
  82 #define MC_COR_ECC_CNT_4        0x90
  83 #define MC_COR_ECC_CNT_5        0x94
  84
  85 #define DIMM_TOP_COR_ERR(r)                     (((r) >> 16) & 0x7fff)
  86 #define DIMM_BOT_COR_ERR(r)                     ((r) & 0x7fff)
  87
  88
  89         /* OFFSETS for Devices 4,5 and 6 Function 0 */
  90
  91 #define MC_CHANNEL_DIMM_INIT_PARAMS 0x58
  92   #define THREE_DIMMS_PRESENT           (1 << 24)
  93   #define SINGLE_QUAD_RANK_PRESENT      (1 << 23)
  94   #define QUAD_RANK_PRESENT             (1 << 22)
  95   #define REGISTERED_DIMM               (1 << 15)
  96
  97 #define MC_CHANNEL_MAPPER       0x60
  98   #define RDLCH(r, ch)          ((((r) >> (3 + (ch * 6))) & 0x07) - 1)
  99   #define WRLCH(r, ch)          ((((r) >> (ch * 6)) & 0x07) - 1)
 100
 101 #define MC_CHANNEL_RANK_PRESENT 0x7c
 102   #define RANK_PRESENT_MASK             0xffff
 103
 104 #define MC_CHANNEL_ADDR_MATCH   0xf0
 105 #define MC_CHANNEL_ERROR_MASK   0xf8
 106 #define MC_CHANNEL_ERROR_INJECT 0xfc
 107   #define INJECT_ADDR_PARITY    0x10
 108   #define INJECT_ECC            0x08
 109   #define MASK_CACHELINE        0x06
 110   #define MASK_FULL_CACHELINE   0x06
 111   #define MASK_MSB32_CACHELINE  0x04
 112   #define MASK_LSB32_CACHELINE  0x02
 113   #define NO_MASK_CACHELINE     0x00
 114   #define REPEAT_EN             0x01
 115
 116         /* OFFSETS for Devices 4,5 and 6 Function 1 */
 117
 118 #define MC_DOD_CH_DIMM0         0x48
 119 #define MC_DOD_CH_DIMM1         0x4c
 120 #define MC_DOD_CH_DIMM2         0x50
 121   #define RANKOFFSET_MASK       ((1 << 12) | (1 << 11) | (1 << 10))
 122   #define RANKOFFSET(x)         ((x & RANKOFFSET_MASK) >> 10)
 123   #define DIMM_PRESENT_MASK     (1 << 9)
 124   #define DIMM_PRESENT(x)       (((x) & DIMM_PRESENT_MASK) >> 9)
 125   #define MC_DOD_NUMBANK_MASK           ((1 << 8) | (1 << 7))
 126   #define MC_DOD_NUMBANK(x)             (((x) & MC_DOD_NUMBANK_MASK) >> 7)
 127   #define MC_DOD_NUMRANK_MASK           ((1 << 6) | (1 << 5))
 128   #define MC_DOD_NUMRANK(x)             (((x) & MC_DOD_NUMRANK_MASK) >> 5)
 129   #define MC_DOD_NUMROW_MASK            ((1 << 4) | (1 << 3) | (1 << 2))
 130   #define MC_DOD_NUMROW(x)              (((x) & MC_DOD_NUMROW_MASK) >> 2)
 131   #define MC_DOD_NUMCOL_MASK            3
 132   #define MC_DOD_NUMCOL(x)              ((x) & MC_DOD_NUMCOL_MASK)
 133
 134 #define MC_RANK_PRESENT         0x7c
 135
 136 #define MC_SAG_CH_0     0x80
 137 #define MC_SAG_CH_1     0x84
 138 #define MC_SAG_CH_2     0x88
 139 #define MC_SAG_CH_3     0x8c
 140 #define MC_SAG_CH_4     0x90
 141 #define MC_SAG_CH_5     0x94
 142 #define MC_SAG_CH_6     0x98
 143 #define MC_SAG_CH_7     0x9c
 144
 145 #define MC_RIR_LIMIT_CH_0       0x40
 146 #define MC_RIR_LIMIT_CH_1       0x44
 147 #define MC_RIR_LIMIT_CH_2       0x48
 148 #define MC_RIR_LIMIT_CH_3       0x4C
 149 #define MC_RIR_LIMIT_CH_4       0x50
 150 #define MC_RIR_LIMIT_CH_5       0x54
 151 #define MC_RIR_LIMIT_CH_6       0x58
 152 #define MC_RIR_LIMIT_CH_7       0x5C
 153 #define MC_RIR_LIMIT_MASK       ((1 << 10) - 1)
 154
 155 #define MC_RIR_WAY_CH           0x80
 156   #define MC_RIR_WAY_OFFSET_MASK        (((1 << 14) - 1) & ~0x7)
 157   #define MC_RIR_WAY_RANK_MASK          0x7
 158
 159 /*
 160  * i7core structs
 161  */
 162
 163 #define NUM_CHANS 3
 164 #define MAX_DIMMS 3             /* Max DIMMS per channel */
 165 #define NUM_SOCKETS 2           /* Max number of MC sockets */
 166 #define MAX_MCR_FUNC  4
 167 #define MAX_CHAN_FUNC 3
 168
 169 struct i7core_info {
 170         u32     mc_control;
 171         u32     mc_status;
 172         u32     max_dod;
 173         u32     ch_map;
 174 };
 175
 176
 177 struct i7core_inject {
 178         int     enable;
 179
 180         u8      socket;
 181         u32     section;
 182         u32     type;
 183         u32     eccmask;
 184
 185         /* Error address mask */
 186         int channel, dimm, rank, bank, page, col;
 187 };
 188
 189 struct i7core_channel {
 190         u32             ranks;
 191         u32             dimms;
 192 };
 193
 194 struct pci_id_descr {
 195         int             dev;
 196         int             func;
 197         int             dev_id;
 198         struct pci_dev  *pdev[NUM_SOCKETS];
 199 };
 200
 201 struct i7core_pvt {
 202         struct pci_dev  *pci_noncore[NUM_SOCKETS];
 203         struct pci_dev  *pci_mcr[NUM_SOCKETS][MAX_MCR_FUNC + 1];
 204         struct pci_dev  *pci_ch[NUM_SOCKETS][NUM_CHANS][MAX_CHAN_FUNC + 1];
 205
 206         struct i7core_info      info;
 207         struct i7core_inject    inject;
 208         struct i7core_channel   channel[NUM_SOCKETS][NUM_CHANS];
 209
 210         int                     sockets; /* Number of sockets */
 211         int                     channels; /* Number of active channels */
 212
 213         int             ce_count_available[NUM_SOCKETS];
 214         int             csrow_map[NUM_SOCKETS][NUM_CHANS][MAX_DIMMS];
 215
 216                         /* ECC corrected errors counts per udimm */
 217         unsigned long   udimm_ce_count[NUM_SOCKETS][MAX_DIMMS];
 218         int             udimm_last_ce_count[NUM_SOCKETS][MAX_DIMMS];
 219                         /* ECC corrected errors counts per rdimm */
 220         unsigned long   rdimm_ce_count[NUM_SOCKETS][NUM_CHANS][MAX_DIMMS];
 221         int             rdimm_last_ce_count[NUM_SOCKETS][NUM_CHANS][MAX_DIMMS];
 222
 223         unsigned int    is_registered[NUM_SOCKETS];
 224
 225         /* mcelog glue */
 226         struct edac_mce         edac_mce;
 227         struct mce              mce_entry[MCE_LOG_LEN];
 228         unsigned                mce_count;
 229         spinlock_t              mce_lock;
 230 };
 231
 232 /* Device name and register DID (Device ID) */
 233 struct i7core_dev_info {
 234         const char *ctl_name;   /* name for this device */
 235         u16 fsb_mapping_errors; /* DID for the branchmap,control */
 236 };
 237
 238 #define PCI_DESCR(device, function, device_id)  \
 239         .dev = (device),                        \
 240         .func = (function),                     \
 241         .dev_id = (device_id)
 242
 243 struct pci_id_descr pci_devs[] = {
 244                 /* Memory controller */
 245         { PCI_DESCR(3, 0, PCI_DEVICE_ID_INTEL_I7_MCR)     },
 246         { PCI_DESCR(3, 1, PCI_DEVICE_ID_INTEL_I7_MC_TAD)  },
 247         { PCI_DESCR(3, 2, PCI_DEVICE_ID_INTEL_I7_MC_RAS)  }, /* if RDIMM */
 248         { PCI_DESCR(3, 4, PCI_DEVICE_ID_INTEL_I7_MC_TEST) },
 249
 250                 /* Channel 0 */
 251         { PCI_DESCR(4, 0, PCI_DEVICE_ID_INTEL_I7_MC_CH0_CTRL) },
 252         { PCI_DESCR(4, 1, PCI_DEVICE_ID_INTEL_I7_MC_CH0_ADDR) },
 253         { PCI_DESCR(4, 2, PCI_DEVICE_ID_INTEL_I7_MC_CH0_RANK) },
 254         { PCI_DESCR(4, 3, PCI_DEVICE_ID_INTEL_I7_MC_CH0_TC)   },
 255
 256                 /* Channel 1 */
 257         { PCI_DESCR(5, 0, PCI_DEVICE_ID_INTEL_I7_MC_CH1_CTRL) },
 258         { PCI_DESCR(5, 1, PCI_DEVICE_ID_INTEL_I7_MC_CH1_ADDR) },
 259         { PCI_DESCR(5, 2, PCI_DEVICE_ID_INTEL_I7_MC_CH1_RANK) },
 260         { PCI_DESCR(5, 3, PCI_DEVICE_ID_INTEL_I7_MC_CH1_TC)   },
 261
 262                 /* Channel 2 */
 263         { PCI_DESCR(6, 0, PCI_DEVICE_ID_INTEL_I7_MC_CH2_CTRL) },
 264         { PCI_DESCR(6, 1, PCI_DEVICE_ID_INTEL_I7_MC_CH2_ADDR) },
 265         { PCI_DESCR(6, 2, PCI_DEVICE_ID_INTEL_I7_MC_CH2_RANK) },
 266         { PCI_DESCR(6, 3, PCI_DEVICE_ID_INTEL_I7_MC_CH2_TC)   },
 267
 268                 /* Generic Non-core registers */
 269         /*
 270          * This is the PCI device on i7core and on Xeon 35xx (8086:2c41)
 271          * On Xeon 55xx, however, it has a different id (8086:2c40). So,
 272          * the probing code needs to test for the other address in case of
 273          * failure of this one
 274          */
 275         { PCI_DESCR(0, 0, PCI_DEVICE_ID_INTEL_I7_NOCORE)  },
 276
 277 };
 278 #define N_DEVS ARRAY_SIZE(pci_devs)
 279
 280 /*
 281  *      pci_device_id   table for which devices we are looking for
 282  * This should match the first device at pci_devs table
 283  */
 284 static const struct pci_device_id i7core_pci_tbl[] __devinitdata = {
 285         {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_X58_HUB_MGMT)},
 286         {0,}                    /* 0 terminated list. */
 287 };
 288
 289
 290 /* Table of devices attributes supported by this driver */
 291 static const struct i7core_dev_info i7core_devs[] = {
 292         {
 293                 .ctl_name = "i7 Core",
 294                 .fsb_mapping_errors = PCI_DEVICE_ID_INTEL_I7_MCR,
 295         },
 296 };
 297
 298 static struct edac_pci_ctl_info *i7core_pci;
 299
 300 /****************************************************************************
 301                         Anciliary status routines
 302  ****************************************************************************/
 303
 304         /* MC_CONTROL bits */
 305 #define CH_ACTIVE(pvt, ch)      ((pvt)->info.mc_control & (1 << (8 + ch)))
 306 #define ECCx8(pvt)              ((pvt)->info.mc_control & (1 << 1))
 307
 308         /* MC_STATUS bits */
 309 #define ECC_ENABLED(pvt)        ((pvt)->info.mc_status & (1 << 4))
 310 #define CH_DISABLED(pvt, ch)    ((pvt)->info.mc_status & (1 << ch))
 311
 312         /* MC_MAX_DOD read functions */
 313 static inline int numdimms(u32 dimms)
 314 {
 315         return (dimms & 0x3) + 1;
 316 }
 317
 318 static inline int numrank(u32 rank)
 319 {
 320         static int ranks[4] = { 1, 2, 4, -EINVAL };
 321
 322         return ranks[rank & 0x3];
 323 }
 324
 325 static inline int numbank(u32 bank)
 326 {
 327         static int banks[4] = { 4, 8, 16, -EINVAL };
 328
 329         return banks[bank & 0x3];
 330 }
 331
 332 static inline int numrow(u32 row)
 333 {
 334         static int rows[8] = {
 335                 1 << 12, 1 << 13, 1 << 14, 1 << 15,
 336                 1 << 16, -EINVAL, -EINVAL, -EINVAL,
 337         };
 338
 339         return rows[row & 0x7];
 340 }
 341
 342 static inline int numcol(u32 col)
 343 {
 344         static int cols[8] = {
 345                 1 << 10, 1 << 11, 1 << 12, -EINVAL,
 346         };
 347         return cols[col & 0x3];
 348 }
 349
 350 /****************************************************************************
 351                         Memory check routines
 352  ****************************************************************************/
 353 static struct pci_dev *get_pdev_slot_func(u8 socket, unsigned slot,
 354                                           unsigned func)
 355 {
 356         int i;
 357
 358         for (i = 0; i < N_DEVS; i++) {
 359                 if (!pci_devs[i].pdev[socket])
 360                         continue;
 361
 362                 if (PCI_SLOT(pci_devs[i].pdev[socket]->devfn) == slot &&
 363                     PCI_FUNC(pci_devs[i].pdev[socket]->devfn) == func) {
 364                         return pci_devs[i].pdev[socket];
 365                 }
 366         }
 367
 368         return NULL;
 369 }
 370
 371 /**
 372  * i7core_get_active_channels() - gets the number of channels and csrows
 373  * @socket:     Quick Path Interconnect socket
 374  * @channels:   Number of channels that will be returned
 375  * @csrows:     Number of csrows found
 376  *
 377  * Since EDAC core needs to know in advance the number of available channels
 378  * and csrows, in order to allocate memory for csrows/channels, it is needed
 379  * to run two similar steps. At the first step, implemented on this function,
 380  * it checks the number of csrows/channels present at one socket.
 381  * this is used in order to properly allocate the size of mci components.
 382  *
 383  * It should be noticed that none of the current available datasheets explain
 384  * or even mention how csrows are seen by the memory controller. So, we need
 385  * to add a fake description for csrows.
 386  * So, this driver is attributing one DIMM memory for one csrow.
 387  */
 388 static int i7core_get_active_channels(u8 socket, unsigned *channels,
 389                                       unsigned *csrows)
 390 {
 391         struct pci_dev *pdev = NULL;
 392         int i, j;
 393         u32 status, control;
 394
 395         *channels = 0;
 396         *csrows = 0;
 397
 398         pdev = get_pdev_slot_func(socket, 3, 0);
 399         if (!pdev) {
 400                 i7core_printk(KERN_ERR, "Couldn't find socket %d fn 3.0!!!\n",
 401                               socket);
 402                 return -ENODEV;
 403         }
 404
 405         /* Device 3 function 0 reads */
 406         pci_read_config_dword(pdev, MC_STATUS, &status);
 407         pci_read_config_dword(pdev, MC_CONTROL, &control);
 408
 409         for (i = 0; i < NUM_CHANS; i++) {
 410                 u32 dimm_dod[3];
 411                 /* Check if the channel is active */
 412                 if (!(control & (1 << (8 + i))))
 413                         continue;
 414
 415                 /* Check if the channel is disabled */
 416                 if (status & (1 << i))
 417                         continue;
 418
 419                 pdev = get_pdev_slot_func(socket, i + 4, 1);
 420                 if (!pdev) {
 421                         i7core_printk(KERN_ERR, "Couldn't find socket %d "
 422                                                 "fn %d.%d!!!\n",
 423                                                 socket, i + 4, 1);
 424                         return -ENODEV;
 425                 }
 426                 /* Devices 4-6 function 1 */
 427                 pci_read_config_dword(pdev,
 428                                 MC_DOD_CH_DIMM0, &dimm_dod[0]);
 429                 pci_read_config_dword(pdev,
 430                                 MC_DOD_CH_DIMM1, &dimm_dod[1]);
 431                 pci_read_config_dword(pdev,
 432                                 MC_DOD_CH_DIMM2, &dimm_dod[2]);
 433
 434                 (*channels)++;
 435
 436                 for (j = 0; j < 3; j++) {
 437                         if (!DIMM_PRESENT(dimm_dod[j]))
 438                                 continue;
 439                         (*csrows)++;
 440                 }
 441         }
 442
 443         debugf0("Number of active channels on socket %d: %d\n",
 444                 socket, *channels);
 445
 446         return 0;
 447 }
 448
 449 static int get_dimm_config(struct mem_ctl_info *mci, int *csrow, u8 socket)
 450 {
 451         struct i7core_pvt *pvt = mci->pvt_info;
 452         struct csrow_info *csr;
 453         struct pci_dev *pdev;
 454         int i, j;
 455         unsigned long last_page = 0;
 456         enum edac_type mode;
 457         enum mem_type mtype;
 458
 459         /* Get data from the MC register, function 0 */
 460         pdev = pvt->pci_mcr[socket][0];
 461         if (!pdev)
 462                 return -ENODEV;
 463
 464         /* Device 3 function 0 reads */
 465         pci_read_config_dword(pdev, MC_CONTROL, &pvt->info.mc_control);
 466         pci_read_config_dword(pdev, MC_STATUS, &pvt->info.mc_status);
 467         pci_read_config_dword(pdev, MC_MAX_DOD, &pvt->info.max_dod);
 468         pci_read_config_dword(pdev, MC_CHANNEL_MAPPER, &pvt->info.ch_map);
 469
 470         debugf0("QPI %d control=0x%08x status=0x%08x dod=0x%08x map=0x%08x\n",
 471                 socket, pvt->info.mc_control, pvt->info.mc_status,
 472                 pvt->info.max_dod, pvt->info.ch_map);
 473
 474         if (ECC_ENABLED(pvt)) {
 475                 debugf0("ECC enabled with x%d SDCC\n", ECCx8(pvt) ? 8 : 4);
 476                 if (ECCx8(pvt))
 477                         mode = EDAC_S8ECD8ED;
 478                 else
 479                         mode = EDAC_S4ECD4ED;
 480         } else {
 481                 debugf0("ECC disabled\n");
 482                 mode = EDAC_NONE;
 483         }
 484
 485         /* FIXME: need to handle the error codes */
 486         debugf0("DOD Max limits: DIMMS: %d, %d-ranked, %d-banked "
 487                 "x%x x 0x%x\n",
 488                 numdimms(pvt->info.max_dod),
 489                 numrank(pvt->info.max_dod >> 2),
 490                 numbank(pvt->info.max_dod >> 4),
 491                 numrow(pvt->info.max_dod >> 6),
 492                 numcol(pvt->info.max_dod >> 9));
 493
 494         for (i = 0; i < NUM_CHANS; i++) {
 495                 u32 data, dimm_dod[3], value[8];
 496
 497                 if (!CH_ACTIVE(pvt, i)) {
 498                         debugf0("Channel %i is not active\n", i);
 499                         continue;
 500                 }
 501                 if (CH_DISABLED(pvt, i)) {
 502                         debugf0("Channel %i is disabled\n", i);
 503                         continue;
 504                 }
 505
 506                 /* Devices 4-6 function 0 */
 507                 pci_read_config_dword(pvt->pci_ch[socket][i][0],
 508                                 MC_CHANNEL_DIMM_INIT_PARAMS, &data);
 509
 510                 pvt->channel[socket][i].ranks = (data & QUAD_RANK_PRESENT) ?
 511                                                 4 : 2;
 512
 513                 if (data & REGISTERED_DIMM)
 514                         mtype = MEM_RDDR3;
 515                 else
 516                         mtype = MEM_DDR3;
 517 #if 0
 518                 if (data & THREE_DIMMS_PRESENT)
 519                         pvt->channel[i].dimms = 3;
 520                 else if (data & SINGLE_QUAD_RANK_PRESENT)
 521                         pvt->channel[i].dimms = 1;
 522                 else
 523                         pvt->channel[i].dimms = 2;
 524 #endif
 525
 526                 /* Devices 4-6 function 1 */
 527                 pci_read_config_dword(pvt->pci_ch[socket][i][1],
 528                                 MC_DOD_CH_DIMM0, &dimm_dod[0]);
 529                 pci_read_config_dword(pvt->pci_ch[socket][i][1],
 530                                 MC_DOD_CH_DIMM1, &dimm_dod[1]);
 531                 pci_read_config_dword(pvt->pci_ch[socket][i][1],
 532                                 MC_DOD_CH_DIMM2, &dimm_dod[2]);
 533
 534                 debugf0("Ch%d phy rd%d, wr%d (0x%08x): "
 535                         "%d ranks, %cDIMMs\n",
 536                         i,
 537                         RDLCH(pvt->info.ch_map, i), WRLCH(pvt->info.ch_map, i),
 538                         data,
 539                         pvt->channel[socket][i].ranks,
 540                         (data & REGISTERED_DIMM) ? 'R' : 'U');
 541
 542                 for (j = 0; j < 3; j++) {
 543                         u32 banks, ranks, rows, cols;
 544                         u32 size, npages;
 545
 546                         if (!DIMM_PRESENT(dimm_dod[j]))
 547                                 continue;
 548
 549                         banks = numbank(MC_DOD_NUMBANK(dimm_dod[j]));
 550                         ranks = numrank(MC_DOD_NUMRANK(dimm_dod[j]));
 551                         rows = numrow(MC_DOD_NUMROW(dimm_dod[j]));
 552                         cols = numcol(MC_DOD_NUMCOL(dimm_dod[j]));
 553
 554                         /* DDR3 has 8 I/O banks */
 555                         size = (rows * cols * banks * ranks) >> (20 - 3);
 556
 557                         pvt->channel[socket][i].dimms++;
 558
 559                         debugf0("\tdimm %d %d Mb offset: %x, "
 560                                 "bank: %d, rank: %d, row: %#x, col: %#x\n",
 561                                 j, size,
 562                                 RANKOFFSET(dimm_dod[j]),
 563                                 banks, ranks, rows, cols);
 564
 565 #if PAGE_SHIFT > 20
 566                         npages = size >> (PAGE_SHIFT - 20);
 567 #else
 568                         npages = size << (20 - PAGE_SHIFT);
 569 #endif
 570
 571                         csr = &mci->csrows[*csrow];
 572                         csr->first_page = last_page + 1;
 573                         last_page += npages;
 574                         csr->last_page = last_page;
 575                         csr->nr_pages = npages;
 576
 577                         csr->page_mask = 0;
 578                         csr->grain = 8;
 579                         csr->csrow_idx = *csrow;
 580                         csr->nr_channels = 1;
 581
 582                         csr->channels[0].chan_idx = i;
 583                         csr->channels[0].ce_count = 0;
 584
 585                         pvt->csrow_map[socket][i][j] = *csrow;
 586
 587                         switch (banks) {
 588                         case 4:
 589                                 csr->dtype = DEV_X4;
 590                                 break;
 591                         case 8:
 592                                 csr->dtype = DEV_X8;
 593                                 break;
 594                         case 16:
 595                                 csr->dtype = DEV_X16;
 596                                 break;
 597                         default:
 598                                 csr->dtype = DEV_UNKNOWN;
 599                         }
 600
 601                         csr->edac_mode = mode;
 602                         csr->mtype = mtype;
 603
 604                         (*csrow)++;
 605                 }
 606
 607                 pci_read_config_dword(pdev, MC_SAG_CH_0, &value[0]);
 608                 pci_read_config_dword(pdev, MC_SAG_CH_1, &value[1]);
 609                 pci_read_config_dword(pdev, MC_SAG_CH_2, &value[2]);
 610                 pci_read_config_dword(pdev, MC_SAG_CH_3, &value[3]);
 611                 pci_read_config_dword(pdev, MC_SAG_CH_4, &value[4]);
 612                 pci_read_config_dword(pdev, MC_SAG_CH_5, &value[5]);
 613                 pci_read_config_dword(pdev, MC_SAG_CH_6, &value[6]);
 614                 pci_read_config_dword(pdev, MC_SAG_CH_7, &value[7]);
 615                 debugf1("\t[%i] DIVBY3\tREMOVED\tOFFSET\n", i);
 616                 for (j = 0; j < 8; j++)
 617                         debugf1("\t\t%#x\t%#x\t%#x\n",
 618                                 (value[j] >> 27) & 0x1,
 619                                 (value[j] >> 24) & 0x7,
 620                                 (value[j] && ((1 << 24) - 1)));
 621         }
 622
 623         return 0;
 624 }
 625
 626 /****************************************************************************
 627                         Error insertion routines
 628  ****************************************************************************/
 629
 630 /* The i7core has independent error injection features per channel.
 631    However, to have a simpler code, we don't allow enabling error injection
 632    on more than one channel.
 633    Also, since a change at an inject parameter will be applied only at enable,
 634    we're disabling error injection on all write calls to the sysfs nodes that
 635    controls the error code injection.
 636  */
 637 static int disable_inject(struct mem_ctl_info *mci)
 638 {
 639         struct i7core_pvt *pvt = mci->pvt_info;
 640
 641         pvt->inject.enable = 0;
 642
 643         if (!pvt->pci_ch[pvt->inject.socket][pvt->inject.channel][0])
 644                 return -ENODEV;
 645
 646         pci_write_config_dword(pvt->pci_ch[pvt->inject.socket][pvt->inject.channel][0],
 647                                 MC_CHANNEL_ERROR_INJECT, 0);
 648
 649         return 0;
 650 }
 651
 652 /*
 653  * i7core inject inject.socket
 654  *
 655  *      accept and store error injection inject.socket value
 656  */
 657 static ssize_t i7core_inject_socket_store(struct mem_ctl_info *mci,
 658                                            const char *data, size_t count)
 659 {
 660         struct i7core_pvt *pvt = mci->pvt_info;
 661         unsigned long value;
 662         int rc;
 663
 664         rc = strict_strtoul(data, 10, &value);
 665         if ((rc < 0) || (value >= pvt->sockets))
 666                 return -EIO;
 667
 668         pvt->inject.socket = (u32) value;
 669         return count;
 670 }
 671
 672 static ssize_t i7core_inject_socket_show(struct mem_ctl_info *mci,
 673                                               char *data)
 674 {
 675         struct i7core_pvt *pvt = mci->pvt_info;
 676         return sprintf(data, "%d\n", pvt->inject.socket);
 677 }
 678
 679 /*
 680  * i7core inject inject.section
 681  *
 682  *      accept and store error injection inject.section value
 683  *      bit 0 - refers to the lower 32-byte half cacheline
 684  *      bit 1 - refers to the upper 32-byte half cacheline
 685  */
 686 static ssize_t i7core_inject_section_store(struct mem_ctl_info *mci,
 687                                            const char *data, size_t count)
 688 {
 689         struct i7core_pvt *pvt = mci->pvt_info;
 690         unsigned long value;
 691         int rc;
 692
 693         if (pvt->inject.enable)
 694                 disable_inject(mci);
 695
 696         rc = strict_strtoul(data, 10, &value);
 697         if ((rc < 0) || (value > 3))
 698                 return -EIO;
 699
 700         pvt->inject.section = (u32) value;
 701         return count;
 702 }
 703
 704 static ssize_t i7core_inject_section_show(struct mem_ctl_info *mci,
 705                                               char *data)
 706 {
 707         struct i7core_pvt *pvt = mci->pvt_info;
 708         return sprintf(data, "0x%08x\n", pvt->inject.section);
 709 }
 710
 711 /*
 712  * i7core inject.type
 713  *
 714  *      accept and store error injection inject.section value
 715  *      bit 0 - repeat enable - Enable error repetition
 716  *      bit 1 - inject ECC error
 717  *      bit 2 - inject parity error
 718  */
 719 static ssize_t i7core_inject_type_store(struct mem_ctl_info *mci,
 720                                         const char *data, size_t count)
 721 {
 722         struct i7core_pvt *pvt = mci->pvt_info;
 723         unsigned long value;
 724         int rc;
 725
 726         if (pvt->inject.enable)
 727                 disable_inject(mci);
 728
 729         rc = strict_strtoul(data, 10, &value);
 730         if ((rc < 0) || (value > 7))
 731                 return -EIO;
 732
 733         pvt->inject.type = (u32) value;
 734         return count;
 735 }
 736
 737 static ssize_t i7core_inject_type_show(struct mem_ctl_info *mci,
 738                                               char *data)
 739 {
 740         struct i7core_pvt *pvt = mci->pvt_info;
 741         return sprintf(data, "0x%08x\n", pvt->inject.type);
 742 }
 743
 744 /*
 745  * i7core_inject_inject.eccmask_store
 746  *
 747  * The type of error (UE/CE) will depend on the inject.eccmask value:
 748  *   Any bits set to a 1 will flip the corresponding ECC bit
 749  *   Correctable errors can be injected by flipping 1 bit or the bits within
 750  *   a symbol pair (2 consecutive aligned 8-bit pairs - i.e. 7:0 and 15:8 or
 751  *   23:16 and 31:24). Flipping bits in two symbol pairs will cause an
 752  *   uncorrectable error to be injected.
 753  */
 754 static ssize_t i7core_inject_eccmask_store(struct mem_ctl_info *mci,
 755                                         const char *data, size_t count)
 756 {
 757         struct i7core_pvt *pvt = mci->pvt_info;
 758         unsigned long value;
 759         int rc;
 760
 761         if (pvt->inject.enable)
 762                 disable_inject(mci);
 763
 764         rc = strict_strtoul(data, 10, &value);
 765         if (rc < 0)
 766                 return -EIO;
 767
 768         pvt->inject.eccmask = (u32) value;
 769         return count;
 770 }
 771
 772 static ssize_t i7core_inject_eccmask_show(struct mem_ctl_info *mci,
 773                                               char *data)
 774 {
 775         struct i7core_pvt *pvt = mci->pvt_info;
 776         return sprintf(data, "0x%08x\n", pvt->inject.eccmask);
 777 }
 778
 779 /*
 780  * i7core_addrmatch
 781  *
 782  * The type of error (UE/CE) will depend on the inject.eccmask value:
 783  *   Any bits set to a 1 will flip the corresponding ECC bit
 784  *   Correctable errors can be injected by flipping 1 bit or the bits within
 785  *   a symbol pair (2 consecutive aligned 8-bit pairs - i.e. 7:0 and 15:8 or
 786  *   23:16 and 31:24). Flipping bits in two symbol pairs will cause an
 787  *   uncorrectable error to be injected.
 788  */
 789 static ssize_t i7core_inject_addrmatch_store(struct mem_ctl_info *mci,
 790                                         const char *data, size_t count)
 791 {
 792         struct i7core_pvt *pvt = mci->pvt_info;
 793         char *cmd, *val;
 794         long value;
 795         int rc;
 796
 797         if (pvt->inject.enable)
 798                 disable_inject(mci);
 799
 800         do {
 801                 cmd = strsep((char **) &data, ":");
 802                 if (!cmd)
 803                         break;
 804                 val = strsep((char **) &data, " \n\t");
 805                 if (!val)
 806                         return cmd - data;
 807
 808                 if (!strcasecmp(val, "any"))
 809                         value = -1;
 810                 else {
 811                         rc = strict_strtol(val, 10, &value);
 812                         if ((rc < 0) || (value < 0))
 813                                 return cmd - data;
 814                 }
 815
 816                 if (!strcasecmp(cmd, "channel")) {
 817                         if (value < 3)
 818                                 pvt->inject.channel = value;
 819                         else
 820                                 return cmd - data;
 821                 } else if (!strcasecmp(cmd, "dimm")) {
 822                         if (value < 3)
 823                                 pvt->inject.dimm = value;
 824                         else
 825                                 return cmd - data;
 826                 } else if (!strcasecmp(cmd, "rank")) {
 827                         if (value < 4)
 828                                 pvt->inject.rank = value;
 829                         else
 830                                 return cmd - data;
 831                 } else if (!strcasecmp(cmd, "bank")) {
 832                         if (value < 32)
 833                                 pvt->inject.bank = value;
 834                         else
 835                                 return cmd - data;
 836                 } else if (!strcasecmp(cmd, "page")) {
 837                         if (value <= 0xffff)
 838                                 pvt->inject.page = value;
 839                         else
 840                                 return cmd - data;
 841                 } else if (!strcasecmp(cmd, "col") ||
 842                            !strcasecmp(cmd, "column")) {
 843                         if (value <= 0x3fff)
 844                                 pvt->inject.col = value;
 845                         else
 846                                 return cmd - data;
 847                 }
 848         } while (1);
 849
 850         return count;
 851 }
 852
 853 static ssize_t i7core_inject_addrmatch_show(struct mem_ctl_info *mci,
 854                                               char *data)
 855 {
 856         struct i7core_pvt *pvt = mci->pvt_info;
 857         char channel[4], dimm[4], bank[4], rank[4], page[7], col[7];
 858
 859         if (pvt->inject.channel < 0)
 860                 sprintf(channel, "any");
 861         else
 862                 sprintf(channel, "%d", pvt->inject.channel);
 863         if (pvt->inject.dimm < 0)
 864                 sprintf(dimm, "any");
 865         else
 866                 sprintf(dimm, "%d", pvt->inject.dimm);
 867         if (pvt->inject.bank < 0)
 868                 sprintf(bank, "any");
 869         else
 870                 sprintf(bank, "%d", pvt->inject.bank);
 871         if (pvt->inject.rank < 0)
 872                 sprintf(rank, "any");
 873         else
 874                 sprintf(rank, "%d", pvt->inject.rank);
 875         if (pvt->inject.page < 0)
 876                 sprintf(page, "any");
 877         else
 878                 sprintf(page, "0x%04x", pvt->inject.page);
 879         if (pvt->inject.col < 0)
 880                 sprintf(col, "any");
 881         else
 882                 sprintf(col, "0x%04x", pvt->inject.col);
 883
 884         return sprintf(data, "channel: %s\ndimm: %s\nbank: %s\n"
 885                              "rank: %s\npage: %s\ncolumn: %s\n",
 886                        channel, dimm, bank, rank, page, col);
 887 }
 888
 889 static int write_and_test(struct pci_dev *dev, int where, u32 val)
 890 {
 891         u32 read;
 892         int count;
 893
 894         debugf0("setting pci %02x:%02x.%x reg=%02x value=%08x\n",
 895                 dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
 896                 where, val);
 897
 898         for (count = 0; count < 10; count++) {
 899                 if (count)
 900                         msleep(100);
 901                 pci_write_config_dword(dev, where, val);
 902                 pci_read_config_dword(dev, where, &read);
 903
 904                 if (read == val)
 905                         return 0;
 906         }
 907
 908         i7core_printk(KERN_ERR, "Error during set pci %02x:%02x.%x reg=%02x "
 909                 "write=%08x. Read=%08x\n",
 910                 dev->bus->number, PCI_SLOT(dev->devfn), PCI_FUNC(dev->devfn),
 911                 where, val, read);
 912
 913         return -EINVAL;
 914 }
 915
 916 /*
 917  * This routine prepares the Memory Controller for error injection.
 918  * The error will be injected when some process tries to write to the
 919  * memory that matches the given criteria.
 920  * The criteria can be set in terms of a mask where dimm, rank, bank, page
 921  * and col can be specified.
 922  * A -1 value for any of the mask items will make the MCU to ignore
 923  * that matching criteria for error injection.
 924  *
 925  * It should be noticed that the error will only happen after a write operation
 926  * on a memory that matches the condition. if REPEAT_EN is not enabled at
 927  * inject mask, then it will produce just one error. Otherwise, it will repeat
 928  * until the injectmask would be cleaned.
 929  *
 930  * FIXME: This routine assumes that MAXNUMDIMMS value of MC_MAX_DOD
 931  *    is reliable enough to check if the MC is using the
 932  *    three channels. However, this is not clear at the datasheet.
 933  */
 934 static ssize_t i7core_inject_enable_store(struct mem_ctl_info *mci,
 935                                        const char *data, size_t count)
 936 {
 937         struct i7core_pvt *pvt = mci->pvt_info;
 938         u32 injectmask;
 939         u64 mask = 0;
 940         int  rc;
 941         long enable;
 942
 943         if (!pvt->pci_ch[pvt->inject.socket][pvt->inject.channel][0])
 944                 return 0;
 945
 946         rc = strict_strtoul(data, 10, &enable);
 947         if ((rc < 0))
 948                 return 0;
 949
 950         if (enable) {
 951                 pvt->inject.enable = 1;
 952         } else {
 953                 disable_inject(mci);
 954                 return count;
 955         }
 956
 957         /* Sets pvt->inject.dimm mask */
 958         if (pvt->inject.dimm < 0)
 959                 mask |= 1L << 41;
 960         else {
 961                 if (pvt->channel[pvt->inject.socket][pvt->inject.channel].dimms > 2)
 962                         mask |= (pvt->inject.dimm & 0x3L) << 35;
 963                 else
 964                         mask |= (pvt->inject.dimm & 0x1L) << 36;
 965         }
 966
 967         /* Sets pvt->inject.rank mask */
 968         if (pvt->inject.rank < 0)
 969                 mask |= 1L << 40;
 970         else {
 971                 if (pvt->channel[pvt->inject.socket][pvt->inject.channel].dimms > 2)
 972                         mask |= (pvt->inject.rank & 0x1L) << 34;
 973                 else
 974                         mask |= (pvt->inject.rank & 0x3L) << 34;
 975         }
 976
 977         /* Sets pvt->inject.bank mask */
 978         if (pvt->inject.bank < 0)
 979                 mask |= 1L << 39;
 980         else
 981                 mask |= (pvt->inject.bank & 0x15L) << 30;
 982
 983         /* Sets pvt->inject.page mask */
 984         if (pvt->inject.page < 0)
 985                 mask |= 1L << 38;
 986         else
 987                 mask |= (pvt->inject.page & 0xffffL) << 14;
 988
 989         /* Sets pvt->inject.column mask */
 990         if (pvt->inject.col < 0)
 991                 mask |= 1L << 37;
 992         else
 993                 mask |= (pvt->inject.col & 0x3fffL);
 994
 995         /*
 996          * bit    0: REPEAT_EN
 997          * bits 1-2: MASK_HALF_CACHELINE
 998          * bit    3: INJECT_ECC
 999          * bit    4: INJECT_ADDR_PARITY
1000          */
1001
1002         injectmask = (pvt->inject.type & 1) |
1003                      (pvt->inject.section & 0x3) << 1 |
1004                      (pvt->inject.type & 0x6) << (3 - 1);
1005
1006         /* Unlock writes to registers - this register is write only */
1007         pci_write_config_dword(pvt->pci_noncore[pvt->inject.socket],
1008                                MC_CFG_CONTROL, 0x2);
1009
1010         write_and_test(pvt->pci_ch[pvt->inject.socket][pvt->inject.channel][0],
1011                                MC_CHANNEL_ADDR_MATCH, mask);
1012         write_and_test(pvt->pci_ch[pvt->inject.socket][pvt->inject.channel][0],
1013                                MC_CHANNEL_ADDR_MATCH + 4, mask >> 32L);
1014
1015         write_and_test(pvt->pci_ch[pvt->inject.socket][pvt->inject.channel][0],
1016                                MC_CHANNEL_ERROR_MASK, pvt->inject.eccmask);
1017
1018         write_and_test(pvt->pci_ch[pvt->inject.socket][pvt->inject.channel][0],
1019                                MC_CHANNEL_ERROR_INJECT, injectmask);
1020
1021         /*
1022          * This is something undocumented, based on my tests
1023          * Without writing 8 to this register, errors aren't injected. Not sure
1024          * why.
1025          */
1026         pci_write_config_dword(pvt->pci_noncore[pvt->inject.socket],
1027                                MC_CFG_CONTROL, 8);
1028
1029         debugf0("Error inject addr match 0x%016llx, ecc 0x%08x,"
1030                 " inject 0x%08x\n",
1031                 mask, pvt->inject.eccmask, injectmask);
1032
1033
1034         return count;
1035 }
1036
1037 static ssize_t i7core_inject_enable_show(struct mem_ctl_info *mci,
1038                                         char *data)
1039 {
1040         struct i7core_pvt *pvt = mci->pvt_info;
1041         u32 injectmask;
1042
1043         pci_read_config_dword(pvt->pci_ch[pvt->inject.socket][pvt->inject.channel][0],
1044                                MC_CHANNEL_ERROR_INJECT, &injectmask);
1045
1046         debugf0("Inject error read: 0x%018x\n", injectmask);
1047
1048         if (injectmask & 0x0c)
1049                 pvt->inject.enable = 1;
1050
1051         return sprintf(data, "%d\n", pvt->inject.enable);
1052 }
1053
1054 static ssize_t i7core_ce_regs_show(struct mem_ctl_info *mci, char *data)
1055 {
1056         unsigned i, j, count, total = 0;
1057         struct i7core_pvt *pvt = mci->pvt_info;
1058
1059         for (i = 0; i < pvt->sockets; i++) {
1060                 if (!pvt->ce_count_available[i]) {
1061                         count = sprintf(data, "socket 0 data unavailable\n");
1062                         continue;
1063                 }
1064                 if (!pvt->is_registered[i])
1065                         count = sprintf(data, "socket %d, dimm0: %lu\n"
1066                                               "dimm1: %lu\ndimm2: %lu\n",
1067                                         i,
1068                                         pvt->udimm_ce_count[i][0],
1069                                         pvt->udimm_ce_count[i][1],
1070                                         pvt->udimm_ce_count[i][2]);
1071                 else
1072                         for (j = 0; j < NUM_CHANS; j++) {
1073                                 count = sprintf(data, "socket %d, channel %d"
1074                                                 "dimm0: %lu\n"
1075                                                 "dimm1: %lu\ndimm2: %lu\n",
1076                                                 i, j,
1077                                                 pvt->rdimm_ce_count[i][j][0],
1078                                                 pvt->rdimm_ce_count[i][j][1],
1079                                                 pvt->rdimm_ce_count[i][j][2]);
1080                                         }
1081                 data  += count;
1082                 total += count;
1083         }
1084
1085         return total;
1086 }
1087
1088 /*
1089  * Sysfs struct
1090  */
1091 static struct mcidev_sysfs_attribute i7core_inj_attrs[] = {
1092         {
1093                 .attr = {
1094                         .name = "inject_socket",
1095                         .mode = (S_IRUGO | S_IWUSR)
1096                 },
1097                 .show  = i7core_inject_socket_show,
1098                 .store = i7core_inject_socket_store,
1099         }, {
1100                 .attr = {
1101                         .name = "inject_section",
1102                         .mode = (S_IRUGO | S_IWUSR)
1103                 },
1104                 .show  = i7core_inject_section_show,
1105                 .store = i7core_inject_section_store,
1106         }, {
1107                 .attr = {
1108                         .name = "inject_type",
1109                         .mode = (S_IRUGO | S_IWUSR)
1110                 },
1111                 .show  = i7core_inject_type_show,
1112                 .store = i7core_inject_type_store,
1113         }, {
1114                 .attr = {
1115                         .name = "inject_eccmask",
1116                         .mode = (S_IRUGO | S_IWUSR)
1117                 },
1118                 .show  = i7core_inject_eccmask_show,
1119                 .store = i7core_inject_eccmask_store,
1120         }, {
1121                 .attr = {
1122                         .name = "inject_addrmatch",
1123                         .mode = (S_IRUGO | S_IWUSR)
1124                 },
1125                 .show  = i7core_inject_addrmatch_show,
1126                 .store = i7core_inject_addrmatch_store,
1127         }, {
1128                 .attr = {
1129                         .name = "inject_enable",
1130                         .mode = (S_IRUGO | S_IWUSR)
1131                 },
1132                 .show  = i7core_inject_enable_show,
1133                 .store = i7core_inject_enable_store,
1134         }, {
1135                 .attr = {
1136                         .name = "corrected_error_counts",
1137                         .mode = (S_IRUGO | S_IWUSR)
1138                 },
1139                 .show  = i7core_ce_regs_show,
1140                 .store = NULL,
1141         },
1142 };
1143
1144 /****************************************************************************
1145         Device initialization routines: put/get, init/exit
1146  ****************************************************************************/
1147
1148 /*
1149  *      i7core_put_devices      'put' all the devices that we have
1150  *                              reserved via 'get'
1151  */
1152 static void i7core_put_devices(void)
1153 {
1154         int i, j;
1155
1156         for (i = 0; i < NUM_SOCKETS; i++)
1157                 for (j = 0; j < N_DEVS; j++)
1158                         pci_dev_put(pci_devs[j].pdev[i]);
1159 }
1160
1161 /*
1162  *      i7core_get_devices      Find and perform 'get' operation on the MCH's
1163  *                      device/functions we want to reference for this driver
1164  *
1165  *                      Need to 'get' device 16 func 1 and func 2
1166  */
1167 int i7core_get_onedevice(struct pci_dev **prev, int devno)
1168 {
1169         struct pci_dev *pdev = NULL;
1170         u8 bus = 0;
1171         u8 socket = 0;
1172
1173         pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
1174                               pci_devs[devno].dev_id, *prev);
1175
1176         /*
1177          * On Xeon 55xx, the Intel Quckpath Arch Generic Non-core pci buses
1178          * aren't announced by acpi. So, we need to use a legacy scan probing
1179          * to detect them
1180          */
1181         if (unlikely(!pdev && !devno && !prev)) {
1182                 pcibios_scan_specific_bus(254);
1183                 pcibios_scan_specific_bus(255);
1184
1185                 pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
1186                                       pci_devs[devno].dev_id, *prev);
1187         }
1188
1189         /*
1190          * On Xeon 55xx, the Intel Quckpath Arch Generic Non-core regs
1191          * is at addr 8086:2c40, instead of 8086:2c41. So, we need
1192          * to probe for the alternate address in case of failure
1193          */
1194         if (pci_devs[devno].dev_id == PCI_DEVICE_ID_INTEL_I7_NOCORE && !pdev)
1195                 pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
1196                                       PCI_DEVICE_ID_INTEL_I7_NOCORE_ALT, *prev);
1197
1198         if (!pdev) {
1199                 if (*prev) {
1200                         *prev = pdev;
1201                         return 0;
1202                 }
1203
1204                 /*
1205                  * Dev 3 function 2 only exists on chips with RDIMMs
1206                  * so, it is ok to not found it
1207                  */
1208                 if ((pci_devs[devno].dev == 3) && (pci_devs[devno].func == 2)) {
1209                         *prev = pdev;
1210                         return 0;
1211                 }
1212
1213                 i7core_printk(KERN_ERR,
1214                         "Device not found: dev %02x.%d PCI ID %04x:%04x\n",
1215                         pci_devs[devno].dev, pci_devs[devno].func,
1216                         PCI_VENDOR_ID_INTEL, pci_devs[devno].dev_id);
1217
1218                 /* End of list, leave */
1219                 return -ENODEV;
1220         }
1221         bus = pdev->bus->number;
1222
1223         if (bus == 0x3f)
1224                 socket = 0;
1225         else
1226                 socket = 255 - bus;
1227
1228         if (socket >= NUM_SOCKETS) {
1229                 i7core_printk(KERN_ERR,
1230                         "Unexpected socket for "
1231                         "dev %02x:%02x.%d PCI ID %04x:%04x\n",
1232                         bus, pci_devs[devno].dev, pci_devs[devno].func,
1233                         PCI_VENDOR_ID_INTEL, pci_devs[devno].dev_id);
1234                 pci_dev_put(pdev);
1235                 return -ENODEV;
1236         }
1237
1238         if (pci_devs[devno].pdev[socket]) {
1239                 i7core_printk(KERN_ERR,
1240                         "Duplicated device for "
1241                         "dev %02x:%02x.%d PCI ID %04x:%04x\n",
1242                         bus, pci_devs[devno].dev, pci_devs[devno].func,
1243                         PCI_VENDOR_ID_INTEL, pci_devs[devno].dev_id);
1244                 pci_dev_put(pdev);
1245                 return -ENODEV;
1246         }
1247
1248         pci_devs[devno].pdev[socket] = pdev;
1249
1250         /* Sanity check */
1251         if (unlikely(PCI_SLOT(pdev->devfn) != pci_devs[devno].dev ||
1252                         PCI_FUNC(pdev->devfn) != pci_devs[devno].func)) {
1253                 i7core_printk(KERN_ERR,
1254                         "Device PCI ID %04x:%04x "
1255                         "has dev %02x:%02x.%d instead of dev %02x:%02x.%d\n",
1256                         PCI_VENDOR_ID_INTEL, pci_devs[devno].dev_id,
1257                         bus, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
1258                         bus, pci_devs[devno].dev, pci_devs[devno].func);
1259                 return -ENODEV;
1260         }
1261
1262         /* Be sure that the device is enabled */
1263         if (unlikely(pci_enable_device(pdev) < 0)) {
1264                 i7core_printk(KERN_ERR,
1265                         "Couldn't enable "
1266                         "dev %02x:%02x.%d PCI ID %04x:%04x\n",
1267                         bus, pci_devs[devno].dev, pci_devs[devno].func,
1268                         PCI_VENDOR_ID_INTEL, pci_devs[devno].dev_id);
1269                 return -ENODEV;
1270         }
1271
1272         i7core_printk(KERN_INFO,
1273                         "Registered socket %d "
1274                         "dev %02x:%02x.%d PCI ID %04x:%04x\n",
1275                         socket, bus, pci_devs[devno].dev, pci_devs[devno].func,
1276                         PCI_VENDOR_ID_INTEL, pci_devs[devno].dev_id);
1277
1278         *prev = pdev;
1279
1280         return 0;
1281 }
1282
1283 static int i7core_get_devices(void)
1284 {
1285         int i;
1286         struct pci_dev *pdev = NULL;
1287
1288         for (i = 0; i < N_DEVS; i++) {
1289                 pdev = NULL;
1290                 do {
1291                         if (i7core_get_onedevice(&pdev, i) < 0) {
1292                                 i7core_put_devices();
1293                                 return -ENODEV;
1294                         }
1295                 } while (pdev);
1296         }
1297         return 0;
1298 }
1299
1300 static int mci_bind_devs(struct mem_ctl_info *mci)
1301 {
1302         struct i7core_pvt *pvt = mci->pvt_info;
1303         struct pci_dev *pdev;
1304         int i, j, func, slot;
1305
1306
1307         for (i = 0; i < pvt->sockets; i++) {
1308                 pvt->is_registered[i] = 0;
1309                 for (j = 0; j < N_DEVS; j++) {
1310                         pdev = pci_devs[j].pdev[i];
1311                         if (!pdev)
1312                                 continue;
1313
1314                         func = PCI_FUNC(pdev->devfn);
1315                         slot = PCI_SLOT(pdev->devfn);
1316                         if (slot == 3) {
1317                                 if (unlikely(func > MAX_MCR_FUNC))
1318                                         goto error;
1319                                 pvt->pci_mcr[i][func] = pdev;
1320                         } else if (likely(slot >= 4 && slot < 4 + NUM_CHANS)) {
1321                                 if (unlikely(func > MAX_CHAN_FUNC))
1322                                         goto error;
1323                                 pvt->pci_ch[i][slot - 4][func] = pdev;
1324                         } else if (!slot && !func)
1325                                 pvt->pci_noncore[i] = pdev;
1326                         else
1327                                 goto error;
1328
1329                         debugf0("Associated fn %d.%d, dev = %p, socket %d\n",
1330                                 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn),
1331                                 pdev, i);
1332
1333                         if (PCI_SLOT(pdev->devfn) == 3 &&
1334                            PCI_FUNC(pdev->devfn) == 2)
1335                                 pvt->is_registered[i] = 1;
1336                 }
1337         }
1338
1339         return 0;
1340
1341 error:
1342         i7core_printk(KERN_ERR, "Device %d, function %d "
1343                       "is out of the expected range\n",
1344                       slot, func);
1345         return -EINVAL;
1346 }
1347
1348 /****************************************************************************
1349                         Error check routines
1350  ****************************************************************************/
1351 static void i7core_rdimm_update_csrow(struct mem_ctl_info *mci, int socket,
1352                                          int chan, int dimm, int add)
1353 {
1354         char *msg;
1355         struct i7core_pvt *pvt = mci->pvt_info;
1356         int row = pvt->csrow_map[socket][chan][dimm], i;
1357
1358         for (i = 0; i < add; i++) {
1359                 msg = kasprintf(GFP_KERNEL, "Corrected error "
1360                                 "(Socket=%d channel=%d dimm=%d",
1361                                 socket, chan, dimm);
1362
1363                 edac_mc_handle_fbd_ce(mci, row, 0, msg);
1364                 kfree (msg);
1365         }
1366 }
1367
1368 static void i7core_rdimm_update_ce_count(struct mem_ctl_info *mci,
1369                         int socket, int chan, int new0, int new1, int new2)
1370 {
1371         struct i7core_pvt *pvt = mci->pvt_info;
1372         int add0 = 0, add1 = 0, add2 = 0;
1373         /* Updates CE counters if it is not the first time here */
1374         if (pvt->ce_count_available[socket]) {
1375                 /* Updates CE counters */
1376
1377                 add2 = new2 - pvt->rdimm_last_ce_count[socket][chan][2];
1378                 add1 = new1 - pvt->rdimm_last_ce_count[socket][chan][1];
1379                 add0 = new0 - pvt->rdimm_last_ce_count[socket][chan][0];
1380
1381                 if (add2 < 0)
1382                         add2 += 0x7fff;
1383                 pvt->rdimm_ce_count[socket][chan][2] += add2;
1384
1385                 if (add1 < 0)
1386                         add1 += 0x7fff;
1387                 pvt->rdimm_ce_count[socket][chan][1] += add1;
1388
1389                 if (add0 < 0)
1390                         add0 += 0x7fff;
1391                 pvt->rdimm_ce_count[socket][chan][0] += add0;
1392         } else
1393                 pvt->ce_count_available[socket] = 1;
1394
1395         /* Store the new values */
1396         pvt->rdimm_last_ce_count[socket][chan][2] = new2;
1397         pvt->rdimm_last_ce_count[socket][chan][1] = new1;
1398         pvt->rdimm_last_ce_count[socket][chan][0] = new0;
1399
1400         /*updated the edac core */
1401         if (add0 != 0)
1402                 i7core_rdimm_update_csrow(mci, socket, chan, 0, add0);
1403         if (add1 != 0)
1404                 i7core_rdimm_update_csrow(mci, socket, chan, 1, add1);
1405         if (add2 != 0)
1406                 i7core_rdimm_update_csrow(mci, socket, chan, 2, add2);
1407
1408 }
1409
1410 static void i7core_rdimm_check_mc_ecc_err(struct mem_ctl_info *mci, u8 socket)
1411 {
1412         struct i7core_pvt *pvt = mci->pvt_info;
1413         u32 rcv[3][2];
1414         int i, new0, new1, new2;
1415
1416         /*Read DEV 3: FUN 2:  MC_COR_ECC_CNT regs directly*/
1417         pci_read_config_dword(pvt->pci_mcr[socket][2], MC_COR_ECC_CNT_0,
1418                                                                 &rcv[0][0]);
1419         pci_read_config_dword(pvt->pci_mcr[socket][2], MC_COR_ECC_CNT_1,
1420                                                                 &rcv[0][1]);
1421         pci_read_config_dword(pvt->pci_mcr[socket][2], MC_COR_ECC_CNT_2,
1422                                                                 &rcv[1][0]);
1423         pci_read_config_dword(pvt->pci_mcr[socket][2], MC_COR_ECC_CNT_3,
1424                                                                 &rcv[1][1]);
1425         pci_read_config_dword(pvt->pci_mcr[socket][2], MC_COR_ECC_CNT_4,
1426                                                                 &rcv[2][0]);
1427         pci_read_config_dword(pvt->pci_mcr[socket][2], MC_COR_ECC_CNT_5,
1428                                                                 &rcv[2][1]);
1429         for (i = 0 ; i < 3; i++) {
1430                 debugf3("MC_COR_ECC_CNT%d = 0x%x; MC_COR_ECC_CNT%d = 0x%x\n",
1431                         (i * 2), rcv[i][0], (i * 2) + 1, rcv[i][1]);
1432                 /*if the channel has 3 dimms*/
1433                 if (pvt->channel[socket][i].dimms > 2) {
1434                         new0 = DIMM_BOT_COR_ERR(rcv[i][0]);
1435                         new1 = DIMM_TOP_COR_ERR(rcv[i][0]);
1436                         new2 = DIMM_BOT_COR_ERR(rcv[i][1]);
1437                 } else {
1438                         new0 = DIMM_TOP_COR_ERR(rcv[i][0]) +
1439                                         DIMM_BOT_COR_ERR(rcv[i][0]);
1440                         new1 = DIMM_TOP_COR_ERR(rcv[i][1]) +
1441                                         DIMM_BOT_COR_ERR(rcv[i][1]);
1442                         new2 = 0;
1443                 }
1444
1445                 i7core_rdimm_update_ce_count(mci, socket, i, new0, new1, new2);
1446         }
1447 }
1448
1449 /* This function is based on the device 3 function 4 registers as described on:
1450  * Intel Xeon Processor 5500 Series Datasheet Volume 2
1451  *      http://www.intel.com/Assets/PDF/datasheet/321322.pdf
1452  * also available at:
1453  *      http://www.arrownac.com/manufacturers/intel/s/nehalem/5500-datasheet-v2.pdf
1454  */
1455 static void i7core_udimm_check_mc_ecc_err(struct mem_ctl_info *mci, u8 socket)
1456 {
1457         struct i7core_pvt *pvt = mci->pvt_info;
1458         u32 rcv1, rcv0;
1459         int new0, new1, new2;
1460
1461         if (!pvt->pci_mcr[socket][4]) {
1462                 debugf0("%s MCR registers not found\n", __func__);
1463                 return;
1464         }
1465
1466         /* Corrected test errors */
1467         pci_read_config_dword(pvt->pci_mcr[socket][4], MC_TEST_ERR_RCV1, &rcv1);
1468         pci_read_config_dword(pvt->pci_mcr[socket][4], MC_TEST_ERR_RCV0, &rcv0);
1469
1470         /* Store the new values */
1471         new2 = DIMM2_COR_ERR(rcv1);
1472         new1 = DIMM1_COR_ERR(rcv0);
1473         new0 = DIMM0_COR_ERR(rcv0);
1474
1475         /* Updates CE counters if it is not the first time here */
1476         if (pvt->ce_count_available[socket]) {
1477                 /* Updates CE counters */
1478                 int add0, add1, add2;
1479
1480                 add2 = new2 - pvt->udimm_last_ce_count[socket][2];
1481                 add1 = new1 - pvt->udimm_last_ce_count[socket][1];
1482                 add0 = new0 - pvt->udimm_last_ce_count[socket][0];
1483
1484                 if (add2 < 0)
1485                         add2 += 0x7fff;
1486                 pvt->udimm_ce_count[socket][2] += add2;
1487
1488                 if (add1 < 0)
1489                         add1 += 0x7fff;
1490                 pvt->udimm_ce_count[socket][1] += add1;
1491
1492                 if (add0 < 0)
1493                         add0 += 0x7fff;
1494                 pvt->udimm_ce_count[socket][0] += add0;
1495
1496                 if (add0 | add1 | add2)
1497                         i7core_printk(KERN_ERR, "New Corrected error(s): "
1498                                       "dimm0: +%d, dimm1: +%d, dimm2 +%d\n",
1499                                       add0, add1, add2);
1500         } else
1501                 pvt->ce_count_available[socket] = 1;
1502
1503         /* Store the new values */
1504         pvt->udimm_last_ce_count[socket][2] = new2;
1505         pvt->udimm_last_ce_count[socket][1] = new1;
1506         pvt->udimm_last_ce_count[socket][0] = new0;
1507 }
1508
1509 /*
1510  * According with tables E-11 and E-12 of chapter E.3.3 of Intel 64 and IA-32
1511  * Architectures Software Developer’s Manual Volume 3B.
1512  * Nehalem are defined as family 0x06, model 0x1a
1513  *
1514  * The MCA registers used here are the following ones:
1515  *     struct mce field MCA Register
1516  *     m->status        MSR_IA32_MC8_STATUS
1517  *     m->addr          MSR_IA32_MC8_ADDR
1518  *     m->misc          MSR_IA32_MC8_MISC
1519  * In the case of Nehalem, the error information is masked at .status and .misc
1520  * fields
1521  */
1522 static void i7core_mce_output_error(struct mem_ctl_info *mci,
1523                                     struct mce *m)
1524 {
1525         struct i7core_pvt *pvt = mci->pvt_info;
1526         char *type, *optype, *err, *msg;
1527         unsigned long error = m->status & 0x1ff0000l;
1528         u32 optypenum = (m->status >> 4) & 0x07;
1529         u32 core_err_cnt = (m->status >> 38) && 0x7fff;
1530         u32 dimm = (m->misc >> 16) & 0x3;
1531         u32 channel = (m->misc >> 18) & 0x3;
1532         u32 syndrome = m->misc >> 32;
1533         u32 errnum = find_first_bit(&error, 32);
1534         int csrow;
1535 #ifdef CONFIG_SMP
1536         u32 socket_id = cpu_data[m->cpu].phys_proc_id;
1537 #else
1538         u32 socket_id = 0;
1539 #endif
1540
1541         if (m->mcgstatus & 1)
1542                 type = "FATAL";
1543         else
1544                 type = "NON_FATAL";
1545
1546         switch (optypenum) {
1547         case 0:
1548                 optype = "generic undef request";
1549                 break;
1550         case 1:
1551                 optype = "read error";
1552                 break;
1553         case 2:
1554                 optype = "write error";
1555                 break;
1556         case 3:
1557                 optype = "addr/cmd error";
1558                 break;
1559         case 4:
1560                 optype = "scrubbing error";
1561                 break;
1562         default:
1563                 optype = "reserved";
1564                 break;
1565         }
1566
1567         switch (errnum) {
1568         case 16:
1569                 err = "read ECC error";
1570                 break;
1571         case 17:
1572                 err = "RAS ECC error";
1573                 break;
1574         case 18:
1575                 err = "write parity error";
1576                 break;
1577         case 19:
1578                 err = "redundacy loss";
1579                 break;
1580         case 20:
1581                 err = "reserved";
1582                 break;
1583         case 21:
1584                 err = "memory range error";
1585                 break;
1586         case 22:
1587                 err = "RTID out of range";
1588                 break;
1589         case 23:
1590                 err = "address parity error";
1591                 break;
1592         case 24:
1593                 err = "byte enable parity error";
1594                 break;
1595         default:
1596                 err = "unknown";
1597         }
1598
1599         /* FIXME: should convert addr into bank and rank information */
1600         msg = kasprintf(GFP_ATOMIC,
1601                 "%s (addr = 0x%08llx, socket=%d, Dimm=%d, Channel=%d, "
1602                 "syndrome=0x%08x, count=%d, Err=%08llx:%08llx (%s: %s))\n",
1603                 type, (long long) m->addr, socket_id, dimm, channel,
1604                 syndrome, core_err_cnt, (long long)m->status,
1605                 (long long)m->misc, optype, err);
1606
1607         debugf0("%s", msg);
1608
1609         if (socket_id < NUM_SOCKETS)
1610                 csrow = pvt->csrow_map[socket_id][channel][dimm];
1611         else
1612                 csrow = -1;
1613
1614         /* Call the helper to output message */
1615         if (m->mcgstatus & 1)
1616                 edac_mc_handle_fbd_ue(mci, csrow, 0,
1617                                 0 /* FIXME: should be channel here */, msg);
1618         else if (!pvt->is_registered[socket_id])
1619                 edac_mc_handle_fbd_ce(mci, csrow,
1620                                 0 /* FIXME: should be channel here */, msg);
1621
1622         kfree(msg);
1623 }
1624
1625 /*
1626  *      i7core_check_error      Retrieve and process errors reported by the
1627  *                              hardware. Called by the Core module.
1628  */
1629 static void i7core_check_error(struct mem_ctl_info *mci)
1630 {
1631         struct i7core_pvt *pvt = mci->pvt_info;
1632         int i;
1633         unsigned count = 0;
1634         struct mce *m = NULL;
1635         unsigned long flags;
1636
1637         /* Copy all mce errors into a temporary buffer */
1638         spin_lock_irqsave(&pvt->mce_lock, flags);
1639         if (pvt->mce_count) {
1640                 m = kmalloc(sizeof(*m) * pvt->mce_count, GFP_ATOMIC);
1641                 if (m) {
1642                         count = pvt->mce_count;
1643                         memcpy(m, &pvt->mce_entry, sizeof(*m) * count);
1644                 }
1645                 pvt->mce_count = 0;
1646         }
1647         spin_unlock_irqrestore(&pvt->mce_lock, flags);
1648
1649         /* proccess mcelog errors */
1650         for (i = 0; i < count; i++)
1651                 i7core_mce_output_error(mci, &m[i]);
1652
1653         kfree(m);
1654
1655         /* check memory count errors */
1656         for (i = 0; i < pvt->sockets; i++)
1657                 if (!pvt->is_registered[i])
1658                         i7core_udimm_check_mc_ecc_err(mci, i);
1659                 else
1660                         i7core_rdimm_check_mc_ecc_err(mci, i);
1661 }
1662
1663 /*
1664  * i7core_mce_check_error       Replicates mcelog routine to get errors
1665  *                              This routine simply queues mcelog errors, and
1666  *                              return. The error itself should be handled later
1667  *                              by i7core_check_error.
1668  */
1669 static int i7core_mce_check_error(void *priv, struct mce *mce)
1670 {
1671         struct mem_ctl_info *mci = priv;
1672         struct i7core_pvt *pvt = mci->pvt_info;
1673         unsigned long flags;
1674
1675         /*
1676          * Just let mcelog handle it if the error is
1677          * outside the memory controller
1678          */
1679         if (((mce->status & 0xffff) >> 7) != 1)
1680                 return 0;
1681
1682         /* Bank 8 registers are the only ones that we know how to handle */
1683         if (mce->bank != 8)
1684                 return 0;
1685
1686         spin_lock_irqsave(&pvt->mce_lock, flags);
1687         if (pvt->mce_count < MCE_LOG_LEN) {
1688                 memcpy(&pvt->mce_entry[pvt->mce_count], mce, sizeof(*mce));
1689                 pvt->mce_count++;
1690         }
1691         spin_unlock_irqrestore(&pvt->mce_lock, flags);
1692
1693         /* Handle fatal errors immediately */
1694         if (mce->mcgstatus & 1)
1695                 i7core_check_error(mci);
1696
1697         /* Advice mcelog that the error were handled */
1698         return 1;
1699 }
1700
1701 /*
1702  *      i7core_probe    Probe for ONE instance of device to see if it is
1703  *                      present.
1704  *      return:
1705  *              0 for FOUND a device
1706  *              < 0 for error code
1707  */
1708 static int __devinit i7core_probe(struct pci_dev *pdev,
1709                                   const struct pci_device_id *id)
1710 {
1711         struct mem_ctl_info *mci;
1712         struct i7core_pvt *pvt;
1713         int num_channels = 0;
1714         int num_csrows = 0;
1715         int csrow = 0;
1716         int dev_idx = id->driver_data;
1717         int rc, i;
1718         u8 sockets;
1719
1720         if (unlikely(dev_idx >= ARRAY_SIZE(i7core_devs)))
1721                 return -EINVAL;
1722
1723         /* get the pci devices we want to reserve for our use */
1724         rc = i7core_get_devices();
1725         if (unlikely(rc < 0))
1726                 return rc;
1727
1728         sockets = 1;
1729         for (i = NUM_SOCKETS - 1; i > 0; i--)
1730                 if (pci_devs[0].pdev[i]) {
1731                         sockets = i + 1;
1732                         break;
1733                 }
1734
1735         for (i = 0; i < sockets; i++) {
1736                 int channels;
1737                 int csrows;
1738
1739                 /* Check the number of active and not disabled channels */
1740                 rc = i7core_get_active_channels(i, &channels, &csrows);
1741                 if (unlikely(rc < 0))
1742                         goto fail0;
1743
1744                 num_channels += channels;
1745                 num_csrows += csrows;
1746         }
1747
1748         /* allocate a new MC control structure */
1749         mci = edac_mc_alloc(sizeof(*pvt), num_csrows, num_channels, 0);
1750         if (unlikely(!mci)) {
1751                 rc = -ENOMEM;
1752                 goto fail0;
1753         }
1754
1755         debugf0("MC: " __FILE__ ": %s(): mci = %p\n", __func__, mci);
1756
1757         mci->dev = &pdev->dev;  /* record ptr to the generic device */
1758         pvt = mci->pvt_info;
1759         memset(pvt, 0, sizeof(*pvt));
1760         pvt->sockets = sockets;
1761         mci->mc_idx = 0;
1762
1763         /*
1764          * FIXME: how to handle RDDR3 at MCI level? It is possible to have
1765          * Mixed RDDR3/UDDR3 with Nehalem, provided that they are on different
1766          * memory channels
1767          */
1768         mci->mtype_cap = MEM_FLAG_DDR3;
1769         mci->edac_ctl_cap = EDAC_FLAG_NONE;
1770         mci->edac_cap = EDAC_FLAG_NONE;
1771         mci->mod_name = "i7core_edac.c";
1772         mci->mod_ver = I7CORE_REVISION;
1773         mci->ctl_name = i7core_devs[dev_idx].ctl_name;
1774         mci->dev_name = pci_name(pdev);
1775         mci->ctl_page_to_phys = NULL;
1776         mci->mc_driver_sysfs_attributes = i7core_inj_attrs;
1777         /* Set the function pointer to an actual operation function */
1778         mci->edac_check = i7core_check_error;
1779
1780         /* Store pci devices at mci for faster access */
1781         rc = mci_bind_devs(mci);
1782         if (unlikely(rc < 0))
1783                 goto fail1;
1784
1785         /* Get dimm basic config */
1786         for (i = 0; i < sockets; i++)
1787                 get_dimm_config(mci, &csrow, i);
1788
1789         /* add this new MC control structure to EDAC's list of MCs */
1790         if (unlikely(edac_mc_add_mc(mci))) {
1791                 debugf0("MC: " __FILE__
1792                         ": %s(): failed edac_mc_add_mc()\n", __func__);
1793                 /* FIXME: perhaps some code should go here that disables error
1794                  * reporting if we just enabled it
1795                  */
1796
1797                 rc = -EINVAL;
1798                 goto fail1;
1799         }
1800
1801         /* allocating generic PCI control info */
1802         i7core_pci = edac_pci_create_generic_ctl(&pdev->dev, EDAC_MOD_STR);
1803         if (unlikely(!i7core_pci)) {
1804                 printk(KERN_WARNING
1805                         "%s(): Unable to create PCI control\n",
1806                         __func__);
1807                 printk(KERN_WARNING
1808                         "%s(): PCI error report via EDAC not setup\n",
1809                         __func__);
1810         }
1811
1812         /* Default error mask is any memory */
1813         pvt->inject.channel = 0;
1814         pvt->inject.dimm = -1;
1815         pvt->inject.rank = -1;
1816         pvt->inject.bank = -1;
1817         pvt->inject.page = -1;
1818         pvt->inject.col = -1;
1819
1820         /* Registers on edac_mce in order to receive memory errors */
1821         pvt->edac_mce.priv = mci;
1822         pvt->edac_mce.check_error = i7core_mce_check_error;
1823         spin_lock_init(&pvt->mce_lock);
1824
1825         rc = edac_mce_register(&pvt->edac_mce);
1826         if (unlikely(rc < 0)) {
1827                 debugf0("MC: " __FILE__
1828                         ": %s(): failed edac_mce_register()\n", __func__);
1829                 goto fail1;
1830         }
1831
1832         i7core_printk(KERN_INFO, "Driver loaded.\n");
1833
1834         return 0;
1835
1836 fail1:
1837         edac_mc_free(mci);
1838
1839 fail0:
1840         i7core_put_devices();
1841         return rc;
1842 }
1843
1844 /*
1845  *      i7core_remove   destructor for one instance of device
1846  *
1847  */
1848 static void __devexit i7core_remove(struct pci_dev *pdev)
1849 {
1850         struct mem_ctl_info *mci;
1851         struct i7core_pvt *pvt;
1852
1853         debugf0(__FILE__ ": %s()\n", __func__);
1854
1855         if (i7core_pci)
1856                 edac_pci_release_generic_ctl(i7core_pci);
1857
1858
1859         mci = edac_mc_del_mc(&pdev->dev);
1860         if (!mci)
1861                 return;
1862
1863         /* Unregisters on edac_mce in order to receive memory errors */
1864         pvt = mci->pvt_info;
1865         edac_mce_unregister(&pvt->edac_mce);
1866
1867         /* retrieve references to resources, and free those resources */
1868         i7core_put_devices();
1869
1870         edac_mc_free(mci);
1871 }
1872
1873 MODULE_DEVICE_TABLE(pci, i7core_pci_tbl);
1874
1875 /*
1876  *      i7core_driver   pci_driver structure for this module
1877  *
1878  */
1879 static struct pci_driver i7core_driver = {
1880         .name     = "i7core_edac",
1881         .probe    = i7core_probe,
1882         .remove   = __devexit_p(i7core_remove),
1883         .id_table = i7core_pci_tbl,
1884 };
1885
1886 /*
1887  *      i7core_init             Module entry function
1888  *                      Try to initialize this module for its devices
1889  */
1890 static int __init i7core_init(void)
1891 {
1892         int pci_rc;
1893
1894         debugf2("MC: " __FILE__ ": %s()\n", __func__);
1895
1896         /* Ensure that the OPSTATE is set correctly for POLL or NMI */
1897         opstate_init();
1898
1899         pci_rc = pci_register_driver(&i7core_driver);
1900
1901         if (pci_rc >= 0)
1902                 return 0;
1903
1904         i7core_printk(KERN_ERR, "Failed to register device with error %d.\n",
1905                       pci_rc);
1906
1907         return pci_rc;
1908 }
1909
1910 /*
1911  *      i7core_exit()   Module exit function
1912  *                      Unregister the driver
1913  */
1914 static void __exit i7core_exit(void)
1915 {
1916         debugf2("MC: " __FILE__ ": %s()\n", __func__);
1917         pci_unregister_driver(&i7core_driver);
1918 }
1919
1920 module_init(i7core_init);
1921 module_exit(i7core_exit);
1922
1923 MODULE_LICENSE("GPL");
1924 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
1925 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com)");
1926 MODULE_DESCRIPTION("MC Driver for Intel i7 Core memory controllers - "
1927                    I7CORE_REVISION);
1928
1929 module_param(edac_op_state, int, 0444);
1930 MODULE_PARM_DESC(edac_op_state, "EDAC Error Reporting state: 0=Poll,1=NMI");