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>
17 #include <linux/ioport.h>
19 int ofnode_read_u32(ofnode node
, const char *propname
, u32
*outp
)
21 assert(ofnode_valid(node
));
22 debug("%s: %s: ", __func__
, propname
);
24 if (ofnode_is_np(node
)) {
25 return of_read_u32(ofnode_to_np(node
), propname
, outp
);
30 cell
= fdt_getprop(gd
->fdt_blob
, ofnode_to_offset(node
),
32 if (!cell
|| len
< sizeof(int)) {
33 debug("(not found)\n");
36 *outp
= fdt32_to_cpu(cell
[0]);
38 debug("%#x (%d)\n", *outp
, *outp
);
43 int ofnode_read_u32_default(ofnode node
, const char *propname
, u32 def
)
45 assert(ofnode_valid(node
));
46 ofnode_read_u32(node
, propname
, &def
);
51 int ofnode_read_s32_default(ofnode node
, const char *propname
, s32 def
)
53 assert(ofnode_valid(node
));
54 ofnode_read_u32(node
, propname
, (u32
*)&def
);
59 bool ofnode_read_bool(ofnode node
, const char *propname
)
63 assert(ofnode_valid(node
));
64 debug("%s: %s: ", __func__
, propname
);
66 prop
= ofnode_get_property(node
, propname
, NULL
);
68 debug("%s\n", prop
? "true" : "false");
70 return prop
? true : false;
73 const char *ofnode_read_string(ofnode node
, const char *propname
)
75 const char *str
= NULL
;
78 assert(ofnode_valid(node
));
79 debug("%s: %s: ", __func__
, propname
);
81 if (ofnode_is_np(node
)) {
82 struct property
*prop
= of_find_property(
83 ofnode_to_np(node
), propname
, NULL
);
90 str
= fdt_getprop(gd
->fdt_blob
, ofnode_to_offset(node
),
94 debug("<not found>\n");
97 if (strnlen(str
, len
) >= len
) {
106 ofnode
ofnode_find_subnode(ofnode node
, const char *subnode_name
)
110 assert(ofnode_valid(node
));
111 debug("%s: %s: ", __func__
, subnode_name
);
113 if (ofnode_is_np(node
)) {
114 const struct device_node
*np
= ofnode_to_np(node
);
116 for (np
= np
->child
; np
; np
= np
->sibling
) {
117 if (!strcmp(subnode_name
, np
->name
))
120 subnode
= np_to_ofnode(np
);
122 int ooffset
= fdt_subnode_offset(gd
->fdt_blob
,
123 ofnode_to_offset(node
), subnode_name
);
124 subnode
= offset_to_ofnode(ooffset
);
126 debug("%s\n", ofnode_valid(subnode
) ?
127 ofnode_get_name(subnode
) : "<none>");
132 int ofnode_read_u32_array(ofnode node
, const char *propname
,
133 u32
*out_values
, size_t sz
)
135 assert(ofnode_valid(node
));
136 debug("%s: %s: ", __func__
, propname
);
138 if (ofnode_is_np(node
)) {
139 return of_read_u32_array(ofnode_to_np(node
), propname
,
142 return fdtdec_get_int_array(gd
->fdt_blob
,
143 ofnode_to_offset(node
), propname
,
148 ofnode
ofnode_first_subnode(ofnode node
)
150 assert(ofnode_valid(node
));
151 if (ofnode_is_np(node
))
152 return np_to_ofnode(node
.np
->child
);
154 return offset_to_ofnode(
155 fdt_first_subnode(gd
->fdt_blob
, ofnode_to_offset(node
)));
158 ofnode
ofnode_next_subnode(ofnode node
)
160 assert(ofnode_valid(node
));
161 if (ofnode_is_np(node
))
162 return np_to_ofnode(node
.np
->sibling
);
164 return offset_to_ofnode(
165 fdt_next_subnode(gd
->fdt_blob
, ofnode_to_offset(node
)));
168 ofnode
ofnode_get_parent(ofnode node
)
172 assert(ofnode_valid(node
));
173 if (ofnode_is_np(node
))
174 parent
= np_to_ofnode(of_get_parent(ofnode_to_np(node
)));
176 parent
.of_offset
= fdt_parent_offset(gd
->fdt_blob
,
177 ofnode_to_offset(node
));
182 const char *ofnode_get_name(ofnode node
)
184 assert(ofnode_valid(node
));
185 if (ofnode_is_np(node
))
186 return strrchr(node
.np
->full_name
, '/') + 1;
188 return fdt_get_name(gd
->fdt_blob
, ofnode_to_offset(node
), NULL
);
191 ofnode
ofnode_get_by_phandle(uint phandle
)
195 if (of_live_active())
196 node
= np_to_ofnode(of_find_node_by_phandle(phandle
));
198 node
.of_offset
= fdt_node_offset_by_phandle(gd
->fdt_blob
,
204 int ofnode_read_size(ofnode node
, const char *propname
)
208 if (ofnode_is_np(node
)) {
209 struct property
*prop
= of_find_property(
210 ofnode_to_np(node
), propname
, NULL
);
215 if (fdt_getprop(gd
->fdt_blob
, ofnode_to_offset(node
), propname
,
223 fdt_addr_t
ofnode_get_addr_index(ofnode node
, int index
)
225 if (ofnode_is_np(node
)) {
226 const __be32
*prop_val
;
231 prop_val
= of_get_address(ofnode_to_np(node
), index
, &size
,
234 return FDT_ADDR_T_NONE
;
236 if (IS_ENABLED(CONFIG_OF_TRANSLATE
)) {
237 return of_translate_address(ofnode_to_np(node
), prop_val
);
239 na
= of_n_addr_cells(ofnode_to_np(node
));
240 return of_read_number(prop_val
, na
);
243 return fdt_get_base_address(gd
->fdt_blob
,
244 ofnode_to_offset(node
));
247 return FDT_ADDR_T_NONE
;
250 fdt_addr_t
ofnode_get_addr(ofnode node
)
252 return ofnode_get_addr_index(node
, 0);
255 int ofnode_stringlist_search(ofnode node
, const char *property
,
258 if (ofnode_is_np(node
)) {
259 return of_property_match_string(ofnode_to_np(node
),
264 ret
= fdt_stringlist_search(gd
->fdt_blob
,
265 ofnode_to_offset(node
), property
,
267 if (ret
== -FDT_ERR_NOTFOUND
)
276 int ofnode_read_string_index(ofnode node
, const char *property
, int index
,
279 if (ofnode_is_np(node
)) {
280 return of_property_read_string_index(ofnode_to_np(node
),
281 property
, index
, outp
);
285 *outp
= fdt_stringlist_get(gd
->fdt_blob
, ofnode_to_offset(node
),
286 property
, index
, &len
);
293 int ofnode_read_string_count(ofnode node
, const char *property
)
295 if (ofnode_is_np(node
)) {
296 return of_property_count_strings(ofnode_to_np(node
), property
);
298 return fdt_stringlist_count(gd
->fdt_blob
,
299 ofnode_to_offset(node
), property
);
303 static void ofnode_from_fdtdec_phandle_args(struct fdtdec_phandle_args
*in
,
304 struct ofnode_phandle_args
*out
)
306 assert(OF_MAX_PHANDLE_ARGS
== MAX_PHANDLE_ARGS
);
307 out
->node
= offset_to_ofnode(in
->node
);
308 out
->args_count
= in
->args_count
;
309 memcpy(out
->args
, in
->args
, sizeof(out
->args
));
312 static void ofnode_from_of_phandle_args(struct of_phandle_args
*in
,
313 struct ofnode_phandle_args
*out
)
315 assert(OF_MAX_PHANDLE_ARGS
== MAX_PHANDLE_ARGS
);
316 out
->node
= np_to_ofnode(in
->np
);
317 out
->args_count
= in
->args_count
;
318 memcpy(out
->args
, in
->args
, sizeof(out
->args
));
321 int ofnode_parse_phandle_with_args(ofnode node
, const char *list_name
,
322 const char *cells_name
, int cell_count
,
324 struct ofnode_phandle_args
*out_args
)
326 if (ofnode_is_np(node
)) {
327 struct of_phandle_args args
;
330 ret
= of_parse_phandle_with_args(ofnode_to_np(node
),
331 list_name
, cells_name
, index
,
335 ofnode_from_of_phandle_args(&args
, out_args
);
337 struct fdtdec_phandle_args args
;
340 ret
= fdtdec_parse_phandle_with_args(gd
->fdt_blob
,
341 ofnode_to_offset(node
),
342 list_name
, cells_name
,
343 cell_count
, index
, &args
);
346 ofnode_from_fdtdec_phandle_args(&args
, out_args
);
352 int ofnode_count_phandle_with_args(ofnode node
, const char *list_name
,
353 const char *cells_name
)
355 if (ofnode_is_np(node
))
356 return of_count_phandle_with_args(ofnode_to_np(node
),
357 list_name
, cells_name
);
359 return fdtdec_parse_phandle_with_args(gd
->fdt_blob
,
360 ofnode_to_offset(node
), list_name
, cells_name
,
364 ofnode
ofnode_path(const char *path
)
366 if (of_live_active())
367 return np_to_ofnode(of_find_node_by_path(path
));
369 return offset_to_ofnode(fdt_path_offset(gd
->fdt_blob
, path
));
372 const char *ofnode_get_chosen_prop(const char *name
)
376 chosen_node
= ofnode_path("/chosen");
378 return ofnode_read_string(chosen_node
, name
);
381 ofnode
ofnode_get_chosen_node(const char *name
)
385 prop
= ofnode_get_chosen_prop(name
);
387 return ofnode_null();
389 return ofnode_path(prop
);
392 static int decode_timing_property(ofnode node
, const char *name
,
393 struct timing_entry
*result
)
397 length
= ofnode_read_size(node
, name
);
399 debug("%s: could not find property %s\n",
400 ofnode_get_name(node
), name
);
404 if (length
== sizeof(u32
)) {
405 result
->typ
= ofnode_read_u32_default(node
, name
, 0);
406 result
->min
= result
->typ
;
407 result
->max
= result
->typ
;
409 ret
= ofnode_read_u32_array(node
, name
, &result
->min
, 3);
415 int ofnode_decode_display_timing(ofnode parent
, int index
,
416 struct display_timing
*dt
)
419 ofnode timings
, node
;
423 timings
= ofnode_find_subnode(parent
, "display-timings");
424 if (!ofnode_valid(timings
))
428 ofnode_for_each_subnode(node
, timings
) {
433 if (!ofnode_valid(node
))
436 memset(dt
, 0, sizeof(*dt
));
438 ret
|= decode_timing_property(node
, "hback-porch", &dt
->hback_porch
);
439 ret
|= decode_timing_property(node
, "hfront-porch", &dt
->hfront_porch
);
440 ret
|= decode_timing_property(node
, "hactive", &dt
->hactive
);
441 ret
|= decode_timing_property(node
, "hsync-len", &dt
->hsync_len
);
442 ret
|= decode_timing_property(node
, "vback-porch", &dt
->vback_porch
);
443 ret
|= decode_timing_property(node
, "vfront-porch", &dt
->vfront_porch
);
444 ret
|= decode_timing_property(node
, "vactive", &dt
->vactive
);
445 ret
|= decode_timing_property(node
, "vsync-len", &dt
->vsync_len
);
446 ret
|= decode_timing_property(node
, "clock-frequency", &dt
->pixelclock
);
449 val
= ofnode_read_u32_default(node
, "vsync-active", -1);
451 dt
->flags
|= val
? DISPLAY_FLAGS_VSYNC_HIGH
:
452 DISPLAY_FLAGS_VSYNC_LOW
;
454 val
= ofnode_read_u32_default(node
, "hsync-active", -1);
456 dt
->flags
|= val
? DISPLAY_FLAGS_HSYNC_HIGH
:
457 DISPLAY_FLAGS_HSYNC_LOW
;
459 val
= ofnode_read_u32_default(node
, "de-active", -1);
461 dt
->flags
|= val
? DISPLAY_FLAGS_DE_HIGH
:
462 DISPLAY_FLAGS_DE_LOW
;
464 val
= ofnode_read_u32_default(node
, "pixelclk-active", -1);
466 dt
->flags
|= val
? DISPLAY_FLAGS_PIXDATA_POSEDGE
:
467 DISPLAY_FLAGS_PIXDATA_NEGEDGE
;
470 if (ofnode_read_bool(node
, "interlaced"))
471 dt
->flags
|= DISPLAY_FLAGS_INTERLACED
;
472 if (ofnode_read_bool(node
, "doublescan"))
473 dt
->flags
|= DISPLAY_FLAGS_DOUBLESCAN
;
474 if (ofnode_read_bool(node
, "doubleclk"))
475 dt
->flags
|= DISPLAY_FLAGS_DOUBLECLK
;
480 const void *ofnode_get_property(ofnode node
, const char *propname
, int *lenp
)
482 if (ofnode_is_np(node
))
483 return of_get_property(ofnode_to_np(node
), propname
, lenp
);
485 return fdt_getprop(gd
->fdt_blob
, ofnode_to_offset(node
),
489 bool ofnode_is_available(ofnode node
)
491 if (ofnode_is_np(node
))
492 return of_device_is_available(ofnode_to_np(node
));
494 return fdtdec_get_is_enabled(gd
->fdt_blob
,
495 ofnode_to_offset(node
));
498 fdt_addr_t
ofnode_get_addr_size(ofnode node
, const char *property
,
501 if (ofnode_is_np(node
)) {
504 const struct device_node
*np
= ofnode_to_np(node
);
505 const __be32
*prop
= of_get_property(np
, property
, &psize
);
508 return FDT_ADDR_T_NONE
;
509 na
= of_n_addr_cells(np
);
510 ns
= of_n_addr_cells(np
);
511 *sizep
= of_read_number(prop
+ na
, ns
);
512 return of_read_number(prop
, na
);
514 return fdtdec_get_addr_size(gd
->fdt_blob
,
515 ofnode_to_offset(node
), property
,
520 const uint8_t *ofnode_read_u8_array_ptr(ofnode node
, const char *propname
,
523 if (ofnode_is_np(node
)) {
524 const struct device_node
*np
= ofnode_to_np(node
);
526 const __be32
*prop
= of_get_property(np
, propname
, &psize
);
528 if (!prop
|| sz
!= psize
)
530 return (uint8_t *)prop
;
533 return fdtdec_locate_byte_array(gd
->fdt_blob
,
534 ofnode_to_offset(node
), propname
, sz
);
538 int ofnode_read_pci_addr(ofnode node
, enum fdt_pci_space type
,
539 const char *propname
, struct fdt_pci_addr
*addr
)
545 debug("%s: %s: ", __func__
, propname
);
548 * If we follow the pci bus bindings strictly, we should check
549 * the value of the node's parent node's #address-cells and
550 * #size-cells. They need to be 3 and 2 accordingly. However,
551 * for simplicity we skip the check here.
553 cell
= ofnode_get_property(node
, propname
, &len
);
557 if ((len
% FDT_PCI_REG_SIZE
) == 0) {
558 int num
= len
/ FDT_PCI_REG_SIZE
;
561 for (i
= 0; i
< num
; i
++) {
562 debug("pci address #%d: %08lx %08lx %08lx\n", i
,
563 (ulong
)fdt32_to_cpu(cell
[0]),
564 (ulong
)fdt32_to_cpu(cell
[1]),
565 (ulong
)fdt32_to_cpu(cell
[2]));
566 if ((fdt32_to_cpu(*cell
) & type
) == type
) {
567 addr
->phys_hi
= fdt32_to_cpu(cell
[0]);
568 addr
->phys_mid
= fdt32_to_cpu(cell
[1]);
569 addr
->phys_lo
= fdt32_to_cpu(cell
[1]);
573 cell
+= (FDT_PCI_ADDR_CELLS
+
588 debug("(not found)\n");
592 int ofnode_read_addr_cells(ofnode node
)
594 if (ofnode_is_np(node
))
595 return of_n_addr_cells(ofnode_to_np(node
));
596 else /* NOTE: this call should walk up the parent stack */
597 return fdt_address_cells(gd
->fdt_blob
, ofnode_to_offset(node
));
600 int ofnode_read_size_cells(ofnode node
)
602 if (ofnode_is_np(node
))
603 return of_n_size_cells(ofnode_to_np(node
));
604 else /* NOTE: this call should walk up the parent stack */
605 return fdt_size_cells(gd
->fdt_blob
, ofnode_to_offset(node
));
608 int ofnode_read_simple_addr_cells(ofnode node
)
610 if (ofnode_is_np(node
))
611 return of_simple_addr_cells(ofnode_to_np(node
));
613 return fdt_address_cells(gd
->fdt_blob
, ofnode_to_offset(node
));
616 int ofnode_read_simple_size_cells(ofnode node
)
618 if (ofnode_is_np(node
))
619 return of_simple_size_cells(ofnode_to_np(node
));
621 return fdt_size_cells(gd
->fdt_blob
, ofnode_to_offset(node
));
624 bool ofnode_pre_reloc(ofnode node
)
626 if (ofnode_read_bool(node
, "u-boot,dm-pre-reloc"))
629 #ifdef CONFIG_TPL_BUILD
630 if (ofnode_read_bool(node
, "u-boot,dm-tpl"))
632 #elif defined(CONFIG_SPL_BUILD)
633 if (ofnode_read_bool(node
, "u-boot,dm-spl"))
637 * In regular builds individual spl and tpl handling both
638 * count as handled pre-relocation for later second init.
640 if (ofnode_read_bool(node
, "u-boot,dm-spl") ||
641 ofnode_read_bool(node
, "u-boot,dm-tpl"))
648 int ofnode_read_resource(ofnode node
, uint index
, struct resource
*res
)
650 if (ofnode_is_np(node
)) {
651 return of_address_to_resource(ofnode_to_np(node
), index
, res
);
653 struct fdt_resource fres
;
656 ret
= fdt_get_resource(gd
->fdt_blob
, ofnode_to_offset(node
),
657 "reg", index
, &fres
);
660 memset(res
, '\0', sizeof(*res
));
661 res
->start
= fres
.start
;
668 int ofnode_read_resource_byname(ofnode node
, const char *name
,
669 struct resource
*res
)
673 index
= ofnode_stringlist_search(node
, "reg-names", name
);
677 return ofnode_read_resource(node
, index
, res
);
680 u64
ofnode_translate_address(ofnode node
, const fdt32_t
*in_addr
)
682 if (ofnode_is_np(node
))
683 return of_translate_address(ofnode_to_np(node
), in_addr
);
685 return fdt_translate_address(gd
->fdt_blob
, ofnode_to_offset(node
), in_addr
);