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         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 EXPORT_SYMBOL_GPL(edac_mc_free);
 243
 244
 245 /**
 246  * find_mci_by_dev
 247  *
 248  *      scan list of controllers looking for the one that manages
 249  *      the 'dev' device
 250  * @dev: pointer to a struct device related with the MCI
 251  */
 252 struct mem_ctl_info *find_mci_by_dev(struct device *dev)
 253 {
 254         struct mem_ctl_info *mci;
 255         struct list_head *item;
 256
 257         debugf3("%s()\n", __func__);
 258
 259         list_for_each(item, &mc_devices) {
 260                 mci = list_entry(item, struct mem_ctl_info, link);
 261
 262                 if (mci->dev == dev)
 263                         return mci;
 264         }
 265
 266         return NULL;
 267 }
 268 EXPORT_SYMBOL_GPL(find_mci_by_dev);
 269
 270 /*
 271  * handler for EDAC to check if NMI type handler has asserted interrupt
 272  */
 273 static int edac_mc_assert_error_check_and_clear(void)
 274 {
 275         int old_state;
 276
 277         if (edac_op_state == EDAC_OPSTATE_POLL)
 278                 return 1;
 279
 280         old_state = edac_err_assert;
 281         edac_err_assert = 0;
 282
 283         return old_state;
 284 }
 285
 286 /*
 287  * edac_mc_workq_function
 288  *      performs the operation scheduled by a workq request
 289  */
 290 static void edac_mc_workq_function(struct work_struct *work_req)
 291 {
 292         struct delayed_work *d_work = to_delayed_work(work_req);
 293         struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
 294
 295         mutex_lock(&mem_ctls_mutex);
 296
 297         /* if this control struct has movd to offline state, we are done */
 298         if (mci->op_state == OP_OFFLINE) {
 299                 mutex_unlock(&mem_ctls_mutex);
 300                 return;
 301         }
 302
 303         /* Only poll controllers that are running polled and have a check */
 304         if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL))
 305                 mci->edac_check(mci);
 306
 307         mutex_unlock(&mem_ctls_mutex);
 308
 309         /* Reschedule */
 310         queue_delayed_work(edac_workqueue, &mci->work,
 311                         msecs_to_jiffies(edac_mc_get_poll_msec()));
 312 }
 313
 314 /*
 315  * edac_mc_workq_setup
 316  *      initialize a workq item for this mci
 317  *      passing in the new delay period in msec
 318  *
 319  *      locking model:
 320  *
 321  *              called with the mem_ctls_mutex held
 322  */
 323 static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec)
 324 {
 325         debugf0("%s()\n", __func__);
 326
 327         /* if this instance is not in the POLL state, then simply return */
 328         if (mci->op_state != OP_RUNNING_POLL)
 329                 return;
 330
 331         INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
 332         queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
 333 }
 334
 335 /*
 336  * edac_mc_workq_teardown
 337  *      stop the workq processing on this mci
 338  *
 339  *      locking model:
 340  *
 341  *              called WITHOUT lock held
 342  */
 343 static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
 344 {
 345         int status;
 346
 347         if (mci->op_state != OP_RUNNING_POLL)
 348                 return;
 349
 350         status = cancel_delayed_work(&mci->work);
 351         if (status == 0) {
 352                 debugf0("%s() not canceled, flush the queue\n",
 353                         __func__);
 354
 355                 /* workq instance might be running, wait for it */
 356                 flush_workqueue(edac_workqueue);
 357         }
 358 }
 359
 360 /*
 361  * edac_mc_reset_delay_period(unsigned long value)
 362  *
 363  *      user space has updated our poll period value, need to
 364  *      reset our workq delays
 365  */
 366 void edac_mc_reset_delay_period(int value)
 367 {
 368         struct mem_ctl_info *mci;
 369         struct list_head *item;
 370
 371         mutex_lock(&mem_ctls_mutex);
 372
 373         /* scan the list and turn off all workq timers, doing so under lock
 374          */
 375         list_for_each(item, &mc_devices) {
 376                 mci = list_entry(item, struct mem_ctl_info, link);
 377
 378                 if (mci->op_state == OP_RUNNING_POLL)
 379                         cancel_delayed_work(&mci->work);
 380         }
 381
 382         mutex_unlock(&mem_ctls_mutex);
 383
 384
 385         /* re-walk the list, and reset the poll delay */
 386         mutex_lock(&mem_ctls_mutex);
 387
 388         list_for_each(item, &mc_devices) {
 389                 mci = list_entry(item, struct mem_ctl_info, link);
 390
 391                 edac_mc_workq_setup(mci, (unsigned long) value);
 392         }
 393
 394         mutex_unlock(&mem_ctls_mutex);
 395 }
 396
 397
 398
 399 /* Return 0 on success, 1 on failure.
 400  * Before calling this function, caller must
 401  * assign a unique value to mci->mc_idx.
 402  *
 403  *      locking model:
 404  *
 405  *              called with the mem_ctls_mutex lock held
 406  */
 407 static int add_mc_to_global_list(struct mem_ctl_info *mci)
 408 {
 409         struct list_head *item, *insert_before;
 410         struct mem_ctl_info *p;
 411
 412         insert_before = &mc_devices;
 413
 414         p = find_mci_by_dev(mci->dev);
 415         if (unlikely(p != NULL))
 416                 goto fail0;
 417
 418         list_for_each(item, &mc_devices) {
 419                 p = list_entry(item, struct mem_ctl_info, link);
 420
 421                 if (p->mc_idx >= mci->mc_idx) {
 422                         if (unlikely(p->mc_idx == mci->mc_idx))
 423                                 goto fail1;
 424
 425                         insert_before = item;
 426                         break;
 427                 }
 428         }
 429
 430         list_add_tail_rcu(&mci->link, insert_before);
 431         atomic_inc(&edac_handlers);
 432         return 0;
 433
 434 fail0:
 435         edac_printk(KERN_WARNING, EDAC_MC,
 436                 "%s (%s) %s %s already assigned %d\n", dev_name(p->dev),
 437                 edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
 438         return 1;
 439
 440 fail1:
 441         edac_printk(KERN_WARNING, EDAC_MC,
 442                 "bug in low-level driver: attempt to assign\n"
 443                 "    duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
 444         return 1;
 445 }
 446
 447 static void complete_mc_list_del(struct rcu_head *head)
 448 {
 449         struct mem_ctl_info *mci;
 450
 451         mci = container_of(head, struct mem_ctl_info, rcu);
 452         INIT_LIST_HEAD(&mci->link);
 453 }
 454
 455 static void del_mc_from_global_list(struct mem_ctl_info *mci)
 456 {
 457         atomic_dec(&edac_handlers);
 458         list_del_rcu(&mci->link);
 459         call_rcu(&mci->rcu, complete_mc_list_del);
 460         rcu_barrier();
 461 }
 462
 463 /**
 464  * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
 465  *
 466  * If found, return a pointer to the structure.
 467  * Else return NULL.
 468  *
 469  * Caller must hold mem_ctls_mutex.
 470  */
 471 struct mem_ctl_info *edac_mc_find(int idx)
 472 {
 473         struct list_head *item;
 474         struct mem_ctl_info *mci;
 475
 476         list_for_each(item, &mc_devices) {
 477                 mci = list_entry(item, struct mem_ctl_info, link);
 478
 479                 if (mci->mc_idx >= idx) {
 480                         if (mci->mc_idx == idx)
 481                                 return mci;
 482
 483                         break;
 484                 }
 485         }
 486
 487         return NULL;
 488 }
 489 EXPORT_SYMBOL(edac_mc_find);
 490
 491 /**
 492  * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
 493  *                 create sysfs entries associated with mci structure
 494  * @mci: pointer to the mci structure to be added to the list
 495  * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
 496  *
 497  * Return:
 498  *      0       Success
 499  *      !0      Failure
 500  */
 501
 502 /* FIXME - should a warning be printed if no error detection? correction? */
 503 int edac_mc_add_mc(struct mem_ctl_info *mci)
 504 {
 505         debugf0("%s()\n", __func__);
 506
 507 #ifdef CONFIG_EDAC_DEBUG
 508         if (edac_debug_level >= 3)
 509                 edac_mc_dump_mci(mci);
 510
 511         if (edac_debug_level >= 4) {
 512                 int i;
 513
 514                 for (i = 0; i < mci->nr_csrows; i++) {
 515                         int j;
 516
 517                         edac_mc_dump_csrow(&mci->csrows[i]);
 518                         for (j = 0; j < mci->csrows[i].nr_channels; j++)
 519                                 edac_mc_dump_channel(&mci->csrows[i].
 520                                                 channels[j]);
 521                 }
 522         }
 523 #endif
 524         mutex_lock(&mem_ctls_mutex);
 525
 526         if (add_mc_to_global_list(mci))
 527                 goto fail0;
 528
 529         /* set load time so that error rate can be tracked */
 530         mci->start_time = jiffies;
 531
 532         if (edac_create_sysfs_mci_device(mci)) {
 533                 edac_mc_printk(mci, KERN_WARNING,
 534                         "failed to create sysfs device\n");
 535                 goto fail1;
 536         }
 537
 538         /* If there IS a check routine, then we are running POLLED */
 539         if (mci->edac_check != NULL) {
 540                 /* This instance is NOW RUNNING */
 541                 mci->op_state = OP_RUNNING_POLL;
 542
 543                 edac_mc_workq_setup(mci, edac_mc_get_poll_msec());
 544         } else {
 545                 mci->op_state = OP_RUNNING_INTERRUPT;
 546         }
 547
 548         /* Report action taken */
 549         edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
 550                 " DEV %s\n", mci->mod_name, mci->ctl_name, edac_dev_name(mci));
 551
 552         mutex_unlock(&mem_ctls_mutex);
 553         return 0;
 554
 555 fail1:
 556         del_mc_from_global_list(mci);
 557
 558 fail0:
 559         mutex_unlock(&mem_ctls_mutex);
 560         return 1;
 561 }
 562 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
 563
 564 /**
 565  * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
 566  *                 remove mci structure from global list
 567  * @pdev: Pointer to 'struct device' representing mci structure to remove.
 568  *
 569  * Return pointer to removed mci structure, or NULL if device not found.
 570  */
 571 struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
 572 {
 573         struct mem_ctl_info *mci;
 574
 575         debugf0("%s()\n", __func__);
 576
 577         mutex_lock(&mem_ctls_mutex);
 578
 579         /* find the requested mci struct in the global list */
 580         mci = find_mci_by_dev(dev);
 581         if (mci == NULL) {
 582                 mutex_unlock(&mem_ctls_mutex);
 583                 return NULL;
 584         }
 585
 586         /* marking MCI offline */
 587         mci->op_state = OP_OFFLINE;
 588
 589         del_mc_from_global_list(mci);
 590         mutex_unlock(&mem_ctls_mutex);
 591
 592         /* flush workq processes and remove sysfs */
 593         edac_mc_workq_teardown(mci);
 594         edac_remove_sysfs_mci_device(mci);
 595
 596         edac_printk(KERN_INFO, EDAC_MC,
 597                 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
 598                 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
 599
 600         return mci;
 601 }
 602 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
 603
 604 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
 605                                 u32 size)
 606 {
 607         struct page *pg;
 608         void *virt_addr;
 609         unsigned long flags = 0;
 610
 611         debugf3("%s()\n", __func__);
 612
 613         /* ECC error page was not in our memory. Ignore it. */
 614         if (!pfn_valid(page))
 615                 return;
 616
 617         /* Find the actual page structure then map it and fix */
 618         pg = pfn_to_page(page);
 619
 620         if (PageHighMem(pg))
 621                 local_irq_save(flags);
 622
 623         virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);
 624
 625         /* Perform architecture specific atomic scrub operation */
 626         atomic_scrub(virt_addr + offset, size);
 627
 628         /* Unmap and complete */
 629         kunmap_atomic(virt_addr, KM_BOUNCE_READ);
 630
 631         if (PageHighMem(pg))
 632                 local_irq_restore(flags);
 633 }
 634
 635 /* FIXME - should return -1 */
 636 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
 637 {
 638         struct csrow_info *csrows = mci->csrows;
 639         int row, i;
 640
 641         debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
 642         row = -1;
 643
 644         for (i = 0; i < mci->nr_csrows; i++) {
 645                 struct csrow_info *csrow = &csrows[i];
 646
 647                 if (csrow->nr_pages == 0)
 648                         continue;
 649
 650                 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
 651                         "mask(0x%lx)\n", mci->mc_idx, __func__,
 652                         csrow->first_page, page, csrow->last_page,
 653                         csrow->page_mask);
 654
 655                 if ((page >= csrow->first_page) &&
 656                     (page <= csrow->last_page) &&
 657                     ((page & csrow->page_mask) ==
 658                      (csrow->first_page & csrow->page_mask))) {
 659                         row = i;
 660                         break;
 661                 }
 662         }
 663
 664         if (row == -1)
 665                 edac_mc_printk(mci, KERN_ERR,
 666                         "could not look up page error address %lx\n",
 667                         (unsigned long)page);
 668
 669         return row;
 670 }
 671 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
 672
 673 /* FIXME - setable log (warning/emerg) levels */
 674 /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
 675 void edac_mc_handle_ce(struct mem_ctl_info *mci,
 676                 unsigned long page_frame_number,
 677                 unsigned long offset_in_page, unsigned long syndrome,
 678                 int row, int channel, const char *msg)
 679 {
 680         unsigned long remapped_page;
 681
 682         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
 683
 684         /* FIXME - maybe make panic on INTERNAL ERROR an option */
 685         if (row >= mci->nr_csrows || row < 0) {
 686                 /* something is wrong */
 687                 edac_mc_printk(mci, KERN_ERR,
 688                         "INTERNAL ERROR: row out of range "
 689                         "(%d >= %d)\n", row, mci->nr_csrows);
 690                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 691                 return;
 692         }
 693
 694         if (channel >= mci->csrows[row].nr_channels || channel < 0) {
 695                 /* something is wrong */
 696                 edac_mc_printk(mci, KERN_ERR,
 697                         "INTERNAL ERROR: channel out of range "
 698                         "(%d >= %d)\n", channel,
 699                         mci->csrows[row].nr_channels);
 700                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 701                 return;
 702         }
 703
 704         if (edac_mc_get_log_ce())
 705                 /* FIXME - put in DIMM location */
 706                 edac_mc_printk(mci, KERN_WARNING,
 707                         "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
 708                         "0x%lx, row %d, channel %d, label \"%s\": %s\n",
 709                         page_frame_number, offset_in_page,
 710                         mci->csrows[row].grain, syndrome, row, channel,
 711                         mci->csrows[row].channels[channel].label, msg);
 712
 713         mci->ce_count++;
 714         mci->csrows[row].ce_count++;
 715         mci->csrows[row].channels[channel].ce_count++;
 716
 717         if (mci->scrub_mode & SCRUB_SW_SRC) {
 718                 /*
 719                  * Some MC's can remap memory so that it is still available
 720                  * at a different address when PCI devices map into memory.
 721                  * MC's that can't do this lose the memory where PCI devices
 722                  * are mapped.  This mapping is MC dependant and so we call
 723                  * back into the MC driver for it to map the MC page to
 724                  * a physical (CPU) page which can then be mapped to a virtual
 725                  * page - which can then be scrubbed.
 726                  */
 727                 remapped_page = mci->ctl_page_to_phys ?
 728                         mci->ctl_page_to_phys(mci, page_frame_number) :
 729                         page_frame_number;
 730
 731                 edac_mc_scrub_block(remapped_page, offset_in_page,
 732                                 mci->csrows[row].grain);
 733         }
 734 }
 735 EXPORT_SYMBOL_GPL(edac_mc_handle_ce);
 736
 737 void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
 738 {
 739         if (edac_mc_get_log_ce())
 740                 edac_mc_printk(mci, KERN_WARNING,
 741                         "CE - no information available: %s\n", msg);
 742
 743         mci->ce_noinfo_count++;
 744         mci->ce_count++;
 745 }
 746 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);
 747
 748 void edac_mc_handle_ue(struct mem_ctl_info *mci,
 749                 unsigned long page_frame_number,
 750                 unsigned long offset_in_page, int row, const char *msg)
 751 {
 752         int len = EDAC_MC_LABEL_LEN * 4;
 753         char labels[len + 1];
 754         char *pos = labels;
 755         int chan;
 756         int chars;
 757
 758         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
 759
 760         /* FIXME - maybe make panic on INTERNAL ERROR an option */
 761         if (row >= mci->nr_csrows || row < 0) {
 762                 /* something is wrong */
 763                 edac_mc_printk(mci, KERN_ERR,
 764                         "INTERNAL ERROR: row out of range "
 765                         "(%d >= %d)\n", row, mci->nr_csrows);
 766                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 767                 return;
 768         }
 769
 770         chars = snprintf(pos, len + 1, "%s",
 771                          mci->csrows[row].channels[0].label);
 772         len -= chars;
 773         pos += chars;
 774
 775         for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
 776                 chan++) {
 777                 chars = snprintf(pos, len + 1, ":%s",
 778                                  mci->csrows[row].channels[chan].label);
 779                 len -= chars;
 780                 pos += chars;
 781         }
 782
 783         if (edac_mc_get_log_ue())
 784                 edac_mc_printk(mci, KERN_EMERG,
 785                         "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
 786                         "labels \"%s\": %s\n", page_frame_number,
 787                         offset_in_page, mci->csrows[row].grain, row,
 788                         labels, msg);
 789
 790         if (edac_mc_get_panic_on_ue())
 791                 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
 792                         "row %d, labels \"%s\": %s\n", mci->mc_idx,
 793                         page_frame_number, offset_in_page,
 794                         mci->csrows[row].grain, row, labels, msg);
 795
 796         mci->ue_count++;
 797         mci->csrows[row].ue_count++;
 798 }
 799 EXPORT_SYMBOL_GPL(edac_mc_handle_ue);
 800
 801 void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
 802 {
 803         if (edac_mc_get_panic_on_ue())
 804                 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
 805
 806         if (edac_mc_get_log_ue())
 807                 edac_mc_printk(mci, KERN_WARNING,
 808                         "UE - no information available: %s\n", msg);
 809         mci->ue_noinfo_count++;
 810         mci->ue_count++;
 811 }
 812 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);
 813
 814 /*************************************************************
 815  * On Fully Buffered DIMM modules, this help function is
 816  * called to process UE events
 817  */
 818 void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci,
 819                         unsigned int csrow,
 820                         unsigned int channela,
 821                         unsigned int channelb, char *msg)
 822 {
 823         int len = EDAC_MC_LABEL_LEN * 4;
 824         char labels[len + 1];
 825         char *pos = labels;
 826         int chars;
 827
 828         if (csrow >= mci->nr_csrows) {
 829                 /* something is wrong */
 830                 edac_mc_printk(mci, KERN_ERR,
 831                         "INTERNAL ERROR: row out of range (%d >= %d)\n",
 832                         csrow, mci->nr_csrows);
 833                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 834                 return;
 835         }
 836
 837         if (channela >= mci->csrows[csrow].nr_channels) {
 838                 /* something is wrong */
 839                 edac_mc_printk(mci, KERN_ERR,
 840                         "INTERNAL ERROR: channel-a out of range "
 841                         "(%d >= %d)\n",
 842                         channela, mci->csrows[csrow].nr_channels);
 843                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 844                 return;
 845         }
 846
 847         if (channelb >= mci->csrows[csrow].nr_channels) {
 848                 /* something is wrong */
 849                 edac_mc_printk(mci, KERN_ERR,
 850                         "INTERNAL ERROR: channel-b out of range "
 851                         "(%d >= %d)\n",
 852                         channelb, mci->csrows[csrow].nr_channels);
 853                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
 854                 return;
 855         }
 856
 857         mci->ue_count++;
 858         mci->csrows[csrow].ue_count++;
 859
 860         /* Generate the DIMM labels from the specified channels */
 861         chars = snprintf(pos, len + 1, "%s",
 862                          mci->csrows[csrow].channels[channela].label);
 863         len -= chars;
 864         pos += chars;
 865         chars = snprintf(pos, len + 1, "-%s",
 866                          mci->csrows[csrow].channels[channelb].label);
 867
 868         if (edac_mc_get_log_ue())
 869                 edac_mc_printk(mci, KERN_EMERG,
 870                         "UE row %d, channel-a= %d channel-b= %d "
 871                         "labels \"%s\": %s\n", csrow, channela, channelb,
 872                         labels, msg);
 873
 874         if (edac_mc_get_panic_on_ue())
 875                 panic("UE row %d, channel-a= %d channel-b= %d "
 876                         "labels \"%s\": %s\n", csrow, channela,
 877                         channelb, labels, msg);
 878 }
 879 EXPORT_SYMBOL(edac_mc_handle_fbd_ue);
 880
 881 /*************************************************************
 882  * On Fully Buffered DIMM modules, this help function is
 883  * called to process CE events
 884  */
 885 void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
 886                         unsigned int csrow, unsigned int channel, char *msg)
 887 {
 888
 889         /* Ensure boundary values */
 890         if (csrow >= mci->nr_csrows) {
 891                 /* something is wrong */
 892                 edac_mc_printk(mci, KERN_ERR,
 893                         "INTERNAL ERROR: row out of range (%d >= %d)\n",
 894                         csrow, mci->nr_csrows);
 895                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 896                 return;
 897         }
 898         if (channel >= mci->csrows[csrow].nr_channels) {
 899                 /* something is wrong */
 900                 edac_mc_printk(mci, KERN_ERR,
 901                         "INTERNAL ERROR: channel out of range (%d >= %d)\n",
 902                         channel, mci->csrows[csrow].nr_channels);
 903                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
 904                 return;
 905         }
 906
 907         if (edac_mc_get_log_ce())
 908                 /* FIXME - put in DIMM location */
 909                 edac_mc_printk(mci, KERN_WARNING,
 910                         "CE row %d, channel %d, label \"%s\": %s\n",
 911                         csrow, channel,
 912                         mci->csrows[csrow].channels[channel].label, msg);
 913
 914         mci->ce_count++;
 915         mci->csrows[csrow].ce_count++;
 916         mci->csrows[csrow].channels[channel].ce_count++;
 917 }
 918 EXPORT_SYMBOL(edac_mc_handle_fbd_ce);