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 /*
  80  * keep those in sync with the enum mem_type
  81  */
  82 const char *edac_mem_types[] = {
  83         "Empty csrow",
  84         "Reserved csrow type",
  85         "Unknown csrow type",
  86         "Fast page mode RAM",
  87         "Extended data out RAM",
  88         "Burst Extended data out RAM",
  89         "Single data rate SDRAM",
  90         "Registered single data rate SDRAM",
  91         "Double data rate SDRAM",
  92         "Registered Double data rate SDRAM",
  93         "Rambus DRAM",
  94         "Unbuffered DDR2 RAM",
  95         "Fully buffered DDR2",
  96         "Registered DDR2 RAM",
  97         "Rambus XDR",
  98         "Unbuffered DDR3 RAM",
  99         "Registered DDR3 RAM",
 100 };
 101 EXPORT_SYMBOL_GPL(edac_mem_types);
 102
 103 #endif                          /* CONFIG_EDAC_DEBUG */
 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
 211         /*
 212          * Initialize the 'root' kobj for the edac_mc controller
 213          */
 214         err = edac_mc_register_sysfs_main_kobj(mci);
 215         if (err) {
 216                 kfree(mci);
 217                 return NULL;
 218         }
 219
 220         /* at this point, the root kobj is valid, and in order to
 221          * 'free' the object, then the function:
 222          *      edac_mc_unregister_sysfs_main_kobj() must be called
 223          * which will perform kobj unregistration and the actual free
 224          * will occur during the kobject callback operation
 225          */
 226         return mci;
 227 }
 228 EXPORT_SYMBOL_GPL(edac_mc_alloc);
 229
 230 /**
 231  * edac_mc_free
 232  *      'Free' a previously allocated 'mci' structure
 233  * @mci: pointer to a struct mem_ctl_info structure
 234  */
 235 void edac_mc_free(struct mem_ctl_info *mci)
 236 {
 237         edac_mc_unregister_sysfs_main_kobj(mci);
 238 }
 239 EXPORT_SYMBOL_GPL(edac_mc_free);
 240
 241
 242 /*
 243  * find_mci_by_dev
 244  *
 245  *      scan list of controllers looking for the one that manages
 246  *      the 'dev' device
 247  */
 248 static struct mem_ctl_info *find_mci_by_dev(struct device *dev)
 249 {
 250         struct mem_ctl_info *mci;
 251         struct list_head *item;
 252
 253         debugf3("%s()\n", __func__);
 254
 255         list_for_each(item, &mc_devices) {
 256                 mci = list_entry(item, struct mem_ctl_info, link);
 257
 258                 if (mci->dev == dev)
 259                         return mci;
 260         }
 261
 262         return NULL;
 263 }
 264
 265 /*
 266  * handler for EDAC to check if NMI type handler has asserted interrupt
 267  */
 268 static int edac_mc_assert_error_check_and_clear(void)
 269 {
 270         int old_state;
 271
 272         if (edac_op_state == EDAC_OPSTATE_POLL)
 273                 return 1;
 274
 275         old_state = edac_err_assert;
 276         edac_err_assert = 0;
 277
 278         return old_state;
 279 }
 280
 281 /*
 282  * edac_mc_workq_function
 283  *      performs the operation scheduled by a workq request
 284  */
 285 static void edac_mc_workq_function(struct work_struct *work_req)
 286 {
 287         struct delayed_work *d_work = to_delayed_work(work_req);
 288         struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
 289
 290         mutex_lock(&mem_ctls_mutex);
 291
 292         /* if this control struct has movd to offline state, we are done */
 293         if (mci->op_state == OP_OFFLINE) {
 294                 mutex_unlock(&mem_ctls_mutex);
 295                 return;
 296         }
 297
 298         /* Only poll controllers that are running polled and have a check */
 299         if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL))
 300                 mci->edac_check(mci);
 301
 302         mutex_unlock(&mem_ctls_mutex);
 303
 304         /* Reschedule */
 305         queue_delayed_work(edac_workqueue, &mci->work,
 306                         msecs_to_jiffies(edac_mc_get_poll_msec()));
 307 }
 308
 309 /*
 310  * edac_mc_workq_setup
 311  *      initialize a workq item for this mci
 312  *      passing in the new delay period in msec
 313  *
 314  *      locking model:
 315  *
 316  *              called with the mem_ctls_mutex held
 317  */
 318 static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec)
 319 {
 320         debugf0("%s()\n", __func__);
 321
 322         /* if this instance is not in the POLL state, then simply return */
 323         if (mci->op_state != OP_RUNNING_POLL)
 324                 return;
 325
 326         INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
 327         queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
 328 }
 329
 330 /*
 331  * edac_mc_workq_teardown
 332  *      stop the workq processing on this mci
 333  *
 334  *      locking model:
 335  *
 336  *              called WITHOUT lock held
 337  */
 338 static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
 339 {
 340         int status;
 341
 342         if (mci->op_state != OP_RUNNING_POLL)
 343                 return;
 344
 345         status = cancel_delayed_work(&mci->work);
 346         if (status == 0) {
 347                 debugf0("%s() not canceled, flush the queue\n",
 348                         __func__);
 349
 350                 /* workq instance might be running, wait for it */
 351                 flush_workqueue(edac_workqueue);
 352         }
 353 }
 354
 355 /*
 356  * edac_mc_reset_delay_period(unsigned long value)
 357  *
 358  *      user space has updated our poll period value, need to
 359  *      reset our workq delays
 360  */
 361 void edac_mc_reset_delay_period(int value)
 362 {
 363         struct mem_ctl_info *mci;
 364         struct list_head *item;
 365
 366         mutex_lock(&mem_ctls_mutex);
 367
 368         /* scan the list and turn off all workq timers, doing so under lock
 369          */
 370         list_for_each(item, &mc_devices) {
 371                 mci = list_entry(item, struct mem_ctl_info, link);
 372
 373                 if (mci->op_state == OP_RUNNING_POLL)
 374                         cancel_delayed_work(&mci->work);
 375         }
 376
 377         mutex_unlock(&mem_ctls_mutex);
 378
 379
 380         /* re-walk the list, and reset the poll delay */
 381         mutex_lock(&mem_ctls_mutex);
 382
 383         list_for_each(item, &mc_devices) {
 384                 mci = list_entry(item, struct mem_ctl_info, link);
 385
 386                 edac_mc_workq_setup(mci, (unsigned long) value);
 387         }
 388
 389         mutex_unlock(&mem_ctls_mutex);
 390 }
 391
 392
 393
 394 /* Return 0 on success, 1 on failure.
 395  * Before calling this function, caller must
 396  * assign a unique value to mci->mc_idx.
 397  *
 398  *      locking model:
 399  *
 400  *              called with the mem_ctls_mutex lock held
 401  */
 402 static int add_mc_to_global_list(struct mem_ctl_info *mci)
 403 {
 404         struct list_head *item, *insert_before;
 405         struct mem_ctl_info *p;
 406
 407         insert_before = &mc_devices;
 408
 409         p = find_mci_by_dev(mci->dev);
 410         if (unlikely(p != NULL))
 411                 goto fail0;
 412
 413         list_for_each(item, &mc_devices) {
 414                 p = list_entry(item, struct mem_ctl_info, link);
 415
 416                 if (p->mc_idx >= mci->mc_idx) {
 417                         if (unlikely(p->mc_idx == mci->mc_idx))
 418                                 goto fail1;
 419
 420                         insert_before = item;
 421                         break;
 422                 }
 423         }
 424
 425         list_add_tail_rcu(&mci->link, insert_before);
 426         atomic_inc(&edac_handlers);
 427         return 0;
 428
 429 fail0:
 430         edac_printk(KERN_WARNING, EDAC_MC,
 431                 "%s (%s) %s %s already assigned %d\n", dev_name(p->dev),
 432                 edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
 433         return 1;
 434
 435 fail1:
 436         edac_printk(KERN_WARNING, EDAC_MC,
 437                 "bug in low-level driver: attempt to assign\n"
 438                 "    duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
 439         return 1;
 440 }
 441
 442 static void complete_mc_list_del(struct rcu_head *head)
 443 {
 444         struct mem_ctl_info *mci;
 445
 446         mci = container_of(head, struct mem_ctl_info, rcu);
 447         INIT_LIST_HEAD(&mci->link);
 448 }
 449
 450 static void del_mc_from_global_list(struct mem_ctl_info *mci)
 451 {
 452         atomic_dec(&edac_handlers);
 453         list_del_rcu(&mci->link);
 454         call_rcu(&mci->rcu, complete_mc_list_del);
 455         rcu_barrier();
 456 }
 457
 458 /**
 459  * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
 460  *
 461  * If found, return a pointer to the structure.
 462  * Else return NULL.
 463  *
 464  * Caller must hold mem_ctls_mutex.
 465  */
 466 struct mem_ctl_info *edac_mc_find(int idx)
 467 {
 468         struct list_head *item;
 469         struct mem_ctl_info *mci;
 470
 471         list_for_each(item, &mc_devices) {
 472                 mci = list_entry(item, struct mem_ctl_info, link);
 473
 474                 if (mci->mc_idx >= idx) {
 475                         if (mci->mc_idx == idx)
 476                                 return mci;
 477
 478                         break;
 479                 }
 480         }
 481
 482         return NULL;
 483 }
 484 EXPORT_SYMBOL(edac_mc_find);
 485
 486 /**
 487  * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
 488  *                 create sysfs entries associated with mci structure
 489  * @mci: pointer to the mci structure to be added to the list
 490  * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
 491  *
 492  * Return:
 493  *      0       Success
 494  *      !0      Failure
 495  */
 496
 497 /* FIXME - should a warning be printed if no error detection? correction? */
 498 int edac_mc_add_mc(struct mem_ctl_info *mci)
 499 {
 500         debugf0("%s()\n", __func__);
 501
 502 #ifdef CONFIG_EDAC_DEBUG
 503         if (edac_debug_level >= 3)
 504                 edac_mc_dump_mci(mci);
 505
 506         if (edac_debug_level >= 4) {
 507                 int i;
 508
 509                 for (i = 0; i < mci->nr_csrows; i++) {
 510                         int j;
 511
 512                         edac_mc_dump_csrow(&mci->csrows[i]);
 513                         for (j = 0; j < mci->csrows[i].nr_channels; j++)
 514                                 edac_mc_dump_channel(&mci->csrows[i].
 515                                                 channels[j]);
 516                 }
 517         }
 518 #endif
 519         mutex_lock(&mem_ctls_mutex);
 520
 521         if (add_mc_to_global_list(mci))
 522                 goto fail0;
 523
 524         /* set load time so that error rate can be tracked */
 525         mci->start_time = jiffies;
 526
 527         if (edac_create_sysfs_mci_device(mci)) {
 528                 edac_mc_printk(mci, KERN_WARNING,
 529                         "failed to create sysfs device\n");
 530                 goto fail1;
 531         }
 532
 533         /* If there IS a check routine, then we are running POLLED */
 534         if (mci->edac_check != NULL) {
 535                 /* This instance is NOW RUNNING */
 536                 mci->op_state = OP_RUNNING_POLL;
 537
 538                 edac_mc_workq_setup(mci, edac_mc_get_poll_msec());
 539         } else {
 540                 mci->op_state = OP_RUNNING_INTERRUPT;
 541         }
 542
 543         /* Report action taken */
 544         edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
 545                 " DEV %s\n", mci->mod_name, mci->ctl_name, edac_dev_name(mci));
 546
 547         mutex_unlock(&mem_ctls_mutex);
 548         return 0;
 549
 550 fail1:
 551         del_mc_from_global_list(mci);
 552
 553 fail0:
 554         mutex_unlock(&mem_ctls_mutex);
 555         return 1;
 556 }
 557 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
 558
 559 /**
 560  * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
 561  *                 remove mci structure from global list
 562  * @pdev: Pointer to 'struct device' representing mci structure to remove.
 563  *
 564  * Return pointer to removed mci structure, or NULL if device not found.
 565  */
 566 struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
 567 {
 568         struct mem_ctl_info *mci;
 569
 570         debugf0("%s()\n", __func__);
 571
 572         mutex_lock(&mem_ctls_mutex);
 573
 574         /* find the requested mci struct in the global list */
 575         mci = find_mci_by_dev(dev);
 576         if (mci == NULL) {
 577                 mutex_unlock(&mem_ctls_mutex);
 578                 return NULL;
 579         }
 580
 581         /* marking MCI offline */
 582         mci->op_state = OP_OFFLINE;
 583
 584         del_mc_from_global_list(mci);
 585         mutex_unlock(&mem_ctls_mutex);
 586
 587         /* flush workq processes and remove sysfs */
 588         edac_mc_workq_teardown(mci);
 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 dependant 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);