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 | |
14cc571b | 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 | ||
1a45027d | 40 | static int edac_pci_get_log_pe(void) |
4de78c68 DJ |
41 | { |
42 | return edac_pci_log_pe; | |
43 | } | |
44 | ||
1a45027d | 45 | static int edac_pci_get_log_npe(void) |
4de78c68 DJ |
46 | { |
47 | return edac_pci_log_npe; | |
48 | } | |
49 | ||
1a45027d | 50 | static int edac_pci_get_panic_on_pe(void) |
4de78c68 DJ |
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 */ | |
14cc571b | 86 | kobject_put(edac_pci_top_main_kobj); |
d4c1465b DT |
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 | ||
d4c1465b DT |
165 | /* First bump the ref count on the top main kobj, which will |
166 | * track the number of PCI instances we have, and thus nest | |
167 | * properly on keeping the module loaded | |
168 | */ | |
14cc571b | 169 | main_kobj = kobject_get(edac_pci_top_main_kobj); |
d4c1465b DT |
170 | if (!main_kobj) { |
171 | err = -ENODEV; | |
172 | goto error_out; | |
173 | } | |
174 | ||
175 | /* And now register this new kobject under the main kobj */ | |
b2ed215a | 176 | err = kobject_init_and_add(&pci->kobj, &ktype_pci_instance, |
14cc571b | 177 | edac_pci_top_main_kobj, "pci%d", idx); |
91b99041 DJ |
178 | if (err != 0) { |
179 | debugf2("%s() failed to register instance pci%d\n", | |
079708b9 | 180 | __func__, idx); |
14cc571b | 181 | kobject_put(edac_pci_top_main_kobj); |
d4c1465b | 182 | goto error_out; |
91b99041 DJ |
183 | } |
184 | ||
b2ed215a | 185 | kobject_uevent(&pci->kobj, KOBJ_ADD); |
91b99041 DJ |
186 | debugf1("%s() Register instance 'pci%d' kobject\n", __func__, idx); |
187 | ||
188 | return 0; | |
d4c1465b DT |
189 | |
190 | /* Error unwind statck */ | |
191 | error_out: | |
192 | return err; | |
91b99041 DJ |
193 | } |
194 | ||
d4c1465b DT |
195 | /* |
196 | * edac_pci_unregister_sysfs_instance_kobj | |
197 | * | |
198 | * unregister the kobj for the EDAC PCI instance | |
199 | */ | |
1a45027d AB |
200 | static void edac_pci_unregister_sysfs_instance_kobj( |
201 | struct edac_pci_ctl_info *pci) | |
91b99041 | 202 | { |
d4c1465b DT |
203 | debugf0("%s()\n", __func__); |
204 | ||
205 | /* Unregister the instance kobject and allow its release | |
206 | * function release the main reference count and then | |
207 | * kfree the memory | |
208 | */ | |
c10997f6 | 209 | kobject_put(&pci->kobj); |
91b99041 DJ |
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) | |
7c9281d7 | 215 | |
d4c1465b | 216 | /* simple show/store functions for attributes */ |
7c9281d7 DT |
217 | static ssize_t edac_pci_int_show(void *ptr, char *buffer) |
218 | { | |
219 | int *value = ptr; | |
079708b9 | 220 | return sprintf(buffer, "%d\n", *value); |
7c9281d7 DT |
221 | } |
222 | ||
223 | static ssize_t edac_pci_int_store(void *ptr, const char *buffer, size_t count) | |
224 | { | |
225 | int *value = ptr; | |
226 | ||
227 | if (isdigit(*buffer)) | |
079708b9 | 228 | *value = simple_strtoul(buffer, NULL, 0); |
7c9281d7 DT |
229 | |
230 | return count; | |
231 | } | |
232 | ||
233 | struct edac_pci_dev_attribute { | |
234 | struct attribute attr; | |
235 | void *value; | |
079708b9 DT |
236 | ssize_t(*show) (void *, char *); |
237 | ssize_t(*store) (void *, const char *, size_t); | |
7c9281d7 DT |
238 | }; |
239 | ||
240 | /* Set of show/store abstract level functions for PCI Parity object */ | |
241 | static ssize_t edac_pci_dev_show(struct kobject *kobj, struct attribute *attr, | |
079708b9 | 242 | char *buffer) |
7c9281d7 DT |
243 | { |
244 | struct edac_pci_dev_attribute *edac_pci_dev; | |
079708b9 | 245 | edac_pci_dev = (struct edac_pci_dev_attribute *)attr; |
7c9281d7 DT |
246 | |
247 | if (edac_pci_dev->show) | |
248 | return edac_pci_dev->show(edac_pci_dev->value, buffer); | |
249 | return -EIO; | |
250 | } | |
251 | ||
252 | static ssize_t edac_pci_dev_store(struct kobject *kobj, | |
052dfb45 DT |
253 | struct attribute *attr, const char *buffer, |
254 | size_t count) | |
7c9281d7 DT |
255 | { |
256 | struct edac_pci_dev_attribute *edac_pci_dev; | |
079708b9 | 257 | edac_pci_dev = (struct edac_pci_dev_attribute *)attr; |
7c9281d7 DT |
258 | |
259 | if (edac_pci_dev->show) | |
260 | return edac_pci_dev->store(edac_pci_dev->value, buffer, count); | |
261 | return -EIO; | |
262 | } | |
263 | ||
264 | static struct sysfs_ops edac_pci_sysfs_ops = { | |
079708b9 DT |
265 | .show = edac_pci_dev_show, |
266 | .store = edac_pci_dev_store | |
7c9281d7 DT |
267 | }; |
268 | ||
269 | #define EDAC_PCI_ATTR(_name,_mode,_show,_store) \ | |
270 | static 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) \ | |
278 | static 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 */ | |
079708b9 | 286 | EDAC_PCI_ATTR(check_pci_errors, S_IRUGO | S_IWUSR, edac_pci_int_show, |
052dfb45 | 287 | edac_pci_int_store); |
079708b9 | 288 | EDAC_PCI_ATTR(edac_pci_log_pe, S_IRUGO | S_IWUSR, edac_pci_int_show, |
052dfb45 | 289 | edac_pci_int_store); |
079708b9 | 290 | EDAC_PCI_ATTR(edac_pci_log_npe, S_IRUGO | S_IWUSR, edac_pci_int_show, |
052dfb45 | 291 | edac_pci_int_store); |
079708b9 | 292 | EDAC_PCI_ATTR(edac_pci_panic_on_pe, S_IRUGO | S_IWUSR, edac_pci_int_show, |
052dfb45 | 293 | edac_pci_int_store); |
7c9281d7 | 294 | EDAC_PCI_ATTR(pci_parity_count, S_IRUGO, edac_pci_int_show, NULL); |
91b99041 | 295 | EDAC_PCI_ATTR(pci_nonparity_count, S_IRUGO, edac_pci_int_show, NULL); |
7c9281d7 DT |
296 | |
297 | /* Base Attributes of the memory ECC object */ | |
298 | static struct edac_pci_dev_attribute *edac_pci_attr[] = { | |
91b99041 | 299 | &edac_pci_attr_check_pci_errors, |
4de78c68 DJ |
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, | |
7c9281d7 | 303 | &edac_pci_attr_pci_parity_count, |
91b99041 | 304 | &edac_pci_attr_pci_nonparity_count, |
7c9281d7 DT |
305 | NULL, |
306 | }; | |
307 | ||
d4c1465b DT |
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 | */ | |
317 | static void edac_pci_release_main_kobj(struct kobject *kobj) | |
7c9281d7 | 318 | { |
d4c1465b | 319 | debugf0("%s() here to module_put(THIS_MODULE)\n", __func__); |
91b99041 | 320 | |
14cc571b AJ |
321 | kfree(kobj); |
322 | ||
d4c1465b DT |
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); | |
7c9281d7 DT |
327 | } |
328 | ||
d4c1465b DT |
329 | /* ktype struct for the EDAC PCI main kobj */ |
330 | static struct kobj_type ktype_edac_pci_main_kobj = { | |
331 | .release = edac_pci_release_main_kobj, | |
7c9281d7 | 332 | .sysfs_ops = &edac_pci_sysfs_ops, |
079708b9 | 333 | .default_attrs = (struct attribute **)edac_pci_attr, |
7c9281d7 DT |
334 | }; |
335 | ||
336 | /** | |
d4c1465b | 337 | * edac_pci_main_kobj_setup() |
7c9281d7 DT |
338 | * |
339 | * setup the sysfs for EDAC PCI attributes | |
340 | * assumes edac_class has already been initialized | |
341 | */ | |
1a45027d | 342 | static int edac_pci_main_kobj_setup(void) |
7c9281d7 DT |
343 | { |
344 | int err; | |
345 | struct sysdev_class *edac_class; | |
346 | ||
d4c1465b DT |
347 | debugf0("%s()\n", __func__); |
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; | |
7c9281d7 | 352 | |
d4c1465b DT |
353 | /* First time, so create the main kobject and its |
354 | * controls and atributes | |
355 | */ | |
7c9281d7 | 356 | edac_class = edac_get_edac_class(); |
91b99041 DJ |
357 | if (edac_class == NULL) { |
358 | debugf1("%s() no edac_class\n", __func__); | |
d4c1465b DT |
359 | err = -ENODEV; |
360 | goto decrement_count_fail; | |
91b99041 | 361 | } |
7c9281d7 | 362 | |
d4c1465b DT |
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 | debugf1("%s() try_module_get() failed\n", __func__); | |
369 | err = -ENODEV; | |
370 | goto decrement_count_fail; | |
371 | } | |
7c9281d7 | 372 | |
14cc571b AJ |
373 | edac_pci_top_main_kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL); |
374 | if (!edac_pci_top_main_kobj) { | |
375 | debugf1("Failed to allocate\n"); | |
376 | err = -ENOMEM; | |
377 | goto kzalloc_fail; | |
378 | } | |
379 | ||
91b99041 | 380 | /* Instanstiate the pci object */ |
14cc571b AJ |
381 | err = kobject_init_and_add(edac_pci_top_main_kobj, |
382 | &ktype_edac_pci_main_kobj, | |
b2ed215a | 383 | &edac_class->kset.kobj, "pci"); |
91b99041 DJ |
384 | if (err) { |
385 | debugf1("Failed to register '.../edac/pci'\n"); | |
b2ed215a | 386 | goto kobject_init_and_add_fail; |
7c9281d7 DT |
387 | } |
388 | ||
d4c1465b DT |
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 | */ | |
14cc571b | 393 | kobject_uevent(edac_pci_top_main_kobj, KOBJ_ADD); |
91b99041 DJ |
394 | debugf1("Registered '.../edac/pci' kobject\n"); |
395 | ||
396 | return 0; | |
d4c1465b DT |
397 | |
398 | /* Error unwind statck */ | |
b2ed215a | 399 | kobject_init_and_add_fail: |
14cc571b AJ |
400 | kfree(edac_pci_top_main_kobj); |
401 | ||
402 | kzalloc_fail: | |
d4c1465b DT |
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) { | |
c10997f6 | 427 | debugf0("%s() called kobject_put on main kobj\n", |
d4c1465b | 428 | __func__); |
14cc571b | 429 | kobject_put(edac_pci_top_main_kobj); |
d4c1465b | 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 | 573 | |
6b09ff9d BB |
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) { | |
91b99041 | 578 | if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) { |
7c9281d7 | 579 | edac_printk(KERN_CRIT, EDAC_PCI, |
052dfb45 DT |
580 | "Signaled System Error on %s\n", |
581 | pci_name(dev)); | |
91b99041 DJ |
582 | atomic_inc(&pci_nonparity_count); |
583 | } | |
7c9281d7 DT |
584 | |
585 | if (status & (PCI_STATUS_PARITY)) { | |
586 | edac_printk(KERN_CRIT, EDAC_PCI, | |
052dfb45 DT |
587 | "Master Data Parity Error on %s\n", |
588 | pci_name(dev)); | |
7c9281d7 DT |
589 | |
590 | atomic_inc(&pci_parity_count); | |
591 | } | |
592 | ||
593 | if (status & (PCI_STATUS_DETECTED_PARITY)) { | |
594 | edac_printk(KERN_CRIT, EDAC_PCI, | |
052dfb45 DT |
595 | "Detected Parity Error on %s\n", |
596 | pci_name(dev)); | |
7c9281d7 DT |
597 | |
598 | atomic_inc(&pci_parity_count); | |
599 | } | |
600 | } | |
601 | ||
7c9281d7 | 602 | |
d4c1465b | 603 | debugf4("PCI HEADER TYPE= 0x%02x %s\n", header_type, dev->dev.bus_id); |
7c9281d7 DT |
604 | |
605 | if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) { | |
606 | /* On bridges, need to examine secondary status register */ | |
607 | status = get_pci_parity_status(dev, 1); | |
608 | ||
d4c1465b | 609 | debugf4("PCI SEC_STATUS= 0x%04x %s\n", status, dev->dev.bus_id); |
7c9281d7 | 610 | |
6b09ff9d BB |
611 | /* check the secondary status reg for errors, |
612 | * on NOT broken boards | |
613 | */ | |
614 | if (status && !dev->broken_parity_status) { | |
91b99041 | 615 | if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) { |
7c9281d7 | 616 | edac_printk(KERN_CRIT, EDAC_PCI, "Bridge " |
052dfb45 DT |
617 | "Signaled System Error on %s\n", |
618 | pci_name(dev)); | |
91b99041 DJ |
619 | atomic_inc(&pci_nonparity_count); |
620 | } | |
7c9281d7 DT |
621 | |
622 | if (status & (PCI_STATUS_PARITY)) { | |
623 | edac_printk(KERN_CRIT, EDAC_PCI, "Bridge " | |
052dfb45 DT |
624 | "Master Data Parity Error on " |
625 | "%s\n", pci_name(dev)); | |
7c9281d7 DT |
626 | |
627 | atomic_inc(&pci_parity_count); | |
628 | } | |
629 | ||
630 | if (status & (PCI_STATUS_DETECTED_PARITY)) { | |
631 | edac_printk(KERN_CRIT, EDAC_PCI, "Bridge " | |
052dfb45 DT |
632 | "Detected Parity Error on %s\n", |
633 | pci_name(dev)); | |
7c9281d7 DT |
634 | |
635 | atomic_inc(&pci_parity_count); | |
636 | } | |
637 | } | |
638 | } | |
639 | } | |
640 | ||
d4c1465b DT |
641 | /* reduce some complexity in definition of the iterator */ |
642 | typedef void (*pci_parity_check_fn_t) (struct pci_dev *dev); | |
643 | ||
7c9281d7 DT |
644 | /* |
645 | * pci_dev parity list iterator | |
d4c1465b | 646 | * Scan the PCI device list for one pass, looking for SERRORs |
7c9281d7 DT |
647 | * Master Parity ERRORS or Parity ERRORs on primary or secondary devices |
648 | */ | |
649 | static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn) | |
650 | { | |
651 | struct pci_dev *dev = NULL; | |
652 | ||
653 | /* request for kernel access to the next PCI device, if any, | |
654 | * and while we are looking at it have its reference count | |
655 | * bumped until we are done with it | |
656 | */ | |
079708b9 | 657 | while ((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) { |
7c9281d7 DT |
658 | fn(dev); |
659 | } | |
660 | } | |
661 | ||
662 | /* | |
663 | * edac_pci_do_parity_check | |
664 | * | |
665 | * performs the actual PCI parity check operation | |
666 | */ | |
667 | void edac_pci_do_parity_check(void) | |
668 | { | |
7c9281d7 DT |
669 | int before_count; |
670 | ||
671 | debugf3("%s()\n", __func__); | |
672 | ||
d4c1465b | 673 | /* if policy has PCI check off, leave now */ |
91b99041 | 674 | if (!check_pci_errors) |
7c9281d7 DT |
675 | return; |
676 | ||
677 | before_count = atomic_read(&pci_parity_count); | |
678 | ||
679 | /* scan all PCI devices looking for a Parity Error on devices and | |
d4c1465b DT |
680 | * bridges. |
681 | * The iterator calls pci_get_device() which might sleep, thus | |
682 | * we cannot disable interrupts in this scan. | |
7c9281d7 | 683 | */ |
7c9281d7 | 684 | edac_pci_dev_parity_iterator(edac_pci_dev_parity_test); |
7c9281d7 DT |
685 | |
686 | /* Only if operator has selected panic on PCI Error */ | |
4de78c68 | 687 | if (edac_pci_get_panic_on_pe()) { |
7c9281d7 DT |
688 | /* If the count is different 'after' from 'before' */ |
689 | if (before_count != atomic_read(&pci_parity_count)) | |
690 | panic("EDAC: PCI Parity Error"); | |
691 | } | |
692 | } | |
693 | ||
d4c1465b DT |
694 | /* |
695 | * edac_pci_clear_parity_errors | |
696 | * | |
697 | * function to perform an iteration over the PCI devices | |
698 | * and clearn their current status | |
699 | */ | |
7c9281d7 DT |
700 | void edac_pci_clear_parity_errors(void) |
701 | { | |
702 | /* Clear any PCI bus parity errors that devices initially have logged | |
703 | * in their registers. | |
704 | */ | |
705 | edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear); | |
706 | } | |
d4c1465b DT |
707 | |
708 | /* | |
709 | * edac_pci_handle_pe | |
710 | * | |
711 | * Called to handle a PARITY ERROR event | |
712 | */ | |
91b99041 DJ |
713 | void edac_pci_handle_pe(struct edac_pci_ctl_info *pci, const char *msg) |
714 | { | |
715 | ||
716 | /* global PE counter incremented by edac_pci_do_parity_check() */ | |
717 | atomic_inc(&pci->counters.pe_count); | |
718 | ||
4de78c68 | 719 | if (edac_pci_get_log_pe()) |
91b99041 DJ |
720 | edac_pci_printk(pci, KERN_WARNING, |
721 | "Parity Error ctl: %s %d: %s\n", | |
722 | pci->ctl_name, pci->pci_idx, msg); | |
723 | ||
724 | /* | |
725 | * poke all PCI devices and see which one is the troublemaker | |
726 | * panic() is called if set | |
727 | */ | |
728 | edac_pci_do_parity_check(); | |
729 | } | |
730 | EXPORT_SYMBOL_GPL(edac_pci_handle_pe); | |
7c9281d7 | 731 | |
d4c1465b DT |
732 | |
733 | /* | |
734 | * edac_pci_handle_npe | |
735 | * | |
736 | * Called to handle a NON-PARITY ERROR event | |
737 | */ | |
91b99041 DJ |
738 | void edac_pci_handle_npe(struct edac_pci_ctl_info *pci, const char *msg) |
739 | { | |
740 | ||
741 | /* global NPE counter incremented by edac_pci_do_parity_check() */ | |
742 | atomic_inc(&pci->counters.npe_count); | |
743 | ||
4de78c68 | 744 | if (edac_pci_get_log_npe()) |
91b99041 DJ |
745 | edac_pci_printk(pci, KERN_WARNING, |
746 | "Non-Parity Error ctl: %s %d: %s\n", | |
747 | pci->ctl_name, pci->pci_idx, msg); | |
748 | ||
749 | /* | |
750 | * poke all PCI devices and see which one is the troublemaker | |
751 | * panic() is called if set | |
752 | */ | |
753 | edac_pci_do_parity_check(); | |
754 | } | |
755 | EXPORT_SYMBOL_GPL(edac_pci_handle_npe); | |
7c9281d7 DT |
756 | |
757 | /* | |
758 | * Define the PCI parameter to the module | |
759 | */ | |
91b99041 | 760 | module_param(check_pci_errors, int, 0644); |
4de78c68 | 761 | MODULE_PARM_DESC(check_pci_errors, |
079708b9 | 762 | "Check for PCI bus parity errors: 0=off 1=on"); |
4de78c68 DJ |
763 | module_param(edac_pci_panic_on_pe, int, 0644); |
764 | MODULE_PARM_DESC(edac_pci_panic_on_pe, | |
079708b9 | 765 | "Panic on PCI Bus Parity error: 0=off 1=on"); |
7c9281d7 | 766 | |
079708b9 | 767 | #endif /* CONFIG_PCI */ |