2 * Procedures for creating, accessing and interpreting the device tree.
4 * Paul Mackerras August 1996.
5 * Copyright (C) 1996-2005 Paul Mackerras.
7 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
8 * {engebret|bergner}@us.ibm.com
10 * Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net
12 * Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
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.
21 #define pr_fmt(fmt) "OF: " fmt
23 #include <linux/console.h>
24 #include <linux/ctype.h>
25 #include <linux/cpu.h>
26 #include <linux/module.h>
28 #include <linux/of_device.h>
29 #include <linux/of_graph.h>
30 #include <linux/spinlock.h>
31 #include <linux/slab.h>
32 #include <linux/string.h>
33 #include <linux/proc_fs.h>
35 #include "of_private.h"
37 LIST_HEAD(aliases_lookup
);
39 struct device_node
*of_root
;
40 EXPORT_SYMBOL(of_root
);
41 struct device_node
*of_chosen
;
42 struct device_node
*of_aliases
;
43 struct device_node
*of_stdout
;
44 static const char *of_stdout_options
;
49 * Used to protect the of_aliases, to hold off addition of nodes to sysfs.
50 * This mutex must be held whenever modifications are being made to the
51 * device tree. The of_{attach,detach}_node() and
52 * of_{add,remove,update}_property() helpers make sure this happens.
54 DEFINE_MUTEX(of_mutex
);
56 /* use when traversing tree through the child, sibling,
57 * or parent members of struct device_node.
59 DEFINE_RAW_SPINLOCK(devtree_lock
);
61 int of_n_addr_cells(struct device_node
*np
)
68 if (!of_property_read_u32(np
, "#address-cells", &cells
))
71 /* No #address-cells property for the root node */
72 return OF_ROOT_NODE_ADDR_CELLS_DEFAULT
;
74 EXPORT_SYMBOL(of_n_addr_cells
);
76 int of_n_size_cells(struct device_node
*np
)
83 if (!of_property_read_u32(np
, "#size-cells", &cells
))
86 /* No #size-cells property for the root node */
87 return OF_ROOT_NODE_SIZE_CELLS_DEFAULT
;
89 EXPORT_SYMBOL(of_n_size_cells
);
92 int __weak
of_node_to_nid(struct device_node
*np
)
98 void __init
of_core_init(void)
100 struct device_node
*np
;
102 /* Create the kset, and register existing nodes */
103 mutex_lock(&of_mutex
);
104 of_kset
= kset_create_and_add("devicetree", NULL
, firmware_kobj
);
106 mutex_unlock(&of_mutex
);
107 pr_err("failed to register existing nodes\n");
110 for_each_of_allnodes(np
)
111 __of_attach_node_sysfs(np
);
112 mutex_unlock(&of_mutex
);
114 /* Symlink in /proc as required by userspace ABI */
116 proc_symlink("device-tree", NULL
, "/sys/firmware/devicetree/base");
119 static struct property
*__of_find_property(const struct device_node
*np
,
120 const char *name
, int *lenp
)
127 for (pp
= np
->properties
; pp
; pp
= pp
->next
) {
128 if (of_prop_cmp(pp
->name
, name
) == 0) {
138 struct property
*of_find_property(const struct device_node
*np
,
145 raw_spin_lock_irqsave(&devtree_lock
, flags
);
146 pp
= __of_find_property(np
, name
, lenp
);
147 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
151 EXPORT_SYMBOL(of_find_property
);
153 struct device_node
*__of_find_all_nodes(struct device_node
*prev
)
155 struct device_node
*np
;
158 } else if (prev
->child
) {
161 /* Walk back up looking for a sibling, or the end of the structure */
163 while (np
->parent
&& !np
->sibling
)
165 np
= np
->sibling
; /* Might be null at the end of the tree */
171 * of_find_all_nodes - Get next node in global list
172 * @prev: Previous node or NULL to start iteration
173 * of_node_put() will be called on it
175 * Returns a node pointer with refcount incremented, use
176 * of_node_put() on it when done.
178 struct device_node
*of_find_all_nodes(struct device_node
*prev
)
180 struct device_node
*np
;
183 raw_spin_lock_irqsave(&devtree_lock
, flags
);
184 np
= __of_find_all_nodes(prev
);
187 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
190 EXPORT_SYMBOL(of_find_all_nodes
);
193 * Find a property with a given name for a given node
194 * and return the value.
196 const void *__of_get_property(const struct device_node
*np
,
197 const char *name
, int *lenp
)
199 struct property
*pp
= __of_find_property(np
, name
, lenp
);
201 return pp
? pp
->value
: NULL
;
205 * Find a property with a given name for a given node
206 * and return the value.
208 const void *of_get_property(const struct device_node
*np
, const char *name
,
211 struct property
*pp
= of_find_property(np
, name
, lenp
);
213 return pp
? pp
->value
: NULL
;
215 EXPORT_SYMBOL(of_get_property
);
218 * arch_match_cpu_phys_id - Match the given logical CPU and physical id
220 * @cpu: logical cpu index of a core/thread
221 * @phys_id: physical identifier of a core/thread
223 * CPU logical to physical index mapping is architecture specific.
224 * However this __weak function provides a default match of physical
225 * id to logical cpu index. phys_id provided here is usually values read
226 * from the device tree which must match the hardware internal registers.
228 * Returns true if the physical identifier and the logical cpu index
229 * correspond to the same core/thread, false otherwise.
231 bool __weak
arch_match_cpu_phys_id(int cpu
, u64 phys_id
)
233 return (u32
)phys_id
== cpu
;
237 * Checks if the given "prop_name" property holds the physical id of the
238 * core/thread corresponding to the logical cpu 'cpu'. If 'thread' is not
239 * NULL, local thread number within the core is returned in it.
241 static bool __of_find_n_match_cpu_property(struct device_node
*cpun
,
242 const char *prop_name
, int cpu
, unsigned int *thread
)
245 int ac
, prop_len
, tid
;
248 ac
= of_n_addr_cells(cpun
);
249 cell
= of_get_property(cpun
, prop_name
, &prop_len
);
252 prop_len
/= sizeof(*cell
) * ac
;
253 for (tid
= 0; tid
< prop_len
; tid
++) {
254 hwid
= of_read_number(cell
, ac
);
255 if (arch_match_cpu_phys_id(cpu
, hwid
)) {
266 * arch_find_n_match_cpu_physical_id - See if the given device node is
267 * for the cpu corresponding to logical cpu 'cpu'. Return true if so,
268 * else false. If 'thread' is non-NULL, the local thread number within the
269 * core is returned in it.
271 bool __weak
arch_find_n_match_cpu_physical_id(struct device_node
*cpun
,
272 int cpu
, unsigned int *thread
)
274 /* Check for non-standard "ibm,ppc-interrupt-server#s" property
275 * for thread ids on PowerPC. If it doesn't exist fallback to
276 * standard "reg" property.
278 if (IS_ENABLED(CONFIG_PPC
) &&
279 __of_find_n_match_cpu_property(cpun
,
280 "ibm,ppc-interrupt-server#s",
284 return __of_find_n_match_cpu_property(cpun
, "reg", cpu
, thread
);
288 * of_get_cpu_node - Get device node associated with the given logical CPU
290 * @cpu: CPU number(logical index) for which device node is required
291 * @thread: if not NULL, local thread number within the physical core is
294 * The main purpose of this function is to retrieve the device node for the
295 * given logical CPU index. It should be used to initialize the of_node in
296 * cpu device. Once of_node in cpu device is populated, all the further
297 * references can use that instead.
299 * CPU logical to physical index mapping is architecture specific and is built
300 * before booting secondary cores. This function uses arch_match_cpu_phys_id
301 * which can be overridden by architecture specific implementation.
303 * Returns a node pointer for the logical cpu with refcount incremented, use
304 * of_node_put() on it when done. Returns NULL if not found.
306 struct device_node
*of_get_cpu_node(int cpu
, unsigned int *thread
)
308 struct device_node
*cpun
;
310 for_each_node_by_type(cpun
, "cpu") {
311 if (arch_find_n_match_cpu_physical_id(cpun
, cpu
, thread
))
316 EXPORT_SYMBOL(of_get_cpu_node
);
319 * __of_device_is_compatible() - Check if the node matches given constraints
320 * @device: pointer to node
321 * @compat: required compatible string, NULL or "" for any match
322 * @type: required device_type value, NULL or "" for any match
323 * @name: required node name, NULL or "" for any match
325 * Checks if the given @compat, @type and @name strings match the
326 * properties of the given @device. A constraints can be skipped by
327 * passing NULL or an empty string as the constraint.
329 * Returns 0 for no match, and a positive integer on match. The return
330 * value is a relative score with larger values indicating better
331 * matches. The score is weighted for the most specific compatible value
332 * to get the highest score. Matching type is next, followed by matching
333 * name. Practically speaking, this results in the following priority
336 * 1. specific compatible && type && name
337 * 2. specific compatible && type
338 * 3. specific compatible && name
339 * 4. specific compatible
340 * 5. general compatible && type && name
341 * 6. general compatible && type
342 * 7. general compatible && name
343 * 8. general compatible
348 static int __of_device_is_compatible(const struct device_node
*device
,
349 const char *compat
, const char *type
, const char *name
)
351 struct property
*prop
;
353 int index
= 0, score
= 0;
355 /* Compatible match has highest priority */
356 if (compat
&& compat
[0]) {
357 prop
= __of_find_property(device
, "compatible", NULL
);
358 for (cp
= of_prop_next_string(prop
, NULL
); cp
;
359 cp
= of_prop_next_string(prop
, cp
), index
++) {
360 if (of_compat_cmp(cp
, compat
, strlen(compat
)) == 0) {
361 score
= INT_MAX
/2 - (index
<< 2);
369 /* Matching type is better than matching name */
370 if (type
&& type
[0]) {
371 if (!device
->type
|| of_node_cmp(type
, device
->type
))
376 /* Matching name is a bit better than not */
377 if (name
&& name
[0]) {
378 if (!device
->name
|| of_node_cmp(name
, device
->name
))
386 /** Checks if the given "compat" string matches one of the strings in
387 * the device's "compatible" property
389 int of_device_is_compatible(const struct device_node
*device
,
395 raw_spin_lock_irqsave(&devtree_lock
, flags
);
396 res
= __of_device_is_compatible(device
, compat
, NULL
, NULL
);
397 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
400 EXPORT_SYMBOL(of_device_is_compatible
);
402 /** Checks if the device is compatible with any of the entries in
403 * a NULL terminated array of strings. Returns the best match
406 int of_device_compatible_match(struct device_node
*device
,
407 const char *const *compat
)
409 unsigned int tmp
, score
= 0;
415 tmp
= of_device_is_compatible(device
, *compat
);
425 * of_machine_is_compatible - Test root of device tree for a given compatible value
426 * @compat: compatible string to look for in root node's compatible property.
428 * Returns a positive integer if the root node has the given value in its
429 * compatible property.
431 int of_machine_is_compatible(const char *compat
)
433 struct device_node
*root
;
436 root
= of_find_node_by_path("/");
438 rc
= of_device_is_compatible(root
, compat
);
443 EXPORT_SYMBOL(of_machine_is_compatible
);
446 * __of_device_is_available - check if a device is available for use
448 * @device: Node to check for availability, with locks already held
450 * Returns true if the status property is absent or set to "okay" or "ok",
453 static bool __of_device_is_available(const struct device_node
*device
)
461 status
= __of_get_property(device
, "status", &statlen
);
466 if (!strcmp(status
, "okay") || !strcmp(status
, "ok"))
474 * of_device_is_available - check if a device is available for use
476 * @device: Node to check for availability
478 * Returns true if the status property is absent or set to "okay" or "ok",
481 bool of_device_is_available(const struct device_node
*device
)
486 raw_spin_lock_irqsave(&devtree_lock
, flags
);
487 res
= __of_device_is_available(device
);
488 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
492 EXPORT_SYMBOL(of_device_is_available
);
495 * of_device_is_big_endian - check if a device has BE registers
497 * @device: Node to check for endianness
499 * Returns true if the device has a "big-endian" property, or if the kernel
500 * was compiled for BE *and* the device has a "native-endian" property.
501 * Returns false otherwise.
503 * Callers would nominally use ioread32be/iowrite32be if
504 * of_device_is_big_endian() == true, or readl/writel otherwise.
506 bool of_device_is_big_endian(const struct device_node
*device
)
508 if (of_property_read_bool(device
, "big-endian"))
510 if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN
) &&
511 of_property_read_bool(device
, "native-endian"))
515 EXPORT_SYMBOL(of_device_is_big_endian
);
518 * of_get_parent - Get a node's parent if any
519 * @node: Node to get parent
521 * Returns a node pointer with refcount incremented, use
522 * of_node_put() on it when done.
524 struct device_node
*of_get_parent(const struct device_node
*node
)
526 struct device_node
*np
;
532 raw_spin_lock_irqsave(&devtree_lock
, flags
);
533 np
= of_node_get(node
->parent
);
534 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
537 EXPORT_SYMBOL(of_get_parent
);
540 * of_get_next_parent - Iterate to a node's parent
541 * @node: Node to get parent of
543 * This is like of_get_parent() except that it drops the
544 * refcount on the passed node, making it suitable for iterating
545 * through a node's parents.
547 * Returns a node pointer with refcount incremented, use
548 * of_node_put() on it when done.
550 struct device_node
*of_get_next_parent(struct device_node
*node
)
552 struct device_node
*parent
;
558 raw_spin_lock_irqsave(&devtree_lock
, flags
);
559 parent
= of_node_get(node
->parent
);
561 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
564 EXPORT_SYMBOL(of_get_next_parent
);
566 static struct device_node
*__of_get_next_child(const struct device_node
*node
,
567 struct device_node
*prev
)
569 struct device_node
*next
;
574 next
= prev
? prev
->sibling
: node
->child
;
575 for (; next
; next
= next
->sibling
)
576 if (of_node_get(next
))
581 #define __for_each_child_of_node(parent, child) \
582 for (child = __of_get_next_child(parent, NULL); child != NULL; \
583 child = __of_get_next_child(parent, child))
586 * of_get_next_child - Iterate a node childs
588 * @prev: previous child of the parent node, or NULL to get first
590 * Returns a node pointer with refcount incremented, use of_node_put() on
591 * it when done. Returns NULL when prev is the last child. Decrements the
594 struct device_node
*of_get_next_child(const struct device_node
*node
,
595 struct device_node
*prev
)
597 struct device_node
*next
;
600 raw_spin_lock_irqsave(&devtree_lock
, flags
);
601 next
= __of_get_next_child(node
, prev
);
602 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
605 EXPORT_SYMBOL(of_get_next_child
);
608 * of_get_next_available_child - Find the next available child node
610 * @prev: previous child of the parent node, or NULL to get first
612 * This function is like of_get_next_child(), except that it
613 * automatically skips any disabled nodes (i.e. status = "disabled").
615 struct device_node
*of_get_next_available_child(const struct device_node
*node
,
616 struct device_node
*prev
)
618 struct device_node
*next
;
624 raw_spin_lock_irqsave(&devtree_lock
, flags
);
625 next
= prev
? prev
->sibling
: node
->child
;
626 for (; next
; next
= next
->sibling
) {
627 if (!__of_device_is_available(next
))
629 if (of_node_get(next
))
633 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
636 EXPORT_SYMBOL(of_get_next_available_child
);
639 * of_get_child_by_name - Find the child node by name for a given parent
641 * @name: child name to look for.
643 * This function looks for child node for given matching name
645 * Returns a node pointer if found, with refcount incremented, use
646 * of_node_put() on it when done.
647 * Returns NULL if node is not found.
649 struct device_node
*of_get_child_by_name(const struct device_node
*node
,
652 struct device_node
*child
;
654 for_each_child_of_node(node
, child
)
655 if (child
->name
&& (of_node_cmp(child
->name
, name
) == 0))
659 EXPORT_SYMBOL(of_get_child_by_name
);
661 struct device_node
*__of_find_node_by_path(struct device_node
*parent
,
664 struct device_node
*child
;
667 len
= strcspn(path
, "/:");
671 __for_each_child_of_node(parent
, child
) {
672 const char *name
= kbasename(child
->full_name
);
673 if (strncmp(path
, name
, len
) == 0 && (strlen(name
) == len
))
679 struct device_node
*__of_find_node_by_full_path(struct device_node
*node
,
682 const char *separator
= strchr(path
, ':');
684 while (node
&& *path
== '/') {
685 struct device_node
*tmp
= node
;
687 path
++; /* Increment past '/' delimiter */
688 node
= __of_find_node_by_path(node
, path
);
690 path
= strchrnul(path
, '/');
691 if (separator
&& separator
< path
)
698 * of_find_node_opts_by_path - Find a node matching a full OF path
699 * @path: Either the full path to match, or if the path does not
700 * start with '/', the name of a property of the /aliases
701 * node (an alias). In the case of an alias, the node
702 * matching the alias' value will be returned.
703 * @opts: Address of a pointer into which to store the start of
704 * an options string appended to the end of the path with
710 * foo/bar Valid alias + relative path
712 * Returns a node pointer with refcount incremented, use
713 * of_node_put() on it when done.
715 struct device_node
*of_find_node_opts_by_path(const char *path
, const char **opts
)
717 struct device_node
*np
= NULL
;
720 const char *separator
= strchr(path
, ':');
723 *opts
= separator
? separator
+ 1 : NULL
;
725 if (strcmp(path
, "/") == 0)
726 return of_node_get(of_root
);
728 /* The path could begin with an alias */
731 const char *p
= separator
;
734 p
= strchrnul(path
, '/');
737 /* of_aliases must not be NULL */
741 for_each_property_of_node(of_aliases
, pp
) {
742 if (strlen(pp
->name
) == len
&& !strncmp(pp
->name
, path
, len
)) {
743 np
= of_find_node_by_path(pp
->value
);
752 /* Step down the tree matching path components */
753 raw_spin_lock_irqsave(&devtree_lock
, flags
);
755 np
= of_node_get(of_root
);
756 np
= __of_find_node_by_full_path(np
, path
);
757 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
760 EXPORT_SYMBOL(of_find_node_opts_by_path
);
763 * of_find_node_by_name - Find a node by its "name" property
764 * @from: The node to start searching from or NULL; the node
765 * you pass will not be searched, only the next one
766 * will. Typically, you pass what the previous call
767 * returned. of_node_put() will be called on @from.
768 * @name: The name string to match against
770 * Returns a node pointer with refcount incremented, use
771 * of_node_put() on it when done.
773 struct device_node
*of_find_node_by_name(struct device_node
*from
,
776 struct device_node
*np
;
779 raw_spin_lock_irqsave(&devtree_lock
, flags
);
780 for_each_of_allnodes_from(from
, np
)
781 if (np
->name
&& (of_node_cmp(np
->name
, name
) == 0)
785 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
788 EXPORT_SYMBOL(of_find_node_by_name
);
791 * of_find_node_by_type - Find a node by its "device_type" property
792 * @from: The node to start searching from, or NULL to start searching
793 * the entire device tree. The node you pass will not be
794 * searched, only the next one will; typically, you pass
795 * what the previous call returned. of_node_put() will be
796 * called on from for you.
797 * @type: The type string to match against
799 * Returns a node pointer with refcount incremented, use
800 * of_node_put() on it when done.
802 struct device_node
*of_find_node_by_type(struct device_node
*from
,
805 struct device_node
*np
;
808 raw_spin_lock_irqsave(&devtree_lock
, flags
);
809 for_each_of_allnodes_from(from
, np
)
810 if (np
->type
&& (of_node_cmp(np
->type
, type
) == 0)
814 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
817 EXPORT_SYMBOL(of_find_node_by_type
);
820 * of_find_compatible_node - Find a node based on type and one of the
821 * tokens in its "compatible" property
822 * @from: The node to start searching from or NULL, the node
823 * you pass will not be searched, only the next one
824 * will; typically, you pass what the previous call
825 * returned. of_node_put() will be called on it
826 * @type: The type string to match "device_type" or NULL to ignore
827 * @compatible: The string to match to one of the tokens in the device
830 * Returns a node pointer with refcount incremented, use
831 * of_node_put() on it when done.
833 struct device_node
*of_find_compatible_node(struct device_node
*from
,
834 const char *type
, const char *compatible
)
836 struct device_node
*np
;
839 raw_spin_lock_irqsave(&devtree_lock
, flags
);
840 for_each_of_allnodes_from(from
, np
)
841 if (__of_device_is_compatible(np
, compatible
, type
, NULL
) &&
845 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
848 EXPORT_SYMBOL(of_find_compatible_node
);
851 * of_find_node_with_property - Find a node which has a property with
853 * @from: The node to start searching from or NULL, the node
854 * you pass will not be searched, only the next one
855 * will; typically, you pass what the previous call
856 * returned. of_node_put() will be called on it
857 * @prop_name: The name of the property to look for.
859 * Returns a node pointer with refcount incremented, use
860 * of_node_put() on it when done.
862 struct device_node
*of_find_node_with_property(struct device_node
*from
,
863 const char *prop_name
)
865 struct device_node
*np
;
869 raw_spin_lock_irqsave(&devtree_lock
, flags
);
870 for_each_of_allnodes_from(from
, np
) {
871 for (pp
= np
->properties
; pp
; pp
= pp
->next
) {
872 if (of_prop_cmp(pp
->name
, prop_name
) == 0) {
880 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
883 EXPORT_SYMBOL(of_find_node_with_property
);
886 const struct of_device_id
*__of_match_node(const struct of_device_id
*matches
,
887 const struct device_node
*node
)
889 const struct of_device_id
*best_match
= NULL
;
890 int score
, best_score
= 0;
895 for (; matches
->name
[0] || matches
->type
[0] || matches
->compatible
[0]; matches
++) {
896 score
= __of_device_is_compatible(node
, matches
->compatible
,
897 matches
->type
, matches
->name
);
898 if (score
> best_score
) {
899 best_match
= matches
;
908 * of_match_node - Tell if a device_node has a matching of_match structure
909 * @matches: array of of device match structures to search in
910 * @node: the of device structure to match against
912 * Low level utility function used by device matching.
914 const struct of_device_id
*of_match_node(const struct of_device_id
*matches
,
915 const struct device_node
*node
)
917 const struct of_device_id
*match
;
920 raw_spin_lock_irqsave(&devtree_lock
, flags
);
921 match
= __of_match_node(matches
, node
);
922 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
925 EXPORT_SYMBOL(of_match_node
);
928 * of_find_matching_node_and_match - Find a node based on an of_device_id
930 * @from: The node to start searching from or NULL, the node
931 * you pass will not be searched, only the next one
932 * will; typically, you pass what the previous call
933 * returned. of_node_put() will be called on it
934 * @matches: array of of device match structures to search in
935 * @match Updated to point at the matches entry which matched
937 * Returns a node pointer with refcount incremented, use
938 * of_node_put() on it when done.
940 struct device_node
*of_find_matching_node_and_match(struct device_node
*from
,
941 const struct of_device_id
*matches
,
942 const struct of_device_id
**match
)
944 struct device_node
*np
;
945 const struct of_device_id
*m
;
951 raw_spin_lock_irqsave(&devtree_lock
, flags
);
952 for_each_of_allnodes_from(from
, np
) {
953 m
= __of_match_node(matches
, np
);
954 if (m
&& of_node_get(np
)) {
961 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
964 EXPORT_SYMBOL(of_find_matching_node_and_match
);
967 * of_modalias_node - Lookup appropriate modalias for a device node
968 * @node: pointer to a device tree node
969 * @modalias: Pointer to buffer that modalias value will be copied into
970 * @len: Length of modalias value
972 * Based on the value of the compatible property, this routine will attempt
973 * to choose an appropriate modalias value for a particular device tree node.
974 * It does this by stripping the manufacturer prefix (as delimited by a ',')
975 * from the first entry in the compatible list property.
977 * This routine returns 0 on success, <0 on failure.
979 int of_modalias_node(struct device_node
*node
, char *modalias
, int len
)
981 const char *compatible
, *p
;
984 compatible
= of_get_property(node
, "compatible", &cplen
);
985 if (!compatible
|| strlen(compatible
) > cplen
)
987 p
= strchr(compatible
, ',');
988 strlcpy(modalias
, p
? p
+ 1 : compatible
, len
);
991 EXPORT_SYMBOL_GPL(of_modalias_node
);
994 * of_find_node_by_phandle - Find a node given a phandle
995 * @handle: phandle of the node to find
997 * Returns a node pointer with refcount incremented, use
998 * of_node_put() on it when done.
1000 struct device_node
*of_find_node_by_phandle(phandle handle
)
1002 struct device_node
*np
;
1003 unsigned long flags
;
1008 raw_spin_lock_irqsave(&devtree_lock
, flags
);
1009 for_each_of_allnodes(np
)
1010 if (np
->phandle
== handle
)
1013 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
1016 EXPORT_SYMBOL(of_find_node_by_phandle
);
1018 void of_print_phandle_args(const char *msg
, const struct of_phandle_args
*args
)
1021 printk("%s %pOF", msg
, args
->np
);
1022 for (i
= 0; i
< args
->args_count
; i
++) {
1023 const char delim
= i
? ',' : ':';
1025 pr_cont("%c%08x", delim
, args
->args
[i
]);
1030 int of_phandle_iterator_init(struct of_phandle_iterator
*it
,
1031 const struct device_node
*np
,
1032 const char *list_name
,
1033 const char *cells_name
,
1039 memset(it
, 0, sizeof(*it
));
1041 list
= of_get_property(np
, list_name
, &size
);
1045 it
->cells_name
= cells_name
;
1046 it
->cell_count
= cell_count
;
1048 it
->list_end
= list
+ size
/ sizeof(*list
);
1049 it
->phandle_end
= list
;
1054 EXPORT_SYMBOL_GPL(of_phandle_iterator_init
);
1056 int of_phandle_iterator_next(struct of_phandle_iterator
*it
)
1061 of_node_put(it
->node
);
1065 if (!it
->cur
|| it
->phandle_end
>= it
->list_end
)
1068 it
->cur
= it
->phandle_end
;
1070 /* If phandle is 0, then it is an empty entry with no arguments. */
1071 it
->phandle
= be32_to_cpup(it
->cur
++);
1076 * Find the provider node and parse the #*-cells property to
1077 * determine the argument length.
1079 it
->node
= of_find_node_by_phandle(it
->phandle
);
1081 if (it
->cells_name
) {
1083 pr_err("%pOF: could not find phandle\n",
1088 if (of_property_read_u32(it
->node
, it
->cells_name
,
1090 pr_err("%pOF: could not get %s for %pOF\n",
1097 count
= it
->cell_count
;
1101 * Make sure that the arguments actually fit in the remaining
1102 * property data length
1104 if (it
->cur
+ count
> it
->list_end
) {
1105 pr_err("%pOF: arguments longer than property\n",
1111 it
->phandle_end
= it
->cur
+ count
;
1112 it
->cur_count
= count
;
1118 of_node_put(it
->node
);
1124 EXPORT_SYMBOL_GPL(of_phandle_iterator_next
);
1126 int of_phandle_iterator_args(struct of_phandle_iterator
*it
,
1132 count
= it
->cur_count
;
1134 if (WARN_ON(size
< count
))
1137 for (i
= 0; i
< count
; i
++)
1138 args
[i
] = be32_to_cpup(it
->cur
++);
1143 static int __of_parse_phandle_with_args(const struct device_node
*np
,
1144 const char *list_name
,
1145 const char *cells_name
,
1146 int cell_count
, int index
,
1147 struct of_phandle_args
*out_args
)
1149 struct of_phandle_iterator it
;
1150 int rc
, cur_index
= 0;
1152 /* Loop over the phandles until all the requested entry is found */
1153 of_for_each_phandle(&it
, rc
, np
, list_name
, cells_name
, cell_count
) {
1155 * All of the error cases bail out of the loop, so at
1156 * this point, the parsing is successful. If the requested
1157 * index matches, then fill the out_args structure and return,
1158 * or return -ENOENT for an empty entry.
1161 if (cur_index
== index
) {
1168 c
= of_phandle_iterator_args(&it
,
1171 out_args
->np
= it
.node
;
1172 out_args
->args_count
= c
;
1174 of_node_put(it
.node
);
1177 /* Found it! return success */
1185 * Unlock node before returning result; will be one of:
1186 * -ENOENT : index is for empty phandle
1187 * -EINVAL : parsing error on data
1191 of_node_put(it
.node
);
1196 * of_parse_phandle - Resolve a phandle property to a device_node pointer
1197 * @np: Pointer to device node holding phandle property
1198 * @phandle_name: Name of property holding a phandle value
1199 * @index: For properties holding a table of phandles, this is the index into
1202 * Returns the device_node pointer with refcount incremented. Use
1203 * of_node_put() on it when done.
1205 struct device_node
*of_parse_phandle(const struct device_node
*np
,
1206 const char *phandle_name
, int index
)
1208 struct of_phandle_args args
;
1213 if (__of_parse_phandle_with_args(np
, phandle_name
, NULL
, 0,
1219 EXPORT_SYMBOL(of_parse_phandle
);
1222 * of_parse_phandle_with_args() - Find a node pointed by phandle in a list
1223 * @np: pointer to a device tree node containing a list
1224 * @list_name: property name that contains a list
1225 * @cells_name: property name that specifies phandles' arguments count
1226 * @index: index of a phandle to parse out
1227 * @out_args: optional pointer to output arguments structure (will be filled)
1229 * This function is useful to parse lists of phandles and their arguments.
1230 * Returns 0 on success and fills out_args, on error returns appropriate
1233 * Caller is responsible to call of_node_put() on the returned out_args->np
1239 * #list-cells = <2>;
1243 * #list-cells = <1>;
1247 * list = <&phandle1 1 2 &phandle2 3>;
1250 * To get a device_node of the `node2' node you may call this:
1251 * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
1253 int of_parse_phandle_with_args(const struct device_node
*np
, const char *list_name
,
1254 const char *cells_name
, int index
,
1255 struct of_phandle_args
*out_args
)
1259 return __of_parse_phandle_with_args(np
, list_name
, cells_name
, 0,
1262 EXPORT_SYMBOL(of_parse_phandle_with_args
);
1265 * of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list
1266 * @np: pointer to a device tree node containing a list
1267 * @list_name: property name that contains a list
1268 * @cell_count: number of argument cells following the phandle
1269 * @index: index of a phandle to parse out
1270 * @out_args: optional pointer to output arguments structure (will be filled)
1272 * This function is useful to parse lists of phandles and their arguments.
1273 * Returns 0 on success and fills out_args, on error returns appropriate
1276 * Caller is responsible to call of_node_put() on the returned out_args->np
1288 * list = <&phandle1 0 2 &phandle2 2 3>;
1291 * To get a device_node of the `node2' node you may call this:
1292 * of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args);
1294 int of_parse_phandle_with_fixed_args(const struct device_node
*np
,
1295 const char *list_name
, int cell_count
,
1296 int index
, struct of_phandle_args
*out_args
)
1300 return __of_parse_phandle_with_args(np
, list_name
, NULL
, cell_count
,
1303 EXPORT_SYMBOL(of_parse_phandle_with_fixed_args
);
1306 * of_count_phandle_with_args() - Find the number of phandles references in a property
1307 * @np: pointer to a device tree node containing a list
1308 * @list_name: property name that contains a list
1309 * @cells_name: property name that specifies phandles' arguments count
1311 * Returns the number of phandle + argument tuples within a property. It
1312 * is a typical pattern to encode a list of phandle and variable
1313 * arguments into a single property. The number of arguments is encoded
1314 * by a property in the phandle-target node. For example, a gpios
1315 * property would contain a list of GPIO specifies consisting of a
1316 * phandle and 1 or more arguments. The number of arguments are
1317 * determined by the #gpio-cells property in the node pointed to by the
1320 int of_count_phandle_with_args(const struct device_node
*np
, const char *list_name
,
1321 const char *cells_name
)
1323 struct of_phandle_iterator it
;
1324 int rc
, cur_index
= 0;
1326 rc
= of_phandle_iterator_init(&it
, np
, list_name
, cells_name
, 0);
1330 while ((rc
= of_phandle_iterator_next(&it
)) == 0)
1338 EXPORT_SYMBOL(of_count_phandle_with_args
);
1341 * __of_add_property - Add a property to a node without lock operations
1343 int __of_add_property(struct device_node
*np
, struct property
*prop
)
1345 struct property
**next
;
1348 next
= &np
->properties
;
1350 if (strcmp(prop
->name
, (*next
)->name
) == 0)
1351 /* duplicate ! don't insert it */
1354 next
= &(*next
)->next
;
1362 * of_add_property - Add a property to a node
1364 int of_add_property(struct device_node
*np
, struct property
*prop
)
1366 unsigned long flags
;
1369 mutex_lock(&of_mutex
);
1371 raw_spin_lock_irqsave(&devtree_lock
, flags
);
1372 rc
= __of_add_property(np
, prop
);
1373 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
1376 __of_add_property_sysfs(np
, prop
);
1378 mutex_unlock(&of_mutex
);
1381 of_property_notify(OF_RECONFIG_ADD_PROPERTY
, np
, prop
, NULL
);
1386 int __of_remove_property(struct device_node
*np
, struct property
*prop
)
1388 struct property
**next
;
1390 for (next
= &np
->properties
; *next
; next
= &(*next
)->next
) {
1397 /* found the node */
1399 prop
->next
= np
->deadprops
;
1400 np
->deadprops
= prop
;
1406 * of_remove_property - Remove a property from a node.
1408 * Note that we don't actually remove it, since we have given out
1409 * who-knows-how-many pointers to the data using get-property.
1410 * Instead we just move the property to the "dead properties"
1411 * list, so it won't be found any more.
1413 int of_remove_property(struct device_node
*np
, struct property
*prop
)
1415 unsigned long flags
;
1421 mutex_lock(&of_mutex
);
1423 raw_spin_lock_irqsave(&devtree_lock
, flags
);
1424 rc
= __of_remove_property(np
, prop
);
1425 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
1428 __of_remove_property_sysfs(np
, prop
);
1430 mutex_unlock(&of_mutex
);
1433 of_property_notify(OF_RECONFIG_REMOVE_PROPERTY
, np
, prop
, NULL
);
1438 int __of_update_property(struct device_node
*np
, struct property
*newprop
,
1439 struct property
**oldpropp
)
1441 struct property
**next
, *oldprop
;
1443 for (next
= &np
->properties
; *next
; next
= &(*next
)->next
) {
1444 if (of_prop_cmp((*next
)->name
, newprop
->name
) == 0)
1447 *oldpropp
= oldprop
= *next
;
1450 /* replace the node */
1451 newprop
->next
= oldprop
->next
;
1453 oldprop
->next
= np
->deadprops
;
1454 np
->deadprops
= oldprop
;
1457 newprop
->next
= NULL
;
1465 * of_update_property - Update a property in a node, if the property does
1466 * not exist, add it.
1468 * Note that we don't actually remove it, since we have given out
1469 * who-knows-how-many pointers to the data using get-property.
1470 * Instead we just move the property to the "dead properties" list,
1471 * and add the new property to the property list
1473 int of_update_property(struct device_node
*np
, struct property
*newprop
)
1475 struct property
*oldprop
;
1476 unsigned long flags
;
1482 mutex_lock(&of_mutex
);
1484 raw_spin_lock_irqsave(&devtree_lock
, flags
);
1485 rc
= __of_update_property(np
, newprop
, &oldprop
);
1486 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
1489 __of_update_property_sysfs(np
, newprop
, oldprop
);
1491 mutex_unlock(&of_mutex
);
1494 of_property_notify(OF_RECONFIG_UPDATE_PROPERTY
, np
, newprop
, oldprop
);
1499 static void of_alias_add(struct alias_prop
*ap
, struct device_node
*np
,
1500 int id
, const char *stem
, int stem_len
)
1504 strncpy(ap
->stem
, stem
, stem_len
);
1505 ap
->stem
[stem_len
] = 0;
1506 list_add_tail(&ap
->link
, &aliases_lookup
);
1507 pr_debug("adding DT alias:%s: stem=%s id=%i node=%pOF\n",
1508 ap
->alias
, ap
->stem
, ap
->id
, np
);
1512 * of_alias_scan - Scan all properties of the 'aliases' node
1514 * The function scans all the properties of the 'aliases' node and populates
1515 * the global lookup table with the properties. It returns the
1516 * number of alias properties found, or an error code in case of failure.
1518 * @dt_alloc: An allocator that provides a virtual address to memory
1519 * for storing the resulting tree
1521 void of_alias_scan(void * (*dt_alloc
)(u64 size
, u64 align
))
1523 struct property
*pp
;
1525 of_aliases
= of_find_node_by_path("/aliases");
1526 of_chosen
= of_find_node_by_path("/chosen");
1527 if (of_chosen
== NULL
)
1528 of_chosen
= of_find_node_by_path("/chosen@0");
1531 /* linux,stdout-path and /aliases/stdout are for legacy compatibility */
1532 const char *name
= NULL
;
1534 if (of_property_read_string(of_chosen
, "stdout-path", &name
))
1535 of_property_read_string(of_chosen
, "linux,stdout-path",
1537 if (IS_ENABLED(CONFIG_PPC
) && !name
)
1538 of_property_read_string(of_aliases
, "stdout", &name
);
1540 of_stdout
= of_find_node_opts_by_path(name
, &of_stdout_options
);
1546 for_each_property_of_node(of_aliases
, pp
) {
1547 const char *start
= pp
->name
;
1548 const char *end
= start
+ strlen(start
);
1549 struct device_node
*np
;
1550 struct alias_prop
*ap
;
1553 /* Skip those we do not want to proceed */
1554 if (!strcmp(pp
->name
, "name") ||
1555 !strcmp(pp
->name
, "phandle") ||
1556 !strcmp(pp
->name
, "linux,phandle"))
1559 np
= of_find_node_by_path(pp
->value
);
1563 /* walk the alias backwards to extract the id and work out
1564 * the 'stem' string */
1565 while (isdigit(*(end
-1)) && end
> start
)
1569 if (kstrtoint(end
, 10, &id
) < 0)
1572 /* Allocate an alias_prop with enough space for the stem */
1573 ap
= dt_alloc(sizeof(*ap
) + len
+ 1, __alignof__(*ap
));
1576 memset(ap
, 0, sizeof(*ap
) + len
+ 1);
1578 of_alias_add(ap
, np
, id
, start
, len
);
1583 * of_alias_get_id - Get alias id for the given device_node
1584 * @np: Pointer to the given device_node
1585 * @stem: Alias stem of the given device_node
1587 * The function travels the lookup table to get the alias id for the given
1588 * device_node and alias stem. It returns the alias id if found.
1590 int of_alias_get_id(struct device_node
*np
, const char *stem
)
1592 struct alias_prop
*app
;
1595 mutex_lock(&of_mutex
);
1596 list_for_each_entry(app
, &aliases_lookup
, link
) {
1597 if (strcmp(app
->stem
, stem
) != 0)
1600 if (np
== app
->np
) {
1605 mutex_unlock(&of_mutex
);
1609 EXPORT_SYMBOL_GPL(of_alias_get_id
);
1612 * of_alias_get_highest_id - Get highest alias id for the given stem
1613 * @stem: Alias stem to be examined
1615 * The function travels the lookup table to get the highest alias id for the
1616 * given alias stem. It returns the alias id if found.
1618 int of_alias_get_highest_id(const char *stem
)
1620 struct alias_prop
*app
;
1623 mutex_lock(&of_mutex
);
1624 list_for_each_entry(app
, &aliases_lookup
, link
) {
1625 if (strcmp(app
->stem
, stem
) != 0)
1631 mutex_unlock(&of_mutex
);
1635 EXPORT_SYMBOL_GPL(of_alias_get_highest_id
);
1638 * of_console_check() - Test and setup console for DT setup
1639 * @dn - Pointer to device node
1640 * @name - Name to use for preferred console without index. ex. "ttyS"
1641 * @index - Index to use for preferred console.
1643 * Check if the given device node matches the stdout-path property in the
1644 * /chosen node. If it does then register it as the preferred console and return
1645 * TRUE. Otherwise return FALSE.
1647 bool of_console_check(struct device_node
*dn
, char *name
, int index
)
1649 if (!dn
|| dn
!= of_stdout
|| console_set_on_cmdline
)
1653 * XXX: cast `options' to char pointer to suppress complication
1654 * warnings: printk, UART and console drivers expect char pointer.
1656 return !add_preferred_console(name
, index
, (char *)of_stdout_options
);
1658 EXPORT_SYMBOL_GPL(of_console_check
);
1661 * of_find_next_cache_node - Find a node's subsidiary cache
1662 * @np: node of type "cpu" or "cache"
1664 * Returns a node pointer with refcount incremented, use
1665 * of_node_put() on it when done. Caller should hold a reference
1668 struct device_node
*of_find_next_cache_node(const struct device_node
*np
)
1670 struct device_node
*child
, *cache_node
;
1672 cache_node
= of_parse_phandle(np
, "l2-cache", 0);
1674 cache_node
= of_parse_phandle(np
, "next-level-cache", 0);
1679 /* OF on pmac has nodes instead of properties named "l2-cache"
1680 * beneath CPU nodes.
1682 if (!strcmp(np
->type
, "cpu"))
1683 for_each_child_of_node(np
, child
)
1684 if (!strcmp(child
->type
, "cache"))
1691 * of_find_last_cache_level - Find the level at which the last cache is
1692 * present for the given logical cpu
1694 * @cpu: cpu number(logical index) for which the last cache level is needed
1696 * Returns the the level at which the last cache is present. It is exactly
1697 * same as the total number of cache levels for the given logical cpu.
1699 int of_find_last_cache_level(unsigned int cpu
)
1701 u32 cache_level
= 0;
1702 struct device_node
*prev
= NULL
, *np
= of_cpu_device_node_get(cpu
);
1707 np
= of_find_next_cache_node(np
);
1710 of_property_read_u32(prev
, "cache-level", &cache_level
);