blob: 1472f48c8ac6109677f28da6d1067c11e3e16fa4 [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>
Douglas Thompson20bcb7a2007-07-19 01:49:47 -070033#include "edac_core.h"
Douglas Thompson7c9281d2007-07-19 01:49:33 -070034#include "edac_module.h"
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -030035#include <ras/ras_event.h>
36
Borislav Petkovb01aec92015-05-21 19:59:31 +020037#ifdef CONFIG_EDAC_ATOMIC_SCRUB
38#include <asm/edac.h>
39#else
40#define edac_atomic_scrub(va, size) do { } while (0)
41#endif
42
Alan Coxda9bb1d2006-01-18 17:44:13 -080043/* lock to memory controller's control array */
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -070044static DEFINE_MUTEX(mem_ctls_mutex);
Robert P. J. Dayff6ac2a2008-04-29 01:03:17 -070045static LIST_HEAD(mc_devices);
Alan Coxda9bb1d2006-01-18 17:44:13 -080046
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -030047/*
48 * Used to lock EDAC MC to just one module, avoiding two drivers e. g.
49 * apei/ghes and i7core_edac to be used at the same time.
50 */
51static void const *edac_mc_owner;
52
Borislav Petkov88d84ac2013-07-19 12:28:25 +020053static struct bus_type mc_bus[EDAC_MAX_MCS];
54
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030055unsigned edac_dimm_info_location(struct dimm_info *dimm, char *buf,
56 unsigned len)
57{
58 struct mem_ctl_info *mci = dimm->mci;
59 int i, n, count = 0;
60 char *p = buf;
61
62 for (i = 0; i < mci->n_layers; i++) {
63 n = snprintf(p, len, "%s %d ",
64 edac_layer_name[mci->layers[i].type],
65 dimm->location[i]);
66 p += n;
67 len -= n;
68 count += n;
69 if (!len)
70 break;
71 }
72
73 return count;
74}
75
Alan Coxda9bb1d2006-01-18 17:44:13 -080076#ifdef CONFIG_EDAC_DEBUG
77
Mauro Carvalho Chehaba4b4be32012-01-27 10:26:13 -030078static void edac_mc_dump_channel(struct rank_info *chan)
Alan Coxda9bb1d2006-01-18 17:44:13 -080079{
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030080 edac_dbg(4, " channel->chan_idx = %d\n", chan->chan_idx);
81 edac_dbg(4, " channel = %p\n", chan);
82 edac_dbg(4, " channel->csrow = %p\n", chan->csrow);
83 edac_dbg(4, " channel->dimm = %p\n", chan->dimm);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -030084}
85
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030086static void edac_mc_dump_dimm(struct dimm_info *dimm, int number)
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -030087{
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030088 char location[80];
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -030089
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030090 edac_dimm_info_location(dimm, location, sizeof(location));
91
92 edac_dbg(4, "%s%i: %smapped as virtual row %d, chan %d\n",
Mauro Carvalho Chehab9713fae2013-03-11 09:28:48 -030093 dimm->mci->csbased ? "rank" : "dimm",
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -030094 number, location, dimm->csrow, dimm->cschannel);
95 edac_dbg(4, " dimm = %p\n", dimm);
96 edac_dbg(4, " dimm->label = '%s'\n", dimm->label);
97 edac_dbg(4, " dimm->nr_pages = 0x%x\n", dimm->nr_pages);
98 edac_dbg(4, " dimm->grain = %d\n", dimm->grain);
99 edac_dbg(4, " dimm->nr_pages = 0x%x\n", dimm->nr_pages);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800100}
101
Adrian Bunk2da1c112007-07-19 01:49:32 -0700102static void edac_mc_dump_csrow(struct csrow_info *csrow)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800103{
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -0300104 edac_dbg(4, "csrow->csrow_idx = %d\n", csrow->csrow_idx);
105 edac_dbg(4, " csrow = %p\n", csrow);
106 edac_dbg(4, " csrow->first_page = 0x%lx\n", csrow->first_page);
107 edac_dbg(4, " csrow->last_page = 0x%lx\n", csrow->last_page);
108 edac_dbg(4, " csrow->page_mask = 0x%lx\n", csrow->page_mask);
109 edac_dbg(4, " csrow->nr_channels = %d\n", csrow->nr_channels);
110 edac_dbg(4, " csrow->channels = %p\n", csrow->channels);
111 edac_dbg(4, " csrow->mci = %p\n", csrow->mci);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800112}
113
Adrian Bunk2da1c112007-07-19 01:49:32 -0700114static void edac_mc_dump_mci(struct mem_ctl_info *mci)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800115{
Joe Perches956b9ba2012-04-29 17:08:39 -0300116 edac_dbg(3, "\tmci = %p\n", mci);
117 edac_dbg(3, "\tmci->mtype_cap = %lx\n", mci->mtype_cap);
118 edac_dbg(3, "\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap);
119 edac_dbg(3, "\tmci->edac_cap = %lx\n", mci->edac_cap);
120 edac_dbg(4, "\tmci->edac_check = %p\n", mci->edac_check);
121 edac_dbg(3, "\tmci->nr_csrows = %d, csrows = %p\n",
122 mci->nr_csrows, mci->csrows);
123 edac_dbg(3, "\tmci->nr_dimms = %d, dimms = %p\n",
124 mci->tot_dimms, mci->dimms);
125 edac_dbg(3, "\tdev = %p\n", mci->pdev);
126 edac_dbg(3, "\tmod_name:ctl_name = %s:%s\n",
127 mci->mod_name, mci->ctl_name);
128 edac_dbg(3, "\tpvt_info = %p\n\n", mci->pvt_info);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800129}
130
Borislav Petkov24f9a7f2010-10-07 18:29:15 +0200131#endif /* CONFIG_EDAC_DEBUG */
132
Borislav Petkovf4ce6ec2014-08-13 23:27:55 +0200133const char * const edac_mem_types[] = {
Borislav Petkov4cfc3a42014-09-30 20:38:54 +0200134 [MEM_EMPTY] = "Empty csrow",
135 [MEM_RESERVED] = "Reserved csrow type",
136 [MEM_UNKNOWN] = "Unknown csrow type",
137 [MEM_FPM] = "Fast page mode RAM",
138 [MEM_EDO] = "Extended data out RAM",
139 [MEM_BEDO] = "Burst Extended data out RAM",
140 [MEM_SDR] = "Single data rate SDRAM",
141 [MEM_RDR] = "Registered single data rate SDRAM",
142 [MEM_DDR] = "Double data rate SDRAM",
143 [MEM_RDDR] = "Registered Double data rate SDRAM",
144 [MEM_RMBS] = "Rambus DRAM",
145 [MEM_DDR2] = "Unbuffered DDR2 RAM",
146 [MEM_FB_DDR2] = "Fully buffered DDR2",
147 [MEM_RDDR2] = "Registered DDR2 RAM",
148 [MEM_XDR] = "Rambus XDR",
149 [MEM_DDR3] = "Unbuffered DDR3 RAM",
150 [MEM_RDDR3] = "Registered DDR3 RAM",
151 [MEM_LRDDR3] = "Load-Reduced DDR3 RAM",
152 [MEM_DDR4] = "Unbuffered DDR4 RAM",
153 [MEM_RDDR4] = "Registered DDR4 RAM",
Borislav Petkov239642f2009-11-12 15:33:16 +0100154};
155EXPORT_SYMBOL_GPL(edac_mem_types);
156
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300157/**
158 * edac_align_ptr - Prepares the pointer offsets for a single-shot allocation
159 * @p: pointer to a pointer with the memory offset to be used. At
160 * return, this will be incremented to point to the next offset
161 * @size: Size of the data structure to be reserved
162 * @n_elems: Number of elements that should be reserved
Alan Coxda9bb1d2006-01-18 17:44:13 -0800163 *
164 * If 'size' is a constant, the compiler will optimize this whole function
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300165 * down to either a no-op or the addition of a constant to the value of '*p'.
166 *
167 * The 'p' pointer is absolutely needed to keep the proper advancing
168 * further in memory to the proper offsets when allocating the struct along
169 * with its embedded structs, as edac_device_alloc_ctl_info() does it
170 * above, for example.
171 *
172 * At return, the pointer 'p' will be incremented to be used on a next call
173 * to this function.
Alan Coxda9bb1d2006-01-18 17:44:13 -0800174 */
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300175void *edac_align_ptr(void **p, unsigned size, int n_elems)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800176{
177 unsigned align, r;
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300178 void *ptr = *p;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800179
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300180 *p += size * n_elems;
181
182 /*
183 * 'p' can possibly be an unaligned item X such that sizeof(X) is
184 * 'size'. Adjust 'p' so that its alignment is at least as
185 * stringent as what the compiler would provide for X and return
186 * the aligned result.
187 * Here we assume that the alignment of a "long long" is the most
Alan Coxda9bb1d2006-01-18 17:44:13 -0800188 * stringent alignment that the compiler will ever provide by default.
189 * As far as I know, this is a reasonable assumption.
190 */
191 if (size > sizeof(long))
192 align = sizeof(long long);
193 else if (size > sizeof(int))
194 align = sizeof(long);
195 else if (size > sizeof(short))
196 align = sizeof(int);
197 else if (size > sizeof(char))
198 align = sizeof(short);
199 else
Douglas Thompson079708b2007-07-19 01:49:58 -0700200 return (char *)ptr;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800201
Chris Metcalf8447c4d12012-06-06 13:11:05 -0400202 r = (unsigned long)p % align;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800203
204 if (r == 0)
Douglas Thompson079708b2007-07-19 01:49:58 -0700205 return (char *)ptr;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800206
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300207 *p += align - r;
208
Douglas Thompson7391c6d2007-07-19 01:50:21 -0700209 return (void *)(((unsigned long)ptr) + align - r);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800210}
211
Shaun Ruffellfaa2ad02012-09-22 20:26:38 -0500212static void _edac_mc_free(struct mem_ctl_info *mci)
213{
214 int i, chn, row;
215 struct csrow_info *csr;
216 const unsigned int tot_dimms = mci->tot_dimms;
217 const unsigned int tot_channels = mci->num_cschannel;
218 const unsigned int tot_csrows = mci->nr_csrows;
219
220 if (mci->dimms) {
221 for (i = 0; i < tot_dimms; i++)
222 kfree(mci->dimms[i]);
223 kfree(mci->dimms);
224 }
225 if (mci->csrows) {
226 for (row = 0; row < tot_csrows; row++) {
227 csr = mci->csrows[row];
228 if (csr) {
229 if (csr->channels) {
230 for (chn = 0; chn < tot_channels; chn++)
231 kfree(csr->channels[chn]);
232 kfree(csr->channels);
233 }
234 kfree(csr);
235 }
236 }
237 kfree(mci->csrows);
238 }
239 kfree(mci);
240}
241
Alan Coxda9bb1d2006-01-18 17:44:13 -0800242/**
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300243 * edac_mc_alloc: Allocate and partially fill a struct mem_ctl_info structure
244 * @mc_num: Memory controller number
245 * @n_layers: Number of MC hierarchy layers
246 * layers: Describes each layer as seen by the Memory Controller
247 * @size_pvt: size of private storage needed
248 *
Alan Coxda9bb1d2006-01-18 17:44:13 -0800249 *
250 * Everything is kmalloc'ed as one big chunk - more efficient.
251 * Only can be used if all structures have the same lifetime - otherwise
252 * you have to allocate and initialize your own structures.
253 *
254 * Use edac_mc_free() to free mc structures allocated by this function.
255 *
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300256 * NOTE: drivers handle multi-rank memories in different ways: in some
257 * drivers, one multi-rank memory stick is mapped as one entry, while, in
258 * others, a single multi-rank memory stick would be mapped into several
259 * entries. Currently, this function will allocate multiple struct dimm_info
260 * on such scenarios, as grouping the multiple ranks require drivers change.
261 *
Alan Coxda9bb1d2006-01-18 17:44:13 -0800262 * Returns:
Mauro Carvalho Chehabca0907b2012-05-02 14:37:00 -0300263 * On failure: NULL
264 * On success: struct mem_ctl_info pointer
Alan Coxda9bb1d2006-01-18 17:44:13 -0800265 */
Mauro Carvalho Chehabca0907b2012-05-02 14:37:00 -0300266struct mem_ctl_info *edac_mc_alloc(unsigned mc_num,
267 unsigned n_layers,
268 struct edac_mc_layer *layers,
269 unsigned sz_pvt)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800270{
271 struct mem_ctl_info *mci;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300272 struct edac_mc_layer *layer;
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300273 struct csrow_info *csr;
274 struct rank_info *chan;
Mauro Carvalho Chehaba7d7d2e2012-01-27 14:12:32 -0300275 struct dimm_info *dimm;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300276 u32 *ce_per_layer[EDAC_MAX_LAYERS], *ue_per_layer[EDAC_MAX_LAYERS];
277 unsigned pos[EDAC_MAX_LAYERS];
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300278 unsigned size, tot_dimms = 1, count = 1;
279 unsigned tot_csrows = 1, tot_channels = 1, tot_errcount = 0;
Mauro Carvalho Chehab5926ff52012-02-09 11:05:20 -0300280 void *pvt, *p, *ptr = NULL;
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300281 int i, j, row, chn, n, len, off;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300282 bool per_rank = false;
283
284 BUG_ON(n_layers > EDAC_MAX_LAYERS || n_layers == 0);
285 /*
286 * Calculate the total amount of dimms and csrows/cschannels while
287 * in the old API emulation mode
288 */
289 for (i = 0; i < n_layers; i++) {
290 tot_dimms *= layers[i].size;
291 if (layers[i].is_virt_csrow)
292 tot_csrows *= layers[i].size;
293 else
294 tot_channels *= layers[i].size;
295
296 if (layers[i].type == EDAC_MC_LAYER_CHIP_SELECT)
297 per_rank = true;
298 }
Alan Coxda9bb1d2006-01-18 17:44:13 -0800299
300 /* Figure out the offsets of the various items from the start of an mc
301 * structure. We want the alignment of each item to be at least as
302 * stringent as what the compiler would provide if we could simply
303 * hardcode everything into a single struct.
304 */
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300305 mci = edac_align_ptr(&ptr, sizeof(*mci), 1);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300306 layer = edac_align_ptr(&ptr, sizeof(*layer), n_layers);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300307 for (i = 0; i < n_layers; i++) {
308 count *= layers[i].size;
Joe Perches956b9ba2012-04-29 17:08:39 -0300309 edac_dbg(4, "errcount layer %d size %d\n", i, count);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300310 ce_per_layer[i] = edac_align_ptr(&ptr, sizeof(u32), count);
311 ue_per_layer[i] = edac_align_ptr(&ptr, sizeof(u32), count);
312 tot_errcount += 2 * count;
313 }
314
Joe Perches956b9ba2012-04-29 17:08:39 -0300315 edac_dbg(4, "allocating %d error counters\n", tot_errcount);
Mauro Carvalho Chehab93e4fe62012-04-16 10:18:12 -0300316 pvt = edac_align_ptr(&ptr, sz_pvt, 1);
Douglas Thompson079708b2007-07-19 01:49:58 -0700317 size = ((unsigned long)pvt) + sz_pvt;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800318
Joe Perches956b9ba2012-04-29 17:08:39 -0300319 edac_dbg(1, "allocating %u bytes for mci data (%d %s, %d csrows/channels)\n",
320 size,
321 tot_dimms,
322 per_rank ? "ranks" : "dimms",
323 tot_csrows * tot_channels);
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300324
Doug Thompson8096cfa2007-07-19 01:50:27 -0700325 mci = kzalloc(size, GFP_KERNEL);
326 if (mci == NULL)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800327 return NULL;
328
329 /* Adjust pointers so they point within the memory we just allocated
330 * rather than an imaginary chunk of memory located at address 0.
331 */
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300332 layer = (struct edac_mc_layer *)(((char *)mci) + ((unsigned long)layer));
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300333 for (i = 0; i < n_layers; i++) {
334 mci->ce_per_layer[i] = (u32 *)((char *)mci + ((unsigned long)ce_per_layer[i]));
335 mci->ue_per_layer[i] = (u32 *)((char *)mci + ((unsigned long)ue_per_layer[i]));
336 }
Douglas Thompson079708b2007-07-19 01:49:58 -0700337 pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800338
Doug Thompsonb8f6f972007-07-19 01:50:26 -0700339 /* setup index and various internal pointers */
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300340 mci->mc_idx = mc_num;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300341 mci->tot_dimms = tot_dimms;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800342 mci->pvt_info = pvt;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300343 mci->n_layers = n_layers;
344 mci->layers = layer;
345 memcpy(mci->layers, layers, sizeof(*layer) * n_layers);
346 mci->nr_csrows = tot_csrows;
347 mci->num_cschannel = tot_channels;
Mauro Carvalho Chehab9713fae2013-03-11 09:28:48 -0300348 mci->csbased = per_rank;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800349
Mauro Carvalho Chehaba7d7d2e2012-01-27 14:12:32 -0300350 /*
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300351 * Alocate and fill the csrow/channels structs
Mauro Carvalho Chehaba7d7d2e2012-01-27 14:12:32 -0300352 */
Joe Perchesd3d09e12013-01-26 11:24:00 -0800353 mci->csrows = kcalloc(tot_csrows, sizeof(*mci->csrows), GFP_KERNEL);
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300354 if (!mci->csrows)
355 goto error;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300356 for (row = 0; row < tot_csrows; row++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300357 csr = kzalloc(sizeof(**mci->csrows), GFP_KERNEL);
358 if (!csr)
359 goto error;
360 mci->csrows[row] = csr;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300361 csr->csrow_idx = row;
362 csr->mci = mci;
363 csr->nr_channels = tot_channels;
Joe Perchesd3d09e12013-01-26 11:24:00 -0800364 csr->channels = kcalloc(tot_channels, sizeof(*csr->channels),
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300365 GFP_KERNEL);
366 if (!csr->channels)
367 goto error;
Mauro Carvalho Chehaba7d7d2e2012-01-27 14:12:32 -0300368
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300369 for (chn = 0; chn < tot_channels; chn++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300370 chan = kzalloc(sizeof(**csr->channels), GFP_KERNEL);
371 if (!chan)
372 goto error;
373 csr->channels[chn] = chan;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800374 chan->chan_idx = chn;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300375 chan->csrow = csr;
376 }
377 }
Mauro Carvalho Chehaba7d7d2e2012-01-27 14:12:32 -0300378
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300379 /*
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300380 * Allocate and fill the dimm structs
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300381 */
Joe Perchesd3d09e12013-01-26 11:24:00 -0800382 mci->dimms = kcalloc(tot_dimms, sizeof(*mci->dimms), GFP_KERNEL);
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300383 if (!mci->dimms)
384 goto error;
385
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300386 memset(&pos, 0, sizeof(pos));
387 row = 0;
388 chn = 0;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300389 for (i = 0; i < tot_dimms; i++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300390 chan = mci->csrows[row]->channels[chn];
391 off = EDAC_DIMM_OFF(layer, n_layers, pos[0], pos[1], pos[2]);
392 if (off < 0 || off >= tot_dimms) {
393 edac_mc_printk(mci, KERN_ERR, "EDAC core bug: EDAC_DIMM_OFF is trying to do an illegal data access\n");
394 goto error;
395 }
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300396
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300397 dimm = kzalloc(sizeof(**mci->dimms), GFP_KERNEL);
Dan Carpenter08a4a132012-05-18 15:51:02 +0300398 if (!dimm)
399 goto error;
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300400 mci->dimms[off] = dimm;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300401 dimm->mci = mci;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300402
Mauro Carvalho Chehab5926ff52012-02-09 11:05:20 -0300403 /*
404 * Copy DIMM location and initialize it.
405 */
406 len = sizeof(dimm->label);
407 p = dimm->label;
408 n = snprintf(p, len, "mc#%u", mc_num);
409 p += n;
410 len -= n;
411 for (j = 0; j < n_layers; j++) {
412 n = snprintf(p, len, "%s#%u",
413 edac_layer_name[layers[j].type],
414 pos[j]);
415 p += n;
416 len -= n;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300417 dimm->location[j] = pos[j];
418
Mauro Carvalho Chehab5926ff52012-02-09 11:05:20 -0300419 if (len <= 0)
420 break;
421 }
422
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300423 /* Link it to the csrows old API data */
424 chan->dimm = dimm;
425 dimm->csrow = row;
426 dimm->cschannel = chn;
427
428 /* Increment csrow location */
Mauro Carvalho Chehab24bef662012-10-24 10:30:01 -0200429 if (layers[0].is_virt_csrow) {
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300430 chn++;
Mauro Carvalho Chehab24bef662012-10-24 10:30:01 -0200431 if (chn == tot_channels) {
432 chn = 0;
433 row++;
434 }
435 } else {
436 row++;
437 if (row == tot_csrows) {
438 row = 0;
439 chn++;
440 }
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300441 }
442
443 /* Increment dimm location */
444 for (j = n_layers - 1; j >= 0; j--) {
445 pos[j]++;
446 if (pos[j] < layers[j].size)
447 break;
448 pos[j] = 0;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800449 }
450 }
451
Dave Jiang81d87cb2007-07-19 01:49:52 -0700452 mci->op_state = OP_ALLOC;
Doug Thompson8096cfa2007-07-19 01:50:27 -0700453
Alan Coxda9bb1d2006-01-18 17:44:13 -0800454 return mci;
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300455
456error:
Shaun Ruffellfaa2ad02012-09-22 20:26:38 -0500457 _edac_mc_free(mci);
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300458
459 return NULL;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800460}
Dave Peterson91105402006-03-26 01:38:55 -0800461EXPORT_SYMBOL_GPL(edac_mc_alloc);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800462
Alan Coxda9bb1d2006-01-18 17:44:13 -0800463/**
Doug Thompson8096cfa2007-07-19 01:50:27 -0700464 * edac_mc_free
465 * 'Free' a previously allocated 'mci' structure
Alan Coxda9bb1d2006-01-18 17:44:13 -0800466 * @mci: pointer to a struct mem_ctl_info structure
Alan Coxda9bb1d2006-01-18 17:44:13 -0800467 */
468void edac_mc_free(struct mem_ctl_info *mci)
469{
Joe Perches956b9ba2012-04-29 17:08:39 -0300470 edac_dbg(1, "\n");
Mauro Carvalho Chehabbbc560a2010-08-16 18:22:43 -0300471
Shaun Ruffellfaa2ad02012-09-22 20:26:38 -0500472 /* If we're not yet registered with sysfs free only what was allocated
473 * in edac_mc_alloc().
474 */
475 if (!device_is_registered(&mci->dev)) {
476 _edac_mc_free(mci);
477 return;
478 }
479
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300480 /* the mci instance is freed here, when the sysfs object is dropped */
Mauro Carvalho Chehab7a623c02012-04-16 16:41:11 -0300481 edac_unregister_sysfs(mci);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800482}
Dave Peterson91105402006-03-26 01:38:55 -0800483EXPORT_SYMBOL_GPL(edac_mc_free);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800484
Doug Thompsonbce19682007-07-26 10:41:14 -0700485
Mauro Carvalho Chehab939747bd2010-08-10 11:22:01 -0300486/**
Doug Thompsonbce19682007-07-26 10:41:14 -0700487 * find_mci_by_dev
488 *
489 * scan list of controllers looking for the one that manages
490 * the 'dev' device
Mauro Carvalho Chehab939747bd2010-08-10 11:22:01 -0300491 * @dev: pointer to a struct device related with the MCI
Doug Thompsonbce19682007-07-26 10:41:14 -0700492 */
Mauro Carvalho Chehab939747bd2010-08-10 11:22:01 -0300493struct mem_ctl_info *find_mci_by_dev(struct device *dev)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800494{
495 struct mem_ctl_info *mci;
496 struct list_head *item;
497
Joe Perches956b9ba2012-04-29 17:08:39 -0300498 edac_dbg(3, "\n");
Alan Coxda9bb1d2006-01-18 17:44:13 -0800499
500 list_for_each(item, &mc_devices) {
501 mci = list_entry(item, struct mem_ctl_info, link);
502
Mauro Carvalho Chehabfd687502012-03-16 07:44:18 -0300503 if (mci->pdev == dev)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800504 return mci;
505 }
506
507 return NULL;
508}
Mauro Carvalho Chehab939747bd2010-08-10 11:22:01 -0300509EXPORT_SYMBOL_GPL(find_mci_by_dev);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800510
Dave Jiang81d87cb2007-07-19 01:49:52 -0700511/*
512 * handler for EDAC to check if NMI type handler has asserted interrupt
513 */
514static int edac_mc_assert_error_check_and_clear(void)
515{
Dave Jiang66ee2f92007-07-19 01:49:54 -0700516 int old_state;
Dave Jiang81d87cb2007-07-19 01:49:52 -0700517
Douglas Thompson079708b2007-07-19 01:49:58 -0700518 if (edac_op_state == EDAC_OPSTATE_POLL)
Dave Jiang81d87cb2007-07-19 01:49:52 -0700519 return 1;
520
Dave Jiang66ee2f92007-07-19 01:49:54 -0700521 old_state = edac_err_assert;
522 edac_err_assert = 0;
Dave Jiang81d87cb2007-07-19 01:49:52 -0700523
Dave Jiang66ee2f92007-07-19 01:49:54 -0700524 return old_state;
Dave Jiang81d87cb2007-07-19 01:49:52 -0700525}
526
527/*
528 * edac_mc_workq_function
529 * performs the operation scheduled by a workq request
530 */
Dave Jiang81d87cb2007-07-19 01:49:52 -0700531static void edac_mc_workq_function(struct work_struct *work_req)
532{
Jean Delvarefbeb4382009-04-13 14:40:21 -0700533 struct delayed_work *d_work = to_delayed_work(work_req);
Dave Jiang81d87cb2007-07-19 01:49:52 -0700534 struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
Dave Jiang81d87cb2007-07-19 01:49:52 -0700535
536 mutex_lock(&mem_ctls_mutex);
537
Borislav Petkov06e912d2016-02-02 11:36:11 +0100538 if (mci->op_state != OP_RUNNING_POLL) {
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700539 mutex_unlock(&mem_ctls_mutex);
540 return;
541 }
542
Borislav Petkov06e912d2016-02-02 11:36:11 +0100543 if (edac_mc_assert_error_check_and_clear())
Dave Jiang81d87cb2007-07-19 01:49:52 -0700544 mci->edac_check(mci);
545
Dave Jiang81d87cb2007-07-19 01:49:52 -0700546 mutex_unlock(&mem_ctls_mutex);
547
Borislav Petkov06e912d2016-02-02 11:36:11 +0100548 /* Queue ourselves again. */
Borislav Petkovc4cf3b42015-11-30 19:02:01 +0100549 edac_queue_work(&mci->work, msecs_to_jiffies(edac_mc_get_poll_msec()));
Dave Jiang81d87cb2007-07-19 01:49:52 -0700550}
551
552/*
Doug Thompsonbce19682007-07-26 10:41:14 -0700553 * edac_mc_reset_delay_period(unsigned long value)
554 *
555 * user space has updated our poll period value, need to
556 * reset our workq delays
Dave Jiang81d87cb2007-07-19 01:49:52 -0700557 */
Borislav Petkov9da21b12014-02-03 15:05:13 -0500558void edac_mc_reset_delay_period(unsigned long value)
Dave Jiang81d87cb2007-07-19 01:49:52 -0700559{
Doug Thompsonbce19682007-07-26 10:41:14 -0700560 struct mem_ctl_info *mci;
561 struct list_head *item;
Dave Jiang81d87cb2007-07-19 01:49:52 -0700562
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700563 mutex_lock(&mem_ctls_mutex);
564
Doug Thompsonbce19682007-07-26 10:41:14 -0700565 list_for_each(item, &mc_devices) {
566 mci = list_entry(item, struct mem_ctl_info, link);
567
Borislav Petkovc4cf3b42015-11-30 19:02:01 +0100568 edac_mod_work(&mci->work, value);
Doug Thompsonbce19682007-07-26 10:41:14 -0700569 }
Dave Jiang81d87cb2007-07-19 01:49:52 -0700570 mutex_unlock(&mem_ctls_mutex);
571}
572
Doug Thompsonbce19682007-07-26 10:41:14 -0700573
574
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700575/* Return 0 on success, 1 on failure.
576 * Before calling this function, caller must
577 * assign a unique value to mci->mc_idx.
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700578 *
579 * locking model:
580 *
581 * called with the mem_ctls_mutex lock held
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700582 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700583static int add_mc_to_global_list(struct mem_ctl_info *mci)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800584{
585 struct list_head *item, *insert_before;
586 struct mem_ctl_info *p;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800587
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700588 insert_before = &mc_devices;
589
Mauro Carvalho Chehabfd687502012-03-16 07:44:18 -0300590 p = find_mci_by_dev(mci->pdev);
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700591 if (unlikely(p != NULL))
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700592 goto fail0;
593
594 list_for_each(item, &mc_devices) {
595 p = list_entry(item, struct mem_ctl_info, link);
596
597 if (p->mc_idx >= mci->mc_idx) {
598 if (unlikely(p->mc_idx == mci->mc_idx))
599 goto fail1;
600
601 insert_before = item;
602 break;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800603 }
Alan Coxda9bb1d2006-01-18 17:44:13 -0800604 }
605
606 list_add_tail_rcu(&mci->link, insert_before);
Dave Jiangc0d12172007-07-19 01:49:46 -0700607 atomic_inc(&edac_handlers);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800608 return 0;
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700609
Douglas Thompson052dfb42007-07-19 01:50:13 -0700610fail0:
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700611 edac_printk(KERN_WARNING, EDAC_MC,
Mauro Carvalho Chehabfd687502012-03-16 07:44:18 -0300612 "%s (%s) %s %s already assigned %d\n", dev_name(p->pdev),
Stephen Rothwell17aa7e02008-05-05 13:54:19 +1000613 edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700614 return 1;
615
Douglas Thompson052dfb42007-07-19 01:50:13 -0700616fail1:
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700617 edac_printk(KERN_WARNING, EDAC_MC,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700618 "bug in low-level driver: attempt to assign\n"
619 " duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700620 return 1;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800621}
622
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300623static int del_mc_from_global_list(struct mem_ctl_info *mci)
Dave Petersona1d03fc2006-03-26 01:38:46 -0800624{
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300625 int handlers = atomic_dec_return(&edac_handlers);
Dave Petersona1d03fc2006-03-26 01:38:46 -0800626 list_del_rcu(&mci->link);
Lai Jiangshane2e77092011-05-26 16:25:58 -0700627
628 /* these are for safe removal of devices from global list while
629 * NMI handlers may be traversing list
630 */
631 synchronize_rcu();
632 INIT_LIST_HEAD(&mci->link);
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300633
634 return handlers;
Dave Petersona1d03fc2006-03-26 01:38:46 -0800635}
636
Alan Coxda9bb1d2006-01-18 17:44:13 -0800637/**
Douglas Thompson5da08312007-07-19 01:49:31 -0700638 * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
639 *
640 * If found, return a pointer to the structure.
641 * Else return NULL.
642 *
643 * Caller must hold mem_ctls_mutex.
644 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700645struct mem_ctl_info *edac_mc_find(int idx)
Douglas Thompson5da08312007-07-19 01:49:31 -0700646{
647 struct list_head *item;
648 struct mem_ctl_info *mci;
649
650 list_for_each(item, &mc_devices) {
651 mci = list_entry(item, struct mem_ctl_info, link);
652
653 if (mci->mc_idx >= idx) {
654 if (mci->mc_idx == idx)
655 return mci;
656
657 break;
658 }
659 }
660
661 return NULL;
662}
663EXPORT_SYMBOL(edac_mc_find);
664
665/**
Takashi Iwai4e8d2302015-02-04 11:48:52 +0100666 * edac_mc_add_mc_with_groups: Insert the 'mci' structure into the mci
667 * global list and create sysfs entries associated with mci structure
Alan Coxda9bb1d2006-01-18 17:44:13 -0800668 * @mci: pointer to the mci structure to be added to the list
Takashi Iwai4e8d2302015-02-04 11:48:52 +0100669 * @groups: optional attribute groups for the driver-specific sysfs entries
Alan Coxda9bb1d2006-01-18 17:44:13 -0800670 *
671 * Return:
672 * 0 Success
673 * !0 Failure
674 */
675
676/* FIXME - should a warning be printed if no error detection? correction? */
Takashi Iwai4e8d2302015-02-04 11:48:52 +0100677int edac_mc_add_mc_with_groups(struct mem_ctl_info *mci,
678 const struct attribute_group **groups)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800679{
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300680 int ret = -EINVAL;
Joe Perches956b9ba2012-04-29 17:08:39 -0300681 edac_dbg(0, "\n");
Doug Thompsonb8f6f972007-07-19 01:50:26 -0700682
Borislav Petkov88d84ac2013-07-19 12:28:25 +0200683 if (mci->mc_idx >= EDAC_MAX_MCS) {
684 pr_warn_once("Too many memory controllers: %d\n", mci->mc_idx);
685 return -ENODEV;
686 }
687
Alan Coxda9bb1d2006-01-18 17:44:13 -0800688#ifdef CONFIG_EDAC_DEBUG
689 if (edac_debug_level >= 3)
690 edac_mc_dump_mci(mci);
Dave Petersone7ecd892006-03-26 01:38:52 -0800691
Alan Coxda9bb1d2006-01-18 17:44:13 -0800692 if (edac_debug_level >= 4) {
693 int i;
694
695 for (i = 0; i < mci->nr_csrows; i++) {
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -0300696 struct csrow_info *csrow = mci->csrows[i];
697 u32 nr_pages = 0;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800698 int j;
Dave Petersone7ecd892006-03-26 01:38:52 -0800699
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -0300700 for (j = 0; j < csrow->nr_channels; j++)
701 nr_pages += csrow->channels[j]->dimm->nr_pages;
702 if (!nr_pages)
703 continue;
704 edac_mc_dump_csrow(csrow);
705 for (j = 0; j < csrow->nr_channels; j++)
706 if (csrow->channels[j]->dimm->nr_pages)
707 edac_mc_dump_channel(csrow->channels[j]);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800708 }
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300709 for (i = 0; i < mci->tot_dimms; i++)
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -0300710 if (mci->dimms[i]->nr_pages)
711 edac_mc_dump_dimm(mci->dimms[i], i);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800712 }
713#endif
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700714 mutex_lock(&mem_ctls_mutex);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800715
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300716 if (edac_mc_owner && edac_mc_owner != mci->mod_name) {
717 ret = -EPERM;
718 goto fail0;
719 }
720
Alan Coxda9bb1d2006-01-18 17:44:13 -0800721 if (add_mc_to_global_list(mci))
Dave Peterson028a7b62006-03-26 01:38:47 -0800722 goto fail0;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800723
724 /* set load time so that error rate can be tracked */
725 mci->start_time = jiffies;
726
Borislav Petkov88d84ac2013-07-19 12:28:25 +0200727 mci->bus = &mc_bus[mci->mc_idx];
728
Takashi Iwai4e8d2302015-02-04 11:48:52 +0100729 if (edac_create_sysfs_mci_device(mci, groups)) {
eric wollesen9794f332007-02-12 00:53:08 -0800730 edac_mc_printk(mci, KERN_WARNING,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700731 "failed to create sysfs device\n");
eric wollesen9794f332007-02-12 00:53:08 -0800732 goto fail1;
733 }
Alan Coxda9bb1d2006-01-18 17:44:13 -0800734
Borislav Petkov09667602016-02-02 10:59:53 +0100735 if (mci->edac_check) {
Dave Jiang81d87cb2007-07-19 01:49:52 -0700736 mci->op_state = OP_RUNNING_POLL;
737
Borislav Petkov626a7a42016-02-02 11:06:41 +0100738 INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
739 edac_queue_work(&mci->work, msecs_to_jiffies(edac_mc_get_poll_msec()));
740
Dave Jiang81d87cb2007-07-19 01:49:52 -0700741 } else {
742 mci->op_state = OP_RUNNING_INTERRUPT;
743 }
744
Alan Coxda9bb1d2006-01-18 17:44:13 -0800745 /* Report action taken */
Robert Richter7270a602013-10-10 18:22:36 +0200746 edac_mc_printk(mci, KERN_INFO,
747 "Giving out device to module %s controller %s: DEV %s (%s)\n",
748 mci->mod_name, mci->ctl_name, mci->dev_name,
749 edac_op_state_to_string(mci->op_state));
Alan Coxda9bb1d2006-01-18 17:44:13 -0800750
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300751 edac_mc_owner = mci->mod_name;
752
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700753 mutex_unlock(&mem_ctls_mutex);
Dave Peterson028a7b62006-03-26 01:38:47 -0800754 return 0;
755
Douglas Thompson052dfb42007-07-19 01:50:13 -0700756fail1:
Dave Peterson028a7b62006-03-26 01:38:47 -0800757 del_mc_from_global_list(mci);
758
Douglas Thompson052dfb42007-07-19 01:50:13 -0700759fail0:
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700760 mutex_unlock(&mem_ctls_mutex);
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300761 return ret;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800762}
Takashi Iwai4e8d2302015-02-04 11:48:52 +0100763EXPORT_SYMBOL_GPL(edac_mc_add_mc_with_groups);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800764
Alan Coxda9bb1d2006-01-18 17:44:13 -0800765/**
Dave Peterson472678e2006-03-26 01:38:49 -0800766 * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
767 * remove mci structure from global list
Doug Thompson37f04582006-06-30 01:56:07 -0700768 * @pdev: Pointer to 'struct device' representing mci structure to remove.
Alan Coxda9bb1d2006-01-18 17:44:13 -0800769 *
Dave Peterson18dbc332006-03-26 01:38:50 -0800770 * Return pointer to removed mci structure, or NULL if device not found.
Alan Coxda9bb1d2006-01-18 17:44:13 -0800771 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700772struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800773{
Dave Peterson18dbc332006-03-26 01:38:50 -0800774 struct mem_ctl_info *mci;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800775
Joe Perches956b9ba2012-04-29 17:08:39 -0300776 edac_dbg(0, "\n");
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700777
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700778 mutex_lock(&mem_ctls_mutex);
Dave Peterson18dbc332006-03-26 01:38:50 -0800779
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700780 /* find the requested mci struct in the global list */
781 mci = find_mci_by_dev(dev);
782 if (mci == NULL) {
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700783 mutex_unlock(&mem_ctls_mutex);
Dave Peterson18dbc332006-03-26 01:38:50 -0800784 return NULL;
785 }
786
Borislav Petkov09667602016-02-02 10:59:53 +0100787 /* mark MCI offline: */
788 mci->op_state = OP_OFFLINE;
789
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300790 if (!del_mc_from_global_list(mci))
791 edac_mc_owner = NULL;
Borislav Petkov09667602016-02-02 10:59:53 +0100792
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700793 mutex_unlock(&mem_ctls_mutex);
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700794
Borislav Petkov09667602016-02-02 10:59:53 +0100795 if (mci->edac_check)
Borislav Petkov626a7a42016-02-02 11:06:41 +0100796 edac_stop_work(&mci->work);
Borislav Petkovbb31b3122010-12-02 17:48:35 +0100797
798 /* remove from sysfs */
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700799 edac_remove_sysfs_mci_device(mci);
800
Dave Peterson537fba22006-03-26 01:38:40 -0800801 edac_printk(KERN_INFO, EDAC_MC,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700802 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
Stephen Rothwell17aa7e02008-05-05 13:54:19 +1000803 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700804
Dave Peterson18dbc332006-03-26 01:38:50 -0800805 return mci;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800806}
Dave Peterson91105402006-03-26 01:38:55 -0800807EXPORT_SYMBOL_GPL(edac_mc_del_mc);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800808
Adrian Bunk2da1c112007-07-19 01:49:32 -0700809static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
810 u32 size)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800811{
812 struct page *pg;
813 void *virt_addr;
814 unsigned long flags = 0;
815
Joe Perches956b9ba2012-04-29 17:08:39 -0300816 edac_dbg(3, "\n");
Alan Coxda9bb1d2006-01-18 17:44:13 -0800817
818 /* ECC error page was not in our memory. Ignore it. */
Douglas Thompson079708b2007-07-19 01:49:58 -0700819 if (!pfn_valid(page))
Alan Coxda9bb1d2006-01-18 17:44:13 -0800820 return;
821
822 /* Find the actual page structure then map it and fix */
823 pg = pfn_to_page(page);
824
825 if (PageHighMem(pg))
826 local_irq_save(flags);
827
Cong Wang4e5df7c2011-11-25 23:14:19 +0800828 virt_addr = kmap_atomic(pg);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800829
830 /* Perform architecture specific atomic scrub operation */
Borislav Petkovb01aec92015-05-21 19:59:31 +0200831 edac_atomic_scrub(virt_addr + offset, size);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800832
833 /* Unmap and complete */
Cong Wang4e5df7c2011-11-25 23:14:19 +0800834 kunmap_atomic(virt_addr);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800835
836 if (PageHighMem(pg))
837 local_irq_restore(flags);
838}
839
Alan Coxda9bb1d2006-01-18 17:44:13 -0800840/* FIXME - should return -1 */
Dave Petersone7ecd892006-03-26 01:38:52 -0800841int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800842{
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300843 struct csrow_info **csrows = mci->csrows;
Mauro Carvalho Chehaba895bf82012-01-28 09:09:38 -0300844 int row, i, j, n;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800845
Joe Perches956b9ba2012-04-29 17:08:39 -0300846 edac_dbg(1, "MC%d: 0x%lx\n", mci->mc_idx, page);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800847 row = -1;
848
849 for (i = 0; i < mci->nr_csrows; i++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300850 struct csrow_info *csrow = csrows[i];
Mauro Carvalho Chehaba895bf82012-01-28 09:09:38 -0300851 n = 0;
852 for (j = 0; j < csrow->nr_channels; j++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300853 struct dimm_info *dimm = csrow->channels[j]->dimm;
Mauro Carvalho Chehaba895bf82012-01-28 09:09:38 -0300854 n += dimm->nr_pages;
855 }
856 if (n == 0)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800857 continue;
858
Joe Perches956b9ba2012-04-29 17:08:39 -0300859 edac_dbg(3, "MC%d: first(0x%lx) page(0x%lx) last(0x%lx) mask(0x%lx)\n",
860 mci->mc_idx,
861 csrow->first_page, page, csrow->last_page,
862 csrow->page_mask);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800863
864 if ((page >= csrow->first_page) &&
865 (page <= csrow->last_page) &&
866 ((page & csrow->page_mask) ==
867 (csrow->first_page & csrow->page_mask))) {
868 row = i;
869 break;
870 }
871 }
872
873 if (row == -1)
Dave Peterson537fba22006-03-26 01:38:40 -0800874 edac_mc_printk(mci, KERN_ERR,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700875 "could not look up page error address %lx\n",
876 (unsigned long)page);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800877
878 return row;
879}
Dave Peterson91105402006-03-26 01:38:55 -0800880EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800881
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300882const char *edac_layer_name[] = {
883 [EDAC_MC_LAYER_BRANCH] = "branch",
884 [EDAC_MC_LAYER_CHANNEL] = "channel",
885 [EDAC_MC_LAYER_SLOT] = "slot",
886 [EDAC_MC_LAYER_CHIP_SELECT] = "csrow",
Mauro Carvalho Chehabc66b5a72013-02-15 07:21:08 -0300887 [EDAC_MC_LAYER_ALL_MEM] = "memory",
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300888};
889EXPORT_SYMBOL_GPL(edac_layer_name);
890
891static void edac_inc_ce_error(struct mem_ctl_info *mci,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300892 bool enable_per_layer_report,
893 const int pos[EDAC_MAX_LAYERS],
894 const u16 count)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800895{
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300896 int i, index = 0;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800897
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300898 mci->ce_mc += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300899
900 if (!enable_per_layer_report) {
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300901 mci->ce_noinfo_count += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300902 return;
903 }
904
905 for (i = 0; i < mci->n_layers; i++) {
906 if (pos[i] < 0)
907 break;
908 index += pos[i];
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300909 mci->ce_per_layer[i][index] += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300910
911 if (i < mci->n_layers - 1)
912 index *= mci->layers[i + 1].size;
913 }
914}
915
916static void edac_inc_ue_error(struct mem_ctl_info *mci,
917 bool enable_per_layer_report,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300918 const int pos[EDAC_MAX_LAYERS],
919 const u16 count)
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300920{
921 int i, index = 0;
922
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300923 mci->ue_mc += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300924
925 if (!enable_per_layer_report) {
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300926 mci->ce_noinfo_count += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300927 return;
928 }
929
930 for (i = 0; i < mci->n_layers; i++) {
931 if (pos[i] < 0)
932 break;
933 index += pos[i];
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300934 mci->ue_per_layer[i][index] += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300935
936 if (i < mci->n_layers - 1)
937 index *= mci->layers[i + 1].size;
938 }
939}
940
941static void edac_ce_error(struct mem_ctl_info *mci,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300942 const u16 error_count,
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300943 const int pos[EDAC_MAX_LAYERS],
944 const char *msg,
945 const char *location,
946 const char *label,
947 const char *detail,
948 const char *other_detail,
949 const bool enable_per_layer_report,
950 const unsigned long page_frame_number,
951 const unsigned long offset_in_page,
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -0300952 long grain)
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300953{
954 unsigned long remapped_page;
Borislav Petkovf430d572012-09-10 18:36:09 +0200955 char *msg_aux = "";
956
957 if (*msg)
958 msg_aux = " ";
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300959
960 if (edac_mc_get_log_ce()) {
961 if (other_detail && *other_detail)
962 edac_mc_printk(mci, KERN_WARNING,
Borislav Petkovf430d572012-09-10 18:36:09 +0200963 "%d CE %s%son %s (%s %s - %s)\n",
964 error_count, msg, msg_aux, label,
965 location, detail, other_detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300966 else
967 edac_mc_printk(mci, KERN_WARNING,
Borislav Petkovf430d572012-09-10 18:36:09 +0200968 "%d CE %s%son %s (%s %s)\n",
969 error_count, msg, msg_aux, label,
970 location, detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300971 }
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300972 edac_inc_ce_error(mci, enable_per_layer_report, pos, error_count);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800973
Loc Hoaa2064d2014-05-08 17:03:16 -0600974 if (mci->scrub_mode == SCRUB_SW_SRC) {
Alan Coxda9bb1d2006-01-18 17:44:13 -0800975 /*
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300976 * Some memory controllers (called MCs below) can remap
977 * memory so that it is still available at a different
978 * address when PCI devices map into memory.
979 * MC's that can't do this, lose the memory where PCI
980 * devices are mapped. This mapping is MC-dependent
981 * and so we call back into the MC driver for it to
982 * map the MC page to a physical (CPU) page which can
983 * then be mapped to a virtual page - which can then
984 * be scrubbed.
985 */
Alan Coxda9bb1d2006-01-18 17:44:13 -0800986 remapped_page = mci->ctl_page_to_phys ?
Douglas Thompson052dfb42007-07-19 01:50:13 -0700987 mci->ctl_page_to_phys(mci, page_frame_number) :
988 page_frame_number;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800989
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300990 edac_mc_scrub_block(remapped_page,
991 offset_in_page, grain);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800992 }
993}
994
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300995static void edac_ue_error(struct mem_ctl_info *mci,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300996 const u16 error_count,
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300997 const int pos[EDAC_MAX_LAYERS],
998 const char *msg,
999 const char *location,
1000 const char *label,
1001 const char *detail,
1002 const char *other_detail,
1003 const bool enable_per_layer_report)
Alan Coxda9bb1d2006-01-18 17:44:13 -08001004{
Borislav Petkovf430d572012-09-10 18:36:09 +02001005 char *msg_aux = "";
1006
1007 if (*msg)
1008 msg_aux = " ";
1009
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001010 if (edac_mc_get_log_ue()) {
1011 if (other_detail && *other_detail)
1012 edac_mc_printk(mci, KERN_WARNING,
Borislav Petkovf430d572012-09-10 18:36:09 +02001013 "%d UE %s%son %s (%s %s - %s)\n",
1014 error_count, msg, msg_aux, label,
1015 location, detail, other_detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001016 else
1017 edac_mc_printk(mci, KERN_WARNING,
Borislav Petkovf430d572012-09-10 18:36:09 +02001018 "%d UE %s%son %s (%s %s)\n",
1019 error_count, msg, msg_aux, label,
1020 location, detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001021 }
Dave Petersone7ecd892006-03-26 01:38:52 -08001022
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001023 if (edac_mc_get_panic_on_ue()) {
1024 if (other_detail && *other_detail)
Borislav Petkovf430d572012-09-10 18:36:09 +02001025 panic("UE %s%son %s (%s%s - %s)\n",
1026 msg, msg_aux, label, location, detail, other_detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001027 else
Borislav Petkovf430d572012-09-10 18:36:09 +02001028 panic("UE %s%son %s (%s%s)\n",
1029 msg, msg_aux, label, location, detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001030 }
1031
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001032 edac_inc_ue_error(mci, enable_per_layer_report, pos, error_count);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001033}
1034
Mauro Carvalho Chehabe7e24832012-10-31 13:46:11 -03001035/**
1036 * edac_raw_mc_handle_error - reports a memory event to userspace without doing
1037 * anything to discover the error location
1038 *
1039 * @type: severity of the error (CE/UE/Fatal)
1040 * @mci: a struct mem_ctl_info pointer
1041 * @e: error description
1042 *
1043 * This raw function is used internally by edac_mc_handle_error(). It should
1044 * only be called directly when the hardware error come directly from BIOS,
1045 * like in the case of APEI GHES driver.
1046 */
1047void edac_raw_mc_handle_error(const enum hw_event_mc_err_type type,
1048 struct mem_ctl_info *mci,
1049 struct edac_raw_error_desc *e)
1050{
1051 char detail[80];
1052 int pos[EDAC_MAX_LAYERS] = { e->top_layer, e->mid_layer, e->low_layer };
1053
1054 /* Memory type dependent details about the error */
1055 if (type == HW_EVENT_ERR_CORRECTED) {
1056 snprintf(detail, sizeof(detail),
1057 "page:0x%lx offset:0x%lx grain:%ld syndrome:0x%lx",
1058 e->page_frame_number, e->offset_in_page,
1059 e->grain, e->syndrome);
1060 edac_ce_error(mci, e->error_count, pos, e->msg, e->location, e->label,
1061 detail, e->other_detail, e->enable_per_layer_report,
1062 e->page_frame_number, e->offset_in_page, e->grain);
1063 } else {
1064 snprintf(detail, sizeof(detail),
1065 "page:0x%lx offset:0x%lx grain:%ld",
1066 e->page_frame_number, e->offset_in_page, e->grain);
1067
1068 edac_ue_error(mci, e->error_count, pos, e->msg, e->location, e->label,
1069 detail, e->other_detail, e->enable_per_layer_report);
1070 }
1071
1072
1073}
1074EXPORT_SYMBOL_GPL(edac_raw_mc_handle_error);
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001075
1076/**
1077 * edac_mc_handle_error - reports a memory event to userspace
1078 *
1079 * @type: severity of the error (CE/UE/Fatal)
1080 * @mci: a struct mem_ctl_info pointer
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001081 * @error_count: Number of errors of the same type
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001082 * @page_frame_number: mem page where the error occurred
1083 * @offset_in_page: offset of the error inside the page
1084 * @syndrome: ECC syndrome
1085 * @top_layer: Memory layer[0] position
1086 * @mid_layer: Memory layer[1] position
1087 * @low_layer: Memory layer[2] position
1088 * @msg: Message meaningful to the end users that
1089 * explains the event
1090 * @other_detail: Technical details about the event that
1091 * may help hardware manufacturers and
1092 * EDAC developers to analyse the event
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001093 */
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001094void edac_mc_handle_error(const enum hw_event_mc_err_type type,
1095 struct mem_ctl_info *mci,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001096 const u16 error_count,
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001097 const unsigned long page_frame_number,
1098 const unsigned long offset_in_page,
1099 const unsigned long syndrome,
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001100 const int top_layer,
1101 const int mid_layer,
1102 const int low_layer,
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001103 const char *msg,
Mauro Carvalho Chehab03f7eae2012-06-04 11:29:25 -03001104 const char *other_detail)
Alan Coxda9bb1d2006-01-18 17:44:13 -08001105{
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001106 char *p;
1107 int row = -1, chan = -1;
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001108 int pos[EDAC_MAX_LAYERS] = { top_layer, mid_layer, low_layer };
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001109 int i, n_labels = 0;
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001110 u8 grain_bits;
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001111 struct edac_raw_error_desc *e = &mci->error_desc;
Alan Coxda9bb1d2006-01-18 17:44:13 -08001112
Joe Perches956b9ba2012-04-29 17:08:39 -03001113 edac_dbg(3, "MC%d\n", mci->mc_idx);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001114
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001115 /* Fills the error report buffer */
1116 memset(e, 0, sizeof (*e));
1117 e->error_count = error_count;
1118 e->top_layer = top_layer;
1119 e->mid_layer = mid_layer;
1120 e->low_layer = low_layer;
1121 e->page_frame_number = page_frame_number;
1122 e->offset_in_page = offset_in_page;
1123 e->syndrome = syndrome;
1124 e->msg = msg;
1125 e->other_detail = other_detail;
1126
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001127 /*
1128 * Check if the event report is consistent and if the memory
1129 * location is known. If it is known, enable_per_layer_report will be
1130 * true, the DIMM(s) label info will be filled and the per-layer
1131 * error counters will be incremented.
1132 */
1133 for (i = 0; i < mci->n_layers; i++) {
1134 if (pos[i] >= (int)mci->layers[i].size) {
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001135
1136 edac_mc_printk(mci, KERN_ERR,
1137 "INTERNAL ERROR: %s value is out of range (%d >= %d)\n",
1138 edac_layer_name[mci->layers[i].type],
1139 pos[i], mci->layers[i].size);
1140 /*
1141 * Instead of just returning it, let's use what's
1142 * known about the error. The increment routines and
1143 * the DIMM filter logic will do the right thing by
1144 * pointing the likely damaged DIMMs.
1145 */
1146 pos[i] = -1;
1147 }
1148 if (pos[i] >= 0)
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001149 e->enable_per_layer_report = true;
Alan Coxda9bb1d2006-01-18 17:44:13 -08001150 }
1151
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001152 /*
1153 * Get the dimm label/grain that applies to the match criteria.
1154 * As the error algorithm may not be able to point to just one memory
1155 * stick, the logic here will get all possible labels that could
1156 * pottentially be affected by the error.
1157 * On FB-DIMM memory controllers, for uncorrected errors, it is common
1158 * to have only the MC channel and the MC dimm (also called "branch")
1159 * but the channel is not known, as the memory is arranged in pairs,
1160 * where each memory belongs to a separate channel within the same
1161 * branch.
1162 */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001163 p = e->label;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001164 *p = '\0';
Borislav Petkov4da1b7b2012-09-10 17:57:44 +02001165
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001166 for (i = 0; i < mci->tot_dimms; i++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -03001167 struct dimm_info *dimm = mci->dimms[i];
Dave Petersone7ecd892006-03-26 01:38:52 -08001168
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001169 if (top_layer >= 0 && top_layer != dimm->location[0])
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001170 continue;
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001171 if (mid_layer >= 0 && mid_layer != dimm->location[1])
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001172 continue;
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001173 if (low_layer >= 0 && low_layer != dimm->location[2])
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001174 continue;
1175
1176 /* get the max grain, over the error match range */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001177 if (dimm->grain > e->grain)
1178 e->grain = dimm->grain;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001179
1180 /*
1181 * If the error is memory-controller wide, there's no need to
1182 * seek for the affected DIMMs because the whole
1183 * channel/memory controller/... may be affected.
1184 * Also, don't show errors for empty DIMM slots.
1185 */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001186 if (e->enable_per_layer_report && dimm->nr_pages) {
1187 if (n_labels >= EDAC_MAX_LABELS) {
1188 e->enable_per_layer_report = false;
1189 break;
1190 }
1191 n_labels++;
1192 if (p != e->label) {
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001193 strcpy(p, OTHER_LABEL);
1194 p += strlen(OTHER_LABEL);
1195 }
1196 strcpy(p, dimm->label);
1197 p += strlen(p);
1198 *p = '\0';
1199
1200 /*
1201 * get csrow/channel of the DIMM, in order to allow
1202 * incrementing the compat API counters
1203 */
Joe Perches956b9ba2012-04-29 17:08:39 -03001204 edac_dbg(4, "%s csrows map: (%d,%d)\n",
Mauro Carvalho Chehab9713fae2013-03-11 09:28:48 -03001205 mci->csbased ? "rank" : "dimm",
Joe Perches956b9ba2012-04-29 17:08:39 -03001206 dimm->csrow, dimm->cschannel);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001207 if (row == -1)
1208 row = dimm->csrow;
1209 else if (row >= 0 && row != dimm->csrow)
1210 row = -2;
1211
1212 if (chan == -1)
1213 chan = dimm->cschannel;
1214 else if (chan >= 0 && chan != dimm->cschannel)
1215 chan = -2;
1216 }
Alan Coxda9bb1d2006-01-18 17:44:13 -08001217 }
1218
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001219 if (!e->enable_per_layer_report) {
1220 strcpy(e->label, "any memory");
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001221 } else {
Joe Perches956b9ba2012-04-29 17:08:39 -03001222 edac_dbg(4, "csrow/channel to increment: (%d,%d)\n", row, chan);
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001223 if (p == e->label)
1224 strcpy(e->label, "unknown memory");
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001225 if (type == HW_EVENT_ERR_CORRECTED) {
1226 if (row >= 0) {
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001227 mci->csrows[row]->ce_count += error_count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001228 if (chan >= 0)
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001229 mci->csrows[row]->channels[chan]->ce_count += error_count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001230 }
1231 } else
1232 if (row >= 0)
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001233 mci->csrows[row]->ue_count += error_count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001234 }
Alan Coxda9bb1d2006-01-18 17:44:13 -08001235
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001236 /* Fill the RAM location data */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001237 p = e->location;
Borislav Petkov4da1b7b2012-09-10 17:57:44 +02001238
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001239 for (i = 0; i < mci->n_layers; i++) {
1240 if (pos[i] < 0)
1241 continue;
1242
1243 p += sprintf(p, "%s:%d ",
1244 edac_layer_name[mci->layers[i].type],
1245 pos[i]);
1246 }
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001247 if (p > e->location)
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001248 *(p - 1) = '\0';
1249
1250 /* Report the error via the trace interface */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001251 grain_bits = fls_long(e->grain) + 1;
1252 trace_mc_event(type, e->msg, e->label, e->error_count,
1253 mci->mc_idx, e->top_layer, e->mid_layer, e->low_layer,
Tan Xiaojun990995b2015-10-20 19:45:38 +08001254 (e->page_frame_number << PAGE_SHIFT) | e->offset_in_page,
Mauro Carvalho Chehabe7e24832012-10-31 13:46:11 -03001255 grain_bits, e->syndrome, e->other_detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001256
Mauro Carvalho Chehabe7e24832012-10-31 13:46:11 -03001257 edac_raw_mc_handle_error(type, mci, e);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001258}
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001259EXPORT_SYMBOL_GPL(edac_mc_handle_error);