amd64_edac: Fix channel interleave removal
[linux-2.6.git] / drivers / edac / edac_pci_sysfs.c
index 0b179e0..023b01c 100644 (file)
@@ -7,37 +7,67 @@
  *
  */
 #include <linux/module.h>
-#include <linux/sysdev.h>
+#include <linux/edac.h>
+#include <linux/slab.h>
 #include <linux/ctype.h>
 
 #include "edac_core.h"
 #include "edac_module.h"
 
-
+/* Turn off this whole feature if PCI is not configured */
 #ifdef CONFIG_PCI
 
 #define EDAC_PCI_SYMLINK       "device"
 
-static int check_pci_errors = 0;       /* default YES check PCI parity */
-static int panic_on_pci_parity = 0;    /* default no panic on PCI Parity */
-static int log_pci_errs = 1;
+/* data variables exported via sysfs */
+static int check_pci_errors;           /* default NO check PCI parity */
+static int edac_pci_panic_on_pe;       /* default NO panic on PCI Parity */
+static int edac_pci_log_pe = 1;                /* log PCI parity errors */
+static int edac_pci_log_npe = 1;       /* log PCI non-parity error errors */
+static int edac_pci_poll_msec = 1000;  /* one second workq period */
+
 static atomic_t pci_parity_count = ATOMIC_INIT(0);
 static atomic_t pci_nonparity_count = ATOMIC_INIT(0);
 
-static struct kobject edac_pci_kobj; /* /sys/devices/system/edac/pci */
-static struct completion edac_pci_kobj_complete;
+static struct kobject *edac_pci_top_main_kobj;
 static atomic_t edac_pci_sysfs_refcount = ATOMIC_INIT(0);
 
+/* getter functions for the data variables */
+int edac_pci_get_check_errors(void)
+{
+       return check_pci_errors;
+}
+
+static int edac_pci_get_log_pe(void)
+{
+       return edac_pci_log_pe;
+}
+
+static int edac_pci_get_log_npe(void)
+{
+       return edac_pci_log_npe;
+}
+
+static int edac_pci_get_panic_on_pe(void)
+{
+       return edac_pci_panic_on_pe;
+}
+
+int edac_pci_get_poll_msec(void)
+{
+       return edac_pci_poll_msec;
+}
+
 /**************************** EDAC PCI sysfs instance *******************/
 static ssize_t instance_pe_count_show(struct edac_pci_ctl_info *pci, char *data)
 {
-        return sprintf(data,"%u\n", atomic_read(&pci->counters.pe_count));
+       return sprintf(data, "%u\n", atomic_read(&pci->counters.pe_count));
 }
 
 static ssize_t instance_npe_count_show(struct edac_pci_ctl_info *pci,
-               char *data)
+                               char *data)
 {
-        return sprintf(data,"%u\n", atomic_read(&pci->counters.npe_count));
+       return sprintf(data, "%u\n", atomic_read(&pci->counters.npe_count));
 }
 
 #define to_instance(k) container_of(k, struct edac_pci_ctl_info, kobj)
@@ -48,47 +78,51 @@ static void edac_pci_instance_release(struct kobject *kobj)
 {
        struct edac_pci_ctl_info *pci;
 
-       debugf1("%s()\n", __func__);
+       debugf0("%s()\n", __func__);
 
+       /* Form pointer to containing struct, the pci control struct */
        pci = to_instance(kobj);
-       complete(&pci->kobj_complete);
+
+       /* decrement reference count on top main kobj */
+       kobject_put(edac_pci_top_main_kobj);
+
+       kfree(pci);     /* Free the control struct */
 }
 
 /* instance specific attribute structure */
 struct instance_attribute {
-        struct attribute attr;
-        ssize_t (*show)(struct edac_pci_ctl_info *, char *);
-        ssize_t (*store)(struct edac_pci_ctl_info *, const char *, size_t);
+       struct attribute attr;
+       ssize_t(*show) (struct edac_pci_ctl_info *, char *);
+       ssize_t(*store) (struct edac_pci_ctl_info *, const char *, size_t);
 };
 
 /* Function to 'show' fields from the edac_pci 'instance' structure */
 static ssize_t edac_pci_instance_show(struct kobject *kobj,
-                        struct attribute *attr,
-                        char *buffer)
+                               struct attribute *attr, char *buffer)
 {
-        struct edac_pci_ctl_info *pci = to_instance(kobj);
-        struct instance_attribute *instance_attr = to_instance_attr(attr);
+       struct edac_pci_ctl_info *pci = to_instance(kobj);
+       struct instance_attribute *instance_attr = to_instance_attr(attr);
 
-        if (instance_attr->show)
-                return instance_attr->show(pci, buffer);
-        return -EIO;
+       if (instance_attr->show)
+               return instance_attr->show(pci, buffer);
+       return -EIO;
 }
 
-
 /* Function to 'store' fields into the edac_pci 'instance' structure */
 static ssize_t edac_pci_instance_store(struct kobject *kobj,
-                        struct attribute *attr,
-                       const char *buffer, size_t count)
+                               struct attribute *attr,
+                               const char *buffer, size_t count)
 {
-        struct edac_pci_ctl_info *pci = to_instance(kobj);
-        struct instance_attribute *instance_attr = to_instance_attr(attr);
+       struct edac_pci_ctl_info *pci = to_instance(kobj);
+       struct instance_attribute *instance_attr = to_instance_attr(attr);
 
-        if (instance_attr->store)
-                return instance_attr->store(pci, buffer, count);
-        return -EIO;
+       if (instance_attr->store)
+               return instance_attr->store(pci, buffer, count);
+       return -EIO;
 }
 
-static struct sysfs_ops pci_instance_ops = {
+/* fs_ops table */
+static const struct sysfs_ops pci_instance_ops = {
        .show = edac_pci_instance_show,
        .store = edac_pci_instance_store
 };
@@ -110,52 +144,81 @@ static struct instance_attribute *pci_instance_attr[] = {
        NULL
 };
 
-/* the ktype for pci instance */
+/* the ktype for a pci instance */
 static struct kobj_type ktype_pci_instance = {
        .release = edac_pci_instance_release,
        .sysfs_ops = &pci_instance_ops,
        .default_attrs = (struct attribute **)pci_instance_attr,
 };
 
+/*
+ * edac_pci_create_instance_kobj
+ *
+ *     construct one EDAC PCI instance's kobject for use
+ */
 static int edac_pci_create_instance_kobj(struct edac_pci_ctl_info *pci, int idx)
 {
+       struct kobject *main_kobj;
        int err;
 
-       pci->kobj.parent = &edac_pci_kobj;
-       pci->kobj.ktype = &ktype_pci_instance;
+       debugf0("%s()\n", __func__);
 
-       err = kobject_set_name(&pci->kobj, "pci%d", idx);
-       if (err)
-               return err;
+       /* First bump the ref count on the top main kobj, which will
+        * track the number of PCI instances we have, and thus nest
+        * properly on keeping the module loaded
+        */
+       main_kobj = kobject_get(edac_pci_top_main_kobj);
+       if (!main_kobj) {
+               err = -ENODEV;
+               goto error_out;
+       }
 
-       err = kobject_register(&pci->kobj);
+       /* And now register this new kobject under the main kobj */
+       err = kobject_init_and_add(&pci->kobj, &ktype_pci_instance,
+                                  edac_pci_top_main_kobj, "pci%d", idx);
        if (err != 0) {
                debugf2("%s() failed to register instance pci%d\n",
-                               __func__, idx);
-               return err;
+                       __func__, idx);
+               kobject_put(edac_pci_top_main_kobj);
+               goto error_out;
        }
 
+       kobject_uevent(&pci->kobj, KOBJ_ADD);
        debugf1("%s() Register instance 'pci%d' kobject\n", __func__, idx);
 
        return 0;
+
+       /* Error unwind statck */
+error_out:
+       return err;
 }
 
-static void
-edac_pci_delete_instance_kobj(struct edac_pci_ctl_info *pci, int idx)
+/*
+ * edac_pci_unregister_sysfs_instance_kobj
+ *
+ *     unregister the kobj for the EDAC PCI instance
+ */
+static void edac_pci_unregister_sysfs_instance_kobj(
+                       struct edac_pci_ctl_info *pci)
 {
-       init_completion(&pci->kobj_complete);
-       kobject_unregister(&pci->kobj);
-       wait_for_completion(&pci->kobj_complete);
+       debugf0("%s()\n", __func__);
+
+       /* Unregister the instance kobject and allow its release
+        * function release the main reference count and then
+        * kfree the memory
+        */
+       kobject_put(&pci->kobj);
 }
 
 /***************************** EDAC PCI sysfs root **********************/
 #define to_edacpci(k) container_of(k, struct edac_pci_ctl_info, kobj)
 #define to_edacpci_attr(a) container_of(a, struct edac_pci_attr, attr)
 
+/* simple show/store functions for attributes */
 static ssize_t edac_pci_int_show(void *ptr, char *buffer)
 {
        int *value = ptr;
-       return sprintf(buffer,"%d\n",*value);
+       return sprintf(buffer, "%d\n", *value);
 }
 
 static ssize_t edac_pci_int_store(void *ptr, const char *buffer, size_t count)
@@ -163,7 +226,7 @@ static ssize_t edac_pci_int_store(void *ptr, const char *buffer, size_t count)
        int *value = ptr;
 
        if (isdigit(*buffer))
-               *value = simple_strtoul(buffer,NULL,0);
+               *value = simple_strtoul(buffer, NULL, 0);
 
        return count;
 }
@@ -171,16 +234,16 @@ static ssize_t edac_pci_int_store(void *ptr, const char *buffer, size_t count)
 struct edac_pci_dev_attribute {
        struct attribute attr;
        void *value;
-       ssize_t (*show)(void *,char *);
-       ssize_t (*store)(void *, const char *,size_t);
+        ssize_t(*show) (void *, char *);
+        ssize_t(*store) (void *, const char *, size_t);
 };
 
 /* Set of show/store abstract level functions for PCI Parity object */
 static ssize_t edac_pci_dev_show(struct kobject *kobj, struct attribute *attr,
-               char *buffer)
+                                char *buffer)
 {
        struct edac_pci_dev_attribute *edac_pci_dev;
-       edac_pci_dev= (struct edac_pci_dev_attribute*)attr;
+       edac_pci_dev = (struct edac_pci_dev_attribute *)attr;
 
        if (edac_pci_dev->show)
                return edac_pci_dev->show(edac_pci_dev->value, buffer);
@@ -188,19 +251,20 @@ static ssize_t edac_pci_dev_show(struct kobject *kobj, struct attribute *attr,
 }
 
 static ssize_t edac_pci_dev_store(struct kobject *kobj,
-               struct attribute *attr, const char *buffer, size_t count)
+                               struct attribute *attr, const char *buffer,
+                               size_t count)
 {
        struct edac_pci_dev_attribute *edac_pci_dev;
-       edac_pci_dev= (struct edac_pci_dev_attribute*)attr;
+       edac_pci_dev = (struct edac_pci_dev_attribute *)attr;
 
        if (edac_pci_dev->show)
                return edac_pci_dev->store(edac_pci_dev->value, buffer, count);
        return -EIO;
 }
 
-static struct sysfs_ops edac_pci_sysfs_ops = {
-       .show   = edac_pci_dev_show,
-       .store  = edac_pci_dev_store
+static const struct sysfs_ops edac_pci_sysfs_ops = {
+       .show = edac_pci_dev_show,
+       .store = edac_pci_dev_store
 };
 
 #define EDAC_PCI_ATTR(_name,_mode,_show,_store)                        \
@@ -220,11 +284,13 @@ static struct edac_pci_dev_attribute edac_pci_attr_##_name = {            \
 };
 
 /* PCI Parity control files */
-EDAC_PCI_ATTR(check_pci_errors, S_IRUGO|S_IWUSR, edac_pci_int_show,
+EDAC_PCI_ATTR(check_pci_errors, S_IRUGO | S_IWUSR, edac_pci_int_show,
+       edac_pci_int_store);
+EDAC_PCI_ATTR(edac_pci_log_pe, S_IRUGO | S_IWUSR, edac_pci_int_show,
        edac_pci_int_store);
-EDAC_PCI_ATTR(log_pci_errs, S_IRUGO|S_IWUSR, edac_pci_int_show,
+EDAC_PCI_ATTR(edac_pci_log_npe, S_IRUGO | S_IWUSR, edac_pci_int_show,
        edac_pci_int_store);
-EDAC_PCI_ATTR(panic_on_pci_parity, S_IRUGO|S_IWUSR, edac_pci_int_show,
+EDAC_PCI_ATTR(edac_pci_panic_on_pe, S_IRUGO | S_IWUSR, edac_pci_int_show,
        edac_pci_int_store);
 EDAC_PCI_ATTR(pci_parity_count, S_IRUGO, edac_pci_int_show, NULL);
 EDAC_PCI_ATTR(pci_nonparity_count, S_IRUGO, edac_pci_int_show, NULL);
@@ -232,128 +298,206 @@ EDAC_PCI_ATTR(pci_nonparity_count, S_IRUGO, edac_pci_int_show, NULL);
 /* Base Attributes of the memory ECC object */
 static struct edac_pci_dev_attribute *edac_pci_attr[] = {
        &edac_pci_attr_check_pci_errors,
-       &edac_pci_attr_log_pci_errs,
-       &edac_pci_attr_panic_on_pci_parity,
+       &edac_pci_attr_edac_pci_log_pe,
+       &edac_pci_attr_edac_pci_log_npe,
+       &edac_pci_attr_edac_pci_panic_on_pe,
        &edac_pci_attr_pci_parity_count,
        &edac_pci_attr_pci_nonparity_count,
        NULL,
 };
 
-/* No memory to release */
-static void edac_pci_release(struct kobject *kobj)
+/*
+ * edac_pci_release_main_kobj
+ *
+ *     This release function is called when the reference count to the
+ *     passed kobj goes to zero.
+ *
+ *     This kobj is the 'main' kobject that EDAC PCI instances
+ *     link to, and thus provide for proper nesting counts
+ */
+static void edac_pci_release_main_kobj(struct kobject *kobj)
 {
-       struct edac_pci_ctl_info *pci;
+       debugf0("%s() here to module_put(THIS_MODULE)\n", __func__);
 
-       pci = to_edacpci(kobj);
+       kfree(kobj);
 
-       debugf1("%s()\n", __func__);
-       complete(&pci->kobj_complete);
+       /* last reference to top EDAC PCI kobject has been removed,
+        * NOW release our ref count on the core module
+        */
+       module_put(THIS_MODULE);
 }
 
-static struct kobj_type ktype_edac_pci = {
-       .release = edac_pci_release,
+/* ktype struct for the EDAC PCI main kobj */
+static struct kobj_type ktype_edac_pci_main_kobj = {
+       .release = edac_pci_release_main_kobj,
        .sysfs_ops = &edac_pci_sysfs_ops,
-       .default_attrs = (struct attribute **) edac_pci_attr,
+       .default_attrs = (struct attribute **)edac_pci_attr,
 };
 
 /**
- * edac_sysfs_pci_setup()
+ * edac_pci_main_kobj_setup()
  *
  *     setup the sysfs for EDAC PCI attributes
  *     assumes edac_class has already been initialized
  */
-int edac_pci_register_main_kobj(void)
+static int edac_pci_main_kobj_setup(void)
 {
        int err;
        struct sysdev_class *edac_class;
 
-       debugf1("%s()\n", __func__);
+       debugf0("%s()\n", __func__);
+
+       /* check and count if we have already created the main kobject */
+       if (atomic_inc_return(&edac_pci_sysfs_refcount) != 1)
+               return 0;
 
-       edac_class = edac_get_edac_class();
+       /* First time, so create the main kobject and its
+        * controls and atributes
+        */
+       edac_class = edac_get_sysfs_class();
        if (edac_class == NULL) {
                debugf1("%s() no edac_class\n", __func__);
-               return -ENODEV;
+               err = -ENODEV;
+               goto decrement_count_fail;
        }
 
-       edac_pci_kobj.ktype = &ktype_edac_pci;
-
-       edac_pci_kobj.parent = &edac_class->kset.kobj;
+       /* Bump the reference count on this module to ensure the
+        * modules isn't unloaded until we deconstruct the top
+        * level main kobj for EDAC PCI
+        */
+       if (!try_module_get(THIS_MODULE)) {
+               debugf1("%s() try_module_get() failed\n", __func__);
+               err = -ENODEV;
+               goto mod_get_fail;
+       }
 
-       err = kobject_set_name(&edac_pci_kobj, "pci");
-       if(err)
-               return err;
+       edac_pci_top_main_kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL);
+       if (!edac_pci_top_main_kobj) {
+               debugf1("Failed to allocate\n");
+               err = -ENOMEM;
+               goto kzalloc_fail;
+       }
 
        /* Instanstiate the pci object */
-       /* FIXME: maybe new sysdev_create_subdir() */
-       err = kobject_register(&edac_pci_kobj);
-
+       err = kobject_init_and_add(edac_pci_top_main_kobj,
+                                  &ktype_edac_pci_main_kobj,
+                                  &edac_class->kset.kobj, "pci");
        if (err) {
                debugf1("Failed to register '.../edac/pci'\n");
-               return err;
+               goto kobject_init_and_add_fail;
        }
 
+       /* At this point, to 'release' the top level kobject
+        * for EDAC PCI, then edac_pci_main_kobj_teardown()
+        * must be used, for resources to be cleaned up properly
+        */
+       kobject_uevent(edac_pci_top_main_kobj, KOBJ_ADD);
        debugf1("Registered '.../edac/pci' kobject\n");
 
        return 0;
+
+       /* Error unwind statck */
+kobject_init_and_add_fail:
+       kfree(edac_pci_top_main_kobj);
+
+kzalloc_fail:
+       module_put(THIS_MODULE);
+
+mod_get_fail:
+       edac_put_sysfs_class();
+
+decrement_count_fail:
+       /* if are on this error exit, nothing to tear down */
+       atomic_dec(&edac_pci_sysfs_refcount);
+
+       return err;
 }
 
 /*
- * edac_pci_unregister_main_kobj()
+ * edac_pci_main_kobj_teardown()
  *
- *     perform the sysfs teardown for the PCI attributes
+ *     if no longer linked (needed) remove the top level EDAC PCI
+ *     kobject with its controls and attributes
  */
-void edac_pci_unregister_main_kobj(void)
+static void edac_pci_main_kobj_teardown(void)
 {
        debugf0("%s()\n", __func__);
-       init_completion(&edac_pci_kobj_complete);
-       kobject_unregister(&edac_pci_kobj);
-       wait_for_completion(&edac_pci_kobj_complete);
+
+       /* Decrement the count and only if no more controller instances
+        * are connected perform the unregisteration of the top level
+        * main kobj
+        */
+       if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0) {
+               debugf0("%s() called kobject_put on main kobj\n",
+                       __func__);
+               kobject_put(edac_pci_top_main_kobj);
+       }
+       edac_put_sysfs_class();
 }
 
+/*
+ *
+ * edac_pci_create_sysfs
+ *
+ *     Create the controls/attributes for the specified EDAC PCI device
+ */
 int edac_pci_create_sysfs(struct edac_pci_ctl_info *pci)
 {
        int err;
        struct kobject *edac_kobj = &pci->kobj;
 
-       if (atomic_inc_return(&edac_pci_sysfs_refcount) == 1) {
-               err = edac_pci_register_main_kobj();
-               if (err) {
-                       atomic_dec(&edac_pci_sysfs_refcount);
-                       return err;
-               }
-       }
-
-       err = edac_pci_create_instance_kobj(pci, pci->pci_idx);
-       if (err) {
-               if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0)
-                       edac_pci_unregister_main_kobj();
-       }
+       debugf0("%s() idx=%d\n", __func__, pci->pci_idx);
 
+       /* create the top main EDAC PCI kobject, IF needed */
+       err = edac_pci_main_kobj_setup();
+       if (err)
+               return err;
 
-       debugf0("%s() idx=%d\n", __func__, pci->pci_idx);
+       /* Create this instance's kobject under the MAIN kobject */
+       err = edac_pci_create_instance_kobj(pci, pci->pci_idx);
+       if (err)
+               goto unregister_cleanup;
 
-       err = sysfs_create_link(edac_kobj,
-                       &pci->dev->kobj,
-                       EDAC_PCI_SYMLINK);
+       err = sysfs_create_link(edac_kobj, &pci->dev->kobj, EDAC_PCI_SYMLINK);
        if (err) {
                debugf0("%s() sysfs_create_link() returned err= %d\n",
-                               __func__, err);
-               return err;
+                       __func__, err);
+               goto symlink_fail;
        }
 
        return 0;
+
+       /* Error unwind stack */
+symlink_fail:
+       edac_pci_unregister_sysfs_instance_kobj(pci);
+
+unregister_cleanup:
+       edac_pci_main_kobj_teardown();
+
+       return err;
 }
 
+/*
+ * edac_pci_remove_sysfs
+ *
+ *     remove the controls and attributes for this EDAC PCI device
+ */
 void edac_pci_remove_sysfs(struct edac_pci_ctl_info *pci)
 {
-       debugf0("%s()\n", __func__);
-
-       edac_pci_delete_instance_kobj(pci, pci->pci_idx);
+       debugf0("%s() index=%d\n", __func__, pci->pci_idx);
 
+       /* Remove the symlink */
        sysfs_remove_link(&pci->kobj, EDAC_PCI_SYMLINK);
 
-       if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0)
-               edac_pci_unregister_main_kobj();
+       /* remove this PCI instance's sysfs entries */
+       edac_pci_unregister_sysfs_instance_kobj(pci);
+
+       /* Call the main unregister function, which will determine
+        * if this 'pci' is the last instance.
+        * If it is, the main kobject will be unregistered as a result
+        */
+       debugf0("%s() calling edac_pci_main_kobj_teardown()\n", __func__);
+       edac_pci_main_kobj_teardown();
 }
 
 /************************ PCI error handling *************************/
@@ -389,7 +533,6 @@ static u16 get_pci_parity_status(struct pci_dev *dev, int secondary)
        return status;
 }
 
-typedef void (*pci_parity_check_fn_t) (struct pci_dev *dev);
 
 /* Clear any PCI parity errors logged by this device. */
 static void edac_pci_dev_parity_clear(struct pci_dev *dev)
@@ -408,20 +551,33 @@ static void edac_pci_dev_parity_clear(struct pci_dev *dev)
 /*
  *  PCI Parity polling
  *
+ *     Fucntion to retrieve the current parity status
+ *     and decode it
+ *
  */
 static void edac_pci_dev_parity_test(struct pci_dev *dev)
 {
+       unsigned long flags;
        u16 status;
-       u8  header_type;
+       u8 header_type;
 
-       /* read the STATUS register on this device
-        */
+       /* stop any interrupts until we can acquire the status */
+       local_irq_save(flags);
+
+       /* read the STATUS register on this device */
        status = get_pci_parity_status(dev, 0);
 
-       debugf2("PCI STATUS= 0x%04x %s\n", status, dev->dev.bus_id );
+       /* read the device TYPE, looking for bridges */
+       pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
+
+       local_irq_restore(flags);
+
+       debugf4("PCI STATUS= 0x%04x %s\n", status, dev_name(&dev->dev));
 
-       /* check the status reg for errors */
-       if (status) {
+       /* check the status reg for errors on boards NOT marked as broken
+        * if broken, we cannot trust any of the status bits
+        */
+       if (status && !dev->broken_parity_status) {
                if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
                        edac_printk(KERN_CRIT, EDAC_PCI,
                                "Signaled System Error on %s\n",
@@ -446,20 +602,19 @@ static void edac_pci_dev_parity_test(struct pci_dev *dev)
                }
        }
 
-       /* read the device TYPE, looking for bridges */
-       pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
 
-       debugf2("PCI HEADER TYPE= 0x%02x %s\n", header_type, dev->dev.bus_id );
+       debugf4("PCI HEADER TYPE= 0x%02x %s\n", header_type, dev_name(&dev->dev));
 
        if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
                /* On bridges, need to examine secondary status register  */
                status = get_pci_parity_status(dev, 1);
 
-               debugf2("PCI SEC_STATUS= 0x%04x %s\n",
-                               status, dev->dev.bus_id );
+               debugf4("PCI SEC_STATUS= 0x%04x %s\n", status, dev_name(&dev->dev));
 
-               /* check the secondary status reg for errors */
-               if (status) {
+               /* check the secondary status reg for errors,
+                * on NOT broken boards
+                */
+               if (status && !dev->broken_parity_status) {
                        if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
                                edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
                                        "Signaled System Error on %s\n",
@@ -486,9 +641,12 @@ static void edac_pci_dev_parity_test(struct pci_dev *dev)
        }
 }
 
+/* reduce some complexity in definition of the iterator */
+typedef void (*pci_parity_check_fn_t) (struct pci_dev *dev);
+
 /*
  * pci_dev parity list iterator
- *     Scan the PCI device list for one iteration, looking for SERRORs
+ *     Scan the PCI device list for one pass, looking for SERRORs
  *     Master Parity ERRORS or Parity ERRORs on primary or secondary devices
  */
 static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn)
@@ -499,7 +657,7 @@ static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn)
         * and while we are looking at it have its reference count
         * bumped until we are done with it
         */
-       while((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
+       while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
                fn(dev);
        }
 }
@@ -511,31 +669,37 @@ static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn)
  */
 void edac_pci_do_parity_check(void)
 {
-       unsigned long flags;
        int before_count;
 
        debugf3("%s()\n", __func__);
 
+       /* if policy has PCI check off, leave now */
        if (!check_pci_errors)
                return;
 
        before_count = atomic_read(&pci_parity_count);
 
        /* scan all PCI devices looking for a Parity Error on devices and
-        * bridges
+        * bridges.
+        * The iterator calls pci_get_device() which might sleep, thus
+        * we cannot disable interrupts in this scan.
         */
-       local_irq_save(flags);
        edac_pci_dev_parity_iterator(edac_pci_dev_parity_test);
-       local_irq_restore(flags);
 
        /* Only if operator has selected panic on PCI Error */
-       if (panic_on_pci_parity) {
+       if (edac_pci_get_panic_on_pe()) {
                /* If the count is different 'after' from 'before' */
                if (before_count != atomic_read(&pci_parity_count))
                        panic("EDAC: PCI Parity Error");
        }
 }
 
+/*
+ * edac_pci_clear_parity_errors
+ *
+ *     function to perform an iteration over the PCI devices
+ *     and clearn their current status
+ */
 void edac_pci_clear_parity_errors(void)
 {
        /* Clear any PCI bus parity errors that devices initially have logged
@@ -543,13 +707,19 @@ void edac_pci_clear_parity_errors(void)
         */
        edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear);
 }
+
+/*
+ * edac_pci_handle_pe
+ *
+ *     Called to handle a PARITY ERROR event
+ */
 void edac_pci_handle_pe(struct edac_pci_ctl_info *pci, const char *msg)
 {
 
        /* global PE counter incremented by edac_pci_do_parity_check() */
        atomic_inc(&pci->counters.pe_count);
 
-       if (log_pci_errs)
+       if (edac_pci_get_log_pe())
                edac_pci_printk(pci, KERN_WARNING,
                                "Parity Error ctl: %s %d: %s\n",
                                pci->ctl_name, pci->pci_idx, msg);
@@ -562,13 +732,19 @@ void edac_pci_handle_pe(struct edac_pci_ctl_info *pci, const char *msg)
 }
 EXPORT_SYMBOL_GPL(edac_pci_handle_pe);
 
+
+/*
+ * edac_pci_handle_npe
+ *
+ *     Called to handle a NON-PARITY ERROR event
+ */
 void edac_pci_handle_npe(struct edac_pci_ctl_info *pci, const char *msg)
 {
 
        /* global NPE counter incremented by edac_pci_do_parity_check() */
        atomic_inc(&pci->counters.npe_count);
 
-       if (log_pci_errs)
+       if (edac_pci_get_log_npe())
                edac_pci_printk(pci, KERN_WARNING,
                                "Non-Parity Error ctl: %s %d: %s\n",
                                pci->ctl_name, pci->pci_idx, msg);
@@ -585,8 +761,10 @@ EXPORT_SYMBOL_GPL(edac_pci_handle_npe);
  * Define the PCI parameter to the module
  */
 module_param(check_pci_errors, int, 0644);
-MODULE_PARM_DESC(check_pci_errors, "Check for PCI bus parity errors: 0=off 1=on");
-module_param(panic_on_pci_parity, int, 0644);
-MODULE_PARM_DESC(panic_on_pci_parity, "Panic on PCI Bus Parity error: 0=off 1=on");
+MODULE_PARM_DESC(check_pci_errors,
+                "Check for PCI bus parity errors: 0=off 1=on");
+module_param(edac_pci_panic_on_pe, int, 0644);
+MODULE_PARM_DESC(edac_pci_panic_on_pe,
+                "Panic on PCI Bus Parity error: 0=off 1=on");
 
-#endif /* CONFIG_PCI */
+#endif                         /* CONFIG_PCI */