SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/edac/i82860_edac.c

   1 /*
   2  * Intel 82860 Memory Controller kernel module
   3  * (C) 2005 Red Hat (http://www.redhat.com)
   4  * This file may be distributed under the terms of the
   5  * GNU General Public License.
   6  *
   7  * Written by Ben Woodard <woodard@redhat.com>
   8  * shamelessly copied from and based upon the edac_i82875 driver
   9  * by Thayne Harbaugh of Linux Networx. (http://lnxi.com)
  10  */
  11
  12 #include <linux/config.h>
  13 #include <linux/module.h>
  14 #include <linux/init.h>
  15 #include <linux/pci.h>
  16 #include <linux/pci_ids.h>
  17 #include <linux/slab.h>
  18 #include "edac_mc.h"
  19
  20 #define  I82860_REVISION " Ver: 2.0.0 " __DATE__
  21
  22 #define i82860_printk(level, fmt, arg...) \
  23         edac_printk(level, "i82860", fmt, ##arg)
  24
  25 #define i82860_mc_printk(mci, level, fmt, arg...) \
  26         edac_mc_chipset_printk(mci, level, "i82860", fmt, ##arg)
  27
  28 #ifndef PCI_DEVICE_ID_INTEL_82860_0
  29 #define PCI_DEVICE_ID_INTEL_82860_0     0x2531
  30 #endif                          /* PCI_DEVICE_ID_INTEL_82860_0 */
  31
  32 #define I82860_MCHCFG 0x50
  33 #define I82860_GBA 0x60
  34 #define I82860_GBA_MASK 0x7FF
  35 #define I82860_GBA_SHIFT 24
  36 #define I82860_ERRSTS 0xC8
  37 #define I82860_EAP 0xE4
  38 #define I82860_DERRCTL_STS 0xE2
  39
  40 enum i82860_chips {
  41         I82860 = 0,
  42 };
  43
  44 struct i82860_dev_info {
  45         const char *ctl_name;
  46 };
  47
  48 struct i82860_error_info {
  49         u16 errsts;
  50         u32 eap;
  51         u16 derrsyn;
  52         u16 errsts2;
  53 };
  54
  55 static const struct i82860_dev_info i82860_devs[] = {
  56         [I82860] = {
  57                 .ctl_name = "i82860"
  58         },
  59 };
  60
  61 static struct pci_dev *mci_pdev = NULL; /* init dev: in case that AGP code
  62                                          * has already registered driver
  63                                          */
  64
  65 static void i82860_get_error_info(struct mem_ctl_info *mci,
  66                 struct i82860_error_info *info)
  67 {
  68         struct pci_dev *pdev;
  69
  70         pdev = to_pci_dev(mci->dev);
  71
  72         /*
  73          * This is a mess because there is no atomic way to read all the
  74          * registers at once and the registers can transition from CE being
  75          * overwritten by UE.
  76          */
  77         pci_read_config_word(pdev, I82860_ERRSTS, &info->errsts);
  78         pci_read_config_dword(pdev, I82860_EAP, &info->eap);
  79         pci_read_config_word(pdev, I82860_DERRCTL_STS, &info->derrsyn);
  80         pci_read_config_word(pdev, I82860_ERRSTS, &info->errsts2);
  81
  82         pci_write_bits16(pdev, I82860_ERRSTS, 0x0003, 0x0003);
  83
  84         /*
  85          * If the error is the same for both reads then the first set of reads
  86          * is valid.  If there is a change then there is a CE no info and the
  87          * second set of reads is valid and should be UE info.
  88          */
  89         if (!(info->errsts2 & 0x0003))
  90                 return;
  91
  92         if ((info->errsts ^ info->errsts2) & 0x0003) {
  93                 pci_read_config_dword(pdev, I82860_EAP, &info->eap);
  94                 pci_read_config_word(pdev, I82860_DERRCTL_STS,
  95                                 &info->derrsyn);
  96         }
  97 }
  98
  99 static int i82860_process_error_info(struct mem_ctl_info *mci,
 100                 struct i82860_error_info *info, int handle_errors)
 101 {
 102         int row;
 103
 104         if (!(info->errsts2 & 0x0003))
 105                 return 0;
 106
 107         if (!handle_errors)
 108                 return 1;
 109
 110         if ((info->errsts ^ info->errsts2) & 0x0003) {
 111                 edac_mc_handle_ce_no_info(mci, "UE overwrote CE");
 112                 info->errsts = info->errsts2;
 113         }
 114
 115         info->eap >>= PAGE_SHIFT;
 116         row = edac_mc_find_csrow_by_page(mci, info->eap);
 117
 118         if (info->errsts & 0x0002)
 119                 edac_mc_handle_ue(mci, info->eap, 0, row, "i82860 UE");
 120         else
 121                 edac_mc_handle_ce(mci, info->eap, 0, info->derrsyn, row, 0,
 122                                 "i82860 UE");
 123
 124         return 1;
 125 }
 126
 127 static void i82860_check(struct mem_ctl_info *mci)
 128 {
 129         struct i82860_error_info info;
 130
 131         debugf1("MC%d: %s()\n", mci->mc_idx, __func__);
 132         i82860_get_error_info(mci, &info);
 133         i82860_process_error_info(mci, &info, 1);
 134 }
 135
 136 static int i82860_probe1(struct pci_dev *pdev, int dev_idx)
 137 {
 138         int rc = -ENODEV;
 139         int index;
 140         struct mem_ctl_info *mci = NULL;
 141         unsigned long last_cumul_size;
 142         struct i82860_error_info discard;
 143
 144         u16 mchcfg_ddim;        /* DRAM Data Integrity Mode 0=none,2=edac */
 145
 146         /* RDRAM has channels but these don't map onto the abstractions that
 147            edac uses.
 148            The device groups from the GRA registers seem to map reasonably
 149            well onto the notion of a chip select row.
 150            There are 16 GRA registers and since the name is associated with
 151            the channel and the GRA registers map to physical devices so we are
 152            going to make 1 channel for group.
 153          */
 154         mci = edac_mc_alloc(0, 16, 1);
 155
 156         if (!mci)
 157                 return -ENOMEM;
 158
 159         debugf3("%s(): init mci\n", __func__);
 160         mci->dev = &pdev->dev;
 161         mci->mtype_cap = MEM_FLAG_DDR;
 162
 163         mci->edac_ctl_cap = EDAC_FLAG_NONE | EDAC_FLAG_SECDED;
 164         /* I"m not sure about this but I think that all RDRAM is SECDED */
 165         mci->edac_cap = EDAC_FLAG_SECDED;
 166         /* adjust FLAGS */
 167
 168         mci->mod_name = EDAC_MOD_STR;
 169         mci->mod_ver = I82860_REVISION;
 170         mci->ctl_name = i82860_devs[dev_idx].ctl_name;
 171         mci->edac_check = i82860_check;
 172         mci->ctl_page_to_phys = NULL;
 173
 174         pci_read_config_word(pdev, I82860_MCHCFG, &mchcfg_ddim);
 175         mchcfg_ddim = mchcfg_ddim & 0x180;
 176
 177         /*
 178          * The group row boundary (GRA) reg values are boundary address
 179          * for each DRAM row with a granularity of 16MB.  GRA regs are
 180          * cumulative; therefore GRA15 will contain the total memory contained
 181          * in all eight rows.
 182          */
 183         for (last_cumul_size = index = 0; index < mci->nr_csrows; index++) {
 184                 u16 value;
 185                 u32 cumul_size;
 186                 struct csrow_info *csrow = &mci->csrows[index];
 187
 188                 pci_read_config_word(pdev, I82860_GBA + index * 2,
 189                                 &value);
 190
 191                 cumul_size = (value & I82860_GBA_MASK) <<
 192                     (I82860_GBA_SHIFT - PAGE_SHIFT);
 193                 debugf3("%s(): (%d) cumul_size 0x%x\n", __func__, index,
 194                         cumul_size);
 195
 196                 if (cumul_size == last_cumul_size)
 197                         continue;       /* not populated */
 198
 199                 csrow->first_page = last_cumul_size;
 200                 csrow->last_page = cumul_size - 1;
 201                 csrow->nr_pages = cumul_size - last_cumul_size;
 202                 last_cumul_size = cumul_size;
 203                 csrow->grain = 1 << 12;  /* I82860_EAP has 4KiB reolution */
 204                 csrow->mtype = MEM_RMBS;
 205                 csrow->dtype = DEV_UNKNOWN;
 206                 csrow->edac_mode = mchcfg_ddim ? EDAC_SECDED : EDAC_NONE;
 207         }
 208
 209         i82860_get_error_info(mci, &discard);  /* clear counters */
 210
 211         if (edac_mc_add_mc(mci)) {
 212                 debugf3("%s(): failed edac_mc_add_mc()\n", __func__);
 213                 edac_mc_free(mci);
 214         } else {
 215                 /* get this far and it's successful */
 216                 debugf3("%s(): success\n", __func__);
 217                 rc = 0;
 218         }
 219
 220         return rc;
 221 }
 222
 223 /* returns count (>= 0), or negative on error */
 224 static int __devinit i82860_init_one(struct pci_dev *pdev,
 225                 const struct pci_device_id *ent)
 226 {
 227         int rc;
 228
 229         debugf0("%s()\n", __func__);
 230         i82860_printk(KERN_INFO, "i82860 init one\n");
 231
 232         if (pci_enable_device(pdev) < 0)
 233                 return -EIO;
 234
 235         rc = i82860_probe1(pdev, ent->driver_data);
 236
 237         if (rc == 0)
 238                 mci_pdev = pci_dev_get(pdev);
 239
 240         return rc;
 241 }
 242
 243 static void __devexit i82860_remove_one(struct pci_dev *pdev)
 244 {
 245         struct mem_ctl_info *mci;
 246
 247         debugf0("%s()\n", __func__);
 248
 249         if ((mci = edac_mc_del_mc(&pdev->dev)) == NULL)
 250                 return;
 251
 252         edac_mc_free(mci);
 253 }
 254
 255 static const struct pci_device_id i82860_pci_tbl[] __devinitdata = {
 256         {
 257                 PCI_VEND_DEV(INTEL, 82860_0), PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 258                 I82860
 259         },
 260         {
 261                 0,
 262         }       /* 0 terminated list. */
 263 };
 264
 265 MODULE_DEVICE_TABLE(pci, i82860_pci_tbl);
 266
 267 static struct pci_driver i82860_driver = {
 268         .name = EDAC_MOD_STR,
 269         .probe = i82860_init_one,
 270         .remove = __devexit_p(i82860_remove_one),
 271         .id_table = i82860_pci_tbl,
 272 };
 273
 274 static int __init i82860_init(void)
 275 {
 276         int pci_rc;
 277
 278         debugf3("%s()\n", __func__);
 279
 280         if ((pci_rc = pci_register_driver(&i82860_driver)) < 0)
 281                 goto fail0;
 282
 283         if (!mci_pdev) {
 284                 mci_pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
 285                                         PCI_DEVICE_ID_INTEL_82860_0, NULL);
 286
 287                 if (mci_pdev == NULL) {
 288                         debugf0("860 pci_get_device fail\n");
 289                         pci_rc = -ENODEV;
 290                         goto fail1;
 291                 }
 292
 293                 pci_rc = i82860_init_one(mci_pdev, i82860_pci_tbl);
 294
 295                 if (pci_rc < 0) {
 296                         debugf0("860 init fail\n");
 297                         pci_rc = -ENODEV;
 298                         goto fail1;
 299                 }
 300         }
 301
 302         return 0;
 303
 304 fail1:
 305         pci_unregister_driver(&i82860_driver);
 306
 307 fail0:
 308         if (mci_pdev != NULL)
 309                 pci_dev_put(mci_pdev);
 310
 311         return pci_rc;
 312 }
 313
 314 static void __exit i82860_exit(void)
 315 {
 316         debugf3("%s()\n", __func__);
 317
 318         pci_unregister_driver(&i82860_driver);
 319
 320         if (mci_pdev != NULL)
 321                 pci_dev_put(mci_pdev);
 322 }
 323
 324 module_init(i82860_init);
 325 module_exit(i82860_exit);
 326
 327 MODULE_LICENSE("GPL");
 328 MODULE_AUTHOR("Red Hat Inc. (http://www.redhat.com) "
 329         "Ben Woodard <woodard@redhat.com>");
 330 MODULE_DESCRIPTION("ECC support for Intel 82860 memory hub controllers");