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.
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/
11 * Modified by Dave Peterson and Doug Thompson
15 #include <linux/config.h>
16 #include <linux/module.h>
17 #include <linux/proc_fs.h>
18 #include <linux/kernel.h>
19 #include <linux/types.h>
20 #include <linux/smp.h>
21 #include <linux/init.h>
22 #include <linux/sysctl.h>
23 #include <linux/highmem.h>
24 #include <linux/timer.h>
25 #include <linux/slab.h>
26 #include <linux/jiffies.h>
27 #include <linux/spinlock.h>
28 #include <linux/list.h>
29 #include <linux/sysdev.h>
30 #include <linux/ctype.h>
31 #include <linux/kthread.h>
32 #include <asm/uaccess.h>
37 #define EDAC_MC_VERSION "Ver: 2.0.0 " __DATE__
39 /* For now, disable the EDAC sysfs code. The sysfs interface that EDAC
40 * presents to user space needs more thought, and is likely to change
43 #define DISABLE_EDAC_SYSFS
45 #ifdef CONFIG_EDAC_DEBUG
46 /* Values of 0 to 4 will generate output */
47 int edac_debug_level
= 1;
48 EXPORT_SYMBOL_GPL(edac_debug_level
);
51 /* EDAC Controls, setable by module parameter, and sysfs */
52 static int log_ue
= 1;
53 static int log_ce
= 1;
54 static int panic_on_ue
;
55 static int poll_msec
= 1000;
57 /* lock to memory controller's control array */
58 static DECLARE_MUTEX(mem_ctls_mutex
);
59 static struct list_head mc_devices
= LIST_HEAD_INIT(mc_devices
);
61 static struct task_struct
*edac_thread
;
64 static int check_pci_parity
= 0; /* default YES check PCI parity */
65 static int panic_on_pci_parity
; /* default no panic on PCI Parity */
66 static atomic_t pci_parity_count
= ATOMIC_INIT(0);
68 /* Structure of the whitelist and blacklist arrays */
69 struct edac_pci_device_list
{
70 unsigned int vendor
; /* Vendor ID */
71 unsigned int device
; /* Deviice ID */
74 #define MAX_LISTED_PCI_DEVICES 32
76 /* List of PCI devices (vendor-id:device-id) that should be skipped */
77 static struct edac_pci_device_list pci_blacklist
[MAX_LISTED_PCI_DEVICES
];
78 static int pci_blacklist_count
;
80 /* List of PCI devices (vendor-id:device-id) that should be scanned */
81 static struct edac_pci_device_list pci_whitelist
[MAX_LISTED_PCI_DEVICES
];
82 static int pci_whitelist_count
;
84 #ifndef DISABLE_EDAC_SYSFS
85 static struct kobject edac_pci_kobj
; /* /sys/devices/system/edac/pci */
86 static struct completion edac_pci_kobj_complete
;
87 #endif /* DISABLE_EDAC_SYSFS */
88 #endif /* CONFIG_PCI */
90 /* START sysfs data and methods */
92 #ifndef DISABLE_EDAC_SYSFS
94 static const char *mem_types
[] = {
95 [MEM_EMPTY
] = "Empty",
96 [MEM_RESERVED
] = "Reserved",
97 [MEM_UNKNOWN
] = "Unknown",
101 [MEM_SDR
] = "Unbuffered-SDR",
102 [MEM_RDR
] = "Registered-SDR",
103 [MEM_DDR
] = "Unbuffered-DDR",
104 [MEM_RDDR
] = "Registered-DDR",
108 static const char *dev_types
[] = {
109 [DEV_UNKNOWN
] = "Unknown",
119 static const char *edac_caps
[] = {
120 [EDAC_UNKNOWN
] = "Unknown",
121 [EDAC_NONE
] = "None",
122 [EDAC_RESERVED
] = "Reserved",
123 [EDAC_PARITY
] = "PARITY",
125 [EDAC_SECDED
] = "SECDED",
126 [EDAC_S2ECD2ED
] = "S2ECD2ED",
127 [EDAC_S4ECD4ED
] = "S4ECD4ED",
128 [EDAC_S8ECD8ED
] = "S8ECD8ED",
129 [EDAC_S16ECD16ED
] = "S16ECD16ED"
132 /* sysfs object: /sys/devices/system/edac */
133 static struct sysdev_class edac_class
= {
134 set_kset_name("edac"),
138 * /sys/devices/system/edac/mc
140 static struct kobject edac_memctrl_kobj
;
142 /* We use these to wait for the reference counts on edac_memctrl_kobj and
143 * edac_pci_kobj to reach 0.
145 static struct completion edac_memctrl_kobj_complete
;
148 * /sys/devices/system/edac/mc;
149 * data structures and methods
152 static ssize_t
memctrl_string_show(void *ptr
, char *buffer
)
154 char *value
= (char*) ptr
;
155 return sprintf(buffer
, "%s\n", value
);
159 static ssize_t
memctrl_int_show(void *ptr
, char *buffer
)
161 int *value
= (int*) ptr
;
162 return sprintf(buffer
, "%d\n", *value
);
165 static ssize_t
memctrl_int_store(void *ptr
, const char *buffer
, size_t count
)
167 int *value
= (int*) ptr
;
169 if (isdigit(*buffer
))
170 *value
= simple_strtoul(buffer
, NULL
, 0);
175 struct memctrl_dev_attribute
{
176 struct attribute attr
;
178 ssize_t (*show
)(void *,char *);
179 ssize_t (*store
)(void *, const char *, size_t);
182 /* Set of show/store abstract level functions for memory control object */
183 static ssize_t
memctrl_dev_show(struct kobject
*kobj
,
184 struct attribute
*attr
, char *buffer
)
186 struct memctrl_dev_attribute
*memctrl_dev
;
187 memctrl_dev
= (struct memctrl_dev_attribute
*)attr
;
189 if (memctrl_dev
->show
)
190 return memctrl_dev
->show(memctrl_dev
->value
, buffer
);
195 static ssize_t
memctrl_dev_store(struct kobject
*kobj
, struct attribute
*attr
,
196 const char *buffer
, size_t count
)
198 struct memctrl_dev_attribute
*memctrl_dev
;
199 memctrl_dev
= (struct memctrl_dev_attribute
*)attr
;
201 if (memctrl_dev
->store
)
202 return memctrl_dev
->store(memctrl_dev
->value
, buffer
, count
);
207 static struct sysfs_ops memctrlfs_ops
= {
208 .show
= memctrl_dev_show
,
209 .store
= memctrl_dev_store
212 #define MEMCTRL_ATTR(_name,_mode,_show,_store) \
213 struct memctrl_dev_attribute attr_##_name = { \
214 .attr = {.name = __stringify(_name), .mode = _mode }, \
220 #define MEMCTRL_STRING_ATTR(_name,_data,_mode,_show,_store) \
221 struct memctrl_dev_attribute attr_##_name = { \
222 .attr = {.name = __stringify(_name), .mode = _mode }, \
228 /* cwrow<id> attribute f*/
230 MEMCTRL_STRING_ATTR(mc_version
,EDAC_MC_VERSION
,S_IRUGO
,memctrl_string_show
,NULL
);
233 /* csrow<id> control files */
234 MEMCTRL_ATTR(panic_on_ue
,S_IRUGO
|S_IWUSR
,memctrl_int_show
,memctrl_int_store
);
235 MEMCTRL_ATTR(log_ue
,S_IRUGO
|S_IWUSR
,memctrl_int_show
,memctrl_int_store
);
236 MEMCTRL_ATTR(log_ce
,S_IRUGO
|S_IWUSR
,memctrl_int_show
,memctrl_int_store
);
237 MEMCTRL_ATTR(poll_msec
,S_IRUGO
|S_IWUSR
,memctrl_int_show
,memctrl_int_store
);
239 /* Base Attributes of the memory ECC object */
240 static struct memctrl_dev_attribute
*memctrl_attr
[] = {
248 /* Main MC kobject release() function */
249 static void edac_memctrl_master_release(struct kobject
*kobj
)
251 debugf1("%s()\n", __func__
);
252 complete(&edac_memctrl_kobj_complete
);
255 static struct kobj_type ktype_memctrl
= {
256 .release
= edac_memctrl_master_release
,
257 .sysfs_ops
= &memctrlfs_ops
,
258 .default_attrs
= (struct attribute
**) memctrl_attr
,
261 #endif /* DISABLE_EDAC_SYSFS */
263 /* Initialize the main sysfs entries for edac:
264 * /sys/devices/system/edac
271 static int edac_sysfs_memctrl_setup(void)
272 #ifdef DISABLE_EDAC_SYSFS
280 debugf1("%s()\n", __func__
);
282 /* create the /sys/devices/system/edac directory */
283 err
= sysdev_class_register(&edac_class
);
286 /* Init the MC's kobject */
287 memset(&edac_memctrl_kobj
, 0, sizeof (edac_memctrl_kobj
));
288 edac_memctrl_kobj
.parent
= &edac_class
.kset
.kobj
;
289 edac_memctrl_kobj
.ktype
= &ktype_memctrl
;
291 /* generate sysfs "..../edac/mc" */
292 err
= kobject_set_name(&edac_memctrl_kobj
,"mc");
295 /* FIXME: maybe new sysdev_create_subdir() */
296 err
= kobject_register(&edac_memctrl_kobj
);
299 debugf1("Failed to register '.../edac/mc'\n");
301 debugf1("Registered '.../edac/mc' kobject\n");
304 debugf1("%s() error=%d\n", __func__
, err
);
308 #endif /* DISABLE_EDAC_SYSFS */
312 * the '..../edac/mc' kobject followed by '..../edac' itself
314 static void edac_sysfs_memctrl_teardown(void)
316 #ifndef DISABLE_EDAC_SYSFS
317 debugf0("MC: " __FILE__
": %s()\n", __func__
);
319 /* Unregister the MC's kobject and wait for reference count to reach
322 init_completion(&edac_memctrl_kobj_complete
);
323 kobject_unregister(&edac_memctrl_kobj
);
324 wait_for_completion(&edac_memctrl_kobj_complete
);
326 /* Unregister the 'edac' object */
327 sysdev_class_unregister(&edac_class
);
328 #endif /* DISABLE_EDAC_SYSFS */
333 #ifndef DISABLE_EDAC_SYSFS
336 * /sys/devices/system/edac/pci;
337 * data structures and methods
340 struct list_control
{
341 struct edac_pci_device_list
*list
;
346 /* Output the list as: vendor_id:device:id<,vendor_id:device_id> */
347 static ssize_t
edac_pci_list_string_show(void *ptr
, char *buffer
)
349 struct list_control
*listctl
;
350 struct edac_pci_device_list
*list
;
356 list
= listctl
->list
;
358 for (i
= 0; i
< *(listctl
->count
); i
++, list
++ ) {
360 len
+= snprintf(p
+ len
, (PAGE_SIZE
-len
), ",");
362 len
+= snprintf(p
+ len
,
365 list
->vendor
,list
->device
);
368 len
+= snprintf(p
+ len
,(PAGE_SIZE
-len
), "\n");
369 return (ssize_t
) len
;
374 * Scan string from **s to **e looking for one 'vendor:device' tuple
375 * where each field is a hex value
377 * return 0 if an entry is NOT found
378 * return 1 if an entry is found
379 * fill in *vendor_id and *device_id with values found
381 * In both cases, make sure *s has been moved forward toward *e
383 static int parse_one_device(const char **s
,const char **e
,
384 unsigned int *vendor_id
, unsigned int *device_id
)
386 const char *runner
, *p
;
388 /* if null byte, we are done */
390 (*s
)++; /* keep *s moving */
394 /* skip over newlines & whitespace */
395 if ((**s
== '\n') || isspace(**s
)) {
400 if (!isxdigit(**s
)) {
405 /* parse vendor_id */
408 while (runner
< *e
) {
409 /* scan for vendor:device delimiter */
410 if (*runner
== ':') {
411 *vendor_id
= simple_strtol((char*) *s
, (char**) &p
, 16);
419 if (!isxdigit(*runner
)) {
424 /* parse device_id */
426 *device_id
= simple_strtol((char*)runner
, (char**)&p
, 16);
434 static ssize_t
edac_pci_list_string_store(void *ptr
, const char *buffer
,
437 struct list_control
*listctl
;
438 struct edac_pci_device_list
*list
;
439 unsigned int vendor_id
, device_id
;
446 list
= listctl
->list
;
447 index
= listctl
->count
;
450 while (*index
< MAX_LISTED_PCI_DEVICES
) {
451 if (parse_one_device(&s
,&e
,&vendor_id
,&device_id
)) {
452 list
[ *index
].vendor
= vendor_id
;
453 list
[ *index
].device
= device_id
;
457 /* check for all data consume */
466 static ssize_t
edac_pci_int_show(void *ptr
, char *buffer
)
469 return sprintf(buffer
,"%d\n",*value
);
472 static ssize_t
edac_pci_int_store(void *ptr
, const char *buffer
, size_t count
)
476 if (isdigit(*buffer
))
477 *value
= simple_strtoul(buffer
,NULL
,0);
482 struct edac_pci_dev_attribute
{
483 struct attribute attr
;
485 ssize_t (*show
)(void *,char *);
486 ssize_t (*store
)(void *, const char *,size_t);
489 /* Set of show/store abstract level functions for PCI Parity object */
490 static ssize_t
edac_pci_dev_show(struct kobject
*kobj
, struct attribute
*attr
,
493 struct edac_pci_dev_attribute
*edac_pci_dev
;
494 edac_pci_dev
= (struct edac_pci_dev_attribute
*)attr
;
496 if (edac_pci_dev
->show
)
497 return edac_pci_dev
->show(edac_pci_dev
->value
, buffer
);
501 static ssize_t
edac_pci_dev_store(struct kobject
*kobj
,
502 struct attribute
*attr
, const char *buffer
, size_t count
)
504 struct edac_pci_dev_attribute
*edac_pci_dev
;
505 edac_pci_dev
= (struct edac_pci_dev_attribute
*)attr
;
507 if (edac_pci_dev
->show
)
508 return edac_pci_dev
->store(edac_pci_dev
->value
, buffer
, count
);
512 static struct sysfs_ops edac_pci_sysfs_ops
= {
513 .show
= edac_pci_dev_show
,
514 .store
= edac_pci_dev_store
517 #define EDAC_PCI_ATTR(_name,_mode,_show,_store) \
518 struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
519 .attr = {.name = __stringify(_name), .mode = _mode }, \
525 #define EDAC_PCI_STRING_ATTR(_name,_data,_mode,_show,_store) \
526 struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
527 .attr = {.name = __stringify(_name), .mode = _mode }, \
534 static struct list_control pci_whitelist_control
= {
535 .list
= pci_whitelist
,
536 .count
= &pci_whitelist_count
539 static struct list_control pci_blacklist_control
= {
540 .list
= pci_blacklist
,
541 .count
= &pci_blacklist_count
544 /* whitelist attribute */
545 EDAC_PCI_STRING_ATTR(pci_parity_whitelist
,
546 &pci_whitelist_control
,
548 edac_pci_list_string_show
,
549 edac_pci_list_string_store
);
551 EDAC_PCI_STRING_ATTR(pci_parity_blacklist
,
552 &pci_blacklist_control
,
554 edac_pci_list_string_show
,
555 edac_pci_list_string_store
);
558 /* PCI Parity control files */
559 EDAC_PCI_ATTR(check_pci_parity
, S_IRUGO
|S_IWUSR
, edac_pci_int_show
,
561 EDAC_PCI_ATTR(panic_on_pci_parity
, S_IRUGO
|S_IWUSR
, edac_pci_int_show
,
563 EDAC_PCI_ATTR(pci_parity_count
, S_IRUGO
, edac_pci_int_show
, NULL
);
565 /* Base Attributes of the memory ECC object */
566 static struct edac_pci_dev_attribute
*edac_pci_attr
[] = {
567 &edac_pci_attr_check_pci_parity
,
568 &edac_pci_attr_panic_on_pci_parity
,
569 &edac_pci_attr_pci_parity_count
,
573 /* No memory to release */
574 static void edac_pci_release(struct kobject
*kobj
)
576 debugf1("%s()\n", __func__
);
577 complete(&edac_pci_kobj_complete
);
580 static struct kobj_type ktype_edac_pci
= {
581 .release
= edac_pci_release
,
582 .sysfs_ops
= &edac_pci_sysfs_ops
,
583 .default_attrs
= (struct attribute
**) edac_pci_attr
,
586 #endif /* DISABLE_EDAC_SYSFS */
589 * edac_sysfs_pci_setup()
592 static int edac_sysfs_pci_setup(void)
593 #ifdef DISABLE_EDAC_SYSFS
601 debugf1("%s()\n", __func__
);
603 memset(&edac_pci_kobj
, 0, sizeof(edac_pci_kobj
));
604 edac_pci_kobj
.parent
= &edac_class
.kset
.kobj
;
605 edac_pci_kobj
.ktype
= &ktype_edac_pci
;
606 err
= kobject_set_name(&edac_pci_kobj
, "pci");
609 /* Instanstiate the csrow object */
610 /* FIXME: maybe new sysdev_create_subdir() */
611 err
= kobject_register(&edac_pci_kobj
);
614 debugf1("Failed to register '.../edac/pci'\n");
616 debugf1("Registered '.../edac/pci' kobject\n");
621 #endif /* DISABLE_EDAC_SYSFS */
623 static void edac_sysfs_pci_teardown(void)
625 #ifndef DISABLE_EDAC_SYSFS
626 debugf0("%s()\n", __func__
);
627 init_completion(&edac_pci_kobj_complete
);
628 kobject_unregister(&edac_pci_kobj
);
629 wait_for_completion(&edac_pci_kobj_complete
);
634 static u16
get_pci_parity_status(struct pci_dev
*dev
, int secondary
)
639 where
= secondary
? PCI_SEC_STATUS
: PCI_STATUS
;
640 pci_read_config_word(dev
, where
, &status
);
642 /* If we get back 0xFFFF then we must suspect that the card has been
643 * pulled but the Linux PCI layer has not yet finished cleaning up.
644 * We don't want to report on such devices
647 if (status
== 0xFFFF) {
650 pci_read_config_dword(dev
, 0, &sanity
);
652 if (sanity
== 0xFFFFFFFF)
656 status
&= PCI_STATUS_DETECTED_PARITY
| PCI_STATUS_SIG_SYSTEM_ERROR
|
660 /* reset only the bits we are interested in */
661 pci_write_config_word(dev
, where
, status
);
666 typedef void (*pci_parity_check_fn_t
) (struct pci_dev
*dev
);
668 /* Clear any PCI parity errors logged by this device. */
669 static void edac_pci_dev_parity_clear(struct pci_dev
*dev
)
673 get_pci_parity_status(dev
, 0);
675 /* read the device TYPE, looking for bridges */
676 pci_read_config_byte(dev
, PCI_HEADER_TYPE
, &header_type
);
678 if ((header_type
& 0x7F) == PCI_HEADER_TYPE_BRIDGE
)
679 get_pci_parity_status(dev
, 1);
686 static void edac_pci_dev_parity_test(struct pci_dev
*dev
)
691 /* read the STATUS register on this device
693 status
= get_pci_parity_status(dev
, 0);
695 debugf2("PCI STATUS= 0x%04x %s\n", status
, dev
->dev
.bus_id
);
697 /* check the status reg for errors */
699 if (status
& (PCI_STATUS_SIG_SYSTEM_ERROR
))
700 edac_printk(KERN_CRIT
, EDAC_PCI
,
701 "Signaled System Error on %s\n",
704 if (status
& (PCI_STATUS_PARITY
)) {
705 edac_printk(KERN_CRIT
, EDAC_PCI
,
706 "Master Data Parity Error on %s\n",
709 atomic_inc(&pci_parity_count
);
712 if (status
& (PCI_STATUS_DETECTED_PARITY
)) {
713 edac_printk(KERN_CRIT
, EDAC_PCI
,
714 "Detected Parity Error on %s\n",
717 atomic_inc(&pci_parity_count
);
721 /* read the device TYPE, looking for bridges */
722 pci_read_config_byte(dev
, PCI_HEADER_TYPE
, &header_type
);
724 debugf2("PCI HEADER TYPE= 0x%02x %s\n", header_type
, dev
->dev
.bus_id
);
726 if ((header_type
& 0x7F) == PCI_HEADER_TYPE_BRIDGE
) {
727 /* On bridges, need to examine secondary status register */
728 status
= get_pci_parity_status(dev
, 1);
730 debugf2("PCI SEC_STATUS= 0x%04x %s\n",
731 status
, dev
->dev
.bus_id
);
733 /* check the secondary status reg for errors */
735 if (status
& (PCI_STATUS_SIG_SYSTEM_ERROR
))
736 edac_printk(KERN_CRIT
, EDAC_PCI
, "Bridge "
737 "Signaled System Error on %s\n",
740 if (status
& (PCI_STATUS_PARITY
)) {
741 edac_printk(KERN_CRIT
, EDAC_PCI
, "Bridge "
742 "Master Data Parity Error on "
743 "%s\n", pci_name(dev
));
745 atomic_inc(&pci_parity_count
);
748 if (status
& (PCI_STATUS_DETECTED_PARITY
)) {
749 edac_printk(KERN_CRIT
, EDAC_PCI
, "Bridge "
750 "Detected Parity Error on %s\n",
753 atomic_inc(&pci_parity_count
);
760 * check_dev_on_list: Scan for a PCI device on a white/black list
761 * @list: an EDAC &edac_pci_device_list white/black list pointer
762 * @free_index: index of next free entry on the list
763 * @pci_dev: PCI Device pointer
765 * see if list contains the device.
767 * Returns: 0 not found
770 static int check_dev_on_list(struct edac_pci_device_list
*list
,
771 int free_index
, struct pci_dev
*dev
)
774 int rc
= 0; /* Assume not found */
775 unsigned short vendor
=dev
->vendor
;
776 unsigned short device
=dev
->device
;
778 /* Scan the list, looking for a vendor/device match */
779 for (i
= 0; i
< free_index
; i
++, list
++ ) {
780 if ((list
->vendor
== vendor
) && (list
->device
== device
)) {
790 * pci_dev parity list iterator
791 * Scan the PCI device list for one iteration, looking for SERRORs
792 * Master Parity ERRORS or Parity ERRORs on primary or secondary devices
794 static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn
)
796 struct pci_dev
*dev
= NULL
;
798 /* request for kernel access to the next PCI device, if any,
799 * and while we are looking at it have its reference count
800 * bumped until we are done with it
802 while((dev
= pci_get_device(PCI_ANY_ID
, PCI_ANY_ID
, dev
)) != NULL
) {
803 /* if whitelist exists then it has priority, so only scan
804 * those devices on the whitelist
806 if (pci_whitelist_count
> 0 ) {
807 if (check_dev_on_list(pci_whitelist
,
808 pci_whitelist_count
, dev
))
812 * if no whitelist, then check if this devices is
815 if (!check_dev_on_list(pci_blacklist
,
816 pci_blacklist_count
, dev
))
822 static void do_pci_parity_check(void)
827 debugf3("%s()\n", __func__
);
829 if (!check_pci_parity
)
832 before_count
= atomic_read(&pci_parity_count
);
834 /* scan all PCI devices looking for a Parity Error on devices and
837 local_irq_save(flags
);
838 edac_pci_dev_parity_iterator(edac_pci_dev_parity_test
);
839 local_irq_restore(flags
);
841 /* Only if operator has selected panic on PCI Error */
842 if (panic_on_pci_parity
) {
843 /* If the count is different 'after' from 'before' */
844 if (before_count
!= atomic_read(&pci_parity_count
))
845 panic("EDAC: PCI Parity Error");
849 static inline void clear_pci_parity_errors(void)
851 /* Clear any PCI bus parity errors that devices initially have logged
852 * in their registers.
854 edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear
);
857 #else /* CONFIG_PCI */
859 static inline void do_pci_parity_check(void)
864 static inline void clear_pci_parity_errors(void)
869 static void edac_sysfs_pci_teardown(void)
873 static int edac_sysfs_pci_setup(void)
877 #endif /* CONFIG_PCI */
879 #ifndef DISABLE_EDAC_SYSFS
881 /* EDAC sysfs CSROW data structures and methods */
883 /* Set of more detailed csrow<id> attribute show/store functions */
884 static ssize_t
csrow_ch0_dimm_label_show(struct csrow_info
*csrow
, char *data
)
888 if (csrow
->nr_channels
> 0) {
889 size
= snprintf(data
, EDAC_MC_LABEL_LEN
,"%s\n",
890 csrow
->channels
[0].label
);
896 static ssize_t
csrow_ch1_dimm_label_show(struct csrow_info
*csrow
, char *data
)
900 if (csrow
->nr_channels
> 0) {
901 size
= snprintf(data
, EDAC_MC_LABEL_LEN
, "%s\n",
902 csrow
->channels
[1].label
);
908 static ssize_t
csrow_ch0_dimm_label_store(struct csrow_info
*csrow
,
909 const char *data
, size_t size
)
911 ssize_t max_size
= 0;
913 if (csrow
->nr_channels
> 0) {
914 max_size
= min((ssize_t
)size
,(ssize_t
)EDAC_MC_LABEL_LEN
-1);
915 strncpy(csrow
->channels
[0].label
, data
, max_size
);
916 csrow
->channels
[0].label
[max_size
] = '\0';
922 static ssize_t
csrow_ch1_dimm_label_store(struct csrow_info
*csrow
,
923 const char *data
, size_t size
)
925 ssize_t max_size
= 0;
927 if (csrow
->nr_channels
> 1) {
928 max_size
= min((ssize_t
)size
,(ssize_t
)EDAC_MC_LABEL_LEN
-1);
929 strncpy(csrow
->channels
[1].label
, data
, max_size
);
930 csrow
->channels
[1].label
[max_size
] = '\0';
936 static ssize_t
csrow_ue_count_show(struct csrow_info
*csrow
, char *data
)
938 return sprintf(data
,"%u\n", csrow
->ue_count
);
941 static ssize_t
csrow_ce_count_show(struct csrow_info
*csrow
, char *data
)
943 return sprintf(data
,"%u\n", csrow
->ce_count
);
946 static ssize_t
csrow_ch0_ce_count_show(struct csrow_info
*csrow
, char *data
)
950 if (csrow
->nr_channels
> 0) {
951 size
= sprintf(data
,"%u\n", csrow
->channels
[0].ce_count
);
957 static ssize_t
csrow_ch1_ce_count_show(struct csrow_info
*csrow
, char *data
)
961 if (csrow
->nr_channels
> 1) {
962 size
= sprintf(data
,"%u\n", csrow
->channels
[1].ce_count
);
968 static ssize_t
csrow_size_show(struct csrow_info
*csrow
, char *data
)
970 return sprintf(data
,"%u\n", PAGES_TO_MiB(csrow
->nr_pages
));
973 static ssize_t
csrow_mem_type_show(struct csrow_info
*csrow
, char *data
)
975 return sprintf(data
,"%s\n", mem_types
[csrow
->mtype
]);
978 static ssize_t
csrow_dev_type_show(struct csrow_info
*csrow
, char *data
)
980 return sprintf(data
,"%s\n", dev_types
[csrow
->dtype
]);
983 static ssize_t
csrow_edac_mode_show(struct csrow_info
*csrow
, char *data
)
985 return sprintf(data
,"%s\n", edac_caps
[csrow
->edac_mode
]);
988 struct csrowdev_attribute
{
989 struct attribute attr
;
990 ssize_t (*show
)(struct csrow_info
*,char *);
991 ssize_t (*store
)(struct csrow_info
*, const char *,size_t);
994 #define to_csrow(k) container_of(k, struct csrow_info, kobj)
995 #define to_csrowdev_attr(a) container_of(a, struct csrowdev_attribute, attr)
997 /* Set of show/store higher level functions for csrow objects */
998 static ssize_t
csrowdev_show(struct kobject
*kobj
, struct attribute
*attr
,
1001 struct csrow_info
*csrow
= to_csrow(kobj
);
1002 struct csrowdev_attribute
*csrowdev_attr
= to_csrowdev_attr(attr
);
1004 if (csrowdev_attr
->show
)
1005 return csrowdev_attr
->show(csrow
, buffer
);
1010 static ssize_t
csrowdev_store(struct kobject
*kobj
, struct attribute
*attr
,
1011 const char *buffer
, size_t count
)
1013 struct csrow_info
*csrow
= to_csrow(kobj
);
1014 struct csrowdev_attribute
* csrowdev_attr
= to_csrowdev_attr(attr
);
1016 if (csrowdev_attr
->store
)
1017 return csrowdev_attr
->store(csrow
, buffer
, count
);
1022 static struct sysfs_ops csrowfs_ops
= {
1023 .show
= csrowdev_show
,
1024 .store
= csrowdev_store
1027 #define CSROWDEV_ATTR(_name,_mode,_show,_store) \
1028 struct csrowdev_attribute attr_##_name = { \
1029 .attr = {.name = __stringify(_name), .mode = _mode }, \
1034 /* cwrow<id>/attribute files */
1035 CSROWDEV_ATTR(size_mb
,S_IRUGO
,csrow_size_show
,NULL
);
1036 CSROWDEV_ATTR(dev_type
,S_IRUGO
,csrow_dev_type_show
,NULL
);
1037 CSROWDEV_ATTR(mem_type
,S_IRUGO
,csrow_mem_type_show
,NULL
);
1038 CSROWDEV_ATTR(edac_mode
,S_IRUGO
,csrow_edac_mode_show
,NULL
);
1039 CSROWDEV_ATTR(ue_count
,S_IRUGO
,csrow_ue_count_show
,NULL
);
1040 CSROWDEV_ATTR(ce_count
,S_IRUGO
,csrow_ce_count_show
,NULL
);
1041 CSROWDEV_ATTR(ch0_ce_count
,S_IRUGO
,csrow_ch0_ce_count_show
,NULL
);
1042 CSROWDEV_ATTR(ch1_ce_count
,S_IRUGO
,csrow_ch1_ce_count_show
,NULL
);
1044 /* control/attribute files */
1045 CSROWDEV_ATTR(ch0_dimm_label
,S_IRUGO
|S_IWUSR
,
1046 csrow_ch0_dimm_label_show
,
1047 csrow_ch0_dimm_label_store
);
1048 CSROWDEV_ATTR(ch1_dimm_label
,S_IRUGO
|S_IWUSR
,
1049 csrow_ch1_dimm_label_show
,
1050 csrow_ch1_dimm_label_store
);
1052 /* Attributes of the CSROW<id> object */
1053 static struct csrowdev_attribute
*csrow_attr
[] = {
1062 &attr_ch0_dimm_label
,
1063 &attr_ch1_dimm_label
,
1067 /* No memory to release */
1068 static void edac_csrow_instance_release(struct kobject
*kobj
)
1070 struct csrow_info
*cs
;
1072 debugf1("%s()\n", __func__
);
1073 cs
= container_of(kobj
, struct csrow_info
, kobj
);
1074 complete(&cs
->kobj_complete
);
1077 static struct kobj_type ktype_csrow
= {
1078 .release
= edac_csrow_instance_release
,
1079 .sysfs_ops
= &csrowfs_ops
,
1080 .default_attrs
= (struct attribute
**) csrow_attr
,
1083 /* Create a CSROW object under specifed edac_mc_device */
1084 static int edac_create_csrow_object(struct kobject
*edac_mci_kobj
,
1085 struct csrow_info
*csrow
, int index
)
1089 debugf0("%s()\n", __func__
);
1090 memset(&csrow
->kobj
, 0, sizeof(csrow
->kobj
));
1092 /* generate ..../edac/mc/mc<id>/csrow<index> */
1094 csrow
->kobj
.parent
= edac_mci_kobj
;
1095 csrow
->kobj
.ktype
= &ktype_csrow
;
1097 /* name this instance of csrow<id> */
1098 err
= kobject_set_name(&csrow
->kobj
,"csrow%d",index
);
1101 /* Instanstiate the csrow object */
1102 err
= kobject_register(&csrow
->kobj
);
1105 debugf0("Failed to register CSROW%d\n",index
);
1107 debugf0("Registered CSROW%d\n",index
);
1113 /* sysfs data structures and methods for the MCI kobjects */
1115 static ssize_t
mci_reset_counters_store(struct mem_ctl_info
*mci
,
1116 const char *data
, size_t count
)
1120 mci
->ue_noinfo_count
= 0;
1121 mci
->ce_noinfo_count
= 0;
1125 for (row
= 0; row
< mci
->nr_csrows
; row
++) {
1126 struct csrow_info
*ri
= &mci
->csrows
[row
];
1131 for (chan
= 0; chan
< ri
->nr_channels
; chan
++)
1132 ri
->channels
[chan
].ce_count
= 0;
1135 mci
->start_time
= jiffies
;
1139 static ssize_t
mci_ue_count_show(struct mem_ctl_info
*mci
, char *data
)
1141 return sprintf(data
,"%d\n", mci
->ue_count
);
1144 static ssize_t
mci_ce_count_show(struct mem_ctl_info
*mci
, char *data
)
1146 return sprintf(data
,"%d\n", mci
->ce_count
);
1149 static ssize_t
mci_ce_noinfo_show(struct mem_ctl_info
*mci
, char *data
)
1151 return sprintf(data
,"%d\n", mci
->ce_noinfo_count
);
1154 static ssize_t
mci_ue_noinfo_show(struct mem_ctl_info
*mci
, char *data
)
1156 return sprintf(data
,"%d\n", mci
->ue_noinfo_count
);
1159 static ssize_t
mci_seconds_show(struct mem_ctl_info
*mci
, char *data
)
1161 return sprintf(data
,"%ld\n", (jiffies
- mci
->start_time
) / HZ
);
1164 static ssize_t
mci_mod_name_show(struct mem_ctl_info
*mci
, char *data
)
1166 return sprintf(data
,"%s %s\n", mci
->mod_name
, mci
->mod_ver
);
1169 static ssize_t
mci_ctl_name_show(struct mem_ctl_info
*mci
, char *data
)
1171 return sprintf(data
,"%s\n", mci
->ctl_name
);
1174 static int mci_output_edac_cap(char *buf
, unsigned long edac_cap
)
1179 for (bit_idx
= 0; bit_idx
< 8 * sizeof(edac_cap
); bit_idx
++) {
1180 if ((edac_cap
>> bit_idx
) & 0x1)
1181 p
+= sprintf(p
, "%s ", edac_caps
[bit_idx
]);
1187 static ssize_t
mci_edac_capability_show(struct mem_ctl_info
*mci
, char *data
)
1191 p
+= mci_output_edac_cap(p
,mci
->edac_ctl_cap
);
1192 p
+= sprintf(p
, "\n");
1196 static ssize_t
mci_edac_current_capability_show(struct mem_ctl_info
*mci
,
1201 p
+= mci_output_edac_cap(p
,mci
->edac_cap
);
1202 p
+= sprintf(p
, "\n");
1206 static int mci_output_mtype_cap(char *buf
, unsigned long mtype_cap
)
1211 for (bit_idx
= 0; bit_idx
< 8 * sizeof(mtype_cap
); bit_idx
++) {
1212 if ((mtype_cap
>> bit_idx
) & 0x1)
1213 p
+= sprintf(p
, "%s ", mem_types
[bit_idx
]);
1219 static ssize_t
mci_supported_mem_type_show(struct mem_ctl_info
*mci
,
1224 p
+= mci_output_mtype_cap(p
,mci
->mtype_cap
);
1225 p
+= sprintf(p
, "\n");
1229 static ssize_t
mci_size_mb_show(struct mem_ctl_info
*mci
, char *data
)
1231 int total_pages
, csrow_idx
;
1233 for (total_pages
= csrow_idx
= 0; csrow_idx
< mci
->nr_csrows
;
1235 struct csrow_info
*csrow
= &mci
->csrows
[csrow_idx
];
1237 if (!csrow
->nr_pages
)
1240 total_pages
+= csrow
->nr_pages
;
1243 return sprintf(data
,"%u\n", PAGES_TO_MiB(total_pages
));
1246 struct mcidev_attribute
{
1247 struct attribute attr
;
1248 ssize_t (*show
)(struct mem_ctl_info
*,char *);
1249 ssize_t (*store
)(struct mem_ctl_info
*, const char *,size_t);
1252 #define to_mci(k) container_of(k, struct mem_ctl_info, edac_mci_kobj)
1253 #define to_mcidev_attr(a) container_of(a, struct mcidev_attribute, attr)
1255 static ssize_t
mcidev_show(struct kobject
*kobj
, struct attribute
*attr
,
1258 struct mem_ctl_info
*mem_ctl_info
= to_mci(kobj
);
1259 struct mcidev_attribute
* mcidev_attr
= to_mcidev_attr(attr
);
1261 if (mcidev_attr
->show
)
1262 return mcidev_attr
->show(mem_ctl_info
, buffer
);
1267 static ssize_t
mcidev_store(struct kobject
*kobj
, struct attribute
*attr
,
1268 const char *buffer
, size_t count
)
1270 struct mem_ctl_info
*mem_ctl_info
= to_mci(kobj
);
1271 struct mcidev_attribute
* mcidev_attr
= to_mcidev_attr(attr
);
1273 if (mcidev_attr
->store
)
1274 return mcidev_attr
->store(mem_ctl_info
, buffer
, count
);
1279 static struct sysfs_ops mci_ops
= {
1280 .show
= mcidev_show
,
1281 .store
= mcidev_store
1284 #define MCIDEV_ATTR(_name,_mode,_show,_store) \
1285 struct mcidev_attribute mci_attr_##_name = { \
1286 .attr = {.name = __stringify(_name), .mode = _mode }, \
1292 MCIDEV_ATTR(reset_counters
,S_IWUSR
,NULL
,mci_reset_counters_store
);
1294 /* Attribute files */
1295 MCIDEV_ATTR(mc_name
,S_IRUGO
,mci_ctl_name_show
,NULL
);
1296 MCIDEV_ATTR(module_name
,S_IRUGO
,mci_mod_name_show
,NULL
);
1297 MCIDEV_ATTR(edac_capability
,S_IRUGO
,mci_edac_capability_show
,NULL
);
1298 MCIDEV_ATTR(size_mb
,S_IRUGO
,mci_size_mb_show
,NULL
);
1299 MCIDEV_ATTR(seconds_since_reset
,S_IRUGO
,mci_seconds_show
,NULL
);
1300 MCIDEV_ATTR(ue_noinfo_count
,S_IRUGO
,mci_ue_noinfo_show
,NULL
);
1301 MCIDEV_ATTR(ce_noinfo_count
,S_IRUGO
,mci_ce_noinfo_show
,NULL
);
1302 MCIDEV_ATTR(ue_count
,S_IRUGO
,mci_ue_count_show
,NULL
);
1303 MCIDEV_ATTR(ce_count
,S_IRUGO
,mci_ce_count_show
,NULL
);
1304 MCIDEV_ATTR(edac_current_capability
,S_IRUGO
,
1305 mci_edac_current_capability_show
,NULL
);
1306 MCIDEV_ATTR(supported_mem_type
,S_IRUGO
,
1307 mci_supported_mem_type_show
,NULL
);
1309 static struct mcidev_attribute
*mci_attr
[] = {
1310 &mci_attr_reset_counters
,
1311 &mci_attr_module_name
,
1313 &mci_attr_edac_capability
,
1314 &mci_attr_edac_current_capability
,
1315 &mci_attr_supported_mem_type
,
1317 &mci_attr_seconds_since_reset
,
1318 &mci_attr_ue_noinfo_count
,
1319 &mci_attr_ce_noinfo_count
,
1326 * Release of a MC controlling instance
1328 static void edac_mci_instance_release(struct kobject
*kobj
)
1330 struct mem_ctl_info
*mci
;
1333 debugf0("%s() idx=%d\n", __func__
, mci
->mc_idx
);
1334 complete(&mci
->kobj_complete
);
1337 static struct kobj_type ktype_mci
= {
1338 .release
= edac_mci_instance_release
,
1339 .sysfs_ops
= &mci_ops
,
1340 .default_attrs
= (struct attribute
**) mci_attr
,
1343 #endif /* DISABLE_EDAC_SYSFS */
1345 #define EDAC_DEVICE_SYMLINK "device"
1348 * Create a new Memory Controller kobject instance,
1349 * mc<id> under the 'mc' directory
1355 static int edac_create_sysfs_mci_device(struct mem_ctl_info
*mci
)
1356 #ifdef DISABLE_EDAC_SYSFS
1364 struct csrow_info
*csrow
;
1365 struct kobject
*edac_mci_kobj
=&mci
->edac_mci_kobj
;
1367 debugf0("%s() idx=%d\n", __func__
, mci
->mc_idx
);
1368 memset(edac_mci_kobj
, 0, sizeof(*edac_mci_kobj
));
1370 /* set the name of the mc<id> object */
1371 err
= kobject_set_name(edac_mci_kobj
,"mc%d",mci
->mc_idx
);
1376 /* link to our parent the '..../edac/mc' object */
1377 edac_mci_kobj
->parent
= &edac_memctrl_kobj
;
1378 edac_mci_kobj
->ktype
= &ktype_mci
;
1380 /* register the mc<id> kobject */
1381 err
= kobject_register(edac_mci_kobj
);
1386 /* create a symlink for the device */
1387 err
= sysfs_create_link(edac_mci_kobj
, &mci
->dev
->kobj
,
1388 EDAC_DEVICE_SYMLINK
);
1393 /* Make directories for each CSROW object
1394 * under the mc<id> kobject
1396 for (i
= 0; i
< mci
->nr_csrows
; i
++) {
1397 csrow
= &mci
->csrows
[i
];
1399 /* Only expose populated CSROWs */
1400 if (csrow
->nr_pages
> 0) {
1401 err
= edac_create_csrow_object(edac_mci_kobj
,csrow
,i
);
1410 /* CSROW error: backout what has already been registered, */
1412 for ( i
--; i
>= 0; i
--) {
1413 if (csrow
->nr_pages
> 0) {
1414 init_completion(&csrow
->kobj_complete
);
1415 kobject_unregister(&mci
->csrows
[i
].kobj
);
1416 wait_for_completion(&csrow
->kobj_complete
);
1421 init_completion(&mci
->kobj_complete
);
1422 kobject_unregister(edac_mci_kobj
);
1423 wait_for_completion(&mci
->kobj_complete
);
1426 #endif /* DISABLE_EDAC_SYSFS */
1429 * remove a Memory Controller instance
1431 static void edac_remove_sysfs_mci_device(struct mem_ctl_info
*mci
)
1433 #ifndef DISABLE_EDAC_SYSFS
1436 debugf0("%s()\n", __func__
);
1438 /* remove all csrow kobjects */
1439 for (i
= 0; i
< mci
->nr_csrows
; i
++) {
1440 if (mci
->csrows
[i
].nr_pages
> 0) {
1441 init_completion(&mci
->csrows
[i
].kobj_complete
);
1442 kobject_unregister(&mci
->csrows
[i
].kobj
);
1443 wait_for_completion(&mci
->csrows
[i
].kobj_complete
);
1447 sysfs_remove_link(&mci
->edac_mci_kobj
, EDAC_DEVICE_SYMLINK
);
1448 init_completion(&mci
->kobj_complete
);
1449 kobject_unregister(&mci
->edac_mci_kobj
);
1450 wait_for_completion(&mci
->kobj_complete
);
1451 #endif /* DISABLE_EDAC_SYSFS */
1454 /* END OF sysfs data and methods */
1456 #ifdef CONFIG_EDAC_DEBUG
1458 void edac_mc_dump_channel(struct channel_info
*chan
)
1460 debugf4("\tchannel = %p\n", chan
);
1461 debugf4("\tchannel->chan_idx = %d\n", chan
->chan_idx
);
1462 debugf4("\tchannel->ce_count = %d\n", chan
->ce_count
);
1463 debugf4("\tchannel->label = '%s'\n", chan
->label
);
1464 debugf4("\tchannel->csrow = %p\n\n", chan
->csrow
);
1466 EXPORT_SYMBOL_GPL(edac_mc_dump_channel
);
1468 void edac_mc_dump_csrow(struct csrow_info
*csrow
)
1470 debugf4("\tcsrow = %p\n", csrow
);
1471 debugf4("\tcsrow->csrow_idx = %d\n", csrow
->csrow_idx
);
1472 debugf4("\tcsrow->first_page = 0x%lx\n",
1474 debugf4("\tcsrow->last_page = 0x%lx\n", csrow
->last_page
);
1475 debugf4("\tcsrow->page_mask = 0x%lx\n", csrow
->page_mask
);
1476 debugf4("\tcsrow->nr_pages = 0x%x\n", csrow
->nr_pages
);
1477 debugf4("\tcsrow->nr_channels = %d\n",
1478 csrow
->nr_channels
);
1479 debugf4("\tcsrow->channels = %p\n", csrow
->channels
);
1480 debugf4("\tcsrow->mci = %p\n\n", csrow
->mci
);
1482 EXPORT_SYMBOL_GPL(edac_mc_dump_csrow
);
1484 void edac_mc_dump_mci(struct mem_ctl_info
*mci
)
1486 debugf3("\tmci = %p\n", mci
);
1487 debugf3("\tmci->mtype_cap = %lx\n", mci
->mtype_cap
);
1488 debugf3("\tmci->edac_ctl_cap = %lx\n", mci
->edac_ctl_cap
);
1489 debugf3("\tmci->edac_cap = %lx\n", mci
->edac_cap
);
1490 debugf4("\tmci->edac_check = %p\n", mci
->edac_check
);
1491 debugf3("\tmci->nr_csrows = %d, csrows = %p\n",
1492 mci
->nr_csrows
, mci
->csrows
);
1493 debugf3("\tdev = %p\n", mci
->dev
);
1494 debugf3("\tmod_name:ctl_name = %s:%s\n",
1495 mci
->mod_name
, mci
->ctl_name
);
1496 debugf3("\tpvt_info = %p\n\n", mci
->pvt_info
);
1498 EXPORT_SYMBOL_GPL(edac_mc_dump_mci
);
1500 #endif /* CONFIG_EDAC_DEBUG */
1502 /* 'ptr' points to a possibly unaligned item X such that sizeof(X) is 'size'.
1503 * Adjust 'ptr' so that its alignment is at least as stringent as what the
1504 * compiler would provide for X and return the aligned result.
1506 * If 'size' is a constant, the compiler will optimize this whole function
1507 * down to either a no-op or the addition of a constant to the value of 'ptr'.
1509 static inline char * align_ptr(void *ptr
, unsigned size
)
1513 /* Here we assume that the alignment of a "long long" is the most
1514 * stringent alignment that the compiler will ever provide by default.
1515 * As far as I know, this is a reasonable assumption.
1517 if (size
> sizeof(long))
1518 align
= sizeof(long long);
1519 else if (size
> sizeof(int))
1520 align
= sizeof(long);
1521 else if (size
> sizeof(short))
1522 align
= sizeof(int);
1523 else if (size
> sizeof(char))
1524 align
= sizeof(short);
1526 return (char *) ptr
;
1531 return (char *) ptr
;
1533 return (char *) (((unsigned long) ptr
) + align
- r
);
1537 * edac_mc_alloc: Allocate a struct mem_ctl_info structure
1538 * @size_pvt: size of private storage needed
1539 * @nr_csrows: Number of CWROWS needed for this MC
1540 * @nr_chans: Number of channels for the MC
1542 * Everything is kmalloc'ed as one big chunk - more efficient.
1543 * Only can be used if all structures have the same lifetime - otherwise
1544 * you have to allocate and initialize your own structures.
1546 * Use edac_mc_free() to free mc structures allocated by this function.
1549 * NULL allocation failed
1550 * struct mem_ctl_info pointer
1552 struct mem_ctl_info
*edac_mc_alloc(unsigned sz_pvt
, unsigned nr_csrows
,
1555 struct mem_ctl_info
*mci
;
1556 struct csrow_info
*csi
, *csrow
;
1557 struct channel_info
*chi
, *chp
, *chan
;
1562 /* Figure out the offsets of the various items from the start of an mc
1563 * structure. We want the alignment of each item to be at least as
1564 * stringent as what the compiler would provide if we could simply
1565 * hardcode everything into a single struct.
1567 mci
= (struct mem_ctl_info
*) 0;
1568 csi
= (struct csrow_info
*)align_ptr(&mci
[1], sizeof(*csi
));
1569 chi
= (struct channel_info
*)
1570 align_ptr(&csi
[nr_csrows
], sizeof(*chi
));
1571 pvt
= align_ptr(&chi
[nr_chans
* nr_csrows
], sz_pvt
);
1572 size
= ((unsigned long) pvt
) + sz_pvt
;
1574 if ((mci
= kmalloc(size
, GFP_KERNEL
)) == NULL
)
1577 /* Adjust pointers so they point within the memory we just allocated
1578 * rather than an imaginary chunk of memory located at address 0.
1580 csi
= (struct csrow_info
*) (((char *) mci
) + ((unsigned long) csi
));
1581 chi
= (struct channel_info
*) (((char *) mci
) + ((unsigned long) chi
));
1582 pvt
= sz_pvt
? (((char *) mci
) + ((unsigned long) pvt
)) : NULL
;
1584 memset(mci
, 0, size
); /* clear all fields */
1586 mci
->pvt_info
= pvt
;
1587 mci
->nr_csrows
= nr_csrows
;
1589 for (row
= 0; row
< nr_csrows
; row
++) {
1591 csrow
->csrow_idx
= row
;
1593 csrow
->nr_channels
= nr_chans
;
1594 chp
= &chi
[row
* nr_chans
];
1595 csrow
->channels
= chp
;
1597 for (chn
= 0; chn
< nr_chans
; chn
++) {
1599 chan
->chan_idx
= chn
;
1600 chan
->csrow
= csrow
;
1606 EXPORT_SYMBOL_GPL(edac_mc_alloc
);
1609 * edac_mc_free: Free a previously allocated 'mci' structure
1610 * @mci: pointer to a struct mem_ctl_info structure
1612 void edac_mc_free(struct mem_ctl_info
*mci
)
1616 EXPORT_SYMBOL_GPL(edac_mc_free
);
1618 static struct mem_ctl_info
*find_mci_by_dev(struct device
*dev
)
1620 struct mem_ctl_info
*mci
;
1621 struct list_head
*item
;
1623 debugf3("%s()\n", __func__
);
1625 list_for_each(item
, &mc_devices
) {
1626 mci
= list_entry(item
, struct mem_ctl_info
, link
);
1628 if (mci
->dev
== dev
)
1635 static int add_mc_to_global_list(struct mem_ctl_info
*mci
)
1637 struct list_head
*item
, *insert_before
;
1638 struct mem_ctl_info
*p
;
1641 if (list_empty(&mc_devices
)) {
1643 insert_before
= &mc_devices
;
1645 if (find_mci_by_dev(mci
->dev
)) {
1646 edac_printk(KERN_WARNING
, EDAC_MC
,
1647 "%s (%s) %s %s already assigned %d\n",
1648 mci
->dev
->bus_id
, dev_name(mci
->dev
),
1649 mci
->mod_name
, mci
->ctl_name
,
1654 insert_before
= NULL
;
1657 list_for_each(item
, &mc_devices
) {
1658 p
= list_entry(item
, struct mem_ctl_info
, link
);
1660 if (p
->mc_idx
!= i
) {
1661 insert_before
= item
;
1670 if (insert_before
== NULL
)
1671 insert_before
= &mc_devices
;
1674 list_add_tail_rcu(&mci
->link
, insert_before
);
1678 static void complete_mc_list_del(struct rcu_head
*head
)
1680 struct mem_ctl_info
*mci
;
1682 mci
= container_of(head
, struct mem_ctl_info
, rcu
);
1683 INIT_LIST_HEAD(&mci
->link
);
1684 complete(&mci
->complete
);
1687 static void del_mc_from_global_list(struct mem_ctl_info
*mci
)
1689 list_del_rcu(&mci
->link
);
1690 init_completion(&mci
->complete
);
1691 call_rcu(&mci
->rcu
, complete_mc_list_del
);
1692 wait_for_completion(&mci
->complete
);
1696 * edac_mc_add_mc: Insert the 'mci' structure into the mci global list and
1697 * create sysfs entries associated with mci structure
1698 * @mci: pointer to the mci structure to be added to the list
1705 /* FIXME - should a warning be printed if no error detection? correction? */
1706 int edac_mc_add_mc(struct mem_ctl_info
*mci
)
1708 debugf0("%s()\n", __func__
);
1709 #ifdef CONFIG_EDAC_DEBUG
1710 if (edac_debug_level
>= 3)
1711 edac_mc_dump_mci(mci
);
1713 if (edac_debug_level
>= 4) {
1716 for (i
= 0; i
< mci
->nr_csrows
; i
++) {
1719 edac_mc_dump_csrow(&mci
->csrows
[i
]);
1720 for (j
= 0; j
< mci
->csrows
[i
].nr_channels
; j
++)
1721 edac_mc_dump_channel(
1722 &mci
->csrows
[i
].channels
[j
]);
1726 down(&mem_ctls_mutex
);
1728 if (add_mc_to_global_list(mci
))
1731 /* set load time so that error rate can be tracked */
1732 mci
->start_time
= jiffies
;
1734 if (edac_create_sysfs_mci_device(mci
)) {
1735 edac_mc_printk(mci
, KERN_WARNING
,
1736 "failed to create sysfs device\n");
1740 /* Report action taken */
1741 edac_mc_printk(mci
, KERN_INFO
, "Giving out device to %s %s: DEV %s\n",
1742 mci
->mod_name
, mci
->ctl_name
, dev_name(mci
->dev
));
1744 up(&mem_ctls_mutex
);
1748 del_mc_from_global_list(mci
);
1751 up(&mem_ctls_mutex
);
1754 EXPORT_SYMBOL_GPL(edac_mc_add_mc
);
1757 * edac_mc_del_mc: Remove sysfs entries for specified mci structure and
1758 * remove mci structure from global list
1759 * @pdev: Pointer to 'struct device' representing mci structure to remove.
1761 * Return pointer to removed mci structure, or NULL if device not found.
1763 struct mem_ctl_info
* edac_mc_del_mc(struct device
*dev
)
1765 struct mem_ctl_info
*mci
;
1767 debugf0("MC: %s()\n", __func__
);
1768 down(&mem_ctls_mutex
);
1770 if ((mci
= find_mci_by_dev(dev
)) == NULL
) {
1771 up(&mem_ctls_mutex
);
1775 edac_remove_sysfs_mci_device(mci
);
1776 del_mc_from_global_list(mci
);
1777 up(&mem_ctls_mutex
);
1778 edac_printk(KERN_INFO
, EDAC_MC
,
1779 "Removed device %d for %s %s: DEV %s\n", mci
->mc_idx
,
1780 mci
->mod_name
, mci
->ctl_name
, dev_name(mci
->dev
));
1783 EXPORT_SYMBOL_GPL(edac_mc_del_mc
);
1785 void edac_mc_scrub_block(unsigned long page
, unsigned long offset
, u32 size
)
1789 unsigned long flags
= 0;
1791 debugf3("%s()\n", __func__
);
1793 /* ECC error page was not in our memory. Ignore it. */
1794 if(!pfn_valid(page
))
1797 /* Find the actual page structure then map it and fix */
1798 pg
= pfn_to_page(page
);
1800 if (PageHighMem(pg
))
1801 local_irq_save(flags
);
1803 virt_addr
= kmap_atomic(pg
, KM_BOUNCE_READ
);
1805 /* Perform architecture specific atomic scrub operation */
1806 atomic_scrub(virt_addr
+ offset
, size
);
1808 /* Unmap and complete */
1809 kunmap_atomic(virt_addr
, KM_BOUNCE_READ
);
1811 if (PageHighMem(pg
))
1812 local_irq_restore(flags
);
1814 EXPORT_SYMBOL_GPL(edac_mc_scrub_block
);
1816 /* FIXME - should return -1 */
1817 int edac_mc_find_csrow_by_page(struct mem_ctl_info
*mci
, unsigned long page
)
1819 struct csrow_info
*csrows
= mci
->csrows
;
1822 debugf1("MC%d: %s(): 0x%lx\n", mci
->mc_idx
, __func__
, page
);
1825 for (i
= 0; i
< mci
->nr_csrows
; i
++) {
1826 struct csrow_info
*csrow
= &csrows
[i
];
1828 if (csrow
->nr_pages
== 0)
1831 debugf3("MC%d: %s(): first(0x%lx) page(0x%lx) last(0x%lx) "
1832 "mask(0x%lx)\n", mci
->mc_idx
, __func__
,
1833 csrow
->first_page
, page
, csrow
->last_page
,
1836 if ((page
>= csrow
->first_page
) &&
1837 (page
<= csrow
->last_page
) &&
1838 ((page
& csrow
->page_mask
) ==
1839 (csrow
->first_page
& csrow
->page_mask
))) {
1846 edac_mc_printk(mci
, KERN_ERR
,
1847 "could not look up page error address %lx\n",
1848 (unsigned long) page
);
1852 EXPORT_SYMBOL_GPL(edac_mc_find_csrow_by_page
);
1854 /* FIXME - setable log (warning/emerg) levels */
1855 /* FIXME - integrate with evlog: http://evlog.sourceforge.net/ */
1856 void edac_mc_handle_ce(struct mem_ctl_info
*mci
,
1857 unsigned long page_frame_number
, unsigned long offset_in_page
,
1858 unsigned long syndrome
, int row
, int channel
, const char *msg
)
1860 unsigned long remapped_page
;
1862 debugf3("MC%d: %s()\n", mci
->mc_idx
, __func__
);
1864 /* FIXME - maybe make panic on INTERNAL ERROR an option */
1865 if (row
>= mci
->nr_csrows
|| row
< 0) {
1866 /* something is wrong */
1867 edac_mc_printk(mci
, KERN_ERR
,
1868 "INTERNAL ERROR: row out of range "
1869 "(%d >= %d)\n", row
, mci
->nr_csrows
);
1870 edac_mc_handle_ce_no_info(mci
, "INTERNAL ERROR");
1874 if (channel
>= mci
->csrows
[row
].nr_channels
|| channel
< 0) {
1875 /* something is wrong */
1876 edac_mc_printk(mci
, KERN_ERR
,
1877 "INTERNAL ERROR: channel out of range "
1878 "(%d >= %d)\n", channel
,
1879 mci
->csrows
[row
].nr_channels
);
1880 edac_mc_handle_ce_no_info(mci
, "INTERNAL ERROR");
1885 /* FIXME - put in DIMM location */
1886 edac_mc_printk(mci
, KERN_WARNING
,
1887 "CE page 0x%lx, offset 0x%lx, grain %d, syndrome "
1888 "0x%lx, row %d, channel %d, label \"%s\": %s\n",
1889 page_frame_number
, offset_in_page
,
1890 mci
->csrows
[row
].grain
, syndrome
, row
, channel
,
1891 mci
->csrows
[row
].channels
[channel
].label
, msg
);
1894 mci
->csrows
[row
].ce_count
++;
1895 mci
->csrows
[row
].channels
[channel
].ce_count
++;
1897 if (mci
->scrub_mode
& SCRUB_SW_SRC
) {
1899 * Some MC's can remap memory so that it is still available
1900 * at a different address when PCI devices map into memory.
1901 * MC's that can't do this lose the memory where PCI devices
1902 * are mapped. This mapping is MC dependant and so we call
1903 * back into the MC driver for it to map the MC page to
1904 * a physical (CPU) page which can then be mapped to a virtual
1905 * page - which can then be scrubbed.
1907 remapped_page
= mci
->ctl_page_to_phys
?
1908 mci
->ctl_page_to_phys(mci
, page_frame_number
) :
1911 edac_mc_scrub_block(remapped_page
, offset_in_page
,
1912 mci
->csrows
[row
].grain
);
1915 EXPORT_SYMBOL_GPL(edac_mc_handle_ce
);
1917 void edac_mc_handle_ce_no_info(struct mem_ctl_info
*mci
, const char *msg
)
1920 edac_mc_printk(mci
, KERN_WARNING
,
1921 "CE - no information available: %s\n", msg
);
1923 mci
->ce_noinfo_count
++;
1926 EXPORT_SYMBOL_GPL(edac_mc_handle_ce_no_info
);
1928 void edac_mc_handle_ue(struct mem_ctl_info
*mci
,
1929 unsigned long page_frame_number
, unsigned long offset_in_page
,
1930 int row
, const char *msg
)
1932 int len
= EDAC_MC_LABEL_LEN
* 4;
1933 char labels
[len
+ 1];
1938 debugf3("MC%d: %s()\n", mci
->mc_idx
, __func__
);
1940 /* FIXME - maybe make panic on INTERNAL ERROR an option */
1941 if (row
>= mci
->nr_csrows
|| row
< 0) {
1942 /* something is wrong */
1943 edac_mc_printk(mci
, KERN_ERR
,
1944 "INTERNAL ERROR: row out of range "
1945 "(%d >= %d)\n", row
, mci
->nr_csrows
);
1946 edac_mc_handle_ue_no_info(mci
, "INTERNAL ERROR");
1950 chars
= snprintf(pos
, len
+ 1, "%s",
1951 mci
->csrows
[row
].channels
[0].label
);
1955 for (chan
= 1; (chan
< mci
->csrows
[row
].nr_channels
) && (len
> 0);
1957 chars
= snprintf(pos
, len
+ 1, ":%s",
1958 mci
->csrows
[row
].channels
[chan
].label
);
1964 edac_mc_printk(mci
, KERN_EMERG
,
1965 "UE page 0x%lx, offset 0x%lx, grain %d, row %d, "
1966 "labels \"%s\": %s\n", page_frame_number
,
1967 offset_in_page
, mci
->csrows
[row
].grain
, row
, labels
,
1971 panic("EDAC MC%d: UE page 0x%lx, offset 0x%lx, grain %d, "
1972 "row %d, labels \"%s\": %s\n", mci
->mc_idx
,
1973 page_frame_number
, offset_in_page
,
1974 mci
->csrows
[row
].grain
, row
, labels
, msg
);
1977 mci
->csrows
[row
].ue_count
++;
1979 EXPORT_SYMBOL_GPL(edac_mc_handle_ue
);
1981 void edac_mc_handle_ue_no_info(struct mem_ctl_info
*mci
, const char *msg
)
1984 panic("EDAC MC%d: Uncorrected Error", mci
->mc_idx
);
1987 edac_mc_printk(mci
, KERN_WARNING
,
1988 "UE - no information available: %s\n", msg
);
1989 mci
->ue_noinfo_count
++;
1992 EXPORT_SYMBOL_GPL(edac_mc_handle_ue_no_info
);
1996 * Iterate over all MC instances and check for ECC, et al, errors
1998 static inline void check_mc_devices(void)
2000 struct list_head
*item
;
2001 struct mem_ctl_info
*mci
;
2003 debugf3("%s()\n", __func__
);
2004 down(&mem_ctls_mutex
);
2006 list_for_each(item
, &mc_devices
) {
2007 mci
= list_entry(item
, struct mem_ctl_info
, link
);
2009 if (mci
->edac_check
!= NULL
)
2010 mci
->edac_check(mci
);
2013 up(&mem_ctls_mutex
);
2017 * Check MC status every poll_msec.
2018 * Check PCI status every poll_msec as well.
2020 * This where the work gets done for edac.
2022 * SMP safe, doesn't use NMI, and auto-rate-limits.
2024 static void do_edac_check(void)
2026 debugf3("%s()\n", __func__
);
2028 do_pci_parity_check();
2031 static int edac_kernel_thread(void *arg
)
2033 while (!kthread_should_stop()) {
2036 /* goto sleep for the interval */
2037 schedule_timeout_interruptible((HZ
* poll_msec
) / 1000);
2046 * module initialization entry point
2048 static int __init
edac_mc_init(void)
2050 edac_printk(KERN_INFO
, EDAC_MC
, EDAC_MC_VERSION
"\n");
2053 * Harvest and clear any boot/initialization PCI parity errors
2055 * FIXME: This only clears errors logged by devices present at time of
2056 * module initialization. We should also do an initial clear
2057 * of each newly hotplugged device.
2059 clear_pci_parity_errors();
2061 /* Create the MC sysfs entries */
2062 if (edac_sysfs_memctrl_setup()) {
2063 edac_printk(KERN_ERR
, EDAC_MC
,
2064 "Error initializing sysfs code\n");
2068 /* Create the PCI parity sysfs entries */
2069 if (edac_sysfs_pci_setup()) {
2070 edac_sysfs_memctrl_teardown();
2071 edac_printk(KERN_ERR
, EDAC_MC
,
2072 "EDAC PCI: Error initializing sysfs code\n");
2076 /* create our kernel thread */
2077 edac_thread
= kthread_run(edac_kernel_thread
, NULL
, "kedac");
2079 if (IS_ERR(edac_thread
)) {
2080 /* remove the sysfs entries */
2081 edac_sysfs_memctrl_teardown();
2082 edac_sysfs_pci_teardown();
2083 return PTR_ERR(edac_thread
);
2091 * module exit/termination functioni
2093 static void __exit
edac_mc_exit(void)
2095 debugf0("%s()\n", __func__
);
2096 kthread_stop(edac_thread
);
2098 /* tear down the sysfs device */
2099 edac_sysfs_memctrl_teardown();
2100 edac_sysfs_pci_teardown();
2103 module_init(edac_mc_init
);
2104 module_exit(edac_mc_exit
);
2106 MODULE_LICENSE("GPL");
2107 MODULE_AUTHOR("Linux Networx (http://lnxi.com) Thayne Harbaugh et al\n"
2108 "Based on work by Dan Hollis et al");
2109 MODULE_DESCRIPTION("Core library routines for MC reporting");
2111 module_param(panic_on_ue
, int, 0644);
2112 MODULE_PARM_DESC(panic_on_ue
, "Panic on uncorrected error: 0=off 1=on");
2114 module_param(check_pci_parity
, int, 0644);
2115 MODULE_PARM_DESC(check_pci_parity
, "Check for PCI bus parity errors: 0=off 1=on");
2116 module_param(panic_on_pci_parity
, int, 0644);
2117 MODULE_PARM_DESC(panic_on_pci_parity
, "Panic on PCI Bus Parity error: 0=off 1=on");
2119 module_param(log_ue
, int, 0644);
2120 MODULE_PARM_DESC(log_ue
, "Log uncorrectable error to console: 0=off 1=on");
2121 module_param(log_ce
, int, 0644);
2122 MODULE_PARM_DESC(log_ce
, "Log correctable error to console: 0=off 1=on");
2123 module_param(poll_msec
, int, 0644);
2124 MODULE_PARM_DESC(poll_msec
, "Polling period in milliseconds");
2125 #ifdef CONFIG_EDAC_DEBUG
2126 module_param(edac_debug_level
, int, 0644);
2127 MODULE_PARM_DESC(edac_debug_level
, "Debug level");