10e5b19a3e3be62a1e749c531b3c86b5c8b39830
[linux-2.6.git] / 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
250         /* Record which module 'owns' this control structure
251          * and bump the ref count of the module
252          */
253         edac_dev->owner = THIS_MODULE;
254
255         if (!try_module_get(edac_dev->owner)) {
256                 err = -ENODEV;
257                 goto err_out;
258         }
259
260         /* register */
261         err = kobject_init_and_add(&edac_dev->kobj, &ktype_device_ctrl,
262                                    &edac_class->kset.kobj,
263                                    "%s", edac_dev->name);
264         if (err) {
265                 debugf1("%s()Failed to register '.../edac/%s'\n",
266                         __func__, edac_dev->name);
267                 goto err_kobj_reg;
268         }
269         kobject_uevent(&edac_dev->kobj, KOBJ_ADD);
270
271         /* At this point, to 'free' the control struct,
272          * edac_device_unregister_sysfs_main_kobj() must be used
273          */
274
275         debugf4("%s() Registered '.../edac/%s' kobject\n",
276                 __func__, edac_dev->name);
277
278         return 0;
279
280         /* Error exit stack */
281 err_kobj_reg:
282         module_put(edac_dev->owner);
283
284 err_out:
285         return err;
286 }
287
288 /*
289  * edac_device_unregister_sysfs_main_kobj:
290  *      the '..../edac/<name>' kobject
291  */
292 void edac_device_unregister_sysfs_main_kobj(
293                                         struct edac_device_ctl_info *edac_dev)
294 {
295         debugf0("%s()\n", __func__);
296         debugf4("%s() name of kobject is: %s\n",
297                 __func__, kobject_name(&edac_dev->kobj));
298
299         /*
300          * Unregister the edac device's kobject and
301          * allow for reference count to reach 0 at which point
302          * the callback will be called to:
303          *   a) module_put() this module
304          *   b) 'kfree' the memory
305          */
306         kobject_unregister(&edac_dev->kobj);
307 }
308
309 /* edac_dev -> instance information */
310
311 /*
312  * Set of low-level instance attribute show functions
313  */
314 static ssize_t instance_ue_count_show(struct edac_device_instance *instance,
315                                 char *data)
316 {
317         return sprintf(data, "%u\n", instance->counters.ue_count);
318 }
319
320 static ssize_t instance_ce_count_show(struct edac_device_instance *instance,
321                                 char *data)
322 {
323         return sprintf(data, "%u\n", instance->counters.ce_count);
324 }
325
326 #define to_instance(k) container_of(k, struct edac_device_instance, kobj)
327 #define to_instance_attr(a) container_of(a,struct instance_attribute,attr)
328
329 /* DEVICE instance kobject release() function */
330 static void edac_device_ctrl_instance_release(struct kobject *kobj)
331 {
332         struct edac_device_instance *instance;
333
334         debugf1("%s()\n", __func__);
335
336         /* map from this kobj to the main control struct
337          * and then dec the main kobj count
338          */
339         instance = to_instance(kobj);
340         kobject_put(&instance->ctl->kobj);
341 }
342
343 /* instance specific attribute structure */
344 struct instance_attribute {
345         struct attribute attr;
346         ssize_t(*show) (struct edac_device_instance *, char *);
347         ssize_t(*store) (struct edac_device_instance *, const char *, size_t);
348 };
349
350 /* Function to 'show' fields from the edac_dev 'instance' structure */
351 static ssize_t edac_dev_instance_show(struct kobject *kobj,
352                                 struct attribute *attr, char *buffer)
353 {
354         struct edac_device_instance *instance = to_instance(kobj);
355         struct instance_attribute *instance_attr = to_instance_attr(attr);
356
357         if (instance_attr->show)
358                 return instance_attr->show(instance, buffer);
359         return -EIO;
360 }
361
362 /* Function to 'store' fields into the edac_dev 'instance' structure */
363 static ssize_t edac_dev_instance_store(struct kobject *kobj,
364                                 struct attribute *attr,
365                                 const char *buffer, size_t count)
366 {
367         struct edac_device_instance *instance = to_instance(kobj);
368         struct instance_attribute *instance_attr = to_instance_attr(attr);
369
370         if (instance_attr->store)
371                 return instance_attr->store(instance, buffer, count);
372         return -EIO;
373 }
374
375 /* edac_dev file operations for an 'instance' */
376 static struct sysfs_ops device_instance_ops = {
377         .show = edac_dev_instance_show,
378         .store = edac_dev_instance_store
379 };
380
381 #define INSTANCE_ATTR(_name,_mode,_show,_store)        \
382 static struct instance_attribute attr_instance_##_name = {      \
383         .attr = {.name = __stringify(_name), .mode = _mode },   \
384         .show   = _show,                                        \
385         .store  = _store,                                       \
386 };
387
388 /*
389  * Define attributes visible for the edac_device instance object
390  *      Each contains a pointer to a show and an optional set
391  *      function pointer that does the low level output/input
392  */
393 INSTANCE_ATTR(ce_count, S_IRUGO, instance_ce_count_show, NULL);
394 INSTANCE_ATTR(ue_count, S_IRUGO, instance_ue_count_show, NULL);
395
396 /* list of edac_dev 'instance' attributes */
397 static struct instance_attribute *device_instance_attr[] = {
398         &attr_instance_ce_count,
399         &attr_instance_ue_count,
400         NULL,
401 };
402
403 /* The 'ktype' for each edac_dev 'instance' */
404 static struct kobj_type ktype_instance_ctrl = {
405         .release = edac_device_ctrl_instance_release,
406         .sysfs_ops = &device_instance_ops,
407         .default_attrs = (struct attribute **)device_instance_attr,
408 };
409
410 /* edac_dev -> instance -> block information */
411
412 #define to_block(k) container_of(k, struct edac_device_block, kobj)
413 #define to_block_attr(a) \
414         container_of(a, struct edac_dev_sysfs_block_attribute, attr)
415
416 /*
417  * Set of low-level block attribute show functions
418  */
419 static ssize_t block_ue_count_show(struct kobject *kobj,
420                                         struct attribute *attr, char *data)
421 {
422         struct edac_device_block *block = to_block(kobj);
423
424         return sprintf(data, "%u\n", block->counters.ue_count);
425 }
426
427 static ssize_t block_ce_count_show(struct kobject *kobj,
428                                         struct attribute *attr, char *data)
429 {
430         struct edac_device_block *block = to_block(kobj);
431
432         return sprintf(data, "%u\n", block->counters.ce_count);
433 }
434
435 /* DEVICE block kobject release() function */
436 static void edac_device_ctrl_block_release(struct kobject *kobj)
437 {
438         struct edac_device_block *block;
439
440         debugf1("%s()\n", __func__);
441
442         /* get the container of the kobj */
443         block = to_block(kobj);
444
445         /* map from 'block kobj' to 'block->instance->controller->main_kobj'
446          * now 'release' the block kobject
447          */
448         kobject_put(&block->instance->ctl->kobj);
449 }
450
451
452 /* Function to 'show' fields from the edac_dev 'block' structure */
453 static ssize_t edac_dev_block_show(struct kobject *kobj,
454                                 struct attribute *attr, char *buffer)
455 {
456         struct edac_dev_sysfs_block_attribute *block_attr =
457                                                 to_block_attr(attr);
458
459         if (block_attr->show)
460                 return block_attr->show(kobj, attr, buffer);
461         return -EIO;
462 }
463
464 /* Function to 'store' fields into the edac_dev 'block' structure */
465 static ssize_t edac_dev_block_store(struct kobject *kobj,
466                                 struct attribute *attr,
467                                 const char *buffer, size_t count)
468 {
469         struct edac_dev_sysfs_block_attribute *block_attr;
470
471         block_attr = to_block_attr(attr);
472
473         if (block_attr->store)
474                 return block_attr->store(kobj, attr, buffer, count);
475         return -EIO;
476 }
477
478 /* edac_dev file operations for a 'block' */
479 static struct sysfs_ops device_block_ops = {
480         .show = edac_dev_block_show,
481         .store = edac_dev_block_store
482 };
483
484 #define BLOCK_ATTR(_name,_mode,_show,_store)        \
485 static struct edac_dev_sysfs_block_attribute attr_block_##_name = {     \
486         .attr = {.name = __stringify(_name), .mode = _mode },   \
487         .show   = _show,                                        \
488         .store  = _store,                                       \
489 };
490
491 BLOCK_ATTR(ce_count, S_IRUGO, block_ce_count_show, NULL);
492 BLOCK_ATTR(ue_count, S_IRUGO, block_ue_count_show, NULL);
493
494 /* list of edac_dev 'block' attributes */
495 static struct edac_dev_sysfs_block_attribute *device_block_attr[] = {
496         &attr_block_ce_count,
497         &attr_block_ue_count,
498         NULL,
499 };
500
501 /* The 'ktype' for each edac_dev 'block' */
502 static struct kobj_type ktype_block_ctrl = {
503         .release = edac_device_ctrl_block_release,
504         .sysfs_ops = &device_block_ops,
505         .default_attrs = (struct attribute **)device_block_attr,
506 };
507
508 /* block ctor/dtor  code */
509
510 /*
511  * edac_device_create_block
512  */
513 static int edac_device_create_block(struct edac_device_ctl_info *edac_dev,
514                                 struct edac_device_instance *instance,
515                                 struct edac_device_block *block)
516 {
517         int i;
518         int err;
519         struct edac_dev_sysfs_block_attribute *sysfs_attrib;
520         struct kobject *main_kobj;
521
522         debugf4("%s() Instance '%s' inst_p=%p  block '%s'  block_p=%p\n",
523                 __func__, instance->name, instance, block->name, block);
524         debugf4("%s() block kobj=%p  block kobj->parent=%p\n",
525                 __func__, &block->kobj, &block->kobj.parent);
526
527         /* init this block's kobject */
528         memset(&block->kobj, 0, sizeof(struct kobject));
529
530         /* bump the main kobject's reference count for this controller
531          * and this instance is dependant on the main
532          */
533         main_kobj = kobject_get(&edac_dev->kobj);
534         if (!main_kobj) {
535                 err = -ENODEV;
536                 goto err_out;
537         }
538
539         /* Add this block's kobject */
540         err = kobject_init_and_add(&block->kobj, &ktype_block_ctrl,
541                                    &instance->kobj,
542                                    "%s", block->name);
543         if (err) {
544                 debugf1("%s() Failed to register instance '%s'\n",
545                         __func__, block->name);
546                 kobject_put(main_kobj);
547                 err = -ENODEV;
548                 goto err_out;
549         }
550
551         /* If there are driver level block attributes, then added them
552          * to the block kobject
553          */
554         sysfs_attrib = block->block_attributes;
555         if (sysfs_attrib && block->nr_attribs) {
556                 for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) {
557
558                         debugf4("%s() creating block attrib='%s' "
559                                 "attrib->%p to kobj=%p\n",
560                                 __func__,
561                                 sysfs_attrib->attr.name,
562                                 sysfs_attrib, &block->kobj);
563
564                         /* Create each block_attribute file */
565                         err = sysfs_create_file(&block->kobj,
566                                 &sysfs_attrib->attr);
567                         if (err)
568                                 goto err_on_attrib;
569                 }
570         }
571         kobject_uevent(&block->kobj, KOBJ_ADD);
572
573         return 0;
574
575         /* Error unwind stack */
576 err_on_attrib:
577         kobject_unregister(&block->kobj);
578
579 err_out:
580         return err;
581 }
582
583 /*
584  * edac_device_delete_block(edac_dev,block);
585  */
586 static void edac_device_delete_block(struct edac_device_ctl_info *edac_dev,
587                                 struct edac_device_block *block)
588 {
589         struct edac_dev_sysfs_block_attribute *sysfs_attrib;
590         int i;
591
592         /* if this block has 'attributes' then we need to iterate over the list
593          * and 'remove' the attributes on this block
594          */
595         sysfs_attrib = block->block_attributes;
596         if (sysfs_attrib && block->nr_attribs) {
597                 for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) {
598
599                         /* remove each block_attrib file */
600                         sysfs_remove_file(&block->kobj,
601                                 (struct attribute *) sysfs_attrib);
602                 }
603         }
604
605         /* unregister this block's kobject, SEE:
606          *      edac_device_ctrl_block_release() callback operation
607          */
608         kobject_unregister(&block->kobj);
609 }
610
611 /* instance ctor/dtor code */
612
613 /*
614  * edac_device_create_instance
615  *      create just one instance of an edac_device 'instance'
616  */
617 static int edac_device_create_instance(struct edac_device_ctl_info *edac_dev,
618                                 int idx)
619 {
620         int i, j;
621         int err;
622         struct edac_device_instance *instance;
623         struct kobject *main_kobj;
624
625         instance = &edac_dev->instances[idx];
626
627         /* Init the instance's kobject */
628         memset(&instance->kobj, 0, sizeof(struct kobject));
629
630         instance->ctl = edac_dev;
631
632         /* bump the main kobject's reference count for this controller
633          * and this instance is dependant on the main
634          */
635         main_kobj = kobject_get(&edac_dev->kobj);
636         if (!main_kobj) {
637                 err = -ENODEV;
638                 goto err_out;
639         }
640
641         /* Formally register this instance's kobject under the edac_device */
642         err = kobject_init_and_add(&instance->kobj, &ktype_instance_ctrl,
643                                    &edac_dev->kobj, "%s", instance->name);
644         if (err != 0) {
645                 debugf2("%s() Failed to register instance '%s'\n",
646                         __func__, instance->name);
647                 kobject_put(main_kobj);
648                 goto err_out;
649         }
650
651         debugf4("%s() now register '%d' blocks for instance %d\n",
652                 __func__, instance->nr_blocks, idx);
653
654         /* register all blocks of this instance */
655         for (i = 0; i < instance->nr_blocks; i++) {
656                 err = edac_device_create_block(edac_dev, instance,
657                                                 &instance->blocks[i]);
658                 if (err) {
659                         /* If any fail, remove all previous ones */
660                         for (j = 0; j < i; j++)
661                                 edac_device_delete_block(edac_dev,
662                                                         &instance->blocks[j]);
663                         goto err_release_instance_kobj;
664                 }
665         }
666         kobject_uevent(&instance->kobj, KOBJ_ADD);
667
668         debugf4("%s() Registered instance %d '%s' kobject\n",
669                 __func__, idx, instance->name);
670
671         return 0;
672
673         /* error unwind stack */
674 err_release_instance_kobj:
675         kobject_unregister(&instance->kobj);
676
677 err_out:
678         return err;
679 }
680
681 /*
682  * edac_device_remove_instance
683  *      remove an edac_device instance
684  */
685 static void edac_device_delete_instance(struct edac_device_ctl_info *edac_dev,
686                                         int idx)
687 {
688         struct edac_device_instance *instance;
689         int i;
690
691         instance = &edac_dev->instances[idx];
692
693         /* unregister all blocks in this instance */
694         for (i = 0; i < instance->nr_blocks; i++)
695                 edac_device_delete_block(edac_dev, &instance->blocks[i]);
696
697         /* unregister this instance's kobject, SEE:
698          *      edac_device_ctrl_instance_release() for callback operation
699          */
700         kobject_unregister(&instance->kobj);
701 }
702
703 /*
704  * edac_device_create_instances
705  *      create the first level of 'instances' for this device
706  *      (ie  'cache' might have 'cache0', 'cache1', 'cache2', etc
707  */
708 static int edac_device_create_instances(struct edac_device_ctl_info *edac_dev)
709 {
710         int i, j;
711         int err;
712
713         debugf0("%s()\n", __func__);
714
715         /* iterate over creation of the instances */
716         for (i = 0; i < edac_dev->nr_instances; i++) {
717                 err = edac_device_create_instance(edac_dev, i);
718                 if (err) {
719                         /* unwind previous instances on error */
720                         for (j = 0; j < i; j++)
721                                 edac_device_delete_instance(edac_dev, j);
722                         return err;
723                 }
724         }
725
726         return 0;
727 }
728
729 /*
730  * edac_device_delete_instances(edac_dev);
731  *      unregister all the kobjects of the instances
732  */
733 static void edac_device_delete_instances(struct edac_device_ctl_info *edac_dev)
734 {
735         int i;
736
737         /* iterate over creation of the instances */
738         for (i = 0; i < edac_dev->nr_instances; i++)
739                 edac_device_delete_instance(edac_dev, i);
740 }
741
742 /* edac_dev sysfs ctor/dtor  code */
743
744 /*
745  * edac_device_add_main_sysfs_attributes
746  *      add some attributes to this instance's main kobject
747  */
748 static int edac_device_add_main_sysfs_attributes(
749                         struct edac_device_ctl_info *edac_dev)
750 {
751         struct edac_dev_sysfs_attribute *sysfs_attrib;
752         int err = 0;
753
754         sysfs_attrib = edac_dev->sysfs_attributes;
755         if (sysfs_attrib) {
756                 /* iterate over the array and create an attribute for each
757                  * entry in the list
758                  */
759                 while (sysfs_attrib->attr.name != NULL) {
760                         err = sysfs_create_file(&edac_dev->kobj,
761                                 (struct attribute*) sysfs_attrib);
762                         if (err)
763                                 goto err_out;
764
765                         sysfs_attrib++;
766                 }
767         }
768
769 err_out:
770         return err;
771 }
772
773 /*
774  * edac_device_remove_main_sysfs_attributes
775  *      remove any attributes to this instance's main kobject
776  */
777 static void edac_device_remove_main_sysfs_attributes(
778                         struct edac_device_ctl_info *edac_dev)
779 {
780         struct edac_dev_sysfs_attribute *sysfs_attrib;
781
782         /* if there are main attributes, defined, remove them. First,
783          * point to the start of the array and iterate over it
784          * removing each attribute listed from this device's instance's kobject
785          */
786         sysfs_attrib = edac_dev->sysfs_attributes;
787         if (sysfs_attrib) {
788                 while (sysfs_attrib->attr.name != NULL) {
789                         sysfs_remove_file(&edac_dev->kobj,
790                                         (struct attribute *) sysfs_attrib);
791                         sysfs_attrib++;
792                 }
793         }
794 }
795
796 /*
797  * edac_device_create_sysfs() Constructor
798  *
799  * accept a created edac_device control structure
800  * and 'export' it to sysfs. The 'main' kobj should already have been
801  * created. 'instance' and 'block' kobjects should be registered
802  * along with any 'block' attributes from the low driver. In addition,
803  * the main attributes (if any) are connected to the main kobject of
804  * the control structure.
805  *
806  * Return:
807  *      0       Success
808  *      !0      Failure
809  */
810 int edac_device_create_sysfs(struct edac_device_ctl_info *edac_dev)
811 {
812         int err;
813         struct kobject *edac_kobj = &edac_dev->kobj;
814
815         debugf0("%s() idx=%d\n", __func__, edac_dev->dev_idx);
816
817         /*  go create any main attributes callers wants */
818         err = edac_device_add_main_sysfs_attributes(edac_dev);
819         if (err) {
820                 debugf0("%s() failed to add sysfs attribs\n", __func__);
821                 goto err_out;
822         }
823
824         /* create a symlink from the edac device
825          * to the platform 'device' being used for this
826          */
827         err = sysfs_create_link(edac_kobj,
828                                 &edac_dev->dev->kobj, EDAC_DEVICE_SYMLINK);
829         if (err) {
830                 debugf0("%s() sysfs_create_link() returned err= %d\n",
831                         __func__, err);
832                 goto err_remove_main_attribs;
833         }
834
835         /* Create the first level instance directories
836          * In turn, the nested blocks beneath the instances will
837          * be registered as well
838          */
839         err = edac_device_create_instances(edac_dev);
840         if (err) {
841                 debugf0("%s() edac_device_create_instances() "
842                         "returned err= %d\n", __func__, err);
843                 goto err_remove_link;
844         }
845
846
847         debugf4("%s() create-instances done, idx=%d\n",
848                 __func__, edac_dev->dev_idx);
849
850         return 0;
851
852         /* Error unwind stack */
853 err_remove_link:
854         /* remove the sym link */
855         sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK);
856
857 err_remove_main_attribs:
858         edac_device_remove_main_sysfs_attributes(edac_dev);
859
860 err_out:
861         return err;
862 }
863
864 /*
865  * edac_device_remove_sysfs() destructor
866  *
867  * given an edac_device struct, tear down the kobject resources
868  */
869 void edac_device_remove_sysfs(struct edac_device_ctl_info *edac_dev)
870 {
871         debugf0("%s()\n", __func__);
872
873         /* remove any main attributes for this device */
874         edac_device_remove_main_sysfs_attributes(edac_dev);
875
876         /* remove the device sym link */
877         sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK);
878
879         /* walk the instance/block kobject tree, deconstructing it */
880         edac_device_delete_instances(edac_dev);
881 }