Root/drivers/edac/edac_pci_sysfs.c

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.
5 *
6 * Written Doug Thompson <norsk5@xmission.com>
7 *
8 */
9#include <linux/module.h>
10#include <linux/edac.h>
11#include <linux/slab.h>
12#include <linux/ctype.h>
13
14#include "edac_core.h"
15#include "edac_module.h"
16
17/* Turn off this whole feature if PCI is not configured */
18#ifdef CONFIG_PCI
19
20#define EDAC_PCI_SYMLINK "device"
21
22/* data variables exported via sysfs */
23static int check_pci_errors; /* default NO check PCI parity */
24static int edac_pci_panic_on_pe; /* default NO panic on PCI Parity */
25static int edac_pci_log_pe = 1; /* log PCI parity errors */
26static int edac_pci_log_npe = 1; /* log PCI non-parity error errors */
27static int edac_pci_poll_msec = 1000; /* one second workq period */
28
29static atomic_t pci_parity_count = ATOMIC_INIT(0);
30static atomic_t pci_nonparity_count = ATOMIC_INIT(0);
31
32static struct kobject *edac_pci_top_main_kobj;
33static atomic_t edac_pci_sysfs_refcount = ATOMIC_INIT(0);
34
35/* getter functions for the data variables */
36int edac_pci_get_check_errors(void)
37{
38    return check_pci_errors;
39}
40
41static int edac_pci_get_log_pe(void)
42{
43    return edac_pci_log_pe;
44}
45
46static int edac_pci_get_log_npe(void)
47{
48    return edac_pci_log_npe;
49}
50
51static int edac_pci_get_panic_on_pe(void)
52{
53    return edac_pci_panic_on_pe;
54}
55
56int edac_pci_get_poll_msec(void)
57{
58    return edac_pci_poll_msec;
59}
60
61/**************************** EDAC PCI sysfs instance *******************/
62static ssize_t instance_pe_count_show(struct edac_pci_ctl_info *pci, char *data)
63{
64    return sprintf(data, "%u\n", atomic_read(&pci->counters.pe_count));
65}
66
67static ssize_t instance_npe_count_show(struct edac_pci_ctl_info *pci,
68                char *data)
69{
70    return sprintf(data, "%u\n", atomic_read(&pci->counters.npe_count));
71}
72
73#define to_instance(k) container_of(k, struct edac_pci_ctl_info, kobj)
74#define to_instance_attr(a) container_of(a, struct instance_attribute, attr)
75
76/* DEVICE instance kobject release() function */
77static void edac_pci_instance_release(struct kobject *kobj)
78{
79    struct edac_pci_ctl_info *pci;
80
81    edac_dbg(0, "\n");
82
83    /* Form pointer to containing struct, the pci control struct */
84    pci = to_instance(kobj);
85
86    /* decrement reference count on top main kobj */
87    kobject_put(edac_pci_top_main_kobj);
88
89    kfree(pci); /* Free the control struct */
90}
91
92/* instance specific attribute structure */
93struct instance_attribute {
94    struct attribute attr;
95    ssize_t(*show) (struct edac_pci_ctl_info *, char *);
96    ssize_t(*store) (struct edac_pci_ctl_info *, const char *, size_t);
97};
98
99/* Function to 'show' fields from the edac_pci 'instance' structure */
100static ssize_t edac_pci_instance_show(struct kobject *kobj,
101                struct attribute *attr, char *buffer)
102{
103    struct edac_pci_ctl_info *pci = to_instance(kobj);
104    struct instance_attribute *instance_attr = to_instance_attr(attr);
105
106    if (instance_attr->show)
107        return instance_attr->show(pci, buffer);
108    return -EIO;
109}
110
111/* Function to 'store' fields into the edac_pci 'instance' structure */
112static ssize_t edac_pci_instance_store(struct kobject *kobj,
113                struct attribute *attr,
114                const char *buffer, size_t count)
115{
116    struct edac_pci_ctl_info *pci = to_instance(kobj);
117    struct instance_attribute *instance_attr = to_instance_attr(attr);
118
119    if (instance_attr->store)
120        return instance_attr->store(pci, buffer, count);
121    return -EIO;
122}
123
124/* fs_ops table */
125static const struct sysfs_ops pci_instance_ops = {
126    .show = edac_pci_instance_show,
127    .store = edac_pci_instance_store
128};
129
130#define INSTANCE_ATTR(_name, _mode, _show, _store) \
131static struct instance_attribute attr_instance_##_name = { \
132    .attr = {.name = __stringify(_name), .mode = _mode }, \
133    .show = _show, \
134    .store = _store, \
135};
136
137INSTANCE_ATTR(pe_count, S_IRUGO, instance_pe_count_show, NULL);
138INSTANCE_ATTR(npe_count, S_IRUGO, instance_npe_count_show, NULL);
139
140/* pci instance attributes */
141static struct instance_attribute *pci_instance_attr[] = {
142    &attr_instance_pe_count,
143    &attr_instance_npe_count,
144    NULL
145};
146
147/* the ktype for a pci instance */
148static struct kobj_type ktype_pci_instance = {
149    .release = edac_pci_instance_release,
150    .sysfs_ops = &pci_instance_ops,
151    .default_attrs = (struct attribute **)pci_instance_attr,
152};
153
154/*
155 * edac_pci_create_instance_kobj
156 *
157 * construct one EDAC PCI instance's kobject for use
158 */
159static int edac_pci_create_instance_kobj(struct edac_pci_ctl_info *pci, int idx)
160{
161    struct kobject *main_kobj;
162    int err;
163
164    edac_dbg(0, "\n");
165
166    /* First bump the ref count on the top main kobj, which will
167     * track the number of PCI instances we have, and thus nest
168     * properly on keeping the module loaded
169     */
170    main_kobj = kobject_get(edac_pci_top_main_kobj);
171    if (!main_kobj) {
172        err = -ENODEV;
173        goto error_out;
174    }
175
176    /* And now register this new kobject under the main kobj */
177    err = kobject_init_and_add(&pci->kobj, &ktype_pci_instance,
178                   edac_pci_top_main_kobj, "pci%d", idx);
179    if (err != 0) {
180        edac_dbg(2, "failed to register instance pci%d\n", idx);
181        kobject_put(edac_pci_top_main_kobj);
182        goto error_out;
183    }
184
185    kobject_uevent(&pci->kobj, KOBJ_ADD);
186    edac_dbg(1, "Register instance 'pci%d' kobject\n", idx);
187
188    return 0;
189
190    /* Error unwind statck */
191error_out:
192    return err;
193}
194
195/*
196 * edac_pci_unregister_sysfs_instance_kobj
197 *
198 * unregister the kobj for the EDAC PCI instance
199 */
200static void edac_pci_unregister_sysfs_instance_kobj(
201            struct edac_pci_ctl_info *pci)
202{
203    edac_dbg(0, "\n");
204
205    /* Unregister the instance kobject and allow its release
206     * function release the main reference count and then
207     * kfree the memory
208     */
209    kobject_put(&pci->kobj);
210}
211
212/***************************** EDAC PCI sysfs root **********************/
213#define to_edacpci(k) container_of(k, struct edac_pci_ctl_info, kobj)
214#define to_edacpci_attr(a) container_of(a, struct edac_pci_attr, attr)
215
216/* simple show/store functions for attributes */
217static ssize_t edac_pci_int_show(void *ptr, char *buffer)
218{
219    int *value = ptr;
220    return sprintf(buffer, "%d\n", *value);
221}
222
223static ssize_t edac_pci_int_store(void *ptr, const char *buffer, size_t count)
224{
225    int *value = ptr;
226
227    if (isdigit(*buffer))
228        *value = simple_strtoul(buffer, NULL, 0);
229
230    return count;
231}
232
233struct edac_pci_dev_attribute {
234    struct attribute attr;
235    void *value;
236     ssize_t(*show) (void *, char *);
237     ssize_t(*store) (void *, const char *, size_t);
238};
239
240/* Set of show/store abstract level functions for PCI Parity object */
241static ssize_t edac_pci_dev_show(struct kobject *kobj, struct attribute *attr,
242                 char *buffer)
243{
244    struct edac_pci_dev_attribute *edac_pci_dev;
245    edac_pci_dev = (struct edac_pci_dev_attribute *)attr;
246
247    if (edac_pci_dev->show)
248        return edac_pci_dev->show(edac_pci_dev->value, buffer);
249    return -EIO;
250}
251
252static ssize_t edac_pci_dev_store(struct kobject *kobj,
253                struct attribute *attr, const char *buffer,
254                size_t count)
255{
256    struct edac_pci_dev_attribute *edac_pci_dev;
257    edac_pci_dev = (struct edac_pci_dev_attribute *)attr;
258
259    if (edac_pci_dev->show)
260        return edac_pci_dev->store(edac_pci_dev->value, buffer, count);
261    return -EIO;
262}
263
264static const struct sysfs_ops edac_pci_sysfs_ops = {
265    .show = edac_pci_dev_show,
266    .store = edac_pci_dev_store
267};
268
269#define EDAC_PCI_ATTR(_name,_mode,_show,_store) \
270static struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
271    .attr = {.name = __stringify(_name), .mode = _mode }, \
272    .value = &_name, \
273    .show = _show, \
274    .store = _store, \
275};
276
277#define EDAC_PCI_STRING_ATTR(_name,_data,_mode,_show,_store) \
278static struct edac_pci_dev_attribute edac_pci_attr_##_name = { \
279    .attr = {.name = __stringify(_name), .mode = _mode }, \
280    .value = _data, \
281    .show = _show, \
282    .store = _store, \
283};
284
285/* PCI Parity control files */
286EDAC_PCI_ATTR(check_pci_errors, S_IRUGO | S_IWUSR, edac_pci_int_show,
287    edac_pci_int_store);
288EDAC_PCI_ATTR(edac_pci_log_pe, S_IRUGO | S_IWUSR, edac_pci_int_show,
289    edac_pci_int_store);
290EDAC_PCI_ATTR(edac_pci_log_npe, S_IRUGO | S_IWUSR, edac_pci_int_show,
291    edac_pci_int_store);
292EDAC_PCI_ATTR(edac_pci_panic_on_pe, S_IRUGO | S_IWUSR, edac_pci_int_show,
293    edac_pci_int_store);
294EDAC_PCI_ATTR(pci_parity_count, S_IRUGO, edac_pci_int_show, NULL);
295EDAC_PCI_ATTR(pci_nonparity_count, S_IRUGO, edac_pci_int_show, NULL);
296
297/* Base Attributes of the memory ECC object */
298static struct edac_pci_dev_attribute *edac_pci_attr[] = {
299    &edac_pci_attr_check_pci_errors,
300    &edac_pci_attr_edac_pci_log_pe,
301    &edac_pci_attr_edac_pci_log_npe,
302    &edac_pci_attr_edac_pci_panic_on_pe,
303    &edac_pci_attr_pci_parity_count,
304    &edac_pci_attr_pci_nonparity_count,
305    NULL,
306};
307
308/*
309 * edac_pci_release_main_kobj
310 *
311 * This release function is called when the reference count to the
312 * passed kobj goes to zero.
313 *
314 * This kobj is the 'main' kobject that EDAC PCI instances
315 * link to, and thus provide for proper nesting counts
316 */
317static void edac_pci_release_main_kobj(struct kobject *kobj)
318{
319    edac_dbg(0, "here to module_put(THIS_MODULE)\n");
320
321    kfree(kobj);
322
323    /* last reference to top EDAC PCI kobject has been removed,
324     * NOW release our ref count on the core module
325     */
326    module_put(THIS_MODULE);
327}
328
329/* ktype struct for the EDAC PCI main kobj */
330static struct kobj_type ktype_edac_pci_main_kobj = {
331    .release = edac_pci_release_main_kobj,
332    .sysfs_ops = &edac_pci_sysfs_ops,
333    .default_attrs = (struct attribute **)edac_pci_attr,
334};
335
336/**
337 * edac_pci_main_kobj_setup()
338 *
339 * setup the sysfs for EDAC PCI attributes
340 * assumes edac_subsys has already been initialized
341 */
342static int edac_pci_main_kobj_setup(void)
343{
344    int err;
345    struct bus_type *edac_subsys;
346
347    edac_dbg(0, "\n");
348
349    /* check and count if we have already created the main kobject */
350    if (atomic_inc_return(&edac_pci_sysfs_refcount) != 1)
351        return 0;
352
353    /* First time, so create the main kobject and its
354     * controls and attributes
355     */
356    edac_subsys = edac_get_sysfs_subsys();
357    if (edac_subsys == NULL) {
358        edac_dbg(1, "no edac_subsys\n");
359        err = -ENODEV;
360        goto decrement_count_fail;
361    }
362
363    /* Bump the reference count on this module to ensure the
364     * modules isn't unloaded until we deconstruct the top
365     * level main kobj for EDAC PCI
366     */
367    if (!try_module_get(THIS_MODULE)) {
368        edac_dbg(1, "try_module_get() failed\n");
369        err = -ENODEV;
370        goto mod_get_fail;
371    }
372
373    edac_pci_top_main_kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL);
374    if (!edac_pci_top_main_kobj) {
375        edac_dbg(1, "Failed to allocate\n");
376        err = -ENOMEM;
377        goto kzalloc_fail;
378    }
379
380    /* Instanstiate the pci object */
381    err = kobject_init_and_add(edac_pci_top_main_kobj,
382                   &ktype_edac_pci_main_kobj,
383                   &edac_subsys->dev_root->kobj, "pci");
384    if (err) {
385        edac_dbg(1, "Failed to register '.../edac/pci'\n");
386        goto kobject_init_and_add_fail;
387    }
388
389    /* At this point, to 'release' the top level kobject
390     * for EDAC PCI, then edac_pci_main_kobj_teardown()
391     * must be used, for resources to be cleaned up properly
392     */
393    kobject_uevent(edac_pci_top_main_kobj, KOBJ_ADD);
394    edac_dbg(1, "Registered '.../edac/pci' kobject\n");
395
396    return 0;
397
398    /* Error unwind statck */
399kobject_init_and_add_fail:
400    kfree(edac_pci_top_main_kobj);
401
402kzalloc_fail:
403    module_put(THIS_MODULE);
404
405mod_get_fail:
406    edac_put_sysfs_subsys();
407
408decrement_count_fail:
409    /* if are on this error exit, nothing to tear down */
410    atomic_dec(&edac_pci_sysfs_refcount);
411
412    return err;
413}
414
415/*
416 * edac_pci_main_kobj_teardown()
417 *
418 * if no longer linked (needed) remove the top level EDAC PCI
419 * kobject with its controls and attributes
420 */
421static void edac_pci_main_kobj_teardown(void)
422{
423    edac_dbg(0, "\n");
424
425    /* Decrement the count and only if no more controller instances
426     * are connected perform the unregisteration of the top level
427     * main kobj
428     */
429    if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0) {
430        edac_dbg(0, "called kobject_put on main kobj\n");
431        kobject_put(edac_pci_top_main_kobj);
432    }
433    edac_put_sysfs_subsys();
434}
435
436/*
437 *
438 * edac_pci_create_sysfs
439 *
440 * Create the controls/attributes for the specified EDAC PCI device
441 */
442int edac_pci_create_sysfs(struct edac_pci_ctl_info *pci)
443{
444    int err;
445    struct kobject *edac_kobj = &pci->kobj;
446
447    edac_dbg(0, "idx=%d\n", pci->pci_idx);
448
449    /* create the top main EDAC PCI kobject, IF needed */
450    err = edac_pci_main_kobj_setup();
451    if (err)
452        return err;
453
454    /* Create this instance's kobject under the MAIN kobject */
455    err = edac_pci_create_instance_kobj(pci, pci->pci_idx);
456    if (err)
457        goto unregister_cleanup;
458
459    err = sysfs_create_link(edac_kobj, &pci->dev->kobj, EDAC_PCI_SYMLINK);
460    if (err) {
461        edac_dbg(0, "sysfs_create_link() returned err= %d\n", err);
462        goto symlink_fail;
463    }
464
465    return 0;
466
467    /* Error unwind stack */
468symlink_fail:
469    edac_pci_unregister_sysfs_instance_kobj(pci);
470
471unregister_cleanup:
472    edac_pci_main_kobj_teardown();
473
474    return err;
475}
476
477/*
478 * edac_pci_remove_sysfs
479 *
480 * remove the controls and attributes for this EDAC PCI device
481 */
482void edac_pci_remove_sysfs(struct edac_pci_ctl_info *pci)
483{
484    edac_dbg(0, "index=%d\n", pci->pci_idx);
485
486    /* Remove the symlink */
487    sysfs_remove_link(&pci->kobj, EDAC_PCI_SYMLINK);
488
489    /* remove this PCI instance's sysfs entries */
490    edac_pci_unregister_sysfs_instance_kobj(pci);
491
492    /* Call the main unregister function, which will determine
493     * if this 'pci' is the last instance.
494     * If it is, the main kobject will be unregistered as a result
495     */
496    edac_dbg(0, "calling edac_pci_main_kobj_teardown()\n");
497    edac_pci_main_kobj_teardown();
498}
499
500/************************ PCI error handling *************************/
501static u16 get_pci_parity_status(struct pci_dev *dev, int secondary)
502{
503    int where;
504    u16 status;
505
506    where = secondary ? PCI_SEC_STATUS : PCI_STATUS;
507    pci_read_config_word(dev, where, &status);
508
509    /* If we get back 0xFFFF then we must suspect that the card has been
510     * pulled but the Linux PCI layer has not yet finished cleaning up.
511     * We don't want to report on such devices
512     */
513
514    if (status == 0xFFFF) {
515        u32 sanity;
516
517        pci_read_config_dword(dev, 0, &sanity);
518
519        if (sanity == 0xFFFFFFFF)
520            return 0;
521    }
522
523    status &= PCI_STATUS_DETECTED_PARITY | PCI_STATUS_SIG_SYSTEM_ERROR |
524        PCI_STATUS_PARITY;
525
526    if (status)
527        /* reset only the bits we are interested in */
528        pci_write_config_word(dev, where, status);
529
530    return status;
531}
532
533
534/* Clear any PCI parity errors logged by this device. */
535static void edac_pci_dev_parity_clear(struct pci_dev *dev)
536{
537    u8 header_type;
538
539    get_pci_parity_status(dev, 0);
540
541    /* read the device TYPE, looking for bridges */
542    pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
543
544    if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE)
545        get_pci_parity_status(dev, 1);
546}
547
548/*
549 * PCI Parity polling
550 *
551 * Function to retrieve the current parity status
552 * and decode it
553 *
554 */
555static void edac_pci_dev_parity_test(struct pci_dev *dev)
556{
557    unsigned long flags;
558    u16 status;
559    u8 header_type;
560
561    /* stop any interrupts until we can acquire the status */
562    local_irq_save(flags);
563
564    /* read the STATUS register on this device */
565    status = get_pci_parity_status(dev, 0);
566
567    /* read the device TYPE, looking for bridges */
568    pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
569
570    local_irq_restore(flags);
571
572    edac_dbg(4, "PCI STATUS= 0x%04x %s\n", status, dev_name(&dev->dev));
573
574    /* check the status reg for errors on boards NOT marked as broken
575     * if broken, we cannot trust any of the status bits
576     */
577    if (status && !dev->broken_parity_status) {
578        if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
579            edac_printk(KERN_CRIT, EDAC_PCI,
580                "Signaled System Error on %s\n",
581                pci_name(dev));
582            atomic_inc(&pci_nonparity_count);
583        }
584
585        if (status & (PCI_STATUS_PARITY)) {
586            edac_printk(KERN_CRIT, EDAC_PCI,
587                "Master Data Parity Error on %s\n",
588                pci_name(dev));
589
590            atomic_inc(&pci_parity_count);
591        }
592
593        if (status & (PCI_STATUS_DETECTED_PARITY)) {
594            edac_printk(KERN_CRIT, EDAC_PCI,
595                "Detected Parity Error on %s\n",
596                pci_name(dev));
597
598            atomic_inc(&pci_parity_count);
599        }
600    }
601
602
603    edac_dbg(4, "PCI HEADER TYPE= 0x%02x %s\n",
604         header_type, dev_name(&dev->dev));
605
606    if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
607        /* On bridges, need to examine secondary status register */
608        status = get_pci_parity_status(dev, 1);
609
610        edac_dbg(4, "PCI SEC_STATUS= 0x%04x %s\n",
611             status, dev_name(&dev->dev));
612
613        /* check the secondary status reg for errors,
614         * on NOT broken boards
615         */
616        if (status && !dev->broken_parity_status) {
617            if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
618                edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
619                    "Signaled System Error on %s\n",
620                    pci_name(dev));
621                atomic_inc(&pci_nonparity_count);
622            }
623
624            if (status & (PCI_STATUS_PARITY)) {
625                edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
626                    "Master Data Parity Error on "
627                    "%s\n", pci_name(dev));
628
629                atomic_inc(&pci_parity_count);
630            }
631
632            if (status & (PCI_STATUS_DETECTED_PARITY)) {
633                edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
634                    "Detected Parity Error on %s\n",
635                    pci_name(dev));
636
637                atomic_inc(&pci_parity_count);
638            }
639        }
640    }
641}
642
643/* reduce some complexity in definition of the iterator */
644typedef void (*pci_parity_check_fn_t) (struct pci_dev *dev);
645
646/*
647 * pci_dev parity list iterator
648 * Scan the PCI device list for one pass, looking for SERRORs
649 * Master Parity ERRORS or Parity ERRORs on primary or secondary devices
650 */
651static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn)
652{
653    struct pci_dev *dev = NULL;
654
655    /* request for kernel access to the next PCI device, if any,
656     * and while we are looking at it have its reference count
657     * bumped until we are done with it
658     */
659    while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
660        fn(dev);
661    }
662}
663
664/*
665 * edac_pci_do_parity_check
666 *
667 * performs the actual PCI parity check operation
668 */
669void edac_pci_do_parity_check(void)
670{
671    int before_count;
672
673    edac_dbg(3, "\n");
674
675    /* if policy has PCI check off, leave now */
676    if (!check_pci_errors)
677        return;
678
679    before_count = atomic_read(&pci_parity_count);
680
681    /* scan all PCI devices looking for a Parity Error on devices and
682     * bridges.
683     * The iterator calls pci_get_device() which might sleep, thus
684     * we cannot disable interrupts in this scan.
685     */
686    edac_pci_dev_parity_iterator(edac_pci_dev_parity_test);
687
688    /* Only if operator has selected panic on PCI Error */
689    if (edac_pci_get_panic_on_pe()) {
690        /* If the count is different 'after' from 'before' */
691        if (before_count != atomic_read(&pci_parity_count))
692            panic("EDAC: PCI Parity Error");
693    }
694}
695
696/*
697 * edac_pci_clear_parity_errors
698 *
699 * function to perform an iteration over the PCI devices
700 * and clearn their current status
701 */
702void edac_pci_clear_parity_errors(void)
703{
704    /* Clear any PCI bus parity errors that devices initially have logged
705     * in their registers.
706     */
707    edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear);
708}
709
710/*
711 * edac_pci_handle_pe
712 *
713 * Called to handle a PARITY ERROR event
714 */
715void edac_pci_handle_pe(struct edac_pci_ctl_info *pci, const char *msg)
716{
717
718    /* global PE counter incremented by edac_pci_do_parity_check() */
719    atomic_inc(&pci->counters.pe_count);
720
721    if (edac_pci_get_log_pe())
722        edac_pci_printk(pci, KERN_WARNING,
723                "Parity Error ctl: %s %d: %s\n",
724                pci->ctl_name, pci->pci_idx, msg);
725
726    /*
727     * poke all PCI devices and see which one is the troublemaker
728     * panic() is called if set
729     */
730    edac_pci_do_parity_check();
731}
732EXPORT_SYMBOL_GPL(edac_pci_handle_pe);
733
734
735/*
736 * edac_pci_handle_npe
737 *
738 * Called to handle a NON-PARITY ERROR event
739 */
740void edac_pci_handle_npe(struct edac_pci_ctl_info *pci, const char *msg)
741{
742
743    /* global NPE counter incremented by edac_pci_do_parity_check() */
744    atomic_inc(&pci->counters.npe_count);
745
746    if (edac_pci_get_log_npe())
747        edac_pci_printk(pci, KERN_WARNING,
748                "Non-Parity Error ctl: %s %d: %s\n",
749                pci->ctl_name, pci->pci_idx, msg);
750
751    /*
752     * poke all PCI devices and see which one is the troublemaker
753     * panic() is called if set
754     */
755    edac_pci_do_parity_check();
756}
757EXPORT_SYMBOL_GPL(edac_pci_handle_npe);
758
759/*
760 * Define the PCI parameter to the module
761 */
762module_param(check_pci_errors, int, 0644);
763MODULE_PARM_DESC(check_pci_errors,
764         "Check for PCI bus parity errors: 0=off 1=on");
765module_param(edac_pci_panic_on_pe, int, 0644);
766MODULE_PARM_DESC(edac_pci_panic_on_pe,
767         "Panic on PCI Bus Parity error: 0=off 1=on");
768
769#endif /* CONFIG_PCI */
770

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive