drivers/net/ipg.c: cleanups
[linux-2.6] / 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 <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"
36
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);
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", 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);
63 }
64
65 static void edac_mc_dump_mci(struct mem_ctl_info *mci)
66 {
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);
77 }
78
79 #endif                          /* CONFIG_EDAC_DEBUG */
80
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.
84  *
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'.
87  */
88 void *edac_align_ptr(void *ptr, unsigned size)
89 {
90         unsigned align, r;
91
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.
95          */
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;
106
107         r = size % align;
108
109         if (r == 0)
110                 return (char *)ptr;
111
112         return (void *)(((unsigned long)ptr) + align - r);
113 }
114
115 /**
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
120  *
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.
124  *
125  * Use edac_mc_free() to free mc structures allocated by this function.
126  *
127  * Returns:
128  *      NULL allocation failed
129  *      struct mem_ctl_info pointer
130  */
131 struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows,
132                                 unsigned nr_chans, int edac_index)
133 {
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;
141
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.
146          */
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;
152
153         mci = kzalloc(size, GFP_KERNEL);
154         if (mci == NULL)
155                 return NULL;
156
157         /* Adjust pointers so they point within the memory we just allocated
158          * rather than an imaginary chunk of memory located at address 0.
159          */
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;
163
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;
169
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;
177
178                 for (chn = 0; chn < nr_chans; chn++) {
179                         chan = &chp[chn];
180                         chan->chan_idx = chn;
181                         chan->csrow = csrow;
182                 }
183         }
184
185         mci->op_state = OP_ALLOC;
186
187         /*
188          * Initialize the 'root' kobj for the edac_mc controller
189          */
190         err = edac_mc_register_sysfs_main_kobj(mci);
191         if (err) {
192                 kfree(mci);
193                 return NULL;
194         }
195
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
201          */
202         return mci;
203 }
204 EXPORT_SYMBOL_GPL(edac_mc_alloc);
205
206 /**
207  * edac_mc_free
208  *      'Free' a previously allocated 'mci' structure
209  * @mci: pointer to a struct mem_ctl_info structure
210  */
211 void edac_mc_free(struct mem_ctl_info *mci)
212 {
213         edac_mc_unregister_sysfs_main_kobj(mci);
214 }
215 EXPORT_SYMBOL_GPL(edac_mc_free);
216
217
218 /*
219  * find_mci_by_dev
220  *
221  *      scan list of controllers looking for the one that manages
222  *      the 'dev' device
223  */
224 static struct mem_ctl_info *find_mci_by_dev(struct device *dev)
225 {
226         struct mem_ctl_info *mci;
227         struct list_head *item;
228
229         debugf3("%s()\n", __func__);
230
231         list_for_each(item, &mc_devices) {
232                 mci = list_entry(item, struct mem_ctl_info, link);
233
234                 if (mci->dev == dev)
235                         return mci;
236         }
237
238         return NULL;
239 }
240
241 /*
242  * handler for EDAC to check if NMI type handler has asserted interrupt
243  */
244 static int edac_mc_assert_error_check_and_clear(void)
245 {
246         int old_state;
247
248         if (edac_op_state == EDAC_OPSTATE_POLL)
249                 return 1;
250
251         old_state = edac_err_assert;
252         edac_err_assert = 0;
253
254         return old_state;
255 }
256
257 /*
258  * edac_mc_workq_function
259  *      performs the operation scheduled by a workq request
260  */
261 static void edac_mc_workq_function(struct work_struct *work_req)
262 {
263         struct delayed_work *d_work = (struct delayed_work *)work_req;
264         struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
265
266         mutex_lock(&mem_ctls_mutex);
267
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;
272         }
273
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);
277
278         mutex_unlock(&mem_ctls_mutex);
279
280         /* Reschedule */
281         queue_delayed_work(edac_workqueue, &mci->work,
282                         msecs_to_jiffies(edac_mc_get_poll_msec()));
283 }
284
285 /*
286  * edac_mc_workq_setup
287  *      initialize a workq item for this mci
288  *      passing in the new delay period in msec
289  *
290  *      locking model:
291  *
292  *              called with the mem_ctls_mutex held
293  */
294 static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec)
295 {
296         debugf0("%s()\n", __func__);
297
298         /* if this instance is not in the POLL state, then simply return */
299         if (mci->op_state != OP_RUNNING_POLL)
300                 return;
301
302         INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
303         queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
304 }
305
306 /*
307  * edac_mc_workq_teardown
308  *      stop the workq processing on this mci
309  *
310  *      locking model:
311  *
312  *              called WITHOUT lock held
313  */
314 static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
315 {
316         int status;
317
318         status = cancel_delayed_work(&mci->work);
319         if (status == 0) {
320                 debugf0("%s() not canceled, flush the queue\n",
321                         __func__);
322
323                 /* workq instance might be running, wait for it */
324                 flush_workqueue(edac_workqueue);
325         }
326 }
327
328 /*
329  * edac_mc_reset_delay_period(unsigned long value)
330  *
331  *      user space has updated our poll period value, need to
332  *      reset our workq delays
333  */
334 void edac_mc_reset_delay_period(int value)
335 {
336         struct mem_ctl_info *mci;
337         struct list_head *item;
338
339         mutex_lock(&mem_ctls_mutex);
340
341         /* scan the list and turn off all workq timers, doing so under lock
342          */
343         list_for_each(item, &mc_devices) {
344                 mci = list_entry(item, struct mem_ctl_info, link);
345
346                 if (mci->op_state == OP_RUNNING_POLL)
347                         cancel_delayed_work(&mci->work);
348         }
349
350         mutex_unlock(&mem_ctls_mutex);
351
352
353         /* re-walk the list, and reset the poll delay */
354         mutex_lock(&mem_ctls_mutex);
355
356         list_for_each(item, &mc_devices) {
357                 mci = list_entry(item, struct mem_ctl_info, link);
358
359                 edac_mc_workq_setup(mci, (unsigned long) value);
360         }
361
362         mutex_unlock(&mem_ctls_mutex);
363 }
364
365
366
367 /* Return 0 on success, 1 on failure.
368  * Before calling this function, caller must
369  * assign a unique value to mci->mc_idx.
370  *
371  *      locking model:
372  *
373  *              called with the mem_ctls_mutex lock held
374  */
375 static int add_mc_to_global_list(struct mem_ctl_info *mci)
376 {
377         struct list_head *item, *insert_before;
378         struct mem_ctl_info *p;
379
380         insert_before = &mc_devices;
381
382         p = find_mci_by_dev(mci->dev);
383         if (unlikely(p != NULL))
384                 goto fail0;
385
386         list_for_each(item, &mc_devices) {
387                 p = list_entry(item, struct mem_ctl_info, link);
388
389                 if (p->mc_idx >= mci->mc_idx) {
390                         if (unlikely(p->mc_idx == mci->mc_idx))
391                                 goto fail1;
392
393                         insert_before = item;
394                         break;
395                 }
396         }
397
398         list_add_tail_rcu(&mci->link, insert_before);
399         atomic_inc(&edac_handlers);
400         return 0;
401
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;
407
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;
413 }
414
415 static void complete_mc_list_del(struct rcu_head *head)
416 {
417         struct mem_ctl_info *mci;
418
419         mci = container_of(head, struct mem_ctl_info, rcu);
420         INIT_LIST_HEAD(&mci->link);
421         complete(&mci->complete);
422 }
423
424 static void del_mc_from_global_list(struct mem_ctl_info *mci)
425 {
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);
431 }
432
433 /**
434  * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
435  *
436  * If found, return a pointer to the structure.
437  * Else return NULL.
438  *
439  * Caller must hold mem_ctls_mutex.
440  */
441 struct mem_ctl_info *edac_mc_find(int idx)
442 {
443         struct list_head *item;
444         struct mem_ctl_info *mci;
445
446         list_for_each(item, &mc_devices) {
447                 mci = list_entry(item, struct mem_ctl_info, link);
448
449                 if (mci->mc_idx >= idx) {
450                         if (mci->mc_idx == idx)
451                                 return mci;
452
453                         break;
454                 }
455         }
456
457         return NULL;
458 }
459 EXPORT_SYMBOL(edac_mc_find);
460
461 /**
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.
466  *
467  * Return:
468  *      0       Success
469  *      !0      Failure
470  */
471
472 /* FIXME - should a warning be printed if no error detection? correction? */
473 int edac_mc_add_mc(struct mem_ctl_info *mci)
474 {
475         debugf0("%s()\n", __func__);
476
477 #ifdef CONFIG_EDAC_DEBUG
478         if (edac_debug_level >= 3)
479                 edac_mc_dump_mci(mci);
480
481         if (edac_debug_level >= 4) {
482                 int i;
483
484                 for (i = 0; i < mci->nr_csrows; i++) {
485                         int j;
486
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]);
491                 }
492         }
493 #endif
494         mutex_lock(&mem_ctls_mutex);
495
496         if (add_mc_to_global_list(mci))
497                 goto fail0;
498
499         /* set load time so that error rate can be tracked */
500         mci->start_time = jiffies;
501
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;
506         }
507
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;
512
513                 edac_mc_workq_setup(mci, edac_mc_get_poll_msec());
514         } else {
515                 mci->op_state = OP_RUNNING_INTERRUPT;
516         }
517
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));
521
522         mutex_unlock(&mem_ctls_mutex);
523         return 0;
524
525 fail1:
526         del_mc_from_global_list(mci);
527
528 fail0:
529         mutex_unlock(&mem_ctls_mutex);
530         return 1;
531 }
532 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
533
534 /**
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.
538  *
539  * Return pointer to removed mci structure, or NULL if device not found.
540  */
541 struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
542 {
543         struct mem_ctl_info *mci;
544
545         debugf0("%s()\n", __func__);
546
547         mutex_lock(&mem_ctls_mutex);
548
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;
554         }
555
556         /* marking MCI offline */
557         mci->op_state = OP_OFFLINE;
558
559         del_mc_from_global_list(mci);
560         mutex_unlock(&mem_ctls_mutex);
561
562         /* flush workq processes and remove sysfs */
563         edac_mc_workq_teardown(mci);
564         edac_remove_sysfs_mci_device(mci);
565
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));
569
570         return mci;
571 }
572 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
573
574 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
575                                 u32 size)
576 {
577         struct page *pg;
578         void *virt_addr;
579         unsigned long flags = 0;
580
581         debugf3("%s()\n", __func__);
582
583         /* ECC error page was not in our memory. Ignore it. */
584         if (!pfn_valid(page))
585                 return;
586
587         /* Find the actual page structure then map it and fix */
588         pg = pfn_to_page(page);
589
590         if (PageHighMem(pg))
591                 local_irq_save(flags);
592
593         virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);
594
595         /* Perform architecture specific atomic scrub operation */
596         atomic_scrub(virt_addr + offset, size);
597
598         /* Unmap and complete */
599         kunmap_atomic(virt_addr, KM_BOUNCE_READ);
600
601         if (PageHighMem(pg))
602                 local_irq_restore(flags);
603 }
604
605 /* FIXME - should return -1 */
606 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
607 {
608         struct csrow_info *csrows = mci->csrows;
609         int row, i;
610
611         debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
612         row = -1;
613
614         for (i = 0; i < mci->nr_csrows; i++) {
615                 struct csrow_info *csrow = &csrows[i];
616
617                 if (csrow->nr_pages == 0)
618                         continue;
619
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);
624
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;
631                 }
632         }
633
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);
638
639         return row;
640 }
641 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
642
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)
649 {
650         unsigned long remapped_page;
651
652         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
653
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;
662         }
663
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;
672         }
673
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);
682
683         mci->ce_count++;
684         mci->csrows[row].ce_count++;
685         mci->csrows[row].channels[channel].ce_count++;
686
687         if (mci->scrub_mode & SCRUB_SW_SRC) {
688                 /*
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.
696                  */
697                 remapped_page = mci->ctl_page_to_phys ?
698                         mci->ctl_page_to_phys(mci, page_frame_number) :
699                         page_frame_number;
700
701                 edac_mc_scrub_block(remapped_page, offset_in_page,
702                                 mci->csrows[row].grain);
703         }
704 }
705 EXPORT_SYMBOL_GPL(edac_mc_handle_ce);
706
707 void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
708 {
709         if (edac_mc_get_log_ce())
710                 edac_mc_printk(mci, KERN_WARNING,
711                         "CE - no information available: %s\n", msg);
712
713         mci->ce_noinfo_count++;
714         mci->ce_count++;
715 }
716 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);
717
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)
721 {
722         int len = EDAC_MC_LABEL_LEN * 4;
723         char labels[len + 1];
724         char *pos = labels;
725         int chan;
726         int chars;
727
728         debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
729
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;
738         }
739
740         chars = snprintf(pos, len + 1, "%s",
741                          mci->csrows[row].channels[0].label);
742         len -= chars;
743         pos += chars;
744
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;
751         }
752
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);
759
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);
765
766         mci->ue_count++;
767         mci->csrows[row].ue_count++;
768 }
769 EXPORT_SYMBOL_GPL(edac_mc_handle_ue);
770
771 void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
772 {
773         if (edac_mc_get_panic_on_ue())
774                 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
775
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++;
781 }
782 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);
783
784 /*************************************************************
785  * On Fully Buffered DIMM modules, this help function is
786  * called to process UE events
787  */
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)
792 {
793         int len = EDAC_MC_LABEL_LEN * 4;
794         char labels[len + 1];
795         char *pos = labels;
796         int chars;
797
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;
805         }
806
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;
815         }
816
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;
825         }
826
827         mci->ue_count++;
828         mci->csrows[csrow].ue_count++;
829
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);
837
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);
843
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);
848 }
849 EXPORT_SYMBOL(edac_mc_handle_fbd_ue);
850
851 /*************************************************************
852  * On Fully Buffered DIMM modules, this help function is
853  * called to process CE events
854  */
855 void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
856                         unsigned int csrow, unsigned int channel, char *msg)
857 {
858
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;
867         }
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;
875         }
876
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);
883
884         mci->ce_count++;
885         mci->csrows[csrow].ce_count++;
886         mci->csrows[csrow].channels[channel].ce_count++;
887 }
888 EXPORT_SYMBOL(edac_mc_handle_fbd_ce);
889
890 /*
891  * Iterate over all MC instances and check for ECC, et al, errors
892  */
893 void edac_check_mc_devices(void)
894 {
895         struct list_head *item;
896         struct mem_ctl_info *mci;
897
898         debugf3("%s()\n", __func__);
899         mutex_lock(&mem_ctls_mutex);
900
901         list_for_each(item, &mc_devices) {
902                 mci = list_entry(item, struct mem_ctl_info, link);
903
904                 if (mci->edac_check != NULL)
905                         mci->edac_check(mci);
906         }
907
908         mutex_unlock(&mem_ctls_mutex);
909 }