2 * (C) 2005, 2006 Linux Networx (http://lnxi.com)
3 * This file may be distributed under the terms of the
4 * GNU General Public License.
6 * Written Doug Thompson <norsk5@xmission.com>
9 #include <linux/module.h>
10 #include <linux/sysdev.h>
11 #include <linux/ctype.h>
13 #include "edac_core.h"
14 #include "edac_module.h"
19 #define EDAC_PCI_SYMLINK "device"
21 static int check_pci_errors
= 0; /* default YES check PCI parity */
22 static int edac_pci_panic_on_pe
= 0; /* default no panic on PCI Parity */
23 static int edac_pci_log_pe
= 1; /* log PCI parity errors */
24 static int edac_pci_log_npe
= 1; /* log PCI non-parity error errors */
25 static atomic_t pci_parity_count
= ATOMIC_INIT(0);
26 static atomic_t pci_nonparity_count
= ATOMIC_INIT(0);
27 static int edac_pci_poll_msec
= 1000;
29 static struct kobject edac_pci_kobj
; /* /sys/devices/system/edac/pci */
30 static struct completion edac_pci_kobj_complete
;
31 static atomic_t edac_pci_sysfs_refcount
= ATOMIC_INIT(0);
33 int edac_pci_get_check_errors(void)
35 return check_pci_errors
;
38 int edac_pci_get_log_pe(void)
40 return edac_pci_log_pe
;
43 int edac_pci_get_log_npe(void)
45 return edac_pci_log_npe
;
48 int edac_pci_get_panic_on_pe(void)
50 return edac_pci_panic_on_pe
;
53 int edac_pci_get_poll_msec(void)
55 return edac_pci_poll_msec
;
58 /**************************** EDAC PCI sysfs instance *******************/
59 static ssize_t
instance_pe_count_show(struct edac_pci_ctl_info
*pci
, char *data
)
61 return sprintf(data
,"%u\n", atomic_read(&pci
->counters
.pe_count
));
64 static ssize_t
instance_npe_count_show(struct edac_pci_ctl_info
*pci
,
67 return sprintf(data
,"%u\n", atomic_read(&pci
->counters
.npe_count
));
70 #define to_instance(k) container_of(k, struct edac_pci_ctl_info, kobj)
71 #define to_instance_attr(a) container_of(a, struct instance_attribute, attr)
73 /* DEVICE instance kobject release() function */
74 static void edac_pci_instance_release(struct kobject
*kobj
)
76 struct edac_pci_ctl_info
*pci
;
78 debugf1("%s()\n", __func__
);
80 pci
= to_instance(kobj
);
81 complete(&pci
->kobj_complete
);
84 /* instance specific attribute structure */
85 struct instance_attribute
{
86 struct attribute attr
;
87 ssize_t (*show
)(struct edac_pci_ctl_info
*, char *);
88 ssize_t (*store
)(struct edac_pci_ctl_info
*, const char *, size_t);
91 /* Function to 'show' fields from the edac_pci 'instance' structure */
92 static ssize_t
edac_pci_instance_show(struct kobject
*kobj
,
93 struct attribute
*attr
,
96 struct edac_pci_ctl_info
*pci
= to_instance(kobj
);
97 struct instance_attribute
*instance_attr
= to_instance_attr(attr
);
99 if (instance_attr
->show
)
100 return instance_attr
->show(pci
, buffer
);
105 /* Function to 'store' fields into the edac_pci 'instance' structure */
106 static ssize_t
edac_pci_instance_store(struct kobject
*kobj
,
107 struct attribute
*attr
,
108 const char *buffer
, size_t count
)
110 struct edac_pci_ctl_info
*pci
= to_instance(kobj
);
111 struct instance_attribute
*instance_attr
= to_instance_attr(attr
);
113 if (instance_attr
->store
)
114 return instance_attr
->store(pci
, buffer
, count
);
118 static struct sysfs_ops pci_instance_ops
= {
119 .show
= edac_pci_instance_show
,
120 .store
= edac_pci_instance_store
123 #define INSTANCE_ATTR(_name, _mode, _show, _store) \
124 static struct instance_attribute attr_instance_##_name = { \
125 .attr = {.name = __stringify(_name), .mode = _mode }, \
130 INSTANCE_ATTR(pe_count
, S_IRUGO
, instance_pe_count_show
, NULL
);
131 INSTANCE_ATTR(npe_count
, S_IRUGO
, instance_npe_count_show
, NULL
);
133 /* pci instance attributes */
134 static struct instance_attribute
*pci_instance_attr
[] = {
135 &attr_instance_pe_count
,
136 &attr_instance_npe_count
,
140 /* the ktype for pci instance */
141 static struct kobj_type ktype_pci_instance
= {
142 .release
= edac_pci_instance_release
,
143 .sysfs_ops
= &pci_instance_ops
,
144 .default_attrs
= (struct attribute
**)pci_instance_attr
,
147 static int edac_pci_create_instance_kobj(struct edac_pci_ctl_info
*pci
, int idx
)
151 pci
->kobj
.parent
= &edac_pci_kobj
;
152 pci
->kobj
.ktype
= &ktype_pci_instance
;
154 err
= kobject_set_name(&pci
->kobj
, "pci%d", idx
);
158 err
= kobject_register(&pci
->kobj
);
160 debugf2("%s() failed to register instance pci%d\n",
165 debugf1("%s() Register instance 'pci%d' kobject\n", __func__
, idx
);
171 edac_pci_delete_instance_kobj(struct edac_pci_ctl_info
*pci
, int idx
)
173 init_completion(&pci
->kobj_complete
);
174 kobject_unregister(&pci
->kobj
);
175 wait_for_completion(&pci
->kobj_complete
);
178 /***************************** EDAC PCI sysfs root **********************/
179 #define to_edacpci(k) container_of(k, struct edac_pci_ctl_info, kobj)
180 #define to_edacpci_attr(a) container_of(a, struct edac_pci_attr, attr)
182 static ssize_t
edac_pci_int_show(void *ptr
, char *buffer
)
185 return sprintf(buffer
,"%d\n",*value
);
188 static ssize_t
edac_pci_int_store(void *ptr
, const char *buffer
, size_t count
)
192 if (isdigit(*buffer
))
193 *value
= simple_strtoul(buffer
,NULL
,0);
198 struct edac_pci_dev_attribute
{
199 struct attribute attr
;
201 ssize_t (*show
)(void *,char *);
202 ssize_t (*store
)(void *, const char *,size_t);
205 /* Set of show/store abstract level functions for PCI Parity object */
206 static ssize_t
edac_pci_dev_show(struct kobject
*kobj
, struct attribute
*attr
,
209 struct edac_pci_dev_attribute
*edac_pci_dev
;
210 edac_pci_dev
= (struct edac_pci_dev_attribute
*)attr
;
212 if (edac_pci_dev
->show
)
213 return edac_pci_dev
->show(edac_pci_dev
->value
, buffer
);
217 static ssize_t
edac_pci_dev_store(struct kobject
*kobj
,
218 struct attribute
*attr
, const char *buffer
, size_t count
)
220 struct edac_pci_dev_attribute
*edac_pci_dev
;
221 edac_pci_dev
= (struct edac_pci_dev_attribute
*)attr
;
223 if (edac_pci_dev
->show
)
224 return edac_pci_dev
->store(edac_pci_dev
->value
, buffer
, count
);
228 static struct sysfs_ops edac_pci_sysfs_ops
= {
229 .show
= edac_pci_dev_show
,
230 .store
= edac_pci_dev_store
233 #define EDAC_PCI_ATTR(_name,_mode,_show,_store) \
234 static struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
235 .attr = {.name = __stringify(_name), .mode = _mode }, \
241 #define EDAC_PCI_STRING_ATTR(_name,_data,_mode,_show,_store) \
242 static struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
243 .attr = {.name = __stringify(_name), .mode = _mode }, \
249 /* PCI Parity control files */
250 EDAC_PCI_ATTR(check_pci_errors
, S_IRUGO
|S_IWUSR
, edac_pci_int_show
,
252 EDAC_PCI_ATTR(edac_pci_log_pe
, S_IRUGO
|S_IWUSR
, edac_pci_int_show
,
254 EDAC_PCI_ATTR(edac_pci_log_npe
, S_IRUGO
|S_IWUSR
, edac_pci_int_show
,
256 EDAC_PCI_ATTR(edac_pci_panic_on_pe
, S_IRUGO
|S_IWUSR
, edac_pci_int_show
,
258 EDAC_PCI_ATTR(pci_parity_count
, S_IRUGO
, edac_pci_int_show
, NULL
);
259 EDAC_PCI_ATTR(pci_nonparity_count
, S_IRUGO
, edac_pci_int_show
, NULL
);
261 /* Base Attributes of the memory ECC object */
262 static struct edac_pci_dev_attribute
*edac_pci_attr
[] = {
263 &edac_pci_attr_check_pci_errors
,
264 &edac_pci_attr_edac_pci_log_pe
,
265 &edac_pci_attr_edac_pci_log_npe
,
266 &edac_pci_attr_edac_pci_panic_on_pe
,
267 &edac_pci_attr_pci_parity_count
,
268 &edac_pci_attr_pci_nonparity_count
,
272 /* No memory to release */
273 static void edac_pci_release(struct kobject
*kobj
)
275 struct edac_pci_ctl_info
*pci
;
277 pci
= to_edacpci(kobj
);
279 debugf1("%s()\n", __func__
);
280 complete(&pci
->kobj_complete
);
283 static struct kobj_type ktype_edac_pci
= {
284 .release
= edac_pci_release
,
285 .sysfs_ops
= &edac_pci_sysfs_ops
,
286 .default_attrs
= (struct attribute
**) edac_pci_attr
,
290 * edac_sysfs_pci_setup()
292 * setup the sysfs for EDAC PCI attributes
293 * assumes edac_class has already been initialized
295 int edac_pci_register_main_kobj(void)
298 struct sysdev_class
*edac_class
;
300 debugf1("%s()\n", __func__
);
302 edac_class
= edac_get_edac_class();
303 if (edac_class
== NULL
) {
304 debugf1("%s() no edac_class\n", __func__
);
308 edac_pci_kobj
.ktype
= &ktype_edac_pci
;
310 edac_pci_kobj
.parent
= &edac_class
->kset
.kobj
;
312 err
= kobject_set_name(&edac_pci_kobj
, "pci");
316 /* Instanstiate the pci object */
317 /* FIXME: maybe new sysdev_create_subdir() */
318 err
= kobject_register(&edac_pci_kobj
);
321 debugf1("Failed to register '.../edac/pci'\n");
325 debugf1("Registered '.../edac/pci' kobject\n");
331 * edac_pci_unregister_main_kobj()
333 * perform the sysfs teardown for the PCI attributes
335 void edac_pci_unregister_main_kobj(void)
337 debugf0("%s()\n", __func__
);
338 init_completion(&edac_pci_kobj_complete
);
339 kobject_unregister(&edac_pci_kobj
);
340 wait_for_completion(&edac_pci_kobj_complete
);
343 int edac_pci_create_sysfs(struct edac_pci_ctl_info
*pci
)
346 struct kobject
*edac_kobj
= &pci
->kobj
;
348 if (atomic_inc_return(&edac_pci_sysfs_refcount
) == 1) {
349 err
= edac_pci_register_main_kobj();
351 atomic_dec(&edac_pci_sysfs_refcount
);
356 err
= edac_pci_create_instance_kobj(pci
, pci
->pci_idx
);
358 if (atomic_dec_return(&edac_pci_sysfs_refcount
) == 0)
359 edac_pci_unregister_main_kobj();
363 debugf0("%s() idx=%d\n", __func__
, pci
->pci_idx
);
365 err
= sysfs_create_link(edac_kobj
,
369 debugf0("%s() sysfs_create_link() returned err= %d\n",
377 void edac_pci_remove_sysfs(struct edac_pci_ctl_info
*pci
)
379 debugf0("%s()\n", __func__
);
381 edac_pci_delete_instance_kobj(pci
, pci
->pci_idx
);
383 sysfs_remove_link(&pci
->kobj
, EDAC_PCI_SYMLINK
);
385 if (atomic_dec_return(&edac_pci_sysfs_refcount
) == 0)
386 edac_pci_unregister_main_kobj();
389 /************************ PCI error handling *************************/
390 static u16
get_pci_parity_status(struct pci_dev
*dev
, int secondary
)
395 where
= secondary
? PCI_SEC_STATUS
: PCI_STATUS
;
396 pci_read_config_word(dev
, where
, &status
);
398 /* If we get back 0xFFFF then we must suspect that the card has been
399 * pulled but the Linux PCI layer has not yet finished cleaning up.
400 * We don't want to report on such devices
403 if (status
== 0xFFFF) {
406 pci_read_config_dword(dev
, 0, &sanity
);
408 if (sanity
== 0xFFFFFFFF)
412 status
&= PCI_STATUS_DETECTED_PARITY
| PCI_STATUS_SIG_SYSTEM_ERROR
|
416 /* reset only the bits we are interested in */
417 pci_write_config_word(dev
, where
, status
);
422 typedef void (*pci_parity_check_fn_t
) (struct pci_dev
*dev
);
424 /* Clear any PCI parity errors logged by this device. */
425 static void edac_pci_dev_parity_clear(struct pci_dev
*dev
)
429 get_pci_parity_status(dev
, 0);
431 /* read the device TYPE, looking for bridges */
432 pci_read_config_byte(dev
, PCI_HEADER_TYPE
, &header_type
);
434 if ((header_type
& 0x7F) == PCI_HEADER_TYPE_BRIDGE
)
435 get_pci_parity_status(dev
, 1);
442 static void edac_pci_dev_parity_test(struct pci_dev
*dev
)
447 /* read the STATUS register on this device
449 status
= get_pci_parity_status(dev
, 0);
451 debugf2("PCI STATUS= 0x%04x %s\n", status
, dev
->dev
.bus_id
);
453 /* check the status reg for errors */
455 if (status
& (PCI_STATUS_SIG_SYSTEM_ERROR
)) {
456 edac_printk(KERN_CRIT
, EDAC_PCI
,
457 "Signaled System Error on %s\n",
459 atomic_inc(&pci_nonparity_count
);
462 if (status
& (PCI_STATUS_PARITY
)) {
463 edac_printk(KERN_CRIT
, EDAC_PCI
,
464 "Master Data Parity Error on %s\n",
467 atomic_inc(&pci_parity_count
);
470 if (status
& (PCI_STATUS_DETECTED_PARITY
)) {
471 edac_printk(KERN_CRIT
, EDAC_PCI
,
472 "Detected Parity Error on %s\n",
475 atomic_inc(&pci_parity_count
);
479 /* read the device TYPE, looking for bridges */
480 pci_read_config_byte(dev
, PCI_HEADER_TYPE
, &header_type
);
482 debugf2("PCI HEADER TYPE= 0x%02x %s\n", header_type
, dev
->dev
.bus_id
);
484 if ((header_type
& 0x7F) == PCI_HEADER_TYPE_BRIDGE
) {
485 /* On bridges, need to examine secondary status register */
486 status
= get_pci_parity_status(dev
, 1);
488 debugf2("PCI SEC_STATUS= 0x%04x %s\n",
489 status
, dev
->dev
.bus_id
);
491 /* check the secondary status reg for errors */
493 if (status
& (PCI_STATUS_SIG_SYSTEM_ERROR
)) {
494 edac_printk(KERN_CRIT
, EDAC_PCI
, "Bridge "
495 "Signaled System Error on %s\n",
497 atomic_inc(&pci_nonparity_count
);
500 if (status
& (PCI_STATUS_PARITY
)) {
501 edac_printk(KERN_CRIT
, EDAC_PCI
, "Bridge "
502 "Master Data Parity Error on "
503 "%s\n", pci_name(dev
));
505 atomic_inc(&pci_parity_count
);
508 if (status
& (PCI_STATUS_DETECTED_PARITY
)) {
509 edac_printk(KERN_CRIT
, EDAC_PCI
, "Bridge "
510 "Detected Parity Error on %s\n",
513 atomic_inc(&pci_parity_count
);
520 * pci_dev parity list iterator
521 * Scan the PCI device list for one iteration, looking for SERRORs
522 * Master Parity ERRORS or Parity ERRORs on primary or secondary devices
524 static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn
)
526 struct pci_dev
*dev
= NULL
;
528 /* request for kernel access to the next PCI device, if any,
529 * and while we are looking at it have its reference count
530 * bumped until we are done with it
532 while((dev
= pci_get_device(PCI_ANY_ID
, PCI_ANY_ID
, dev
)) != NULL
) {
538 * edac_pci_do_parity_check
540 * performs the actual PCI parity check operation
542 void edac_pci_do_parity_check(void)
547 debugf3("%s()\n", __func__
);
549 if (!check_pci_errors
)
552 before_count
= atomic_read(&pci_parity_count
);
554 /* scan all PCI devices looking for a Parity Error on devices and
557 local_irq_save(flags
);
558 edac_pci_dev_parity_iterator(edac_pci_dev_parity_test
);
559 local_irq_restore(flags
);
561 /* Only if operator has selected panic on PCI Error */
562 if (edac_pci_get_panic_on_pe()) {
563 /* If the count is different 'after' from 'before' */
564 if (before_count
!= atomic_read(&pci_parity_count
))
565 panic("EDAC: PCI Parity Error");
569 void edac_pci_clear_parity_errors(void)
571 /* Clear any PCI bus parity errors that devices initially have logged
572 * in their registers.
574 edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear
);
576 void edac_pci_handle_pe(struct edac_pci_ctl_info
*pci
, const char *msg
)
579 /* global PE counter incremented by edac_pci_do_parity_check() */
580 atomic_inc(&pci
->counters
.pe_count
);
582 if (edac_pci_get_log_pe())
583 edac_pci_printk(pci
, KERN_WARNING
,
584 "Parity Error ctl: %s %d: %s\n",
585 pci
->ctl_name
, pci
->pci_idx
, msg
);
588 * poke all PCI devices and see which one is the troublemaker
589 * panic() is called if set
591 edac_pci_do_parity_check();
593 EXPORT_SYMBOL_GPL(edac_pci_handle_pe
);
595 void edac_pci_handle_npe(struct edac_pci_ctl_info
*pci
, const char *msg
)
598 /* global NPE counter incremented by edac_pci_do_parity_check() */
599 atomic_inc(&pci
->counters
.npe_count
);
601 if (edac_pci_get_log_npe())
602 edac_pci_printk(pci
, KERN_WARNING
,
603 "Non-Parity Error ctl: %s %d: %s\n",
604 pci
->ctl_name
, pci
->pci_idx
, msg
);
607 * poke all PCI devices and see which one is the troublemaker
608 * panic() is called if set
610 edac_pci_do_parity_check();
612 EXPORT_SYMBOL_GPL(edac_pci_handle_npe
);
615 * Define the PCI parameter to the module
617 module_param(check_pci_errors
, int, 0644);
618 MODULE_PARM_DESC(check_pci_errors
,
619 "Check for PCI bus parity errors: 0=off 1=on");
620 module_param(edac_pci_panic_on_pe
, int, 0644);
621 MODULE_PARM_DESC(edac_pci_panic_on_pe
,
622 "Panic on PCI Bus Parity error: 0=off 1=on");
624 #endif /* CONFIG_PCI */