drivers/edac/edac_device_sysfs.c

   1 /*
   2  * file for managing the edac_device class of devices for EDAC
   3  *
   4  * (C) 2007 SoftwareBitMaker (http://www.softwarebitmaker.com)
   5  *
   6  * This file may be distributed under the terms of the
   7  * GNU General Public License.
   8  *
   9  * Written Doug Thompson <norsk5@xmission.com>
  10  *
  11  */
  12
  13 #include <linux/ctype.h>
  14 #include <linux/module.h>
  15
  16 #include "edac_core.h"
  17 #include "edac_module.h"
  18
  19 #define EDAC_DEVICE_SYMLINK     "device"
  20
  21 #define to_edacdev(k) container_of(k, struct edac_device_ctl_info, kobj)
  22 #define to_edacdev_attr(a) container_of(a, struct edacdev_attribute, attr)
  23
  24
  25 /*
  26  * Set of edac_device_ctl_info attribute store/show functions
  27  */
  28
  29 /* 'log_ue' */
  30 static ssize_t edac_device_ctl_log_ue_show(struct edac_device_ctl_info
  31                                         *ctl_info, char *data)
  32 {
  33         return sprintf(data, "%u\n", ctl_info->log_ue);
  34 }
  35
  36 static ssize_t edac_device_ctl_log_ue_store(struct edac_device_ctl_info
  37                                         *ctl_info, const char *data,
  38                                         size_t count)
  39 {
  40         /* if parameter is zero, turn off flag, if non-zero turn on flag */
  41         ctl_info->log_ue = (simple_strtoul(data, NULL, 0) != 0);
  42
  43         return count;
  44 }
  45
  46 /* 'log_ce' */
  47 static ssize_t edac_device_ctl_log_ce_show(struct edac_device_ctl_info
  48                                         *ctl_info, char *data)
  49 {
  50         return sprintf(data, "%u\n", ctl_info->log_ce);
  51 }
  52
  53 static ssize_t edac_device_ctl_log_ce_store(struct edac_device_ctl_info
  54                                         *ctl_info, const char *data,
  55                                         size_t count)
  56 {
  57         /* if parameter is zero, turn off flag, if non-zero turn on flag */
  58         ctl_info->log_ce = (simple_strtoul(data, NULL, 0) != 0);
  59
  60         return count;
  61 }
  62
  63 /* 'panic_on_ue' */
  64 static ssize_t edac_device_ctl_panic_on_ue_show(struct edac_device_ctl_info
  65                                                 *ctl_info, char *data)
  66 {
  67         return sprintf(data, "%u\n", ctl_info->panic_on_ue);
  68 }
  69
  70 static ssize_t edac_device_ctl_panic_on_ue_store(struct edac_device_ctl_info
  71                                                  *ctl_info, const char *data,
  72                                                  size_t count)
  73 {
  74         /* if parameter is zero, turn off flag, if non-zero turn on flag */
  75         ctl_info->panic_on_ue = (simple_strtoul(data, NULL, 0) != 0);
  76
  77         return count;
  78 }
  79
  80 /* 'poll_msec' show and store functions*/
  81 static ssize_t edac_device_ctl_poll_msec_show(struct edac_device_ctl_info
  82                                         *ctl_info, char *data)
  83 {
  84         return sprintf(data, "%u\n", ctl_info->poll_msec);
  85 }
  86
  87 static ssize_t edac_device_ctl_poll_msec_store(struct edac_device_ctl_info
  88                                         *ctl_info, const char *data,
  89                                         size_t count)
  90 {
  91         unsigned long value;
  92
  93         /* get the value and enforce that it is non-zero, must be at least
  94          * one millisecond for the delay period, between scans
  95          * Then cancel last outstanding delay for the work request
  96          * and set a new one.
  97          */
  98         value = simple_strtoul(data, NULL, 0);
  99         edac_device_reset_delay_period(ctl_info, value);
 100
 101         return count;
 102 }
 103
 104 /* edac_device_ctl_info specific attribute structure */
 105 struct ctl_info_attribute {
 106         struct attribute attr;
 107         ssize_t(*show) (struct edac_device_ctl_info *, char *);
 108         ssize_t(*store) (struct edac_device_ctl_info *, const char *, size_t);
 109 };
 110
 111 #define to_ctl_info(k) container_of(k, struct edac_device_ctl_info, kobj)
 112 #define to_ctl_info_attr(a) container_of(a,struct ctl_info_attribute,attr)
 113
 114 /* Function to 'show' fields from the edac_dev 'ctl_info' structure */
 115 static ssize_t edac_dev_ctl_info_show(struct kobject *kobj,
 116                                 struct attribute *attr, char *buffer)
 117 {
 118         struct edac_device_ctl_info *edac_dev = to_ctl_info(kobj);
 119         struct ctl_info_attribute *ctl_info_attr = to_ctl_info_attr(attr);
 120
 121         if (ctl_info_attr->show)
 122                 return ctl_info_attr->show(edac_dev, buffer);
 123         return -EIO;
 124 }
 125
 126 /* Function to 'store' fields into the edac_dev 'ctl_info' structure */
 127 static ssize_t edac_dev_ctl_info_store(struct kobject *kobj,
 128                                 struct attribute *attr,
 129                                 const char *buffer, size_t count)
 130 {
 131         struct edac_device_ctl_info *edac_dev = to_ctl_info(kobj);
 132         struct ctl_info_attribute *ctl_info_attr = to_ctl_info_attr(attr);
 133
 134         if (ctl_info_attr->store)
 135                 return ctl_info_attr->store(edac_dev, buffer, count);
 136         return -EIO;
 137 }
 138
 139 /* edac_dev file operations for an 'ctl_info' */
 140 static struct sysfs_ops device_ctl_info_ops = {
 141         .show = edac_dev_ctl_info_show,
 142         .store = edac_dev_ctl_info_store
 143 };
 144
 145 #define CTL_INFO_ATTR(_name,_mode,_show,_store)        \
 146 static struct ctl_info_attribute attr_ctl_info_##_name = {      \
 147         .attr = {.name = __stringify(_name), .mode = _mode },   \
 148         .show   = _show,                                        \
 149         .store  = _store,                                       \
 150 };
 151
 152 /* Declare the various ctl_info attributes here and their respective ops */
 153 CTL_INFO_ATTR(log_ue, S_IRUGO | S_IWUSR,
 154         edac_device_ctl_log_ue_show, edac_device_ctl_log_ue_store);
 155 CTL_INFO_ATTR(log_ce, S_IRUGO | S_IWUSR,
 156         edac_device_ctl_log_ce_show, edac_device_ctl_log_ce_store);
 157 CTL_INFO_ATTR(panic_on_ue, S_IRUGO | S_IWUSR,
 158         edac_device_ctl_panic_on_ue_show,
 159         edac_device_ctl_panic_on_ue_store);
 160 CTL_INFO_ATTR(poll_msec, S_IRUGO | S_IWUSR,
 161         edac_device_ctl_poll_msec_show, edac_device_ctl_poll_msec_store);
 162
 163 /* Base Attributes of the EDAC_DEVICE ECC object */
 164 static struct ctl_info_attribute *device_ctrl_attr[] = {
 165         &attr_ctl_info_panic_on_ue,
 166         &attr_ctl_info_log_ue,
 167         &attr_ctl_info_log_ce,
 168         &attr_ctl_info_poll_msec,
 169         NULL,
 170 };
 171
 172 /*
 173  * edac_device_ctrl_master_release
 174  *
 175  *      called when the reference count for the 'main' kobj
 176  *      for a edac_device control struct reaches zero
 177  *
 178  *      Reference count model:
 179  *              One 'main' kobject for each control structure allocated.
 180  *              That main kobj is initially set to one AND
 181  *              the reference count for the EDAC 'core' module is
 182  *              bumped by one, thus added 'keep in memory' dependency.
 183  *
 184  *              Each new internal kobj (in instances and blocks) then
 185  *              bumps the 'main' kobject.
 186  *
 187  *              When they are released their release functions decrement
 188  *              the 'main' kobj.
 189  *
 190  *              When the main kobj reaches zero (0) then THIS function
 191  *              is called which then decrements the EDAC 'core' module.
 192  *              When the module reference count reaches zero then the
 193  *              module no longer has dependency on keeping the release
 194  *              function code in memory and module can be unloaded.
 195  *
 196  *              This will support several control objects as well, each
 197  *              with its own 'main' kobj.
 198  */
 199 static void edac_device_ctrl_master_release(struct kobject *kobj)
 200 {
 201         struct edac_device_ctl_info *edac_dev = to_edacdev(kobj);
 202
 203         debugf4("%s() control index=%d\n", __func__, edac_dev->dev_idx);
 204
 205         /* decrement the EDAC CORE module ref count */
 206         module_put(edac_dev->owner);
 207
 208         /* free the control struct containing the 'main' kobj
 209          * passed in to this routine
 210          */
 211         kfree(edac_dev);
 212 }
 213
 214 /* ktype for the main (master) kobject */
 215 static struct kobj_type ktype_device_ctrl = {
 216         .release = edac_device_ctrl_master_release,
 217         .sysfs_ops = &device_ctl_info_ops,
 218         .default_attrs = (struct attribute **)device_ctrl_attr,
 219 };
 220
 221 /*
 222  * edac_device_register_sysfs_main_kobj
 223  *
 224  *      perform the high level setup for the new edac_device instance
 225  *
 226  * Return:  0 SUCCESS
 227  *         !0 FAILURE
 228  */
 229 int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev)
 230 {
 231         struct sysdev_class *edac_class;
 232         int err;
 233
 234         debugf1("%s()\n", __func__);
 235
 236         /* get the /sys/devices/system/edac reference */
 237         edac_class = edac_get_edac_class();
 238         if (edac_class == NULL) {
 239                 debugf1("%s() no edac_class error\n", __func__);
 240                 err = -ENODEV;
 241                 goto err_out;
 242         }
 243
 244         /* Point to the 'edac_class' this instance 'reports' to */
 245         edac_dev->edac_class = edac_class;
 246
 247         /* Init the devices's kobject */
 248         memset(&edac_dev->kobj, 0, sizeof(struct kobject));
 249         edac_dev->kobj.ktype = &ktype_device_ctrl;
 250
 251         /* set this new device under the edac_class kobject */
 252         edac_dev->kobj.parent = &edac_class->kset.kobj;
 253
 254         /* generate sysfs "..../edac/<name>"   */
 255         debugf4("%s() set name of kobject to: %s\n", __func__, edac_dev->name);
 256         err = kobject_set_name(&edac_dev->kobj, "%s", edac_dev->name);
 257         if (err)
 258                 goto err_out;
 259
 260         /* Record which module 'owns' this control structure
 261          * and bump the ref count of the module
 262          */
 263         edac_dev->owner = THIS_MODULE;
 264
 265         if (!try_module_get(edac_dev->owner)) {
 266                 err = -ENODEV;
 267                 goto err_out;
 268         }
 269
 270         /* register */
 271         err = kobject_register(&edac_dev->kobj);
 272         if (err) {
 273                 debugf1("%s()Failed to register '.../edac/%s'\n",
 274                         __func__, edac_dev->name);
 275                 goto err_kobj_reg;
 276         }
 277
 278         /* At this point, to 'free' the control struct,
 279          * edac_device_unregister_sysfs_main_kobj() must be used
 280          */
 281
 282         debugf4("%s() Registered '.../edac/%s' kobject\n",
 283                 __func__, edac_dev->name);
 284
 285         return 0;
 286
 287         /* Error exit stack */
 288 err_kobj_reg:
 289         module_put(edac_dev->owner);
 290
 291 err_out:
 292         return err;
 293 }
 294
 295 /*
 296  * edac_device_unregister_sysfs_main_kobj:
 297  *      the '..../edac/<name>' kobject
 298  */
 299 void edac_device_unregister_sysfs_main_kobj(
 300                                         struct edac_device_ctl_info *edac_dev)
 301 {
 302         debugf0("%s()\n", __func__);
 303         debugf4("%s() name of kobject is: %s\n",
 304                 __func__, kobject_name(&edac_dev->kobj));
 305
 306         /*
 307          * Unregister the edac device's kobject and
 308          * allow for reference count to reach 0 at which point
 309          * the callback will be called to:
 310          *   a) module_put() this module
 311          *   b) 'kfree' the memory
 312          */
 313         kobject_unregister(&edac_dev->kobj);
 314 }
 315
 316 /* edac_dev -> instance information */
 317
 318 /*
 319  * Set of low-level instance attribute show functions
 320  */
 321 static ssize_t instance_ue_count_show(struct edac_device_instance *instance,
 322                                 char *data)
 323 {
 324         return sprintf(data, "%u\n", instance->counters.ue_count);
 325 }
 326
 327 static ssize_t instance_ce_count_show(struct edac_device_instance *instance,
 328                                 char *data)
 329 {
 330         return sprintf(data, "%u\n", instance->counters.ce_count);
 331 }
 332
 333 #define to_instance(k) container_of(k, struct edac_device_instance, kobj)
 334 #define to_instance_attr(a) container_of(a,struct instance_attribute,attr)
 335
 336 /* DEVICE instance kobject release() function */
 337 static void edac_device_ctrl_instance_release(struct kobject *kobj)
 338 {
 339         struct edac_device_instance *instance;
 340
 341         debugf1("%s()\n", __func__);
 342
 343         /* map from this kobj to the main control struct
 344          * and then dec the main kobj count
 345          */
 346         instance = to_instance(kobj);
 347         kobject_put(&instance->ctl->kobj);
 348 }
 349
 350 /* instance specific attribute structure */
 351 struct instance_attribute {
 352         struct attribute attr;
 353         ssize_t(*show) (struct edac_device_instance *, char *);
 354         ssize_t(*store) (struct edac_device_instance *, const char *, size_t);
 355 };
 356
 357 /* Function to 'show' fields from the edac_dev 'instance' structure */
 358 static ssize_t edac_dev_instance_show(struct kobject *kobj,
 359                                 struct attribute *attr, char *buffer)
 360 {
 361         struct edac_device_instance *instance = to_instance(kobj);
 362         struct instance_attribute *instance_attr = to_instance_attr(attr);
 363
 364         if (instance_attr->show)
 365                 return instance_attr->show(instance, buffer);
 366         return -EIO;
 367 }
 368
 369 /* Function to 'store' fields into the edac_dev 'instance' structure */
 370 static ssize_t edac_dev_instance_store(struct kobject *kobj,
 371                                 struct attribute *attr,
 372                                 const char *buffer, size_t count)
 373 {
 374         struct edac_device_instance *instance = to_instance(kobj);
 375         struct instance_attribute *instance_attr = to_instance_attr(attr);
 376
 377         if (instance_attr->store)
 378                 return instance_attr->store(instance, buffer, count);
 379         return -EIO;
 380 }
 381
 382 /* edac_dev file operations for an 'instance' */
 383 static struct sysfs_ops device_instance_ops = {
 384         .show = edac_dev_instance_show,
 385         .store = edac_dev_instance_store
 386 };
 387
 388 #define INSTANCE_ATTR(_name,_mode,_show,_store)        \
 389 static struct instance_attribute attr_instance_##_name = {      \
 390         .attr = {.name = __stringify(_name), .mode = _mode },   \
 391         .show   = _show,                                        \
 392         .store  = _store,                                       \
 393 };
 394
 395 /*
 396  * Define attributes visible for the edac_device instance object
 397  *      Each contains a pointer to a show and an optional set
 398  *      function pointer that does the low level output/input
 399  */
 400 INSTANCE_ATTR(ce_count, S_IRUGO, instance_ce_count_show, NULL);
 401 INSTANCE_ATTR(ue_count, S_IRUGO, instance_ue_count_show, NULL);
 402
 403 /* list of edac_dev 'instance' attributes */
 404 static struct instance_attribute *device_instance_attr[] = {
 405         &attr_instance_ce_count,
 406         &attr_instance_ue_count,
 407         NULL,
 408 };
 409
 410 /* The 'ktype' for each edac_dev 'instance' */
 411 static struct kobj_type ktype_instance_ctrl = {
 412         .release = edac_device_ctrl_instance_release,
 413         .sysfs_ops = &device_instance_ops,
 414         .default_attrs = (struct attribute **)device_instance_attr,
 415 };
 416
 417 /* edac_dev -> instance -> block information */
 418
 419 #define to_block(k) container_of(k, struct edac_device_block, kobj)
 420 #define to_block_attr(a) \
 421         container_of(a, struct edac_dev_sysfs_block_attribute, attr)
 422
 423 /*
 424  * Set of low-level block attribute show functions
 425  */
 426 static ssize_t block_ue_count_show(struct kobject *kobj,
 427                                         struct attribute *attr, char *data)
 428 {
 429         struct edac_device_block *block = to_block(kobj);
 430
 431         return sprintf(data, "%u\n", block->counters.ue_count);
 432 }
 433
 434 static ssize_t block_ce_count_show(struct kobject *kobj,
 435                                         struct attribute *attr, char *data)
 436 {
 437         struct edac_device_block *block = to_block(kobj);
 438
 439         return sprintf(data, "%u\n", block->counters.ce_count);
 440 }
 441
 442 /* DEVICE block kobject release() function */
 443 static void edac_device_ctrl_block_release(struct kobject *kobj)
 444 {
 445         struct edac_device_block *block;
 446
 447         debugf1("%s()\n", __func__);
 448
 449         /* get the container of the kobj */
 450         block = to_block(kobj);
 451
 452         /* map from 'block kobj' to 'block->instance->controller->main_kobj'
 453          * now 'release' the block kobject
 454          */
 455         kobject_put(&block->instance->ctl->kobj);
 456 }
 457
 458
 459 /* Function to 'show' fields from the edac_dev 'block' structure */
 460 static ssize_t edac_dev_block_show(struct kobject *kobj,
 461                                 struct attribute *attr, char *buffer)
 462 {
 463         struct edac_dev_sysfs_block_attribute *block_attr =
 464                                                 to_block_attr(attr);
 465
 466         if (block_attr->show)
 467                 return block_attr->show(kobj, attr, buffer);
 468         return -EIO;
 469 }
 470
 471 /* Function to 'store' fields into the edac_dev 'block' structure */
 472 static ssize_t edac_dev_block_store(struct kobject *kobj,
 473                                 struct attribute *attr,
 474                                 const char *buffer, size_t count)
 475 {
 476         struct edac_dev_sysfs_block_attribute *block_attr;
 477
 478         block_attr = to_block_attr(attr);
 479
 480         if (block_attr->store)
 481                 return block_attr->store(kobj, attr, buffer, count);
 482         return -EIO;
 483 }
 484
 485 /* edac_dev file operations for a 'block' */
 486 static struct sysfs_ops device_block_ops = {
 487         .show = edac_dev_block_show,
 488         .store = edac_dev_block_store
 489 };
 490
 491 #define BLOCK_ATTR(_name,_mode,_show,_store)        \
 492 static struct edac_dev_sysfs_block_attribute attr_block_##_name = {     \
 493         .attr = {.name = __stringify(_name), .mode = _mode },   \
 494         .show   = _show,                                        \
 495         .store  = _store,                                       \
 496 };
 497
 498 BLOCK_ATTR(ce_count, S_IRUGO, block_ce_count_show, NULL);
 499 BLOCK_ATTR(ue_count, S_IRUGO, block_ue_count_show, NULL);
 500
 501 /* list of edac_dev 'block' attributes */
 502 static struct edac_dev_sysfs_block_attribute *device_block_attr[] = {
 503         &attr_block_ce_count,
 504         &attr_block_ue_count,
 505         NULL,
 506 };
 507
 508 /* The 'ktype' for each edac_dev 'block' */
 509 static struct kobj_type ktype_block_ctrl = {
 510         .release = edac_device_ctrl_block_release,
 511         .sysfs_ops = &device_block_ops,
 512         .default_attrs = (struct attribute **)device_block_attr,
 513 };
 514
 515 /* block ctor/dtor  code */
 516
 517 /*
 518  * edac_device_create_block
 519  */
 520 static int edac_device_create_block(struct edac_device_ctl_info *edac_dev,
 521                                 struct edac_device_instance *instance,
 522                                 struct edac_device_block *block)
 523 {
 524         int i;
 525         int err;
 526         struct edac_dev_sysfs_block_attribute *sysfs_attrib;
 527         struct kobject *main_kobj;
 528
 529         debugf4("%s() Instance '%s' inst_p=%p  block '%s'  block_p=%p\n",
 530                 __func__, instance->name, instance, block->name, block);
 531         debugf4("%s() block kobj=%p  block kobj->parent=%p\n",
 532                 __func__, &block->kobj, &block->kobj.parent);
 533
 534         /* init this block's kobject */
 535         memset(&block->kobj, 0, sizeof(struct kobject));
 536         block->kobj.parent = &instance->kobj;
 537         block->kobj.ktype = &ktype_block_ctrl;
 538
 539         err = kobject_set_name(&block->kobj, "%s", block->name);
 540         if (err)
 541                 return err;
 542
 543         /* bump the main kobject's reference count for this controller
 544          * and this instance is dependant on the main
 545          */
 546         main_kobj = kobject_get(&edac_dev->kobj);
 547         if (!main_kobj) {
 548                 err = -ENODEV;
 549                 goto err_out;
 550         }
 551
 552         /* Add this block's kobject */
 553         err = kobject_register(&block->kobj);
 554         if (err) {
 555                 debugf1("%s() Failed to register instance '%s'\n",
 556                         __func__, block->name);
 557                 kobject_put(main_kobj);
 558                 err = -ENODEV;
 559                 goto err_out;
 560         }
 561
 562         /* If there are driver level block attributes, then added them
 563          * to the block kobject
 564          */
 565         sysfs_attrib = block->block_attributes;
 566         if (sysfs_attrib && block->nr_attribs) {
 567                 for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) {
 568
 569                         debugf4("%s() creating block attrib='%s' "
 570                                 "attrib->%p to kobj=%p\n",
 571                                 __func__,
 572                                 sysfs_attrib->attr.name,
 573                                 sysfs_attrib, &block->kobj);
 574
 575                         /* Create each block_attribute file */
 576                         err = sysfs_create_file(&block->kobj,
 577                                 &sysfs_attrib->attr);
 578                         if (err)
 579                                 goto err_on_attrib;
 580                 }
 581         }
 582
 583         return 0;
 584
 585         /* Error unwind stack */
 586 err_on_attrib:
 587         kobject_unregister(&block->kobj);
 588
 589 err_out:
 590         return err;
 591 }
 592
 593 /*
 594  * edac_device_delete_block(edac_dev,block);
 595  */
 596 static void edac_device_delete_block(struct edac_device_ctl_info *edac_dev,
 597                                 struct edac_device_block *block)
 598 {
 599         struct edac_dev_sysfs_block_attribute *sysfs_attrib;
 600         int i;
 601
 602         /* if this block has 'attributes' then we need to iterate over the list
 603          * and 'remove' the attributes on this block
 604          */
 605         sysfs_attrib = block->block_attributes;
 606         if (sysfs_attrib && block->nr_attribs) {
 607                 for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) {
 608
 609                         /* remove each block_attrib file */
 610                         sysfs_remove_file(&block->kobj,
 611                                 (struct attribute *) sysfs_attrib);
 612                 }
 613         }
 614
 615         /* unregister this block's kobject, SEE:
 616          *      edac_device_ctrl_block_release() callback operation
 617          */
 618         kobject_unregister(&block->kobj);
 619 }
 620
 621 /* instance ctor/dtor code */
 622
 623 /*
 624  * edac_device_create_instance
 625  *      create just one instance of an edac_device 'instance'
 626  */
 627 static int edac_device_create_instance(struct edac_device_ctl_info *edac_dev,
 628                                 int idx)
 629 {
 630         int i, j;
 631         int err;
 632         struct edac_device_instance *instance;
 633         struct kobject *main_kobj;
 634
 635         instance = &edac_dev->instances[idx];
 636
 637         /* Init the instance's kobject */
 638         memset(&instance->kobj, 0, sizeof(struct kobject));
 639
 640         /* set this new device under the edac_device main kobject */
 641         instance->kobj.parent = &edac_dev->kobj;
 642         instance->kobj.ktype = &ktype_instance_ctrl;
 643         instance->ctl = edac_dev;
 644
 645         err = kobject_set_name(&instance->kobj, "%s", instance->name);
 646         if (err)
 647                 goto err_out;
 648
 649         /* bump the main kobject's reference count for this controller
 650          * and this instance is dependant on the main
 651          */
 652         main_kobj = kobject_get(&edac_dev->kobj);
 653         if (!main_kobj) {
 654                 err = -ENODEV;
 655                 goto err_out;
 656         }
 657
 658         /* Formally register this instance's kobject */
 659         err = kobject_register(&instance->kobj);
 660         if (err != 0) {
 661                 debugf2("%s() Failed to register instance '%s'\n",
 662                         __func__, instance->name);
 663                 kobject_put(main_kobj);
 664                 goto err_out;
 665         }
 666
 667         debugf4("%s() now register '%d' blocks for instance %d\n",
 668                 __func__, instance->nr_blocks, idx);
 669
 670         /* register all blocks of this instance */
 671         for (i = 0; i < instance->nr_blocks; i++) {
 672                 err = edac_device_create_block(edac_dev, instance,
 673                                                 &instance->blocks[i]);
 674                 if (err) {
 675                         /* If any fail, remove all previous ones */
 676                         for (j = 0; j < i; j++)
 677                                 edac_device_delete_block(edac_dev,
 678                                                         &instance->blocks[j]);
 679                         goto err_release_instance_kobj;
 680                 }
 681         }
 682
 683         debugf4("%s() Registered instance %d '%s' kobject\n",
 684                 __func__, idx, instance->name);
 685
 686         return 0;
 687
 688         /* error unwind stack */
 689 err_release_instance_kobj:
 690         kobject_unregister(&instance->kobj);
 691
 692 err_out:
 693         return err;
 694 }
 695
 696 /*
 697  * edac_device_remove_instance
 698  *      remove an edac_device instance
 699  */
 700 static void edac_device_delete_instance(struct edac_device_ctl_info *edac_dev,
 701                                         int idx)
 702 {
 703         struct edac_device_instance *instance;
 704         int i;
 705
 706         instance = &edac_dev->instances[idx];
 707
 708         /* unregister all blocks in this instance */
 709         for (i = 0; i < instance->nr_blocks; i++)
 710                 edac_device_delete_block(edac_dev, &instance->blocks[i]);
 711
 712         /* unregister this instance's kobject, SEE:
 713          *      edac_device_ctrl_instance_release() for callback operation
 714          */
 715         kobject_unregister(&instance->kobj);
 716 }
 717
 718 /*
 719  * edac_device_create_instances
 720  *      create the first level of 'instances' for this device
 721  *      (ie  'cache' might have 'cache0', 'cache1', 'cache2', etc
 722  */
 723 static int edac_device_create_instances(struct edac_device_ctl_info *edac_dev)
 724 {
 725         int i, j;
 726         int err;
 727
 728         debugf0("%s()\n", __func__);
 729
 730         /* iterate over creation of the instances */
 731         for (i = 0; i < edac_dev->nr_instances; i++) {
 732                 err = edac_device_create_instance(edac_dev, i);
 733                 if (err) {
 734                         /* unwind previous instances on error */
 735                         for (j = 0; j < i; j++)
 736                                 edac_device_delete_instance(edac_dev, j);
 737                         return err;
 738                 }
 739         }
 740
 741         return 0;
 742 }
 743
 744 /*
 745  * edac_device_delete_instances(edac_dev);
 746  *      unregister all the kobjects of the instances
 747  */
 748 static void edac_device_delete_instances(struct edac_device_ctl_info *edac_dev)
 749 {
 750         int i;
 751
 752         /* iterate over creation of the instances */
 753         for (i = 0; i < edac_dev->nr_instances; i++)
 754                 edac_device_delete_instance(edac_dev, i);
 755 }
 756
 757 /* edac_dev sysfs ctor/dtor  code */
 758
 759 /*
 760  * edac_device_add_main_sysfs_attributes
 761  *      add some attributes to this instance's main kobject
 762  */
 763 static int edac_device_add_main_sysfs_attributes(
 764                         struct edac_device_ctl_info *edac_dev)
 765 {
 766         struct edac_dev_sysfs_attribute *sysfs_attrib;
 767         int err = 0;
 768
 769         sysfs_attrib = edac_dev->sysfs_attributes;
 770         if (sysfs_attrib) {
 771                 /* iterate over the array and create an attribute for each
 772                  * entry in the list
 773                  */
 774                 while (sysfs_attrib->attr.name != NULL) {
 775                         err = sysfs_create_file(&edac_dev->kobj,
 776                                 (struct attribute*) sysfs_attrib);
 777                         if (err)
 778                                 goto err_out;
 779
 780                         sysfs_attrib++;
 781                 }
 782         }
 783
 784 err_out:
 785         return err;
 786 }
 787
 788 /*
 789  * edac_device_remove_main_sysfs_attributes
 790  *      remove any attributes to this instance's main kobject
 791  */
 792 static void edac_device_remove_main_sysfs_attributes(
 793                         struct edac_device_ctl_info *edac_dev)
 794 {
 795         struct edac_dev_sysfs_attribute *sysfs_attrib;
 796
 797         /* if there are main attributes, defined, remove them. First,
 798          * point to the start of the array and iterate over it
 799          * removing each attribute listed from this device's instance's kobject
 800          */
 801         sysfs_attrib = edac_dev->sysfs_attributes;
 802         if (sysfs_attrib) {
 803                 while (sysfs_attrib->attr.name != NULL) {
 804                         sysfs_remove_file(&edac_dev->kobj,
 805                                         (struct attribute *) sysfs_attrib);
 806                         sysfs_attrib++;
 807                 }
 808         }
 809 }
 810
 811 /*
 812  * edac_device_create_sysfs() Constructor
 813  *
 814  * accept a created edac_device control structure
 815  * and 'export' it to sysfs. The 'main' kobj should already have been
 816  * created. 'instance' and 'block' kobjects should be registered
 817  * along with any 'block' attributes from the low driver. In addition,
 818  * the main attributes (if any) are connected to the main kobject of
 819  * the control structure.
 820  *
 821  * Return:
 822  *      0       Success
 823  *      !0      Failure
 824  */
 825 int edac_device_create_sysfs(struct edac_device_ctl_info *edac_dev)
 826 {
 827         int err;
 828         struct kobject *edac_kobj = &edac_dev->kobj;
 829
 830         debugf0("%s() idx=%d\n", __func__, edac_dev->dev_idx);
 831
 832         /*  go create any main attributes callers wants */
 833         err = edac_device_add_main_sysfs_attributes(edac_dev);
 834         if (err) {
 835                 debugf0("%s() failed to add sysfs attribs\n", __func__);
 836                 goto err_out;
 837         }
 838
 839         /* create a symlink from the edac device
 840          * to the platform 'device' being used for this
 841          */
 842         err = sysfs_create_link(edac_kobj,
 843                                 &edac_dev->dev->kobj, EDAC_DEVICE_SYMLINK);
 844         if (err) {
 845                 debugf0("%s() sysfs_create_link() returned err= %d\n",
 846                         __func__, err);
 847                 goto err_remove_main_attribs;
 848         }
 849
 850         /* Create the first level instance directories
 851          * In turn, the nested blocks beneath the instances will
 852          * be registered as well
 853          */
 854         err = edac_device_create_instances(edac_dev);
 855         if (err) {
 856                 debugf0("%s() edac_device_create_instances() "
 857                         "returned err= %d\n", __func__, err);
 858                 goto err_remove_link;
 859         }
 860
 861
 862         debugf4("%s() create-instances done, idx=%d\n",
 863                 __func__, edac_dev->dev_idx);
 864
 865         return 0;
 866
 867         /* Error unwind stack */
 868 err_remove_link:
 869         /* remove the sym link */
 870         sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK);
 871
 872 err_remove_main_attribs:
 873         edac_device_remove_main_sysfs_attributes(edac_dev);
 874
 875 err_out:
 876         return err;
 877 }
 878
 879 /*
 880  * edac_device_remove_sysfs() destructor
 881  *
 882  * given an edac_device struct, tear down the kobject resources
 883  */
 884 void edac_device_remove_sysfs(struct edac_device_ctl_info *edac_dev)
 885 {
 886         debugf0("%s()\n", __func__);
 887
 888         /* remove any main attributes for this device */
 889         edac_device_remove_main_sysfs_attributes(edac_dev);
 890
 891         /* remove the device sym link */
 892         sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK);
 893
 894         /* walk the instance/block kobject tree, deconstructing it */
 895         edac_device_delete_instances(edac_dev);
 896 }