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_put(&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_put(&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_put(&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_put(&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_put(&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 }
882