Input: remove cdev from input_dev structure
[linux-2.6] / 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 }