Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / drivers / edac / edac_pci_sysfs.c
blob72c9eb9fdffbe497142d542b777997cddfb1c1b7
1 /*
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>
8 */
9 #include <linux/module.h>
10 #include <linux/edac.h>
11 #include <linux/slab.h>
12 #include <linux/ctype.h>
14 #include "edac_pci.h"
15 #include "edac_module.h"
17 #define EDAC_PCI_SYMLINK "device"
19 /* data variables exported via sysfs */
20 static int check_pci_errors; /* default NO 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 int edac_pci_poll_msec = 1000; /* one second workq period */
26 static atomic_t pci_parity_count = ATOMIC_INIT(0);
27 static atomic_t pci_nonparity_count = ATOMIC_INIT(0);
29 static struct kobject *edac_pci_top_main_kobj;
30 static atomic_t edac_pci_sysfs_refcount = ATOMIC_INIT(0);
32 /* getter functions for the data variables */
33 int edac_pci_get_check_errors(void)
35 return check_pci_errors;
38 static int edac_pci_get_log_pe(void)
40 return edac_pci_log_pe;
43 static int edac_pci_get_log_npe(void)
45 return edac_pci_log_npe;
48 static 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,
65 char *data)
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 edac_dbg(0, "\n");
80 /* Form pointer to containing struct, the pci control struct */
81 pci = to_instance(kobj);
83 /* decrement reference count on top main kobj */
84 kobject_put(edac_pci_top_main_kobj);
86 kfree(pci); /* Free the control struct */
89 /* instance specific attribute structure */
90 struct instance_attribute {
91 struct attribute attr;
92 ssize_t(*show) (struct edac_pci_ctl_info *, char *);
93 ssize_t(*store) (struct edac_pci_ctl_info *, const char *, size_t);
96 /* Function to 'show' fields from the edac_pci 'instance' structure */
97 static ssize_t edac_pci_instance_show(struct kobject *kobj,
98 struct attribute *attr, char *buffer)
100 struct edac_pci_ctl_info *pci = to_instance(kobj);
101 struct instance_attribute *instance_attr = to_instance_attr(attr);
103 if (instance_attr->show)
104 return instance_attr->show(pci, buffer);
105 return -EIO;
108 /* Function to 'store' fields into the edac_pci 'instance' structure */
109 static ssize_t edac_pci_instance_store(struct kobject *kobj,
110 struct attribute *attr,
111 const char *buffer, size_t count)
113 struct edac_pci_ctl_info *pci = to_instance(kobj);
114 struct instance_attribute *instance_attr = to_instance_attr(attr);
116 if (instance_attr->store)
117 return instance_attr->store(pci, buffer, count);
118 return -EIO;
121 /* fs_ops table */
122 static const struct sysfs_ops pci_instance_ops = {
123 .show = edac_pci_instance_show,
124 .store = edac_pci_instance_store
127 #define INSTANCE_ATTR(_name, _mode, _show, _store) \
128 static struct instance_attribute attr_instance_##_name = { \
129 .attr = {.name = __stringify(_name), .mode = _mode }, \
130 .show = _show, \
131 .store = _store, \
134 INSTANCE_ATTR(pe_count, S_IRUGO, instance_pe_count_show, NULL);
135 INSTANCE_ATTR(npe_count, S_IRUGO, instance_npe_count_show, NULL);
137 /* pci instance attributes */
138 static struct instance_attribute *pci_instance_attr[] = {
139 &attr_instance_pe_count,
140 &attr_instance_npe_count,
141 NULL
144 /* the ktype for a pci instance */
145 static struct kobj_type ktype_pci_instance = {
146 .release = edac_pci_instance_release,
147 .sysfs_ops = &pci_instance_ops,
148 .default_attrs = (struct attribute **)pci_instance_attr,
152 * edac_pci_create_instance_kobj
154 * construct one EDAC PCI instance's kobject for use
156 static int edac_pci_create_instance_kobj(struct edac_pci_ctl_info *pci, int idx)
158 struct kobject *main_kobj;
159 int err;
161 edac_dbg(0, "\n");
163 /* First bump the ref count on the top main kobj, which will
164 * track the number of PCI instances we have, and thus nest
165 * properly on keeping the module loaded
167 main_kobj = kobject_get(edac_pci_top_main_kobj);
168 if (!main_kobj) {
169 err = -ENODEV;
170 goto error_out;
173 /* And now register this new kobject under the main kobj */
174 err = kobject_init_and_add(&pci->kobj, &ktype_pci_instance,
175 edac_pci_top_main_kobj, "pci%d", idx);
176 if (err != 0) {
177 edac_dbg(2, "failed to register instance pci%d\n", idx);
178 kobject_put(edac_pci_top_main_kobj);
179 goto error_out;
182 kobject_uevent(&pci->kobj, KOBJ_ADD);
183 edac_dbg(1, "Register instance 'pci%d' kobject\n", idx);
185 return 0;
187 /* Error unwind statck */
188 error_out:
189 return err;
193 * edac_pci_unregister_sysfs_instance_kobj
195 * unregister the kobj for the EDAC PCI instance
197 static void edac_pci_unregister_sysfs_instance_kobj(
198 struct edac_pci_ctl_info *pci)
200 edac_dbg(0, "\n");
202 /* Unregister the instance kobject and allow its release
203 * function release the main reference count and then
204 * kfree the memory
206 kobject_put(&pci->kobj);
209 /***************************** EDAC PCI sysfs root **********************/
210 #define to_edacpci(k) container_of(k, struct edac_pci_ctl_info, kobj)
211 #define to_edacpci_attr(a) container_of(a, struct edac_pci_attr, attr)
213 /* simple show/store functions for attributes */
214 static ssize_t edac_pci_int_show(void *ptr, char *buffer)
216 int *value = ptr;
217 return sprintf(buffer, "%d\n", *value);
220 static ssize_t edac_pci_int_store(void *ptr, const char *buffer, size_t count)
222 int *value = ptr;
224 if (isdigit(*buffer))
225 *value = simple_strtoul(buffer, NULL, 0);
227 return count;
230 struct edac_pci_dev_attribute {
231 struct attribute attr;
232 void *value;
233 ssize_t(*show) (void *, char *);
234 ssize_t(*store) (void *, const char *, size_t);
237 /* Set of show/store abstract level functions for PCI Parity object */
238 static ssize_t edac_pci_dev_show(struct kobject *kobj, struct attribute *attr,
239 char *buffer)
241 struct edac_pci_dev_attribute *edac_pci_dev;
242 edac_pci_dev = (struct edac_pci_dev_attribute *)attr;
244 if (edac_pci_dev->show)
245 return edac_pci_dev->show(edac_pci_dev->value, buffer);
246 return -EIO;
249 static ssize_t edac_pci_dev_store(struct kobject *kobj,
250 struct attribute *attr, const char *buffer,
251 size_t count)
253 struct edac_pci_dev_attribute *edac_pci_dev;
254 edac_pci_dev = (struct edac_pci_dev_attribute *)attr;
256 if (edac_pci_dev->store)
257 return edac_pci_dev->store(edac_pci_dev->value, buffer, count);
258 return -EIO;
261 static const struct sysfs_ops edac_pci_sysfs_ops = {
262 .show = edac_pci_dev_show,
263 .store = edac_pci_dev_store
266 #define EDAC_PCI_ATTR(_name,_mode,_show,_store) \
267 static struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
268 .attr = {.name = __stringify(_name), .mode = _mode }, \
269 .value = &_name, \
270 .show = _show, \
271 .store = _store, \
274 #define EDAC_PCI_STRING_ATTR(_name,_data,_mode,_show,_store) \
275 static struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
276 .attr = {.name = __stringify(_name), .mode = _mode }, \
277 .value = _data, \
278 .show = _show, \
279 .store = _store, \
282 /* PCI Parity control files */
283 EDAC_PCI_ATTR(check_pci_errors, S_IRUGO | S_IWUSR, edac_pci_int_show,
284 edac_pci_int_store);
285 EDAC_PCI_ATTR(edac_pci_log_pe, S_IRUGO | S_IWUSR, edac_pci_int_show,
286 edac_pci_int_store);
287 EDAC_PCI_ATTR(edac_pci_log_npe, S_IRUGO | S_IWUSR, edac_pci_int_show,
288 edac_pci_int_store);
289 EDAC_PCI_ATTR(edac_pci_panic_on_pe, S_IRUGO | S_IWUSR, edac_pci_int_show,
290 edac_pci_int_store);
291 EDAC_PCI_ATTR(pci_parity_count, S_IRUGO, edac_pci_int_show, NULL);
292 EDAC_PCI_ATTR(pci_nonparity_count, S_IRUGO, edac_pci_int_show, NULL);
294 /* Base Attributes of the memory ECC object */
295 static struct edac_pci_dev_attribute *edac_pci_attr[] = {
296 &edac_pci_attr_check_pci_errors,
297 &edac_pci_attr_edac_pci_log_pe,
298 &edac_pci_attr_edac_pci_log_npe,
299 &edac_pci_attr_edac_pci_panic_on_pe,
300 &edac_pci_attr_pci_parity_count,
301 &edac_pci_attr_pci_nonparity_count,
302 NULL,
306 * edac_pci_release_main_kobj
308 * This release function is called when the reference count to the
309 * passed kobj goes to zero.
311 * This kobj is the 'main' kobject that EDAC PCI instances
312 * link to, and thus provide for proper nesting counts
314 static void edac_pci_release_main_kobj(struct kobject *kobj)
316 edac_dbg(0, "here to module_put(THIS_MODULE)\n");
318 kfree(kobj);
320 /* last reference to top EDAC PCI kobject has been removed,
321 * NOW release our ref count on the core module
323 module_put(THIS_MODULE);
326 /* ktype struct for the EDAC PCI main kobj */
327 static struct kobj_type ktype_edac_pci_main_kobj = {
328 .release = edac_pci_release_main_kobj,
329 .sysfs_ops = &edac_pci_sysfs_ops,
330 .default_attrs = (struct attribute **)edac_pci_attr,
334 * edac_pci_main_kobj_setup: Setup the sysfs for EDAC PCI attributes.
336 static int edac_pci_main_kobj_setup(void)
338 int err;
339 struct bus_type *edac_subsys;
341 edac_dbg(0, "\n");
343 /* check and count if we have already created the main kobject */
344 if (atomic_inc_return(&edac_pci_sysfs_refcount) != 1)
345 return 0;
347 /* First time, so create the main kobject and its
348 * controls and attributes
350 edac_subsys = edac_get_sysfs_subsys();
352 /* Bump the reference count on this module to ensure the
353 * modules isn't unloaded until we deconstruct the top
354 * level main kobj for EDAC PCI
356 if (!try_module_get(THIS_MODULE)) {
357 edac_dbg(1, "try_module_get() failed\n");
358 err = -ENODEV;
359 goto decrement_count_fail;
362 edac_pci_top_main_kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL);
363 if (!edac_pci_top_main_kobj) {
364 edac_dbg(1, "Failed to allocate\n");
365 err = -ENOMEM;
366 goto kzalloc_fail;
369 /* Instanstiate the pci object */
370 err = kobject_init_and_add(edac_pci_top_main_kobj,
371 &ktype_edac_pci_main_kobj,
372 &edac_subsys->dev_root->kobj, "pci");
373 if (err) {
374 edac_dbg(1, "Failed to register '.../edac/pci'\n");
375 goto kobject_init_and_add_fail;
378 /* At this point, to 'release' the top level kobject
379 * for EDAC PCI, then edac_pci_main_kobj_teardown()
380 * must be used, for resources to be cleaned up properly
382 kobject_uevent(edac_pci_top_main_kobj, KOBJ_ADD);
383 edac_dbg(1, "Registered '.../edac/pci' kobject\n");
385 return 0;
387 /* Error unwind statck */
388 kobject_init_and_add_fail:
389 kfree(edac_pci_top_main_kobj);
391 kzalloc_fail:
392 module_put(THIS_MODULE);
394 decrement_count_fail:
395 /* if are on this error exit, nothing to tear down */
396 atomic_dec(&edac_pci_sysfs_refcount);
398 return err;
402 * edac_pci_main_kobj_teardown()
404 * if no longer linked (needed) remove the top level EDAC PCI
405 * kobject with its controls and attributes
407 static void edac_pci_main_kobj_teardown(void)
409 edac_dbg(0, "\n");
411 /* Decrement the count and only if no more controller instances
412 * are connected perform the unregisteration of the top level
413 * main kobj
415 if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0) {
416 edac_dbg(0, "called kobject_put on main kobj\n");
417 kobject_put(edac_pci_top_main_kobj);
421 int edac_pci_create_sysfs(struct edac_pci_ctl_info *pci)
423 int err;
424 struct kobject *edac_kobj = &pci->kobj;
426 edac_dbg(0, "idx=%d\n", pci->pci_idx);
428 /* create the top main EDAC PCI kobject, IF needed */
429 err = edac_pci_main_kobj_setup();
430 if (err)
431 return err;
433 /* Create this instance's kobject under the MAIN kobject */
434 err = edac_pci_create_instance_kobj(pci, pci->pci_idx);
435 if (err)
436 goto unregister_cleanup;
438 err = sysfs_create_link(edac_kobj, &pci->dev->kobj, EDAC_PCI_SYMLINK);
439 if (err) {
440 edac_dbg(0, "sysfs_create_link() returned err= %d\n", err);
441 goto symlink_fail;
444 return 0;
446 /* Error unwind stack */
447 symlink_fail:
448 edac_pci_unregister_sysfs_instance_kobj(pci);
450 unregister_cleanup:
451 edac_pci_main_kobj_teardown();
453 return err;
456 void edac_pci_remove_sysfs(struct edac_pci_ctl_info *pci)
458 edac_dbg(0, "index=%d\n", pci->pci_idx);
460 /* Remove the symlink */
461 sysfs_remove_link(&pci->kobj, EDAC_PCI_SYMLINK);
463 /* remove this PCI instance's sysfs entries */
464 edac_pci_unregister_sysfs_instance_kobj(pci);
466 /* Call the main unregister function, which will determine
467 * if this 'pci' is the last instance.
468 * If it is, the main kobject will be unregistered as a result
470 edac_dbg(0, "calling edac_pci_main_kobj_teardown()\n");
471 edac_pci_main_kobj_teardown();
474 /************************ PCI error handling *************************/
475 static u16 get_pci_parity_status(struct pci_dev *dev, int secondary)
477 int where;
478 u16 status;
480 where = secondary ? PCI_SEC_STATUS : PCI_STATUS;
481 pci_read_config_word(dev, where, &status);
483 /* If we get back 0xFFFF then we must suspect that the card has been
484 * pulled but the Linux PCI layer has not yet finished cleaning up.
485 * We don't want to report on such devices
488 if (status == 0xFFFF) {
489 u32 sanity;
491 pci_read_config_dword(dev, 0, &sanity);
493 if (sanity == 0xFFFFFFFF)
494 return 0;
497 status &= PCI_STATUS_DETECTED_PARITY | PCI_STATUS_SIG_SYSTEM_ERROR |
498 PCI_STATUS_PARITY;
500 if (status)
501 /* reset only the bits we are interested in */
502 pci_write_config_word(dev, where, status);
504 return status;
508 /* Clear any PCI parity errors logged by this device. */
509 static void edac_pci_dev_parity_clear(struct pci_dev *dev)
511 u8 header_type;
513 get_pci_parity_status(dev, 0);
515 /* read the device TYPE, looking for bridges */
516 pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
518 if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE)
519 get_pci_parity_status(dev, 1);
523 * PCI Parity polling
525 * Function to retrieve the current parity status
526 * and decode it
529 static void edac_pci_dev_parity_test(struct pci_dev *dev)
531 unsigned long flags;
532 u16 status;
533 u8 header_type;
535 /* stop any interrupts until we can acquire the status */
536 local_irq_save(flags);
538 /* read the STATUS register on this device */
539 status = get_pci_parity_status(dev, 0);
541 /* read the device TYPE, looking for bridges */
542 pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
544 local_irq_restore(flags);
546 edac_dbg(4, "PCI STATUS= 0x%04x %s\n", status, dev_name(&dev->dev));
548 /* check the status reg for errors on boards NOT marked as broken
549 * if broken, we cannot trust any of the status bits
551 if (status && !dev->broken_parity_status) {
552 if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
553 edac_printk(KERN_CRIT, EDAC_PCI,
554 "Signaled System Error on %s\n",
555 pci_name(dev));
556 atomic_inc(&pci_nonparity_count);
559 if (status & (PCI_STATUS_PARITY)) {
560 edac_printk(KERN_CRIT, EDAC_PCI,
561 "Master Data Parity Error on %s\n",
562 pci_name(dev));
564 atomic_inc(&pci_parity_count);
567 if (status & (PCI_STATUS_DETECTED_PARITY)) {
568 edac_printk(KERN_CRIT, EDAC_PCI,
569 "Detected Parity Error on %s\n",
570 pci_name(dev));
572 atomic_inc(&pci_parity_count);
577 edac_dbg(4, "PCI HEADER TYPE= 0x%02x %s\n",
578 header_type, dev_name(&dev->dev));
580 if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
581 /* On bridges, need to examine secondary status register */
582 status = get_pci_parity_status(dev, 1);
584 edac_dbg(4, "PCI SEC_STATUS= 0x%04x %s\n",
585 status, dev_name(&dev->dev));
587 /* check the secondary status reg for errors,
588 * on NOT broken boards
590 if (status && !dev->broken_parity_status) {
591 if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
592 edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
593 "Signaled System Error on %s\n",
594 pci_name(dev));
595 atomic_inc(&pci_nonparity_count);
598 if (status & (PCI_STATUS_PARITY)) {
599 edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
600 "Master Data Parity Error on "
601 "%s\n", pci_name(dev));
603 atomic_inc(&pci_parity_count);
606 if (status & (PCI_STATUS_DETECTED_PARITY)) {
607 edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
608 "Detected Parity Error on %s\n",
609 pci_name(dev));
611 atomic_inc(&pci_parity_count);
617 /* reduce some complexity in definition of the iterator */
618 typedef void (*pci_parity_check_fn_t) (struct pci_dev *dev);
621 * pci_dev parity list iterator
623 * Scan the PCI device list looking for SERRORs, Master Parity ERRORS or
624 * Parity ERRORs on primary or secondary devices.
626 static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn)
628 struct pci_dev *dev = NULL;
630 for_each_pci_dev(dev)
631 fn(dev);
635 * edac_pci_do_parity_check
637 * performs the actual PCI parity check operation
639 void edac_pci_do_parity_check(void)
641 int before_count;
643 edac_dbg(3, "\n");
645 /* if policy has PCI check off, leave now */
646 if (!check_pci_errors)
647 return;
649 before_count = atomic_read(&pci_parity_count);
651 /* scan all PCI devices looking for a Parity Error on devices and
652 * bridges.
653 * The iterator calls pci_get_device() which might sleep, thus
654 * we cannot disable interrupts in this scan.
656 edac_pci_dev_parity_iterator(edac_pci_dev_parity_test);
658 /* Only if operator has selected panic on PCI Error */
659 if (edac_pci_get_panic_on_pe()) {
660 /* If the count is different 'after' from 'before' */
661 if (before_count != atomic_read(&pci_parity_count))
662 panic("EDAC: PCI Parity Error");
667 * edac_pci_clear_parity_errors
669 * function to perform an iteration over the PCI devices
670 * and clearn their current status
672 void edac_pci_clear_parity_errors(void)
674 /* Clear any PCI bus parity errors that devices initially have logged
675 * in their registers.
677 edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear);
681 * edac_pci_handle_pe
683 * Called to handle a PARITY ERROR event
685 void edac_pci_handle_pe(struct edac_pci_ctl_info *pci, const char *msg)
688 /* global PE counter incremented by edac_pci_do_parity_check() */
689 atomic_inc(&pci->counters.pe_count);
691 if (edac_pci_get_log_pe())
692 edac_pci_printk(pci, KERN_WARNING,
693 "Parity Error ctl: %s %d: %s\n",
694 pci->ctl_name, pci->pci_idx, msg);
697 * poke all PCI devices and see which one is the troublemaker
698 * panic() is called if set
700 edac_pci_do_parity_check();
702 EXPORT_SYMBOL_GPL(edac_pci_handle_pe);
706 * edac_pci_handle_npe
708 * Called to handle a NON-PARITY ERROR event
710 void edac_pci_handle_npe(struct edac_pci_ctl_info *pci, const char *msg)
713 /* global NPE counter incremented by edac_pci_do_parity_check() */
714 atomic_inc(&pci->counters.npe_count);
716 if (edac_pci_get_log_npe())
717 edac_pci_printk(pci, KERN_WARNING,
718 "Non-Parity Error ctl: %s %d: %s\n",
719 pci->ctl_name, pci->pci_idx, msg);
722 * poke all PCI devices and see which one is the troublemaker
723 * panic() is called if set
725 edac_pci_do_parity_check();
727 EXPORT_SYMBOL_GPL(edac_pci_handle_npe);
730 * Define the PCI parameter to the module
732 module_param(check_pci_errors, int, 0644);
733 MODULE_PARM_DESC(check_pci_errors,
734 "Check for PCI bus parity errors: 0=off 1=on");
735 module_param(edac_pci_panic_on_pe, int, 0644);
736 MODULE_PARM_DESC(edac_pci_panic_on_pe,
737 "Panic on PCI Bus Parity error: 0=off 1=on");