1/*
2 * file for managing the edac_device subsystem of devices for EDAC
3 *
4 * (C) 2007 SoftwareBitMaker
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#include <linux/slab.h>
16#include <linux/edac.h>
17
18#include "edac_core.h"
19#include "edac_module.h"
20
21#define EDAC_DEVICE_SYMLINK	"device"
22
23#define to_edacdev(k) container_of(k, struct edac_device_ctl_info, kobj)
24#define to_edacdev_attr(a) container_of(a, struct edacdev_attribute, attr)
25
26
27/*
28 * Set of edac_device_ctl_info attribute store/show functions
29 */
30
31/* 'log_ue' */
32static ssize_t edac_device_ctl_log_ue_show(struct edac_device_ctl_info
33					*ctl_info, char *data)
34{
35	return sprintf(data, "%u\n", ctl_info->log_ue);
36}
37
38static ssize_t edac_device_ctl_log_ue_store(struct edac_device_ctl_info
39					*ctl_info, const char *data,
40					size_t count)
41{
42	/* if parameter is zero, turn off flag, if non-zero turn on flag */
43	ctl_info->log_ue = (simple_strtoul(data, NULL, 0) != 0);
44
45	return count;
46}
47
48/* 'log_ce' */
49static ssize_t edac_device_ctl_log_ce_show(struct edac_device_ctl_info
50					*ctl_info, char *data)
51{
52	return sprintf(data, "%u\n", ctl_info->log_ce);
53}
54
55static ssize_t edac_device_ctl_log_ce_store(struct edac_device_ctl_info
56					*ctl_info, const char *data,
57					size_t count)
58{
59	/* if parameter is zero, turn off flag, if non-zero turn on flag */
60	ctl_info->log_ce = (simple_strtoul(data, NULL, 0) != 0);
61
62	return count;
63}
64
65/* 'panic_on_ue' */
66static ssize_t edac_device_ctl_panic_on_ue_show(struct edac_device_ctl_info
67						*ctl_info, char *data)
68{
69	return sprintf(data, "%u\n", ctl_info->panic_on_ue);
70}
71
72static ssize_t edac_device_ctl_panic_on_ue_store(struct edac_device_ctl_info
73						 *ctl_info, const char *data,
74						 size_t count)
75{
76	/* if parameter is zero, turn off flag, if non-zero turn on flag */
77	ctl_info->panic_on_ue = (simple_strtoul(data, NULL, 0) != 0);
78
79	return count;
80}
81
82/* 'poll_msec' show and store functions*/
83static ssize_t edac_device_ctl_poll_msec_show(struct edac_device_ctl_info
84					*ctl_info, char *data)
85{
86	return sprintf(data, "%u\n", ctl_info->poll_msec);
87}
88
89static ssize_t edac_device_ctl_poll_msec_store(struct edac_device_ctl_info
90					*ctl_info, const char *data,
91					size_t count)
92{
93	unsigned long value;
94
95	/* get the value and enforce that it is non-zero, must be at least
96	 * one millisecond for the delay period, between scans
97	 * Then cancel last outstanding delay for the work request
98	 * and set a new one.
99	 */
100	value = simple_strtoul(data, NULL, 0);
101	edac_device_reset_delay_period(ctl_info, value);
102
103	return count;
104}
105
106/* edac_device_ctl_info specific attribute structure */
107struct ctl_info_attribute {
108	struct attribute attr;
109	ssize_t(*show) (struct edac_device_ctl_info *, char *);
110	ssize_t(*store) (struct edac_device_ctl_info *, const char *, size_t);
111};
112
113#define to_ctl_info(k) container_of(k, struct edac_device_ctl_info, kobj)
114#define to_ctl_info_attr(a) container_of(a,struct ctl_info_attribute,attr)
115
116/* Function to 'show' fields from the edac_dev 'ctl_info' structure */
117static ssize_t edac_dev_ctl_info_show(struct kobject *kobj,
118				struct attribute *attr, char *buffer)
119{
120	struct edac_device_ctl_info *edac_dev = to_ctl_info(kobj);
121	struct ctl_info_attribute *ctl_info_attr = to_ctl_info_attr(attr);
122
123	if (ctl_info_attr->show)
124		return ctl_info_attr->show(edac_dev, buffer);
125	return -EIO;
126}
127
128/* Function to 'store' fields into the edac_dev 'ctl_info' structure */
129static ssize_t edac_dev_ctl_info_store(struct kobject *kobj,
130				struct attribute *attr,
131				const char *buffer, size_t count)
132{
133	struct edac_device_ctl_info *edac_dev = to_ctl_info(kobj);
134	struct ctl_info_attribute *ctl_info_attr = to_ctl_info_attr(attr);
135
136	if (ctl_info_attr->store)
137		return ctl_info_attr->store(edac_dev, buffer, count);
138	return -EIO;
139}
140
141/* edac_dev file operations for an 'ctl_info' */
142static const struct sysfs_ops device_ctl_info_ops = {
143	.show = edac_dev_ctl_info_show,
144	.store = edac_dev_ctl_info_store
145};
146
147#define CTL_INFO_ATTR(_name,_mode,_show,_store)        \
148static struct ctl_info_attribute attr_ctl_info_##_name = {      \
149	.attr = {.name = __stringify(_name), .mode = _mode },   \
150	.show   = _show,                                        \
151	.store  = _store,                                       \
152};
153
154/* Declare the various ctl_info attributes here and their respective ops */
155CTL_INFO_ATTR(log_ue, S_IRUGO | S_IWUSR,
156	edac_device_ctl_log_ue_show, edac_device_ctl_log_ue_store);
157CTL_INFO_ATTR(log_ce, S_IRUGO | S_IWUSR,
158	edac_device_ctl_log_ce_show, edac_device_ctl_log_ce_store);
159CTL_INFO_ATTR(panic_on_ue, S_IRUGO | S_IWUSR,
160	edac_device_ctl_panic_on_ue_show,
161	edac_device_ctl_panic_on_ue_store);
162CTL_INFO_ATTR(poll_msec, S_IRUGO | S_IWUSR,
163	edac_device_ctl_poll_msec_show, edac_device_ctl_poll_msec_store);
164
165/* Base Attributes of the EDAC_DEVICE ECC object */
166static struct ctl_info_attribute *device_ctrl_attr[] = {
167	&attr_ctl_info_panic_on_ue,
168	&attr_ctl_info_log_ue,
169	&attr_ctl_info_log_ce,
170	&attr_ctl_info_poll_msec,
171	NULL,
172};
173
174/*
175 * edac_device_ctrl_master_release
176 *
177 *	called when the reference count for the 'main' kobj
178 *	for a edac_device control struct reaches zero
179 *
180 *	Reference count model:
181 *		One 'main' kobject for each control structure allocated.
182 *		That main kobj is initially set to one AND
183 *		the reference count for the EDAC 'core' module is
184 *		bumped by one, thus added 'keep in memory' dependency.
185 *
186 *		Each new internal kobj (in instances and blocks) then
187 *		bumps the 'main' kobject.
188 *
189 *		When they are released their release functions decrement
190 *		the 'main' kobj.
191 *
192 *		When the main kobj reaches zero (0) then THIS function
193 *		is called which then decrements the EDAC 'core' module.
194 *		When the module reference count reaches zero then the
195 *		module no longer has dependency on keeping the release
196 *		function code in memory and module can be unloaded.
197 *
198 *		This will support several control objects as well, each
199 *		with its own 'main' kobj.
200 */
201static void edac_device_ctrl_master_release(struct kobject *kobj)
202{
203	struct edac_device_ctl_info *edac_dev = to_edacdev(kobj);
204
205	edac_dbg(4, "control index=%d\n", edac_dev->dev_idx);
206
207	/* decrement the EDAC CORE module ref count */
208	module_put(edac_dev->owner);
209
210	/* free the control struct containing the 'main' kobj
211	 * passed in to this routine
212	 */
213	kfree(edac_dev);
214}
215
216/* ktype for the main (master) kobject */
217static struct kobj_type ktype_device_ctrl = {
218	.release = edac_device_ctrl_master_release,
219	.sysfs_ops = &device_ctl_info_ops,
220	.default_attrs = (struct attribute **)device_ctrl_attr,
221};
222
223/*
224 * edac_device_register_sysfs_main_kobj
225 *
226 *	perform the high level setup for the new edac_device instance
227 *
228 * Return:  0 SUCCESS
229 *         !0 FAILURE
230 */
231int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev)
232{
233	struct bus_type *edac_subsys;
234	int err;
235
236	edac_dbg(1, "\n");
237
238	/* get the /sys/devices/system/edac reference */
239	edac_subsys = edac_get_sysfs_subsys();
240	if (edac_subsys == NULL) {
241		edac_dbg(1, "no edac_subsys error\n");
242		err = -ENODEV;
243		goto err_out;
244	}
245
246	/* Point to the 'edac_subsys' this instance 'reports' to */
247	edac_dev->edac_subsys = edac_subsys;
248
249	/* Init the devices's kobject */
250	memset(&edac_dev->kobj, 0, sizeof(struct kobject));
251
252	/* Record which module 'owns' this control structure
253	 * and bump the ref count of the module
254	 */
255	edac_dev->owner = THIS_MODULE;
256
257	if (!try_module_get(edac_dev->owner)) {
258		err = -ENODEV;
259		goto err_mod_get;
260	}
261
262	/* register */
263	err = kobject_init_and_add(&edac_dev->kobj, &ktype_device_ctrl,
264				   &edac_subsys->dev_root->kobj,
265				   "%s", edac_dev->name);
266	if (err) {
267		edac_dbg(1, "Failed to register '.../edac/%s'\n",
268			 edac_dev->name);
269		goto err_kobj_reg;
270	}
271	kobject_uevent(&edac_dev->kobj, KOBJ_ADD);
272
273	/* At this point, to 'free' the control struct,
274	 * edac_device_unregister_sysfs_main_kobj() must be used
275	 */
276
277	edac_dbg(4, "Registered '.../edac/%s' kobject\n", edac_dev->name);
278
279	return 0;
280
281	/* Error exit stack */
282err_kobj_reg:
283	module_put(edac_dev->owner);
284
285err_mod_get:
286	edac_put_sysfs_subsys();
287
288err_out:
289	return err;
290}
291
292/*
293 * edac_device_unregister_sysfs_main_kobj:
294 *	the '..../edac/<name>' kobject
295 */
296void edac_device_unregister_sysfs_main_kobj(struct edac_device_ctl_info *dev)
297{
298	edac_dbg(0, "\n");
299	edac_dbg(4, "name of kobject is: %s\n", kobject_name(&dev->kobj));
300
301	/*
302	 * Unregister the edac device's kobject and
303	 * allow for reference count to reach 0 at which point
304	 * the callback will be called to:
305	 *   a) module_put() this module
306	 *   b) 'kfree' the memory
307	 */
308	kobject_put(&dev->kobj);
309	edac_put_sysfs_subsys();
310}
311
312/* edac_dev -> instance information */
313
314/*
315 * Set of low-level instance attribute show functions
316 */
317static ssize_t instance_ue_count_show(struct edac_device_instance *instance,
318				char *data)
319{
320	return sprintf(data, "%u\n", instance->counters.ue_count);
321}
322
323static ssize_t instance_ce_count_show(struct edac_device_instance *instance,
324				char *data)
325{
326	return sprintf(data, "%u\n", instance->counters.ce_count);
327}
328
329#define to_instance(k) container_of(k, struct edac_device_instance, kobj)
330#define to_instance_attr(a) container_of(a,struct instance_attribute,attr)
331
332/* DEVICE instance kobject release() function */
333static void edac_device_ctrl_instance_release(struct kobject *kobj)
334{
335	struct edac_device_instance *instance;
336
337	edac_dbg(1, "\n");
338
339	/* map from this kobj to the main control struct
340	 * and then dec the main kobj count
341	 */
342	instance = to_instance(kobj);
343	kobject_put(&instance->ctl->kobj);
344}
345
346/* instance specific attribute structure */
347struct instance_attribute {
348	struct attribute attr;
349	ssize_t(*show) (struct edac_device_instance *, char *);
350	ssize_t(*store) (struct edac_device_instance *, const char *, size_t);
351};
352
353/* Function to 'show' fields from the edac_dev 'instance' structure */
354static ssize_t edac_dev_instance_show(struct kobject *kobj,
355				struct attribute *attr, char *buffer)
356{
357	struct edac_device_instance *instance = to_instance(kobj);
358	struct instance_attribute *instance_attr = to_instance_attr(attr);
359
360	if (instance_attr->show)
361		return instance_attr->show(instance, buffer);
362	return -EIO;
363}
364
365/* Function to 'store' fields into the edac_dev 'instance' structure */
366static ssize_t edac_dev_instance_store(struct kobject *kobj,
367				struct attribute *attr,
368				const char *buffer, size_t count)
369{
370	struct edac_device_instance *instance = to_instance(kobj);
371	struct instance_attribute *instance_attr = to_instance_attr(attr);
372
373	if (instance_attr->store)
374		return instance_attr->store(instance, buffer, count);
375	return -EIO;
376}
377
378/* edac_dev file operations for an 'instance' */
379static const struct sysfs_ops device_instance_ops = {
380	.show = edac_dev_instance_show,
381	.store = edac_dev_instance_store
382};
383
384#define INSTANCE_ATTR(_name,_mode,_show,_store)        \
385static struct instance_attribute attr_instance_##_name = {      \
386	.attr = {.name = __stringify(_name), .mode = _mode },   \
387	.show   = _show,                                        \
388	.store  = _store,                                       \
389};
390
391/*
392 * Define attributes visible for the edac_device instance object
393 *	Each contains a pointer to a show and an optional set
394 *	function pointer that does the low level output/input
395 */
396INSTANCE_ATTR(ce_count, S_IRUGO, instance_ce_count_show, NULL);
397INSTANCE_ATTR(ue_count, S_IRUGO, instance_ue_count_show, NULL);
398
399/* list of edac_dev 'instance' attributes */
400static struct instance_attribute *device_instance_attr[] = {
401	&attr_instance_ce_count,
402	&attr_instance_ue_count,
403	NULL,
404};
405
406/* The 'ktype' for each edac_dev 'instance' */
407static struct kobj_type ktype_instance_ctrl = {
408	.release = edac_device_ctrl_instance_release,
409	.sysfs_ops = &device_instance_ops,
410	.default_attrs = (struct attribute **)device_instance_attr,
411};
412
413/* edac_dev -> instance -> block information */
414
415#define to_block(k) container_of(k, struct edac_device_block, kobj)
416#define to_block_attr(a) \
417	container_of(a, struct edac_dev_sysfs_block_attribute, attr)
418
419/*
420 * Set of low-level block attribute show functions
421 */
422static ssize_t block_ue_count_show(struct kobject *kobj,
423					struct attribute *attr, char *data)
424{
425	struct edac_device_block *block = to_block(kobj);
426
427	return sprintf(data, "%u\n", block->counters.ue_count);
428}
429
430static ssize_t block_ce_count_show(struct kobject *kobj,
431					struct attribute *attr, char *data)
432{
433	struct edac_device_block *block = to_block(kobj);
434
435	return sprintf(data, "%u\n", block->counters.ce_count);
436}
437
438/* DEVICE block kobject release() function */
439static void edac_device_ctrl_block_release(struct kobject *kobj)
440{
441	struct edac_device_block *block;
442
443	edac_dbg(1, "\n");
444
445	/* get the container of the kobj */
446	block = to_block(kobj);
447
448	/* map from 'block kobj' to 'block->instance->controller->main_kobj'
449	 * now 'release' the block kobject
450	 */
451	kobject_put(&block->instance->ctl->kobj);
452}
453
454
455/* Function to 'show' fields from the edac_dev 'block' structure */
456static ssize_t edac_dev_block_show(struct kobject *kobj,
457				struct attribute *attr, char *buffer)
458{
459	struct edac_dev_sysfs_block_attribute *block_attr =
460						to_block_attr(attr);
461
462	if (block_attr->show)
463		return block_attr->show(kobj, attr, buffer);
464	return -EIO;
465}
466
467/* Function to 'store' fields into the edac_dev 'block' structure */
468static ssize_t edac_dev_block_store(struct kobject *kobj,
469				struct attribute *attr,
470				const char *buffer, size_t count)
471{
472	struct edac_dev_sysfs_block_attribute *block_attr;
473
474	block_attr = to_block_attr(attr);
475
476	if (block_attr->store)
477		return block_attr->store(kobj, attr, buffer, count);
478	return -EIO;
479}
480
481/* edac_dev file operations for a 'block' */
482static const struct sysfs_ops device_block_ops = {
483	.show = edac_dev_block_show,
484	.store = edac_dev_block_store
485};
486
487#define BLOCK_ATTR(_name,_mode,_show,_store)        \
488static struct edac_dev_sysfs_block_attribute attr_block_##_name = {	\
489	.attr = {.name = __stringify(_name), .mode = _mode },   \
490	.show   = _show,                                        \
491	.store  = _store,                                       \
492};
493
494BLOCK_ATTR(ce_count, S_IRUGO, block_ce_count_show, NULL);
495BLOCK_ATTR(ue_count, S_IRUGO, block_ue_count_show, NULL);
496
497/* list of edac_dev 'block' attributes */
498static struct edac_dev_sysfs_block_attribute *device_block_attr[] = {
499	&attr_block_ce_count,
500	&attr_block_ue_count,
501	NULL,
502};
503
504/* The 'ktype' for each edac_dev 'block' */
505static struct kobj_type ktype_block_ctrl = {
506	.release = edac_device_ctrl_block_release,
507	.sysfs_ops = &device_block_ops,
508	.default_attrs = (struct attribute **)device_block_attr,
509};
510
511/* block ctor/dtor  code */
512
513/*
514 * edac_device_create_block
515 */
516static int edac_device_create_block(struct edac_device_ctl_info *edac_dev,
517				struct edac_device_instance *instance,
518				struct edac_device_block *block)
519{
520	int i;
521	int err;
522	struct edac_dev_sysfs_block_attribute *sysfs_attrib;
523	struct kobject *main_kobj;
524
525	edac_dbg(4, "Instance '%s' inst_p=%p  block '%s'  block_p=%p\n",
526		 instance->name, instance, block->name, block);
527	edac_dbg(4, "block kobj=%p  block kobj->parent=%p\n",
528		 &block->kobj, &block->kobj.parent);
529
530	/* init this block's kobject */
531	memset(&block->kobj, 0, sizeof(struct kobject));
532
533	/* bump the main kobject's reference count for this controller
534	 * and this instance is dependent on the main
535	 */
536	main_kobj = kobject_get(&edac_dev->kobj);
537	if (!main_kobj) {
538		err = -ENODEV;
539		goto err_out;
540	}
541
542	/* Add this block's kobject */
543	err = kobject_init_and_add(&block->kobj, &ktype_block_ctrl,
544				   &instance->kobj,
545				   "%s", block->name);
546	if (err) {
547		edac_dbg(1, "Failed to register instance '%s'\n", block->name);
548		kobject_put(main_kobj);
549		err = -ENODEV;
550		goto err_out;
551	}
552
553	/* If there are driver level block attributes, then added them
554	 * to the block kobject
555	 */
556	sysfs_attrib = block->block_attributes;
557	if (sysfs_attrib && block->nr_attribs) {
558		for (i = 0; i < block->nr_attribs; i++, sysfs_attrib++) {
559
560			edac_dbg(4, "creating block attrib='%s' attrib->%p to kobj=%p\n",
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 */
576err_on_attrib:
577	kobject_put(&block->kobj);
578
579err_out:
580	return err;
581}
582
583/*
584 * edac_device_delete_block(edac_dev,block);
585 */
586static 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 */
617static 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 dependent 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		edac_dbg(2, "Failed to register instance '%s'\n",
646			 instance->name);
647		kobject_put(main_kobj);
648		goto err_out;
649	}
650
651	edac_dbg(4, "now register '%d' blocks for instance %d\n",
652		 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	edac_dbg(4, "Registered instance %d '%s' kobject\n",
669		 idx, instance->name);
670
671	return 0;
672
673	/* error unwind stack */
674err_release_instance_kobj:
675	kobject_put(&instance->kobj);
676
677err_out:
678	return err;
679}
680
681/*
682 * edac_device_remove_instance
683 *	remove an edac_device instance
684 */
685static 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 */
708static int edac_device_create_instances(struct edac_device_ctl_info *edac_dev)
709{
710	int i, j;
711	int err;
712
713	edac_dbg(0, "\n");
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 */
733static 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 */
748static 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
769err_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 */
777static 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 */
810int 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	edac_dbg(0, "idx=%d\n", 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		edac_dbg(0, "failed to add sysfs attribs\n");
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		edac_dbg(0, "sysfs_create_link() returned err= %d\n", err);
831		goto err_remove_main_attribs;
832	}
833
834	/* Create the first level instance directories
835	 * In turn, the nested blocks beneath the instances will
836	 * be registered as well
837	 */
838	err = edac_device_create_instances(edac_dev);
839	if (err) {
840		edac_dbg(0, "edac_device_create_instances() returned err= %d\n",
841			 err);
842		goto err_remove_link;
843	}
844
845
846	edac_dbg(4, "create-instances done, idx=%d\n", edac_dev->dev_idx);
847
848	return 0;
849
850	/* Error unwind stack */
851err_remove_link:
852	/* remove the sym link */
853	sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK);
854
855err_remove_main_attribs:
856	edac_device_remove_main_sysfs_attributes(edac_dev);
857
858err_out:
859	return err;
860}
861
862/*
863 * edac_device_remove_sysfs() destructor
864 *
865 * given an edac_device struct, tear down the kobject resources
866 */
867void edac_device_remove_sysfs(struct edac_device_ctl_info *edac_dev)
868{
869	edac_dbg(0, "\n");
870
871	/* remove any main attributes for this device */
872	edac_device_remove_main_sysfs_attributes(edac_dev);
873
874	/* remove the device sym link */
875	sysfs_remove_link(&edac_dev->kobj, EDAC_DEVICE_SYMLINK);
876
877	/* walk the instance/block kobject tree, deconstructing it */
878	edac_device_delete_instances(edac_dev);
879}
880