2 * Originally from Linux v4.9
3 * Paul Mackerras August 1996.
4 * Copyright (C) 1996-2005 Paul Mackerras.
6 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
7 * {engebret|bergner}@us.ibm.com
9 * Adapted for sparc and sparc64 by David S. Miller davem@davemloft.net
11 * Reconsolidated from arch/x/kernel/prom.c by Stephen Rothwell and
15 * Copyright (c) 2017 Google, Inc
17 * This file follows drivers/of/base.c with functions in the same order as the
20 * SPDX-License-Identifier: GPL-2.0+
25 #include <dm/of_access.h>
26 #include <linux/ctype.h>
27 #include <linux/err.h>
28 #include <linux/ioport.h>
30 DECLARE_GLOBAL_DATA_PTR
;
32 /* list of struct alias_prop aliases */
33 LIST_HEAD(aliases_lookup
);
36 static struct device_node
*of_aliases
;
39 static struct device_node
*of_chosen
;
41 /* node pointed to by the stdout-path alias */
42 static struct device_node
*of_stdout
;
44 /* pointer to options given after the alias (separated by :) or NULL if none */
45 static const char *of_stdout_options
;
48 * struct alias_prop - Alias property in 'aliases' node
50 * The structure represents one alias property of 'aliases' node as
51 * an entry in aliases_lookup list.
53 * @link: List node to link the structure in aliases_lookup list
54 * @alias: Alias property name
55 * @np: Pointer to device_node that the alias stands for
56 * @id: Index value from end of alias name
57 * @stem: Alias string without the index
60 struct list_head link
;
62 struct device_node
*np
;
67 int of_n_addr_cells(const struct device_node
*np
)
74 ip
= of_get_property(np
, "#address-cells", NULL
);
76 return be32_to_cpup(ip
);
79 /* No #address-cells property for the root node */
80 return OF_ROOT_NODE_ADDR_CELLS_DEFAULT
;
83 int of_n_size_cells(const struct device_node
*np
)
90 ip
= of_get_property(np
, "#size-cells", NULL
);
92 return be32_to_cpup(ip
);
95 /* No #size-cells property for the root node */
96 return OF_ROOT_NODE_SIZE_CELLS_DEFAULT
;
99 int of_simple_addr_cells(const struct device_node
*np
)
103 ip
= of_get_property(np
, "#address-cells", NULL
);
105 return be32_to_cpup(ip
);
107 /* Return a default of 2 to match fdt_address_cells()*/
111 int of_simple_size_cells(const struct device_node
*np
)
115 ip
= of_get_property(np
, "#size-cells", NULL
);
117 return be32_to_cpup(ip
);
119 /* Return a default of 2 to match fdt_size_cells()*/
123 struct property
*of_find_property(const struct device_node
*np
,
124 const char *name
, int *lenp
)
131 for (pp
= np
->properties
; pp
; pp
= pp
->next
) {
132 if (strcmp(pp
->name
, name
) == 0) {
139 *lenp
= -FDT_ERR_NOTFOUND
;
144 struct device_node
*of_find_all_nodes(struct device_node
*prev
)
146 struct device_node
*np
;
150 } else if (prev
->child
) {
154 * Walk back up looking for a sibling, or the end of the
158 while (np
->parent
&& !np
->sibling
)
160 np
= np
->sibling
; /* Might be null at the end of the tree */
166 const void *of_get_property(const struct device_node
*np
, const char *name
,
169 struct property
*pp
= of_find_property(np
, name
, lenp
);
171 return pp
? pp
->value
: NULL
;
174 static const char *of_prop_next_string(struct property
*prop
, const char *cur
)
176 const void *curv
= cur
;
184 curv
+= strlen(cur
) + 1;
185 if (curv
>= prop
->value
+ prop
->length
)
191 int of_device_is_compatible(const struct device_node
*device
,
192 const char *compat
, const char *type
,
195 struct property
*prop
;
197 int index
= 0, score
= 0;
199 /* Compatible match has highest priority */
200 if (compat
&& compat
[0]) {
201 prop
= of_find_property(device
, "compatible", NULL
);
202 for (cp
= of_prop_next_string(prop
, NULL
); cp
;
203 cp
= of_prop_next_string(prop
, cp
), index
++) {
204 if (of_compat_cmp(cp
, compat
, strlen(compat
)) == 0) {
205 score
= INT_MAX
/2 - (index
<< 2);
213 /* Matching type is better than matching name */
214 if (type
&& type
[0]) {
215 if (!device
->type
|| of_node_cmp(type
, device
->type
))
220 /* Matching name is a bit better than not */
221 if (name
&& name
[0]) {
222 if (!device
->name
|| of_node_cmp(name
, device
->name
))
230 bool of_device_is_available(const struct device_node
*device
)
238 status
= of_get_property(device
, "status", &statlen
);
243 if (!strcmp(status
, "okay"))
250 struct device_node
*of_get_parent(const struct device_node
*node
)
252 const struct device_node
*np
;
257 np
= of_node_get(node
->parent
);
259 return (struct device_node
*)np
;
262 static struct device_node
*__of_get_next_child(const struct device_node
*node
,
263 struct device_node
*prev
)
265 struct device_node
*next
;
270 next
= prev
? prev
->sibling
: node
->child
;
272 * coverity[dead_error_line : FALSE]
273 * Dead code here since our current implementation of of_node_get()
274 * always returns NULL (Coverity CID 163245). But we leave it as is
275 * since we may want to implement get/put later.
277 for (; next
; next
= next
->sibling
)
278 if (of_node_get(next
))
284 #define __for_each_child_of_node(parent, child) \
285 for (child = __of_get_next_child(parent, NULL); child != NULL; \
286 child = __of_get_next_child(parent, child))
288 static struct device_node
*__of_find_node_by_path(struct device_node
*parent
,
291 struct device_node
*child
;
294 len
= strcspn(path
, "/:");
298 __for_each_child_of_node(parent
, child
) {
299 const char *name
= strrchr(child
->full_name
, '/');
302 if (strncmp(path
, name
, len
) == 0 && (strlen(name
) == len
))
308 #define for_each_property_of_node(dn, pp) \
309 for (pp = dn->properties; pp != NULL; pp = pp->next)
311 struct device_node
*of_find_node_opts_by_path(const char *path
,
314 struct device_node
*np
= NULL
;
316 const char *separator
= strchr(path
, ':');
319 *opts
= separator
? separator
+ 1 : NULL
;
321 if (strcmp(path
, "/") == 0)
322 return of_node_get(gd
->of_root
);
324 /* The path could begin with an alias */
327 const char *p
= separator
;
330 p
= strchrnul(path
, '/');
333 /* of_aliases must not be NULL */
337 for_each_property_of_node(of_aliases
, pp
) {
338 if (strlen(pp
->name
) == len
&& !strncmp(pp
->name
, path
,
340 np
= of_find_node_by_path(pp
->value
);
349 /* Step down the tree matching path components */
351 np
= of_node_get(gd
->of_root
);
352 while (np
&& *path
== '/') {
353 struct device_node
*tmp
= np
;
355 path
++; /* Increment past '/' delimiter */
356 np
= __of_find_node_by_path(np
, path
);
358 path
= strchrnul(path
, '/');
359 if (separator
&& separator
< path
)
366 struct device_node
*of_find_compatible_node(struct device_node
*from
,
367 const char *type
, const char *compatible
)
369 struct device_node
*np
;
371 for_each_of_allnodes_from(from
, np
)
372 if (of_device_is_compatible(np
, compatible
, type
, NULL
) &&
380 struct device_node
*of_find_node_by_phandle(phandle handle
)
382 struct device_node
*np
;
387 for_each_of_allnodes(np
)
388 if (np
->phandle
== handle
)
390 (void)of_node_get(np
);
396 * of_find_property_value_of_size() - find property of given size
398 * Search for a property in a device node and validate the requested size.
400 * @np: device node from which the property value is to be read.
401 * @propname: name of the property to be searched.
402 * @len: requested length of property value
404 * @return the property value on success, -EINVAL if the property does not
405 * exist, -ENODATA if property does not have a value, and -EOVERFLOW if the
406 * property data isn't large enough.
408 static void *of_find_property_value_of_size(const struct device_node
*np
,
409 const char *propname
, u32 len
)
411 struct property
*prop
= of_find_property(np
, propname
, NULL
);
414 return ERR_PTR(-EINVAL
);
416 return ERR_PTR(-ENODATA
);
417 if (len
> prop
->length
)
418 return ERR_PTR(-EOVERFLOW
);
423 int of_read_u32(const struct device_node
*np
, const char *propname
, u32
*outp
)
427 debug("%s: %s: ", __func__
, propname
);
430 val
= of_find_property_value_of_size(np
, propname
, sizeof(*outp
));
432 debug("(not found)\n");
436 *outp
= be32_to_cpup(val
);
437 debug("%#x (%d)\n", *outp
, *outp
);
442 int of_read_u32_array(const struct device_node
*np
, const char *propname
,
443 u32
*out_values
, size_t sz
)
447 debug("%s: %s: ", __func__
, propname
);
448 val
= of_find_property_value_of_size(np
, propname
,
449 sz
* sizeof(*out_values
));
454 debug("size %zd\n", sz
);
456 *out_values
++ = be32_to_cpup(val
++);
461 int of_property_match_string(const struct device_node
*np
, const char *propname
,
464 const struct property
*prop
= of_find_property(np
, propname
, NULL
);
475 end
= p
+ prop
->length
;
477 for (i
= 0; p
< end
; i
++, p
+= l
) {
478 l
= strnlen(p
, end
- p
) + 1;
481 debug("comparing %s with %s\n", string
, p
);
482 if (strcmp(string
, p
) == 0)
483 return i
; /* Found it; return index */
489 * of_property_read_string_helper() - Utility helper for parsing string properties
490 * @np: device node from which the property value is to be read.
491 * @propname: name of the property to be searched.
492 * @out_strs: output array of string pointers.
493 * @sz: number of array elements to read.
494 * @skip: Number of strings to skip over at beginning of list.
496 * Don't call this function directly. It is a utility helper for the
497 * of_property_read_string*() family of functions.
499 int of_property_read_string_helper(const struct device_node
*np
,
500 const char *propname
, const char **out_strs
,
503 const struct property
*prop
= of_find_property(np
, propname
, NULL
);
512 end
= p
+ prop
->length
;
514 for (i
= 0; p
< end
&& (!out_strs
|| i
< skip
+ sz
); i
++, p
+= l
) {
515 l
= strnlen(p
, end
- p
) + 1;
518 if (out_strs
&& i
>= skip
)
522 return i
<= 0 ? -ENODATA
: i
;
525 static int __of_parse_phandle_with_args(const struct device_node
*np
,
526 const char *list_name
,
527 const char *cells_name
,
528 int cell_count
, int index
,
529 struct of_phandle_args
*out_args
)
531 const __be32
*list
, *list_end
;
532 int rc
= 0, cur_index
= 0;
534 struct device_node
*node
= NULL
;
538 /* Retrieve the phandle list property */
539 list
= of_get_property(np
, list_name
, &size
);
542 list_end
= list
+ size
/ sizeof(*list
);
544 /* Loop over the phandles until all the requested entry is found */
545 while (list
< list_end
) {
550 * If phandle is 0, then it is an empty entry with no
551 * arguments. Skip forward to the next entry.
553 phandle
= be32_to_cpup(list
++);
556 * Find the provider node and parse the #*-cells
557 * property to determine the argument length.
559 * This is not needed if the cell count is hard-coded
560 * (i.e. cells_name not set, but cell_count is set),
561 * except when we're going to return the found node
564 if (cells_name
|| cur_index
== index
) {
565 node
= of_find_node_by_phandle(phandle
);
567 debug("%s: could not find phandle\n",
574 if (of_read_u32(node
, cells_name
, &count
)) {
575 debug("%s: could not get %s for %s\n",
576 np
->full_name
, cells_name
,
585 * Make sure that the arguments actually fit in the
586 * remaining property data length
588 if (list
+ count
> list_end
) {
589 debug("%s: arguments longer than property\n",
596 * All of the error cases above bail out of the loop, so at
597 * this point, the parsing is successful. If the requested
598 * index matches, then fill the out_args structure and return,
599 * or return -ENOENT for an empty entry.
602 if (cur_index
== index
) {
608 if (WARN_ON(count
> OF_MAX_PHANDLE_ARGS
))
609 count
= OF_MAX_PHANDLE_ARGS
;
611 out_args
->args_count
= count
;
612 for (i
= 0; i
< count
; i
++)
614 be32_to_cpup(list
++);
619 /* Found it! return success */
630 * Unlock node before returning result; will be one of:
631 * -ENOENT : index is for empty phandle
632 * -EINVAL : parsing error on data
633 * [1..n] : Number of phandle (count mode; when index = -1)
635 rc
= index
< 0 ? cur_index
: -ENOENT
;
642 struct device_node
*of_parse_phandle(const struct device_node
*np
,
643 const char *phandle_name
, int index
)
645 struct of_phandle_args args
;
650 if (__of_parse_phandle_with_args(np
, phandle_name
, NULL
, 0, index
,
657 int of_parse_phandle_with_args(const struct device_node
*np
,
658 const char *list_name
, const char *cells_name
,
659 int index
, struct of_phandle_args
*out_args
)
664 return __of_parse_phandle_with_args(np
, list_name
, cells_name
, 0,
668 int of_count_phandle_with_args(const struct device_node
*np
,
669 const char *list_name
, const char *cells_name
)
671 return __of_parse_phandle_with_args(np
, list_name
, cells_name
, 0,
675 static void of_alias_add(struct alias_prop
*ap
, struct device_node
*np
,
676 int id
, const char *stem
, int stem_len
)
680 strncpy(ap
->stem
, stem
, stem_len
);
681 ap
->stem
[stem_len
] = 0;
682 list_add_tail(&ap
->link
, &aliases_lookup
);
683 debug("adding DT alias:%s: stem=%s id=%i node=%s\n",
684 ap
->alias
, ap
->stem
, ap
->id
, of_node_full_name(np
));
687 int of_alias_scan(void)
691 of_aliases
= of_find_node_by_path("/aliases");
692 of_chosen
= of_find_node_by_path("/chosen");
693 if (of_chosen
== NULL
)
694 of_chosen
= of_find_node_by_path("/chosen@0");
699 name
= of_get_property(of_chosen
, "stdout-path", NULL
);
701 of_stdout
= of_find_node_opts_by_path(name
,
708 for_each_property_of_node(of_aliases
, pp
) {
709 const char *start
= pp
->name
;
710 const char *end
= start
+ strlen(start
);
711 struct device_node
*np
;
712 struct alias_prop
*ap
;
716 /* Skip those we do not want to proceed */
717 if (!strcmp(pp
->name
, "name") ||
718 !strcmp(pp
->name
, "phandle") ||
719 !strcmp(pp
->name
, "linux,phandle"))
722 np
= of_find_node_by_path(pp
->value
);
727 * walk the alias backwards to extract the id and work out
730 while (isdigit(*(end
-1)) && end
> start
)
734 if (strict_strtoul(end
, 10, &id
) < 0)
737 /* Allocate an alias_prop with enough space for the stem */
738 ap
= malloc(sizeof(*ap
) + len
+ 1);
741 memset(ap
, 0, sizeof(*ap
) + len
+ 1);
743 of_alias_add(ap
, np
, id
, start
, len
);
749 int of_alias_get_id(const struct device_node
*np
, const char *stem
)
751 struct alias_prop
*app
;
754 mutex_lock(&of_mutex
);
755 list_for_each_entry(app
, &aliases_lookup
, link
) {
756 if (strcmp(app
->stem
, stem
) != 0)
764 mutex_unlock(&of_mutex
);
769 struct device_node
*of_get_stdout(void)