SAFE public projects git trees. - safe/jmp/linux-2.6/blob - 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 struct list_head mc_devices = LIST_HEAD_INIT(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 /* 'ptr' points to a possibly unaligned item X such that sizeof(X) is 'size'.
  82  * Adjust 'ptr' so that its alignment is at least as stringent as what the
  83  * compiler would provide for X and return the aligned result.
  84  *
  85  * If 'size' is a constant, the compiler will optimize this whole function
  86  * down to either a no-op or the addition of a constant to the value of 'ptr'.
  87  */
  88 char *edac_align_ptr(void *ptr, unsigned size)
  89 {
  90         unsigned align, r;
  91
  92         /* Here we assume that the alignment of a "long long" is the most
  93          * stringent alignment that the compiler will ever provide by default.
  94          * As far as I know, this is a reasonable assumption.
  95          */
  96         if (size > sizeof(long))
  97                 align = sizeof(long long);
  98         else if (size > sizeof(int))
  99                 align = sizeof(long);
 100         else if (size > sizeof(short))
 101                 align = sizeof(int);
 102         else if (size > sizeof(char))
 103                 align = sizeof(short);
 104         else
 105                 return (char *)ptr;
 106
 107         r = size % align;
 108
 109         if (r == 0)
 110                 return (char *)ptr;
 111
 112         return (char *)(((unsigned long)ptr) + align - r);
 113 }
 114
 115 /**
 116  * edac_mc_alloc: Allocate a struct mem_ctl_info structure
 117  * @size_pvt:   size of private storage needed
 118  * @nr_csrows:  Number of CWROWS needed for this MC
 119  * @nr_chans:   Number of channels for the MC
 120  *
 121  * Everything is kmalloc'ed as one big chunk - more efficient.
 122  * Only can be used if all structures have the same lifetime - otherwise
 123  * you have to allocate and initialize your own structures.
 124  *
 125  * Use edac_mc_free() to free mc structures allocated by this function.
 126  *
 127  * Returns:
 128  *      NULL allocation failed
 129  *      struct mem_ctl_info pointer
 130  */
 131 struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows,
 132                                    unsigned nr_chans)
 133 {
 134         struct mem_ctl_info *mci;
 135         struct csrow_info *csi, *csrow;
 136         struct channel_info *chi, *chp, *chan;
 137         void *pvt;
 138         unsigned size;
 139         int row, chn;
 140
 141         /* Figure out the offsets of the various items from the start of an mc
 142          * structure.  We want the alignment of each item to be at least as
 143          * stringent as what the compiler would provide if we could simply
 144          * hardcode everything into a single struct.
 145          */
 146         mci = (struct mem_ctl_info *)0;
 147         csi = (struct csrow_info *)edac_align_ptr(&mci[1], sizeof(*csi));
 148         chi = (struct channel_info *)
 149             edac_align_ptr(&csi[nr_csrows], sizeof(*chi));
 150         pvt = edac_align_ptr(&chi[nr_chans * nr_csrows], sz_pvt);
 151         size = ((unsigned long)pvt) + sz_pvt;
 152
 153         if ((mci = kmalloc(size, GFP_KERNEL)) == NULL)
 154                 return NULL;
 155
 156         /* Adjust pointers so they point within the memory we just allocated
 157          * rather than an imaginary chunk of memory located at address 0.
 158          */
 159         csi = (struct csrow_info *)(((char *)mci) + ((unsigned long)csi));
 160         chi = (struct channel_info *)(((char *)mci) + ((unsigned long)chi));
 161         pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL;
 162
 163         memset(mci, 0, size);   /* clear all fields */
 164         mci->csrows = csi;
 165         mci->pvt_info = pvt;
 166         mci->nr_csrows = nr_csrows;
 167
 168         for (row = 0; row < nr_csrows; row++) {
 169                 csrow = &csi[row];
 170                 csrow->csrow_idx = row;
 171                 csrow->mci = mci;
 172                 csrow->nr_channels = nr_chans;
 173                 chp = &chi[row * nr_chans];
 174                 csrow->channels = chp;
 175
 176                 for (chn = 0; chn < nr_chans; chn++) {
 177                         chan = &chp[chn];
 178                         chan->chan_idx = chn;
 179                         chan->csrow = csrow;
 180                 }
 181         }
 182
 183         mci->op_state = OP_ALLOC;
 184
 185         return mci;
 186 }
 187
 188 EXPORT_SYMBOL_GPL(edac_mc_alloc);
 189
 190 /**
 191  * edac_mc_free:  Free a previously allocated 'mci' structure
 192  * @mci: pointer to a struct mem_ctl_info structure
 193  */
 194 void edac_mc_free(struct mem_ctl_info *mci)
 195 {
 196         kfree(mci);
 197 }
 198
 199 EXPORT_SYMBOL_GPL(edac_mc_free);
 200
 201 static struct mem_ctl_info *find_mci_by_dev(struct device *dev)
 202 {
 203         struct mem_ctl_info *mci;
 204         struct list_head *item;
 205
 206         debugf3("%s()\n", __func__);
 207
 208         list_for_each(item, &mc_devices) {
 209                 mci = list_entry(item, struct mem_ctl_info, link);
 210
 211                 if (mci->dev == dev)
 212                         return mci;
 213         }
 214
 215         return NULL;
 216 }
 217
 218 /*
 219  * handler for EDAC to check if NMI type handler has asserted interrupt
 220  */
 221 static int edac_mc_assert_error_check_and_clear(void)
 222 {
 223         int old_state;
 224
 225         if (edac_op_state == EDAC_OPSTATE_POLL)
 226                 return 1;
 227
 228         old_state = edac_err_assert;
 229         edac_err_assert = 0;
 230
 231         return old_state;
 232 }
 233
 234 /*
 235  * edac_mc_workq_function
 236  *      performs the operation scheduled by a workq request
 237  */
 238 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
 239 static void edac_mc_workq_function(struct work_struct *work_req)
 240 {
 241         struct delayed_work *d_work = (struct delayed_work *)work_req;
 242         struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
 243 #else
 244 static void edac_mc_workq_function(void *ptr)
 245 {
 246         struct mem_ctl_info *mci = (struct mem_ctl_info *)ptr;
 247 #endif
 248
 249         mutex_lock(&mem_ctls_mutex);
 250
 251         /* Only poll controllers that are running polled and have a check */
 252         if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL))
 253                 mci->edac_check(mci);
 254
 255         /*
 256          * FIXME: temp place holder for PCI checks,
 257          * goes away when we break out PCI
 258          */
 259         edac_pci_do_parity_check();
 260
 261         mutex_unlock(&mem_ctls_mutex);
 262
 263         /* Reschedule */
 264         queue_delayed_work(edac_workqueue, &mci->work,
 265                            msecs_to_jiffies(edac_mc_get_poll_msec()));
 266 }
 267
 268 /*
 269  * edac_mc_workq_setup
 270  *      initialize a workq item for this mci
 271  *      passing in the new delay period in msec
 272  */
 273 void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec)
 274 {
 275         debugf0("%s()\n", __func__);
 276
 277 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
 278         INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
 279 #else
 280         INIT_WORK(&mci->work, edac_mc_workq_function, mci);
 281 #endif
 282         queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
 283 }
 284
 285 /*
 286  * edac_mc_workq_teardown
 287  *      stop the workq processing on this mci
 288  */
 289 void edac_mc_workq_teardown(struct mem_ctl_info *mci)
 290 {
 291         int status;
 292
 293         status = cancel_delayed_work(&mci->work);
 294         if (status == 0) {
 295                 /* workq instance might be running, wait for it */
 296                 flush_workqueue(edac_workqueue);
 297         }
 298 }
 299
 300 /*
 301  * edac_reset_delay_period
 302  */
 303
 304 void edac_reset_delay_period(struct mem_ctl_info *mci, unsigned long value)
 305 {
 306         mutex_lock(&mem_ctls_mutex);
 307
 308         /* cancel the current workq request */
 309         edac_mc_workq_teardown(mci);
 310
 311         /* restart the workq request, with new delay value */
 312         edac_mc_workq_setup(mci, value);
 313
 314         mutex_unlock(&mem_ctls_mutex);
 315 }
 316
 317 /* Return 0 on success, 1 on failure.
 318  * Before calling this function, caller must
 319  * assign a unique value to mci->mc_idx.
 320  */
 321 static int add_mc_to_global_list(struct mem_ctl_info *mci)
 322 {
 323         struct list_head *item, *insert_before;
 324         struct mem_ctl_info *p;
 325
 326         insert_before = &mc_devices;
 327
 328         if (unlikely((p = find_mci_by_dev(mci->dev)) != NULL))
 329                 goto fail0;
 330
 331         list_for_each(item, &mc_devices) {
 332                 p = list_entry(item, struct mem_ctl_info, link);
 333
 334                 if (p->mc_idx >= mci->mc_idx) {
 335                         if (unlikely(p->mc_idx == mci->mc_idx))
 336                                 goto fail1;
 337
 338                         insert_before = item;
 339                         break;
 340                 }
 341         }
 342
 343         list_add_tail_rcu(&mci->link, insert_before);
 344         atomic_inc(&edac_handlers);
 345         return 0;
 346
 347       fail0:
 348         edac_printk(KERN_WARNING, EDAC_MC,
 349                     "%s (%s) %s %s already assigned %d\n", p->dev->bus_id,
 350                     dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
 351         return 1;
 352
 353       fail1:
 354         edac_printk(KERN_WARNING, EDAC_MC,
 355                     "bug in low-level driver: attempt to assign\n"
 356                     "    duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
 357         return 1;
 358 }
 359
 360 static void complete_mc_list_del(struct rcu_head *head)
 361 {
 362         struct mem_ctl_info *mci;
 363
 364         mci = container_of(head, struct mem_ctl_info, rcu);
 365         INIT_LIST_HEAD(&mci->link);
 366         complete(&mci->complete);
 367 }
 368
 369 static void del_mc_from_global_list(struct mem_ctl_info *mci)
 370 {
 371         atomic_dec(&edac_handlers);
 372         list_del_rcu(&mci->link);
 373         init_completion(&mci->complete);
 374         call_rcu(&mci->rcu, complete_mc_list_del);
 375         wait_for_completion(&mci->complete);
 376 }
 377
 378 /**
 379  * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
 380  *
 381  * If found, return a pointer to the structure.
 382  * Else return NULL.
 383  *
 384  * Caller must hold mem_ctls_mutex.
 385  */
 386 struct mem_ctl_info *edac_mc_find(int idx)
 387 {
 388         struct list_head *item;
 389         struct mem_ctl_info *mci;
 390
 391         list_for_each(item, &mc_devices) {
 392                 mci = list_entry(item, struct mem_ctl_info, link);
 393
 394                 if (mci->mc_idx >= idx) {
 395                         if (mci->mc_idx == idx)
 396                                 return mci;
 397
 398                         break;
 399                 }
 400         }
 401
 402         return NULL;
 403 }
 404
 405 EXPORT_SYMBOL(edac_mc_find);
 406
 407 /**
 408  * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
 409  *                 create sysfs entries associated with mci structure
 410  * @mci: pointer to the mci structure to be added to the list
 411  * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
 412  *
 413  * Return:
 414  *      0       Success
 415  *      !0      Failure
 416  */
 417
 418 /* FIXME - should a warning be printed if no error detection? correction? */
 419 int edac_mc_add_mc(struct mem_ctl_info *mci, int mc_idx)
 420 {
 421         debugf0("%s()\n", __func__);
 422         mci->mc_idx = mc_idx;
 423 #ifdef CONFIG_EDAC_DEBUG
 424         if (edac_debug_level >= 3)
 425                 edac_mc_dump_mci(mci);
 426
 427         if (edac_debug_level >= 4) {
 428                 int i;
 429
 430                 for (i = 0; i < mci->nr_csrows; i++) {
 431                         int j;
 432
 433                         edac_mc_dump_csrow(&mci->csrows[i]);
 434                         for (j = 0; j < mci->csrows[i].nr_channels; j++)
 435                                 edac_mc_dump_channel(&mci->csrows[i].
 436                                                      channels[j]);
 437                 }
 438         }
 439 #endif
 440         mutex_lock(&mem_ctls_mutex);
 441
 442         if (add_mc_to_global_list(mci))
 443                 goto fail0;
 444
 445         /* set load time so that error rate can be tracked */
 446         mci->start_time = jiffies;
 447
 448         if (edac_create_sysfs_mci_device(mci)) {
 449                 edac_mc_printk(mci, KERN_WARNING,
 450                                "failed to create sysfs device\n");
 451                 goto fail1;
 452         }
 453
 454         /* If there IS a check routine, then we are running POLLED */
 455         if (mci->edac_check != NULL) {
 456                 /* This instance is NOW RUNNING */
 457                 mci->op_state = OP_RUNNING_POLL;
 458
 459                 edac_mc_workq_setup(mci, edac_mc_get_poll_msec());
 460         } else {
 461                 mci->op_state = OP_RUNNING_INTERRUPT;
 462         }
 463
 464         /* Report action taken */
 465         edac_mc_printk(mci, KERN_INFO, "Giving out device to %s %s: DEV %s\n",
 466                        mci->mod_name, mci->ctl_name, dev_name(mci));
 467
 468         mutex_unlock(&mem_ctls_mutex);
 469         return 0;
 470
 471       fail1:
 472         del_mc_from_global_list(mci);
 473
 474       fail0:
 475         mutex_unlock(&mem_ctls_mutex);
 476         return 1;
 477 }
 478
 479 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
 480
 481 /**
 482  * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
 483  *                 remove mci structure from global list
 484  * @pdev: Pointer to 'struct device' representing mci structure to remove.
 485  *
 486  * Return pointer to removed mci structure, or NULL if device not found.
 487  */
 488 struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
 489 {
 490         struct mem_ctl_info *mci;
 491
 492         debugf0("MC: %s()\n", __func__);
 493         mutex_lock(&mem_ctls_mutex);
 494
 495         if ((mci = find_mci_by_dev(dev)) == NULL) {
 496                 mutex_unlock(&mem_ctls_mutex);
 497                 return NULL;
 498         }
 499
 500         /* marking MCI offline */
 501         mci->op_state = OP_OFFLINE;
 502
 503         /* flush workq processes */
 504         edac_mc_workq_teardown(mci);
 505
 506         edac_remove_sysfs_mci_device(mci);
 507         del_mc_from_global_list(mci);
 508         mutex_unlock(&mem_ctls_mutex);
 509         edac_printk(KERN_INFO, EDAC_MC,
 510                     "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
 511                     mci->mod_name, mci->ctl_name, dev_name(mci));
 512         return mci;
 513 }
 514
 515 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
 516
 517 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
 518                                 u32 size)
 519 {
 520         struct page *pg;
 521         void *virt_addr;
 522         unsigned long flags = 0;
 523
 524         debugf3("%s()\n", __func__);
 525
 526         /* ECC error page was not in our memory. Ignore it. */
 527         if (!pfn_valid(page))
 528                 return;
 529
 530         /* Find the actual page structure then map it and fix */
 531         pg = pfn_to_page(page);
 532
 533         if (PageHighMem(pg))
 534                 local_irq_save(flags);
 535
 536         virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);
 537
 538         /* Perform architecture specific atomic scrub operation */
 539         atomic_scrub(virt_addr + offset, size);
 540
 541         /* Unmap and complete */
 542         kunmap_atomic(virt_addr, KM_BOUNCE_READ);
 543
 544         if (PageHighMem(pg))
 545                 local_irq_restore(flags);
 546 }
 547
 548 /* FIXME - should return -1 */
 549 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
 550 {
 551         struct csrow_info *csrows = mci->csrows;
 552         int row, i;
 553
 554         debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
 555         row = -1;
 556
 557         for (i = 0; i < mci->nr_csrows; i++) {
 558                 struct csrow_info *csrow = &csrows[i];
 559
 560                 if (csrow->nr_pages == 0)
 561                         continue;
 562
 563                 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
 564                         "mask(0x%lx)\n", mci->mc_idx, __func__,
 565                         csrow->first_page, page, csrow->last_page,
 566                         csrow->page_mask);
 567
 568                 if ((page >= csrow->first_page) &&
 569                     (page <= csrow->last_page) &&
 570                     ((page & csrow->page_mask) ==
 571                      (csrow->first_page & csrow->page_mask))) {
 572                         row = i;
 573                         break;
 574                 }
 575         }
 576
 577         if (row == -1)
 578                 edac_mc_printk(mci, KERN_ERR,
 579                                "could not look up page error address %lx\n",
 580                                (unsigned long)page);
 581
 582         return row;
 583 }
 584
 585 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
 586
 587 /* FIXME - setable log (warning/emerg) levels */
 588 /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
 589 void edac_mc_handle_ce(struct mem_ctl_info *mci,
 590                        unsigned long page_frame_number,
 591                        unsigned long offset_in_page, unsigned long syndrome,
 592                        int row, int channel, const char *msg)
 593 {
 594         unsigned long remapped_page;
 595
 596         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
 597
 598         /* FIXME - maybe make panic on INTERNAL ERROR an option */
 599         if (row >= mci->nr_csrows || row < 0) {
 600                 /* something is wrong */
 601                 edac_mc_printk(mci, KERN_ERR,
 602                                "INTERNAL ERROR: row out of range "
 603                                "(%d >= %d)\n", row, mci->nr_csrows);
 604                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 605                 return;
 606         }
 607
 608         if (channel >= mci->csrows[row].nr_channels || channel < 0) {
 609                 /* something is wrong */
 610                 edac_mc_printk(mci, KERN_ERR,
 611                                "INTERNAL ERROR: channel out of range "
 612                                "(%d >= %d)\n", channel,
 613                                mci->csrows[row].nr_channels);
 614                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 615                 return;
 616         }
 617
 618         if (edac_mc_get_log_ce())
 619                 /* FIXME - put in DIMM location */
 620                 edac_mc_printk(mci, KERN_WARNING,
 621                                "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
 622                                "0x%lx, row %d, channel %d, label \"%s\": %s\n",
 623                                page_frame_number, offset_in_page,
 624                                mci->csrows[row].grain, syndrome, row, channel,
 625                                mci->csrows[row].channels[channel].label, msg);
 626
 627         mci->ce_count++;
 628         mci->csrows[row].ce_count++;
 629         mci->csrows[row].channels[channel].ce_count++;
 630
 631         if (mci->scrub_mode & SCRUB_SW_SRC) {
 632                 /*
 633                  * Some MC's can remap memory so that it is still available
 634                  * at a different address when PCI devices map into memory.
 635                  * MC's that can't do this lose the memory where PCI devices
 636                  * are mapped.  This mapping is MC dependant and so we call
 637                  * back into the MC driver for it to map the MC page to
 638                  * a physical (CPU) page which can then be mapped to a virtual
 639                  * page - which can then be scrubbed.
 640                  */
 641                 remapped_page = mci->ctl_page_to_phys ?
 642                     mci->ctl_page_to_phys(mci, page_frame_number) :
 643                     page_frame_number;
 644
 645                 edac_mc_scrub_block(remapped_page, offset_in_page,
 646                                     mci->csrows[row].grain);
 647         }
 648 }
 649
 650 EXPORT_SYMBOL_GPL(edac_mc_handle_ce);
 651
 652 void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
 653 {
 654         if (edac_mc_get_log_ce())
 655                 edac_mc_printk(mci, KERN_WARNING,
 656                                "CE - no information available: %s\n", msg);
 657
 658         mci->ce_noinfo_count++;
 659         mci->ce_count++;
 660 }
 661
 662 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);
 663
 664 void edac_mc_handle_ue(struct mem_ctl_info *mci,
 665                        unsigned long page_frame_number,
 666                        unsigned long offset_in_page, int row, const char *msg)
 667 {
 668         int len = EDAC_MC_LABEL_LEN * 4;
 669         char labels[len + 1];
 670         char *pos = labels;
 671         int chan;
 672         int chars;
 673
 674         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
 675
 676         /* FIXME - maybe make panic on INTERNAL ERROR an option */
 677         if (row >= mci->nr_csrows || row < 0) {
 678                 /* something is wrong */
 679                 edac_mc_printk(mci, KERN_ERR,
 680                                "INTERNAL ERROR: row out of range "
 681                                "(%d >= %d)\n", row, mci->nr_csrows);
 682                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 683                 return;
 684         }
 685
 686         chars = snprintf(pos, len + 1, "%s",
 687                          mci->csrows[row].channels[0].label);
 688         len -= chars;
 689         pos += chars;
 690
 691         for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
 692              chan++) {
 693                 chars = snprintf(pos, len + 1, ":%s",
 694                                  mci->csrows[row].channels[chan].label);
 695                 len -= chars;
 696                 pos += chars;
 697         }
 698
 699         if (edac_mc_get_log_ue())
 700                 edac_mc_printk(mci, KERN_EMERG,
 701                                "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
 702                                "labels \"%s\": %s\n", page_frame_number,
 703                                offset_in_page, mci->csrows[row].grain, row,
 704                                labels, msg);
 705
 706         if (edac_mc_get_panic_on_ue())
 707                 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
 708                       "row %d, labels \"%s\": %s\n", mci->mc_idx,
 709                       page_frame_number, offset_in_page,
 710                       mci->csrows[row].grain, row, labels, msg);
 711
 712         mci->ue_count++;
 713         mci->csrows[row].ue_count++;
 714 }
 715
 716 EXPORT_SYMBOL_GPL(edac_mc_handle_ue);
 717
 718 void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
 719 {
 720         if (edac_mc_get_panic_on_ue())
 721                 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
 722
 723         if (edac_mc_get_log_ue())
 724                 edac_mc_printk(mci, KERN_WARNING,
 725                                "UE - no information available: %s\n", msg);
 726         mci->ue_noinfo_count++;
 727         mci->ue_count++;
 728 }
 729
 730 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);
 731
 732 /*************************************************************
 733  * On Fully Buffered DIMM modules, this help function is
 734  * called to process UE events
 735  */
 736 void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci,
 737                            unsigned int csrow,
 738                            unsigned int channela,
 739                            unsigned int channelb, char *msg)
 740 {
 741         int len = EDAC_MC_LABEL_LEN * 4;
 742         char labels[len + 1];
 743         char *pos = labels;
 744         int chars;
 745
 746         if (csrow >= mci->nr_csrows) {
 747                 /* something is wrong */
 748                 edac_mc_printk(mci, KERN_ERR,
 749                                "INTERNAL ERROR: row out of range (%d >= %d)\n",
 750                                csrow, mci->nr_csrows);
 751                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 752                 return;
 753         }
 754
 755         if (channela >= mci->csrows[csrow].nr_channels) {
 756                 /* something is wrong */
 757                 edac_mc_printk(mci, KERN_ERR,
 758                                "INTERNAL ERROR: channel-a out of range "
 759                                "(%d >= %d)\n",
 760                                channela, mci->csrows[csrow].nr_channels);
 761                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 762                 return;
 763         }
 764
 765         if (channelb >= mci->csrows[csrow].nr_channels) {
 766                 /* something is wrong */
 767                 edac_mc_printk(mci, KERN_ERR,
 768                                "INTERNAL ERROR: channel-b out of range "
 769                                "(%d >= %d)\n",
 770                                channelb, mci->csrows[csrow].nr_channels);
 771                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 772                 return;
 773         }
 774
 775         mci->ue_count++;
 776         mci->csrows[csrow].ue_count++;
 777
 778         /* Generate the DIMM labels from the specified channels */
 779         chars = snprintf(pos, len + 1, "%s",
 780                          mci->csrows[csrow].channels[channela].label);
 781         len -= chars;
 782         pos += chars;
 783         chars = snprintf(pos, len + 1, "-%s",
 784                          mci->csrows[csrow].channels[channelb].label);
 785
 786         if (edac_mc_get_log_ue())
 787                 edac_mc_printk(mci, KERN_EMERG,
 788                                "UE row %d, channel-a= %d channel-b= %d "
 789                                "labels \"%s\": %s\n", csrow, channela, channelb,
 790                                labels, msg);
 791
 792         if (edac_mc_get_panic_on_ue())
 793                 panic("UE row %d, channel-a= %d channel-b= %d "
 794                       "labels \"%s\": %s\n", csrow, channela,
 795                       channelb, labels, msg);
 796 }
 797
 798 EXPORT_SYMBOL(edac_mc_handle_fbd_ue);
 799
 800 /*************************************************************
 801  * On Fully Buffered DIMM modules, this help function is
 802  * called to process CE events
 803  */
 804 void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
 805                            unsigned int csrow, unsigned int channel, char *msg)
 806 {
 807
 808         /* Ensure boundary values */
 809         if (csrow >= mci->nr_csrows) {
 810                 /* something is wrong */
 811                 edac_mc_printk(mci, KERN_ERR,
 812                                "INTERNAL ERROR: row out of range (%d >= %d)\n",
 813                                csrow, mci->nr_csrows);
 814                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 815                 return;
 816         }
 817         if (channel >= mci->csrows[csrow].nr_channels) {
 818                 /* something is wrong */
 819                 edac_mc_printk(mci, KERN_ERR,
 820                                "INTERNAL ERROR: channel out of range (%d >= %d)\n",
 821                                channel, mci->csrows[csrow].nr_channels);
 822                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 823                 return;
 824         }
 825
 826         if (edac_mc_get_log_ce())
 827                 /* FIXME - put in DIMM location */
 828                 edac_mc_printk(mci, KERN_WARNING,
 829                                "CE row %d, channel %d, label \"%s\": %s\n",
 830                                csrow, channel,
 831                                mci->csrows[csrow].channels[channel].label, msg);
 832
 833         mci->ce_count++;
 834         mci->csrows[csrow].ce_count++;
 835         mci->csrows[csrow].channels[channel].ce_count++;
 836 }
 837
 838 EXPORT_SYMBOL(edac_mc_handle_fbd_ce);
 839
 840 /*
 841  * Iterate over all MC instances and check for ECC, et al, errors
 842  */
 843 void edac_check_mc_devices(void)
 844 {
 845         struct list_head *item;
 846         struct mem_ctl_info *mci;
 847
 848         debugf3("%s()\n", __func__);
 849         mutex_lock(&mem_ctls_mutex);
 850
 851         list_for_each(item, &mc_devices) {
 852                 mci = list_entry(item, struct mem_ctl_info, link);
 853
 854                 if (mci->edac_check != NULL)
 855                         mci->edac_check(mci);
 856         }
 857
 858         mutex_unlock(&mem_ctls_mutex);
 859 }