2 * Copyright (c) 2017 Google, Inc
3 * Written by Simon Glass <sjg@chromium.org>
5 * SPDX-License-Identifier: GPL-2.0+
11 #include <fdt_support.h>
13 #include <dm/of_access.h>
14 #include <dm/of_addr.h>
15 #include <dm/ofnode.h>
16 #include <linux/err.h>
18 int ofnode_read_u32(ofnode node
, const char *propname
, u32
*outp
)
20 assert(ofnode_valid(node
));
21 debug("%s: %s: ", __func__
, propname
);
23 if (ofnode_is_np(node
)) {
24 return of_read_u32(ofnode_to_np(node
), propname
, outp
);
29 cell
= fdt_getprop(gd
->fdt_blob
, ofnode_to_offset(node
),
31 if (!cell
|| len
< sizeof(int)) {
32 debug("(not found)\n");
35 *outp
= fdt32_to_cpu(cell
[0]);
37 debug("%#x (%d)\n", *outp
, *outp
);
42 int ofnode_read_u32_default(ofnode node
, const char *propname
, u32 def
)
44 assert(ofnode_valid(node
));
45 ofnode_read_u32(node
, propname
, &def
);
50 int ofnode_read_s32_default(ofnode node
, const char *propname
, s32 def
)
52 assert(ofnode_valid(node
));
53 ofnode_read_u32(node
, propname
, (u32
*)&def
);
58 bool ofnode_read_bool(ofnode node
, const char *propname
)
62 assert(ofnode_valid(node
));
63 debug("%s: %s: ", __func__
, propname
);
65 prop
= ofnode_get_property(node
, propname
, NULL
);
67 debug("%s\n", prop
? "true" : "false");
69 return prop
? true : false;
72 const char *ofnode_read_string(ofnode node
, const char *propname
)
74 const char *str
= NULL
;
77 assert(ofnode_valid(node
));
78 debug("%s: %s: ", __func__
, propname
);
80 if (ofnode_is_np(node
)) {
81 struct property
*prop
= of_find_property(
82 ofnode_to_np(node
), propname
, NULL
);
89 str
= fdt_getprop(gd
->fdt_blob
, ofnode_to_offset(node
),
93 debug("<not found>\n");
96 if (strnlen(str
, len
) >= len
) {
105 ofnode
ofnode_find_subnode(ofnode node
, const char *subnode_name
)
109 assert(ofnode_valid(node
));
110 debug("%s: %s: ", __func__
, subnode_name
);
112 if (ofnode_is_np(node
)) {
113 const struct device_node
*np
= ofnode_to_np(node
);
115 for (np
= np
->child
; np
; np
= np
->sibling
) {
116 if (!strcmp(subnode_name
, np
->name
))
119 subnode
= np_to_ofnode(np
);
121 int ooffset
= fdt_subnode_offset(gd
->fdt_blob
,
122 ofnode_to_offset(node
), subnode_name
);
123 subnode
= offset_to_ofnode(ooffset
);
125 debug("%s\n", ofnode_valid(subnode
) ?
126 ofnode_get_name(subnode
) : "<none>");
131 int ofnode_read_u32_array(ofnode node
, const char *propname
,
132 u32
*out_values
, size_t sz
)
134 assert(ofnode_valid(node
));
135 debug("%s: %s: ", __func__
, propname
);
137 if (ofnode_is_np(node
)) {
138 return of_read_u32_array(ofnode_to_np(node
), propname
,
141 return fdtdec_get_int_array(gd
->fdt_blob
,
142 ofnode_to_offset(node
), propname
,
147 ofnode
ofnode_first_subnode(ofnode node
)
149 assert(ofnode_valid(node
));
150 if (ofnode_is_np(node
))
151 return np_to_ofnode(node
.np
->child
);
153 return offset_to_ofnode(
154 fdt_first_subnode(gd
->fdt_blob
, ofnode_to_offset(node
)));
157 ofnode
ofnode_next_subnode(ofnode node
)
159 assert(ofnode_valid(node
));
160 if (ofnode_is_np(node
))
161 return np_to_ofnode(node
.np
->sibling
);
163 return offset_to_ofnode(
164 fdt_next_subnode(gd
->fdt_blob
, ofnode_to_offset(node
)));
167 const char *ofnode_get_name(ofnode node
)
169 assert(ofnode_valid(node
));
170 if (ofnode_is_np(node
))
171 return strrchr(node
.np
->full_name
, '/') + 1;
173 return fdt_get_name(gd
->fdt_blob
, ofnode_to_offset(node
), NULL
);
176 int ofnode_read_size(ofnode node
, const char *propname
)
180 if (ofnode_is_np(node
)) {
181 struct property
*prop
= of_find_property(
182 ofnode_to_np(node
), propname
, NULL
);
187 if (fdt_getprop(gd
->fdt_blob
, ofnode_to_offset(node
), propname
,
195 fdt_addr_t
ofnode_get_addr_index(ofnode node
, int index
)
197 if (ofnode_is_np(node
)) {
198 const __be32
*prop_val
;
202 prop_val
= of_get_address(
203 (struct device_node
*)ofnode_to_np(node
), index
,
206 return FDT_ADDR_T_NONE
;
207 return be32_to_cpup(prop_val
);
209 return fdt_get_base_address(gd
->fdt_blob
,
210 ofnode_to_offset(node
));
213 return FDT_ADDR_T_NONE
;
216 fdt_addr_t
ofnode_get_addr(ofnode node
)
218 return ofnode_get_addr_index(node
, 0);
221 int ofnode_stringlist_search(ofnode node
, const char *property
,
224 if (ofnode_is_np(node
)) {
225 return of_property_match_string(ofnode_to_np(node
),
230 ret
= fdt_stringlist_search(gd
->fdt_blob
,
231 ofnode_to_offset(node
), property
,
233 if (ret
== -FDT_ERR_NOTFOUND
)
242 int ofnode_read_string_index(ofnode node
, const char *property
, int index
,
245 if (ofnode_is_np(node
)) {
246 return of_property_read_string_index(ofnode_to_np(node
),
247 property
, index
, outp
);
251 *outp
= fdt_stringlist_get(gd
->fdt_blob
, ofnode_to_offset(node
),
252 property
, index
, &len
);
259 int ofnode_read_string_count(ofnode node
, const char *property
)
261 if (ofnode_is_np(node
)) {
262 return of_property_count_strings(ofnode_to_np(node
), property
);
264 return fdt_stringlist_count(gd
->fdt_blob
,
265 ofnode_to_offset(node
), property
);
269 static void ofnode_from_fdtdec_phandle_args(struct fdtdec_phandle_args
*in
,
270 struct ofnode_phandle_args
*out
)
272 assert(OF_MAX_PHANDLE_ARGS
== MAX_PHANDLE_ARGS
);
273 out
->node
= offset_to_ofnode(in
->node
);
274 out
->args_count
= in
->args_count
;
275 memcpy(out
->args
, in
->args
, sizeof(out
->args
));
278 static void ofnode_from_of_phandle_args(struct of_phandle_args
*in
,
279 struct ofnode_phandle_args
*out
)
281 assert(OF_MAX_PHANDLE_ARGS
== MAX_PHANDLE_ARGS
);
282 out
->node
= np_to_ofnode(in
->np
);
283 out
->args_count
= in
->args_count
;
284 memcpy(out
->args
, in
->args
, sizeof(out
->args
));
287 int ofnode_parse_phandle_with_args(ofnode node
, const char *list_name
,
288 const char *cells_name
, int cell_count
,
290 struct ofnode_phandle_args
*out_args
)
292 if (ofnode_is_np(node
)) {
293 struct of_phandle_args args
;
296 ret
= of_parse_phandle_with_args(ofnode_to_np(node
),
297 list_name
, cells_name
, index
, &args
);
300 ofnode_from_of_phandle_args(&args
, out_args
);
302 struct fdtdec_phandle_args args
;
305 ret
= fdtdec_parse_phandle_with_args(gd
->fdt_blob
,
306 ofnode_to_offset(node
), list_name
, cells_name
,
307 cell_count
, index
, &args
);
310 ofnode_from_fdtdec_phandle_args(&args
, out_args
);
316 ofnode
ofnode_path(const char *path
)
318 if (of_live_active())
319 return np_to_ofnode(of_find_node_by_path(path
));
321 return offset_to_ofnode(fdt_path_offset(gd
->fdt_blob
, path
));
324 const char *ofnode_get_chosen_prop(const char *name
)
328 chosen_node
= ofnode_path("/chosen");
330 return ofnode_read_string(chosen_node
, name
);
333 ofnode
ofnode_get_chosen_node(const char *name
)
337 prop
= ofnode_get_chosen_prop(name
);
339 return ofnode_null();
341 return ofnode_path(prop
);
344 static int decode_timing_property(ofnode node
, const char *name
,
345 struct timing_entry
*result
)
349 length
= ofnode_read_size(node
, name
);
351 debug("%s: could not find property %s\n",
352 ofnode_get_name(node
), name
);
356 if (length
== sizeof(u32
)) {
357 result
->typ
= ofnode_read_u32_default(node
, name
, 0);
358 result
->min
= result
->typ
;
359 result
->max
= result
->typ
;
361 ret
= ofnode_read_u32_array(node
, name
, &result
->min
, 3);
367 int ofnode_decode_display_timing(ofnode parent
, int index
,
368 struct display_timing
*dt
)
371 ofnode timings
, node
;
375 timings
= ofnode_find_subnode(parent
, "display-timings");
376 if (!ofnode_valid(timings
))
379 for (i
= 0, node
= ofnode_first_subnode(timings
);
380 ofnode_valid(node
) && i
!= index
;
381 node
= ofnode_first_subnode(node
))
384 if (!ofnode_valid(node
))
387 memset(dt
, 0, sizeof(*dt
));
389 ret
|= decode_timing_property(node
, "hback-porch", &dt
->hback_porch
);
390 ret
|= decode_timing_property(node
, "hfront-porch", &dt
->hfront_porch
);
391 ret
|= decode_timing_property(node
, "hactive", &dt
->hactive
);
392 ret
|= decode_timing_property(node
, "hsync-len", &dt
->hsync_len
);
393 ret
|= decode_timing_property(node
, "vback-porch", &dt
->vback_porch
);
394 ret
|= decode_timing_property(node
, "vfront-porch", &dt
->vfront_porch
);
395 ret
|= decode_timing_property(node
, "vactive", &dt
->vactive
);
396 ret
|= decode_timing_property(node
, "vsync-len", &dt
->vsync_len
);
397 ret
|= decode_timing_property(node
, "clock-frequency", &dt
->pixelclock
);
400 val
= ofnode_read_u32_default(node
, "vsync-active", -1);
402 dt
->flags
|= val
? DISPLAY_FLAGS_VSYNC_HIGH
:
403 DISPLAY_FLAGS_VSYNC_LOW
;
405 val
= ofnode_read_u32_default(node
, "hsync-active", -1);
407 dt
->flags
|= val
? DISPLAY_FLAGS_HSYNC_HIGH
:
408 DISPLAY_FLAGS_HSYNC_LOW
;
410 val
= ofnode_read_u32_default(node
, "de-active", -1);
412 dt
->flags
|= val
? DISPLAY_FLAGS_DE_HIGH
:
413 DISPLAY_FLAGS_DE_LOW
;
415 val
= ofnode_read_u32_default(node
, "pixelclk-active", -1);
417 dt
->flags
|= val
? DISPLAY_FLAGS_PIXDATA_POSEDGE
:
418 DISPLAY_FLAGS_PIXDATA_NEGEDGE
;
421 if (ofnode_read_bool(node
, "interlaced"))
422 dt
->flags
|= DISPLAY_FLAGS_INTERLACED
;
423 if (ofnode_read_bool(node
, "doublescan"))
424 dt
->flags
|= DISPLAY_FLAGS_DOUBLESCAN
;
425 if (ofnode_read_bool(node
, "doubleclk"))
426 dt
->flags
|= DISPLAY_FLAGS_DOUBLECLK
;
431 const void *ofnode_get_property(ofnode node
, const char *propname
, int *lenp
)
433 if (ofnode_is_np(node
))
434 return of_get_property(ofnode_to_np(node
), propname
, lenp
);
436 return fdt_getprop(gd
->fdt_blob
, ofnode_to_offset(node
),
440 bool ofnode_is_available(ofnode node
)
442 if (ofnode_is_np(node
))
443 return of_device_is_available(ofnode_to_np(node
));
445 return fdtdec_get_is_enabled(gd
->fdt_blob
,
446 ofnode_to_offset(node
));
449 fdt_addr_t
ofnode_get_addr_size(ofnode node
, const char *property
,
452 if (ofnode_is_np(node
)) {
455 const struct device_node
*np
= ofnode_to_np(node
);
456 const __be32
*prop
= of_get_property(np
, "reg", &psize
);
458 na
= of_n_addr_cells(np
);
459 ns
= of_n_addr_cells(np
);
460 *sizep
= of_read_number(prop
+ na
, ns
);
461 return of_read_number(prop
, na
);
463 return fdtdec_get_addr_size(gd
->fdt_blob
,
464 ofnode_to_offset(node
), property
,
469 const uint8_t *ofnode_read_u8_array_ptr(ofnode node
, const char *propname
,
472 if (ofnode_is_np(node
)) {
473 const struct device_node
*np
= ofnode_to_np(node
);
475 const __be32
*prop
= of_get_property(np
, propname
, &psize
);
477 if (!prop
|| sz
!= psize
)
479 return (uint8_t *)prop
;
482 return fdtdec_locate_byte_array(gd
->fdt_blob
,
483 ofnode_to_offset(node
), propname
, sz
);
487 int ofnode_read_pci_addr(ofnode node
, enum fdt_pci_space type
,
488 const char *propname
, struct fdt_pci_addr
*addr
)
494 debug("%s: %s: ", __func__
, propname
);
497 * If we follow the pci bus bindings strictly, we should check
498 * the value of the node's parent node's #address-cells and
499 * #size-cells. They need to be 3 and 2 accordingly. However,
500 * for simplicity we skip the check here.
502 cell
= ofnode_get_property(node
, propname
, &len
);
506 if ((len
% FDT_PCI_REG_SIZE
) == 0) {
507 int num
= len
/ FDT_PCI_REG_SIZE
;
510 for (i
= 0; i
< num
; i
++) {
511 debug("pci address #%d: %08lx %08lx %08lx\n", i
,
512 (ulong
)fdt32_to_cpu(cell
[0]),
513 (ulong
)fdt32_to_cpu(cell
[1]),
514 (ulong
)fdt32_to_cpu(cell
[2]));
515 if ((fdt32_to_cpu(*cell
) & type
) == type
) {
516 addr
->phys_hi
= fdt32_to_cpu(cell
[0]);
517 addr
->phys_mid
= fdt32_to_cpu(cell
[1]);
518 addr
->phys_lo
= fdt32_to_cpu(cell
[1]);
521 cell
+= (FDT_PCI_ADDR_CELLS
+
537 debug("(not found)\n");
541 int ofnode_read_addr_cells(ofnode node
)
543 if (ofnode_is_np(node
))
544 return of_n_addr_cells(ofnode_to_np(node
));
545 else /* NOTE: this call should walk up the parent stack */
546 return fdt_address_cells(gd
->fdt_blob
, ofnode_to_offset(node
));
549 int ofnode_read_size_cells(ofnode node
)
551 if (ofnode_is_np(node
))
552 return of_n_size_cells(ofnode_to_np(node
));
553 else /* NOTE: this call should walk up the parent stack */
554 return fdt_size_cells(gd
->fdt_blob
, ofnode_to_offset(node
));
557 int ofnode_read_simple_addr_cells(ofnode node
)
559 if (ofnode_is_np(node
))
560 return of_simple_addr_cells(ofnode_to_np(node
));
562 return fdt_address_cells(gd
->fdt_blob
, ofnode_to_offset(node
));
565 int ofnode_read_simple_size_cells(ofnode node
)
567 if (ofnode_is_np(node
))
568 return of_simple_size_cells(ofnode_to_np(node
));
570 return fdt_size_cells(gd
->fdt_blob
, ofnode_to_offset(node
));
573 bool ofnode_pre_reloc(ofnode node
)
575 if (ofnode_read_bool(node
, "u-boot,dm-pre-reloc"))
578 #ifdef CONFIG_TPL_BUILD
579 if (ofnode_read_bool(node
, "u-boot,dm-tpl"))
581 #elif defined(CONFIG_SPL_BUILD)
582 if (ofnode_read_bool(node
, "u-boot,dm-spl"))
586 * In regular builds individual spl and tpl handling both
587 * count as handled pre-relocation for later second init.
589 if (ofnode_read_bool(node
, "u-boot,dm-spl") ||
590 ofnode_read_bool(node
, "u-boot,dm-tpl"))