Branch data Line data Source code
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_pci.h"
15 : : #include "edac_module.h"
16 : :
17 : : #define EDAC_PCI_SYMLINK "device"
18 : :
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 */
25 : :
26 : : static atomic_t pci_parity_count = ATOMIC_INIT(0);
27 : : static atomic_t pci_nonparity_count = ATOMIC_INIT(0);
28 : :
29 : : static struct kobject *edac_pci_top_main_kobj;
30 : : static atomic_t edac_pci_sysfs_refcount = ATOMIC_INIT(0);
31 : :
32 : : /* getter functions for the data variables */
33 : 0 : int edac_pci_get_check_errors(void)
34 : : {
35 : 0 : return check_pci_errors;
36 : : }
37 : :
38 : 0 : static int edac_pci_get_log_pe(void)
39 : : {
40 : 0 : return edac_pci_log_pe;
41 : : }
42 : :
43 : 0 : static int edac_pci_get_log_npe(void)
44 : : {
45 : 0 : return edac_pci_log_npe;
46 : : }
47 : :
48 : 0 : static int edac_pci_get_panic_on_pe(void)
49 : : {
50 : 0 : return edac_pci_panic_on_pe;
51 : : }
52 : :
53 : 0 : int edac_pci_get_poll_msec(void)
54 : : {
55 : 0 : return edac_pci_poll_msec;
56 : : }
57 : :
58 : : /**************************** EDAC PCI sysfs instance *******************/
59 : 0 : static ssize_t instance_pe_count_show(struct edac_pci_ctl_info *pci, char *data)
60 : : {
61 : 0 : return sprintf(data, "%u\n", atomic_read(&pci->counters.pe_count));
62 : : }
63 : :
64 : 0 : static ssize_t instance_npe_count_show(struct edac_pci_ctl_info *pci,
65 : : char *data)
66 : : {
67 : 0 : return sprintf(data, "%u\n", atomic_read(&pci->counters.npe_count));
68 : : }
69 : :
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)
72 : :
73 : : /* DEVICE instance kobject release() function */
74 : 0 : static void edac_pci_instance_release(struct kobject *kobj)
75 : : {
76 : 0 : struct edac_pci_ctl_info *pci;
77 : :
78 : 0 : edac_dbg(0, "\n");
79 : :
80 : : /* Form pointer to containing struct, the pci control struct */
81 : 0 : pci = to_instance(kobj);
82 : :
83 : : /* decrement reference count on top main kobj */
84 : 0 : kobject_put(edac_pci_top_main_kobj);
85 : :
86 : 0 : kfree(pci); /* Free the control struct */
87 : 0 : }
88 : :
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);
94 : : };
95 : :
96 : : /* Function to 'show' fields from the edac_pci 'instance' structure */
97 : 0 : static ssize_t edac_pci_instance_show(struct kobject *kobj,
98 : : struct attribute *attr, char *buffer)
99 : : {
100 : 0 : struct edac_pci_ctl_info *pci = to_instance(kobj);
101 : 0 : struct instance_attribute *instance_attr = to_instance_attr(attr);
102 : :
103 [ # # ]: 0 : if (instance_attr->show)
104 : 0 : return instance_attr->show(pci, buffer);
105 : : return -EIO;
106 : : }
107 : :
108 : : /* Function to 'store' fields into the edac_pci 'instance' structure */
109 : 0 : static ssize_t edac_pci_instance_store(struct kobject *kobj,
110 : : struct attribute *attr,
111 : : const char *buffer, size_t count)
112 : : {
113 : 0 : struct edac_pci_ctl_info *pci = to_instance(kobj);
114 : 0 : struct instance_attribute *instance_attr = to_instance_attr(attr);
115 : :
116 [ # # ]: 0 : if (instance_attr->store)
117 : 0 : return instance_attr->store(pci, buffer, count);
118 : : return -EIO;
119 : : }
120 : :
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
125 : : };
126 : :
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, \
132 : : };
133 : :
134 : : INSTANCE_ATTR(pe_count, S_IRUGO, instance_pe_count_show, NULL);
135 : : INSTANCE_ATTR(npe_count, S_IRUGO, instance_npe_count_show, NULL);
136 : :
137 : : /* pci instance attributes */
138 : : static struct instance_attribute *pci_instance_attr[] = {
139 : : &attr_instance_pe_count,
140 : : &attr_instance_npe_count,
141 : : NULL
142 : : };
143 : :
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,
149 : : };
150 : :
151 : : /*
152 : : * edac_pci_create_instance_kobj
153 : : *
154 : : * construct one EDAC PCI instance's kobject for use
155 : : */
156 : 0 : static int edac_pci_create_instance_kobj(struct edac_pci_ctl_info *pci, int idx)
157 : : {
158 : 0 : struct kobject *main_kobj;
159 : 0 : int err;
160 : :
161 : 0 : edac_dbg(0, "\n");
162 : :
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
166 : : */
167 : 0 : main_kobj = kobject_get(edac_pci_top_main_kobj);
168 [ # # ]: 0 : if (!main_kobj) {
169 : 0 : err = -ENODEV;
170 : 0 : goto error_out;
171 : : }
172 : :
173 : : /* And now register this new kobject under the main kobj */
174 : 0 : err = kobject_init_and_add(&pci->kobj, &ktype_pci_instance,
175 : : edac_pci_top_main_kobj, "pci%d", idx);
176 [ # # ]: 0 : if (err != 0) {
177 : 0 : edac_dbg(2, "failed to register instance pci%d\n", idx);
178 : 0 : kobject_put(edac_pci_top_main_kobj);
179 : 0 : goto error_out;
180 : : }
181 : :
182 : 0 : kobject_uevent(&pci->kobj, KOBJ_ADD);
183 : 0 : edac_dbg(1, "Register instance 'pci%d' kobject\n", idx);
184 : :
185 : 0 : return 0;
186 : :
187 : : /* Error unwind statck */
188 : : error_out:
189 : : return err;
190 : : }
191 : :
192 : : /*
193 : : * edac_pci_unregister_sysfs_instance_kobj
194 : : *
195 : : * unregister the kobj for the EDAC PCI instance
196 : : */
197 : 0 : static void edac_pci_unregister_sysfs_instance_kobj(
198 : : struct edac_pci_ctl_info *pci)
199 : : {
200 : 0 : edac_dbg(0, "\n");
201 : :
202 : : /* Unregister the instance kobject and allow its release
203 : : * function release the main reference count and then
204 : : * kfree the memory
205 : : */
206 : 0 : kobject_put(&pci->kobj);
207 : 0 : }
208 : :
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)
212 : :
213 : : /* simple show/store functions for attributes */
214 : 0 : static ssize_t edac_pci_int_show(void *ptr, char *buffer)
215 : : {
216 : 0 : int *value = ptr;
217 : 0 : return sprintf(buffer, "%d\n", *value);
218 : : }
219 : :
220 : 0 : static ssize_t edac_pci_int_store(void *ptr, const char *buffer, size_t count)
221 : : {
222 : 0 : int *value = ptr;
223 : :
224 [ # # ]: 0 : if (isdigit(*buffer))
225 : 0 : *value = simple_strtoul(buffer, NULL, 0);
226 : :
227 : 0 : return count;
228 : : }
229 : :
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);
235 : : };
236 : :
237 : : /* Set of show/store abstract level functions for PCI Parity object */
238 : 0 : static ssize_t edac_pci_dev_show(struct kobject *kobj, struct attribute *attr,
239 : : char *buffer)
240 : : {
241 : 0 : struct edac_pci_dev_attribute *edac_pci_dev;
242 : 0 : edac_pci_dev = (struct edac_pci_dev_attribute *)attr;
243 : :
244 [ # # ]: 0 : if (edac_pci_dev->show)
245 : 0 : return edac_pci_dev->show(edac_pci_dev->value, buffer);
246 : : return -EIO;
247 : : }
248 : :
249 : 0 : static ssize_t edac_pci_dev_store(struct kobject *kobj,
250 : : struct attribute *attr, const char *buffer,
251 : : size_t count)
252 : : {
253 : 0 : struct edac_pci_dev_attribute *edac_pci_dev;
254 : 0 : edac_pci_dev = (struct edac_pci_dev_attribute *)attr;
255 : :
256 [ # # ]: 0 : if (edac_pci_dev->store)
257 : 0 : return edac_pci_dev->store(edac_pci_dev->value, buffer, count);
258 : : return -EIO;
259 : : }
260 : :
261 : : static const struct sysfs_ops edac_pci_sysfs_ops = {
262 : : .show = edac_pci_dev_show,
263 : : .store = edac_pci_dev_store
264 : : };
265 : :
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, \
272 : : };
273 : :
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, \
280 : : };
281 : :
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);
293 : :
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,
303 : : };
304 : :
305 : : /*
306 : : * edac_pci_release_main_kobj
307 : : *
308 : : * This release function is called when the reference count to the
309 : : * passed kobj goes to zero.
310 : : *
311 : : * This kobj is the 'main' kobject that EDAC PCI instances
312 : : * link to, and thus provide for proper nesting counts
313 : : */
314 : 0 : static void edac_pci_release_main_kobj(struct kobject *kobj)
315 : : {
316 : 0 : edac_dbg(0, "here to module_put(THIS_MODULE)\n");
317 : :
318 : 0 : kfree(kobj);
319 : :
320 : : /* last reference to top EDAC PCI kobject has been removed,
321 : : * NOW release our ref count on the core module
322 : : */
323 : 0 : module_put(THIS_MODULE);
324 : 0 : }
325 : :
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,
331 : : };
332 : :
333 : : /**
334 : : * edac_pci_main_kobj_setup: Setup the sysfs for EDAC PCI attributes.
335 : : */
336 : 0 : static int edac_pci_main_kobj_setup(void)
337 : : {
338 : 0 : int err;
339 : 0 : struct bus_type *edac_subsys;
340 : :
341 : 0 : edac_dbg(0, "\n");
342 : :
343 : : /* check and count if we have already created the main kobject */
344 [ # # ]: 0 : if (atomic_inc_return(&edac_pci_sysfs_refcount) != 1)
345 : : return 0;
346 : :
347 : : /* First time, so create the main kobject and its
348 : : * controls and attributes
349 : : */
350 : 0 : edac_subsys = edac_get_sysfs_subsys();
351 : :
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
355 : : */
356 [ # # ]: 0 : if (!try_module_get(THIS_MODULE)) {
357 : 0 : edac_dbg(1, "try_module_get() failed\n");
358 : 0 : err = -ENODEV;
359 : 0 : goto decrement_count_fail;
360 : : }
361 : :
362 : 0 : edac_pci_top_main_kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL);
363 [ # # ]: 0 : if (!edac_pci_top_main_kobj) {
364 : 0 : edac_dbg(1, "Failed to allocate\n");
365 : 0 : err = -ENOMEM;
366 : 0 : goto kzalloc_fail;
367 : : }
368 : :
369 : : /* Instanstiate the pci object */
370 : 0 : err = kobject_init_and_add(edac_pci_top_main_kobj,
371 : : &ktype_edac_pci_main_kobj,
372 : 0 : &edac_subsys->dev_root->kobj, "pci");
373 [ # # ]: 0 : if (err) {
374 : 0 : edac_dbg(1, "Failed to register '.../edac/pci'\n");
375 : 0 : goto kobject_init_and_add_fail;
376 : : }
377 : :
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
381 : : */
382 : 0 : kobject_uevent(edac_pci_top_main_kobj, KOBJ_ADD);
383 : 0 : edac_dbg(1, "Registered '.../edac/pci' kobject\n");
384 : :
385 : 0 : return 0;
386 : :
387 : : /* Error unwind statck */
388 : : kobject_init_and_add_fail:
389 : 0 : kfree(edac_pci_top_main_kobj);
390 : :
391 : 0 : kzalloc_fail:
392 : 0 : module_put(THIS_MODULE);
393 : :
394 : 0 : decrement_count_fail:
395 : : /* if are on this error exit, nothing to tear down */
396 : 0 : atomic_dec(&edac_pci_sysfs_refcount);
397 : :
398 : 0 : return err;
399 : : }
400 : :
401 : : /*
402 : : * edac_pci_main_kobj_teardown()
403 : : *
404 : : * if no longer linked (needed) remove the top level EDAC PCI
405 : : * kobject with its controls and attributes
406 : : */
407 : 0 : static void edac_pci_main_kobj_teardown(void)
408 : : {
409 : 0 : edac_dbg(0, "\n");
410 : :
411 : : /* Decrement the count and only if no more controller instances
412 : : * are connected perform the unregisteration of the top level
413 : : * main kobj
414 : : */
415 [ # # ]: 0 : if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0) {
416 : 0 : edac_dbg(0, "called kobject_put on main kobj\n");
417 : 0 : kobject_put(edac_pci_top_main_kobj);
418 : : }
419 : 0 : }
420 : :
421 : 0 : int edac_pci_create_sysfs(struct edac_pci_ctl_info *pci)
422 : : {
423 : 0 : int err;
424 : 0 : struct kobject *edac_kobj = &pci->kobj;
425 : :
426 : 0 : edac_dbg(0, "idx=%d\n", pci->pci_idx);
427 : :
428 : : /* create the top main EDAC PCI kobject, IF needed */
429 : 0 : err = edac_pci_main_kobj_setup();
430 [ # # ]: 0 : if (err)
431 : : return err;
432 : :
433 : : /* Create this instance's kobject under the MAIN kobject */
434 : 0 : err = edac_pci_create_instance_kobj(pci, pci->pci_idx);
435 [ # # ]: 0 : if (err)
436 : 0 : goto unregister_cleanup;
437 : :
438 : 0 : err = sysfs_create_link(edac_kobj, &pci->dev->kobj, EDAC_PCI_SYMLINK);
439 [ # # ]: 0 : if (err) {
440 : 0 : edac_dbg(0, "sysfs_create_link() returned err= %d\n", err);
441 : 0 : goto symlink_fail;
442 : : }
443 : :
444 : : return 0;
445 : :
446 : : /* Error unwind stack */
447 : : symlink_fail:
448 : 0 : edac_pci_unregister_sysfs_instance_kobj(pci);
449 : :
450 : 0 : unregister_cleanup:
451 : 0 : edac_pci_main_kobj_teardown();
452 : :
453 : 0 : return err;
454 : : }
455 : :
456 : 0 : void edac_pci_remove_sysfs(struct edac_pci_ctl_info *pci)
457 : : {
458 : 0 : edac_dbg(0, "index=%d\n", pci->pci_idx);
459 : :
460 : : /* Remove the symlink */
461 : 0 : sysfs_remove_link(&pci->kobj, EDAC_PCI_SYMLINK);
462 : :
463 : : /* remove this PCI instance's sysfs entries */
464 : 0 : edac_pci_unregister_sysfs_instance_kobj(pci);
465 : :
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
469 : : */
470 : 0 : edac_dbg(0, "calling edac_pci_main_kobj_teardown()\n");
471 : 0 : edac_pci_main_kobj_teardown();
472 : 0 : }
473 : :
474 : : /************************ PCI error handling *************************/
475 : 196 : static u16 get_pci_parity_status(struct pci_dev *dev, int secondary)
476 : : {
477 : 196 : int where;
478 : 196 : u16 status;
479 : :
480 [ + - ]: 196 : where = secondary ? PCI_SEC_STATUS : PCI_STATUS;
481 : 196 : pci_read_config_word(dev, where, &status);
482 : :
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
486 : : */
487 : :
488 [ - + ]: 196 : if (status == 0xFFFF) {
489 : 0 : u32 sanity;
490 : :
491 : 0 : pci_read_config_dword(dev, 0, &sanity);
492 : :
493 [ # # ]: 0 : if (sanity == 0xFFFFFFFF)
494 : 0 : return 0;
495 : : }
496 : :
497 : 196 : status &= PCI_STATUS_DETECTED_PARITY | PCI_STATUS_SIG_SYSTEM_ERROR |
498 : : PCI_STATUS_PARITY;
499 : :
500 [ - + ]: 196 : if (status)
501 : : /* reset only the bits we are interested in */
502 : 0 : pci_write_config_word(dev, where, status);
503 : :
504 : 196 : return status;
505 : : }
506 : :
507 : :
508 : : /* Clear any PCI parity errors logged by this device. */
509 : 196 : static void edac_pci_dev_parity_clear(struct pci_dev *dev)
510 : : {
511 : 196 : u8 header_type;
512 : :
513 : 196 : get_pci_parity_status(dev, 0);
514 : :
515 : : /* read the device TYPE, looking for bridges */
516 : 196 : pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
517 : :
518 [ - + ]: 196 : if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE)
519 : 0 : get_pci_parity_status(dev, 1);
520 : 196 : }
521 : :
522 : : /*
523 : : * PCI Parity polling
524 : : *
525 : : * Function to retrieve the current parity status
526 : : * and decode it
527 : : *
528 : : */
529 : 0 : static void edac_pci_dev_parity_test(struct pci_dev *dev)
530 : : {
531 : 0 : unsigned long flags;
532 : 0 : u16 status;
533 : 0 : u8 header_type;
534 : :
535 : : /* stop any interrupts until we can acquire the status */
536 : 0 : local_irq_save(flags);
537 : :
538 : : /* read the STATUS register on this device */
539 : 0 : status = get_pci_parity_status(dev, 0);
540 : :
541 : : /* read the device TYPE, looking for bridges */
542 : 0 : pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
543 : :
544 : 0 : local_irq_restore(flags);
545 : :
546 : 0 : edac_dbg(4, "PCI STATUS= 0x%04x %s\n", status, dev_name(&dev->dev));
547 : :
548 : : /* check the status reg for errors on boards NOT marked as broken
549 : : * if broken, we cannot trust any of the status bits
550 : : */
551 [ # # # # ]: 0 : if (status && !dev->broken_parity_status) {
552 [ # # ]: 0 : if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
553 [ # # ]: 0 : edac_printk(KERN_CRIT, EDAC_PCI,
554 : : "Signaled System Error on %s\n",
555 : : pci_name(dev));
556 : 0 : atomic_inc(&pci_nonparity_count);
557 : : }
558 : :
559 [ # # ]: 0 : if (status & (PCI_STATUS_PARITY)) {
560 [ # # ]: 0 : edac_printk(KERN_CRIT, EDAC_PCI,
561 : : "Master Data Parity Error on %s\n",
562 : : pci_name(dev));
563 : :
564 : 0 : atomic_inc(&pci_parity_count);
565 : : }
566 : :
567 [ # # ]: 0 : if (status & (PCI_STATUS_DETECTED_PARITY)) {
568 [ # # ]: 0 : edac_printk(KERN_CRIT, EDAC_PCI,
569 : : "Detected Parity Error on %s\n",
570 : : pci_name(dev));
571 : :
572 : 0 : atomic_inc(&pci_parity_count);
573 : : }
574 : : }
575 : :
576 : :
577 : 0 : edac_dbg(4, "PCI HEADER TYPE= 0x%02x %s\n",
578 : : header_type, dev_name(&dev->dev));
579 : :
580 [ # # ]: 0 : if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
581 : : /* On bridges, need to examine secondary status register */
582 : 0 : status = get_pci_parity_status(dev, 1);
583 : :
584 : 0 : edac_dbg(4, "PCI SEC_STATUS= 0x%04x %s\n",
585 : : status, dev_name(&dev->dev));
586 : :
587 : : /* check the secondary status reg for errors,
588 : : * on NOT broken boards
589 : : */
590 [ # # # # ]: 0 : if (status && !dev->broken_parity_status) {
591 [ # # ]: 0 : if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
592 [ # # ]: 0 : edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
593 : : "Signaled System Error on %s\n",
594 : : pci_name(dev));
595 : 0 : atomic_inc(&pci_nonparity_count);
596 : : }
597 : :
598 [ # # ]: 0 : if (status & (PCI_STATUS_PARITY)) {
599 [ # # ]: 0 : edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
600 : : "Master Data Parity Error on "
601 : : "%s\n", pci_name(dev));
602 : :
603 : 0 : atomic_inc(&pci_parity_count);
604 : : }
605 : :
606 [ # # ]: 0 : if (status & (PCI_STATUS_DETECTED_PARITY)) {
607 [ # # ]: 0 : edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
608 : : "Detected Parity Error on %s\n",
609 : : pci_name(dev));
610 : :
611 : 0 : atomic_inc(&pci_parity_count);
612 : : }
613 : : }
614 : : }
615 : 0 : }
616 : :
617 : : /* reduce some complexity in definition of the iterator */
618 : : typedef void (*pci_parity_check_fn_t) (struct pci_dev *dev);
619 : :
620 : : /*
621 : : * pci_dev parity list iterator
622 : : *
623 : : * Scan the PCI device list looking for SERRORs, Master Parity ERRORS or
624 : : * Parity ERRORs on primary or secondary devices.
625 : : */
626 : 28 : static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn)
627 : : {
628 : 28 : struct pci_dev *dev = NULL;
629 : :
630 [ + + ]: 224 : for_each_pci_dev(dev)
631 : 196 : fn(dev);
632 : 28 : }
633 : :
634 : : /*
635 : : * edac_pci_do_parity_check
636 : : *
637 : : * performs the actual PCI parity check operation
638 : : */
639 : 0 : void edac_pci_do_parity_check(void)
640 : : {
641 : 0 : int before_count;
642 : :
643 : 0 : edac_dbg(3, "\n");
644 : :
645 : : /* if policy has PCI check off, leave now */
646 [ # # ]: 0 : if (!check_pci_errors)
647 : : return;
648 : :
649 : 0 : before_count = atomic_read(&pci_parity_count);
650 : :
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.
655 : : */
656 : 0 : edac_pci_dev_parity_iterator(edac_pci_dev_parity_test);
657 : :
658 : : /* Only if operator has selected panic on PCI Error */
659 [ # # ]: 0 : if (edac_pci_get_panic_on_pe()) {
660 : : /* If the count is different 'after' from 'before' */
661 [ # # ]: 0 : if (before_count != atomic_read(&pci_parity_count))
662 : 0 : panic("EDAC: PCI Parity Error");
663 : : }
664 : : }
665 : :
666 : : /*
667 : : * edac_pci_clear_parity_errors
668 : : *
669 : : * function to perform an iteration over the PCI devices
670 : : * and clearn their current status
671 : : */
672 : 28 : void edac_pci_clear_parity_errors(void)
673 : : {
674 : : /* Clear any PCI bus parity errors that devices initially have logged
675 : : * in their registers.
676 : : */
677 : 28 : edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear);
678 : 28 : }
679 : :
680 : : /*
681 : : * edac_pci_handle_pe
682 : : *
683 : : * Called to handle a PARITY ERROR event
684 : : */
685 : 0 : void edac_pci_handle_pe(struct edac_pci_ctl_info *pci, const char *msg)
686 : : {
687 : :
688 : : /* global PE counter incremented by edac_pci_do_parity_check() */
689 : 0 : atomic_inc(&pci->counters.pe_count);
690 : :
691 [ # # ]: 0 : if (edac_pci_get_log_pe())
692 : 0 : edac_pci_printk(pci, KERN_WARNING,
693 : : "Parity Error ctl: %s %d: %s\n",
694 : : pci->ctl_name, pci->pci_idx, msg);
695 : :
696 : : /*
697 : : * poke all PCI devices and see which one is the troublemaker
698 : : * panic() is called if set
699 : : */
700 : 0 : edac_pci_do_parity_check();
701 : 0 : }
702 : : EXPORT_SYMBOL_GPL(edac_pci_handle_pe);
703 : :
704 : :
705 : : /*
706 : : * edac_pci_handle_npe
707 : : *
708 : : * Called to handle a NON-PARITY ERROR event
709 : : */
710 : 0 : void edac_pci_handle_npe(struct edac_pci_ctl_info *pci, const char *msg)
711 : : {
712 : :
713 : : /* global NPE counter incremented by edac_pci_do_parity_check() */
714 : 0 : atomic_inc(&pci->counters.npe_count);
715 : :
716 [ # # ]: 0 : if (edac_pci_get_log_npe())
717 : 0 : edac_pci_printk(pci, KERN_WARNING,
718 : : "Non-Parity Error ctl: %s %d: %s\n",
719 : : pci->ctl_name, pci->pci_idx, msg);
720 : :
721 : : /*
722 : : * poke all PCI devices and see which one is the troublemaker
723 : : * panic() is called if set
724 : : */
725 : 0 : edac_pci_do_parity_check();
726 : 0 : }
727 : : EXPORT_SYMBOL_GPL(edac_pci_handle_npe);
728 : :
729 : : /*
730 : : * Define the PCI parameter to the module
731 : : */
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");
|
