blob: c3ee3ad98a63834e055b0218465d3033ff127a1c [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
Nicholas Krausefbedcaf2016-05-19 18:45:58 -0400568 if (mci->op_state == OP_RUNNING_POLL)
569 edac_mod_work(&mci->work, value);
Doug Thompsonbce19682007-07-26 10:41:14 -0700570 }
Dave Jiang81d87cb2007-07-19 01:49:52 -0700571 mutex_unlock(&mem_ctls_mutex);
572}
573
Doug Thompsonbce19682007-07-26 10:41:14 -0700574
575
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700576/* Return 0 on success, 1 on failure.
577 * Before calling this function, caller must
578 * assign a unique value to mci->mc_idx.
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700579 *
580 * locking model:
581 *
582 * called with the mem_ctls_mutex lock held
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700583 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700584static int add_mc_to_global_list(struct mem_ctl_info *mci)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800585{
586 struct list_head *item, *insert_before;
587 struct mem_ctl_info *p;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800588
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700589 insert_before = &mc_devices;
590
Mauro Carvalho Chehabfd687502012-03-16 07:44:18 -0300591 p = find_mci_by_dev(mci->pdev);
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700592 if (unlikely(p != NULL))
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700593 goto fail0;
594
595 list_for_each(item, &mc_devices) {
596 p = list_entry(item, struct mem_ctl_info, link);
597
598 if (p->mc_idx >= mci->mc_idx) {
599 if (unlikely(p->mc_idx == mci->mc_idx))
600 goto fail1;
601
602 insert_before = item;
603 break;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800604 }
Alan Coxda9bb1d2006-01-18 17:44:13 -0800605 }
606
607 list_add_tail_rcu(&mci->link, insert_before);
Dave Jiangc0d12172007-07-19 01:49:46 -0700608 atomic_inc(&edac_handlers);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800609 return 0;
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700610
Douglas Thompson052dfb42007-07-19 01:50:13 -0700611fail0:
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700612 edac_printk(KERN_WARNING, EDAC_MC,
Mauro Carvalho Chehabfd687502012-03-16 07:44:18 -0300613 "%s (%s) %s %s already assigned %d\n", dev_name(p->pdev),
Stephen Rothwell17aa7e02008-05-05 13:54:19 +1000614 edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700615 return 1;
616
Douglas Thompson052dfb42007-07-19 01:50:13 -0700617fail1:
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700618 edac_printk(KERN_WARNING, EDAC_MC,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700619 "bug in low-level driver: attempt to assign\n"
620 " duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700621 return 1;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800622}
623
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300624static int del_mc_from_global_list(struct mem_ctl_info *mci)
Dave Petersona1d03fc2006-03-26 01:38:46 -0800625{
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300626 int handlers = atomic_dec_return(&edac_handlers);
Dave Petersona1d03fc2006-03-26 01:38:46 -0800627 list_del_rcu(&mci->link);
Lai Jiangshane2e77092011-05-26 16:25:58 -0700628
629 /* these are for safe removal of devices from global list while
630 * NMI handlers may be traversing list
631 */
632 synchronize_rcu();
633 INIT_LIST_HEAD(&mci->link);
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300634
635 return handlers;
Dave Petersona1d03fc2006-03-26 01:38:46 -0800636}
637
Alan Coxda9bb1d2006-01-18 17:44:13 -0800638/**
Douglas Thompson5da08312007-07-19 01:49:31 -0700639 * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
640 *
641 * If found, return a pointer to the structure.
642 * Else return NULL.
643 *
644 * Caller must hold mem_ctls_mutex.
645 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700646struct mem_ctl_info *edac_mc_find(int idx)
Douglas Thompson5da08312007-07-19 01:49:31 -0700647{
648 struct list_head *item;
649 struct mem_ctl_info *mci;
650
651 list_for_each(item, &mc_devices) {
652 mci = list_entry(item, struct mem_ctl_info, link);
653
654 if (mci->mc_idx >= idx) {
655 if (mci->mc_idx == idx)
656 return mci;
657
658 break;
659 }
660 }
661
662 return NULL;
663}
664EXPORT_SYMBOL(edac_mc_find);
665
666/**
Takashi Iwai4e8d2302015-02-04 11:48:52 +0100667 * edac_mc_add_mc_with_groups: Insert the 'mci' structure into the mci
668 * global list and create sysfs entries associated with mci structure
Alan Coxda9bb1d2006-01-18 17:44:13 -0800669 * @mci: pointer to the mci structure to be added to the list
Takashi Iwai4e8d2302015-02-04 11:48:52 +0100670 * @groups: optional attribute groups for the driver-specific sysfs entries
Alan Coxda9bb1d2006-01-18 17:44:13 -0800671 *
672 * Return:
673 * 0 Success
674 * !0 Failure
675 */
676
677/* FIXME - should a warning be printed if no error detection? correction? */
Takashi Iwai4e8d2302015-02-04 11:48:52 +0100678int edac_mc_add_mc_with_groups(struct mem_ctl_info *mci,
679 const struct attribute_group **groups)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800680{
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300681 int ret = -EINVAL;
Joe Perches956b9ba2012-04-29 17:08:39 -0300682 edac_dbg(0, "\n");
Doug Thompsonb8f6f972007-07-19 01:50:26 -0700683
Borislav Petkov88d84ac2013-07-19 12:28:25 +0200684 if (mci->mc_idx >= EDAC_MAX_MCS) {
685 pr_warn_once("Too many memory controllers: %d\n", mci->mc_idx);
686 return -ENODEV;
687 }
688
Alan Coxda9bb1d2006-01-18 17:44:13 -0800689#ifdef CONFIG_EDAC_DEBUG
690 if (edac_debug_level >= 3)
691 edac_mc_dump_mci(mci);
Dave Petersone7ecd892006-03-26 01:38:52 -0800692
Alan Coxda9bb1d2006-01-18 17:44:13 -0800693 if (edac_debug_level >= 4) {
694 int i;
695
696 for (i = 0; i < mci->nr_csrows; i++) {
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -0300697 struct csrow_info *csrow = mci->csrows[i];
698 u32 nr_pages = 0;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800699 int j;
Dave Petersone7ecd892006-03-26 01:38:52 -0800700
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -0300701 for (j = 0; j < csrow->nr_channels; j++)
702 nr_pages += csrow->channels[j]->dimm->nr_pages;
703 if (!nr_pages)
704 continue;
705 edac_mc_dump_csrow(csrow);
706 for (j = 0; j < csrow->nr_channels; j++)
707 if (csrow->channels[j]->dimm->nr_pages)
708 edac_mc_dump_channel(csrow->channels[j]);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800709 }
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300710 for (i = 0; i < mci->tot_dimms; i++)
Mauro Carvalho Chehab6e84d352012-04-30 10:24:43 -0300711 if (mci->dimms[i]->nr_pages)
712 edac_mc_dump_dimm(mci->dimms[i], i);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800713 }
714#endif
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700715 mutex_lock(&mem_ctls_mutex);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800716
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300717 if (edac_mc_owner && edac_mc_owner != mci->mod_name) {
718 ret = -EPERM;
719 goto fail0;
720 }
721
Alan Coxda9bb1d2006-01-18 17:44:13 -0800722 if (add_mc_to_global_list(mci))
Dave Peterson028a7b62006-03-26 01:38:47 -0800723 goto fail0;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800724
725 /* set load time so that error rate can be tracked */
726 mci->start_time = jiffies;
727
Borislav Petkov88d84ac2013-07-19 12:28:25 +0200728 mci->bus = &mc_bus[mci->mc_idx];
729
Takashi Iwai4e8d2302015-02-04 11:48:52 +0100730 if (edac_create_sysfs_mci_device(mci, groups)) {
eric wollesen9794f332007-02-12 00:53:08 -0800731 edac_mc_printk(mci, KERN_WARNING,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700732 "failed to create sysfs device\n");
eric wollesen9794f332007-02-12 00:53:08 -0800733 goto fail1;
734 }
Alan Coxda9bb1d2006-01-18 17:44:13 -0800735
Borislav Petkov09667602016-02-02 10:59:53 +0100736 if (mci->edac_check) {
Dave Jiang81d87cb2007-07-19 01:49:52 -0700737 mci->op_state = OP_RUNNING_POLL;
738
Borislav Petkov626a7a42016-02-02 11:06:41 +0100739 INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
740 edac_queue_work(&mci->work, msecs_to_jiffies(edac_mc_get_poll_msec()));
741
Dave Jiang81d87cb2007-07-19 01:49:52 -0700742 } else {
743 mci->op_state = OP_RUNNING_INTERRUPT;
744 }
745
Alan Coxda9bb1d2006-01-18 17:44:13 -0800746 /* Report action taken */
Robert Richter7270a602013-10-10 18:22:36 +0200747 edac_mc_printk(mci, KERN_INFO,
748 "Giving out device to module %s controller %s: DEV %s (%s)\n",
749 mci->mod_name, mci->ctl_name, mci->dev_name,
750 edac_op_state_to_string(mci->op_state));
Alan Coxda9bb1d2006-01-18 17:44:13 -0800751
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300752 edac_mc_owner = mci->mod_name;
753
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700754 mutex_unlock(&mem_ctls_mutex);
Dave Peterson028a7b62006-03-26 01:38:47 -0800755 return 0;
756
Douglas Thompson052dfb42007-07-19 01:50:13 -0700757fail1:
Dave Peterson028a7b62006-03-26 01:38:47 -0800758 del_mc_from_global_list(mci);
759
Douglas Thompson052dfb42007-07-19 01:50:13 -0700760fail0:
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700761 mutex_unlock(&mem_ctls_mutex);
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300762 return ret;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800763}
Takashi Iwai4e8d2302015-02-04 11:48:52 +0100764EXPORT_SYMBOL_GPL(edac_mc_add_mc_with_groups);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800765
Alan Coxda9bb1d2006-01-18 17:44:13 -0800766/**
Dave Peterson472678e2006-03-26 01:38:49 -0800767 * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
768 * remove mci structure from global list
Doug Thompson37f04582006-06-30 01:56:07 -0700769 * @pdev: Pointer to 'struct device' representing mci structure to remove.
Alan Coxda9bb1d2006-01-18 17:44:13 -0800770 *
Dave Peterson18dbc332006-03-26 01:38:50 -0800771 * Return pointer to removed mci structure, or NULL if device not found.
Alan Coxda9bb1d2006-01-18 17:44:13 -0800772 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700773struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800774{
Dave Peterson18dbc332006-03-26 01:38:50 -0800775 struct mem_ctl_info *mci;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800776
Joe Perches956b9ba2012-04-29 17:08:39 -0300777 edac_dbg(0, "\n");
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700778
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700779 mutex_lock(&mem_ctls_mutex);
Dave Peterson18dbc332006-03-26 01:38:50 -0800780
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700781 /* find the requested mci struct in the global list */
782 mci = find_mci_by_dev(dev);
783 if (mci == NULL) {
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700784 mutex_unlock(&mem_ctls_mutex);
Dave Peterson18dbc332006-03-26 01:38:50 -0800785 return NULL;
786 }
787
Borislav Petkov09667602016-02-02 10:59:53 +0100788 /* mark MCI offline: */
789 mci->op_state = OP_OFFLINE;
790
Mauro Carvalho Chehab80cc7d82012-10-31 10:42:29 -0300791 if (!del_mc_from_global_list(mci))
792 edac_mc_owner = NULL;
Borislav Petkov09667602016-02-02 10:59:53 +0100793
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700794 mutex_unlock(&mem_ctls_mutex);
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700795
Borislav Petkov09667602016-02-02 10:59:53 +0100796 if (mci->edac_check)
Borislav Petkov626a7a42016-02-02 11:06:41 +0100797 edac_stop_work(&mci->work);
Borislav Petkovbb31b3122010-12-02 17:48:35 +0100798
799 /* remove from sysfs */
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700800 edac_remove_sysfs_mci_device(mci);
801
Dave Peterson537fba22006-03-26 01:38:40 -0800802 edac_printk(KERN_INFO, EDAC_MC,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700803 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
Stephen Rothwell17aa7e02008-05-05 13:54:19 +1000804 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700805
Dave Peterson18dbc332006-03-26 01:38:50 -0800806 return mci;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800807}
Dave Peterson91105402006-03-26 01:38:55 -0800808EXPORT_SYMBOL_GPL(edac_mc_del_mc);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800809
Adrian Bunk2da1c112007-07-19 01:49:32 -0700810static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
811 u32 size)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800812{
813 struct page *pg;
814 void *virt_addr;
815 unsigned long flags = 0;
816
Joe Perches956b9ba2012-04-29 17:08:39 -0300817 edac_dbg(3, "\n");
Alan Coxda9bb1d2006-01-18 17:44:13 -0800818
819 /* ECC error page was not in our memory. Ignore it. */
Douglas Thompson079708b2007-07-19 01:49:58 -0700820 if (!pfn_valid(page))
Alan Coxda9bb1d2006-01-18 17:44:13 -0800821 return;
822
823 /* Find the actual page structure then map it and fix */
824 pg = pfn_to_page(page);
825
826 if (PageHighMem(pg))
827 local_irq_save(flags);
828
Cong Wang4e5df7c2011-11-25 23:14:19 +0800829 virt_addr = kmap_atomic(pg);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800830
831 /* Perform architecture specific atomic scrub operation */
Borislav Petkovb01aec92015-05-21 19:59:31 +0200832 edac_atomic_scrub(virt_addr + offset, size);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800833
834 /* Unmap and complete */
Cong Wang4e5df7c2011-11-25 23:14:19 +0800835 kunmap_atomic(virt_addr);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800836
837 if (PageHighMem(pg))
838 local_irq_restore(flags);
839}
840
Alan Coxda9bb1d2006-01-18 17:44:13 -0800841/* FIXME - should return -1 */
Dave Petersone7ecd892006-03-26 01:38:52 -0800842int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800843{
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300844 struct csrow_info **csrows = mci->csrows;
Mauro Carvalho Chehaba895bf82012-01-28 09:09:38 -0300845 int row, i, j, n;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800846
Joe Perches956b9ba2012-04-29 17:08:39 -0300847 edac_dbg(1, "MC%d: 0x%lx\n", mci->mc_idx, page);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800848 row = -1;
849
850 for (i = 0; i < mci->nr_csrows; i++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300851 struct csrow_info *csrow = csrows[i];
Mauro Carvalho Chehaba895bf82012-01-28 09:09:38 -0300852 n = 0;
853 for (j = 0; j < csrow->nr_channels; j++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -0300854 struct dimm_info *dimm = csrow->channels[j]->dimm;
Mauro Carvalho Chehaba895bf82012-01-28 09:09:38 -0300855 n += dimm->nr_pages;
856 }
857 if (n == 0)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800858 continue;
859
Joe Perches956b9ba2012-04-29 17:08:39 -0300860 edac_dbg(3, "MC%d: first(0x%lx) page(0x%lx) last(0x%lx) mask(0x%lx)\n",
861 mci->mc_idx,
862 csrow->first_page, page, csrow->last_page,
863 csrow->page_mask);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800864
865 if ((page >= csrow->first_page) &&
866 (page <= csrow->last_page) &&
867 ((page & csrow->page_mask) ==
868 (csrow->first_page & csrow->page_mask))) {
869 row = i;
870 break;
871 }
872 }
873
874 if (row == -1)
Dave Peterson537fba22006-03-26 01:38:40 -0800875 edac_mc_printk(mci, KERN_ERR,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700876 "could not look up page error address %lx\n",
877 (unsigned long)page);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800878
879 return row;
880}
Dave Peterson91105402006-03-26 01:38:55 -0800881EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800882
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300883const char *edac_layer_name[] = {
884 [EDAC_MC_LAYER_BRANCH] = "branch",
885 [EDAC_MC_LAYER_CHANNEL] = "channel",
886 [EDAC_MC_LAYER_SLOT] = "slot",
887 [EDAC_MC_LAYER_CHIP_SELECT] = "csrow",
Mauro Carvalho Chehabc66b5a72013-02-15 07:21:08 -0300888 [EDAC_MC_LAYER_ALL_MEM] = "memory",
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300889};
890EXPORT_SYMBOL_GPL(edac_layer_name);
891
892static void edac_inc_ce_error(struct mem_ctl_info *mci,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300893 bool enable_per_layer_report,
894 const int pos[EDAC_MAX_LAYERS],
895 const u16 count)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800896{
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300897 int i, index = 0;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800898
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300899 mci->ce_mc += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300900
901 if (!enable_per_layer_report) {
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300902 mci->ce_noinfo_count += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300903 return;
904 }
905
906 for (i = 0; i < mci->n_layers; i++) {
907 if (pos[i] < 0)
908 break;
909 index += pos[i];
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300910 mci->ce_per_layer[i][index] += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300911
912 if (i < mci->n_layers - 1)
913 index *= mci->layers[i + 1].size;
914 }
915}
916
917static void edac_inc_ue_error(struct mem_ctl_info *mci,
918 bool enable_per_layer_report,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300919 const int pos[EDAC_MAX_LAYERS],
920 const u16 count)
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300921{
922 int i, index = 0;
923
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300924 mci->ue_mc += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300925
926 if (!enable_per_layer_report) {
Emmanouil Maroudas993f88f2016-04-23 18:33:00 +0300927 mci->ue_noinfo_count += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300928 return;
929 }
930
931 for (i = 0; i < mci->n_layers; i++) {
932 if (pos[i] < 0)
933 break;
934 index += pos[i];
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300935 mci->ue_per_layer[i][index] += count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300936
937 if (i < mci->n_layers - 1)
938 index *= mci->layers[i + 1].size;
939 }
940}
941
942static void edac_ce_error(struct mem_ctl_info *mci,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300943 const u16 error_count,
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300944 const int pos[EDAC_MAX_LAYERS],
945 const char *msg,
946 const char *location,
947 const char *label,
948 const char *detail,
949 const char *other_detail,
950 const bool enable_per_layer_report,
951 const unsigned long page_frame_number,
952 const unsigned long offset_in_page,
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -0300953 long grain)
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300954{
955 unsigned long remapped_page;
Borislav Petkovf430d572012-09-10 18:36:09 +0200956 char *msg_aux = "";
957
958 if (*msg)
959 msg_aux = " ";
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300960
961 if (edac_mc_get_log_ce()) {
962 if (other_detail && *other_detail)
963 edac_mc_printk(mci, KERN_WARNING,
Borislav Petkovf430d572012-09-10 18:36:09 +0200964 "%d CE %s%son %s (%s %s - %s)\n",
965 error_count, msg, msg_aux, label,
966 location, detail, other_detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300967 else
968 edac_mc_printk(mci, KERN_WARNING,
Borislav Petkovf430d572012-09-10 18:36:09 +0200969 "%d CE %s%son %s (%s %s)\n",
970 error_count, msg, msg_aux, label,
971 location, detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300972 }
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300973 edac_inc_ce_error(mci, enable_per_layer_report, pos, error_count);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800974
Loc Hoaa2064d2014-05-08 17:03:16 -0600975 if (mci->scrub_mode == SCRUB_SW_SRC) {
Alan Coxda9bb1d2006-01-18 17:44:13 -0800976 /*
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300977 * Some memory controllers (called MCs below) can remap
978 * memory so that it is still available at a different
979 * address when PCI devices map into memory.
980 * MC's that can't do this, lose the memory where PCI
981 * devices are mapped. This mapping is MC-dependent
982 * and so we call back into the MC driver for it to
983 * map the MC page to a physical (CPU) page which can
984 * then be mapped to a virtual page - which can then
985 * be scrubbed.
986 */
Alan Coxda9bb1d2006-01-18 17:44:13 -0800987 remapped_page = mci->ctl_page_to_phys ?
Douglas Thompson052dfb42007-07-19 01:50:13 -0700988 mci->ctl_page_to_phys(mci, page_frame_number) :
989 page_frame_number;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800990
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300991 edac_mc_scrub_block(remapped_page,
992 offset_in_page, grain);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800993 }
994}
995
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300996static void edac_ue_error(struct mem_ctl_info *mci,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -0300997 const u16 error_count,
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -0300998 const int pos[EDAC_MAX_LAYERS],
999 const char *msg,
1000 const char *location,
1001 const char *label,
1002 const char *detail,
1003 const char *other_detail,
1004 const bool enable_per_layer_report)
Alan Coxda9bb1d2006-01-18 17:44:13 -08001005{
Borislav Petkovf430d572012-09-10 18:36:09 +02001006 char *msg_aux = "";
1007
1008 if (*msg)
1009 msg_aux = " ";
1010
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001011 if (edac_mc_get_log_ue()) {
1012 if (other_detail && *other_detail)
1013 edac_mc_printk(mci, KERN_WARNING,
Borislav Petkovf430d572012-09-10 18:36:09 +02001014 "%d UE %s%son %s (%s %s - %s)\n",
1015 error_count, msg, msg_aux, label,
1016 location, detail, other_detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001017 else
1018 edac_mc_printk(mci, KERN_WARNING,
Borislav Petkovf430d572012-09-10 18:36:09 +02001019 "%d UE %s%son %s (%s %s)\n",
1020 error_count, msg, msg_aux, label,
1021 location, detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001022 }
Dave Petersone7ecd892006-03-26 01:38:52 -08001023
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001024 if (edac_mc_get_panic_on_ue()) {
1025 if (other_detail && *other_detail)
Borislav Petkovf430d572012-09-10 18:36:09 +02001026 panic("UE %s%son %s (%s%s - %s)\n",
1027 msg, msg_aux, label, location, detail, other_detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001028 else
Borislav Petkovf430d572012-09-10 18:36:09 +02001029 panic("UE %s%son %s (%s%s)\n",
1030 msg, msg_aux, label, location, detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001031 }
1032
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001033 edac_inc_ue_error(mci, enable_per_layer_report, pos, error_count);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001034}
1035
Mauro Carvalho Chehabe7e24832012-10-31 13:46:11 -03001036/**
1037 * edac_raw_mc_handle_error - reports a memory event to userspace without doing
1038 * anything to discover the error location
1039 *
1040 * @type: severity of the error (CE/UE/Fatal)
1041 * @mci: a struct mem_ctl_info pointer
1042 * @e: error description
1043 *
1044 * This raw function is used internally by edac_mc_handle_error(). It should
1045 * only be called directly when the hardware error come directly from BIOS,
1046 * like in the case of APEI GHES driver.
1047 */
1048void edac_raw_mc_handle_error(const enum hw_event_mc_err_type type,
1049 struct mem_ctl_info *mci,
1050 struct edac_raw_error_desc *e)
1051{
1052 char detail[80];
1053 int pos[EDAC_MAX_LAYERS] = { e->top_layer, e->mid_layer, e->low_layer };
1054
1055 /* Memory type dependent details about the error */
1056 if (type == HW_EVENT_ERR_CORRECTED) {
1057 snprintf(detail, sizeof(detail),
1058 "page:0x%lx offset:0x%lx grain:%ld syndrome:0x%lx",
1059 e->page_frame_number, e->offset_in_page,
1060 e->grain, e->syndrome);
1061 edac_ce_error(mci, e->error_count, pos, e->msg, e->location, e->label,
1062 detail, e->other_detail, e->enable_per_layer_report,
1063 e->page_frame_number, e->offset_in_page, e->grain);
1064 } else {
1065 snprintf(detail, sizeof(detail),
1066 "page:0x%lx offset:0x%lx grain:%ld",
1067 e->page_frame_number, e->offset_in_page, e->grain);
1068
1069 edac_ue_error(mci, e->error_count, pos, e->msg, e->location, e->label,
1070 detail, e->other_detail, e->enable_per_layer_report);
1071 }
1072
1073
1074}
1075EXPORT_SYMBOL_GPL(edac_raw_mc_handle_error);
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001076
1077/**
1078 * edac_mc_handle_error - reports a memory event to userspace
1079 *
1080 * @type: severity of the error (CE/UE/Fatal)
1081 * @mci: a struct mem_ctl_info pointer
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001082 * @error_count: Number of errors of the same type
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001083 * @page_frame_number: mem page where the error occurred
1084 * @offset_in_page: offset of the error inside the page
1085 * @syndrome: ECC syndrome
1086 * @top_layer: Memory layer[0] position
1087 * @mid_layer: Memory layer[1] position
1088 * @low_layer: Memory layer[2] position
1089 * @msg: Message meaningful to the end users that
1090 * explains the event
1091 * @other_detail: Technical details about the event that
1092 * may help hardware manufacturers and
1093 * EDAC developers to analyse the event
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001094 */
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001095void edac_mc_handle_error(const enum hw_event_mc_err_type type,
1096 struct mem_ctl_info *mci,
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001097 const u16 error_count,
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001098 const unsigned long page_frame_number,
1099 const unsigned long offset_in_page,
1100 const unsigned long syndrome,
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001101 const int top_layer,
1102 const int mid_layer,
1103 const int low_layer,
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001104 const char *msg,
Mauro Carvalho Chehab03f7eae2012-06-04 11:29:25 -03001105 const char *other_detail)
Alan Coxda9bb1d2006-01-18 17:44:13 -08001106{
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001107 char *p;
1108 int row = -1, chan = -1;
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001109 int pos[EDAC_MAX_LAYERS] = { top_layer, mid_layer, low_layer };
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001110 int i, n_labels = 0;
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001111 u8 grain_bits;
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001112 struct edac_raw_error_desc *e = &mci->error_desc;
Alan Coxda9bb1d2006-01-18 17:44:13 -08001113
Joe Perches956b9ba2012-04-29 17:08:39 -03001114 edac_dbg(3, "MC%d\n", mci->mc_idx);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001115
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001116 /* Fills the error report buffer */
1117 memset(e, 0, sizeof (*e));
1118 e->error_count = error_count;
1119 e->top_layer = top_layer;
1120 e->mid_layer = mid_layer;
1121 e->low_layer = low_layer;
1122 e->page_frame_number = page_frame_number;
1123 e->offset_in_page = offset_in_page;
1124 e->syndrome = syndrome;
1125 e->msg = msg;
1126 e->other_detail = other_detail;
1127
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001128 /*
1129 * Check if the event report is consistent and if the memory
1130 * location is known. If it is known, enable_per_layer_report will be
1131 * true, the DIMM(s) label info will be filled and the per-layer
1132 * error counters will be incremented.
1133 */
1134 for (i = 0; i < mci->n_layers; i++) {
1135 if (pos[i] >= (int)mci->layers[i].size) {
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001136
1137 edac_mc_printk(mci, KERN_ERR,
1138 "INTERNAL ERROR: %s value is out of range (%d >= %d)\n",
1139 edac_layer_name[mci->layers[i].type],
1140 pos[i], mci->layers[i].size);
1141 /*
1142 * Instead of just returning it, let's use what's
1143 * known about the error. The increment routines and
1144 * the DIMM filter logic will do the right thing by
1145 * pointing the likely damaged DIMMs.
1146 */
1147 pos[i] = -1;
1148 }
1149 if (pos[i] >= 0)
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001150 e->enable_per_layer_report = true;
Alan Coxda9bb1d2006-01-18 17:44:13 -08001151 }
1152
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001153 /*
1154 * Get the dimm label/grain that applies to the match criteria.
1155 * As the error algorithm may not be able to point to just one memory
1156 * stick, the logic here will get all possible labels that could
1157 * pottentially be affected by the error.
1158 * On FB-DIMM memory controllers, for uncorrected errors, it is common
1159 * to have only the MC channel and the MC dimm (also called "branch")
1160 * but the channel is not known, as the memory is arranged in pairs,
1161 * where each memory belongs to a separate channel within the same
1162 * branch.
1163 */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001164 p = e->label;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001165 *p = '\0';
Borislav Petkov4da1b7b2012-09-10 17:57:44 +02001166
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001167 for (i = 0; i < mci->tot_dimms; i++) {
Mauro Carvalho Chehabde3910eb2012-04-24 15:05:43 -03001168 struct dimm_info *dimm = mci->dimms[i];
Dave Petersone7ecd892006-03-26 01:38:52 -08001169
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001170 if (top_layer >= 0 && top_layer != dimm->location[0])
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001171 continue;
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001172 if (mid_layer >= 0 && mid_layer != dimm->location[1])
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001173 continue;
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001174 if (low_layer >= 0 && low_layer != dimm->location[2])
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001175 continue;
1176
1177 /* get the max grain, over the error match range */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001178 if (dimm->grain > e->grain)
1179 e->grain = dimm->grain;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001180
1181 /*
1182 * If the error is memory-controller wide, there's no need to
1183 * seek for the affected DIMMs because the whole
1184 * channel/memory controller/... may be affected.
1185 * Also, don't show errors for empty DIMM slots.
1186 */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001187 if (e->enable_per_layer_report && dimm->nr_pages) {
1188 if (n_labels >= EDAC_MAX_LABELS) {
1189 e->enable_per_layer_report = false;
1190 break;
1191 }
1192 n_labels++;
1193 if (p != e->label) {
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001194 strcpy(p, OTHER_LABEL);
1195 p += strlen(OTHER_LABEL);
1196 }
1197 strcpy(p, dimm->label);
1198 p += strlen(p);
1199 *p = '\0';
1200
1201 /*
1202 * get csrow/channel of the DIMM, in order to allow
1203 * incrementing the compat API counters
1204 */
Joe Perches956b9ba2012-04-29 17:08:39 -03001205 edac_dbg(4, "%s csrows map: (%d,%d)\n",
Mauro Carvalho Chehab9713fae2013-03-11 09:28:48 -03001206 mci->csbased ? "rank" : "dimm",
Joe Perches956b9ba2012-04-29 17:08:39 -03001207 dimm->csrow, dimm->cschannel);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001208 if (row == -1)
1209 row = dimm->csrow;
1210 else if (row >= 0 && row != dimm->csrow)
1211 row = -2;
1212
1213 if (chan == -1)
1214 chan = dimm->cschannel;
1215 else if (chan >= 0 && chan != dimm->cschannel)
1216 chan = -2;
1217 }
Alan Coxda9bb1d2006-01-18 17:44:13 -08001218 }
1219
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001220 if (!e->enable_per_layer_report) {
1221 strcpy(e->label, "any memory");
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001222 } else {
Joe Perches956b9ba2012-04-29 17:08:39 -03001223 edac_dbg(4, "csrow/channel to increment: (%d,%d)\n", row, chan);
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001224 if (p == e->label)
1225 strcpy(e->label, "unknown memory");
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001226 if (type == HW_EVENT_ERR_CORRECTED) {
1227 if (row >= 0) {
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001228 mci->csrows[row]->ce_count += error_count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001229 if (chan >= 0)
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001230 mci->csrows[row]->channels[chan]->ce_count += error_count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001231 }
1232 } else
1233 if (row >= 0)
Mauro Carvalho Chehab9eb07a72012-06-04 13:27:43 -03001234 mci->csrows[row]->ue_count += error_count;
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001235 }
Alan Coxda9bb1d2006-01-18 17:44:13 -08001236
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001237 /* Fill the RAM location data */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001238 p = e->location;
Borislav Petkov4da1b7b2012-09-10 17:57:44 +02001239
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001240 for (i = 0; i < mci->n_layers; i++) {
1241 if (pos[i] < 0)
1242 continue;
1243
1244 p += sprintf(p, "%s:%d ",
1245 edac_layer_name[mci->layers[i].type],
1246 pos[i]);
1247 }
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001248 if (p > e->location)
Mauro Carvalho Chehab53f2d022012-02-23 08:10:34 -03001249 *(p - 1) = '\0';
1250
1251 /* Report the error via the trace interface */
Mauro Carvalho Chehabc7ef7642013-02-21 13:36:45 -03001252 grain_bits = fls_long(e->grain) + 1;
1253 trace_mc_event(type, e->msg, e->label, e->error_count,
1254 mci->mc_idx, e->top_layer, e->mid_layer, e->low_layer,
Tan Xiaojun990995b2015-10-20 19:45:38 +08001255 (e->page_frame_number << PAGE_SHIFT) | e->offset_in_page,
Mauro Carvalho Chehabe7e24832012-10-31 13:46:11 -03001256 grain_bits, e->syndrome, e->other_detail);
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001257
Mauro Carvalho Chehabe7e24832012-10-31 13:46:11 -03001258 edac_raw_mc_handle_error(type, mci, e);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001259}
Mauro Carvalho Chehab4275be62012-04-18 15:20:50 -03001260EXPORT_SYMBOL_GPL(edac_mc_handle_error);