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