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