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