xref: /openbmc/linux/drivers/base/swnode.c (revision 6197e5b7)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Software nodes for the firmware node framework.
4  *
5  * Copyright (C) 2018, Intel Corporation
6  * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
7  */
8 
9 #include <linux/device.h>
10 #include <linux/kernel.h>
11 #include <linux/property.h>
12 #include <linux/slab.h>
13 
14 struct swnode {
15 	int id;
16 	struct kobject kobj;
17 	struct fwnode_handle fwnode;
18 	const struct software_node *node;
19 
20 	/* hierarchy */
21 	struct ida child_ids;
22 	struct list_head entry;
23 	struct list_head children;
24 	struct swnode *parent;
25 
26 	unsigned int allocated:1;
27 	unsigned int managed:1;
28 };
29 
30 static DEFINE_IDA(swnode_root_ids);
31 static struct kset *swnode_kset;
32 
33 #define kobj_to_swnode(_kobj_) container_of(_kobj_, struct swnode, kobj)
34 
35 static const struct fwnode_operations software_node_ops;
36 
37 bool is_software_node(const struct fwnode_handle *fwnode)
38 {
39 	return !IS_ERR_OR_NULL(fwnode) && fwnode->ops == &software_node_ops;
40 }
41 EXPORT_SYMBOL_GPL(is_software_node);
42 
43 #define to_swnode(__fwnode)						\
44 	({								\
45 		typeof(__fwnode) __to_swnode_fwnode = __fwnode;		\
46 									\
47 		is_software_node(__to_swnode_fwnode) ?			\
48 			container_of(__to_swnode_fwnode,		\
49 				     struct swnode, fwnode) : NULL;	\
50 	})
51 
52 static inline struct swnode *dev_to_swnode(struct device *dev)
53 {
54 	struct fwnode_handle *fwnode = dev_fwnode(dev);
55 
56 	if (!fwnode)
57 		return NULL;
58 
59 	if (!is_software_node(fwnode))
60 		fwnode = fwnode->secondary;
61 
62 	return to_swnode(fwnode);
63 }
64 
65 static struct swnode *
66 software_node_to_swnode(const struct software_node *node)
67 {
68 	struct swnode *swnode = NULL;
69 	struct kobject *k;
70 
71 	if (!node)
72 		return NULL;
73 
74 	spin_lock(&swnode_kset->list_lock);
75 
76 	list_for_each_entry(k, &swnode_kset->list, entry) {
77 		swnode = kobj_to_swnode(k);
78 		if (swnode->node == node)
79 			break;
80 		swnode = NULL;
81 	}
82 
83 	spin_unlock(&swnode_kset->list_lock);
84 
85 	return swnode;
86 }
87 
88 const struct software_node *to_software_node(const struct fwnode_handle *fwnode)
89 {
90 	const struct swnode *swnode = to_swnode(fwnode);
91 
92 	return swnode ? swnode->node : NULL;
93 }
94 EXPORT_SYMBOL_GPL(to_software_node);
95 
96 struct fwnode_handle *software_node_fwnode(const struct software_node *node)
97 {
98 	struct swnode *swnode = software_node_to_swnode(node);
99 
100 	return swnode ? &swnode->fwnode : NULL;
101 }
102 EXPORT_SYMBOL_GPL(software_node_fwnode);
103 
104 /* -------------------------------------------------------------------------- */
105 /* property_entry processing */
106 
107 static const struct property_entry *
108 property_entry_get(const struct property_entry *prop, const char *name)
109 {
110 	if (!prop)
111 		return NULL;
112 
113 	for (; prop->name; prop++)
114 		if (!strcmp(name, prop->name))
115 			return prop;
116 
117 	return NULL;
118 }
119 
120 static const void *property_get_pointer(const struct property_entry *prop)
121 {
122 	if (!prop->length)
123 		return NULL;
124 
125 	return prop->is_inline ? &prop->value : prop->pointer;
126 }
127 
128 static const void *property_entry_find(const struct property_entry *props,
129 				       const char *propname, size_t length)
130 {
131 	const struct property_entry *prop;
132 	const void *pointer;
133 
134 	prop = property_entry_get(props, propname);
135 	if (!prop)
136 		return ERR_PTR(-EINVAL);
137 	pointer = property_get_pointer(prop);
138 	if (!pointer)
139 		return ERR_PTR(-ENODATA);
140 	if (length > prop->length)
141 		return ERR_PTR(-EOVERFLOW);
142 	return pointer;
143 }
144 
145 static int
146 property_entry_count_elems_of_size(const struct property_entry *props,
147 				   const char *propname, size_t length)
148 {
149 	const struct property_entry *prop;
150 
151 	prop = property_entry_get(props, propname);
152 	if (!prop)
153 		return -EINVAL;
154 
155 	return prop->length / length;
156 }
157 
158 static int property_entry_read_int_array(const struct property_entry *props,
159 					 const char *name,
160 					 unsigned int elem_size, void *val,
161 					 size_t nval)
162 {
163 	const void *pointer;
164 	size_t length;
165 
166 	if (!val)
167 		return property_entry_count_elems_of_size(props, name,
168 							  elem_size);
169 
170 	if (!is_power_of_2(elem_size) || elem_size > sizeof(u64))
171 		return -ENXIO;
172 
173 	length = nval * elem_size;
174 
175 	pointer = property_entry_find(props, name, length);
176 	if (IS_ERR(pointer))
177 		return PTR_ERR(pointer);
178 
179 	memcpy(val, pointer, length);
180 	return 0;
181 }
182 
183 static int property_entry_read_string_array(const struct property_entry *props,
184 					    const char *propname,
185 					    const char **strings, size_t nval)
186 {
187 	const void *pointer;
188 	size_t length;
189 	int array_len;
190 
191 	/* Find out the array length. */
192 	array_len = property_entry_count_elems_of_size(props, propname,
193 						       sizeof(const char *));
194 	if (array_len < 0)
195 		return array_len;
196 
197 	/* Return how many there are if strings is NULL. */
198 	if (!strings)
199 		return array_len;
200 
201 	array_len = min_t(size_t, nval, array_len);
202 	length = array_len * sizeof(*strings);
203 
204 	pointer = property_entry_find(props, propname, length);
205 	if (IS_ERR(pointer))
206 		return PTR_ERR(pointer);
207 
208 	memcpy(strings, pointer, length);
209 
210 	return array_len;
211 }
212 
213 static void property_entry_free_data(const struct property_entry *p)
214 {
215 	const char * const *src_str;
216 	size_t i, nval;
217 
218 	if (p->type == DEV_PROP_STRING) {
219 		src_str = property_get_pointer(p);
220 		nval = p->length / sizeof(*src_str);
221 		for (i = 0; i < nval; i++)
222 			kfree(src_str[i]);
223 	}
224 
225 	if (!p->is_inline)
226 		kfree(p->pointer);
227 
228 	kfree(p->name);
229 }
230 
231 static bool property_copy_string_array(const char **dst_ptr,
232 				       const char * const *src_ptr,
233 				       size_t nval)
234 {
235 	int i;
236 
237 	for (i = 0; i < nval; i++) {
238 		dst_ptr[i] = kstrdup(src_ptr[i], GFP_KERNEL);
239 		if (!dst_ptr[i] && src_ptr[i]) {
240 			while (--i >= 0)
241 				kfree(dst_ptr[i]);
242 			return false;
243 		}
244 	}
245 
246 	return true;
247 }
248 
249 static int property_entry_copy_data(struct property_entry *dst,
250 				    const struct property_entry *src)
251 {
252 	const void *pointer = property_get_pointer(src);
253 	void *dst_ptr;
254 	size_t nval;
255 
256 	/*
257 	 * Properties with no data should not be marked as stored
258 	 * out of line.
259 	 */
260 	if (!src->is_inline && !src->length)
261 		return -ENODATA;
262 
263 	/*
264 	 * Reference properties are never stored inline as
265 	 * they are too big.
266 	 */
267 	if (src->type == DEV_PROP_REF && src->is_inline)
268 		return -EINVAL;
269 
270 	if (src->length <= sizeof(dst->value)) {
271 		dst_ptr = &dst->value;
272 		dst->is_inline = true;
273 	} else {
274 		dst_ptr = kmalloc(src->length, GFP_KERNEL);
275 		if (!dst_ptr)
276 			return -ENOMEM;
277 		dst->pointer = dst_ptr;
278 	}
279 
280 	if (src->type == DEV_PROP_STRING) {
281 		nval = src->length / sizeof(const char *);
282 		if (!property_copy_string_array(dst_ptr, pointer, nval)) {
283 			if (!dst->is_inline)
284 				kfree(dst->pointer);
285 			return -ENOMEM;
286 		}
287 	} else {
288 		memcpy(dst_ptr, pointer, src->length);
289 	}
290 
291 	dst->length = src->length;
292 	dst->type = src->type;
293 	dst->name = kstrdup(src->name, GFP_KERNEL);
294 	if (!dst->name) {
295 		property_entry_free_data(dst);
296 		return -ENOMEM;
297 	}
298 
299 	return 0;
300 }
301 
302 /**
303  * property_entries_dup - duplicate array of properties
304  * @properties: array of properties to copy
305  *
306  * This function creates a deep copy of the given NULL-terminated array
307  * of property entries.
308  */
309 struct property_entry *
310 property_entries_dup(const struct property_entry *properties)
311 {
312 	struct property_entry *p;
313 	int i, n = 0;
314 	int ret;
315 
316 	if (!properties)
317 		return NULL;
318 
319 	while (properties[n].name)
320 		n++;
321 
322 	p = kcalloc(n + 1, sizeof(*p), GFP_KERNEL);
323 	if (!p)
324 		return ERR_PTR(-ENOMEM);
325 
326 	for (i = 0; i < n; i++) {
327 		ret = property_entry_copy_data(&p[i], &properties[i]);
328 		if (ret) {
329 			while (--i >= 0)
330 				property_entry_free_data(&p[i]);
331 			kfree(p);
332 			return ERR_PTR(ret);
333 		}
334 	}
335 
336 	return p;
337 }
338 EXPORT_SYMBOL_GPL(property_entries_dup);
339 
340 /**
341  * property_entries_free - free previously allocated array of properties
342  * @properties: array of properties to destroy
343  *
344  * This function frees given NULL-terminated array of property entries,
345  * along with their data.
346  */
347 void property_entries_free(const struct property_entry *properties)
348 {
349 	const struct property_entry *p;
350 
351 	if (!properties)
352 		return;
353 
354 	for (p = properties; p->name; p++)
355 		property_entry_free_data(p);
356 
357 	kfree(properties);
358 }
359 EXPORT_SYMBOL_GPL(property_entries_free);
360 
361 /* -------------------------------------------------------------------------- */
362 /* fwnode operations */
363 
364 static struct fwnode_handle *software_node_get(struct fwnode_handle *fwnode)
365 {
366 	struct swnode *swnode = to_swnode(fwnode);
367 
368 	kobject_get(&swnode->kobj);
369 
370 	return &swnode->fwnode;
371 }
372 
373 static void software_node_put(struct fwnode_handle *fwnode)
374 {
375 	struct swnode *swnode = to_swnode(fwnode);
376 
377 	kobject_put(&swnode->kobj);
378 }
379 
380 static bool software_node_property_present(const struct fwnode_handle *fwnode,
381 					   const char *propname)
382 {
383 	struct swnode *swnode = to_swnode(fwnode);
384 
385 	return !!property_entry_get(swnode->node->properties, propname);
386 }
387 
388 static int software_node_read_int_array(const struct fwnode_handle *fwnode,
389 					const char *propname,
390 					unsigned int elem_size, void *val,
391 					size_t nval)
392 {
393 	struct swnode *swnode = to_swnode(fwnode);
394 
395 	return property_entry_read_int_array(swnode->node->properties, propname,
396 					     elem_size, val, nval);
397 }
398 
399 static int software_node_read_string_array(const struct fwnode_handle *fwnode,
400 					   const char *propname,
401 					   const char **val, size_t nval)
402 {
403 	struct swnode *swnode = to_swnode(fwnode);
404 
405 	return property_entry_read_string_array(swnode->node->properties,
406 						propname, val, nval);
407 }
408 
409 static const char *
410 software_node_get_name(const struct fwnode_handle *fwnode)
411 {
412 	const struct swnode *swnode = to_swnode(fwnode);
413 
414 	if (!swnode)
415 		return "(null)";
416 
417 	return kobject_name(&swnode->kobj);
418 }
419 
420 static const char *
421 software_node_get_name_prefix(const struct fwnode_handle *fwnode)
422 {
423 	struct fwnode_handle *parent;
424 	const char *prefix;
425 
426 	parent = fwnode_get_parent(fwnode);
427 	if (!parent)
428 		return "";
429 
430 	/* Figure out the prefix from the parents. */
431 	while (is_software_node(parent))
432 		parent = fwnode_get_next_parent(parent);
433 
434 	prefix = fwnode_get_name_prefix(parent);
435 	fwnode_handle_put(parent);
436 
437 	/* Guess something if prefix was NULL. */
438 	return prefix ?: "/";
439 }
440 
441 static struct fwnode_handle *
442 software_node_get_parent(const struct fwnode_handle *fwnode)
443 {
444 	struct swnode *swnode = to_swnode(fwnode);
445 
446 	if (!swnode || !swnode->parent)
447 		return NULL;
448 
449 	return fwnode_handle_get(&swnode->parent->fwnode);
450 }
451 
452 static struct fwnode_handle *
453 software_node_get_next_child(const struct fwnode_handle *fwnode,
454 			     struct fwnode_handle *child)
455 {
456 	struct swnode *p = to_swnode(fwnode);
457 	struct swnode *c = to_swnode(child);
458 
459 	if (!p || list_empty(&p->children) ||
460 	    (c && list_is_last(&c->entry, &p->children)))
461 		return NULL;
462 
463 	if (c)
464 		c = list_next_entry(c, entry);
465 	else
466 		c = list_first_entry(&p->children, struct swnode, entry);
467 	return &c->fwnode;
468 }
469 
470 static struct fwnode_handle *
471 software_node_get_named_child_node(const struct fwnode_handle *fwnode,
472 				   const char *childname)
473 {
474 	struct swnode *swnode = to_swnode(fwnode);
475 	struct swnode *child;
476 
477 	if (!swnode || list_empty(&swnode->children))
478 		return NULL;
479 
480 	list_for_each_entry(child, &swnode->children, entry) {
481 		if (!strcmp(childname, kobject_name(&child->kobj))) {
482 			kobject_get(&child->kobj);
483 			return &child->fwnode;
484 		}
485 	}
486 	return NULL;
487 }
488 
489 static int
490 software_node_get_reference_args(const struct fwnode_handle *fwnode,
491 				 const char *propname, const char *nargs_prop,
492 				 unsigned int nargs, unsigned int index,
493 				 struct fwnode_reference_args *args)
494 {
495 	struct swnode *swnode = to_swnode(fwnode);
496 	const struct software_node_ref_args *ref_array;
497 	const struct software_node_ref_args *ref;
498 	const struct property_entry *prop;
499 	struct fwnode_handle *refnode;
500 	u32 nargs_prop_val;
501 	int error;
502 	int i;
503 
504 	if (!swnode)
505 		return -ENOENT;
506 
507 	prop = property_entry_get(swnode->node->properties, propname);
508 	if (!prop)
509 		return -ENOENT;
510 
511 	if (prop->type != DEV_PROP_REF)
512 		return -EINVAL;
513 
514 	/*
515 	 * We expect that references are never stored inline, even
516 	 * single ones, as they are too big.
517 	 */
518 	if (prop->is_inline)
519 		return -EINVAL;
520 
521 	if (index * sizeof(*ref) >= prop->length)
522 		return -ENOENT;
523 
524 	ref_array = prop->pointer;
525 	ref = &ref_array[index];
526 
527 	refnode = software_node_fwnode(ref->node);
528 	if (!refnode)
529 		return -ENOENT;
530 
531 	if (nargs_prop) {
532 		error = property_entry_read_int_array(swnode->node->properties,
533 						      nargs_prop, sizeof(u32),
534 						      &nargs_prop_val, 1);
535 		if (error)
536 			return error;
537 
538 		nargs = nargs_prop_val;
539 	}
540 
541 	if (nargs > NR_FWNODE_REFERENCE_ARGS)
542 		return -EINVAL;
543 
544 	args->fwnode = software_node_get(refnode);
545 	args->nargs = nargs;
546 
547 	for (i = 0; i < nargs; i++)
548 		args->args[i] = ref->args[i];
549 
550 	return 0;
551 }
552 
553 static const struct fwnode_operations software_node_ops = {
554 	.get = software_node_get,
555 	.put = software_node_put,
556 	.property_present = software_node_property_present,
557 	.property_read_int_array = software_node_read_int_array,
558 	.property_read_string_array = software_node_read_string_array,
559 	.get_name = software_node_get_name,
560 	.get_name_prefix = software_node_get_name_prefix,
561 	.get_parent = software_node_get_parent,
562 	.get_next_child_node = software_node_get_next_child,
563 	.get_named_child_node = software_node_get_named_child_node,
564 	.get_reference_args = software_node_get_reference_args
565 };
566 
567 /* -------------------------------------------------------------------------- */
568 
569 /**
570  * software_node_find_by_name - Find software node by name
571  * @parent: Parent of the software node
572  * @name: Name of the software node
573  *
574  * The function will find a node that is child of @parent and that is named
575  * @name. If no node is found, the function returns NULL.
576  *
577  * NOTE: you will need to drop the reference with fwnode_handle_put() after use.
578  */
579 const struct software_node *
580 software_node_find_by_name(const struct software_node *parent, const char *name)
581 {
582 	struct swnode *swnode = NULL;
583 	struct kobject *k;
584 
585 	if (!name)
586 		return NULL;
587 
588 	spin_lock(&swnode_kset->list_lock);
589 
590 	list_for_each_entry(k, &swnode_kset->list, entry) {
591 		swnode = kobj_to_swnode(k);
592 		if (parent == swnode->node->parent && swnode->node->name &&
593 		    !strcmp(name, swnode->node->name)) {
594 			kobject_get(&swnode->kobj);
595 			break;
596 		}
597 		swnode = NULL;
598 	}
599 
600 	spin_unlock(&swnode_kset->list_lock);
601 
602 	return swnode ? swnode->node : NULL;
603 }
604 EXPORT_SYMBOL_GPL(software_node_find_by_name);
605 
606 static int
607 software_node_register_properties(struct software_node *node,
608 				  const struct property_entry *properties)
609 {
610 	struct property_entry *props;
611 
612 	props = property_entries_dup(properties);
613 	if (IS_ERR(props))
614 		return PTR_ERR(props);
615 
616 	node->properties = props;
617 
618 	return 0;
619 }
620 
621 static void software_node_release(struct kobject *kobj)
622 {
623 	struct swnode *swnode = kobj_to_swnode(kobj);
624 
625 	if (swnode->parent) {
626 		ida_simple_remove(&swnode->parent->child_ids, swnode->id);
627 		list_del(&swnode->entry);
628 	} else {
629 		ida_simple_remove(&swnode_root_ids, swnode->id);
630 	}
631 
632 	if (swnode->allocated) {
633 		property_entries_free(swnode->node->properties);
634 		kfree(swnode->node);
635 	}
636 	ida_destroy(&swnode->child_ids);
637 	kfree(swnode);
638 }
639 
640 static struct kobj_type software_node_type = {
641 	.release = software_node_release,
642 	.sysfs_ops = &kobj_sysfs_ops,
643 };
644 
645 static struct fwnode_handle *
646 swnode_register(const struct software_node *node, struct swnode *parent,
647 		unsigned int allocated)
648 {
649 	struct swnode *swnode;
650 	int ret;
651 
652 	swnode = kzalloc(sizeof(*swnode), GFP_KERNEL);
653 	if (!swnode) {
654 		ret = -ENOMEM;
655 		goto out_err;
656 	}
657 
658 	ret = ida_simple_get(parent ? &parent->child_ids : &swnode_root_ids,
659 			     0, 0, GFP_KERNEL);
660 	if (ret < 0) {
661 		kfree(swnode);
662 		goto out_err;
663 	}
664 
665 	swnode->id = ret;
666 	swnode->node = node;
667 	swnode->parent = parent;
668 	swnode->allocated = allocated;
669 	swnode->kobj.kset = swnode_kset;
670 	fwnode_init(&swnode->fwnode, &software_node_ops);
671 
672 	ida_init(&swnode->child_ids);
673 	INIT_LIST_HEAD(&swnode->entry);
674 	INIT_LIST_HEAD(&swnode->children);
675 
676 	if (node->name)
677 		ret = kobject_init_and_add(&swnode->kobj, &software_node_type,
678 					   parent ? &parent->kobj : NULL,
679 					   "%s", node->name);
680 	else
681 		ret = kobject_init_and_add(&swnode->kobj, &software_node_type,
682 					   parent ? &parent->kobj : NULL,
683 					   "node%d", swnode->id);
684 	if (ret) {
685 		kobject_put(&swnode->kobj);
686 		return ERR_PTR(ret);
687 	}
688 
689 	if (parent)
690 		list_add_tail(&swnode->entry, &parent->children);
691 
692 	kobject_uevent(&swnode->kobj, KOBJ_ADD);
693 	return &swnode->fwnode;
694 
695 out_err:
696 	if (allocated)
697 		property_entries_free(node->properties);
698 	return ERR_PTR(ret);
699 }
700 
701 /**
702  * software_node_register_nodes - Register an array of software nodes
703  * @nodes: Zero terminated array of software nodes to be registered
704  *
705  * Register multiple software nodes at once.
706  */
707 int software_node_register_nodes(const struct software_node *nodes)
708 {
709 	int ret;
710 	int i;
711 
712 	for (i = 0; nodes[i].name; i++) {
713 		ret = software_node_register(&nodes[i]);
714 		if (ret) {
715 			software_node_unregister_nodes(nodes);
716 			return ret;
717 		}
718 	}
719 
720 	return 0;
721 }
722 EXPORT_SYMBOL_GPL(software_node_register_nodes);
723 
724 /**
725  * software_node_unregister_nodes - Unregister an array of software nodes
726  * @nodes: Zero terminated array of software nodes to be unregistered
727  *
728  * Unregister multiple software nodes at once.
729  *
730  * NOTE: Be careful using this call if the nodes had parent pointers set up in
731  * them before registering.  If so, it is wiser to remove the nodes
732  * individually, in the correct order (child before parent) instead of relying
733  * on the sequential order of the list of nodes in the array.
734  */
735 void software_node_unregister_nodes(const struct software_node *nodes)
736 {
737 	int i;
738 
739 	for (i = 0; nodes[i].name; i++)
740 		software_node_unregister(&nodes[i]);
741 }
742 EXPORT_SYMBOL_GPL(software_node_unregister_nodes);
743 
744 /**
745  * software_node_register_node_group - Register a group of software nodes
746  * @node_group: NULL terminated array of software node pointers to be registered
747  *
748  * Register multiple software nodes at once.
749  */
750 int software_node_register_node_group(const struct software_node **node_group)
751 {
752 	unsigned int i;
753 	int ret;
754 
755 	if (!node_group)
756 		return 0;
757 
758 	for (i = 0; node_group[i]; i++) {
759 		ret = software_node_register(node_group[i]);
760 		if (ret) {
761 			software_node_unregister_node_group(node_group);
762 			return ret;
763 		}
764 	}
765 
766 	return 0;
767 }
768 EXPORT_SYMBOL_GPL(software_node_register_node_group);
769 
770 /**
771  * software_node_unregister_node_group - Unregister a group of software nodes
772  * @node_group: NULL terminated array of software node pointers to be unregistered
773  *
774  * Unregister multiple software nodes at once.
775  */
776 void software_node_unregister_node_group(const struct software_node **node_group)
777 {
778 	unsigned int i;
779 
780 	if (!node_group)
781 		return;
782 
783 	for (i = 0; node_group[i]; i++)
784 		software_node_unregister(node_group[i]);
785 }
786 EXPORT_SYMBOL_GPL(software_node_unregister_node_group);
787 
788 /**
789  * software_node_register - Register static software node
790  * @node: The software node to be registered
791  */
792 int software_node_register(const struct software_node *node)
793 {
794 	struct swnode *parent = software_node_to_swnode(node->parent);
795 
796 	if (software_node_to_swnode(node))
797 		return -EEXIST;
798 
799 	return PTR_ERR_OR_ZERO(swnode_register(node, parent, 0));
800 }
801 EXPORT_SYMBOL_GPL(software_node_register);
802 
803 /**
804  * software_node_unregister - Unregister static software node
805  * @node: The software node to be unregistered
806  */
807 void software_node_unregister(const struct software_node *node)
808 {
809 	struct swnode *swnode;
810 
811 	swnode = software_node_to_swnode(node);
812 	if (swnode)
813 		fwnode_remove_software_node(&swnode->fwnode);
814 }
815 EXPORT_SYMBOL_GPL(software_node_unregister);
816 
817 struct fwnode_handle *
818 fwnode_create_software_node(const struct property_entry *properties,
819 			    const struct fwnode_handle *parent)
820 {
821 	struct software_node *node;
822 	struct swnode *p = NULL;
823 	int ret;
824 
825 	if (parent) {
826 		if (IS_ERR(parent))
827 			return ERR_CAST(parent);
828 		if (!is_software_node(parent))
829 			return ERR_PTR(-EINVAL);
830 		p = to_swnode(parent);
831 	}
832 
833 	node = kzalloc(sizeof(*node), GFP_KERNEL);
834 	if (!node)
835 		return ERR_PTR(-ENOMEM);
836 
837 	ret = software_node_register_properties(node, properties);
838 	if (ret) {
839 		kfree(node);
840 		return ERR_PTR(ret);
841 	}
842 
843 	node->parent = p ? p->node : NULL;
844 
845 	return swnode_register(node, p, 1);
846 }
847 EXPORT_SYMBOL_GPL(fwnode_create_software_node);
848 
849 void fwnode_remove_software_node(struct fwnode_handle *fwnode)
850 {
851 	struct swnode *swnode = to_swnode(fwnode);
852 
853 	if (!swnode)
854 		return;
855 
856 	kobject_put(&swnode->kobj);
857 }
858 EXPORT_SYMBOL_GPL(fwnode_remove_software_node);
859 
860 /**
861  * device_add_software_node - Assign software node to a device
862  * @dev: The device the software node is meant for.
863  * @swnode: The software node.
864  *
865  * This function will register @swnode and make it the secondary firmware node
866  * pointer of @dev. If @dev has no primary node, then @swnode will become the primary
867  * node.
868  */
869 int device_add_software_node(struct device *dev, const struct software_node *swnode)
870 {
871 	int ret;
872 
873 	/* Only one software node per device. */
874 	if (dev_to_swnode(dev))
875 		return -EBUSY;
876 
877 	ret = software_node_register(swnode);
878 	if (ret)
879 		return ret;
880 
881 	set_secondary_fwnode(dev, software_node_fwnode(swnode));
882 
883 	return 0;
884 }
885 EXPORT_SYMBOL_GPL(device_add_software_node);
886 
887 /**
888  * device_remove_software_node - Remove device's software node
889  * @dev: The device with the software node.
890  *
891  * This function will unregister the software node of @dev.
892  */
893 void device_remove_software_node(struct device *dev)
894 {
895 	struct swnode *swnode;
896 
897 	swnode = dev_to_swnode(dev);
898 	if (!swnode)
899 		return;
900 
901 	software_node_notify(dev, KOBJ_REMOVE);
902 	set_secondary_fwnode(dev, NULL);
903 	kobject_put(&swnode->kobj);
904 }
905 EXPORT_SYMBOL_GPL(device_remove_software_node);
906 
907 /**
908  * device_create_managed_software_node - Create a software node for a device
909  * @dev: The device the software node is assigned to.
910  * @properties: Device properties for the software node.
911  * @parent: Parent of the software node.
912  *
913  * Creates a software node as a managed resource for @dev, which means the
914  * lifetime of the newly created software node is tied to the lifetime of @dev.
915  * Software nodes created with this function should not be reused or shared
916  * because of that. The function takes a deep copy of @properties for the
917  * software node.
918  *
919  * Since the new software node is assigned directly to @dev, and since it should
920  * not be shared, it is not returned to the caller. The function returns 0 on
921  * success, and errno in case of an error.
922  */
923 int device_create_managed_software_node(struct device *dev,
924 					const struct property_entry *properties,
925 					const struct software_node *parent)
926 {
927 	struct fwnode_handle *p = software_node_fwnode(parent);
928 	struct fwnode_handle *fwnode;
929 
930 	if (parent && !p)
931 		return -EINVAL;
932 
933 	fwnode = fwnode_create_software_node(properties, p);
934 	if (IS_ERR(fwnode))
935 		return PTR_ERR(fwnode);
936 
937 	to_swnode(fwnode)->managed = true;
938 	set_secondary_fwnode(dev, fwnode);
939 
940 	return 0;
941 }
942 EXPORT_SYMBOL_GPL(device_create_managed_software_node);
943 
944 int software_node_notify(struct device *dev, unsigned long action)
945 {
946 	struct swnode *swnode;
947 	int ret;
948 
949 	swnode = dev_to_swnode(dev);
950 	if (!swnode)
951 		return 0;
952 
953 	switch (action) {
954 	case KOBJ_ADD:
955 		ret = sysfs_create_link(&dev->kobj, &swnode->kobj,
956 					"software_node");
957 		if (ret)
958 			break;
959 
960 		ret = sysfs_create_link(&swnode->kobj, &dev->kobj,
961 					dev_name(dev));
962 		if (ret) {
963 			sysfs_remove_link(&dev->kobj, "software_node");
964 			break;
965 		}
966 		kobject_get(&swnode->kobj);
967 		break;
968 	case KOBJ_REMOVE:
969 		sysfs_remove_link(&swnode->kobj, dev_name(dev));
970 		sysfs_remove_link(&dev->kobj, "software_node");
971 		kobject_put(&swnode->kobj);
972 
973 		if (swnode->managed) {
974 			set_secondary_fwnode(dev, NULL);
975 			kobject_put(&swnode->kobj);
976 		}
977 		break;
978 	default:
979 		break;
980 	}
981 
982 	return 0;
983 }
984 
985 static int __init software_node_init(void)
986 {
987 	swnode_kset = kset_create_and_add("software_nodes", NULL, kernel_kobj);
988 	if (!swnode_kset)
989 		return -ENOMEM;
990 	return 0;
991 }
992 postcore_initcall(software_node_init);
993 
994 static void __exit software_node_exit(void)
995 {
996 	ida_destroy(&swnode_root_ids);
997 	kset_unregister(swnode_kset);
998 }
999 __exitcall(software_node_exit);
1000