blob: 9f134823fa75848d69e1f7c1f4edd07ae141e08d [file] [log] [blame]
Alan Coxda9bb1d2006-01-18 17:44:13 -08001/*
2 * edac_mc kernel module
Doug Thompson49c0dab72006-07-10 04:45:19 -07003 * (C) 2005, 2006 Linux Networx (http://lnxi.com)
Alan Coxda9bb1d2006-01-18 17:44:13 -08004 * 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
Alan Coxda9bb1d2006-01-18 17:44:13 -080015#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>
Alan Coxda9bb1d2006-01-18 17:44:13 -080028#include <linux/ctype.h>
Dave Jiangc0d12172007-07-19 01:49:46 -070029#include <linux/edac.h>
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -030030#include <linux/bitops.h>
Alan Coxda9bb1d2006-01-18 17:44:13 -080031#include <asm/uaccess.h>
32#include <asm/page.h>
33#include <asm/edac.h>
Douglas Thompson20bcb7a2007-07-19 01:49:47 -070034#include "edac_core.h"
Douglas Thompson7c9281d2007-07-19 01:49:33 -070035#include "edac_module.h"
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -030036#include <ras/ras_event.h>
37
Alan Coxda9bb1d2006-01-18 17:44:13 -080038/* lock to memory controller's control array */
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -070039static DEFINE_MUTEX(mem_ctls_mutex);
Robert P. J. Dayff6ac2a2008-04-29 01:03:17 -070040static LIST_HEAD(mc_devices);
Alan Coxda9bb1d2006-01-18 17:44:13 -080041
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -030042/*
43 * Used to lock EDAC MC to just one module, avoiding two drivers e. g.
44 * apei/ghes and i7core_edac to be used at the same time.
45 */
46static void const *edac_mc_owner;
47
Borislav Petkov88d84ac2013-07-19 12:28:25 +020048static struct bus_type mc_bus[EDAC_MAX_MCS];
49
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030050unsigned edac_dimm_info_location(struct dimm_info *dimm, char *buf,
51 unsigned len)
52{
53 struct mem_ctl_info *mci = dimm->mci;
54 int i, n, count = 0;
55 char *p = buf;
56
57 for (i = 0; i < mci->n_layers; i++) {
58 n = snprintf(p, len, "%s %d ",
59 edac_layer_name[mci->layers[i].type],
60 dimm->location[i]);
61 p += n;
62 len -= n;
63 count += n;
64 if (!len)
65 break;
66 }
67
68 return count;
69}
70
Alan Coxda9bb1d2006-01-18 17:44:13 -080071#ifdef CONFIG_EDAC_DEBUG
72
Mauro Carvalho Chehaba4b4be32012-01-27 10:26:13 -030073static void edac_mc_dump_channel(struct rank_info *chan)
Alan Coxda9bb1d2006-01-18 17:44:13 -080074{
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030075 edac_dbg(4, " channel->chan_idx = %d\n", chan->chan_idx);
76 edac_dbg(4, " channel = %p\n", chan);
77 edac_dbg(4, " channel->csrow = %p\n", chan->csrow);
78 edac_dbg(4, " channel->dimm = %p\n", chan->dimm);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -030079}
80
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030081static void edac_mc_dump_dimm(struct dimm_info *dimm, int number)
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -030082{
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030083 char location[80];
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -030084
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030085 edac_dimm_info_location(dimm, location, sizeof(location));
86
87 edac_dbg(4, "%s%i: %smapped as virtual row %d, chan %d\n",
Mauro Carvalho Chehab9713fae2013-03-11 09:28:48 -030088 dimm->mci->csbased ? "rank" : "dimm",
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030089 number, location, dimm->csrow, dimm->cschannel);
90 edac_dbg(4, " dimm = %p\n", dimm);
91 edac_dbg(4, " dimm->label = '%s'\n", dimm->label);
92 edac_dbg(4, " dimm->nr_pages = 0x%x\n", dimm->nr_pages);
93 edac_dbg(4, " dimm->grain = %d\n", dimm->grain);
94 edac_dbg(4, " dimm->nr_pages = 0x%x\n", dimm->nr_pages);
Alan Coxda9bb1d2006-01-18 17:44:13 -080095}
96
Adrian Bunk2da1c112007-07-19 01:49:32 -070097static void edac_mc_dump_csrow(struct csrow_info *csrow)
Alan Coxda9bb1d2006-01-18 17:44:13 -080098{
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030099 edac_dbg(4, "csrow->csrow_idx = %d\n", csrow->csrow_idx);
100 edac_dbg(4, " csrow = %p\n", csrow);
101 edac_dbg(4, " csrow->first_page = 0x%lx\n", csrow->first_page);
102 edac_dbg(4, " csrow->last_page = 0x%lx\n", csrow->last_page);
103 edac_dbg(4, " csrow->page_mask = 0x%lx\n", csrow->page_mask);
104 edac_dbg(4, " csrow->nr_channels = %d\n", csrow->nr_channels);
105 edac_dbg(4, " csrow->channels = %p\n", csrow->channels);
106 edac_dbg(4, " csrow->mci = %p\n", csrow->mci);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800107}
108
Adrian Bunk2da1c112007-07-19 01:49:32 -0700109static void edac_mc_dump_mci(struct mem_ctl_info *mci)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800110{
Joe Perches956b9ba2012-04-29 17:08:39 -0300111 edac_dbg(3, "\tmci = %p\n", mci);
112 edac_dbg(3, "\tmci->mtype_cap = %lx\n", mci->mtype_cap);
113 edac_dbg(3, "\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap);
114 edac_dbg(3, "\tmci->edac_cap = %lx\n", mci->edac_cap);
115 edac_dbg(4, "\tmci->edac_check = %p\n", mci->edac_check);
116 edac_dbg(3, "\tmci->nr_csrows = %d, csrows = %p\n",
117 mci->nr_csrows, mci->csrows);
118 edac_dbg(3, "\tmci->nr_dimms = %d, dimms = %p\n",
119 mci->tot_dimms, mci->dimms);
120 edac_dbg(3, "\tdev = %p\n", mci->pdev);
121 edac_dbg(3, "\tmod_name:ctl_name = %s:%s\n",
122 mci->mod_name, mci->ctl_name);
123 edac_dbg(3, "\tpvt_info = %p\n\n", mci->pvt_info);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800124}
125
Borislav Petkov24f9a7f2010-10-07 18:29:15 +0200126#endif /* CONFIG_EDAC_DEBUG */
127
Borislav Petkov239642f2009-11-12 15:33:16 +0100128/*
129 * keep those in sync with the enum mem_type
130 */
131const char *edac_mem_types[] = {
132 "Empty csrow",
133 "Reserved csrow type",
134 "Unknown csrow type",
135 "Fast page mode RAM",
136 "Extended data out RAM",
137 "Burst Extended data out RAM",
138 "Single data rate SDRAM",
139 "Registered single data rate SDRAM",
140 "Double data rate SDRAM",
141 "Registered Double data rate SDRAM",
142 "Rambus DRAM",
143 "Unbuffered DDR2 RAM",
144 "Fully buffered DDR2",
145 "Registered DDR2 RAM",
146 "Rambus XDR",
147 "Unbuffered DDR3 RAM",
148 "Registered DDR3 RAM",
149};
150EXPORT_SYMBOL_GPL(edac_mem_types);
151
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300152/**
153 * edac_align_ptr - Prepares the pointer offsets for a single-shot allocation
154 * @p: pointer to a pointer with the memory offset to be used. At
155 * return, this will be incremented to point to the next offset
156 * @size: Size of the data structure to be reserved
157 * @n_elems: Number of elements that should be reserved
Alan Coxda9bb1d2006-01-18 17:44:13 -0800158 *
159 * If 'size' is a constant, the compiler will optimize this whole function
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300160 * down to either a no-op or the addition of a constant to the value of '*p'.
161 *
162 * The 'p' pointer is absolutely needed to keep the proper advancing
163 * further in memory to the proper offsets when allocating the struct along
164 * with its embedded structs, as edac_device_alloc_ctl_info() does it
165 * above, for example.
166 *
167 * At return, the pointer 'p' will be incremented to be used on a next call
168 * to this function.
Alan Coxda9bb1d2006-01-18 17:44:13 -0800169 */
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300170void *edac_align_ptr(void **p, unsigned size, int n_elems)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800171{
172 unsigned align, r;
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300173 void *ptr = *p;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800174
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300175 *p += size * n_elems;
176
177 /*
178 * 'p' can possibly be an unaligned item X such that sizeof(X) is
179 * 'size'. Adjust 'p' so that its alignment is at least as
180 * stringent as what the compiler would provide for X and return
181 * the aligned result.
182 * Here we assume that the alignment of a "long long" is the most
Alan Coxda9bb1d2006-01-18 17:44:13 -0800183 * stringent alignment that the compiler will ever provide by default.
184 * As far as I know, this is a reasonable assumption.
185 */
186 if (size > sizeof(long))
187 align = sizeof(long long);
188 else if (size > sizeof(int))
189 align = sizeof(long);
190 else if (size > sizeof(short))
191 align = sizeof(int);
192 else if (size > sizeof(char))
193 align = sizeof(short);
194 else
Douglas Thompson079708b2007-07-19 01:49:58 -0700195 return (char *)ptr;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800196
Chris Metcalf8447c4d12012-06-06 13:11:05 -0400197 r = (unsigned long)p % align;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800198
199 if (r == 0)
Douglas Thompson079708b2007-07-19 01:49:58 -0700200 return (char *)ptr;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800201
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300202 *p += align - r;
203
Douglas Thompson7391c6d2007-07-19 01:50:21 -0700204 return (void *)(((unsigned long)ptr) + align - r);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800205}
206
Shaun Ruffellfaa2ad02012-09-22 20:26:38 -0500207static void _edac_mc_free(struct mem_ctl_info *mci)
208{
209 int i, chn, row;
210 struct csrow_info *csr;
211 const unsigned int tot_dimms = mci->tot_dimms;
212 const unsigned int tot_channels = mci->num_cschannel;
213 const unsigned int tot_csrows = mci->nr_csrows;
214
215 if (mci->dimms) {
216 for (i = 0; i < tot_dimms; i++)
217 kfree(mci->dimms[i]);
218 kfree(mci->dimms);
219 }
220 if (mci->csrows) {
221 for (row = 0; row < tot_csrows; row++) {
222 csr = mci->csrows[row];
223 if (csr) {
224 if (csr->channels) {
225 for (chn = 0; chn < tot_channels; chn++)
226 kfree(csr->channels[chn]);
227 kfree(csr->channels);
228 }
229 kfree(csr);
230 }
231 }
232 kfree(mci->csrows);
233 }
234 kfree(mci);
235}
236
Alan Coxda9bb1d2006-01-18 17:44:13 -0800237/**
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300238 * edac_mc_alloc: Allocate and partially fill a struct mem_ctl_info structure
239 * @mc_num: Memory controller number
240 * @n_layers: Number of MC hierarchy layers
241 * layers: Describes each layer as seen by the Memory Controller
242 * @size_pvt: size of private storage needed
243 *
Alan Coxda9bb1d2006-01-18 17:44:13 -0800244 *
245 * Everything is kmalloc'ed as one big chunk - more efficient.
246 * Only can be used if all structures have the same lifetime - otherwise
247 * you have to allocate and initialize your own structures.
248 *
249 * Use edac_mc_free() to free mc structures allocated by this function.
250 *
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300251 * NOTE: drivers handle multi-rank memories in different ways: in some
252 * drivers, one multi-rank memory stick is mapped as one entry, while, in
253 * others, a single multi-rank memory stick would be mapped into several
254 * entries. Currently, this function will allocate multiple struct dimm_info
255 * on such scenarios, as grouping the multiple ranks require drivers change.
256 *
Alan Coxda9bb1d2006-01-18 17:44:13 -0800257 * Returns:
Mauro Carvalho Chehabca0907b2012-05-02 14:37:00 -0300258 * On failure: NULL
259 * On success: struct mem_ctl_info pointer
Alan Coxda9bb1d2006-01-18 17:44:13 -0800260 */
Mauro Carvalho Chehabca0907b2012-05-02 14:37:00 -0300261struct mem_ctl_info *edac_mc_alloc(unsigned mc_num,
262 unsigned n_layers,
263 struct edac_mc_layer *layers,
264 unsigned sz_pvt)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800265{
266 struct mem_ctl_info *mci;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300267 struct edac_mc_layer *layer;
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300268 struct csrow_info *csr;
269 struct rank_info *chan;
Mauro Carvalho Chehaba7d7d2e2012-01-27 14:12:32 -0300270 struct dimm_info *dimm;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300271 u32 *ce_per_layer[EDAC_MAX_LAYERS], *ue_per_layer[EDAC_MAX_LAYERS];
272 unsigned pos[EDAC_MAX_LAYERS];
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300273 unsigned size, tot_dimms = 1, count = 1;
274 unsigned tot_csrows = 1, tot_channels = 1, tot_errcount = 0;
Mauro Carvalho Chehab5926ff52012-02-09 11:05:20 -0300275 void *pvt, *p, *ptr = NULL;
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300276 int i, j, row, chn, n, len, off;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300277 bool per_rank = false;
278
279 BUG_ON(n_layers > EDAC_MAX_LAYERS || n_layers == 0);
280 /*
281 * Calculate the total amount of dimms and csrows/cschannels while
282 * in the old API emulation mode
283 */
284 for (i = 0; i < n_layers; i++) {
285 tot_dimms *= layers[i].size;
286 if (layers[i].is_virt_csrow)
287 tot_csrows *= layers[i].size;
288 else
289 tot_channels *= layers[i].size;
290
291 if (layers[i].type == EDAC_MC_LAYER_CHIP_SELECT)
292 per_rank = true;
293 }
Alan Coxda9bb1d2006-01-18 17:44:13 -0800294
295 /* Figure out the offsets of the various items from the start of an mc
296 * structure. We want the alignment of each item to be at least as
297 * stringent as what the compiler would provide if we could simply
298 * hardcode everything into a single struct.
299 */
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300300 mci = edac_align_ptr(&ptr, sizeof(*mci), 1);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300301 layer = edac_align_ptr(&ptr, sizeof(*layer), n_layers);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300302 for (i = 0; i < n_layers; i++) {
303 count *= layers[i].size;
Joe Perches956b9ba2012-04-29 17:08:39 -0300304 edac_dbg(4, "errcount layer %d size %d\n", i, count);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300305 ce_per_layer[i] = edac_align_ptr(&ptr, sizeof(u32), count);
306 ue_per_layer[i] = edac_align_ptr(&ptr, sizeof(u32), count);
307 tot_errcount += 2 * count;
308 }
309
Joe Perches956b9ba2012-04-29 17:08:39 -0300310 edac_dbg(4, "allocating %d error counters\n", tot_errcount);
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300311 pvt = edac_align_ptr(&ptr, sz_pvt, 1);
Douglas Thompson079708b2007-07-19 01:49:58 -0700312 size = ((unsigned long)pvt) + sz_pvt;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800313
Joe Perches956b9ba2012-04-29 17:08:39 -0300314 edac_dbg(1, "allocating %u bytes for mci data (%d %s, %d csrows/channels)\n",
315 size,
316 tot_dimms,
317 per_rank ? "ranks" : "dimms",
318 tot_csrows * tot_channels);
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300319
Doug Thompson8096cfa2007-07-19 01:50:27 -0700320 mci = kzalloc(size, GFP_KERNEL);
321 if (mci == NULL)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800322 return NULL;
323
324 /* Adjust pointers so they point within the memory we just allocated
325 * rather than an imaginary chunk of memory located at address 0.
326 */
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300327 layer = (struct edac_mc_layer *)(((char *)mci) + ((unsigned long)layer));
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300328 for (i = 0; i < n_layers; i++) {
329 mci->ce_per_layer[i] = (u32 *)((char *)mci + ((unsigned long)ce_per_layer[i]));
330 mci->ue_per_layer[i] = (u32 *)((char *)mci + ((unsigned long)ue_per_layer[i]));
331 }
Douglas Thompson079708b2007-07-19 01:49:58 -0700332 pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800333
Doug Thompsonb8f6f972007-07-19 01:50:26 -0700334 /* setup index and various internal pointers */
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300335 mci->mc_idx = mc_num;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300336 mci->tot_dimms = tot_dimms;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800337 mci->pvt_info = pvt;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300338 mci->n_layers = n_layers;
339 mci->layers = layer;
340 memcpy(mci->layers, layers, sizeof(*layer) * n_layers);
341 mci->nr_csrows = tot_csrows;
342 mci->num_cschannel = tot_channels;
Mauro Carvalho Chehab9713fae2013-03-11 09:28:48 -0300343 mci->csbased = per_rank;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800344
Mauro Carvalho Chehaba7d7d2e2012-01-27 14:12:32 -0300345 /*
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300346 * Alocate and fill the csrow/channels structs
Mauro Carvalho Chehaba7d7d2e2012-01-27 14:12:32 -0300347 */
Joe Perchesd3d09e12013-01-26 11:24:00 -0800348 mci->csrows = kcalloc(tot_csrows, sizeof(*mci->csrows), GFP_KERNEL);
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300349 if (!mci->csrows)
350 goto error;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300351 for (row = 0; row < tot_csrows; row++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300352 csr = kzalloc(sizeof(**mci->csrows), GFP_KERNEL);
353 if (!csr)
354 goto error;
355 mci->csrows[row] = csr;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300356 csr->csrow_idx = row;
357 csr->mci = mci;
358 csr->nr_channels = tot_channels;
Joe Perchesd3d09e12013-01-26 11:24:00 -0800359 csr->channels = kcalloc(tot_channels, sizeof(*csr->channels),
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300360 GFP_KERNEL);
361 if (!csr->channels)
362 goto error;
Mauro Carvalho Chehaba7d7d2e2012-01-27 14:12:32 -0300363
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300364 for (chn = 0; chn < tot_channels; chn++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300365 chan = kzalloc(sizeof(**csr->channels), GFP_KERNEL);
366 if (!chan)
367 goto error;
368 csr->channels[chn] = chan;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800369 chan->chan_idx = chn;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300370 chan->csrow = csr;
371 }
372 }
Mauro Carvalho Chehaba7d7d2e2012-01-27 14:12:32 -0300373
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300374 /*
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300375 * Allocate and fill the dimm structs
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300376 */
Joe Perchesd3d09e12013-01-26 11:24:00 -0800377 mci->dimms = kcalloc(tot_dimms, sizeof(*mci->dimms), GFP_KERNEL);
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300378 if (!mci->dimms)
379 goto error;
380
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300381 memset(&pos, 0, sizeof(pos));
382 row = 0;
383 chn = 0;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300384 for (i = 0; i < tot_dimms; i++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300385 chan = mci->csrows[row]->channels[chn];
386 off = EDAC_DIMM_OFF(layer, n_layers, pos[0], pos[1], pos[2]);
387 if (off < 0 || off >= tot_dimms) {
388 edac_mc_printk(mci, KERN_ERR, "EDAC core bug: EDAC_DIMM_OFF is trying to do an illegal data access\n");
389 goto error;
390 }
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300391
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300392 dimm = kzalloc(sizeof(**mci->dimms), GFP_KERNEL);
Dan Carpenter08a4a132012-05-18 15:51:02 +0300393 if (!dimm)
394 goto error;
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300395 mci->dimms[off] = dimm;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300396 dimm->mci = mci;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300397
Mauro Carvalho Chehab5926ff52012-02-09 11:05:20 -0300398 /*
399 * Copy DIMM location and initialize it.
400 */
401 len = sizeof(dimm->label);
402 p = dimm->label;
403 n = snprintf(p, len, "mc#%u", mc_num);
404 p += n;
405 len -= n;
406 for (j = 0; j < n_layers; j++) {
407 n = snprintf(p, len, "%s#%u",
408 edac_layer_name[layers[j].type],
409 pos[j]);
410 p += n;
411 len -= n;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300412 dimm->location[j] = pos[j];
413
Mauro Carvalho Chehab5926ff52012-02-09 11:05:20 -0300414 if (len <= 0)
415 break;
416 }
417
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300418 /* Link it to the csrows old API data */
419 chan->dimm = dimm;
420 dimm->csrow = row;
421 dimm->cschannel = chn;
422
423 /* Increment csrow location */
Mauro Carvalho Chehab24bef662012-10-24 10:30:01 -0200424 if (layers[0].is_virt_csrow) {
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300425 chn++;
Mauro Carvalho Chehab24bef662012-10-24 10:30:01 -0200426 if (chn == tot_channels) {
427 chn = 0;
428 row++;
429 }
430 } else {
431 row++;
432 if (row == tot_csrows) {
433 row = 0;
434 chn++;
435 }
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300436 }
437
438 /* Increment dimm location */
439 for (j = n_layers - 1; j >= 0; j--) {
440 pos[j]++;
441 if (pos[j] < layers[j].size)
442 break;
443 pos[j] = 0;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800444 }
445 }
446
Dave Jiang81d87cb2007-07-19 01:49:52 -0700447 mci->op_state = OP_ALLOC;
Doug Thompson8096cfa2007-07-19 01:50:27 -0700448
Alan Coxda9bb1d2006-01-18 17:44:13 -0800449 return mci;
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300450
451error:
Shaun Ruffellfaa2ad02012-09-22 20:26:38 -0500452 _edac_mc_free(mci);
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300453
454 return NULL;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800455}
Dave Peterson91105402006-03-26 01:38:55 -0800456EXPORT_SYMBOL_GPL(edac_mc_alloc);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800457
Alan Coxda9bb1d2006-01-18 17:44:13 -0800458/**
Doug Thompson8096cfa2007-07-19 01:50:27 -0700459 * edac_mc_free
460 * 'Free' a previously allocated 'mci' structure
Alan Coxda9bb1d2006-01-18 17:44:13 -0800461 * @mci: pointer to a struct mem_ctl_info structure
Alan Coxda9bb1d2006-01-18 17:44:13 -0800462 */
463void edac_mc_free(struct mem_ctl_info *mci)
464{
Joe Perches956b9ba2012-04-29 17:08:39 -0300465 edac_dbg(1, "\n");
Mauro Carvalho Chehabbbc560a2010-08-16 18:22:43 -0300466
Shaun Ruffellfaa2ad02012-09-22 20:26:38 -0500467 /* If we're not yet registered with sysfs free only what was allocated
468 * in edac_mc_alloc().
469 */
470 if (!device_is_registered(&mci->dev)) {
471 _edac_mc_free(mci);
472 return;
473 }
474
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300475 /* the mci instance is freed here, when the sysfs object is dropped */
Mauro Carvalho Chehab7a623c02012-04-16 16:41:11 -0300476 edac_unregister_sysfs(mci);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800477}
Dave Peterson91105402006-03-26 01:38:55 -0800478EXPORT_SYMBOL_GPL(edac_mc_free);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800479
Doug Thompsonbce19682007-07-26 10:41:14 -0700480
Mauro Carvalho Chehab939747bd2010-08-10 11:22:01 -0300481/**
Doug Thompsonbce19682007-07-26 10:41:14 -0700482 * find_mci_by_dev
483 *
484 * scan list of controllers looking for the one that manages
485 * the 'dev' device
Mauro Carvalho Chehab939747bd2010-08-10 11:22:01 -0300486 * @dev: pointer to a struct device related with the MCI
Doug Thompsonbce19682007-07-26 10:41:14 -0700487 */
Mauro Carvalho Chehab939747bd2010-08-10 11:22:01 -0300488struct mem_ctl_info *find_mci_by_dev(struct device *dev)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800489{
490 struct mem_ctl_info *mci;
491 struct list_head *item;
492
Joe Perches956b9ba2012-04-29 17:08:39 -0300493 edac_dbg(3, "\n");
Alan Coxda9bb1d2006-01-18 17:44:13 -0800494
495 list_for_each(item, &mc_devices) {
496 mci = list_entry(item, struct mem_ctl_info, link);
497
Mauro Carvalho Chehabfd687502012-03-16 07:44:18 -0300498 if (mci->pdev == dev)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800499 return mci;
500 }
501
502 return NULL;
503}
Mauro Carvalho Chehab939747bd2010-08-10 11:22:01 -0300504EXPORT_SYMBOL_GPL(find_mci_by_dev);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800505
Dave Jiang81d87cb2007-07-19 01:49:52 -0700506/*
507 * handler for EDAC to check if NMI type handler has asserted interrupt
508 */
509static int edac_mc_assert_error_check_and_clear(void)
510{
Dave Jiang66ee2f92007-07-19 01:49:54 -0700511 int old_state;
Dave Jiang81d87cb2007-07-19 01:49:52 -0700512
Douglas Thompson079708b2007-07-19 01:49:58 -0700513 if (edac_op_state == EDAC_OPSTATE_POLL)
Dave Jiang81d87cb2007-07-19 01:49:52 -0700514 return 1;
515
Dave Jiang66ee2f92007-07-19 01:49:54 -0700516 old_state = edac_err_assert;
517 edac_err_assert = 0;
Dave Jiang81d87cb2007-07-19 01:49:52 -0700518
Dave Jiang66ee2f92007-07-19 01:49:54 -0700519 return old_state;
Dave Jiang81d87cb2007-07-19 01:49:52 -0700520}
521
522/*
523 * edac_mc_workq_function
524 * performs the operation scheduled by a workq request
525 */
Dave Jiang81d87cb2007-07-19 01:49:52 -0700526static void edac_mc_workq_function(struct work_struct *work_req)
527{
Jean Delvarefbeb4382009-04-13 14:40:21 -0700528 struct delayed_work *d_work = to_delayed_work(work_req);
Dave Jiang81d87cb2007-07-19 01:49:52 -0700529 struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
Dave Jiang81d87cb2007-07-19 01:49:52 -0700530
531 mutex_lock(&mem_ctls_mutex);
532
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700533 /* if this control struct has movd to offline state, we are done */
534 if (mci->op_state == OP_OFFLINE) {
535 mutex_unlock(&mem_ctls_mutex);
536 return;
537 }
538
Dave Jiang81d87cb2007-07-19 01:49:52 -0700539 /* Only poll controllers that are running polled and have a check */
540 if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL))
541 mci->edac_check(mci);
542
Dave Jiang81d87cb2007-07-19 01:49:52 -0700543 mutex_unlock(&mem_ctls_mutex);
544
545 /* Reschedule */
Dave Jiang4de78c62007-07-19 01:49:54 -0700546 queue_delayed_work(edac_workqueue, &mci->work,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700547 msecs_to_jiffies(edac_mc_get_poll_msec()));
Dave Jiang81d87cb2007-07-19 01:49:52 -0700548}
549
550/*
551 * edac_mc_workq_setup
552 * initialize a workq item for this mci
553 * passing in the new delay period in msec
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700554 *
555 * locking model:
556 *
557 * called with the mem_ctls_mutex held
Dave Jiang81d87cb2007-07-19 01:49:52 -0700558 */
Borislav Petkovcb6ef422014-02-12 18:15:00 +0100559static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec,
560 bool init)
Dave Jiang81d87cb2007-07-19 01:49:52 -0700561{
Joe Perches956b9ba2012-04-29 17:08:39 -0300562 edac_dbg(0, "\n");
Dave Jiang81d87cb2007-07-19 01:49:52 -0700563
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700564 /* if this instance is not in the POLL state, then simply return */
565 if (mci->op_state != OP_RUNNING_POLL)
566 return;
567
Borislav Petkovcb6ef422014-02-12 18:15:00 +0100568 if (init)
569 INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
570
Tejun Heo41f63c52012-08-03 10:30:47 -0700571 mod_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
Dave Jiang81d87cb2007-07-19 01:49:52 -0700572}
573
574/*
575 * edac_mc_workq_teardown
576 * stop the workq processing on this mci
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700577 *
578 * locking model:
579 *
580 * called WITHOUT lock held
Dave Jiang81d87cb2007-07-19 01:49:52 -0700581 */
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700582static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
Dave Jiang81d87cb2007-07-19 01:49:52 -0700583{
584 int status;
585
Borislav Petkov00740c52010-09-26 12:42:23 +0200586 if (mci->op_state != OP_RUNNING_POLL)
587 return;
588
Doug Thompsonbce19682007-07-26 10:41:14 -0700589 status = cancel_delayed_work(&mci->work);
590 if (status == 0) {
Joe Perches956b9ba2012-04-29 17:08:39 -0300591 edac_dbg(0, "not canceled, flush the queue\n");
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700592
Doug Thompsonbce19682007-07-26 10:41:14 -0700593 /* workq instance might be running, wait for it */
594 flush_workqueue(edac_workqueue);
Dave Jiang81d87cb2007-07-19 01:49:52 -0700595 }
596}
597
598/*
Doug Thompsonbce19682007-07-26 10:41:14 -0700599 * edac_mc_reset_delay_period(unsigned long value)
600 *
601 * user space has updated our poll period value, need to
602 * reset our workq delays
Dave Jiang81d87cb2007-07-19 01:49:52 -0700603 */
Borislav Petkov9da21b12014-02-03 15:05:13 -0500604void edac_mc_reset_delay_period(unsigned long value)
Dave Jiang81d87cb2007-07-19 01:49:52 -0700605{
Doug Thompsonbce19682007-07-26 10:41:14 -0700606 struct mem_ctl_info *mci;
607 struct list_head *item;
Dave Jiang81d87cb2007-07-19 01:49:52 -0700608
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700609 mutex_lock(&mem_ctls_mutex);
610
Doug Thompsonbce19682007-07-26 10:41:14 -0700611 list_for_each(item, &mc_devices) {
612 mci = list_entry(item, struct mem_ctl_info, link);
613
Borislav Petkovcb6ef422014-02-12 18:15:00 +0100614 edac_mc_workq_setup(mci, value, false);
Doug Thompsonbce19682007-07-26 10:41:14 -0700615 }
Dave Jiang81d87cb2007-07-19 01:49:52 -0700616
617 mutex_unlock(&mem_ctls_mutex);
618}
619
Doug Thompsonbce19682007-07-26 10:41:14 -0700620
621
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700622/* Return 0 on success, 1 on failure.
623 * Before calling this function, caller must
624 * assign a unique value to mci->mc_idx.
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700625 *
626 * locking model:
627 *
628 * called with the mem_ctls_mutex lock held
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700629 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700630static int add_mc_to_global_list(struct mem_ctl_info *mci)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800631{
632 struct list_head *item, *insert_before;
633 struct mem_ctl_info *p;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800634
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700635 insert_before = &mc_devices;
636
Mauro Carvalho Chehabfd687502012-03-16 07:44:18 -0300637 p = find_mci_by_dev(mci->pdev);
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700638 if (unlikely(p != NULL))
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700639 goto fail0;
640
641 list_for_each(item, &mc_devices) {
642 p = list_entry(item, struct mem_ctl_info, link);
643
644 if (p->mc_idx >= mci->mc_idx) {
645 if (unlikely(p->mc_idx == mci->mc_idx))
646 goto fail1;
647
648 insert_before = item;
649 break;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800650 }
Alan Coxda9bb1d2006-01-18 17:44:13 -0800651 }
652
653 list_add_tail_rcu(&mci->link, insert_before);
Dave Jiangc0d12172007-07-19 01:49:46 -0700654 atomic_inc(&edac_handlers);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800655 return 0;
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700656
Douglas Thompson052dfb42007-07-19 01:50:13 -0700657fail0:
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700658 edac_printk(KERN_WARNING, EDAC_MC,
Mauro Carvalho Chehabfd687502012-03-16 07:44:18 -0300659 "%s (%s) %s %s already assigned %d\n", dev_name(p->pdev),
Stephen Rothwell17aa7e02008-05-05 13:54:19 +1000660 edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700661 return 1;
662
Douglas Thompson052dfb42007-07-19 01:50:13 -0700663fail1:
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700664 edac_printk(KERN_WARNING, EDAC_MC,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700665 "bug in low-level driver: attempt to assign\n"
666 " duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700667 return 1;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800668}
669
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300670static int del_mc_from_global_list(struct mem_ctl_info *mci)
Dave Petersona1d03fc2006-03-26 01:38:46 -0800671{
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300672 int handlers = atomic_dec_return(&edac_handlers);
Dave Petersona1d03fc2006-03-26 01:38:46 -0800673 list_del_rcu(&mci->link);
Lai Jiangshane2e77092011-05-26 16:25:58 -0700674
675 /* these are for safe removal of devices from global list while
676 * NMI handlers may be traversing list
677 */
678 synchronize_rcu();
679 INIT_LIST_HEAD(&mci->link);
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300680
681 return handlers;
Dave Petersona1d03fc2006-03-26 01:38:46 -0800682}
683
Alan Coxda9bb1d2006-01-18 17:44:13 -0800684/**
Douglas Thompson5da08312007-07-19 01:49:31 -0700685 * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
686 *
687 * If found, return a pointer to the structure.
688 * Else return NULL.
689 *
690 * Caller must hold mem_ctls_mutex.
691 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700692struct mem_ctl_info *edac_mc_find(int idx)
Douglas Thompson5da08312007-07-19 01:49:31 -0700693{
694 struct list_head *item;
695 struct mem_ctl_info *mci;
696
697 list_for_each(item, &mc_devices) {
698 mci = list_entry(item, struct mem_ctl_info, link);
699
700 if (mci->mc_idx >= idx) {
701 if (mci->mc_idx == idx)
702 return mci;
703
704 break;
705 }
706 }
707
708 return NULL;
709}
710EXPORT_SYMBOL(edac_mc_find);
711
712/**
Dave Peterson472678e2006-03-26 01:38:49 -0800713 * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
714 * create sysfs entries associated with mci structure
Alan Coxda9bb1d2006-01-18 17:44:13 -0800715 * @mci: pointer to the mci structure to be added to the list
716 *
717 * Return:
718 * 0 Success
719 * !0 Failure
720 */
721
722/* FIXME - should a warning be printed if no error detection? correction? */
Doug Thompsonb8f6f972007-07-19 01:50:26 -0700723int edac_mc_add_mc(struct mem_ctl_info *mci)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800724{
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300725 int ret = -EINVAL;
Joe Perches956b9ba2012-04-29 17:08:39 -0300726 edac_dbg(0, "\n");
Doug Thompsonb8f6f972007-07-19 01:50:26 -0700727
Borislav Petkov88d84ac2013-07-19 12:28:25 +0200728 if (mci->mc_idx >= EDAC_MAX_MCS) {
729 pr_warn_once("Too many memory controllers: %d\n", mci->mc_idx);
730 return -ENODEV;
731 }
732
Alan Coxda9bb1d2006-01-18 17:44:13 -0800733#ifdef CONFIG_EDAC_DEBUG
734 if (edac_debug_level >= 3)
735 edac_mc_dump_mci(mci);
Dave Petersone7ecd892006-03-26 01:38:52 -0800736
Alan Coxda9bb1d2006-01-18 17:44:13 -0800737 if (edac_debug_level >= 4) {
738 int i;
739
740 for (i = 0; i < mci->nr_csrows; i++) {
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -0300741 struct csrow_info *csrow = mci->csrows[i];
742 u32 nr_pages = 0;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800743 int j;
Dave Petersone7ecd892006-03-26 01:38:52 -0800744
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -0300745 for (j = 0; j < csrow->nr_channels; j++)
746 nr_pages += csrow->channels[j]->dimm->nr_pages;
747 if (!nr_pages)
748 continue;
749 edac_mc_dump_csrow(csrow);
750 for (j = 0; j < csrow->nr_channels; j++)
751 if (csrow->channels[j]->dimm->nr_pages)
752 edac_mc_dump_channel(csrow->channels[j]);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800753 }
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300754 for (i = 0; i < mci->tot_dimms; i++)
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -0300755 if (mci->dimms[i]->nr_pages)
756 edac_mc_dump_dimm(mci->dimms[i], i);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800757 }
758#endif
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700759 mutex_lock(&mem_ctls_mutex);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800760
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300761 if (edac_mc_owner && edac_mc_owner != mci->mod_name) {
762 ret = -EPERM;
763 goto fail0;
764 }
765
Alan Coxda9bb1d2006-01-18 17:44:13 -0800766 if (add_mc_to_global_list(mci))
Dave Peterson028a7b62006-03-26 01:38:47 -0800767 goto fail0;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800768
769 /* set load time so that error rate can be tracked */
770 mci->start_time = jiffies;
771
Borislav Petkov88d84ac2013-07-19 12:28:25 +0200772 mci->bus = &mc_bus[mci->mc_idx];
773
eric wollesen9794f332007-02-12 00:53:08 -0800774 if (edac_create_sysfs_mci_device(mci)) {
775 edac_mc_printk(mci, KERN_WARNING,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700776 "failed to create sysfs device\n");
eric wollesen9794f332007-02-12 00:53:08 -0800777 goto fail1;
778 }
Alan Coxda9bb1d2006-01-18 17:44:13 -0800779
Dave Jiang81d87cb2007-07-19 01:49:52 -0700780 /* If there IS a check routine, then we are running POLLED */
781 if (mci->edac_check != NULL) {
782 /* This instance is NOW RUNNING */
783 mci->op_state = OP_RUNNING_POLL;
784
Borislav Petkovcb6ef422014-02-12 18:15:00 +0100785 edac_mc_workq_setup(mci, edac_mc_get_poll_msec(), true);
Dave Jiang81d87cb2007-07-19 01:49:52 -0700786 } else {
787 mci->op_state = OP_RUNNING_INTERRUPT;
788 }
789
Alan Coxda9bb1d2006-01-18 17:44:13 -0800790 /* Report action taken */
Robert Richter7270a602013-10-10 18:22:36 +0200791 edac_mc_printk(mci, KERN_INFO,
792 "Giving out device to module %s controller %s: DEV %s (%s)\n",
793 mci->mod_name, mci->ctl_name, mci->dev_name,
794 edac_op_state_to_string(mci->op_state));
Alan Coxda9bb1d2006-01-18 17:44:13 -0800795
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300796 edac_mc_owner = mci->mod_name;
797
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700798 mutex_unlock(&mem_ctls_mutex);
Dave Peterson028a7b62006-03-26 01:38:47 -0800799 return 0;
800
Douglas Thompson052dfb42007-07-19 01:50:13 -0700801fail1:
Dave Peterson028a7b62006-03-26 01:38:47 -0800802 del_mc_from_global_list(mci);
803
Douglas Thompson052dfb42007-07-19 01:50:13 -0700804fail0:
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700805 mutex_unlock(&mem_ctls_mutex);
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300806 return ret;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800807}
Dave Peterson91105402006-03-26 01:38:55 -0800808EXPORT_SYMBOL_GPL(edac_mc_add_mc);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800809
Alan Coxda9bb1d2006-01-18 17:44:13 -0800810/**
Dave Peterson472678e2006-03-26 01:38:49 -0800811 * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
812 * remove mci structure from global list
Doug Thompson37f04582006-06-30 01:56:07 -0700813 * @pdev: Pointer to 'struct device' representing mci structure to remove.
Alan Coxda9bb1d2006-01-18 17:44:13 -0800814 *
Dave Peterson18dbc332006-03-26 01:38:50 -0800815 * Return pointer to removed mci structure, or NULL if device not found.
Alan Coxda9bb1d2006-01-18 17:44:13 -0800816 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700817struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800818{
Dave Peterson18dbc332006-03-26 01:38:50 -0800819 struct mem_ctl_info *mci;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800820
Joe Perches956b9ba2012-04-29 17:08:39 -0300821 edac_dbg(0, "\n");
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700822
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700823 mutex_lock(&mem_ctls_mutex);
Dave Peterson18dbc332006-03-26 01:38:50 -0800824
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700825 /* find the requested mci struct in the global list */
826 mci = find_mci_by_dev(dev);
827 if (mci == NULL) {
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700828 mutex_unlock(&mem_ctls_mutex);
Dave Peterson18dbc332006-03-26 01:38:50 -0800829 return NULL;
830 }
831
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300832 if (!del_mc_from_global_list(mci))
833 edac_mc_owner = NULL;
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700834 mutex_unlock(&mem_ctls_mutex);
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700835
Borislav Petkovbb31b3122010-12-02 17:48:35 +0100836 /* flush workq processes */
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700837 edac_mc_workq_teardown(mci);
Borislav Petkovbb31b3122010-12-02 17:48:35 +0100838
839 /* marking MCI offline */
840 mci->op_state = OP_OFFLINE;
841
842 /* remove from sysfs */
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700843 edac_remove_sysfs_mci_device(mci);
844
Dave Peterson537fba22006-03-26 01:38:40 -0800845 edac_printk(KERN_INFO, EDAC_MC,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700846 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
Stephen Rothwell17aa7e02008-05-05 13:54:19 +1000847 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700848
Dave Peterson18dbc332006-03-26 01:38:50 -0800849 return mci;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800850}
Dave Peterson91105402006-03-26 01:38:55 -0800851EXPORT_SYMBOL_GPL(edac_mc_del_mc);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800852
Adrian Bunk2da1c112007-07-19 01:49:32 -0700853static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
854 u32 size)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800855{
856 struct page *pg;
857 void *virt_addr;
858 unsigned long flags = 0;
859
Joe Perches956b9ba2012-04-29 17:08:39 -0300860 edac_dbg(3, "\n");
Alan Coxda9bb1d2006-01-18 17:44:13 -0800861
862 /* ECC error page was not in our memory. Ignore it. */
Douglas Thompson079708b2007-07-19 01:49:58 -0700863 if (!pfn_valid(page))
Alan Coxda9bb1d2006-01-18 17:44:13 -0800864 return;
865
866 /* Find the actual page structure then map it and fix */
867 pg = pfn_to_page(page);
868
869 if (PageHighMem(pg))
870 local_irq_save(flags);
871
Cong Wang4e5df7c2011-11-25 23:14:19 +0800872 virt_addr = kmap_atomic(pg);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800873
874 /* Perform architecture specific atomic scrub operation */
875 atomic_scrub(virt_addr + offset, size);
876
877 /* Unmap and complete */
Cong Wang4e5df7c2011-11-25 23:14:19 +0800878 kunmap_atomic(virt_addr);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800879
880 if (PageHighMem(pg))
881 local_irq_restore(flags);
882}
883
Alan Coxda9bb1d2006-01-18 17:44:13 -0800884/* FIXME - should return -1 */
Dave Petersone7ecd892006-03-26 01:38:52 -0800885int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800886{
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300887 struct csrow_info **csrows = mci->csrows;
Mauro Carvalho Chehaba895bf82012-01-28 09:09:38 -0300888 int row, i, j, n;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800889
Joe Perches956b9ba2012-04-29 17:08:39 -0300890 edac_dbg(1, "MC%d: 0x%lx\n", mci->mc_idx, page);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800891 row = -1;
892
893 for (i = 0; i < mci->nr_csrows; i++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300894 struct csrow_info *csrow = csrows[i];
Mauro Carvalho Chehaba895bf82012-01-28 09:09:38 -0300895 n = 0;
896 for (j = 0; j < csrow->nr_channels; j++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300897 struct dimm_info *dimm = csrow->channels[j]->dimm;
Mauro Carvalho Chehaba895bf82012-01-28 09:09:38 -0300898 n += dimm->nr_pages;
899 }
900 if (n == 0)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800901 continue;
902
Joe Perches956b9ba2012-04-29 17:08:39 -0300903 edac_dbg(3, "MC%d: first(0x%lx) page(0x%lx) last(0x%lx) mask(0x%lx)\n",
904 mci->mc_idx,
905 csrow->first_page, page, csrow->last_page,
906 csrow->page_mask);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800907
908 if ((page >= csrow->first_page) &&
909 (page <= csrow->last_page) &&
910 ((page & csrow->page_mask) ==
911 (csrow->first_page & csrow->page_mask))) {
912 row = i;
913 break;
914 }
915 }
916
917 if (row == -1)
Dave Peterson537fba22006-03-26 01:38:40 -0800918 edac_mc_printk(mci, KERN_ERR,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700919 "could not look up page error address %lx\n",
920 (unsigned long)page);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800921
922 return row;
923}
Dave Peterson91105402006-03-26 01:38:55 -0800924EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800925
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300926const char *edac_layer_name[] = {
927 [EDAC_MC_LAYER_BRANCH] = "branch",
928 [EDAC_MC_LAYER_CHANNEL] = "channel",
929 [EDAC_MC_LAYER_SLOT] = "slot",
930 [EDAC_MC_LAYER_CHIP_SELECT] = "csrow",
Mauro Carvalho Chehabc66b5a72013-02-15 07:21:08 -0300931 [EDAC_MC_LAYER_ALL_MEM] = "memory",
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300932};
933EXPORT_SYMBOL_GPL(edac_layer_name);
934
935static void edac_inc_ce_error(struct mem_ctl_info *mci,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300936 bool enable_per_layer_report,
937 const int pos[EDAC_MAX_LAYERS],
938 const u16 count)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800939{
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300940 int i, index = 0;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800941
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300942 mci->ce_mc += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300943
944 if (!enable_per_layer_report) {
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300945 mci->ce_noinfo_count += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300946 return;
947 }
948
949 for (i = 0; i < mci->n_layers; i++) {
950 if (pos[i] < 0)
951 break;
952 index += pos[i];
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300953 mci->ce_per_layer[i][index] += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300954
955 if (i < mci->n_layers - 1)
956 index *= mci->layers[i + 1].size;
957 }
958}
959
960static void edac_inc_ue_error(struct mem_ctl_info *mci,
961 bool enable_per_layer_report,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300962 const int pos[EDAC_MAX_LAYERS],
963 const u16 count)
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300964{
965 int i, index = 0;
966
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300967 mci->ue_mc += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300968
969 if (!enable_per_layer_report) {
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300970 mci->ce_noinfo_count += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300971 return;
972 }
973
974 for (i = 0; i < mci->n_layers; i++) {
975 if (pos[i] < 0)
976 break;
977 index += pos[i];
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300978 mci->ue_per_layer[i][index] += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300979
980 if (i < mci->n_layers - 1)
981 index *= mci->layers[i + 1].size;
982 }
983}
984
985static void edac_ce_error(struct mem_ctl_info *mci,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300986 const u16 error_count,
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300987 const int pos[EDAC_MAX_LAYERS],
988 const char *msg,
989 const char *location,
990 const char *label,
991 const char *detail,
992 const char *other_detail,
993 const bool enable_per_layer_report,
994 const unsigned long page_frame_number,
995 const unsigned long offset_in_page,
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -0300996 long grain)
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300997{
998 unsigned long remapped_page;
Borislav Petkovf430d572012-09-10 18:36:09 +0200999 char *msg_aux = "";
1000
1001 if (*msg)
1002 msg_aux = " ";
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001003
1004 if (edac_mc_get_log_ce()) {
1005 if (other_detail && *other_detail)
1006 edac_mc_printk(mci, KERN_WARNING,
Borislav Petkovf430d572012-09-10 18:36:09 +02001007 "%d CE %s%son %s (%s %s - %s)\n",
1008 error_count, msg, msg_aux, label,
1009 location, detail, other_detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001010 else
1011 edac_mc_printk(mci, KERN_WARNING,
Borislav Petkovf430d572012-09-10 18:36:09 +02001012 "%d CE %s%son %s (%s %s)\n",
1013 error_count, msg, msg_aux, label,
1014 location, detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001015 }
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001016 edac_inc_ce_error(mci, enable_per_layer_report, pos, error_count);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001017
Loc Hoaa2064d2014-05-08 17:03:16 -06001018 if (mci->scrub_mode == SCRUB_SW_SRC) {
Alan Coxda9bb1d2006-01-18 17:44:13 -08001019 /*
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001020 * Some memory controllers (called MCs below) can remap
1021 * memory so that it is still available at a different
1022 * address when PCI devices map into memory.
1023 * MC's that can't do this, lose the memory where PCI
1024 * devices are mapped. This mapping is MC-dependent
1025 * and so we call back into the MC driver for it to
1026 * map the MC page to a physical (CPU) page which can
1027 * then be mapped to a virtual page - which can then
1028 * be scrubbed.
1029 */
Alan Coxda9bb1d2006-01-18 17:44:13 -08001030 remapped_page = mci->ctl_page_to_phys ?
Douglas Thompson052dfb42007-07-19 01:50:13 -07001031 mci->ctl_page_to_phys(mci, page_frame_number) :
1032 page_frame_number;
Alan Coxda9bb1d2006-01-18 17:44:13 -08001033
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001034 edac_mc_scrub_block(remapped_page,
1035 offset_in_page, grain);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001036 }
1037}
1038
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001039static void edac_ue_error(struct mem_ctl_info *mci,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001040 const u16 error_count,
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001041 const int pos[EDAC_MAX_LAYERS],
1042 const char *msg,
1043 const char *location,
1044 const char *label,
1045 const char *detail,
1046 const char *other_detail,
1047 const bool enable_per_layer_report)
Alan Coxda9bb1d2006-01-18 17:44:13 -08001048{
Borislav Petkovf430d572012-09-10 18:36:09 +02001049 char *msg_aux = "";
1050
1051 if (*msg)
1052 msg_aux = " ";
1053
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001054 if (edac_mc_get_log_ue()) {
1055 if (other_detail && *other_detail)
1056 edac_mc_printk(mci, KERN_WARNING,
Borislav Petkovf430d572012-09-10 18:36:09 +02001057 "%d UE %s%son %s (%s %s - %s)\n",
1058 error_count, msg, msg_aux, label,
1059 location, detail, other_detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001060 else
1061 edac_mc_printk(mci, KERN_WARNING,
Borislav Petkovf430d572012-09-10 18:36:09 +02001062 "%d UE %s%son %s (%s %s)\n",
1063 error_count, msg, msg_aux, label,
1064 location, detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001065 }
Dave Petersone7ecd892006-03-26 01:38:52 -08001066
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001067 if (edac_mc_get_panic_on_ue()) {
1068 if (other_detail && *other_detail)
Borislav Petkovf430d572012-09-10 18:36:09 +02001069 panic("UE %s%son %s (%s%s - %s)\n",
1070 msg, msg_aux, label, location, detail, other_detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001071 else
Borislav Petkovf430d572012-09-10 18:36:09 +02001072 panic("UE %s%son %s (%s%s)\n",
1073 msg, msg_aux, label, location, detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001074 }
1075
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001076 edac_inc_ue_error(mci, enable_per_layer_report, pos, error_count);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001077}
1078
Mauro Carvalho Chehabe7e24832012-10-31 13:46:11 -03001079/**
1080 * edac_raw_mc_handle_error - reports a memory event to userspace without doing
1081 * anything to discover the error location
1082 *
1083 * @type: severity of the error (CE/UE/Fatal)
1084 * @mci: a struct mem_ctl_info pointer
1085 * @e: error description
1086 *
1087 * This raw function is used internally by edac_mc_handle_error(). It should
1088 * only be called directly when the hardware error come directly from BIOS,
1089 * like in the case of APEI GHES driver.
1090 */
1091void edac_raw_mc_handle_error(const enum hw_event_mc_err_type type,
1092 struct mem_ctl_info *mci,
1093 struct edac_raw_error_desc *e)
1094{
1095 char detail[80];
1096 int pos[EDAC_MAX_LAYERS] = { e->top_layer, e->mid_layer, e->low_layer };
1097
1098 /* Memory type dependent details about the error */
1099 if (type == HW_EVENT_ERR_CORRECTED) {
1100 snprintf(detail, sizeof(detail),
1101 "page:0x%lx offset:0x%lx grain:%ld syndrome:0x%lx",
1102 e->page_frame_number, e->offset_in_page,
1103 e->grain, e->syndrome);
1104 edac_ce_error(mci, e->error_count, pos, e->msg, e->location, e->label,
1105 detail, e->other_detail, e->enable_per_layer_report,
1106 e->page_frame_number, e->offset_in_page, e->grain);
1107 } else {
1108 snprintf(detail, sizeof(detail),
1109 "page:0x%lx offset:0x%lx grain:%ld",
1110 e->page_frame_number, e->offset_in_page, e->grain);
1111
1112 edac_ue_error(mci, e->error_count, pos, e->msg, e->location, e->label,
1113 detail, e->other_detail, e->enable_per_layer_report);
1114 }
1115
1116
1117}
1118EXPORT_SYMBOL_GPL(edac_raw_mc_handle_error);
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001119
1120/**
1121 * edac_mc_handle_error - reports a memory event to userspace
1122 *
1123 * @type: severity of the error (CE/UE/Fatal)
1124 * @mci: a struct mem_ctl_info pointer
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001125 * @error_count: Number of errors of the same type
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001126 * @page_frame_number: mem page where the error occurred
1127 * @offset_in_page: offset of the error inside the page
1128 * @syndrome: ECC syndrome
1129 * @top_layer: Memory layer[0] position
1130 * @mid_layer: Memory layer[1] position
1131 * @low_layer: Memory layer[2] position
1132 * @msg: Message meaningful to the end users that
1133 * explains the event
1134 * @other_detail: Technical details about the event that
1135 * may help hardware manufacturers and
1136 * EDAC developers to analyse the event
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001137 */
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001138void edac_mc_handle_error(const enum hw_event_mc_err_type type,
1139 struct mem_ctl_info *mci,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001140 const u16 error_count,
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001141 const unsigned long page_frame_number,
1142 const unsigned long offset_in_page,
1143 const unsigned long syndrome,
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001144 const int top_layer,
1145 const int mid_layer,
1146 const int low_layer,
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001147 const char *msg,
Mauro Carvalho Chehab03f7eae2012-06-04 11:29:25 -03001148 const char *other_detail)
Alan Coxda9bb1d2006-01-18 17:44:13 -08001149{
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001150 char *p;
1151 int row = -1, chan = -1;
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001152 int pos[EDAC_MAX_LAYERS] = { top_layer, mid_layer, low_layer };
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001153 int i, n_labels = 0;
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001154 u8 grain_bits;
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001155 struct edac_raw_error_desc *e = &mci->error_desc;
Alan Coxda9bb1d2006-01-18 17:44:13 -08001156
Joe Perches956b9ba2012-04-29 17:08:39 -03001157 edac_dbg(3, "MC%d\n", mci->mc_idx);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001158
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001159 /* Fills the error report buffer */
1160 memset(e, 0, sizeof (*e));
1161 e->error_count = error_count;
1162 e->top_layer = top_layer;
1163 e->mid_layer = mid_layer;
1164 e->low_layer = low_layer;
1165 e->page_frame_number = page_frame_number;
1166 e->offset_in_page = offset_in_page;
1167 e->syndrome = syndrome;
1168 e->msg = msg;
1169 e->other_detail = other_detail;
1170
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001171 /*
1172 * Check if the event report is consistent and if the memory
1173 * location is known. If it is known, enable_per_layer_report will be
1174 * true, the DIMM(s) label info will be filled and the per-layer
1175 * error counters will be incremented.
1176 */
1177 for (i = 0; i < mci->n_layers; i++) {
1178 if (pos[i] >= (int)mci->layers[i].size) {
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001179
1180 edac_mc_printk(mci, KERN_ERR,
1181 "INTERNAL ERROR: %s value is out of range (%d >= %d)\n",
1182 edac_layer_name[mci->layers[i].type],
1183 pos[i], mci->layers[i].size);
1184 /*
1185 * Instead of just returning it, let's use what's
1186 * known about the error. The increment routines and
1187 * the DIMM filter logic will do the right thing by
1188 * pointing the likely damaged DIMMs.
1189 */
1190 pos[i] = -1;
1191 }
1192 if (pos[i] >= 0)
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001193 e->enable_per_layer_report = true;
Alan Coxda9bb1d2006-01-18 17:44:13 -08001194 }
1195
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001196 /*
1197 * Get the dimm label/grain that applies to the match criteria.
1198 * As the error algorithm may not be able to point to just one memory
1199 * stick, the logic here will get all possible labels that could
1200 * pottentially be affected by the error.
1201 * On FB-DIMM memory controllers, for uncorrected errors, it is common
1202 * to have only the MC channel and the MC dimm (also called "branch")
1203 * but the channel is not known, as the memory is arranged in pairs,
1204 * where each memory belongs to a separate channel within the same
1205 * branch.
1206 */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001207 p = e->label;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001208 *p = '\0';
Borislav Petkov4da1b7b2012-09-10 17:57:44 +02001209
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001210 for (i = 0; i < mci->tot_dimms; i++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -03001211 struct dimm_info *dimm = mci->dimms[i];
Dave Petersone7ecd892006-03-26 01:38:52 -08001212
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001213 if (top_layer >= 0 && top_layer != dimm->location[0])
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001214 continue;
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001215 if (mid_layer >= 0 && mid_layer != dimm->location[1])
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001216 continue;
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001217 if (low_layer >= 0 && low_layer != dimm->location[2])
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001218 continue;
1219
1220 /* get the max grain, over the error match range */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001221 if (dimm->grain > e->grain)
1222 e->grain = dimm->grain;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001223
1224 /*
1225 * If the error is memory-controller wide, there's no need to
1226 * seek for the affected DIMMs because the whole
1227 * channel/memory controller/... may be affected.
1228 * Also, don't show errors for empty DIMM slots.
1229 */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001230 if (e->enable_per_layer_report && dimm->nr_pages) {
1231 if (n_labels >= EDAC_MAX_LABELS) {
1232 e->enable_per_layer_report = false;
1233 break;
1234 }
1235 n_labels++;
1236 if (p != e->label) {
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001237 strcpy(p, OTHER_LABEL);
1238 p += strlen(OTHER_LABEL);
1239 }
1240 strcpy(p, dimm->label);
1241 p += strlen(p);
1242 *p = '\0';
1243
1244 /*
1245 * get csrow/channel of the DIMM, in order to allow
1246 * incrementing the compat API counters
1247 */
Joe Perches956b9ba2012-04-29 17:08:39 -03001248 edac_dbg(4, "%s csrows map: (%d,%d)\n",
Mauro Carvalho Chehab9713fae2013-03-11 09:28:48 -03001249 mci->csbased ? "rank" : "dimm",
Joe Perches956b9ba2012-04-29 17:08:39 -03001250 dimm->csrow, dimm->cschannel);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001251 if (row == -1)
1252 row = dimm->csrow;
1253 else if (row >= 0 && row != dimm->csrow)
1254 row = -2;
1255
1256 if (chan == -1)
1257 chan = dimm->cschannel;
1258 else if (chan >= 0 && chan != dimm->cschannel)
1259 chan = -2;
1260 }
Alan Coxda9bb1d2006-01-18 17:44:13 -08001261 }
1262
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001263 if (!e->enable_per_layer_report) {
1264 strcpy(e->label, "any memory");
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001265 } else {
Joe Perches956b9ba2012-04-29 17:08:39 -03001266 edac_dbg(4, "csrow/channel to increment: (%d,%d)\n", row, chan);
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001267 if (p == e->label)
1268 strcpy(e->label, "unknown memory");
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001269 if (type == HW_EVENT_ERR_CORRECTED) {
1270 if (row >= 0) {
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001271 mci->csrows[row]->ce_count += error_count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001272 if (chan >= 0)
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001273 mci->csrows[row]->channels[chan]->ce_count += error_count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001274 }
1275 } else
1276 if (row >= 0)
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001277 mci->csrows[row]->ue_count += error_count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001278 }
Alan Coxda9bb1d2006-01-18 17:44:13 -08001279
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001280 /* Fill the RAM location data */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001281 p = e->location;
Borislav Petkov4da1b7b2012-09-10 17:57:44 +02001282
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001283 for (i = 0; i < mci->n_layers; i++) {
1284 if (pos[i] < 0)
1285 continue;
1286
1287 p += sprintf(p, "%s:%d ",
1288 edac_layer_name[mci->layers[i].type],
1289 pos[i]);
1290 }
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001291 if (p > e->location)
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001292 *(p - 1) = '\0';
1293
1294 /* Report the error via the trace interface */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001295 grain_bits = fls_long(e->grain) + 1;
1296 trace_mc_event(type, e->msg, e->label, e->error_count,
1297 mci->mc_idx, e->top_layer, e->mid_layer, e->low_layer,
1298 PAGES_TO_MiB(e->page_frame_number) | e->offset_in_page,
Mauro Carvalho Chehabe7e24832012-10-31 13:46:11 -03001299 grain_bits, e->syndrome, e->other_detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001300
Mauro Carvalho Chehabe7e24832012-10-31 13:46:11 -03001301 edac_raw_mc_handle_error(type, mci, e);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001302}
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001303EXPORT_SYMBOL_GPL(edac_mc_handle_error);