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> | |
30e1f7a8 | 10 | #include <linux/edac.h> |
5a0e3ad6 | 11 | #include <linux/slab.h> |
7c9281d7 DT |
12 | #include <linux/ctype.h> |
13 | ||
20bcb7a8 | 14 | #include "edac_core.h" |
7c9281d7 DT |
15 | #include "edac_module.h" |
16 | ||
d4c1465b | 17 | /* Turn off this whole feature if PCI is not configured */ |
7c9281d7 | 18 | #ifdef CONFIG_PCI |
91b99041 DJ |
19 | |
20 | #define EDAC_PCI_SYMLINK "device" | |
21 | ||
d4c1465b DT |
22 | /* data variables exported via sysfs */ |
23 | static int check_pci_errors; /* default NO check PCI parity */ | |
24 | static int edac_pci_panic_on_pe; /* default NO panic on PCI Parity */ | |
25 | static int edac_pci_log_pe = 1; /* log PCI parity errors */ | |
4de78c68 | 26 | static int edac_pci_log_npe = 1; /* log PCI non-parity error errors */ |
d4c1465b DT |
27 | static int edac_pci_poll_msec = 1000; /* one second workq period */ |
28 | ||
7c9281d7 | 29 | static atomic_t pci_parity_count = ATOMIC_INIT(0); |
91b99041 | 30 | static atomic_t pci_nonparity_count = ATOMIC_INIT(0); |
7c9281d7 | 31 | |
14cc571b | 32 | static struct kobject *edac_pci_top_main_kobj; |
91b99041 DJ |
33 | static atomic_t edac_pci_sysfs_refcount = ATOMIC_INIT(0); |
34 | ||
d4c1465b | 35 | /* getter functions for the data variables */ |
4de78c68 DJ |
36 | int edac_pci_get_check_errors(void) |
37 | { | |
38 | return check_pci_errors; | |
39 | } | |
40 | ||
1a45027d | 41 | static int edac_pci_get_log_pe(void) |
4de78c68 DJ |
42 | { |
43 | return edac_pci_log_pe; | |
44 | } | |
45 | ||
1a45027d | 46 | static int edac_pci_get_log_npe(void) |
4de78c68 DJ |
47 | { |
48 | return edac_pci_log_npe; | |
49 | } | |
50 | ||
1a45027d | 51 | static int edac_pci_get_panic_on_pe(void) |
4de78c68 DJ |
52 | { |
53 | return edac_pci_panic_on_pe; | |
54 | } | |
55 | ||
56 | int edac_pci_get_poll_msec(void) | |
57 | { | |
58 | return edac_pci_poll_msec; | |
59 | } | |
60 | ||
91b99041 DJ |
61 | /**************************** EDAC PCI sysfs instance *******************/ |
62 | static ssize_t instance_pe_count_show(struct edac_pci_ctl_info *pci, char *data) | |
63 | { | |
079708b9 | 64 | return sprintf(data, "%u\n", atomic_read(&pci->counters.pe_count)); |
91b99041 DJ |
65 | } |
66 | ||
67 | static ssize_t instance_npe_count_show(struct edac_pci_ctl_info *pci, | |
052dfb45 | 68 | char *data) |
91b99041 | 69 | { |
079708b9 | 70 | return sprintf(data, "%u\n", atomic_read(&pci->counters.npe_count)); |
91b99041 DJ |
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 */ | |
77 | static void edac_pci_instance_release(struct kobject *kobj) | |
78 | { | |
79 | struct edac_pci_ctl_info *pci; | |
80 | ||
956b9ba1 | 81 | edac_dbg(0, "\n"); |
91b99041 | 82 | |
d4c1465b | 83 | /* Form pointer to containing struct, the pci control struct */ |
91b99041 | 84 | pci = to_instance(kobj); |
d4c1465b DT |
85 | |
86 | /* decrement reference count on top main kobj */ | |
14cc571b | 87 | kobject_put(edac_pci_top_main_kobj); |
d4c1465b DT |
88 | |
89 | kfree(pci); /* Free the control struct */ | |
91b99041 DJ |
90 | } |
91 | ||
92 | /* instance specific attribute structure */ | |
93 | struct instance_attribute { | |
079708b9 | 94 | struct attribute attr; |
d4c1465b DT |
95 | ssize_t(*show) (struct edac_pci_ctl_info *, char *); |
96 | ssize_t(*store) (struct edac_pci_ctl_info *, const char *, size_t); | |
91b99041 DJ |
97 | }; |
98 | ||
99 | /* Function to 'show' fields from the edac_pci 'instance' structure */ | |
100 | static ssize_t edac_pci_instance_show(struct kobject *kobj, | |
052dfb45 | 101 | struct attribute *attr, char *buffer) |
91b99041 | 102 | { |
079708b9 DT |
103 | struct edac_pci_ctl_info *pci = to_instance(kobj); |
104 | struct instance_attribute *instance_attr = to_instance_attr(attr); | |
91b99041 | 105 | |
079708b9 DT |
106 | if (instance_attr->show) |
107 | return instance_attr->show(pci, buffer); | |
108 | return -EIO; | |
91b99041 DJ |
109 | } |
110 | ||
91b99041 DJ |
111 | /* Function to 'store' fields into the edac_pci 'instance' structure */ |
112 | static ssize_t edac_pci_instance_store(struct kobject *kobj, | |
052dfb45 DT |
113 | struct attribute *attr, |
114 | const char *buffer, size_t count) | |
91b99041 | 115 | { |
079708b9 DT |
116 | struct edac_pci_ctl_info *pci = to_instance(kobj); |
117 | struct instance_attribute *instance_attr = to_instance_attr(attr); | |
91b99041 | 118 | |
079708b9 DT |
119 | if (instance_attr->store) |
120 | return instance_attr->store(pci, buffer, count); | |
121 | return -EIO; | |
91b99041 DJ |
122 | } |
123 | ||
d4c1465b | 124 | /* fs_ops table */ |
52cf25d0 | 125 | static const struct sysfs_ops pci_instance_ops = { |
91b99041 DJ |
126 | .show = edac_pci_instance_show, |
127 | .store = edac_pci_instance_store | |
128 | }; | |
129 | ||
130 | #define INSTANCE_ATTR(_name, _mode, _show, _store) \ | |
131 | static struct instance_attribute attr_instance_##_name = { \ | |
132 | .attr = {.name = __stringify(_name), .mode = _mode }, \ | |
133 | .show = _show, \ | |
134 | .store = _store, \ | |
135 | }; | |
136 | ||
137 | INSTANCE_ATTR(pe_count, S_IRUGO, instance_pe_count_show, NULL); | |
138 | INSTANCE_ATTR(npe_count, S_IRUGO, instance_npe_count_show, NULL); | |
139 | ||
140 | /* pci instance attributes */ | |
141 | static struct instance_attribute *pci_instance_attr[] = { | |
142 | &attr_instance_pe_count, | |
143 | &attr_instance_npe_count, | |
144 | NULL | |
145 | }; | |
7c9281d7 | 146 | |
d4c1465b | 147 | /* the ktype for a pci instance */ |
91b99041 DJ |
148 | static 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 | ||
d4c1465b DT |
154 | /* |
155 | * edac_pci_create_instance_kobj | |
156 | * | |
157 | * construct one EDAC PCI instance's kobject for use | |
158 | */ | |
91b99041 DJ |
159 | static int edac_pci_create_instance_kobj(struct edac_pci_ctl_info *pci, int idx) |
160 | { | |
d4c1465b | 161 | struct kobject *main_kobj; |
91b99041 DJ |
162 | int err; |
163 | ||
956b9ba1 | 164 | edac_dbg(0, "\n"); |
d4c1465b | 165 | |
d4c1465b DT |
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 | */ | |
14cc571b | 170 | main_kobj = kobject_get(edac_pci_top_main_kobj); |
d4c1465b DT |
171 | if (!main_kobj) { |
172 | err = -ENODEV; | |
173 | goto error_out; | |
174 | } | |
175 | ||
176 | /* And now register this new kobject under the main kobj */ | |
b2ed215a | 177 | err = kobject_init_and_add(&pci->kobj, &ktype_pci_instance, |
14cc571b | 178 | edac_pci_top_main_kobj, "pci%d", idx); |
91b99041 | 179 | if (err != 0) { |
956b9ba1 | 180 | edac_dbg(2, "failed to register instance pci%d\n", 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); |
956b9ba1 | 186 | edac_dbg(1, "Register instance 'pci%d' kobject\n", idx); |
91b99041 DJ |
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 | { |
956b9ba1 | 203 | edac_dbg(0, "\n"); |
d4c1465b DT |
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 | 258 | |
8024c4c0 | 259 | if (edac_pci_dev->store) |
7c9281d7 DT |
260 | return edac_pci_dev->store(edac_pci_dev->value, buffer, count); |
261 | return -EIO; | |
262 | } | |
263 | ||
52cf25d0 | 264 | static const 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 | { |
956b9ba1 | 319 | edac_dbg(0, "here to module_put(THIS_MODULE)\n"); |
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 | |
fe5ff8b8 | 340 | * assumes edac_subsys has already been initialized |
7c9281d7 | 341 | */ |
1a45027d | 342 | static int edac_pci_main_kobj_setup(void) |
7c9281d7 DT |
343 | { |
344 | int err; | |
fe5ff8b8 | 345 | struct bus_type *edac_subsys; |
7c9281d7 | 346 | |
956b9ba1 | 347 | edac_dbg(0, "\n"); |
d4c1465b DT |
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 | 353 | /* First time, so create the main kobject and its |
25985edc | 354 | * controls and attributes |
d4c1465b | 355 | */ |
fe5ff8b8 KS |
356 | edac_subsys = edac_get_sysfs_subsys(); |
357 | if (edac_subsys == NULL) { | |
956b9ba1 | 358 | edac_dbg(1, "no edac_subsys\n"); |
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)) { | |
956b9ba1 | 368 | edac_dbg(1, "try_module_get() failed\n"); |
d4c1465b | 369 | err = -ENODEV; |
30e1f7a8 | 370 | goto mod_get_fail; |
d4c1465b | 371 | } |
7c9281d7 | 372 | |
14cc571b AJ |
373 | edac_pci_top_main_kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL); |
374 | if (!edac_pci_top_main_kobj) { | |
956b9ba1 | 375 | edac_dbg(1, "Failed to allocate\n"); |
14cc571b AJ |
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, | |
fe5ff8b8 | 383 | &edac_subsys->dev_root->kobj, "pci"); |
91b99041 | 384 | if (err) { |
956b9ba1 | 385 | edac_dbg(1, "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); |
956b9ba1 | 394 | edac_dbg(1, "Registered '.../edac/pci' kobject\n"); |
91b99041 DJ |
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 | ||
30e1f7a8 | 405 | mod_get_fail: |
fe5ff8b8 | 406 | edac_put_sysfs_subsys(); |
30e1f7a8 | 407 | |
d4c1465b DT |
408 | decrement_count_fail: |
409 | /* if are on this error exit, nothing to tear down */ | |
410 | atomic_dec(&edac_pci_sysfs_refcount); | |
411 | ||
412 | return err; | |
7c9281d7 DT |
413 | } |
414 | ||
415 | /* | |
d4c1465b | 416 | * edac_pci_main_kobj_teardown() |
7c9281d7 | 417 | * |
d4c1465b DT |
418 | * if no longer linked (needed) remove the top level EDAC PCI |
419 | * kobject with its controls and attributes | |
7c9281d7 | 420 | */ |
d4c1465b | 421 | static void edac_pci_main_kobj_teardown(void) |
7c9281d7 | 422 | { |
956b9ba1 | 423 | edac_dbg(0, "\n"); |
d4c1465b DT |
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) { | |
956b9ba1 | 430 | edac_dbg(0, "called kobject_put on main kobj\n"); |
14cc571b | 431 | kobject_put(edac_pci_top_main_kobj); |
1c069100 | 432 | edac_put_sysfs_subsys(); |
d4c1465b | 433 | } |
7c9281d7 DT |
434 | } |
435 | ||
d4c1465b DT |
436 | /* |
437 | * | |
438 | * edac_pci_create_sysfs | |
439 | * | |
440 | * Create the controls/attributes for the specified EDAC PCI device | |
441 | */ | |
91b99041 DJ |
442 | int edac_pci_create_sysfs(struct edac_pci_ctl_info *pci) |
443 | { | |
444 | int err; | |
445 | struct kobject *edac_kobj = &pci->kobj; | |
446 | ||
956b9ba1 | 447 | edac_dbg(0, "idx=%d\n", pci->pci_idx); |
91b99041 | 448 | |
d4c1465b DT |
449 | /* create the top main EDAC PCI kobject, IF needed */ |
450 | err = edac_pci_main_kobj_setup(); | |
451 | if (err) | |
452 | return err; | |
7c9281d7 | 453 | |
d4c1465b DT |
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; | |
91b99041 | 458 | |
079708b9 | 459 | err = sysfs_create_link(edac_kobj, &pci->dev->kobj, EDAC_PCI_SYMLINK); |
91b99041 | 460 | if (err) { |
956b9ba1 | 461 | edac_dbg(0, "sysfs_create_link() returned err= %d\n", err); |
d4c1465b | 462 | goto symlink_fail; |
91b99041 DJ |
463 | } |
464 | ||
465 | return 0; | |
d4c1465b DT |
466 | |
467 | /* Error unwind stack */ | |
468 | symlink_fail: | |
469 | edac_pci_unregister_sysfs_instance_kobj(pci); | |
470 | ||
471 | unregister_cleanup: | |
472 | edac_pci_main_kobj_teardown(); | |
473 | ||
474 | return err; | |
91b99041 DJ |
475 | } |
476 | ||
d4c1465b DT |
477 | /* |
478 | * edac_pci_remove_sysfs | |
479 | * | |
480 | * remove the controls and attributes for this EDAC PCI device | |
481 | */ | |
91b99041 DJ |
482 | void edac_pci_remove_sysfs(struct edac_pci_ctl_info *pci) |
483 | { | |
956b9ba1 | 484 | edac_dbg(0, "index=%d\n", pci->pci_idx); |
91b99041 | 485 | |
d4c1465b | 486 | /* Remove the symlink */ |
91b99041 DJ |
487 | sysfs_remove_link(&pci->kobj, EDAC_PCI_SYMLINK); |
488 | ||
d4c1465b DT |
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 | */ | |
956b9ba1 | 496 | edac_dbg(0, "calling edac_pci_main_kobj_teardown()\n"); |
d4c1465b | 497 | edac_pci_main_kobj_teardown(); |
91b99041 DJ |
498 | } |
499 | ||
500 | /************************ PCI error handling *************************/ | |
7c9281d7 DT |
501 | static 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 | | |
052dfb45 | 524 | PCI_STATUS_PARITY; |
7c9281d7 DT |
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 | ||
7c9281d7 DT |
533 | |
534 | /* Clear any PCI parity errors logged by this device. */ | |
535 | static 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 | * | |
25985edc | 551 | * Function to retrieve the current parity status |
d4c1465b DT |
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 | ||
956b9ba1 | 572 | edac_dbg(4, "PCI STATUS= 0x%04x %s\n", status, dev_name(&dev->dev)); |
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 | |
956b9ba1 JP |
603 | edac_dbg(4, "PCI HEADER TYPE= 0x%02x %s\n", |
604 | header_type, dev_name(&dev->dev)); | |
7c9281d7 DT |
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 | ||
956b9ba1 JP |
610 | edac_dbg(4, "PCI SEC_STATUS= 0x%04x %s\n", |
611 | status, dev_name(&dev->dev)); | |
7c9281d7 | 612 | |
6b09ff9d BB |
613 | /* check the secondary status reg for errors, |
614 | * on NOT broken boards | |
615 | */ | |
616 | if (status && !dev->broken_parity_status) { | |
91b99041 | 617 | if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) { |
7c9281d7 | 618 | edac_printk(KERN_CRIT, EDAC_PCI, "Bridge " |
052dfb45 DT |
619 | "Signaled System Error on %s\n", |
620 | pci_name(dev)); | |
91b99041 DJ |
621 | atomic_inc(&pci_nonparity_count); |
622 | } | |
7c9281d7 DT |
623 | |
624 | if (status & (PCI_STATUS_PARITY)) { | |
625 | edac_printk(KERN_CRIT, EDAC_PCI, "Bridge " | |
052dfb45 DT |
626 | "Master Data Parity Error on " |
627 | "%s\n", pci_name(dev)); | |
7c9281d7 DT |
628 | |
629 | atomic_inc(&pci_parity_count); | |
630 | } | |
631 | ||
632 | if (status & (PCI_STATUS_DETECTED_PARITY)) { | |
633 | edac_printk(KERN_CRIT, EDAC_PCI, "Bridge " | |
052dfb45 DT |
634 | "Detected Parity Error on %s\n", |
635 | pci_name(dev)); | |
7c9281d7 DT |
636 | |
637 | atomic_inc(&pci_parity_count); | |
638 | } | |
639 | } | |
640 | } | |
641 | } | |
642 | ||
d4c1465b DT |
643 | /* reduce some complexity in definition of the iterator */ |
644 | typedef void (*pci_parity_check_fn_t) (struct pci_dev *dev); | |
645 | ||
7c9281d7 DT |
646 | /* |
647 | * pci_dev parity list iterator | |
3bfe5aae WY |
648 | * |
649 | * Scan the PCI device list looking for SERRORs, Master Parity ERRORS or | |
650 | * Parity ERRORs on primary or secondary devices. | |
7c9281d7 DT |
651 | */ |
652 | static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn) | |
653 | { | |
654 | struct pci_dev *dev = NULL; | |
655 | ||
3bfe5aae | 656 | for_each_pci_dev(dev) |
7c9281d7 | 657 | fn(dev); |
7c9281d7 DT |
658 | } |
659 | ||
660 | /* | |
661 | * edac_pci_do_parity_check | |
662 | * | |
663 | * performs the actual PCI parity check operation | |
664 | */ | |
665 | void edac_pci_do_parity_check(void) | |
666 | { | |
7c9281d7 DT |
667 | int before_count; |
668 | ||
956b9ba1 | 669 | edac_dbg(3, "\n"); |
7c9281d7 | 670 | |
d4c1465b | 671 | /* if policy has PCI check off, leave now */ |
91b99041 | 672 | if (!check_pci_errors) |
7c9281d7 DT |
673 | return; |
674 | ||
675 | before_count = atomic_read(&pci_parity_count); | |
676 | ||
677 | /* scan all PCI devices looking for a Parity Error on devices and | |
d4c1465b DT |
678 | * bridges. |
679 | * The iterator calls pci_get_device() which might sleep, thus | |
680 | * we cannot disable interrupts in this scan. | |
7c9281d7 | 681 | */ |
7c9281d7 | 682 | edac_pci_dev_parity_iterator(edac_pci_dev_parity_test); |
7c9281d7 DT |
683 | |
684 | /* Only if operator has selected panic on PCI Error */ | |
4de78c68 | 685 | if (edac_pci_get_panic_on_pe()) { |
7c9281d7 DT |
686 | /* If the count is different 'after' from 'before' */ |
687 | if (before_count != atomic_read(&pci_parity_count)) | |
688 | panic("EDAC: PCI Parity Error"); | |
689 | } | |
690 | } | |
691 | ||
d4c1465b DT |
692 | /* |
693 | * edac_pci_clear_parity_errors | |
694 | * | |
695 | * function to perform an iteration over the PCI devices | |
696 | * and clearn their current status | |
697 | */ | |
7c9281d7 DT |
698 | void edac_pci_clear_parity_errors(void) |
699 | { | |
700 | /* Clear any PCI bus parity errors that devices initially have logged | |
701 | * in their registers. | |
702 | */ | |
703 | edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear); | |
704 | } | |
d4c1465b DT |
705 | |
706 | /* | |
707 | * edac_pci_handle_pe | |
708 | * | |
709 | * Called to handle a PARITY ERROR event | |
710 | */ | |
91b99041 DJ |
711 | void edac_pci_handle_pe(struct edac_pci_ctl_info *pci, const char *msg) |
712 | { | |
713 | ||
714 | /* global PE counter incremented by edac_pci_do_parity_check() */ | |
715 | atomic_inc(&pci->counters.pe_count); | |
716 | ||
4de78c68 | 717 | if (edac_pci_get_log_pe()) |
91b99041 DJ |
718 | edac_pci_printk(pci, KERN_WARNING, |
719 | "Parity Error ctl: %s %d: %s\n", | |
720 | pci->ctl_name, pci->pci_idx, msg); | |
721 | ||
722 | /* | |
723 | * poke all PCI devices and see which one is the troublemaker | |
724 | * panic() is called if set | |
725 | */ | |
726 | edac_pci_do_parity_check(); | |
727 | } | |
728 | EXPORT_SYMBOL_GPL(edac_pci_handle_pe); | |
7c9281d7 | 729 | |
d4c1465b DT |
730 | |
731 | /* | |
732 | * edac_pci_handle_npe | |
733 | * | |
734 | * Called to handle a NON-PARITY ERROR event | |
735 | */ | |
91b99041 DJ |
736 | void edac_pci_handle_npe(struct edac_pci_ctl_info *pci, const char *msg) |
737 | { | |
738 | ||
739 | /* global NPE counter incremented by edac_pci_do_parity_check() */ | |
740 | atomic_inc(&pci->counters.npe_count); | |
741 | ||
4de78c68 | 742 | if (edac_pci_get_log_npe()) |
91b99041 DJ |
743 | edac_pci_printk(pci, KERN_WARNING, |
744 | "Non-Parity Error ctl: %s %d: %s\n", | |
745 | pci->ctl_name, pci->pci_idx, msg); | |
746 | ||
747 | /* | |
748 | * poke all PCI devices and see which one is the troublemaker | |
749 | * panic() is called if set | |
750 | */ | |
751 | edac_pci_do_parity_check(); | |
752 | } | |
753 | EXPORT_SYMBOL_GPL(edac_pci_handle_npe); | |
7c9281d7 DT |
754 | |
755 | /* | |
756 | * Define the PCI parameter to the module | |
757 | */ | |
91b99041 | 758 | module_param(check_pci_errors, int, 0644); |
4de78c68 | 759 | MODULE_PARM_DESC(check_pci_errors, |
079708b9 | 760 | "Check for PCI bus parity errors: 0=off 1=on"); |
4de78c68 DJ |
761 | module_param(edac_pci_panic_on_pe, int, 0644); |
762 | MODULE_PARM_DESC(edac_pci_panic_on_pe, | |
079708b9 | 763 | "Panic on PCI Bus Parity error: 0=off 1=on"); |
7c9281d7 | 764 | |
079708b9 | 765 | #endif /* CONFIG_PCI */ |