blob: 499ac90ad67e9d8db65dc55773a1650adf5017a1 [file] [log] [blame]
Alan Coxda9bb1d2006-01-18 17:44:13 -08001/*
2 * edac_mc kernel module
3 * (C) 2005 Linux Networx (http://lnxi.com)
4 * 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
15
16#include <linux/config.h>
Alan Coxda9bb1d2006-01-18 17:44:13 -080017#include <linux/module.h>
18#include <linux/proc_fs.h>
19#include <linux/kernel.h>
20#include <linux/types.h>
21#include <linux/smp.h>
22#include <linux/init.h>
23#include <linux/sysctl.h>
24#include <linux/highmem.h>
25#include <linux/timer.h>
26#include <linux/slab.h>
27#include <linux/jiffies.h>
28#include <linux/spinlock.h>
29#include <linux/list.h>
30#include <linux/sysdev.h>
31#include <linux/ctype.h>
Dave Petersonf2fe42a2006-03-26 01:38:38 -080032#include <linux/kthread.h>
Alan Coxda9bb1d2006-01-18 17:44:13 -080033
34#include <asm/uaccess.h>
35#include <asm/page.h>
36#include <asm/edac.h>
37
38#include "edac_mc.h"
39
Dave Peterson537fba22006-03-26 01:38:40 -080040#define EDAC_MC_VERSION "Ver: 2.0.0 " __DATE__
Alan Coxda9bb1d2006-01-18 17:44:13 -080041
Dave Petersonceb2ca92006-03-13 21:20:50 -080042/* For now, disable the EDAC sysfs code. The sysfs interface that EDAC
43 * presents to user space needs more thought, and is likely to change
44 * substantially.
45 */
46#define DISABLE_EDAC_SYSFS
47
Alan Coxda9bb1d2006-01-18 17:44:13 -080048#ifdef CONFIG_EDAC_DEBUG
49/* Values of 0 to 4 will generate output */
50int edac_debug_level = 1;
51EXPORT_SYMBOL(edac_debug_level);
52#endif
53
54/* EDAC Controls, setable by module parameter, and sysfs */
55static int log_ue = 1;
56static int log_ce = 1;
Dave Petersonceb2ca92006-03-13 21:20:50 -080057static int panic_on_ue;
Alan Coxda9bb1d2006-01-18 17:44:13 -080058static int poll_msec = 1000;
59
60static int check_pci_parity = 0; /* default YES check PCI parity */
61static int panic_on_pci_parity; /* default no panic on PCI Parity */
62static atomic_t pci_parity_count = ATOMIC_INIT(0);
63
64/* lock to memory controller's control array */
65static DECLARE_MUTEX(mem_ctls_mutex);
66static struct list_head mc_devices = LIST_HEAD_INIT(mc_devices);
67
Dave Petersonf2fe42a2006-03-26 01:38:38 -080068static struct task_struct *edac_thread;
69
Alan Coxda9bb1d2006-01-18 17:44:13 -080070/* Structure of the whitelist and blacklist arrays */
71struct edac_pci_device_list {
72 unsigned int vendor; /* Vendor ID */
73 unsigned int device; /* Deviice ID */
74};
75
76
77#define MAX_LISTED_PCI_DEVICES 32
78
79/* List of PCI devices (vendor-id:device-id) that should be skipped */
80static struct edac_pci_device_list pci_blacklist[MAX_LISTED_PCI_DEVICES];
81static int pci_blacklist_count;
82
83/* List of PCI devices (vendor-id:device-id) that should be scanned */
84static struct edac_pci_device_list pci_whitelist[MAX_LISTED_PCI_DEVICES];
85static int pci_whitelist_count ;
86
87/* START sysfs data and methods */
88
Dave Petersonceb2ca92006-03-13 21:20:50 -080089#ifndef DISABLE_EDAC_SYSFS
90
Alan Coxda9bb1d2006-01-18 17:44:13 -080091static const char *mem_types[] = {
92 [MEM_EMPTY] = "Empty",
93 [MEM_RESERVED] = "Reserved",
94 [MEM_UNKNOWN] = "Unknown",
95 [MEM_FPM] = "FPM",
96 [MEM_EDO] = "EDO",
97 [MEM_BEDO] = "BEDO",
98 [MEM_SDR] = "Unbuffered-SDR",
99 [MEM_RDR] = "Registered-SDR",
100 [MEM_DDR] = "Unbuffered-DDR",
101 [MEM_RDDR] = "Registered-DDR",
102 [MEM_RMBS] = "RMBS"
103};
104
105static const char *dev_types[] = {
106 [DEV_UNKNOWN] = "Unknown",
107 [DEV_X1] = "x1",
108 [DEV_X2] = "x2",
109 [DEV_X4] = "x4",
110 [DEV_X8] = "x8",
111 [DEV_X16] = "x16",
112 [DEV_X32] = "x32",
113 [DEV_X64] = "x64"
114};
115
116static const char *edac_caps[] = {
117 [EDAC_UNKNOWN] = "Unknown",
118 [EDAC_NONE] = "None",
119 [EDAC_RESERVED] = "Reserved",
120 [EDAC_PARITY] = "PARITY",
121 [EDAC_EC] = "EC",
122 [EDAC_SECDED] = "SECDED",
123 [EDAC_S2ECD2ED] = "S2ECD2ED",
124 [EDAC_S4ECD4ED] = "S4ECD4ED",
125 [EDAC_S8ECD8ED] = "S8ECD8ED",
126 [EDAC_S16ECD16ED] = "S16ECD16ED"
127};
128
129
130/* sysfs object: /sys/devices/system/edac */
131static struct sysdev_class edac_class = {
132 set_kset_name("edac"),
133};
134
135/* sysfs objects:
136 * /sys/devices/system/edac/mc
137 * /sys/devices/system/edac/pci
138 */
139static struct kobject edac_memctrl_kobj;
140static struct kobject edac_pci_kobj;
141
142/*
143 * /sys/devices/system/edac/mc;
144 * data structures and methods
145 */
Arjan van de Ven4136cab2006-03-11 03:27:15 -0800146#if 0
Alan Coxda9bb1d2006-01-18 17:44:13 -0800147static ssize_t memctrl_string_show(void *ptr, char *buffer)
148{
149 char *value = (char*) ptr;
150 return sprintf(buffer, "%s\n", value);
151}
Arjan van de Ven4136cab2006-03-11 03:27:15 -0800152#endif
Alan Coxda9bb1d2006-01-18 17:44:13 -0800153
154static ssize_t memctrl_int_show(void *ptr, char *buffer)
155{
156 int *value = (int*) ptr;
157 return sprintf(buffer, "%d\n", *value);
158}
159
160static ssize_t memctrl_int_store(void *ptr, const char *buffer, size_t count)
161{
162 int *value = (int*) ptr;
163
164 if (isdigit(*buffer))
165 *value = simple_strtoul(buffer, NULL, 0);
166
167 return count;
168}
169
170struct memctrl_dev_attribute {
171 struct attribute attr;
172 void *value;
173 ssize_t (*show)(void *,char *);
174 ssize_t (*store)(void *, const char *, size_t);
175};
176
177/* Set of show/store abstract level functions for memory control object */
178static ssize_t
179memctrl_dev_show(struct kobject *kobj, struct attribute *attr, char *buffer)
180{
181 struct memctrl_dev_attribute *memctrl_dev;
182 memctrl_dev = (struct memctrl_dev_attribute*)attr;
183
184 if (memctrl_dev->show)
185 return memctrl_dev->show(memctrl_dev->value, buffer);
186 return -EIO;
187}
188
189static ssize_t
190memctrl_dev_store(struct kobject *kobj, struct attribute *attr,
191 const char *buffer, size_t count)
192{
193 struct memctrl_dev_attribute *memctrl_dev;
194 memctrl_dev = (struct memctrl_dev_attribute*)attr;
195
196 if (memctrl_dev->store)
197 return memctrl_dev->store(memctrl_dev->value, buffer, count);
198 return -EIO;
199}
200
201static struct sysfs_ops memctrlfs_ops = {
202 .show = memctrl_dev_show,
203 .store = memctrl_dev_store
204};
205
206#define MEMCTRL_ATTR(_name,_mode,_show,_store) \
207struct memctrl_dev_attribute attr_##_name = { \
208 .attr = {.name = __stringify(_name), .mode = _mode }, \
209 .value = &_name, \
210 .show = _show, \
211 .store = _store, \
212};
213
214#define MEMCTRL_STRING_ATTR(_name,_data,_mode,_show,_store) \
215struct memctrl_dev_attribute attr_##_name = { \
216 .attr = {.name = __stringify(_name), .mode = _mode }, \
217 .value = _data, \
218 .show = _show, \
219 .store = _store, \
220};
221
222/* cwrow<id> attribute f*/
Arjan van de Ven4136cab2006-03-11 03:27:15 -0800223#if 0
Alan Coxda9bb1d2006-01-18 17:44:13 -0800224MEMCTRL_STRING_ATTR(mc_version,EDAC_MC_VERSION,S_IRUGO,memctrl_string_show,NULL);
Arjan van de Ven4136cab2006-03-11 03:27:15 -0800225#endif
Alan Coxda9bb1d2006-01-18 17:44:13 -0800226
227/* csrow<id> control files */
228MEMCTRL_ATTR(panic_on_ue,S_IRUGO|S_IWUSR,memctrl_int_show,memctrl_int_store);
229MEMCTRL_ATTR(log_ue,S_IRUGO|S_IWUSR,memctrl_int_show,memctrl_int_store);
230MEMCTRL_ATTR(log_ce,S_IRUGO|S_IWUSR,memctrl_int_show,memctrl_int_store);
231MEMCTRL_ATTR(poll_msec,S_IRUGO|S_IWUSR,memctrl_int_show,memctrl_int_store);
232
233
234/* Base Attributes of the memory ECC object */
235static struct memctrl_dev_attribute *memctrl_attr[] = {
236 &attr_panic_on_ue,
237 &attr_log_ue,
238 &attr_log_ce,
239 &attr_poll_msec,
Alan Coxda9bb1d2006-01-18 17:44:13 -0800240 NULL,
241};
242
243/* Main MC kobject release() function */
244static void edac_memctrl_master_release(struct kobject *kobj)
245{
Dave Peterson537fba22006-03-26 01:38:40 -0800246 debugf1("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800247}
248
249static struct kobj_type ktype_memctrl = {
250 .release = edac_memctrl_master_release,
251 .sysfs_ops = &memctrlfs_ops,
252 .default_attrs = (struct attribute **) memctrl_attr,
253};
254
Dave Petersonceb2ca92006-03-13 21:20:50 -0800255#endif /* DISABLE_EDAC_SYSFS */
Alan Coxda9bb1d2006-01-18 17:44:13 -0800256
257/* Initialize the main sysfs entries for edac:
258 * /sys/devices/system/edac
259 *
260 * and children
261 *
262 * Return: 0 SUCCESS
263 * !0 FAILURE
264 */
265static int edac_sysfs_memctrl_setup(void)
Dave Petersonceb2ca92006-03-13 21:20:50 -0800266#ifdef DISABLE_EDAC_SYSFS
267{
268 return 0;
269}
270#else
Alan Coxda9bb1d2006-01-18 17:44:13 -0800271{
272 int err=0;
273
Dave Peterson537fba22006-03-26 01:38:40 -0800274 debugf1("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800275
276 /* create the /sys/devices/system/edac directory */
277 err = sysdev_class_register(&edac_class);
278 if (!err) {
279 /* Init the MC's kobject */
280 memset(&edac_memctrl_kobj, 0, sizeof (edac_memctrl_kobj));
281 kobject_init(&edac_memctrl_kobj);
282
283 edac_memctrl_kobj.parent = &edac_class.kset.kobj;
284 edac_memctrl_kobj.ktype = &ktype_memctrl;
285
286 /* generate sysfs "..../edac/mc" */
287 err = kobject_set_name(&edac_memctrl_kobj,"mc");
288 if (!err) {
289 /* FIXME: maybe new sysdev_create_subdir() */
290 err = kobject_register(&edac_memctrl_kobj);
291 if (err) {
292 debugf1("Failed to register '.../edac/mc'\n");
293 } else {
294 debugf1("Registered '.../edac/mc' kobject\n");
295 }
296 }
297 } else {
Dave Peterson537fba22006-03-26 01:38:40 -0800298 debugf1("%s() error=%d\n", __func__, err);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800299 }
300
301 return err;
302}
Dave Petersonceb2ca92006-03-13 21:20:50 -0800303#endif /* DISABLE_EDAC_SYSFS */
Alan Coxda9bb1d2006-01-18 17:44:13 -0800304
305/*
306 * MC teardown:
307 * the '..../edac/mc' kobject followed by '..../edac' itself
308 */
309static void edac_sysfs_memctrl_teardown(void)
310{
Dave Petersonceb2ca92006-03-13 21:20:50 -0800311#ifndef DISABLE_EDAC_SYSFS
Alan Coxda9bb1d2006-01-18 17:44:13 -0800312 debugf0("MC: " __FILE__ ": %s()\n", __func__);
313
314 /* Unregister the MC's kobject */
315 kobject_unregister(&edac_memctrl_kobj);
316
317 /* release the master edac mc kobject */
318 kobject_put(&edac_memctrl_kobj);
319
320 /* Unregister the 'edac' object */
321 sysdev_class_unregister(&edac_class);
Dave Petersonceb2ca92006-03-13 21:20:50 -0800322#endif /* DISABLE_EDAC_SYSFS */
Alan Coxda9bb1d2006-01-18 17:44:13 -0800323}
324
Dave Petersonceb2ca92006-03-13 21:20:50 -0800325#ifndef DISABLE_EDAC_SYSFS
326
Alan Coxda9bb1d2006-01-18 17:44:13 -0800327/*
328 * /sys/devices/system/edac/pci;
329 * data structures and methods
330 */
331
332struct list_control {
333 struct edac_pci_device_list *list;
334 int *count;
335};
336
Arjan van de Ven4136cab2006-03-11 03:27:15 -0800337
338#if 0
Alan Coxda9bb1d2006-01-18 17:44:13 -0800339/* Output the list as: vendor_id:device:id<,vendor_id:device_id> */
340static ssize_t edac_pci_list_string_show(void *ptr, char *buffer)
341{
342 struct list_control *listctl;
343 struct edac_pci_device_list *list;
344 char *p = buffer;
345 int len=0;
346 int i;
347
348 listctl = ptr;
349 list = listctl->list;
350
351 for (i = 0; i < *(listctl->count); i++, list++ ) {
352 if (len > 0)
353 len += snprintf(p + len, (PAGE_SIZE-len), ",");
354
355 len += snprintf(p + len,
356 (PAGE_SIZE-len),
357 "%x:%x",
358 list->vendor,list->device);
359 }
360
361 len += snprintf(p + len,(PAGE_SIZE-len), "\n");
362
363 return (ssize_t) len;
364}
365
366/**
367 *
368 * Scan string from **s to **e looking for one 'vendor:device' tuple
369 * where each field is a hex value
370 *
371 * return 0 if an entry is NOT found
372 * return 1 if an entry is found
373 * fill in *vendor_id and *device_id with values found
374 *
375 * In both cases, make sure *s has been moved forward toward *e
376 */
377static int parse_one_device(const char **s,const char **e,
378 unsigned int *vendor_id, unsigned int *device_id)
379{
380 const char *runner, *p;
381
382 /* if null byte, we are done */
383 if (!**s) {
384 (*s)++; /* keep *s moving */
385 return 0;
386 }
387
388 /* skip over newlines & whitespace */
389 if ((**s == '\n') || isspace(**s)) {
390 (*s)++;
391 return 0;
392 }
393
394 if (!isxdigit(**s)) {
395 (*s)++;
396 return 0;
397 }
398
399 /* parse vendor_id */
400 runner = *s;
401 while (runner < *e) {
402 /* scan for vendor:device delimiter */
403 if (*runner == ':') {
404 *vendor_id = simple_strtol((char*) *s, (char**) &p, 16);
405 runner = p + 1;
406 break;
407 }
408 runner++;
409 }
410
411 if (!isxdigit(*runner)) {
412 *s = ++runner;
413 return 0;
414 }
415
416 /* parse device_id */
417 if (runner < *e) {
418 *device_id = simple_strtol((char*)runner, (char**)&p, 16);
419 runner = p;
420 }
421
422 *s = runner;
423
424 return 1;
425}
426
427static ssize_t edac_pci_list_string_store(void *ptr, const char *buffer,
428 size_t count)
429{
430 struct list_control *listctl;
431 struct edac_pci_device_list *list;
432 unsigned int vendor_id, device_id;
433 const char *s, *e;
434 int *index;
435
436 s = (char*)buffer;
437 e = s + count;
438
439 listctl = ptr;
440 list = listctl->list;
441 index = listctl->count;
442
443 *index = 0;
444 while (*index < MAX_LISTED_PCI_DEVICES) {
445
446 if (parse_one_device(&s,&e,&vendor_id,&device_id)) {
447 list[ *index ].vendor = vendor_id;
448 list[ *index ].device = device_id;
449 (*index)++;
450 }
451
452 /* check for all data consume */
453 if (s >= e)
454 break;
455 }
456
457 return count;
458}
459
Arjan van de Ven4136cab2006-03-11 03:27:15 -0800460#endif
Alan Coxda9bb1d2006-01-18 17:44:13 -0800461static ssize_t edac_pci_int_show(void *ptr, char *buffer)
462{
463 int *value = ptr;
464 return sprintf(buffer,"%d\n",*value);
465}
466
467static ssize_t edac_pci_int_store(void *ptr, const char *buffer, size_t count)
468{
469 int *value = ptr;
470
471 if (isdigit(*buffer))
472 *value = simple_strtoul(buffer,NULL,0);
473
474 return count;
475}
476
477struct edac_pci_dev_attribute {
478 struct attribute attr;
479 void *value;
480 ssize_t (*show)(void *,char *);
481 ssize_t (*store)(void *, const char *,size_t);
482};
483
484/* Set of show/store abstract level functions for PCI Parity object */
485static ssize_t edac_pci_dev_show(struct kobject *kobj, struct attribute *attr,
486 char *buffer)
487{
488 struct edac_pci_dev_attribute *edac_pci_dev;
489 edac_pci_dev= (struct edac_pci_dev_attribute*)attr;
490
491 if (edac_pci_dev->show)
492 return edac_pci_dev->show(edac_pci_dev->value, buffer);
493 return -EIO;
494}
495
496static ssize_t edac_pci_dev_store(struct kobject *kobj, struct attribute *attr,
497 const char *buffer, size_t count)
498{
499 struct edac_pci_dev_attribute *edac_pci_dev;
500 edac_pci_dev= (struct edac_pci_dev_attribute*)attr;
501
502 if (edac_pci_dev->show)
503 return edac_pci_dev->store(edac_pci_dev->value, buffer, count);
504 return -EIO;
505}
506
507static struct sysfs_ops edac_pci_sysfs_ops = {
508 .show = edac_pci_dev_show,
509 .store = edac_pci_dev_store
510};
511
512
513#define EDAC_PCI_ATTR(_name,_mode,_show,_store) \
514struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
515 .attr = {.name = __stringify(_name), .mode = _mode }, \
516 .value = &_name, \
517 .show = _show, \
518 .store = _store, \
519};
520
521#define EDAC_PCI_STRING_ATTR(_name,_data,_mode,_show,_store) \
522struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
523 .attr = {.name = __stringify(_name), .mode = _mode }, \
524 .value = _data, \
525 .show = _show, \
526 .store = _store, \
527};
528
Arjan van de Ven4136cab2006-03-11 03:27:15 -0800529#if 0
Alan Coxda9bb1d2006-01-18 17:44:13 -0800530static struct list_control pci_whitelist_control = {
531 .list = pci_whitelist,
532 .count = &pci_whitelist_count
533};
534
535static struct list_control pci_blacklist_control = {
536 .list = pci_blacklist,
537 .count = &pci_blacklist_count
538};
539
540/* whitelist attribute */
541EDAC_PCI_STRING_ATTR(pci_parity_whitelist,
542 &pci_whitelist_control,
543 S_IRUGO|S_IWUSR,
544 edac_pci_list_string_show,
545 edac_pci_list_string_store);
546
547EDAC_PCI_STRING_ATTR(pci_parity_blacklist,
548 &pci_blacklist_control,
549 S_IRUGO|S_IWUSR,
550 edac_pci_list_string_show,
551 edac_pci_list_string_store);
Arjan van de Ven4136cab2006-03-11 03:27:15 -0800552#endif
Alan Coxda9bb1d2006-01-18 17:44:13 -0800553
554/* PCI Parity control files */
555EDAC_PCI_ATTR(check_pci_parity,S_IRUGO|S_IWUSR,edac_pci_int_show,edac_pci_int_store);
556EDAC_PCI_ATTR(panic_on_pci_parity,S_IRUGO|S_IWUSR,edac_pci_int_show,edac_pci_int_store);
557EDAC_PCI_ATTR(pci_parity_count,S_IRUGO,edac_pci_int_show,NULL);
558
559/* Base Attributes of the memory ECC object */
560static struct edac_pci_dev_attribute *edac_pci_attr[] = {
561 &edac_pci_attr_check_pci_parity,
562 &edac_pci_attr_panic_on_pci_parity,
563 &edac_pci_attr_pci_parity_count,
Alan Coxda9bb1d2006-01-18 17:44:13 -0800564 NULL,
565};
566
567/* No memory to release */
568static void edac_pci_release(struct kobject *kobj)
569{
Dave Peterson537fba22006-03-26 01:38:40 -0800570 debugf1("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800571}
572
573static struct kobj_type ktype_edac_pci = {
574 .release = edac_pci_release,
575 .sysfs_ops = &edac_pci_sysfs_ops,
576 .default_attrs = (struct attribute **) edac_pci_attr,
577};
578
Dave Petersonceb2ca92006-03-13 21:20:50 -0800579#endif /* DISABLE_EDAC_SYSFS */
580
Alan Coxda9bb1d2006-01-18 17:44:13 -0800581/**
582 * edac_sysfs_pci_setup()
583 *
584 */
585static int edac_sysfs_pci_setup(void)
Dave Petersonceb2ca92006-03-13 21:20:50 -0800586#ifdef DISABLE_EDAC_SYSFS
587{
588 return 0;
589}
590#else
Alan Coxda9bb1d2006-01-18 17:44:13 -0800591{
592 int err;
593
Dave Peterson537fba22006-03-26 01:38:40 -0800594 debugf1("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800595
596 memset(&edac_pci_kobj, 0, sizeof(edac_pci_kobj));
597
598 kobject_init(&edac_pci_kobj);
599 edac_pci_kobj.parent = &edac_class.kset.kobj;
600 edac_pci_kobj.ktype = &ktype_edac_pci;
601
602 err = kobject_set_name(&edac_pci_kobj, "pci");
603 if (!err) {
604 /* Instanstiate the csrow object */
605 /* FIXME: maybe new sysdev_create_subdir() */
606 err = kobject_register(&edac_pci_kobj);
607 if (err)
608 debugf1("Failed to register '.../edac/pci'\n");
609 else
610 debugf1("Registered '.../edac/pci' kobject\n");
611 }
612 return err;
613}
Dave Petersonceb2ca92006-03-13 21:20:50 -0800614#endif /* DISABLE_EDAC_SYSFS */
Alan Coxda9bb1d2006-01-18 17:44:13 -0800615
616static void edac_sysfs_pci_teardown(void)
617{
Dave Petersonceb2ca92006-03-13 21:20:50 -0800618#ifndef DISABLE_EDAC_SYSFS
Dave Peterson537fba22006-03-26 01:38:40 -0800619 debugf0("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800620
621 kobject_unregister(&edac_pci_kobj);
622 kobject_put(&edac_pci_kobj);
Dave Petersonceb2ca92006-03-13 21:20:50 -0800623#endif
Alan Coxda9bb1d2006-01-18 17:44:13 -0800624}
625
Dave Petersonceb2ca92006-03-13 21:20:50 -0800626#ifndef DISABLE_EDAC_SYSFS
627
Alan Coxda9bb1d2006-01-18 17:44:13 -0800628/* EDAC sysfs CSROW data structures and methods */
629
630/* Set of more detailed csrow<id> attribute show/store functions */
631static ssize_t csrow_ch0_dimm_label_show(struct csrow_info *csrow, char *data)
632{
633 ssize_t size = 0;
634
635 if (csrow->nr_channels > 0) {
636 size = snprintf(data, EDAC_MC_LABEL_LEN,"%s\n",
637 csrow->channels[0].label);
638 }
639 return size;
640}
641
642static ssize_t csrow_ch1_dimm_label_show(struct csrow_info *csrow, char *data)
643{
644 ssize_t size = 0;
645
646 if (csrow->nr_channels > 0) {
647 size = snprintf(data, EDAC_MC_LABEL_LEN, "%s\n",
648 csrow->channels[1].label);
649 }
650 return size;
651}
652
653static ssize_t csrow_ch0_dimm_label_store(struct csrow_info *csrow,
654 const char *data, size_t size)
655{
656 ssize_t max_size = 0;
657
658 if (csrow->nr_channels > 0) {
659 max_size = min((ssize_t)size,(ssize_t)EDAC_MC_LABEL_LEN-1);
660 strncpy(csrow->channels[0].label, data, max_size);
661 csrow->channels[0].label[max_size] = '\0';
662 }
663 return size;
664}
665
666static ssize_t csrow_ch1_dimm_label_store(struct csrow_info *csrow,
667 const char *data, size_t size)
668{
669 ssize_t max_size = 0;
670
671 if (csrow->nr_channels > 1) {
672 max_size = min((ssize_t)size,(ssize_t)EDAC_MC_LABEL_LEN-1);
673 strncpy(csrow->channels[1].label, data, max_size);
674 csrow->channels[1].label[max_size] = '\0';
675 }
676 return max_size;
677}
678
679static ssize_t csrow_ue_count_show(struct csrow_info *csrow, char *data)
680{
681 return sprintf(data,"%u\n", csrow->ue_count);
682}
683
684static ssize_t csrow_ce_count_show(struct csrow_info *csrow, char *data)
685{
686 return sprintf(data,"%u\n", csrow->ce_count);
687}
688
689static ssize_t csrow_ch0_ce_count_show(struct csrow_info *csrow, char *data)
690{
691 ssize_t size = 0;
692
693 if (csrow->nr_channels > 0) {
694 size = sprintf(data,"%u\n", csrow->channels[0].ce_count);
695 }
696 return size;
697}
698
699static ssize_t csrow_ch1_ce_count_show(struct csrow_info *csrow, char *data)
700{
701 ssize_t size = 0;
702
703 if (csrow->nr_channels > 1) {
704 size = sprintf(data,"%u\n", csrow->channels[1].ce_count);
705 }
706 return size;
707}
708
709static ssize_t csrow_size_show(struct csrow_info *csrow, char *data)
710{
711 return sprintf(data,"%u\n", PAGES_TO_MiB(csrow->nr_pages));
712}
713
714static ssize_t csrow_mem_type_show(struct csrow_info *csrow, char *data)
715{
716 return sprintf(data,"%s\n", mem_types[csrow->mtype]);
717}
718
719static ssize_t csrow_dev_type_show(struct csrow_info *csrow, char *data)
720{
721 return sprintf(data,"%s\n", dev_types[csrow->dtype]);
722}
723
724static ssize_t csrow_edac_mode_show(struct csrow_info *csrow, char *data)
725{
726 return sprintf(data,"%s\n", edac_caps[csrow->edac_mode]);
727}
728
729struct csrowdev_attribute {
730 struct attribute attr;
731 ssize_t (*show)(struct csrow_info *,char *);
732 ssize_t (*store)(struct csrow_info *, const char *,size_t);
733};
734
735#define to_csrow(k) container_of(k, struct csrow_info, kobj)
736#define to_csrowdev_attr(a) container_of(a, struct csrowdev_attribute, attr)
737
738/* Set of show/store higher level functions for csrow objects */
739static ssize_t csrowdev_show(struct kobject *kobj, struct attribute *attr,
740 char *buffer)
741{
742 struct csrow_info *csrow = to_csrow(kobj);
743 struct csrowdev_attribute *csrowdev_attr = to_csrowdev_attr(attr);
744
745 if (csrowdev_attr->show)
746 return csrowdev_attr->show(csrow, buffer);
747 return -EIO;
748}
749
750static ssize_t csrowdev_store(struct kobject *kobj, struct attribute *attr,
751 const char *buffer, size_t count)
752{
753 struct csrow_info *csrow = to_csrow(kobj);
754 struct csrowdev_attribute * csrowdev_attr = to_csrowdev_attr(attr);
755
756 if (csrowdev_attr->store)
757 return csrowdev_attr->store(csrow, buffer, count);
758 return -EIO;
759}
760
761static struct sysfs_ops csrowfs_ops = {
762 .show = csrowdev_show,
763 .store = csrowdev_store
764};
765
766#define CSROWDEV_ATTR(_name,_mode,_show,_store) \
767struct csrowdev_attribute attr_##_name = { \
768 .attr = {.name = __stringify(_name), .mode = _mode }, \
769 .show = _show, \
770 .store = _store, \
771};
772
773/* cwrow<id>/attribute files */
774CSROWDEV_ATTR(size_mb,S_IRUGO,csrow_size_show,NULL);
775CSROWDEV_ATTR(dev_type,S_IRUGO,csrow_dev_type_show,NULL);
776CSROWDEV_ATTR(mem_type,S_IRUGO,csrow_mem_type_show,NULL);
777CSROWDEV_ATTR(edac_mode,S_IRUGO,csrow_edac_mode_show,NULL);
778CSROWDEV_ATTR(ue_count,S_IRUGO,csrow_ue_count_show,NULL);
779CSROWDEV_ATTR(ce_count,S_IRUGO,csrow_ce_count_show,NULL);
780CSROWDEV_ATTR(ch0_ce_count,S_IRUGO,csrow_ch0_ce_count_show,NULL);
781CSROWDEV_ATTR(ch1_ce_count,S_IRUGO,csrow_ch1_ce_count_show,NULL);
782
783/* control/attribute files */
784CSROWDEV_ATTR(ch0_dimm_label,S_IRUGO|S_IWUSR,
785 csrow_ch0_dimm_label_show,
786 csrow_ch0_dimm_label_store);
787CSROWDEV_ATTR(ch1_dimm_label,S_IRUGO|S_IWUSR,
788 csrow_ch1_dimm_label_show,
789 csrow_ch1_dimm_label_store);
790
791
792/* Attributes of the CSROW<id> object */
793static struct csrowdev_attribute *csrow_attr[] = {
794 &attr_dev_type,
795 &attr_mem_type,
796 &attr_edac_mode,
797 &attr_size_mb,
798 &attr_ue_count,
799 &attr_ce_count,
800 &attr_ch0_ce_count,
801 &attr_ch1_ce_count,
802 &attr_ch0_dimm_label,
803 &attr_ch1_dimm_label,
804 NULL,
805};
806
807
808/* No memory to release */
809static void edac_csrow_instance_release(struct kobject *kobj)
810{
Dave Peterson537fba22006-03-26 01:38:40 -0800811 debugf1("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800812}
813
814static struct kobj_type ktype_csrow = {
815 .release = edac_csrow_instance_release,
816 .sysfs_ops = &csrowfs_ops,
817 .default_attrs = (struct attribute **) csrow_attr,
818};
819
820/* Create a CSROW object under specifed edac_mc_device */
821static int edac_create_csrow_object(struct kobject *edac_mci_kobj,
822 struct csrow_info *csrow, int index )
823{
824 int err = 0;
825
Dave Peterson537fba22006-03-26 01:38:40 -0800826 debugf0("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -0800827
828 memset(&csrow->kobj, 0, sizeof(csrow->kobj));
829
830 /* generate ..../edac/mc/mc<id>/csrow<index> */
831
832 kobject_init(&csrow->kobj);
833 csrow->kobj.parent = edac_mci_kobj;
834 csrow->kobj.ktype = &ktype_csrow;
835
836 /* name this instance of csrow<id> */
837 err = kobject_set_name(&csrow->kobj,"csrow%d",index);
838 if (!err) {
839 /* Instanstiate the csrow object */
840 err = kobject_register(&csrow->kobj);
841 if (err)
842 debugf0("Failed to register CSROW%d\n",index);
843 else
844 debugf0("Registered CSROW%d\n",index);
845 }
846
847 return err;
848}
849
850/* sysfs data structures and methods for the MCI kobjects */
851
852static ssize_t mci_reset_counters_store(struct mem_ctl_info *mci,
853 const char *data, size_t count )
854{
855 int row, chan;
856
857 mci->ue_noinfo_count = 0;
858 mci->ce_noinfo_count = 0;
859 mci->ue_count = 0;
860 mci->ce_count = 0;
861 for (row = 0; row < mci->nr_csrows; row++) {
862 struct csrow_info *ri = &mci->csrows[row];
863
864 ri->ue_count = 0;
865 ri->ce_count = 0;
866 for (chan = 0; chan < ri->nr_channels; chan++)
867 ri->channels[chan].ce_count = 0;
868 }
869 mci->start_time = jiffies;
870
871 return count;
872}
873
874static ssize_t mci_ue_count_show(struct mem_ctl_info *mci, char *data)
875{
876 return sprintf(data,"%d\n", mci->ue_count);
877}
878
879static ssize_t mci_ce_count_show(struct mem_ctl_info *mci, char *data)
880{
881 return sprintf(data,"%d\n", mci->ce_count);
882}
883
884static ssize_t mci_ce_noinfo_show(struct mem_ctl_info *mci, char *data)
885{
886 return sprintf(data,"%d\n", mci->ce_noinfo_count);
887}
888
889static ssize_t mci_ue_noinfo_show(struct mem_ctl_info *mci, char *data)
890{
891 return sprintf(data,"%d\n", mci->ue_noinfo_count);
892}
893
894static ssize_t mci_seconds_show(struct mem_ctl_info *mci, char *data)
895{
896 return sprintf(data,"%ld\n", (jiffies - mci->start_time) / HZ);
897}
898
899static ssize_t mci_mod_name_show(struct mem_ctl_info *mci, char *data)
900{
901 return sprintf(data,"%s %s\n", mci->mod_name, mci->mod_ver);
902}
903
904static ssize_t mci_ctl_name_show(struct mem_ctl_info *mci, char *data)
905{
906 return sprintf(data,"%s\n", mci->ctl_name);
907}
908
909static int mci_output_edac_cap(char *buf, unsigned long edac_cap)
910{
911 char *p = buf;
912 int bit_idx;
913
914 for (bit_idx = 0; bit_idx < 8 * sizeof(edac_cap); bit_idx++) {
915 if ((edac_cap >> bit_idx) & 0x1)
916 p += sprintf(p, "%s ", edac_caps[bit_idx]);
917 }
918
919 return p - buf;
920}
921
922static ssize_t mci_edac_capability_show(struct mem_ctl_info *mci, char *data)
923{
924 char *p = data;
925
926 p += mci_output_edac_cap(p,mci->edac_ctl_cap);
927 p += sprintf(p, "\n");
928
929 return p - data;
930}
931
932static ssize_t mci_edac_current_capability_show(struct mem_ctl_info *mci,
933 char *data)
934{
935 char *p = data;
936
937 p += mci_output_edac_cap(p,mci->edac_cap);
938 p += sprintf(p, "\n");
939
940 return p - data;
941}
942
943static int mci_output_mtype_cap(char *buf, unsigned long mtype_cap)
944{
945 char *p = buf;
946 int bit_idx;
947
948 for (bit_idx = 0; bit_idx < 8 * sizeof(mtype_cap); bit_idx++) {
949 if ((mtype_cap >> bit_idx) & 0x1)
950 p += sprintf(p, "%s ", mem_types[bit_idx]);
951 }
952
953 return p - buf;
954}
955
956static ssize_t mci_supported_mem_type_show(struct mem_ctl_info *mci, char *data)
957{
958 char *p = data;
959
960 p += mci_output_mtype_cap(p,mci->mtype_cap);
961 p += sprintf(p, "\n");
962
963 return p - data;
964}
965
966static ssize_t mci_size_mb_show(struct mem_ctl_info *mci, char *data)
967{
968 int total_pages, csrow_idx;
969
970 for (total_pages = csrow_idx = 0; csrow_idx < mci->nr_csrows;
971 csrow_idx++) {
972 struct csrow_info *csrow = &mci->csrows[csrow_idx];
973
974 if (!csrow->nr_pages)
975 continue;
976 total_pages += csrow->nr_pages;
977 }
978
979 return sprintf(data,"%u\n", PAGES_TO_MiB(total_pages));
980}
981
982struct mcidev_attribute {
983 struct attribute attr;
984 ssize_t (*show)(struct mem_ctl_info *,char *);
985 ssize_t (*store)(struct mem_ctl_info *, const char *,size_t);
986};
987
988#define to_mci(k) container_of(k, struct mem_ctl_info, edac_mci_kobj)
989#define to_mcidev_attr(a) container_of(a, struct mcidev_attribute, attr)
990
991static ssize_t mcidev_show(struct kobject *kobj, struct attribute *attr,
992 char *buffer)
993{
994 struct mem_ctl_info *mem_ctl_info = to_mci(kobj);
995 struct mcidev_attribute * mcidev_attr = to_mcidev_attr(attr);
996
997 if (mcidev_attr->show)
998 return mcidev_attr->show(mem_ctl_info, buffer);
999 return -EIO;
1000}
1001
1002static ssize_t mcidev_store(struct kobject *kobj, struct attribute *attr,
1003 const char *buffer, size_t count)
1004{
1005 struct mem_ctl_info *mem_ctl_info = to_mci(kobj);
1006 struct mcidev_attribute * mcidev_attr = to_mcidev_attr(attr);
1007
1008 if (mcidev_attr->store)
1009 return mcidev_attr->store(mem_ctl_info, buffer, count);
1010 return -EIO;
1011}
1012
1013static struct sysfs_ops mci_ops = {
1014 .show = mcidev_show,
1015 .store = mcidev_store
1016};
1017
1018#define MCIDEV_ATTR(_name,_mode,_show,_store) \
1019struct mcidev_attribute mci_attr_##_name = { \
1020 .attr = {.name = __stringify(_name), .mode = _mode }, \
1021 .show = _show, \
1022 .store = _store, \
1023};
1024
1025/* Control file */
1026MCIDEV_ATTR(reset_counters,S_IWUSR,NULL,mci_reset_counters_store);
1027
1028/* Attribute files */
1029MCIDEV_ATTR(mc_name,S_IRUGO,mci_ctl_name_show,NULL);
1030MCIDEV_ATTR(module_name,S_IRUGO,mci_mod_name_show,NULL);
1031MCIDEV_ATTR(edac_capability,S_IRUGO,mci_edac_capability_show,NULL);
1032MCIDEV_ATTR(size_mb,S_IRUGO,mci_size_mb_show,NULL);
1033MCIDEV_ATTR(seconds_since_reset,S_IRUGO,mci_seconds_show,NULL);
1034MCIDEV_ATTR(ue_noinfo_count,S_IRUGO,mci_ue_noinfo_show,NULL);
1035MCIDEV_ATTR(ce_noinfo_count,S_IRUGO,mci_ce_noinfo_show,NULL);
1036MCIDEV_ATTR(ue_count,S_IRUGO,mci_ue_count_show,NULL);
1037MCIDEV_ATTR(ce_count,S_IRUGO,mci_ce_count_show,NULL);
1038MCIDEV_ATTR(edac_current_capability,S_IRUGO,
1039 mci_edac_current_capability_show,NULL);
1040MCIDEV_ATTR(supported_mem_type,S_IRUGO,
1041 mci_supported_mem_type_show,NULL);
1042
1043
1044static struct mcidev_attribute *mci_attr[] = {
1045 &mci_attr_reset_counters,
1046 &mci_attr_module_name,
1047 &mci_attr_mc_name,
1048 &mci_attr_edac_capability,
1049 &mci_attr_edac_current_capability,
1050 &mci_attr_supported_mem_type,
1051 &mci_attr_size_mb,
1052 &mci_attr_seconds_since_reset,
1053 &mci_attr_ue_noinfo_count,
1054 &mci_attr_ce_noinfo_count,
1055 &mci_attr_ue_count,
1056 &mci_attr_ce_count,
1057 NULL
1058};
1059
1060
1061/*
1062 * Release of a MC controlling instance
1063 */
1064static void edac_mci_instance_release(struct kobject *kobj)
1065{
1066 struct mem_ctl_info *mci;
1067 mci = container_of(kobj,struct mem_ctl_info,edac_mci_kobj);
1068
Dave Peterson537fba22006-03-26 01:38:40 -08001069 debugf0("%s() idx=%d calling kfree\n", __func__, mci->mc_idx);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001070
1071 kfree(mci);
1072}
1073
1074static struct kobj_type ktype_mci = {
1075 .release = edac_mci_instance_release,
1076 .sysfs_ops = &mci_ops,
1077 .default_attrs = (struct attribute **) mci_attr,
1078};
1079
Dave Petersonceb2ca92006-03-13 21:20:50 -08001080#endif /* DISABLE_EDAC_SYSFS */
1081
Alan Coxda9bb1d2006-01-18 17:44:13 -08001082#define EDAC_DEVICE_SYMLINK "device"
1083
1084/*
1085 * Create a new Memory Controller kobject instance,
1086 * mc<id> under the 'mc' directory
1087 *
1088 * Return:
1089 * 0 Success
1090 * !0 Failure
1091 */
1092static int edac_create_sysfs_mci_device(struct mem_ctl_info *mci)
Dave Petersonceb2ca92006-03-13 21:20:50 -08001093#ifdef DISABLE_EDAC_SYSFS
1094{
1095 return 0;
1096}
1097#else
Alan Coxda9bb1d2006-01-18 17:44:13 -08001098{
1099 int i;
1100 int err;
1101 struct csrow_info *csrow;
1102 struct kobject *edac_mci_kobj=&mci->edac_mci_kobj;
1103
Dave Peterson537fba22006-03-26 01:38:40 -08001104 debugf0("%s() idx=%d\n", __func__, mci->mc_idx);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001105
1106 memset(edac_mci_kobj, 0, sizeof(*edac_mci_kobj));
1107 kobject_init(edac_mci_kobj);
1108
1109 /* set the name of the mc<id> object */
1110 err = kobject_set_name(edac_mci_kobj,"mc%d",mci->mc_idx);
1111 if (err)
1112 return err;
1113
1114 /* link to our parent the '..../edac/mc' object */
1115 edac_mci_kobj->parent = &edac_memctrl_kobj;
1116 edac_mci_kobj->ktype = &ktype_mci;
1117
1118 /* register the mc<id> kobject */
1119 err = kobject_register(edac_mci_kobj);
1120 if (err)
1121 return err;
1122
1123 /* create a symlink for the device */
1124 err = sysfs_create_link(edac_mci_kobj, &mci->pdev->dev.kobj,
1125 EDAC_DEVICE_SYMLINK);
1126 if (err) {
1127 kobject_unregister(edac_mci_kobj);
1128 return err;
1129 }
1130
1131 /* Make directories for each CSROW object
1132 * under the mc<id> kobject
1133 */
1134 for (i = 0; i < mci->nr_csrows; i++) {
1135
1136 csrow = &mci->csrows[i];
1137
1138 /* Only expose populated CSROWs */
1139 if (csrow->nr_pages > 0) {
1140 err = edac_create_csrow_object(edac_mci_kobj,csrow,i);
1141 if (err)
1142 goto fail;
1143 }
1144 }
1145
1146 /* Mark this MCI instance as having sysfs entries */
1147 mci->sysfs_active = MCI_SYSFS_ACTIVE;
1148
1149 return 0;
1150
1151
1152 /* CSROW error: backout what has already been registered, */
1153fail:
1154 for ( i--; i >= 0; i--) {
1155 if (csrow->nr_pages > 0) {
1156 kobject_unregister(&mci->csrows[i].kobj);
1157 kobject_put(&mci->csrows[i].kobj);
1158 }
1159 }
1160
1161 kobject_unregister(edac_mci_kobj);
1162 kobject_put(edac_mci_kobj);
1163
1164 return err;
1165}
Dave Petersonceb2ca92006-03-13 21:20:50 -08001166#endif /* DISABLE_EDAC_SYSFS */
Alan Coxda9bb1d2006-01-18 17:44:13 -08001167
1168/*
1169 * remove a Memory Controller instance
1170 */
1171static void edac_remove_sysfs_mci_device(struct mem_ctl_info *mci)
1172{
Dave Petersonceb2ca92006-03-13 21:20:50 -08001173#ifndef DISABLE_EDAC_SYSFS
Alan Coxda9bb1d2006-01-18 17:44:13 -08001174 int i;
1175
Dave Peterson537fba22006-03-26 01:38:40 -08001176 debugf0("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001177
1178 /* remove all csrow kobjects */
1179 for (i = 0; i < mci->nr_csrows; i++) {
1180 if (mci->csrows[i].nr_pages > 0) {
1181 kobject_unregister(&mci->csrows[i].kobj);
1182 kobject_put(&mci->csrows[i].kobj);
1183 }
1184 }
1185
1186 sysfs_remove_link(&mci->edac_mci_kobj, EDAC_DEVICE_SYMLINK);
1187
1188 kobject_unregister(&mci->edac_mci_kobj);
1189 kobject_put(&mci->edac_mci_kobj);
Dave Petersonceb2ca92006-03-13 21:20:50 -08001190#endif /* DISABLE_EDAC_SYSFS */
Alan Coxda9bb1d2006-01-18 17:44:13 -08001191}
1192
1193/* END OF sysfs data and methods */
1194
1195#ifdef CONFIG_EDAC_DEBUG
1196
1197EXPORT_SYMBOL(edac_mc_dump_channel);
1198
1199void edac_mc_dump_channel(struct channel_info *chan)
1200{
1201 debugf4("\tchannel = %p\n", chan);
1202 debugf4("\tchannel->chan_idx = %d\n", chan->chan_idx);
1203 debugf4("\tchannel->ce_count = %d\n", chan->ce_count);
1204 debugf4("\tchannel->label = '%s'\n", chan->label);
1205 debugf4("\tchannel->csrow = %p\n\n", chan->csrow);
1206}
1207
1208
1209EXPORT_SYMBOL(edac_mc_dump_csrow);
1210
1211void edac_mc_dump_csrow(struct csrow_info *csrow)
1212{
1213 debugf4("\tcsrow = %p\n", csrow);
1214 debugf4("\tcsrow->csrow_idx = %d\n", csrow->csrow_idx);
1215 debugf4("\tcsrow->first_page = 0x%lx\n",
1216 csrow->first_page);
1217 debugf4("\tcsrow->last_page = 0x%lx\n", csrow->last_page);
1218 debugf4("\tcsrow->page_mask = 0x%lx\n", csrow->page_mask);
1219 debugf4("\tcsrow->nr_pages = 0x%x\n", csrow->nr_pages);
1220 debugf4("\tcsrow->nr_channels = %d\n",
1221 csrow->nr_channels);
1222 debugf4("\tcsrow->channels = %p\n", csrow->channels);
1223 debugf4("\tcsrow->mci = %p\n\n", csrow->mci);
1224}
1225
1226
1227EXPORT_SYMBOL(edac_mc_dump_mci);
1228
1229void edac_mc_dump_mci(struct mem_ctl_info *mci)
1230{
1231 debugf3("\tmci = %p\n", mci);
1232 debugf3("\tmci->mtype_cap = %lx\n", mci->mtype_cap);
1233 debugf3("\tmci->edac_ctl_cap = %lx\n", mci->edac_ctl_cap);
1234 debugf3("\tmci->edac_cap = %lx\n", mci->edac_cap);
1235 debugf4("\tmci->edac_check = %p\n", mci->edac_check);
1236 debugf3("\tmci->nr_csrows = %d, csrows = %p\n",
1237 mci->nr_csrows, mci->csrows);
1238 debugf3("\tpdev = %p\n", mci->pdev);
1239 debugf3("\tmod_name:ctl_name = %s:%s\n",
1240 mci->mod_name, mci->ctl_name);
1241 debugf3("\tpvt_info = %p\n\n", mci->pvt_info);
1242}
1243
1244
1245#endif /* CONFIG_EDAC_DEBUG */
1246
1247/* 'ptr' points to a possibly unaligned item X such that sizeof(X) is 'size'.
1248 * Adjust 'ptr' so that its alignment is at least as stringent as what the
1249 * compiler would provide for X and return the aligned result.
1250 *
1251 * If 'size' is a constant, the compiler will optimize this whole function
1252 * down to either a no-op or the addition of a constant to the value of 'ptr'.
1253 */
1254static inline char * align_ptr (void *ptr, unsigned size)
1255{
1256 unsigned align, r;
1257
1258 /* Here we assume that the alignment of a "long long" is the most
1259 * stringent alignment that the compiler will ever provide by default.
1260 * As far as I know, this is a reasonable assumption.
1261 */
1262 if (size > sizeof(long))
1263 align = sizeof(long long);
1264 else if (size > sizeof(int))
1265 align = sizeof(long);
1266 else if (size > sizeof(short))
1267 align = sizeof(int);
1268 else if (size > sizeof(char))
1269 align = sizeof(short);
1270 else
1271 return (char *) ptr;
1272
1273 r = size % align;
1274
1275 if (r == 0)
1276 return (char *) ptr;
1277
1278 return (char *) (((unsigned long) ptr) + align - r);
1279}
1280
1281
1282EXPORT_SYMBOL(edac_mc_alloc);
1283
1284/**
1285 * edac_mc_alloc: Allocate a struct mem_ctl_info structure
1286 * @size_pvt: size of private storage needed
1287 * @nr_csrows: Number of CWROWS needed for this MC
1288 * @nr_chans: Number of channels for the MC
1289 *
1290 * Everything is kmalloc'ed as one big chunk - more efficient.
1291 * Only can be used if all structures have the same lifetime - otherwise
1292 * you have to allocate and initialize your own structures.
1293 *
1294 * Use edac_mc_free() to free mc structures allocated by this function.
1295 *
1296 * Returns:
1297 * NULL allocation failed
1298 * struct mem_ctl_info pointer
1299 */
1300struct mem_ctl_info *edac_mc_alloc(unsigned sz_pvt, unsigned nr_csrows,
1301 unsigned nr_chans)
1302{
1303 struct mem_ctl_info *mci;
1304 struct csrow_info *csi, *csrow;
1305 struct channel_info *chi, *chp, *chan;
1306 void *pvt;
1307 unsigned size;
1308 int row, chn;
1309
1310 /* Figure out the offsets of the various items from the start of an mc
1311 * structure. We want the alignment of each item to be at least as
1312 * stringent as what the compiler would provide if we could simply
1313 * hardcode everything into a single struct.
1314 */
1315 mci = (struct mem_ctl_info *) 0;
1316 csi = (struct csrow_info *)align_ptr(&mci[1], sizeof(*csi));
1317 chi = (struct channel_info *)
1318 align_ptr(&csi[nr_csrows], sizeof(*chi));
1319 pvt = align_ptr(&chi[nr_chans * nr_csrows], sz_pvt);
1320 size = ((unsigned long) pvt) + sz_pvt;
1321
1322 if ((mci = kmalloc(size, GFP_KERNEL)) == NULL)
1323 return NULL;
1324
1325 /* Adjust pointers so they point within the memory we just allocated
1326 * rather than an imaginary chunk of memory located at address 0.
1327 */
1328 csi = (struct csrow_info *) (((char *) mci) + ((unsigned long) csi));
1329 chi = (struct channel_info *) (((char *) mci) + ((unsigned long) chi));
1330 pvt = sz_pvt ? (((char *) mci) + ((unsigned long) pvt)) : NULL;
1331
1332 memset(mci, 0, size); /* clear all fields */
1333
1334 mci->csrows = csi;
1335 mci->pvt_info = pvt;
1336 mci->nr_csrows = nr_csrows;
1337
1338 for (row = 0; row < nr_csrows; row++) {
1339 csrow = &csi[row];
1340 csrow->csrow_idx = row;
1341 csrow->mci = mci;
1342 csrow->nr_channels = nr_chans;
1343 chp = &chi[row * nr_chans];
1344 csrow->channels = chp;
1345
1346 for (chn = 0; chn < nr_chans; chn++) {
1347 chan = &chp[chn];
1348 chan->chan_idx = chn;
1349 chan->csrow = csrow;
1350 }
1351 }
1352
1353 return mci;
1354}
1355
1356
1357EXPORT_SYMBOL(edac_mc_free);
1358
1359/**
1360 * edac_mc_free: Free a previously allocated 'mci' structure
1361 * @mci: pointer to a struct mem_ctl_info structure
1362 *
1363 * Free up a previously allocated mci structure
1364 * A MCI structure can be in 2 states after being allocated
1365 * by edac_mc_alloc().
1366 * 1) Allocated in a MC driver's probe, but not yet committed
1367 * 2) Allocated and committed, by a call to edac_mc_add_mc()
1368 * edac_mc_add_mc() is the function that adds the sysfs entries
1369 * thus, this free function must determine which state the 'mci'
1370 * structure is in, then either free it directly or
1371 * perform kobject cleanup by calling edac_remove_sysfs_mci_device().
1372 *
1373 * VOID Return
1374 */
1375void edac_mc_free(struct mem_ctl_info *mci)
1376{
1377 /* only if sysfs entries for this mci instance exist
1378 * do we remove them and defer the actual kfree via
1379 * the kobject 'release()' callback.
1380 *
1381 * Otherwise, do a straight kfree now.
1382 */
1383 if (mci->sysfs_active == MCI_SYSFS_ACTIVE)
1384 edac_remove_sysfs_mci_device(mci);
1385 else
1386 kfree(mci);
1387}
1388
1389
1390
1391EXPORT_SYMBOL(edac_mc_find_mci_by_pdev);
1392
1393struct mem_ctl_info *edac_mc_find_mci_by_pdev(struct pci_dev *pdev)
1394{
1395 struct mem_ctl_info *mci;
1396 struct list_head *item;
1397
Dave Peterson537fba22006-03-26 01:38:40 -08001398 debugf3("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001399
1400 list_for_each(item, &mc_devices) {
1401 mci = list_entry(item, struct mem_ctl_info, link);
1402
1403 if (mci->pdev == pdev)
1404 return mci;
1405 }
1406
1407 return NULL;
1408}
1409
1410static int add_mc_to_global_list (struct mem_ctl_info *mci)
1411{
1412 struct list_head *item, *insert_before;
1413 struct mem_ctl_info *p;
1414 int i;
1415
1416 if (list_empty(&mc_devices)) {
1417 mci->mc_idx = 0;
1418 insert_before = &mc_devices;
1419 } else {
1420 if (edac_mc_find_mci_by_pdev(mci->pdev)) {
Dave Peterson537fba22006-03-26 01:38:40 -08001421 edac_printk(KERN_WARNING, EDAC_MC,
1422 "%s (%s) %s %s already assigned %d\n",
1423 mci->pdev->dev.bus_id,
1424 pci_name(mci->pdev), mci->mod_name,
1425 mci->ctl_name, mci->mc_idx);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001426 return 1;
1427 }
1428
1429 insert_before = NULL;
1430 i = 0;
1431
1432 list_for_each(item, &mc_devices) {
1433 p = list_entry(item, struct mem_ctl_info, link);
1434
1435 if (p->mc_idx != i) {
1436 insert_before = item;
1437 break;
1438 }
1439
1440 i++;
1441 }
1442
1443 mci->mc_idx = i;
1444
1445 if (insert_before == NULL)
1446 insert_before = &mc_devices;
1447 }
1448
1449 list_add_tail_rcu(&mci->link, insert_before);
1450 return 0;
1451}
1452
1453
1454
1455EXPORT_SYMBOL(edac_mc_add_mc);
1456
1457/**
1458 * edac_mc_add_mc: Insert the 'mci' structure into the mci global list
1459 * @mci: pointer to the mci structure to be added to the list
1460 *
1461 * Return:
1462 * 0 Success
1463 * !0 Failure
1464 */
1465
1466/* FIXME - should a warning be printed if no error detection? correction? */
1467int edac_mc_add_mc(struct mem_ctl_info *mci)
1468{
1469 int rc = 1;
1470
Dave Peterson537fba22006-03-26 01:38:40 -08001471 debugf0("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001472#ifdef CONFIG_EDAC_DEBUG
1473 if (edac_debug_level >= 3)
1474 edac_mc_dump_mci(mci);
1475 if (edac_debug_level >= 4) {
1476 int i;
1477
1478 for (i = 0; i < mci->nr_csrows; i++) {
1479 int j;
1480 edac_mc_dump_csrow(&mci->csrows[i]);
1481 for (j = 0; j < mci->csrows[i].nr_channels; j++)
1482 edac_mc_dump_channel(&mci->csrows[i].
1483 channels[j]);
1484 }
1485 }
1486#endif
1487 down(&mem_ctls_mutex);
1488
1489 if (add_mc_to_global_list(mci))
1490 goto finish;
1491
1492 /* set load time so that error rate can be tracked */
1493 mci->start_time = jiffies;
1494
1495 if (edac_create_sysfs_mci_device(mci)) {
Dave Peterson537fba22006-03-26 01:38:40 -08001496 edac_mc_printk(mci, KERN_WARNING,
1497 "failed to create sysfs device\n");
Alan Coxda9bb1d2006-01-18 17:44:13 -08001498 /* FIXME - should there be an error code and unwind? */
1499 goto finish;
1500 }
1501
1502 /* Report action taken */
Dave Peterson537fba22006-03-26 01:38:40 -08001503 edac_mc_printk(mci, KERN_INFO, "Giving out device to %s %s: PCI %s\n",
1504 mci->mod_name, mci->ctl_name, pci_name(mci->pdev));
Alan Coxda9bb1d2006-01-18 17:44:13 -08001505
1506 rc = 0;
1507
1508finish:
1509 up(&mem_ctls_mutex);
1510 return rc;
1511}
1512
1513
1514
1515static void complete_mc_list_del (struct rcu_head *head)
1516{
1517 struct mem_ctl_info *mci;
1518
1519 mci = container_of(head, struct mem_ctl_info, rcu);
1520 INIT_LIST_HEAD(&mci->link);
1521 complete(&mci->complete);
1522}
1523
1524static void del_mc_from_global_list (struct mem_ctl_info *mci)
1525{
1526 list_del_rcu(&mci->link);
1527 init_completion(&mci->complete);
1528 call_rcu(&mci->rcu, complete_mc_list_del);
1529 wait_for_completion(&mci->complete);
1530}
1531
1532EXPORT_SYMBOL(edac_mc_del_mc);
1533
1534/**
1535 * edac_mc_del_mc: Remove the specified mci structure from global list
1536 * @mci: Pointer to struct mem_ctl_info structure
1537 *
1538 * Returns:
1539 * 0 Success
1540 * 1 Failure
1541 */
1542int edac_mc_del_mc(struct mem_ctl_info *mci)
1543{
1544 int rc = 1;
1545
Dave Peterson537fba22006-03-26 01:38:40 -08001546 debugf0("MC%d: %s()\n", mci->mc_idx, __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001547 down(&mem_ctls_mutex);
1548 del_mc_from_global_list(mci);
Dave Peterson537fba22006-03-26 01:38:40 -08001549 edac_printk(KERN_INFO, EDAC_MC,
1550 "Removed device %d for %s %s: PCI %s\n", mci->mc_idx,
1551 mci->mod_name, mci->ctl_name, pci_name(mci->pdev));
Alan Coxda9bb1d2006-01-18 17:44:13 -08001552 rc = 0;
1553 up(&mem_ctls_mutex);
1554
1555 return rc;
1556}
1557
1558
1559EXPORT_SYMBOL(edac_mc_scrub_block);
1560
1561void edac_mc_scrub_block(unsigned long page, unsigned long offset,
1562 u32 size)
1563{
1564 struct page *pg;
1565 void *virt_addr;
1566 unsigned long flags = 0;
1567
Dave Peterson537fba22006-03-26 01:38:40 -08001568 debugf3("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001569
1570 /* ECC error page was not in our memory. Ignore it. */
1571 if(!pfn_valid(page))
1572 return;
1573
1574 /* Find the actual page structure then map it and fix */
1575 pg = pfn_to_page(page);
1576
1577 if (PageHighMem(pg))
1578 local_irq_save(flags);
1579
1580 virt_addr = kmap_atomic(pg, KM_BOUNCE_READ);
1581
1582 /* Perform architecture specific atomic scrub operation */
1583 atomic_scrub(virt_addr + offset, size);
1584
1585 /* Unmap and complete */
1586 kunmap_atomic(virt_addr, KM_BOUNCE_READ);
1587
1588 if (PageHighMem(pg))
1589 local_irq_restore(flags);
1590}
1591
1592
1593/* FIXME - should return -1 */
1594EXPORT_SYMBOL(edac_mc_find_csrow_by_page);
1595
1596int edac_mc_find_csrow_by_page(struct mem_ctl_info *mci,
1597 unsigned long page)
1598{
1599 struct csrow_info *csrows = mci->csrows;
1600 int row, i;
1601
Dave Peterson537fba22006-03-26 01:38:40 -08001602 debugf1("MC%d: %s(): 0x%lx\n", mci->mc_idx, __func__, page);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001603 row = -1;
1604
1605 for (i = 0; i < mci->nr_csrows; i++) {
1606 struct csrow_info *csrow = &csrows[i];
1607
1608 if (csrow->nr_pages == 0)
1609 continue;
1610
Dave Peterson537fba22006-03-26 01:38:40 -08001611 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
1612 "mask(0x%lx)\n", mci->mc_idx, __func__,
1613 csrow->first_page, page, csrow->last_page,
1614 csrow->page_mask);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001615
1616 if ((page >= csrow->first_page) &&
1617 (page <= csrow->last_page) &&
1618 ((page & csrow->page_mask) ==
1619 (csrow->first_page & csrow->page_mask))) {
1620 row = i;
1621 break;
1622 }
1623 }
1624
1625 if (row == -1)
Dave Peterson537fba22006-03-26 01:38:40 -08001626 edac_mc_printk(mci, KERN_ERR,
1627 "could not look up page error address %lx\n",
1628 (unsigned long) page);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001629
1630 return row;
1631}
1632
1633
1634EXPORT_SYMBOL(edac_mc_handle_ce);
1635
1636/* FIXME - setable log (warning/emerg) levels */
1637/* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
1638void edac_mc_handle_ce(struct mem_ctl_info *mci,
1639 unsigned long page_frame_number,
1640 unsigned long offset_in_page,
1641 unsigned long syndrome, int row, int channel,
1642 const char *msg)
1643{
1644 unsigned long remapped_page;
1645
Dave Peterson537fba22006-03-26 01:38:40 -08001646 debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001647
1648 /* FIXME - maybe make panic on INTERNAL ERROR an option */
1649 if (row >= mci->nr_csrows || row < 0) {
1650 /* something is wrong */
Dave Peterson537fba22006-03-26 01:38:40 -08001651 edac_mc_printk(mci, KERN_ERR,
1652 "INTERNAL ERROR: row out of range "
1653 "(%d >= %d)\n", row, mci->nr_csrows);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001654 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
1655 return;
1656 }
1657 if (channel >= mci->csrows[row].nr_channels || channel < 0) {
1658 /* something is wrong */
Dave Peterson537fba22006-03-26 01:38:40 -08001659 edac_mc_printk(mci, KERN_ERR,
1660 "INTERNAL ERROR: channel out of range "
1661 "(%d >= %d)\n", channel,
1662 mci->csrows[row].nr_channels);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001663 edac_mc_handle_ce_no_info(mci, "INTERNAL ERROR");
1664 return;
1665 }
1666
1667 if (log_ce)
1668 /* FIXME - put in DIMM location */
Dave Peterson537fba22006-03-26 01:38:40 -08001669 edac_mc_printk(mci, KERN_WARNING,
1670 "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
1671 "0x%lx, row %d, channel %d, label \"%s\": %s\n",
1672 page_frame_number, offset_in_page,
1673 mci->csrows[row].grain, syndrome, row, channel,
1674 mci->csrows[row].channels[channel].label, msg);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001675
1676 mci->ce_count++;
1677 mci->csrows[row].ce_count++;
1678 mci->csrows[row].channels[channel].ce_count++;
1679
1680 if (mci->scrub_mode & SCRUB_SW_SRC) {
1681 /*
1682 * Some MC's can remap memory so that it is still available
1683 * at a different address when PCI devices map into memory.
1684 * MC's that can't do this lose the memory where PCI devices
1685 * are mapped. This mapping is MC dependant and so we call
1686 * back into the MC driver for it to map the MC page to
1687 * a physical (CPU) page which can then be mapped to a virtual
1688 * page - which can then be scrubbed.
1689 */
1690 remapped_page = mci->ctl_page_to_phys ?
1691 mci->ctl_page_to_phys(mci, page_frame_number) :
1692 page_frame_number;
1693
1694 edac_mc_scrub_block(remapped_page, offset_in_page,
1695 mci->csrows[row].grain);
1696 }
1697}
1698
1699
1700EXPORT_SYMBOL(edac_mc_handle_ce_no_info);
1701
1702void edac_mc_handle_ce_no_info(struct mem_ctl_info *mci,
1703 const char *msg)
1704{
1705 if (log_ce)
Dave Peterson537fba22006-03-26 01:38:40 -08001706 edac_mc_printk(mci, KERN_WARNING,
1707 "CE - no information available: %s\n", msg);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001708 mci->ce_noinfo_count++;
1709 mci->ce_count++;
1710}
1711
1712
1713EXPORT_SYMBOL(edac_mc_handle_ue);
1714
1715void edac_mc_handle_ue(struct mem_ctl_info *mci,
1716 unsigned long page_frame_number,
1717 unsigned long offset_in_page, int row,
1718 const char *msg)
1719{
1720 int len = EDAC_MC_LABEL_LEN * 4;
1721 char labels[len + 1];
1722 char *pos = labels;
1723 int chan;
1724 int chars;
1725
Dave Peterson537fba22006-03-26 01:38:40 -08001726 debugf3("MC%d: %s()\n", mci->mc_idx, __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001727
1728 /* FIXME - maybe make panic on INTERNAL ERROR an option */
1729 if (row >= mci->nr_csrows || row < 0) {
1730 /* something is wrong */
Dave Peterson537fba22006-03-26 01:38:40 -08001731 edac_mc_printk(mci, KERN_ERR,
1732 "INTERNAL ERROR: row out of range "
1733 "(%d >= %d)\n", row, mci->nr_csrows);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001734 edac_mc_handle_ue_no_info(mci, "INTERNAL ERROR");
1735 return;
1736 }
1737
1738 chars = snprintf(pos, len + 1, "%s",
1739 mci->csrows[row].channels[0].label);
1740 len -= chars;
1741 pos += chars;
1742 for (chan = 1; (chan < mci->csrows[row].nr_channels) && (len > 0);
1743 chan++) {
1744 chars = snprintf(pos, len + 1, ":%s",
1745 mci->csrows[row].channels[chan].label);
1746 len -= chars;
1747 pos += chars;
1748 }
1749
1750 if (log_ue)
Dave Peterson537fba22006-03-26 01:38:40 -08001751 edac_mc_printk(mci, KERN_EMERG,
1752 "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
1753 "labels \"%s\": %s\n", page_frame_number,
1754 offset_in_page, mci->csrows[row].grain, row, labels,
1755 msg);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001756
1757 if (panic_on_ue)
1758 panic
1759 ("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, row %d,"
1760 " labels \"%s\": %s\n", mci->mc_idx,
1761 page_frame_number, offset_in_page,
1762 mci->csrows[row].grain, row, labels, msg);
1763
1764 mci->ue_count++;
1765 mci->csrows[row].ue_count++;
1766}
1767
1768
1769EXPORT_SYMBOL(edac_mc_handle_ue_no_info);
1770
1771void edac_mc_handle_ue_no_info(struct mem_ctl_info *mci,
1772 const char *msg)
1773{
1774 if (panic_on_ue)
1775 panic("EDAC MC%d: Uncorrected Error", mci->mc_idx);
1776
1777 if (log_ue)
Dave Peterson537fba22006-03-26 01:38:40 -08001778 edac_mc_printk(mci, KERN_WARNING,
1779 "UE - no information available: %s\n", msg);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001780 mci->ue_noinfo_count++;
1781 mci->ue_count++;
1782}
1783
1784
1785#ifdef CONFIG_PCI
1786
1787static u16 get_pci_parity_status(struct pci_dev *dev, int secondary)
1788{
1789 int where;
1790 u16 status;
1791
1792 where = secondary ? PCI_SEC_STATUS : PCI_STATUS;
1793 pci_read_config_word(dev, where, &status);
1794
1795 /* If we get back 0xFFFF then we must suspect that the card has been pulled but
1796 the Linux PCI layer has not yet finished cleaning up. We don't want to report
1797 on such devices */
1798
1799 if (status == 0xFFFF) {
1800 u32 sanity;
1801 pci_read_config_dword(dev, 0, &sanity);
1802 if (sanity == 0xFFFFFFFF)
1803 return 0;
1804 }
1805 status &= PCI_STATUS_DETECTED_PARITY | PCI_STATUS_SIG_SYSTEM_ERROR |
1806 PCI_STATUS_PARITY;
1807
1808 if (status)
1809 /* reset only the bits we are interested in */
1810 pci_write_config_word(dev, where, status);
1811
1812 return status;
1813}
1814
1815typedef void (*pci_parity_check_fn_t) (struct pci_dev *dev);
1816
1817/* Clear any PCI parity errors logged by this device. */
1818static void edac_pci_dev_parity_clear( struct pci_dev *dev )
1819{
1820 u8 header_type;
1821
1822 get_pci_parity_status(dev, 0);
1823
1824 /* read the device TYPE, looking for bridges */
1825 pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
1826
1827 if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE)
1828 get_pci_parity_status(dev, 1);
1829}
1830
1831/*
1832 * PCI Parity polling
1833 *
1834 */
1835static void edac_pci_dev_parity_test(struct pci_dev *dev)
1836{
1837 u16 status;
1838 u8 header_type;
1839
1840 /* read the STATUS register on this device
1841 */
1842 status = get_pci_parity_status(dev, 0);
1843
1844 debugf2("PCI STATUS= 0x%04x %s\n", status, dev->dev.bus_id );
1845
1846 /* check the status reg for errors */
1847 if (status) {
1848 if (status & (PCI_STATUS_SIG_SYSTEM_ERROR))
Dave Peterson537fba22006-03-26 01:38:40 -08001849 edac_printk(KERN_CRIT, EDAC_PCI,
Alan Coxda9bb1d2006-01-18 17:44:13 -08001850 "Signaled System Error on %s\n",
Dave Peterson537fba22006-03-26 01:38:40 -08001851 pci_name(dev));
Alan Coxda9bb1d2006-01-18 17:44:13 -08001852
1853 if (status & (PCI_STATUS_PARITY)) {
Dave Peterson537fba22006-03-26 01:38:40 -08001854 edac_printk(KERN_CRIT, EDAC_PCI,
Alan Coxda9bb1d2006-01-18 17:44:13 -08001855 "Master Data Parity Error on %s\n",
Dave Peterson537fba22006-03-26 01:38:40 -08001856 pci_name(dev));
Alan Coxda9bb1d2006-01-18 17:44:13 -08001857
1858 atomic_inc(&pci_parity_count);
1859 }
1860
1861 if (status & (PCI_STATUS_DETECTED_PARITY)) {
Dave Peterson537fba22006-03-26 01:38:40 -08001862 edac_printk(KERN_CRIT, EDAC_PCI,
Alan Coxda9bb1d2006-01-18 17:44:13 -08001863 "Detected Parity Error on %s\n",
Dave Peterson537fba22006-03-26 01:38:40 -08001864 pci_name(dev));
Alan Coxda9bb1d2006-01-18 17:44:13 -08001865
1866 atomic_inc(&pci_parity_count);
1867 }
1868 }
1869
1870 /* read the device TYPE, looking for bridges */
1871 pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
1872
1873 debugf2("PCI HEADER TYPE= 0x%02x %s\n", header_type, dev->dev.bus_id );
1874
1875 if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
1876 /* On bridges, need to examine secondary status register */
1877 status = get_pci_parity_status(dev, 1);
1878
1879 debugf2("PCI SEC_STATUS= 0x%04x %s\n",
1880 status, dev->dev.bus_id );
1881
1882 /* check the secondary status reg for errors */
1883 if (status) {
1884 if (status & (PCI_STATUS_SIG_SYSTEM_ERROR))
Dave Peterson537fba22006-03-26 01:38:40 -08001885 edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
Alan Coxda9bb1d2006-01-18 17:44:13 -08001886 "Signaled System Error on %s\n",
Dave Peterson537fba22006-03-26 01:38:40 -08001887 pci_name(dev));
Alan Coxda9bb1d2006-01-18 17:44:13 -08001888
1889 if (status & (PCI_STATUS_PARITY)) {
Dave Peterson537fba22006-03-26 01:38:40 -08001890 edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
1891 "Master Data Parity Error on "
1892 "%s\n", pci_name(dev));
Alan Coxda9bb1d2006-01-18 17:44:13 -08001893
1894 atomic_inc(&pci_parity_count);
1895 }
1896
1897 if (status & (PCI_STATUS_DETECTED_PARITY)) {
Dave Peterson537fba22006-03-26 01:38:40 -08001898 edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
Alan Coxda9bb1d2006-01-18 17:44:13 -08001899 "Detected Parity Error on %s\n",
Dave Peterson537fba22006-03-26 01:38:40 -08001900 pci_name(dev));
Alan Coxda9bb1d2006-01-18 17:44:13 -08001901
1902 atomic_inc(&pci_parity_count);
1903 }
1904 }
1905 }
1906}
1907
1908/*
1909 * check_dev_on_list: Scan for a PCI device on a white/black list
1910 * @list: an EDAC &edac_pci_device_list white/black list pointer
1911 * @free_index: index of next free entry on the list
1912 * @pci_dev: PCI Device pointer
1913 *
1914 * see if list contains the device.
1915 *
1916 * Returns: 0 not found
1917 * 1 found on list
1918 */
1919static int check_dev_on_list(struct edac_pci_device_list *list, int free_index,
1920 struct pci_dev *dev)
1921{
1922 int i;
1923 int rc = 0; /* Assume not found */
1924 unsigned short vendor=dev->vendor;
1925 unsigned short device=dev->device;
1926
1927 /* Scan the list, looking for a vendor/device match
1928 */
1929 for (i = 0; i < free_index; i++, list++ ) {
1930 if ( (list->vendor == vendor ) &&
1931 (list->device == device )) {
1932 rc = 1;
1933 break;
1934 }
1935 }
1936
1937 return rc;
1938}
1939
1940/*
1941 * pci_dev parity list iterator
1942 * Scan the PCI device list for one iteration, looking for SERRORs
1943 * Master Parity ERRORS or Parity ERRORs on primary or secondary devices
1944 */
1945static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn)
1946{
1947 struct pci_dev *dev=NULL;
1948
1949 /* request for kernel access to the next PCI device, if any,
1950 * and while we are looking at it have its reference count
1951 * bumped until we are done with it
1952 */
1953 while((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
1954
1955 /* if whitelist exists then it has priority, so only scan those
1956 * devices on the whitelist
1957 */
1958 if (pci_whitelist_count > 0 ) {
1959 if (check_dev_on_list(pci_whitelist,
1960 pci_whitelist_count, dev))
1961 fn(dev);
1962 } else {
1963 /*
1964 * if no whitelist, then check if this devices is
1965 * blacklisted
1966 */
1967 if (!check_dev_on_list(pci_blacklist,
1968 pci_blacklist_count, dev))
1969 fn(dev);
1970 }
1971 }
1972}
1973
1974static void do_pci_parity_check(void)
1975{
1976 unsigned long flags;
1977 int before_count;
1978
Dave Peterson537fba22006-03-26 01:38:40 -08001979 debugf3("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -08001980
1981 if (!check_pci_parity)
1982 return;
1983
1984 before_count = atomic_read(&pci_parity_count);
1985
1986 /* scan all PCI devices looking for a Parity Error on devices and
1987 * bridges
1988 */
1989 local_irq_save(flags);
1990 edac_pci_dev_parity_iterator(edac_pci_dev_parity_test);
1991 local_irq_restore(flags);
1992
1993 /* Only if operator has selected panic on PCI Error */
1994 if (panic_on_pci_parity) {
1995 /* If the count is different 'after' from 'before' */
1996 if (before_count != atomic_read(&pci_parity_count))
1997 panic("EDAC: PCI Parity Error");
1998 }
1999}
2000
2001
2002static inline void clear_pci_parity_errors(void)
2003{
2004 /* Clear any PCI bus parity errors that devices initially have logged
2005 * in their registers.
2006 */
2007 edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear);
2008}
2009
2010
2011#else /* CONFIG_PCI */
2012
2013
2014static inline void do_pci_parity_check(void)
2015{
2016 /* no-op */
2017}
2018
2019
2020static inline void clear_pci_parity_errors(void)
2021{
2022 /* no-op */
2023}
2024
2025
2026#endif /* CONFIG_PCI */
2027
2028/*
2029 * Iterate over all MC instances and check for ECC, et al, errors
2030 */
2031static inline void check_mc_devices (void)
2032{
2033 unsigned long flags;
2034 struct list_head *item;
2035 struct mem_ctl_info *mci;
2036
Dave Peterson537fba22006-03-26 01:38:40 -08002037 debugf3("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -08002038
2039 /* during poll, have interrupts off */
2040 local_irq_save(flags);
2041
2042 list_for_each(item, &mc_devices) {
2043 mci = list_entry(item, struct mem_ctl_info, link);
2044
2045 if (mci->edac_check != NULL)
2046 mci->edac_check(mci);
2047 }
2048
2049 local_irq_restore(flags);
2050}
2051
2052
2053/*
2054 * Check MC status every poll_msec.
2055 * Check PCI status every poll_msec as well.
2056 *
2057 * This where the work gets done for edac.
2058 *
2059 * SMP safe, doesn't use NMI, and auto-rate-limits.
2060 */
2061static void do_edac_check(void)
2062{
Dave Peterson537fba22006-03-26 01:38:40 -08002063 debugf3("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -08002064 check_mc_devices();
Alan Coxda9bb1d2006-01-18 17:44:13 -08002065 do_pci_parity_check();
2066}
2067
Alan Coxda9bb1d2006-01-18 17:44:13 -08002068static int edac_kernel_thread(void *arg)
2069{
Dave Petersonf2fe42a2006-03-26 01:38:38 -08002070 while (!kthread_should_stop()) {
2071 do_edac_check();
Alan Coxda9bb1d2006-01-18 17:44:13 -08002072
2073 /* goto sleep for the interval */
Dave Petersonf2fe42a2006-03-26 01:38:38 -08002074 schedule_timeout_interruptible((HZ * poll_msec) / 1000);
Alan Coxda9bb1d2006-01-18 17:44:13 -08002075 try_to_freeze();
2076 }
2077
Alan Coxda9bb1d2006-01-18 17:44:13 -08002078 return 0;
2079}
2080
2081/*
2082 * edac_mc_init
2083 * module initialization entry point
2084 */
2085static int __init edac_mc_init(void)
2086{
Dave Peterson537fba22006-03-26 01:38:40 -08002087 edac_printk(KERN_INFO, EDAC_MC, EDAC_MC_VERSION "\n");
Alan Coxda9bb1d2006-01-18 17:44:13 -08002088
2089 /*
2090 * Harvest and clear any boot/initialization PCI parity errors
2091 *
2092 * FIXME: This only clears errors logged by devices present at time of
2093 * module initialization. We should also do an initial clear
2094 * of each newly hotplugged device.
2095 */
2096 clear_pci_parity_errors();
2097
2098 /* perform check for first time to harvest boot leftovers */
2099 do_edac_check();
2100
2101 /* Create the MC sysfs entires */
2102 if (edac_sysfs_memctrl_setup()) {
Dave Peterson537fba22006-03-26 01:38:40 -08002103 edac_printk(KERN_ERR, EDAC_MC,
2104 "Error initializing sysfs code\n");
Alan Coxda9bb1d2006-01-18 17:44:13 -08002105 return -ENODEV;
2106 }
2107
2108 /* Create the PCI parity sysfs entries */
2109 if (edac_sysfs_pci_setup()) {
2110 edac_sysfs_memctrl_teardown();
Dave Peterson537fba22006-03-26 01:38:40 -08002111 edac_printk(KERN_ERR, EDAC_MC,
2112 "EDAC PCI: Error initializing sysfs code\n");
Alan Coxda9bb1d2006-01-18 17:44:13 -08002113 return -ENODEV;
2114 }
2115
Alan Coxda9bb1d2006-01-18 17:44:13 -08002116 /* create our kernel thread */
Dave Petersonf2fe42a2006-03-26 01:38:38 -08002117 edac_thread = kthread_run(edac_kernel_thread, NULL, "kedac");
2118 if (IS_ERR(edac_thread)) {
Alan Coxda9bb1d2006-01-18 17:44:13 -08002119 /* remove the sysfs entries */
2120 edac_sysfs_memctrl_teardown();
2121 edac_sysfs_pci_teardown();
Dave Petersonf2fe42a2006-03-26 01:38:38 -08002122 return PTR_ERR(edac_thread);
Alan Coxda9bb1d2006-01-18 17:44:13 -08002123 }
2124
Alan Coxda9bb1d2006-01-18 17:44:13 -08002125 return 0;
2126}
2127
2128
2129/*
2130 * edac_mc_exit()
2131 * module exit/termination functioni
2132 */
2133static void __exit edac_mc_exit(void)
2134{
Dave Peterson537fba22006-03-26 01:38:40 -08002135 debugf0("%s()\n", __func__);
Alan Coxda9bb1d2006-01-18 17:44:13 -08002136
Dave Petersonf2fe42a2006-03-26 01:38:38 -08002137 kthread_stop(edac_thread);
Alan Coxda9bb1d2006-01-18 17:44:13 -08002138
2139 /* tear down the sysfs device */
2140 edac_sysfs_memctrl_teardown();
2141 edac_sysfs_pci_teardown();
2142}
2143
2144
2145
2146
2147module_init(edac_mc_init);
2148module_exit(edac_mc_exit);
2149
2150MODULE_LICENSE("GPL");
2151MODULE_AUTHOR("Linux Networx (http://lnxi.com) Thayne Harbaugh et al\n"
2152 "Based on.work by Dan Hollis et al");
2153MODULE_DESCRIPTION("Core library routines for MC reporting");
2154
2155module_param(panic_on_ue, int, 0644);
2156MODULE_PARM_DESC(panic_on_ue, "Panic on uncorrected error: 0=off 1=on");
2157module_param(check_pci_parity, int, 0644);
2158MODULE_PARM_DESC(check_pci_parity, "Check for PCI bus parity errors: 0=off 1=on");
2159module_param(panic_on_pci_parity, int, 0644);
2160MODULE_PARM_DESC(panic_on_pci_parity, "Panic on PCI Bus Parity error: 0=off 1=on");
2161module_param(log_ue, int, 0644);
2162MODULE_PARM_DESC(log_ue, "Log uncorrectable error to console: 0=off 1=on");
2163module_param(log_ce, int, 0644);
2164MODULE_PARM_DESC(log_ce, "Log correctable error to console: 0=off 1=on");
2165module_param(poll_msec, int, 0644);
2166MODULE_PARM_DESC(poll_msec, "Polling period in milliseconds");
2167#ifdef CONFIG_EDAC_DEBUG
2168module_param(edac_debug_level, int, 0644);
2169MODULE_PARM_DESC(edac_debug_level, "Debug level");
2170#endif