edac_mc.c 31.4 KB
Newer Older
A
Alan Cox 已提交
1 2
/*
 * edac_mc kernel module
3
 * (C) 2005, 2006 Linux Networx (http://lnxi.com)
A
Alan Cox 已提交
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 * This file may be distributed under the terms of the
 * GNU General Public License.
 *
 * Written by Thayne Harbaugh
 * Based on work by Dan Hollis <goemon at anime dot net> and others.
 *	http://www.anime.net/~goemon/linux-ecc/
 *
 * Modified by Dave Peterson and Doug Thompson
 *
 */

#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/smp.h>
#include <linux/init.h>
#include <linux/sysctl.h>
#include <linux/highmem.h>
#include <linux/timer.h>
#include <linux/slab.h>
#include <linux/jiffies.h>
#include <linux/spinlock.h>
#include <linux/list.h>
#include <linux/ctype.h>
D
Dave Jiang 已提交
29
#include <linux/edac.h>
30
#include <linux/bitops.h>
31
#include <linux/uaccess.h>
A
Alan Cox 已提交
32
#include <asm/page.h>
33
#include "edac_mc.h"
34
#include "edac_module.h"
35 36
#include <ras/ras_event.h>

37 38 39 40 41 42
#ifdef CONFIG_EDAC_ATOMIC_SCRUB
#include <asm/edac.h>
#else
#define edac_atomic_scrub(va, size) do { } while (0)
#endif

43 44 45
int edac_op_state = EDAC_OPSTATE_INVAL;
EXPORT_SYMBOL_GPL(edac_op_state);

B
Borislav Petkov 已提交
46 47
static int edac_report = EDAC_REPORTING_ENABLED;

A
Alan Cox 已提交
48
/* lock to memory controller's control array */
49
static DEFINE_MUTEX(mem_ctls_mutex);
50
static LIST_HEAD(mc_devices);
A
Alan Cox 已提交
51

52 53 54 55 56 57
/*
 * Used to lock EDAC MC to just one module, avoiding two drivers e. g.
 *	apei/ghes and i7core_edac to be used at the same time.
 */
static void const *edac_mc_owner;

B
Borislav Petkov 已提交
58 59
static struct bus_type mc_bus[EDAC_MAX_MCS];

60
int edac_get_report_status(void)
B
Borislav Petkov 已提交
61 62 63
{
	return edac_report;
}
64
EXPORT_SYMBOL_GPL(edac_get_report_status);
B
Borislav Petkov 已提交
65

66
void edac_set_report_status(int new)
B
Borislav Petkov 已提交
67 68 69 70 71 72
{
	if (new == EDAC_REPORTING_ENABLED ||
	    new == EDAC_REPORTING_DISABLED ||
	    new == EDAC_REPORTING_FORCE)
		edac_report = new;
}
73
EXPORT_SYMBOL_GPL(edac_set_report_status);
B
Borislav Petkov 已提交
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118

static int edac_report_set(const char *str, const struct kernel_param *kp)
{
	if (!str)
		return -EINVAL;

	if (!strncmp(str, "on", 2))
		edac_report = EDAC_REPORTING_ENABLED;
	else if (!strncmp(str, "off", 3))
		edac_report = EDAC_REPORTING_DISABLED;
	else if (!strncmp(str, "force", 5))
		edac_report = EDAC_REPORTING_FORCE;

	return 0;
}

static int edac_report_get(char *buffer, const struct kernel_param *kp)
{
	int ret = 0;

	switch (edac_report) {
	case EDAC_REPORTING_ENABLED:
		ret = sprintf(buffer, "on");
		break;
	case EDAC_REPORTING_DISABLED:
		ret = sprintf(buffer, "off");
		break;
	case EDAC_REPORTING_FORCE:
		ret = sprintf(buffer, "force");
		break;
	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

static const struct kernel_param_ops edac_report_ops = {
	.set = edac_report_set,
	.get = edac_report_get,
};

module_param_cb(edac_report, &edac_report_ops, &edac_report, 0644);

119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
unsigned edac_dimm_info_location(struct dimm_info *dimm, char *buf,
			         unsigned len)
{
	struct mem_ctl_info *mci = dimm->mci;
	int i, n, count = 0;
	char *p = buf;

	for (i = 0; i < mci->n_layers; i++) {
		n = snprintf(p, len, "%s %d ",
			      edac_layer_name[mci->layers[i].type],
			      dimm->location[i]);
		p += n;
		len -= n;
		count += n;
		if (!len)
			break;
	}

	return count;
}

A
Alan Cox 已提交
140 141
#ifdef CONFIG_EDAC_DEBUG

142
static void edac_mc_dump_channel(struct rank_info *chan)
A
Alan Cox 已提交
143
{
144 145 146 147
	edac_dbg(4, "  channel->chan_idx = %d\n", chan->chan_idx);
	edac_dbg(4, "    channel = %p\n", chan);
	edac_dbg(4, "    channel->csrow = %p\n", chan->csrow);
	edac_dbg(4, "    channel->dimm = %p\n", chan->dimm);
148 149
}

150
static void edac_mc_dump_dimm(struct dimm_info *dimm, int number)
151
{
152 153 154 155 156
	char location[80];

	edac_dimm_info_location(dimm, location, sizeof(location));

	edac_dbg(4, "%s%i: %smapped as virtual row %d, chan %d\n",
157
		 dimm->mci->csbased ? "rank" : "dimm",
158 159 160 161 162 163
		 number, location, dimm->csrow, dimm->cschannel);
	edac_dbg(4, "  dimm = %p\n", dimm);
	edac_dbg(4, "  dimm->label = '%s'\n", dimm->label);
	edac_dbg(4, "  dimm->nr_pages = 0x%x\n", dimm->nr_pages);
	edac_dbg(4, "  dimm->grain = %d\n", dimm->grain);
	edac_dbg(4, "  dimm->nr_pages = 0x%x\n", dimm->nr_pages);
A
Alan Cox 已提交
164 165
}

166
static void edac_mc_dump_csrow(struct csrow_info *csrow)
A
Alan Cox 已提交
167
{
168 169 170 171 172 173 174 175
	edac_dbg(4, "csrow->csrow_idx = %d\n", csrow->csrow_idx);
	edac_dbg(4, "  csrow = %p\n", csrow);
	edac_dbg(4, "  csrow->first_page = 0x%lx\n", csrow->first_page);
	edac_dbg(4, "  csrow->last_page = 0x%lx\n", csrow->last_page);
	edac_dbg(4, "  csrow->page_mask = 0x%lx\n", csrow->page_mask);
	edac_dbg(4, "  csrow->nr_channels = %d\n", csrow->nr_channels);
	edac_dbg(4, "  csrow->channels = %p\n", csrow->channels);
	edac_dbg(4, "  csrow->mci = %p\n", csrow->mci);
A
Alan Cox 已提交
176 177
}

178
static void edac_mc_dump_mci(struct mem_ctl_info *mci)
A
Alan Cox 已提交
179
{
180 181 182 183 184 185 186 187 188 189 190 191 192
	edac_dbg(3, "\tmci = %p\n", mci);
	edac_dbg(3, "\tmci->mtype_cap = %lx\n", mci->mtype_cap);
	edac_dbg(3, "\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap);
	edac_dbg(3, "\tmci->edac_cap = %lx\n", mci->edac_cap);
	edac_dbg(4, "\tmci->edac_check = %p\n", mci->edac_check);
	edac_dbg(3, "\tmci->nr_csrows = %d, csrows = %p\n",
		 mci->nr_csrows, mci->csrows);
	edac_dbg(3, "\tmci->nr_dimms = %d, dimms = %p\n",
		 mci->tot_dimms, mci->dimms);
	edac_dbg(3, "\tdev = %p\n", mci->pdev);
	edac_dbg(3, "\tmod_name:ctl_name = %s:%s\n",
		 mci->mod_name, mci->ctl_name);
	edac_dbg(3, "\tpvt_info = %p\n\n", mci->pvt_info);
A
Alan Cox 已提交
193 194
}

195 196
#endif				/* CONFIG_EDAC_DEBUG */

197
const char * const edac_mem_types[] = {
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
	[MEM_EMPTY]	= "Empty csrow",
	[MEM_RESERVED]	= "Reserved csrow type",
	[MEM_UNKNOWN]	= "Unknown csrow type",
	[MEM_FPM]	= "Fast page mode RAM",
	[MEM_EDO]	= "Extended data out RAM",
	[MEM_BEDO]	= "Burst Extended data out RAM",
	[MEM_SDR]	= "Single data rate SDRAM",
	[MEM_RDR]	= "Registered single data rate SDRAM",
	[MEM_DDR]	= "Double data rate SDRAM",
	[MEM_RDDR]	= "Registered Double data rate SDRAM",
	[MEM_RMBS]	= "Rambus DRAM",
	[MEM_DDR2]	= "Unbuffered DDR2 RAM",
	[MEM_FB_DDR2]	= "Fully buffered DDR2",
	[MEM_RDDR2]	= "Registered DDR2 RAM",
	[MEM_XDR]	= "Rambus XDR",
	[MEM_DDR3]	= "Unbuffered DDR3 RAM",
	[MEM_RDDR3]	= "Registered DDR3 RAM",
	[MEM_LRDDR3]	= "Load-Reduced DDR3 RAM",
	[MEM_DDR4]	= "Unbuffered DDR4 RAM",
	[MEM_RDDR4]	= "Registered DDR4 RAM",
218 219 220
};
EXPORT_SYMBOL_GPL(edac_mem_types);

221 222 223 224 225 226
/**
 * edac_align_ptr - Prepares the pointer offsets for a single-shot allocation
 * @p:		pointer to a pointer with the memory offset to be used. At
 *		return, this will be incremented to point to the next offset
 * @size:	Size of the data structure to be reserved
 * @n_elems:	Number of elements that should be reserved
A
Alan Cox 已提交
227 228
 *
 * If 'size' is a constant, the compiler will optimize this whole function
229 230 231 232 233 234 235 236 237
 * down to either a no-op or the addition of a constant to the value of '*p'.
 *
 * The 'p' pointer is absolutely needed to keep the proper advancing
 * further in memory to the proper offsets when allocating the struct along
 * with its embedded structs, as edac_device_alloc_ctl_info() does it
 * above, for example.
 *
 * At return, the pointer 'p' will be incremented to be used on a next call
 * to this function.
A
Alan Cox 已提交
238
 */
239
void *edac_align_ptr(void **p, unsigned size, int n_elems)
A
Alan Cox 已提交
240 241
{
	unsigned align, r;
242
	void *ptr = *p;
A
Alan Cox 已提交
243

244 245 246 247 248 249 250 251
	*p += size * n_elems;

	/*
	 * 'p' can possibly be an unaligned item X such that sizeof(X) is
	 * 'size'.  Adjust 'p' so that its alignment is at least as
	 * stringent as what the compiler would provide for X and return
	 * the aligned result.
	 * Here we assume that the alignment of a "long long" is the most
A
Alan Cox 已提交
252 253 254 255 256 257 258 259 260 261 262 263
	 * stringent alignment that the compiler will ever provide by default.
	 * As far as I know, this is a reasonable assumption.
	 */
	if (size > sizeof(long))
		align = sizeof(long long);
	else if (size > sizeof(int))
		align = sizeof(long);
	else if (size > sizeof(short))
		align = sizeof(int);
	else if (size > sizeof(char))
		align = sizeof(short);
	else
264
		return (char *)ptr;
A
Alan Cox 已提交
265

266
	r = (unsigned long)p % align;
A
Alan Cox 已提交
267 268

	if (r == 0)
269
		return (char *)ptr;
A
Alan Cox 已提交
270

271 272
	*p += align - r;

273
	return (void *)(((unsigned long)ptr) + align - r);
A
Alan Cox 已提交
274 275
}

276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
static void _edac_mc_free(struct mem_ctl_info *mci)
{
	int i, chn, row;
	struct csrow_info *csr;
	const unsigned int tot_dimms = mci->tot_dimms;
	const unsigned int tot_channels = mci->num_cschannel;
	const unsigned int tot_csrows = mci->nr_csrows;

	if (mci->dimms) {
		for (i = 0; i < tot_dimms; i++)
			kfree(mci->dimms[i]);
		kfree(mci->dimms);
	}
	if (mci->csrows) {
		for (row = 0; row < tot_csrows; row++) {
			csr = mci->csrows[row];
			if (csr) {
				if (csr->channels) {
					for (chn = 0; chn < tot_channels; chn++)
						kfree(csr->channels[chn]);
					kfree(csr->channels);
				}
				kfree(csr);
			}
		}
		kfree(mci->csrows);
	}
	kfree(mci);
}

306 307 308 309
struct mem_ctl_info *edac_mc_alloc(unsigned mc_num,
				   unsigned n_layers,
				   struct edac_mc_layer *layers,
				   unsigned sz_pvt)
A
Alan Cox 已提交
310 311
{
	struct mem_ctl_info *mci;
312
	struct edac_mc_layer *layer;
313 314
	struct csrow_info *csr;
	struct rank_info *chan;
315
	struct dimm_info *dimm;
316 317 318 319
	u32 *ce_per_layer[EDAC_MAX_LAYERS], *ue_per_layer[EDAC_MAX_LAYERS];
	unsigned pos[EDAC_MAX_LAYERS];
	unsigned size, tot_dimms = 1, count = 1;
	unsigned tot_csrows = 1, tot_channels = 1, tot_errcount = 0;
320
	void *pvt, *p, *ptr = NULL;
321
	int i, j, row, chn, n, len, off;
322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
	bool per_rank = false;

	BUG_ON(n_layers > EDAC_MAX_LAYERS || n_layers == 0);
	/*
	 * Calculate the total amount of dimms and csrows/cschannels while
	 * in the old API emulation mode
	 */
	for (i = 0; i < n_layers; i++) {
		tot_dimms *= layers[i].size;
		if (layers[i].is_virt_csrow)
			tot_csrows *= layers[i].size;
		else
			tot_channels *= layers[i].size;

		if (layers[i].type == EDAC_MC_LAYER_CHIP_SELECT)
			per_rank = true;
	}
A
Alan Cox 已提交
339 340 341 342 343 344

	/* Figure out the offsets of the various items from the start of an mc
	 * structure.  We want the alignment of each item to be at least as
	 * stringent as what the compiler would provide if we could simply
	 * hardcode everything into a single struct.
	 */
345
	mci = edac_align_ptr(&ptr, sizeof(*mci), 1);
346 347 348
	layer = edac_align_ptr(&ptr, sizeof(*layer), n_layers);
	for (i = 0; i < n_layers; i++) {
		count *= layers[i].size;
349
		edac_dbg(4, "errcount layer %d size %d\n", i, count);
350 351 352 353 354
		ce_per_layer[i] = edac_align_ptr(&ptr, sizeof(u32), count);
		ue_per_layer[i] = edac_align_ptr(&ptr, sizeof(u32), count);
		tot_errcount += 2 * count;
	}

355
	edac_dbg(4, "allocating %d error counters\n", tot_errcount);
356
	pvt = edac_align_ptr(&ptr, sz_pvt, 1);
357
	size = ((unsigned long)pvt) + sz_pvt;
A
Alan Cox 已提交
358

359 360 361 362 363
	edac_dbg(1, "allocating %u bytes for mci data (%d %s, %d csrows/channels)\n",
		 size,
		 tot_dimms,
		 per_rank ? "ranks" : "dimms",
		 tot_csrows * tot_channels);
364

365 366
	mci = kzalloc(size, GFP_KERNEL);
	if (mci == NULL)
A
Alan Cox 已提交
367 368 369 370 371
		return NULL;

	/* Adjust pointers so they point within the memory we just allocated
	 * rather than an imaginary chunk of memory located at address 0.
	 */
372 373 374 375 376
	layer = (struct edac_mc_layer *)(((char *)mci) + ((unsigned long)layer));
	for (i = 0; i < n_layers; i++) {
		mci->ce_per_layer[i] = (u32 *)((char *)mci + ((unsigned long)ce_per_layer[i]));
		mci->ue_per_layer[i] = (u32 *)((char *)mci + ((unsigned long)ue_per_layer[i]));
	}
377
	pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL;
A
Alan Cox 已提交
378

379
	/* setup index and various internal pointers */
380 381
	mci->mc_idx = mc_num;
	mci->tot_dimms = tot_dimms;
A
Alan Cox 已提交
382
	mci->pvt_info = pvt;
383 384 385 386 387
	mci->n_layers = n_layers;
	mci->layers = layer;
	memcpy(mci->layers, layers, sizeof(*layer) * n_layers);
	mci->nr_csrows = tot_csrows;
	mci->num_cschannel = tot_channels;
388
	mci->csbased = per_rank;
A
Alan Cox 已提交
389

390
	/*
391
	 * Alocate and fill the csrow/channels structs
392
	 */
J
Joe Perches 已提交
393
	mci->csrows = kcalloc(tot_csrows, sizeof(*mci->csrows), GFP_KERNEL);
394 395
	if (!mci->csrows)
		goto error;
396
	for (row = 0; row < tot_csrows; row++) {
397 398 399 400
		csr = kzalloc(sizeof(**mci->csrows), GFP_KERNEL);
		if (!csr)
			goto error;
		mci->csrows[row] = csr;
401 402 403
		csr->csrow_idx = row;
		csr->mci = mci;
		csr->nr_channels = tot_channels;
J
Joe Perches 已提交
404
		csr->channels = kcalloc(tot_channels, sizeof(*csr->channels),
405 406 407
					GFP_KERNEL);
		if (!csr->channels)
			goto error;
408 409

		for (chn = 0; chn < tot_channels; chn++) {
410 411 412 413
			chan = kzalloc(sizeof(**csr->channels), GFP_KERNEL);
			if (!chan)
				goto error;
			csr->channels[chn] = chan;
A
Alan Cox 已提交
414
			chan->chan_idx = chn;
415 416 417 418 419
			chan->csrow = csr;
		}
	}

	/*
420
	 * Allocate and fill the dimm structs
421
	 */
J
Joe Perches 已提交
422
	mci->dimms  = kcalloc(tot_dimms, sizeof(*mci->dimms), GFP_KERNEL);
423 424 425
	if (!mci->dimms)
		goto error;

426 427 428 429
	memset(&pos, 0, sizeof(pos));
	row = 0;
	chn = 0;
	for (i = 0; i < tot_dimms; i++) {
430 431 432 433 434 435
		chan = mci->csrows[row]->channels[chn];
		off = EDAC_DIMM_OFF(layer, n_layers, pos[0], pos[1], pos[2]);
		if (off < 0 || off >= tot_dimms) {
			edac_mc_printk(mci, KERN_ERR, "EDAC core bug: EDAC_DIMM_OFF is trying to do an illegal data access\n");
			goto error;
		}
436

437
		dimm = kzalloc(sizeof(**mci->dimms), GFP_KERNEL);
438 439
		if (!dimm)
			goto error;
440
		mci->dimms[off] = dimm;
441 442
		dimm->mci = mci;

443 444 445 446 447 448 449 450 451 452 453 454 455 456
		/*
		 * Copy DIMM location and initialize it.
		 */
		len = sizeof(dimm->label);
		p = dimm->label;
		n = snprintf(p, len, "mc#%u", mc_num);
		p += n;
		len -= n;
		for (j = 0; j < n_layers; j++) {
			n = snprintf(p, len, "%s#%u",
				     edac_layer_name[layers[j].type],
				     pos[j]);
			p += n;
			len -= n;
457 458
			dimm->location[j] = pos[j];

459 460 461 462
			if (len <= 0)
				break;
		}

463 464 465 466 467 468
		/* Link it to the csrows old API data */
		chan->dimm = dimm;
		dimm->csrow = row;
		dimm->cschannel = chn;

		/* Increment csrow location */
469
		if (layers[0].is_virt_csrow) {
470
			chn++;
471 472 473 474 475 476 477 478 479 480
			if (chn == tot_channels) {
				chn = 0;
				row++;
			}
		} else {
			row++;
			if (row == tot_csrows) {
				row = 0;
				chn++;
			}
481
		}
482

483 484 485 486 487 488
		/* Increment dimm location */
		for (j = n_layers - 1; j >= 0; j--) {
			pos[j]++;
			if (pos[j] < layers[j].size)
				break;
			pos[j] = 0;
A
Alan Cox 已提交
489 490 491
		}
	}

492
	mci->op_state = OP_ALLOC;
493

A
Alan Cox 已提交
494
	return mci;
495 496

error:
497
	_edac_mc_free(mci);
498 499

	return NULL;
500
}
501
EXPORT_SYMBOL_GPL(edac_mc_alloc);
A
Alan Cox 已提交
502 503 504

void edac_mc_free(struct mem_ctl_info *mci)
{
505
	edac_dbg(1, "\n");
506

507 508 509 510 511 512 513 514
	/* If we're not yet registered with sysfs free only what was allocated
	 * in edac_mc_alloc().
	 */
	if (!device_is_registered(&mci->dev)) {
		_edac_mc_free(mci);
		return;
	}

515
	/* the mci instance is freed here, when the sysfs object is dropped */
516
	edac_unregister_sysfs(mci);
A
Alan Cox 已提交
517
}
518
EXPORT_SYMBOL_GPL(edac_mc_free);
A
Alan Cox 已提交
519

520 521 522 523 524 525 526 527 528 529 530 531 532 533
bool edac_has_mcs(void)
{
	bool ret;

	mutex_lock(&mem_ctls_mutex);

	ret = list_empty(&mc_devices);

	mutex_unlock(&mem_ctls_mutex);

	return !ret;
}
EXPORT_SYMBOL_GPL(edac_has_mcs);

534 535
/* Caller must hold mem_ctls_mutex */
static struct mem_ctl_info *__find_mci_by_dev(struct device *dev)
A
Alan Cox 已提交
536 537 538 539
{
	struct mem_ctl_info *mci;
	struct list_head *item;

540
	edac_dbg(3, "\n");
A
Alan Cox 已提交
541 542 543 544

	list_for_each(item, &mc_devices) {
		mci = list_entry(item, struct mem_ctl_info, link);

545
		if (mci->pdev == dev)
A
Alan Cox 已提交
546 547 548 549 550
			return mci;
	}

	return NULL;
}
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568

/**
 * find_mci_by_dev
 *
 *	scan list of controllers looking for the one that manages
 *	the 'dev' device
 * @dev: pointer to a struct device related with the MCI
 */
struct mem_ctl_info *find_mci_by_dev(struct device *dev)
{
	struct mem_ctl_info *ret;

	mutex_lock(&mem_ctls_mutex);
	ret = __find_mci_by_dev(dev);
	mutex_unlock(&mem_ctls_mutex);

	return ret;
}
569
EXPORT_SYMBOL_GPL(find_mci_by_dev);
A
Alan Cox 已提交
570

571 572 573 574 575 576
/*
 * edac_mc_workq_function
 *	performs the operation scheduled by a workq request
 */
static void edac_mc_workq_function(struct work_struct *work_req)
{
J
Jean Delvare 已提交
577
	struct delayed_work *d_work = to_delayed_work(work_req);
578 579 580 581
	struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);

	mutex_lock(&mem_ctls_mutex);

582
	if (mci->op_state != OP_RUNNING_POLL) {
583 584 585 586
		mutex_unlock(&mem_ctls_mutex);
		return;
	}

B
Borislav Petkov 已提交
587
	if (edac_op_state == EDAC_OPSTATE_POLL)
588 589 590 591
		mci->edac_check(mci);

	mutex_unlock(&mem_ctls_mutex);

592
	/* Queue ourselves again. */
B
Borislav Petkov 已提交
593
	edac_queue_work(&mci->work, msecs_to_jiffies(edac_mc_get_poll_msec()));
594 595 596
}

/*
597 598 599 600
 * edac_mc_reset_delay_period(unsigned long value)
 *
 *	user space has updated our poll period value, need to
 *	reset our workq delays
601
 */
602
void edac_mc_reset_delay_period(unsigned long value)
603
{
604 605 606 607 608 609 610 611
	struct mem_ctl_info *mci;
	struct list_head *item;

	mutex_lock(&mem_ctls_mutex);

	list_for_each(item, &mc_devices) {
		mci = list_entry(item, struct mem_ctl_info, link);

612 613
		if (mci->op_state == OP_RUNNING_POLL)
			edac_mod_work(&mci->work, value);
614
	}
615 616 617
	mutex_unlock(&mem_ctls_mutex);
}

618 619


620 621 622
/* Return 0 on success, 1 on failure.
 * Before calling this function, caller must
 * assign a unique value to mci->mc_idx.
623 624 625 626
 *
 *	locking model:
 *
 *		called with the mem_ctls_mutex lock held
627
 */
628
static int add_mc_to_global_list(struct mem_ctl_info *mci)
A
Alan Cox 已提交
629 630 631 632
{
	struct list_head *item, *insert_before;
	struct mem_ctl_info *p;

633
	insert_before = &mc_devices;
A
Alan Cox 已提交
634

635
	p = __find_mci_by_dev(mci->pdev);
636
	if (unlikely(p != NULL))
637
		goto fail0;
A
Alan Cox 已提交
638

639 640
	list_for_each(item, &mc_devices) {
		p = list_entry(item, struct mem_ctl_info, link);
A
Alan Cox 已提交
641

642 643 644
		if (p->mc_idx >= mci->mc_idx) {
			if (unlikely(p->mc_idx == mci->mc_idx))
				goto fail1;
A
Alan Cox 已提交
645

646 647
			insert_before = item;
			break;
A
Alan Cox 已提交
648 649 650 651 652
		}
	}

	list_add_tail_rcu(&mci->link, insert_before);
	return 0;
653

654
fail0:
655
	edac_printk(KERN_WARNING, EDAC_MC,
656
		"%s (%s) %s %s already assigned %d\n", dev_name(p->pdev),
657
		edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
658 659
	return 1;

660
fail1:
661
	edac_printk(KERN_WARNING, EDAC_MC,
662 663
		"bug in low-level driver: attempt to assign\n"
		"    duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
664
	return 1;
A
Alan Cox 已提交
665 666
}

667
static int del_mc_from_global_list(struct mem_ctl_info *mci)
668 669
{
	list_del_rcu(&mci->link);
670 671 672 673 674 675

	/* these are for safe removal of devices from global list while
	 * NMI handlers may be traversing list
	 */
	synchronize_rcu();
	INIT_LIST_HEAD(&mci->link);
676

B
Borislav Petkov 已提交
677
	return list_empty(&mc_devices);
678 679
}

680
struct mem_ctl_info *edac_mc_find(int idx)
681
{
682
	struct mem_ctl_info *mci = NULL;
683
	struct list_head *item;
684 685

	mutex_lock(&mem_ctls_mutex);
686 687 688 689 690

	list_for_each(item, &mc_devices) {
		mci = list_entry(item, struct mem_ctl_info, link);

		if (mci->mc_idx >= idx) {
691 692 693
			if (mci->mc_idx == idx) {
				goto unlock;
			}
694 695 696 697
			break;
		}
	}

698 699 700
unlock:
	mutex_unlock(&mem_ctls_mutex);
	return mci;
701 702 703
}
EXPORT_SYMBOL(edac_mc_find);

A
Alan Cox 已提交
704 705

/* FIXME - should a warning be printed if no error detection? correction? */
706 707
int edac_mc_add_mc_with_groups(struct mem_ctl_info *mci,
			       const struct attribute_group **groups)
A
Alan Cox 已提交
708
{
709
	int ret = -EINVAL;
710
	edac_dbg(0, "\n");
711

B
Borislav Petkov 已提交
712 713 714 715 716
	if (mci->mc_idx >= EDAC_MAX_MCS) {
		pr_warn_once("Too many memory controllers: %d\n", mci->mc_idx);
		return -ENODEV;
	}

A
Alan Cox 已提交
717 718 719
#ifdef CONFIG_EDAC_DEBUG
	if (edac_debug_level >= 3)
		edac_mc_dump_mci(mci);
D
Dave Peterson 已提交
720

A
Alan Cox 已提交
721 722 723 724
	if (edac_debug_level >= 4) {
		int i;

		for (i = 0; i < mci->nr_csrows; i++) {
725 726
			struct csrow_info *csrow = mci->csrows[i];
			u32 nr_pages = 0;
A
Alan Cox 已提交
727
			int j;
D
Dave Peterson 已提交
728

729 730 731 732 733 734 735 736
			for (j = 0; j < csrow->nr_channels; j++)
				nr_pages += csrow->channels[j]->dimm->nr_pages;
			if (!nr_pages)
				continue;
			edac_mc_dump_csrow(csrow);
			for (j = 0; j < csrow->nr_channels; j++)
				if (csrow->channels[j]->dimm->nr_pages)
					edac_mc_dump_channel(csrow->channels[j]);
A
Alan Cox 已提交
737
		}
738
		for (i = 0; i < mci->tot_dimms; i++)
739 740
			if (mci->dimms[i]->nr_pages)
				edac_mc_dump_dimm(mci->dimms[i], i);
A
Alan Cox 已提交
741 742
	}
#endif
743
	mutex_lock(&mem_ctls_mutex);
A
Alan Cox 已提交
744

745 746 747 748 749
	if (edac_mc_owner && edac_mc_owner != mci->mod_name) {
		ret = -EPERM;
		goto fail0;
	}

A
Alan Cox 已提交
750
	if (add_mc_to_global_list(mci))
751
		goto fail0;
A
Alan Cox 已提交
752 753 754 755

	/* set load time so that error rate can be tracked */
	mci->start_time = jiffies;

B
Borislav Petkov 已提交
756 757
	mci->bus = &mc_bus[mci->mc_idx];

758
	if (edac_create_sysfs_mci_device(mci, groups)) {
759
		edac_mc_printk(mci, KERN_WARNING,
760
			"failed to create sysfs device\n");
761 762
		goto fail1;
	}
A
Alan Cox 已提交
763

764
	if (mci->edac_check) {
765 766
		mci->op_state = OP_RUNNING_POLL;

767 768 769
		INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
		edac_queue_work(&mci->work, msecs_to_jiffies(edac_mc_get_poll_msec()));

770 771 772 773
	} else {
		mci->op_state = OP_RUNNING_INTERRUPT;
	}

A
Alan Cox 已提交
774
	/* Report action taken */
775 776 777 778
	edac_mc_printk(mci, KERN_INFO,
		"Giving out device to module %s controller %s: DEV %s (%s)\n",
		mci->mod_name, mci->ctl_name, mci->dev_name,
		edac_op_state_to_string(mci->op_state));
A
Alan Cox 已提交
779

780 781
	edac_mc_owner = mci->mod_name;

782
	mutex_unlock(&mem_ctls_mutex);
783
	return 0;
A
Alan Cox 已提交
784

785
fail1:
786 787
	del_mc_from_global_list(mci);

788
fail0:
789
	mutex_unlock(&mem_ctls_mutex);
790
	return ret;
A
Alan Cox 已提交
791
}
792
EXPORT_SYMBOL_GPL(edac_mc_add_mc_with_groups);
A
Alan Cox 已提交
793

794
struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
A
Alan Cox 已提交
795
{
796
	struct mem_ctl_info *mci;
A
Alan Cox 已提交
797

798
	edac_dbg(0, "\n");
799

800
	mutex_lock(&mem_ctls_mutex);
801

802
	/* find the requested mci struct in the global list */
803
	mci = __find_mci_by_dev(dev);
804
	if (mci == NULL) {
805
		mutex_unlock(&mem_ctls_mutex);
806 807 808
		return NULL;
	}

809 810 811
	/* mark MCI offline: */
	mci->op_state = OP_OFFLINE;

B
Borislav Petkov 已提交
812
	if (del_mc_from_global_list(mci))
813
		edac_mc_owner = NULL;
814

815
	mutex_unlock(&mem_ctls_mutex);
816

817
	if (mci->edac_check)
818
		edac_stop_work(&mci->work);
819 820

	/* remove from sysfs */
821 822
	edac_remove_sysfs_mci_device(mci);

D
Dave Peterson 已提交
823
	edac_printk(KERN_INFO, EDAC_MC,
824
		"Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
825
		mci->mod_name, mci->ctl_name, edac_dev_name(mci));
826

827
	return mci;
A
Alan Cox 已提交
828
}
829
EXPORT_SYMBOL_GPL(edac_mc_del_mc);
A
Alan Cox 已提交
830

831 832
static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
				u32 size)
A
Alan Cox 已提交
833 834 835 836 837
{
	struct page *pg;
	void *virt_addr;
	unsigned long flags = 0;

838
	edac_dbg(3, "\n");
A
Alan Cox 已提交
839 840

	/* ECC error page was not in our memory. Ignore it. */
841
	if (!pfn_valid(page))
A
Alan Cox 已提交
842 843 844 845 846 847 848 849
		return;

	/* Find the actual page structure then map it and fix */
	pg = pfn_to_page(page);

	if (PageHighMem(pg))
		local_irq_save(flags);

850
	virt_addr = kmap_atomic(pg);
A
Alan Cox 已提交
851 852

	/* Perform architecture specific atomic scrub operation */
853
	edac_atomic_scrub(virt_addr + offset, size);
A
Alan Cox 已提交
854 855

	/* Unmap and complete */
856
	kunmap_atomic(virt_addr);
A
Alan Cox 已提交
857 858 859 860 861 862

	if (PageHighMem(pg))
		local_irq_restore(flags);
}

/* FIXME - should return -1 */
D
Dave Peterson 已提交
863
int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
A
Alan Cox 已提交
864
{
865
	struct csrow_info **csrows = mci->csrows;
866
	int row, i, j, n;
A
Alan Cox 已提交
867

868
	edac_dbg(1, "MC%d: 0x%lx\n", mci->mc_idx, page);
A
Alan Cox 已提交
869 870 871
	row = -1;

	for (i = 0; i < mci->nr_csrows; i++) {
872
		struct csrow_info *csrow = csrows[i];
873 874
		n = 0;
		for (j = 0; j < csrow->nr_channels; j++) {
875
			struct dimm_info *dimm = csrow->channels[j]->dimm;
876 877 878
			n += dimm->nr_pages;
		}
		if (n == 0)
A
Alan Cox 已提交
879 880
			continue;

881 882 883 884
		edac_dbg(3, "MC%d: first(0x%lx) page(0x%lx) last(0x%lx) mask(0x%lx)\n",
			 mci->mc_idx,
			 csrow->first_page, page, csrow->last_page,
			 csrow->page_mask);
A
Alan Cox 已提交
885 886 887 888 889 890 891 892 893 894 895

		if ((page >= csrow->first_page) &&
		    (page <= csrow->last_page) &&
		    ((page & csrow->page_mask) ==
		     (csrow->first_page & csrow->page_mask))) {
			row = i;
			break;
		}
	}

	if (row == -1)
D
Dave Peterson 已提交
896
		edac_mc_printk(mci, KERN_ERR,
897 898
			"could not look up page error address %lx\n",
			(unsigned long)page);
A
Alan Cox 已提交
899 900 901

	return row;
}
902
EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
A
Alan Cox 已提交
903

904 905 906 907 908
const char *edac_layer_name[] = {
	[EDAC_MC_LAYER_BRANCH] = "branch",
	[EDAC_MC_LAYER_CHANNEL] = "channel",
	[EDAC_MC_LAYER_SLOT] = "slot",
	[EDAC_MC_LAYER_CHIP_SELECT] = "csrow",
909
	[EDAC_MC_LAYER_ALL_MEM] = "memory",
910 911 912 913
};
EXPORT_SYMBOL_GPL(edac_layer_name);

static void edac_inc_ce_error(struct mem_ctl_info *mci,
914 915 916
			      bool enable_per_layer_report,
			      const int pos[EDAC_MAX_LAYERS],
			      const u16 count)
A
Alan Cox 已提交
917
{
918
	int i, index = 0;
A
Alan Cox 已提交
919

920
	mci->ce_mc += count;
A
Alan Cox 已提交
921

922
	if (!enable_per_layer_report) {
923
		mci->ce_noinfo_count += count;
A
Alan Cox 已提交
924 925
		return;
	}
D
Dave Peterson 已提交
926

927 928 929 930
	for (i = 0; i < mci->n_layers; i++) {
		if (pos[i] < 0)
			break;
		index += pos[i];
931
		mci->ce_per_layer[i][index] += count;
932 933 934 935 936 937 938 939

		if (i < mci->n_layers - 1)
			index *= mci->layers[i + 1].size;
	}
}

static void edac_inc_ue_error(struct mem_ctl_info *mci,
				    bool enable_per_layer_report,
940 941
				    const int pos[EDAC_MAX_LAYERS],
				    const u16 count)
942 943 944
{
	int i, index = 0;

945
	mci->ue_mc += count;
946 947

	if (!enable_per_layer_report) {
948
		mci->ue_noinfo_count += count;
A
Alan Cox 已提交
949 950 951
		return;
	}

952 953 954 955
	for (i = 0; i < mci->n_layers; i++) {
		if (pos[i] < 0)
			break;
		index += pos[i];
956
		mci->ue_per_layer[i][index] += count;
957

958 959 960 961
		if (i < mci->n_layers - 1)
			index *= mci->layers[i + 1].size;
	}
}
A
Alan Cox 已提交
962

963
static void edac_ce_error(struct mem_ctl_info *mci,
964
			  const u16 error_count,
965 966 967 968 969 970 971 972 973
			  const int pos[EDAC_MAX_LAYERS],
			  const char *msg,
			  const char *location,
			  const char *label,
			  const char *detail,
			  const char *other_detail,
			  const bool enable_per_layer_report,
			  const unsigned long page_frame_number,
			  const unsigned long offset_in_page,
974
			  long grain)
975 976
{
	unsigned long remapped_page;
977 978 979 980
	char *msg_aux = "";

	if (*msg)
		msg_aux = " ";
981 982 983 984

	if (edac_mc_get_log_ce()) {
		if (other_detail && *other_detail)
			edac_mc_printk(mci, KERN_WARNING,
985 986 987
				       "%d CE %s%son %s (%s %s - %s)\n",
				       error_count, msg, msg_aux, label,
				       location, detail, other_detail);
988 989
		else
			edac_mc_printk(mci, KERN_WARNING,
990 991 992
				       "%d CE %s%son %s (%s %s)\n",
				       error_count, msg, msg_aux, label,
				       location, detail);
993
	}
994
	edac_inc_ce_error(mci, enable_per_layer_report, pos, error_count);
A
Alan Cox 已提交
995

996
	if (mci->scrub_mode == SCRUB_SW_SRC) {
A
Alan Cox 已提交
997
		/*
998 999 1000 1001 1002 1003 1004 1005 1006 1007
			* Some memory controllers (called MCs below) can remap
			* memory so that it is still available at a different
			* address when PCI devices map into memory.
			* MC's that can't do this, lose the memory where PCI
			* devices are mapped. This mapping is MC-dependent
			* and so we call back into the MC driver for it to
			* map the MC page to a physical (CPU) page which can
			* then be mapped to a virtual page - which can then
			* be scrubbed.
			*/
A
Alan Cox 已提交
1008
		remapped_page = mci->ctl_page_to_phys ?
1009 1010
			mci->ctl_page_to_phys(mci, page_frame_number) :
			page_frame_number;
A
Alan Cox 已提交
1011

1012 1013
		edac_mc_scrub_block(remapped_page,
					offset_in_page, grain);
A
Alan Cox 已提交
1014 1015 1016
	}
}

1017
static void edac_ue_error(struct mem_ctl_info *mci,
1018
			  const u16 error_count,
1019 1020 1021 1022 1023 1024 1025
			  const int pos[EDAC_MAX_LAYERS],
			  const char *msg,
			  const char *location,
			  const char *label,
			  const char *detail,
			  const char *other_detail,
			  const bool enable_per_layer_report)
A
Alan Cox 已提交
1026
{
1027 1028 1029 1030 1031
	char *msg_aux = "";

	if (*msg)
		msg_aux = " ";

1032 1033 1034
	if (edac_mc_get_log_ue()) {
		if (other_detail && *other_detail)
			edac_mc_printk(mci, KERN_WARNING,
1035 1036 1037
				       "%d UE %s%son %s (%s %s - %s)\n",
				       error_count, msg, msg_aux, label,
				       location, detail, other_detail);
1038 1039
		else
			edac_mc_printk(mci, KERN_WARNING,
1040 1041 1042
				       "%d UE %s%son %s (%s %s)\n",
				       error_count, msg, msg_aux, label,
				       location, detail);
1043
	}
D
Dave Peterson 已提交
1044

1045 1046
	if (edac_mc_get_panic_on_ue()) {
		if (other_detail && *other_detail)
1047 1048
			panic("UE %s%son %s (%s%s - %s)\n",
			      msg, msg_aux, label, location, detail, other_detail);
1049
		else
1050 1051
			panic("UE %s%son %s (%s%s)\n",
			      msg, msg_aux, label, location, detail);
1052 1053
	}

1054
	edac_inc_ue_error(mci, enable_per_layer_report, pos, error_count);
A
Alan Cox 已提交
1055 1056
}

1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
void edac_raw_mc_handle_error(const enum hw_event_mc_err_type type,
			      struct mem_ctl_info *mci,
			      struct edac_raw_error_desc *e)
{
	char detail[80];
	int pos[EDAC_MAX_LAYERS] = { e->top_layer, e->mid_layer, e->low_layer };

	/* Memory type dependent details about the error */
	if (type == HW_EVENT_ERR_CORRECTED) {
		snprintf(detail, sizeof(detail),
			"page:0x%lx offset:0x%lx grain:%ld syndrome:0x%lx",
			e->page_frame_number, e->offset_in_page,
			e->grain, e->syndrome);
		edac_ce_error(mci, e->error_count, pos, e->msg, e->location, e->label,
			      detail, e->other_detail, e->enable_per_layer_report,
			      e->page_frame_number, e->offset_in_page, e->grain);
	} else {
		snprintf(detail, sizeof(detail),
			"page:0x%lx offset:0x%lx grain:%ld",
			e->page_frame_number, e->offset_in_page, e->grain);

		edac_ue_error(mci, e->error_count, pos, e->msg, e->location, e->label,
			      detail, e->other_detail, e->enable_per_layer_report);
	}


}
EXPORT_SYMBOL_GPL(edac_raw_mc_handle_error);
1085

1086 1087
void edac_mc_handle_error(const enum hw_event_mc_err_type type,
			  struct mem_ctl_info *mci,
1088
			  const u16 error_count,
1089 1090 1091
			  const unsigned long page_frame_number,
			  const unsigned long offset_in_page,
			  const unsigned long syndrome,
1092 1093 1094
			  const int top_layer,
			  const int mid_layer,
			  const int low_layer,
1095
			  const char *msg,
1096
			  const char *other_detail)
A
Alan Cox 已提交
1097
{
1098 1099
	char *p;
	int row = -1, chan = -1;
1100
	int pos[EDAC_MAX_LAYERS] = { top_layer, mid_layer, low_layer };
1101
	int i, n_labels = 0;
1102
	u8 grain_bits;
1103
	struct edac_raw_error_desc *e = &mci->error_desc;
A
Alan Cox 已提交
1104

1105
	edac_dbg(3, "MC%d\n", mci->mc_idx);
A
Alan Cox 已提交
1106

1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
	/* Fills the error report buffer */
	memset(e, 0, sizeof (*e));
	e->error_count = error_count;
	e->top_layer = top_layer;
	e->mid_layer = mid_layer;
	e->low_layer = low_layer;
	e->page_frame_number = page_frame_number;
	e->offset_in_page = offset_in_page;
	e->syndrome = syndrome;
	e->msg = msg;
	e->other_detail = other_detail;

1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140
	/*
	 * Check if the event report is consistent and if the memory
	 * location is known. If it is known, enable_per_layer_report will be
	 * true, the DIMM(s) label info will be filled and the per-layer
	 * error counters will be incremented.
	 */
	for (i = 0; i < mci->n_layers; i++) {
		if (pos[i] >= (int)mci->layers[i].size) {

			edac_mc_printk(mci, KERN_ERR,
				       "INTERNAL ERROR: %s value is out of range (%d >= %d)\n",
				       edac_layer_name[mci->layers[i].type],
				       pos[i], mci->layers[i].size);
			/*
			 * Instead of just returning it, let's use what's
			 * known about the error. The increment routines and
			 * the DIMM filter logic will do the right thing by
			 * pointing the likely damaged DIMMs.
			 */
			pos[i] = -1;
		}
		if (pos[i] >= 0)
1141
			e->enable_per_layer_report = true;
A
Alan Cox 已提交
1142 1143
	}

1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
	/*
	 * Get the dimm label/grain that applies to the match criteria.
	 * As the error algorithm may not be able to point to just one memory
	 * stick, the logic here will get all possible labels that could
	 * pottentially be affected by the error.
	 * On FB-DIMM memory controllers, for uncorrected errors, it is common
	 * to have only the MC channel and the MC dimm (also called "branch")
	 * but the channel is not known, as the memory is arranged in pairs,
	 * where each memory belongs to a separate channel within the same
	 * branch.
	 */
1155
	p = e->label;
1156
	*p = '\0';
1157

1158
	for (i = 0; i < mci->tot_dimms; i++) {
1159
		struct dimm_info *dimm = mci->dimms[i];
A
Alan Cox 已提交
1160

1161
		if (top_layer >= 0 && top_layer != dimm->location[0])
1162
			continue;
1163
		if (mid_layer >= 0 && mid_layer != dimm->location[1])
1164
			continue;
1165
		if (low_layer >= 0 && low_layer != dimm->location[2])
1166
			continue;
A
Alan Cox 已提交
1167

1168
		/* get the max grain, over the error match range */
1169 1170
		if (dimm->grain > e->grain)
			e->grain = dimm->grain;
1171

1172 1173 1174 1175 1176 1177
		/*
		 * If the error is memory-controller wide, there's no need to
		 * seek for the affected DIMMs because the whole
		 * channel/memory controller/...  may be affected.
		 * Also, don't show errors for empty DIMM slots.
		 */
1178 1179 1180 1181 1182 1183 1184
		if (e->enable_per_layer_report && dimm->nr_pages) {
			if (n_labels >= EDAC_MAX_LABELS) {
				e->enable_per_layer_report = false;
				break;
			}
			n_labels++;
			if (p != e->label) {
1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195
				strcpy(p, OTHER_LABEL);
				p += strlen(OTHER_LABEL);
			}
			strcpy(p, dimm->label);
			p += strlen(p);
			*p = '\0';

			/*
			 * get csrow/channel of the DIMM, in order to allow
			 * incrementing the compat API counters
			 */
1196
			edac_dbg(4, "%s csrows map: (%d,%d)\n",
1197
				 mci->csbased ? "rank" : "dimm",
1198
				 dimm->csrow, dimm->cschannel);
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208
			if (row == -1)
				row = dimm->csrow;
			else if (row >= 0 && row != dimm->csrow)
				row = -2;

			if (chan == -1)
				chan = dimm->cschannel;
			else if (chan >= 0 && chan != dimm->cschannel)
				chan = -2;
		}
1209 1210
	}

1211 1212
	if (!e->enable_per_layer_report) {
		strcpy(e->label, "any memory");
1213
	} else {
1214
		edac_dbg(4, "csrow/channel to increment: (%d,%d)\n", row, chan);
1215 1216
		if (p == e->label)
			strcpy(e->label, "unknown memory");
1217 1218
		if (type == HW_EVENT_ERR_CORRECTED) {
			if (row >= 0) {
1219
				mci->csrows[row]->ce_count += error_count;
1220
				if (chan >= 0)
1221
					mci->csrows[row]->channels[chan]->ce_count += error_count;
1222 1223 1224
			}
		} else
			if (row >= 0)
1225
				mci->csrows[row]->ue_count += error_count;
1226 1227
	}

1228
	/* Fill the RAM location data */
1229
	p = e->location;
1230

1231 1232 1233
	for (i = 0; i < mci->n_layers; i++) {
		if (pos[i] < 0)
			continue;
1234

1235 1236 1237
		p += sprintf(p, "%s:%d ",
			     edac_layer_name[mci->layers[i].type],
			     pos[i]);
1238
	}
1239
	if (p > e->location)
1240 1241 1242
		*(p - 1) = '\0';

	/* Report the error via the trace interface */
1243
	grain_bits = fls_long(e->grain) + 1;
1244 1245 1246 1247 1248 1249 1250

	if (IS_ENABLED(CONFIG_RAS))
		trace_mc_event(type, e->msg, e->label, e->error_count,
			       mci->mc_idx, e->top_layer, e->mid_layer,
			       e->low_layer,
			       (e->page_frame_number << PAGE_SHIFT) | e->offset_in_page,
			       grain_bits, e->syndrome, e->other_detail);
1251

1252
	edac_raw_mc_handle_error(type, mci, e);
1253
}
1254
EXPORT_SYMBOL_GPL(edac_mc_handle_error);