Merge tag 'v3.8-rc7' into next
[~shefty/rdma-dev.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 <linux/bitops.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 #define CREATE_TRACE_POINTS
38 #define TRACE_INCLUDE_PATH ../../include/ras
39 #include <ras/ras_event.h>
40
41 /* lock to memory controller's control array */
42 static DEFINE_MUTEX(mem_ctls_mutex);
43 static LIST_HEAD(mc_devices);
44
45 unsigned edac_dimm_info_location(struct dimm_info *dimm, char *buf,
46                                  unsigned len)
47 {
48         struct mem_ctl_info *mci = dimm->mci;
49         int i, n, count = 0;
50         char *p = buf;
51
52         for (i = 0; i < mci->n_layers; i++) {
53                 n = snprintf(p, len, "%s %d ",
54                               edac_layer_name[mci->layers[i].type],
55                               dimm->location[i]);
56                 p += n;
57                 len -= n;
58                 count += n;
59                 if (!len)
60                         break;
61         }
62
63         return count;
64 }
65
66 #ifdef CONFIG_EDAC_DEBUG
67
68 static void edac_mc_dump_channel(struct rank_info *chan)
69 {
70         edac_dbg(4, "  channel->chan_idx = %d\n", chan->chan_idx);
71         edac_dbg(4, "    channel = %p\n", chan);
72         edac_dbg(4, "    channel->csrow = %p\n", chan->csrow);
73         edac_dbg(4, "    channel->dimm = %p\n", chan->dimm);
74 }
75
76 static void edac_mc_dump_dimm(struct dimm_info *dimm, int number)
77 {
78         char location[80];
79
80         edac_dimm_info_location(dimm, location, sizeof(location));
81
82         edac_dbg(4, "%s%i: %smapped as virtual row %d, chan %d\n",
83                  dimm->mci->mem_is_per_rank ? "rank" : "dimm",
84                  number, location, dimm->csrow, dimm->cschannel);
85         edac_dbg(4, "  dimm = %p\n", dimm);
86         edac_dbg(4, "  dimm->label = '%s'\n", dimm->label);
87         edac_dbg(4, "  dimm->nr_pages = 0x%x\n", dimm->nr_pages);
88         edac_dbg(4, "  dimm->grain = %d\n", dimm->grain);
89         edac_dbg(4, "  dimm->nr_pages = 0x%x\n", dimm->nr_pages);
90 }
91
92 static void edac_mc_dump_csrow(struct csrow_info *csrow)
93 {
94         edac_dbg(4, "csrow->csrow_idx = %d\n", csrow->csrow_idx);
95         edac_dbg(4, "  csrow = %p\n", csrow);
96         edac_dbg(4, "  csrow->first_page = 0x%lx\n", csrow->first_page);
97         edac_dbg(4, "  csrow->last_page = 0x%lx\n", csrow->last_page);
98         edac_dbg(4, "  csrow->page_mask = 0x%lx\n", csrow->page_mask);
99         edac_dbg(4, "  csrow->nr_channels = %d\n", csrow->nr_channels);
100         edac_dbg(4, "  csrow->channels = %p\n", csrow->channels);
101         edac_dbg(4, "  csrow->mci = %p\n", csrow->mci);
102 }
103
104 static void edac_mc_dump_mci(struct mem_ctl_info *mci)
105 {
106         edac_dbg(3, "\tmci = %p\n", mci);
107         edac_dbg(3, "\tmci->mtype_cap = %lx\n", mci->mtype_cap);
108         edac_dbg(3, "\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap);
109         edac_dbg(3, "\tmci->edac_cap = %lx\n", mci->edac_cap);
110         edac_dbg(4, "\tmci->edac_check = %p\n", mci->edac_check);
111         edac_dbg(3, "\tmci->nr_csrows = %d, csrows = %p\n",
112                  mci->nr_csrows, mci->csrows);
113         edac_dbg(3, "\tmci->nr_dimms = %d, dimms = %p\n",
114                  mci->tot_dimms, mci->dimms);
115         edac_dbg(3, "\tdev = %p\n", mci->pdev);
116         edac_dbg(3, "\tmod_name:ctl_name = %s:%s\n",
117                  mci->mod_name, mci->ctl_name);
118         edac_dbg(3, "\tpvt_info = %p\n\n", mci->pvt_info);
119 }
120
121 #endif                          /* CONFIG_EDAC_DEBUG */
122
123 /*
124  * keep those in sync with the enum mem_type
125  */
126 const char *edac_mem_types[] = {
127         "Empty csrow",
128         "Reserved csrow type",
129         "Unknown csrow type",
130         "Fast page mode RAM",
131         "Extended data out RAM",
132         "Burst Extended data out RAM",
133         "Single data rate SDRAM",
134         "Registered single data rate SDRAM",
135         "Double data rate SDRAM",
136         "Registered Double data rate SDRAM",
137         "Rambus DRAM",
138         "Unbuffered DDR2 RAM",
139         "Fully buffered DDR2",
140         "Registered DDR2 RAM",
141         "Rambus XDR",
142         "Unbuffered DDR3 RAM",
143         "Registered DDR3 RAM",
144 };
145 EXPORT_SYMBOL_GPL(edac_mem_types);
146
147 /**
148  * edac_align_ptr - Prepares the pointer offsets for a single-shot allocation
149  * @p:          pointer to a pointer with the memory offset to be used. At
150  *              return, this will be incremented to point to the next offset
151  * @size:       Size of the data structure to be reserved
152  * @n_elems:    Number of elements that should be reserved
153  *
154  * If 'size' is a constant, the compiler will optimize this whole function
155  * down to either a no-op or the addition of a constant to the value of '*p'.
156  *
157  * The 'p' pointer is absolutely needed to keep the proper advancing
158  * further in memory to the proper offsets when allocating the struct along
159  * with its embedded structs, as edac_device_alloc_ctl_info() does it
160  * above, for example.
161  *
162  * At return, the pointer 'p' will be incremented to be used on a next call
163  * to this function.
164  */
165 void *edac_align_ptr(void **p, unsigned size, int n_elems)
166 {
167         unsigned align, r;
168         void *ptr = *p;
169
170         *p += size * n_elems;
171
172         /*
173          * 'p' can possibly be an unaligned item X such that sizeof(X) is
174          * 'size'.  Adjust 'p' so that its alignment is at least as
175          * stringent as what the compiler would provide for X and return
176          * the aligned result.
177          * Here we assume that the alignment of a "long long" is the most
178          * stringent alignment that the compiler will ever provide by default.
179          * As far as I know, this is a reasonable assumption.
180          */
181         if (size > sizeof(long))
182                 align = sizeof(long long);
183         else if (size > sizeof(int))
184                 align = sizeof(long);
185         else if (size > sizeof(short))
186                 align = sizeof(int);
187         else if (size > sizeof(char))
188                 align = sizeof(short);
189         else
190                 return (char *)ptr;
191
192         r = (unsigned long)p % align;
193
194         if (r == 0)
195                 return (char *)ptr;
196
197         *p += align - r;
198
199         return (void *)(((unsigned long)ptr) + align - r);
200 }
201
202 static void _edac_mc_free(struct mem_ctl_info *mci)
203 {
204         int i, chn, row;
205         struct csrow_info *csr;
206         const unsigned int tot_dimms = mci->tot_dimms;
207         const unsigned int tot_channels = mci->num_cschannel;
208         const unsigned int tot_csrows = mci->nr_csrows;
209
210         if (mci->dimms) {
211                 for (i = 0; i < tot_dimms; i++)
212                         kfree(mci->dimms[i]);
213                 kfree(mci->dimms);
214         }
215         if (mci->csrows) {
216                 for (row = 0; row < tot_csrows; row++) {
217                         csr = mci->csrows[row];
218                         if (csr) {
219                                 if (csr->channels) {
220                                         for (chn = 0; chn < tot_channels; chn++)
221                                                 kfree(csr->channels[chn]);
222                                         kfree(csr->channels);
223                                 }
224                                 kfree(csr);
225                         }
226                 }
227                 kfree(mci->csrows);
228         }
229         kfree(mci);
230 }
231
232 /**
233  * edac_mc_alloc: Allocate and partially fill a struct mem_ctl_info structure
234  * @mc_num:             Memory controller number
235  * @n_layers:           Number of MC hierarchy layers
236  * layers:              Describes each layer as seen by the Memory Controller
237  * @size_pvt:           size of private storage needed
238  *
239  *
240  * Everything is kmalloc'ed as one big chunk - more efficient.
241  * Only can be used if all structures have the same lifetime - otherwise
242  * you have to allocate and initialize your own structures.
243  *
244  * Use edac_mc_free() to free mc structures allocated by this function.
245  *
246  * NOTE: drivers handle multi-rank memories in different ways: in some
247  * drivers, one multi-rank memory stick is mapped as one entry, while, in
248  * others, a single multi-rank memory stick would be mapped into several
249  * entries. Currently, this function will allocate multiple struct dimm_info
250  * on such scenarios, as grouping the multiple ranks require drivers change.
251  *
252  * Returns:
253  *      On failure: NULL
254  *      On success: struct mem_ctl_info pointer
255  */
256 struct mem_ctl_info *edac_mc_alloc(unsigned mc_num,
257                                    unsigned n_layers,
258                                    struct edac_mc_layer *layers,
259                                    unsigned sz_pvt)
260 {
261         struct mem_ctl_info *mci;
262         struct edac_mc_layer *layer;
263         struct csrow_info *csr;
264         struct rank_info *chan;
265         struct dimm_info *dimm;
266         u32 *ce_per_layer[EDAC_MAX_LAYERS], *ue_per_layer[EDAC_MAX_LAYERS];
267         unsigned pos[EDAC_MAX_LAYERS];
268         unsigned size, tot_dimms = 1, count = 1;
269         unsigned tot_csrows = 1, tot_channels = 1, tot_errcount = 0;
270         void *pvt, *p, *ptr = NULL;
271         int i, j, row, chn, n, len, off;
272         bool per_rank = false;
273
274         BUG_ON(n_layers > EDAC_MAX_LAYERS || n_layers == 0);
275         /*
276          * Calculate the total amount of dimms and csrows/cschannels while
277          * in the old API emulation mode
278          */
279         for (i = 0; i < n_layers; i++) {
280                 tot_dimms *= layers[i].size;
281                 if (layers[i].is_virt_csrow)
282                         tot_csrows *= layers[i].size;
283                 else
284                         tot_channels *= layers[i].size;
285
286                 if (layers[i].type == EDAC_MC_LAYER_CHIP_SELECT)
287                         per_rank = true;
288         }
289
290         /* Figure out the offsets of the various items from the start of an mc
291          * structure.  We want the alignment of each item to be at least as
292          * stringent as what the compiler would provide if we could simply
293          * hardcode everything into a single struct.
294          */
295         mci = edac_align_ptr(&ptr, sizeof(*mci), 1);
296         layer = edac_align_ptr(&ptr, sizeof(*layer), n_layers);
297         for (i = 0; i < n_layers; i++) {
298                 count *= layers[i].size;
299                 edac_dbg(4, "errcount layer %d size %d\n", i, count);
300                 ce_per_layer[i] = edac_align_ptr(&ptr, sizeof(u32), count);
301                 ue_per_layer[i] = edac_align_ptr(&ptr, sizeof(u32), count);
302                 tot_errcount += 2 * count;
303         }
304
305         edac_dbg(4, "allocating %d error counters\n", tot_errcount);
306         pvt = edac_align_ptr(&ptr, sz_pvt, 1);
307         size = ((unsigned long)pvt) + sz_pvt;
308
309         edac_dbg(1, "allocating %u bytes for mci data (%d %s, %d csrows/channels)\n",
310                  size,
311                  tot_dimms,
312                  per_rank ? "ranks" : "dimms",
313                  tot_csrows * tot_channels);
314
315         mci = kzalloc(size, GFP_KERNEL);
316         if (mci == NULL)
317                 return NULL;
318
319         /* Adjust pointers so they point within the memory we just allocated
320          * rather than an imaginary chunk of memory located at address 0.
321          */
322         layer = (struct edac_mc_layer *)(((char *)mci) + ((unsigned long)layer));
323         for (i = 0; i < n_layers; i++) {
324                 mci->ce_per_layer[i] = (u32 *)((char *)mci + ((unsigned long)ce_per_layer[i]));
325                 mci->ue_per_layer[i] = (u32 *)((char *)mci + ((unsigned long)ue_per_layer[i]));
326         }
327         pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL;
328
329         /* setup index and various internal pointers */
330         mci->mc_idx = mc_num;
331         mci->tot_dimms = tot_dimms;
332         mci->pvt_info = pvt;
333         mci->n_layers = n_layers;
334         mci->layers = layer;
335         memcpy(mci->layers, layers, sizeof(*layer) * n_layers);
336         mci->nr_csrows = tot_csrows;
337         mci->num_cschannel = tot_channels;
338         mci->mem_is_per_rank = per_rank;
339
340         /*
341          * Alocate and fill the csrow/channels structs
342          */
343         mci->csrows = kcalloc(tot_csrows, sizeof(*mci->csrows), GFP_KERNEL);
344         if (!mci->csrows)
345                 goto error;
346         for (row = 0; row < tot_csrows; row++) {
347                 csr = kzalloc(sizeof(**mci->csrows), GFP_KERNEL);
348                 if (!csr)
349                         goto error;
350                 mci->csrows[row] = csr;
351                 csr->csrow_idx = row;
352                 csr->mci = mci;
353                 csr->nr_channels = tot_channels;
354                 csr->channels = kcalloc(tot_channels, sizeof(*csr->channels),
355                                         GFP_KERNEL);
356                 if (!csr->channels)
357                         goto error;
358
359                 for (chn = 0; chn < tot_channels; chn++) {
360                         chan = kzalloc(sizeof(**csr->channels), GFP_KERNEL);
361                         if (!chan)
362                                 goto error;
363                         csr->channels[chn] = chan;
364                         chan->chan_idx = chn;
365                         chan->csrow = csr;
366                 }
367         }
368
369         /*
370          * Allocate and fill the dimm structs
371          */
372         mci->dimms  = kcalloc(tot_dimms, sizeof(*mci->dimms), GFP_KERNEL);
373         if (!mci->dimms)
374                 goto error;
375
376         memset(&pos, 0, sizeof(pos));
377         row = 0;
378         chn = 0;
379         for (i = 0; i < tot_dimms; i++) {
380                 chan = mci->csrows[row]->channels[chn];
381                 off = EDAC_DIMM_OFF(layer, n_layers, pos[0], pos[1], pos[2]);
382                 if (off < 0 || off >= tot_dimms) {
383                         edac_mc_printk(mci, KERN_ERR, "EDAC core bug: EDAC_DIMM_OFF is trying to do an illegal data access\n");
384                         goto error;
385                 }
386
387                 dimm = kzalloc(sizeof(**mci->dimms), GFP_KERNEL);
388                 if (!dimm)
389                         goto error;
390                 mci->dimms[off] = dimm;
391                 dimm->mci = mci;
392
393                 /*
394                  * Copy DIMM location and initialize it.
395                  */
396                 len = sizeof(dimm->label);
397                 p = dimm->label;
398                 n = snprintf(p, len, "mc#%u", mc_num);
399                 p += n;
400                 len -= n;
401                 for (j = 0; j < n_layers; j++) {
402                         n = snprintf(p, len, "%s#%u",
403                                      edac_layer_name[layers[j].type],
404                                      pos[j]);
405                         p += n;
406                         len -= n;
407                         dimm->location[j] = pos[j];
408
409                         if (len <= 0)
410                                 break;
411                 }
412
413                 /* Link it to the csrows old API data */
414                 chan->dimm = dimm;
415                 dimm->csrow = row;
416                 dimm->cschannel = chn;
417
418                 /* Increment csrow location */
419                 if (layers[0].is_virt_csrow) {
420                         chn++;
421                         if (chn == tot_channels) {
422                                 chn = 0;
423                                 row++;
424                         }
425                 } else {
426                         row++;
427                         if (row == tot_csrows) {
428                                 row = 0;
429                                 chn++;
430                         }
431                 }
432
433                 /* Increment dimm location */
434                 for (j = n_layers - 1; j >= 0; j--) {
435                         pos[j]++;
436                         if (pos[j] < layers[j].size)
437                                 break;
438                         pos[j] = 0;
439                 }
440         }
441
442         mci->op_state = OP_ALLOC;
443
444         return mci;
445
446 error:
447         _edac_mc_free(mci);
448
449         return NULL;
450 }
451 EXPORT_SYMBOL_GPL(edac_mc_alloc);
452
453 /**
454  * edac_mc_free
455  *      'Free' a previously allocated 'mci' structure
456  * @mci: pointer to a struct mem_ctl_info structure
457  */
458 void edac_mc_free(struct mem_ctl_info *mci)
459 {
460         edac_dbg(1, "\n");
461
462         /* If we're not yet registered with sysfs free only what was allocated
463          * in edac_mc_alloc().
464          */
465         if (!device_is_registered(&mci->dev)) {
466                 _edac_mc_free(mci);
467                 return;
468         }
469
470         /* the mci instance is freed here, when the sysfs object is dropped */
471         edac_unregister_sysfs(mci);
472 }
473 EXPORT_SYMBOL_GPL(edac_mc_free);
474
475
476 /**
477  * find_mci_by_dev
478  *
479  *      scan list of controllers looking for the one that manages
480  *      the 'dev' device
481  * @dev: pointer to a struct device related with the MCI
482  */
483 struct mem_ctl_info *find_mci_by_dev(struct device *dev)
484 {
485         struct mem_ctl_info *mci;
486         struct list_head *item;
487
488         edac_dbg(3, "\n");
489
490         list_for_each(item, &mc_devices) {
491                 mci = list_entry(item, struct mem_ctl_info, link);
492
493                 if (mci->pdev == dev)
494                         return mci;
495         }
496
497         return NULL;
498 }
499 EXPORT_SYMBOL_GPL(find_mci_by_dev);
500
501 /*
502  * handler for EDAC to check if NMI type handler has asserted interrupt
503  */
504 static int edac_mc_assert_error_check_and_clear(void)
505 {
506         int old_state;
507
508         if (edac_op_state == EDAC_OPSTATE_POLL)
509                 return 1;
510
511         old_state = edac_err_assert;
512         edac_err_assert = 0;
513
514         return old_state;
515 }
516
517 /*
518  * edac_mc_workq_function
519  *      performs the operation scheduled by a workq request
520  */
521 static void edac_mc_workq_function(struct work_struct *work_req)
522 {
523         struct delayed_work *d_work = to_delayed_work(work_req);
524         struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
525
526         mutex_lock(&mem_ctls_mutex);
527
528         /* if this control struct has movd to offline state, we are done */
529         if (mci->op_state == OP_OFFLINE) {
530                 mutex_unlock(&mem_ctls_mutex);
531                 return;
532         }
533
534         /* Only poll controllers that are running polled and have a check */
535         if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL))
536                 mci->edac_check(mci);
537
538         mutex_unlock(&mem_ctls_mutex);
539
540         /* Reschedule */
541         queue_delayed_work(edac_workqueue, &mci->work,
542                         msecs_to_jiffies(edac_mc_get_poll_msec()));
543 }
544
545 /*
546  * edac_mc_workq_setup
547  *      initialize a workq item for this mci
548  *      passing in the new delay period in msec
549  *
550  *      locking model:
551  *
552  *              called with the mem_ctls_mutex held
553  */
554 static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec)
555 {
556         edac_dbg(0, "\n");
557
558         /* if this instance is not in the POLL state, then simply return */
559         if (mci->op_state != OP_RUNNING_POLL)
560                 return;
561
562         INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
563         mod_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
564 }
565
566 /*
567  * edac_mc_workq_teardown
568  *      stop the workq processing on this mci
569  *
570  *      locking model:
571  *
572  *              called WITHOUT lock held
573  */
574 static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
575 {
576         int status;
577
578         if (mci->op_state != OP_RUNNING_POLL)
579                 return;
580
581         status = cancel_delayed_work(&mci->work);
582         if (status == 0) {
583                 edac_dbg(0, "not canceled, flush the queue\n");
584
585                 /* workq instance might be running, wait for it */
586                 flush_workqueue(edac_workqueue);
587         }
588 }
589
590 /*
591  * edac_mc_reset_delay_period(unsigned long value)
592  *
593  *      user space has updated our poll period value, need to
594  *      reset our workq delays
595  */
596 void edac_mc_reset_delay_period(int value)
597 {
598         struct mem_ctl_info *mci;
599         struct list_head *item;
600
601         mutex_lock(&mem_ctls_mutex);
602
603         list_for_each(item, &mc_devices) {
604                 mci = list_entry(item, struct mem_ctl_info, link);
605
606                 edac_mc_workq_setup(mci, (unsigned long) value);
607         }
608
609         mutex_unlock(&mem_ctls_mutex);
610 }
611
612
613
614 /* Return 0 on success, 1 on failure.
615  * Before calling this function, caller must
616  * assign a unique value to mci->mc_idx.
617  *
618  *      locking model:
619  *
620  *              called with the mem_ctls_mutex lock held
621  */
622 static int add_mc_to_global_list(struct mem_ctl_info *mci)
623 {
624         struct list_head *item, *insert_before;
625         struct mem_ctl_info *p;
626
627         insert_before = &mc_devices;
628
629         p = find_mci_by_dev(mci->pdev);
630         if (unlikely(p != NULL))
631                 goto fail0;
632
633         list_for_each(item, &mc_devices) {
634                 p = list_entry(item, struct mem_ctl_info, link);
635
636                 if (p->mc_idx >= mci->mc_idx) {
637                         if (unlikely(p->mc_idx == mci->mc_idx))
638                                 goto fail1;
639
640                         insert_before = item;
641                         break;
642                 }
643         }
644
645         list_add_tail_rcu(&mci->link, insert_before);
646         atomic_inc(&edac_handlers);
647         return 0;
648
649 fail0:
650         edac_printk(KERN_WARNING, EDAC_MC,
651                 "%s (%s) %s %s already assigned %d\n", dev_name(p->pdev),
652                 edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
653         return 1;
654
655 fail1:
656         edac_printk(KERN_WARNING, EDAC_MC,
657                 "bug in low-level driver: attempt to assign\n"
658                 "    duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
659         return 1;
660 }
661
662 static void del_mc_from_global_list(struct mem_ctl_info *mci)
663 {
664         atomic_dec(&edac_handlers);
665         list_del_rcu(&mci->link);
666
667         /* these are for safe removal of devices from global list while
668          * NMI handlers may be traversing list
669          */
670         synchronize_rcu();
671         INIT_LIST_HEAD(&mci->link);
672 }
673
674 /**
675  * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
676  *
677  * If found, return a pointer to the structure.
678  * Else return NULL.
679  *
680  * Caller must hold mem_ctls_mutex.
681  */
682 struct mem_ctl_info *edac_mc_find(int idx)
683 {
684         struct list_head *item;
685         struct mem_ctl_info *mci;
686
687         list_for_each(item, &mc_devices) {
688                 mci = list_entry(item, struct mem_ctl_info, link);
689
690                 if (mci->mc_idx >= idx) {
691                         if (mci->mc_idx == idx)
692                                 return mci;
693
694                         break;
695                 }
696         }
697
698         return NULL;
699 }
700 EXPORT_SYMBOL(edac_mc_find);
701
702 /**
703  * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
704  *                 create sysfs entries associated with mci structure
705  * @mci: pointer to the mci structure to be added to the list
706  *
707  * Return:
708  *      0       Success
709  *      !0      Failure
710  */
711
712 /* FIXME - should a warning be printed if no error detection? correction? */
713 int edac_mc_add_mc(struct mem_ctl_info *mci)
714 {
715         edac_dbg(0, "\n");
716
717 #ifdef CONFIG_EDAC_DEBUG
718         if (edac_debug_level >= 3)
719                 edac_mc_dump_mci(mci);
720
721         if (edac_debug_level >= 4) {
722                 int i;
723
724                 for (i = 0; i < mci->nr_csrows; i++) {
725                         struct csrow_info *csrow = mci->csrows[i];
726                         u32 nr_pages = 0;
727                         int j;
728
729                         for (j = 0; j < csrow->nr_channels; j++)
730                                 nr_pages += csrow->channels[j]->dimm->nr_pages;
731                         if (!nr_pages)
732                                 continue;
733                         edac_mc_dump_csrow(csrow);
734                         for (j = 0; j < csrow->nr_channels; j++)
735                                 if (csrow->channels[j]->dimm->nr_pages)
736                                         edac_mc_dump_channel(csrow->channels[j]);
737                 }
738                 for (i = 0; i < mci->tot_dimms; i++)
739                         if (mci->dimms[i]->nr_pages)
740                                 edac_mc_dump_dimm(mci->dimms[i], i);
741         }
742 #endif
743         mutex_lock(&mem_ctls_mutex);
744
745         if (add_mc_to_global_list(mci))
746                 goto fail0;
747
748         /* set load time so that error rate can be tracked */
749         mci->start_time = jiffies;
750
751         if (edac_create_sysfs_mci_device(mci)) {
752                 edac_mc_printk(mci, KERN_WARNING,
753                         "failed to create sysfs device\n");
754                 goto fail1;
755         }
756
757         /* If there IS a check routine, then we are running POLLED */
758         if (mci->edac_check != NULL) {
759                 /* This instance is NOW RUNNING */
760                 mci->op_state = OP_RUNNING_POLL;
761
762                 edac_mc_workq_setup(mci, edac_mc_get_poll_msec());
763         } else {
764                 mci->op_state = OP_RUNNING_INTERRUPT;
765         }
766
767         /* Report action taken */
768         edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
769                 " DEV %s\n", mci->mod_name, mci->ctl_name, edac_dev_name(mci));
770
771         mutex_unlock(&mem_ctls_mutex);
772         return 0;
773
774 fail1:
775         del_mc_from_global_list(mci);
776
777 fail0:
778         mutex_unlock(&mem_ctls_mutex);
779         return 1;
780 }
781 EXPORT_SYMBOL_GPL(edac_mc_add_mc);
782
783 /**
784  * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
785  *                 remove mci structure from global list
786  * @pdev: Pointer to 'struct device' representing mci structure to remove.
787  *
788  * Return pointer to removed mci structure, or NULL if device not found.
789  */
790 struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
791 {
792         struct mem_ctl_info *mci;
793
794         edac_dbg(0, "\n");
795
796         mutex_lock(&mem_ctls_mutex);
797
798         /* find the requested mci struct in the global list */
799         mci = find_mci_by_dev(dev);
800         if (mci == NULL) {
801                 mutex_unlock(&mem_ctls_mutex);
802                 return NULL;
803         }
804
805         del_mc_from_global_list(mci);
806         mutex_unlock(&mem_ctls_mutex);
807
808         /* flush workq processes */
809         edac_mc_workq_teardown(mci);
810
811         /* marking MCI offline */
812         mci->op_state = OP_OFFLINE;
813
814         /* remove from sysfs */
815         edac_remove_sysfs_mci_device(mci);
816
817         edac_printk(KERN_INFO, EDAC_MC,
818                 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
819                 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
820
821         return mci;
822 }
823 EXPORT_SYMBOL_GPL(edac_mc_del_mc);
824
825 static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
826                                 u32 size)
827 {
828         struct page *pg;
829         void *virt_addr;
830         unsigned long flags = 0;
831
832         edac_dbg(3, "\n");
833
834         /* ECC error page was not in our memory. Ignore it. */
835         if (!pfn_valid(page))
836                 return;
837
838         /* Find the actual page structure then map it and fix */
839         pg = pfn_to_page(page);
840
841         if (PageHighMem(pg))
842                 local_irq_save(flags);
843
844         virt_addr = kmap_atomic(pg);
845
846         /* Perform architecture specific atomic scrub operation */
847         atomic_scrub(virt_addr + offset, size);
848
849         /* Unmap and complete */
850         kunmap_atomic(virt_addr);
851
852         if (PageHighMem(pg))
853                 local_irq_restore(flags);
854 }
855
856 /* FIXME - should return -1 */
857 int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
858 {
859         struct csrow_info **csrows = mci->csrows;
860         int row, i, j, n;
861
862         edac_dbg(1, "MC%d: 0x%lx\n", mci->mc_idx, page);
863         row = -1;
864
865         for (i = 0; i < mci->nr_csrows; i++) {
866                 struct csrow_info *csrow = csrows[i];
867                 n = 0;
868                 for (j = 0; j < csrow->nr_channels; j++) {
869                         struct dimm_info *dimm = csrow->channels[j]->dimm;
870                         n += dimm->nr_pages;
871                 }
872                 if (n == 0)
873                         continue;
874
875                 edac_dbg(3, "MC%d: first(0x%lx) page(0x%lx) last(0x%lx) mask(0x%lx)\n",
876                          mci->mc_idx,
877                          csrow->first_page, page, csrow->last_page,
878                          csrow->page_mask);
879
880                 if ((page >= csrow->first_page) &&
881                     (page <= csrow->last_page) &&
882                     ((page & csrow->page_mask) ==
883                      (csrow->first_page & csrow->page_mask))) {
884                         row = i;
885                         break;
886                 }
887         }
888
889         if (row == -1)
890                 edac_mc_printk(mci, KERN_ERR,
891                         "could not look up page error address %lx\n",
892                         (unsigned long)page);
893
894         return row;
895 }
896 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
897
898 const char *edac_layer_name[] = {
899         [EDAC_MC_LAYER_BRANCH] = "branch",
900         [EDAC_MC_LAYER_CHANNEL] = "channel",
901         [EDAC_MC_LAYER_SLOT] = "slot",
902         [EDAC_MC_LAYER_CHIP_SELECT] = "csrow",
903 };
904 EXPORT_SYMBOL_GPL(edac_layer_name);
905
906 static void edac_inc_ce_error(struct mem_ctl_info *mci,
907                               bool enable_per_layer_report,
908                               const int pos[EDAC_MAX_LAYERS],
909                               const u16 count)
910 {
911         int i, index = 0;
912
913         mci->ce_mc += count;
914
915         if (!enable_per_layer_report) {
916                 mci->ce_noinfo_count += count;
917                 return;
918         }
919
920         for (i = 0; i < mci->n_layers; i++) {
921                 if (pos[i] < 0)
922                         break;
923                 index += pos[i];
924                 mci->ce_per_layer[i][index] += count;
925
926                 if (i < mci->n_layers - 1)
927                         index *= mci->layers[i + 1].size;
928         }
929 }
930
931 static void edac_inc_ue_error(struct mem_ctl_info *mci,
932                                     bool enable_per_layer_report,
933                                     const int pos[EDAC_MAX_LAYERS],
934                                     const u16 count)
935 {
936         int i, index = 0;
937
938         mci->ue_mc += count;
939
940         if (!enable_per_layer_report) {
941                 mci->ce_noinfo_count += count;
942                 return;
943         }
944
945         for (i = 0; i < mci->n_layers; i++) {
946                 if (pos[i] < 0)
947                         break;
948                 index += pos[i];
949                 mci->ue_per_layer[i][index] += count;
950
951                 if (i < mci->n_layers - 1)
952                         index *= mci->layers[i + 1].size;
953         }
954 }
955
956 static void edac_ce_error(struct mem_ctl_info *mci,
957                           const u16 error_count,
958                           const int pos[EDAC_MAX_LAYERS],
959                           const char *msg,
960                           const char *location,
961                           const char *label,
962                           const char *detail,
963                           const char *other_detail,
964                           const bool enable_per_layer_report,
965                           const unsigned long page_frame_number,
966                           const unsigned long offset_in_page,
967                           long grain)
968 {
969         unsigned long remapped_page;
970         char *msg_aux = "";
971
972         if (*msg)
973                 msg_aux = " ";
974
975         if (edac_mc_get_log_ce()) {
976                 if (other_detail && *other_detail)
977                         edac_mc_printk(mci, KERN_WARNING,
978                                        "%d CE %s%son %s (%s %s - %s)\n",
979                                        error_count, msg, msg_aux, label,
980                                        location, detail, other_detail);
981                 else
982                         edac_mc_printk(mci, KERN_WARNING,
983                                        "%d CE %s%son %s (%s %s)\n",
984                                        error_count, msg, msg_aux, label,
985                                        location, detail);
986         }
987         edac_inc_ce_error(mci, enable_per_layer_report, pos, error_count);
988
989         if (mci->scrub_mode & SCRUB_SW_SRC) {
990                 /*
991                         * Some memory controllers (called MCs below) can remap
992                         * memory so that it is still available at a different
993                         * address when PCI devices map into memory.
994                         * MC's that can't do this, lose the memory where PCI
995                         * devices are mapped. This mapping is MC-dependent
996                         * and so we call back into the MC driver for it to
997                         * map the MC page to a physical (CPU) page which can
998                         * then be mapped to a virtual page - which can then
999                         * be scrubbed.
1000                         */
1001                 remapped_page = mci->ctl_page_to_phys ?
1002                         mci->ctl_page_to_phys(mci, page_frame_number) :
1003                         page_frame_number;
1004
1005                 edac_mc_scrub_block(remapped_page,
1006                                         offset_in_page, grain);
1007         }
1008 }
1009
1010 static void edac_ue_error(struct mem_ctl_info *mci,
1011                           const u16 error_count,
1012                           const int pos[EDAC_MAX_LAYERS],
1013                           const char *msg,
1014                           const char *location,
1015                           const char *label,
1016                           const char *detail,
1017                           const char *other_detail,
1018                           const bool enable_per_layer_report)
1019 {
1020         char *msg_aux = "";
1021
1022         if (*msg)
1023                 msg_aux = " ";
1024
1025         if (edac_mc_get_log_ue()) {
1026                 if (other_detail && *other_detail)
1027                         edac_mc_printk(mci, KERN_WARNING,
1028                                        "%d UE %s%son %s (%s %s - %s)\n",
1029                                        error_count, msg, msg_aux, label,
1030                                        location, detail, other_detail);
1031                 else
1032                         edac_mc_printk(mci, KERN_WARNING,
1033                                        "%d UE %s%son %s (%s %s)\n",
1034                                        error_count, msg, msg_aux, label,
1035                                        location, detail);
1036         }
1037
1038         if (edac_mc_get_panic_on_ue()) {
1039                 if (other_detail && *other_detail)
1040                         panic("UE %s%son %s (%s%s - %s)\n",
1041                               msg, msg_aux, label, location, detail, other_detail);
1042                 else
1043                         panic("UE %s%son %s (%s%s)\n",
1044                               msg, msg_aux, label, location, detail);
1045         }
1046
1047         edac_inc_ue_error(mci, enable_per_layer_report, pos, error_count);
1048 }
1049
1050 #define OTHER_LABEL " or "
1051
1052 /**
1053  * edac_mc_handle_error - reports a memory event to userspace
1054  *
1055  * @type:               severity of the error (CE/UE/Fatal)
1056  * @mci:                a struct mem_ctl_info pointer
1057  * @error_count:        Number of errors of the same type
1058  * @page_frame_number:  mem page where the error occurred
1059  * @offset_in_page:     offset of the error inside the page
1060  * @syndrome:           ECC syndrome
1061  * @top_layer:          Memory layer[0] position
1062  * @mid_layer:          Memory layer[1] position
1063  * @low_layer:          Memory layer[2] position
1064  * @msg:                Message meaningful to the end users that
1065  *                      explains the event
1066  * @other_detail:       Technical details about the event that
1067  *                      may help hardware manufacturers and
1068  *                      EDAC developers to analyse the event
1069  */
1070 void edac_mc_handle_error(const enum hw_event_mc_err_type type,
1071                           struct mem_ctl_info *mci,
1072                           const u16 error_count,
1073                           const unsigned long page_frame_number,
1074                           const unsigned long offset_in_page,
1075                           const unsigned long syndrome,
1076                           const int top_layer,
1077                           const int mid_layer,
1078                           const int low_layer,
1079                           const char *msg,
1080                           const char *other_detail)
1081 {
1082         /* FIXME: too much for stack: move it to some pre-alocated area */
1083         char detail[80], location[80];
1084         char label[(EDAC_MC_LABEL_LEN + 1 + sizeof(OTHER_LABEL)) * mci->tot_dimms];
1085         char *p;
1086         int row = -1, chan = -1;
1087         int pos[EDAC_MAX_LAYERS] = { top_layer, mid_layer, low_layer };
1088         int i;
1089         long grain;
1090         bool enable_per_layer_report = false;
1091         u8 grain_bits;
1092
1093         edac_dbg(3, "MC%d\n", mci->mc_idx);
1094
1095         /*
1096          * Check if the event report is consistent and if the memory
1097          * location is known. If it is known, enable_per_layer_report will be
1098          * true, the DIMM(s) label info will be filled and the per-layer
1099          * error counters will be incremented.
1100          */
1101         for (i = 0; i < mci->n_layers; i++) {
1102                 if (pos[i] >= (int)mci->layers[i].size) {
1103
1104                         edac_mc_printk(mci, KERN_ERR,
1105                                        "INTERNAL ERROR: %s value is out of range (%d >= %d)\n",
1106                                        edac_layer_name[mci->layers[i].type],
1107                                        pos[i], mci->layers[i].size);
1108                         /*
1109                          * Instead of just returning it, let's use what's
1110                          * known about the error. The increment routines and
1111                          * the DIMM filter logic will do the right thing by
1112                          * pointing the likely damaged DIMMs.
1113                          */
1114                         pos[i] = -1;
1115                 }
1116                 if (pos[i] >= 0)
1117                         enable_per_layer_report = true;
1118         }
1119
1120         /*
1121          * Get the dimm label/grain that applies to the match criteria.
1122          * As the error algorithm may not be able to point to just one memory
1123          * stick, the logic here will get all possible labels that could
1124          * pottentially be affected by the error.
1125          * On FB-DIMM memory controllers, for uncorrected errors, it is common
1126          * to have only the MC channel and the MC dimm (also called "branch")
1127          * but the channel is not known, as the memory is arranged in pairs,
1128          * where each memory belongs to a separate channel within the same
1129          * branch.
1130          */
1131         grain = 0;
1132         p = label;
1133         *p = '\0';
1134
1135         for (i = 0; i < mci->tot_dimms; i++) {
1136                 struct dimm_info *dimm = mci->dimms[i];
1137
1138                 if (top_layer >= 0 && top_layer != dimm->location[0])
1139                         continue;
1140                 if (mid_layer >= 0 && mid_layer != dimm->location[1])
1141                         continue;
1142                 if (low_layer >= 0 && low_layer != dimm->location[2])
1143                         continue;
1144
1145                 /* get the max grain, over the error match range */
1146                 if (dimm->grain > grain)
1147                         grain = dimm->grain;
1148
1149                 /*
1150                  * If the error is memory-controller wide, there's no need to
1151                  * seek for the affected DIMMs because the whole
1152                  * channel/memory controller/...  may be affected.
1153                  * Also, don't show errors for empty DIMM slots.
1154                  */
1155                 if (enable_per_layer_report && dimm->nr_pages) {
1156                         if (p != label) {
1157                                 strcpy(p, OTHER_LABEL);
1158                                 p += strlen(OTHER_LABEL);
1159                         }
1160                         strcpy(p, dimm->label);
1161                         p += strlen(p);
1162                         *p = '\0';
1163
1164                         /*
1165                          * get csrow/channel of the DIMM, in order to allow
1166                          * incrementing the compat API counters
1167                          */
1168                         edac_dbg(4, "%s csrows map: (%d,%d)\n",
1169                                  mci->mem_is_per_rank ? "rank" : "dimm",
1170                                  dimm->csrow, dimm->cschannel);
1171                         if (row == -1)
1172                                 row = dimm->csrow;
1173                         else if (row >= 0 && row != dimm->csrow)
1174                                 row = -2;
1175
1176                         if (chan == -1)
1177                                 chan = dimm->cschannel;
1178                         else if (chan >= 0 && chan != dimm->cschannel)
1179                                 chan = -2;
1180                 }
1181         }
1182
1183         if (!enable_per_layer_report) {
1184                 strcpy(label, "any memory");
1185         } else {
1186                 edac_dbg(4, "csrow/channel to increment: (%d,%d)\n", row, chan);
1187                 if (p == label)
1188                         strcpy(label, "unknown memory");
1189                 if (type == HW_EVENT_ERR_CORRECTED) {
1190                         if (row >= 0) {
1191                                 mci->csrows[row]->ce_count += error_count;
1192                                 if (chan >= 0)
1193                                         mci->csrows[row]->channels[chan]->ce_count += error_count;
1194                         }
1195                 } else
1196                         if (row >= 0)
1197                                 mci->csrows[row]->ue_count += error_count;
1198         }
1199
1200         /* Fill the RAM location data */
1201         p = location;
1202
1203         for (i = 0; i < mci->n_layers; i++) {
1204                 if (pos[i] < 0)
1205                         continue;
1206
1207                 p += sprintf(p, "%s:%d ",
1208                              edac_layer_name[mci->layers[i].type],
1209                              pos[i]);
1210         }
1211         if (p > location)
1212                 *(p - 1) = '\0';
1213
1214         /* Report the error via the trace interface */
1215         grain_bits = fls_long(grain) + 1;
1216         trace_mc_event(type, msg, label, error_count,
1217                        mci->mc_idx, top_layer, mid_layer, low_layer,
1218                        PAGES_TO_MiB(page_frame_number) | offset_in_page,
1219                        grain_bits, syndrome, other_detail);
1220
1221         /* Memory type dependent details about the error */
1222         if (type == HW_EVENT_ERR_CORRECTED) {
1223                 snprintf(detail, sizeof(detail),
1224                         "page:0x%lx offset:0x%lx grain:%ld syndrome:0x%lx",
1225                         page_frame_number, offset_in_page,
1226                         grain, syndrome);
1227                 edac_ce_error(mci, error_count, pos, msg, location, label,
1228                               detail, other_detail, enable_per_layer_report,
1229                               page_frame_number, offset_in_page, grain);
1230         } else {
1231                 snprintf(detail, sizeof(detail),
1232                         "page:0x%lx offset:0x%lx grain:%ld",
1233                         page_frame_number, offset_in_page, grain);
1234
1235                 edac_ue_error(mci, error_count, pos, msg, location, label,
1236                               detail, other_detail, enable_per_layer_report);
1237         }
1238 }
1239 EXPORT_SYMBOL_GPL(edac_mc_handle_error);