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"
38 /* lock to memory controller's control array */
39 static DEFINE_MUTEX(mem_ctls_mutex
);
40 static struct list_head mc_devices
= LIST_HEAD_INIT(mc_devices
);
42 #ifdef CONFIG_EDAC_DEBUG
44 static void edac_mc_dump_channel(struct channel_info
*chan
)
46 debugf4("\tchannel = %p\n", chan
);
47 debugf4("\tchannel->chan_idx = %d\n", chan
->chan_idx
);
48 debugf4("\tchannel->ce_count = %d\n", chan
->ce_count
);
49 debugf4("\tchannel->label = '%s'\n", chan
->label
);
50 debugf4("\tchannel->csrow = %p\n\n", chan
->csrow
);
53 static void edac_mc_dump_csrow(struct csrow_info
*csrow
)
55 debugf4("\tcsrow = %p\n", csrow
);
56 debugf4("\tcsrow->csrow_idx = %d\n", csrow
->csrow_idx
);
57 debugf4("\tcsrow->first_page = 0x%lx\n",
59 debugf4("\tcsrow->last_page = 0x%lx\n", csrow
->last_page
);
60 debugf4("\tcsrow->page_mask = 0x%lx\n", csrow
->page_mask
);
61 debugf4("\tcsrow->nr_pages = 0x%x\n", csrow
->nr_pages
);
62 debugf4("\tcsrow->nr_channels = %d\n",
64 debugf4("\tcsrow->channels = %p\n", csrow
->channels
);
65 debugf4("\tcsrow->mci = %p\n\n", csrow
->mci
);
68 static void edac_mc_dump_mci(struct mem_ctl_info
*mci
)
70 debugf3("\tmci = %p\n", mci
);
71 debugf3("\tmci->mtype_cap = %lx\n", mci
->mtype_cap
);
72 debugf3("\tmci->edac_ctl_cap = %lx\n", mci
->edac_ctl_cap
);
73 debugf3("\tmci->edac_cap = %lx\n", mci
->edac_cap
);
74 debugf4("\tmci->edac_check = %p\n", mci
->edac_check
);
75 debugf3("\tmci->nr_csrows = %d, csrows = %p\n",
76 mci
->nr_csrows
, mci
->csrows
);
77 debugf3("\tdev = %p\n", mci
->dev
);
78 debugf3("\tmod_name:ctl_name = %s:%s\n",
79 mci
->mod_name
, mci
->ctl_name
);
80 debugf3("\tpvt_info = %p\n\n", mci
->pvt_info
);
83 #endif /* CONFIG_EDAC_DEBUG */
85 /* 'ptr' points to a possibly unaligned item X such that sizeof(X) is 'size'.
86 * Adjust 'ptr' so that its alignment is at least as stringent as what the
87 * compiler would provide for X and return the aligned result.
89 * If 'size' is a constant, the compiler will optimize this whole function
90 * down to either a no-op or the addition of a constant to the value of 'ptr'.
92 char * edac_align_ptr(void *ptr
, unsigned size
)
96 /* Here we assume that the alignment of a "long long" is the most
97 * stringent alignment that the compiler will ever provide by default.
98 * As far as I know, this is a reasonable assumption.
100 if (size
> sizeof(long))
101 align
= sizeof(long long);
102 else if (size
> sizeof(int))
103 align
= sizeof(long);
104 else if (size
> sizeof(short))
106 else if (size
> sizeof(char))
107 align
= sizeof(short);
116 return (char *) (((unsigned long) ptr
) + align
- r
);
120 * edac_mc_alloc: Allocate a struct mem_ctl_info structure
121 * @size_pvt: size of private storage needed
122 * @nr_csrows: Number of CWROWS needed for this MC
123 * @nr_chans: Number of channels for the MC
125 * Everything is kmalloc'ed as one big chunk - more efficient.
126 * Only can be used if all structures have the same lifetime - otherwise
127 * you have to allocate and initialize your own structures.
129 * Use edac_mc_free() to free mc structures allocated by this function.
132 * NULL allocation failed
133 * struct mem_ctl_info pointer
135 struct mem_ctl_info
*edac_mc_alloc(unsigned sz_pvt
, unsigned nr_csrows
,
138 struct mem_ctl_info
*mci
;
139 struct csrow_info
*csi
, *csrow
;
140 struct channel_info
*chi
, *chp
, *chan
;
145 /* Figure out the offsets of the various items from the start of an mc
146 * structure. We want the alignment of each item to be at least as
147 * stringent as what the compiler would provide if we could simply
148 * hardcode everything into a single struct.
150 mci
= (struct mem_ctl_info
*) 0;
151 csi
= (struct csrow_info
*)edac_align_ptr(&mci
[1], sizeof(*csi
));
152 chi
= (struct channel_info
*)
153 edac_align_ptr(&csi
[nr_csrows
], sizeof(*chi
));
154 pvt
= edac_align_ptr(&chi
[nr_chans
* nr_csrows
], sz_pvt
);
155 size
= ((unsigned long) pvt
) + sz_pvt
;
157 if ((mci
= kmalloc(size
, GFP_KERNEL
)) == NULL
)
160 /* Adjust pointers so they point within the memory we just allocated
161 * rather than an imaginary chunk of memory located at address 0.
163 csi
= (struct csrow_info
*) (((char *) mci
) + ((unsigned long) csi
));
164 chi
= (struct channel_info
*) (((char *) mci
) + ((unsigned long) chi
));
165 pvt
= sz_pvt
? (((char *) mci
) + ((unsigned long) pvt
)) : NULL
;
167 memset(mci
, 0, size
); /* clear all fields */
170 mci
->nr_csrows
= nr_csrows
;
172 for (row
= 0; row
< nr_csrows
; row
++) {
174 csrow
->csrow_idx
= row
;
176 csrow
->nr_channels
= nr_chans
;
177 chp
= &chi
[row
* nr_chans
];
178 csrow
->channels
= chp
;
180 for (chn
= 0; chn
< nr_chans
; chn
++) {
182 chan
->chan_idx
= chn
;
187 mci
->op_state
= OP_ALLOC
;
191 EXPORT_SYMBOL_GPL(edac_mc_alloc
);
194 * edac_mc_free: Free a previously allocated 'mci' structure
195 * @mci: pointer to a struct mem_ctl_info structure
197 void edac_mc_free(struct mem_ctl_info
*mci
)
201 EXPORT_SYMBOL_GPL(edac_mc_free
);
203 static struct mem_ctl_info
*find_mci_by_dev(struct device
*dev
)
205 struct mem_ctl_info
*mci
;
206 struct list_head
*item
;
208 debugf3("%s()\n", __func__
);
210 list_for_each(item
, &mc_devices
) {
211 mci
= list_entry(item
, struct mem_ctl_info
, link
);
221 * handler for EDAC to check if NMI type handler has asserted interrupt
223 static int edac_mc_assert_error_check_and_clear(void)
227 if(edac_op_state
== EDAC_OPSTATE_POLL
)
230 old_state
= edac_err_assert
;
237 * edac_mc_workq_function
238 * performs the operation scheduled by a workq request
240 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
241 static void edac_mc_workq_function(struct work_struct
*work_req
)
243 struct delayed_work
*d_work
= (struct delayed_work
*) work_req
;
244 struct mem_ctl_info
*mci
= to_edac_mem_ctl_work(d_work
);
246 static void edac_mc_workq_function(void *ptr
)
248 struct mem_ctl_info
*mci
= (struct mem_ctl_info
*) ptr
;
251 mutex_lock(&mem_ctls_mutex
);
253 /* Only poll controllers that are running polled and have a check */
254 if (edac_mc_assert_error_check_and_clear() && (mci
->edac_check
!= NULL
))
255 mci
->edac_check(mci
);
258 * FIXME: temp place holder for PCI checks,
259 * goes away when we break out PCI
261 edac_pci_do_parity_check();
263 mutex_unlock(&mem_ctls_mutex
);
266 queue_delayed_work(edac_workqueue
, &mci
->work
, edac_mc_get_poll_msec());
270 * edac_mc_workq_setup
271 * initialize a workq item for this mci
272 * passing in the new delay period in msec
274 void edac_mc_workq_setup(struct mem_ctl_info
*mci
, unsigned msec
)
276 debugf0("%s()\n", __func__
);
278 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20))
279 INIT_DELAYED_WORK(&mci
->work
, edac_mc_workq_function
);
281 INIT_WORK(&mci
->work
, edac_mc_workq_function
, mci
);
283 queue_delayed_work(edac_workqueue
, &mci
->work
, msecs_to_jiffies(msec
));
287 * edac_mc_workq_teardown
288 * stop the workq processing on this mci
290 void edac_mc_workq_teardown(struct mem_ctl_info
*mci
)
294 status
= cancel_delayed_work(&mci
->work
);
296 /* workq instance might be running, wait for it */
297 flush_workqueue(edac_workqueue
);
302 * edac_reset_delay_period
305 void edac_reset_delay_period(struct mem_ctl_info
*mci
, unsigned long value
)
307 mutex_lock(&mem_ctls_mutex
);
309 /* cancel the current workq request */
310 edac_mc_workq_teardown(mci
);
312 /* restart the workq request, with new delay value */
313 edac_mc_workq_setup(mci
, value
);
315 mutex_unlock(&mem_ctls_mutex
);
318 /* Return 0 on success, 1 on failure.
319 * Before calling this function, caller must
320 * assign a unique value to mci->mc_idx.
322 static int add_mc_to_global_list (struct mem_ctl_info
*mci
)
324 struct list_head
*item
, *insert_before
;
325 struct mem_ctl_info
*p
;
327 insert_before
= &mc_devices
;
329 if (unlikely((p
= find_mci_by_dev(mci
->dev
)) != NULL
))
332 list_for_each(item
, &mc_devices
) {
333 p
= list_entry(item
, struct mem_ctl_info
, link
);
335 if (p
->mc_idx
>= mci
->mc_idx
) {
336 if (unlikely(p
->mc_idx
== mci
->mc_idx
))
339 insert_before
= item
;
344 list_add_tail_rcu(&mci
->link
, insert_before
);
345 atomic_inc(&edac_handlers
);
349 edac_printk(KERN_WARNING
, EDAC_MC
,
350 "%s (%s) %s %s already assigned %d\n", p
->dev
->bus_id
,
351 dev_name(mci
), p
->mod_name
, p
->ctl_name
, p
->mc_idx
);
355 edac_printk(KERN_WARNING
, EDAC_MC
,
356 "bug in low-level driver: attempt to assign\n"
357 " duplicate mc_idx %d in %s()\n", p
->mc_idx
, __func__
);
361 static void complete_mc_list_del(struct rcu_head
*head
)
363 struct mem_ctl_info
*mci
;
365 mci
= container_of(head
, struct mem_ctl_info
, rcu
);
366 INIT_LIST_HEAD(&mci
->link
);
367 complete(&mci
->complete
);
370 static void del_mc_from_global_list(struct mem_ctl_info
*mci
)
372 atomic_dec(&edac_handlers
);
373 list_del_rcu(&mci
->link
);
374 init_completion(&mci
->complete
);
375 call_rcu(&mci
->rcu
, complete_mc_list_del
);
376 wait_for_completion(&mci
->complete
);
380 * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
382 * If found, return a pointer to the structure.
385 * Caller must hold mem_ctls_mutex.
387 struct mem_ctl_info
* edac_mc_find(int idx
)
389 struct list_head
*item
;
390 struct mem_ctl_info
*mci
;
392 list_for_each(item
, &mc_devices
) {
393 mci
= list_entry(item
, struct mem_ctl_info
, link
);
395 if (mci
->mc_idx
>= idx
) {
396 if (mci
->mc_idx
== idx
)
405 EXPORT_SYMBOL(edac_mc_find
);
408 * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
409 * create sysfs entries associated with mci structure
410 * @mci: pointer to the mci structure to be added to the list
411 * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
418 /* FIXME - should a warning be printed if no error detection? correction? */
419 int edac_mc_add_mc(struct mem_ctl_info
*mci
, int mc_idx
)
421 debugf0("%s()\n", __func__
);
422 mci
->mc_idx
= mc_idx
;
423 #ifdef CONFIG_EDAC_DEBUG
424 if (edac_debug_level
>= 3)
425 edac_mc_dump_mci(mci
);
427 if (edac_debug_level
>= 4) {
430 for (i
= 0; i
< mci
->nr_csrows
; i
++) {
433 edac_mc_dump_csrow(&mci
->csrows
[i
]);
434 for (j
= 0; j
< mci
->csrows
[i
].nr_channels
; j
++)
435 edac_mc_dump_channel(
436 &mci
->csrows
[i
].channels
[j
]);
440 mutex_lock(&mem_ctls_mutex
);
442 if (add_mc_to_global_list(mci
))
445 /* set load time so that error rate can be tracked */
446 mci
->start_time
= jiffies
;
448 if (edac_create_sysfs_mci_device(mci
)) {
449 edac_mc_printk(mci
, KERN_WARNING
,
450 "failed to create sysfs device\n");
454 /* If there IS a check routine, then we are running POLLED */
455 if (mci
->edac_check
!= NULL
) {
456 /* This instance is NOW RUNNING */
457 mci
->op_state
= OP_RUNNING_POLL
;
459 edac_mc_workq_setup(mci
, edac_mc_get_poll_msec());
461 mci
->op_state
= OP_RUNNING_INTERRUPT
;
464 /* Report action taken */
465 edac_mc_printk(mci
, KERN_INFO
, "Giving out device to %s %s: DEV %s\n",
466 mci
->mod_name
, mci
->ctl_name
, dev_name(mci
));
468 mutex_unlock(&mem_ctls_mutex
);
472 del_mc_from_global_list(mci
);
475 mutex_unlock(&mem_ctls_mutex
);
478 EXPORT_SYMBOL_GPL(edac_mc_add_mc
);
481 * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
482 * remove mci structure from global list
483 * @pdev: Pointer to 'struct device' representing mci structure to remove.
485 * Return pointer to removed mci structure, or NULL if device not found.
487 struct mem_ctl_info
* edac_mc_del_mc(struct device
*dev
)
489 struct mem_ctl_info
*mci
;
491 debugf0("MC: %s()\n", __func__
);
492 mutex_lock(&mem_ctls_mutex
);
494 if ((mci
= find_mci_by_dev(dev
)) == NULL
) {
495 mutex_unlock(&mem_ctls_mutex
);
499 /* marking MCI offline */
500 mci
->op_state
= OP_OFFLINE
;
502 /* flush workq processes */
503 edac_mc_workq_teardown(mci
);
505 edac_remove_sysfs_mci_device(mci
);
506 del_mc_from_global_list(mci
);
507 mutex_unlock(&mem_ctls_mutex
);
508 edac_printk(KERN_INFO
, EDAC_MC
,
509 "Removed device %d for %s %s: DEV %s\n", mci
->mc_idx
,
510 mci
->mod_name
, mci
->ctl_name
, dev_name(mci
));
513 EXPORT_SYMBOL_GPL(edac_mc_del_mc
);
515 static void edac_mc_scrub_block(unsigned long page
, unsigned long offset
,
520 unsigned long flags
= 0;
522 debugf3("%s()\n", __func__
);
524 /* ECC error page was not in our memory. Ignore it. */
528 /* Find the actual page structure then map it and fix */
529 pg
= pfn_to_page(page
);
532 local_irq_save(flags
);
534 virt_addr
= kmap_atomic(pg
, KM_BOUNCE_READ
);
536 /* Perform architecture specific atomic scrub operation */
537 atomic_scrub(virt_addr
+ offset
, size
);
539 /* Unmap and complete */
540 kunmap_atomic(virt_addr
, KM_BOUNCE_READ
);
543 local_irq_restore(flags
);
546 /* FIXME - should return -1 */
547 int edac_mc_find_csrow_by_page(struct mem_ctl_info
*mci
, unsigned long page
)
549 struct csrow_info
*csrows
= mci
->csrows
;
552 debugf1("MC%d: %s(): 0x%lx\n", mci
->mc_idx
, __func__
, page
);
555 for (i
= 0; i
< mci
->nr_csrows
; i
++) {
556 struct csrow_info
*csrow
= &csrows
[i
];
558 if (csrow
->nr_pages
== 0)
561 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
562 "mask(0x%lx)\n", mci
->mc_idx
, __func__
,
563 csrow
->first_page
, page
, csrow
->last_page
,
566 if ((page
>= csrow
->first_page
) &&
567 (page
<= csrow
->last_page
) &&
568 ((page
& csrow
->page_mask
) ==
569 (csrow
->first_page
& csrow
->page_mask
))) {
576 edac_mc_printk(mci
, KERN_ERR
,
577 "could not look up page error address %lx\n",
578 (unsigned long) page
);
582 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page
);
584 /* FIXME - setable log (warning/emerg) levels */
585 /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
586 void edac_mc_handle_ce(struct mem_ctl_info
*mci
,
587 unsigned long page_frame_number
, unsigned long offset_in_page
,
588 unsigned long syndrome
, int row
, int channel
, const char *msg
)
590 unsigned long remapped_page
;
592 debugf3("MC%d: %s()\n", mci
->mc_idx
, __func__
);
594 /* FIXME - maybe make panic on INTERNAL ERROR an option */
595 if (row
>= mci
->nr_csrows
|| row
< 0) {
596 /* something is wrong */
597 edac_mc_printk(mci
, KERN_ERR
,
598 "INTERNAL ERROR: row out of range "
599 "(%d >= %d)\n", row
, mci
->nr_csrows
);
600 edac_mc_handle_ce_no_info(mci
, "INTERNAL ERROR");
604 if (channel
>= mci
->csrows
[row
].nr_channels
|| channel
< 0) {
605 /* something is wrong */
606 edac_mc_printk(mci
, KERN_ERR
,
607 "INTERNAL ERROR: channel out of range "
608 "(%d >= %d)\n", channel
,
609 mci
->csrows
[row
].nr_channels
);
610 edac_mc_handle_ce_no_info(mci
, "INTERNAL ERROR");
614 if (edac_get_log_ce())
615 /* FIXME - put in DIMM location */
616 edac_mc_printk(mci
, KERN_WARNING
,
617 "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
618 "0x%lx, row %d, channel %d, label \"%s\": %s\n",
619 page_frame_number
, offset_in_page
,
620 mci
->csrows
[row
].grain
, syndrome
, row
, channel
,
621 mci
->csrows
[row
].channels
[channel
].label
, msg
);
624 mci
->csrows
[row
].ce_count
++;
625 mci
->csrows
[row
].channels
[channel
].ce_count
++;
627 if (mci
->scrub_mode
& SCRUB_SW_SRC
) {
629 * Some MC's can remap memory so that it is still available
630 * at a different address when PCI devices map into memory.
631 * MC's that can't do this lose the memory where PCI devices
632 * are mapped. This mapping is MC dependant and so we call
633 * back into the MC driver for it to map the MC page to
634 * a physical (CPU) page which can then be mapped to a virtual
635 * page - which can then be scrubbed.
637 remapped_page
= mci
->ctl_page_to_phys
?
638 mci
->ctl_page_to_phys(mci
, page_frame_number
) :
641 edac_mc_scrub_block(remapped_page
, offset_in_page
,
642 mci
->csrows
[row
].grain
);
645 EXPORT_SYMBOL_GPL(edac_mc_handle_ce
);
647 void edac_mc_handle_ce_no_info(struct mem_ctl_info
*mci
, const char *msg
)
649 if (edac_get_log_ce())
650 edac_mc_printk(mci
, KERN_WARNING
,
651 "CE - no information available: %s\n", msg
);
653 mci
->ce_noinfo_count
++;
656 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info
);
658 void edac_mc_handle_ue(struct mem_ctl_info
*mci
,
659 unsigned long page_frame_number
, unsigned long offset_in_page
,
660 int row
, const char *msg
)
662 int len
= EDAC_MC_LABEL_LEN
* 4;
663 char labels
[len
+ 1];
668 debugf3("MC%d: %s()\n", mci
->mc_idx
, __func__
);
670 /* FIXME - maybe make panic on INTERNAL ERROR an option */
671 if (row
>= mci
->nr_csrows
|| row
< 0) {
672 /* something is wrong */
673 edac_mc_printk(mci
, KERN_ERR
,
674 "INTERNAL ERROR: row out of range "
675 "(%d >= %d)\n", row
, mci
->nr_csrows
);
676 edac_mc_handle_ue_no_info(mci
, "INTERNAL ERROR");
680 chars
= snprintf(pos
, len
+ 1, "%s",
681 mci
->csrows
[row
].channels
[0].label
);
685 for (chan
= 1; (chan
< mci
->csrows
[row
].nr_channels
) && (len
> 0);
687 chars
= snprintf(pos
, len
+ 1, ":%s",
688 mci
->csrows
[row
].channels
[chan
].label
);
693 if (edac_get_log_ue())
694 edac_mc_printk(mci
, KERN_EMERG
,
695 "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
696 "labels \"%s\": %s\n", page_frame_number
,
697 offset_in_page
, mci
->csrows
[row
].grain
, row
, labels
,
700 if (edac_get_panic_on_ue())
701 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
702 "row %d, labels \"%s\": %s\n", mci
->mc_idx
,
703 page_frame_number
, offset_in_page
,
704 mci
->csrows
[row
].grain
, row
, labels
, msg
);
707 mci
->csrows
[row
].ue_count
++;
709 EXPORT_SYMBOL_GPL(edac_mc_handle_ue
);
711 void edac_mc_handle_ue_no_info(struct mem_ctl_info
*mci
, const char *msg
)
713 if (edac_get_panic_on_ue())
714 panic("EDAC MC%d: Uncorrected Error", mci
->mc_idx
);
716 if (edac_get_log_ue())
717 edac_mc_printk(mci
, KERN_WARNING
,
718 "UE - no information available: %s\n", msg
);
719 mci
->ue_noinfo_count
++;
722 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info
);
725 /*************************************************************
726 * On Fully Buffered DIMM modules, this help function is
727 * called to process UE events
729 void edac_mc_handle_fbd_ue(struct mem_ctl_info
*mci
,
731 unsigned int channela
,
732 unsigned int channelb
,
735 int len
= EDAC_MC_LABEL_LEN
* 4;
736 char labels
[len
+ 1];
740 if (csrow
>= mci
->nr_csrows
) {
741 /* something is wrong */
742 edac_mc_printk(mci
, KERN_ERR
,
743 "INTERNAL ERROR: row out of range (%d >= %d)\n",
744 csrow
, mci
->nr_csrows
);
745 edac_mc_handle_ue_no_info(mci
, "INTERNAL ERROR");
749 if (channela
>= mci
->csrows
[csrow
].nr_channels
) {
750 /* something is wrong */
751 edac_mc_printk(mci
, KERN_ERR
,
752 "INTERNAL ERROR: channel-a out of range "
754 channela
, mci
->csrows
[csrow
].nr_channels
);
755 edac_mc_handle_ue_no_info(mci
, "INTERNAL ERROR");
759 if (channelb
>= mci
->csrows
[csrow
].nr_channels
) {
760 /* something is wrong */
761 edac_mc_printk(mci
, KERN_ERR
,
762 "INTERNAL ERROR: channel-b out of range "
764 channelb
, mci
->csrows
[csrow
].nr_channels
);
765 edac_mc_handle_ue_no_info(mci
, "INTERNAL ERROR");
770 mci
->csrows
[csrow
].ue_count
++;
772 /* Generate the DIMM labels from the specified channels */
773 chars
= snprintf(pos
, len
+ 1, "%s",
774 mci
->csrows
[csrow
].channels
[channela
].label
);
775 len
-= chars
; pos
+= chars
;
776 chars
= snprintf(pos
, len
+ 1, "-%s",
777 mci
->csrows
[csrow
].channels
[channelb
].label
);
779 if (edac_get_log_ue())
780 edac_mc_printk(mci
, KERN_EMERG
,
781 "UE row %d, channel-a= %d channel-b= %d "
782 "labels \"%s\": %s\n", csrow
, channela
, channelb
,
785 if (edac_get_panic_on_ue())
786 panic("UE row %d, channel-a= %d channel-b= %d "
787 "labels \"%s\": %s\n", csrow
, channela
,
788 channelb
, labels
, msg
);
790 EXPORT_SYMBOL(edac_mc_handle_fbd_ue
);
792 /*************************************************************
793 * On Fully Buffered DIMM modules, this help function is
794 * called to process CE events
796 void edac_mc_handle_fbd_ce(struct mem_ctl_info
*mci
,
798 unsigned int channel
,
802 /* Ensure boundary values */
803 if (csrow
>= mci
->nr_csrows
) {
804 /* something is wrong */
805 edac_mc_printk(mci
, KERN_ERR
,
806 "INTERNAL ERROR: row out of range (%d >= %d)\n",
807 csrow
, mci
->nr_csrows
);
808 edac_mc_handle_ce_no_info(mci
, "INTERNAL ERROR");
811 if (channel
>= mci
->csrows
[csrow
].nr_channels
) {
812 /* something is wrong */
813 edac_mc_printk(mci
, KERN_ERR
,
814 "INTERNAL ERROR: channel out of range (%d >= %d)\n",
815 channel
, mci
->csrows
[csrow
].nr_channels
);
816 edac_mc_handle_ce_no_info(mci
, "INTERNAL ERROR");
820 if (edac_get_log_ce())
821 /* FIXME - put in DIMM location */
822 edac_mc_printk(mci
, KERN_WARNING
,
823 "CE row %d, channel %d, label \"%s\": %s\n",
825 mci
->csrows
[csrow
].channels
[channel
].label
,
829 mci
->csrows
[csrow
].ce_count
++;
830 mci
->csrows
[csrow
].channels
[channel
].ce_count
++;
832 EXPORT_SYMBOL(edac_mc_handle_fbd_ce
);
836 * Iterate over all MC instances and check for ECC, et al, errors
838 void edac_check_mc_devices(void)
840 struct list_head
*item
;
841 struct mem_ctl_info
*mci
;
843 debugf3("%s()\n", __func__
);
844 mutex_lock(&mem_ctls_mutex
);
846 list_for_each(item
, &mc_devices
) {
847 mci
= list_entry(item
, struct mem_ctl_info
, link
);
849 if (mci
->edac_check
!= NULL
)
850 mci
->edac_check(mci
);
853 mutex_unlock(&mem_ctls_mutex
);