1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
// SPDX-License-Identifier: GPL-2.0+
#include <common.h>
#include <dm.h>
#include <dm/of_extra.h>
#include <dm/test.h>
#include <test/ut.h>
static int dm_test_ofnode_compatible(struct unit_test_state *uts)
{
ofnode root_node = ofnode_path("/");
ut_assert(ofnode_valid(root_node));
ut_assert(ofnode_device_is_compatible(root_node, "sandbox"));
return 0;
}
DM_TEST(dm_test_ofnode_compatible, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
static int dm_test_ofnode_by_prop_value(struct unit_test_state *uts)
{
const char propname[] = "compatible";
const char propval[] = "denx,u-boot-fdt-test";
const char *str;
ofnode node = ofnode_null();
/* Find first matching node, there should be at least one */
node = ofnode_by_prop_value(node, propname, propval, sizeof(propval));
ut_assert(ofnode_valid(node));
str = ofnode_read_string(node, propname);
ut_assert(str && !strcmp(str, propval));
/* Find the rest of the matching nodes */
while (true) {
node = ofnode_by_prop_value(node, propname, propval,
sizeof(propval));
if (!ofnode_valid(node))
break;
str = ofnode_read_string(node, propname);
ut_assert(str && !strcmp(str, propval));
}
return 0;
}
DM_TEST(dm_test_ofnode_by_prop_value, DM_TESTF_SCAN_FDT);
static int dm_test_ofnode_fmap(struct unit_test_state *uts)
{
struct fmap_entry entry;
ofnode node;
node = ofnode_path("/cros-ec/flash");
ut_assert(ofnode_valid(node));
ut_assertok(ofnode_read_fmap_entry(node, &entry));
ut_asserteq(0x08000000, entry.offset);
ut_asserteq(0x20000, entry.length);
return 0;
}
DM_TEST(dm_test_ofnode_fmap, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
static int dm_test_ofnode_read(struct unit_test_state *uts)
{
const u32 *val;
ofnode node;
int size;
node = ofnode_path("/a-test");
ut_assert(ofnode_valid(node));
val = ofnode_read_prop(node, "int-value", &size);
ut_assertnonnull(val);
ut_asserteq(4, size);
ut_asserteq(1234, fdt32_to_cpu(val[0]));
val = ofnode_read_prop(node, "missing", &size);
ut_assertnull(val);
ut_asserteq(-FDT_ERR_NOTFOUND, size);
/* Check it works without a size parameter */
val = ofnode_read_prop(node, "missing", NULL);
ut_assertnull(val);
return 0;
}
DM_TEST(dm_test_ofnode_read, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
static int dm_test_ofnode_read_chosen(struct unit_test_state *uts)
{
const char *str;
const u32 *val;
ofnode node;
int size;
str = ofnode_read_chosen_string("setting");
ut_assertnonnull(str);
ut_asserteq_str("sunrise ohoka", str);
ut_asserteq_ptr(NULL, ofnode_read_chosen_string("no-setting"));
node = ofnode_get_chosen_node("other-node");
ut_assert(ofnode_valid(node));
ut_asserteq_str("c-test@5", ofnode_get_name(node));
node = ofnode_get_chosen_node("setting");
ut_assert(!ofnode_valid(node));
val = ofnode_read_chosen_prop("int-values", &size);
ut_assertnonnull(val);
ut_asserteq(8, size);
ut_asserteq(0x1937, fdt32_to_cpu(val[0]));
ut_asserteq(72993, fdt32_to_cpu(val[1]));
return 0;
}
DM_TEST(dm_test_ofnode_read_chosen, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
static int dm_test_ofnode_get_child_count(struct unit_test_state *uts)
{
ofnode node, child_node;
u32 val;
node = ofnode_path("/i-test");
ut_assert(ofnode_valid(node));
val = ofnode_get_child_count(node);
ut_asserteq(3, val);
child_node = ofnode_first_subnode(node);
ut_assert(ofnode_valid(child_node));
val = ofnode_get_child_count(child_node);
ut_asserteq(0, val);
return 0;
}
DM_TEST(dm_test_ofnode_get_child_count,
DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
|
