blob: a4e9db2d6524f9dfd001236b2c5f693ecd7b0d17 [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>
28#include <linux/sysdev.h>
29#include <linux/ctype.h>
Dave Jiangc0d12172007-07-19 01:49:46 -070030#include <linux/edac.h>
Alan Coxda9bb1d2006-01-18 17:44:13 -080031#include <asm/uaccess.h>
32#include <asm/page.h>
33#include <asm/edac.h>
Douglas Thompson20bcb7a2007-07-19 01:49:47 -070034#include "edac_core.h"
Douglas Thompson7c9281d2007-07-19 01:49:33 -070035#include "edac_module.h"
Alan Coxda9bb1d2006-01-18 17:44:13 -080036
Alan Coxda9bb1d2006-01-18 17:44:13 -080037/* lock to memory controller's control array */
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -070038static DEFINE_MUTEX(mem_ctls_mutex);
Robert P. J. Dayff6ac2a2008-04-29 01:03:17 -070039static LIST_HEAD(mc_devices);
Alan Coxda9bb1d2006-01-18 17:44:13 -080040
Alan Coxda9bb1d2006-01-18 17:44:13 -080041#ifdef CONFIG_EDAC_DEBUG
42
Adrian Bunk2da1c112007-07-19 01:49:32 -070043static void edac_mc_dump_channel(struct channel_info *chan)
Alan Coxda9bb1d2006-01-18 17:44:13 -080044{
45 debugf4("\tchannel = %p\n", chan);
46 debugf4("\tchannel->chan_idx = %d\n", chan->chan_idx);
47 debugf4("\tchannel->ce_count = %d\n", chan->ce_count);
48 debugf4("\tchannel->label = '%s'\n", chan->label);
49 debugf4("\tchannel->csrow = %p\n\n", chan->csrow);
50}
51
Adrian Bunk2da1c112007-07-19 01:49:32 -070052static void edac_mc_dump_csrow(struct csrow_info *csrow)
Alan Coxda9bb1d2006-01-18 17:44:13 -080053{
54 debugf4("\tcsrow = %p\n", csrow);
55 debugf4("\tcsrow->csrow_idx = %d\n", csrow->csrow_idx);
Douglas Thompson079708b2007-07-19 01:49:58 -070056 debugf4("\tcsrow->first_page = 0x%lx\n", csrow->first_page);
Alan Coxda9bb1d2006-01-18 17:44:13 -080057 debugf4("\tcsrow->last_page = 0x%lx\n", csrow->last_page);
58 debugf4("\tcsrow->page_mask = 0x%lx\n", csrow->page_mask);
59 debugf4("\tcsrow->nr_pages = 0x%x\n", csrow->nr_pages);
Douglas Thompson079708b2007-07-19 01:49:58 -070060 debugf4("\tcsrow->nr_channels = %d\n", csrow->nr_channels);
Alan Coxda9bb1d2006-01-18 17:44:13 -080061 debugf4("\tcsrow->channels = %p\n", csrow->channels);
62 debugf4("\tcsrow->mci = %p\n\n", csrow->mci);
63}
64
Adrian Bunk2da1c112007-07-19 01:49:32 -070065static void edac_mc_dump_mci(struct mem_ctl_info *mci)
Alan Coxda9bb1d2006-01-18 17:44:13 -080066{
67 debugf3("\tmci = %p\n", mci);
68 debugf3("\tmci->mtype_cap = %lx\n", mci->mtype_cap);
69 debugf3("\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap);
70 debugf3("\tmci->edac_cap = %lx\n", mci->edac_cap);
71 debugf4("\tmci->edac_check = %p\n", mci->edac_check);
72 debugf3("\tmci->nr_csrows = %d, csrows = %p\n",
73 mci->nr_csrows, mci->csrows);
Doug Thompson37f04582006-06-30 01:56:07 -070074 debugf3("\tdev = %p\n", mci->dev);
Douglas Thompson079708b2007-07-19 01:49:58 -070075 debugf3("\tmod_name:ctl_name = %s:%s\n", mci->mod_name, mci->ctl_name);
Alan Coxda9bb1d2006-01-18 17:44:13 -080076 debugf3("\tpvt_info = %p\n\n", mci->pvt_info);
77}
78
Borislav Petkov24f9a7f2010-10-07 18:29:15 +020079#endif /* CONFIG_EDAC_DEBUG */
80
Borislav Petkov239642f2009-11-12 15:33:16 +010081/*
82 * keep those in sync with the enum mem_type
83 */
84const char *edac_mem_types[] = {
85 "Empty csrow",
86 "Reserved csrow type",
87 "Unknown csrow type",
88 "Fast page mode RAM",
89 "Extended data out RAM",
90 "Burst Extended data out RAM",
91 "Single data rate SDRAM",
92 "Registered single data rate SDRAM",
93 "Double data rate SDRAM",
94 "Registered Double data rate SDRAM",
95 "Rambus DRAM",
96 "Unbuffered DDR2 RAM",
97 "Fully buffered DDR2",
98 "Registered DDR2 RAM",
99 "Rambus XDR",
100 "Unbuffered DDR3 RAM",
101 "Registered DDR3 RAM",
102};
103EXPORT_SYMBOL_GPL(edac_mem_types);
104
Alan Coxda9bb1d2006-01-18 17:44:13 -0800105/* 'ptr' points to a possibly unaligned item X such that sizeof(X) is 'size'.
106 * Adjust 'ptr' so that its alignment is at least as stringent as what the
107 * compiler would provide for X and return the aligned result.
108 *
109 * If 'size' is a constant, the compiler will optimize this whole function
110 * down to either a no-op or the addition of a constant to the value of 'ptr'.
111 */
Douglas Thompson7391c6d2007-07-19 01:50:21 -0700112void *edac_align_ptr(void *ptr, unsigned size)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800113{
114 unsigned align, r;
115
116 /* Here we assume that the alignment of a "long long" is the most
117 * stringent alignment that the compiler will ever provide by default.
118 * As far as I know, this is a reasonable assumption.
119 */
120 if (size > sizeof(long))
121 align = sizeof(long long);
122 else if (size > sizeof(int))
123 align = sizeof(long);
124 else if (size > sizeof(short))
125 align = sizeof(int);
126 else if (size > sizeof(char))
127 align = sizeof(short);
128 else
Douglas Thompson079708b2007-07-19 01:49:58 -0700129 return (char *)ptr;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800130
131 r = size % align;
132
133 if (r == 0)
Douglas Thompson079708b2007-07-19 01:49:58 -0700134 return (char *)ptr;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800135
Douglas Thompson7391c6d2007-07-19 01:50:21 -0700136 return (void *)(((unsigned long)ptr) + align - r);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800137}
138
Alan Coxda9bb1d2006-01-18 17:44:13 -0800139/**
140 * edac_mc_alloc: Allocate a struct mem_ctl_info structure
141 * @size_pvt: size of private storage needed
142 * @nr_csrows: Number of CWROWS needed for this MC
143 * @nr_chans: Number of channels for the MC
144 *
145 * Everything is kmalloc'ed as one big chunk - more efficient.
146 * Only can be used if all structures have the same lifetime - otherwise
147 * you have to allocate and initialize your own structures.
148 *
149 * Use edac_mc_free() to free mc structures allocated by this function.
150 *
151 * Returns:
152 * NULL allocation failed
153 * struct mem_ctl_info pointer
154 */
155struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows,
Doug Thompsonb8f6f972007-07-19 01:50:26 -0700156 unsigned nr_chans, int edac_index)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800157{
158 struct mem_ctl_info *mci;
159 struct csrow_info *csi, *csrow;
160 struct channel_info *chi, *chp, *chan;
161 void *pvt;
162 unsigned size;
163 int row, chn;
Doug Thompson8096cfa2007-07-19 01:50:27 -0700164 int err;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800165
166 /* Figure out the offsets of the various items from the start of an mc
167 * structure. We want the alignment of each item to be at least as
168 * stringent as what the compiler would provide if we could simply
169 * hardcode everything into a single struct.
170 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700171 mci = (struct mem_ctl_info *)0;
Douglas Thompson7391c6d2007-07-19 01:50:21 -0700172 csi = edac_align_ptr(&mci[1], sizeof(*csi));
173 chi = edac_align_ptr(&csi[nr_csrows], sizeof(*chi));
Douglas Thompsone27e3da2007-07-19 01:49:36 -0700174 pvt = edac_align_ptr(&chi[nr_chans * nr_csrows], sz_pvt);
Douglas Thompson079708b2007-07-19 01:49:58 -0700175 size = ((unsigned long)pvt) + sz_pvt;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800176
Doug Thompson8096cfa2007-07-19 01:50:27 -0700177 mci = kzalloc(size, GFP_KERNEL);
178 if (mci == NULL)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800179 return NULL;
180
181 /* Adjust pointers so they point within the memory we just allocated
182 * rather than an imaginary chunk of memory located at address 0.
183 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700184 csi = (struct csrow_info *)(((char *)mci) + ((unsigned long)csi));
185 chi = (struct channel_info *)(((char *)mci) + ((unsigned long)chi));
186 pvt = sz_pvt ? (((char *)mci) + ((unsigned long)pvt)) : NULL;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800187
Doug Thompsonb8f6f972007-07-19 01:50:26 -0700188 /* setup index and various internal pointers */
189 mci->mc_idx = edac_index;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800190 mci->csrows = csi;
191 mci->pvt_info = pvt;
192 mci->nr_csrows = nr_csrows;
193
194 for (row = 0; row < nr_csrows; row++) {
195 csrow = &csi[row];
196 csrow->csrow_idx = row;
197 csrow->mci = mci;
198 csrow->nr_channels = nr_chans;
199 chp = &chi[row * nr_chans];
200 csrow->channels = chp;
201
202 for (chn = 0; chn < nr_chans; chn++) {
203 chan = &chp[chn];
204 chan->chan_idx = chn;
205 chan->csrow = csrow;
206 }
207 }
208
Dave Jiang81d87cb2007-07-19 01:49:52 -0700209 mci->op_state = OP_ALLOC;
Mauro Carvalho Chehab6fe11082010-08-12 00:30:25 -0300210 INIT_LIST_HEAD(&mci->grp_kobj_list);
Dave Jiang81d87cb2007-07-19 01:49:52 -0700211
Doug Thompson8096cfa2007-07-19 01:50:27 -0700212 /*
213 * Initialize the 'root' kobj for the edac_mc controller
214 */
215 err = edac_mc_register_sysfs_main_kobj(mci);
216 if (err) {
217 kfree(mci);
218 return NULL;
219 }
220
221 /* at this point, the root kobj is valid, and in order to
222 * 'free' the object, then the function:
223 * edac_mc_unregister_sysfs_main_kobj() must be called
224 * which will perform kobj unregistration and the actual free
225 * will occur during the kobject callback operation
226 */
Alan Coxda9bb1d2006-01-18 17:44:13 -0800227 return mci;
228}
Dave Peterson91105402006-03-26 01:38:55 -0800229EXPORT_SYMBOL_GPL(edac_mc_alloc);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800230
Alan Coxda9bb1d2006-01-18 17:44:13 -0800231/**
Doug Thompson8096cfa2007-07-19 01:50:27 -0700232 * edac_mc_free
233 * 'Free' a previously allocated 'mci' structure
Alan Coxda9bb1d2006-01-18 17:44:13 -0800234 * @mci: pointer to a struct mem_ctl_info structure
Alan Coxda9bb1d2006-01-18 17:44:13 -0800235 */
236void edac_mc_free(struct mem_ctl_info *mci)
237{
Mauro Carvalho Chehabbbc560a2010-08-16 18:22:43 -0300238 debugf1("%s()\n", __func__);
239
Doug Thompson8096cfa2007-07-19 01:50:27 -0700240 edac_mc_unregister_sysfs_main_kobj(mci);
Mauro Carvalho Chehabaccf74f2010-08-16 18:34:37 -0300241
242 /* free the mci instance memory here */
243 kfree(mci);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800244}
Dave Peterson91105402006-03-26 01:38:55 -0800245EXPORT_SYMBOL_GPL(edac_mc_free);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800246
Doug Thompsonbce19682007-07-26 10:41:14 -0700247
Mauro Carvalho Chehab939747bd2010-08-10 11:22:01 -0300248/**
Doug Thompsonbce19682007-07-26 10:41:14 -0700249 * find_mci_by_dev
250 *
251 * scan list of controllers looking for the one that manages
252 * the 'dev' device
Mauro Carvalho Chehab939747bd2010-08-10 11:22:01 -0300253 * @dev: pointer to a struct device related with the MCI
Doug Thompsonbce19682007-07-26 10:41:14 -0700254 */
Mauro Carvalho Chehab939747bd2010-08-10 11:22:01 -0300255struct mem_ctl_info *find_mci_by_dev(struct device *dev)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800256{
257 struct mem_ctl_info *mci;
258 struct list_head *item;
259
Dave Peterson537fba22006-03-26 01:38:40 -0800260 debugf3("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800261
262 list_for_each(item, &mc_devices) {
263 mci = list_entry(item, struct mem_ctl_info, link);
264
Doug Thompson37f04582006-06-30 01:56:07 -0700265 if (mci->dev == dev)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800266 return mci;
267 }
268
269 return NULL;
270}
Mauro Carvalho Chehab939747bd2010-08-10 11:22:01 -0300271EXPORT_SYMBOL_GPL(find_mci_by_dev);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800272
Dave Jiang81d87cb2007-07-19 01:49:52 -0700273/*
274 * handler for EDAC to check if NMI type handler has asserted interrupt
275 */
276static int edac_mc_assert_error_check_and_clear(void)
277{
Dave Jiang66ee2f92007-07-19 01:49:54 -0700278 int old_state;
Dave Jiang81d87cb2007-07-19 01:49:52 -0700279
Douglas Thompson079708b2007-07-19 01:49:58 -0700280 if (edac_op_state == EDAC_OPSTATE_POLL)
Dave Jiang81d87cb2007-07-19 01:49:52 -0700281 return 1;
282
Dave Jiang66ee2f92007-07-19 01:49:54 -0700283 old_state = edac_err_assert;
284 edac_err_assert = 0;
Dave Jiang81d87cb2007-07-19 01:49:52 -0700285
Dave Jiang66ee2f92007-07-19 01:49:54 -0700286 return old_state;
Dave Jiang81d87cb2007-07-19 01:49:52 -0700287}
288
289/*
290 * edac_mc_workq_function
291 * performs the operation scheduled by a workq request
292 */
Dave Jiang81d87cb2007-07-19 01:49:52 -0700293static void edac_mc_workq_function(struct work_struct *work_req)
294{
Jean Delvarefbeb4382009-04-13 14:40:21 -0700295 struct delayed_work *d_work = to_delayed_work(work_req);
Dave Jiang81d87cb2007-07-19 01:49:52 -0700296 struct mem_ctl_info *mci = to_edac_mem_ctl_work(d_work);
Dave Jiang81d87cb2007-07-19 01:49:52 -0700297
298 mutex_lock(&mem_ctls_mutex);
299
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700300 /* if this control struct has movd to offline state, we are done */
301 if (mci->op_state == OP_OFFLINE) {
302 mutex_unlock(&mem_ctls_mutex);
303 return;
304 }
305
Dave Jiang81d87cb2007-07-19 01:49:52 -0700306 /* Only poll controllers that are running polled and have a check */
307 if (edac_mc_assert_error_check_and_clear() && (mci->edac_check != NULL))
308 mci->edac_check(mci);
309
Dave Jiang81d87cb2007-07-19 01:49:52 -0700310 mutex_unlock(&mem_ctls_mutex);
311
312 /* Reschedule */
Dave Jiang4de78c62007-07-19 01:49:54 -0700313 queue_delayed_work(edac_workqueue, &mci->work,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700314 msecs_to_jiffies(edac_mc_get_poll_msec()));
Dave Jiang81d87cb2007-07-19 01:49:52 -0700315}
316
317/*
318 * edac_mc_workq_setup
319 * initialize a workq item for this mci
320 * passing in the new delay period in msec
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700321 *
322 * locking model:
323 *
324 * called with the mem_ctls_mutex held
Dave Jiang81d87cb2007-07-19 01:49:52 -0700325 */
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700326static void edac_mc_workq_setup(struct mem_ctl_info *mci, unsigned msec)
Dave Jiang81d87cb2007-07-19 01:49:52 -0700327{
328 debugf0("%s()\n", __func__);
329
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700330 /* if this instance is not in the POLL state, then simply return */
331 if (mci->op_state != OP_RUNNING_POLL)
332 return;
333
Dave Jiang81d87cb2007-07-19 01:49:52 -0700334 INIT_DELAYED_WORK(&mci->work, edac_mc_workq_function);
Dave Jiang81d87cb2007-07-19 01:49:52 -0700335 queue_delayed_work(edac_workqueue, &mci->work, msecs_to_jiffies(msec));
336}
337
338/*
339 * edac_mc_workq_teardown
340 * stop the workq processing on this mci
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700341 *
342 * locking model:
343 *
344 * called WITHOUT lock held
Dave Jiang81d87cb2007-07-19 01:49:52 -0700345 */
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700346static void edac_mc_workq_teardown(struct mem_ctl_info *mci)
Dave Jiang81d87cb2007-07-19 01:49:52 -0700347{
348 int status;
349
Borislav Petkov00740c52010-09-26 12:42:23 +0200350 if (mci->op_state != OP_RUNNING_POLL)
351 return;
352
Doug Thompsonbce19682007-07-26 10:41:14 -0700353 status = cancel_delayed_work(&mci->work);
354 if (status == 0) {
355 debugf0("%s() not canceled, flush the queue\n",
356 __func__);
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700357
Doug Thompsonbce19682007-07-26 10:41:14 -0700358 /* workq instance might be running, wait for it */
359 flush_workqueue(edac_workqueue);
Dave Jiang81d87cb2007-07-19 01:49:52 -0700360 }
361}
362
363/*
Doug Thompsonbce19682007-07-26 10:41:14 -0700364 * edac_mc_reset_delay_period(unsigned long value)
365 *
366 * user space has updated our poll period value, need to
367 * reset our workq delays
Dave Jiang81d87cb2007-07-19 01:49:52 -0700368 */
Doug Thompsonbce19682007-07-26 10:41:14 -0700369void edac_mc_reset_delay_period(int value)
Dave Jiang81d87cb2007-07-19 01:49:52 -0700370{
Doug Thompsonbce19682007-07-26 10:41:14 -0700371 struct mem_ctl_info *mci;
372 struct list_head *item;
Dave Jiang81d87cb2007-07-19 01:49:52 -0700373
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700374 mutex_lock(&mem_ctls_mutex);
375
Doug Thompsonbce19682007-07-26 10:41:14 -0700376 /* scan the list and turn off all workq timers, doing so under lock
377 */
378 list_for_each(item, &mc_devices) {
379 mci = list_entry(item, struct mem_ctl_info, link);
380
381 if (mci->op_state == OP_RUNNING_POLL)
382 cancel_delayed_work(&mci->work);
383 }
384
385 mutex_unlock(&mem_ctls_mutex);
386
387
388 /* re-walk the list, and reset the poll delay */
389 mutex_lock(&mem_ctls_mutex);
390
391 list_for_each(item, &mc_devices) {
392 mci = list_entry(item, struct mem_ctl_info, link);
393
394 edac_mc_workq_setup(mci, (unsigned long) value);
395 }
Dave Jiang81d87cb2007-07-19 01:49:52 -0700396
397 mutex_unlock(&mem_ctls_mutex);
398}
399
Doug Thompsonbce19682007-07-26 10:41:14 -0700400
401
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700402/* Return 0 on success, 1 on failure.
403 * Before calling this function, caller must
404 * assign a unique value to mci->mc_idx.
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700405 *
406 * locking model:
407 *
408 * called with the mem_ctls_mutex lock held
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700409 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700410static int add_mc_to_global_list(struct mem_ctl_info *mci)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800411{
412 struct list_head *item, *insert_before;
413 struct mem_ctl_info *p;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800414
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700415 insert_before = &mc_devices;
416
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700417 p = find_mci_by_dev(mci->dev);
418 if (unlikely(p != NULL))
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700419 goto fail0;
420
421 list_for_each(item, &mc_devices) {
422 p = list_entry(item, struct mem_ctl_info, link);
423
424 if (p->mc_idx >= mci->mc_idx) {
425 if (unlikely(p->mc_idx == mci->mc_idx))
426 goto fail1;
427
428 insert_before = item;
429 break;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800430 }
Alan Coxda9bb1d2006-01-18 17:44:13 -0800431 }
432
433 list_add_tail_rcu(&mci->link, insert_before);
Dave Jiangc0d12172007-07-19 01:49:46 -0700434 atomic_inc(&edac_handlers);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800435 return 0;
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700436
Douglas Thompson052dfb42007-07-19 01:50:13 -0700437fail0:
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700438 edac_printk(KERN_WARNING, EDAC_MC,
Kay Sievers281efb12009-01-06 14:42:57 -0800439 "%s (%s) %s %s already assigned %d\n", dev_name(p->dev),
Stephen Rothwell17aa7e02008-05-05 13:54:19 +1000440 edac_dev_name(mci), p->mod_name, p->ctl_name, p->mc_idx);
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700441 return 1;
442
Douglas Thompson052dfb42007-07-19 01:50:13 -0700443fail1:
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700444 edac_printk(KERN_WARNING, EDAC_MC,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700445 "bug in low-level driver: attempt to assign\n"
446 " duplicate mc_idx %d in %s()\n", p->mc_idx, __func__);
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700447 return 1;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800448}
449
Dave Petersone7ecd892006-03-26 01:38:52 -0800450static void complete_mc_list_del(struct rcu_head *head)
Dave Petersona1d03fc2006-03-26 01:38:46 -0800451{
452 struct mem_ctl_info *mci;
453
454 mci = container_of(head, struct mem_ctl_info, rcu);
455 INIT_LIST_HEAD(&mci->link);
Dave Petersona1d03fc2006-03-26 01:38:46 -0800456}
457
Dave Petersone7ecd892006-03-26 01:38:52 -0800458static void del_mc_from_global_list(struct mem_ctl_info *mci)
Dave Petersona1d03fc2006-03-26 01:38:46 -0800459{
Dave Jiangc0d12172007-07-19 01:49:46 -0700460 atomic_dec(&edac_handlers);
Dave Petersona1d03fc2006-03-26 01:38:46 -0800461 list_del_rcu(&mci->link);
Dave Petersona1d03fc2006-03-26 01:38:46 -0800462 call_rcu(&mci->rcu, complete_mc_list_del);
Jesper Dangaard Brouer458e5ff2009-09-23 15:57:29 -0700463 rcu_barrier();
Dave Petersona1d03fc2006-03-26 01:38:46 -0800464}
465
Alan Coxda9bb1d2006-01-18 17:44:13 -0800466/**
Douglas Thompson5da08312007-07-19 01:49:31 -0700467 * edac_mc_find: Search for a mem_ctl_info structure whose index is 'idx'.
468 *
469 * If found, return a pointer to the structure.
470 * Else return NULL.
471 *
472 * Caller must hold mem_ctls_mutex.
473 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700474struct mem_ctl_info *edac_mc_find(int idx)
Douglas Thompson5da08312007-07-19 01:49:31 -0700475{
476 struct list_head *item;
477 struct mem_ctl_info *mci;
478
479 list_for_each(item, &mc_devices) {
480 mci = list_entry(item, struct mem_ctl_info, link);
481
482 if (mci->mc_idx >= idx) {
483 if (mci->mc_idx == idx)
484 return mci;
485
486 break;
487 }
488 }
489
490 return NULL;
491}
492EXPORT_SYMBOL(edac_mc_find);
493
494/**
Dave Peterson472678e2006-03-26 01:38:49 -0800495 * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
496 * create sysfs entries associated with mci structure
Alan Coxda9bb1d2006-01-18 17:44:13 -0800497 * @mci: pointer to the mci structure to be added to the list
Doug Thompson2d7bbb92006-06-30 01:56:08 -0700498 * @mc_idx: A unique numeric identifier to be assigned to the 'mci' structure.
Alan Coxda9bb1d2006-01-18 17:44:13 -0800499 *
500 * Return:
501 * 0 Success
502 * !0 Failure
503 */
504
505/* FIXME - should a warning be printed if no error detection? correction? */
Doug Thompsonb8f6f972007-07-19 01:50:26 -0700506int edac_mc_add_mc(struct mem_ctl_info *mci)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800507{
Dave Peterson537fba22006-03-26 01:38:40 -0800508 debugf0("%s()\n", __func__);
Doug Thompsonb8f6f972007-07-19 01:50:26 -0700509
Alan Coxda9bb1d2006-01-18 17:44:13 -0800510#ifdef CONFIG_EDAC_DEBUG
511 if (edac_debug_level >= 3)
512 edac_mc_dump_mci(mci);
Dave Petersone7ecd892006-03-26 01:38:52 -0800513
Alan Coxda9bb1d2006-01-18 17:44:13 -0800514 if (edac_debug_level >= 4) {
515 int i;
516
517 for (i = 0; i < mci->nr_csrows; i++) {
518 int j;
Dave Petersone7ecd892006-03-26 01:38:52 -0800519
Alan Coxda9bb1d2006-01-18 17:44:13 -0800520 edac_mc_dump_csrow(&mci->csrows[i]);
521 for (j = 0; j < mci->csrows[i].nr_channels; j++)
Douglas Thompson079708b2007-07-19 01:49:58 -0700522 edac_mc_dump_channel(&mci->csrows[i].
Douglas Thompson052dfb42007-07-19 01:50:13 -0700523 channels[j]);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800524 }
525 }
526#endif
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700527 mutex_lock(&mem_ctls_mutex);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800528
529 if (add_mc_to_global_list(mci))
Dave Peterson028a7b62006-03-26 01:38:47 -0800530 goto fail0;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800531
532 /* set load time so that error rate can be tracked */
533 mci->start_time = jiffies;
534
eric wollesen9794f332007-02-12 00:53:08 -0800535 if (edac_create_sysfs_mci_device(mci)) {
536 edac_mc_printk(mci, KERN_WARNING,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700537 "failed to create sysfs device\n");
eric wollesen9794f332007-02-12 00:53:08 -0800538 goto fail1;
539 }
Alan Coxda9bb1d2006-01-18 17:44:13 -0800540
Dave Jiang81d87cb2007-07-19 01:49:52 -0700541 /* If there IS a check routine, then we are running POLLED */
542 if (mci->edac_check != NULL) {
543 /* This instance is NOW RUNNING */
544 mci->op_state = OP_RUNNING_POLL;
545
546 edac_mc_workq_setup(mci, edac_mc_get_poll_msec());
547 } else {
548 mci->op_state = OP_RUNNING_INTERRUPT;
549 }
550
Alan Coxda9bb1d2006-01-18 17:44:13 -0800551 /* Report action taken */
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700552 edac_mc_printk(mci, KERN_INFO, "Giving out device to '%s' '%s':"
Stephen Rothwell17aa7e02008-05-05 13:54:19 +1000553 " DEV %s\n", mci->mod_name, mci->ctl_name, edac_dev_name(mci));
Alan Coxda9bb1d2006-01-18 17:44:13 -0800554
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700555 mutex_unlock(&mem_ctls_mutex);
Dave Peterson028a7b62006-03-26 01:38:47 -0800556 return 0;
557
Douglas Thompson052dfb42007-07-19 01:50:13 -0700558fail1:
Dave Peterson028a7b62006-03-26 01:38:47 -0800559 del_mc_from_global_list(mci);
560
Douglas Thompson052dfb42007-07-19 01:50:13 -0700561fail0:
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700562 mutex_unlock(&mem_ctls_mutex);
Dave Peterson028a7b62006-03-26 01:38:47 -0800563 return 1;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800564}
Dave Peterson91105402006-03-26 01:38:55 -0800565EXPORT_SYMBOL_GPL(edac_mc_add_mc);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800566
Alan Coxda9bb1d2006-01-18 17:44:13 -0800567/**
Dave Peterson472678e2006-03-26 01:38:49 -0800568 * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
569 * remove mci structure from global list
Doug Thompson37f04582006-06-30 01:56:07 -0700570 * @pdev: Pointer to 'struct device' representing mci structure to remove.
Alan Coxda9bb1d2006-01-18 17:44:13 -0800571 *
Dave Peterson18dbc332006-03-26 01:38:50 -0800572 * Return pointer to removed mci structure, or NULL if device not found.
Alan Coxda9bb1d2006-01-18 17:44:13 -0800573 */
Douglas Thompson079708b2007-07-19 01:49:58 -0700574struct mem_ctl_info *edac_mc_del_mc(struct device *dev)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800575{
Dave Peterson18dbc332006-03-26 01:38:50 -0800576 struct mem_ctl_info *mci;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800577
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700578 debugf0("%s()\n", __func__);
579
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700580 mutex_lock(&mem_ctls_mutex);
Dave Peterson18dbc332006-03-26 01:38:50 -0800581
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700582 /* find the requested mci struct in the global list */
583 mci = find_mci_by_dev(dev);
584 if (mci == NULL) {
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700585 mutex_unlock(&mem_ctls_mutex);
Dave Peterson18dbc332006-03-26 01:38:50 -0800586 return NULL;
587 }
588
Alan Coxda9bb1d2006-01-18 17:44:13 -0800589 del_mc_from_global_list(mci);
Matthias Kaehlcke63b7df92007-07-19 01:49:38 -0700590 mutex_unlock(&mem_ctls_mutex);
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700591
Borislav Petkovbb31b3122010-12-02 17:48:35 +0100592 /* flush workq processes */
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700593 edac_mc_workq_teardown(mci);
Borislav Petkovbb31b3122010-12-02 17:48:35 +0100594
595 /* marking MCI offline */
596 mci->op_state = OP_OFFLINE;
597
598 /* remove from sysfs */
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700599 edac_remove_sysfs_mci_device(mci);
600
Dave Peterson537fba22006-03-26 01:38:40 -0800601 edac_printk(KERN_INFO, EDAC_MC,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700602 "Removed device %d for %s %s: DEV %s\n", mci->mc_idx,
Stephen Rothwell17aa7e02008-05-05 13:54:19 +1000603 mci->mod_name, mci->ctl_name, edac_dev_name(mci));
Doug Thompsonbf52fa42007-07-19 01:50:30 -0700604
Dave Peterson18dbc332006-03-26 01:38:50 -0800605 return mci;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800606}
Dave Peterson91105402006-03-26 01:38:55 -0800607EXPORT_SYMBOL_GPL(edac_mc_del_mc);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800608
Adrian Bunk2da1c112007-07-19 01:49:32 -0700609static void edac_mc_scrub_block(unsigned long page, unsigned long offset,
610 u32 size)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800611{
612 struct page *pg;
613 void *virt_addr;
614 unsigned long flags = 0;
615
Dave Peterson537fba22006-03-26 01:38:40 -0800616 debugf3("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800617
618 /* ECC error page was not in our memory. Ignore it. */
Douglas Thompson079708b2007-07-19 01:49:58 -0700619 if (!pfn_valid(page))
Alan Coxda9bb1d2006-01-18 17:44:13 -0800620 return;
621
622 /* Find the actual page structure then map it and fix */
623 pg = pfn_to_page(page);
624
625 if (PageHighMem(pg))
626 local_irq_save(flags);
627
628 virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);
629
630 /* Perform architecture specific atomic scrub operation */
631 atomic_scrub(virt_addr + offset, size);
632
633 /* Unmap and complete */
634 kunmap_atomic(virt_addr, KM_BOUNCE_READ);
635
636 if (PageHighMem(pg))
637 local_irq_restore(flags);
638}
639
Alan Coxda9bb1d2006-01-18 17:44:13 -0800640/* FIXME - should return -1 */
Dave Petersone7ecd892006-03-26 01:38:52 -0800641int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci, unsigned long page)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800642{
643 struct csrow_info *csrows = mci->csrows;
644 int row, i;
645
Dave Peterson537fba22006-03-26 01:38:40 -0800646 debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800647 row = -1;
648
649 for (i = 0; i < mci->nr_csrows; i++) {
650 struct csrow_info *csrow = &csrows[i];
651
652 if (csrow->nr_pages == 0)
653 continue;
654
Dave Peterson537fba22006-03-26 01:38:40 -0800655 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
656 "mask(0x%lx)\n", mci->mc_idx, __func__,
657 csrow->first_page, page, csrow->last_page,
658 csrow->page_mask);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800659
660 if ((page >= csrow->first_page) &&
661 (page <= csrow->last_page) &&
662 ((page & csrow->page_mask) ==
663 (csrow->first_page & csrow->page_mask))) {
664 row = i;
665 break;
666 }
667 }
668
669 if (row == -1)
Dave Peterson537fba22006-03-26 01:38:40 -0800670 edac_mc_printk(mci, KERN_ERR,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700671 "could not look up page error address %lx\n",
672 (unsigned long)page);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800673
674 return row;
675}
Dave Peterson91105402006-03-26 01:38:55 -0800676EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800677
Alan Coxda9bb1d2006-01-18 17:44:13 -0800678/* FIXME - setable log (warning/emerg) levels */
679/* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
680void edac_mc_handle_ce(struct mem_ctl_info *mci,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700681 unsigned long page_frame_number,
682 unsigned long offset_in_page, unsigned long syndrome,
683 int row, int channel, const char *msg)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800684{
685 unsigned long remapped_page;
686
Dave Peterson537fba22006-03-26 01:38:40 -0800687 debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800688
689 /* FIXME - maybe make panic on INTERNAL ERROR an option */
690 if (row >= mci->nr_csrows || row < 0) {
691 /* something is wrong */
Dave Peterson537fba22006-03-26 01:38:40 -0800692 edac_mc_printk(mci, KERN_ERR,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700693 "INTERNAL ERROR: row out of range "
694 "(%d >= %d)\n", row, mci->nr_csrows);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800695 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
696 return;
697 }
Dave Petersone7ecd892006-03-26 01:38:52 -0800698
Alan Coxda9bb1d2006-01-18 17:44:13 -0800699 if (channel >= mci->csrows[row].nr_channels || channel < 0) {
700 /* something is wrong */
Dave Peterson537fba22006-03-26 01:38:40 -0800701 edac_mc_printk(mci, KERN_ERR,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700702 "INTERNAL ERROR: channel out of range "
703 "(%d >= %d)\n", channel,
704 mci->csrows[row].nr_channels);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800705 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
706 return;
707 }
708
Dave Jiang4de78c62007-07-19 01:49:54 -0700709 if (edac_mc_get_log_ce())
Alan Coxda9bb1d2006-01-18 17:44:13 -0800710 /* FIXME - put in DIMM location */
Dave Peterson537fba22006-03-26 01:38:40 -0800711 edac_mc_printk(mci, KERN_WARNING,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700712 "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
713 "0x%lx, row %d, channel %d, label \"%s\": %s\n",
714 page_frame_number, offset_in_page,
715 mci->csrows[row].grain, syndrome, row, channel,
716 mci->csrows[row].channels[channel].label, msg);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800717
718 mci->ce_count++;
719 mci->csrows[row].ce_count++;
720 mci->csrows[row].channels[channel].ce_count++;
721
722 if (mci->scrub_mode & SCRUB_SW_SRC) {
723 /*
724 * Some MC's can remap memory so that it is still available
725 * at a different address when PCI devices map into memory.
726 * MC's that can't do this lose the memory where PCI devices
727 * are mapped. This mapping is MC dependant and so we call
728 * back into the MC driver for it to map the MC page to
729 * a physical (CPU) page which can then be mapped to a virtual
730 * page - which can then be scrubbed.
731 */
732 remapped_page = mci->ctl_page_to_phys ?
Douglas Thompson052dfb42007-07-19 01:50:13 -0700733 mci->ctl_page_to_phys(mci, page_frame_number) :
734 page_frame_number;
Alan Coxda9bb1d2006-01-18 17:44:13 -0800735
736 edac_mc_scrub_block(remapped_page, offset_in_page,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700737 mci->csrows[row].grain);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800738 }
739}
Dave Peterson91105402006-03-26 01:38:55 -0800740EXPORT_SYMBOL_GPL(edac_mc_handle_ce);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800741
Dave Petersone7ecd892006-03-26 01:38:52 -0800742void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci, const char *msg)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800743{
Dave Jiang4de78c62007-07-19 01:49:54 -0700744 if (edac_mc_get_log_ce())
Dave Peterson537fba22006-03-26 01:38:40 -0800745 edac_mc_printk(mci, KERN_WARNING,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700746 "CE - no information available: %s\n", msg);
Dave Petersone7ecd892006-03-26 01:38:52 -0800747
Alan Coxda9bb1d2006-01-18 17:44:13 -0800748 mci->ce_noinfo_count++;
749 mci->ce_count++;
750}
Dave Peterson91105402006-03-26 01:38:55 -0800751EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800752
Alan Coxda9bb1d2006-01-18 17:44:13 -0800753void edac_mc_handle_ue(struct mem_ctl_info *mci,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700754 unsigned long page_frame_number,
755 unsigned long offset_in_page, int row, const char *msg)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800756{
757 int len = EDAC_MC_LABEL_LEN * 4;
758 char labels[len + 1];
759 char *pos = labels;
760 int chan;
761 int chars;
762
Dave Peterson537fba22006-03-26 01:38:40 -0800763 debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800764
765 /* FIXME - maybe make panic on INTERNAL ERROR an option */
766 if (row >= mci->nr_csrows || row < 0) {
767 /* something is wrong */
Dave Peterson537fba22006-03-26 01:38:40 -0800768 edac_mc_printk(mci, KERN_ERR,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700769 "INTERNAL ERROR: row out of range "
770 "(%d >= %d)\n", row, mci->nr_csrows);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800771 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
772 return;
773 }
774
775 chars = snprintf(pos, len + 1, "%s",
Douglas Thompson079708b2007-07-19 01:49:58 -0700776 mci->csrows[row].channels[0].label);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800777 len -= chars;
778 pos += chars;
Dave Petersone7ecd892006-03-26 01:38:52 -0800779
Alan Coxda9bb1d2006-01-18 17:44:13 -0800780 for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
Douglas Thompson052dfb42007-07-19 01:50:13 -0700781 chan++) {
Alan Coxda9bb1d2006-01-18 17:44:13 -0800782 chars = snprintf(pos, len + 1, ":%s",
Douglas Thompson079708b2007-07-19 01:49:58 -0700783 mci->csrows[row].channels[chan].label);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800784 len -= chars;
785 pos += chars;
786 }
787
Dave Jiang4de78c62007-07-19 01:49:54 -0700788 if (edac_mc_get_log_ue())
Dave Peterson537fba22006-03-26 01:38:40 -0800789 edac_mc_printk(mci, KERN_EMERG,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700790 "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
791 "labels \"%s\": %s\n", page_frame_number,
792 offset_in_page, mci->csrows[row].grain, row,
793 labels, msg);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800794
Dave Jiang4de78c62007-07-19 01:49:54 -0700795 if (edac_mc_get_panic_on_ue())
Dave Petersone7ecd892006-03-26 01:38:52 -0800796 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
Douglas Thompson052dfb42007-07-19 01:50:13 -0700797 "row %d, labels \"%s\": %s\n", mci->mc_idx,
798 page_frame_number, offset_in_page,
799 mci->csrows[row].grain, row, labels, msg);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800800
801 mci->ue_count++;
802 mci->csrows[row].ue_count++;
803}
Dave Peterson91105402006-03-26 01:38:55 -0800804EXPORT_SYMBOL_GPL(edac_mc_handle_ue);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800805
Dave Petersone7ecd892006-03-26 01:38:52 -0800806void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci, const char *msg)
Alan Coxda9bb1d2006-01-18 17:44:13 -0800807{
Dave Jiang4de78c62007-07-19 01:49:54 -0700808 if (edac_mc_get_panic_on_ue())
Alan Coxda9bb1d2006-01-18 17:44:13 -0800809 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
810
Dave Jiang4de78c62007-07-19 01:49:54 -0700811 if (edac_mc_get_log_ue())
Dave Peterson537fba22006-03-26 01:38:40 -0800812 edac_mc_printk(mci, KERN_WARNING,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700813 "UE - no information available: %s\n", msg);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800814 mci->ue_noinfo_count++;
815 mci->ue_count++;
816}
Douglas Thompson079708b2007-07-19 01:49:58 -0700817EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800818
eric wollesen9794f332007-02-12 00:53:08 -0800819/*************************************************************
820 * On Fully Buffered DIMM modules, this help function is
821 * called to process UE events
822 */
823void edac_mc_handle_fbd_ue(struct mem_ctl_info *mci,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700824 unsigned int csrow,
825 unsigned int channela,
826 unsigned int channelb, char *msg)
eric wollesen9794f332007-02-12 00:53:08 -0800827{
828 int len = EDAC_MC_LABEL_LEN * 4;
829 char labels[len + 1];
830 char *pos = labels;
831 int chars;
832
833 if (csrow >= mci->nr_csrows) {
834 /* something is wrong */
835 edac_mc_printk(mci, KERN_ERR,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700836 "INTERNAL ERROR: row out of range (%d >= %d)\n",
837 csrow, mci->nr_csrows);
eric wollesen9794f332007-02-12 00:53:08 -0800838 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
839 return;
840 }
841
842 if (channela >= mci->csrows[csrow].nr_channels) {
843 /* something is wrong */
844 edac_mc_printk(mci, KERN_ERR,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700845 "INTERNAL ERROR: channel-a out of range "
846 "(%d >= %d)\n",
847 channela, mci->csrows[csrow].nr_channels);
eric wollesen9794f332007-02-12 00:53:08 -0800848 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
849 return;
850 }
851
852 if (channelb >= mci->csrows[csrow].nr_channels) {
853 /* something is wrong */
854 edac_mc_printk(mci, KERN_ERR,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700855 "INTERNAL ERROR: channel-b out of range "
856 "(%d >= %d)\n",
857 channelb, mci->csrows[csrow].nr_channels);
eric wollesen9794f332007-02-12 00:53:08 -0800858 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
859 return;
860 }
861
862 mci->ue_count++;
863 mci->csrows[csrow].ue_count++;
864
865 /* Generate the DIMM labels from the specified channels */
866 chars = snprintf(pos, len + 1, "%s",
867 mci->csrows[csrow].channels[channela].label);
Douglas Thompson079708b2007-07-19 01:49:58 -0700868 len -= chars;
869 pos += chars;
eric wollesen9794f332007-02-12 00:53:08 -0800870 chars = snprintf(pos, len + 1, "-%s",
871 mci->csrows[csrow].channels[channelb].label);
872
Dave Jiang4de78c62007-07-19 01:49:54 -0700873 if (edac_mc_get_log_ue())
eric wollesen9794f332007-02-12 00:53:08 -0800874 edac_mc_printk(mci, KERN_EMERG,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700875 "UE row %d, channel-a= %d channel-b= %d "
876 "labels \"%s\": %s\n", csrow, channela, channelb,
877 labels, msg);
eric wollesen9794f332007-02-12 00:53:08 -0800878
Dave Jiang4de78c62007-07-19 01:49:54 -0700879 if (edac_mc_get_panic_on_ue())
eric wollesen9794f332007-02-12 00:53:08 -0800880 panic("UE row %d, channel-a= %d channel-b= %d "
Douglas Thompson052dfb42007-07-19 01:50:13 -0700881 "labels \"%s\": %s\n", csrow, channela,
882 channelb, labels, msg);
eric wollesen9794f332007-02-12 00:53:08 -0800883}
884EXPORT_SYMBOL(edac_mc_handle_fbd_ue);
885
886/*************************************************************
887 * On Fully Buffered DIMM modules, this help function is
888 * called to process CE events
889 */
890void edac_mc_handle_fbd_ce(struct mem_ctl_info *mci,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700891 unsigned int csrow, unsigned int channel, char *msg)
eric wollesen9794f332007-02-12 00:53:08 -0800892{
893
894 /* Ensure boundary values */
895 if (csrow >= mci->nr_csrows) {
896 /* something is wrong */
897 edac_mc_printk(mci, KERN_ERR,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700898 "INTERNAL ERROR: row out of range (%d >= %d)\n",
899 csrow, mci->nr_csrows);
eric wollesen9794f332007-02-12 00:53:08 -0800900 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
901 return;
902 }
903 if (channel >= mci->csrows[csrow].nr_channels) {
904 /* something is wrong */
905 edac_mc_printk(mci, KERN_ERR,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700906 "INTERNAL ERROR: channel out of range (%d >= %d)\n",
907 channel, mci->csrows[csrow].nr_channels);
eric wollesen9794f332007-02-12 00:53:08 -0800908 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
909 return;
910 }
911
Dave Jiang4de78c62007-07-19 01:49:54 -0700912 if (edac_mc_get_log_ce())
eric wollesen9794f332007-02-12 00:53:08 -0800913 /* FIXME - put in DIMM location */
914 edac_mc_printk(mci, KERN_WARNING,
Douglas Thompson052dfb42007-07-19 01:50:13 -0700915 "CE row %d, channel %d, label \"%s\": %s\n",
916 csrow, channel,
917 mci->csrows[csrow].channels[channel].label, msg);
eric wollesen9794f332007-02-12 00:53:08 -0800918
919 mci->ce_count++;
920 mci->csrows[csrow].ce_count++;
921 mci->csrows[csrow].channels[channel].ce_count++;
922}
Douglas Thompson079708b2007-07-19 01:49:58 -0700923EXPORT_SYMBOL(edac_mc_handle_fbd_ce);