[SCSI] bfa: remove unused and empty functions
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / edac / edac_mc.c
blob795ea69c4d8f5fb6149c62fba8e085bd83363309
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 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);
80 * keep those in sync with the enum mem_type
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",
101 EXPORT_SYMBOL_GPL(edac_mem_types);
103 #endif /* CONFIG_EDAC_DEBUG */
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)
114 unsigned align, r;
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))
125 align = sizeof(int);
126 else if (size > sizeof(char))
127 align = sizeof(short);
128 else
129 return (char *)ptr;
131 r = size % align;
133 if (r == 0)
134 return (char *)ptr;
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.
151 * Returns:
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;
161 void *pvt;
162 unsigned size;
163 int row, chn;
164 int err;
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);
178 if (mci == NULL)
179 return NULL;
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;
190 mci->csrows = csi;
191 mci->pvt_info = pvt;
192 mci->nr_csrows = nr_csrows;
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;
202 for (chn = 0; chn < nr_chans; chn++) {
203 chan = &chp[chn];
204 chan->chan_idx = chn;
205 chan->csrow = csrow;
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);
216 if (err) {
217 kfree(mci);
218 return NULL;
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
227 return mci;
229 EXPORT_SYMBOL_GPL(edac_mc_alloc);
232 * edac_mc_free
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 */
243 kfree(mci);
245 EXPORT_SYMBOL_GPL(edac_mc_free);
249 * find_mci_by_dev
251 * scan list of controllers looking for the one that manages
252 * the 'dev' device
253 * @dev: pointer to a struct device related with the MCI
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);
265 if (mci->dev == dev)
266 return mci;
269 return NULL;
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)
278 int old_state;
280 if (edac_op_state == EDAC_OPSTATE_POLL)
281 return 1;
283 old_state = edac_err_assert;
284 edac_err_assert = 0;
286 return old_state;
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);
303 return;
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);
312 /* Reschedule */
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
322 * locking model:
324 * called with the mem_ctls_mutex held
326 static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec)
328 debugf0("%s()\n", __func__);
330 /* if this instance is not in the POLL state, then simply return */
331 if (mci->op_state != OP_RUNNING_POLL)
332 return;
334 INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
335 queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
339 * edac_mc_workq_teardown
340 * stop the workq processing on this mci
342 * locking model:
344 * called WITHOUT lock held
346 static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
348 int status;
350 if (mci->op_state != OP_RUNNING_POLL)
351 return;
353 status = cancel_delayed_work(&mci->work);
354 if (status == 0) {
355 debugf0("%s() not canceled, flush the queue\n",
356 __func__);
358 /* workq instance might be running, wait for it */
359 flush_workqueue(edac_workqueue);
364 * edac_mc_reset_delay_period(unsigned long value)
366 * user space has updated our poll period value, need to
367 * reset our workq delays
369 void edac_mc_reset_delay_period(int value)
371 struct mem_ctl_info *mci;
372 struct list_head *item;
374 mutex_lock(&mem_ctls_mutex);
376 /* scan the list and turn off all workq timers, doing so under lock
378 list_for_each(item, &mc_devices) {
379 mci = list_entry(item, struct mem_ctl_info, link);
381 if (mci->op_state == OP_RUNNING_POLL)
382 cancel_delayed_work(&mci->work);
385 mutex_unlock(&mem_ctls_mutex);
388 /* re-walk the list, and reset the poll delay */
389 mutex_lock(&mem_ctls_mutex);
391 list_for_each(item, &mc_devices) {
392 mci = list_entry(item, struct mem_ctl_info, link);
394 edac_mc_workq_setup(mci, (unsigned long) value);
397 mutex_unlock(&mem_ctls_mutex);
402 /* Return 0 on success, 1 on failure.
403 * Before calling this function, caller must
404 * assign a unique value to mci->mc_idx.
406 * locking model:
408 * called with the mem_ctls_mutex lock held
410 static int add_mc_to_global_list(struct mem_ctl_info *mci)
412 struct list_head *item, *insert_before;
413 struct mem_ctl_info *p;
415 insert_before = &mc_devices;
417 p = find_mci_by_dev(mci->dev);
418 if (unlikely(p != NULL))
419 goto fail0;
421 list_for_each(item, &mc_devices) {
422 p = list_entry(item, struct mem_ctl_info, link);
424 if (p->mc_idx >= mci->mc_idx) {
425 if (unlikely(p->mc_idx == mci->mc_idx))
426 goto fail1;
428 insert_before = item;
429 break;
433 list_add_tail_rcu(&mci->link, insert_before);
434 atomic_inc(&edac_handlers);
435 return 0;
437 fail0:
438 edac_printk(KERN_WARNING, EDAC_MC,
439 "%s (%s) %s %s already assigned %d\n", dev_name(p->dev),
440 edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
441 return 1;
443 fail1:
444 edac_printk(KERN_WARNING, EDAC_MC,
445 "bug in low-level driver: attempt to assign\n"
446 " duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
447 return 1;
450 static void complete_mc_list_del(struct rcu_head *head)
452 struct mem_ctl_info *mci;
454 mci = container_of(head, struct mem_ctl_info, rcu);
455 INIT_LIST_HEAD(&mci->link);
458 static void del_mc_from_global_list(struct mem_ctl_info *mci)
460 atomic_dec(&edac_handlers);
461 list_del_rcu(&mci->link);
462 call_rcu(&mci->rcu, complete_mc_list_del);
463 rcu_barrier();
467 * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
469 * If found, return a pointer to the structure.
470 * Else return NULL.
472 * Caller must hold mem_ctls_mutex.
474 struct mem_ctl_info *edac_mc_find(int idx)
476 struct list_head *item;
477 struct mem_ctl_info *mci;
479 list_for_each(item, &mc_devices) {
480 mci = list_entry(item, struct mem_ctl_info, link);
482 if (mci->mc_idx >= idx) {
483 if (mci->mc_idx == idx)
484 return mci;
486 break;
490 return NULL;
492 EXPORT_SYMBOL(edac_mc_find);
495 * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
496 * create sysfs entries associated with mci structure
497 * @mci: pointer to the mci structure to be added to the list
498 * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
500 * Return:
501 * 0 Success
502 * !0 Failure
505 /* FIXME - should a warning be printed if no error detection? correction? */
506 int edac_mc_add_mc(struct mem_ctl_info *mci)
508 debugf0("%s()\n", __func__);
510 #ifdef CONFIG_EDAC_DEBUG
511 if (edac_debug_level >= 3)
512 edac_mc_dump_mci(mci);
514 if (edac_debug_level >= 4) {
515 int i;
517 for (i = 0; i < mci->nr_csrows; i++) {
518 int j;
520 edac_mc_dump_csrow(&mci->csrows[i]);
521 for (j = 0; j < mci->csrows[i].nr_channels; j++)
522 edac_mc_dump_channel(&mci->csrows[i].
523 channels[j]);
526 #endif
527 mutex_lock(&mem_ctls_mutex);
529 if (add_mc_to_global_list(mci))
530 goto fail0;
532 /* set load time so that error rate can be tracked */
533 mci->start_time = jiffies;
535 if (edac_create_sysfs_mci_device(mci)) {
536 edac_mc_printk(mci, KERN_WARNING,
537 "failed to create sysfs device\n");
538 goto fail1;
541 /* If there IS a check routine, then we are running POLLED */
542 if (mci->edac_check != NULL) {
543 /* This instance is NOW RUNNING */
544 mci->op_state = OP_RUNNING_POLL;
546 edac_mc_workq_setup(mci, edac_mc_get_poll_msec());
547 } else {
548 mci->op_state = OP_RUNNING_INTERRUPT;
551 /* Report action taken */
552 edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
553 " DEV %s\n", mci->mod_name, mci->ctl_name, edac_dev_name(mci));
555 mutex_unlock(&mem_ctls_mutex);
556 return 0;
558 fail1:
559 del_mc_from_global_list(mci);
561 fail0:
562 mutex_unlock(&mem_ctls_mutex);
563 return 1;
565 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
568 * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
569 * remove mci structure from global list
570 * @pdev: Pointer to 'struct device' representing mci structure to remove.
572 * Return pointer to removed mci structure, or NULL if device not found.
574 struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
576 struct mem_ctl_info *mci;
578 debugf0("%s()\n", __func__);
580 mutex_lock(&mem_ctls_mutex);
582 /* find the requested mci struct in the global list */
583 mci = find_mci_by_dev(dev);
584 if (mci == NULL) {
585 mutex_unlock(&mem_ctls_mutex);
586 return NULL;
589 del_mc_from_global_list(mci);
590 mutex_unlock(&mem_ctls_mutex);
592 /* flush workq processes */
593 edac_mc_workq_teardown(mci);
595 /* marking MCI offline */
596 mci->op_state = OP_OFFLINE;
598 /* remove from sysfs */
599 edac_remove_sysfs_mci_device(mci);
601 edac_printk(KERN_INFO, EDAC_MC,
602 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
603 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
605 return mci;
607 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
609 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
610 u32 size)
612 struct page *pg;
613 void *virt_addr;
614 unsigned long flags = 0;
616 debugf3("%s()\n", __func__);
618 /* ECC error page was not in our memory. Ignore it. */
619 if (!pfn_valid(page))
620 return;
622 /* Find the actual page structure then map it and fix */
623 pg = pfn_to_page(page);
625 if (PageHighMem(pg))
626 local_irq_save(flags);
628 virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);
630 /* Perform architecture specific atomic scrub operation */
631 atomic_scrub(virt_addr + offset, size);
633 /* Unmap and complete */
634 kunmap_atomic(virt_addr, KM_BOUNCE_READ);
636 if (PageHighMem(pg))
637 local_irq_restore(flags);
640 /* FIXME - should return -1 */
641 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
643 struct csrow_info *csrows = mci->csrows;
644 int row, i;
646 debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
647 row = -1;
649 for (i = 0; i < mci->nr_csrows; i++) {
650 struct csrow_info *csrow = &csrows[i];
652 if (csrow->nr_pages == 0)
653 continue;
655 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
656 "mask(0x%lx)\n", mci->mc_idx, __func__,
657 csrow->first_page, page, csrow->last_page,
658 csrow->page_mask);
660 if ((page >= csrow->first_page) &&
661 (page <= csrow->last_page) &&
662 ((page & csrow->page_mask) ==
663 (csrow->first_page & csrow->page_mask))) {
664 row = i;
665 break;
669 if (row == -1)
670 edac_mc_printk(mci, KERN_ERR,
671 "could not look up page error address %lx\n",
672 (unsigned long)page);
674 return row;
676 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
678 /* FIXME - setable log (warning/emerg) levels */
679 /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
680 void edac_mc_handle_ce(struct mem_ctl_info *mci,
681 unsigned long page_frame_number,
682 unsigned long offset_in_page, unsigned long syndrome,
683 int row, int channel, const char *msg)
685 unsigned long remapped_page;
687 debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
689 /* FIXME - maybe make panic on INTERNAL ERROR an option */
690 if (row >= mci->nr_csrows || row < 0) {
691 /* something is wrong */
692 edac_mc_printk(mci, KERN_ERR,
693 "INTERNAL ERROR: row out of range "
694 "(%d >= %d)\n", row, mci->nr_csrows);
695 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
696 return;
699 if (channel >= mci->csrows[row].nr_channels || channel < 0) {
700 /* something is wrong */
701 edac_mc_printk(mci, KERN_ERR,
702 "INTERNAL ERROR: channel out of range "
703 "(%d >= %d)\n", channel,
704 mci->csrows[row].nr_channels);
705 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
706 return;
709 if (edac_mc_get_log_ce())
710 /* FIXME - put in DIMM location */
711 edac_mc_printk(mci, KERN_WARNING,
712 "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
713 "0x%lx, row %d, channel %d, label \"%s\": %s\n",
714 page_frame_number, offset_in_page,
715 mci->csrows[row].grain, syndrome, row, channel,
716 mci->csrows[row].channels[channel].label, msg);
718 mci->ce_count++;
719 mci->csrows[row].ce_count++;
720 mci->csrows[row].channels[channel].ce_count++;
722 if (mci->scrub_mode & SCRUB_SW_SRC) {
724 * Some MC's can remap memory so that it is still available
725 * at a different address when PCI devices map into memory.
726 * MC's that can't do this lose the memory where PCI devices
727 * are mapped. This mapping is MC dependant and so we call
728 * back into the MC driver for it to map the MC page to
729 * a physical (CPU) page which can then be mapped to a virtual
730 * page - which can then be scrubbed.
732 remapped_page = mci->ctl_page_to_phys ?
733 mci->ctl_page_to_phys(mci, page_frame_number) :
734 page_frame_number;
736 edac_mc_scrub_block(remapped_page, offset_in_page,
737 mci->csrows[row].grain);
740 EXPORT_SYMBOL_GPL(edac_mc_handle_ce);
742 void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
744 if (edac_mc_get_log_ce())
745 edac_mc_printk(mci, KERN_WARNING,
746 "CE - no information available: %s\n", msg);
748 mci->ce_noinfo_count++;
749 mci->ce_count++;
751 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);
753 void edac_mc_handle_ue(struct mem_ctl_info *mci,
754 unsigned long page_frame_number,
755 unsigned long offset_in_page, int row, const char *msg)
757 int len = EDAC_MC_LABEL_LEN * 4;
758 char labels[len + 1];
759 char *pos = labels;
760 int chan;
761 int chars;
763 debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
765 /* FIXME - maybe make panic on INTERNAL ERROR an option */
766 if (row >= mci->nr_csrows || row < 0) {
767 /* something is wrong */
768 edac_mc_printk(mci, KERN_ERR,
769 "INTERNAL ERROR: row out of range "
770 "(%d >= %d)\n", row, mci->nr_csrows);
771 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
772 return;
775 chars = snprintf(pos, len + 1, "%s",
776 mci->csrows[row].channels[0].label);
777 len -= chars;
778 pos += chars;
780 for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
781 chan++) {
782 chars = snprintf(pos, len + 1, ":%s",
783 mci->csrows[row].channels[chan].label);
784 len -= chars;
785 pos += chars;
788 if (edac_mc_get_log_ue())
789 edac_mc_printk(mci, KERN_EMERG,
790 "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
791 "labels \"%s\": %s\n", page_frame_number,
792 offset_in_page, mci->csrows[row].grain, row,
793 labels, msg);
795 if (edac_mc_get_panic_on_ue())
796 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
797 "row %d, labels \"%s\": %s\n", mci->mc_idx,
798 page_frame_number, offset_in_page,
799 mci->csrows[row].grain, row, labels, msg);
801 mci->ue_count++;
802 mci->csrows[row].ue_count++;
804 EXPORT_SYMBOL_GPL(edac_mc_handle_ue);
806 void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
808 if (edac_mc_get_panic_on_ue())
809 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
811 if (edac_mc_get_log_ue())
812 edac_mc_printk(mci, KERN_WARNING,
813 "UE - no information available: %s\n", msg);
814 mci->ue_noinfo_count++;
815 mci->ue_count++;
817 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);
819 /*************************************************************
820 * On Fully Buffered DIMM modules, this help function is
821 * called to process UE events
823 void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci,
824 unsigned int csrow,
825 unsigned int channela,
826 unsigned int channelb, char *msg)
828 int len = EDAC_MC_LABEL_LEN * 4;
829 char labels[len + 1];
830 char *pos = labels;
831 int chars;
833 if (csrow >= mci->nr_csrows) {
834 /* something is wrong */
835 edac_mc_printk(mci, KERN_ERR,
836 "INTERNAL ERROR: row out of range (%d >= %d)\n",
837 csrow, mci->nr_csrows);
838 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
839 return;
842 if (channela >= mci->csrows[csrow].nr_channels) {
843 /* something is wrong */
844 edac_mc_printk(mci, KERN_ERR,
845 "INTERNAL ERROR: channel-a out of range "
846 "(%d >= %d)\n",
847 channela, mci->csrows[csrow].nr_channels);
848 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
849 return;
852 if (channelb >= mci->csrows[csrow].nr_channels) {
853 /* something is wrong */
854 edac_mc_printk(mci, KERN_ERR,
855 "INTERNAL ERROR: channel-b out of range "
856 "(%d >= %d)\n",
857 channelb, mci->csrows[csrow].nr_channels);
858 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
859 return;
862 mci->ue_count++;
863 mci->csrows[csrow].ue_count++;
865 /* Generate the DIMM labels from the specified channels */
866 chars = snprintf(pos, len + 1, "%s",
867 mci->csrows[csrow].channels[channela].label);
868 len -= chars;
869 pos += chars;
870 chars = snprintf(pos, len + 1, "-%s",
871 mci->csrows[csrow].channels[channelb].label);
873 if (edac_mc_get_log_ue())
874 edac_mc_printk(mci, KERN_EMERG,
875 "UE row %d, channel-a= %d channel-b= %d "
876 "labels \"%s\": %s\n", csrow, channela, channelb,
877 labels, msg);
879 if (edac_mc_get_panic_on_ue())
880 panic("UE row %d, channel-a= %d channel-b= %d "
881 "labels \"%s\": %s\n", csrow, channela,
882 channelb, labels, msg);
884 EXPORT_SYMBOL(edac_mc_handle_fbd_ue);
886 /*************************************************************
887 * On Fully Buffered DIMM modules, this help function is
888 * called to process CE events
890 void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
891 unsigned int csrow, unsigned int channel, char *msg)
894 /* Ensure boundary values */
895 if (csrow >= mci->nr_csrows) {
896 /* something is wrong */
897 edac_mc_printk(mci, KERN_ERR,
898 "INTERNAL ERROR: row out of range (%d >= %d)\n",
899 csrow, mci->nr_csrows);
900 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
901 return;
903 if (channel >= mci->csrows[csrow].nr_channels) {
904 /* something is wrong */
905 edac_mc_printk(mci, KERN_ERR,
906 "INTERNAL ERROR: channel out of range (%d >= %d)\n",
907 channel, mci->csrows[csrow].nr_channels);
908 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
909 return;
912 if (edac_mc_get_log_ce())
913 /* FIXME - put in DIMM location */
914 edac_mc_printk(mci, KERN_WARNING,
915 "CE row %d, channel %d, label \"%s\": %s\n",
916 csrow, channel,
917 mci->csrows[csrow].channels[channel].label, msg);
919 mci->ce_count++;
920 mci->csrows[csrow].ce_count++;
921 mci->csrows[csrow].channels[channel].ce_count++;
923 EXPORT_SYMBOL(edac_mc_handle_fbd_ce);