3be5b7fe79cddf4c37bfc9033f8f6d88b3d5fe98
[linux-2.6.git] / drivers / edac / edac_mc.c
1 /*
2  * edac_mc kernel module
3  * (C) 2005, 2006 Linux Networx (http://lnxi.com)
4  * This file may be distributed under the terms of the
5  * GNU General Public License.
6  *
7  * Written by Thayne Harbaugh
8  * Based on work by Dan Hollis <goemon at anime dot net> and others.
9  *      http://www.anime.net/~goemon/linux-ecc/
10  *
11  * Modified by Dave Peterson and Doug Thompson
12  *
13  */
14
15 #include <linux/module.h>
16 #include <linux/proc_fs.h>
17 #include <linux/kernel.h>
18 #include <linux/types.h>
19 #include <linux/smp.h>
20 #include <linux/init.h>
21 #include <linux/sysctl.h>
22 #include <linux/highmem.h>
23 #include <linux/timer.h>
24 #include <linux/slab.h>
25 #include <linux/jiffies.h>
26 #include <linux/spinlock.h>
27 #include <linux/list.h>
28 #include <linux/sysdev.h>
29 #include <linux/ctype.h>
30 #include <asm/uaccess.h>
31 #include <asm/page.h>
32 #include <asm/edac.h>
33 #include "edac_mc.h"
34 #include "edac_module.h"
35
36
37 /* lock to memory controller's control array */
38 static DECLARE_MUTEX(mem_ctls_mutex);
39 static struct list_head mc_devices = LIST_HEAD_INIT(mc_devices);
40
41 #ifdef CONFIG_EDAC_DEBUG
42
43 static void edac_mc_dump_channel(struct channel_info *chan)
44 {
45         debugf4("\tchannel = %p\n", chan);
46         debugf4("\tchannel->chan_idx = %d\n", chan->chan_idx);
47         debugf4("\tchannel->ce_count = %d\n", chan->ce_count);
48         debugf4("\tchannel->label = '%s'\n", chan->label);
49         debugf4("\tchannel->csrow = %p\n\n", chan->csrow);
50 }
51
52 static void edac_mc_dump_csrow(struct csrow_info *csrow)
53 {
54         debugf4("\tcsrow = %p\n", csrow);
55         debugf4("\tcsrow->csrow_idx = %d\n", csrow->csrow_idx);
56         debugf4("\tcsrow->first_page = 0x%lx\n",
57                 csrow->first_page);
58         debugf4("\tcsrow->last_page = 0x%lx\n", csrow->last_page);
59         debugf4("\tcsrow->page_mask = 0x%lx\n", csrow->page_mask);
60         debugf4("\tcsrow->nr_pages = 0x%x\n", csrow->nr_pages);
61         debugf4("\tcsrow->nr_channels = %d\n",
62                 csrow->nr_channels);
63         debugf4("\tcsrow->channels = %p\n", csrow->channels);
64         debugf4("\tcsrow->mci = %p\n\n", csrow->mci);
65 }
66
67 static void edac_mc_dump_mci(struct mem_ctl_info *mci)
68 {
69         debugf3("\tmci = %p\n", mci);
70         debugf3("\tmci->mtype_cap = %lx\n", mci->mtype_cap);
71         debugf3("\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap);
72         debugf3("\tmci->edac_cap = %lx\n", mci->edac_cap);
73         debugf4("\tmci->edac_check = %p\n", mci->edac_check);
74         debugf3("\tmci->nr_csrows = %d, csrows = %p\n",
75                 mci->nr_csrows, mci->csrows);
76         debugf3("\tdev = %p\n", mci->dev);
77         debugf3("\tmod_name:ctl_name = %s:%s\n",
78                 mci->mod_name, mci->ctl_name);
79         debugf3("\tpvt_info = %p\n\n", mci->pvt_info);
80 }
81
82 #endif  /* CONFIG_EDAC_DEBUG */
83
84 /* 'ptr' points to a possibly unaligned item X such that sizeof(X) is 'size'.
85  * Adjust 'ptr' so that its alignment is at least as stringent as what the
86  * compiler would provide for X and return the aligned result.
87  *
88  * If 'size' is a constant, the compiler will optimize this whole function
89  * down to either a no-op or the addition of a constant to the value of 'ptr'.
90  */
91 static inline char * align_ptr(void *ptr, unsigned size)
92 {
93         unsigned align, r;
94
95         /* Here we assume that the alignment of a "long long" is the most
96          * stringent alignment that the compiler will ever provide by default.
97          * As far as I know, this is a reasonable assumption.
98          */
99         if (size > sizeof(long))
100                 align = sizeof(long long);
101         else if (size > sizeof(int))
102                 align = sizeof(long);
103         else if (size > sizeof(short))
104                 align = sizeof(int);
105         else if (size > sizeof(char))
106                 align = sizeof(short);
107         else
108                 return (char *) ptr;
109
110         r = size % align;
111
112         if (r == 0)
113                 return (char *) ptr;
114
115         return (char *) (((unsigned long) ptr) + align - r);
116 }
117
118 /**
119  * edac_mc_alloc: Allocate a struct mem_ctl_info structure
120  * @size_pvt:   size of private storage needed
121  * @nr_csrows:  Number of CWROWS needed for this MC
122  * @nr_chans:   Number of channels for the MC
123  *
124  * Everything is kmalloc'ed as one big chunk - more efficient.
125  * Only can be used if all structures have the same lifetime - otherwise
126  * you have to allocate and initialize your own structures.
127  *
128  * Use edac_mc_free() to free mc structures allocated by this function.
129  *
130  * Returns:
131  *      NULL allocation failed
132  *      struct mem_ctl_info pointer
133  */
134 struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows,
135                 unsigned nr_chans)
136 {
137         struct mem_ctl_info *mci;
138         struct csrow_info *csi, *csrow;
139         struct channel_info *chi, *chp, *chan;
140         void *pvt;
141         unsigned size;
142         int row, chn;
143
144         /* Figure out the offsets of the various items from the start of an mc
145          * structure.  We want the alignment of each item to be at least as
146          * stringent as what the compiler would provide if we could simply
147          * hardcode everything into a single struct.
148          */
149         mci = (struct mem_ctl_info *) 0;
150         csi = (struct csrow_info *)align_ptr(&mci[1], sizeof(*csi));
151         chi = (struct channel_info *)
152                         align_ptr(&csi[nr_csrows], sizeof(*chi));
153         pvt = align_ptr(&chi[nr_chans * nr_csrows], sz_pvt);
154         size = ((unsigned long) pvt) + sz_pvt;
155
156         if ((mci = kmalloc(size, GFP_KERNEL)) == NULL)
157                 return NULL;
158
159         /* Adjust pointers so they point within the memory we just allocated
160          * rather than an imaginary chunk of memory located at address 0.
161          */
162         csi = (struct csrow_info *) (((char *) mci) + ((unsigned long) csi));
163         chi = (struct channel_info *) (((char *) mci) + ((unsigned long) chi));
164         pvt = sz_pvt ? (((char *) mci) + ((unsigned long) pvt)) : NULL;
165
166         memset(mci, 0, size);  /* clear all fields */
167         mci->csrows = csi;
168         mci->pvt_info = pvt;
169         mci->nr_csrows = nr_csrows;
170
171         for (row = 0; row < nr_csrows; row++) {
172                 csrow = &csi[row];
173                 csrow->csrow_idx = row;
174                 csrow->mci = mci;
175                 csrow->nr_channels = nr_chans;
176                 chp = &chi[row * nr_chans];
177                 csrow->channels = chp;
178
179                 for (chn = 0; chn < nr_chans; chn++) {
180                         chan = &chp[chn];
181                         chan->chan_idx = chn;
182                         chan->csrow = csrow;
183                 }
184         }
185
186         return mci;
187 }
188 EXPORT_SYMBOL_GPL(edac_mc_alloc);
189
190 /**
191  * edac_mc_free:  Free a previously allocated 'mci' structure
192  * @mci: pointer to a struct mem_ctl_info structure
193  */
194 void edac_mc_free(struct mem_ctl_info *mci)
195 {
196         kfree(mci);
197 }
198 EXPORT_SYMBOL_GPL(edac_mc_free);
199
200 static struct mem_ctl_info *find_mci_by_dev(struct device *dev)
201 {
202         struct mem_ctl_info *mci;
203         struct list_head *item;
204
205         debugf3("%s()\n", __func__);
206
207         list_for_each(item, &mc_devices) {
208                 mci = list_entry(item, struct mem_ctl_info, link);
209
210                 if (mci->dev == dev)
211                         return mci;
212         }
213
214         return NULL;
215 }
216
217 /* Return 0 on success, 1 on failure.
218  * Before calling this function, caller must
219  * assign a unique value to mci->mc_idx.
220  */
221 static int add_mc_to_global_list (struct mem_ctl_info *mci)
222 {
223         struct list_head *item, *insert_before;
224         struct mem_ctl_info *p;
225
226         insert_before = &mc_devices;
227
228         if (unlikely((p = find_mci_by_dev(mci->dev)) != NULL))
229                 goto fail0;
230
231         list_for_each(item, &mc_devices) {
232                 p = list_entry(item, struct mem_ctl_info, link);
233
234                 if (p->mc_idx >= mci->mc_idx) {
235                         if (unlikely(p->mc_idx == mci->mc_idx))
236                                 goto fail1;
237
238                         insert_before = item;
239                         break;
240                 }
241         }
242
243         list_add_tail_rcu(&mci->link, insert_before);
244         return 0;
245
246 fail0:
247         edac_printk(KERN_WARNING, EDAC_MC,
248                     "%s (%s) %s %s already assigned %d\n", p->dev->bus_id,
249                     dev_name(p->dev), p->mod_name, p->ctl_name, p->mc_idx);
250         return 1;
251
252 fail1:
253         edac_printk(KERN_WARNING, EDAC_MC,
254                     "bug in low-level driver: attempt to assign\n"
255                     "    duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
256         return 1;
257 }
258
259 static void complete_mc_list_del(struct rcu_head *head)
260 {
261         struct mem_ctl_info *mci;
262
263         mci = container_of(head, struct mem_ctl_info, rcu);
264         INIT_LIST_HEAD(&mci->link);
265         complete(&mci->complete);
266 }
267
268 static void del_mc_from_global_list(struct mem_ctl_info *mci)
269 {
270         list_del_rcu(&mci->link);
271         init_completion(&mci->complete);
272         call_rcu(&mci->rcu, complete_mc_list_del);
273         wait_for_completion(&mci->complete);
274 }
275
276 /**
277  * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
278  *
279  * If found, return a pointer to the structure.
280  * Else return NULL.
281  *
282  * Caller must hold mem_ctls_mutex.
283  */
284 struct mem_ctl_info * edac_mc_find(int idx)
285 {
286         struct list_head *item;
287         struct mem_ctl_info *mci;
288
289         list_for_each(item, &mc_devices) {
290                 mci = list_entry(item, struct mem_ctl_info, link);
291
292                 if (mci->mc_idx >= idx) {
293                         if (mci->mc_idx == idx)
294                                 return mci;
295
296                         break;
297                 }
298         }
299
300         return NULL;
301 }
302 EXPORT_SYMBOL(edac_mc_find);
303
304 /**
305  * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
306  *                 create sysfs entries associated with mci structure
307  * @mci: pointer to the mci structure to be added to the list
308  * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
309  *
310  * Return:
311  *      0       Success
312  *      !0      Failure
313  */
314
315 /* FIXME - should a warning be printed if no error detection? correction? */
316 int edac_mc_add_mc(struct mem_ctl_info *mci, int mc_idx)
317 {
318         debugf0("%s()\n", __func__);
319         mci->mc_idx = mc_idx;
320 #ifdef CONFIG_EDAC_DEBUG
321         if (edac_debug_level >= 3)
322                 edac_mc_dump_mci(mci);
323
324         if (edac_debug_level >= 4) {
325                 int i;
326
327                 for (i = 0; i < mci->nr_csrows; i++) {
328                         int j;
329
330                         edac_mc_dump_csrow(&mci->csrows[i]);
331                         for (j = 0; j < mci->csrows[i].nr_channels; j++)
332                                 edac_mc_dump_channel(
333                                         &mci->csrows[i].channels[j]);
334                 }
335         }
336 #endif
337         down(&mem_ctls_mutex);
338
339         if (add_mc_to_global_list(mci))
340                 goto fail0;
341
342         /* set load time so that error rate can be tracked */
343         mci->start_time = jiffies;
344
345         if (edac_create_sysfs_mci_device(mci)) {
346                 edac_mc_printk(mci, KERN_WARNING,
347                         "failed to create sysfs device\n");
348                 goto fail1;
349         }
350
351         /* Report action taken */
352         edac_mc_printk(mci, KERN_INFO, "Giving out device to %s %s: DEV %s\n",
353                 mci->mod_name, mci->ctl_name, dev_name(mci->dev));
354
355         up(&mem_ctls_mutex);
356         return 0;
357
358 fail1:
359         del_mc_from_global_list(mci);
360
361 fail0:
362         up(&mem_ctls_mutex);
363         return 1;
364 }
365 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
366
367 /**
368  * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
369  *                 remove mci structure from global list
370  * @pdev: Pointer to 'struct device' representing mci structure to remove.
371  *
372  * Return pointer to removed mci structure, or NULL if device not found.
373  */
374 struct mem_ctl_info * edac_mc_del_mc(struct device *dev)
375 {
376         struct mem_ctl_info *mci;
377
378         debugf0("MC: %s()\n", __func__);
379         down(&mem_ctls_mutex);
380
381         if ((mci = find_mci_by_dev(dev)) == NULL) {
382                 up(&mem_ctls_mutex);
383                 return NULL;
384         }
385
386         edac_remove_sysfs_mci_device(mci);
387         del_mc_from_global_list(mci);
388         up(&mem_ctls_mutex);
389         edac_printk(KERN_INFO, EDAC_MC,
390                 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
391                 mci->mod_name, mci->ctl_name, dev_name(mci->dev));
392         return mci;
393 }
394 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
395
396 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
397                                 u32 size)
398 {
399         struct page *pg;
400         void *virt_addr;
401         unsigned long flags = 0;
402
403         debugf3("%s()\n", __func__);
404
405         /* ECC error page was not in our memory. Ignore it. */
406         if(!pfn_valid(page))
407                 return;
408
409         /* Find the actual page structure then map it and fix */
410         pg = pfn_to_page(page);
411
412         if (PageHighMem(pg))
413                 local_irq_save(flags);
414
415         virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);
416
417         /* Perform architecture specific atomic scrub operation */
418         atomic_scrub(virt_addr + offset, size);
419
420         /* Unmap and complete */
421         kunmap_atomic(virt_addr, KM_BOUNCE_READ);
422
423         if (PageHighMem(pg))
424                 local_irq_restore(flags);
425 }
426
427 /* FIXME - should return -1 */
428 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
429 {
430         struct csrow_info *csrows = mci->csrows;
431         int row, i;
432
433         debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
434         row = -1;
435
436         for (i = 0; i < mci->nr_csrows; i++) {
437                 struct csrow_info *csrow = &csrows[i];
438
439                 if (csrow->nr_pages == 0)
440                         continue;
441
442                 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
443                         "mask(0x%lx)\n", mci->mc_idx, __func__,
444                         csrow->first_page, page, csrow->last_page,
445                         csrow->page_mask);
446
447                 if ((page >= csrow->first_page) &&
448                     (page <= csrow->last_page) &&
449                     ((page & csrow->page_mask) ==
450                      (csrow->first_page & csrow->page_mask))) {
451                         row = i;
452                         break;
453                 }
454         }
455
456         if (row == -1)
457                 edac_mc_printk(mci, KERN_ERR,
458                         "could not look up page error address %lx\n",
459                         (unsigned long) page);
460
461         return row;
462 }
463 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
464
465 /* FIXME - setable log (warning/emerg) levels */
466 /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
467 void edac_mc_handle_ce(struct mem_ctl_info *mci,
468                 unsigned long page_frame_number, unsigned long offset_in_page,
469                 unsigned long syndrome, int row, int channel, const char *msg)
470 {
471         unsigned long remapped_page;
472
473         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
474
475         /* FIXME - maybe make panic on INTERNAL ERROR an option */
476         if (row >= mci->nr_csrows || row < 0) {
477                 /* something is wrong */
478                 edac_mc_printk(mci, KERN_ERR,
479                         "INTERNAL ERROR: row out of range "
480                         "(%d >= %d)\n", row, mci->nr_csrows);
481                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
482                 return;
483         }
484
485         if (channel >= mci->csrows[row].nr_channels || channel < 0) {
486                 /* something is wrong */
487                 edac_mc_printk(mci, KERN_ERR,
488                         "INTERNAL ERROR: channel out of range "
489                         "(%d >= %d)\n", channel,
490                         mci->csrows[row].nr_channels);
491                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
492                 return;
493         }
494
495         if (edac_get_log_ce())
496                 /* FIXME - put in DIMM location */
497                 edac_mc_printk(mci, KERN_WARNING,
498                         "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
499                         "0x%lx, row %d, channel %d, label \"%s\": %s\n",
500                         page_frame_number, offset_in_page,
501                         mci->csrows[row].grain, syndrome, row, channel,
502                         mci->csrows[row].channels[channel].label, msg);
503
504         mci->ce_count++;
505         mci->csrows[row].ce_count++;
506         mci->csrows[row].channels[channel].ce_count++;
507
508         if (mci->scrub_mode & SCRUB_SW_SRC) {
509                 /*
510                  * Some MC's can remap memory so that it is still available
511                  * at a different address when PCI devices map into memory.
512                  * MC's that can't do this lose the memory where PCI devices
513                  * are mapped.  This mapping is MC dependant and so we call
514                  * back into the MC driver for it to map the MC page to
515                  * a physical (CPU) page which can then be mapped to a virtual
516                  * page - which can then be scrubbed.
517                  */
518                 remapped_page = mci->ctl_page_to_phys ?
519                     mci->ctl_page_to_phys(mci, page_frame_number) :
520                     page_frame_number;
521
522                 edac_mc_scrub_block(remapped_page, offset_in_page,
523                                         mci->csrows[row].grain);
524         }
525 }
526 EXPORT_SYMBOL_GPL(edac_mc_handle_ce);
527
528 void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
529 {
530         if (edac_get_log_ce())
531                 edac_mc_printk(mci, KERN_WARNING,
532                         "CE - no information available: %s\n", msg);
533
534         mci->ce_noinfo_count++;
535         mci->ce_count++;
536 }
537 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);
538
539 void edac_mc_handle_ue(struct mem_ctl_info *mci,
540                 unsigned long page_frame_number, unsigned long offset_in_page,
541                 int row, const char *msg)
542 {
543         int len = EDAC_MC_LABEL_LEN * 4;
544         char labels[len + 1];
545         char *pos = labels;
546         int chan;
547         int chars;
548
549         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
550
551         /* FIXME - maybe make panic on INTERNAL ERROR an option */
552         if (row >= mci->nr_csrows || row < 0) {
553                 /* something is wrong */
554                 edac_mc_printk(mci, KERN_ERR,
555                         "INTERNAL ERROR: row out of range "
556                         "(%d >= %d)\n", row, mci->nr_csrows);
557                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
558                 return;
559         }
560
561         chars = snprintf(pos, len + 1, "%s",
562                         mci->csrows[row].channels[0].label);
563         len -= chars;
564         pos += chars;
565
566         for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
567              chan++) {
568                 chars = snprintf(pos, len + 1, ":%s",
569                                 mci->csrows[row].channels[chan].label);
570                 len -= chars;
571                 pos += chars;
572         }
573
574         if (edac_get_log_ue())
575                 edac_mc_printk(mci, KERN_EMERG,
576                         "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
577                         "labels \"%s\": %s\n", page_frame_number,
578                         offset_in_page, mci->csrows[row].grain, row, labels,
579                         msg);
580
581         if (edac_get_panic_on_ue())
582                 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
583                         "row %d, labels \"%s\": %s\n", mci->mc_idx,
584                         page_frame_number, offset_in_page,
585                         mci->csrows[row].grain, row, labels, msg);
586
587         mci->ue_count++;
588         mci->csrows[row].ue_count++;
589 }
590 EXPORT_SYMBOL_GPL(edac_mc_handle_ue);
591
592 void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
593 {
594         if (edac_get_panic_on_ue())
595                 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
596
597         if (edac_get_log_ue())
598                 edac_mc_printk(mci, KERN_WARNING,
599                         "UE - no information available: %s\n", msg);
600         mci->ue_noinfo_count++;
601         mci->ue_count++;
602 }
603 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);
604
605
606 /*************************************************************
607  * On Fully Buffered DIMM modules, this help function is
608  * called to process UE events
609  */
610 void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci,
611                                 unsigned int csrow,
612                                 unsigned int channela,
613                                 unsigned int channelb,
614                                 char *msg)
615 {
616         int len = EDAC_MC_LABEL_LEN * 4;
617         char labels[len + 1];
618         char *pos = labels;
619         int chars;
620
621         if (csrow >= mci->nr_csrows) {
622                 /* something is wrong */
623                 edac_mc_printk(mci, KERN_ERR,
624                         "INTERNAL ERROR: row out of range (%d >= %d)\n",
625                         csrow, mci->nr_csrows);
626                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
627                 return;
628         }
629
630         if (channela >= mci->csrows[csrow].nr_channels) {
631                 /* something is wrong */
632                 edac_mc_printk(mci, KERN_ERR,
633                         "INTERNAL ERROR: channel-a out of range "
634                         "(%d >= %d)\n",
635                         channela, mci->csrows[csrow].nr_channels);
636                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
637                 return;
638         }
639
640         if (channelb >= mci->csrows[csrow].nr_channels) {
641                 /* something is wrong */
642                 edac_mc_printk(mci, KERN_ERR,
643                         "INTERNAL ERROR: channel-b out of range "
644                         "(%d >= %d)\n",
645                         channelb, mci->csrows[csrow].nr_channels);
646                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
647                 return;
648         }
649
650         mci->ue_count++;
651         mci->csrows[csrow].ue_count++;
652
653         /* Generate the DIMM labels from the specified channels */
654         chars = snprintf(pos, len + 1, "%s",
655                          mci->csrows[csrow].channels[channela].label);
656         len -= chars; pos += chars;
657         chars = snprintf(pos, len + 1, "-%s",
658                          mci->csrows[csrow].channels[channelb].label);
659
660         if (edac_get_log_ue())
661                 edac_mc_printk(mci, KERN_EMERG,
662                         "UE row %d, channel-a= %d channel-b= %d "
663                         "labels \"%s\": %s\n", csrow, channela, channelb,
664                         labels, msg);
665
666         if (edac_get_panic_on_ue())
667                 panic("UE row %d, channel-a= %d channel-b= %d "
668                                 "labels \"%s\": %s\n", csrow, channela,
669                                 channelb, labels, msg);
670 }
671 EXPORT_SYMBOL(edac_mc_handle_fbd_ue);
672
673 /*************************************************************
674  * On Fully Buffered DIMM modules, this help function is
675  * called to process CE events
676  */
677 void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
678                            unsigned int csrow,
679                            unsigned int channel,
680                            char *msg)
681 {
682
683         /* Ensure boundary values */
684         if (csrow >= mci->nr_csrows) {
685                 /* something is wrong */
686                 edac_mc_printk(mci, KERN_ERR,
687                         "INTERNAL ERROR: row out of range (%d >= %d)\n",
688                         csrow, mci->nr_csrows);
689                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
690                 return;
691         }
692         if (channel >= mci->csrows[csrow].nr_channels) {
693                 /* something is wrong */
694                 edac_mc_printk(mci, KERN_ERR,
695                         "INTERNAL ERROR: channel out of range (%d >= %d)\n",
696                         channel, mci->csrows[csrow].nr_channels);
697                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
698                 return;
699         }
700
701         if (edac_get_log_ce())
702                 /* FIXME - put in DIMM location */
703                 edac_mc_printk(mci, KERN_WARNING,
704                         "CE row %d, channel %d, label \"%s\": %s\n",
705                         csrow, channel,
706                         mci->csrows[csrow].channels[channel].label,
707                         msg);
708
709         mci->ce_count++;
710         mci->csrows[csrow].ce_count++;
711         mci->csrows[csrow].channels[channel].ce_count++;
712 }
713 EXPORT_SYMBOL(edac_mc_handle_fbd_ce);
714
715
716 /*
717  * Iterate over all MC instances and check for ECC, et al, errors
718  */
719 void edac_check_mc_devices(void)
720 {
721         struct list_head *item;
722         struct mem_ctl_info *mci;
723
724         debugf3("%s()\n", __func__);
725         down(&mem_ctls_mutex);
726
727         list_for_each(item, &mc_devices) {
728                 mci = list_entry(item, struct mem_ctl_info, link);
729
730                 if (mci->edac_check != NULL)
731                         mci->edac_check(mci);
732         }
733
734         up(&mem_ctls_mutex);
735 }