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"
18 #define EDAC_PCI_SYMLINK "device"
20 static int check_pci_errors
; /* default YES check PCI parity */
21 static int edac_pci_panic_on_pe
; /* default no panic on PCI Parity */
22 static int edac_pci_log_pe
= 1; /* log PCI parity errors */
23 static int edac_pci_log_npe
= 1; /* log PCI non-parity error errors */
24 static atomic_t pci_parity_count
= ATOMIC_INIT(0);
25 static atomic_t pci_nonparity_count
= ATOMIC_INIT(0);
26 static int edac_pci_poll_msec
= 1000;
28 static struct kobject edac_pci_kobj
; /* /sys/devices/system/edac/pci */
29 static struct completion edac_pci_kobj_complete
;
30 static atomic_t edac_pci_sysfs_refcount
= ATOMIC_INIT(0);
32 int edac_pci_get_check_errors(void)
34 return check_pci_errors
;
37 int edac_pci_get_log_pe(void)
39 return edac_pci_log_pe
;
42 int edac_pci_get_log_npe(void)
44 return edac_pci_log_npe
;
47 int edac_pci_get_panic_on_pe(void)
49 return edac_pci_panic_on_pe
;
52 int edac_pci_get_poll_msec(void)
54 return edac_pci_poll_msec
;
57 /**************************** EDAC PCI sysfs instance *******************/
58 static ssize_t
instance_pe_count_show(struct edac_pci_ctl_info
*pci
, char *data
)
60 return sprintf(data
, "%u\n", atomic_read(&pci
->counters
.pe_count
));
63 static ssize_t
instance_npe_count_show(struct edac_pci_ctl_info
*pci
,
66 return sprintf(data
, "%u\n", atomic_read(&pci
->counters
.npe_count
));
69 #define to_instance(k) container_of(k, struct edac_pci_ctl_info, kobj)
70 #define to_instance_attr(a) container_of(a, struct instance_attribute, attr)
72 /* DEVICE instance kobject release() function */
73 static void edac_pci_instance_release(struct kobject
*kobj
)
75 struct edac_pci_ctl_info
*pci
;
77 debugf1("%s()\n", __func__
);
79 pci
= to_instance(kobj
);
80 complete(&pci
->kobj_complete
);
83 /* instance specific attribute structure */
84 struct instance_attribute
{
85 struct attribute attr
;
86 ssize_t(*show
) (struct edac_pci_ctl_info
*, char *);
87 ssize_t(*store
) (struct edac_pci_ctl_info
*, const char *, size_t);
90 /* Function to 'show' fields from the edac_pci 'instance' structure */
91 static ssize_t
edac_pci_instance_show(struct kobject
*kobj
,
92 struct attribute
*attr
, char *buffer
)
94 struct edac_pci_ctl_info
*pci
= to_instance(kobj
);
95 struct instance_attribute
*instance_attr
= to_instance_attr(attr
);
97 if (instance_attr
->show
)
98 return instance_attr
->show(pci
, buffer
);
102 /* Function to 'store' fields into the edac_pci 'instance' structure */
103 static ssize_t
edac_pci_instance_store(struct kobject
*kobj
,
104 struct attribute
*attr
,
105 const char *buffer
, size_t count
)
107 struct edac_pci_ctl_info
*pci
= to_instance(kobj
);
108 struct instance_attribute
*instance_attr
= to_instance_attr(attr
);
110 if (instance_attr
->store
)
111 return instance_attr
->store(pci
, buffer
, count
);
115 static struct sysfs_ops pci_instance_ops
= {
116 .show
= edac_pci_instance_show
,
117 .store
= edac_pci_instance_store
120 #define INSTANCE_ATTR(_name, _mode, _show, _store) \
121 static struct instance_attribute attr_instance_##_name = { \
122 .attr = {.name = __stringify(_name), .mode = _mode }, \
127 INSTANCE_ATTR(pe_count
, S_IRUGO
, instance_pe_count_show
, NULL
);
128 INSTANCE_ATTR(npe_count
, S_IRUGO
, instance_npe_count_show
, NULL
);
130 /* pci instance attributes */
131 static struct instance_attribute
*pci_instance_attr
[] = {
132 &attr_instance_pe_count
,
133 &attr_instance_npe_count
,
137 /* the ktype for pci instance */
138 static struct kobj_type ktype_pci_instance
= {
139 .release
= edac_pci_instance_release
,
140 .sysfs_ops
= &pci_instance_ops
,
141 .default_attrs
= (struct attribute
**)pci_instance_attr
,
144 static int edac_pci_create_instance_kobj(struct edac_pci_ctl_info
*pci
, int idx
)
148 pci
->kobj
.parent
= &edac_pci_kobj
;
149 pci
->kobj
.ktype
= &ktype_pci_instance
;
151 err
= kobject_set_name(&pci
->kobj
, "pci%d", idx
);
155 err
= kobject_register(&pci
->kobj
);
157 debugf2("%s() failed to register instance pci%d\n",
162 debugf1("%s() Register instance 'pci%d' kobject\n", __func__
, idx
);
168 edac_pci_delete_instance_kobj(struct edac_pci_ctl_info
*pci
, int idx
)
170 init_completion(&pci
->kobj_complete
);
171 kobject_unregister(&pci
->kobj
);
172 wait_for_completion(&pci
->kobj_complete
);
175 /***************************** EDAC PCI sysfs root **********************/
176 #define to_edacpci(k) container_of(k, struct edac_pci_ctl_info, kobj)
177 #define to_edacpci_attr(a) container_of(a, struct edac_pci_attr, attr)
179 static ssize_t
edac_pci_int_show(void *ptr
, char *buffer
)
182 return sprintf(buffer
, "%d\n", *value
);
185 static ssize_t
edac_pci_int_store(void *ptr
, const char *buffer
, size_t count
)
189 if (isdigit(*buffer
))
190 *value
= simple_strtoul(buffer
, NULL
, 0);
195 struct edac_pci_dev_attribute
{
196 struct attribute attr
;
198 ssize_t(*show
) (void *, char *);
199 ssize_t(*store
) (void *, const char *, size_t);
202 /* Set of show/store abstract level functions for PCI Parity object */
203 static ssize_t
edac_pci_dev_show(struct kobject
*kobj
, struct attribute
*attr
,
206 struct edac_pci_dev_attribute
*edac_pci_dev
;
207 edac_pci_dev
= (struct edac_pci_dev_attribute
*)attr
;
209 if (edac_pci_dev
->show
)
210 return edac_pci_dev
->show(edac_pci_dev
->value
, buffer
);
214 static ssize_t
edac_pci_dev_store(struct kobject
*kobj
,
215 struct attribute
*attr
, const char *buffer
,
218 struct edac_pci_dev_attribute
*edac_pci_dev
;
219 edac_pci_dev
= (struct edac_pci_dev_attribute
*)attr
;
221 if (edac_pci_dev
->show
)
222 return edac_pci_dev
->store(edac_pci_dev
->value
, buffer
, count
);
226 static struct sysfs_ops edac_pci_sysfs_ops
= {
227 .show
= edac_pci_dev_show
,
228 .store
= edac_pci_dev_store
231 #define EDAC_PCI_ATTR(_name,_mode,_show,_store) \
232 static struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
233 .attr = {.name = __stringify(_name), .mode = _mode }, \
239 #define EDAC_PCI_STRING_ATTR(_name,_data,_mode,_show,_store) \
240 static struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
241 .attr = {.name = __stringify(_name), .mode = _mode }, \
247 /* PCI Parity control files */
248 EDAC_PCI_ATTR(check_pci_errors
, S_IRUGO
| S_IWUSR
, edac_pci_int_show
,
250 EDAC_PCI_ATTR(edac_pci_log_pe
, S_IRUGO
| S_IWUSR
, edac_pci_int_show
,
252 EDAC_PCI_ATTR(edac_pci_log_npe
, S_IRUGO
| S_IWUSR
, edac_pci_int_show
,
254 EDAC_PCI_ATTR(edac_pci_panic_on_pe
, S_IRUGO
| S_IWUSR
, edac_pci_int_show
,
256 EDAC_PCI_ATTR(pci_parity_count
, S_IRUGO
, edac_pci_int_show
, NULL
);
257 EDAC_PCI_ATTR(pci_nonparity_count
, S_IRUGO
, edac_pci_int_show
, NULL
);
259 /* Base Attributes of the memory ECC object */
260 static struct edac_pci_dev_attribute
*edac_pci_attr
[] = {
261 &edac_pci_attr_check_pci_errors
,
262 &edac_pci_attr_edac_pci_log_pe
,
263 &edac_pci_attr_edac_pci_log_npe
,
264 &edac_pci_attr_edac_pci_panic_on_pe
,
265 &edac_pci_attr_pci_parity_count
,
266 &edac_pci_attr_pci_nonparity_count
,
270 /* No memory to release */
271 static void edac_pci_release(struct kobject
*kobj
)
273 struct edac_pci_ctl_info
*pci
;
275 pci
= to_edacpci(kobj
);
277 debugf1("%s()\n", __func__
);
278 complete(&pci
->kobj_complete
);
281 static struct kobj_type ktype_edac_pci
= {
282 .release
= edac_pci_release
,
283 .sysfs_ops
= &edac_pci_sysfs_ops
,
284 .default_attrs
= (struct attribute
**)edac_pci_attr
,
288 * edac_sysfs_pci_setup()
290 * setup the sysfs for EDAC PCI attributes
291 * assumes edac_class has already been initialized
293 int edac_pci_register_main_kobj(void)
296 struct sysdev_class
*edac_class
;
298 debugf1("%s()\n", __func__
);
300 edac_class
= edac_get_edac_class();
301 if (edac_class
== NULL
) {
302 debugf1("%s() no edac_class\n", __func__
);
306 edac_pci_kobj
.ktype
= &ktype_edac_pci
;
308 edac_pci_kobj
.parent
= &edac_class
->kset
.kobj
;
310 err
= kobject_set_name(&edac_pci_kobj
, "pci");
314 /* Instanstiate the pci object */
315 /* FIXME: maybe new sysdev_create_subdir() */
316 err
= kobject_register(&edac_pci_kobj
);
319 debugf1("Failed to register '.../edac/pci'\n");
323 debugf1("Registered '.../edac/pci' kobject\n");
329 * edac_pci_unregister_main_kobj()
331 * perform the sysfs teardown for the PCI attributes
333 void edac_pci_unregister_main_kobj(void)
335 debugf0("%s()\n", __func__
);
336 init_completion(&edac_pci_kobj_complete
);
337 kobject_unregister(&edac_pci_kobj
);
338 wait_for_completion(&edac_pci_kobj_complete
);
341 int edac_pci_create_sysfs(struct edac_pci_ctl_info
*pci
)
344 struct kobject
*edac_kobj
= &pci
->kobj
;
346 if (atomic_inc_return(&edac_pci_sysfs_refcount
) == 1) {
347 err
= edac_pci_register_main_kobj();
349 atomic_dec(&edac_pci_sysfs_refcount
);
354 err
= edac_pci_create_instance_kobj(pci
, pci
->pci_idx
);
356 if (atomic_dec_return(&edac_pci_sysfs_refcount
) == 0)
357 edac_pci_unregister_main_kobj();
360 debugf0("%s() idx=%d\n", __func__
, pci
->pci_idx
);
362 err
= sysfs_create_link(edac_kobj
, &pci
->dev
->kobj
, EDAC_PCI_SYMLINK
);
364 debugf0("%s() sysfs_create_link() returned err= %d\n",
372 void edac_pci_remove_sysfs(struct edac_pci_ctl_info
*pci
)
374 debugf0("%s()\n", __func__
);
376 edac_pci_delete_instance_kobj(pci
, pci
->pci_idx
);
378 sysfs_remove_link(&pci
->kobj
, EDAC_PCI_SYMLINK
);
380 if (atomic_dec_return(&edac_pci_sysfs_refcount
) == 0)
381 edac_pci_unregister_main_kobj();
384 /************************ PCI error handling *************************/
385 static u16
get_pci_parity_status(struct pci_dev
*dev
, int secondary
)
390 where
= secondary
? PCI_SEC_STATUS
: PCI_STATUS
;
391 pci_read_config_word(dev
, where
, &status
);
393 /* If we get back 0xFFFF then we must suspect that the card has been
394 * pulled but the Linux PCI layer has not yet finished cleaning up.
395 * We don't want to report on such devices
398 if (status
== 0xFFFF) {
401 pci_read_config_dword(dev
, 0, &sanity
);
403 if (sanity
== 0xFFFFFFFF)
407 status
&= PCI_STATUS_DETECTED_PARITY
| PCI_STATUS_SIG_SYSTEM_ERROR
|
411 /* reset only the bits we are interested in */
412 pci_write_config_word(dev
, where
, status
);
417 typedef void (*pci_parity_check_fn_t
) (struct pci_dev
* dev
);
419 /* Clear any PCI parity errors logged by this device. */
420 static void edac_pci_dev_parity_clear(struct pci_dev
*dev
)
424 get_pci_parity_status(dev
, 0);
426 /* read the device TYPE, looking for bridges */
427 pci_read_config_byte(dev
, PCI_HEADER_TYPE
, &header_type
);
429 if ((header_type
& 0x7F) == PCI_HEADER_TYPE_BRIDGE
)
430 get_pci_parity_status(dev
, 1);
437 static void edac_pci_dev_parity_test(struct pci_dev
*dev
)
442 /* read the STATUS register on this device
444 status
= get_pci_parity_status(dev
, 0);
446 debugf2("PCI STATUS= 0x%04x %s\n", status
, dev
->dev
.bus_id
);
448 /* check the status reg for errors */
450 if (status
& (PCI_STATUS_SIG_SYSTEM_ERROR
)) {
451 edac_printk(KERN_CRIT
, EDAC_PCI
,
452 "Signaled System Error on %s\n",
454 atomic_inc(&pci_nonparity_count
);
457 if (status
& (PCI_STATUS_PARITY
)) {
458 edac_printk(KERN_CRIT
, EDAC_PCI
,
459 "Master Data Parity Error on %s\n",
462 atomic_inc(&pci_parity_count
);
465 if (status
& (PCI_STATUS_DETECTED_PARITY
)) {
466 edac_printk(KERN_CRIT
, EDAC_PCI
,
467 "Detected Parity Error on %s\n",
470 atomic_inc(&pci_parity_count
);
474 /* read the device TYPE, looking for bridges */
475 pci_read_config_byte(dev
, PCI_HEADER_TYPE
, &header_type
);
477 debugf2("PCI HEADER TYPE= 0x%02x %s\n", header_type
, dev
->dev
.bus_id
);
479 if ((header_type
& 0x7F) == PCI_HEADER_TYPE_BRIDGE
) {
480 /* On bridges, need to examine secondary status register */
481 status
= get_pci_parity_status(dev
, 1);
483 debugf2("PCI SEC_STATUS= 0x%04x %s\n", status
, dev
->dev
.bus_id
);
485 /* check the secondary status reg for errors */
487 if (status
& (PCI_STATUS_SIG_SYSTEM_ERROR
)) {
488 edac_printk(KERN_CRIT
, EDAC_PCI
, "Bridge "
489 "Signaled System Error on %s\n",
491 atomic_inc(&pci_nonparity_count
);
494 if (status
& (PCI_STATUS_PARITY
)) {
495 edac_printk(KERN_CRIT
, EDAC_PCI
, "Bridge "
496 "Master Data Parity Error on "
497 "%s\n", pci_name(dev
));
499 atomic_inc(&pci_parity_count
);
502 if (status
& (PCI_STATUS_DETECTED_PARITY
)) {
503 edac_printk(KERN_CRIT
, EDAC_PCI
, "Bridge "
504 "Detected Parity Error on %s\n",
507 atomic_inc(&pci_parity_count
);
514 * pci_dev parity list iterator
515 * Scan the PCI device list for one iteration, looking for SERRORs
516 * Master Parity ERRORS or Parity ERRORs on primary or secondary devices
518 static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn
)
520 struct pci_dev
*dev
= NULL
;
522 /* request for kernel access to the next PCI device, if any,
523 * and while we are looking at it have its reference count
524 * bumped until we are done with it
526 while ((dev
= pci_get_device(PCI_ANY_ID
, PCI_ANY_ID
, dev
)) != NULL
) {
532 * edac_pci_do_parity_check
534 * performs the actual PCI parity check operation
536 void edac_pci_do_parity_check(void)
541 debugf3("%s()\n", __func__
);
543 if (!check_pci_errors
)
546 before_count
= atomic_read(&pci_parity_count
);
548 /* scan all PCI devices looking for a Parity Error on devices and
551 local_irq_save(flags
);
552 edac_pci_dev_parity_iterator(edac_pci_dev_parity_test
);
553 local_irq_restore(flags
);
555 /* Only if operator has selected panic on PCI Error */
556 if (edac_pci_get_panic_on_pe()) {
557 /* If the count is different 'after' from 'before' */
558 if (before_count
!= atomic_read(&pci_parity_count
))
559 panic("EDAC: PCI Parity Error");
563 void edac_pci_clear_parity_errors(void)
565 /* Clear any PCI bus parity errors that devices initially have logged
566 * in their registers.
568 edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear
);
570 void edac_pci_handle_pe(struct edac_pci_ctl_info
*pci
, const char *msg
)
573 /* global PE counter incremented by edac_pci_do_parity_check() */
574 atomic_inc(&pci
->counters
.pe_count
);
576 if (edac_pci_get_log_pe())
577 edac_pci_printk(pci
, KERN_WARNING
,
578 "Parity Error ctl: %s %d: %s\n",
579 pci
->ctl_name
, pci
->pci_idx
, msg
);
582 * poke all PCI devices and see which one is the troublemaker
583 * panic() is called if set
585 edac_pci_do_parity_check();
588 EXPORT_SYMBOL_GPL(edac_pci_handle_pe
);
590 void edac_pci_handle_npe(struct edac_pci_ctl_info
*pci
, const char *msg
)
593 /* global NPE counter incremented by edac_pci_do_parity_check() */
594 atomic_inc(&pci
->counters
.npe_count
);
596 if (edac_pci_get_log_npe())
597 edac_pci_printk(pci
, KERN_WARNING
,
598 "Non-Parity Error ctl: %s %d: %s\n",
599 pci
->ctl_name
, pci
->pci_idx
, msg
);
602 * poke all PCI devices and see which one is the troublemaker
603 * panic() is called if set
605 edac_pci_do_parity_check();
608 EXPORT_SYMBOL_GPL(edac_pci_handle_npe
);
611 * Define the PCI parameter to the module
613 module_param(check_pci_errors
, int, 0644);
614 MODULE_PARM_DESC(check_pci_errors
,
615 "Check for PCI bus parity errors: 0=off 1=on");
616 module_param(edac_pci_panic_on_pe
, int, 0644);
617 MODULE_PARM_DESC(edac_pci_panic_on_pe
,
618 "Panic on PCI Bus Parity error: 0=off 1=on");
620 #endif /* CONFIG_PCI */