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         mci->op_state = OP_OFFLINE;
 352
 353         cancel_delayed_work_sync(&mci->work);
 354         flush_workqueue(edac_workqueue);
 355 }
 356
 357 /*
 358  * edac_mc_reset_delay_period(unsigned long value)
 359  *
 360  *      user space has updated our poll period value, need to
 361  *      reset our workq delays
 362  */
 363 void edac_mc_reset_delay_period(int value)
 364 {
 365         struct mem_ctl_info *mci;
 366         struct list_head *item;
 367
 368         mutex_lock(&mem_ctls_mutex);
 369
 370         /* scan the list and turn off all workq timers, doing so under lock
 371          */
 372         list_for_each(item, &mc_devices) {
 373                 mci = list_entry(item, struct mem_ctl_info, link);
 374
 375                 if (mci->op_state == OP_RUNNING_POLL)
 376                         cancel_delayed_work(&mci->work);
 377         }
 378
 379         mutex_unlock(&mem_ctls_mutex);
 380
 381
 382         /* re-walk the list, and reset the poll delay */
 383         mutex_lock(&mem_ctls_mutex);
 384
 385         list_for_each(item, &mc_devices) {
 386                 mci = list_entry(item, struct mem_ctl_info, link);
 387
 388                 edac_mc_workq_setup(mci, value, false);
 389         }
 390
 391         mutex_unlock(&mem_ctls_mutex);
 392 }
 393
 394
 395
 396 /* Return 0 on success, 1 on failure.
 397  * Before calling this function, caller must
 398  * assign a unique value to mci->mc_idx.
 399  *
 400  *      locking model:
 401  *
 402  *              called with the mem_ctls_mutex lock held
 403  */
 404 static int add_mc_to_global_list(struct mem_ctl_info *mci)
 405 {
 406         struct list_head *item, *insert_before;
 407         struct mem_ctl_info *p;
 408
 409         insert_before = &mc_devices;
 410
 411         p = find_mci_by_dev(mci->dev);
 412         if (unlikely(p != NULL))
 413                 goto fail0;
 414
 415         list_for_each(item, &mc_devices) {
 416                 p = list_entry(item, struct mem_ctl_info, link);
 417
 418                 if (p->mc_idx >= mci->mc_idx) {
 419                         if (unlikely(p->mc_idx == mci->mc_idx))
 420                                 goto fail1;
 421
 422                         insert_before = item;
 423                         break;
 424                 }
 425         }
 426
 427         list_add_tail_rcu(&mci->link, insert_before);
 428         atomic_inc(&edac_handlers);
 429         return 0;
 430
 431 fail0:
 432         edac_printk(KERN_WARNING, EDAC_MC,
 433                 "%s (%s) %s %s already assigned %d\n", dev_name(p->dev),
 434                 edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
 435         return 1;
 436
 437 fail1:
 438         edac_printk(KERN_WARNING, EDAC_MC,
 439                 "bug in low-level driver: attempt to assign\n"
 440                 "    duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
 441         return 1;
 442 }
 443
 444 static void del_mc_from_global_list(struct mem_ctl_info *mci)
 445 {
 446         atomic_dec(&edac_handlers);
 447         list_del_rcu(&mci->link);
 448
 449         /* these are for safe removal of devices from global list while
 450          * NMI handlers may be traversing list
 451          */
 452         synchronize_rcu();
 453         INIT_LIST_HEAD(&mci->link);
 454 }
 455
 456 /**
 457  * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
 458  *
 459  * If found, return a pointer to the structure.
 460  * Else return NULL.
 461  *
 462  * Caller must hold mem_ctls_mutex.
 463  */
 464 struct mem_ctl_info *edac_mc_find(int idx)
 465 {
 466         struct list_head *item;
 467         struct mem_ctl_info *mci;
 468
 469         list_for_each(item, &mc_devices) {
 470                 mci = list_entry(item, struct mem_ctl_info, link);
 471
 472                 if (mci->mc_idx >= idx) {
 473                         if (mci->mc_idx == idx)
 474                                 return mci;
 475
 476                         break;
 477                 }
 478         }
 479
 480         return NULL;
 481 }
 482 EXPORT_SYMBOL(edac_mc_find);
 483
 484 /**
 485  * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
 486  *                 create sysfs entries associated with mci structure
 487  * @mci: pointer to the mci structure to be added to the list
 488  * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
 489  *
 490  * Return:
 491  *      0       Success
 492  *      !0      Failure
 493  */
 494
 495 /* FIXME - should a warning be printed if no error detection? correction? */
 496 int edac_mc_add_mc(struct mem_ctl_info *mci)
 497 {
 498         debugf0("%s()\n", __func__);
 499
 500 #ifdef CONFIG_EDAC_DEBUG
 501         if (edac_debug_level >= 3)
 502                 edac_mc_dump_mci(mci);
 503
 504         if (edac_debug_level >= 4) {
 505                 int i;
 506
 507                 for (i = 0; i < mci->nr_csrows; i++) {
 508                         int j;
 509
 510                         edac_mc_dump_csrow(&mci->csrows[i]);
 511                         for (j = 0; j < mci->csrows[i].nr_channels; j++)
 512                                 edac_mc_dump_channel(&mci->csrows[i].
 513                                                 channels[j]);
 514                 }
 515         }
 516 #endif
 517         mutex_lock(&mem_ctls_mutex);
 518
 519         if (add_mc_to_global_list(mci))
 520                 goto fail0;
 521
 522         /* set load time so that error rate can be tracked */
 523         mci->start_time = jiffies;
 524
 525         if (edac_create_sysfs_mci_device(mci)) {
 526                 edac_mc_printk(mci, KERN_WARNING,
 527                         "failed to create sysfs device\n");
 528                 goto fail1;
 529         }
 530
 531         /* If there IS a check routine, then we are running POLLED */
 532         if (mci->edac_check != NULL) {
 533                 /* This instance is NOW RUNNING */
 534                 mci->op_state = OP_RUNNING_POLL;
 535
 536                 edac_mc_workq_setup(mci, edac_mc_get_poll_msec(), true);
 537         } else {
 538                 mci->op_state = OP_RUNNING_INTERRUPT;
 539         }
 540
 541         /* Report action taken */
 542         edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
 543                 " DEV %s\n", mci->mod_name, mci->ctl_name, edac_dev_name(mci));
 544
 545         mutex_unlock(&mem_ctls_mutex);
 546         return 0;
 547
 548 fail1:
 549         del_mc_from_global_list(mci);
 550
 551 fail0:
 552         mutex_unlock(&mem_ctls_mutex);
 553         return 1;
 554 }
 555 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
 556
 557 /**
 558  * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
 559  *                 remove mci structure from global list
 560  * @pdev: Pointer to 'struct device' representing mci structure to remove.
 561  *
 562  * Return pointer to removed mci structure, or NULL if device not found.
 563  */
 564 struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
 565 {
 566         struct mem_ctl_info *mci;
 567
 568         debugf0("%s()\n", __func__);
 569
 570         mutex_lock(&mem_ctls_mutex);
 571
 572         /* find the requested mci struct in the global list */
 573         mci = find_mci_by_dev(dev);
 574         if (mci == NULL) {
 575                 mutex_unlock(&mem_ctls_mutex);
 576                 return NULL;
 577         }
 578
 579         del_mc_from_global_list(mci);
 580         mutex_unlock(&mem_ctls_mutex);
 581
 582         /* flush workq processes */
 583         edac_mc_workq_teardown(mci);
 584
 585         /* marking MCI offline */
 586         mci->op_state = OP_OFFLINE;
 587
 588         /* remove from sysfs */
 589         edac_remove_sysfs_mci_device(mci);
 590
 591         edac_printk(KERN_INFO, EDAC_MC,
 592                 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
 593                 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
 594
 595         return mci;
 596 }
 597 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
 598
 599 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
 600                                 u32 size)
 601 {
 602         struct page *pg;
 603         void *virt_addr;
 604         unsigned long flags = 0;
 605
 606         debugf3("%s()\n", __func__);
 607
 608         /* ECC error page was not in our memory. Ignore it. */
 609         if (!pfn_valid(page))
 610                 return;
 611
 612         /* Find the actual page structure then map it and fix */
 613         pg = pfn_to_page(page);
 614
 615         if (PageHighMem(pg))
 616                 local_irq_save(flags);
 617
 618         virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);
 619
 620         /* Perform architecture specific atomic scrub operation */
 621         atomic_scrub(virt_addr + offset, size);
 622
 623         /* Unmap and complete */
 624         kunmap_atomic(virt_addr, KM_BOUNCE_READ);
 625
 626         if (PageHighMem(pg))
 627                 local_irq_restore(flags);
 628 }
 629
 630 /* FIXME - should return -1 */
 631 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
 632 {
 633         struct csrow_info *csrows = mci->csrows;
 634         int row, i;
 635
 636         debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
 637         row = -1;
 638
 639         for (i = 0; i < mci->nr_csrows; i++) {
 640                 struct csrow_info *csrow = &csrows[i];
 641
 642                 if (csrow->nr_pages == 0)
 643                         continue;
 644
 645                 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
 646                         "mask(0x%lx)\n", mci->mc_idx, __func__,
 647                         csrow->first_page, page, csrow->last_page,
 648                         csrow->page_mask);
 649
 650                 if ((page >= csrow->first_page) &&
 651                     (page <= csrow->last_page) &&
 652                     ((page & csrow->page_mask) ==
 653                      (csrow->first_page & csrow->page_mask))) {
 654                         row = i;
 655                         break;
 656                 }
 657         }
 658
 659         if (row == -1)
 660                 edac_mc_printk(mci, KERN_ERR,
 661                         "could not look up page error address %lx\n",
 662                         (unsigned long)page);
 663
 664         return row;
 665 }
 666 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
 667
 668 /* FIXME - setable log (warning/emerg) levels */
 669 /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
 670 void edac_mc_handle_ce(struct mem_ctl_info *mci,
 671                 unsigned long page_frame_number,
 672                 unsigned long offset_in_page, unsigned long syndrome,
 673                 int row, int channel, const char *msg)
 674 {
 675         unsigned long remapped_page;
 676
 677         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
 678
 679         /* FIXME - maybe make panic on INTERNAL ERROR an option */
 680         if (row >= mci->nr_csrows || row < 0) {
 681                 /* something is wrong */
 682                 edac_mc_printk(mci, KERN_ERR,
 683                         "INTERNAL ERROR: row out of range "
 684                         "(%d >= %d)\n", row, mci->nr_csrows);
 685                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 686                 return;
 687         }
 688
 689         if (channel >= mci->csrows[row].nr_channels || channel < 0) {
 690                 /* something is wrong */
 691                 edac_mc_printk(mci, KERN_ERR,
 692                         "INTERNAL ERROR: channel out of range "
 693                         "(%d >= %d)\n", channel,
 694                         mci->csrows[row].nr_channels);
 695                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 696                 return;
 697         }
 698
 699         if (edac_mc_get_log_ce())
 700                 /* FIXME - put in DIMM location */
 701                 edac_mc_printk(mci, KERN_WARNING,
 702                         "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
 703                         "0x%lx, row %d, channel %d, label \"%s\": %s\n",
 704                         page_frame_number, offset_in_page,
 705                         mci->csrows[row].grain, syndrome, row, channel,
 706                         mci->csrows[row].channels[channel].label, msg);
 707
 708         mci->ce_count++;
 709         mci->csrows[row].ce_count++;
 710         mci->csrows[row].channels[channel].ce_count++;
 711
 712         if (mci->scrub_mode & SCRUB_SW_SRC) {
 713                 /*
 714                  * Some MC's can remap memory so that it is still available
 715                  * at a different address when PCI devices map into memory.
 716                  * MC's that can't do this lose the memory where PCI devices
 717                  * are mapped.  This mapping is MC dependent and so we call
 718                  * back into the MC driver for it to map the MC page to
 719                  * a physical (CPU) page which can then be mapped to a virtual
 720                  * page - which can then be scrubbed.
 721                  */
 722                 remapped_page = mci->ctl_page_to_phys ?
 723                         mci->ctl_page_to_phys(mci, page_frame_number) :
 724                         page_frame_number;
 725
 726                 edac_mc_scrub_block(remapped_page, offset_in_page,
 727                                 mci->csrows[row].grain);
 728         }
 729 }
 730 EXPORT_SYMBOL_GPL(edac_mc_handle_ce);
 731
 732 void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
 733 {
 734         if (edac_mc_get_log_ce())
 735                 edac_mc_printk(mci, KERN_WARNING,
 736                         "CE - no information available: %s\n", msg);
 737
 738         mci->ce_noinfo_count++;
 739         mci->ce_count++;
 740 }
 741 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);
 742
 743 void edac_mc_handle_ue(struct mem_ctl_info *mci,
 744                 unsigned long page_frame_number,
 745                 unsigned long offset_in_page, int row, const char *msg)
 746 {
 747         int len = EDAC_MC_LABEL_LEN * 4;
 748         char labels[len + 1];
 749         char *pos = labels;
 750         int chan;
 751         int chars;
 752
 753         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
 754
 755         /* FIXME - maybe make panic on INTERNAL ERROR an option */
 756         if (row >= mci->nr_csrows || row < 0) {
 757                 /* something is wrong */
 758                 edac_mc_printk(mci, KERN_ERR,
 759                         "INTERNAL ERROR: row out of range "
 760                         "(%d >= %d)\n", row, mci->nr_csrows);
 761                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 762                 return;
 763         }
 764
 765         chars = snprintf(pos, len + 1, "%s",
 766                          mci->csrows[row].channels[0].label);
 767         len -= chars;
 768         pos += chars;
 769
 770         for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
 771                 chan++) {
 772                 chars = snprintf(pos, len + 1, ":%s",
 773                                  mci->csrows[row].channels[chan].label);
 774                 len -= chars;
 775                 pos += chars;
 776         }
 777
 778         if (edac_mc_get_log_ue())
 779                 edac_mc_printk(mci, KERN_EMERG,
 780                         "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
 781                         "labels \"%s\": %s\n", page_frame_number,
 782                         offset_in_page, mci->csrows[row].grain, row,
 783                         labels, msg);
 784
 785         if (edac_mc_get_panic_on_ue())
 786                 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
 787                         "row %d, labels \"%s\": %s\n", mci->mc_idx,
 788                         page_frame_number, offset_in_page,
 789                         mci->csrows[row].grain, row, labels, msg);
 790
 791         mci->ue_count++;
 792         mci->csrows[row].ue_count++;
 793 }
 794 EXPORT_SYMBOL_GPL(edac_mc_handle_ue);
 795
 796 void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
 797 {
 798         if (edac_mc_get_panic_on_ue())
 799                 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
 800
 801         if (edac_mc_get_log_ue())
 802                 edac_mc_printk(mci, KERN_WARNING,
 803                         "UE - no information available: %s\n", msg);
 804         mci->ue_noinfo_count++;
 805         mci->ue_count++;
 806 }
 807 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);
 808
 809 /*************************************************************
 810  * On Fully Buffered DIMM modules, this help function is
 811  * called to process UE events
 812  */
 813 void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci,
 814                         unsigned int csrow,
 815                         unsigned int channela,
 816                         unsigned int channelb, char *msg)
 817 {
 818         int len = EDAC_MC_LABEL_LEN * 4;
 819         char labels[len + 1];
 820         char *pos = labels;
 821         int chars;
 822
 823         if (csrow >= mci->nr_csrows) {
 824                 /* something is wrong */
 825                 edac_mc_printk(mci, KERN_ERR,
 826                         "INTERNAL ERROR: row out of range (%d >= %d)\n",
 827                         csrow, mci->nr_csrows);
 828                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 829                 return;
 830         }
 831
 832         if (channela >= mci->csrows[csrow].nr_channels) {
 833                 /* something is wrong */
 834                 edac_mc_printk(mci, KERN_ERR,
 835                         "INTERNAL ERROR: channel-a out of range "
 836                         "(%d >= %d)\n",
 837                         channela, mci->csrows[csrow].nr_channels);
 838                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 839                 return;
 840         }
 841
 842         if (channelb >= mci->csrows[csrow].nr_channels) {
 843                 /* something is wrong */
 844                 edac_mc_printk(mci, KERN_ERR,
 845                         "INTERNAL ERROR: channel-b out of range "
 846                         "(%d >= %d)\n",
 847                         channelb, mci->csrows[csrow].nr_channels);
 848                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 849                 return;
 850         }
 851
 852         mci->ue_count++;
 853         mci->csrows[csrow].ue_count++;
 854
 855         /* Generate the DIMM labels from the specified channels */
 856         chars = snprintf(pos, len + 1, "%s",
 857                          mci->csrows[csrow].channels[channela].label);
 858         len -= chars;
 859         pos += chars;
 860         chars = snprintf(pos, len + 1, "-%s",
 861                          mci->csrows[csrow].channels[channelb].label);
 862
 863         if (edac_mc_get_log_ue())
 864                 edac_mc_printk(mci, KERN_EMERG,
 865                         "UE row %d, channel-a= %d channel-b= %d "
 866                         "labels \"%s\": %s\n", csrow, channela, channelb,
 867                         labels, msg);
 868
 869         if (edac_mc_get_panic_on_ue())
 870                 panic("UE row %d, channel-a= %d channel-b= %d "
 871                         "labels \"%s\": %s\n", csrow, channela,
 872                         channelb, labels, msg);
 873 }
 874 EXPORT_SYMBOL(edac_mc_handle_fbd_ue);
 875
 876 /*************************************************************
 877  * On Fully Buffered DIMM modules, this help function is
 878  * called to process CE events
 879  */
 880 void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
 881                         unsigned int csrow, unsigned int channel, char *msg)
 882 {
 883
 884         /* Ensure boundary values */
 885         if (csrow >= mci->nr_csrows) {
 886                 /* something is wrong */
 887                 edac_mc_printk(mci, KERN_ERR,
 888                         "INTERNAL ERROR: row out of range (%d >= %d)\n",
 889                         csrow, mci->nr_csrows);
 890                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 891                 return;
 892         }
 893         if (channel >= mci->csrows[csrow].nr_channels) {
 894                 /* something is wrong */
 895                 edac_mc_printk(mci, KERN_ERR,
 896                         "INTERNAL ERROR: channel out of range (%d >= %d)\n",
 897                         channel, mci->csrows[csrow].nr_channels);
 898                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 899                 return;
 900         }
 901
 902         if (edac_mc_get_log_ce())
 903                 /* FIXME - put in DIMM location */
 904                 edac_mc_printk(mci, KERN_WARNING,
 905                         "CE row %d, channel %d, label \"%s\": %s\n",
 906                         csrow, channel,
 907                         mci->csrows[csrow].channels[channel].label, msg);
 908
 909         mci->ce_count++;
 910         mci->csrows[csrow].ce_count++;
 911         mci->csrows[csrow].channels[channel].ce_count++;
 912 }
 913 EXPORT_SYMBOL(edac_mc_handle_fbd_ce);