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