drivers/edac: updated PCI monitoring
[linux-3.10.git] / drivers / edac / edac_pci_sysfs.c
1 /*
2  * (C) 2005, 2006 Linux Networx (http://lnxi.com)
3  * This file may be distributed under the terms of the
4  * GNU General Public License.
5  *
6  * Written Doug Thompson <norsk5@xmission.com>
7  *
8  */
9 #include <linux/module.h>
10 #include <linux/sysdev.h>
11 #include <linux/ctype.h>
12
13 #include "edac_core.h"
14 #include "edac_module.h"
15
16
17 #ifdef CONFIG_PCI
18
19 #define EDAC_PCI_SYMLINK        "device"
20
21 static int check_pci_errors = 0;        /* default YES check PCI parity */
22 static int panic_on_pci_parity = 0;     /* default no panic on PCI Parity */
23 static int log_pci_errs = 1;
24 static atomic_t pci_parity_count = ATOMIC_INIT(0);
25 static atomic_t pci_nonparity_count = ATOMIC_INIT(0);
26
27 static struct kobject edac_pci_kobj; /* /sys/devices/system/edac/pci */
28 static struct completion edac_pci_kobj_complete;
29 static atomic_t edac_pci_sysfs_refcount = ATOMIC_INIT(0);
30
31 /**************************** EDAC PCI sysfs instance *******************/
32 static ssize_t instance_pe_count_show(struct edac_pci_ctl_info *pci, char *data)
33 {
34         return sprintf(data,"%u\n", atomic_read(&pci->counters.pe_count));
35 }
36
37 static ssize_t instance_npe_count_show(struct edac_pci_ctl_info *pci,
38                 char *data)
39 {
40         return sprintf(data,"%u\n", atomic_read(&pci->counters.npe_count));
41 }
42
43 #define to_instance(k) container_of(k, struct edac_pci_ctl_info, kobj)
44 #define to_instance_attr(a) container_of(a, struct instance_attribute, attr)
45
46 /* DEVICE instance kobject release() function */
47 static void edac_pci_instance_release(struct kobject *kobj)
48 {
49         struct edac_pci_ctl_info *pci;
50
51         debugf1("%s()\n", __func__);
52
53         pci = to_instance(kobj);
54         complete(&pci->kobj_complete);
55 }
56
57 /* instance specific attribute structure */
58 struct instance_attribute {
59         struct attribute attr;
60         ssize_t (*show)(struct edac_pci_ctl_info *, char *);
61         ssize_t (*store)(struct edac_pci_ctl_info *, const char *, size_t);
62 };
63
64 /* Function to 'show' fields from the edac_pci 'instance' structure */
65 static ssize_t edac_pci_instance_show(struct kobject *kobj,
66                         struct attribute *attr,
67                         char *buffer)
68 {
69         struct edac_pci_ctl_info *pci = to_instance(kobj);
70         struct instance_attribute *instance_attr = to_instance_attr(attr);
71
72         if (instance_attr->show)
73                 return instance_attr->show(pci, buffer);
74         return -EIO;
75 }
76
77
78 /* Function to 'store' fields into the edac_pci 'instance' structure */
79 static ssize_t edac_pci_instance_store(struct kobject *kobj,
80                         struct attribute *attr,
81                         const char *buffer, size_t count)
82 {
83         struct edac_pci_ctl_info *pci = to_instance(kobj);
84         struct instance_attribute *instance_attr = to_instance_attr(attr);
85
86         if (instance_attr->store)
87                 return instance_attr->store(pci, buffer, count);
88         return -EIO;
89 }
90
91 static struct sysfs_ops pci_instance_ops = {
92         .show = edac_pci_instance_show,
93         .store = edac_pci_instance_store
94 };
95
96 #define INSTANCE_ATTR(_name, _mode, _show, _store)      \
97 static struct instance_attribute attr_instance_##_name = {      \
98         .attr   = {.name = __stringify(_name), .mode = _mode }, \
99         .show   = _show,                                        \
100         .store  = _store,                                       \
101 };
102
103 INSTANCE_ATTR(pe_count, S_IRUGO, instance_pe_count_show, NULL);
104 INSTANCE_ATTR(npe_count, S_IRUGO, instance_npe_count_show, NULL);
105
106 /* pci instance attributes */
107 static struct instance_attribute *pci_instance_attr[] = {
108         &attr_instance_pe_count,
109         &attr_instance_npe_count,
110         NULL
111 };
112
113 /* the ktype for pci instance */
114 static struct kobj_type ktype_pci_instance = {
115         .release = edac_pci_instance_release,
116         .sysfs_ops = &pci_instance_ops,
117         .default_attrs = (struct attribute **)pci_instance_attr,
118 };
119
120 static int edac_pci_create_instance_kobj(struct edac_pci_ctl_info *pci, int idx)
121 {
122         int err;
123
124         pci->kobj.parent = &edac_pci_kobj;
125         pci->kobj.ktype = &ktype_pci_instance;
126
127         err = kobject_set_name(&pci->kobj, "pci%d", idx);
128         if (err)
129                 return err;
130
131         err = kobject_register(&pci->kobj);
132         if (err != 0) {
133                 debugf2("%s() failed to register instance pci%d\n",
134                                 __func__, idx);
135                 return err;
136         }
137
138         debugf1("%s() Register instance 'pci%d' kobject\n", __func__, idx);
139
140         return 0;
141 }
142
143 static void
144 edac_pci_delete_instance_kobj(struct edac_pci_ctl_info *pci, int idx)
145 {
146         init_completion(&pci->kobj_complete);
147         kobject_unregister(&pci->kobj);
148         wait_for_completion(&pci->kobj_complete);
149 }
150
151 /***************************** EDAC PCI sysfs root **********************/
152 #define to_edacpci(k) container_of(k, struct edac_pci_ctl_info, kobj)
153 #define to_edacpci_attr(a) container_of(a, struct edac_pci_attr, attr)
154
155 static ssize_t edac_pci_int_show(void *ptr, char *buffer)
156 {
157         int *value = ptr;
158         return sprintf(buffer,"%d\n",*value);
159 }
160
161 static ssize_t edac_pci_int_store(void *ptr, const char *buffer, size_t count)
162 {
163         int *value = ptr;
164
165         if (isdigit(*buffer))
166                 *value = simple_strtoul(buffer,NULL,0);
167
168         return count;
169 }
170
171 struct edac_pci_dev_attribute {
172         struct attribute attr;
173         void *value;
174         ssize_t (*show)(void *,char *);
175         ssize_t (*store)(void *, const char *,size_t);
176 };
177
178 /* Set of show/store abstract level functions for PCI Parity object */
179 static ssize_t edac_pci_dev_show(struct kobject *kobj, struct attribute *attr,
180                 char *buffer)
181 {
182         struct edac_pci_dev_attribute *edac_pci_dev;
183         edac_pci_dev= (struct edac_pci_dev_attribute*)attr;
184
185         if (edac_pci_dev->show)
186                 return edac_pci_dev->show(edac_pci_dev->value, buffer);
187         return -EIO;
188 }
189
190 static ssize_t edac_pci_dev_store(struct kobject *kobj,
191                 struct attribute *attr, const char *buffer, size_t count)
192 {
193         struct edac_pci_dev_attribute *edac_pci_dev;
194         edac_pci_dev= (struct edac_pci_dev_attribute*)attr;
195
196         if (edac_pci_dev->show)
197                 return edac_pci_dev->store(edac_pci_dev->value, buffer, count);
198         return -EIO;
199 }
200
201 static struct sysfs_ops edac_pci_sysfs_ops = {
202         .show   = edac_pci_dev_show,
203         .store  = edac_pci_dev_store
204 };
205
206 #define EDAC_PCI_ATTR(_name,_mode,_show,_store)                 \
207 static struct edac_pci_dev_attribute edac_pci_attr_##_name = {          \
208         .attr = {.name = __stringify(_name), .mode = _mode },   \
209         .value  = &_name,                                       \
210         .show   = _show,                                        \
211         .store  = _store,                                       \
212 };
213
214 #define EDAC_PCI_STRING_ATTR(_name,_data,_mode,_show,_store)    \
215 static struct edac_pci_dev_attribute edac_pci_attr_##_name = {          \
216         .attr = {.name = __stringify(_name), .mode = _mode },   \
217         .value  = _data,                                        \
218         .show   = _show,                                        \
219         .store  = _store,                                       \
220 };
221
222 /* PCI Parity control files */
223 EDAC_PCI_ATTR(check_pci_errors, S_IRUGO|S_IWUSR, edac_pci_int_show,
224         edac_pci_int_store);
225 EDAC_PCI_ATTR(log_pci_errs, S_IRUGO|S_IWUSR, edac_pci_int_show,
226         edac_pci_int_store);
227 EDAC_PCI_ATTR(panic_on_pci_parity, S_IRUGO|S_IWUSR, edac_pci_int_show,
228         edac_pci_int_store);
229 EDAC_PCI_ATTR(pci_parity_count, S_IRUGO, edac_pci_int_show, NULL);
230 EDAC_PCI_ATTR(pci_nonparity_count, S_IRUGO, edac_pci_int_show, NULL);
231
232 /* Base Attributes of the memory ECC object */
233 static struct edac_pci_dev_attribute *edac_pci_attr[] = {
234         &edac_pci_attr_check_pci_errors,
235         &edac_pci_attr_log_pci_errs,
236         &edac_pci_attr_panic_on_pci_parity,
237         &edac_pci_attr_pci_parity_count,
238         &edac_pci_attr_pci_nonparity_count,
239         NULL,
240 };
241
242 /* No memory to release */
243 static void edac_pci_release(struct kobject *kobj)
244 {
245         struct edac_pci_ctl_info *pci;
246
247         pci = to_edacpci(kobj);
248
249         debugf1("%s()\n", __func__);
250         complete(&pci->kobj_complete);
251 }
252
253 static struct kobj_type ktype_edac_pci = {
254         .release = edac_pci_release,
255         .sysfs_ops = &edac_pci_sysfs_ops,
256         .default_attrs = (struct attribute **) edac_pci_attr,
257 };
258
259 /**
260  * edac_sysfs_pci_setup()
261  *
262  *      setup the sysfs for EDAC PCI attributes
263  *      assumes edac_class has already been initialized
264  */
265 int edac_pci_register_main_kobj(void)
266 {
267         int err;
268         struct sysdev_class *edac_class;
269
270         debugf1("%s()\n", __func__);
271
272         edac_class = edac_get_edac_class();
273         if (edac_class == NULL) {
274                 debugf1("%s() no edac_class\n", __func__);
275                 return -ENODEV;
276         }
277
278         edac_pci_kobj.ktype = &ktype_edac_pci;
279
280         edac_pci_kobj.parent = &edac_class->kset.kobj;
281
282         err = kobject_set_name(&edac_pci_kobj, "pci");
283         if(err)
284                 return err;
285
286         /* Instanstiate the pci object */
287         /* FIXME: maybe new sysdev_create_subdir() */
288         err = kobject_register(&edac_pci_kobj);
289
290         if (err) {
291                 debugf1("Failed to register '.../edac/pci'\n");
292                 return err;
293         }
294
295         debugf1("Registered '.../edac/pci' kobject\n");
296
297         return 0;
298 }
299
300 /*
301  * edac_pci_unregister_main_kobj()
302  *
303  *      perform the sysfs teardown for the PCI attributes
304  */
305 void edac_pci_unregister_main_kobj(void)
306 {
307         debugf0("%s()\n", __func__);
308         init_completion(&edac_pci_kobj_complete);
309         kobject_unregister(&edac_pci_kobj);
310         wait_for_completion(&edac_pci_kobj_complete);
311 }
312
313 int edac_pci_create_sysfs(struct edac_pci_ctl_info *pci)
314 {
315         int err;
316         struct kobject *edac_kobj = &pci->kobj;
317
318         if (atomic_inc_return(&edac_pci_sysfs_refcount) == 1) {
319                 err = edac_pci_register_main_kobj();
320                 if (err) {
321                         atomic_dec(&edac_pci_sysfs_refcount);
322                         return err;
323                 }
324         }
325
326         err = edac_pci_create_instance_kobj(pci, pci->pci_idx);
327         if (err) {
328                 if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0)
329                         edac_pci_unregister_main_kobj();
330         }
331
332
333         debugf0("%s() idx=%d\n", __func__, pci->pci_idx);
334
335         err = sysfs_create_link(edac_kobj,
336                         &pci->dev->kobj,
337                         EDAC_PCI_SYMLINK);
338         if (err) {
339                 debugf0("%s() sysfs_create_link() returned err= %d\n",
340                                 __func__, err);
341                 return err;
342         }
343
344         return 0;
345 }
346
347 void edac_pci_remove_sysfs(struct edac_pci_ctl_info *pci)
348 {
349         debugf0("%s()\n", __func__);
350
351         edac_pci_delete_instance_kobj(pci, pci->pci_idx);
352
353         sysfs_remove_link(&pci->kobj, EDAC_PCI_SYMLINK);
354
355         if (atomic_dec_return(&edac_pci_sysfs_refcount) == 0)
356                 edac_pci_unregister_main_kobj();
357 }
358
359 /************************ PCI error handling *************************/
360 static u16 get_pci_parity_status(struct pci_dev *dev, int secondary)
361 {
362         int where;
363         u16 status;
364
365         where = secondary ? PCI_SEC_STATUS : PCI_STATUS;
366         pci_read_config_word(dev, where, &status);
367
368         /* If we get back 0xFFFF then we must suspect that the card has been
369          * pulled but the Linux PCI layer has not yet finished cleaning up.
370          * We don't want to report on such devices
371          */
372
373         if (status == 0xFFFF) {
374                 u32 sanity;
375
376                 pci_read_config_dword(dev, 0, &sanity);
377
378                 if (sanity == 0xFFFFFFFF)
379                         return 0;
380         }
381
382         status &= PCI_STATUS_DETECTED_PARITY | PCI_STATUS_SIG_SYSTEM_ERROR |
383                 PCI_STATUS_PARITY;
384
385         if (status)
386                 /* reset only the bits we are interested in */
387                 pci_write_config_word(dev, where, status);
388
389         return status;
390 }
391
392 typedef void (*pci_parity_check_fn_t) (struct pci_dev *dev);
393
394 /* Clear any PCI parity errors logged by this device. */
395 static void edac_pci_dev_parity_clear(struct pci_dev *dev)
396 {
397         u8 header_type;
398
399         get_pci_parity_status(dev, 0);
400
401         /* read the device TYPE, looking for bridges */
402         pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
403
404         if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE)
405                 get_pci_parity_status(dev, 1);
406 }
407
408 /*
409  *  PCI Parity polling
410  *
411  */
412 static void edac_pci_dev_parity_test(struct pci_dev *dev)
413 {
414         u16 status;
415         u8  header_type;
416
417         /* read the STATUS register on this device
418          */
419         status = get_pci_parity_status(dev, 0);
420
421         debugf2("PCI STATUS= 0x%04x %s\n", status, dev->dev.bus_id );
422
423         /* check the status reg for errors */
424         if (status) {
425                 if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
426                         edac_printk(KERN_CRIT, EDAC_PCI,
427                                 "Signaled System Error on %s\n",
428                                 pci_name(dev));
429                         atomic_inc(&pci_nonparity_count);
430                 }
431
432                 if (status & (PCI_STATUS_PARITY)) {
433                         edac_printk(KERN_CRIT, EDAC_PCI,
434                                 "Master Data Parity Error on %s\n",
435                                 pci_name(dev));
436
437                         atomic_inc(&pci_parity_count);
438                 }
439
440                 if (status & (PCI_STATUS_DETECTED_PARITY)) {
441                         edac_printk(KERN_CRIT, EDAC_PCI,
442                                 "Detected Parity Error on %s\n",
443                                 pci_name(dev));
444
445                         atomic_inc(&pci_parity_count);
446                 }
447         }
448
449         /* read the device TYPE, looking for bridges */
450         pci_read_config_byte(dev, PCI_HEADER_TYPE, &header_type);
451
452         debugf2("PCI HEADER TYPE= 0x%02x %s\n", header_type, dev->dev.bus_id );
453
454         if ((header_type & 0x7F) == PCI_HEADER_TYPE_BRIDGE) {
455                 /* On bridges, need to examine secondary status register  */
456                 status = get_pci_parity_status(dev, 1);
457
458                 debugf2("PCI SEC_STATUS= 0x%04x %s\n",
459                                 status, dev->dev.bus_id );
460
461                 /* check the secondary status reg for errors */
462                 if (status) {
463                         if (status & (PCI_STATUS_SIG_SYSTEM_ERROR)) {
464                                 edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
465                                         "Signaled System Error on %s\n",
466                                         pci_name(dev));
467                                 atomic_inc(&pci_nonparity_count);
468                         }
469
470                         if (status & (PCI_STATUS_PARITY)) {
471                                 edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
472                                         "Master Data Parity Error on "
473                                         "%s\n", pci_name(dev));
474
475                                 atomic_inc(&pci_parity_count);
476                         }
477
478                         if (status & (PCI_STATUS_DETECTED_PARITY)) {
479                                 edac_printk(KERN_CRIT, EDAC_PCI, "Bridge "
480                                         "Detected Parity Error on %s\n",
481                                         pci_name(dev));
482
483                                 atomic_inc(&pci_parity_count);
484                         }
485                 }
486         }
487 }
488
489 /*
490  * pci_dev parity list iterator
491  *      Scan the PCI device list for one iteration, looking for SERRORs
492  *      Master Parity ERRORS or Parity ERRORs on primary or secondary devices
493  */
494 static inline void edac_pci_dev_parity_iterator(pci_parity_check_fn_t fn)
495 {
496         struct pci_dev *dev = NULL;
497
498         /* request for kernel access to the next PCI device, if any,
499          * and while we are looking at it have its reference count
500          * bumped until we are done with it
501          */
502         while((dev = pci_get_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
503                 fn(dev);
504         }
505 }
506
507 /*
508  * edac_pci_do_parity_check
509  *
510  *      performs the actual PCI parity check operation
511  */
512 void edac_pci_do_parity_check(void)
513 {
514         unsigned long flags;
515         int before_count;
516
517         debugf3("%s()\n", __func__);
518
519         if (!check_pci_errors)
520                 return;
521
522         before_count = atomic_read(&pci_parity_count);
523
524         /* scan all PCI devices looking for a Parity Error on devices and
525          * bridges
526          */
527         local_irq_save(flags);
528         edac_pci_dev_parity_iterator(edac_pci_dev_parity_test);
529         local_irq_restore(flags);
530
531         /* Only if operator has selected panic on PCI Error */
532         if (panic_on_pci_parity) {
533                 /* If the count is different 'after' from 'before' */
534                 if (before_count != atomic_read(&pci_parity_count))
535                         panic("EDAC: PCI Parity Error");
536         }
537 }
538
539 void edac_pci_clear_parity_errors(void)
540 {
541         /* Clear any PCI bus parity errors that devices initially have logged
542          * in their registers.
543          */
544         edac_pci_dev_parity_iterator(edac_pci_dev_parity_clear);
545 }
546 void edac_pci_handle_pe(struct edac_pci_ctl_info *pci, const char *msg)
547 {
548
549         /* global PE counter incremented by edac_pci_do_parity_check() */
550         atomic_inc(&pci->counters.pe_count);
551
552         if (log_pci_errs)
553                 edac_pci_printk(pci, KERN_WARNING,
554                                 "Parity Error ctl: %s %d: %s\n",
555                                 pci->ctl_name, pci->pci_idx, msg);
556
557         /*
558          * poke all PCI devices and see which one is the troublemaker
559          * panic() is called if set
560          */
561         edac_pci_do_parity_check();
562 }
563 EXPORT_SYMBOL_GPL(edac_pci_handle_pe);
564
565 void edac_pci_handle_npe(struct edac_pci_ctl_info *pci, const char *msg)
566 {
567
568         /* global NPE counter incremented by edac_pci_do_parity_check() */
569         atomic_inc(&pci->counters.npe_count);
570
571         if (log_pci_errs)
572                 edac_pci_printk(pci, KERN_WARNING,
573                                 "Non-Parity Error ctl: %s %d: %s\n",
574                                 pci->ctl_name, pci->pci_idx, msg);
575
576         /*
577          * poke all PCI devices and see which one is the troublemaker
578          * panic() is called if set
579          */
580         edac_pci_do_parity_check();
581 }
582 EXPORT_SYMBOL_GPL(edac_pci_handle_npe);
583
584 /*
585  * Define the PCI parameter to the module
586  */
587 module_param(check_pci_errors, int, 0644);
588 MODULE_PARM_DESC(check_pci_errors, "Check for PCI bus parity errors: 0=off 1=on");
589 module_param(panic_on_pci_parity, int, 0644);
590 MODULE_PARM_DESC(panic_on_pci_parity, "Panic on PCI Bus Parity error: 0=off 1=on");
591
592 #endif  /* CONFIG_PCI */