feef7733fae7702733feb642bfcf0ac7c431f484
[linux-3.10.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/ctype.h>
29 #include <linux/edac.h>
30 #include <asm/uaccess.h>
31 #include <asm/page.h>
32 #include <asm/edac.h>
33 #include "edac_core.h"
34 #include "edac_module.h"
35
36 /* lock to memory controller's control array */
37 static DEFINE_MUTEX(mem_ctls_mutex);
38 static LIST_HEAD(mc_devices);
39
40 #ifdef CONFIG_EDAC_DEBUG
41
42 static void edac_mc_dump_channel(struct rank_info *chan)
43 {
44         debugf4("\tchannel = %p\n", chan);
45         debugf4("\tchannel->chan_idx = %d\n", chan->chan_idx);
46         debugf4("\tchannel->ce_count = %d\n", chan->ce_count);
47         debugf4("\tchannel->label = '%s'\n", chan->label);
48         debugf4("\tchannel->csrow = %p\n\n", chan->csrow);
49 }
50
51 static void edac_mc_dump_csrow(struct csrow_info *csrow)
52 {
53         debugf4("\tcsrow = %p\n", csrow);
54         debugf4("\tcsrow->csrow_idx = %d\n", csrow->csrow_idx);
55         debugf4("\tcsrow->first_page = 0x%lx\n", csrow->first_page);
56         debugf4("\tcsrow->last_page = 0x%lx\n", csrow->last_page);
57         debugf4("\tcsrow->page_mask = 0x%lx\n", csrow->page_mask);
58         debugf4("\tcsrow->nr_pages = 0x%x\n", csrow->nr_pages);
59         debugf4("\tcsrow->nr_channels = %d\n", csrow->nr_channels);
60         debugf4("\tcsrow->channels = %p\n", csrow->channels);
61         debugf4("\tcsrow->mci = %p\n\n", csrow->mci);
62 }
63
64 static void edac_mc_dump_mci(struct mem_ctl_info *mci)
65 {
66         debugf3("\tmci = %p\n", mci);
67         debugf3("\tmci->mtype_cap = %lx\n", mci->mtype_cap);
68         debugf3("\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap);
69         debugf3("\tmci->edac_cap = %lx\n", mci->edac_cap);
70         debugf4("\tmci->edac_check = %p\n", mci->edac_check);
71         debugf3("\tmci->nr_csrows = %d, csrows = %p\n",
72                 mci->nr_csrows, mci->csrows);
73         debugf3("\tdev = %p\n", mci->dev);
74         debugf3("\tmod_name:ctl_name = %s:%s\n", mci->mod_name, mci->ctl_name);
75         debugf3("\tpvt_info = %p\n\n", mci->pvt_info);
76 }
77
78 #endif                          /* CONFIG_EDAC_DEBUG */
79
80 /*
81  * keep those in sync with the enum mem_type
82  */
83 const char *edac_mem_types[] = {
84         "Empty csrow",
85         "Reserved csrow type",
86         "Unknown csrow type",
87         "Fast page mode RAM",
88         "Extended data out RAM",
89         "Burst Extended data out RAM",
90         "Single data rate SDRAM",
91         "Registered single data rate SDRAM",
92         "Double data rate SDRAM",
93         "Registered Double data rate SDRAM",
94         "Rambus DRAM",
95         "Unbuffered DDR2 RAM",
96         "Fully buffered DDR2",
97         "Registered DDR2 RAM",
98         "Rambus XDR",
99         "Unbuffered DDR3 RAM",
100         "Registered DDR3 RAM",
101 };
102 EXPORT_SYMBOL_GPL(edac_mem_types);
103
104 /* 'ptr' points to a possibly unaligned item X such that sizeof(X) is 'size'.
105  * Adjust 'ptr' so that its alignment is at least as stringent as what the
106  * compiler would provide for X and return the aligned result.
107  *
108  * If 'size' is a constant, the compiler will optimize this whole function
109  * down to either a no-op or the addition of a constant to the value of 'ptr'.
110  */
111 void *edac_align_ptr(void *ptr, unsigned size)
112 {
113         unsigned align, r;
114
115         /* Here we assume that the alignment of a "long long" is the most
116          * stringent alignment that the compiler will ever provide by default.
117          * As far as I know, this is a reasonable assumption.
118          */
119         if (size > sizeof(long))
120                 align = sizeof(long long);
121         else if (size > sizeof(int))
122                 align = sizeof(long);
123         else if (size > sizeof(short))
124                 align = sizeof(int);
125         else if (size > sizeof(char))
126                 align = sizeof(short);
127         else
128                 return (char *)ptr;
129
130         r = size % align;
131
132         if (r == 0)
133                 return (char *)ptr;
134
135         return (void *)(((unsigned long)ptr) + align - r);
136 }
137
138 /**
139  * edac_mc_alloc: Allocate a struct mem_ctl_info structure
140  * @size_pvt:   size of private storage needed
141  * @nr_csrows:  Number of CWROWS needed for this MC
142  * @nr_chans:   Number of channels for the MC
143  *
144  * Everything is kmalloc'ed as one big chunk - more efficient.
145  * Only can be used if all structures have the same lifetime - otherwise
146  * you have to allocate and initialize your own structures.
147  *
148  * Use edac_mc_free() to free mc structures allocated by this function.
149  *
150  * Returns:
151  *      NULL allocation failed
152  *      struct mem_ctl_info pointer
153  */
154 struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows,
155                                 unsigned nr_chans, int edac_index)
156 {
157         struct mem_ctl_info *mci;
158         struct csrow_info *csi, *csrow;
159         struct rank_info *chi, *chp, *chan;
160         void *pvt;
161         unsigned size;
162         int row, chn;
163         int err;
164
165         /* Figure out the offsets of the various items from the start of an mc
166          * structure.  We want the alignment of each item to be at least as
167          * stringent as what the compiler would provide if we could simply
168          * hardcode everything into a single struct.
169          */
170         mci = (struct mem_ctl_info *)0;
171         csi = edac_align_ptr(&mci[1], sizeof(*csi));
172         chi = edac_align_ptr(&csi[nr_csrows], sizeof(*chi));
173         pvt = edac_align_ptr(&chi[nr_chans * nr_csrows], sz_pvt);
174         size = ((unsigned long)pvt) + sz_pvt;
175
176         mci = kzalloc(size, GFP_KERNEL);
177         if (mci == NULL)
178                 return NULL;
179
180         /* Adjust pointers so they point within the memory we just allocated
181          * rather than an imaginary chunk of memory located at address 0.
182          */
183         csi = (struct csrow_info *)(((char *)mci) + ((unsigned long)csi));
184         chi = (struct rank_info *)(((char *)mci) + ((unsigned long)chi));
185         pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL;
186
187         /* setup index and various internal pointers */
188         mci->mc_idx = edac_index;
189         mci->csrows = csi;
190         mci->pvt_info = pvt;
191         mci->nr_csrows = nr_csrows;
192
193         for (row = 0; row < nr_csrows; row++) {
194                 csrow = &csi[row];
195                 csrow->csrow_idx = row;
196                 csrow->mci = mci;
197                 csrow->nr_channels = nr_chans;
198                 chp = &chi[row * nr_chans];
199                 csrow->channels = chp;
200
201                 for (chn = 0; chn < nr_chans; chn++) {
202                         chan = &chp[chn];
203                         chan->chan_idx = chn;
204                         chan->csrow = csrow;
205                 }
206         }
207
208         mci->op_state = OP_ALLOC;
209         INIT_LIST_HEAD(&mci->grp_kobj_list);
210
211         /*
212          * Initialize the 'root' kobj for the edac_mc controller
213          */
214         err = edac_mc_register_sysfs_main_kobj(mci);
215         if (err) {
216                 kfree(mci);
217                 return NULL;
218         }
219
220         /* at this point, the root kobj is valid, and in order to
221          * 'free' the object, then the function:
222          *      edac_mc_unregister_sysfs_main_kobj() must be called
223          * which will perform kobj unregistration and the actual free
224          * will occur during the kobject callback operation
225          */
226         return mci;
227 }
228 EXPORT_SYMBOL_GPL(edac_mc_alloc);
229
230 /**
231  * edac_mc_free
232  *      'Free' a previously allocated 'mci' structure
233  * @mci: pointer to a struct mem_ctl_info structure
234  */
235 void edac_mc_free(struct mem_ctl_info *mci)
236 {
237         debugf1("%s()\n", __func__);
238
239         edac_mc_unregister_sysfs_main_kobj(mci);
240
241         /* free the mci instance memory here */
242         kfree(mci);
243 }
244 EXPORT_SYMBOL_GPL(edac_mc_free);
245
246
247 /**
248  * find_mci_by_dev
249  *
250  *      scan list of controllers looking for the one that manages
251  *      the 'dev' device
252  * @dev: pointer to a struct device related with the MCI
253  */
254 struct mem_ctl_info *find_mci_by_dev(struct device *dev)
255 {
256         struct mem_ctl_info *mci;
257         struct list_head *item;
258
259         debugf3("%s()\n", __func__);
260
261         list_for_each(item, &mc_devices) {
262                 mci = list_entry(item, struct mem_ctl_info, link);
263
264                 if (mci->dev == dev)
265                         return mci;
266         }
267
268         return NULL;
269 }
270 EXPORT_SYMBOL_GPL(find_mci_by_dev);
271
272 /*
273  * handler for EDAC to check if NMI type handler has asserted interrupt
274  */
275 static int edac_mc_assert_error_check_and_clear(void)
276 {
277         int old_state;
278
279         if (edac_op_state == EDAC_OPSTATE_POLL)
280                 return 1;
281
282         old_state = edac_err_assert;
283         edac_err_assert = 0;
284
285         return old_state;
286 }
287
288 /*
289  * edac_mc_workq_function
290  *      performs the operation scheduled by a workq request
291  */
292 static void edac_mc_workq_function(struct work_struct *work_req)
293 {
294         struct delayed_work *d_work = to_delayed_work(work_req);
295         struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
296
297         mutex_lock(&mem_ctls_mutex);
298
299         /* if this control struct has movd to offline state, we are done */
300         if (mci->op_state == OP_OFFLINE) {
301                 mutex_unlock(&mem_ctls_mutex);
302                 return;
303         }
304
305         /* Only poll controllers that are running polled and have a check */
306         if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL))
307                 mci->edac_check(mci);
308
309         mutex_unlock(&mem_ctls_mutex);
310
311         /* Reschedule */
312         queue_delayed_work(edac_workqueue, &mci->work,
313                         msecs_to_jiffies(edac_mc_get_poll_msec()));
314 }
315
316 /*
317  * edac_mc_workq_setup
318  *      initialize a workq item for this mci
319  *      passing in the new delay period in msec
320  *
321  *      locking model:
322  *
323  *              called with the mem_ctls_mutex held
324  */
325 static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec)
326 {
327         debugf0("%s()\n", __func__);
328
329         /* if this instance is not in the POLL state, then simply return */
330         if (mci->op_state != OP_RUNNING_POLL)
331                 return;
332
333         INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
334         queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
335 }
336
337 /*
338  * edac_mc_workq_teardown
339  *      stop the workq processing on this mci
340  *
341  *      locking model:
342  *
343  *              called WITHOUT lock held
344  */
345 static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
346 {
347         int status;
348
349         if (mci->op_state != OP_RUNNING_POLL)
350                 return;
351
352         status = cancel_delayed_work(&mci->work);
353         if (status == 0) {
354                 debugf0("%s() not canceled, flush the queue\n",
355                         __func__);
356
357                 /* workq instance might be running, wait for it */
358                 flush_workqueue(edac_workqueue);
359         }
360 }
361
362 /*
363  * edac_mc_reset_delay_period(unsigned long value)
364  *
365  *      user space has updated our poll period value, need to
366  *      reset our workq delays
367  */
368 void edac_mc_reset_delay_period(int value)
369 {
370         struct mem_ctl_info *mci;
371         struct list_head *item;
372
373         mutex_lock(&mem_ctls_mutex);
374
375         /* scan the list and turn off all workq timers, doing so under lock
376          */
377         list_for_each(item, &mc_devices) {
378                 mci = list_entry(item, struct mem_ctl_info, link);
379
380                 if (mci->op_state == OP_RUNNING_POLL)
381                         cancel_delayed_work(&mci->work);
382         }
383
384         mutex_unlock(&mem_ctls_mutex);
385
386
387         /* re-walk the list, and reset the poll delay */
388         mutex_lock(&mem_ctls_mutex);
389
390         list_for_each(item, &mc_devices) {
391                 mci = list_entry(item, struct mem_ctl_info, link);
392
393                 edac_mc_workq_setup(mci, (unsigned long) value);
394         }
395
396         mutex_unlock(&mem_ctls_mutex);
397 }
398
399
400
401 /* Return 0 on success, 1 on failure.
402  * Before calling this function, caller must
403  * assign a unique value to mci->mc_idx.
404  *
405  *      locking model:
406  *
407  *              called with the mem_ctls_mutex lock held
408  */
409 static int add_mc_to_global_list(struct mem_ctl_info *mci)
410 {
411         struct list_head *item, *insert_before;
412         struct mem_ctl_info *p;
413
414         insert_before = &mc_devices;
415
416         p = find_mci_by_dev(mci->dev);
417         if (unlikely(p != NULL))
418                 goto fail0;
419
420         list_for_each(item, &mc_devices) {
421                 p = list_entry(item, struct mem_ctl_info, link);
422
423                 if (p->mc_idx >= mci->mc_idx) {
424                         if (unlikely(p->mc_idx == mci->mc_idx))
425                                 goto fail1;
426
427                         insert_before = item;
428                         break;
429                 }
430         }
431
432         list_add_tail_rcu(&mci->link, insert_before);
433         atomic_inc(&edac_handlers);
434         return 0;
435
436 fail0:
437         edac_printk(KERN_WARNING, EDAC_MC,
438                 "%s (%s) %s %s already assigned %d\n", dev_name(p->dev),
439                 edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
440         return 1;
441
442 fail1:
443         edac_printk(KERN_WARNING, EDAC_MC,
444                 "bug in low-level driver: attempt to assign\n"
445                 "    duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
446         return 1;
447 }
448
449 static void del_mc_from_global_list(struct mem_ctl_info *mci)
450 {
451         atomic_dec(&edac_handlers);
452         list_del_rcu(&mci->link);
453
454         /* these are for safe removal of devices from global list while
455          * NMI handlers may be traversing list
456          */
457         synchronize_rcu();
458         INIT_LIST_HEAD(&mci->link);
459 }
460
461 /**
462  * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
463  *
464  * If found, return a pointer to the structure.
465  * Else return NULL.
466  *
467  * Caller must hold mem_ctls_mutex.
468  */
469 struct mem_ctl_info *edac_mc_find(int idx)
470 {
471         struct list_head *item;
472         struct mem_ctl_info *mci;
473
474         list_for_each(item, &mc_devices) {
475                 mci = list_entry(item, struct mem_ctl_info, link);
476
477                 if (mci->mc_idx >= idx) {
478                         if (mci->mc_idx == idx)
479                                 return mci;
480
481                         break;
482                 }
483         }
484
485         return NULL;
486 }
487 EXPORT_SYMBOL(edac_mc_find);
488
489 /**
490  * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
491  *                 create sysfs entries associated with mci structure
492  * @mci: pointer to the mci structure to be added to the list
493  * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
494  *
495  * Return:
496  *      0       Success
497  *      !0      Failure
498  */
499
500 /* FIXME - should a warning be printed if no error detection? correction? */
501 int edac_mc_add_mc(struct mem_ctl_info *mci)
502 {
503         debugf0("%s()\n", __func__);
504
505 #ifdef CONFIG_EDAC_DEBUG
506         if (edac_debug_level >= 3)
507                 edac_mc_dump_mci(mci);
508
509         if (edac_debug_level >= 4) {
510                 int i;
511
512                 for (i = 0; i < mci->nr_csrows; i++) {
513                         int j;
514
515                         edac_mc_dump_csrow(&mci->csrows[i]);
516                         for (j = 0; j < mci->csrows[i].nr_channels; j++)
517                                 edac_mc_dump_channel(&mci->csrows[i].
518                                                 channels[j]);
519                 }
520         }
521 #endif
522         mutex_lock(&mem_ctls_mutex);
523
524         if (add_mc_to_global_list(mci))
525                 goto fail0;
526
527         /* set load time so that error rate can be tracked */
528         mci->start_time = jiffies;
529
530         if (edac_create_sysfs_mci_device(mci)) {
531                 edac_mc_printk(mci, KERN_WARNING,
532                         "failed to create sysfs device\n");
533                 goto fail1;
534         }
535
536         /* If there IS a check routine, then we are running POLLED */
537         if (mci->edac_check != NULL) {
538                 /* This instance is NOW RUNNING */
539                 mci->op_state = OP_RUNNING_POLL;
540
541                 edac_mc_workq_setup(mci, edac_mc_get_poll_msec());
542         } else {
543                 mci->op_state = OP_RUNNING_INTERRUPT;
544         }
545
546         /* Report action taken */
547         edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
548                 " DEV %s\n", mci->mod_name, mci->ctl_name, edac_dev_name(mci));
549
550         mutex_unlock(&mem_ctls_mutex);
551         return 0;
552
553 fail1:
554         del_mc_from_global_list(mci);
555
556 fail0:
557         mutex_unlock(&mem_ctls_mutex);
558         return 1;
559 }
560 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
561
562 /**
563  * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
564  *                 remove mci structure from global list
565  * @pdev: Pointer to 'struct device' representing mci structure to remove.
566  *
567  * Return pointer to removed mci structure, or NULL if device not found.
568  */
569 struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
570 {
571         struct mem_ctl_info *mci;
572
573         debugf0("%s()\n", __func__);
574
575         mutex_lock(&mem_ctls_mutex);
576
577         /* find the requested mci struct in the global list */
578         mci = find_mci_by_dev(dev);
579         if (mci == NULL) {
580                 mutex_unlock(&mem_ctls_mutex);
581                 return NULL;
582         }
583
584         del_mc_from_global_list(mci);
585         mutex_unlock(&mem_ctls_mutex);
586
587         /* flush workq processes */
588         edac_mc_workq_teardown(mci);
589
590         /* marking MCI offline */
591         mci->op_state = OP_OFFLINE;
592
593         /* remove from sysfs */
594         edac_remove_sysfs_mci_device(mci);
595
596         edac_printk(KERN_INFO, EDAC_MC,
597                 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
598                 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
599
600         return mci;
601 }
602 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
603
604 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
605                                 u32 size)
606 {
607         struct page *pg;
608         void *virt_addr;
609         unsigned long flags = 0;
610
611         debugf3("%s()\n", __func__);
612
613         /* ECC error page was not in our memory. Ignore it. */
614         if (!pfn_valid(page))
615                 return;
616
617         /* Find the actual page structure then map it and fix */
618         pg = pfn_to_page(page);
619
620         if (PageHighMem(pg))
621                 local_irq_save(flags);
622
623         virt_addr = kmap_atomic(pg);
624
625         /* Perform architecture specific atomic scrub operation */
626         atomic_scrub(virt_addr + offset, size);
627
628         /* Unmap and complete */
629         kunmap_atomic(virt_addr);
630
631         if (PageHighMem(pg))
632                 local_irq_restore(flags);
633 }
634
635 /* FIXME - should return -1 */
636 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
637 {
638         struct csrow_info *csrows = mci->csrows;
639         int row, i;
640
641         debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
642         row = -1;
643
644         for (i = 0; i < mci->nr_csrows; i++) {
645                 struct csrow_info *csrow = &csrows[i];
646
647                 if (csrow->nr_pages == 0)
648                         continue;
649
650                 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
651                         "mask(0x%lx)\n", mci->mc_idx, __func__,
652                         csrow->first_page, page, csrow->last_page,
653                         csrow->page_mask);
654
655                 if ((page >= csrow->first_page) &&
656                     (page <= csrow->last_page) &&
657                     ((page & csrow->page_mask) ==
658                      (csrow->first_page & csrow->page_mask))) {
659                         row = i;
660                         break;
661                 }
662         }
663
664         if (row == -1)
665                 edac_mc_printk(mci, KERN_ERR,
666                         "could not look up page error address %lx\n",
667                         (unsigned long)page);
668
669         return row;
670 }
671 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
672
673 /* FIXME - setable log (warning/emerg) levels */
674 /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
675 void edac_mc_handle_ce(struct mem_ctl_info *mci,
676                 unsigned long page_frame_number,
677                 unsigned long offset_in_page, unsigned long syndrome,
678                 int row, int channel, const char *msg)
679 {
680         unsigned long remapped_page;
681
682         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
683
684         /* FIXME - maybe make panic on INTERNAL ERROR an option */
685         if (row >= mci->nr_csrows || row < 0) {
686                 /* something is wrong */
687                 edac_mc_printk(mci, KERN_ERR,
688                         "INTERNAL ERROR: row out of range "
689                         "(%d >= %d)\n", row, mci->nr_csrows);
690                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
691                 return;
692         }
693
694         if (channel >= mci->csrows[row].nr_channels || channel < 0) {
695                 /* something is wrong */
696                 edac_mc_printk(mci, KERN_ERR,
697                         "INTERNAL ERROR: channel out of range "
698                         "(%d >= %d)\n", channel,
699                         mci->csrows[row].nr_channels);
700                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
701                 return;
702         }
703
704         if (edac_mc_get_log_ce())
705                 /* FIXME - put in DIMM location */
706                 edac_mc_printk(mci, KERN_WARNING,
707                         "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
708                         "0x%lx, row %d, channel %d, label \"%s\": %s\n",
709                         page_frame_number, offset_in_page,
710                         mci->csrows[row].grain, syndrome, row, channel,
711                         mci->csrows[row].channels[channel].label, msg);
712
713         mci->ce_count++;
714         mci->csrows[row].ce_count++;
715         mci->csrows[row].channels[channel].ce_count++;
716
717         if (mci->scrub_mode & SCRUB_SW_SRC) {
718                 /*
719                  * Some MC's can remap memory so that it is still available
720                  * at a different address when PCI devices map into memory.
721                  * MC's that can't do this lose the memory where PCI devices
722                  * are mapped.  This mapping is MC dependent and so we call
723                  * back into the MC driver for it to map the MC page to
724                  * a physical (CPU) page which can then be mapped to a virtual
725                  * page - which can then be scrubbed.
726                  */
727                 remapped_page = mci->ctl_page_to_phys ?
728                         mci->ctl_page_to_phys(mci, page_frame_number) :
729                         page_frame_number;
730
731                 edac_mc_scrub_block(remapped_page, offset_in_page,
732                                 mci->csrows[row].grain);
733         }
734 }
735 EXPORT_SYMBOL_GPL(edac_mc_handle_ce);
736
737 void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
738 {
739         if (edac_mc_get_log_ce())
740                 edac_mc_printk(mci, KERN_WARNING,
741                         "CE - no information available: %s\n", msg);
742
743         mci->ce_noinfo_count++;
744         mci->ce_count++;
745 }
746 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);
747
748 void edac_mc_handle_ue(struct mem_ctl_info *mci,
749                 unsigned long page_frame_number,
750                 unsigned long offset_in_page, int row, const char *msg)
751 {
752         int len = EDAC_MC_LABEL_LEN * 4;
753         char labels[len + 1];
754         char *pos = labels;
755         int chan;
756         int chars;
757
758         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
759
760         /* FIXME - maybe make panic on INTERNAL ERROR an option */
761         if (row >= mci->nr_csrows || row < 0) {
762                 /* something is wrong */
763                 edac_mc_printk(mci, KERN_ERR,
764                         "INTERNAL ERROR: row out of range "
765                         "(%d >= %d)\n", row, mci->nr_csrows);
766                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
767                 return;
768         }
769
770         chars = snprintf(pos, len + 1, "%s",
771                          mci->csrows[row].channels[0].label);
772         len -= chars;
773         pos += chars;
774
775         for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
776                 chan++) {
777                 chars = snprintf(pos, len + 1, ":%s",
778                                  mci->csrows[row].channels[chan].label);
779                 len -= chars;
780                 pos += chars;
781         }
782
783         if (edac_mc_get_log_ue())
784                 edac_mc_printk(mci, KERN_EMERG,
785                         "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
786                         "labels \"%s\": %s\n", page_frame_number,
787                         offset_in_page, mci->csrows[row].grain, row,
788                         labels, msg);
789
790         if (edac_mc_get_panic_on_ue())
791                 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
792                         "row %d, labels \"%s\": %s\n", mci->mc_idx,
793                         page_frame_number, offset_in_page,
794                         mci->csrows[row].grain, row, labels, msg);
795
796         mci->ue_count++;
797         mci->csrows[row].ue_count++;
798 }
799 EXPORT_SYMBOL_GPL(edac_mc_handle_ue);
800
801 void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
802 {
803         if (edac_mc_get_panic_on_ue())
804                 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
805
806         if (edac_mc_get_log_ue())
807                 edac_mc_printk(mci, KERN_WARNING,
808                         "UE - no information available: %s\n", msg);
809         mci->ue_noinfo_count++;
810         mci->ue_count++;
811 }
812 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);
813
814 /*************************************************************
815  * On Fully Buffered DIMM modules, this help function is
816  * called to process UE events
817  */
818 void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci,
819                         unsigned int csrow,
820                         unsigned int channela,
821                         unsigned int channelb, char *msg)
822 {
823         int len = EDAC_MC_LABEL_LEN * 4;
824         char labels[len + 1];
825         char *pos = labels;
826         int chars;
827
828         if (csrow >= mci->nr_csrows) {
829                 /* something is wrong */
830                 edac_mc_printk(mci, KERN_ERR,
831                         "INTERNAL ERROR: row out of range (%d >= %d)\n",
832                         csrow, mci->nr_csrows);
833                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
834                 return;
835         }
836
837         if (channela >= mci->csrows[csrow].nr_channels) {
838                 /* something is wrong */
839                 edac_mc_printk(mci, KERN_ERR,
840                         "INTERNAL ERROR: channel-a out of range "
841                         "(%d >= %d)\n",
842                         channela, mci->csrows[csrow].nr_channels);
843                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
844                 return;
845         }
846
847         if (channelb >= mci->csrows[csrow].nr_channels) {
848                 /* something is wrong */
849                 edac_mc_printk(mci, KERN_ERR,
850                         "INTERNAL ERROR: channel-b out of range "
851                         "(%d >= %d)\n",
852                         channelb, mci->csrows[csrow].nr_channels);
853                 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
854                 return;
855         }
856
857         mci->ue_count++;
858         mci->csrows[csrow].ue_count++;
859
860         /* Generate the DIMM labels from the specified channels */
861         chars = snprintf(pos, len + 1, "%s",
862                          mci->csrows[csrow].channels[channela].label);
863         len -= chars;
864         pos += chars;
865         chars = snprintf(pos, len + 1, "-%s",
866                          mci->csrows[csrow].channels[channelb].label);
867
868         if (edac_mc_get_log_ue())
869                 edac_mc_printk(mci, KERN_EMERG,
870                         "UE row %d, channel-a= %d channel-b= %d "
871                         "labels \"%s\": %s\n", csrow, channela, channelb,
872                         labels, msg);
873
874         if (edac_mc_get_panic_on_ue())
875                 panic("UE row %d, channel-a= %d channel-b= %d "
876                         "labels \"%s\": %s\n", csrow, channela,
877                         channelb, labels, msg);
878 }
879 EXPORT_SYMBOL(edac_mc_handle_fbd_ue);
880
881 /*************************************************************
882  * On Fully Buffered DIMM modules, this help function is
883  * called to process CE events
884  */
885 void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
886                         unsigned int csrow, unsigned int channel, char *msg)
887 {
888
889         /* Ensure boundary values */
890         if (csrow >= mci->nr_csrows) {
891                 /* something is wrong */
892                 edac_mc_printk(mci, KERN_ERR,
893                         "INTERNAL ERROR: row out of range (%d >= %d)\n",
894                         csrow, mci->nr_csrows);
895                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
896                 return;
897         }
898         if (channel >= mci->csrows[csrow].nr_channels) {
899                 /* something is wrong */
900                 edac_mc_printk(mci, KERN_ERR,
901                         "INTERNAL ERROR: channel out of range (%d >= %d)\n",
902                         channel, mci->csrows[csrow].nr_channels);
903                 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
904                 return;
905         }
906
907         if (edac_mc_get_log_ce())
908                 /* FIXME - put in DIMM location */
909                 edac_mc_printk(mci, KERN_WARNING,
910                         "CE row %d, channel %d, label \"%s\": %s\n",
911                         csrow, channel,
912                         mci->csrows[csrow].channels[channel].label, msg);
913
914         mci->ce_count++;
915         mci->csrows[csrow].ce_count++;
916         mci->csrows[csrow].channels[channel].ce_count++;
917 }
918 EXPORT_SYMBOL(edac_mc_handle_fbd_ce);