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.
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/
11 * Modified by Dave Peterson and Doug Thompson
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>
34 #include "edac_core.h"
35 #include "edac_module.h"
37 /* lock to memory controller's control array */
38 static DEFINE_MUTEX(mem_ctls_mutex);
39 static LIST_HEAD(mc_devices);
41 #ifdef CONFIG_EDAC_DEBUG
43 static void edac_mc_dump_channel(struct channel_info *chan)
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);
52 static void edac_mc_dump_csrow(struct csrow_info *csrow)
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);
65 static void edac_mc_dump_mci(struct mem_ctl_info *mci)
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);
79 #endif /* CONFIG_EDAC_DEBUG */
82 * keep those in sync with the enum mem_type
84 const char *edac_mem_types[] = {
86 "Reserved csrow type",
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",
96 "Unbuffered DDR2 RAM",
97 "Fully buffered DDR2",
98 "Registered DDR2 RAM",
100 "Unbuffered DDR3 RAM",
101 "Registered DDR3 RAM",
103 EXPORT_SYMBOL_GPL(edac_mem_types);
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.
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'.
112 void *edac_align_ptr(void *ptr, unsigned size)
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.
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))
126 else if (size > sizeof(char))
127 align = sizeof(short);
136 return (void *)(((unsigned long)ptr) + align - r);
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
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.
149 * Use edac_mc_free() to free mc structures allocated by this function.
152 * NULL allocation failed
153 * struct mem_ctl_info pointer
155 struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows,
156 unsigned nr_chans, int edac_index)
158 struct mem_ctl_info *mci;
159 struct csrow_info *csi, *csrow;
160 struct channel_info *chi, *chp, *chan;
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.
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;
177 mci = kzalloc(size, GFP_KERNEL);
181 /* Adjust pointers so they point within the memory we just allocated
182 * rather than an imaginary chunk of memory located at address 0.
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;
188 /* setup index and various internal pointers */
189 mci->mc_idx = edac_index;
192 mci->nr_csrows = nr_csrows;
194 for (row = 0; row < nr_csrows; row++) {
196 csrow->csrow_idx = row;
198 csrow->nr_channels = nr_chans;
199 chp = &chi[row * nr_chans];
200 csrow->channels = chp;
202 for (chn = 0; chn < nr_chans; chn++) {
204 chan->chan_idx = chn;
209 mci->op_state = OP_ALLOC;
210 INIT_LIST_HEAD(&mci->grp_kobj_list);
213 * Initialize the 'root' kobj for the edac_mc controller
215 err = edac_mc_register_sysfs_main_kobj(mci);
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
229 EXPORT_SYMBOL_GPL(edac_mc_alloc);
233 * 'Free' a previously allocated 'mci' structure
234 * @mci: pointer to a struct mem_ctl_info structure
236 void edac_mc_free(struct mem_ctl_info *mci)
238 debugf1("%s()\n", __func__);
240 edac_mc_unregister_sysfs_main_kobj(mci);
242 /* free the mci instance memory here */
245 EXPORT_SYMBOL_GPL(edac_mc_free);
251 * scan list of controllers looking for the one that manages
253 * @dev: pointer to a struct device related with the MCI
255 struct mem_ctl_info *find_mci_by_dev(struct device *dev)
257 struct mem_ctl_info *mci;
258 struct list_head *item;
260 debugf3("%s()\n", __func__);
262 list_for_each(item, &mc_devices) {
263 mci = list_entry(item, struct mem_ctl_info, link);
271 EXPORT_SYMBOL_GPL(find_mci_by_dev);
274 * handler for EDAC to check if NMI type handler has asserted interrupt
276 static int edac_mc_assert_error_check_and_clear(void)
280 if (edac_op_state == EDAC_OPSTATE_POLL)
283 old_state = edac_err_assert;
290 * edac_mc_workq_function
291 * performs the operation scheduled by a workq request
293 static void edac_mc_workq_function(struct work_struct *work_req)
295 struct delayed_work *d_work = to_delayed_work(work_req);
296 struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
298 mutex_lock(&mem_ctls_mutex);
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);
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);
310 mutex_unlock(&mem_ctls_mutex);
313 queue_delayed_work(edac_workqueue, &mci->work,
314 msecs_to_jiffies(edac_mc_get_poll_msec()));
318 * edac_mc_workq_setup
319 * initialize a workq item for this mci
320 * passing in the new delay period in msec
324 * called with the mem_ctls_mutex held
326 static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec,
329 debugf0("%s()\n", __func__);
331 /* if this instance is not in the POLL state, then simply return */
332 if (mci->op_state != OP_RUNNING_POLL)
336 INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
338 queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
342 * edac_mc_workq_teardown
343 * stop the workq processing on this mci
347 * called WITHOUT lock held
349 static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
351 mci->op_state = OP_OFFLINE;
353 cancel_delayed_work_sync(&mci->work);
354 flush_workqueue(edac_workqueue);
358 * edac_mc_reset_delay_period(unsigned long value)
360 * user space has updated our poll period value, need to
361 * reset our workq delays
363 void edac_mc_reset_delay_period(int value)
365 struct mem_ctl_info *mci;
366 struct list_head *item;
368 mutex_lock(&mem_ctls_mutex);
370 /* scan the list and turn off all workq timers, doing so under lock
372 list_for_each(item, &mc_devices) {
373 mci = list_entry(item, struct mem_ctl_info, link);
375 if (mci->op_state == OP_RUNNING_POLL)
376 cancel_delayed_work(&mci->work);
379 mutex_unlock(&mem_ctls_mutex);
382 /* re-walk the list, and reset the poll delay */
383 mutex_lock(&mem_ctls_mutex);
385 list_for_each(item, &mc_devices) {
386 mci = list_entry(item, struct mem_ctl_info, link);
388 edac_mc_workq_setup(mci, value, false);
391 mutex_unlock(&mem_ctls_mutex);
396 /* Return 0 on success, 1 on failure.
397 * Before calling this function, caller must
398 * assign a unique value to mci->mc_idx.
402 * called with the mem_ctls_mutex lock held
404 static int add_mc_to_global_list(struct mem_ctl_info *mci)
406 struct list_head *item, *insert_before;
407 struct mem_ctl_info *p;
409 insert_before = &mc_devices;
411 p = find_mci_by_dev(mci->dev);
412 if (unlikely(p != NULL))
415 list_for_each(item, &mc_devices) {
416 p = list_entry(item, struct mem_ctl_info, link);
418 if (p->mc_idx >= mci->mc_idx) {
419 if (unlikely(p->mc_idx == mci->mc_idx))
422 insert_before = item;
427 list_add_tail_rcu(&mci->link, insert_before);
428 atomic_inc(&edac_handlers);
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);
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__);
444 static void del_mc_from_global_list(struct mem_ctl_info *mci)
446 atomic_dec(&edac_handlers);
447 list_del_rcu(&mci->link);
449 /* these are for safe removal of devices from global list while
450 * NMI handlers may be traversing list
453 INIT_LIST_HEAD(&mci->link);
457 * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
459 * If found, return a pointer to the structure.
462 * Caller must hold mem_ctls_mutex.
464 struct mem_ctl_info *edac_mc_find(int idx)
466 struct list_head *item;
467 struct mem_ctl_info *mci;
469 list_for_each(item, &mc_devices) {
470 mci = list_entry(item, struct mem_ctl_info, link);
472 if (mci->mc_idx >= idx) {
473 if (mci->mc_idx == idx)
482 EXPORT_SYMBOL(edac_mc_find);
485 * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
486 * create sysfs entries associated with mci structure
487 * @mci: pointer to the mci structure to be added to the list
488 * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
495 /* FIXME - should a warning be printed if no error detection? correction? */
496 int edac_mc_add_mc(struct mem_ctl_info *mci)
498 debugf0("%s()\n", __func__);
500 #ifdef CONFIG_EDAC_DEBUG
501 if (edac_debug_level >= 3)
502 edac_mc_dump_mci(mci);
504 if (edac_debug_level >= 4) {
507 for (i = 0; i < mci->nr_csrows; i++) {
510 edac_mc_dump_csrow(&mci->csrows[i]);
511 for (j = 0; j < mci->csrows[i].nr_channels; j++)
512 edac_mc_dump_channel(&mci->csrows[i].
517 mutex_lock(&mem_ctls_mutex);
519 if (add_mc_to_global_list(mci))
522 /* set load time so that error rate can be tracked */
523 mci->start_time = jiffies;
525 if (edac_create_sysfs_mci_device(mci)) {
526 edac_mc_printk(mci, KERN_WARNING,
527 "failed to create sysfs device\n");
531 /* If there IS a check routine, then we are running POLLED */
532 if (mci->edac_check != NULL) {
533 /* This instance is NOW RUNNING */
534 mci->op_state = OP_RUNNING_POLL;
536 edac_mc_workq_setup(mci, edac_mc_get_poll_msec(), true);
538 mci->op_state = OP_RUNNING_INTERRUPT;
541 /* Report action taken */
542 edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
543 " DEV %s\n", mci->mod_name, mci->ctl_name, edac_dev_name(mci));
545 mutex_unlock(&mem_ctls_mutex);
549 del_mc_from_global_list(mci);
552 mutex_unlock(&mem_ctls_mutex);
555 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
558 * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
559 * remove mci structure from global list
560 * @pdev: Pointer to 'struct device' representing mci structure to remove.
562 * Return pointer to removed mci structure, or NULL if device not found.
564 struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
566 struct mem_ctl_info *mci;
568 debugf0("%s()\n", __func__);
570 mutex_lock(&mem_ctls_mutex);
572 /* find the requested mci struct in the global list */
573 mci = find_mci_by_dev(dev);
575 mutex_unlock(&mem_ctls_mutex);
579 del_mc_from_global_list(mci);
580 mutex_unlock(&mem_ctls_mutex);
582 /* flush workq processes */
583 edac_mc_workq_teardown(mci);
585 /* marking MCI offline */
586 mci->op_state = OP_OFFLINE;
588 /* remove from sysfs */
589 edac_remove_sysfs_mci_device(mci);
591 edac_printk(KERN_INFO, EDAC_MC,
592 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
593 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
597 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
599 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
604 unsigned long flags = 0;
606 debugf3("%s()\n", __func__);
608 /* ECC error page was not in our memory. Ignore it. */
609 if (!pfn_valid(page))
612 /* Find the actual page structure then map it and fix */
613 pg = pfn_to_page(page);
616 local_irq_save(flags);
618 virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);
620 /* Perform architecture specific atomic scrub operation */
621 atomic_scrub(virt_addr + offset, size);
623 /* Unmap and complete */
624 kunmap_atomic(virt_addr, KM_BOUNCE_READ);
627 local_irq_restore(flags);
630 /* FIXME - should return -1 */
631 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
633 struct csrow_info *csrows = mci->csrows;
636 debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
639 for (i = 0; i < mci->nr_csrows; i++) {
640 struct csrow_info *csrow = &csrows[i];
642 if (csrow->nr_pages == 0)
645 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
646 "mask(0x%lx)\n", mci->mc_idx, __func__,
647 csrow->first_page, page, csrow->last_page,
650 if ((page >= csrow->first_page) &&
651 (page <= csrow->last_page) &&
652 ((page & csrow->page_mask) ==
653 (csrow->first_page & csrow->page_mask))) {
660 edac_mc_printk(mci, KERN_ERR,
661 "could not look up page error address %lx\n",
662 (unsigned long)page);
666 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
668 /* FIXME - setable log (warning/emerg) levels */
669 /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
670 void edac_mc_handle_ce(struct mem_ctl_info *mci,
671 unsigned long page_frame_number,
672 unsigned long offset_in_page, unsigned long syndrome,
673 int row, int channel, const char *msg)
675 unsigned long remapped_page;
677 debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
679 /* FIXME - maybe make panic on INTERNAL ERROR an option */
680 if (row >= mci->nr_csrows || row < 0) {
681 /* something is wrong */
682 edac_mc_printk(mci, KERN_ERR,
683 "INTERNAL ERROR: row out of range "
684 "(%d >= %d)\n", row, mci->nr_csrows);
685 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
689 if (channel >= mci->csrows[row].nr_channels || channel < 0) {
690 /* something is wrong */
691 edac_mc_printk(mci, KERN_ERR,
692 "INTERNAL ERROR: channel out of range "
693 "(%d >= %d)\n", channel,
694 mci->csrows[row].nr_channels);
695 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
699 if (edac_mc_get_log_ce())
700 /* FIXME - put in DIMM location */
701 edac_mc_printk(mci, KERN_WARNING,
702 "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
703 "0x%lx, row %d, channel %d, label \"%s\": %s\n",
704 page_frame_number, offset_in_page,
705 mci->csrows[row].grain, syndrome, row, channel,
706 mci->csrows[row].channels[channel].label, msg);
709 mci->csrows[row].ce_count++;
710 mci->csrows[row].channels[channel].ce_count++;
712 if (mci->scrub_mode & SCRUB_SW_SRC) {
714 * Some MC's can remap memory so that it is still available
715 * at a different address when PCI devices map into memory.
716 * MC's that can't do this lose the memory where PCI devices
717 * are mapped. This mapping is MC dependent and so we call
718 * back into the MC driver for it to map the MC page to
719 * a physical (CPU) page which can then be mapped to a virtual
720 * page - which can then be scrubbed.
722 remapped_page = mci->ctl_page_to_phys ?
723 mci->ctl_page_to_phys(mci, page_frame_number) :
726 edac_mc_scrub_block(remapped_page, offset_in_page,
727 mci->csrows[row].grain);
730 EXPORT_SYMBOL_GPL(edac_mc_handle_ce);
732 void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
734 if (edac_mc_get_log_ce())
735 edac_mc_printk(mci, KERN_WARNING,
736 "CE - no information available: %s\n", msg);
738 mci->ce_noinfo_count++;
741 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);
743 void edac_mc_handle_ue(struct mem_ctl_info *mci,
744 unsigned long page_frame_number,
745 unsigned long offset_in_page, int row, const char *msg)
747 int len = EDAC_MC_LABEL_LEN * 4;
748 char labels[len + 1];
753 debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
755 /* FIXME - maybe make panic on INTERNAL ERROR an option */
756 if (row >= mci->nr_csrows || row < 0) {
757 /* something is wrong */
758 edac_mc_printk(mci, KERN_ERR,
759 "INTERNAL ERROR: row out of range "
760 "(%d >= %d)\n", row, mci->nr_csrows);
761 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
765 chars = snprintf(pos, len + 1, "%s",
766 mci->csrows[row].channels[0].label);
770 for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
772 chars = snprintf(pos, len + 1, ":%s",
773 mci->csrows[row].channels[chan].label);
778 if (edac_mc_get_log_ue())
779 edac_mc_printk(mci, KERN_EMERG,
780 "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
781 "labels \"%s\": %s\n", page_frame_number,
782 offset_in_page, mci->csrows[row].grain, row,
785 if (edac_mc_get_panic_on_ue())
786 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
787 "row %d, labels \"%s\": %s\n", mci->mc_idx,
788 page_frame_number, offset_in_page,
789 mci->csrows[row].grain, row, labels, msg);
792 mci->csrows[row].ue_count++;
794 EXPORT_SYMBOL_GPL(edac_mc_handle_ue);
796 void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
798 if (edac_mc_get_panic_on_ue())
799 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
801 if (edac_mc_get_log_ue())
802 edac_mc_printk(mci, KERN_WARNING,
803 "UE - no information available: %s\n", msg);
804 mci->ue_noinfo_count++;
807 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);
809 /*************************************************************
810 * On Fully Buffered DIMM modules, this help function is
811 * called to process UE events
813 void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci,
815 unsigned int channela,
816 unsigned int channelb, char *msg)
818 int len = EDAC_MC_LABEL_LEN * 4;
819 char labels[len + 1];
823 if (csrow >= mci->nr_csrows) {
824 /* something is wrong */
825 edac_mc_printk(mci, KERN_ERR,
826 "INTERNAL ERROR: row out of range (%d >= %d)\n",
827 csrow, mci->nr_csrows);
828 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
832 if (channela >= mci->csrows[csrow].nr_channels) {
833 /* something is wrong */
834 edac_mc_printk(mci, KERN_ERR,
835 "INTERNAL ERROR: channel-a out of range "
837 channela, mci->csrows[csrow].nr_channels);
838 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
842 if (channelb >= mci->csrows[csrow].nr_channels) {
843 /* something is wrong */
844 edac_mc_printk(mci, KERN_ERR,
845 "INTERNAL ERROR: channel-b out of range "
847 channelb, mci->csrows[csrow].nr_channels);
848 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
853 mci->csrows[csrow].ue_count++;
855 /* Generate the DIMM labels from the specified channels */
856 chars = snprintf(pos, len + 1, "%s",
857 mci->csrows[csrow].channels[channela].label);
860 chars = snprintf(pos, len + 1, "-%s",
861 mci->csrows[csrow].channels[channelb].label);
863 if (edac_mc_get_log_ue())
864 edac_mc_printk(mci, KERN_EMERG,
865 "UE row %d, channel-a= %d channel-b= %d "
866 "labels \"%s\": %s\n", csrow, channela, channelb,
869 if (edac_mc_get_panic_on_ue())
870 panic("UE row %d, channel-a= %d channel-b= %d "
871 "labels \"%s\": %s\n", csrow, channela,
872 channelb, labels, msg);
874 EXPORT_SYMBOL(edac_mc_handle_fbd_ue);
876 /*************************************************************
877 * On Fully Buffered DIMM modules, this help function is
878 * called to process CE events
880 void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
881 unsigned int csrow, unsigned int channel, char *msg)
884 /* Ensure boundary values */
885 if (csrow >= mci->nr_csrows) {
886 /* something is wrong */
887 edac_mc_printk(mci, KERN_ERR,
888 "INTERNAL ERROR: row out of range (%d >= %d)\n",
889 csrow, mci->nr_csrows);
890 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
893 if (channel >= mci->csrows[csrow].nr_channels) {
894 /* something is wrong */
895 edac_mc_printk(mci, KERN_ERR,
896 "INTERNAL ERROR: channel out of range (%d >= %d)\n",
897 channel, mci->csrows[csrow].nr_channels);
898 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
902 if (edac_mc_get_log_ce())
903 /* FIXME - put in DIMM location */
904 edac_mc_printk(mci, KERN_WARNING,
905 "CE row %d, channel %d, label \"%s\": %s\n",
907 mci->csrows[csrow].channels[channel].label, msg);
910 mci->csrows[csrow].ce_count++;
911 mci->csrows[csrow].channels[channel].ce_count++;
913 EXPORT_SYMBOL(edac_mc_handle_fbd_ce);