1 // SPDX-License-Identifier: GPL-2.0
3 * Software nodes for the firmware node framework.
5 * Copyright (C) 2018, Intel Corporation
6 * Author: Heikki Krogerus <heikki.krogerus@linux.intel.com>
9 #include <linux/device.h>
10 #include <linux/kernel.h>
11 #include <linux/property.h>
12 #include <linux/slab.h>
18 struct fwnode_handle fwnode
;
19 const struct software_node
*node
;
24 struct list_head entry
;
25 struct list_head children
;
26 struct swnode
*parent
;
28 unsigned int allocated
:1;
29 unsigned int managed
:1;
32 static DEFINE_IDA(swnode_root_ids
);
33 static struct kset
*swnode_kset
;
35 #define kobj_to_swnode(_kobj_) container_of(_kobj_, struct swnode, kobj)
37 static const struct fwnode_operations software_node_ops
;
39 bool is_software_node(const struct fwnode_handle
*fwnode
)
41 return !IS_ERR_OR_NULL(fwnode
) && fwnode
->ops
== &software_node_ops
;
43 EXPORT_SYMBOL_GPL(is_software_node
);
45 #define to_swnode(__fwnode) \
47 typeof(__fwnode) __to_swnode_fwnode = __fwnode; \
49 is_software_node(__to_swnode_fwnode) ? \
50 container_of(__to_swnode_fwnode, \
51 struct swnode, fwnode) : NULL; \
54 static inline struct swnode
*dev_to_swnode(struct device
*dev
)
56 struct fwnode_handle
*fwnode
= dev_fwnode(dev
);
61 if (!is_software_node(fwnode
))
62 fwnode
= fwnode
->secondary
;
64 return to_swnode(fwnode
);
67 static struct swnode
*
68 software_node_to_swnode(const struct software_node
*node
)
70 struct swnode
*swnode
= NULL
;
76 spin_lock(&swnode_kset
->list_lock
);
78 list_for_each_entry(k
, &swnode_kset
->list
, entry
) {
79 swnode
= kobj_to_swnode(k
);
80 if (swnode
->node
== node
)
85 spin_unlock(&swnode_kset
->list_lock
);
90 const struct software_node
*to_software_node(const struct fwnode_handle
*fwnode
)
92 const struct swnode
*swnode
= to_swnode(fwnode
);
94 return swnode
? swnode
->node
: NULL
;
96 EXPORT_SYMBOL_GPL(to_software_node
);
98 struct fwnode_handle
*software_node_fwnode(const struct software_node
*node
)
100 struct swnode
*swnode
= software_node_to_swnode(node
);
102 return swnode
? &swnode
->fwnode
: NULL
;
104 EXPORT_SYMBOL_GPL(software_node_fwnode
);
106 /* -------------------------------------------------------------------------- */
107 /* property_entry processing */
109 static const struct property_entry
*
110 property_entry_get(const struct property_entry
*prop
, const char *name
)
115 for (; prop
->name
; prop
++)
116 if (!strcmp(name
, prop
->name
))
122 static const void *property_get_pointer(const struct property_entry
*prop
)
127 return prop
->is_inline
? &prop
->value
: prop
->pointer
;
130 static const void *property_entry_find(const struct property_entry
*props
,
131 const char *propname
, size_t length
)
133 const struct property_entry
*prop
;
136 prop
= property_entry_get(props
, propname
);
138 return ERR_PTR(-EINVAL
);
139 pointer
= property_get_pointer(prop
);
141 return ERR_PTR(-ENODATA
);
142 if (length
> prop
->length
)
143 return ERR_PTR(-EOVERFLOW
);
148 property_entry_count_elems_of_size(const struct property_entry
*props
,
149 const char *propname
, size_t length
)
151 const struct property_entry
*prop
;
153 prop
= property_entry_get(props
, propname
);
157 return prop
->length
/ length
;
160 static int property_entry_read_int_array(const struct property_entry
*props
,
162 unsigned int elem_size
, void *val
,
169 return property_entry_count_elems_of_size(props
, name
,
172 if (!is_power_of_2(elem_size
) || elem_size
> sizeof(u64
))
175 length
= nval
* elem_size
;
177 pointer
= property_entry_find(props
, name
, length
);
179 return PTR_ERR(pointer
);
181 memcpy(val
, pointer
, length
);
185 static int property_entry_read_string_array(const struct property_entry
*props
,
186 const char *propname
,
187 const char **strings
, size_t nval
)
193 /* Find out the array length. */
194 array_len
= property_entry_count_elems_of_size(props
, propname
,
195 sizeof(const char *));
199 /* Return how many there are if strings is NULL. */
203 array_len
= min_t(size_t, nval
, array_len
);
204 length
= array_len
* sizeof(*strings
);
206 pointer
= property_entry_find(props
, propname
, length
);
208 return PTR_ERR(pointer
);
210 memcpy(strings
, pointer
, length
);
215 static void property_entry_free_data(const struct property_entry
*p
)
217 const char * const *src_str
;
220 if (p
->type
== DEV_PROP_STRING
) {
221 src_str
= property_get_pointer(p
);
222 nval
= p
->length
/ sizeof(*src_str
);
223 for (i
= 0; i
< nval
; i
++)
233 static bool property_copy_string_array(const char **dst_ptr
,
234 const char * const *src_ptr
,
239 for (i
= 0; i
< nval
; i
++) {
240 dst_ptr
[i
] = kstrdup(src_ptr
[i
], GFP_KERNEL
);
241 if (!dst_ptr
[i
] && src_ptr
[i
]) {
251 static int property_entry_copy_data(struct property_entry
*dst
,
252 const struct property_entry
*src
)
254 const void *pointer
= property_get_pointer(src
);
259 * Properties with no data should not be marked as stored
262 if (!src
->is_inline
&& !src
->length
)
266 * Reference properties are never stored inline as
269 if (src
->type
== DEV_PROP_REF
&& src
->is_inline
)
272 if (src
->length
<= sizeof(dst
->value
)) {
273 dst_ptr
= &dst
->value
;
274 dst
->is_inline
= true;
276 dst_ptr
= kmalloc(src
->length
, GFP_KERNEL
);
279 dst
->pointer
= dst_ptr
;
282 if (src
->type
== DEV_PROP_STRING
) {
283 nval
= src
->length
/ sizeof(const char *);
284 if (!property_copy_string_array(dst_ptr
, pointer
, nval
)) {
290 memcpy(dst_ptr
, pointer
, src
->length
);
293 dst
->length
= src
->length
;
294 dst
->type
= src
->type
;
295 dst
->name
= kstrdup(src
->name
, GFP_KERNEL
);
297 property_entry_free_data(dst
);
305 * property_entries_dup - duplicate array of properties
306 * @properties: array of properties to copy
308 * This function creates a deep copy of the given NULL-terminated array
309 * of property entries.
311 struct property_entry
*
312 property_entries_dup(const struct property_entry
*properties
)
314 struct property_entry
*p
;
321 while (properties
[n
].name
)
324 p
= kcalloc(n
+ 1, sizeof(*p
), GFP_KERNEL
);
326 return ERR_PTR(-ENOMEM
);
328 for (i
= 0; i
< n
; i
++) {
329 ret
= property_entry_copy_data(&p
[i
], &properties
[i
]);
332 property_entry_free_data(&p
[i
]);
340 EXPORT_SYMBOL_GPL(property_entries_dup
);
343 * property_entries_free - free previously allocated array of properties
344 * @properties: array of properties to destroy
346 * This function frees given NULL-terminated array of property entries,
347 * along with their data.
349 void property_entries_free(const struct property_entry
*properties
)
351 const struct property_entry
*p
;
356 for (p
= properties
; p
->name
; p
++)
357 property_entry_free_data(p
);
361 EXPORT_SYMBOL_GPL(property_entries_free
);
363 /* -------------------------------------------------------------------------- */
364 /* fwnode operations */
366 static struct fwnode_handle
*software_node_get(struct fwnode_handle
*fwnode
)
368 struct swnode
*swnode
= to_swnode(fwnode
);
370 kobject_get(&swnode
->kobj
);
372 return &swnode
->fwnode
;
375 static void software_node_put(struct fwnode_handle
*fwnode
)
377 struct swnode
*swnode
= to_swnode(fwnode
);
379 kobject_put(&swnode
->kobj
);
382 static bool software_node_property_present(const struct fwnode_handle
*fwnode
,
383 const char *propname
)
385 struct swnode
*swnode
= to_swnode(fwnode
);
387 return !!property_entry_get(swnode
->node
->properties
, propname
);
390 static int software_node_read_int_array(const struct fwnode_handle
*fwnode
,
391 const char *propname
,
392 unsigned int elem_size
, void *val
,
395 struct swnode
*swnode
= to_swnode(fwnode
);
397 return property_entry_read_int_array(swnode
->node
->properties
, propname
,
398 elem_size
, val
, nval
);
401 static int software_node_read_string_array(const struct fwnode_handle
*fwnode
,
402 const char *propname
,
403 const char **val
, size_t nval
)
405 struct swnode
*swnode
= to_swnode(fwnode
);
407 return property_entry_read_string_array(swnode
->node
->properties
,
408 propname
, val
, nval
);
412 software_node_get_name(const struct fwnode_handle
*fwnode
)
414 const struct swnode
*swnode
= to_swnode(fwnode
);
419 return kobject_name(&swnode
->kobj
);
423 software_node_get_name_prefix(const struct fwnode_handle
*fwnode
)
425 struct fwnode_handle
*parent
;
428 parent
= fwnode_get_parent(fwnode
);
432 /* Figure out the prefix from the parents. */
433 while (is_software_node(parent
))
434 parent
= fwnode_get_next_parent(parent
);
436 prefix
= fwnode_get_name_prefix(parent
);
437 fwnode_handle_put(parent
);
439 /* Guess something if prefix was NULL. */
440 return prefix
?: "/";
443 static struct fwnode_handle
*
444 software_node_get_parent(const struct fwnode_handle
*fwnode
)
446 struct swnode
*swnode
= to_swnode(fwnode
);
448 if (!swnode
|| !swnode
->parent
)
451 return fwnode_handle_get(&swnode
->parent
->fwnode
);
454 static struct fwnode_handle
*
455 software_node_get_next_child(const struct fwnode_handle
*fwnode
,
456 struct fwnode_handle
*child
)
458 struct swnode
*p
= to_swnode(fwnode
);
459 struct swnode
*c
= to_swnode(child
);
461 if (!p
|| list_empty(&p
->children
) ||
462 (c
&& list_is_last(&c
->entry
, &p
->children
))) {
463 fwnode_handle_put(child
);
468 c
= list_next_entry(c
, entry
);
470 c
= list_first_entry(&p
->children
, struct swnode
, entry
);
472 fwnode_handle_put(child
);
473 return fwnode_handle_get(&c
->fwnode
);
476 static struct fwnode_handle
*
477 software_node_get_named_child_node(const struct fwnode_handle
*fwnode
,
478 const char *childname
)
480 struct swnode
*swnode
= to_swnode(fwnode
);
481 struct swnode
*child
;
483 if (!swnode
|| list_empty(&swnode
->children
))
486 list_for_each_entry(child
, &swnode
->children
, entry
) {
487 if (!strcmp(childname
, kobject_name(&child
->kobj
))) {
488 kobject_get(&child
->kobj
);
489 return &child
->fwnode
;
496 software_node_get_reference_args(const struct fwnode_handle
*fwnode
,
497 const char *propname
, const char *nargs_prop
,
498 unsigned int nargs
, unsigned int index
,
499 struct fwnode_reference_args
*args
)
501 struct swnode
*swnode
= to_swnode(fwnode
);
502 const struct software_node_ref_args
*ref_array
;
503 const struct software_node_ref_args
*ref
;
504 const struct property_entry
*prop
;
505 struct fwnode_handle
*refnode
;
513 prop
= property_entry_get(swnode
->node
->properties
, propname
);
517 if (prop
->type
!= DEV_PROP_REF
)
521 * We expect that references are never stored inline, even
522 * single ones, as they are too big.
527 if (index
* sizeof(*ref
) >= prop
->length
)
530 ref_array
= prop
->pointer
;
531 ref
= &ref_array
[index
];
533 refnode
= software_node_fwnode(ref
->node
);
538 error
= property_entry_read_int_array(ref
->node
->properties
,
539 nargs_prop
, sizeof(u32
),
544 nargs
= nargs_prop_val
;
547 if (nargs
> NR_FWNODE_REFERENCE_ARGS
)
550 args
->fwnode
= software_node_get(refnode
);
553 for (i
= 0; i
< nargs
; i
++)
554 args
->args
[i
] = ref
->args
[i
];
559 static struct fwnode_handle
*
560 swnode_graph_find_next_port(const struct fwnode_handle
*parent
,
561 struct fwnode_handle
*port
)
563 struct fwnode_handle
*old
= port
;
565 while ((port
= software_node_get_next_child(parent
, old
))) {
567 * fwnode ports have naming style "port@", so we search for any
568 * children that follow that convention.
570 if (!strncmp(to_swnode(port
)->node
->name
, "port@",
579 static struct fwnode_handle
*
580 software_node_graph_get_next_endpoint(const struct fwnode_handle
*fwnode
,
581 struct fwnode_handle
*endpoint
)
583 struct swnode
*swnode
= to_swnode(fwnode
);
584 struct fwnode_handle
*parent
;
585 struct fwnode_handle
*port
;
591 port
= software_node_get_parent(endpoint
);
592 parent
= software_node_get_parent(port
);
594 parent
= software_node_get_named_child_node(fwnode
, "ports");
596 parent
= software_node_get(&swnode
->fwnode
);
598 port
= swnode_graph_find_next_port(parent
, NULL
);
601 for (; port
; port
= swnode_graph_find_next_port(parent
, port
)) {
602 endpoint
= software_node_get_next_child(port
, endpoint
);
604 fwnode_handle_put(port
);
609 fwnode_handle_put(parent
);
614 static struct fwnode_handle
*
615 software_node_graph_get_remote_endpoint(const struct fwnode_handle
*fwnode
)
617 struct swnode
*swnode
= to_swnode(fwnode
);
618 const struct software_node_ref_args
*ref
;
619 const struct property_entry
*prop
;
624 prop
= property_entry_get(swnode
->node
->properties
, "remote-endpoint");
625 if (!prop
|| prop
->type
!= DEV_PROP_REF
|| prop
->is_inline
)
630 return software_node_get(software_node_fwnode(ref
[0].node
));
633 static struct fwnode_handle
*
634 software_node_graph_get_port_parent(struct fwnode_handle
*fwnode
)
636 struct swnode
*swnode
= to_swnode(fwnode
);
638 swnode
= swnode
->parent
;
639 if (swnode
&& !strcmp(swnode
->node
->name
, "ports"))
640 swnode
= swnode
->parent
;
642 return swnode
? software_node_get(&swnode
->fwnode
) : NULL
;
646 software_node_graph_parse_endpoint(const struct fwnode_handle
*fwnode
,
647 struct fwnode_endpoint
*endpoint
)
649 struct swnode
*swnode
= to_swnode(fwnode
);
650 const char *parent_name
= swnode
->parent
->node
->name
;
653 if (strlen("port@") >= strlen(parent_name
) ||
654 strncmp(parent_name
, "port@", strlen("port@")))
657 /* Ports have naming style "port@n", we need to select the n */
658 ret
= kstrtou32(parent_name
+ strlen("port@"), 10, &endpoint
->port
);
662 endpoint
->id
= swnode
->id
;
663 endpoint
->local_fwnode
= fwnode
;
668 static const struct fwnode_operations software_node_ops
= {
669 .get
= software_node_get
,
670 .put
= software_node_put
,
671 .property_present
= software_node_property_present
,
672 .property_read_int_array
= software_node_read_int_array
,
673 .property_read_string_array
= software_node_read_string_array
,
674 .get_name
= software_node_get_name
,
675 .get_name_prefix
= software_node_get_name_prefix
,
676 .get_parent
= software_node_get_parent
,
677 .get_next_child_node
= software_node_get_next_child
,
678 .get_named_child_node
= software_node_get_named_child_node
,
679 .get_reference_args
= software_node_get_reference_args
,
680 .graph_get_next_endpoint
= software_node_graph_get_next_endpoint
,
681 .graph_get_remote_endpoint
= software_node_graph_get_remote_endpoint
,
682 .graph_get_port_parent
= software_node_graph_get_port_parent
,
683 .graph_parse_endpoint
= software_node_graph_parse_endpoint
,
686 /* -------------------------------------------------------------------------- */
689 * software_node_find_by_name - Find software node by name
690 * @parent: Parent of the software node
691 * @name: Name of the software node
693 * The function will find a node that is child of @parent and that is named
694 * @name. If no node is found, the function returns NULL.
696 * NOTE: you will need to drop the reference with fwnode_handle_put() after use.
698 const struct software_node
*
699 software_node_find_by_name(const struct software_node
*parent
, const char *name
)
701 struct swnode
*swnode
= NULL
;
707 spin_lock(&swnode_kset
->list_lock
);
709 list_for_each_entry(k
, &swnode_kset
->list
, entry
) {
710 swnode
= kobj_to_swnode(k
);
711 if (parent
== swnode
->node
->parent
&& swnode
->node
->name
&&
712 !strcmp(name
, swnode
->node
->name
)) {
713 kobject_get(&swnode
->kobj
);
719 spin_unlock(&swnode_kset
->list_lock
);
721 return swnode
? swnode
->node
: NULL
;
723 EXPORT_SYMBOL_GPL(software_node_find_by_name
);
725 static struct software_node
*software_node_alloc(const struct property_entry
*properties
)
727 struct property_entry
*props
;
728 struct software_node
*node
;
730 props
= property_entries_dup(properties
);
732 return ERR_CAST(props
);
734 node
= kzalloc(sizeof(*node
), GFP_KERNEL
);
736 property_entries_free(props
);
737 return ERR_PTR(-ENOMEM
);
740 node
->properties
= props
;
745 static void software_node_free(const struct software_node
*node
)
747 property_entries_free(node
->properties
);
751 static void software_node_release(struct kobject
*kobj
)
753 struct swnode
*swnode
= kobj_to_swnode(kobj
);
755 if (swnode
->parent
) {
756 ida_simple_remove(&swnode
->parent
->child_ids
, swnode
->id
);
757 list_del(&swnode
->entry
);
759 ida_simple_remove(&swnode_root_ids
, swnode
->id
);
762 if (swnode
->allocated
)
763 software_node_free(swnode
->node
);
765 ida_destroy(&swnode
->child_ids
);
769 static struct kobj_type software_node_type
= {
770 .release
= software_node_release
,
771 .sysfs_ops
= &kobj_sysfs_ops
,
774 static struct fwnode_handle
*
775 swnode_register(const struct software_node
*node
, struct swnode
*parent
,
776 unsigned int allocated
)
778 struct swnode
*swnode
;
781 swnode
= kzalloc(sizeof(*swnode
), GFP_KERNEL
);
783 return ERR_PTR(-ENOMEM
);
785 ret
= ida_simple_get(parent
? &parent
->child_ids
: &swnode_root_ids
,
794 swnode
->parent
= parent
;
795 swnode
->kobj
.kset
= swnode_kset
;
796 fwnode_init(&swnode
->fwnode
, &software_node_ops
);
798 ida_init(&swnode
->child_ids
);
799 INIT_LIST_HEAD(&swnode
->entry
);
800 INIT_LIST_HEAD(&swnode
->children
);
803 ret
= kobject_init_and_add(&swnode
->kobj
, &software_node_type
,
804 parent
? &parent
->kobj
: NULL
,
807 ret
= kobject_init_and_add(&swnode
->kobj
, &software_node_type
,
808 parent
? &parent
->kobj
: NULL
,
809 "node%d", swnode
->id
);
811 kobject_put(&swnode
->kobj
);
816 * Assign the flag only in the successful case, so
817 * the above kobject_put() won't mess up with properties.
819 swnode
->allocated
= allocated
;
822 list_add_tail(&swnode
->entry
, &parent
->children
);
824 kobject_uevent(&swnode
->kobj
, KOBJ_ADD
);
825 return &swnode
->fwnode
;
829 * software_node_register_nodes - Register an array of software nodes
830 * @nodes: Zero terminated array of software nodes to be registered
832 * Register multiple software nodes at once. If any node in the array
833 * has its .parent pointer set (which can only be to another software_node),
834 * then its parent **must** have been registered before it is; either outside
835 * of this function or by ordering the array such that parent comes before
838 int software_node_register_nodes(const struct software_node
*nodes
)
843 for (i
= 0; nodes
[i
].name
; i
++) {
844 const struct software_node
*parent
= nodes
[i
].parent
;
846 if (parent
&& !software_node_to_swnode(parent
)) {
848 goto err_unregister_nodes
;
851 ret
= software_node_register(&nodes
[i
]);
853 goto err_unregister_nodes
;
858 err_unregister_nodes
:
859 software_node_unregister_nodes(nodes
);
862 EXPORT_SYMBOL_GPL(software_node_register_nodes
);
865 * software_node_unregister_nodes - Unregister an array of software nodes
866 * @nodes: Zero terminated array of software nodes to be unregistered
868 * Unregister multiple software nodes at once. If parent pointers are set up
869 * in any of the software nodes then the array **must** be ordered such that
870 * parents come before their children.
872 * NOTE: If you are uncertain whether the array is ordered such that
873 * parents will be unregistered before their children, it is wiser to
874 * remove the nodes individually, in the correct order (child before
877 void software_node_unregister_nodes(const struct software_node
*nodes
)
881 while (nodes
[i
].name
)
885 software_node_unregister(&nodes
[i
]);
887 EXPORT_SYMBOL_GPL(software_node_unregister_nodes
);
890 * software_node_register_node_group - Register a group of software nodes
891 * @node_group: NULL terminated array of software node pointers to be registered
893 * Register multiple software nodes at once. If any node in the array
894 * has its .parent pointer set (which can only be to another software_node),
895 * then its parent **must** have been registered before it is; either outside
896 * of this function or by ordering the array such that parent comes before
899 int software_node_register_node_group(const struct software_node
**node_group
)
907 for (i
= 0; node_group
[i
]; i
++) {
908 ret
= software_node_register(node_group
[i
]);
910 software_node_unregister_node_group(node_group
);
917 EXPORT_SYMBOL_GPL(software_node_register_node_group
);
920 * software_node_unregister_node_group - Unregister a group of software nodes
921 * @node_group: NULL terminated array of software node pointers to be unregistered
923 * Unregister multiple software nodes at once. If parent pointers are set up
924 * in any of the software nodes then the array **must** be ordered such that
925 * parents come before their children.
927 * NOTE: If you are uncertain whether the array is ordered such that
928 * parents will be unregistered before their children, it is wiser to
929 * remove the nodes individually, in the correct order (child before
932 void software_node_unregister_node_group(
933 const struct software_node
**node_group
)
940 while (node_group
[i
])
944 software_node_unregister(node_group
[i
]);
946 EXPORT_SYMBOL_GPL(software_node_unregister_node_group
);
949 * software_node_register - Register static software node
950 * @node: The software node to be registered
952 int software_node_register(const struct software_node
*node
)
954 struct swnode
*parent
= software_node_to_swnode(node
->parent
);
956 if (software_node_to_swnode(node
))
959 if (node
->parent
&& !parent
)
962 return PTR_ERR_OR_ZERO(swnode_register(node
, parent
, 0));
964 EXPORT_SYMBOL_GPL(software_node_register
);
967 * software_node_unregister - Unregister static software node
968 * @node: The software node to be unregistered
970 void software_node_unregister(const struct software_node
*node
)
972 struct swnode
*swnode
;
974 swnode
= software_node_to_swnode(node
);
976 fwnode_remove_software_node(&swnode
->fwnode
);
978 EXPORT_SYMBOL_GPL(software_node_unregister
);
980 struct fwnode_handle
*
981 fwnode_create_software_node(const struct property_entry
*properties
,
982 const struct fwnode_handle
*parent
)
984 struct fwnode_handle
*fwnode
;
985 struct software_node
*node
;
989 return ERR_CAST(parent
);
991 p
= to_swnode(parent
);
993 return ERR_PTR(-EINVAL
);
995 node
= software_node_alloc(properties
);
997 return ERR_CAST(node
);
999 node
->parent
= p
? p
->node
: NULL
;
1001 fwnode
= swnode_register(node
, p
, 1);
1003 software_node_free(node
);
1007 EXPORT_SYMBOL_GPL(fwnode_create_software_node
);
1009 void fwnode_remove_software_node(struct fwnode_handle
*fwnode
)
1011 struct swnode
*swnode
= to_swnode(fwnode
);
1016 kobject_put(&swnode
->kobj
);
1018 EXPORT_SYMBOL_GPL(fwnode_remove_software_node
);
1021 * device_add_software_node - Assign software node to a device
1022 * @dev: The device the software node is meant for.
1023 * @node: The software node.
1025 * This function will make @node the secondary firmware node pointer of @dev. If
1026 * @dev has no primary node, then @node will become the primary node. The
1027 * function will register @node automatically if it wasn't already registered.
1029 int device_add_software_node(struct device
*dev
, const struct software_node
*node
)
1031 struct swnode
*swnode
;
1034 /* Only one software node per device. */
1035 if (dev_to_swnode(dev
))
1038 swnode
= software_node_to_swnode(node
);
1040 kobject_get(&swnode
->kobj
);
1042 ret
= software_node_register(node
);
1046 swnode
= software_node_to_swnode(node
);
1049 set_secondary_fwnode(dev
, &swnode
->fwnode
);
1052 * If the device has been fully registered by the time this function is
1053 * called, software_node_notify() must be called separately so that the
1054 * symlinks get created and the reference count of the node is kept in
1057 if (device_is_registered(dev
))
1058 software_node_notify(dev
);
1062 EXPORT_SYMBOL_GPL(device_add_software_node
);
1065 * device_remove_software_node - Remove device's software node
1066 * @dev: The device with the software node.
1068 * This function will unregister the software node of @dev.
1070 void device_remove_software_node(struct device
*dev
)
1072 struct swnode
*swnode
;
1074 swnode
= dev_to_swnode(dev
);
1078 if (device_is_registered(dev
))
1079 software_node_notify_remove(dev
);
1081 set_secondary_fwnode(dev
, NULL
);
1082 kobject_put(&swnode
->kobj
);
1084 EXPORT_SYMBOL_GPL(device_remove_software_node
);
1087 * device_create_managed_software_node - Create a software node for a device
1088 * @dev: The device the software node is assigned to.
1089 * @properties: Device properties for the software node.
1090 * @parent: Parent of the software node.
1092 * Creates a software node as a managed resource for @dev, which means the
1093 * lifetime of the newly created software node is tied to the lifetime of @dev.
1094 * Software nodes created with this function should not be reused or shared
1095 * because of that. The function takes a deep copy of @properties for the
1098 * Since the new software node is assigned directly to @dev, and since it should
1099 * not be shared, it is not returned to the caller. The function returns 0 on
1100 * success, and errno in case of an error.
1102 int device_create_managed_software_node(struct device
*dev
,
1103 const struct property_entry
*properties
,
1104 const struct software_node
*parent
)
1106 struct fwnode_handle
*p
= software_node_fwnode(parent
);
1107 struct fwnode_handle
*fwnode
;
1112 fwnode
= fwnode_create_software_node(properties
, p
);
1114 return PTR_ERR(fwnode
);
1116 to_swnode(fwnode
)->managed
= true;
1117 set_secondary_fwnode(dev
, fwnode
);
1119 if (device_is_registered(dev
))
1120 software_node_notify(dev
);
1124 EXPORT_SYMBOL_GPL(device_create_managed_software_node
);
1126 void software_node_notify(struct device
*dev
)
1128 struct swnode
*swnode
;
1131 swnode
= dev_to_swnode(dev
);
1135 ret
= sysfs_create_link(&dev
->kobj
, &swnode
->kobj
, "software_node");
1139 ret
= sysfs_create_link(&swnode
->kobj
, &dev
->kobj
, dev_name(dev
));
1141 sysfs_remove_link(&dev
->kobj
, "software_node");
1145 kobject_get(&swnode
->kobj
);
1148 void software_node_notify_remove(struct device
*dev
)
1150 struct swnode
*swnode
;
1152 swnode
= dev_to_swnode(dev
);
1156 sysfs_remove_link(&swnode
->kobj
, dev_name(dev
));
1157 sysfs_remove_link(&dev
->kobj
, "software_node");
1158 kobject_put(&swnode
->kobj
);
1160 if (swnode
->managed
) {
1161 set_secondary_fwnode(dev
, NULL
);
1162 kobject_put(&swnode
->kobj
);
1166 static int __init
software_node_init(void)
1168 swnode_kset
= kset_create_and_add("software_nodes", NULL
, kernel_kobj
);
1173 postcore_initcall(software_node_init
);
1175 static void __exit
software_node_exit(void)
1177 ida_destroy(&swnode_root_ids
);
1178 kset_unregister(swnode_kset
);
1180 __exitcall(software_node_exit
);