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         del_mc_from_global_list(mci);
 582         mutex_unlock(&mem_ctls_mutex);
 583
 584         /* flush workq processes */
 585         edac_mc_workq_teardown(mci);
 586
 587         /* marking MCI offline */
 588         mci->op_state = OP_OFFLINE;
 589
 590         /* remove from sysfs */
 591         edac_remove_sysfs_mci_device(mci);
 592
 593         edac_printk(KERN_INFO, EDAC_MC,
 594                 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
 595                 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
 596
 597         return mci;
 598 }
 599 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
 600
 601 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
 602                                 u32 size)
 603 {
 604         struct page *pg;
 605         void *virt_addr;
 606         unsigned long flags = 0;
 607
 608         debugf3("%s()\n", __func__);
 609
 610         /* ECC error page was not in our memory. Ignore it. */
 611         if (!pfn_valid(page))
 612                 return;
 613
 614         /* Find the actual page structure then map it and fix */
 615         pg = pfn_to_page(page);
 616
 617         if (PageHighMem(pg))
 618                 local_irq_save(flags);
 619
 620         virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);
 621
 622         /* Perform architecture specific atomic scrub operation */
 623         atomic_scrub(virt_addr + offset, size);
 624
 625         /* Unmap and complete */
 626         kunmap_atomic(virt_addr, KM_BOUNCE_READ);
 627
 628         if (PageHighMem(pg))
 629                 local_irq_restore(flags);
 630 }
 631
 632 /* FIXME - should return -1 */
 633 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
 634 {
 635         struct csrow_info *csrows = mci->csrows;
 636         int row, i;
 637
 638         debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
 639         row = -1;
 640
 641         for (i = 0; i < mci->nr_csrows; i++) {
 642                 struct csrow_info *csrow = &csrows[i];
 643
 644                 if (csrow->nr_pages == 0)
 645                         continue;
 646
 647                 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
 648                         "mask(0x%lx)\n", mci->mc_idx, __func__,
 649                         csrow->first_page, page, csrow->last_page,
 650                         csrow->page_mask);
 651
 652                 if ((page >= csrow->first_page) &&
 653                     (page <= csrow->last_page) &&
 654                     ((page & csrow->page_mask) ==
 655                      (csrow->first_page & csrow->page_mask))) {
 656                         row = i;
 657                         break;
 658                 }
 659         }
 660
 661         if (row == -1)
 662                 edac_mc_printk(mci, KERN_ERR,
 663                         "could not look up page error address %lx\n",
 664                         (unsigned long)page);
 665
 666         return row;
 667 }
 668 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
 669
 670 /* FIXME - setable log (warning/emerg) levels */
 671 /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
 672 void edac_mc_handle_ce(struct mem_ctl_info *mci,
 673                 unsigned long page_frame_number,
 674                 unsigned long offset_in_page, unsigned long syndrome,
 675                 int row, int channel, const char *msg)
 676 {
 677         unsigned long remapped_page;
 678
 679         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
 680
 681         /* FIXME - maybe make panic on INTERNAL ERROR an option */
 682         if (row >= mci->nr_csrows || row < 0) {
 683                 /* something is wrong */
 684                 edac_mc_printk(mci, KERN_ERR,
 685                         "INTERNAL ERROR: row out of range "
 686                         "(%d >= %d)\n", row, mci->nr_csrows);
 687                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 688                 return;
 689         }
 690
 691         if (channel >= mci->csrows[row].nr_channels || channel < 0) {
 692                 /* something is wrong */
 693                 edac_mc_printk(mci, KERN_ERR,
 694                         "INTERNAL ERROR: channel out of range "
 695                         "(%d >= %d)\n", channel,
 696                         mci->csrows[row].nr_channels);
 697                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 698                 return;
 699         }
 700
 701         if (edac_mc_get_log_ce())
 702                 /* FIXME - put in DIMM location */
 703                 edac_mc_printk(mci, KERN_WARNING,
 704                         "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
 705                         "0x%lx, row %d, channel %d, label \"%s\": %s\n",
 706                         page_frame_number, offset_in_page,
 707                         mci->csrows[row].grain, syndrome, row, channel,
 708                         mci->csrows[row].channels[channel].label, msg);
 709
 710         mci->ce_count++;
 711         mci->csrows[row].ce_count++;
 712         mci->csrows[row].channels[channel].ce_count++;
 713
 714         if (mci->scrub_mode & SCRUB_SW_SRC) {
 715                 /*
 716                  * Some MC's can remap memory so that it is still available
 717                  * at a different address when PCI devices map into memory.
 718                  * MC's that can't do this lose the memory where PCI devices
 719                  * are mapped.  This mapping is MC dependant and so we call
 720                  * back into the MC driver for it to map the MC page to
 721                  * a physical (CPU) page which can then be mapped to a virtual
 722                  * page - which can then be scrubbed.
 723                  */
 724                 remapped_page = mci->ctl_page_to_phys ?
 725                         mci->ctl_page_to_phys(mci, page_frame_number) :
 726                         page_frame_number;
 727
 728                 edac_mc_scrub_block(remapped_page, offset_in_page,
 729                                 mci->csrows[row].grain);
 730         }
 731 }
 732 EXPORT_SYMBOL_GPL(edac_mc_handle_ce);
 733
 734 void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
 735 {
 736         if (edac_mc_get_log_ce())
 737                 edac_mc_printk(mci, KERN_WARNING,
 738                         "CE - no information available: %s\n", msg);
 739
 740         mci->ce_noinfo_count++;
 741         mci->ce_count++;
 742 }
 743 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);
 744
 745 void edac_mc_handle_ue(struct mem_ctl_info *mci,
 746                 unsigned long page_frame_number,
 747                 unsigned long offset_in_page, int row, const char *msg)
 748 {
 749         int len = EDAC_MC_LABEL_LEN * 4;
 750         char labels[len + 1];
 751         char *pos = labels;
 752         int chan;
 753         int chars;
 754
 755         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
 756
 757         /* FIXME - maybe make panic on INTERNAL ERROR an option */
 758         if (row >= mci->nr_csrows || row < 0) {
 759                 /* something is wrong */
 760                 edac_mc_printk(mci, KERN_ERR,
 761                         "INTERNAL ERROR: row out of range "
 762                         "(%d >= %d)\n", row, mci->nr_csrows);
 763                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 764                 return;
 765         }
 766
 767         chars = snprintf(pos, len + 1, "%s",
 768                          mci->csrows[row].channels[0].label);
 769         len -= chars;
 770         pos += chars;
 771
 772         for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
 773                 chan++) {
 774                 chars = snprintf(pos, len + 1, ":%s",
 775                                  mci->csrows[row].channels[chan].label);
 776                 len -= chars;
 777                 pos += chars;
 778         }
 779
 780         if (edac_mc_get_log_ue())
 781                 edac_mc_printk(mci, KERN_EMERG,
 782                         "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
 783                         "labels \"%s\": %s\n", page_frame_number,
 784                         offset_in_page, mci->csrows[row].grain, row,
 785                         labels, msg);
 786
 787         if (edac_mc_get_panic_on_ue())
 788                 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
 789                         "row %d, labels \"%s\": %s\n", mci->mc_idx,
 790                         page_frame_number, offset_in_page,
 791                         mci->csrows[row].grain, row, labels, msg);
 792
 793         mci->ue_count++;
 794         mci->csrows[row].ue_count++;
 795 }
 796 EXPORT_SYMBOL_GPL(edac_mc_handle_ue);
 797
 798 void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
 799 {
 800         if (edac_mc_get_panic_on_ue())
 801                 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
 802
 803         if (edac_mc_get_log_ue())
 804                 edac_mc_printk(mci, KERN_WARNING,
 805                         "UE - no information available: %s\n", msg);
 806         mci->ue_noinfo_count++;
 807         mci->ue_count++;
 808 }
 809 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);
 810
 811 /*************************************************************
 812  * On Fully Buffered DIMM modules, this help function is
 813  * called to process UE events
 814  */
 815 void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci,
 816                         unsigned int csrow,
 817                         unsigned int channela,
 818                         unsigned int channelb, char *msg)
 819 {
 820         int len = EDAC_MC_LABEL_LEN * 4;
 821         char labels[len + 1];
 822         char *pos = labels;
 823         int chars;
 824
 825         if (csrow >= mci->nr_csrows) {
 826                 /* something is wrong */
 827                 edac_mc_printk(mci, KERN_ERR,
 828                         "INTERNAL ERROR: row out of range (%d >= %d)\n",
 829                         csrow, mci->nr_csrows);
 830                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 831                 return;
 832         }
 833
 834         if (channela >= mci->csrows[csrow].nr_channels) {
 835                 /* something is wrong */
 836                 edac_mc_printk(mci, KERN_ERR,
 837                         "INTERNAL ERROR: channel-a out of range "
 838                         "(%d >= %d)\n",
 839                         channela, mci->csrows[csrow].nr_channels);
 840                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 841                 return;
 842         }
 843
 844         if (channelb >= mci->csrows[csrow].nr_channels) {
 845                 /* something is wrong */
 846                 edac_mc_printk(mci, KERN_ERR,
 847                         "INTERNAL ERROR: channel-b out of range "
 848                         "(%d >= %d)\n",
 849                         channelb, mci->csrows[csrow].nr_channels);
 850                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 851                 return;
 852         }
 853
 854         mci->ue_count++;
 855         mci->csrows[csrow].ue_count++;
 856
 857         /* Generate the DIMM labels from the specified channels */
 858         chars = snprintf(pos, len + 1, "%s",
 859                          mci->csrows[csrow].channels[channela].label);
 860         len -= chars;
 861         pos += chars;
 862         chars = snprintf(pos, len + 1, "-%s",
 863                          mci->csrows[csrow].channels[channelb].label);
 864
 865         if (edac_mc_get_log_ue())
 866                 edac_mc_printk(mci, KERN_EMERG,
 867                         "UE row %d, channel-a= %d channel-b= %d "
 868                         "labels \"%s\": %s\n", csrow, channela, channelb,
 869                         labels, msg);
 870
 871         if (edac_mc_get_panic_on_ue())
 872                 panic("UE row %d, channel-a= %d channel-b= %d "
 873                         "labels \"%s\": %s\n", csrow, channela,
 874                         channelb, labels, msg);
 875 }
 876 EXPORT_SYMBOL(edac_mc_handle_fbd_ue);
 877
 878 /*************************************************************
 879  * On Fully Buffered DIMM modules, this help function is
 880  * called to process CE events
 881  */
 882 void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
 883                         unsigned int csrow, unsigned int channel, char *msg)
 884 {
 885
 886         /* Ensure boundary values */
 887         if (csrow >= mci->nr_csrows) {
 888                 /* something is wrong */
 889                 edac_mc_printk(mci, KERN_ERR,
 890                         "INTERNAL ERROR: row out of range (%d >= %d)\n",
 891                         csrow, mci->nr_csrows);
 892                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 893                 return;
 894         }
 895         if (channel >= mci->csrows[csrow].nr_channels) {
 896                 /* something is wrong */
 897                 edac_mc_printk(mci, KERN_ERR,
 898                         "INTERNAL ERROR: channel out of range (%d >= %d)\n",
 899                         channel, mci->csrows[csrow].nr_channels);
 900                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 901                 return;
 902         }
 903
 904         if (edac_mc_get_log_ce())
 905                 /* FIXME - put in DIMM location */
 906                 edac_mc_printk(mci, KERN_WARNING,
 907                         "CE row %d, channel %d, label \"%s\": %s\n",
 908                         csrow, channel,
 909                         mci->csrows[csrow].channels[channel].label, msg);
 910
 911         mci->ce_count++;
 912         mci->csrows[csrow].ce_count++;
 913         mci->csrows[csrow].channels[channel].ce_count++;
 914 }
 915 EXPORT_SYMBOL(edac_mc_handle_fbd_ce);