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 #ifndef CONFIG_OF_DYNAMIC
99 static void of_node_release(struct kobject
*kobj
)
101 /* Without CONFIG_OF_DYNAMIC, no nodes gets freed */
103 #endif /* CONFIG_OF_DYNAMIC */
105 struct kobj_type of_node_ktype
= {
106 .release
= of_node_release
,
109 static ssize_t
of_node_property_read(struct file
*filp
, struct kobject
*kobj
,
110 struct bin_attribute
*bin_attr
, char *buf
,
111 loff_t offset
, size_t count
)
113 struct property
*pp
= container_of(bin_attr
, struct property
, attr
);
114 return memory_read_from_buffer(buf
, count
, &offset
, pp
->value
, pp
->length
);
117 /* always return newly allocated name, caller must free after use */
118 static const char *safe_name(struct kobject
*kobj
, const char *orig_name
)
120 const char *name
= orig_name
;
121 struct kernfs_node
*kn
;
124 /* don't be a hero. After 16 tries give up */
125 while (i
< 16 && (kn
= sysfs_get_dirent(kobj
->sd
, name
))) {
127 if (name
!= orig_name
)
129 name
= kasprintf(GFP_KERNEL
, "%s#%i", orig_name
, ++i
);
132 if (name
== orig_name
) {
133 name
= kstrdup(orig_name
, GFP_KERNEL
);
135 pr_warn("Duplicate name in %s, renamed to \"%s\"\n",
136 kobject_name(kobj
), name
);
141 int __of_add_property_sysfs(struct device_node
*np
, struct property
*pp
)
145 /* Important: Don't leak passwords */
146 bool secure
= strncmp(pp
->name
, "security-", 9) == 0;
148 if (!IS_ENABLED(CONFIG_SYSFS
))
151 if (!of_kset
|| !of_node_is_attached(np
))
154 sysfs_bin_attr_init(&pp
->attr
);
155 pp
->attr
.attr
.name
= safe_name(&np
->kobj
, pp
->name
);
156 pp
->attr
.attr
.mode
= secure
? 0400 : 0444;
157 pp
->attr
.size
= secure
? 0 : pp
->length
;
158 pp
->attr
.read
= of_node_property_read
;
160 rc
= sysfs_create_bin_file(&np
->kobj
, &pp
->attr
);
161 WARN(rc
, "error adding attribute %s to node %pOF\n", pp
->name
, np
);
165 int __of_attach_node_sysfs(struct device_node
*np
)
168 struct kobject
*parent
;
172 if (!IS_ENABLED(CONFIG_SYSFS
))
178 np
->kobj
.kset
= of_kset
;
180 /* Nodes without parents are new top level trees */
181 name
= safe_name(&of_kset
->kobj
, "base");
184 name
= safe_name(&np
->parent
->kobj
, kbasename(np
->full_name
));
185 parent
= &np
->parent
->kobj
;
189 rc
= kobject_add(&np
->kobj
, parent
, "%s", name
);
194 for_each_property_of_node(np
, pp
)
195 __of_add_property_sysfs(np
, pp
);
200 void __init
of_core_init(void)
202 struct device_node
*np
;
204 /* Create the kset, and register existing nodes */
205 mutex_lock(&of_mutex
);
206 of_kset
= kset_create_and_add("devicetree", NULL
, firmware_kobj
);
208 mutex_unlock(&of_mutex
);
209 pr_err("failed to register existing nodes\n");
212 for_each_of_allnodes(np
)
213 __of_attach_node_sysfs(np
);
214 mutex_unlock(&of_mutex
);
216 /* Symlink in /proc as required by userspace ABI */
218 proc_symlink("device-tree", NULL
, "/sys/firmware/devicetree/base");
221 static struct property
*__of_find_property(const struct device_node
*np
,
222 const char *name
, int *lenp
)
229 for (pp
= np
->properties
; pp
; pp
= pp
->next
) {
230 if (of_prop_cmp(pp
->name
, name
) == 0) {
240 struct property
*of_find_property(const struct device_node
*np
,
247 raw_spin_lock_irqsave(&devtree_lock
, flags
);
248 pp
= __of_find_property(np
, name
, lenp
);
249 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
253 EXPORT_SYMBOL(of_find_property
);
255 struct device_node
*__of_find_all_nodes(struct device_node
*prev
)
257 struct device_node
*np
;
260 } else if (prev
->child
) {
263 /* Walk back up looking for a sibling, or the end of the structure */
265 while (np
->parent
&& !np
->sibling
)
267 np
= np
->sibling
; /* Might be null at the end of the tree */
273 * of_find_all_nodes - Get next node in global list
274 * @prev: Previous node or NULL to start iteration
275 * of_node_put() will be called on it
277 * Returns a node pointer with refcount incremented, use
278 * of_node_put() on it when done.
280 struct device_node
*of_find_all_nodes(struct device_node
*prev
)
282 struct device_node
*np
;
285 raw_spin_lock_irqsave(&devtree_lock
, flags
);
286 np
= __of_find_all_nodes(prev
);
289 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
292 EXPORT_SYMBOL(of_find_all_nodes
);
295 * Find a property with a given name for a given node
296 * and return the value.
298 const void *__of_get_property(const struct device_node
*np
,
299 const char *name
, int *lenp
)
301 struct property
*pp
= __of_find_property(np
, name
, lenp
);
303 return pp
? pp
->value
: NULL
;
307 * Find a property with a given name for a given node
308 * and return the value.
310 const void *of_get_property(const struct device_node
*np
, const char *name
,
313 struct property
*pp
= of_find_property(np
, name
, lenp
);
315 return pp
? pp
->value
: NULL
;
317 EXPORT_SYMBOL(of_get_property
);
320 * arch_match_cpu_phys_id - Match the given logical CPU and physical id
322 * @cpu: logical cpu index of a core/thread
323 * @phys_id: physical identifier of a core/thread
325 * CPU logical to physical index mapping is architecture specific.
326 * However this __weak function provides a default match of physical
327 * id to logical cpu index. phys_id provided here is usually values read
328 * from the device tree which must match the hardware internal registers.
330 * Returns true if the physical identifier and the logical cpu index
331 * correspond to the same core/thread, false otherwise.
333 bool __weak
arch_match_cpu_phys_id(int cpu
, u64 phys_id
)
335 return (u32
)phys_id
== cpu
;
339 * Checks if the given "prop_name" property holds the physical id of the
340 * core/thread corresponding to the logical cpu 'cpu'. If 'thread' is not
341 * NULL, local thread number within the core is returned in it.
343 static bool __of_find_n_match_cpu_property(struct device_node
*cpun
,
344 const char *prop_name
, int cpu
, unsigned int *thread
)
347 int ac
, prop_len
, tid
;
350 ac
= of_n_addr_cells(cpun
);
351 cell
= of_get_property(cpun
, prop_name
, &prop_len
);
354 prop_len
/= sizeof(*cell
) * ac
;
355 for (tid
= 0; tid
< prop_len
; tid
++) {
356 hwid
= of_read_number(cell
, ac
);
357 if (arch_match_cpu_phys_id(cpu
, hwid
)) {
368 * arch_find_n_match_cpu_physical_id - See if the given device node is
369 * for the cpu corresponding to logical cpu 'cpu'. Return true if so,
370 * else false. If 'thread' is non-NULL, the local thread number within the
371 * core is returned in it.
373 bool __weak
arch_find_n_match_cpu_physical_id(struct device_node
*cpun
,
374 int cpu
, unsigned int *thread
)
376 /* Check for non-standard "ibm,ppc-interrupt-server#s" property
377 * for thread ids on PowerPC. If it doesn't exist fallback to
378 * standard "reg" property.
380 if (IS_ENABLED(CONFIG_PPC
) &&
381 __of_find_n_match_cpu_property(cpun
,
382 "ibm,ppc-interrupt-server#s",
386 return __of_find_n_match_cpu_property(cpun
, "reg", cpu
, thread
);
390 * of_get_cpu_node - Get device node associated with the given logical CPU
392 * @cpu: CPU number(logical index) for which device node is required
393 * @thread: if not NULL, local thread number within the physical core is
396 * The main purpose of this function is to retrieve the device node for the
397 * given logical CPU index. It should be used to initialize the of_node in
398 * cpu device. Once of_node in cpu device is populated, all the further
399 * references can use that instead.
401 * CPU logical to physical index mapping is architecture specific and is built
402 * before booting secondary cores. This function uses arch_match_cpu_phys_id
403 * which can be overridden by architecture specific implementation.
405 * Returns a node pointer for the logical cpu with refcount incremented, use
406 * of_node_put() on it when done. Returns NULL if not found.
408 struct device_node
*of_get_cpu_node(int cpu
, unsigned int *thread
)
410 struct device_node
*cpun
;
412 for_each_node_by_type(cpun
, "cpu") {
413 if (arch_find_n_match_cpu_physical_id(cpun
, cpu
, thread
))
418 EXPORT_SYMBOL(of_get_cpu_node
);
421 * __of_device_is_compatible() - Check if the node matches given constraints
422 * @device: pointer to node
423 * @compat: required compatible string, NULL or "" for any match
424 * @type: required device_type value, NULL or "" for any match
425 * @name: required node name, NULL or "" for any match
427 * Checks if the given @compat, @type and @name strings match the
428 * properties of the given @device. A constraints can be skipped by
429 * passing NULL or an empty string as the constraint.
431 * Returns 0 for no match, and a positive integer on match. The return
432 * value is a relative score with larger values indicating better
433 * matches. The score is weighted for the most specific compatible value
434 * to get the highest score. Matching type is next, followed by matching
435 * name. Practically speaking, this results in the following priority
438 * 1. specific compatible && type && name
439 * 2. specific compatible && type
440 * 3. specific compatible && name
441 * 4. specific compatible
442 * 5. general compatible && type && name
443 * 6. general compatible && type
444 * 7. general compatible && name
445 * 8. general compatible
450 static int __of_device_is_compatible(const struct device_node
*device
,
451 const char *compat
, const char *type
, const char *name
)
453 struct property
*prop
;
455 int index
= 0, score
= 0;
457 /* Compatible match has highest priority */
458 if (compat
&& compat
[0]) {
459 prop
= __of_find_property(device
, "compatible", NULL
);
460 for (cp
= of_prop_next_string(prop
, NULL
); cp
;
461 cp
= of_prop_next_string(prop
, cp
), index
++) {
462 if (of_compat_cmp(cp
, compat
, strlen(compat
)) == 0) {
463 score
= INT_MAX
/2 - (index
<< 2);
471 /* Matching type is better than matching name */
472 if (type
&& type
[0]) {
473 if (!device
->type
|| of_node_cmp(type
, device
->type
))
478 /* Matching name is a bit better than not */
479 if (name
&& name
[0]) {
480 if (!device
->name
|| of_node_cmp(name
, device
->name
))
488 /** Checks if the given "compat" string matches one of the strings in
489 * the device's "compatible" property
491 int of_device_is_compatible(const struct device_node
*device
,
497 raw_spin_lock_irqsave(&devtree_lock
, flags
);
498 res
= __of_device_is_compatible(device
, compat
, NULL
, NULL
);
499 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
502 EXPORT_SYMBOL(of_device_is_compatible
);
504 /** Checks if the device is compatible with any of the entries in
505 * a NULL terminated array of strings. Returns the best match
508 int of_device_compatible_match(struct device_node
*device
,
509 const char *const *compat
)
511 unsigned int tmp
, score
= 0;
517 tmp
= of_device_is_compatible(device
, *compat
);
527 * of_machine_is_compatible - Test root of device tree for a given compatible value
528 * @compat: compatible string to look for in root node's compatible property.
530 * Returns a positive integer if the root node has the given value in its
531 * compatible property.
533 int of_machine_is_compatible(const char *compat
)
535 struct device_node
*root
;
538 root
= of_find_node_by_path("/");
540 rc
= of_device_is_compatible(root
, compat
);
545 EXPORT_SYMBOL(of_machine_is_compatible
);
548 * __of_device_is_available - check if a device is available for use
550 * @device: Node to check for availability, with locks already held
552 * Returns true if the status property is absent or set to "okay" or "ok",
555 static bool __of_device_is_available(const struct device_node
*device
)
563 status
= __of_get_property(device
, "status", &statlen
);
568 if (!strcmp(status
, "okay") || !strcmp(status
, "ok"))
576 * of_device_is_available - check if a device is available for use
578 * @device: Node to check for availability
580 * Returns true if the status property is absent or set to "okay" or "ok",
583 bool of_device_is_available(const struct device_node
*device
)
588 raw_spin_lock_irqsave(&devtree_lock
, flags
);
589 res
= __of_device_is_available(device
);
590 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
594 EXPORT_SYMBOL(of_device_is_available
);
597 * of_device_is_big_endian - check if a device has BE registers
599 * @device: Node to check for endianness
601 * Returns true if the device has a "big-endian" property, or if the kernel
602 * was compiled for BE *and* the device has a "native-endian" property.
603 * Returns false otherwise.
605 * Callers would nominally use ioread32be/iowrite32be if
606 * of_device_is_big_endian() == true, or readl/writel otherwise.
608 bool of_device_is_big_endian(const struct device_node
*device
)
610 if (of_property_read_bool(device
, "big-endian"))
612 if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN
) &&
613 of_property_read_bool(device
, "native-endian"))
617 EXPORT_SYMBOL(of_device_is_big_endian
);
620 * of_get_parent - Get a node's parent if any
621 * @node: Node to get parent
623 * Returns a node pointer with refcount incremented, use
624 * of_node_put() on it when done.
626 struct device_node
*of_get_parent(const struct device_node
*node
)
628 struct device_node
*np
;
634 raw_spin_lock_irqsave(&devtree_lock
, flags
);
635 np
= of_node_get(node
->parent
);
636 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
639 EXPORT_SYMBOL(of_get_parent
);
642 * of_get_next_parent - Iterate to a node's parent
643 * @node: Node to get parent of
645 * This is like of_get_parent() except that it drops the
646 * refcount on the passed node, making it suitable for iterating
647 * through a node's parents.
649 * Returns a node pointer with refcount incremented, use
650 * of_node_put() on it when done.
652 struct device_node
*of_get_next_parent(struct device_node
*node
)
654 struct device_node
*parent
;
660 raw_spin_lock_irqsave(&devtree_lock
, flags
);
661 parent
= of_node_get(node
->parent
);
663 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
666 EXPORT_SYMBOL(of_get_next_parent
);
668 static struct device_node
*__of_get_next_child(const struct device_node
*node
,
669 struct device_node
*prev
)
671 struct device_node
*next
;
676 next
= prev
? prev
->sibling
: node
->child
;
677 for (; next
; next
= next
->sibling
)
678 if (of_node_get(next
))
683 #define __for_each_child_of_node(parent, child) \
684 for (child = __of_get_next_child(parent, NULL); child != NULL; \
685 child = __of_get_next_child(parent, child))
688 * of_get_next_child - Iterate a node childs
690 * @prev: previous child of the parent node, or NULL to get first
692 * Returns a node pointer with refcount incremented, use of_node_put() on
693 * it when done. Returns NULL when prev is the last child. Decrements the
696 struct device_node
*of_get_next_child(const struct device_node
*node
,
697 struct device_node
*prev
)
699 struct device_node
*next
;
702 raw_spin_lock_irqsave(&devtree_lock
, flags
);
703 next
= __of_get_next_child(node
, prev
);
704 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
707 EXPORT_SYMBOL(of_get_next_child
);
710 * of_get_next_available_child - Find the next available child node
712 * @prev: previous child of the parent node, or NULL to get first
714 * This function is like of_get_next_child(), except that it
715 * automatically skips any disabled nodes (i.e. status = "disabled").
717 struct device_node
*of_get_next_available_child(const struct device_node
*node
,
718 struct device_node
*prev
)
720 struct device_node
*next
;
726 raw_spin_lock_irqsave(&devtree_lock
, flags
);
727 next
= prev
? prev
->sibling
: node
->child
;
728 for (; next
; next
= next
->sibling
) {
729 if (!__of_device_is_available(next
))
731 if (of_node_get(next
))
735 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
738 EXPORT_SYMBOL(of_get_next_available_child
);
741 * of_get_child_by_name - Find the child node by name for a given parent
743 * @name: child name to look for.
745 * This function looks for child node for given matching name
747 * Returns a node pointer if found, with refcount incremented, use
748 * of_node_put() on it when done.
749 * Returns NULL if node is not found.
751 struct device_node
*of_get_child_by_name(const struct device_node
*node
,
754 struct device_node
*child
;
756 for_each_child_of_node(node
, child
)
757 if (child
->name
&& (of_node_cmp(child
->name
, name
) == 0))
761 EXPORT_SYMBOL(of_get_child_by_name
);
763 static struct device_node
*__of_find_node_by_path(struct device_node
*parent
,
766 struct device_node
*child
;
769 len
= strcspn(path
, "/:");
773 __for_each_child_of_node(parent
, child
) {
774 const char *name
= kbasename(child
->full_name
);
775 if (strncmp(path
, name
, len
) == 0 && (strlen(name
) == len
))
781 struct device_node
*__of_find_node_by_full_path(struct device_node
*node
,
784 const char *separator
= strchr(path
, ':');
786 while (node
&& *path
== '/') {
787 struct device_node
*tmp
= node
;
789 path
++; /* Increment past '/' delimiter */
790 node
= __of_find_node_by_path(node
, path
);
792 path
= strchrnul(path
, '/');
793 if (separator
&& separator
< path
)
800 * of_find_node_opts_by_path - Find a node matching a full OF path
801 * @path: Either the full path to match, or if the path does not
802 * start with '/', the name of a property of the /aliases
803 * node (an alias). In the case of an alias, the node
804 * matching the alias' value will be returned.
805 * @opts: Address of a pointer into which to store the start of
806 * an options string appended to the end of the path with
812 * foo/bar Valid alias + relative path
814 * Returns a node pointer with refcount incremented, use
815 * of_node_put() on it when done.
817 struct device_node
*of_find_node_opts_by_path(const char *path
, const char **opts
)
819 struct device_node
*np
= NULL
;
822 const char *separator
= strchr(path
, ':');
825 *opts
= separator
? separator
+ 1 : NULL
;
827 if (strcmp(path
, "/") == 0)
828 return of_node_get(of_root
);
830 /* The path could begin with an alias */
833 const char *p
= separator
;
836 p
= strchrnul(path
, '/');
839 /* of_aliases must not be NULL */
843 for_each_property_of_node(of_aliases
, pp
) {
844 if (strlen(pp
->name
) == len
&& !strncmp(pp
->name
, path
, len
)) {
845 np
= of_find_node_by_path(pp
->value
);
854 /* Step down the tree matching path components */
855 raw_spin_lock_irqsave(&devtree_lock
, flags
);
857 np
= of_node_get(of_root
);
858 np
= __of_find_node_by_full_path(np
, path
);
859 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
862 EXPORT_SYMBOL(of_find_node_opts_by_path
);
865 * of_find_node_by_name - Find a node by its "name" property
866 * @from: The node to start searching from or NULL, the node
867 * you pass will not be searched, only the next one
868 * will; typically, you pass what the previous call
869 * returned. of_node_put() will be called on it
870 * @name: The name string to match against
872 * Returns a node pointer with refcount incremented, use
873 * of_node_put() on it when done.
875 struct device_node
*of_find_node_by_name(struct device_node
*from
,
878 struct device_node
*np
;
881 raw_spin_lock_irqsave(&devtree_lock
, flags
);
882 for_each_of_allnodes_from(from
, np
)
883 if (np
->name
&& (of_node_cmp(np
->name
, name
) == 0)
887 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
890 EXPORT_SYMBOL(of_find_node_by_name
);
893 * of_find_node_by_type - Find a node by its "device_type" property
894 * @from: The node to start searching from, or NULL to start searching
895 * the entire device tree. The node you pass will not be
896 * searched, only the next one will; typically, you pass
897 * what the previous call returned. of_node_put() will be
898 * called on from for you.
899 * @type: The type string to match against
901 * Returns a node pointer with refcount incremented, use
902 * of_node_put() on it when done.
904 struct device_node
*of_find_node_by_type(struct device_node
*from
,
907 struct device_node
*np
;
910 raw_spin_lock_irqsave(&devtree_lock
, flags
);
911 for_each_of_allnodes_from(from
, np
)
912 if (np
->type
&& (of_node_cmp(np
->type
, type
) == 0)
916 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
919 EXPORT_SYMBOL(of_find_node_by_type
);
922 * of_find_compatible_node - Find a node based on type and one of the
923 * tokens in its "compatible" property
924 * @from: The node to start searching from or NULL, the node
925 * you pass will not be searched, only the next one
926 * will; typically, you pass what the previous call
927 * returned. of_node_put() will be called on it
928 * @type: The type string to match "device_type" or NULL to ignore
929 * @compatible: The string to match to one of the tokens in the device
932 * Returns a node pointer with refcount incremented, use
933 * of_node_put() on it when done.
935 struct device_node
*of_find_compatible_node(struct device_node
*from
,
936 const char *type
, const char *compatible
)
938 struct device_node
*np
;
941 raw_spin_lock_irqsave(&devtree_lock
, flags
);
942 for_each_of_allnodes_from(from
, np
)
943 if (__of_device_is_compatible(np
, compatible
, type
, NULL
) &&
947 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
950 EXPORT_SYMBOL(of_find_compatible_node
);
953 * of_find_node_with_property - Find a node which has a property with
955 * @from: The node to start searching from or NULL, the node
956 * you pass will not be searched, only the next one
957 * will; typically, you pass what the previous call
958 * returned. of_node_put() will be called on it
959 * @prop_name: The name of the property to look for.
961 * Returns a node pointer with refcount incremented, use
962 * of_node_put() on it when done.
964 struct device_node
*of_find_node_with_property(struct device_node
*from
,
965 const char *prop_name
)
967 struct device_node
*np
;
971 raw_spin_lock_irqsave(&devtree_lock
, flags
);
972 for_each_of_allnodes_from(from
, np
) {
973 for (pp
= np
->properties
; pp
; pp
= pp
->next
) {
974 if (of_prop_cmp(pp
->name
, prop_name
) == 0) {
982 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
985 EXPORT_SYMBOL(of_find_node_with_property
);
988 const struct of_device_id
*__of_match_node(const struct of_device_id
*matches
,
989 const struct device_node
*node
)
991 const struct of_device_id
*best_match
= NULL
;
992 int score
, best_score
= 0;
997 for (; matches
->name
[0] || matches
->type
[0] || matches
->compatible
[0]; matches
++) {
998 score
= __of_device_is_compatible(node
, matches
->compatible
,
999 matches
->type
, matches
->name
);
1000 if (score
> best_score
) {
1001 best_match
= matches
;
1010 * of_match_node - Tell if a device_node has a matching of_match structure
1011 * @matches: array of of device match structures to search in
1012 * @node: the of device structure to match against
1014 * Low level utility function used by device matching.
1016 const struct of_device_id
*of_match_node(const struct of_device_id
*matches
,
1017 const struct device_node
*node
)
1019 const struct of_device_id
*match
;
1020 unsigned long flags
;
1022 raw_spin_lock_irqsave(&devtree_lock
, flags
);
1023 match
= __of_match_node(matches
, node
);
1024 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
1027 EXPORT_SYMBOL(of_match_node
);
1030 * of_find_matching_node_and_match - Find a node based on an of_device_id
1032 * @from: The node to start searching from or NULL, the node
1033 * you pass will not be searched, only the next one
1034 * will; typically, you pass what the previous call
1035 * returned. of_node_put() will be called on it
1036 * @matches: array of of device match structures to search in
1037 * @match Updated to point at the matches entry which matched
1039 * Returns a node pointer with refcount incremented, use
1040 * of_node_put() on it when done.
1042 struct device_node
*of_find_matching_node_and_match(struct device_node
*from
,
1043 const struct of_device_id
*matches
,
1044 const struct of_device_id
**match
)
1046 struct device_node
*np
;
1047 const struct of_device_id
*m
;
1048 unsigned long flags
;
1053 raw_spin_lock_irqsave(&devtree_lock
, flags
);
1054 for_each_of_allnodes_from(from
, np
) {
1055 m
= __of_match_node(matches
, np
);
1056 if (m
&& of_node_get(np
)) {
1063 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
1066 EXPORT_SYMBOL(of_find_matching_node_and_match
);
1069 * of_modalias_node - Lookup appropriate modalias for a device node
1070 * @node: pointer to a device tree node
1071 * @modalias: Pointer to buffer that modalias value will be copied into
1072 * @len: Length of modalias value
1074 * Based on the value of the compatible property, this routine will attempt
1075 * to choose an appropriate modalias value for a particular device tree node.
1076 * It does this by stripping the manufacturer prefix (as delimited by a ',')
1077 * from the first entry in the compatible list property.
1079 * This routine returns 0 on success, <0 on failure.
1081 int of_modalias_node(struct device_node
*node
, char *modalias
, int len
)
1083 const char *compatible
, *p
;
1086 compatible
= of_get_property(node
, "compatible", &cplen
);
1087 if (!compatible
|| strlen(compatible
) > cplen
)
1089 p
= strchr(compatible
, ',');
1090 strlcpy(modalias
, p
? p
+ 1 : compatible
, len
);
1093 EXPORT_SYMBOL_GPL(of_modalias_node
);
1096 * of_find_node_by_phandle - Find a node given a phandle
1097 * @handle: phandle of the node to find
1099 * Returns a node pointer with refcount incremented, use
1100 * of_node_put() on it when done.
1102 struct device_node
*of_find_node_by_phandle(phandle handle
)
1104 struct device_node
*np
;
1105 unsigned long flags
;
1110 raw_spin_lock_irqsave(&devtree_lock
, flags
);
1111 for_each_of_allnodes(np
)
1112 if (np
->phandle
== handle
)
1115 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
1118 EXPORT_SYMBOL(of_find_node_by_phandle
);
1120 void of_print_phandle_args(const char *msg
, const struct of_phandle_args
*args
)
1123 printk("%s %pOF", msg
, args
->np
);
1124 for (i
= 0; i
< args
->args_count
; i
++) {
1125 const char delim
= i
? ',' : ':';
1127 pr_cont("%c%08x", delim
, args
->args
[i
]);
1132 int of_phandle_iterator_init(struct of_phandle_iterator
*it
,
1133 const struct device_node
*np
,
1134 const char *list_name
,
1135 const char *cells_name
,
1141 memset(it
, 0, sizeof(*it
));
1143 list
= of_get_property(np
, list_name
, &size
);
1147 it
->cells_name
= cells_name
;
1148 it
->cell_count
= cell_count
;
1150 it
->list_end
= list
+ size
/ sizeof(*list
);
1151 it
->phandle_end
= list
;
1156 EXPORT_SYMBOL_GPL(of_phandle_iterator_init
);
1158 int of_phandle_iterator_next(struct of_phandle_iterator
*it
)
1163 of_node_put(it
->node
);
1167 if (!it
->cur
|| it
->phandle_end
>= it
->list_end
)
1170 it
->cur
= it
->phandle_end
;
1172 /* If phandle is 0, then it is an empty entry with no arguments. */
1173 it
->phandle
= be32_to_cpup(it
->cur
++);
1178 * Find the provider node and parse the #*-cells property to
1179 * determine the argument length.
1181 it
->node
= of_find_node_by_phandle(it
->phandle
);
1183 if (it
->cells_name
) {
1185 pr_err("%pOF: could not find phandle\n",
1190 if (of_property_read_u32(it
->node
, it
->cells_name
,
1192 pr_err("%pOF: could not get %s for %pOF\n",
1199 count
= it
->cell_count
;
1203 * Make sure that the arguments actually fit in the remaining
1204 * property data length
1206 if (it
->cur
+ count
> it
->list_end
) {
1207 pr_err("%pOF: arguments longer than property\n",
1213 it
->phandle_end
= it
->cur
+ count
;
1214 it
->cur_count
= count
;
1220 of_node_put(it
->node
);
1226 EXPORT_SYMBOL_GPL(of_phandle_iterator_next
);
1228 int of_phandle_iterator_args(struct of_phandle_iterator
*it
,
1234 count
= it
->cur_count
;
1236 if (WARN_ON(size
< count
))
1239 for (i
= 0; i
< count
; i
++)
1240 args
[i
] = be32_to_cpup(it
->cur
++);
1245 static int __of_parse_phandle_with_args(const struct device_node
*np
,
1246 const char *list_name
,
1247 const char *cells_name
,
1248 int cell_count
, int index
,
1249 struct of_phandle_args
*out_args
)
1251 struct of_phandle_iterator it
;
1252 int rc
, cur_index
= 0;
1254 /* Loop over the phandles until all the requested entry is found */
1255 of_for_each_phandle(&it
, rc
, np
, list_name
, cells_name
, cell_count
) {
1257 * All of the error cases bail out of the loop, so at
1258 * this point, the parsing is successful. If the requested
1259 * index matches, then fill the out_args structure and return,
1260 * or return -ENOENT for an empty entry.
1263 if (cur_index
== index
) {
1270 c
= of_phandle_iterator_args(&it
,
1273 out_args
->np
= it
.node
;
1274 out_args
->args_count
= c
;
1276 of_node_put(it
.node
);
1279 /* Found it! return success */
1287 * Unlock node before returning result; will be one of:
1288 * -ENOENT : index is for empty phandle
1289 * -EINVAL : parsing error on data
1293 of_node_put(it
.node
);
1298 * of_parse_phandle - Resolve a phandle property to a device_node pointer
1299 * @np: Pointer to device node holding phandle property
1300 * @phandle_name: Name of property holding a phandle value
1301 * @index: For properties holding a table of phandles, this is the index into
1304 * Returns the device_node pointer with refcount incremented. Use
1305 * of_node_put() on it when done.
1307 struct device_node
*of_parse_phandle(const struct device_node
*np
,
1308 const char *phandle_name
, int index
)
1310 struct of_phandle_args args
;
1315 if (__of_parse_phandle_with_args(np
, phandle_name
, NULL
, 0,
1321 EXPORT_SYMBOL(of_parse_phandle
);
1324 * of_parse_phandle_with_args() - Find a node pointed by phandle in a list
1325 * @np: pointer to a device tree node containing a list
1326 * @list_name: property name that contains a list
1327 * @cells_name: property name that specifies phandles' arguments count
1328 * @index: index of a phandle to parse out
1329 * @out_args: optional pointer to output arguments structure (will be filled)
1331 * This function is useful to parse lists of phandles and their arguments.
1332 * Returns 0 on success and fills out_args, on error returns appropriate
1335 * Caller is responsible to call of_node_put() on the returned out_args->np
1341 * #list-cells = <2>;
1345 * #list-cells = <1>;
1349 * list = <&phandle1 1 2 &phandle2 3>;
1352 * To get a device_node of the `node2' node you may call this:
1353 * of_parse_phandle_with_args(node3, "list", "#list-cells", 1, &args);
1355 int of_parse_phandle_with_args(const struct device_node
*np
, const char *list_name
,
1356 const char *cells_name
, int index
,
1357 struct of_phandle_args
*out_args
)
1361 return __of_parse_phandle_with_args(np
, list_name
, cells_name
, 0,
1364 EXPORT_SYMBOL(of_parse_phandle_with_args
);
1367 * of_parse_phandle_with_fixed_args() - Find a node pointed by phandle in a list
1368 * @np: pointer to a device tree node containing a list
1369 * @list_name: property name that contains a list
1370 * @cell_count: number of argument cells following the phandle
1371 * @index: index of a phandle to parse out
1372 * @out_args: optional pointer to output arguments structure (will be filled)
1374 * This function is useful to parse lists of phandles and their arguments.
1375 * Returns 0 on success and fills out_args, on error returns appropriate
1378 * Caller is responsible to call of_node_put() on the returned out_args->np
1390 * list = <&phandle1 0 2 &phandle2 2 3>;
1393 * To get a device_node of the `node2' node you may call this:
1394 * of_parse_phandle_with_fixed_args(node3, "list", 2, 1, &args);
1396 int of_parse_phandle_with_fixed_args(const struct device_node
*np
,
1397 const char *list_name
, int cell_count
,
1398 int index
, struct of_phandle_args
*out_args
)
1402 return __of_parse_phandle_with_args(np
, list_name
, NULL
, cell_count
,
1405 EXPORT_SYMBOL(of_parse_phandle_with_fixed_args
);
1408 * of_count_phandle_with_args() - Find the number of phandles references in a property
1409 * @np: pointer to a device tree node containing a list
1410 * @list_name: property name that contains a list
1411 * @cells_name: property name that specifies phandles' arguments count
1413 * Returns the number of phandle + argument tuples within a property. It
1414 * is a typical pattern to encode a list of phandle and variable
1415 * arguments into a single property. The number of arguments is encoded
1416 * by a property in the phandle-target node. For example, a gpios
1417 * property would contain a list of GPIO specifies consisting of a
1418 * phandle and 1 or more arguments. The number of arguments are
1419 * determined by the #gpio-cells property in the node pointed to by the
1422 int of_count_phandle_with_args(const struct device_node
*np
, const char *list_name
,
1423 const char *cells_name
)
1425 struct of_phandle_iterator it
;
1426 int rc
, cur_index
= 0;
1428 rc
= of_phandle_iterator_init(&it
, np
, list_name
, cells_name
, 0);
1432 while ((rc
= of_phandle_iterator_next(&it
)) == 0)
1440 EXPORT_SYMBOL(of_count_phandle_with_args
);
1443 * __of_add_property - Add a property to a node without lock operations
1445 int __of_add_property(struct device_node
*np
, struct property
*prop
)
1447 struct property
**next
;
1450 next
= &np
->properties
;
1452 if (strcmp(prop
->name
, (*next
)->name
) == 0)
1453 /* duplicate ! don't insert it */
1456 next
= &(*next
)->next
;
1464 * of_add_property - Add a property to a node
1466 int of_add_property(struct device_node
*np
, struct property
*prop
)
1468 unsigned long flags
;
1471 mutex_lock(&of_mutex
);
1473 raw_spin_lock_irqsave(&devtree_lock
, flags
);
1474 rc
= __of_add_property(np
, prop
);
1475 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
1478 __of_add_property_sysfs(np
, prop
);
1480 mutex_unlock(&of_mutex
);
1483 of_property_notify(OF_RECONFIG_ADD_PROPERTY
, np
, prop
, NULL
);
1488 int __of_remove_property(struct device_node
*np
, struct property
*prop
)
1490 struct property
**next
;
1492 for (next
= &np
->properties
; *next
; next
= &(*next
)->next
) {
1499 /* found the node */
1501 prop
->next
= np
->deadprops
;
1502 np
->deadprops
= prop
;
1507 void __of_sysfs_remove_bin_file(struct device_node
*np
, struct property
*prop
)
1509 sysfs_remove_bin_file(&np
->kobj
, &prop
->attr
);
1510 kfree(prop
->attr
.attr
.name
);
1513 void __of_remove_property_sysfs(struct device_node
*np
, struct property
*prop
)
1515 if (!IS_ENABLED(CONFIG_SYSFS
))
1518 /* at early boot, bail here and defer setup to of_init() */
1519 if (of_kset
&& of_node_is_attached(np
))
1520 __of_sysfs_remove_bin_file(np
, prop
);
1524 * of_remove_property - Remove a property from a node.
1526 * Note that we don't actually remove it, since we have given out
1527 * who-knows-how-many pointers to the data using get-property.
1528 * Instead we just move the property to the "dead properties"
1529 * list, so it won't be found any more.
1531 int of_remove_property(struct device_node
*np
, struct property
*prop
)
1533 unsigned long flags
;
1539 mutex_lock(&of_mutex
);
1541 raw_spin_lock_irqsave(&devtree_lock
, flags
);
1542 rc
= __of_remove_property(np
, prop
);
1543 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
1546 __of_remove_property_sysfs(np
, prop
);
1548 mutex_unlock(&of_mutex
);
1551 of_property_notify(OF_RECONFIG_REMOVE_PROPERTY
, np
, prop
, NULL
);
1556 int __of_update_property(struct device_node
*np
, struct property
*newprop
,
1557 struct property
**oldpropp
)
1559 struct property
**next
, *oldprop
;
1561 for (next
= &np
->properties
; *next
; next
= &(*next
)->next
) {
1562 if (of_prop_cmp((*next
)->name
, newprop
->name
) == 0)
1565 *oldpropp
= oldprop
= *next
;
1568 /* replace the node */
1569 newprop
->next
= oldprop
->next
;
1571 oldprop
->next
= np
->deadprops
;
1572 np
->deadprops
= oldprop
;
1575 newprop
->next
= NULL
;
1582 void __of_update_property_sysfs(struct device_node
*np
, struct property
*newprop
,
1583 struct property
*oldprop
)
1585 if (!IS_ENABLED(CONFIG_SYSFS
))
1588 /* At early boot, bail out and defer setup to of_init() */
1593 __of_sysfs_remove_bin_file(np
, oldprop
);
1594 __of_add_property_sysfs(np
, newprop
);
1598 * of_update_property - Update a property in a node, if the property does
1599 * not exist, add it.
1601 * Note that we don't actually remove it, since we have given out
1602 * who-knows-how-many pointers to the data using get-property.
1603 * Instead we just move the property to the "dead properties" list,
1604 * and add the new property to the property list
1606 int of_update_property(struct device_node
*np
, struct property
*newprop
)
1608 struct property
*oldprop
;
1609 unsigned long flags
;
1615 mutex_lock(&of_mutex
);
1617 raw_spin_lock_irqsave(&devtree_lock
, flags
);
1618 rc
= __of_update_property(np
, newprop
, &oldprop
);
1619 raw_spin_unlock_irqrestore(&devtree_lock
, flags
);
1622 __of_update_property_sysfs(np
, newprop
, oldprop
);
1624 mutex_unlock(&of_mutex
);
1627 of_property_notify(OF_RECONFIG_UPDATE_PROPERTY
, np
, newprop
, oldprop
);
1632 static void of_alias_add(struct alias_prop
*ap
, struct device_node
*np
,
1633 int id
, const char *stem
, int stem_len
)
1637 strncpy(ap
->stem
, stem
, stem_len
);
1638 ap
->stem
[stem_len
] = 0;
1639 list_add_tail(&ap
->link
, &aliases_lookup
);
1640 pr_debug("adding DT alias:%s: stem=%s id=%i node=%pOF\n",
1641 ap
->alias
, ap
->stem
, ap
->id
, np
);
1645 * of_alias_scan - Scan all properties of the 'aliases' node
1647 * The function scans all the properties of the 'aliases' node and populates
1648 * the global lookup table with the properties. It returns the
1649 * number of alias properties found, or an error code in case of failure.
1651 * @dt_alloc: An allocator that provides a virtual address to memory
1652 * for storing the resulting tree
1654 void of_alias_scan(void * (*dt_alloc
)(u64 size
, u64 align
))
1656 struct property
*pp
;
1658 of_aliases
= of_find_node_by_path("/aliases");
1659 of_chosen
= of_find_node_by_path("/chosen");
1660 if (of_chosen
== NULL
)
1661 of_chosen
= of_find_node_by_path("/chosen@0");
1664 /* linux,stdout-path and /aliases/stdout are for legacy compatibility */
1665 const char *name
= NULL
;
1667 if (of_property_read_string(of_chosen
, "stdout-path", &name
))
1668 of_property_read_string(of_chosen
, "linux,stdout-path",
1670 if (IS_ENABLED(CONFIG_PPC
) && !name
)
1671 of_property_read_string(of_aliases
, "stdout", &name
);
1673 of_stdout
= of_find_node_opts_by_path(name
, &of_stdout_options
);
1679 for_each_property_of_node(of_aliases
, pp
) {
1680 const char *start
= pp
->name
;
1681 const char *end
= start
+ strlen(start
);
1682 struct device_node
*np
;
1683 struct alias_prop
*ap
;
1686 /* Skip those we do not want to proceed */
1687 if (!strcmp(pp
->name
, "name") ||
1688 !strcmp(pp
->name
, "phandle") ||
1689 !strcmp(pp
->name
, "linux,phandle"))
1692 np
= of_find_node_by_path(pp
->value
);
1696 /* walk the alias backwards to extract the id and work out
1697 * the 'stem' string */
1698 while (isdigit(*(end
-1)) && end
> start
)
1702 if (kstrtoint(end
, 10, &id
) < 0)
1705 /* Allocate an alias_prop with enough space for the stem */
1706 ap
= dt_alloc(sizeof(*ap
) + len
+ 1, __alignof__(*ap
));
1709 memset(ap
, 0, sizeof(*ap
) + len
+ 1);
1711 of_alias_add(ap
, np
, id
, start
, len
);
1716 * of_alias_get_id - Get alias id for the given device_node
1717 * @np: Pointer to the given device_node
1718 * @stem: Alias stem of the given device_node
1720 * The function travels the lookup table to get the alias id for the given
1721 * device_node and alias stem. It returns the alias id if found.
1723 int of_alias_get_id(struct device_node
*np
, const char *stem
)
1725 struct alias_prop
*app
;
1728 mutex_lock(&of_mutex
);
1729 list_for_each_entry(app
, &aliases_lookup
, link
) {
1730 if (strcmp(app
->stem
, stem
) != 0)
1733 if (np
== app
->np
) {
1738 mutex_unlock(&of_mutex
);
1742 EXPORT_SYMBOL_GPL(of_alias_get_id
);
1745 * of_alias_get_highest_id - Get highest alias id for the given stem
1746 * @stem: Alias stem to be examined
1748 * The function travels the lookup table to get the highest alias id for the
1749 * given alias stem. It returns the alias id if found.
1751 int of_alias_get_highest_id(const char *stem
)
1753 struct alias_prop
*app
;
1756 mutex_lock(&of_mutex
);
1757 list_for_each_entry(app
, &aliases_lookup
, link
) {
1758 if (strcmp(app
->stem
, stem
) != 0)
1764 mutex_unlock(&of_mutex
);
1768 EXPORT_SYMBOL_GPL(of_alias_get_highest_id
);
1771 * of_console_check() - Test and setup console for DT setup
1772 * @dn - Pointer to device node
1773 * @name - Name to use for preferred console without index. ex. "ttyS"
1774 * @index - Index to use for preferred console.
1776 * Check if the given device node matches the stdout-path property in the
1777 * /chosen node. If it does then register it as the preferred console and return
1778 * TRUE. Otherwise return FALSE.
1780 bool of_console_check(struct device_node
*dn
, char *name
, int index
)
1782 if (!dn
|| dn
!= of_stdout
|| console_set_on_cmdline
)
1786 * XXX: cast `options' to char pointer to suppress complication
1787 * warnings: printk, UART and console drivers expect char pointer.
1789 return !add_preferred_console(name
, index
, (char *)of_stdout_options
);
1791 EXPORT_SYMBOL_GPL(of_console_check
);
1794 * of_find_next_cache_node - Find a node's subsidiary cache
1795 * @np: node of type "cpu" or "cache"
1797 * Returns a node pointer with refcount incremented, use
1798 * of_node_put() on it when done. Caller should hold a reference
1801 struct device_node
*of_find_next_cache_node(const struct device_node
*np
)
1803 struct device_node
*child
, *cache_node
;
1805 cache_node
= of_parse_phandle(np
, "l2-cache", 0);
1807 cache_node
= of_parse_phandle(np
, "next-level-cache", 0);
1812 /* OF on pmac has nodes instead of properties named "l2-cache"
1813 * beneath CPU nodes.
1815 if (!strcmp(np
->type
, "cpu"))
1816 for_each_child_of_node(np
, child
)
1817 if (!strcmp(child
->type
, "cache"))
1824 * of_find_last_cache_level - Find the level at which the last cache is
1825 * present for the given logical cpu
1827 * @cpu: cpu number(logical index) for which the last cache level is needed
1829 * Returns the the level at which the last cache is present. It is exactly
1830 * same as the total number of cache levels for the given logical cpu.
1832 int of_find_last_cache_level(unsigned int cpu
)
1834 u32 cache_level
= 0;
1835 struct device_node
*prev
= NULL
, *np
= of_cpu_device_node_get(cpu
);
1840 np
= of_find_next_cache_node(np
);
1843 of_property_read_u32(prev
, "cache-level", &cache_level
);