xref: /openbmc/linux/drivers/of/base.c (revision b64d09a4)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Procedures for creating, accessing and interpreting the device tree.
4  *
5  * Paul Mackerras	August 1996.
6  * Copyright (C) 1996-2005 Paul Mackerras.
7  *
8  *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
9  *    {engebret|bergner}@us.ibm.com
10  *
11  *  Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net
12  *
13  *  Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
14  *  Grant Likely.
15  */
16 
17 #define pr_fmt(fmt)	"OF: " fmt
18 
19 #include <linux/console.h>
20 #include <linux/ctype.h>
21 #include <linux/cpu.h>
22 #include <linux/module.h>
23 #include <linux/of.h>
24 #include <linux/of_device.h>
25 #include <linux/of_graph.h>
26 #include <linux/spinlock.h>
27 #include <linux/slab.h>
28 #include <linux/string.h>
29 #include <linux/proc_fs.h>
30 
31 #include "of_private.h"
32 
33 LIST_HEAD(aliases_lookup);
34 
35 struct device_node *of_root;
36 EXPORT_SYMBOL(of_root);
37 struct device_node *of_chosen;
38 EXPORT_SYMBOL(of_chosen);
39 struct device_node *of_aliases;
40 struct device_node *of_stdout;
41 static const char *of_stdout_options;
42 
43 struct kset *of_kset;
44 
45 /*
46  * Used to protect the of_aliases, to hold off addition of nodes to sysfs.
47  * This mutex must be held whenever modifications are being made to the
48  * device tree. The of_{attach,detach}_node() and
49  * of_{add,remove,update}_property() helpers make sure this happens.
50  */
51 DEFINE_MUTEX(of_mutex);
52 
53 /* use when traversing tree through the child, sibling,
54  * or parent members of struct device_node.
55  */
56 DEFINE_RAW_SPINLOCK(devtree_lock);
57 
of_node_name_eq(const struct device_node * np,const char * name)58 bool of_node_name_eq(const struct device_node *np, const char *name)
59 {
60 	const char *node_name;
61 	size_t len;
62 
63 	if (!np)
64 		return false;
65 
66 	node_name = kbasename(np->full_name);
67 	len = strchrnul(node_name, '@') - node_name;
68 
69 	return (strlen(name) == len) && (strncmp(node_name, name, len) == 0);
70 }
71 EXPORT_SYMBOL(of_node_name_eq);
72 
of_node_name_prefix(const struct device_node * np,const char * prefix)73 bool of_node_name_prefix(const struct device_node *np, const char *prefix)
74 {
75 	if (!np)
76 		return false;
77 
78 	return strncmp(kbasename(np->full_name), prefix, strlen(prefix)) == 0;
79 }
80 EXPORT_SYMBOL(of_node_name_prefix);
81 
__of_node_is_type(const struct device_node * np,const char * type)82 static bool __of_node_is_type(const struct device_node *np, const char *type)
83 {
84 	const char *match = __of_get_property(np, "device_type", NULL);
85 
86 	return np && match && type && !strcmp(match, type);
87 }
88 
of_bus_n_addr_cells(struct device_node * np)89 int of_bus_n_addr_cells(struct device_node *np)
90 {
91 	u32 cells;
92 
93 	for (; np; np = np->parent)
94 		if (!of_property_read_u32(np, "#address-cells", &cells))
95 			return cells;
96 
97 	/* No #address-cells property for the root node */
98 	return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
99 }
100 
of_n_addr_cells(struct device_node * np)101 int of_n_addr_cells(struct device_node *np)
102 {
103 	if (np->parent)
104 		np = np->parent;
105 
106 	return of_bus_n_addr_cells(np);
107 }
108 EXPORT_SYMBOL(of_n_addr_cells);
109 
of_bus_n_size_cells(struct device_node * np)110 int of_bus_n_size_cells(struct device_node *np)
111 {
112 	u32 cells;
113 
114 	for (; np; np = np->parent)
115 		if (!of_property_read_u32(np, "#size-cells", &cells))
116 			return cells;
117 
118 	/* No #size-cells property for the root node */
119 	return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
120 }
121 
of_n_size_cells(struct device_node * np)122 int of_n_size_cells(struct device_node *np)
123 {
124 	if (np->parent)
125 		np = np->parent;
126 
127 	return of_bus_n_size_cells(np);
128 }
129 EXPORT_SYMBOL(of_n_size_cells);
130 
131 #ifdef CONFIG_NUMA
of_node_to_nid(struct device_node * np)132 int __weak of_node_to_nid(struct device_node *np)
133 {
134 	return NUMA_NO_NODE;
135 }
136 #endif
137 
138 #define OF_PHANDLE_CACHE_BITS	7
139 #define OF_PHANDLE_CACHE_SZ	BIT(OF_PHANDLE_CACHE_BITS)
140 
141 static struct device_node *phandle_cache[OF_PHANDLE_CACHE_SZ];
142 
of_phandle_cache_hash(phandle handle)143 static u32 of_phandle_cache_hash(phandle handle)
144 {
145 	return hash_32(handle, OF_PHANDLE_CACHE_BITS);
146 }
147 
148 /*
149  * Caller must hold devtree_lock.
150  */
__of_phandle_cache_inv_entry(phandle handle)151 void __of_phandle_cache_inv_entry(phandle handle)
152 {
153 	u32 handle_hash;
154 	struct device_node *np;
155 
156 	if (!handle)
157 		return;
158 
159 	handle_hash = of_phandle_cache_hash(handle);
160 
161 	np = phandle_cache[handle_hash];
162 	if (np && handle == np->phandle)
163 		phandle_cache[handle_hash] = NULL;
164 }
165 
of_core_init(void)166 void __init of_core_init(void)
167 {
168 	struct device_node *np;
169 
170 	of_platform_register_reconfig_notifier();
171 
172 	/* Create the kset, and register existing nodes */
173 	mutex_lock(&of_mutex);
174 	of_kset = kset_create_and_add("devicetree", NULL, firmware_kobj);
175 	if (!of_kset) {
176 		mutex_unlock(&of_mutex);
177 		pr_err("failed to register existing nodes\n");
178 		return;
179 	}
180 	for_each_of_allnodes(np) {
181 		__of_attach_node_sysfs(np);
182 		if (np->phandle && !phandle_cache[of_phandle_cache_hash(np->phandle)])
183 			phandle_cache[of_phandle_cache_hash(np->phandle)] = np;
184 	}
185 	mutex_unlock(&of_mutex);
186 
187 	/* Symlink in /proc as required by userspace ABI */
188 	if (of_root)
189 		proc_symlink("device-tree", NULL, "/sys/firmware/devicetree/base");
190 }
191 
__of_find_property(const struct device_node * np,const char * name,int * lenp)192 static struct property *__of_find_property(const struct device_node *np,
193 					   const char *name, int *lenp)
194 {
195 	struct property *pp;
196 
197 	if (!np)
198 		return NULL;
199 
200 	for (pp = np->properties; pp; pp = pp->next) {
201 		if (of_prop_cmp(pp->name, name) == 0) {
202 			if (lenp)
203 				*lenp = pp->length;
204 			break;
205 		}
206 	}
207 
208 	return pp;
209 }
210 
of_find_property(const struct device_node * np,const char * name,int * lenp)211 struct property *of_find_property(const struct device_node *np,
212 				  const char *name,
213 				  int *lenp)
214 {
215 	struct property *pp;
216 	unsigned long flags;
217 
218 	raw_spin_lock_irqsave(&devtree_lock, flags);
219 	pp = __of_find_property(np, name, lenp);
220 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
221 
222 	return pp;
223 }
224 EXPORT_SYMBOL(of_find_property);
225 
__of_find_all_nodes(struct device_node * prev)226 struct device_node *__of_find_all_nodes(struct device_node *prev)
227 {
228 	struct device_node *np;
229 	if (!prev) {
230 		np = of_root;
231 	} else if (prev->child) {
232 		np = prev->child;
233 	} else {
234 		/* Walk back up looking for a sibling, or the end of the structure */
235 		np = prev;
236 		while (np->parent && !np->sibling)
237 			np = np->parent;
238 		np = np->sibling; /* Might be null at the end of the tree */
239 	}
240 	return np;
241 }
242 
243 /**
244  * of_find_all_nodes - Get next node in global list
245  * @prev:	Previous node or NULL to start iteration
246  *		of_node_put() will be called on it
247  *
248  * Return: A node pointer with refcount incremented, use
249  * of_node_put() on it when done.
250  */
of_find_all_nodes(struct device_node * prev)251 struct device_node *of_find_all_nodes(struct device_node *prev)
252 {
253 	struct device_node *np;
254 	unsigned long flags;
255 
256 	raw_spin_lock_irqsave(&devtree_lock, flags);
257 	np = __of_find_all_nodes(prev);
258 	of_node_get(np);
259 	of_node_put(prev);
260 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
261 	return np;
262 }
263 EXPORT_SYMBOL(of_find_all_nodes);
264 
265 /*
266  * Find a property with a given name for a given node
267  * and return the value.
268  */
__of_get_property(const struct device_node * np,const char * name,int * lenp)269 const void *__of_get_property(const struct device_node *np,
270 			      const char *name, int *lenp)
271 {
272 	struct property *pp = __of_find_property(np, name, lenp);
273 
274 	return pp ? pp->value : NULL;
275 }
276 
277 /*
278  * Find a property with a given name for a given node
279  * and return the value.
280  */
of_get_property(const struct device_node * np,const char * name,int * lenp)281 const void *of_get_property(const struct device_node *np, const char *name,
282 			    int *lenp)
283 {
284 	struct property *pp = of_find_property(np, name, lenp);
285 
286 	return pp ? pp->value : NULL;
287 }
288 EXPORT_SYMBOL(of_get_property);
289 
290 /**
291  * __of_device_is_compatible() - Check if the node matches given constraints
292  * @device: pointer to node
293  * @compat: required compatible string, NULL or "" for any match
294  * @type: required device_type value, NULL or "" for any match
295  * @name: required node name, NULL or "" for any match
296  *
297  * Checks if the given @compat, @type and @name strings match the
298  * properties of the given @device. A constraints can be skipped by
299  * passing NULL or an empty string as the constraint.
300  *
301  * Returns 0 for no match, and a positive integer on match. The return
302  * value is a relative score with larger values indicating better
303  * matches. The score is weighted for the most specific compatible value
304  * to get the highest score. Matching type is next, followed by matching
305  * name. Practically speaking, this results in the following priority
306  * order for matches:
307  *
308  * 1. specific compatible && type && name
309  * 2. specific compatible && type
310  * 3. specific compatible && name
311  * 4. specific compatible
312  * 5. general compatible && type && name
313  * 6. general compatible && type
314  * 7. general compatible && name
315  * 8. general compatible
316  * 9. type && name
317  * 10. type
318  * 11. name
319  */
__of_device_is_compatible(const struct device_node * device,const char * compat,const char * type,const char * name)320 static int __of_device_is_compatible(const struct device_node *device,
321 				     const char *compat, const char *type, const char *name)
322 {
323 	struct property *prop;
324 	const char *cp;
325 	int index = 0, score = 0;
326 
327 	/* Compatible match has highest priority */
328 	if (compat && compat[0]) {
329 		prop = __of_find_property(device, "compatible", NULL);
330 		for (cp = of_prop_next_string(prop, NULL); cp;
331 		     cp = of_prop_next_string(prop, cp), index++) {
332 			if (of_compat_cmp(cp, compat, strlen(compat)) == 0) {
333 				score = INT_MAX/2 - (index << 2);
334 				break;
335 			}
336 		}
337 		if (!score)
338 			return 0;
339 	}
340 
341 	/* Matching type is better than matching name */
342 	if (type && type[0]) {
343 		if (!__of_node_is_type(device, type))
344 			return 0;
345 		score += 2;
346 	}
347 
348 	/* Matching name is a bit better than not */
349 	if (name && name[0]) {
350 		if (!of_node_name_eq(device, name))
351 			return 0;
352 		score++;
353 	}
354 
355 	return score;
356 }
357 
358 /** Checks if the given "compat" string matches one of the strings in
359  * the device's "compatible" property
360  */
of_device_is_compatible(const struct device_node * device,const char * compat)361 int of_device_is_compatible(const struct device_node *device,
362 		const char *compat)
363 {
364 	unsigned long flags;
365 	int res;
366 
367 	raw_spin_lock_irqsave(&devtree_lock, flags);
368 	res = __of_device_is_compatible(device, compat, NULL, NULL);
369 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
370 	return res;
371 }
372 EXPORT_SYMBOL(of_device_is_compatible);
373 
374 /** Checks if the device is compatible with any of the entries in
375  *  a NULL terminated array of strings. Returns the best match
376  *  score or 0.
377  */
of_device_compatible_match(const struct device_node * device,const char * const * compat)378 int of_device_compatible_match(const struct device_node *device,
379 			       const char *const *compat)
380 {
381 	unsigned int tmp, score = 0;
382 
383 	if (!compat)
384 		return 0;
385 
386 	while (*compat) {
387 		tmp = of_device_is_compatible(device, *compat);
388 		if (tmp > score)
389 			score = tmp;
390 		compat++;
391 	}
392 
393 	return score;
394 }
395 EXPORT_SYMBOL_GPL(of_device_compatible_match);
396 
397 /**
398  * of_machine_is_compatible - Test root of device tree for a given compatible value
399  * @compat: compatible string to look for in root node's compatible property.
400  *
401  * Return: A positive integer if the root node has the given value in its
402  * compatible property.
403  */
of_machine_is_compatible(const char * compat)404 int of_machine_is_compatible(const char *compat)
405 {
406 	struct device_node *root;
407 	int rc = 0;
408 
409 	root = of_find_node_by_path("/");
410 	if (root) {
411 		rc = of_device_is_compatible(root, compat);
412 		of_node_put(root);
413 	}
414 	return rc;
415 }
416 EXPORT_SYMBOL(of_machine_is_compatible);
417 
418 /**
419  *  __of_device_is_available - check if a device is available for use
420  *
421  *  @device: Node to check for availability, with locks already held
422  *
423  *  Return: True if the status property is absent or set to "okay" or "ok",
424  *  false otherwise
425  */
__of_device_is_available(const struct device_node * device)426 static bool __of_device_is_available(const struct device_node *device)
427 {
428 	const char *status;
429 	int statlen;
430 
431 	if (!device)
432 		return false;
433 
434 	status = __of_get_property(device, "status", &statlen);
435 	if (status == NULL)
436 		return true;
437 
438 	if (statlen > 0) {
439 		if (!strcmp(status, "okay") || !strcmp(status, "ok"))
440 			return true;
441 	}
442 
443 	return false;
444 }
445 
446 /**
447  *  of_device_is_available - check if a device is available for use
448  *
449  *  @device: Node to check for availability
450  *
451  *  Return: True if the status property is absent or set to "okay" or "ok",
452  *  false otherwise
453  */
of_device_is_available(const struct device_node * device)454 bool of_device_is_available(const struct device_node *device)
455 {
456 	unsigned long flags;
457 	bool res;
458 
459 	raw_spin_lock_irqsave(&devtree_lock, flags);
460 	res = __of_device_is_available(device);
461 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
462 	return res;
463 
464 }
465 EXPORT_SYMBOL(of_device_is_available);
466 
467 /**
468  *  __of_device_is_fail - check if a device has status "fail" or "fail-..."
469  *
470  *  @device: Node to check status for, with locks already held
471  *
472  *  Return: True if the status property is set to "fail" or "fail-..." (for any
473  *  error code suffix), false otherwise
474  */
__of_device_is_fail(const struct device_node * device)475 static bool __of_device_is_fail(const struct device_node *device)
476 {
477 	const char *status;
478 
479 	if (!device)
480 		return false;
481 
482 	status = __of_get_property(device, "status", NULL);
483 	if (status == NULL)
484 		return false;
485 
486 	return !strcmp(status, "fail") || !strncmp(status, "fail-", 5);
487 }
488 
489 /**
490  *  of_device_is_big_endian - check if a device has BE registers
491  *
492  *  @device: Node to check for endianness
493  *
494  *  Return: True if the device has a "big-endian" property, or if the kernel
495  *  was compiled for BE *and* the device has a "native-endian" property.
496  *  Returns false otherwise.
497  *
498  *  Callers would nominally use ioread32be/iowrite32be if
499  *  of_device_is_big_endian() == true, or readl/writel otherwise.
500  */
of_device_is_big_endian(const struct device_node * device)501 bool of_device_is_big_endian(const struct device_node *device)
502 {
503 	if (of_property_read_bool(device, "big-endian"))
504 		return true;
505 	if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) &&
506 	    of_property_read_bool(device, "native-endian"))
507 		return true;
508 	return false;
509 }
510 EXPORT_SYMBOL(of_device_is_big_endian);
511 
512 /**
513  * of_get_parent - Get a node's parent if any
514  * @node:	Node to get parent
515  *
516  * Return: A node pointer with refcount incremented, use
517  * of_node_put() on it when done.
518  */
of_get_parent(const struct device_node * node)519 struct device_node *of_get_parent(const struct device_node *node)
520 {
521 	struct device_node *np;
522 	unsigned long flags;
523 
524 	if (!node)
525 		return NULL;
526 
527 	raw_spin_lock_irqsave(&devtree_lock, flags);
528 	np = of_node_get(node->parent);
529 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
530 	return np;
531 }
532 EXPORT_SYMBOL(of_get_parent);
533 
534 /**
535  * of_get_next_parent - Iterate to a node's parent
536  * @node:	Node to get parent of
537  *
538  * This is like of_get_parent() except that it drops the
539  * refcount on the passed node, making it suitable for iterating
540  * through a node's parents.
541  *
542  * Return: A node pointer with refcount incremented, use
543  * of_node_put() on it when done.
544  */
of_get_next_parent(struct device_node * node)545 struct device_node *of_get_next_parent(struct device_node *node)
546 {
547 	struct device_node *parent;
548 	unsigned long flags;
549 
550 	if (!node)
551 		return NULL;
552 
553 	raw_spin_lock_irqsave(&devtree_lock, flags);
554 	parent = of_node_get(node->parent);
555 	of_node_put(node);
556 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
557 	return parent;
558 }
559 EXPORT_SYMBOL(of_get_next_parent);
560 
__of_get_next_child(const struct device_node * node,struct device_node * prev)561 static struct device_node *__of_get_next_child(const struct device_node *node,
562 						struct device_node *prev)
563 {
564 	struct device_node *next;
565 
566 	if (!node)
567 		return NULL;
568 
569 	next = prev ? prev->sibling : node->child;
570 	of_node_get(next);
571 	of_node_put(prev);
572 	return next;
573 }
574 #define __for_each_child_of_node(parent, child) \
575 	for (child = __of_get_next_child(parent, NULL); child != NULL; \
576 	     child = __of_get_next_child(parent, child))
577 
578 /**
579  * of_get_next_child - Iterate a node childs
580  * @node:	parent node
581  * @prev:	previous child of the parent node, or NULL to get first
582  *
583  * Return: A node pointer with refcount incremented, use of_node_put() on
584  * it when done. Returns NULL when prev is the last child. Decrements the
585  * refcount of prev.
586  */
of_get_next_child(const struct device_node * node,struct device_node * prev)587 struct device_node *of_get_next_child(const struct device_node *node,
588 	struct device_node *prev)
589 {
590 	struct device_node *next;
591 	unsigned long flags;
592 
593 	raw_spin_lock_irqsave(&devtree_lock, flags);
594 	next = __of_get_next_child(node, prev);
595 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
596 	return next;
597 }
598 EXPORT_SYMBOL(of_get_next_child);
599 
600 /**
601  * of_get_next_available_child - Find the next available child node
602  * @node:	parent node
603  * @prev:	previous child of the parent node, or NULL to get first
604  *
605  * This function is like of_get_next_child(), except that it
606  * automatically skips any disabled nodes (i.e. status = "disabled").
607  */
of_get_next_available_child(const struct device_node * node,struct device_node * prev)608 struct device_node *of_get_next_available_child(const struct device_node *node,
609 	struct device_node *prev)
610 {
611 	struct device_node *next;
612 	unsigned long flags;
613 
614 	if (!node)
615 		return NULL;
616 
617 	raw_spin_lock_irqsave(&devtree_lock, flags);
618 	next = prev ? prev->sibling : node->child;
619 	for (; next; next = next->sibling) {
620 		if (!__of_device_is_available(next))
621 			continue;
622 		if (of_node_get(next))
623 			break;
624 	}
625 	of_node_put(prev);
626 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
627 	return next;
628 }
629 EXPORT_SYMBOL(of_get_next_available_child);
630 
631 /**
632  * of_get_next_cpu_node - Iterate on cpu nodes
633  * @prev:	previous child of the /cpus node, or NULL to get first
634  *
635  * Unusable CPUs (those with the status property set to "fail" or "fail-...")
636  * will be skipped.
637  *
638  * Return: A cpu node pointer with refcount incremented, use of_node_put()
639  * on it when done. Returns NULL when prev is the last child. Decrements
640  * the refcount of prev.
641  */
of_get_next_cpu_node(struct device_node * prev)642 struct device_node *of_get_next_cpu_node(struct device_node *prev)
643 {
644 	struct device_node *next = NULL;
645 	unsigned long flags;
646 	struct device_node *node;
647 
648 	if (!prev)
649 		node = of_find_node_by_path("/cpus");
650 
651 	raw_spin_lock_irqsave(&devtree_lock, flags);
652 	if (prev)
653 		next = prev->sibling;
654 	else if (node) {
655 		next = node->child;
656 		of_node_put(node);
657 	}
658 	for (; next; next = next->sibling) {
659 		if (__of_device_is_fail(next))
660 			continue;
661 		if (!(of_node_name_eq(next, "cpu") ||
662 		      __of_node_is_type(next, "cpu")))
663 			continue;
664 		if (of_node_get(next))
665 			break;
666 	}
667 	of_node_put(prev);
668 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
669 	return next;
670 }
671 EXPORT_SYMBOL(of_get_next_cpu_node);
672 
673 /**
674  * of_get_compatible_child - Find compatible child node
675  * @parent:	parent node
676  * @compatible:	compatible string
677  *
678  * Lookup child node whose compatible property contains the given compatible
679  * string.
680  *
681  * Return: a node pointer with refcount incremented, use of_node_put() on it
682  * when done; or NULL if not found.
683  */
of_get_compatible_child(const struct device_node * parent,const char * compatible)684 struct device_node *of_get_compatible_child(const struct device_node *parent,
685 				const char *compatible)
686 {
687 	struct device_node *child;
688 
689 	for_each_child_of_node(parent, child) {
690 		if (of_device_is_compatible(child, compatible))
691 			break;
692 	}
693 
694 	return child;
695 }
696 EXPORT_SYMBOL(of_get_compatible_child);
697 
698 /**
699  * of_get_child_by_name - Find the child node by name for a given parent
700  * @node:	parent node
701  * @name:	child name to look for.
702  *
703  * This function looks for child node for given matching name
704  *
705  * Return: A node pointer if found, with refcount incremented, use
706  * of_node_put() on it when done.
707  * Returns NULL if node is not found.
708  */
of_get_child_by_name(const struct device_node * node,const char * name)709 struct device_node *of_get_child_by_name(const struct device_node *node,
710 				const char *name)
711 {
712 	struct device_node *child;
713 
714 	for_each_child_of_node(node, child)
715 		if (of_node_name_eq(child, name))
716 			break;
717 	return child;
718 }
719 EXPORT_SYMBOL(of_get_child_by_name);
720 
__of_find_node_by_path(struct device_node * parent,const char * path)721 struct device_node *__of_find_node_by_path(struct device_node *parent,
722 						const char *path)
723 {
724 	struct device_node *child;
725 	int len;
726 
727 	len = strcspn(path, "/:");
728 	if (!len)
729 		return NULL;
730 
731 	__for_each_child_of_node(parent, child) {
732 		const char *name = kbasename(child->full_name);
733 		if (strncmp(path, name, len) == 0 && (strlen(name) == len))
734 			return child;
735 	}
736 	return NULL;
737 }
738 
__of_find_node_by_full_path(struct device_node * node,const char * path)739 struct device_node *__of_find_node_by_full_path(struct device_node *node,
740 						const char *path)
741 {
742 	const char *separator = strchr(path, ':');
743 
744 	while (node && *path == '/') {
745 		struct device_node *tmp = node;
746 
747 		path++; /* Increment past '/' delimiter */
748 		node = __of_find_node_by_path(node, path);
749 		of_node_put(tmp);
750 		path = strchrnul(path, '/');
751 		if (separator && separator < path)
752 			break;
753 	}
754 	return node;
755 }
756 
757 /**
758  * of_find_node_opts_by_path - Find a node matching a full OF path
759  * @path: Either the full path to match, or if the path does not
760  *       start with '/', the name of a property of the /aliases
761  *       node (an alias).  In the case of an alias, the node
762  *       matching the alias' value will be returned.
763  * @opts: Address of a pointer into which to store the start of
764  *       an options string appended to the end of the path with
765  *       a ':' separator.
766  *
767  * Valid paths:
768  *  * /foo/bar	Full path
769  *  * foo	Valid alias
770  *  * foo/bar	Valid alias + relative path
771  *
772  * Return: A node pointer with refcount incremented, use
773  * of_node_put() on it when done.
774  */
of_find_node_opts_by_path(const char * path,const char ** opts)775 struct device_node *of_find_node_opts_by_path(const char *path, const char **opts)
776 {
777 	struct device_node *np = NULL;
778 	struct property *pp;
779 	unsigned long flags;
780 	const char *separator = strchr(path, ':');
781 
782 	if (opts)
783 		*opts = separator ? separator + 1 : NULL;
784 
785 	if (strcmp(path, "/") == 0)
786 		return of_node_get(of_root);
787 
788 	/* The path could begin with an alias */
789 	if (*path != '/') {
790 		int len;
791 		const char *p = separator;
792 
793 		if (!p)
794 			p = strchrnul(path, '/');
795 		len = p - path;
796 
797 		/* of_aliases must not be NULL */
798 		if (!of_aliases)
799 			return NULL;
800 
801 		for_each_property_of_node(of_aliases, pp) {
802 			if (strlen(pp->name) == len && !strncmp(pp->name, path, len)) {
803 				np = of_find_node_by_path(pp->value);
804 				break;
805 			}
806 		}
807 		if (!np)
808 			return NULL;
809 		path = p;
810 	}
811 
812 	/* Step down the tree matching path components */
813 	raw_spin_lock_irqsave(&devtree_lock, flags);
814 	if (!np)
815 		np = of_node_get(of_root);
816 	np = __of_find_node_by_full_path(np, path);
817 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
818 	return np;
819 }
820 EXPORT_SYMBOL(of_find_node_opts_by_path);
821 
822 /**
823  * of_find_node_by_name - Find a node by its "name" property
824  * @from:	The node to start searching from or NULL; the node
825  *		you pass will not be searched, only the next one
826  *		will. Typically, you pass what the previous call
827  *		returned. of_node_put() will be called on @from.
828  * @name:	The name string to match against
829  *
830  * Return: A node pointer with refcount incremented, use
831  * of_node_put() on it when done.
832  */
of_find_node_by_name(struct device_node * from,const char * name)833 struct device_node *of_find_node_by_name(struct device_node *from,
834 	const char *name)
835 {
836 	struct device_node *np;
837 	unsigned long flags;
838 
839 	raw_spin_lock_irqsave(&devtree_lock, flags);
840 	for_each_of_allnodes_from(from, np)
841 		if (of_node_name_eq(np, name) && of_node_get(np))
842 			break;
843 	of_node_put(from);
844 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
845 	return np;
846 }
847 EXPORT_SYMBOL(of_find_node_by_name);
848 
849 /**
850  * of_find_node_by_type - Find a node by its "device_type" property
851  * @from:	The node to start searching from, or NULL to start searching
852  *		the entire device tree. The node you pass will not be
853  *		searched, only the next one will; typically, you pass
854  *		what the previous call returned. of_node_put() will be
855  *		called on from for you.
856  * @type:	The type string to match against
857  *
858  * Return: A node pointer with refcount incremented, use
859  * of_node_put() on it when done.
860  */
of_find_node_by_type(struct device_node * from,const char * type)861 struct device_node *of_find_node_by_type(struct device_node *from,
862 	const char *type)
863 {
864 	struct device_node *np;
865 	unsigned long flags;
866 
867 	raw_spin_lock_irqsave(&devtree_lock, flags);
868 	for_each_of_allnodes_from(from, np)
869 		if (__of_node_is_type(np, type) && of_node_get(np))
870 			break;
871 	of_node_put(from);
872 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
873 	return np;
874 }
875 EXPORT_SYMBOL(of_find_node_by_type);
876 
877 /**
878  * of_find_compatible_node - Find a node based on type and one of the
879  *                                tokens in its "compatible" property
880  * @from:	The node to start searching from or NULL, the node
881  *		you pass will not be searched, only the next one
882  *		will; typically, you pass what the previous call
883  *		returned. of_node_put() will be called on it
884  * @type:	The type string to match "device_type" or NULL to ignore
885  * @compatible:	The string to match to one of the tokens in the device
886  *		"compatible" list.
887  *
888  * Return: A node pointer with refcount incremented, use
889  * of_node_put() on it when done.
890  */
of_find_compatible_node(struct device_node * from,const char * type,const char * compatible)891 struct device_node *of_find_compatible_node(struct device_node *from,
892 	const char *type, const char *compatible)
893 {
894 	struct device_node *np;
895 	unsigned long flags;
896 
897 	raw_spin_lock_irqsave(&devtree_lock, flags);
898 	for_each_of_allnodes_from(from, np)
899 		if (__of_device_is_compatible(np, compatible, type, NULL) &&
900 		    of_node_get(np))
901 			break;
902 	of_node_put(from);
903 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
904 	return np;
905 }
906 EXPORT_SYMBOL(of_find_compatible_node);
907 
908 /**
909  * of_find_node_with_property - Find a node which has a property with
910  *                              the given name.
911  * @from:	The node to start searching from or NULL, the node
912  *		you pass will not be searched, only the next one
913  *		will; typically, you pass what the previous call
914  *		returned. of_node_put() will be called on it
915  * @prop_name:	The name of the property to look for.
916  *
917  * Return: A node pointer with refcount incremented, use
918  * of_node_put() on it when done.
919  */
of_find_node_with_property(struct device_node * from,const char * prop_name)920 struct device_node *of_find_node_with_property(struct device_node *from,
921 	const char *prop_name)
922 {
923 	struct device_node *np;
924 	struct property *pp;
925 	unsigned long flags;
926 
927 	raw_spin_lock_irqsave(&devtree_lock, flags);
928 	for_each_of_allnodes_from(from, np) {
929 		for (pp = np->properties; pp; pp = pp->next) {
930 			if (of_prop_cmp(pp->name, prop_name) == 0) {
931 				of_node_get(np);
932 				goto out;
933 			}
934 		}
935 	}
936 out:
937 	of_node_put(from);
938 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
939 	return np;
940 }
941 EXPORT_SYMBOL(of_find_node_with_property);
942 
943 static
__of_match_node(const struct of_device_id * matches,const struct device_node * node)944 const struct of_device_id *__of_match_node(const struct of_device_id *matches,
945 					   const struct device_node *node)
946 {
947 	const struct of_device_id *best_match = NULL;
948 	int score, best_score = 0;
949 
950 	if (!matches)
951 		return NULL;
952 
953 	for (; matches->name[0] || matches->type[0] || matches->compatible[0]; matches++) {
954 		score = __of_device_is_compatible(node, matches->compatible,
955 						  matches->type, matches->name);
956 		if (score > best_score) {
957 			best_match = matches;
958 			best_score = score;
959 		}
960 	}
961 
962 	return best_match;
963 }
964 
965 /**
966  * of_match_node - Tell if a device_node has a matching of_match structure
967  * @matches:	array of of device match structures to search in
968  * @node:	the of device structure to match against
969  *
970  * Low level utility function used by device matching.
971  */
of_match_node(const struct of_device_id * matches,const struct device_node * node)972 const struct of_device_id *of_match_node(const struct of_device_id *matches,
973 					 const struct device_node *node)
974 {
975 	const struct of_device_id *match;
976 	unsigned long flags;
977 
978 	raw_spin_lock_irqsave(&devtree_lock, flags);
979 	match = __of_match_node(matches, node);
980 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
981 	return match;
982 }
983 EXPORT_SYMBOL(of_match_node);
984 
985 /**
986  * of_find_matching_node_and_match - Find a node based on an of_device_id
987  *				     match table.
988  * @from:	The node to start searching from or NULL, the node
989  *		you pass will not be searched, only the next one
990  *		will; typically, you pass what the previous call
991  *		returned. of_node_put() will be called on it
992  * @matches:	array of of device match structures to search in
993  * @match:	Updated to point at the matches entry which matched
994  *
995  * Return: A node pointer with refcount incremented, use
996  * of_node_put() on it when done.
997  */
of_find_matching_node_and_match(struct device_node * from,const struct of_device_id * matches,const struct of_device_id ** match)998 struct device_node *of_find_matching_node_and_match(struct device_node *from,
999 					const struct of_device_id *matches,
1000 					const struct of_device_id **match)
1001 {
1002 	struct device_node *np;
1003 	const struct of_device_id *m;
1004 	unsigned long flags;
1005 
1006 	if (match)
1007 		*match = NULL;
1008 
1009 	raw_spin_lock_irqsave(&devtree_lock, flags);
1010 	for_each_of_allnodes_from(from, np) {
1011 		m = __of_match_node(matches, np);
1012 		if (m && of_node_get(np)) {
1013 			if (match)
1014 				*match = m;
1015 			break;
1016 		}
1017 	}
1018 	of_node_put(from);
1019 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1020 	return np;
1021 }
1022 EXPORT_SYMBOL(of_find_matching_node_and_match);
1023 
1024 /**
1025  * of_alias_from_compatible - Lookup appropriate alias for a device node
1026  *			      depending on compatible
1027  * @node:	pointer to a device tree node
1028  * @alias:	Pointer to buffer that alias value will be copied into
1029  * @len:	Length of alias value
1030  *
1031  * Based on the value of the compatible property, this routine will attempt
1032  * to choose an appropriate alias value for a particular device tree node.
1033  * It does this by stripping the manufacturer prefix (as delimited by a ',')
1034  * from the first entry in the compatible list property.
1035  *
1036  * Note: The matching on just the "product" side of the compatible is a relic
1037  * from I2C and SPI. Please do not add any new user.
1038  *
1039  * Return: This routine returns 0 on success, <0 on failure.
1040  */
of_alias_from_compatible(const struct device_node * node,char * alias,int len)1041 int of_alias_from_compatible(const struct device_node *node, char *alias, int len)
1042 {
1043 	const char *compatible, *p;
1044 	int cplen;
1045 
1046 	compatible = of_get_property(node, "compatible", &cplen);
1047 	if (!compatible || strlen(compatible) > cplen)
1048 		return -ENODEV;
1049 	p = strchr(compatible, ',');
1050 	strscpy(alias, p ? p + 1 : compatible, len);
1051 	return 0;
1052 }
1053 EXPORT_SYMBOL_GPL(of_alias_from_compatible);
1054 
1055 /**
1056  * of_find_node_by_phandle - Find a node given a phandle
1057  * @handle:	phandle of the node to find
1058  *
1059  * Return: A node pointer with refcount incremented, use
1060  * of_node_put() on it when done.
1061  */
of_find_node_by_phandle(phandle handle)1062 struct device_node *of_find_node_by_phandle(phandle handle)
1063 {
1064 	struct device_node *np = NULL;
1065 	unsigned long flags;
1066 	u32 handle_hash;
1067 
1068 	if (!handle)
1069 		return NULL;
1070 
1071 	handle_hash = of_phandle_cache_hash(handle);
1072 
1073 	raw_spin_lock_irqsave(&devtree_lock, flags);
1074 
1075 	if (phandle_cache[handle_hash] &&
1076 	    handle == phandle_cache[handle_hash]->phandle)
1077 		np = phandle_cache[handle_hash];
1078 
1079 	if (!np) {
1080 		for_each_of_allnodes(np)
1081 			if (np->phandle == handle &&
1082 			    !of_node_check_flag(np, OF_DETACHED)) {
1083 				phandle_cache[handle_hash] = np;
1084 				break;
1085 			}
1086 	}
1087 
1088 	of_node_get(np);
1089 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1090 	return np;
1091 }
1092 EXPORT_SYMBOL(of_find_node_by_phandle);
1093 
of_print_phandle_args(const char * msg,const struct of_phandle_args * args)1094 void of_print_phandle_args(const char *msg, const struct of_phandle_args *args)
1095 {
1096 	int i;
1097 	printk("%s %pOF", msg, args->np);
1098 	for (i = 0; i < args->args_count; i++) {
1099 		const char delim = i ? ',' : ':';
1100 
1101 		pr_cont("%c%08x", delim, args->args[i]);
1102 	}
1103 	pr_cont("\n");
1104 }
1105 
of_phandle_iterator_init(struct of_phandle_iterator * it,const struct device_node * np,const char * list_name,const char * cells_name,int cell_count)1106 int of_phandle_iterator_init(struct of_phandle_iterator *it,
1107 		const struct device_node *np,
1108 		const char *list_name,
1109 		const char *cells_name,
1110 		int cell_count)
1111 {
1112 	const __be32 *list;
1113 	int size;
1114 
1115 	memset(it, 0, sizeof(*it));
1116 
1117 	/*
1118 	 * one of cell_count or cells_name must be provided to determine the
1119 	 * argument length.
1120 	 */
1121 	if (cell_count < 0 && !cells_name)
1122 		return -EINVAL;
1123 
1124 	list = of_get_property(np, list_name, &size);
1125 	if (!list)
1126 		return -ENOENT;
1127 
1128 	it->cells_name = cells_name;
1129 	it->cell_count = cell_count;
1130 	it->parent = np;
1131 	it->list_end = list + size / sizeof(*list);
1132 	it->phandle_end = list;
1133 	it->cur = list;
1134 
1135 	return 0;
1136 }
1137 EXPORT_SYMBOL_GPL(of_phandle_iterator_init);
1138 
of_phandle_iterator_next(struct of_phandle_iterator * it)1139 int of_phandle_iterator_next(struct of_phandle_iterator *it)
1140 {
1141 	uint32_t count = 0;
1142 
1143 	if (it->node) {
1144 		of_node_put(it->node);
1145 		it->node = NULL;
1146 	}
1147 
1148 	if (!it->cur || it->phandle_end >= it->list_end)
1149 		return -ENOENT;
1150 
1151 	it->cur = it->phandle_end;
1152 
1153 	/* If phandle is 0, then it is an empty entry with no arguments. */
1154 	it->phandle = be32_to_cpup(it->cur++);
1155 
1156 	if (it->phandle) {
1157 
1158 		/*
1159 		 * Find the provider node and parse the #*-cells property to
1160 		 * determine the argument length.
1161 		 */
1162 		it->node = of_find_node_by_phandle(it->phandle);
1163 
1164 		if (it->cells_name) {
1165 			if (!it->node) {
1166 				pr_err("%pOF: could not find phandle %d\n",
1167 				       it->parent, it->phandle);
1168 				goto err;
1169 			}
1170 
1171 			if (of_property_read_u32(it->node, it->cells_name,
1172 						 &count)) {
1173 				/*
1174 				 * If both cell_count and cells_name is given,
1175 				 * fall back to cell_count in absence
1176 				 * of the cells_name property
1177 				 */
1178 				if (it->cell_count >= 0) {
1179 					count = it->cell_count;
1180 				} else {
1181 					pr_err("%pOF: could not get %s for %pOF\n",
1182 					       it->parent,
1183 					       it->cells_name,
1184 					       it->node);
1185 					goto err;
1186 				}
1187 			}
1188 		} else {
1189 			count = it->cell_count;
1190 		}
1191 
1192 		/*
1193 		 * Make sure that the arguments actually fit in the remaining
1194 		 * property data length
1195 		 */
1196 		if (it->cur + count > it->list_end) {
1197 			if (it->cells_name)
1198 				pr_err("%pOF: %s = %d found %td\n",
1199 					it->parent, it->cells_name,
1200 					count, it->list_end - it->cur);
1201 			else
1202 				pr_err("%pOF: phandle %s needs %d, found %td\n",
1203 					it->parent, of_node_full_name(it->node),
1204 					count, it->list_end - it->cur);
1205 			goto err;
1206 		}
1207 	}
1208 
1209 	it->phandle_end = it->cur + count;
1210 	it->cur_count = count;
1211 
1212 	return 0;
1213 
1214 err:
1215 	if (it->node) {
1216 		of_node_put(it->node);
1217 		it->node = NULL;
1218 	}
1219 
1220 	return -EINVAL;
1221 }
1222 EXPORT_SYMBOL_GPL(of_phandle_iterator_next);
1223 
of_phandle_iterator_args(struct of_phandle_iterator * it,uint32_t * args,int size)1224 int of_phandle_iterator_args(struct of_phandle_iterator *it,
1225 			     uint32_t *args,
1226 			     int size)
1227 {
1228 	int i, count;
1229 
1230 	count = it->cur_count;
1231 
1232 	if (WARN_ON(size < count))
1233 		count = size;
1234 
1235 	for (i = 0; i < count; i++)
1236 		args[i] = be32_to_cpup(it->cur++);
1237 
1238 	return count;
1239 }
1240 
__of_parse_phandle_with_args(const struct device_node * np,const char * list_name,const char * cells_name,int cell_count,int index,struct of_phandle_args * out_args)1241 int __of_parse_phandle_with_args(const struct device_node *np,
1242 				 const char *list_name,
1243 				 const char *cells_name,
1244 				 int cell_count, int index,
1245 				 struct of_phandle_args *out_args)
1246 {
1247 	struct of_phandle_iterator it;
1248 	int rc, cur_index = 0;
1249 
1250 	if (index < 0)
1251 		return -EINVAL;
1252 
1253 	/* Loop over the phandles until all the requested entry is found */
1254 	of_for_each_phandle(&it, rc, np, list_name, cells_name, cell_count) {
1255 		/*
1256 		 * All of the error cases bail out of the loop, so at
1257 		 * this point, the parsing is successful. If the requested
1258 		 * index matches, then fill the out_args structure and return,
1259 		 * or return -ENOENT for an empty entry.
1260 		 */
1261 		rc = -ENOENT;
1262 		if (cur_index == index) {
1263 			if (!it.phandle)
1264 				goto err;
1265 
1266 			if (out_args) {
1267 				int c;
1268 
1269 				c = of_phandle_iterator_args(&it,
1270 							     out_args->args,
1271 							     MAX_PHANDLE_ARGS);
1272 				out_args->np = it.node;
1273 				out_args->args_count = c;
1274 			} else {
1275 				of_node_put(it.node);
1276 			}
1277 
1278 			/* Found it! return success */
1279 			return 0;
1280 		}
1281 
1282 		cur_index++;
1283 	}
1284 
1285 	/*
1286 	 * Unlock node before returning result; will be one of:
1287 	 * -ENOENT : index is for empty phandle
1288 	 * -EINVAL : parsing error on data
1289 	 */
1290 
1291  err:
1292 	of_node_put(it.node);
1293 	return rc;
1294 }
1295 EXPORT_SYMBOL(__of_parse_phandle_with_args);
1296 
1297 /**
1298  * of_parse_phandle_with_args_map() - Find a node pointed by phandle in a list and remap it
1299  * @np:		pointer to a device tree node containing a list
1300  * @list_name:	property name that contains a list
1301  * @stem_name:	stem of property names that specify phandles' arguments count
1302  * @index:	index of a phandle to parse out
1303  * @out_args:	optional pointer to output arguments structure (will be filled)
1304  *
1305  * This function is useful to parse lists of phandles and their arguments.
1306  * Returns 0 on success and fills out_args, on error returns appropriate errno
1307  * value. The difference between this function and of_parse_phandle_with_args()
1308  * is that this API remaps a phandle if the node the phandle points to has
1309  * a <@stem_name>-map property.
1310  *
1311  * Caller is responsible to call of_node_put() on the returned out_args->np
1312  * pointer.
1313  *
1314  * Example::
1315  *
1316  *  phandle1: node1 {
1317  *  	#list-cells = <2>;
1318  *  };
1319  *
1320  *  phandle2: node2 {
1321  *  	#list-cells = <1>;
1322  *  };
1323  *
1324  *  phandle3: node3 {
1325  *  	#list-cells = <1>;
1326  *  	list-map = <0 &phandle2 3>,
1327  *  		   <1 &phandle2 2>,
1328  *  		   <2 &phandle1 5 1>;
1329  *  	list-map-mask = <0x3>;
1330  *  };
1331  *
1332  *  node4 {
1333  *  	list = <&phandle1 1 2 &phandle3 0>;
1334  *  };
1335  *
1336  * To get a device_node of the ``node2`` node you may call this:
1337  * of_parse_phandle_with_args(node4, "list", "list", 1, &args);
1338  */
of_parse_phandle_with_args_map(const struct device_node * np,const char * list_name,const char * stem_name,int index,struct of_phandle_args * out_args)1339 int of_parse_phandle_with_args_map(const struct device_node *np,
1340 				   const char *list_name,
1341 				   const char *stem_name,
1342 				   int index, struct of_phandle_args *out_args)
1343 {
1344 	char *cells_name, *map_name = NULL, *mask_name = NULL;
1345 	char *pass_name = NULL;
1346 	struct device_node *cur, *new = NULL;
1347 	const __be32 *map, *mask, *pass;
1348 	static const __be32 dummy_mask[] = { [0 ... MAX_PHANDLE_ARGS] = ~0 };
1349 	static const __be32 dummy_pass[] = { [0 ... MAX_PHANDLE_ARGS] = 0 };
1350 	__be32 initial_match_array[MAX_PHANDLE_ARGS];
1351 	const __be32 *match_array = initial_match_array;
1352 	int i, ret, map_len, match;
1353 	u32 list_size, new_size;
1354 
1355 	if (index < 0)
1356 		return -EINVAL;
1357 
1358 	cells_name = kasprintf(GFP_KERNEL, "#%s-cells", stem_name);
1359 	if (!cells_name)
1360 		return -ENOMEM;
1361 
1362 	ret = -ENOMEM;
1363 	map_name = kasprintf(GFP_KERNEL, "%s-map", stem_name);
1364 	if (!map_name)
1365 		goto free;
1366 
1367 	mask_name = kasprintf(GFP_KERNEL, "%s-map-mask", stem_name);
1368 	if (!mask_name)
1369 		goto free;
1370 
1371 	pass_name = kasprintf(GFP_KERNEL, "%s-map-pass-thru", stem_name);
1372 	if (!pass_name)
1373 		goto free;
1374 
1375 	ret = __of_parse_phandle_with_args(np, list_name, cells_name, -1, index,
1376 					   out_args);
1377 	if (ret)
1378 		goto free;
1379 
1380 	/* Get the #<list>-cells property */
1381 	cur = out_args->np;
1382 	ret = of_property_read_u32(cur, cells_name, &list_size);
1383 	if (ret < 0)
1384 		goto put;
1385 
1386 	/* Precalculate the match array - this simplifies match loop */
1387 	for (i = 0; i < list_size; i++)
1388 		initial_match_array[i] = cpu_to_be32(out_args->args[i]);
1389 
1390 	ret = -EINVAL;
1391 	while (cur) {
1392 		/* Get the <list>-map property */
1393 		map = of_get_property(cur, map_name, &map_len);
1394 		if (!map) {
1395 			ret = 0;
1396 			goto free;
1397 		}
1398 		map_len /= sizeof(u32);
1399 
1400 		/* Get the <list>-map-mask property (optional) */
1401 		mask = of_get_property(cur, mask_name, NULL);
1402 		if (!mask)
1403 			mask = dummy_mask;
1404 		/* Iterate through <list>-map property */
1405 		match = 0;
1406 		while (map_len > (list_size + 1) && !match) {
1407 			/* Compare specifiers */
1408 			match = 1;
1409 			for (i = 0; i < list_size; i++, map_len--)
1410 				match &= !((match_array[i] ^ *map++) & mask[i]);
1411 
1412 			of_node_put(new);
1413 			new = of_find_node_by_phandle(be32_to_cpup(map));
1414 			map++;
1415 			map_len--;
1416 
1417 			/* Check if not found */
1418 			if (!new)
1419 				goto put;
1420 
1421 			if (!of_device_is_available(new))
1422 				match = 0;
1423 
1424 			ret = of_property_read_u32(new, cells_name, &new_size);
1425 			if (ret)
1426 				goto put;
1427 
1428 			/* Check for malformed properties */
1429 			if (WARN_ON(new_size > MAX_PHANDLE_ARGS))
1430 				goto put;
1431 			if (map_len < new_size)
1432 				goto put;
1433 
1434 			/* Move forward by new node's #<list>-cells amount */
1435 			map += new_size;
1436 			map_len -= new_size;
1437 		}
1438 		if (!match)
1439 			goto put;
1440 
1441 		/* Get the <list>-map-pass-thru property (optional) */
1442 		pass = of_get_property(cur, pass_name, NULL);
1443 		if (!pass)
1444 			pass = dummy_pass;
1445 
1446 		/*
1447 		 * Successfully parsed a <list>-map translation; copy new
1448 		 * specifier into the out_args structure, keeping the
1449 		 * bits specified in <list>-map-pass-thru.
1450 		 */
1451 		match_array = map - new_size;
1452 		for (i = 0; i < new_size; i++) {
1453 			__be32 val = *(map - new_size + i);
1454 
1455 			if (i < list_size) {
1456 				val &= ~pass[i];
1457 				val |= cpu_to_be32(out_args->args[i]) & pass[i];
1458 			}
1459 
1460 			out_args->args[i] = be32_to_cpu(val);
1461 		}
1462 		out_args->args_count = list_size = new_size;
1463 		/* Iterate again with new provider */
1464 		out_args->np = new;
1465 		of_node_put(cur);
1466 		cur = new;
1467 		new = NULL;
1468 	}
1469 put:
1470 	of_node_put(cur);
1471 	of_node_put(new);
1472 free:
1473 	kfree(mask_name);
1474 	kfree(map_name);
1475 	kfree(cells_name);
1476 	kfree(pass_name);
1477 
1478 	return ret;
1479 }
1480 EXPORT_SYMBOL(of_parse_phandle_with_args_map);
1481 
1482 /**
1483  * of_count_phandle_with_args() - Find the number of phandles references in a property
1484  * @np:		pointer to a device tree node containing a list
1485  * @list_name:	property name that contains a list
1486  * @cells_name:	property name that specifies phandles' arguments count
1487  *
1488  * Return: The number of phandle + argument tuples within a property. It
1489  * is a typical pattern to encode a list of phandle and variable
1490  * arguments into a single property. The number of arguments is encoded
1491  * by a property in the phandle-target node. For example, a gpios
1492  * property would contain a list of GPIO specifies consisting of a
1493  * phandle and 1 or more arguments. The number of arguments are
1494  * determined by the #gpio-cells property in the node pointed to by the
1495  * phandle.
1496  */
of_count_phandle_with_args(const struct device_node * np,const char * list_name,const char * cells_name)1497 int of_count_phandle_with_args(const struct device_node *np, const char *list_name,
1498 				const char *cells_name)
1499 {
1500 	struct of_phandle_iterator it;
1501 	int rc, cur_index = 0;
1502 
1503 	/*
1504 	 * If cells_name is NULL we assume a cell count of 0. This makes
1505 	 * counting the phandles trivial as each 32bit word in the list is a
1506 	 * phandle and no arguments are to consider. So we don't iterate through
1507 	 * the list but just use the length to determine the phandle count.
1508 	 */
1509 	if (!cells_name) {
1510 		const __be32 *list;
1511 		int size;
1512 
1513 		list = of_get_property(np, list_name, &size);
1514 		if (!list)
1515 			return -ENOENT;
1516 
1517 		return size / sizeof(*list);
1518 	}
1519 
1520 	rc = of_phandle_iterator_init(&it, np, list_name, cells_name, -1);
1521 	if (rc)
1522 		return rc;
1523 
1524 	while ((rc = of_phandle_iterator_next(&it)) == 0)
1525 		cur_index += 1;
1526 
1527 	if (rc != -ENOENT)
1528 		return rc;
1529 
1530 	return cur_index;
1531 }
1532 EXPORT_SYMBOL(of_count_phandle_with_args);
1533 
__of_remove_property_from_list(struct property ** list,struct property * prop)1534 static struct property *__of_remove_property_from_list(struct property **list, struct property *prop)
1535 {
1536 	struct property **next;
1537 
1538 	for (next = list; *next; next = &(*next)->next) {
1539 		if (*next == prop) {
1540 			*next = prop->next;
1541 			prop->next = NULL;
1542 			return prop;
1543 		}
1544 	}
1545 	return NULL;
1546 }
1547 
1548 /**
1549  * __of_add_property - Add a property to a node without lock operations
1550  * @np:		Caller's Device Node
1551  * @prop:	Property to add
1552  */
__of_add_property(struct device_node * np,struct property * prop)1553 int __of_add_property(struct device_node *np, struct property *prop)
1554 {
1555 	int rc = 0;
1556 	unsigned long flags;
1557 	struct property **next;
1558 
1559 	raw_spin_lock_irqsave(&devtree_lock, flags);
1560 
1561 	__of_remove_property_from_list(&np->deadprops, prop);
1562 
1563 	prop->next = NULL;
1564 	next = &np->properties;
1565 	while (*next) {
1566 		if (strcmp(prop->name, (*next)->name) == 0) {
1567 			/* duplicate ! don't insert it */
1568 			rc = -EEXIST;
1569 			goto out_unlock;
1570 		}
1571 		next = &(*next)->next;
1572 	}
1573 	*next = prop;
1574 
1575 out_unlock:
1576 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1577 	if (rc)
1578 		return rc;
1579 
1580 	__of_add_property_sysfs(np, prop);
1581 	return 0;
1582 }
1583 
1584 /**
1585  * of_add_property - Add a property to a node
1586  * @np:		Caller's Device Node
1587  * @prop:	Property to add
1588  */
of_add_property(struct device_node * np,struct property * prop)1589 int of_add_property(struct device_node *np, struct property *prop)
1590 {
1591 	int rc;
1592 
1593 	mutex_lock(&of_mutex);
1594 	rc = __of_add_property(np, prop);
1595 	mutex_unlock(&of_mutex);
1596 
1597 	if (!rc)
1598 		of_property_notify(OF_RECONFIG_ADD_PROPERTY, np, prop, NULL);
1599 
1600 	return rc;
1601 }
1602 EXPORT_SYMBOL_GPL(of_add_property);
1603 
__of_remove_property(struct device_node * np,struct property * prop)1604 int __of_remove_property(struct device_node *np, struct property *prop)
1605 {
1606 	unsigned long flags;
1607 	int rc = -ENODEV;
1608 
1609 	raw_spin_lock_irqsave(&devtree_lock, flags);
1610 
1611 	if (__of_remove_property_from_list(&np->properties, prop)) {
1612 		/* Found the property, add it to deadprops list */
1613 		prop->next = np->deadprops;
1614 		np->deadprops = prop;
1615 		rc = 0;
1616 	}
1617 
1618 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1619 	if (rc)
1620 		return rc;
1621 
1622 	__of_remove_property_sysfs(np, prop);
1623 	return 0;
1624 }
1625 
1626 /**
1627  * of_remove_property - Remove a property from a node.
1628  * @np:		Caller's Device Node
1629  * @prop:	Property to remove
1630  *
1631  * Note that we don't actually remove it, since we have given out
1632  * who-knows-how-many pointers to the data using get-property.
1633  * Instead we just move the property to the "dead properties"
1634  * list, so it won't be found any more.
1635  */
of_remove_property(struct device_node * np,struct property * prop)1636 int of_remove_property(struct device_node *np, struct property *prop)
1637 {
1638 	int rc;
1639 
1640 	if (!prop)
1641 		return -ENODEV;
1642 
1643 	mutex_lock(&of_mutex);
1644 	rc = __of_remove_property(np, prop);
1645 	mutex_unlock(&of_mutex);
1646 
1647 	if (!rc)
1648 		of_property_notify(OF_RECONFIG_REMOVE_PROPERTY, np, prop, NULL);
1649 
1650 	return rc;
1651 }
1652 EXPORT_SYMBOL_GPL(of_remove_property);
1653 
__of_update_property(struct device_node * np,struct property * newprop,struct property ** oldpropp)1654 int __of_update_property(struct device_node *np, struct property *newprop,
1655 		struct property **oldpropp)
1656 {
1657 	struct property **next, *oldprop;
1658 	unsigned long flags;
1659 
1660 	raw_spin_lock_irqsave(&devtree_lock, flags);
1661 
1662 	__of_remove_property_from_list(&np->deadprops, newprop);
1663 
1664 	for (next = &np->properties; *next; next = &(*next)->next) {
1665 		if (of_prop_cmp((*next)->name, newprop->name) == 0)
1666 			break;
1667 	}
1668 	*oldpropp = oldprop = *next;
1669 
1670 	if (oldprop) {
1671 		/* replace the node */
1672 		newprop->next = oldprop->next;
1673 		*next = newprop;
1674 		oldprop->next = np->deadprops;
1675 		np->deadprops = oldprop;
1676 	} else {
1677 		/* new node */
1678 		newprop->next = NULL;
1679 		*next = newprop;
1680 	}
1681 
1682 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1683 
1684 	__of_update_property_sysfs(np, newprop, oldprop);
1685 
1686 	return 0;
1687 }
1688 
1689 /*
1690  * of_update_property - Update a property in a node, if the property does
1691  * not exist, add it.
1692  *
1693  * Note that we don't actually remove it, since we have given out
1694  * who-knows-how-many pointers to the data using get-property.
1695  * Instead we just move the property to the "dead properties" list,
1696  * and add the new property to the property list
1697  */
of_update_property(struct device_node * np,struct property * newprop)1698 int of_update_property(struct device_node *np, struct property *newprop)
1699 {
1700 	struct property *oldprop;
1701 	int rc;
1702 
1703 	if (!newprop->name)
1704 		return -EINVAL;
1705 
1706 	mutex_lock(&of_mutex);
1707 	rc = __of_update_property(np, newprop, &oldprop);
1708 	mutex_unlock(&of_mutex);
1709 
1710 	if (!rc)
1711 		of_property_notify(OF_RECONFIG_UPDATE_PROPERTY, np, newprop, oldprop);
1712 
1713 	return rc;
1714 }
1715 
of_alias_add(struct alias_prop * ap,struct device_node * np,int id,const char * stem,int stem_len)1716 static void of_alias_add(struct alias_prop *ap, struct device_node *np,
1717 			 int id, const char *stem, int stem_len)
1718 {
1719 	ap->np = np;
1720 	ap->id = id;
1721 	strscpy(ap->stem, stem, stem_len + 1);
1722 	list_add_tail(&ap->link, &aliases_lookup);
1723 	pr_debug("adding DT alias:%s: stem=%s id=%i node=%pOF\n",
1724 		 ap->alias, ap->stem, ap->id, np);
1725 }
1726 
1727 /**
1728  * of_alias_scan - Scan all properties of the 'aliases' node
1729  * @dt_alloc:	An allocator that provides a virtual address to memory
1730  *		for storing the resulting tree
1731  *
1732  * The function scans all the properties of the 'aliases' node and populates
1733  * the global lookup table with the properties.  It returns the
1734  * number of alias properties found, or an error code in case of failure.
1735  */
of_alias_scan(void * (* dt_alloc)(u64 size,u64 align))1736 void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
1737 {
1738 	struct property *pp;
1739 
1740 	of_aliases = of_find_node_by_path("/aliases");
1741 	of_chosen = of_find_node_by_path("/chosen");
1742 	if (of_chosen == NULL)
1743 		of_chosen = of_find_node_by_path("/chosen@0");
1744 
1745 	if (of_chosen) {
1746 		/* linux,stdout-path and /aliases/stdout are for legacy compatibility */
1747 		const char *name = NULL;
1748 
1749 		if (of_property_read_string(of_chosen, "stdout-path", &name))
1750 			of_property_read_string(of_chosen, "linux,stdout-path",
1751 						&name);
1752 		if (IS_ENABLED(CONFIG_PPC) && !name)
1753 			of_property_read_string(of_aliases, "stdout", &name);
1754 		if (name)
1755 			of_stdout = of_find_node_opts_by_path(name, &of_stdout_options);
1756 		if (of_stdout)
1757 			of_stdout->fwnode.flags |= FWNODE_FLAG_BEST_EFFORT;
1758 	}
1759 
1760 	if (!of_aliases)
1761 		return;
1762 
1763 	for_each_property_of_node(of_aliases, pp) {
1764 		const char *start = pp->name;
1765 		const char *end = start + strlen(start);
1766 		struct device_node *np;
1767 		struct alias_prop *ap;
1768 		int id, len;
1769 
1770 		/* Skip those we do not want to proceed */
1771 		if (!strcmp(pp->name, "name") ||
1772 		    !strcmp(pp->name, "phandle") ||
1773 		    !strcmp(pp->name, "linux,phandle"))
1774 			continue;
1775 
1776 		np = of_find_node_by_path(pp->value);
1777 		if (!np)
1778 			continue;
1779 
1780 		/* walk the alias backwards to extract the id and work out
1781 		 * the 'stem' string */
1782 		while (isdigit(*(end-1)) && end > start)
1783 			end--;
1784 		len = end - start;
1785 
1786 		if (kstrtoint(end, 10, &id) < 0)
1787 			continue;
1788 
1789 		/* Allocate an alias_prop with enough space for the stem */
1790 		ap = dt_alloc(sizeof(*ap) + len + 1, __alignof__(*ap));
1791 		if (!ap)
1792 			continue;
1793 		memset(ap, 0, sizeof(*ap) + len + 1);
1794 		ap->alias = start;
1795 		of_alias_add(ap, np, id, start, len);
1796 	}
1797 }
1798 
1799 /**
1800  * of_alias_get_id - Get alias id for the given device_node
1801  * @np:		Pointer to the given device_node
1802  * @stem:	Alias stem of the given device_node
1803  *
1804  * The function travels the lookup table to get the alias id for the given
1805  * device_node and alias stem.
1806  *
1807  * Return: The alias id if found.
1808  */
of_alias_get_id(struct device_node * np,const char * stem)1809 int of_alias_get_id(struct device_node *np, const char *stem)
1810 {
1811 	struct alias_prop *app;
1812 	int id = -ENODEV;
1813 
1814 	mutex_lock(&of_mutex);
1815 	list_for_each_entry(app, &aliases_lookup, link) {
1816 		if (strcmp(app->stem, stem) != 0)
1817 			continue;
1818 
1819 		if (np == app->np) {
1820 			id = app->id;
1821 			break;
1822 		}
1823 	}
1824 	mutex_unlock(&of_mutex);
1825 
1826 	return id;
1827 }
1828 EXPORT_SYMBOL_GPL(of_alias_get_id);
1829 
1830 /**
1831  * of_alias_get_highest_id - Get highest alias id for the given stem
1832  * @stem:	Alias stem to be examined
1833  *
1834  * The function travels the lookup table to get the highest alias id for the
1835  * given alias stem.  It returns the alias id if found.
1836  */
of_alias_get_highest_id(const char * stem)1837 int of_alias_get_highest_id(const char *stem)
1838 {
1839 	struct alias_prop *app;
1840 	int id = -ENODEV;
1841 
1842 	mutex_lock(&of_mutex);
1843 	list_for_each_entry(app, &aliases_lookup, link) {
1844 		if (strcmp(app->stem, stem) != 0)
1845 			continue;
1846 
1847 		if (app->id > id)
1848 			id = app->id;
1849 	}
1850 	mutex_unlock(&of_mutex);
1851 
1852 	return id;
1853 }
1854 EXPORT_SYMBOL_GPL(of_alias_get_highest_id);
1855 
1856 /**
1857  * of_console_check() - Test and setup console for DT setup
1858  * @dn: Pointer to device node
1859  * @name: Name to use for preferred console without index. ex. "ttyS"
1860  * @index: Index to use for preferred console.
1861  *
1862  * Check if the given device node matches the stdout-path property in the
1863  * /chosen node. If it does then register it as the preferred console.
1864  *
1865  * Return: TRUE if console successfully setup. Otherwise return FALSE.
1866  */
of_console_check(struct device_node * dn,char * name,int index)1867 bool of_console_check(struct device_node *dn, char *name, int index)
1868 {
1869 	if (!dn || dn != of_stdout || console_set_on_cmdline)
1870 		return false;
1871 
1872 	/*
1873 	 * XXX: cast `options' to char pointer to suppress complication
1874 	 * warnings: printk, UART and console drivers expect char pointer.
1875 	 */
1876 	return !add_preferred_console(name, index, (char *)of_stdout_options);
1877 }
1878 EXPORT_SYMBOL_GPL(of_console_check);
1879 
1880 /**
1881  * of_find_next_cache_node - Find a node's subsidiary cache
1882  * @np:	node of type "cpu" or "cache"
1883  *
1884  * Return: A node pointer with refcount incremented, use
1885  * of_node_put() on it when done.  Caller should hold a reference
1886  * to np.
1887  */
of_find_next_cache_node(const struct device_node * np)1888 struct device_node *of_find_next_cache_node(const struct device_node *np)
1889 {
1890 	struct device_node *child, *cache_node;
1891 
1892 	cache_node = of_parse_phandle(np, "l2-cache", 0);
1893 	if (!cache_node)
1894 		cache_node = of_parse_phandle(np, "next-level-cache", 0);
1895 
1896 	if (cache_node)
1897 		return cache_node;
1898 
1899 	/* OF on pmac has nodes instead of properties named "l2-cache"
1900 	 * beneath CPU nodes.
1901 	 */
1902 	if (IS_ENABLED(CONFIG_PPC_PMAC) && of_node_is_type(np, "cpu"))
1903 		for_each_child_of_node(np, child)
1904 			if (of_node_is_type(child, "cache"))
1905 				return child;
1906 
1907 	return NULL;
1908 }
1909 
1910 /**
1911  * of_find_last_cache_level - Find the level at which the last cache is
1912  * 		present for the given logical cpu
1913  *
1914  * @cpu: cpu number(logical index) for which the last cache level is needed
1915  *
1916  * Return: The level at which the last cache is present. It is exactly
1917  * same as  the total number of cache levels for the given logical cpu.
1918  */
of_find_last_cache_level(unsigned int cpu)1919 int of_find_last_cache_level(unsigned int cpu)
1920 {
1921 	u32 cache_level = 0;
1922 	struct device_node *prev = NULL, *np = of_cpu_device_node_get(cpu);
1923 
1924 	while (np) {
1925 		of_node_put(prev);
1926 		prev = np;
1927 		np = of_find_next_cache_node(np);
1928 	}
1929 
1930 	of_property_read_u32(prev, "cache-level", &cache_level);
1931 	of_node_put(prev);
1932 
1933 	return cache_level;
1934 }
1935 
1936 /**
1937  * of_map_id - Translate an ID through a downstream mapping.
1938  * @np: root complex device node.
1939  * @id: device ID to map.
1940  * @map_name: property name of the map to use.
1941  * @map_mask_name: optional property name of the mask to use.
1942  * @target: optional pointer to a target device node.
1943  * @id_out: optional pointer to receive the translated ID.
1944  *
1945  * Given a device ID, look up the appropriate implementation-defined
1946  * platform ID and/or the target device which receives transactions on that
1947  * ID, as per the "iommu-map" and "msi-map" bindings. Either of @target or
1948  * @id_out may be NULL if only the other is required. If @target points to
1949  * a non-NULL device node pointer, only entries targeting that node will be
1950  * matched; if it points to a NULL value, it will receive the device node of
1951  * the first matching target phandle, with a reference held.
1952  *
1953  * Return: 0 on success or a standard error code on failure.
1954  */
of_map_id(struct device_node * np,u32 id,const char * map_name,const char * map_mask_name,struct device_node ** target,u32 * id_out)1955 int of_map_id(struct device_node *np, u32 id,
1956 	       const char *map_name, const char *map_mask_name,
1957 	       struct device_node **target, u32 *id_out)
1958 {
1959 	u32 map_mask, masked_id;
1960 	int map_len;
1961 	const __be32 *map = NULL;
1962 
1963 	if (!np || !map_name || (!target && !id_out))
1964 		return -EINVAL;
1965 
1966 	map = of_get_property(np, map_name, &map_len);
1967 	if (!map) {
1968 		if (target)
1969 			return -ENODEV;
1970 		/* Otherwise, no map implies no translation */
1971 		*id_out = id;
1972 		return 0;
1973 	}
1974 
1975 	if (!map_len || map_len % (4 * sizeof(*map))) {
1976 		pr_err("%pOF: Error: Bad %s length: %d\n", np,
1977 			map_name, map_len);
1978 		return -EINVAL;
1979 	}
1980 
1981 	/* The default is to select all bits. */
1982 	map_mask = 0xffffffff;
1983 
1984 	/*
1985 	 * Can be overridden by "{iommu,msi}-map-mask" property.
1986 	 * If of_property_read_u32() fails, the default is used.
1987 	 */
1988 	if (map_mask_name)
1989 		of_property_read_u32(np, map_mask_name, &map_mask);
1990 
1991 	masked_id = map_mask & id;
1992 	for ( ; map_len > 0; map_len -= 4 * sizeof(*map), map += 4) {
1993 		struct device_node *phandle_node;
1994 		u32 id_base = be32_to_cpup(map + 0);
1995 		u32 phandle = be32_to_cpup(map + 1);
1996 		u32 out_base = be32_to_cpup(map + 2);
1997 		u32 id_len = be32_to_cpup(map + 3);
1998 
1999 		if (id_base & ~map_mask) {
2000 			pr_err("%pOF: Invalid %s translation - %s-mask (0x%x) ignores id-base (0x%x)\n",
2001 				np, map_name, map_name,
2002 				map_mask, id_base);
2003 			return -EFAULT;
2004 		}
2005 
2006 		if (masked_id < id_base || masked_id >= id_base + id_len)
2007 			continue;
2008 
2009 		phandle_node = of_find_node_by_phandle(phandle);
2010 		if (!phandle_node)
2011 			return -ENODEV;
2012 
2013 		if (target) {
2014 			if (*target)
2015 				of_node_put(phandle_node);
2016 			else
2017 				*target = phandle_node;
2018 
2019 			if (*target != phandle_node)
2020 				continue;
2021 		}
2022 
2023 		if (id_out)
2024 			*id_out = masked_id - id_base + out_base;
2025 
2026 		pr_debug("%pOF: %s, using mask %08x, id-base: %08x, out-base: %08x, length: %08x, id: %08x -> %08x\n",
2027 			np, map_name, map_mask, id_base, out_base,
2028 			id_len, id, masked_id - id_base + out_base);
2029 		return 0;
2030 	}
2031 
2032 	pr_info("%pOF: no %s translation for id 0x%x on %pOF\n", np, map_name,
2033 		id, target && *target ? *target : NULL);
2034 
2035 	/* Bypasses translation */
2036 	if (id_out)
2037 		*id_out = id;
2038 	return 0;
2039 }
2040 EXPORT_SYMBOL_GPL(of_map_id);
2041