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