xref: /linux/drivers/of/base.c (revision 1e1159bb97cf4191849b4b03f77ab32977c2ece6)
1 /*
2  * Procedures for creating, accessing and interpreting the device tree.
3  *
4  * Paul Mackerras	August 1996.
5  * Copyright (C) 1996-2005 Paul Mackerras.
6  *
7  *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
8  *    {engebret|bergner}@us.ibm.com
9  *
10  *  Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net
11  *
12  *  Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
13  *  Grant Likely.
14  *
15  *      This program is free software; you can redistribute it and/or
16  *      modify it under the terms of the GNU General Public License
17  *      as published by the Free Software Foundation; either version
18  *      2 of the License, or (at your option) any later version.
19  */
20 #include <linux/ctype.h>
21 #include <linux/cpu.h>
22 #include <linux/module.h>
23 #include <linux/of.h>
24 #include <linux/spinlock.h>
25 #include <linux/slab.h>
26 #include <linux/proc_fs.h>
27 
28 #include "of_private.h"
29 
30 LIST_HEAD(aliases_lookup);
31 
32 struct device_node *of_allnodes;
33 EXPORT_SYMBOL(of_allnodes);
34 struct device_node *of_chosen;
35 struct device_node *of_aliases;
36 static struct device_node *of_stdout;
37 
38 DEFINE_MUTEX(of_aliases_mutex);
39 
40 /* use when traversing tree through the allnext, child, sibling,
41  * or parent members of struct device_node.
42  */
43 DEFINE_RAW_SPINLOCK(devtree_lock);
44 
45 int of_n_addr_cells(struct device_node *np)
46 {
47 	const __be32 *ip;
48 
49 	do {
50 		if (np->parent)
51 			np = np->parent;
52 		ip = of_get_property(np, "#address-cells", NULL);
53 		if (ip)
54 			return be32_to_cpup(ip);
55 	} while (np->parent);
56 	/* No #address-cells property for the root node */
57 	return OF_ROOT_NODE_ADDR_CELLS_DEFAULT;
58 }
59 EXPORT_SYMBOL(of_n_addr_cells);
60 
61 int of_n_size_cells(struct device_node *np)
62 {
63 	const __be32 *ip;
64 
65 	do {
66 		if (np->parent)
67 			np = np->parent;
68 		ip = of_get_property(np, "#size-cells", NULL);
69 		if (ip)
70 			return be32_to_cpup(ip);
71 	} while (np->parent);
72 	/* No #size-cells property for the root node */
73 	return OF_ROOT_NODE_SIZE_CELLS_DEFAULT;
74 }
75 EXPORT_SYMBOL(of_n_size_cells);
76 
77 #if defined(CONFIG_OF_DYNAMIC)
78 /**
79  *	of_node_get - Increment refcount of a node
80  *	@node:	Node to inc refcount, NULL is supported to
81  *		simplify writing of callers
82  *
83  *	Returns node.
84  */
85 struct device_node *of_node_get(struct device_node *node)
86 {
87 	if (node)
88 		kref_get(&node->kref);
89 	return node;
90 }
91 EXPORT_SYMBOL(of_node_get);
92 
93 static inline struct device_node *kref_to_device_node(struct kref *kref)
94 {
95 	return container_of(kref, struct device_node, kref);
96 }
97 
98 /**
99  *	of_node_release - release a dynamically allocated node
100  *	@kref:  kref element of the node to be released
101  *
102  *	In of_node_put() this function is passed to kref_put()
103  *	as the destructor.
104  */
105 static void of_node_release(struct kref *kref)
106 {
107 	struct device_node *node = kref_to_device_node(kref);
108 	struct property *prop = node->properties;
109 
110 	/* We should never be releasing nodes that haven't been detached. */
111 	if (!of_node_check_flag(node, OF_DETACHED)) {
112 		pr_err("ERROR: Bad of_node_put() on %s\n", node->full_name);
113 		dump_stack();
114 		kref_init(&node->kref);
115 		return;
116 	}
117 
118 	if (!of_node_check_flag(node, OF_DYNAMIC))
119 		return;
120 
121 	while (prop) {
122 		struct property *next = prop->next;
123 		kfree(prop->name);
124 		kfree(prop->value);
125 		kfree(prop);
126 		prop = next;
127 
128 		if (!prop) {
129 			prop = node->deadprops;
130 			node->deadprops = NULL;
131 		}
132 	}
133 	kfree(node->full_name);
134 	kfree(node->data);
135 	kfree(node);
136 }
137 
138 /**
139  *	of_node_put - Decrement refcount of a node
140  *	@node:	Node to dec refcount, NULL is supported to
141  *		simplify writing of callers
142  *
143  */
144 void of_node_put(struct device_node *node)
145 {
146 	if (node)
147 		kref_put(&node->kref, of_node_release);
148 }
149 EXPORT_SYMBOL(of_node_put);
150 #endif /* CONFIG_OF_DYNAMIC */
151 
152 static struct property *__of_find_property(const struct device_node *np,
153 					   const char *name, int *lenp)
154 {
155 	struct property *pp;
156 
157 	if (!np)
158 		return NULL;
159 
160 	for (pp = np->properties; pp; pp = pp->next) {
161 		if (of_prop_cmp(pp->name, name) == 0) {
162 			if (lenp)
163 				*lenp = pp->length;
164 			break;
165 		}
166 	}
167 
168 	return pp;
169 }
170 
171 struct property *of_find_property(const struct device_node *np,
172 				  const char *name,
173 				  int *lenp)
174 {
175 	struct property *pp;
176 	unsigned long flags;
177 
178 	raw_spin_lock_irqsave(&devtree_lock, flags);
179 	pp = __of_find_property(np, name, lenp);
180 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
181 
182 	return pp;
183 }
184 EXPORT_SYMBOL(of_find_property);
185 
186 /**
187  * of_find_all_nodes - Get next node in global list
188  * @prev:	Previous node or NULL to start iteration
189  *		of_node_put() will be called on it
190  *
191  * Returns a node pointer with refcount incremented, use
192  * of_node_put() on it when done.
193  */
194 struct device_node *of_find_all_nodes(struct device_node *prev)
195 {
196 	struct device_node *np;
197 	unsigned long flags;
198 
199 	raw_spin_lock_irqsave(&devtree_lock, flags);
200 	np = prev ? prev->allnext : of_allnodes;
201 	for (; np != NULL; np = np->allnext)
202 		if (of_node_get(np))
203 			break;
204 	of_node_put(prev);
205 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
206 	return np;
207 }
208 EXPORT_SYMBOL(of_find_all_nodes);
209 
210 /*
211  * Find a property with a given name for a given node
212  * and return the value.
213  */
214 static const void *__of_get_property(const struct device_node *np,
215 				     const char *name, int *lenp)
216 {
217 	struct property *pp = __of_find_property(np, name, lenp);
218 
219 	return pp ? pp->value : NULL;
220 }
221 
222 /*
223  * Find a property with a given name for a given node
224  * and return the value.
225  */
226 const void *of_get_property(const struct device_node *np, const char *name,
227 			    int *lenp)
228 {
229 	struct property *pp = of_find_property(np, name, lenp);
230 
231 	return pp ? pp->value : NULL;
232 }
233 EXPORT_SYMBOL(of_get_property);
234 
235 /*
236  * arch_match_cpu_phys_id - Match the given logical CPU and physical id
237  *
238  * @cpu: logical cpu index of a core/thread
239  * @phys_id: physical identifier of a core/thread
240  *
241  * CPU logical to physical index mapping is architecture specific.
242  * However this __weak function provides a default match of physical
243  * id to logical cpu index. phys_id provided here is usually values read
244  * from the device tree which must match the hardware internal registers.
245  *
246  * Returns true if the physical identifier and the logical cpu index
247  * correspond to the same core/thread, false otherwise.
248  */
249 bool __weak arch_match_cpu_phys_id(int cpu, u64 phys_id)
250 {
251 	return (u32)phys_id == cpu;
252 }
253 
254 /**
255  * Checks if the given "prop_name" property holds the physical id of the
256  * core/thread corresponding to the logical cpu 'cpu'. If 'thread' is not
257  * NULL, local thread number within the core is returned in it.
258  */
259 static bool __of_find_n_match_cpu_property(struct device_node *cpun,
260 			const char *prop_name, int cpu, unsigned int *thread)
261 {
262 	const __be32 *cell;
263 	int ac, prop_len, tid;
264 	u64 hwid;
265 
266 	ac = of_n_addr_cells(cpun);
267 	cell = of_get_property(cpun, prop_name, &prop_len);
268 	if (!cell)
269 		return false;
270 	prop_len /= sizeof(*cell);
271 	for (tid = 0; tid < prop_len; tid++) {
272 		hwid = of_read_number(cell, ac);
273 		if (arch_match_cpu_phys_id(cpu, hwid)) {
274 			if (thread)
275 				*thread = tid;
276 			return true;
277 		}
278 		cell += ac;
279 	}
280 	return false;
281 }
282 
283 /**
284  * of_get_cpu_node - Get device node associated with the given logical CPU
285  *
286  * @cpu: CPU number(logical index) for which device node is required
287  * @thread: if not NULL, local thread number within the physical core is
288  *          returned
289  *
290  * The main purpose of this function is to retrieve the device node for the
291  * given logical CPU index. It should be used to initialize the of_node in
292  * cpu device. Once of_node in cpu device is populated, all the further
293  * references can use that instead.
294  *
295  * CPU logical to physical index mapping is architecture specific and is built
296  * before booting secondary cores. This function uses arch_match_cpu_phys_id
297  * which can be overridden by architecture specific implementation.
298  *
299  * Returns a node pointer for the logical cpu if found, else NULL.
300  */
301 struct device_node *of_get_cpu_node(int cpu, unsigned int *thread)
302 {
303 	struct device_node *cpun, *cpus;
304 
305 	cpus = of_find_node_by_path("/cpus");
306 	if (!cpus) {
307 		pr_warn("Missing cpus node, bailing out\n");
308 		return NULL;
309 	}
310 
311 	for_each_child_of_node(cpus, cpun) {
312 		if (of_node_cmp(cpun->type, "cpu"))
313 			continue;
314 		/* Check for non-standard "ibm,ppc-interrupt-server#s" property
315 		 * for thread ids on PowerPC. If it doesn't exist fallback to
316 		 * standard "reg" property.
317 		 */
318 		if (IS_ENABLED(CONFIG_PPC) &&
319 			__of_find_n_match_cpu_property(cpun,
320 				"ibm,ppc-interrupt-server#s", cpu, thread))
321 			return cpun;
322 		if (__of_find_n_match_cpu_property(cpun, "reg", cpu, thread))
323 			return cpun;
324 	}
325 	return NULL;
326 }
327 EXPORT_SYMBOL(of_get_cpu_node);
328 
329 /** Checks if the given "compat" string matches one of the strings in
330  * the device's "compatible" property
331  */
332 static int __of_device_is_compatible(const struct device_node *device,
333 				     const char *compat)
334 {
335 	const char* cp;
336 	int cplen, l;
337 
338 	cp = __of_get_property(device, "compatible", &cplen);
339 	if (cp == NULL)
340 		return 0;
341 	while (cplen > 0) {
342 		if (of_compat_cmp(cp, compat, strlen(compat)) == 0)
343 			return 1;
344 		l = strlen(cp) + 1;
345 		cp += l;
346 		cplen -= l;
347 	}
348 
349 	return 0;
350 }
351 
352 /** Checks if the given "compat" string matches one of the strings in
353  * the device's "compatible" property
354  */
355 int of_device_is_compatible(const struct device_node *device,
356 		const char *compat)
357 {
358 	unsigned long flags;
359 	int res;
360 
361 	raw_spin_lock_irqsave(&devtree_lock, flags);
362 	res = __of_device_is_compatible(device, compat);
363 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
364 	return res;
365 }
366 EXPORT_SYMBOL(of_device_is_compatible);
367 
368 /**
369  * of_machine_is_compatible - Test root of device tree for a given compatible value
370  * @compat: compatible string to look for in root node's compatible property.
371  *
372  * Returns true if the root node has the given value in its
373  * compatible property.
374  */
375 int of_machine_is_compatible(const char *compat)
376 {
377 	struct device_node *root;
378 	int rc = 0;
379 
380 	root = of_find_node_by_path("/");
381 	if (root) {
382 		rc = of_device_is_compatible(root, compat);
383 		of_node_put(root);
384 	}
385 	return rc;
386 }
387 EXPORT_SYMBOL(of_machine_is_compatible);
388 
389 /**
390  *  __of_device_is_available - check if a device is available for use
391  *
392  *  @device: Node to check for availability, with locks already held
393  *
394  *  Returns 1 if the status property is absent or set to "okay" or "ok",
395  *  0 otherwise
396  */
397 static int __of_device_is_available(const struct device_node *device)
398 {
399 	const char *status;
400 	int statlen;
401 
402 	status = __of_get_property(device, "status", &statlen);
403 	if (status == NULL)
404 		return 1;
405 
406 	if (statlen > 0) {
407 		if (!strcmp(status, "okay") || !strcmp(status, "ok"))
408 			return 1;
409 	}
410 
411 	return 0;
412 }
413 
414 /**
415  *  of_device_is_available - check if a device is available for use
416  *
417  *  @device: Node to check for availability
418  *
419  *  Returns 1 if the status property is absent or set to "okay" or "ok",
420  *  0 otherwise
421  */
422 int of_device_is_available(const struct device_node *device)
423 {
424 	unsigned long flags;
425 	int res;
426 
427 	raw_spin_lock_irqsave(&devtree_lock, flags);
428 	res = __of_device_is_available(device);
429 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
430 	return res;
431 
432 }
433 EXPORT_SYMBOL(of_device_is_available);
434 
435 /**
436  *	of_get_parent - Get a node's parent if any
437  *	@node:	Node to get parent
438  *
439  *	Returns a node pointer with refcount incremented, use
440  *	of_node_put() on it when done.
441  */
442 struct device_node *of_get_parent(const struct device_node *node)
443 {
444 	struct device_node *np;
445 	unsigned long flags;
446 
447 	if (!node)
448 		return NULL;
449 
450 	raw_spin_lock_irqsave(&devtree_lock, flags);
451 	np = of_node_get(node->parent);
452 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
453 	return np;
454 }
455 EXPORT_SYMBOL(of_get_parent);
456 
457 /**
458  *	of_get_next_parent - Iterate to a node's parent
459  *	@node:	Node to get parent of
460  *
461  * 	This is like of_get_parent() except that it drops the
462  * 	refcount on the passed node, making it suitable for iterating
463  * 	through a node's parents.
464  *
465  *	Returns a node pointer with refcount incremented, use
466  *	of_node_put() on it when done.
467  */
468 struct device_node *of_get_next_parent(struct device_node *node)
469 {
470 	struct device_node *parent;
471 	unsigned long flags;
472 
473 	if (!node)
474 		return NULL;
475 
476 	raw_spin_lock_irqsave(&devtree_lock, flags);
477 	parent = of_node_get(node->parent);
478 	of_node_put(node);
479 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
480 	return parent;
481 }
482 EXPORT_SYMBOL(of_get_next_parent);
483 
484 /**
485  *	of_get_next_child - Iterate a node childs
486  *	@node:	parent node
487  *	@prev:	previous child of the parent node, or NULL to get first
488  *
489  *	Returns a node pointer with refcount incremented, use
490  *	of_node_put() on it when done.
491  */
492 struct device_node *of_get_next_child(const struct device_node *node,
493 	struct device_node *prev)
494 {
495 	struct device_node *next;
496 	unsigned long flags;
497 
498 	raw_spin_lock_irqsave(&devtree_lock, flags);
499 	next = prev ? prev->sibling : node->child;
500 	for (; next; next = next->sibling)
501 		if (of_node_get(next))
502 			break;
503 	of_node_put(prev);
504 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
505 	return next;
506 }
507 EXPORT_SYMBOL(of_get_next_child);
508 
509 /**
510  *	of_get_next_available_child - Find the next available child node
511  *	@node:	parent node
512  *	@prev:	previous child of the parent node, or NULL to get first
513  *
514  *      This function is like of_get_next_child(), except that it
515  *      automatically skips any disabled nodes (i.e. status = "disabled").
516  */
517 struct device_node *of_get_next_available_child(const struct device_node *node,
518 	struct device_node *prev)
519 {
520 	struct device_node *next;
521 	unsigned long flags;
522 
523 	raw_spin_lock_irqsave(&devtree_lock, flags);
524 	next = prev ? prev->sibling : node->child;
525 	for (; next; next = next->sibling) {
526 		if (!__of_device_is_available(next))
527 			continue;
528 		if (of_node_get(next))
529 			break;
530 	}
531 	of_node_put(prev);
532 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
533 	return next;
534 }
535 EXPORT_SYMBOL(of_get_next_available_child);
536 
537 /**
538  *	of_get_child_by_name - Find the child node by name for a given parent
539  *	@node:	parent node
540  *	@name:	child name to look for.
541  *
542  *      This function looks for child node for given matching name
543  *
544  *	Returns a node pointer if found, with refcount incremented, use
545  *	of_node_put() on it when done.
546  *	Returns NULL if node is not found.
547  */
548 struct device_node *of_get_child_by_name(const struct device_node *node,
549 				const char *name)
550 {
551 	struct device_node *child;
552 
553 	for_each_child_of_node(node, child)
554 		if (child->name && (of_node_cmp(child->name, name) == 0))
555 			break;
556 	return child;
557 }
558 EXPORT_SYMBOL(of_get_child_by_name);
559 
560 /**
561  *	of_find_node_by_path - Find a node matching a full OF path
562  *	@path:	The full path to match
563  *
564  *	Returns a node pointer with refcount incremented, use
565  *	of_node_put() on it when done.
566  */
567 struct device_node *of_find_node_by_path(const char *path)
568 {
569 	struct device_node *np = of_allnodes;
570 	unsigned long flags;
571 
572 	raw_spin_lock_irqsave(&devtree_lock, flags);
573 	for (; np; np = np->allnext) {
574 		if (np->full_name && (of_node_cmp(np->full_name, path) == 0)
575 		    && of_node_get(np))
576 			break;
577 	}
578 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
579 	return np;
580 }
581 EXPORT_SYMBOL(of_find_node_by_path);
582 
583 /**
584  *	of_find_node_by_name - Find a node by its "name" property
585  *	@from:	The node to start searching from or NULL, the node
586  *		you pass will not be searched, only the next one
587  *		will; typically, you pass what the previous call
588  *		returned. of_node_put() will be called on it
589  *	@name:	The name string to match against
590  *
591  *	Returns a node pointer with refcount incremented, use
592  *	of_node_put() on it when done.
593  */
594 struct device_node *of_find_node_by_name(struct device_node *from,
595 	const char *name)
596 {
597 	struct device_node *np;
598 	unsigned long flags;
599 
600 	raw_spin_lock_irqsave(&devtree_lock, flags);
601 	np = from ? from->allnext : of_allnodes;
602 	for (; np; np = np->allnext)
603 		if (np->name && (of_node_cmp(np->name, name) == 0)
604 		    && of_node_get(np))
605 			break;
606 	of_node_put(from);
607 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
608 	return np;
609 }
610 EXPORT_SYMBOL(of_find_node_by_name);
611 
612 /**
613  *	of_find_node_by_type - Find a node by its "device_type" property
614  *	@from:	The node to start searching from, or NULL to start searching
615  *		the entire device tree. The node you pass will not be
616  *		searched, only the next one will; typically, you pass
617  *		what the previous call returned. of_node_put() will be
618  *		called on from for you.
619  *	@type:	The type string to match against
620  *
621  *	Returns a node pointer with refcount incremented, use
622  *	of_node_put() on it when done.
623  */
624 struct device_node *of_find_node_by_type(struct device_node *from,
625 	const char *type)
626 {
627 	struct device_node *np;
628 	unsigned long flags;
629 
630 	raw_spin_lock_irqsave(&devtree_lock, flags);
631 	np = from ? from->allnext : of_allnodes;
632 	for (; np; np = np->allnext)
633 		if (np->type && (of_node_cmp(np->type, type) == 0)
634 		    && of_node_get(np))
635 			break;
636 	of_node_put(from);
637 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
638 	return np;
639 }
640 EXPORT_SYMBOL(of_find_node_by_type);
641 
642 /**
643  *	of_find_compatible_node - Find a node based on type and one of the
644  *                                tokens in its "compatible" property
645  *	@from:		The node to start searching from or NULL, the node
646  *			you pass will not be searched, only the next one
647  *			will; typically, you pass what the previous call
648  *			returned. of_node_put() will be called on it
649  *	@type:		The type string to match "device_type" or NULL to ignore
650  *	@compatible:	The string to match to one of the tokens in the device
651  *			"compatible" list.
652  *
653  *	Returns a node pointer with refcount incremented, use
654  *	of_node_put() on it when done.
655  */
656 struct device_node *of_find_compatible_node(struct device_node *from,
657 	const char *type, const char *compatible)
658 {
659 	struct device_node *np;
660 	unsigned long flags;
661 
662 	raw_spin_lock_irqsave(&devtree_lock, flags);
663 	np = from ? from->allnext : of_allnodes;
664 	for (; np; np = np->allnext) {
665 		if (type
666 		    && !(np->type && (of_node_cmp(np->type, type) == 0)))
667 			continue;
668 		if (__of_device_is_compatible(np, compatible) &&
669 		    of_node_get(np))
670 			break;
671 	}
672 	of_node_put(from);
673 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
674 	return np;
675 }
676 EXPORT_SYMBOL(of_find_compatible_node);
677 
678 /**
679  *	of_find_node_with_property - Find a node which has a property with
680  *                                   the given name.
681  *	@from:		The node to start searching from or NULL, the node
682  *			you pass will not be searched, only the next one
683  *			will; typically, you pass what the previous call
684  *			returned. of_node_put() will be called on it
685  *	@prop_name:	The name of the property to look for.
686  *
687  *	Returns a node pointer with refcount incremented, use
688  *	of_node_put() on it when done.
689  */
690 struct device_node *of_find_node_with_property(struct device_node *from,
691 	const char *prop_name)
692 {
693 	struct device_node *np;
694 	struct property *pp;
695 	unsigned long flags;
696 
697 	raw_spin_lock_irqsave(&devtree_lock, flags);
698 	np = from ? from->allnext : of_allnodes;
699 	for (; np; np = np->allnext) {
700 		for (pp = np->properties; pp; pp = pp->next) {
701 			if (of_prop_cmp(pp->name, prop_name) == 0) {
702 				of_node_get(np);
703 				goto out;
704 			}
705 		}
706 	}
707 out:
708 	of_node_put(from);
709 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
710 	return np;
711 }
712 EXPORT_SYMBOL(of_find_node_with_property);
713 
714 static
715 const struct of_device_id *__of_match_node(const struct of_device_id *matches,
716 					   const struct device_node *node)
717 {
718 	if (!matches)
719 		return NULL;
720 
721 	while (matches->name[0] || matches->type[0] || matches->compatible[0]) {
722 		int match = 1;
723 		if (matches->name[0])
724 			match &= node->name
725 				&& !strcmp(matches->name, node->name);
726 		if (matches->type[0])
727 			match &= node->type
728 				&& !strcmp(matches->type, node->type);
729 		if (matches->compatible[0])
730 			match &= __of_device_is_compatible(node,
731 							   matches->compatible);
732 		if (match)
733 			return matches;
734 		matches++;
735 	}
736 	return NULL;
737 }
738 
739 /**
740  * of_match_node - Tell if an device_node has a matching of_match structure
741  *	@matches:	array of of device match structures to search in
742  *	@node:		the of device structure to match against
743  *
744  *	Low level utility function used by device matching.
745  */
746 const struct of_device_id *of_match_node(const struct of_device_id *matches,
747 					 const struct device_node *node)
748 {
749 	const struct of_device_id *match;
750 	unsigned long flags;
751 
752 	raw_spin_lock_irqsave(&devtree_lock, flags);
753 	match = __of_match_node(matches, node);
754 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
755 	return match;
756 }
757 EXPORT_SYMBOL(of_match_node);
758 
759 /**
760  *	of_find_matching_node_and_match - Find a node based on an of_device_id
761  *					  match table.
762  *	@from:		The node to start searching from or NULL, the node
763  *			you pass will not be searched, only the next one
764  *			will; typically, you pass what the previous call
765  *			returned. of_node_put() will be called on it
766  *	@matches:	array of of device match structures to search in
767  *	@match		Updated to point at the matches entry which matched
768  *
769  *	Returns a node pointer with refcount incremented, use
770  *	of_node_put() on it when done.
771  */
772 struct device_node *of_find_matching_node_and_match(struct device_node *from,
773 					const struct of_device_id *matches,
774 					const struct of_device_id **match)
775 {
776 	struct device_node *np;
777 	const struct of_device_id *m;
778 	unsigned long flags;
779 
780 	if (match)
781 		*match = NULL;
782 
783 	raw_spin_lock_irqsave(&devtree_lock, flags);
784 	np = from ? from->allnext : of_allnodes;
785 	for (; np; np = np->allnext) {
786 		m = __of_match_node(matches, np);
787 		if (m && of_node_get(np)) {
788 			if (match)
789 				*match = m;
790 			break;
791 		}
792 	}
793 	of_node_put(from);
794 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
795 	return np;
796 }
797 EXPORT_SYMBOL(of_find_matching_node_and_match);
798 
799 /**
800  * of_modalias_node - Lookup appropriate modalias for a device node
801  * @node:	pointer to a device tree node
802  * @modalias:	Pointer to buffer that modalias value will be copied into
803  * @len:	Length of modalias value
804  *
805  * Based on the value of the compatible property, this routine will attempt
806  * to choose an appropriate modalias value for a particular device tree node.
807  * It does this by stripping the manufacturer prefix (as delimited by a ',')
808  * from the first entry in the compatible list property.
809  *
810  * This routine returns 0 on success, <0 on failure.
811  */
812 int of_modalias_node(struct device_node *node, char *modalias, int len)
813 {
814 	const char *compatible, *p;
815 	int cplen;
816 
817 	compatible = of_get_property(node, "compatible", &cplen);
818 	if (!compatible || strlen(compatible) > cplen)
819 		return -ENODEV;
820 	p = strchr(compatible, ',');
821 	strlcpy(modalias, p ? p + 1 : compatible, len);
822 	return 0;
823 }
824 EXPORT_SYMBOL_GPL(of_modalias_node);
825 
826 /**
827  * of_find_node_by_phandle - Find a node given a phandle
828  * @handle:	phandle of the node to find
829  *
830  * Returns a node pointer with refcount incremented, use
831  * of_node_put() on it when done.
832  */
833 struct device_node *of_find_node_by_phandle(phandle handle)
834 {
835 	struct device_node *np;
836 	unsigned long flags;
837 
838 	raw_spin_lock_irqsave(&devtree_lock, flags);
839 	for (np = of_allnodes; np; np = np->allnext)
840 		if (np->phandle == handle)
841 			break;
842 	of_node_get(np);
843 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
844 	return np;
845 }
846 EXPORT_SYMBOL(of_find_node_by_phandle);
847 
848 /**
849  * of_find_property_value_of_size
850  *
851  * @np:		device node from which the property value is to be read.
852  * @propname:	name of the property to be searched.
853  * @len:	requested length of property value
854  *
855  * Search for a property in a device node and valid the requested size.
856  * Returns the property value on success, -EINVAL if the property does not
857  *  exist, -ENODATA if property does not have a value, and -EOVERFLOW if the
858  * property data isn't large enough.
859  *
860  */
861 static void *of_find_property_value_of_size(const struct device_node *np,
862 			const char *propname, u32 len)
863 {
864 	struct property *prop = of_find_property(np, propname, NULL);
865 
866 	if (!prop)
867 		return ERR_PTR(-EINVAL);
868 	if (!prop->value)
869 		return ERR_PTR(-ENODATA);
870 	if (len > prop->length)
871 		return ERR_PTR(-EOVERFLOW);
872 
873 	return prop->value;
874 }
875 
876 /**
877  * of_property_read_u32_index - Find and read a u32 from a multi-value property.
878  *
879  * @np:		device node from which the property value is to be read.
880  * @propname:	name of the property to be searched.
881  * @index:	index of the u32 in the list of values
882  * @out_value:	pointer to return value, modified only if no error.
883  *
884  * Search for a property in a device node and read nth 32-bit value from
885  * it. Returns 0 on success, -EINVAL if the property does not exist,
886  * -ENODATA if property does not have a value, and -EOVERFLOW if the
887  * property data isn't large enough.
888  *
889  * The out_value is modified only if a valid u32 value can be decoded.
890  */
891 int of_property_read_u32_index(const struct device_node *np,
892 				       const char *propname,
893 				       u32 index, u32 *out_value)
894 {
895 	const u32 *val = of_find_property_value_of_size(np, propname,
896 					((index + 1) * sizeof(*out_value)));
897 
898 	if (IS_ERR(val))
899 		return PTR_ERR(val);
900 
901 	*out_value = be32_to_cpup(((__be32 *)val) + index);
902 	return 0;
903 }
904 EXPORT_SYMBOL_GPL(of_property_read_u32_index);
905 
906 /**
907  * of_property_read_u8_array - Find and read an array of u8 from a property.
908  *
909  * @np:		device node from which the property value is to be read.
910  * @propname:	name of the property to be searched.
911  * @out_values:	pointer to return value, modified only if return value is 0.
912  * @sz:		number of array elements to read
913  *
914  * Search for a property in a device node and read 8-bit value(s) from
915  * it. Returns 0 on success, -EINVAL if the property does not exist,
916  * -ENODATA if property does not have a value, and -EOVERFLOW if the
917  * property data isn't large enough.
918  *
919  * dts entry of array should be like:
920  *	property = /bits/ 8 <0x50 0x60 0x70>;
921  *
922  * The out_values is modified only if a valid u8 value can be decoded.
923  */
924 int of_property_read_u8_array(const struct device_node *np,
925 			const char *propname, u8 *out_values, size_t sz)
926 {
927 	const u8 *val = of_find_property_value_of_size(np, propname,
928 						(sz * sizeof(*out_values)));
929 
930 	if (IS_ERR(val))
931 		return PTR_ERR(val);
932 
933 	while (sz--)
934 		*out_values++ = *val++;
935 	return 0;
936 }
937 EXPORT_SYMBOL_GPL(of_property_read_u8_array);
938 
939 /**
940  * of_property_read_u16_array - Find and read an array of u16 from a property.
941  *
942  * @np:		device node from which the property value is to be read.
943  * @propname:	name of the property to be searched.
944  * @out_values:	pointer to return value, modified only if return value is 0.
945  * @sz:		number of array elements to read
946  *
947  * Search for a property in a device node and read 16-bit value(s) from
948  * it. Returns 0 on success, -EINVAL if the property does not exist,
949  * -ENODATA if property does not have a value, and -EOVERFLOW if the
950  * property data isn't large enough.
951  *
952  * dts entry of array should be like:
953  *	property = /bits/ 16 <0x5000 0x6000 0x7000>;
954  *
955  * The out_values is modified only if a valid u16 value can be decoded.
956  */
957 int of_property_read_u16_array(const struct device_node *np,
958 			const char *propname, u16 *out_values, size_t sz)
959 {
960 	const __be16 *val = of_find_property_value_of_size(np, propname,
961 						(sz * sizeof(*out_values)));
962 
963 	if (IS_ERR(val))
964 		return PTR_ERR(val);
965 
966 	while (sz--)
967 		*out_values++ = be16_to_cpup(val++);
968 	return 0;
969 }
970 EXPORT_SYMBOL_GPL(of_property_read_u16_array);
971 
972 /**
973  * of_property_read_u32_array - Find and read an array of 32 bit integers
974  * from a property.
975  *
976  * @np:		device node from which the property value is to be read.
977  * @propname:	name of the property to be searched.
978  * @out_values:	pointer to return value, modified only if return value is 0.
979  * @sz:		number of array elements to read
980  *
981  * Search for a property in a device node and read 32-bit value(s) from
982  * it. Returns 0 on success, -EINVAL if the property does not exist,
983  * -ENODATA if property does not have a value, and -EOVERFLOW if the
984  * property data isn't large enough.
985  *
986  * The out_values is modified only if a valid u32 value can be decoded.
987  */
988 int of_property_read_u32_array(const struct device_node *np,
989 			       const char *propname, u32 *out_values,
990 			       size_t sz)
991 {
992 	const __be32 *val = of_find_property_value_of_size(np, propname,
993 						(sz * sizeof(*out_values)));
994 
995 	if (IS_ERR(val))
996 		return PTR_ERR(val);
997 
998 	while (sz--)
999 		*out_values++ = be32_to_cpup(val++);
1000 	return 0;
1001 }
1002 EXPORT_SYMBOL_GPL(of_property_read_u32_array);
1003 
1004 /**
1005  * of_property_read_u64 - Find and read a 64 bit integer from a property
1006  * @np:		device node from which the property value is to be read.
1007  * @propname:	name of the property to be searched.
1008  * @out_value:	pointer to return value, modified only if return value is 0.
1009  *
1010  * Search for a property in a device node and read a 64-bit value from
1011  * it. Returns 0 on success, -EINVAL if the property does not exist,
1012  * -ENODATA if property does not have a value, and -EOVERFLOW if the
1013  * property data isn't large enough.
1014  *
1015  * The out_value is modified only if a valid u64 value can be decoded.
1016  */
1017 int of_property_read_u64(const struct device_node *np, const char *propname,
1018 			 u64 *out_value)
1019 {
1020 	const __be32 *val = of_find_property_value_of_size(np, propname,
1021 						sizeof(*out_value));
1022 
1023 	if (IS_ERR(val))
1024 		return PTR_ERR(val);
1025 
1026 	*out_value = of_read_number(val, 2);
1027 	return 0;
1028 }
1029 EXPORT_SYMBOL_GPL(of_property_read_u64);
1030 
1031 /**
1032  * of_property_read_string - Find and read a string from a property
1033  * @np:		device node from which the property value is to be read.
1034  * @propname:	name of the property to be searched.
1035  * @out_string:	pointer to null terminated return string, modified only if
1036  *		return value is 0.
1037  *
1038  * Search for a property in a device tree node and retrieve a null
1039  * terminated string value (pointer to data, not a copy). Returns 0 on
1040  * success, -EINVAL if the property does not exist, -ENODATA if property
1041  * does not have a value, and -EILSEQ if the string is not null-terminated
1042  * within the length of the property data.
1043  *
1044  * The out_string pointer is modified only if a valid string can be decoded.
1045  */
1046 int of_property_read_string(struct device_node *np, const char *propname,
1047 				const char **out_string)
1048 {
1049 	struct property *prop = of_find_property(np, propname, NULL);
1050 	if (!prop)
1051 		return -EINVAL;
1052 	if (!prop->value)
1053 		return -ENODATA;
1054 	if (strnlen(prop->value, prop->length) >= prop->length)
1055 		return -EILSEQ;
1056 	*out_string = prop->value;
1057 	return 0;
1058 }
1059 EXPORT_SYMBOL_GPL(of_property_read_string);
1060 
1061 /**
1062  * of_property_read_string_index - Find and read a string from a multiple
1063  * strings property.
1064  * @np:		device node from which the property value is to be read.
1065  * @propname:	name of the property to be searched.
1066  * @index:	index of the string in the list of strings
1067  * @out_string:	pointer to null terminated return string, modified only if
1068  *		return value is 0.
1069  *
1070  * Search for a property in a device tree node and retrieve a null
1071  * terminated string value (pointer to data, not a copy) in the list of strings
1072  * contained in that property.
1073  * Returns 0 on success, -EINVAL if the property does not exist, -ENODATA if
1074  * property does not have a value, and -EILSEQ if the string is not
1075  * null-terminated within the length of the property data.
1076  *
1077  * The out_string pointer is modified only if a valid string can be decoded.
1078  */
1079 int of_property_read_string_index(struct device_node *np, const char *propname,
1080 				  int index, const char **output)
1081 {
1082 	struct property *prop = of_find_property(np, propname, NULL);
1083 	int i = 0;
1084 	size_t l = 0, total = 0;
1085 	const char *p;
1086 
1087 	if (!prop)
1088 		return -EINVAL;
1089 	if (!prop->value)
1090 		return -ENODATA;
1091 	if (strnlen(prop->value, prop->length) >= prop->length)
1092 		return -EILSEQ;
1093 
1094 	p = prop->value;
1095 
1096 	for (i = 0; total < prop->length; total += l, p += l) {
1097 		l = strlen(p) + 1;
1098 		if (i++ == index) {
1099 			*output = p;
1100 			return 0;
1101 		}
1102 	}
1103 	return -ENODATA;
1104 }
1105 EXPORT_SYMBOL_GPL(of_property_read_string_index);
1106 
1107 /**
1108  * of_property_match_string() - Find string in a list and return index
1109  * @np: pointer to node containing string list property
1110  * @propname: string list property name
1111  * @string: pointer to string to search for in string list
1112  *
1113  * This function searches a string list property and returns the index
1114  * of a specific string value.
1115  */
1116 int of_property_match_string(struct device_node *np, const char *propname,
1117 			     const char *string)
1118 {
1119 	struct property *prop = of_find_property(np, propname, NULL);
1120 	size_t l;
1121 	int i;
1122 	const char *p, *end;
1123 
1124 	if (!prop)
1125 		return -EINVAL;
1126 	if (!prop->value)
1127 		return -ENODATA;
1128 
1129 	p = prop->value;
1130 	end = p + prop->length;
1131 
1132 	for (i = 0; p < end; i++, p += l) {
1133 		l = strlen(p) + 1;
1134 		if (p + l > end)
1135 			return -EILSEQ;
1136 		pr_debug("comparing %s with %s\n", string, p);
1137 		if (strcmp(string, p) == 0)
1138 			return i; /* Found it; return index */
1139 	}
1140 	return -ENODATA;
1141 }
1142 EXPORT_SYMBOL_GPL(of_property_match_string);
1143 
1144 /**
1145  * of_property_count_strings - Find and return the number of strings from a
1146  * multiple strings property.
1147  * @np:		device node from which the property value is to be read.
1148  * @propname:	name of the property to be searched.
1149  *
1150  * Search for a property in a device tree node and retrieve the number of null
1151  * terminated string contain in it. Returns the number of strings on
1152  * success, -EINVAL if the property does not exist, -ENODATA if property
1153  * does not have a value, and -EILSEQ if the string is not null-terminated
1154  * within the length of the property data.
1155  */
1156 int of_property_count_strings(struct device_node *np, const char *propname)
1157 {
1158 	struct property *prop = of_find_property(np, propname, NULL);
1159 	int i = 0;
1160 	size_t l = 0, total = 0;
1161 	const char *p;
1162 
1163 	if (!prop)
1164 		return -EINVAL;
1165 	if (!prop->value)
1166 		return -ENODATA;
1167 	if (strnlen(prop->value, prop->length) >= prop->length)
1168 		return -EILSEQ;
1169 
1170 	p = prop->value;
1171 
1172 	for (i = 0; total < prop->length; total += l, p += l, i++)
1173 		l = strlen(p) + 1;
1174 
1175 	return i;
1176 }
1177 EXPORT_SYMBOL_GPL(of_property_count_strings);
1178 
1179 static int __of_parse_phandle_with_args(const struct device_node *np,
1180 					const char *list_name,
1181 					const char *cells_name,
1182 					int cell_count, int index,
1183 					struct of_phandle_args *out_args)
1184 {
1185 	const __be32 *list, *list_end;
1186 	int rc = 0, size, cur_index = 0;
1187 	uint32_t count = 0;
1188 	struct device_node *node = NULL;
1189 	phandle phandle;
1190 
1191 	/* Retrieve the phandle list property */
1192 	list = of_get_property(np, list_name, &size);
1193 	if (!list)
1194 		return -ENOENT;
1195 	list_end = list + size / sizeof(*list);
1196 
1197 	/* Loop over the phandles until all the requested entry is found */
1198 	while (list < list_end) {
1199 		rc = -EINVAL;
1200 		count = 0;
1201 
1202 		/*
1203 		 * If phandle is 0, then it is an empty entry with no
1204 		 * arguments.  Skip forward to the next entry.
1205 		 */
1206 		phandle = be32_to_cpup(list++);
1207 		if (phandle) {
1208 			/*
1209 			 * Find the provider node and parse the #*-cells
1210 			 * property to determine the argument length.
1211 			 *
1212 			 * This is not needed if the cell count is hard-coded
1213 			 * (i.e. cells_name not set, but cell_count is set),
1214 			 * except when we're going to return the found node
1215 			 * below.
1216 			 */
1217 			if (cells_name || cur_index == index) {
1218 				node = of_find_node_by_phandle(phandle);
1219 				if (!node) {
1220 					pr_err("%s: could not find phandle\n",
1221 						np->full_name);
1222 					goto err;
1223 				}
1224 			}
1225 
1226 			if (cells_name) {
1227 				if (of_property_read_u32(node, cells_name,
1228 							 &count)) {
1229 					pr_err("%s: could not get %s for %s\n",
1230 						np->full_name, cells_name,
1231 						node->full_name);
1232 					goto err;
1233 				}
1234 			} else {
1235 				count = cell_count;
1236 			}
1237 
1238 			/*
1239 			 * Make sure that the arguments actually fit in the
1240 			 * remaining property data length
1241 			 */
1242 			if (list + count > list_end) {
1243 				pr_err("%s: arguments longer than property\n",
1244 					 np->full_name);
1245 				goto err;
1246 			}
1247 		}
1248 
1249 		/*
1250 		 * All of the error cases above bail out of the loop, so at
1251 		 * this point, the parsing is successful. If the requested
1252 		 * index matches, then fill the out_args structure and return,
1253 		 * or return -ENOENT for an empty entry.
1254 		 */
1255 		rc = -ENOENT;
1256 		if (cur_index == index) {
1257 			if (!phandle)
1258 				goto err;
1259 
1260 			if (out_args) {
1261 				int i;
1262 				if (WARN_ON(count > MAX_PHANDLE_ARGS))
1263 					count = MAX_PHANDLE_ARGS;
1264 				out_args->np = node;
1265 				out_args->args_count = count;
1266 				for (i = 0; i < count; i++)
1267 					out_args->args[i] = be32_to_cpup(list++);
1268 			} else {
1269 				of_node_put(node);
1270 			}
1271 
1272 			/* Found it! return success */
1273 			return 0;
1274 		}
1275 
1276 		of_node_put(node);
1277 		node = NULL;
1278 		list += count;
1279 		cur_index++;
1280 	}
1281 
1282 	/*
1283 	 * Unlock node before returning result; will be one of:
1284 	 * -ENOENT : index is for empty phandle
1285 	 * -EINVAL : parsing error on data
1286 	 * [1..n]  : Number of phandle (count mode; when index = -1)
1287 	 */
1288 	rc = index < 0 ? cur_index : -ENOENT;
1289  err:
1290 	if (node)
1291 		of_node_put(node);
1292 	return rc;
1293 }
1294 
1295 /**
1296  * of_parse_phandle - Resolve a phandle property to a device_node pointer
1297  * @np: Pointer to device node holding phandle property
1298  * @phandle_name: Name of property holding a phandle value
1299  * @index: For properties holding a table of phandles, this is the index into
1300  *         the table
1301  *
1302  * Returns the device_node pointer with refcount incremented.  Use
1303  * of_node_put() on it when done.
1304  */
1305 struct device_node *of_parse_phandle(const struct device_node *np,
1306 				     const char *phandle_name, int index)
1307 {
1308 	struct of_phandle_args args;
1309 
1310 	if (index < 0)
1311 		return NULL;
1312 
1313 	if (__of_parse_phandle_with_args(np, phandle_name, NULL, 0,
1314 					 index, &args))
1315 		return NULL;
1316 
1317 	return args.np;
1318 }
1319 EXPORT_SYMBOL(of_parse_phandle);
1320 
1321 /**
1322  * of_parse_phandle_with_args() - Find a node pointed by phandle in a list
1323  * @np:		pointer to a device tree node containing a list
1324  * @list_name:	property name that contains a list
1325  * @cells_name:	property name that specifies phandles' arguments count
1326  * @index:	index of a phandle to parse out
1327  * @out_args:	optional pointer to output arguments structure (will be filled)
1328  *
1329  * This function is useful to parse lists of phandles and their arguments.
1330  * Returns 0 on success and fills out_args, on error returns appropriate
1331  * errno value.
1332  *
1333  * Caller is responsible to call of_node_put() on the returned out_args->node
1334  * pointer.
1335  *
1336  * Example:
1337  *
1338  * phandle1: node1 {
1339  * 	#list-cells = <2>;
1340  * }
1341  *
1342  * phandle2: node2 {
1343  * 	#list-cells = <1>;
1344  * }
1345  *
1346  * node3 {
1347  * 	list = <&phandle1 1 2 &phandle2 3>;
1348  * }
1349  *
1350  * To get a device_node of the `node2' node you may call this:
1351  * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
1352  */
1353 int of_parse_phandle_with_args(const struct device_node *np, const char *list_name,
1354 				const char *cells_name, int index,
1355 				struct of_phandle_args *out_args)
1356 {
1357 	if (index < 0)
1358 		return -EINVAL;
1359 	return __of_parse_phandle_with_args(np, list_name, cells_name, 0,
1360 					    index, out_args);
1361 }
1362 EXPORT_SYMBOL(of_parse_phandle_with_args);
1363 
1364 /**
1365  * of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list
1366  * @np:		pointer to a device tree node containing a list
1367  * @list_name:	property name that contains a list
1368  * @cell_count: number of argument cells following the phandle
1369  * @index:	index of a phandle to parse out
1370  * @out_args:	optional pointer to output arguments structure (will be filled)
1371  *
1372  * This function is useful to parse lists of phandles and their arguments.
1373  * Returns 0 on success and fills out_args, on error returns appropriate
1374  * errno value.
1375  *
1376  * Caller is responsible to call of_node_put() on the returned out_args->node
1377  * pointer.
1378  *
1379  * Example:
1380  *
1381  * phandle1: node1 {
1382  * }
1383  *
1384  * phandle2: node2 {
1385  * }
1386  *
1387  * node3 {
1388  * 	list = <&phandle1 0 2 &phandle2 2 3>;
1389  * }
1390  *
1391  * To get a device_node of the `node2' node you may call this:
1392  * of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args);
1393  */
1394 int of_parse_phandle_with_fixed_args(const struct device_node *np,
1395 				const char *list_name, int cell_count,
1396 				int index, struct of_phandle_args *out_args)
1397 {
1398 	if (index < 0)
1399 		return -EINVAL;
1400 	return __of_parse_phandle_with_args(np, list_name, NULL, cell_count,
1401 					   index, out_args);
1402 }
1403 EXPORT_SYMBOL(of_parse_phandle_with_fixed_args);
1404 
1405 /**
1406  * of_count_phandle_with_args() - Find the number of phandles references in a property
1407  * @np:		pointer to a device tree node containing a list
1408  * @list_name:	property name that contains a list
1409  * @cells_name:	property name that specifies phandles' arguments count
1410  *
1411  * Returns the number of phandle + argument tuples within a property. It
1412  * is a typical pattern to encode a list of phandle and variable
1413  * arguments into a single property. The number of arguments is encoded
1414  * by a property in the phandle-target node. For example, a gpios
1415  * property would contain a list of GPIO specifies consisting of a
1416  * phandle and 1 or more arguments. The number of arguments are
1417  * determined by the #gpio-cells property in the node pointed to by the
1418  * phandle.
1419  */
1420 int of_count_phandle_with_args(const struct device_node *np, const char *list_name,
1421 				const char *cells_name)
1422 {
1423 	return __of_parse_phandle_with_args(np, list_name, cells_name, 0, -1,
1424 					    NULL);
1425 }
1426 EXPORT_SYMBOL(of_count_phandle_with_args);
1427 
1428 #if defined(CONFIG_OF_DYNAMIC)
1429 static int of_property_notify(int action, struct device_node *np,
1430 			      struct property *prop)
1431 {
1432 	struct of_prop_reconfig pr;
1433 
1434 	pr.dn = np;
1435 	pr.prop = prop;
1436 	return of_reconfig_notify(action, &pr);
1437 }
1438 #else
1439 static int of_property_notify(int action, struct device_node *np,
1440 			      struct property *prop)
1441 {
1442 	return 0;
1443 }
1444 #endif
1445 
1446 /**
1447  * of_add_property - Add a property to a node
1448  */
1449 int of_add_property(struct device_node *np, struct property *prop)
1450 {
1451 	struct property **next;
1452 	unsigned long flags;
1453 	int rc;
1454 
1455 	rc = of_property_notify(OF_RECONFIG_ADD_PROPERTY, np, prop);
1456 	if (rc)
1457 		return rc;
1458 
1459 	prop->next = NULL;
1460 	raw_spin_lock_irqsave(&devtree_lock, flags);
1461 	next = &np->properties;
1462 	while (*next) {
1463 		if (strcmp(prop->name, (*next)->name) == 0) {
1464 			/* duplicate ! don't insert it */
1465 			raw_spin_unlock_irqrestore(&devtree_lock, flags);
1466 			return -1;
1467 		}
1468 		next = &(*next)->next;
1469 	}
1470 	*next = prop;
1471 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1472 
1473 #ifdef CONFIG_PROC_DEVICETREE
1474 	/* try to add to proc as well if it was initialized */
1475 	if (np->pde)
1476 		proc_device_tree_add_prop(np->pde, prop);
1477 #endif /* CONFIG_PROC_DEVICETREE */
1478 
1479 	return 0;
1480 }
1481 
1482 /**
1483  * of_remove_property - Remove a property from a node.
1484  *
1485  * Note that we don't actually remove it, since we have given out
1486  * who-knows-how-many pointers to the data using get-property.
1487  * Instead we just move the property to the "dead properties"
1488  * list, so it won't be found any more.
1489  */
1490 int of_remove_property(struct device_node *np, struct property *prop)
1491 {
1492 	struct property **next;
1493 	unsigned long flags;
1494 	int found = 0;
1495 	int rc;
1496 
1497 	rc = of_property_notify(OF_RECONFIG_REMOVE_PROPERTY, np, prop);
1498 	if (rc)
1499 		return rc;
1500 
1501 	raw_spin_lock_irqsave(&devtree_lock, flags);
1502 	next = &np->properties;
1503 	while (*next) {
1504 		if (*next == prop) {
1505 			/* found the node */
1506 			*next = prop->next;
1507 			prop->next = np->deadprops;
1508 			np->deadprops = prop;
1509 			found = 1;
1510 			break;
1511 		}
1512 		next = &(*next)->next;
1513 	}
1514 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1515 
1516 	if (!found)
1517 		return -ENODEV;
1518 
1519 #ifdef CONFIG_PROC_DEVICETREE
1520 	/* try to remove the proc node as well */
1521 	if (np->pde)
1522 		proc_device_tree_remove_prop(np->pde, prop);
1523 #endif /* CONFIG_PROC_DEVICETREE */
1524 
1525 	return 0;
1526 }
1527 
1528 /*
1529  * of_update_property - Update a property in a node, if the property does
1530  * not exist, add it.
1531  *
1532  * Note that we don't actually remove it, since we have given out
1533  * who-knows-how-many pointers to the data using get-property.
1534  * Instead we just move the property to the "dead properties" list,
1535  * and add the new property to the property list
1536  */
1537 int of_update_property(struct device_node *np, struct property *newprop)
1538 {
1539 	struct property **next, *oldprop;
1540 	unsigned long flags;
1541 	int rc, found = 0;
1542 
1543 	rc = of_property_notify(OF_RECONFIG_UPDATE_PROPERTY, np, newprop);
1544 	if (rc)
1545 		return rc;
1546 
1547 	if (!newprop->name)
1548 		return -EINVAL;
1549 
1550 	oldprop = of_find_property(np, newprop->name, NULL);
1551 	if (!oldprop)
1552 		return of_add_property(np, newprop);
1553 
1554 	raw_spin_lock_irqsave(&devtree_lock, flags);
1555 	next = &np->properties;
1556 	while (*next) {
1557 		if (*next == oldprop) {
1558 			/* found the node */
1559 			newprop->next = oldprop->next;
1560 			*next = newprop;
1561 			oldprop->next = np->deadprops;
1562 			np->deadprops = oldprop;
1563 			found = 1;
1564 			break;
1565 		}
1566 		next = &(*next)->next;
1567 	}
1568 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1569 
1570 	if (!found)
1571 		return -ENODEV;
1572 
1573 #ifdef CONFIG_PROC_DEVICETREE
1574 	/* try to add to proc as well if it was initialized */
1575 	if (np->pde)
1576 		proc_device_tree_update_prop(np->pde, newprop, oldprop);
1577 #endif /* CONFIG_PROC_DEVICETREE */
1578 
1579 	return 0;
1580 }
1581 
1582 #if defined(CONFIG_OF_DYNAMIC)
1583 /*
1584  * Support for dynamic device trees.
1585  *
1586  * On some platforms, the device tree can be manipulated at runtime.
1587  * The routines in this section support adding, removing and changing
1588  * device tree nodes.
1589  */
1590 
1591 static BLOCKING_NOTIFIER_HEAD(of_reconfig_chain);
1592 
1593 int of_reconfig_notifier_register(struct notifier_block *nb)
1594 {
1595 	return blocking_notifier_chain_register(&of_reconfig_chain, nb);
1596 }
1597 EXPORT_SYMBOL_GPL(of_reconfig_notifier_register);
1598 
1599 int of_reconfig_notifier_unregister(struct notifier_block *nb)
1600 {
1601 	return blocking_notifier_chain_unregister(&of_reconfig_chain, nb);
1602 }
1603 EXPORT_SYMBOL_GPL(of_reconfig_notifier_unregister);
1604 
1605 int of_reconfig_notify(unsigned long action, void *p)
1606 {
1607 	int rc;
1608 
1609 	rc = blocking_notifier_call_chain(&of_reconfig_chain, action, p);
1610 	return notifier_to_errno(rc);
1611 }
1612 
1613 #ifdef CONFIG_PROC_DEVICETREE
1614 static void of_add_proc_dt_entry(struct device_node *dn)
1615 {
1616 	struct proc_dir_entry *ent;
1617 
1618 	ent = proc_mkdir(strrchr(dn->full_name, '/') + 1, dn->parent->pde);
1619 	if (ent)
1620 		proc_device_tree_add_node(dn, ent);
1621 }
1622 #else
1623 static void of_add_proc_dt_entry(struct device_node *dn)
1624 {
1625 	return;
1626 }
1627 #endif
1628 
1629 /**
1630  * of_attach_node - Plug a device node into the tree and global list.
1631  */
1632 int of_attach_node(struct device_node *np)
1633 {
1634 	unsigned long flags;
1635 	int rc;
1636 
1637 	rc = of_reconfig_notify(OF_RECONFIG_ATTACH_NODE, np);
1638 	if (rc)
1639 		return rc;
1640 
1641 	raw_spin_lock_irqsave(&devtree_lock, flags);
1642 	np->sibling = np->parent->child;
1643 	np->allnext = of_allnodes;
1644 	np->parent->child = np;
1645 	of_allnodes = np;
1646 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1647 
1648 	of_add_proc_dt_entry(np);
1649 	return 0;
1650 }
1651 
1652 #ifdef CONFIG_PROC_DEVICETREE
1653 static void of_remove_proc_dt_entry(struct device_node *dn)
1654 {
1655 	proc_remove(dn->pde);
1656 }
1657 #else
1658 static void of_remove_proc_dt_entry(struct device_node *dn)
1659 {
1660 	return;
1661 }
1662 #endif
1663 
1664 /**
1665  * of_detach_node - "Unplug" a node from the device tree.
1666  *
1667  * The caller must hold a reference to the node.  The memory associated with
1668  * the node is not freed until its refcount goes to zero.
1669  */
1670 int of_detach_node(struct device_node *np)
1671 {
1672 	struct device_node *parent;
1673 	unsigned long flags;
1674 	int rc = 0;
1675 
1676 	rc = of_reconfig_notify(OF_RECONFIG_DETACH_NODE, np);
1677 	if (rc)
1678 		return rc;
1679 
1680 	raw_spin_lock_irqsave(&devtree_lock, flags);
1681 
1682 	if (of_node_check_flag(np, OF_DETACHED)) {
1683 		/* someone already detached it */
1684 		raw_spin_unlock_irqrestore(&devtree_lock, flags);
1685 		return rc;
1686 	}
1687 
1688 	parent = np->parent;
1689 	if (!parent) {
1690 		raw_spin_unlock_irqrestore(&devtree_lock, flags);
1691 		return rc;
1692 	}
1693 
1694 	if (of_allnodes == np)
1695 		of_allnodes = np->allnext;
1696 	else {
1697 		struct device_node *prev;
1698 		for (prev = of_allnodes;
1699 		     prev->allnext != np;
1700 		     prev = prev->allnext)
1701 			;
1702 		prev->allnext = np->allnext;
1703 	}
1704 
1705 	if (parent->child == np)
1706 		parent->child = np->sibling;
1707 	else {
1708 		struct device_node *prevsib;
1709 		for (prevsib = np->parent->child;
1710 		     prevsib->sibling != np;
1711 		     prevsib = prevsib->sibling)
1712 			;
1713 		prevsib->sibling = np->sibling;
1714 	}
1715 
1716 	of_node_set_flag(np, OF_DETACHED);
1717 	raw_spin_unlock_irqrestore(&devtree_lock, flags);
1718 
1719 	of_remove_proc_dt_entry(np);
1720 	return rc;
1721 }
1722 #endif /* defined(CONFIG_OF_DYNAMIC) */
1723 
1724 static void of_alias_add(struct alias_prop *ap, struct device_node *np,
1725 			 int id, const char *stem, int stem_len)
1726 {
1727 	ap->np = np;
1728 	ap->id = id;
1729 	strncpy(ap->stem, stem, stem_len);
1730 	ap->stem[stem_len] = 0;
1731 	list_add_tail(&ap->link, &aliases_lookup);
1732 	pr_debug("adding DT alias:%s: stem=%s id=%i node=%s\n",
1733 		 ap->alias, ap->stem, ap->id, of_node_full_name(np));
1734 }
1735 
1736 /**
1737  * of_alias_scan - Scan all properties of 'aliases' node
1738  *
1739  * The function scans all the properties of 'aliases' node and populate
1740  * the the global lookup table with the properties.  It returns the
1741  * number of alias_prop found, or error code in error case.
1742  *
1743  * @dt_alloc:	An allocator that provides a virtual address to memory
1744  *		for the resulting tree
1745  */
1746 void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align))
1747 {
1748 	struct property *pp;
1749 
1750 	of_chosen = of_find_node_by_path("/chosen");
1751 	if (of_chosen == NULL)
1752 		of_chosen = of_find_node_by_path("/chosen@0");
1753 
1754 	if (of_chosen) {
1755 		const char *name;
1756 
1757 		name = of_get_property(of_chosen, "linux,stdout-path", NULL);
1758 		if (name)
1759 			of_stdout = of_find_node_by_path(name);
1760 	}
1761 
1762 	of_aliases = of_find_node_by_path("/aliases");
1763 	if (!of_aliases)
1764 		return;
1765 
1766 	for_each_property_of_node(of_aliases, pp) {
1767 		const char *start = pp->name;
1768 		const char *end = start + strlen(start);
1769 		struct device_node *np;
1770 		struct alias_prop *ap;
1771 		int id, len;
1772 
1773 		/* Skip those we do not want to proceed */
1774 		if (!strcmp(pp->name, "name") ||
1775 		    !strcmp(pp->name, "phandle") ||
1776 		    !strcmp(pp->name, "linux,phandle"))
1777 			continue;
1778 
1779 		np = of_find_node_by_path(pp->value);
1780 		if (!np)
1781 			continue;
1782 
1783 		/* walk the alias backwards to extract the id and work out
1784 		 * the 'stem' string */
1785 		while (isdigit(*(end-1)) && end > start)
1786 			end--;
1787 		len = end - start;
1788 
1789 		if (kstrtoint(end, 10, &id) < 0)
1790 			continue;
1791 
1792 		/* Allocate an alias_prop with enough space for the stem */
1793 		ap = dt_alloc(sizeof(*ap) + len + 1, 4);
1794 		if (!ap)
1795 			continue;
1796 		memset(ap, 0, sizeof(*ap) + len + 1);
1797 		ap->alias = start;
1798 		of_alias_add(ap, np, id, start, len);
1799 	}
1800 }
1801 
1802 /**
1803  * of_alias_get_id - Get alias id for the given device_node
1804  * @np:		Pointer to the given device_node
1805  * @stem:	Alias stem of the given device_node
1806  *
1807  * The function travels the lookup table to get alias id for the given
1808  * device_node and alias stem.  It returns the alias id if find it.
1809  */
1810 int of_alias_get_id(struct device_node *np, const char *stem)
1811 {
1812 	struct alias_prop *app;
1813 	int id = -ENODEV;
1814 
1815 	mutex_lock(&of_aliases_mutex);
1816 	list_for_each_entry(app, &aliases_lookup, link) {
1817 		if (strcmp(app->stem, stem) != 0)
1818 			continue;
1819 
1820 		if (np == app->np) {
1821 			id = app->id;
1822 			break;
1823 		}
1824 	}
1825 	mutex_unlock(&of_aliases_mutex);
1826 
1827 	return id;
1828 }
1829 EXPORT_SYMBOL_GPL(of_alias_get_id);
1830 
1831 const __be32 *of_prop_next_u32(struct property *prop, const __be32 *cur,
1832 			       u32 *pu)
1833 {
1834 	const void *curv = cur;
1835 
1836 	if (!prop)
1837 		return NULL;
1838 
1839 	if (!cur) {
1840 		curv = prop->value;
1841 		goto out_val;
1842 	}
1843 
1844 	curv += sizeof(*cur);
1845 	if (curv >= prop->value + prop->length)
1846 		return NULL;
1847 
1848 out_val:
1849 	*pu = be32_to_cpup(curv);
1850 	return curv;
1851 }
1852 EXPORT_SYMBOL_GPL(of_prop_next_u32);
1853 
1854 const char *of_prop_next_string(struct property *prop, const char *cur)
1855 {
1856 	const void *curv = cur;
1857 
1858 	if (!prop)
1859 		return NULL;
1860 
1861 	if (!cur)
1862 		return prop->value;
1863 
1864 	curv += strlen(cur) + 1;
1865 	if (curv >= prop->value + prop->length)
1866 		return NULL;
1867 
1868 	return curv;
1869 }
1870 EXPORT_SYMBOL_GPL(of_prop_next_string);
1871 
1872 /**
1873  * of_device_is_stdout_path - check if a device node matches the
1874  *                            linux,stdout-path property
1875  *
1876  * Check if this device node matches the linux,stdout-path property
1877  * in the chosen node. return true if yes, false otherwise.
1878  */
1879 int of_device_is_stdout_path(struct device_node *dn)
1880 {
1881 	if (!of_stdout)
1882 		return false;
1883 
1884 	return of_stdout == dn;
1885 }
1886 EXPORT_SYMBOL_GPL(of_device_is_stdout_path);
1887