drivers/edac/edac_mc.c

   1 /*
   2  * edac_mc kernel module
   3  * (C) 2005, 2006 Linux Networx (http://lnxi.com)
   4  * This file may be distributed under the terms of the
   5  * GNU General Public License.
   6  *
   7  * Written by Thayne Harbaugh
   8  * Based on work by Dan Hollis <goemon at anime dot net> and others.
   9  *      http://www.anime.net/~goemon/linux-ecc/
  10  *
  11  * Modified by Dave Peterson and Doug Thompson
  12  *
  13  */
  14
  15 #include <linux/module.h>
  16 #include <linux/proc_fs.h>
  17 #include <linux/kernel.h>
  18 #include <linux/types.h>
  19 #include <linux/smp.h>
  20 #include <linux/init.h>
  21 #include <linux/sysctl.h>
  22 #include <linux/highmem.h>
  23 #include <linux/timer.h>
  24 #include <linux/slab.h>
  25 #include <linux/jiffies.h>
  26 #include <linux/spinlock.h>
  27 #include <linux/list.h>
  28 #include <linux/sysdev.h>
  29 #include <linux/ctype.h>
  30 #include <linux/edac.h>
  31 #include <asm/uaccess.h>
  32 #include <asm/page.h>
  33 #include <asm/edac.h>
  34 #include "edac_core.h"
  35 #include "edac_module.h"
  36
  37 /* lock to memory controller's control array */
  38 static DEFINE_MUTEX(mem_ctls_mutex);
  39 static LIST_HEAD(mc_devices);
  40
  41 #ifdef CONFIG_EDAC_DEBUG
  42
  43 static void edac_mc_dump_channel(struct channel_info *chan)
  44 {
  45         debugf4("\tchannel = %p\n", chan);
  46         debugf4("\tchannel->chan_idx = %d\n", chan->chan_idx);
  47         debugf4("\tchannel->ce_count = %d\n", chan->ce_count);
  48         debugf4("\tchannel->label = '%s'\n", chan->label);
  49         debugf4("\tchannel->csrow = %p\n\n", chan->csrow);
  50 }
  51
  52 static void edac_mc_dump_csrow(struct csrow_info *csrow)
  53 {
  54         debugf4("\tcsrow = %p\n", csrow);
  55         debugf4("\tcsrow->csrow_idx = %d\n", csrow->csrow_idx);
  56         debugf4("\tcsrow->first_page = 0x%lx\n", csrow->first_page);
  57         debugf4("\tcsrow->last_page = 0x%lx\n", csrow->last_page);
  58         debugf4("\tcsrow->page_mask = 0x%lx\n", csrow->page_mask);
  59         debugf4("\tcsrow->nr_pages = 0x%x\n", csrow->nr_pages);
  60         debugf4("\tcsrow->nr_channels = %d\n", csrow->nr_channels);
  61         debugf4("\tcsrow->channels = %p\n", csrow->channels);
  62         debugf4("\tcsrow->mci = %p\n\n", csrow->mci);
  63 }
  64
  65 static void edac_mc_dump_mci(struct mem_ctl_info *mci)
  66 {
  67         debugf3("\tmci = %p\n", mci);
  68         debugf3("\tmci->mtype_cap = %lx\n", mci->mtype_cap);
  69         debugf3("\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap);
  70         debugf3("\tmci->edac_cap = %lx\n", mci->edac_cap);
  71         debugf4("\tmci->edac_check = %p\n", mci->edac_check);
  72         debugf3("\tmci->nr_csrows = %d, csrows = %p\n",
  73                 mci->nr_csrows, mci->csrows);
  74         debugf3("\tdev = %p\n", mci->dev);
  75         debugf3("\tmod_name:ctl_name = %s:%s\n", mci->mod_name, mci->ctl_name);
  76         debugf3("\tpvt_info = %p\n\n", mci->pvt_info);
  77 }
  78
  79 #endif                          /* CONFIG_EDAC_DEBUG */
  80
  81 /*
  82  * keep those in sync with the enum mem_type
  83  */
  84 const char *edac_mem_types[] = {
  85         "Empty csrow",
  86         "Reserved csrow type",
  87         "Unknown csrow type",
  88         "Fast page mode RAM",
  89         "Extended data out RAM",
  90         "Burst Extended data out RAM",
  91         "Single data rate SDRAM",
  92         "Registered single data rate SDRAM",
  93         "Double data rate SDRAM",
  94         "Registered Double data rate SDRAM",
  95         "Rambus DRAM",
  96         "Unbuffered DDR2 RAM",
  97         "Fully buffered DDR2",
  98         "Registered DDR2 RAM",
  99         "Rambus XDR",
 100         "Unbuffered DDR3 RAM",
 101         "Registered DDR3 RAM",
 102 };
 103 EXPORT_SYMBOL_GPL(edac_mem_types);
 104
 105 /* 'ptr' points to a possibly unaligned item X such that sizeof(X) is 'size'.
 106  * Adjust 'ptr' so that its alignment is at least as stringent as what the
 107  * compiler would provide for X and return the aligned result.
 108  *
 109  * If 'size' is a constant, the compiler will optimize this whole function
 110  * down to either a no-op or the addition of a constant to the value of 'ptr'.
 111  */
 112 void *edac_align_ptr(void *ptr, unsigned size)
 113 {
 114         unsigned align, r;
 115
 116         /* Here we assume that the alignment of a "long long" is the most
 117          * stringent alignment that the compiler will ever provide by default.
 118          * As far as I know, this is a reasonable assumption.
 119          */
 120         if (size > sizeof(long))
 121                 align = sizeof(long long);
 122         else if (size > sizeof(int))
 123                 align = sizeof(long);
 124         else if (size > sizeof(short))
 125                 align = sizeof(int);
 126         else if (size > sizeof(char))
 127                 align = sizeof(short);
 128         else
 129                 return (char *)ptr;
 130
 131         r = size % align;
 132
 133         if (r == 0)
 134                 return (char *)ptr;
 135
 136         return (void *)(((unsigned long)ptr) + align - r);
 137 }
 138
 139 /**
 140  * edac_mc_alloc: Allocate a struct mem_ctl_info structure
 141  * @size_pvt:   size of private storage needed
 142  * @nr_csrows:  Number of CWROWS needed for this MC
 143  * @nr_chans:   Number of channels for the MC
 144  *
 145  * Everything is kmalloc'ed as one big chunk - more efficient.
 146  * Only can be used if all structures have the same lifetime - otherwise
 147  * you have to allocate and initialize your own structures.
 148  *
 149  * Use edac_mc_free() to free mc structures allocated by this function.
 150  *
 151  * Returns:
 152  *      NULL allocation failed
 153  *      struct mem_ctl_info pointer
 154  */
 155 struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows,
 156                                 unsigned nr_chans, int edac_index)
 157 {
 158         struct mem_ctl_info *mci;
 159         struct csrow_info *csi, *csrow;
 160         struct channel_info *chi, *chp, *chan;
 161         void *pvt;
 162         unsigned size;
 163         int row, chn;
 164         int err;
 165
 166         /* Figure out the offsets of the various items from the start of an mc
 167          * structure.  We want the alignment of each item to be at least as
 168          * stringent as what the compiler would provide if we could simply
 169          * hardcode everything into a single struct.
 170          */
 171         mci = (struct mem_ctl_info *)0;
 172         csi = edac_align_ptr(&mci[1], sizeof(*csi));
 173         chi = edac_align_ptr(&csi[nr_csrows], sizeof(*chi));
 174         pvt = edac_align_ptr(&chi[nr_chans * nr_csrows], sz_pvt);
 175         size = ((unsigned long)pvt) + sz_pvt;
 176
 177         mci = kzalloc(size, GFP_KERNEL);
 178         if (mci == NULL)
 179                 return NULL;
 180
 181         /* Adjust pointers so they point within the memory we just allocated
 182          * rather than an imaginary chunk of memory located at address 0.
 183          */
 184         csi = (struct csrow_info *)(((char *)mci) + ((unsigned long)csi));
 185         chi = (struct channel_info *)(((char *)mci) + ((unsigned long)chi));
 186         pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL;
 187
 188         /* setup index and various internal pointers */
 189         mci->mc_idx = edac_index;
 190         mci->csrows = csi;
 191         mci->pvt_info = pvt;
 192         mci->nr_csrows = nr_csrows;
 193
 194         for (row = 0; row < nr_csrows; row++) {
 195                 csrow = &csi[row];
 196                 csrow->csrow_idx = row;
 197                 csrow->mci = mci;
 198                 csrow->nr_channels = nr_chans;
 199                 chp = &chi[row * nr_chans];
 200                 csrow->channels = chp;
 201
 202                 for (chn = 0; chn < nr_chans; chn++) {
 203                         chan = &chp[chn];
 204                         chan->chan_idx = chn;
 205                         chan->csrow = csrow;
 206                 }
 207         }
 208
 209         mci->op_state = OP_ALLOC;
 210         INIT_LIST_HEAD(&mci->grp_kobj_list);
 211
 212         /*
 213          * Initialize the 'root' kobj for the edac_mc controller
 214          */
 215         err = edac_mc_register_sysfs_main_kobj(mci);
 216         if (err) {
 217                 kfree(mci);
 218                 return NULL;
 219         }
 220
 221         /* at this point, the root kobj is valid, and in order to
 222          * 'free' the object, then the function:
 223          *      edac_mc_unregister_sysfs_main_kobj() must be called
 224          * which will perform kobj unregistration and the actual free
 225          * will occur during the kobject callback operation
 226          */
 227         return mci;
 228 }
 229 EXPORT_SYMBOL_GPL(edac_mc_alloc);
 230
 231 /**
 232  * edac_mc_free
 233  *      'Free' a previously allocated 'mci' structure
 234  * @mci: pointer to a struct mem_ctl_info structure
 235  */
 236 void edac_mc_free(struct mem_ctl_info *mci)
 237 {
 238         debugf1("%s()\n", __func__);
 239
 240         edac_mc_unregister_sysfs_main_kobj(mci);
 241
 242         /* free the mci instance memory here */
 243         kfree(mci);
 244 }
 245 EXPORT_SYMBOL_GPL(edac_mc_free);
 246
 247
 248 /**
 249  * find_mci_by_dev
 250  *
 251  *      scan list of controllers looking for the one that manages
 252  *      the 'dev' device
 253  * @dev: pointer to a struct device related with the MCI
 254  */
 255 struct mem_ctl_info *find_mci_by_dev(struct device *dev)
 256 {
 257         struct mem_ctl_info *mci;
 258         struct list_head *item;
 259
 260         debugf3("%s()\n", __func__);
 261
 262         list_for_each(item, &mc_devices) {
 263                 mci = list_entry(item, struct mem_ctl_info, link);
 264
 265                 if (mci->dev == dev)
 266                         return mci;
 267         }
 268
 269         return NULL;
 270 }
 271 EXPORT_SYMBOL_GPL(find_mci_by_dev);
 272
 273 /*
 274  * handler for EDAC to check if NMI type handler has asserted interrupt
 275  */
 276 static int edac_mc_assert_error_check_and_clear(void)
 277 {
 278         int old_state;
 279
 280         if (edac_op_state == EDAC_OPSTATE_POLL)
 281                 return 1;
 282
 283         old_state = edac_err_assert;
 284         edac_err_assert = 0;
 285
 286         return old_state;
 287 }
 288
 289 /*
 290  * edac_mc_workq_function
 291  *      performs the operation scheduled by a workq request
 292  */
 293 static void edac_mc_workq_function(struct work_struct *work_req)
 294 {
 295         struct delayed_work *d_work = to_delayed_work(work_req);
 296         struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
 297
 298         mutex_lock(&mem_ctls_mutex);
 299
 300         /* if this control struct has movd to offline state, we are done */
 301         if (mci->op_state == OP_OFFLINE) {
 302                 mutex_unlock(&mem_ctls_mutex);
 303                 return;
 304         }
 305
 306         /* Only poll controllers that are running polled and have a check */
 307         if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL))
 308                 mci->edac_check(mci);
 309
 310         mutex_unlock(&mem_ctls_mutex);
 311
 312         /* Reschedule */
 313         queue_delayed_work(edac_workqueue, &mci->work,
 314                         msecs_to_jiffies(edac_mc_get_poll_msec()));
 315 }
 316
 317 /*
 318  * edac_mc_workq_setup
 319  *      initialize a workq item for this mci
 320  *      passing in the new delay period in msec
 321  *
 322  *      locking model:
 323  *
 324  *              called with the mem_ctls_mutex held
 325  */
 326 static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec,
 327                                 bool init)
 328 {
 329         debugf0("%s()\n", __func__);
 330
 331         /* if this instance is not in the POLL state, then simply return */
 332         if (mci->op_state != OP_RUNNING_POLL)
 333                 return;
 334
 335         if (init)
 336                 INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
 337
 338         queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
 339 }
 340
 341 /*
 342  * edac_mc_workq_teardown
 343  *      stop the workq processing on this mci
 344  *
 345  *      locking model:
 346  *
 347  *              called WITHOUT lock held
 348  */
 349 static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
 350 {
 351         int status;
 352
 353         if (mci->op_state != OP_RUNNING_POLL)
 354                 return;
 355
 356         status = cancel_delayed_work(&mci->work);
 357         if (status == 0) {
 358                 debugf0("%s() not canceled, flush the queue\n",
 359                         __func__);
 360
 361                 /* workq instance might be running, wait for it */
 362                 flush_workqueue(edac_workqueue);
 363         }
 364 }
 365
 366 /*
 367  * edac_mc_reset_delay_period(unsigned long value)
 368  *
 369  *      user space has updated our poll period value, need to
 370  *      reset our workq delays
 371  */
 372 void edac_mc_reset_delay_period(int value)
 373 {
 374         struct mem_ctl_info *mci;
 375         struct list_head *item;
 376
 377         mutex_lock(&mem_ctls_mutex);
 378
 379         /* scan the list and turn off all workq timers, doing so under lock
 380          */
 381         list_for_each(item, &mc_devices) {
 382                 mci = list_entry(item, struct mem_ctl_info, link);
 383
 384                 if (mci->op_state == OP_RUNNING_POLL)
 385                         cancel_delayed_work(&mci->work);
 386         }
 387
 388         mutex_unlock(&mem_ctls_mutex);
 389
 390
 391         /* re-walk the list, and reset the poll delay */
 392         mutex_lock(&mem_ctls_mutex);
 393
 394         list_for_each(item, &mc_devices) {
 395                 mci = list_entry(item, struct mem_ctl_info, link);
 396
 397                 edac_mc_workq_setup(mci, value, false);
 398         }
 399
 400         mutex_unlock(&mem_ctls_mutex);
 401 }
 402
 403
 404
 405 /* Return 0 on success, 1 on failure.
 406  * Before calling this function, caller must
 407  * assign a unique value to mci->mc_idx.
 408  *
 409  *      locking model:
 410  *
 411  *              called with the mem_ctls_mutex lock held
 412  */
 413 static int add_mc_to_global_list(struct mem_ctl_info *mci)
 414 {
 415         struct list_head *item, *insert_before;
 416         struct mem_ctl_info *p;
 417
 418         insert_before = &mc_devices;
 419
 420         p = find_mci_by_dev(mci->dev);
 421         if (unlikely(p != NULL))
 422                 goto fail0;
 423
 424         list_for_each(item, &mc_devices) {
 425                 p = list_entry(item, struct mem_ctl_info, link);
 426
 427                 if (p->mc_idx >= mci->mc_idx) {
 428                         if (unlikely(p->mc_idx == mci->mc_idx))
 429                                 goto fail1;
 430
 431                         insert_before = item;
 432                         break;
 433                 }
 434         }
 435
 436         list_add_tail_rcu(&mci->link, insert_before);
 437         atomic_inc(&edac_handlers);
 438         return 0;
 439
 440 fail0:
 441         edac_printk(KERN_WARNING, EDAC_MC,
 442                 "%s (%s) %s %s already assigned %d\n", dev_name(p->dev),
 443                 edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
 444         return 1;
 445
 446 fail1:
 447         edac_printk(KERN_WARNING, EDAC_MC,
 448                 "bug in low-level driver: attempt to assign\n"
 449                 "    duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
 450         return 1;
 451 }
 452
 453 static void del_mc_from_global_list(struct mem_ctl_info *mci)
 454 {
 455         atomic_dec(&edac_handlers);
 456         list_del_rcu(&mci->link);
 457
 458         /* these are for safe removal of devices from global list while
 459          * NMI handlers may be traversing list
 460          */
 461         synchronize_rcu();
 462         INIT_LIST_HEAD(&mci->link);
 463 }
 464
 465 /**
 466  * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
 467  *
 468  * If found, return a pointer to the structure.
 469  * Else return NULL.
 470  *
 471  * Caller must hold mem_ctls_mutex.
 472  */
 473 struct mem_ctl_info *edac_mc_find(int idx)
 474 {
 475         struct list_head *item;
 476         struct mem_ctl_info *mci;
 477
 478         list_for_each(item, &mc_devices) {
 479                 mci = list_entry(item, struct mem_ctl_info, link);
 480
 481                 if (mci->mc_idx >= idx) {
 482                         if (mci->mc_idx == idx)
 483                                 return mci;
 484
 485                         break;
 486                 }
 487         }
 488
 489         return NULL;
 490 }
 491 EXPORT_SYMBOL(edac_mc_find);
 492
 493 /**
 494  * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
 495  *                 create sysfs entries associated with mci structure
 496  * @mci: pointer to the mci structure to be added to the list
 497  * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
 498  *
 499  * Return:
 500  *      0       Success
 501  *      !0      Failure
 502  */
 503
 504 /* FIXME - should a warning be printed if no error detection? correction? */
 505 int edac_mc_add_mc(struct mem_ctl_info *mci)
 506 {
 507         debugf0("%s()\n", __func__);
 508
 509 #ifdef CONFIG_EDAC_DEBUG
 510         if (edac_debug_level >= 3)
 511                 edac_mc_dump_mci(mci);
 512
 513         if (edac_debug_level >= 4) {
 514                 int i;
 515
 516                 for (i = 0; i < mci->nr_csrows; i++) {
 517                         int j;
 518
 519                         edac_mc_dump_csrow(&mci->csrows[i]);
 520                         for (j = 0; j < mci->csrows[i].nr_channels; j++)
 521                                 edac_mc_dump_channel(&mci->csrows[i].
 522                                                 channels[j]);
 523                 }
 524         }
 525 #endif
 526         mutex_lock(&mem_ctls_mutex);
 527
 528         if (add_mc_to_global_list(mci))
 529                 goto fail0;
 530
 531         /* set load time so that error rate can be tracked */
 532         mci->start_time = jiffies;
 533
 534         if (edac_create_sysfs_mci_device(mci)) {
 535                 edac_mc_printk(mci, KERN_WARNING,
 536                         "failed to create sysfs device\n");
 537                 goto fail1;
 538         }
 539
 540         /* If there IS a check routine, then we are running POLLED */
 541         if (mci->edac_check != NULL) {
 542                 /* This instance is NOW RUNNING */
 543                 mci->op_state = OP_RUNNING_POLL;
 544
 545                 edac_mc_workq_setup(mci, edac_mc_get_poll_msec(), true);
 546         } else {
 547                 mci->op_state = OP_RUNNING_INTERRUPT;
 548         }
 549
 550         /* Report action taken */
 551         edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
 552                 " DEV %s\n", mci->mod_name, mci->ctl_name, edac_dev_name(mci));
 553
 554         mutex_unlock(&mem_ctls_mutex);
 555         return 0;
 556
 557 fail1:
 558         del_mc_from_global_list(mci);
 559
 560 fail0:
 561         mutex_unlock(&mem_ctls_mutex);
 562         return 1;
 563 }
 564 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
 565
 566 /**
 567  * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
 568  *                 remove mci structure from global list
 569  * @pdev: Pointer to 'struct device' representing mci structure to remove.
 570  *
 571  * Return pointer to removed mci structure, or NULL if device not found.
 572  */
 573 struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
 574 {
 575         struct mem_ctl_info *mci;
 576
 577         debugf0("%s()\n", __func__);
 578
 579         mutex_lock(&mem_ctls_mutex);
 580
 581         /* find the requested mci struct in the global list */
 582         mci = find_mci_by_dev(dev);
 583         if (mci == NULL) {
 584                 mutex_unlock(&mem_ctls_mutex);
 585                 return NULL;
 586         }
 587
 588         del_mc_from_global_list(mci);
 589         mutex_unlock(&mem_ctls_mutex);
 590
 591         /* flush workq processes */
 592         edac_mc_workq_teardown(mci);
 593
 594         /* marking MCI offline */
 595         mci->op_state = OP_OFFLINE;
 596
 597         /* remove from sysfs */
 598         edac_remove_sysfs_mci_device(mci);
 599
 600         edac_printk(KERN_INFO, EDAC_MC,
 601                 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
 602                 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
 603
 604         return mci;
 605 }
 606 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
 607
 608 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
 609                                 u32 size)
 610 {
 611         struct page *pg;
 612         void *virt_addr;
 613         unsigned long flags = 0;
 614
 615         debugf3("%s()\n", __func__);
 616
 617         /* ECC error page was not in our memory. Ignore it. */
 618         if (!pfn_valid(page))
 619                 return;
 620
 621         /* Find the actual page structure then map it and fix */
 622         pg = pfn_to_page(page);
 623
 624         if (PageHighMem(pg))
 625                 local_irq_save(flags);
 626
 627         virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);
 628
 629         /* Perform architecture specific atomic scrub operation */
 630         atomic_scrub(virt_addr + offset, size);
 631
 632         /* Unmap and complete */
 633         kunmap_atomic(virt_addr, KM_BOUNCE_READ);
 634
 635         if (PageHighMem(pg))
 636                 local_irq_restore(flags);
 637 }
 638
 639 /* FIXME - should return -1 */
 640 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
 641 {
 642         struct csrow_info *csrows = mci->csrows;
 643         int row, i;
 644
 645         debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
 646         row = -1;
 647
 648         for (i = 0; i < mci->nr_csrows; i++) {
 649                 struct csrow_info *csrow = &csrows[i];
 650
 651                 if (csrow->nr_pages == 0)
 652                         continue;
 653
 654                 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
 655                         "mask(0x%lx)\n", mci->mc_idx, __func__,
 656                         csrow->first_page, page, csrow->last_page,
 657                         csrow->page_mask);
 658
 659                 if ((page >= csrow->first_page) &&
 660                     (page <= csrow->last_page) &&
 661                     ((page & csrow->page_mask) ==
 662                      (csrow->first_page & csrow->page_mask))) {
 663                         row = i;
 664                         break;
 665                 }
 666         }
 667
 668         if (row == -1)
 669                 edac_mc_printk(mci, KERN_ERR,
 670                         "could not look up page error address %lx\n",
 671                         (unsigned long)page);
 672
 673         return row;
 674 }
 675 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
 676
 677 /* FIXME - setable log (warning/emerg) levels */
 678 /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
 679 void edac_mc_handle_ce(struct mem_ctl_info *mci,
 680                 unsigned long page_frame_number,
 681                 unsigned long offset_in_page, unsigned long syndrome,
 682                 int row, int channel, const char *msg)
 683 {
 684         unsigned long remapped_page;
 685
 686         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
 687
 688         /* FIXME - maybe make panic on INTERNAL ERROR an option */
 689         if (row >= mci->nr_csrows || row < 0) {
 690                 /* something is wrong */
 691                 edac_mc_printk(mci, KERN_ERR,
 692                         "INTERNAL ERROR: row out of range "
 693                         "(%d >= %d)\n", row, mci->nr_csrows);
 694                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 695                 return;
 696         }
 697
 698         if (channel >= mci->csrows[row].nr_channels || channel < 0) {
 699                 /* something is wrong */
 700                 edac_mc_printk(mci, KERN_ERR,
 701                         "INTERNAL ERROR: channel out of range "
 702                         "(%d >= %d)\n", channel,
 703                         mci->csrows[row].nr_channels);
 704                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 705                 return;
 706         }
 707
 708         if (edac_mc_get_log_ce())
 709                 /* FIXME - put in DIMM location */
 710                 edac_mc_printk(mci, KERN_WARNING,
 711                         "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
 712                         "0x%lx, row %d, channel %d, label \"%s\": %s\n",
 713                         page_frame_number, offset_in_page,
 714                         mci->csrows[row].grain, syndrome, row, channel,
 715                         mci->csrows[row].channels[channel].label, msg);
 716
 717         mci->ce_count++;
 718         mci->csrows[row].ce_count++;
 719         mci->csrows[row].channels[channel].ce_count++;
 720
 721         if (mci->scrub_mode & SCRUB_SW_SRC) {
 722                 /*
 723                  * Some MC's can remap memory so that it is still available
 724                  * at a different address when PCI devices map into memory.
 725                  * MC's that can't do this lose the memory where PCI devices
 726                  * are mapped.  This mapping is MC dependent and so we call
 727                  * back into the MC driver for it to map the MC page to
 728                  * a physical (CPU) page which can then be mapped to a virtual
 729                  * page - which can then be scrubbed.
 730                  */
 731                 remapped_page = mci->ctl_page_to_phys ?
 732                         mci->ctl_page_to_phys(mci, page_frame_number) :
 733                         page_frame_number;
 734
 735                 edac_mc_scrub_block(remapped_page, offset_in_page,
 736                                 mci->csrows[row].grain);
 737         }
 738 }
 739 EXPORT_SYMBOL_GPL(edac_mc_handle_ce);
 740
 741 void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
 742 {
 743         if (edac_mc_get_log_ce())
 744                 edac_mc_printk(mci, KERN_WARNING,
 745                         "CE - no information available: %s\n", msg);
 746
 747         mci->ce_noinfo_count++;
 748         mci->ce_count++;
 749 }
 750 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);
 751
 752 void edac_mc_handle_ue(struct mem_ctl_info *mci,
 753                 unsigned long page_frame_number,
 754                 unsigned long offset_in_page, int row, const char *msg)
 755 {
 756         int len = EDAC_MC_LABEL_LEN * 4;
 757         char labels[len + 1];
 758         char *pos = labels;
 759         int chan;
 760         int chars;
 761
 762         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
 763
 764         /* FIXME - maybe make panic on INTERNAL ERROR an option */
 765         if (row >= mci->nr_csrows || row < 0) {
 766                 /* something is wrong */
 767                 edac_mc_printk(mci, KERN_ERR,
 768                         "INTERNAL ERROR: row out of range "
 769                         "(%d >= %d)\n", row, mci->nr_csrows);
 770                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 771                 return;
 772         }
 773
 774         chars = snprintf(pos, len + 1, "%s",
 775                          mci->csrows[row].channels[0].label);
 776         len -= chars;
 777         pos += chars;
 778
 779         for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
 780                 chan++) {
 781                 chars = snprintf(pos, len + 1, ":%s",
 782                                  mci->csrows[row].channels[chan].label);
 783                 len -= chars;
 784                 pos += chars;
 785         }
 786
 787         if (edac_mc_get_log_ue())
 788                 edac_mc_printk(mci, KERN_EMERG,
 789                         "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
 790                         "labels \"%s\": %s\n", page_frame_number,
 791                         offset_in_page, mci->csrows[row].grain, row,
 792                         labels, msg);
 793
 794         if (edac_mc_get_panic_on_ue())
 795                 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
 796                         "row %d, labels \"%s\": %s\n", mci->mc_idx,
 797                         page_frame_number, offset_in_page,
 798                         mci->csrows[row].grain, row, labels, msg);
 799
 800         mci->ue_count++;
 801         mci->csrows[row].ue_count++;
 802 }
 803 EXPORT_SYMBOL_GPL(edac_mc_handle_ue);
 804
 805 void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
 806 {
 807         if (edac_mc_get_panic_on_ue())
 808                 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
 809
 810         if (edac_mc_get_log_ue())
 811                 edac_mc_printk(mci, KERN_WARNING,
 812                         "UE - no information available: %s\n", msg);
 813         mci->ue_noinfo_count++;
 814         mci->ue_count++;
 815 }
 816 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);
 817
 818 /*************************************************************
 819  * On Fully Buffered DIMM modules, this help function is
 820  * called to process UE events
 821  */
 822 void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci,
 823                         unsigned int csrow,
 824                         unsigned int channela,
 825                         unsigned int channelb, char *msg)
 826 {
 827         int len = EDAC_MC_LABEL_LEN * 4;
 828         char labels[len + 1];
 829         char *pos = labels;
 830         int chars;
 831
 832         if (csrow >= mci->nr_csrows) {
 833                 /* something is wrong */
 834                 edac_mc_printk(mci, KERN_ERR,
 835                         "INTERNAL ERROR: row out of range (%d >= %d)\n",
 836                         csrow, mci->nr_csrows);
 837                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 838                 return;
 839         }
 840
 841         if (channela >= mci->csrows[csrow].nr_channels) {
 842                 /* something is wrong */
 843                 edac_mc_printk(mci, KERN_ERR,
 844                         "INTERNAL ERROR: channel-a out of range "
 845                         "(%d >= %d)\n",
 846                         channela, mci->csrows[csrow].nr_channels);
 847                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 848                 return;
 849         }
 850
 851         if (channelb >= mci->csrows[csrow].nr_channels) {
 852                 /* something is wrong */
 853                 edac_mc_printk(mci, KERN_ERR,
 854                         "INTERNAL ERROR: channel-b out of range "
 855                         "(%d >= %d)\n",
 856                         channelb, mci->csrows[csrow].nr_channels);
 857                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 858                 return;
 859         }
 860
 861         mci->ue_count++;
 862         mci->csrows[csrow].ue_count++;
 863
 864         /* Generate the DIMM labels from the specified channels */
 865         chars = snprintf(pos, len + 1, "%s",
 866                          mci->csrows[csrow].channels[channela].label);
 867         len -= chars;
 868         pos += chars;
 869         chars = snprintf(pos, len + 1, "-%s",
 870                          mci->csrows[csrow].channels[channelb].label);
 871
 872         if (edac_mc_get_log_ue())
 873                 edac_mc_printk(mci, KERN_EMERG,
 874                         "UE row %d, channel-a= %d channel-b= %d "
 875                         "labels \"%s\": %s\n", csrow, channela, channelb,
 876                         labels, msg);
 877
 878         if (edac_mc_get_panic_on_ue())
 879                 panic("UE row %d, channel-a= %d channel-b= %d "
 880                         "labels \"%s\": %s\n", csrow, channela,
 881                         channelb, labels, msg);
 882 }
 883 EXPORT_SYMBOL(edac_mc_handle_fbd_ue);
 884
 885 /*************************************************************
 886  * On Fully Buffered DIMM modules, this help function is
 887  * called to process CE events
 888  */
 889 void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
 890                         unsigned int csrow, unsigned int channel, char *msg)
 891 {
 892
 893         /* Ensure boundary values */
 894         if (csrow >= mci->nr_csrows) {
 895                 /* something is wrong */
 896                 edac_mc_printk(mci, KERN_ERR,
 897                         "INTERNAL ERROR: row out of range (%d >= %d)\n",
 898                         csrow, mci->nr_csrows);
 899                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 900                 return;
 901         }
 902         if (channel >= mci->csrows[csrow].nr_channels) {
 903                 /* something is wrong */
 904                 edac_mc_printk(mci, KERN_ERR,
 905                         "INTERNAL ERROR: channel out of range (%d >= %d)\n",
 906                         channel, mci->csrows[csrow].nr_channels);
 907                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 908                 return;
 909         }
 910
 911         if (edac_mc_get_log_ce())
 912                 /* FIXME - put in DIMM location */
 913                 edac_mc_printk(mci, KERN_WARNING,
 914                         "CE row %d, channel %d, label \"%s\": %s\n",
 915                         csrow, channel,
 916                         mci->csrows[csrow].channels[channel].label, msg);
 917
 918         mci->ce_count++;
 919         mci->csrows[csrow].ce_count++;
 920         mci->csrows[csrow].channels[channel].ce_count++;
 921 }
 922 EXPORT_SYMBOL(edac_mc_handle_fbd_ce);