drivers/edac/edac_mc.c

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