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