[ARM] serial: s3c2410: platform_get_irq() may return signed unnoticed
[linux-2.6/openmoko-kernel/knife-kernel.git] / drivers / edac / edac_mc.c
blob063a1bffe38b026ba7005ee0b105a4e956baf6e9
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.
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>
32 #include <asm/page.h>
33 #include <asm/edac.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 struct list_head mc_devices = LIST_HEAD_INIT(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 */
81 /* 'ptr' points to a possibly unaligned item X such that sizeof(X) is 'size'.
82 * Adjust 'ptr' so that its alignment is at least as stringent as what the
83 * compiler would provide for X and return the aligned result.
85 * If 'size' is a constant, the compiler will optimize this whole function
86 * down to either a no-op or the addition of a constant to the value of 'ptr'.
88 void *edac_align_ptr(void *ptr, unsigned size)
90 unsigned align, r;
92 /* Here we assume that the alignment of a "long long" is the most
93 * stringent alignment that the compiler will ever provide by default.
94 * As far as I know, this is a reasonable assumption.
96 if (size > sizeof(long))
97 align = sizeof(long long);
98 else if (size > sizeof(int))
99 align = sizeof(long);
100 else if (size > sizeof(short))
101 align = sizeof(int);
102 else if (size > sizeof(char))
103 align = sizeof(short);
104 else
105 return (char *)ptr;
107 r = size % align;
109 if (r == 0)
110 return (char *)ptr;
112 return (void *)(((unsigned long)ptr) + align - r);
116 * edac_mc_alloc: Allocate a struct mem_ctl_info structure
117 * @size_pvt: size of private storage needed
118 * @nr_csrows: Number of CWROWS needed for this MC
119 * @nr_chans: Number of channels for the MC
121 * Everything is kmalloc'ed as one big chunk - more efficient.
122 * Only can be used if all structures have the same lifetime - otherwise
123 * you have to allocate and initialize your own structures.
125 * Use edac_mc_free() to free mc structures allocated by this function.
127 * Returns:
128 * NULL allocation failed
129 * struct mem_ctl_info pointer
131 struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows,
132 unsigned nr_chans, int edac_index)
134 struct mem_ctl_info *mci;
135 struct csrow_info *csi, *csrow;
136 struct channel_info *chi, *chp, *chan;
137 void *pvt;
138 unsigned size;
139 int row, chn;
140 int err;
142 /* Figure out the offsets of the various items from the start of an mc
143 * structure. We want the alignment of each item to be at least as
144 * stringent as what the compiler would provide if we could simply
145 * hardcode everything into a single struct.
147 mci = (struct mem_ctl_info *)0;
148 csi = edac_align_ptr(&mci[1], sizeof(*csi));
149 chi = edac_align_ptr(&csi[nr_csrows], sizeof(*chi));
150 pvt = edac_align_ptr(&chi[nr_chans * nr_csrows], sz_pvt);
151 size = ((unsigned long)pvt) + sz_pvt;
153 mci = kzalloc(size, GFP_KERNEL);
154 if (mci == NULL)
155 return NULL;
157 /* Adjust pointers so they point within the memory we just allocated
158 * rather than an imaginary chunk of memory located at address 0.
160 csi = (struct csrow_info *)(((char *)mci) + ((unsigned long)csi));
161 chi = (struct channel_info *)(((char *)mci) + ((unsigned long)chi));
162 pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL;
164 /* setup index and various internal pointers */
165 mci->mc_idx = edac_index;
166 mci->csrows = csi;
167 mci->pvt_info = pvt;
168 mci->nr_csrows = nr_csrows;
170 for (row = 0; row < nr_csrows; row++) {
171 csrow = &csi[row];
172 csrow->csrow_idx = row;
173 csrow->mci = mci;
174 csrow->nr_channels = nr_chans;
175 chp = &chi[row * nr_chans];
176 csrow->channels = chp;
178 for (chn = 0; chn < nr_chans; chn++) {
179 chan = &chp[chn];
180 chan->chan_idx = chn;
181 chan->csrow = csrow;
185 mci->op_state = OP_ALLOC;
188 * Initialize the 'root' kobj for the edac_mc controller
190 err = edac_mc_register_sysfs_main_kobj(mci);
191 if (err) {
192 kfree(mci);
193 return NULL;
196 /* at this point, the root kobj is valid, and in order to
197 * 'free' the object, then the function:
198 * edac_mc_unregister_sysfs_main_kobj() must be called
199 * which will perform kobj unregistration and the actual free
200 * will occur during the kobject callback operation
202 return mci;
204 EXPORT_SYMBOL_GPL(edac_mc_alloc);
207 * edac_mc_free
208 * 'Free' a previously allocated 'mci' structure
209 * @mci: pointer to a struct mem_ctl_info structure
211 void edac_mc_free(struct mem_ctl_info *mci)
213 edac_mc_unregister_sysfs_main_kobj(mci);
215 EXPORT_SYMBOL_GPL(edac_mc_free);
219 * find_mci_by_dev
221 * scan list of controllers looking for the one that manages
222 * the 'dev' device
224 static struct mem_ctl_info *find_mci_by_dev(struct device *dev)
226 struct mem_ctl_info *mci;
227 struct list_head *item;
229 debugf3("%s()\n", __func__);
231 list_for_each(item, &mc_devices) {
232 mci = list_entry(item, struct mem_ctl_info, link);
234 if (mci->dev == dev)
235 return mci;
238 return NULL;
242 * handler for EDAC to check if NMI type handler has asserted interrupt
244 static int edac_mc_assert_error_check_and_clear(void)
246 int old_state;
248 if (edac_op_state == EDAC_OPSTATE_POLL)
249 return 1;
251 old_state = edac_err_assert;
252 edac_err_assert = 0;
254 return old_state;
258 * edac_mc_workq_function
259 * performs the operation scheduled by a workq request
261 static void edac_mc_workq_function(struct work_struct *work_req)
263 struct delayed_work *d_work = (struct delayed_work *)work_req;
264 struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
266 mutex_lock(&mem_ctls_mutex);
268 /* if this control struct has movd to offline state, we are done */
269 if (mci->op_state == OP_OFFLINE) {
270 mutex_unlock(&mem_ctls_mutex);
271 return;
274 /* Only poll controllers that are running polled and have a check */
275 if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL))
276 mci->edac_check(mci);
278 mutex_unlock(&mem_ctls_mutex);
280 /* Reschedule */
281 queue_delayed_work(edac_workqueue, &mci->work,
282 msecs_to_jiffies(edac_mc_get_poll_msec()));
286 * edac_mc_workq_setup
287 * initialize a workq item for this mci
288 * passing in the new delay period in msec
290 * locking model:
292 * called with the mem_ctls_mutex held
294 static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec)
296 debugf0("%s()\n", __func__);
298 /* if this instance is not in the POLL state, then simply return */
299 if (mci->op_state != OP_RUNNING_POLL)
300 return;
302 INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
303 queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
307 * edac_mc_workq_teardown
308 * stop the workq processing on this mci
310 * locking model:
312 * called WITHOUT lock held
314 static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
316 int status;
318 status = cancel_delayed_work(&mci->work);
319 if (status == 0) {
320 debugf0("%s() not canceled, flush the queue\n",
321 __func__);
323 /* workq instance might be running, wait for it */
324 flush_workqueue(edac_workqueue);
329 * edac_mc_reset_delay_period(unsigned long value)
331 * user space has updated our poll period value, need to
332 * reset our workq delays
334 void edac_mc_reset_delay_period(int value)
336 struct mem_ctl_info *mci;
337 struct list_head *item;
339 mutex_lock(&mem_ctls_mutex);
341 /* scan the list and turn off all workq timers, doing so under lock
343 list_for_each(item, &mc_devices) {
344 mci = list_entry(item, struct mem_ctl_info, link);
346 if (mci->op_state == OP_RUNNING_POLL)
347 cancel_delayed_work(&mci->work);
350 mutex_unlock(&mem_ctls_mutex);
353 /* re-walk the list, and reset the poll delay */
354 mutex_lock(&mem_ctls_mutex);
356 list_for_each(item, &mc_devices) {
357 mci = list_entry(item, struct mem_ctl_info, link);
359 edac_mc_workq_setup(mci, (unsigned long) value);
362 mutex_unlock(&mem_ctls_mutex);
367 /* Return 0 on success, 1 on failure.
368 * Before calling this function, caller must
369 * assign a unique value to mci->mc_idx.
371 * locking model:
373 * called with the mem_ctls_mutex lock held
375 static int add_mc_to_global_list(struct mem_ctl_info *mci)
377 struct list_head *item, *insert_before;
378 struct mem_ctl_info *p;
380 insert_before = &mc_devices;
382 p = find_mci_by_dev(mci->dev);
383 if (unlikely(p != NULL))
384 goto fail0;
386 list_for_each(item, &mc_devices) {
387 p = list_entry(item, struct mem_ctl_info, link);
389 if (p->mc_idx >= mci->mc_idx) {
390 if (unlikely(p->mc_idx == mci->mc_idx))
391 goto fail1;
393 insert_before = item;
394 break;
398 list_add_tail_rcu(&mci->link, insert_before);
399 atomic_inc(&edac_handlers);
400 return 0;
402 fail0:
403 edac_printk(KERN_WARNING, EDAC_MC,
404 "%s (%s) %s %s already assigned %d\n", p->dev->bus_id,
405 dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
406 return 1;
408 fail1:
409 edac_printk(KERN_WARNING, EDAC_MC,
410 "bug in low-level driver: attempt to assign\n"
411 " duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
412 return 1;
415 static void complete_mc_list_del(struct rcu_head *head)
417 struct mem_ctl_info *mci;
419 mci = container_of(head, struct mem_ctl_info, rcu);
420 INIT_LIST_HEAD(&mci->link);
421 complete(&mci->complete);
424 static void del_mc_from_global_list(struct mem_ctl_info *mci)
426 atomic_dec(&edac_handlers);
427 list_del_rcu(&mci->link);
428 init_completion(&mci->complete);
429 call_rcu(&mci->rcu, complete_mc_list_del);
430 wait_for_completion(&mci->complete);
434 * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
436 * If found, return a pointer to the structure.
437 * Else return NULL.
439 * Caller must hold mem_ctls_mutex.
441 struct mem_ctl_info *edac_mc_find(int idx)
443 struct list_head *item;
444 struct mem_ctl_info *mci;
446 list_for_each(item, &mc_devices) {
447 mci = list_entry(item, struct mem_ctl_info, link);
449 if (mci->mc_idx >= idx) {
450 if (mci->mc_idx == idx)
451 return mci;
453 break;
457 return NULL;
459 EXPORT_SYMBOL(edac_mc_find);
462 * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
463 * create sysfs entries associated with mci structure
464 * @mci: pointer to the mci structure to be added to the list
465 * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
467 * Return:
468 * 0 Success
469 * !0 Failure
472 /* FIXME - should a warning be printed if no error detection? correction? */
473 int edac_mc_add_mc(struct mem_ctl_info *mci)
475 debugf0("%s()\n", __func__);
477 #ifdef CONFIG_EDAC_DEBUG
478 if (edac_debug_level >= 3)
479 edac_mc_dump_mci(mci);
481 if (edac_debug_level >= 4) {
482 int i;
484 for (i = 0; i < mci->nr_csrows; i++) {
485 int j;
487 edac_mc_dump_csrow(&mci->csrows[i]);
488 for (j = 0; j < mci->csrows[i].nr_channels; j++)
489 edac_mc_dump_channel(&mci->csrows[i].
490 channels[j]);
493 #endif
494 mutex_lock(&mem_ctls_mutex);
496 if (add_mc_to_global_list(mci))
497 goto fail0;
499 /* set load time so that error rate can be tracked */
500 mci->start_time = jiffies;
502 if (edac_create_sysfs_mci_device(mci)) {
503 edac_mc_printk(mci, KERN_WARNING,
504 "failed to create sysfs device\n");
505 goto fail1;
508 /* If there IS a check routine, then we are running POLLED */
509 if (mci->edac_check != NULL) {
510 /* This instance is NOW RUNNING */
511 mci->op_state = OP_RUNNING_POLL;
513 edac_mc_workq_setup(mci, edac_mc_get_poll_msec());
514 } else {
515 mci->op_state = OP_RUNNING_INTERRUPT;
518 /* Report action taken */
519 edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
520 " DEV %s\n", mci->mod_name, mci->ctl_name, dev_name(mci));
522 mutex_unlock(&mem_ctls_mutex);
523 return 0;
525 fail1:
526 del_mc_from_global_list(mci);
528 fail0:
529 mutex_unlock(&mem_ctls_mutex);
530 return 1;
532 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
535 * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
536 * remove mci structure from global list
537 * @pdev: Pointer to 'struct device' representing mci structure to remove.
539 * Return pointer to removed mci structure, or NULL if device not found.
541 struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
543 struct mem_ctl_info *mci;
545 debugf0("%s()\n", __func__);
547 mutex_lock(&mem_ctls_mutex);
549 /* find the requested mci struct in the global list */
550 mci = find_mci_by_dev(dev);
551 if (mci == NULL) {
552 mutex_unlock(&mem_ctls_mutex);
553 return NULL;
556 /* marking MCI offline */
557 mci->op_state = OP_OFFLINE;
559 del_mc_from_global_list(mci);
560 mutex_unlock(&mem_ctls_mutex);
562 /* flush workq processes and remove sysfs */
563 edac_mc_workq_teardown(mci);
564 edac_remove_sysfs_mci_device(mci);
566 edac_printk(KERN_INFO, EDAC_MC,
567 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
568 mci->mod_name, mci->ctl_name, dev_name(mci));
570 return mci;
572 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
574 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
575 u32 size)
577 struct page *pg;
578 void *virt_addr;
579 unsigned long flags = 0;
581 debugf3("%s()\n", __func__);
583 /* ECC error page was not in our memory. Ignore it. */
584 if (!pfn_valid(page))
585 return;
587 /* Find the actual page structure then map it and fix */
588 pg = pfn_to_page(page);
590 if (PageHighMem(pg))
591 local_irq_save(flags);
593 virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);
595 /* Perform architecture specific atomic scrub operation */
596 atomic_scrub(virt_addr + offset, size);
598 /* Unmap and complete */
599 kunmap_atomic(virt_addr, KM_BOUNCE_READ);
601 if (PageHighMem(pg))
602 local_irq_restore(flags);
605 /* FIXME - should return -1 */
606 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
608 struct csrow_info *csrows = mci->csrows;
609 int row, i;
611 debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
612 row = -1;
614 for (i = 0; i < mci->nr_csrows; i++) {
615 struct csrow_info *csrow = &csrows[i];
617 if (csrow->nr_pages == 0)
618 continue;
620 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
621 "mask(0x%lx)\n", mci->mc_idx, __func__,
622 csrow->first_page, page, csrow->last_page,
623 csrow->page_mask);
625 if ((page >= csrow->first_page) &&
626 (page <= csrow->last_page) &&
627 ((page & csrow->page_mask) ==
628 (csrow->first_page & csrow->page_mask))) {
629 row = i;
630 break;
634 if (row == -1)
635 edac_mc_printk(mci, KERN_ERR,
636 "could not look up page error address %lx\n",
637 (unsigned long)page);
639 return row;
641 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
643 /* FIXME - setable log (warning/emerg) levels */
644 /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
645 void edac_mc_handle_ce(struct mem_ctl_info *mci,
646 unsigned long page_frame_number,
647 unsigned long offset_in_page, unsigned long syndrome,
648 int row, int channel, const char *msg)
650 unsigned long remapped_page;
652 debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
654 /* FIXME - maybe make panic on INTERNAL ERROR an option */
655 if (row >= mci->nr_csrows || row < 0) {
656 /* something is wrong */
657 edac_mc_printk(mci, KERN_ERR,
658 "INTERNAL ERROR: row out of range "
659 "(%d >= %d)\n", row, mci->nr_csrows);
660 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
661 return;
664 if (channel >= mci->csrows[row].nr_channels || channel < 0) {
665 /* something is wrong */
666 edac_mc_printk(mci, KERN_ERR,
667 "INTERNAL ERROR: channel out of range "
668 "(%d >= %d)\n", channel,
669 mci->csrows[row].nr_channels);
670 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
671 return;
674 if (edac_mc_get_log_ce())
675 /* FIXME - put in DIMM location */
676 edac_mc_printk(mci, KERN_WARNING,
677 "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
678 "0x%lx, row %d, channel %d, label \"%s\": %s\n",
679 page_frame_number, offset_in_page,
680 mci->csrows[row].grain, syndrome, row, channel,
681 mci->csrows[row].channels[channel].label, msg);
683 mci->ce_count++;
684 mci->csrows[row].ce_count++;
685 mci->csrows[row].channels[channel].ce_count++;
687 if (mci->scrub_mode & SCRUB_SW_SRC) {
689 * Some MC's can remap memory so that it is still available
690 * at a different address when PCI devices map into memory.
691 * MC's that can't do this lose the memory where PCI devices
692 * are mapped. This mapping is MC dependant and so we call
693 * back into the MC driver for it to map the MC page to
694 * a physical (CPU) page which can then be mapped to a virtual
695 * page - which can then be scrubbed.
697 remapped_page = mci->ctl_page_to_phys ?
698 mci->ctl_page_to_phys(mci, page_frame_number) :
699 page_frame_number;
701 edac_mc_scrub_block(remapped_page, offset_in_page,
702 mci->csrows[row].grain);
705 EXPORT_SYMBOL_GPL(edac_mc_handle_ce);
707 void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
709 if (edac_mc_get_log_ce())
710 edac_mc_printk(mci, KERN_WARNING,
711 "CE - no information available: %s\n", msg);
713 mci->ce_noinfo_count++;
714 mci->ce_count++;
716 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);
718 void edac_mc_handle_ue(struct mem_ctl_info *mci,
719 unsigned long page_frame_number,
720 unsigned long offset_in_page, int row, const char *msg)
722 int len = EDAC_MC_LABEL_LEN * 4;
723 char labels[len + 1];
724 char *pos = labels;
725 int chan;
726 int chars;
728 debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
730 /* FIXME - maybe make panic on INTERNAL ERROR an option */
731 if (row >= mci->nr_csrows || row < 0) {
732 /* something is wrong */
733 edac_mc_printk(mci, KERN_ERR,
734 "INTERNAL ERROR: row out of range "
735 "(%d >= %d)\n", row, mci->nr_csrows);
736 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
737 return;
740 chars = snprintf(pos, len + 1, "%s",
741 mci->csrows[row].channels[0].label);
742 len -= chars;
743 pos += chars;
745 for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
746 chan++) {
747 chars = snprintf(pos, len + 1, ":%s",
748 mci->csrows[row].channels[chan].label);
749 len -= chars;
750 pos += chars;
753 if (edac_mc_get_log_ue())
754 edac_mc_printk(mci, KERN_EMERG,
755 "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
756 "labels \"%s\": %s\n", page_frame_number,
757 offset_in_page, mci->csrows[row].grain, row,
758 labels, msg);
760 if (edac_mc_get_panic_on_ue())
761 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
762 "row %d, labels \"%s\": %s\n", mci->mc_idx,
763 page_frame_number, offset_in_page,
764 mci->csrows[row].grain, row, labels, msg);
766 mci->ue_count++;
767 mci->csrows[row].ue_count++;
769 EXPORT_SYMBOL_GPL(edac_mc_handle_ue);
771 void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
773 if (edac_mc_get_panic_on_ue())
774 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
776 if (edac_mc_get_log_ue())
777 edac_mc_printk(mci, KERN_WARNING,
778 "UE - no information available: %s\n", msg);
779 mci->ue_noinfo_count++;
780 mci->ue_count++;
782 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);
784 /*************************************************************
785 * On Fully Buffered DIMM modules, this help function is
786 * called to process UE events
788 void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci,
789 unsigned int csrow,
790 unsigned int channela,
791 unsigned int channelb, char *msg)
793 int len = EDAC_MC_LABEL_LEN * 4;
794 char labels[len + 1];
795 char *pos = labels;
796 int chars;
798 if (csrow >= mci->nr_csrows) {
799 /* something is wrong */
800 edac_mc_printk(mci, KERN_ERR,
801 "INTERNAL ERROR: row out of range (%d >= %d)\n",
802 csrow, mci->nr_csrows);
803 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
804 return;
807 if (channela >= mci->csrows[csrow].nr_channels) {
808 /* something is wrong */
809 edac_mc_printk(mci, KERN_ERR,
810 "INTERNAL ERROR: channel-a out of range "
811 "(%d >= %d)\n",
812 channela, mci->csrows[csrow].nr_channels);
813 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
814 return;
817 if (channelb >= mci->csrows[csrow].nr_channels) {
818 /* something is wrong */
819 edac_mc_printk(mci, KERN_ERR,
820 "INTERNAL ERROR: channel-b out of range "
821 "(%d >= %d)\n",
822 channelb, mci->csrows[csrow].nr_channels);
823 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
824 return;
827 mci->ue_count++;
828 mci->csrows[csrow].ue_count++;
830 /* Generate the DIMM labels from the specified channels */
831 chars = snprintf(pos, len + 1, "%s",
832 mci->csrows[csrow].channels[channela].label);
833 len -= chars;
834 pos += chars;
835 chars = snprintf(pos, len + 1, "-%s",
836 mci->csrows[csrow].channels[channelb].label);
838 if (edac_mc_get_log_ue())
839 edac_mc_printk(mci, KERN_EMERG,
840 "UE row %d, channel-a= %d channel-b= %d "
841 "labels \"%s\": %s\n", csrow, channela, channelb,
842 labels, msg);
844 if (edac_mc_get_panic_on_ue())
845 panic("UE row %d, channel-a= %d channel-b= %d "
846 "labels \"%s\": %s\n", csrow, channela,
847 channelb, labels, msg);
849 EXPORT_SYMBOL(edac_mc_handle_fbd_ue);
851 /*************************************************************
852 * On Fully Buffered DIMM modules, this help function is
853 * called to process CE events
855 void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
856 unsigned int csrow, unsigned int channel, char *msg)
859 /* Ensure boundary values */
860 if (csrow >= mci->nr_csrows) {
861 /* something is wrong */
862 edac_mc_printk(mci, KERN_ERR,
863 "INTERNAL ERROR: row out of range (%d >= %d)\n",
864 csrow, mci->nr_csrows);
865 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
866 return;
868 if (channel >= mci->csrows[csrow].nr_channels) {
869 /* something is wrong */
870 edac_mc_printk(mci, KERN_ERR,
871 "INTERNAL ERROR: channel out of range (%d >= %d)\n",
872 channel, mci->csrows[csrow].nr_channels);
873 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
874 return;
877 if (edac_mc_get_log_ce())
878 /* FIXME - put in DIMM location */
879 edac_mc_printk(mci, KERN_WARNING,
880 "CE row %d, channel %d, label \"%s\": %s\n",
881 csrow, channel,
882 mci->csrows[csrow].channels[channel].label, msg);
884 mci->ce_count++;
885 mci->csrows[csrow].ce_count++;
886 mci->csrows[csrow].channels[channel].ce_count++;
888 EXPORT_SYMBOL(edac_mc_handle_fbd_ce);
891 * Iterate over all MC instances and check for ECC, et al, errors
893 void edac_check_mc_devices(void)
895 struct list_head *item;
896 struct mem_ctl_info *mci;
898 debugf3("%s()\n", __func__);
899 mutex_lock(&mem_ctls_mutex);
901 list_for_each(item, &mc_devices) {
902 mci = list_entry(item, struct mem_ctl_info, link);
904 if (mci->edac_check != NULL)
905 mci->edac_check(mci);
908 mutex_unlock(&mem_ctls_mutex);