1 /*
2 * Copyright (c) 2020 Nordic Semiconductor ASA
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 */
6
7 #include <zephyr/ztest.h>
8 #include <zephyr/devicetree.h>
9 #include <zephyr/devicetree/nvmem.h>
10 #include <zephyr/device.h>
11 #include <zephyr/drivers/gpio.h>
12
13 #include <stdlib.h>
14
15 #define TEST_CHILDREN DT_PATH(test, test_children)
16 #define TEST_DEADBEEF DT_PATH(test, gpio_deadbeef)
17 #define TEST_ABCD1234 DT_PATH(test, gpio_abcd1234)
18 #define TEST_ALIAS DT_ALIAS(test_alias)
19 #define TEST_NODELABEL DT_NODELABEL(test_nodelabel)
20 #define TEST_INST DT_INST(0, vnd_gpio_device)
21 #define TEST_ARRAYS DT_NODELABEL(test_arrays)
22 #define TEST_PH DT_NODELABEL(test_phandles)
23 #define TEST_INTC DT_NODELABEL(test_intc)
24 #define TEST_IRQ DT_NODELABEL(test_irq)
25 #define TEST_IRQ_EXT DT_NODELABEL(test_irq_extended)
26 #define TEST_TEMP DT_NODELABEL(test_temp_sensor)
27 #define TEST_REG DT_NODELABEL(test_reg)
28 #define TEST_VENDOR DT_NODELABEL(test_vendor)
29 #define TEST_MODEL DT_NODELABEL(test_vendor)
30 #define TEST_ENUM_0 DT_NODELABEL(test_enum_0)
31 #define TEST_64BIT DT_NODELABEL(test_reg_64)
32 #define TEST_INTC DT_NODELABEL(test_intc)
33
34 #define TEST_I2C DT_NODELABEL(test_i2c)
35 #define TEST_I2C_DEV DT_PATH(test, i2c_11112222, test_i2c_dev_10)
36 #define TEST_I2C_BUS DT_BUS(TEST_I2C_DEV)
37
38 #define TEST_I2C_MUX DT_NODELABEL(test_i2c_mux)
39 #define TEST_I2C_MUX_CTLR_1 DT_CHILD(TEST_I2C_MUX, i2c_mux_ctlr_1)
40 #define TEST_I2C_MUX_CTLR_2 DT_CHILD(TEST_I2C_MUX, i2c_mux_ctlr_2)
41 #define TEST_MUXED_I2C_DEV_1 DT_NODELABEL(test_muxed_i2c_dev_1)
42 #define TEST_MUXED_I2C_DEV_2 DT_NODELABEL(test_muxed_i2c_dev_2)
43
44 #define TEST_I3C DT_NODELABEL(test_i3c)
45 #define TEST_I3C_DEV DT_PATH(test, i3c_88889999, test_i3c_dev_420000abcd12345678)
46 #define TEST_I3C_BUS DT_BUS(TEST_I3C_DEV)
47
48 #define TEST_GPIO_1 DT_NODELABEL(test_gpio_1)
49 #define TEST_GPIO_2 DT_NODELABEL(test_gpio_2)
50 #define TEST_GPIO_4 DT_NODELABEL(test_gpio_4)
51
52 #define TEST_GPIO_HOG_1 DT_PATH(test, gpio_deadbeef, test_gpio_hog_1)
53 #define TEST_GPIO_HOG_2 DT_PATH(test, gpio_deadbeef, test_gpio_hog_2)
54 #define TEST_GPIO_HOG_3 DT_PATH(test, gpio_abcd1234, test_gpio_hog_3)
55
56 #define TEST_SPI DT_NODELABEL(test_spi)
57
58 #define TEST_SPI_DEV_0 DT_PATH(test, spi_33334444, test_spi_dev_0)
59 #define TEST_SPI_BUS_0 DT_BUS(TEST_SPI_DEV_0)
60
61 #define TEST_SPI_DEV_1 DT_PATH(test, spi_33334444, test_spi_dev_1)
62 #define TEST_SPI_BUS_1 DT_BUS(TEST_SPI_DEV_1)
63
64 #define TEST_SPI_NO_CS DT_NODELABEL(test_spi_no_cs)
65 #define TEST_SPI_DEV_NO_CS DT_NODELABEL(test_spi_no_cs)
66
67 #define TEST_PWM_CTLR_1 DT_NODELABEL(test_pwm1)
68 #define TEST_PWM_CTLR_2 DT_NODELABEL(test_pwm2)
69
70 #define TEST_CAN_CTRL_0 DT_NODELABEL(test_can0)
71 #define TEST_CAN_CTRL_1 DT_NODELABEL(test_can1)
72 #define TEST_CAN_CTRL_2 DT_NODELABEL(test_can2)
73 #define TEST_CAN_CTRL_3 DT_NODELABEL(test_can3)
74
75 #define TEST_DMA_CTLR_1 DT_NODELABEL(test_dma1)
76 #define TEST_DMA_CTLR_2 DT_NODELABEL(test_dma2)
77
78 #define TEST_VIDEO2 DT_NODELABEL(test_video2)
79 #define TEST_VIDEO2_PORT0 DT_NODELABEL(test_video2_port0)
80 #define TEST_VIDEO2_PORT0_IN0 DT_NODELABEL(test_video2_port0_in0)
81 #define TEST_VIDEO2_PORT0_IN1 DT_NODELABEL(test_video2_port0_in1)
82 #define TEST_VIDEO2_PORT1 DT_NODELABEL(test_video2_port1)
83 #define TEST_VIDEO2_PORT1_IN DT_NODELABEL(test_video2_port1_in)
84 #define TEST_VIDEO0 DT_NODELABEL(test_video0)
85 #define TEST_VIDEO0_OUT DT_NODELABEL(test_video0_out)
86 #define TEST_VIDEO0_PORT DT_NODELABEL(test_video0_port)
87 #define TEST_VIDEO1 DT_NODELABEL(test_video1)
88 #define TEST_VIDEO1_OUT0 DT_NODELABEL(test_video1_out0)
89 #define TEST_VIDEO1_OUT1 DT_NODELABEL(test_video1_out1)
90 #define TEST_VIDEO1_PORT DT_NODELABEL(test_video1_port)
91
92 #define TEST_IO_CHANNEL_CTLR_1 DT_NODELABEL(test_adc_1)
93 #define TEST_IO_CHANNEL_CTLR_2 DT_NODELABEL(test_adc_2)
94
95 #define TEST_RANGES_PCIE DT_NODELABEL(test_ranges_pcie)
96 #define TEST_RANGES_OTHER DT_NODELABEL(test_ranges_other)
97 #define TEST_RANGES_EMPTY DT_NODELABEL(test_ranges_empty)
98
99 #define TEST_MTD_0 DT_PATH(test, test_mtd_ffeeddcc)
100 #define TEST_MTD_1 DT_PATH(test, test_mtd_33221100)
101
102 #define TEST_MEM_0 DT_CHILD(TEST_MTD_0, flash_20000000)
103
104 #define TEST_PARTITION_0 DT_PATH(test, test_mtd_ffeeddcc, flash_20000000, partitions, partition_0)
105 #define TEST_PARTITION_1 DT_PATH(test, test_mtd_ffeeddcc, flash_20000000, partitions, partition_c0)
106 #define TEST_PARTITION_2 DT_PATH(test, test_mtd_33221100, partitions, partition_6ff80)
107
108 #define TEST_SUBPARTITION_COMBINED DT_PATH(test, test_mtd_ffeeddcc, flash_20000000, partitions, \
109 partition_100)
110 #define TEST_SUBPARTITION_0 DT_PATH(test, test_mtd_ffeeddcc, flash_20000000, partitions, \
111 partition_100, partition_0)
112 #define TEST_SUBPARTITION_1 DT_PATH(test, test_mtd_ffeeddcc, flash_20000000, partitions, \
113 partition_100, partition_40)
114
115 #define ZEPHYR_USER DT_PATH(zephyr_user)
116
117 #define TA_HAS_COMPAT(compat) DT_NODE_HAS_COMPAT(TEST_ARRAYS, compat)
118
119 #define TO_STRING(x) TO_STRING_(x)
120 #define TO_STRING_(x) #x
121
ZTEST(devicetree_api,test_path_props)122 ZTEST(devicetree_api, test_path_props)
123 {
124 zassert_equal(DT_NUM_REGS(TEST_DEADBEEF), 1, "");
125 zassert_equal(DT_REG_ADDR(TEST_DEADBEEF), 0xdeadbeef, "");
126 zassert_equal(DT_REG_SIZE(TEST_DEADBEEF), 0x1000, "");
127 zassert_equal(DT_PROP(TEST_DEADBEEF, gpio_controller), 1, "");
128 zassert_equal(DT_PROP(TEST_DEADBEEF, ngpios), 100, "");
129 zassert_true(!strcmp(DT_PROP(TEST_DEADBEEF, status), "okay"), "");
130 zassert_equal(DT_PROP_LEN(TEST_DEADBEEF, compatible), 1, "");
131 zassert_true(!strcmp(DT_PROP_BY_IDX(TEST_DEADBEEF, compatible, 0),
132 "vnd,gpio-device"), "");
133 zassert_true(!strcmp(DT_PROP_LAST(TEST_DEADBEEF, compatible), "vnd,gpio-device"), "");
134 zassert_true(DT_NODE_HAS_PROP(TEST_DEADBEEF, status), "");
135 zassert_false(DT_NODE_HAS_PROP(TEST_DEADBEEF, foobar), "");
136
137 zassert_true(DT_SAME_NODE(TEST_ABCD1234, TEST_GPIO_2), "");
138 zassert_equal(DT_NUM_REGS(TEST_ABCD1234), 2, "");
139 zassert_equal(DT_PROP(TEST_ABCD1234, gpio_controller), 1, "");
140 zassert_equal(DT_PROP(TEST_ABCD1234, ngpios), 200, "");
141 zassert_true(!strcmp(DT_PROP(TEST_ABCD1234, status), "okay"), "");
142 zassert_equal(DT_PROP_LEN(TEST_ABCD1234, compatible), 1, "");
143 zassert_equal(DT_PROP_LEN_OR(TEST_ABCD1234, compatible, 4), 1, "");
144 zassert_equal(DT_PROP_LEN_OR(TEST_ABCD1234, invalid_property, 0), 0, "");
145 zassert_true(!strcmp(DT_PROP_BY_IDX(TEST_ABCD1234, compatible, 0),
146 "vnd,gpio-device"), "");
147 }
148
ZTEST(devicetree_api,test_alias_props)149 ZTEST(devicetree_api, test_alias_props)
150 {
151 zassert_equal(DT_HAS_ALIAS(test_alias), 1, "");
152 zassert_equal(DT_HAS_ALIAS(test_alias_none), 0, "");
153 zassert_equal(DT_NUM_REGS(TEST_ALIAS), 1, "");
154 zassert_equal(DT_REG_ADDR(TEST_ALIAS), 0xdeadbeef, "");
155 zassert_equal(DT_REG_SIZE(TEST_ALIAS), 0x1000, "");
156 zassert_true(DT_SAME_NODE(TEST_ALIAS, TEST_GPIO_1), "");
157 zassert_equal(DT_PROP(TEST_ALIAS, gpio_controller), 1, "");
158 zassert_equal(DT_PROP(TEST_ALIAS, ngpios), 100, "");
159 zassert_true(!strcmp(DT_PROP(TEST_ALIAS, status), "okay"), "");
160 zassert_equal(DT_PROP_LEN(TEST_ALIAS, compatible), 1, "");
161 zassert_true(!strcmp(DT_PROP_BY_IDX(TEST_ALIAS, compatible, 0),
162 "vnd,gpio-device"), "");
163 }
164
ZTEST(devicetree_api,test_nodelabel_props)165 ZTEST(devicetree_api, test_nodelabel_props)
166 {
167 zassert_equal(DT_NUM_REGS(TEST_NODELABEL), 1, "");
168 zassert_equal(DT_REG_ADDR(TEST_NODELABEL), 0xdeadbeef, "");
169 zassert_equal(DT_REG_SIZE(TEST_NODELABEL), 0x1000, "");
170 zassert_equal(DT_PROP(TEST_NODELABEL, gpio_controller), 1, "");
171 zassert_equal(DT_PROP(TEST_NODELABEL, ngpios), 100, "");
172 zassert_true(!strcmp(DT_PROP(TEST_NODELABEL, status), "okay"), "");
173 zassert_equal(DT_PROP_LEN(TEST_NODELABEL, compatible), 1, "");
174 zassert_true(!strcmp(DT_PROP_BY_IDX(TEST_NODELABEL, compatible, 0),
175 "vnd,gpio-device"), "");
176 zassert_equal(DT_PROP_LEN(TEST_ENUM_0, val), 1, "");
177 }
178
179 #undef DT_DRV_COMPAT
180 #define DT_DRV_COMPAT vnd_gpio_device
ZTEST(devicetree_api,test_inst_props)181 ZTEST(devicetree_api, test_inst_props)
182 {
183 /*
184 * Careful:
185 *
186 * We can only test properties that are shared across all
187 * instances of this compatible here. This includes instances
188 * with status "disabled".
189 */
190
191 zassert_equal(DT_PROP(TEST_INST, gpio_controller), 1, "");
192 zassert_true(!strcmp(DT_PROP(TEST_INST, status), "okay") ||
193 !strcmp(DT_PROP(TEST_INST, status), "disabled"), "");
194 zassert_equal(DT_PROP_LEN(TEST_INST, compatible), 1, "");
195 zassert_true(!strcmp(DT_PROP_BY_IDX(TEST_INST, compatible, 0),
196 "vnd,gpio-device"), "");
197
198 zassert_equal(DT_INST_NODE_HAS_PROP(0, gpio_controller), 1, "");
199 zassert_equal(DT_INST_PROP(0, gpio_controller), 1, "");
200 zassert_equal(DT_INST_NODE_HAS_PROP(0, xxxx), 0, "");
201 zassert_true(!strcmp(DT_INST_PROP(0, status), "okay") ||
202 !strcmp(DT_PROP(TEST_INST, status), "disabled"), "");
203 zassert_equal(DT_INST_PROP_LEN(0, compatible), 1, "");
204 zassert_true(!strcmp(DT_INST_PROP_BY_IDX(0, compatible, 0),
205 "vnd,gpio-device"), "");
206 }
207
208 #undef DT_DRV_COMPAT
209 #define DT_DRV_COMPAT vnd_device_with_props
ZTEST(devicetree_api,test_any_inst_prop)210 ZTEST(devicetree_api, test_any_inst_prop)
211 {
212 zassert_equal(DT_ANY_INST_HAS_PROP_STATUS_OKAY(foo), 1, "");
213 zassert_equal(DT_ANY_INST_HAS_PROP_STATUS_OKAY(bar), 1, "");
214 zassert_equal(DT_ANY_INST_HAS_PROP_STATUS_OKAY(baz), 0, "");
215 zassert_equal(DT_ANY_INST_HAS_PROP_STATUS_OKAY(does_not_exist), 0, "");
216
217 zassert_equal(COND_CODE_1(DT_ANY_INST_HAS_PROP_STATUS_OKAY(foo),
218 (5), (6)),
219 5, "");
220 zassert_equal(COND_CODE_0(DT_ANY_INST_HAS_PROP_STATUS_OKAY(foo),
221 (5), (6)),
222 6, "");
223 zassert_equal(COND_CODE_1(DT_ANY_INST_HAS_PROP_STATUS_OKAY(baz),
224 (5), (6)),
225 6, "");
226 zassert_equal(COND_CODE_0(DT_ANY_INST_HAS_PROP_STATUS_OKAY(baz),
227 (5), (6)),
228 5, "");
229 zassert_true(IS_ENABLED(DT_ANY_INST_HAS_PROP_STATUS_OKAY(foo)), "");
230 zassert_true(!IS_ENABLED(DT_ANY_INST_HAS_PROP_STATUS_OKAY(baz)), "");
231 zassert_equal(IF_ENABLED(DT_ANY_INST_HAS_PROP_STATUS_OKAY(foo), (1)) + 1,
232 2, "");
233 zassert_equal(IF_ENABLED(DT_ANY_INST_HAS_PROP_STATUS_OKAY(baz), (1)) + 1,
234 1, "");
235 }
236
ZTEST(devicetree_api,test_all_inst_prop)237 ZTEST(devicetree_api, test_all_inst_prop)
238 {
239 zassert_equal(DT_ALL_INST_HAS_PROP_STATUS_OKAY(foo), 1, "");
240 zassert_equal(DT_ALL_INST_HAS_PROP_STATUS_OKAY(bar), 0, "");
241 zassert_equal(DT_ALL_INST_HAS_PROP_STATUS_OKAY(baz), 0, "");
242 zassert_equal(DT_ALL_INST_HAS_PROP_STATUS_OKAY(does_not_exist), 0, "");
243
244 zassert_equal(COND_CODE_1(DT_ALL_INST_HAS_PROP_STATUS_OKAY(foo),
245 (5), (6)),
246 5, "");
247 zassert_equal(COND_CODE_0(DT_ALL_INST_HAS_PROP_STATUS_OKAY(foo),
248 (5), (6)),
249 6, "");
250 zassert_equal(COND_CODE_1(DT_ALL_INST_HAS_PROP_STATUS_OKAY(baz),
251 (5), (6)),
252 6, "");
253 zassert_equal(COND_CODE_0(DT_ALL_INST_HAS_PROP_STATUS_OKAY(baz),
254 (5), (6)),
255 5, "");
256 zassert_true(IS_ENABLED(DT_ALL_INST_HAS_PROP_STATUS_OKAY(foo)), "");
257 zassert_true(!IS_ENABLED(DT_ALL_INST_HAS_PROP_STATUS_OKAY(baz)), "");
258 zassert_equal(IF_ENABLED(DT_ALL_INST_HAS_PROP_STATUS_OKAY(foo), (1)) + 1,
259 2, "");
260 zassert_equal(IF_ENABLED(DT_ALL_INST_HAS_PROP_STATUS_OKAY(baz), (1)) + 1,
261 1, "");
262 }
263
264 #undef DT_DRV_COMPAT
ZTEST(devicetree_api,test_any_compat_inst_prop)265 ZTEST(devicetree_api, test_any_compat_inst_prop)
266 {
267 zassert_equal(DT_ANY_COMPAT_HAS_PROP_STATUS_OKAY(vnd_device_with_props, foo), 1, "");
268 zassert_equal(DT_ANY_COMPAT_HAS_PROP_STATUS_OKAY(vnd_device_with_props, bar), 1, "");
269 zassert_equal(DT_ANY_COMPAT_HAS_PROP_STATUS_OKAY(vnd_device_with_props, baz), 0, "");
270 zassert_equal(DT_ANY_COMPAT_HAS_PROP_STATUS_OKAY(vnd_device_with_props, does_not_exist),
271 0, "");
272 }
273
274 #undef DT_DRV_COMPAT
275 #define DT_DRV_COMPAT vnd_device_with_props
ZTEST(devicetree_api,test_any_inst_bool)276 ZTEST(devicetree_api, test_any_inst_bool)
277 {
278 zassert_equal(DT_ANY_INST_HAS_BOOL_STATUS_OKAY(bool_foo), 1, "");
279 zassert_equal(DT_ANY_INST_HAS_BOOL_STATUS_OKAY(bool_bar), 1, "");
280 zassert_equal(DT_ANY_INST_HAS_BOOL_STATUS_OKAY(bool_baz), 0, "");
281 zassert_equal(DT_ANY_INST_HAS_BOOL_STATUS_OKAY(does_not_exist), 0, "");
282
283 zassert_equal(COND_CODE_1(DT_ANY_INST_HAS_BOOL_STATUS_OKAY(bool_foo),
284 (5), (6)),
285 5, "");
286 zassert_equal(COND_CODE_0(DT_ANY_INST_HAS_BOOL_STATUS_OKAY(bool_foo),
287 (5), (6)),
288 6, "");
289 zassert_equal(COND_CODE_1(DT_ANY_INST_HAS_BOOL_STATUS_OKAY(bool_baz),
290 (5), (6)),
291 6, "");
292 zassert_equal(COND_CODE_0(DT_ANY_INST_HAS_BOOL_STATUS_OKAY(bool_baz),
293 (5), (6)),
294 5, "");
295 zassert_true(IS_ENABLED(DT_ANY_INST_HAS_BOOL_STATUS_OKAY(bool_foo)), "");
296 zassert_true(!IS_ENABLED(DT_ANY_INST_HAS_BOOL_STATUS_OKAY(bool_baz)), "");
297 zassert_equal(IF_ENABLED(DT_ANY_INST_HAS_BOOL_STATUS_OKAY(bool_foo), (1)) + 1,
298 2, "");
299 zassert_equal(IF_ENABLED(DT_ANY_INST_HAS_BOOL_STATUS_OKAY(bool_baz), (1)) + 1,
300 1, "");
301 }
302
ZTEST(devicetree_api,test_all_inst_bool)303 ZTEST(devicetree_api, test_all_inst_bool)
304 {
305 zassert_equal(DT_ALL_INST_HAS_BOOL_STATUS_OKAY(bool_foo), 1, "");
306 zassert_equal(DT_ALL_INST_HAS_BOOL_STATUS_OKAY(bool_bar), 0, "");
307 zassert_equal(DT_ALL_INST_HAS_BOOL_STATUS_OKAY(bool_baz), 0, "");
308 zassert_equal(DT_ALL_INST_HAS_BOOL_STATUS_OKAY(does_not_exist), 0, "");
309
310 zassert_equal(COND_CODE_1(DT_ALL_INST_HAS_BOOL_STATUS_OKAY(bool_foo),
311 (5), (6)),
312 5, "");
313 zassert_equal(COND_CODE_0(DT_ALL_INST_HAS_BOOL_STATUS_OKAY(bool_foo),
314 (5), (6)),
315 6, "");
316 zassert_equal(COND_CODE_1(DT_ALL_INST_HAS_BOOL_STATUS_OKAY(bool_baz),
317 (5), (6)),
318 6, "");
319 zassert_equal(COND_CODE_0(DT_ALL_INST_HAS_BOOL_STATUS_OKAY(bool_baz),
320 (5), (6)),
321 5, "");
322 zassert_true(IS_ENABLED(DT_ALL_INST_HAS_BOOL_STATUS_OKAY(bool_foo)), "");
323 zassert_true(!IS_ENABLED(DT_ALL_INST_HAS_BOOL_STATUS_OKAY(bool_baz)), "");
324 zassert_equal(IF_ENABLED(DT_ALL_INST_HAS_BOOL_STATUS_OKAY(bool_foo), (1)) + 1,
325 2, "");
326 zassert_equal(IF_ENABLED(DT_ALL_INST_HAS_BOOL_STATUS_OKAY(bool_baz), (1)) + 1,
327 1, "");
328 }
329
ZTEST(devicetree_api,test_default_prop_access)330 ZTEST(devicetree_api, test_default_prop_access)
331 {
332 /*
333 * The APIs guarantee that the default_value is not expanded
334 * if the relevant property or cell is defined. This "X" macro
335 * is meant as poison which causes (hopefully) easy to
336 * understand build errors if this guarantee is not met due to
337 * a regression.
338 */
339 #undef X
340 #define X do.not.expand.this.argument
341
342 /* Node identifier variants. */
343 zassert_equal(DT_PROP_OR(TEST_REG, misc_prop, X), 1234, "");
344 zassert_equal(DT_PROP_OR(TEST_REG, not_a_property, -1), -1, "");
345
346 zassert_equal(DT_PHA_BY_IDX_OR(TEST_TEMP, dmas, 1, channel, X), 3, "");
347 zassert_equal(DT_PHA_BY_IDX_OR(TEST_TEMP, dmas, 1, not_a_cell, -1), -1,
348 "");
349
350 zassert_equal(DT_PHA_OR(TEST_TEMP, dmas, channel, X), 1, "");
351 zassert_equal(DT_PHA_OR(TEST_TEMP, dmas, not_a_cell, -1), -1, "");
352
353 zassert_equal(DT_PHA_BY_NAME_OR(TEST_TEMP, dmas, tx, channel, X), 1,
354 "");
355 zassert_equal(DT_PHA_BY_NAME_OR(TEST_TEMP, dmas, tx, not_a_cell, -1),
356 -1, "");
357
358 /* Instance number variants. */
359 #undef DT_DRV_COMPAT
360 #define DT_DRV_COMPAT vnd_reg_holder
361 zassert_equal(DT_INST_PROP_OR(0, misc_prop, X), 1234, "");
362 zassert_equal(DT_INST_PROP_OR(0, not_a_property, -1), -1, "");
363
364 #undef DT_DRV_COMPAT
365 #define DT_DRV_COMPAT vnd_array_holder
366 zassert_equal(DT_INST_PROP_LEN_OR(0, a, X), 3, "");
367 zassert_equal(DT_INST_PROP_LEN_OR(0, not_a_property, -1), -1, "");
368
369 #undef DT_DRV_COMPAT
370 #define DT_DRV_COMPAT vnd_adc_temp_sensor
371 zassert_equal(DT_INST_PHA_BY_IDX_OR(0, dmas, 1, channel, X), 3, "");
372 zassert_equal(DT_INST_PHA_BY_IDX_OR(0, dmas, 1, not_a_cell, -1), -1,
373 "");
374
375 zassert_equal(DT_INST_PHA_OR(0, dmas, channel, X), 1, "");
376 zassert_equal(DT_INST_PHA_OR(0, dmas, not_a_cell, -1), -1, "");
377
378 zassert_equal(DT_INST_PHA_BY_NAME_OR(0, dmas, tx, channel, X), 1,
379 "");
380 zassert_equal(DT_INST_PHA_BY_NAME_OR(0, dmas, tx, not_a_cell, -1), -1,
381 "");
382
383 #undef X
384 }
385
ZTEST(devicetree_api,test_has_path)386 ZTEST(devicetree_api, test_has_path)
387 {
388 zassert_equal(DT_NODE_HAS_STATUS(DT_PATH(test, gpio_0), okay), 0, "");
389 zassert_equal(DT_NODE_HAS_STATUS(DT_PATH(test, gpio_deadbeef), okay), 1,
390 "");
391 zassert_equal(DT_NODE_HAS_STATUS(DT_PATH(test, gpio_abcd1234), okay), 1,
392 "");
393 }
394
ZTEST(devicetree_api,test_has_alias)395 ZTEST(devicetree_api, test_has_alias)
396 {
397 zassert_equal(DT_NODE_HAS_STATUS(DT_ALIAS(test_alias), okay), 1, "");
398 zassert_equal(DT_NODE_HAS_STATUS(DT_ALIAS(test_undef), okay), 0, "");
399 }
400
ZTEST(devicetree_api,test_node_hashes)401 ZTEST(devicetree_api, test_node_hashes)
402 {
403 zassert_str_equal(TO_STRING(DT_NODE_HASH(DT_ROOT)),
404 "il7asoJjJEMhngUeSt4tHVu8Zxx4EFG_FDeJfL3_oPE");
405 zassert_str_equal(TO_STRING(DT_NODE_HASH(TEST_DEADBEEF)),
406 "kPPqtBX5DX_QDQMO0_cOls2ebJMevAWHhAPY1JCKTyU");
407 zassert_str_equal(TO_STRING(DT_NODE_HASH(TEST_ABCD1234)),
408 "Bk4fvF6o3Mgslz_xiIZaJcuwo6_IeelozwOaxtUsSos");
409 }
410
ZTEST(devicetree_api,test_inst_checks)411 ZTEST(devicetree_api, test_inst_checks)
412 {
413 zassert_equal(DT_NODE_EXISTS(DT_INST(0, vnd_gpio_device)), 1, "");
414 zassert_equal(DT_NODE_EXISTS(DT_INST(1, vnd_gpio_device)), 1, "");
415 zassert_equal(DT_NODE_EXISTS(DT_INST(2, vnd_gpio_device)), 1, "");
416
417 zassert_equal(DT_NUM_INST_STATUS_OKAY(vnd_gpio_device), 2, "");
418 zassert_equal(DT_NUM_INST_STATUS_OKAY(xxxx), 0, "");
419 }
420
ZTEST(devicetree_api,test_has_nodelabel)421 ZTEST(devicetree_api, test_has_nodelabel)
422 {
423 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(disabled_gpio), okay), 0,
424 "");
425 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(test_nodelabel), okay), 1,
426 "");
427 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(test_nodelabel_allcaps),
428 okay),
429 1, "");
430 }
431
ZTEST(devicetree_api,test_has_compat)432 ZTEST(devicetree_api, test_has_compat)
433 {
434 unsigned int compats;
435
436 zassert_true(DT_HAS_COMPAT_STATUS_OKAY(vnd_gpio_device), "");
437 zassert_true(DT_HAS_COMPAT_STATUS_OKAY(vnd_gpio_device), "");
438 zassert_false(DT_HAS_COMPAT_STATUS_OKAY(vnd_disabled_compat), "");
439 zassert_false(DT_HAS_COMPAT_STATUS_OKAY(vnd_reserved_compat), "");
440
441 zassert_equal(TA_HAS_COMPAT(vnd_array_holder), 1, "");
442 zassert_equal(TA_HAS_COMPAT(vnd_undefined_compat), 1, "");
443 zassert_equal(TA_HAS_COMPAT(vnd_not_a_test_array_compat), 0, "");
444 compats = ((TA_HAS_COMPAT(vnd_array_holder) << 0) |
445 (TA_HAS_COMPAT(vnd_undefined_compat) << 1) |
446 (TA_HAS_COMPAT(vnd_not_a_test_array_compat) << 2));
447 zassert_equal(compats, 0x3, "");
448
449 #undef DT_DRV_COMPAT
450 #define DT_DRV_COMPAT vnd_model1
451 zassert_true(DT_INST_NODE_HAS_COMPAT(0, zephyr_model2));
452 }
453
ZTEST(devicetree_api,test_has_status)454 ZTEST(devicetree_api, test_has_status)
455 {
456 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(test_gpio_1), okay),
457 1, "");
458 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(test_gpio_1), disabled),
459 0, "");
460 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(test_gpio_1), reserved),
461 0, "");
462
463 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(test_no_status), okay),
464 1, "");
465 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(test_no_status), disabled),
466 0, "");
467 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(test_no_status), reserved),
468 0, "");
469
470 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(disabled_gpio), disabled),
471 1, "");
472 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(disabled_gpio), okay),
473 0, "");
474 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(disabled_gpio), reserved),
475 0, "");
476
477 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(reserved_gpio), reserved),
478 1, "");
479 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(reserved_gpio), disabled),
480 0, "");
481 zassert_equal(DT_NODE_HAS_STATUS(DT_NODELABEL(reserved_gpio), okay),
482 0, "");
483 }
484
ZTEST(devicetree_api,test_has_status_okay)485 ZTEST(devicetree_api, test_has_status_okay)
486 {
487 zassert_equal(DT_NODE_HAS_STATUS_OKAY(DT_NODELABEL(test_gpio_1)), 1);
488
489 zassert_equal(DT_NODE_HAS_STATUS_OKAY(DT_NODELABEL(test_no_status)), 1);
490
491 zassert_equal(DT_NODE_HAS_STATUS_OKAY(DT_NODELABEL(disabled_gpio)), 0);
492
493 zassert_equal(DT_NODE_HAS_STATUS_OKAY(DT_NODELABEL(reserved_gpio)), 0);
494 }
495
ZTEST(devicetree_api,test_bus)496 ZTEST(devicetree_api, test_bus)
497 {
498 int pin, flags;
499
500 zassert_true(DT_SAME_NODE(TEST_I3C_BUS, TEST_I3C), "");
501 zassert_true(DT_SAME_NODE(TEST_I2C_BUS, TEST_I2C), "");
502 zassert_true(DT_SAME_NODE(TEST_SPI_BUS_0, TEST_SPI), "");
503 zassert_true(DT_SAME_NODE(TEST_SPI_BUS_1, TEST_SPI), "");
504
505 zassert_equal(DT_SPI_DEV_HAS_CS_GPIOS(TEST_SPI_DEV_0), 1, "");
506 zassert_equal(DT_SPI_DEV_HAS_CS_GPIOS(TEST_SPI_DEV_NO_CS), 0, "");
507
508 /* Test a nested I2C bus using vnd,i2c-mux. */
509 zassert_true(DT_SAME_NODE(TEST_I2C_MUX_CTLR_1,
510 DT_BUS(TEST_MUXED_I2C_DEV_1)), "");
511 zassert_true(DT_SAME_NODE(TEST_I2C_MUX_CTLR_2,
512 DT_BUS(TEST_MUXED_I2C_DEV_2)), "");
513
514 #undef DT_DRV_COMPAT
515 #define DT_DRV_COMPAT vnd_spi_device_2
516 /* there is only one instance, and it has no CS */
517 zassert_equal(DT_INST_SPI_DEV_HAS_CS_GPIOS(0), 0, "");
518 /* since there's only one instance, we also know its bus. */
519 zassert_true(DT_SAME_NODE(TEST_SPI_NO_CS, DT_INST_BUS(0)),
520 "expected TEST_SPI_NO_CS as bus for vnd,spi-device-2");
521
522 #undef DT_DRV_COMPAT
523 #define DT_DRV_COMPAT vnd_spi_device
524 /*
525 * DT_INST_SPI_DEV: use with care here. We could be matching
526 * either vnd,spi-device.
527 */
528 zassert_equal(DT_INST_SPI_DEV_HAS_CS_GPIOS(0), 1, "");
529
530 #define CTLR_NODE DT_INST_SPI_DEV_CS_GPIOS_CTLR(0)
531 zassert_true(DT_SAME_NODE(CTLR_NODE, DT_NODELABEL(test_gpio_1)) ||
532 DT_SAME_NODE(CTLR_NODE, DT_NODELABEL(test_gpio_2)), "");
533 #undef CTLR_NODE
534
535 pin = DT_INST_SPI_DEV_CS_GPIOS_PIN(0);
536 zassert_true((pin == 0x10) || (pin == 0x30), "");
537
538 flags = DT_INST_SPI_DEV_CS_GPIOS_FLAGS(0);
539 zassert_true((flags == 0x20) || (flags == 0x40), "");
540
541 zassert_equal(DT_ON_BUS(TEST_SPI_DEV_0, spi), 1, "");
542 zassert_equal(DT_ON_BUS(TEST_SPI_DEV_0, i2c), 0, "");
543 zassert_equal(DT_ON_BUS(TEST_SPI_DEV_0, i3c), 0, "");
544
545 zassert_equal(DT_ON_BUS(TEST_I2C_DEV, i2c), 1, "");
546 zassert_equal(DT_ON_BUS(TEST_I2C_DEV, i3c), 0, "");
547 zassert_equal(DT_ON_BUS(TEST_I2C_DEV, spi), 0, "");
548
549 #undef DT_DRV_COMPAT
550 #define DT_DRV_COMPAT vnd_spi_device
551 zassert_equal(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT), 2, "");
552
553 zassert_equal(DT_INST_ON_BUS(0, spi), 1, "");
554 zassert_equal(DT_INST_ON_BUS(0, i2c), 0, "");
555 zassert_equal(DT_INST_ON_BUS(0, i3c), 0, "");
556
557 zassert_equal(DT_ANY_INST_ON_BUS_STATUS_OKAY(spi), 1, "");
558 zassert_equal(DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c), 0, "");
559 zassert_equal(DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c), 0, "");
560
561 #undef DT_DRV_COMPAT
562 #define DT_DRV_COMPAT vnd_i2c_device
563 zassert_equal(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT), 2, "");
564
565 zassert_equal(DT_INST_ON_BUS(0, i2c), 1, "");
566 zassert_equal(DT_INST_ON_BUS(0, i3c), 0, "");
567 zassert_equal(DT_INST_ON_BUS(0, spi), 0, "");
568
569 zassert_equal(DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c), 1, "");
570 zassert_equal(DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c), 0, "");
571 zassert_equal(DT_ANY_INST_ON_BUS_STATUS_OKAY(spi), 0, "");
572
573 #undef DT_DRV_COMPAT
574 #define DT_DRV_COMPAT vnd_i3c_device
575 zassert_equal(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT), 1, "");
576
577 zassert_equal(DT_INST_ON_BUS(0, i2c), 1, "");
578 zassert_equal(DT_INST_ON_BUS(0, i3c), 1, "");
579 zassert_equal(DT_INST_ON_BUS(0, spi), 0, "");
580
581 zassert_equal(DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c), 1, "");
582 zassert_equal(DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c), 1, "");
583 zassert_equal(DT_ANY_INST_ON_BUS_STATUS_OKAY(spi), 0, "");
584
585 #undef DT_DRV_COMPAT
586 #define DT_DRV_COMPAT vnd_i3c_i2c_device
587 zassert_equal(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT), 1, "");
588
589 zassert_equal(DT_INST_ON_BUS(0, i2c), 1, "");
590 zassert_equal(DT_INST_ON_BUS(0, i3c), 1, "");
591 zassert_equal(DT_INST_ON_BUS(0, spi), 0, "");
592
593 zassert_equal(DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c), 1, "");
594 zassert_equal(DT_ANY_INST_ON_BUS_STATUS_OKAY(i3c), 1, "");
595 zassert_equal(DT_ANY_INST_ON_BUS_STATUS_OKAY(spi), 0, "");
596
597 #undef DT_DRV_COMPAT
598
599 /*
600 * Make sure the underlying DT_HAS_COMPAT_ON_BUS_STATUS_OKAY used by
601 * DT_ANY_INST_ON_BUS works without DT_DRV_COMPAT defined.
602 */
603 zassert_equal(DT_HAS_COMPAT_ON_BUS_STATUS_OKAY(vnd_spi_device, spi), 1);
604 zassert_equal(DT_HAS_COMPAT_ON_BUS_STATUS_OKAY(vnd_spi_device, i2c), 0);
605
606 zassert_equal(DT_HAS_COMPAT_ON_BUS_STATUS_OKAY(vnd_i2c_device, i2c), 1);
607 zassert_equal(DT_HAS_COMPAT_ON_BUS_STATUS_OKAY(vnd_i2c_device, spi), 0);
608
609 zassert_equal(DT_HAS_COMPAT_ON_BUS_STATUS_OKAY(vnd_gpio_expander, i2c), 1);
610 zassert_equal(DT_HAS_COMPAT_ON_BUS_STATUS_OKAY(vnd_gpio_expander, spi), 1);
611 }
612
613 #undef DT_DRV_COMPAT
614 #define DT_DRV_COMPAT vnd_vendor
615
616 #define VND_VENDOR "A stand-in for a real vendor which can be used in examples and tests"
617 #define ZEP_VENDOR "The Zephyr Project"
618
ZTEST(devicetree_api,test_vendor)619 ZTEST(devicetree_api, test_vendor)
620 {
621 /* DT_NODE_VENDOR_HAS_IDX */
622 zassert_true(DT_NODE_VENDOR_HAS_IDX(TEST_VENDOR, 0), "");
623 zassert_false(DT_NODE_VENDOR_HAS_IDX(TEST_VENDOR, 1), "");
624 zassert_true(DT_NODE_VENDOR_HAS_IDX(TEST_VENDOR, 2), "");
625 zassert_false(DT_NODE_VENDOR_HAS_IDX(TEST_VENDOR, 3), "");
626
627 /* DT_NODE_VENDOR_BY_IDX */
628 zassert_true(!strcmp(DT_NODE_VENDOR_BY_IDX(TEST_VENDOR, 0), VND_VENDOR), "");
629 zassert_true(!strcmp(DT_NODE_VENDOR_BY_IDX(TEST_VENDOR, 2), ZEP_VENDOR), "");
630
631 /* DT_NODE_VENDOR_BY_IDX_OR */
632 zassert_true(!strcmp(DT_NODE_VENDOR_BY_IDX_OR(TEST_VENDOR, 0, NULL), VND_VENDOR), "");
633 zassert_is_null(DT_NODE_VENDOR_BY_IDX_OR(TEST_VENDOR, 1, NULL), "");
634 zassert_true(!strcmp(DT_NODE_VENDOR_BY_IDX_OR(TEST_VENDOR, 2, NULL), ZEP_VENDOR), "");
635 zassert_is_null(DT_NODE_VENDOR_BY_IDX_OR(TEST_VENDOR, 3, NULL), "");
636
637 /* DT_NODE_VENDOR_OR */
638 zassert_true(!strcmp(DT_NODE_VENDOR_OR(TEST_VENDOR, NULL), VND_VENDOR), "");
639 }
640
641 #define VND_MODEL "model1"
642 #define ZEP_MODEL "model2"
643
ZTEST(devicetree_api,test_model)644 ZTEST(devicetree_api, test_model)
645 {
646 /* DT_NODE_MODEL_HAS_IDX */
647 zassert_true(DT_NODE_MODEL_HAS_IDX(TEST_MODEL, 0), "");
648 zassert_false(DT_NODE_MODEL_HAS_IDX(TEST_MODEL, 1), "");
649 zassert_true(DT_NODE_MODEL_HAS_IDX(TEST_MODEL, 2), "");
650 zassert_false(DT_NODE_MODEL_HAS_IDX(TEST_MODEL, 3), "");
651
652 /* DT_NODE_MODEL_BY_IDX */
653 zassert_true(!strcmp(DT_NODE_MODEL_BY_IDX(TEST_MODEL, 0), VND_MODEL), "");
654 zassert_true(!strcmp(DT_NODE_MODEL_BY_IDX(TEST_MODEL, 2), ZEP_MODEL), "");
655
656 /* DT_NODE_MODEL_BY_IDX_OR */
657 zassert_true(!strcmp(DT_NODE_MODEL_BY_IDX_OR(TEST_MODEL, 0, NULL), VND_MODEL), "");
658 zassert_is_null(DT_NODE_MODEL_BY_IDX_OR(TEST_MODEL, 1, NULL), "");
659 zassert_true(!strcmp(DT_NODE_MODEL_BY_IDX_OR(TEST_MODEL, 2, NULL), ZEP_MODEL), "");
660 zassert_is_null(DT_NODE_MODEL_BY_IDX_OR(TEST_MODEL, 3, NULL), "");
661
662 /* DT_NODE_MODEL_OR */
663 zassert_true(!strcmp(DT_NODE_MODEL_OR(TEST_MODEL, NULL), VND_MODEL), "");
664 }
665
666 #undef ZEP_MODEL
667 #undef VND_MODEL
668
669 #undef DT_DRV_COMPAT
670 #define DT_DRV_COMPAT vnd_reg_holder
ZTEST(devicetree_api,test_reg)671 ZTEST(devicetree_api, test_reg)
672 {
673 /* DT_REG_HAS_IDX */
674 zassert_true(DT_REG_HAS_IDX(TEST_ABCD1234, 0), "");
675 zassert_true(DT_REG_HAS_IDX(TEST_ABCD1234, 1), "");
676 zassert_false(DT_REG_HAS_IDX(TEST_ABCD1234, 2), "");
677
678 /* DT_REG_HAS_NAME */
679 zassert_true(DT_REG_HAS_NAME(TEST_ABCD1234, one), "");
680 zassert_true(DT_REG_HAS_NAME(TEST_ABCD1234, two), "");
681 zassert_false(DT_REG_HAS_NAME(TEST_ABCD1234, three), "");
682
683 /* DT_REG_ADDR_BY_IDX */
684 zassert_equal(DT_REG_ADDR_BY_IDX(TEST_ABCD1234, 0), 0xabcd1234, "");
685 zassert_equal(DT_REG_ADDR_BY_IDX(TEST_ABCD1234, 1), 0x98765432, "");
686
687 /* DT_REG_SIZE_BY_IDX */
688 zassert_equal(DT_REG_SIZE_BY_IDX(TEST_ABCD1234, 0), 0x500, "");
689 zassert_equal(DT_REG_SIZE_BY_IDX(TEST_ABCD1234, 1), 0xff, "");
690
691 /* DT_REG_ADDR */
692 zassert_equal(DT_REG_ADDR(TEST_ABCD1234), 0xabcd1234, "");
693
694 /* DT_REG_ADDR_U64 */
695 zassert_equal(DT_REG_ADDR_U64(TEST_ABCD1234), 0xabcd1234, "");
696
697 /* DT_REG_SIZE */
698 zassert_equal(DT_REG_SIZE(TEST_ABCD1234), 0x500, "");
699
700 /* DT_REG_ADDR_BY_NAME */
701 zassert_equal(DT_REG_ADDR_BY_NAME(TEST_ABCD1234, one), 0xabcd1234, "");
702 zassert_equal(DT_REG_ADDR_BY_NAME(TEST_ABCD1234, two), 0x98765432, "");
703
704 /* DT_REG_ADDR_BY_NAME_OR */
705 zassert_equal(DT_REG_ADDR_BY_NAME_OR(TEST_ABCD1234, one, 0x10), 0xabcd1234, "");
706 zassert_equal(DT_REG_ADDR_BY_NAME_OR(TEST_ABCD1234, two, 0x11), 0x98765432, "");
707 zassert_equal(DT_REG_ADDR_BY_NAME_OR(TEST_ABCD1234, three, 0x12), 0x12, "");
708
709 /* DT_REG_ADDR_BY_NAME_U64 */
710 zassert_equal(DT_REG_ADDR_BY_NAME_U64(TEST_ABCD1234, one), 0xabcd1234, "");
711 zassert_equal(DT_REG_ADDR_BY_NAME_U64(TEST_ABCD1234, two), 0x98765432, "");
712
713 /* DT_REG_SIZE_BY_NAME */
714 zassert_equal(DT_REG_SIZE_BY_NAME(TEST_ABCD1234, one), 0x500, "");
715 zassert_equal(DT_REG_SIZE_BY_NAME(TEST_ABCD1234, two), 0xff, "");
716
717 /* DT_REG_SIZE_BY_NAME_OR */
718 zassert_equal(DT_REG_SIZE_BY_NAME_OR(TEST_ABCD1234, one, 0x10), 0x500, "");
719 zassert_equal(DT_REG_SIZE_BY_NAME_OR(TEST_ABCD1234, two, 0x11), 0xff, "");
720 zassert_equal(DT_REG_SIZE_BY_NAME_OR(TEST_ABCD1234, three, 0x12), 0x12, "");
721
722 /* DT_INST */
723 zassert_equal(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT), 1, "");
724
725 /* DT_INST_REG_HAS_IDX */
726 zassert_true(DT_INST_REG_HAS_IDX(0, 0), "");
727 zassert_true(DT_INST_REG_HAS_IDX(0, 1), "");
728 zassert_false(DT_INST_REG_HAS_IDX(0, 2), "");
729
730 /* DT_INST_REG_HAS_NAME */
731 zassert_true(DT_INST_REG_HAS_NAME(0, first), "");
732 zassert_true(DT_INST_REG_HAS_NAME(0, second), "");
733 zassert_false(DT_INST_REG_HAS_NAME(0, third), "");
734
735 /* DT_INST_REG_ADDR_BY_IDX */
736 zassert_equal(DT_INST_REG_ADDR_BY_IDX(0, 0), 0x9999aaaa, "");
737 zassert_equal(DT_INST_REG_ADDR_BY_IDX(0, 1), 0xbbbbcccc, "");
738
739 /* DT_INST_REG_SIZE_BY_IDX */
740 zassert_equal(DT_INST_REG_SIZE_BY_IDX(0, 0), 0x1000, "");
741 zassert_equal(DT_INST_REG_SIZE_BY_IDX(0, 1), 0x3f, "");
742
743 /* DT_INST_REG_ADDR */
744 zassert_equal(DT_INST_REG_ADDR(0), 0x9999aaaa, "");
745
746 /* DT_INST_REG_ADDR_U64 */
747 zassert_equal(DT_INST_REG_ADDR_U64(0), 0x9999aaaa, "");
748
749 /* DT_INST_REG_SIZE */
750 zassert_equal(DT_INST_REG_SIZE(0), 0x1000, "");
751
752 /* DT_INST_REG_ADDR_BY_NAME */
753 zassert_equal(DT_INST_REG_ADDR_BY_NAME(0, first), 0x9999aaaa, "");
754 zassert_equal(DT_INST_REG_ADDR_BY_NAME(0, second), 0xbbbbcccc, "");
755
756 /* DT_INST_REG_ADDR_BY_NAME_OR */
757 zassert_equal(DT_INST_REG_ADDR_BY_NAME_OR(0, first, 0x10), 0x9999aaaa, "");
758 zassert_equal(DT_INST_REG_ADDR_BY_NAME_OR(0, second, 0x11), 0xbbbbcccc, "");
759 zassert_equal(DT_INST_REG_SIZE_BY_NAME_OR(0, third, 0x12), 0x12, "");
760
761 /* DT_INST_REG_ADDR_BY_NAME_U64 */
762 zassert_equal(DT_INST_REG_ADDR_BY_NAME_U64(0, first), 0x9999aaaa, "");
763 zassert_equal(DT_INST_REG_ADDR_BY_NAME_U64(0, second), 0xbbbbcccc, "");
764
765 /* DT_INST_REG_SIZE_BY_NAME */
766 zassert_equal(DT_INST_REG_SIZE_BY_NAME(0, first), 0x1000, "");
767 zassert_equal(DT_INST_REG_SIZE_BY_NAME(0, second), 0x3f, "");
768
769 /* DT_REG_SIZE_BY_NAME_OR */
770 zassert_equal(DT_INST_REG_SIZE_BY_NAME_OR(0, first, 0x10), 0x1000, "");
771 zassert_equal(DT_INST_REG_SIZE_BY_NAME_OR(0, second, 0x11), 0x3f, "");
772 zassert_equal(DT_INST_REG_SIZE_BY_NAME_OR(0, third, 0x12), 0x12, "");
773 }
774
775 #undef DT_DRV_COMPAT
776 #define DT_DRV_COMPAT vnd_reg_holder_64
ZTEST(devicetree_api,test_reg_64)777 ZTEST(devicetree_api, test_reg_64)
778 {
779 /* DT_REG_ADDR_U64 */
780 zassert_equal(DT_REG_ADDR_U64(TEST_64BIT), 0xffffffff11223344, "");
781
782 /* DT_REG_ADDR_BY_NAME_U64 */
783 zassert_equal(DT_REG_ADDR_BY_NAME_U64(TEST_64BIT, test_name), 0xffffffff11223344, "");
784
785 /* DT_INST_REG_ADDR_U64 */
786 zassert_equal(DT_INST_REG_ADDR_U64(0), 0xffffffff11223344, "");
787
788 /* DT_INST_REG_ADDR_BY_NAME_U64 */
789 zassert_equal(DT_INST_REG_ADDR_BY_NAME_U64(0, test_name), 0xffffffff11223344, "");
790 }
791
792 #undef DT_DRV_COMPAT
793 #define DT_DRV_COMPAT vnd_interrupt_holder
ZTEST(devicetree_api,test_irq)794 ZTEST(devicetree_api, test_irq)
795 {
796 /* DT_NUM_IRQS */
797 zassert_equal(DT_NUM_IRQS(TEST_DEADBEEF), 1, "");
798 zassert_equal(DT_NUM_IRQS(TEST_I2C_BUS), 2, "");
799 zassert_equal(DT_NUM_IRQS(TEST_SPI), 3, "");
800
801 /* DT_IRQ_HAS_IDX */
802 zassert_true(DT_IRQ_HAS_IDX(TEST_SPI_BUS_0, 0), "");
803 zassert_true(DT_IRQ_HAS_IDX(TEST_SPI_BUS_0, 1), "");
804 zassert_true(DT_IRQ_HAS_IDX(TEST_SPI_BUS_0, 2), "");
805 zassert_false(DT_IRQ_HAS_IDX(TEST_SPI_BUS_0, 3), "");
806
807 zassert_true(DT_IRQ_HAS_IDX(TEST_DEADBEEF, 0), "");
808 zassert_false(DT_IRQ_HAS_IDX(TEST_DEADBEEF, 1), "");
809
810 zassert_true(DT_IRQ_HAS_IDX(TEST_I2C_BUS, 0), "");
811 zassert_true(DT_IRQ_HAS_IDX(TEST_I2C_BUS, 1), "");
812 zassert_false(DT_IRQ_HAS_IDX(TEST_I2C_BUS, 2), "");
813
814 /* DT_IRQ_BY_IDX */
815 zassert_equal(DT_IRQ_BY_IDX(TEST_SPI_BUS_0, 0, irq), 8, "");
816 zassert_equal(DT_IRQ_BY_IDX(TEST_SPI_BUS_0, 1, irq), 9, "");
817 zassert_equal(DT_IRQ_BY_IDX(TEST_SPI_BUS_0, 2, irq), 10, "");
818 zassert_equal(DT_IRQ_BY_IDX(TEST_SPI_BUS_0, 0, priority), 3, "");
819 zassert_equal(DT_IRQ_BY_IDX(TEST_SPI_BUS_0, 1, priority), 0, "");
820 zassert_equal(DT_IRQ_BY_IDX(TEST_SPI_BUS_0, 2, priority), 1, "");
821
822 /* DT_IRQ_BY_NAME */
823 zassert_equal(DT_IRQ_BY_NAME(TEST_I2C_BUS, status, irq), 6, "");
824 zassert_equal(DT_IRQ_BY_NAME(TEST_I2C_BUS, error, irq), 7, "");
825 zassert_equal(DT_IRQ_BY_NAME(TEST_I2C_BUS, status, priority), 2, "");
826 zassert_equal(DT_IRQ_BY_NAME(TEST_I2C_BUS, error, priority), 1, "");
827
828 /* DT_IRQ_HAS_CELL_AT_IDX */
829 zassert_true(DT_IRQ_HAS_CELL_AT_IDX(TEST_IRQ, 0, irq), "");
830 zassert_true(DT_IRQ_HAS_CELL_AT_IDX(TEST_IRQ, 0, priority), "");
831 zassert_false(DT_IRQ_HAS_CELL_AT_IDX(TEST_IRQ, 0, foo), "");
832 zassert_true(DT_IRQ_HAS_CELL_AT_IDX(TEST_IRQ, 2, irq), "");
833 zassert_true(DT_IRQ_HAS_CELL_AT_IDX(TEST_IRQ, 2, priority), "");
834 zassert_false(DT_IRQ_HAS_CELL_AT_IDX(TEST_IRQ, 2, foo), "");
835
836 /* DT_IRQ_HAS_CELL */
837 zassert_true(DT_IRQ_HAS_CELL(TEST_IRQ, irq), "");
838 zassert_true(DT_IRQ_HAS_CELL(TEST_IRQ, priority), "");
839 zassert_false(DT_IRQ_HAS_CELL(TEST_IRQ, foo), "");
840
841 /* DT_IRQ_HAS_NAME */
842 zassert_true(DT_IRQ_HAS_NAME(TEST_IRQ, err), "");
843 zassert_true(DT_IRQ_HAS_NAME(TEST_IRQ, stat), "");
844 zassert_true(DT_IRQ_HAS_NAME(TEST_IRQ, done), "");
845 zassert_false(DT_IRQ_HAS_NAME(TEST_IRQ, alpha), "");
846
847 /* DT_IRQ */
848 zassert_equal(DT_IRQ(TEST_I2C_BUS, irq), 6, "");
849 zassert_equal(DT_IRQ(TEST_I2C_BUS, priority), 2, "");
850
851 /* DT_IRQN */
852 #ifndef CONFIG_MULTI_LEVEL_INTERRUPTS
853 zassert_equal(DT_IRQN(TEST_I2C_BUS), 6, "");
854 zassert_equal(DT_IRQN(DT_INST(0, DT_DRV_COMPAT)), 30, "");
855 #else
856 zassert_equal(DT_IRQN(TEST_I2C_BUS),
857 ((6 + 1) << CONFIG_1ST_LEVEL_INTERRUPT_BITS) | 11, "");
858 zassert_equal(DT_IRQN(DT_INST(0, DT_DRV_COMPAT)),
859 ((30 + 1) << CONFIG_1ST_LEVEL_INTERRUPT_BITS) | 11, "");
860 #endif
861
862 /* DT_IRQN_BY_IDX */
863 #ifndef CONFIG_MULTI_LEVEL_INTERRUPTS
864 zassert_equal(DT_IRQN_BY_IDX(DT_INST(0, DT_DRV_COMPAT), 0), 30, "");
865 zassert_equal(DT_IRQN_BY_IDX(DT_INST(0, DT_DRV_COMPAT), 1), 40, "");
866 zassert_equal(DT_IRQN_BY_IDX(DT_INST(0, DT_DRV_COMPAT), 2), 60, "");
867 #else
868 zassert_equal(DT_IRQN_BY_IDX(DT_INST(0, DT_DRV_COMPAT), 0),
869 ((30 + 1) << CONFIG_1ST_LEVEL_INTERRUPT_BITS) | 11, "");
870 zassert_equal(DT_IRQN_BY_IDX(DT_INST(0, DT_DRV_COMPAT), 1),
871 ((40 + 1) << CONFIG_1ST_LEVEL_INTERRUPT_BITS) | 11, "");
872 zassert_equal(DT_IRQN_BY_IDX(DT_INST(0, DT_DRV_COMPAT), 2),
873 ((60 + 1) << CONFIG_1ST_LEVEL_INTERRUPT_BITS) | 11, "");
874 #endif
875
876 /* DT_INST */
877 zassert_equal(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT), 1, "");
878
879 /* DT_INST_NUM_IRQS */
880 zassert_equal(DT_INST_NUM_IRQS(0), 3);
881
882 /* DT_INST_IRQ_HAS_IDX */
883 zassert_equal(DT_INST_IRQ_HAS_IDX(0, 0), 1, "");
884 zassert_equal(DT_INST_IRQ_HAS_IDX(0, 1), 1, "");
885 zassert_equal(DT_INST_IRQ_HAS_IDX(0, 2), 1, "");
886 zassert_equal(DT_INST_IRQ_HAS_IDX(0, 3), 0, "");
887
888 /* DT_INST_IRQ_BY_IDX */
889 zassert_equal(DT_INST_IRQ_BY_IDX(0, 0, irq), 30, "");
890 zassert_equal(DT_INST_IRQ_BY_IDX(0, 1, irq), 40, "");
891 zassert_equal(DT_INST_IRQ_BY_IDX(0, 2, irq), 60, "");
892 zassert_equal(DT_INST_IRQ_BY_IDX(0, 0, priority), 3, "");
893 zassert_equal(DT_INST_IRQ_BY_IDX(0, 1, priority), 5, "");
894 zassert_equal(DT_INST_IRQ_BY_IDX(0, 2, priority), 7, "");
895
896 /* DT_INST_IRQ_BY_NAME */
897 zassert_equal(DT_INST_IRQ_BY_NAME(0, err, irq), 30, "");
898 zassert_equal(DT_INST_IRQ_BY_NAME(0, stat, irq), 40, "");
899 zassert_equal(DT_INST_IRQ_BY_NAME(0, done, irq), 60, "");
900 zassert_equal(DT_INST_IRQ_BY_NAME(0, err, priority), 3, "");
901 zassert_equal(DT_INST_IRQ_BY_NAME(0, stat, priority), 5, "");
902 zassert_equal(DT_INST_IRQ_BY_NAME(0, done, priority), 7, "");
903
904 /* DT_INST_IRQ */
905 zassert_equal(DT_INST_IRQ(0, irq), 30, "");
906 zassert_equal(DT_INST_IRQ(0, priority), 3, "");
907
908 /* DT_INST_IRQN */
909 #ifndef CONFIG_MULTI_LEVEL_INTERRUPTS
910 zassert_equal(DT_INST_IRQN(0), 30, "");
911 #else
912 zassert_equal(DT_INST_IRQN(0), ((30 + 1) << CONFIG_1ST_LEVEL_INTERRUPT_BITS) | 11, "");
913 #endif
914
915 /* DT_INST_IRQN_BY_IDX */
916 #ifndef CONFIG_MULTI_LEVEL_INTERRUPTS
917 zassert_equal(DT_INST_IRQN_BY_IDX(0, 0), 30, "");
918 zassert_equal(DT_INST_IRQN_BY_IDX(0, 1), 40, "");
919 zassert_equal(DT_INST_IRQN_BY_IDX(0, 2), 60, "");
920 #else
921 zassert_equal(DT_INST_IRQN_BY_IDX(0, 0),
922 ((30 + 1) << CONFIG_1ST_LEVEL_INTERRUPT_BITS) | 11, "");
923 zassert_equal(DT_INST_IRQN_BY_IDX(0, 1),
924 ((40 + 1) << CONFIG_1ST_LEVEL_INTERRUPT_BITS) | 11, "");
925 zassert_equal(DT_INST_IRQN_BY_IDX(0, 2),
926 ((60 + 1) << CONFIG_1ST_LEVEL_INTERRUPT_BITS) | 11, "");
927 #endif
928
929 /* DT_INST_IRQ_HAS_CELL_AT_IDX */
930 zassert_true(DT_INST_IRQ_HAS_CELL_AT_IDX(0, 0, irq), "");
931 zassert_true(DT_INST_IRQ_HAS_CELL_AT_IDX(0, 0, priority), "");
932 zassert_false(DT_INST_IRQ_HAS_CELL_AT_IDX(0, 0, foo), "");
933 zassert_true(DT_INST_IRQ_HAS_CELL_AT_IDX(0, 2, irq), "");
934 zassert_true(DT_INST_IRQ_HAS_CELL_AT_IDX(0, 2, priority), "");
935 zassert_false(DT_INST_IRQ_HAS_CELL_AT_IDX(0, 2, foo), "");
936
937 /* DT_INST_IRQ_HAS_CELL */
938 zassert_true(DT_INST_IRQ_HAS_CELL(0, irq), "");
939 zassert_true(DT_INST_IRQ_HAS_CELL(0, priority), "");
940 zassert_false(DT_INST_IRQ_HAS_CELL(0, foo), "");
941
942 /* DT_INST_IRQ_HAS_NAME */
943 zassert_true(DT_INST_IRQ_HAS_NAME(0, err), "");
944 zassert_true(DT_INST_IRQ_HAS_NAME(0, stat), "");
945 zassert_true(DT_INST_IRQ_HAS_NAME(0, done), "");
946 zassert_false(DT_INST_IRQ_HAS_NAME(0, alpha), "");
947
948 #ifdef CONFIG_MULTI_LEVEL_INTERRUPTS
949 /* the following asserts check if interrupt IDs are encoded
950 * properly when dealing with a node that consumes interrupts
951 * from L2 aggregators extending different L1 interrupts.
952 */
953 zassert_equal(DT_IRQN_BY_IDX(TEST_IRQ_EXT, 0),
954 ((70 + 1) << CONFIG_1ST_LEVEL_INTERRUPT_BITS) | 11, "");
955 zassert_equal(DT_IRQN_BY_IDX(TEST_IRQ_EXT, 2),
956 ((42 + 1) << CONFIG_1ST_LEVEL_INTERRUPT_BITS) | 12, "");
957 #else
958 zassert_equal(DT_IRQN_BY_IDX(TEST_IRQ_EXT, 0), 70, "");
959 zassert_equal(DT_IRQN_BY_IDX(TEST_IRQ_EXT, 2), 42, "");
960 #endif /* CONFIG_MULTI_LEVEL_INTERRUPTS */
961 }
962
ZTEST(devicetree_api,test_irq_level)963 ZTEST(devicetree_api, test_irq_level)
964 {
965 /* DT_IRQ_LEVEL */
966 zassert_equal(DT_IRQ_LEVEL(TEST_TEMP), 0, "");
967 zassert_equal(DT_IRQ_LEVEL(TEST_INTC), 1, "");
968 zassert_equal(DT_IRQ_LEVEL(TEST_SPI), 2, "");
969
970 /* DT_IRQ_LEVEL */
971 #undef DT_DRV_COMPAT
972 #define DT_DRV_COMPAT vnd_adc_temp_sensor
973 zassert_equal(DT_INST_IRQ_LEVEL(0), 0, "");
974
975 #undef DT_DRV_COMPAT
976 #define DT_DRV_COMPAT vnd_intc
977 zassert_equal(DT_INST_IRQ_LEVEL(1), 1, "");
978
979 #undef DT_DRV_COMPAT
980 #define DT_DRV_COMPAT vnd_spi
981 zassert_equal(DT_INST_IRQ_LEVEL(0), 2, "");
982 }
983
984 struct gpios_struct {
985 gpio_pin_t pin;
986 gpio_flags_t flags;
987 };
988
989 #define CLOCK_FREQUENCY_AND_COMMA(node_id, prop, idx) \
990 DT_PROP_BY_PHANDLE_IDX(node_id, prop, idx, clock_frequency),
991
992 /* Helper macro that UTIL_LISTIFY can use and produces an element with comma */
993 #define DT_GPIO_ELEM(idx, node_id, prop) \
994 { \
995 DT_PHA_BY_IDX(node_id, prop, idx, pin),\
996 DT_PHA_BY_IDX(node_id, prop, idx, flags),\
997 }
998 #define DT_GPIO_LISTIFY(node_id, prop) \
999 { LISTIFY(DT_PROP_LEN(node_id, prop), DT_GPIO_ELEM, (,), \
1000 node_id, prop) }
1001
1002 #undef DT_DRV_COMPAT
1003 #define DT_DRV_COMPAT vnd_phandle_holder
ZTEST(devicetree_api,test_phandles)1004 ZTEST(devicetree_api, test_phandles)
1005 {
1006 bool gpio_controller = DT_PROP_BY_PHANDLE(TEST_PH, ph, gpio_controller);
1007 size_t phs_freqs[] = { DT_FOREACH_PROP_ELEM(TEST_PH, phs, CLOCK_FREQUENCY_AND_COMMA) };
1008 struct gpios_struct gps[] = DT_GPIO_LISTIFY(TEST_PH, gpios);
1009
1010 /* phandle */
1011 zassert_true(DT_NODE_HAS_PROP(TEST_PH, ph), "");
1012 zassert_true(DT_SAME_NODE(DT_PROP(TEST_PH, ph),
1013 DT_NODELABEL(test_gpio_1)), "");
1014 zassert_equal(DT_PROP_LEN(TEST_PH, ph), 1, "");
1015 zassert_true(DT_SAME_NODE(DT_PROP_BY_IDX(TEST_PH, ph, 0),
1016 DT_NODELABEL(test_gpio_1)), "");
1017 /* DT_PROP_BY_PHANDLE */
1018 zassert_equal(gpio_controller, true, "");
1019
1020 /* phandles */
1021 zassert_true(DT_NODE_HAS_PROP(TEST_PH, phs), "");
1022 zassert_equal(ARRAY_SIZE(phs_freqs), 2, "");
1023 zassert_equal(DT_PROP_LEN(TEST_PH, phs), 2, "");
1024 zassert_true(DT_SAME_NODE(DT_PROP_BY_IDX(TEST_PH, phs, 1),
1025 TEST_SPI), "");
1026
1027 /* DT_FOREACH_PROP_ELEM on a phandles type property */
1028 zassert_equal(phs_freqs[0], 100000, "");
1029 zassert_equal(phs_freqs[1], 2000000, "");
1030
1031 /* DT_PROP_BY_PHANDLE_IDX on a phandles type property */
1032 zassert_equal(DT_PROP_BY_PHANDLE_IDX(TEST_PH, phs, 0, clock_frequency),
1033 100000, "");
1034 zassert_equal(DT_PROP_BY_PHANDLE_IDX(TEST_PH, phs, 1, clock_frequency),
1035 2000000, "");
1036
1037 /* DT_PROP_BY_PHANDLE_IDX on a phandle-array type property */
1038 zassert_equal(DT_PROP_BY_PHANDLE_IDX(TEST_PH, gpios, 0,
1039 ngpios), 100, "");
1040 zassert_equal(DT_PROP_BY_PHANDLE_IDX(TEST_PH, gpios, 1,
1041 ngpios), 200, "");
1042 zassert_true(!strcmp(DT_PROP_BY_PHANDLE_IDX(TEST_PH, gpios, 0, status),
1043 "okay"), "");
1044 zassert_true(!strcmp(DT_PROP_BY_PHANDLE_IDX(TEST_PH, gpios, 1, status),
1045 "okay"), "");
1046
1047 /* DT_PROP_BY_PHANDLE_IDX_OR */
1048 zassert_true(!strcmp(DT_PROP_BY_PHANDLE_IDX_OR(TEST_PH, phs_or, 0,
1049 val, "zero"), "one"), "");
1050 zassert_true(!strcmp(DT_PROP_BY_PHANDLE_IDX_OR(TEST_PH, phs_or, 1,
1051 val, "zero"), "zero"), "");
1052
1053 /* phandle-array */
1054 zassert_true(DT_NODE_HAS_PROP(TEST_PH, gpios), "");
1055 zassert_equal(ARRAY_SIZE(gps), 2, "");
1056 zassert_equal(DT_PROP_LEN(TEST_PH, gpios), 2, "");
1057
1058 /* DT_PROP_HAS_IDX */
1059 zassert_true(DT_PROP_HAS_IDX(TEST_PH, gpios, 0), "");
1060 zassert_true(DT_PROP_HAS_IDX(TEST_PH, gpios, 1), "");
1061 zassert_false(DT_PROP_HAS_IDX(TEST_PH, gpios, 2), "");
1062
1063 /* DT_PROP_HAS_NAME */
1064 zassert_false(DT_PROP_HAS_NAME(TEST_PH, foos, A), "");
1065 zassert_true(DT_PROP_HAS_NAME(TEST_PH, foos, a), "");
1066 zassert_false(DT_PROP_HAS_NAME(TEST_PH, foos, b-c), "");
1067 zassert_true(DT_PROP_HAS_NAME(TEST_PH, foos, b_c), "");
1068 zassert_false(DT_PROP_HAS_NAME(TEST_PH, bazs, jane), "");
1069
1070 /* DT_PHA_HAS_CELL_AT_IDX */
1071 zassert_true(DT_PHA_HAS_CELL_AT_IDX(TEST_PH, gpios, 1, pin), "");
1072 zassert_true(DT_PHA_HAS_CELL_AT_IDX(TEST_PH, gpios, 1, flags), "");
1073 /* pha-gpios index 1 has nothing, not even a phandle */
1074 zassert_false(DT_PROP_HAS_IDX(TEST_PH, pha_gpios, 1), "");
1075 zassert_false(DT_PHA_HAS_CELL_AT_IDX(TEST_PH, pha_gpios, 1, pin), "");
1076 zassert_false(DT_PHA_HAS_CELL_AT_IDX(TEST_PH, pha_gpios, 1, flags),
1077 "");
1078 /* index 2 only has a pin cell, no flags */
1079 zassert_true(DT_PHA_HAS_CELL_AT_IDX(TEST_PH, pha_gpios, 2, pin), "");
1080 zassert_false(DT_PHA_HAS_CELL_AT_IDX(TEST_PH, pha_gpios, 2, flags),
1081 "");
1082 /* index 3 has both pin and flags cells*/
1083 zassert_true(DT_PHA_HAS_CELL_AT_IDX(TEST_PH, pha_gpios, 3, pin), "");
1084 zassert_true(DT_PHA_HAS_CELL_AT_IDX(TEST_PH, pha_gpios, 3, flags), "");
1085 /* even though index 1 has nothing, the length is still 4 */
1086 zassert_equal(DT_PROP_LEN(TEST_PH, pha_gpios), 4, "");
1087
1088 /* DT_PHA_HAS_CELL */
1089 zassert_true(DT_PHA_HAS_CELL(TEST_PH, gpios, flags), "");
1090 zassert_false(DT_PHA_HAS_CELL(TEST_PH, gpios, bar), "");
1091
1092 /* DT_PHANDLE_BY_IDX */
1093 zassert_true(DT_SAME_NODE(DT_PHANDLE_BY_IDX(TEST_PH, gpios, 0), TEST_GPIO_1), "");
1094 zassert_true(DT_SAME_NODE(DT_PHANDLE_BY_IDX(TEST_PH, gpios, 1), TEST_GPIO_2), "");
1095
1096 /* DT_PHANDLE */
1097 zassert_true(DT_SAME_NODE(DT_PHANDLE(TEST_PH, gpios), TEST_GPIO_1), "");
1098
1099 /* DT_PHA */
1100 zassert_equal(DT_PHA(TEST_PH, gpios, pin), 10, "");
1101 zassert_equal(DT_PHA(TEST_PH, gpios, flags), 20, "");
1102
1103 /* DT_PHA_BY_IDX */
1104 zassert_equal(DT_PHA_BY_IDX(TEST_PH, gpios, 0, pin), 10, "");
1105 zassert_equal(DT_PHA_BY_IDX(TEST_PH, gpios, 0, flags), 20, "");
1106
1107 zassert_equal(DT_PHA_BY_IDX(TEST_PH, gpios, 1, pin), 30, "");
1108 zassert_equal(DT_PHA_BY_IDX(TEST_PH, gpios, 1, flags), 40, "");
1109
1110 /* DT_PHA_BY_NAME */
1111 zassert_equal(DT_PHA_BY_NAME(TEST_PH, foos, a, foocell), 100, "");
1112 zassert_equal(DT_PHA_BY_NAME(TEST_PH, foos, b_c, foocell), 110, "");
1113
1114 /* DT_PHANDLE_BY_NAME */
1115 zassert_true(DT_SAME_NODE(DT_PHANDLE_BY_NAME(TEST_PH, foos, a), TEST_GPIO_1), "");
1116 zassert_true(DT_SAME_NODE(DT_PHANDLE_BY_NAME(TEST_PH, foos, b_c), TEST_GPIO_2), "");
1117
1118 /* DT_PHA_NUM_CELLS_BY_IDX */
1119 zassert_equal(DT_PHA_NUM_CELLS_BY_IDX(TEST_PH, foos, 0), 1);
1120 zassert_equal(DT_PHA_NUM_CELLS_BY_IDX(TEST_PH, pha_gpios, 2), 1);
1121 zassert_equal(DT_PHA_NUM_CELLS_BY_IDX(TEST_PH, pha_gpios, 3), 2);
1122
1123 /* DT_PHA_NUM_CELLS_BY_NAME */
1124 zassert_equal(DT_PHA_NUM_CELLS_BY_NAME(TEST_PH, foos, a), 1);
1125 zassert_equal(DT_PHA_NUM_CELLS_BY_NAME(TEST_PH, pwms, green), 3);
1126 zassert_equal(DT_PHA_NUM_CELLS_BY_NAME(TEST_PH, pwms, red), 3);
1127
1128 /* DT_PHA_ELEM_NAME_BY_IDX */
1129 zassert_str_equal(DT_PHA_ELEM_NAME_BY_IDX(TEST_PH, foos, 0), "A");
1130 zassert_str_equal(DT_PHA_ELEM_NAME_BY_IDX(TEST_PH, foos, 1), "b-c");
1131 zassert_str_equal(DT_PHA_ELEM_NAME_BY_IDX(TEST_PH, pwms, 0), "red");
1132 zassert_str_equal(DT_PHA_ELEM_NAME_BY_IDX(TEST_PH, pwms, 1), "green");
1133
1134 /* DT_PHA_ELEM_IDX_BY_NAME */
1135 zassert_equal(DT_PHA_ELEM_IDX_BY_NAME(TEST_PH, foos, a), 0);
1136 zassert_equal(DT_PHA_ELEM_IDX_BY_NAME(TEST_PH, foos, b_c), 1);
1137 zassert_equal(DT_PHA_ELEM_IDX_BY_NAME(TEST_PH, pwms, red), 0);
1138 zassert_equal(DT_PHA_ELEM_IDX_BY_NAME(TEST_PH, pwms, green), 1);
1139
1140 /* DT_FOREACH_PHA_CELL_BY_IDX */
1141 int chksum;
1142
1143 #define ADD_TWO(node_id, pha, idx, x) (DT_PHA_BY_IDX(node_id, pha, idx, x) + 2) +
1144 chksum = DT_FOREACH_PHA_CELL_BY_IDX(TEST_PH, pwms, 0, ADD_TWO) 0;
1145 zassert_equal(chksum, 211 + 6);
1146 chksum = DT_FOREACH_PHA_CELL_BY_IDX(TEST_PH, foos, 1, ADD_TWO) 0;
1147 zassert_equal(chksum, 110 + 2);
1148
1149 /* DT_FOREACH_PHA_CELL_BY_IDX_SEP */
1150 int cells_one[2] = {
1151 DT_FOREACH_PHA_CELL_BY_IDX_SEP(TEST_PH, pha_gpios, 0, DT_PHA_BY_IDX, (,))
1152 };
1153 int cells_two[1] = {
1154 DT_FOREACH_PHA_CELL_BY_IDX_SEP(TEST_PH, pha_gpios, 2, DT_PHA_BY_IDX, (,))
1155 };
1156
1157 zassert_equal(cells_one[0], 50);
1158 zassert_equal(cells_one[1], 60);
1159 zassert_equal(cells_two[0], 70);
1160
1161 /* DT_FOREACH_PHA_CELL_BY_NAME */
1162 #define ADD_THREE(node_id, pha, idx, x) (DT_PHA_BY_NAME(node_id, pha, idx, x) + 3) +
1163 chksum = DT_FOREACH_PHA_CELL_BY_NAME(TEST_PH, pwms, red, ADD_THREE) 0;
1164 zassert_equal(chksum, 211 + 9);
1165 chksum = DT_FOREACH_PHA_CELL_BY_NAME(TEST_PH, pwms, green, ADD_THREE) 0;
1166 zassert_equal(chksum, 106 + 9);
1167
1168 /* DT_FOREACH_PHA_CELL_BY_NAME_SEP */
1169 int cells_pwms[3] = {
1170 DT_FOREACH_PHA_CELL_BY_NAME_SEP(TEST_PH, pwms, green, DT_PHA_BY_NAME, (,))
1171 };
1172
1173 zassert_equal(cells_pwms[0], 5);
1174 zassert_equal(cells_pwms[1], 100);
1175 zassert_equal(cells_pwms[2], 1);
1176
1177 /* array initializers */
1178 zassert_equal(gps[0].pin, 10, "");
1179 zassert_equal(gps[0].flags, 20, "");
1180
1181 zassert_equal(gps[1].pin, 30, "");
1182 zassert_equal(gps[1].flags, 40, "");
1183
1184 /* DT_INST */
1185 zassert_equal(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT), 1, "");
1186
1187 /* DT_INST_PROP_BY_PHANDLE */
1188 zassert_equal(DT_INST_PROP_BY_PHANDLE(0, ph, ngpios), 100, "");
1189
1190 /* DT_INST_PROP_BY_PHANDLE_IDX */
1191 zassert_equal(DT_INST_PROP_BY_PHANDLE_IDX(0, phs, 0, clock_frequency),
1192 100000, "");
1193 zassert_equal(DT_INST_PROP_BY_PHANDLE_IDX(0, phs, 1, clock_frequency),
1194 2000000, "");
1195 zassert_equal(DT_INST_PROP_BY_PHANDLE_IDX(0, gpios, 0,
1196 gpio_controller),
1197 1, "");
1198 zassert_equal(DT_INST_PROP_BY_PHANDLE_IDX(0, gpios, 1,
1199 gpio_controller),
1200 1, "");
1201 zassert_equal(DT_INST_PROP_BY_PHANDLE_IDX(0, gpios, 0, ngpios),
1202 100, "");
1203 zassert_equal(DT_INST_PROP_BY_PHANDLE_IDX(0, gpios, 1, ngpios),
1204 200, "");
1205
1206 /* DT_INST_PROP_HAS_IDX */
1207 zassert_true(DT_INST_PROP_HAS_IDX(0, gpios, 0), "");
1208 zassert_true(DT_INST_PROP_HAS_IDX(0, gpios, 1), "");
1209 zassert_false(DT_INST_PROP_HAS_IDX(0, gpios, 2), "");
1210
1211 /* DT_INST_PROP_HAS_NAME */
1212 zassert_false(DT_INST_PROP_HAS_NAME(0, foos, A), "");
1213 zassert_true(DT_INST_PROP_HAS_NAME(0, foos, a), "");
1214 zassert_false(DT_INST_PROP_HAS_NAME(0, foos, b-c), "");
1215 zassert_true(DT_INST_PROP_HAS_NAME(0, foos, b_c), "");
1216 zassert_false(DT_INST_PROP_HAS_NAME(0, bazs, jane), "");
1217
1218 /* DT_INST_PHA_HAS_CELL_AT_IDX */
1219 zassert_true(DT_INST_PHA_HAS_CELL_AT_IDX(0, gpios, 1, pin), "");
1220 zassert_true(DT_INST_PHA_HAS_CELL_AT_IDX(0, gpios, 1, flags), "");
1221 /* index 1 has nothing, not even a phandle */
1222 zassert_false(DT_INST_PROP_HAS_IDX(0, pha_gpios, 1), "");
1223 zassert_false(DT_INST_PHA_HAS_CELL_AT_IDX(0, pha_gpios, 1, pin), "");
1224 zassert_false(DT_INST_PHA_HAS_CELL_AT_IDX(0, pha_gpios, 1, flags), "");
1225 /* index 2 only has pin, no flags */
1226 zassert_true(DT_INST_PHA_HAS_CELL_AT_IDX(0, pha_gpios, 2, pin), "");
1227 zassert_false(DT_INST_PHA_HAS_CELL_AT_IDX(0, pha_gpios, 2, flags), "");
1228 /* index 3 has both pin and flags */
1229 zassert_true(DT_INST_PHA_HAS_CELL_AT_IDX(0, pha_gpios, 3, pin), "");
1230 zassert_true(DT_INST_PHA_HAS_CELL_AT_IDX(0, pha_gpios, 3, flags), "");
1231 /* even though index 1 has nothing, the length is still 4 */
1232 zassert_equal(DT_INST_PROP_LEN(0, pha_gpios), 4, "");
1233
1234 /* DT_INST_PHA_HAS_CELL */
1235 zassert_true(DT_INST_PHA_HAS_CELL(0, gpios, flags), "");
1236 zassert_false(DT_INST_PHA_HAS_CELL(0, gpios, bar), "");
1237
1238 /* DT_INST_PHANDLE_BY_IDX */
1239 zassert_true(DT_SAME_NODE(DT_INST_PHANDLE_BY_IDX(0, gpios, 0), TEST_GPIO_1), "");
1240 zassert_true(DT_SAME_NODE(DT_INST_PHANDLE_BY_IDX(0, gpios, 1), TEST_GPIO_2), "");
1241
1242 /* DT_INST_PHANDLE */
1243 zassert_true(DT_SAME_NODE(DT_INST_PHANDLE(0, gpios), TEST_GPIO_1), "");
1244
1245 /* DT_INST_PHA */
1246 zassert_equal(DT_INST_PHA(0, gpios, pin), 10, "");
1247 zassert_equal(DT_INST_PHA(0, gpios, flags), 20, "");
1248
1249 /* DT_INST_PHA_BY_IDX */
1250 zassert_equal(DT_INST_PHA_BY_IDX(0, gpios, 0, pin), 10, "");
1251 zassert_equal(DT_INST_PHA_BY_IDX(0, gpios, 0, flags), 20, "");
1252
1253 zassert_equal(DT_INST_PHA_BY_IDX(0, gpios, 1, pin), 30, "");
1254 zassert_equal(DT_INST_PHA_BY_IDX(0, gpios, 1, flags), 40, "");
1255
1256 /* DT_INST_PHA_BY_NAME */
1257 zassert_equal(DT_INST_PHA_BY_NAME(0, foos, a, foocell), 100, "");
1258 zassert_equal(DT_INST_PHA_BY_NAME(0, foos, b_c, foocell), 110, "");
1259
1260 /* DT_INST_PHANDLE_BY_NAME */
1261 zassert_true(DT_SAME_NODE(DT_INST_PHANDLE_BY_NAME(0, foos, a), TEST_GPIO_1), "");
1262 zassert_true(DT_SAME_NODE(DT_INST_PHANDLE_BY_NAME(0, foos, b_c), TEST_GPIO_2), "");
1263 }
1264
1265 #undef DT_DRV_COMPAT
1266 #define DT_DRV_COMPAT vnd_phandle_holder
ZTEST(devicetree_api,test_gpio)1267 ZTEST(devicetree_api, test_gpio)
1268 {
1269 /* DT_GPIO_CTLR_BY_IDX */
1270 zassert_true(!strcmp(TO_STRING(DT_GPIO_CTLR_BY_IDX(TEST_PH, gpios, 0)),
1271 TO_STRING(DT_NODELABEL(test_gpio_1))), "");
1272 zassert_true(!strcmp(TO_STRING(DT_GPIO_CTLR_BY_IDX(TEST_PH, gpios, 1)),
1273 TO_STRING(DT_NODELABEL(test_gpio_2))), "");
1274
1275 /* DT_GPIO_CTLR */
1276 zassert_true(!strcmp(TO_STRING(DT_GPIO_CTLR(TEST_PH, gpios)),
1277 TO_STRING(DT_NODELABEL(test_gpio_1))), "");
1278
1279 /* DT_GPIO_PIN_BY_IDX */
1280 zassert_equal(DT_GPIO_PIN_BY_IDX(TEST_PH, gpios, 0), 10, "");
1281 zassert_equal(DT_GPIO_PIN_BY_IDX(TEST_PH, gpios, 1), 30, "");
1282
1283 /* DT_GPIO_PIN */
1284 zassert_equal(DT_GPIO_PIN(TEST_PH, gpios), 10, "");
1285
1286 /* DT_GPIO_FLAGS_BY_IDX */
1287 zassert_equal(DT_GPIO_FLAGS_BY_IDX(TEST_PH, gpios, 0), 20, "");
1288 zassert_equal(DT_GPIO_FLAGS_BY_IDX(TEST_PH, gpios, 1), 40, "");
1289
1290 /* DT_GPIO_FLAGS */
1291 zassert_equal(DT_GPIO_FLAGS(TEST_PH, gpios), 20, "");
1292
1293 /* DT_NUM_GPIO_HOGS */
1294 zassert_equal(DT_NUM_GPIO_HOGS(TEST_GPIO_HOG_1), 2, "");
1295 zassert_equal(DT_NUM_GPIO_HOGS(TEST_GPIO_HOG_2), 1, "");
1296 zassert_equal(DT_NUM_GPIO_HOGS(TEST_GPIO_HOG_3), 1, "");
1297
1298 /* DT_GPIO_HOG_PIN_BY_IDX */
1299 zassert_equal(DT_GPIO_HOG_PIN_BY_IDX(TEST_GPIO_HOG_1, 0), 0, "");
1300 zassert_equal(DT_GPIO_HOG_PIN_BY_IDX(TEST_GPIO_HOG_1, 1), 1, "");
1301 zassert_equal(DT_GPIO_HOG_PIN_BY_IDX(TEST_GPIO_HOG_2, 0), 3, "");
1302 zassert_equal(DT_GPIO_HOG_PIN_BY_IDX(TEST_GPIO_HOG_3, 0), 4, "");
1303
1304 /* DT_GPIO_HOG_FLAGS_BY_IDX */
1305 zassert_equal(DT_GPIO_HOG_FLAGS_BY_IDX(TEST_GPIO_HOG_1, 0), 0x00, "");
1306 zassert_equal(DT_GPIO_HOG_FLAGS_BY_IDX(TEST_GPIO_HOG_1, 1), 0x10, "");
1307 zassert_equal(DT_GPIO_HOG_FLAGS_BY_IDX(TEST_GPIO_HOG_2, 0), 0x20, "");
1308 zassert_equal(DT_GPIO_HOG_FLAGS_BY_IDX(TEST_GPIO_HOG_3, 0), 0x30, "");
1309
1310 /* DT_INST */
1311 zassert_equal(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT), 1, "");
1312
1313 /* DT_INST_GPIO_PIN_BY_IDX */
1314 zassert_equal(DT_INST_GPIO_PIN_BY_IDX(0, gpios, 0), 10, "");
1315 zassert_equal(DT_INST_GPIO_PIN_BY_IDX(0, gpios, 1), 30, "");
1316
1317 /* DT_INST_GPIO_PIN */
1318 zassert_equal(DT_INST_GPIO_PIN(0, gpios), 10, "");
1319
1320 /* DT_INST_GPIO_FLAGS_BY_IDX */
1321 zassert_equal(DT_INST_GPIO_FLAGS_BY_IDX(0, gpios, 0), 20, "");
1322 zassert_equal(DT_INST_GPIO_FLAGS_BY_IDX(0, gpios, 1), 40, "");
1323
1324 /* DT_INST_GPIO_FLAGS */
1325 zassert_equal(DT_INST_GPIO_FLAGS(0, gpios), 20, "");
1326 }
1327
1328 #undef DT_DRV_COMPAT
1329 #define DT_DRV_COMPAT vnd_adc_temp_sensor
ZTEST(devicetree_api,test_io_channels)1330 ZTEST(devicetree_api, test_io_channels)
1331 {
1332 /* DT_IO_CHANNELS_CTLR_BY_IDX */
1333 zassert_true(DT_SAME_NODE(DT_IO_CHANNELS_CTLR_BY_IDX(TEST_TEMP, 0),
1334 TEST_IO_CHANNEL_CTLR_1), "");
1335 zassert_true(DT_SAME_NODE(DT_IO_CHANNELS_CTLR_BY_IDX(TEST_TEMP, 1),
1336 TEST_IO_CHANNEL_CTLR_2), "");
1337
1338 /* DT_IO_CHANNELS_CTLR_BY_NAME */
1339 zassert_true(DT_SAME_NODE(DT_IO_CHANNELS_CTLR_BY_NAME(TEST_TEMP, ch1),
1340 TEST_IO_CHANNEL_CTLR_1), "");
1341 zassert_true(DT_SAME_NODE(DT_IO_CHANNELS_CTLR_BY_NAME(TEST_TEMP, ch2),
1342 TEST_IO_CHANNEL_CTLR_2), "");
1343
1344 /* DT_IO_CHANNELS_CTLR */
1345 zassert_true(DT_SAME_NODE(DT_IO_CHANNELS_CTLR(TEST_TEMP),
1346 TEST_IO_CHANNEL_CTLR_1), "");
1347
1348 /* DT_INST_IO_CHANNELS_CTLR_BY_IDX */
1349 zassert_true(DT_SAME_NODE(DT_INST_IO_CHANNELS_CTLR_BY_IDX(0, 0),
1350 TEST_IO_CHANNEL_CTLR_1), "");
1351 zassert_true(DT_SAME_NODE(DT_INST_IO_CHANNELS_CTLR_BY_IDX(0, 1),
1352 TEST_IO_CHANNEL_CTLR_2), "");
1353
1354 /* DT_INST_IO_CHANNELS_CTLR_BY_NAME */
1355 zassert_true(DT_SAME_NODE(DT_INST_IO_CHANNELS_CTLR_BY_NAME(0, ch1),
1356 TEST_IO_CHANNEL_CTLR_1), "");
1357 zassert_true(DT_SAME_NODE(DT_INST_IO_CHANNELS_CTLR_BY_NAME(0, ch2),
1358 TEST_IO_CHANNEL_CTLR_2), "");
1359
1360 /* DT_INST_IO_CHANNELS_CTLR */
1361 zassert_true(DT_SAME_NODE(DT_INST_IO_CHANNELS_CTLR(0),
1362 TEST_IO_CHANNEL_CTLR_1), "");
1363
1364 zassert_equal(DT_IO_CHANNELS_INPUT_BY_IDX(TEST_TEMP, 0), 10, "");
1365 zassert_equal(DT_IO_CHANNELS_INPUT_BY_IDX(TEST_TEMP, 1), 20, "");
1366 zassert_equal(DT_IO_CHANNELS_INPUT_BY_NAME(TEST_TEMP, ch1), 10, "");
1367 zassert_equal(DT_IO_CHANNELS_INPUT_BY_NAME(TEST_TEMP, ch2), 20, "");
1368 zassert_equal(DT_IO_CHANNELS_INPUT(TEST_TEMP), 10, "");
1369
1370 zassert_equal(DT_INST_IO_CHANNELS_INPUT_BY_IDX(0, 0), 10, "");
1371 zassert_equal(DT_INST_IO_CHANNELS_INPUT_BY_IDX(0, 1), 20, "");
1372 zassert_equal(DT_INST_IO_CHANNELS_INPUT_BY_NAME(0, ch1), 10, "");
1373 zassert_equal(DT_INST_IO_CHANNELS_INPUT_BY_NAME(0, ch2), 20, "");
1374 zassert_equal(DT_INST_IO_CHANNELS_INPUT(0), 10, "");
1375 }
1376
1377 #undef DT_DRV_COMPAT
1378 #define DT_DRV_COMPAT vnd_adc_temp_sensor
ZTEST(devicetree_api,test_dma)1379 ZTEST(devicetree_api, test_dma)
1380 {
1381 /* DT_DMAS_CTLR_BY_IDX */
1382 zassert_true(DT_SAME_NODE(DT_DMAS_CTLR_BY_IDX(TEST_TEMP, 0),
1383 TEST_DMA_CTLR_1), "");
1384 zassert_true(DT_SAME_NODE(DT_DMAS_CTLR_BY_IDX(TEST_TEMP, 1),
1385 TEST_DMA_CTLR_2), "");
1386
1387 /* DT_DMAS_CTLR_BY_NAME */
1388 zassert_true(DT_SAME_NODE(DT_DMAS_CTLR_BY_NAME(TEST_TEMP, tx),
1389 TEST_DMA_CTLR_1), "");
1390 zassert_true(DT_SAME_NODE(DT_DMAS_CTLR_BY_NAME(TEST_TEMP, rx),
1391 TEST_DMA_CTLR_2), "");
1392
1393 /* DT_DMAS_CTLR */
1394 zassert_true(DT_SAME_NODE(DT_DMAS_CTLR(TEST_TEMP),
1395 TEST_DMA_CTLR_1), "");
1396
1397 /* DT_INST_DMAS_CTLR_BY_IDX */
1398 zassert_true(DT_SAME_NODE(DT_INST_DMAS_CTLR_BY_IDX(0, 0),
1399 TEST_DMA_CTLR_1), "");
1400 zassert_true(DT_SAME_NODE(DT_INST_DMAS_CTLR_BY_IDX(0, 1),
1401 TEST_DMA_CTLR_2), "");
1402
1403 /* DT_INST_DMAS_CTLR_BY_NAME */
1404 zassert_true(DT_SAME_NODE(DT_INST_DMAS_CTLR_BY_NAME(0, tx),
1405 TEST_DMA_CTLR_1), "");
1406 zassert_true(DT_SAME_NODE(DT_INST_DMAS_CTLR_BY_NAME(0, rx),
1407 TEST_DMA_CTLR_2), "");
1408
1409 /* DT_INST_DMAS_CTLR */
1410 zassert_true(DT_SAME_NODE(DT_INST_DMAS_CTLR(0), TEST_DMA_CTLR_1), "");
1411
1412 zassert_equal(DT_DMAS_CELL_BY_NAME(TEST_TEMP, rx, channel), 3, "");
1413 zassert_equal(DT_INST_DMAS_CELL_BY_NAME(0, rx, channel), 3, "");
1414 zassert_equal(DT_DMAS_CELL_BY_NAME(TEST_TEMP, rx, slot), 4, "");
1415 zassert_equal(DT_INST_DMAS_CELL_BY_NAME(0, rx, slot), 4, "");
1416
1417 zassert_equal(DT_DMAS_CELL_BY_IDX(TEST_TEMP, 1, channel), 3, "");
1418 zassert_equal(DT_INST_DMAS_CELL_BY_IDX(0, 1, channel), 3, "");
1419 zassert_equal(DT_DMAS_CELL_BY_IDX(TEST_TEMP, 1, slot), 4, "");
1420 zassert_equal(DT_INST_DMAS_CELL_BY_IDX(0, 1, slot), 4, "");
1421
1422 zassert_true(DT_DMAS_HAS_NAME(TEST_TEMP, tx), "");
1423 zassert_true(DT_INST_DMAS_HAS_NAME(0, tx), "");
1424 zassert_false(DT_DMAS_HAS_NAME(TEST_TEMP, output), "");
1425 zassert_false(DT_INST_DMAS_HAS_NAME(0, output), "");
1426
1427 zassert_true(DT_DMAS_HAS_IDX(TEST_TEMP, 1), "");
1428 zassert_true(DT_INST_DMAS_HAS_IDX(0, 1), "");
1429 zassert_false(DT_DMAS_HAS_IDX(TEST_TEMP, 2), "");
1430 zassert_false(DT_INST_DMAS_HAS_IDX(0, 2), "");
1431 }
1432
1433 #undef DT_DRV_COMPAT
1434 DT_FOREACH_STATUS_OKAY_VARGS(vnd_video_single_port, DEVICE_DT_DEFINE, NULL, NULL, NULL, NULL,
1435 POST_KERNEL, CONFIG_APPLICATION_INIT_PRIORITY, NULL);
1436 DT_FOREACH_STATUS_OKAY_VARGS(vnd_video_multi_port, DEVICE_DT_DEFINE, NULL, NULL, NULL, NULL,
1437 POST_KERNEL, CONFIG_APPLICATION_INIT_PRIORITY, NULL);
ZTEST(devicetree_api,test_video)1438 ZTEST(devicetree_api, test_video)
1439 {
1440 /* DT_INST_PORT_BY_ID */
1441 #define DT_DRV_COMPAT vnd_video_single_port
1442 zassert_true(DT_SAME_NODE(DT_INST_PORT_BY_ID(0, 0),
1443 TEST_VIDEO0_PORT), "get port node of video0");
1444 zassert_true(DT_SAME_NODE(DT_INST_PORT_BY_ID(1, 0), TEST_VIDEO1_PORT),
1445 "get port node of video1");
1446 #undef DT_DRV_COMPAT
1447 #define DT_DRV_COMPAT vnd_video_multi_port
1448 zassert_true(DT_SAME_NODE(DT_INST_PORT_BY_ID(0, 0), TEST_VIDEO2_PORT0),
1449 "get port@0 node of video2");
1450 zassert_true(DT_SAME_NODE(DT_INST_PORT_BY_ID(0, 1), TEST_VIDEO2_PORT1),
1451 "get port@1 node of video2");
1452 #undef DT_DRV_COMPAT
1453
1454 /* DT_INST_ENDPOINT_BY_ID */
1455 #define DT_DRV_COMPAT vnd_video_single_port
1456 zassert_true(DT_SAME_NODE(DT_INST_ENDPOINT_BY_ID(0, 0, 0), TEST_VIDEO0_OUT),
1457 "get endpoint node of port node of video0");
1458 zassert_true(DT_SAME_NODE(DT_INST_ENDPOINT_BY_ID(1, 0, 0), TEST_VIDEO1_OUT0),
1459 "get endpoint@0 node of port node of video1");
1460 zassert_true(DT_SAME_NODE(DT_INST_ENDPOINT_BY_ID(1, 0, 1), TEST_VIDEO1_OUT1),
1461 "get endpoint@1 node of port node of video1");
1462 #undef DT_DRV_COMPAT
1463 #define DT_DRV_COMPAT vnd_video_multi_port
1464 zassert_true(DT_SAME_NODE(DT_INST_ENDPOINT_BY_ID(0, 0, 0), TEST_VIDEO2_PORT0_IN0),
1465 "get endpoint@0 node of port@0 node of video2");
1466 zassert_true(DT_SAME_NODE(DT_INST_ENDPOINT_BY_ID(0, 0, 1), TEST_VIDEO2_PORT0_IN1),
1467 "get endpoint@1 node of port@0 node of video2");
1468 zassert_true(DT_SAME_NODE(DT_INST_ENDPOINT_BY_ID(0, 1, 0), TEST_VIDEO2_PORT1_IN),
1469 "get endpoint node of port@1 node of video2");
1470 #undef DT_DRV_COMPAT
1471
1472 /* DT_NODE_BY_ENDPOINT */
1473 zassert_true(DT_SAME_NODE(DT_NODE_BY_ENDPOINT(TEST_VIDEO0_OUT),
1474 TEST_VIDEO0), "get video0 node from its endpoint");
1475 zassert_true(DT_SAME_NODE(DT_NODE_BY_ENDPOINT(TEST_VIDEO1_OUT0), TEST_VIDEO1),
1476 "get video1 node from its endpoint@0");
1477 zassert_true(DT_SAME_NODE(DT_NODE_BY_ENDPOINT(TEST_VIDEO1_OUT1), TEST_VIDEO1),
1478 "get video1 node from its endpoint@1");
1479 zassert_true(DT_SAME_NODE(DT_NODE_BY_ENDPOINT(TEST_VIDEO2_PORT0_IN0), TEST_VIDEO2),
1480 "get video2 node from its endpoint@0 at port@0");
1481 zassert_true(DT_SAME_NODE(DT_NODE_BY_ENDPOINT(TEST_VIDEO2_PORT0_IN1), TEST_VIDEO2),
1482 "get video2 node from its endpoint@1 at port@0");
1483 zassert_true(DT_SAME_NODE(DT_NODE_BY_ENDPOINT(TEST_VIDEO2_PORT1_IN), TEST_VIDEO2),
1484 "get video2 node from its endpoint at port@1");
1485
1486 /* DT_NODE_REMOTE_DEVICE */
1487 #define DT_DRV_COMPAT vnd_video_single_port
1488 zassert_true(DT_SAME_NODE(DT_NODE_REMOTE_DEVICE(TEST_VIDEO0_OUT), TEST_VIDEO2),
1489 "get remote device node of video0's endpoint");
1490 zassert_true(DT_SAME_NODE(DT_NODE_REMOTE_DEVICE(TEST_VIDEO1_OUT0), TEST_VIDEO2),
1491 "get remote device node of video1's endpoint@0");
1492 zassert_true(DT_SAME_NODE(DT_NODE_REMOTE_DEVICE(TEST_VIDEO1_OUT1), TEST_VIDEO2),
1493 "get remote device node of video1's endpoint@1");
1494 #undef DT_DRV_COMPAT
1495 #define DT_DRV_COMPAT vnd_video_multi_port
1496 zassert_true(DT_SAME_NODE(DT_NODE_REMOTE_DEVICE(TEST_VIDEO2_PORT0_IN0), TEST_VIDEO0),
1497 "get remote device node of video2's port@0 endpoint@0");
1498 zassert_true(DT_SAME_NODE(DT_NODE_REMOTE_DEVICE(TEST_VIDEO2_PORT0_IN1), TEST_VIDEO1),
1499 "get remote device node of video2's port@0 endpoint@1");
1500 zassert_true(DT_SAME_NODE(DT_NODE_REMOTE_DEVICE(TEST_VIDEO2_PORT1_IN), TEST_VIDEO1),
1501 "get remote device node of video2's port@1 endpoint");
1502 #undef DT_DRV_COMPAT
1503 }
1504
1505 #undef DT_DRV_COMPAT
1506 #define DT_DRV_COMPAT vnd_phandle_holder
ZTEST(devicetree_api,test_pwms)1507 ZTEST(devicetree_api, test_pwms)
1508 {
1509 /* DT_PWMS_CTLR_BY_IDX */
1510 zassert_true(DT_SAME_NODE(DT_PWMS_CTLR_BY_IDX(TEST_PH, 0),
1511 TEST_PWM_CTLR_1), "");
1512 zassert_true(DT_SAME_NODE(DT_PWMS_CTLR_BY_IDX(TEST_PH, 1),
1513 TEST_PWM_CTLR_2), "");
1514
1515 /* DT_PWMS_CTLR_BY_NAME */
1516 zassert_true(DT_SAME_NODE(DT_PWMS_CTLR_BY_NAME(TEST_PH, red),
1517 TEST_PWM_CTLR_1), "");
1518 zassert_true(DT_SAME_NODE(DT_PWMS_CTLR_BY_NAME(TEST_PH, green),
1519 TEST_PWM_CTLR_2), "");
1520
1521 /* DT_PWMS_CTLR */
1522 zassert_true(DT_SAME_NODE(DT_PWMS_CTLR(TEST_PH),
1523 TEST_PWM_CTLR_1), "");
1524
1525 /* DT_PWMS_CELL_BY_IDX */
1526 zassert_equal(DT_PWMS_CELL_BY_IDX(TEST_PH, 1, channel), 5, "");
1527 zassert_equal(DT_PWMS_CELL_BY_IDX(TEST_PH, 1, period), 100, "");
1528 zassert_equal(DT_PWMS_CELL_BY_IDX(TEST_PH, 1, flags), 1, "");
1529
1530 /* DT_PWMS_CELL_BY_NAME */
1531 zassert_equal(DT_PWMS_CELL_BY_NAME(TEST_PH, red, channel), 8, "");
1532 zassert_equal(DT_PWMS_CELL_BY_NAME(TEST_PH, red, period), 200, "");
1533 zassert_equal(DT_PWMS_CELL_BY_NAME(TEST_PH, red, flags), 3, "");
1534
1535 /* DT_PWMS_CELL */
1536 zassert_equal(DT_PWMS_CELL(TEST_PH, channel), 8, "");
1537 zassert_equal(DT_PWMS_CELL(TEST_PH, period), 200, "");
1538 zassert_equal(DT_PWMS_CELL(TEST_PH, flags), 3, "");
1539
1540 /* DT_PWMS_CHANNEL_BY_IDX */
1541 zassert_equal(DT_PWMS_CHANNEL_BY_IDX(TEST_PH, 1), 5, "");
1542
1543 /* DT_PWMS_CHANNEL_BY_NAME */
1544 zassert_equal(DT_PWMS_CHANNEL_BY_NAME(TEST_PH, green), 5, "");
1545
1546 /* DT_PWMS_CHANNEL */
1547 zassert_equal(DT_PWMS_CHANNEL(TEST_PH), 8, "");
1548
1549 /* DT_PWMS_PERIOD_BY_IDX */
1550 zassert_equal(DT_PWMS_PERIOD_BY_IDX(TEST_PH, 1), 100, "");
1551
1552 /* DT_PWMS_PERIOD_BY_NAME */
1553 zassert_equal(DT_PWMS_PERIOD_BY_NAME(TEST_PH, green), 100, "");
1554
1555 /* DT_PWMS_PERIOD */
1556 zassert_equal(DT_PWMS_PERIOD(TEST_PH), 200, "");
1557
1558 /* DT_PWMS_FLAGS_BY_IDX */
1559 zassert_equal(DT_PWMS_FLAGS_BY_IDX(TEST_PH, 1), 1, "");
1560
1561 /* DT_PWMS_FLAGS_BY_NAME */
1562 zassert_equal(DT_PWMS_FLAGS_BY_NAME(TEST_PH, green), 1, "");
1563
1564 /* DT_PWMS_FLAGS */
1565 zassert_equal(DT_PWMS_FLAGS(TEST_PH), 3, "");
1566
1567 /* DT_INST */
1568 zassert_equal(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT), 1, "");
1569
1570 /* DT_INST_PWMS_CTLR_BY_IDX */
1571 zassert_true(DT_SAME_NODE(DT_INST_PWMS_CTLR_BY_IDX(0, 0),
1572 TEST_PWM_CTLR_1), "");
1573 zassert_true(DT_SAME_NODE(DT_INST_PWMS_CTLR_BY_IDX(0, 1),
1574 TEST_PWM_CTLR_2), "");
1575
1576 /* DT_INST_PWMS_CTLR_BY_NAME */
1577 zassert_true(DT_SAME_NODE(DT_INST_PWMS_CTLR_BY_NAME(0, red),
1578 TEST_PWM_CTLR_1), "");
1579 zassert_true(DT_SAME_NODE(DT_INST_PWMS_CTLR_BY_NAME(0, green),
1580 TEST_PWM_CTLR_2), "");
1581
1582 /* DT_INST_PWMS_CTLR */
1583 zassert_true(DT_SAME_NODE(DT_INST_PWMS_CTLR(0), TEST_PWM_CTLR_1), "");
1584
1585 /* DT_INST_PWMS_CELL_BY_IDX */
1586 zassert_equal(DT_INST_PWMS_CELL_BY_IDX(0, 1, channel), 5, "");
1587 zassert_equal(DT_INST_PWMS_CELL_BY_IDX(0, 1, period), 100, "");
1588 zassert_equal(DT_INST_PWMS_CELL_BY_IDX(0, 1, flags), 1, "");
1589
1590 /* DT_INST_PWMS_CELL_BY_NAME */
1591 zassert_equal(DT_INST_PWMS_CELL_BY_NAME(0, green, channel), 5, "");
1592 zassert_equal(DT_INST_PWMS_CELL_BY_NAME(0, green, period), 100, "");
1593 zassert_equal(DT_INST_PWMS_CELL_BY_NAME(0, green, flags), 1, "");
1594
1595 /* DT_INST_PWMS_CELL */
1596 zassert_equal(DT_INST_PWMS_CELL(0, channel), 8, "");
1597 zassert_equal(DT_INST_PWMS_CELL(0, period), 200, "");
1598 zassert_equal(DT_INST_PWMS_CELL(0, flags), 3, "");
1599
1600 /* DT_INST_PWMS_CHANNEL_BY_IDX */
1601 zassert_equal(DT_INST_PWMS_CHANNEL_BY_IDX(0, 1), 5, "");
1602
1603 /* DT_INST_PWMS_CHANNEL_BY_NAME */
1604 zassert_equal(DT_INST_PWMS_CHANNEL_BY_NAME(0, green), 5, "");
1605
1606 /* DT_INST_PWMS_CHANNEL */
1607 zassert_equal(DT_INST_PWMS_CHANNEL(0), 8, "");
1608
1609 /* DT_INST_PWMS_PERIOD_BY_IDX */
1610 zassert_equal(DT_INST_PWMS_PERIOD_BY_IDX(0, 1), 100, "");
1611
1612 /* DT_INST_PWMS_PERIOD_BY_NAME */
1613 zassert_equal(DT_INST_PWMS_PERIOD_BY_NAME(0, red), 200, "");
1614
1615 /* DT_INST_PWMS_PERIOD */
1616 zassert_equal(DT_INST_PWMS_PERIOD(0), 200, "");
1617
1618 /* DT_INST_PWMS_FLAGS_BY_IDX */
1619 zassert_equal(DT_INST_PWMS_FLAGS_BY_IDX(0, 1), 1, "");
1620
1621 /* DT_INST_PWMS_FLAGS_BY_NAME */
1622 zassert_equal(DT_INST_PWMS_FLAGS_BY_NAME(0, red), 3, "");
1623
1624 /* DT_INST_PWMS_FLAGS */
1625 zassert_equal(DT_INST_PWMS_FLAGS(0), 3, "");
1626 }
1627
1628 #undef DT_DRV_COMPAT
1629 #define DT_DRV_COMPAT vnd_can_controller
ZTEST(devicetree_api,test_can)1630 ZTEST(devicetree_api, test_can)
1631 {
1632 /* DT_CAN_TRANSCEIVER_MIN_BITRATE */
1633 zassert_equal(DT_CAN_TRANSCEIVER_MIN_BITRATE(TEST_CAN_CTRL_0, 0), 10000, "");
1634 zassert_equal(DT_CAN_TRANSCEIVER_MIN_BITRATE(TEST_CAN_CTRL_0, 10000), 10000, "");
1635 zassert_equal(DT_CAN_TRANSCEIVER_MIN_BITRATE(TEST_CAN_CTRL_0, 20000), 20000, "");
1636 zassert_equal(DT_CAN_TRANSCEIVER_MIN_BITRATE(TEST_CAN_CTRL_1, 0), 50000, "");
1637 zassert_equal(DT_CAN_TRANSCEIVER_MIN_BITRATE(TEST_CAN_CTRL_1, 50000), 50000, "");
1638 zassert_equal(DT_CAN_TRANSCEIVER_MIN_BITRATE(TEST_CAN_CTRL_1, 100000), 100000, "");
1639 zassert_equal(DT_CAN_TRANSCEIVER_MIN_BITRATE(TEST_CAN_CTRL_2, 0), 0, "");
1640 zassert_equal(DT_CAN_TRANSCEIVER_MIN_BITRATE(TEST_CAN_CTRL_2, 10000), 10000, "");
1641 zassert_equal(DT_CAN_TRANSCEIVER_MIN_BITRATE(TEST_CAN_CTRL_2, 20000), 20000, "");
1642 zassert_equal(DT_CAN_TRANSCEIVER_MIN_BITRATE(TEST_CAN_CTRL_3, 0), 0, "");
1643 zassert_equal(DT_CAN_TRANSCEIVER_MIN_BITRATE(TEST_CAN_CTRL_3, 30000), 30000, "");
1644 zassert_equal(DT_CAN_TRANSCEIVER_MIN_BITRATE(TEST_CAN_CTRL_3, 40000), 40000, "");
1645
1646 /* DT_INST_CAN_TRANSCEIVER_MIN_BITRATE */
1647 zassert_equal(DT_INST_CAN_TRANSCEIVER_MIN_BITRATE(0, 0), 10000, "");
1648 zassert_equal(DT_INST_CAN_TRANSCEIVER_MIN_BITRATE(0, 10000), 10000, "");
1649 zassert_equal(DT_INST_CAN_TRANSCEIVER_MIN_BITRATE(0, 20000), 20000, "");
1650 zassert_equal(DT_INST_CAN_TRANSCEIVER_MIN_BITRATE(1, 0), 50000, "");
1651 zassert_equal(DT_INST_CAN_TRANSCEIVER_MIN_BITRATE(1, 50000), 50000, "");
1652 zassert_equal(DT_INST_CAN_TRANSCEIVER_MIN_BITRATE(1, 100000), 100000, "");
1653 zassert_equal(DT_INST_CAN_TRANSCEIVER_MIN_BITRATE(2, 0), 0, "");
1654 zassert_equal(DT_INST_CAN_TRANSCEIVER_MIN_BITRATE(2, 10000), 10000, "");
1655 zassert_equal(DT_INST_CAN_TRANSCEIVER_MIN_BITRATE(2, 20000), 20000, "");
1656 zassert_equal(DT_INST_CAN_TRANSCEIVER_MIN_BITRATE(3, 0), 0, "");
1657 zassert_equal(DT_INST_CAN_TRANSCEIVER_MIN_BITRATE(3, 30000), 30000, "");
1658 zassert_equal(DT_INST_CAN_TRANSCEIVER_MIN_BITRATE(3, 40000), 40000, "");
1659
1660 /* DT_CAN_TRANSCEIVER_MAX_BITRATE */
1661 zassert_equal(DT_CAN_TRANSCEIVER_MAX_BITRATE(TEST_CAN_CTRL_0, 1000000), 1000000, "");
1662 zassert_equal(DT_CAN_TRANSCEIVER_MAX_BITRATE(TEST_CAN_CTRL_0, 5000000), 5000000, "");
1663 zassert_equal(DT_CAN_TRANSCEIVER_MAX_BITRATE(TEST_CAN_CTRL_0, 8000000), 5000000, "");
1664 zassert_equal(DT_CAN_TRANSCEIVER_MAX_BITRATE(TEST_CAN_CTRL_1, 125000), 125000, "");
1665 zassert_equal(DT_CAN_TRANSCEIVER_MAX_BITRATE(TEST_CAN_CTRL_1, 2000000), 2000000, "");
1666 zassert_equal(DT_CAN_TRANSCEIVER_MAX_BITRATE(TEST_CAN_CTRL_1, 5000000), 2000000, "");
1667 zassert_equal(DT_CAN_TRANSCEIVER_MAX_BITRATE(TEST_CAN_CTRL_2, 125000), 125000, "");
1668 zassert_equal(DT_CAN_TRANSCEIVER_MAX_BITRATE(TEST_CAN_CTRL_2, 1000000), 1000000, "");
1669 zassert_equal(DT_CAN_TRANSCEIVER_MAX_BITRATE(TEST_CAN_CTRL_2, 5000000), 1000000, "");
1670 zassert_equal(DT_CAN_TRANSCEIVER_MAX_BITRATE(TEST_CAN_CTRL_3, 125000), 125000, "");
1671 zassert_equal(DT_CAN_TRANSCEIVER_MAX_BITRATE(TEST_CAN_CTRL_3, 1000000), 1000000, "");
1672 zassert_equal(DT_CAN_TRANSCEIVER_MAX_BITRATE(TEST_CAN_CTRL_3, 5000000), 1000000, "");
1673
1674 /* DT_INST_CAN_TRANSCEIVER_MAX_BITRATE */
1675 zassert_equal(DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(0, 1000000), 1000000, "");
1676 zassert_equal(DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(0, 5000000), 5000000, "");
1677 zassert_equal(DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(0, 8000000), 5000000, "");
1678 zassert_equal(DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(1, 125000), 125000, "");
1679 zassert_equal(DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(1, 2000000), 2000000, "");
1680 zassert_equal(DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(1, 5000000), 2000000, "");
1681 zassert_equal(DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(2, 125000), 125000, "");
1682 zassert_equal(DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(2, 1000000), 1000000, "");
1683 zassert_equal(DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(2, 5000000), 1000000, "");
1684 zassert_equal(DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(3, 125000), 125000, "");
1685 zassert_equal(DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(3, 1000000), 1000000, "");
1686 zassert_equal(DT_INST_CAN_TRANSCEIVER_MAX_BITRATE(3, 5000000), 1000000, "");
1687 }
1688
ZTEST(devicetree_api,test_macro_names)1689 ZTEST(devicetree_api, test_macro_names)
1690 {
1691 /* white box */
1692 zassert_true(!strcmp(TO_STRING(DT_PATH(test, gpio_deadbeef)),
1693 "DT_N_S_test_S_gpio_deadbeef"), "");
1694 zassert_true(!strcmp(TO_STRING(DT_ALIAS(test_alias)),
1695 "DT_N_S_test_S_gpio_deadbeef"), "");
1696 zassert_true(!strcmp(TO_STRING(DT_NODELABEL(test_nodelabel)),
1697 "DT_N_S_test_S_gpio_deadbeef"), "");
1698 zassert_true(!strcmp(TO_STRING(DT_NODELABEL(test_nodelabel_allcaps)),
1699 "DT_N_S_test_S_gpio_deadbeef"), "");
1700
1701 #define CHILD_NODE_ID DT_CHILD(DT_PATH(test, i2c_11112222), test_i2c_dev_10)
1702 #define FULL_PATH_ID DT_PATH(test, i2c_11112222, test_i2c_dev_10)
1703
1704 zassert_true(!strcmp(TO_STRING(CHILD_NODE_ID),
1705 TO_STRING(FULL_PATH_ID)), "");
1706
1707 #undef CHILD_NODE_ID
1708 #undef FULL_PATH_ID
1709 }
1710
1711 static int a[] = DT_PROP(TEST_ARRAYS, a);
1712 static unsigned char b[] = DT_PROP(TEST_ARRAYS, b);
1713 static char *c[] = DT_PROP(TEST_ARRAYS, c);
1714
ZTEST(devicetree_api,test_arrays)1715 ZTEST(devicetree_api, test_arrays)
1716 {
1717 int ok;
1718
1719 zassert_equal(ARRAY_SIZE(a), 3, "");
1720 zassert_equal(ARRAY_SIZE(b), 4, "");
1721 zassert_equal(ARRAY_SIZE(c), 2, "");
1722
1723 zassert_equal(a[0], 1000, "");
1724 zassert_equal(a[1], 2000, "");
1725 zassert_equal(a[2], 3000, "");
1726
1727 zassert_true(DT_PROP_HAS_IDX(TEST_ARRAYS, a, 0), "");
1728 zassert_true(DT_PROP_HAS_IDX(TEST_ARRAYS, a, 1), "");
1729 zassert_true(DT_PROP_HAS_IDX(TEST_ARRAYS, a, 2), "");
1730 zassert_false(DT_PROP_HAS_IDX(TEST_ARRAYS, a, 3), "");
1731
1732 /*
1733 * Verify that DT_PROP_HAS_IDX can be used with COND_CODE_1()
1734 * and COND_CODE_0(), i.e. its expansion is a literal 1 or 0,
1735 * not an equivalent expression that evaluates to 1 or 0.
1736 */
1737 ok = 0;
1738 COND_CODE_1(DT_PROP_HAS_IDX(TEST_ARRAYS, a, 0), (ok = 1;), ());
1739 zassert_equal(ok, 1, "");
1740 ok = 0;
1741 COND_CODE_0(DT_PROP_HAS_IDX(TEST_ARRAYS, a, 3), (ok = 1;), ());
1742 zassert_equal(ok, 1, "");
1743
1744 zassert_equal(DT_PROP_BY_IDX(TEST_ARRAYS, a, 0), a[0], "");
1745 zassert_equal(DT_PROP_BY_IDX(TEST_ARRAYS, a, 1), a[1], "");
1746 zassert_equal(DT_PROP_BY_IDX(TEST_ARRAYS, a, 2), a[2], "");
1747 zassert_equal(DT_PROP_LAST(TEST_ARRAYS, a), a[2], "");
1748
1749 zassert_equal(DT_PROP_LEN(TEST_ARRAYS, a), 3, "");
1750
1751 zassert_equal(b[0], 0xaa, "");
1752 zassert_equal(b[1], 0xbb, "");
1753 zassert_equal(b[2], 0xcc, "");
1754 zassert_equal(b[3], 0xdd, "");
1755
1756 zassert_true(DT_PROP_HAS_IDX(TEST_ARRAYS, b, 0), "");
1757 zassert_true(DT_PROP_HAS_IDX(TEST_ARRAYS, b, 1), "");
1758 zassert_true(DT_PROP_HAS_IDX(TEST_ARRAYS, b, 2), "");
1759 zassert_true(DT_PROP_HAS_IDX(TEST_ARRAYS, b, 3), "");
1760 zassert_false(DT_PROP_HAS_IDX(TEST_ARRAYS, b, 4), "");
1761
1762 zassert_equal(DT_PROP_BY_IDX(TEST_ARRAYS, b, 0), b[0], "");
1763 zassert_equal(DT_PROP_BY_IDX(TEST_ARRAYS, b, 1), b[1], "");
1764 zassert_equal(DT_PROP_BY_IDX(TEST_ARRAYS, b, 2), b[2], "");
1765 zassert_equal(DT_PROP_BY_IDX(TEST_ARRAYS, b, 3), b[3], "");
1766
1767 zassert_equal(DT_PROP_LEN(TEST_ARRAYS, b), 4, "");
1768
1769 zassert_true(!strcmp(c[0], "bar"), "");
1770 zassert_true(!strcmp(c[1], "baz"), "");
1771
1772 zassert_true(DT_PROP_HAS_IDX(TEST_ARRAYS, c, 0), "");
1773 zassert_true(DT_PROP_HAS_IDX(TEST_ARRAYS, c, 1), "");
1774 zassert_false(DT_PROP_HAS_IDX(TEST_ARRAYS, c, 2), "");
1775
1776 zassert_true(!strcmp(DT_PROP_BY_IDX(TEST_ARRAYS, c, 0), c[0]), "");
1777 zassert_true(!strcmp(DT_PROP_BY_IDX(TEST_ARRAYS, c, 1), c[1]), "");
1778
1779 zassert_equal(DT_PROP_LEN(TEST_ARRAYS, c), 2, "");
1780 }
1781
ZTEST(devicetree_api,test_foreach)1782 ZTEST(devicetree_api, test_foreach)
1783 {
1784 /*
1785 * We don't know what platform we are running on, so settle for
1786 * some basic checks related to nodes we know are in our overlay.
1787 */
1788 #define IS_ALIASES(node_id) + DT_SAME_NODE(DT_PATH(aliases), node_id)
1789 #define IS_DISABLED_GPIO(node_id) + DT_SAME_NODE(DT_NODELABEL(disabled_gpio), \
1790 node_id)
1791 zassert_equal(1, DT_FOREACH_NODE(IS_ALIASES), "");
1792 zassert_equal(1, DT_FOREACH_NODE(IS_DISABLED_GPIO), "");
1793 zassert_equal(1, DT_FOREACH_STATUS_OKAY_NODE(IS_ALIASES), "");
1794 zassert_equal(0, DT_FOREACH_STATUS_OKAY_NODE(IS_DISABLED_GPIO), "");
1795
1796 #define IS_ALIASES_VARGS(node_id, mul) + ((mul) * DT_SAME_NODE(DT_PATH(aliases), node_id))
1797 #define IS_DISABLED_GPIO_VARGS(node_id, mul) + ((mul) * \
1798 DT_SAME_NODE(DT_NODELABEL(disabled_gpio), node_id))
1799 zassert_equal(2, DT_FOREACH_NODE_VARGS(IS_ALIASES_VARGS, 2), "");
1800 zassert_equal(2, DT_FOREACH_NODE_VARGS(IS_DISABLED_GPIO_VARGS, 2), "");
1801 zassert_equal(2, DT_FOREACH_STATUS_OKAY_NODE_VARGS(IS_ALIASES_VARGS, 2), "");
1802 zassert_equal(0, DT_FOREACH_STATUS_OKAY_NODE_VARGS(IS_DISABLED_GPIO_VARGS, 2), "");
1803
1804
1805 #undef IS_ALIASES
1806 #undef IS_DISABLED_GPIO
1807 #undef IS_ALIASES_VARGS
1808 #undef IS_DISABLED_GPIO_VARGS
1809 }
1810
1811 #undef DT_DRV_COMPAT
1812 #define DT_DRV_COMPAT vnd_gpio_device
ZTEST(devicetree_api,test_foreach_status_okay)1813 ZTEST(devicetree_api, test_foreach_status_okay)
1814 {
1815 /*
1816 * For-each-node type macro tests.
1817 *
1818 * See test_foreach_prop_elem*() for tests of
1819 * for-each-property type macros.
1820 */
1821 unsigned int val;
1822 const char *str;
1823
1824 /* This should expand to something like:
1825 *
1826 * "/test/enum-0" "/test/enum-1"
1827 *
1828 * but there is no guarantee about the order of nodes in the
1829 * expansion, so we test both.
1830 */
1831 str = DT_FOREACH_STATUS_OKAY(vnd_enum_holder, DT_NODE_PATH);
1832 zassert_true(!strcmp(str, "/test/enum-0/test/enum-1") ||
1833 !strcmp(str, "/test/enum-1/test/enum-0"), "");
1834
1835 #undef MY_FN
1836 #define MY_FN(node_id, operator) DT_ENUM_IDX(node_id, val) operator
1837 /* This should expand to something like:
1838 *
1839 * 0 + 2 + 3
1840 *
1841 * and order of expansion doesn't matter, since we're adding
1842 * the values all up.
1843 */
1844 val = DT_FOREACH_STATUS_OKAY_VARGS(vnd_enum_holder, MY_FN, +) 3;
1845 zassert_equal(val, 5, "");
1846
1847 #undef MY_FN
1848 #define MY_FN(inst, compat, operator) DT_ENUM_IDX(DT_INST(inst, compat), val) operator
1849 /* This should expand to something like:
1850 *
1851 * 0 + 2 + 3
1852 *
1853 * and order of expansion doesn't matter, since we're adding
1854 * the values all up.
1855 */
1856 val = DT_COMPAT_FOREACH_STATUS_OKAY_VARGS(vnd_enum_holder, MY_FN, +) 3;
1857 zassert_equal(val, 5, "");
1858
1859 /*
1860 * Make sure DT_INST_FOREACH_STATUS_OKAY can be called from functions
1861 * using macros with side effects in the current scope.
1862 */
1863 val = 0;
1864 #define INC(inst_ignored) do { val++; } while (0);
1865 DT_INST_FOREACH_STATUS_OKAY(INC)
1866 zassert_equal(val, 2, "");
1867 #undef INC
1868
1869 val = 0;
1870 #define INC_ARG(arg) do { val++; val += arg; } while (0)
1871 #define INC(inst_ignored, arg) INC_ARG(arg);
1872 DT_INST_FOREACH_STATUS_OKAY_VARGS(INC, 1)
1873 zassert_equal(val, 4, "");
1874 #undef INC_ARG
1875 #undef INC
1876
1877 /*
1878 * Make sure DT_INST_FOREACH_STATUS_OKAY works with 0 instances, and does
1879 * not expand its argument at all.
1880 */
1881 #undef DT_DRV_COMPAT
1882 #define DT_DRV_COMPAT xxxx
1883 #define BUILD_BUG_ON_EXPANSION (there is a bug in devicetree.h)
1884 DT_INST_FOREACH_STATUS_OKAY(BUILD_BUG_ON_EXPANSION)
1885 #undef BUILD_BUG_ON_EXPANSION
1886
1887 #undef DT_DRV_COMPAT
1888 #define DT_DRV_COMPAT xxxx
1889 #define BUILD_BUG_ON_EXPANSION(arg) (there is a bug in devicetree.h)
1890 DT_INST_FOREACH_STATUS_OKAY_VARGS(BUILD_BUG_ON_EXPANSION, 1)
1891 #undef BUILD_BUG_ON_EXPANSION
1892 }
1893
ZTEST(devicetree_api,test_foreach_nodelabel)1894 ZTEST(devicetree_api, test_foreach_nodelabel)
1895 {
1896 #undef DT_DRV_COMPAT
1897 #define DT_DRV_COMPAT vnd_adc_temp_sensor
1898 #define ENTRY(nodelabel) enum_ ## nodelabel,
1899 #define VAR_PLUS(nodelabel, to_add) int nodelabel ## _added = enum_ ## nodelabel + to_add;
1900
1901 /* DT_FOREACH_NODELABEL */
1902 enum {
1903 DT_FOREACH_NODELABEL(DT_NODELABEL(test_nodelabel), ENTRY)
1904 };
1905 zassert_equal(enum_test_nodelabel, 0, "");
1906 zassert_equal(enum_TEST_NODELABEL_ALLCAPS, 1, "");
1907 zassert_equal(enum_test_gpio_1, 2, "");
1908
1909 /* DT_FOREACH_NODELABEL_VARGS */
1910 DT_FOREACH_NODELABEL_VARGS(DT_NODELABEL(test_nodelabel), VAR_PLUS, 1);
1911 zassert_equal(test_nodelabel_added, 1, "");
1912 zassert_equal(TEST_NODELABEL_ALLCAPS_added, 2, "");
1913 zassert_equal(test_gpio_1_added, 3, "");
1914
1915 /* DT_NODELABEL_STRING_ARRAY is tested here since it's closely related */
1916 const char *nodelabels[] = DT_NODELABEL_STRING_ARRAY(DT_NODELABEL(test_nodelabel));
1917
1918 zassert_equal(ARRAY_SIZE(nodelabels), 3);
1919 zassert_true(!strcmp(nodelabels[0], "test_nodelabel"), "");
1920 zassert_true(!strcmp(nodelabels[1], "TEST_NODELABEL_ALLCAPS"), "");
1921 zassert_true(!strcmp(nodelabels[2], "test_gpio_1"), "");
1922
1923 /* DT_NUM_NODELABELS */
1924 zassert_equal(DT_NUM_NODELABELS(DT_NODELABEL(test_nodelabel)), 3, "");
1925 zassert_equal(DT_NUM_NODELABELS(DT_PATH(chosen)), 0, "");
1926 zassert_equal(DT_NUM_NODELABELS(DT_ROOT), 0, "");
1927
1928 /* DT_INST_FOREACH_NODELABEL */
1929 enum {
1930 DT_INST_FOREACH_NODELABEL(0, ENTRY)
1931 };
1932 zassert_equal(enum_test_temp_sensor, 0, "");
1933
1934 /* DT_INST_FOREACH_NODELABEL_VARGS */
1935 DT_INST_FOREACH_NODELABEL_VARGS(0, VAR_PLUS, 1);
1936 zassert_equal(test_temp_sensor_added, 1, "");
1937
1938 /* DT_INST_NODELABEL_STRING_ARRAY */
1939 const char *inst_nodelabels[] = DT_INST_NODELABEL_STRING_ARRAY(0);
1940
1941 zassert_equal(ARRAY_SIZE(inst_nodelabels), 1);
1942 zassert_true(!strcmp(inst_nodelabels[0], "test_temp_sensor"), "");
1943
1944 /* DT_INST_NUM_NODELABELS */
1945 zassert_equal(DT_INST_NUM_NODELABELS(0), 1, "");
1946
1947 #undef VAR_PLUS
1948 #undef ENTRY
1949 #undef DT_DRV_COMPAT
1950 }
1951
ZTEST(devicetree_api,test_foreach_prop_elem)1952 ZTEST(devicetree_api, test_foreach_prop_elem)
1953 {
1954 #define TIMES_TWO(node_id, prop, idx) \
1955 (2 * DT_PROP_BY_IDX(node_id, prop, idx)),
1956 #define BY_IDX_COMMA(node_id, prop, idx) DT_PROP_BY_IDX(node_id, prop, idx),
1957
1958 int array_a[] = {
1959 DT_FOREACH_PROP_ELEM(TEST_ARRAYS, a, TIMES_TWO)
1960 };
1961
1962 zassert_equal(ARRAY_SIZE(array_a), 3, "");
1963 zassert_equal(array_a[0], 2000, "");
1964 zassert_equal(array_a[1], 4000, "");
1965 zassert_equal(array_a[2], 6000, "");
1966
1967 int array_b[] = {
1968 DT_FOREACH_PROP_ELEM(TEST_ARRAYS, b, TIMES_TWO)
1969 };
1970
1971 zassert_equal(ARRAY_SIZE(array_b), 4, "");
1972 zassert_equal(array_b[0], 2 * 0xAA, "");
1973 zassert_equal(array_b[1], 2 * 0xBB, "");
1974 zassert_equal(array_b[2], 2 * 0xCC, "");
1975 zassert_equal(array_b[3], 2 * 0xDD, "");
1976
1977 static const char * const array_c[] = {
1978 DT_FOREACH_PROP_ELEM(TEST_ARRAYS, c, BY_IDX_COMMA)
1979 };
1980
1981 zassert_equal(ARRAY_SIZE(array_c), 2, "");
1982 zassert_true(!strcmp(array_c[0], "bar"), "");
1983 zassert_true(!strcmp(array_c[1], "baz"), "");
1984
1985 static const char * const array_val[] = {
1986 DT_FOREACH_PROP_ELEM(TEST_ENUM_0, val, BY_IDX_COMMA)
1987 };
1988
1989 zassert_equal(ARRAY_SIZE(array_val), 1, "");
1990 zassert_true(!strcmp(array_val[0], "zero"), "");
1991
1992 static const char * const string_zephyr_user[] = {
1993 DT_FOREACH_PROP_ELEM(ZEPHYR_USER, string, BY_IDX_COMMA)
1994 };
1995
1996 zassert_equal(ARRAY_SIZE(string_zephyr_user), 1, "");
1997 zassert_true(!strcmp(string_zephyr_user[0], "foo"), "");
1998
1999 #undef BY_IDX_COMMA
2000
2001 #define PATH_COMMA(node_id, prop, idx) \
2002 DT_NODE_PATH(DT_PROP_BY_IDX(node_id, prop, idx)),
2003
2004 static const char * const array_ph[] = {
2005 DT_FOREACH_PROP_ELEM(TEST_PH, ph, PATH_COMMA)
2006 };
2007
2008 zassert_equal(ARRAY_SIZE(array_ph), 1, "");
2009 zassert_true(!strcmp(array_ph[0], DT_NODE_PATH(TEST_GPIO_1)), "");
2010
2011 static const char * const array_zephyr_user_ph[] = {
2012 DT_FOREACH_PROP_ELEM(ZEPHYR_USER, ph, PATH_COMMA)
2013 };
2014
2015 zassert_equal(ARRAY_SIZE(array_zephyr_user_ph), 1, "");
2016 zassert_true(!strcmp(array_zephyr_user_ph[0],
2017 DT_NODE_PATH(TEST_GPIO_1)), "");
2018
2019 static const char * const array_phs[] = {
2020 DT_FOREACH_PROP_ELEM(TEST_PH, phs, PATH_COMMA)
2021 };
2022
2023 zassert_equal(ARRAY_SIZE(array_phs), 2, "");
2024 zassert_true(!strcmp(array_phs[0], DT_NODE_PATH(TEST_I2C)), "");
2025 zassert_true(!strcmp(array_phs[1], DT_NODE_PATH(TEST_SPI)), "");
2026
2027 #undef PATH_COMMA
2028
2029 #define PIN_COMMA(node_id, prop, idx) DT_GPIO_PIN_BY_IDX(node_id, prop, idx),
2030
2031 int array_gpios[] = {
2032 DT_FOREACH_PROP_ELEM(TEST_PH, gpios, PIN_COMMA)
2033 };
2034
2035 zassert_equal(ARRAY_SIZE(array_gpios), 2, "");
2036 zassert_equal(array_gpios[0], 10, "");
2037 zassert_equal(array_gpios[1], 30, "");
2038
2039 #undef PATH_COMMA
2040
2041 int array_sep[] = {
2042 DT_FOREACH_PROP_ELEM_SEP(TEST_ARRAYS, a, DT_PROP_BY_IDX, (,))
2043 };
2044
2045 zassert_equal(ARRAY_SIZE(array_sep), 3, "");
2046 zassert_equal(array_sep[0], 1000, "");
2047 zassert_equal(array_sep[1], 2000, "");
2048 zassert_equal(array_sep[2], 3000, "");
2049
2050 #undef DT_DRV_COMPAT
2051 #define DT_DRV_COMPAT vnd_array_holder
2052
2053 int inst_array[] = {
2054 DT_INST_FOREACH_PROP_ELEM(0, a, TIMES_TWO)
2055 };
2056
2057 zassert_equal(ARRAY_SIZE(inst_array), ARRAY_SIZE(array_a), "");
2058 zassert_equal(inst_array[0], array_a[0], "");
2059 zassert_equal(inst_array[1], array_a[1], "");
2060 zassert_equal(inst_array[2], array_a[2], "");
2061
2062 int inst_array_sep[] = {
2063 DT_INST_FOREACH_PROP_ELEM_SEP(0, a, DT_PROP_BY_IDX, (,))
2064 };
2065
2066 zassert_equal(ARRAY_SIZE(inst_array_sep), ARRAY_SIZE(array_sep), "");
2067 zassert_equal(inst_array_sep[0], array_sep[0], "");
2068 zassert_equal(inst_array_sep[1], array_sep[1], "");
2069 zassert_equal(inst_array_sep[2], array_sep[2], "");
2070 #undef TIMES_TWO
2071 }
2072
ZTEST(devicetree_api,test_foreach_prop_elem_varg)2073 ZTEST(devicetree_api, test_foreach_prop_elem_varg)
2074 {
2075 #define TIMES_TWO_ADD(node_id, prop, idx, arg) \
2076 ((2 * DT_PROP_BY_IDX(node_id, prop, idx)) + arg),
2077
2078 int array[] = {
2079 DT_FOREACH_PROP_ELEM_VARGS(TEST_ARRAYS, a, TIMES_TWO_ADD, 3)
2080 };
2081
2082 zassert_equal(ARRAY_SIZE(array), 3, "");
2083 zassert_equal(array[0], 2003, "");
2084 zassert_equal(array[1], 4003, "");
2085 zassert_equal(array[2], 6003, "");
2086
2087 #define PROP_PLUS_ARG(node_id, prop, idx, arg) \
2088 (DT_PROP_BY_IDX(node_id, prop, idx) + arg)
2089
2090 int array_sep[] = {
2091 DT_FOREACH_PROP_ELEM_SEP_VARGS(TEST_ARRAYS, a, PROP_PLUS_ARG,
2092 (,), 3)
2093 };
2094
2095 zassert_equal(ARRAY_SIZE(array_sep), 3, "");
2096 zassert_equal(array_sep[0], 1003, "");
2097 zassert_equal(array_sep[1], 2003, "");
2098 zassert_equal(array_sep[2], 3003, "");
2099
2100 #undef DT_DRV_COMPAT
2101 #define DT_DRV_COMPAT vnd_array_holder
2102
2103 int inst_array[] = {
2104 DT_INST_FOREACH_PROP_ELEM_VARGS(0, a, TIMES_TWO_ADD, 3)
2105 };
2106
2107 zassert_equal(ARRAY_SIZE(inst_array), ARRAY_SIZE(array), "");
2108 zassert_equal(inst_array[0], array[0], "");
2109 zassert_equal(inst_array[1], array[1], "");
2110 zassert_equal(inst_array[2], array[2], "");
2111
2112 int inst_array_sep[] = {
2113 DT_INST_FOREACH_PROP_ELEM_SEP_VARGS(0, a, PROP_PLUS_ARG, (,),
2114 3)
2115 };
2116
2117 zassert_equal(ARRAY_SIZE(inst_array_sep), ARRAY_SIZE(array_sep), "");
2118 zassert_equal(inst_array_sep[0], array_sep[0], "");
2119 zassert_equal(inst_array_sep[1], array_sep[1], "");
2120 zassert_equal(inst_array_sep[2], array_sep[2], "");
2121 #undef TIMES_TWO
2122 }
2123
2124 struct test_gpio_info {
2125 uint32_t reg_addr;
2126 uint32_t reg_len;
2127 };
2128
2129 struct test_gpio_data {
2130 bool init_called;
2131 bool is_gpio_ctlr;
2132 };
2133
test_gpio_init(const struct device * dev)2134 static int test_gpio_init(const struct device *dev)
2135 {
2136 struct test_gpio_data *data = dev->data;
2137
2138 data->init_called = 1;
2139 return 0;
2140 }
2141
2142 #undef DT_DRV_COMPAT
2143 #define DT_DRV_COMPAT vnd_gpio_device
2144
2145 static DEVICE_API(gpio, test_api);
2146
2147 #define TEST_GPIO_INIT(num) \
2148 static struct test_gpio_data gpio_data_##num = { \
2149 .is_gpio_ctlr = DT_INST_PROP(num, \
2150 gpio_controller), \
2151 }; \
2152 static const struct test_gpio_info gpio_info_##num = { \
2153 .reg_addr = DT_INST_REG_ADDR(num), \
2154 .reg_len = DT_INST_REG_SIZE(num), \
2155 }; \
2156 DEVICE_DT_INST_DEFINE(num, \
2157 test_gpio_init, \
2158 NULL, \
2159 &gpio_data_##num, \
2160 &gpio_info_##num, \
2161 POST_KERNEL, \
2162 CONFIG_APPLICATION_INIT_PRIORITY, \
2163 &test_api);
2164
2165 DT_INST_FOREACH_STATUS_OKAY(TEST_GPIO_INIT)
2166
ZTEST(devicetree_api,test_devices)2167 ZTEST(devicetree_api, test_devices)
2168 {
2169 const struct device *devs[2] = { DEVICE_DT_INST_GET(0), DEVICE_DT_INST_GET(1) };
2170 const struct device *dev_abcd;
2171 struct test_gpio_data *data_dev0;
2172 struct test_gpio_data *data_dev1;
2173 const struct test_gpio_info *config_abdc;
2174
2175 zassert_equal(DT_NUM_INST_STATUS_OKAY(vnd_gpio_device), 2, "");
2176
2177 data_dev0 = devs[0]->data;
2178 data_dev1 = devs[1]->data;
2179
2180 zassert_not_null(devs[0], "");
2181 zassert_not_null(devs[1], "");
2182
2183 zassert_true(data_dev0->is_gpio_ctlr, "");
2184 zassert_true(data_dev1->is_gpio_ctlr, "");
2185 zassert_true(data_dev0->init_called, "");
2186 zassert_true(data_dev1->init_called, "");
2187
2188 dev_abcd = DEVICE_DT_GET(TEST_ABCD1234);
2189 config_abdc = dev_abcd->config;
2190 zassert_not_null(dev_abcd, "");
2191 zassert_equal(config_abdc->reg_addr, 0xabcd1234, "");
2192 zassert_equal(config_abdc->reg_len, 0x500, "");
2193 }
2194
ZTEST(devicetree_api,test_cs_gpios)2195 ZTEST(devicetree_api, test_cs_gpios)
2196 {
2197 zassert_equal(DT_SPI_HAS_CS_GPIOS(TEST_SPI_NO_CS), 0, "");
2198 zassert_equal(DT_SPI_NUM_CS_GPIOS(TEST_SPI_NO_CS), 0, "");
2199
2200 zassert_equal(DT_SPI_HAS_CS_GPIOS(TEST_SPI), 1, "");
2201 zassert_equal(DT_SPI_NUM_CS_GPIOS(TEST_SPI), 3, "");
2202
2203 zassert_equal(DT_DEP_ORD(DT_SPI_DEV_CS_GPIOS_CTLR(TEST_SPI_DEV_0)),
2204 DT_DEP_ORD(DT_NODELABEL(test_gpio_1)),
2205 "dev 0 cs gpio controller");
2206 zassert_equal(DT_SPI_DEV_CS_GPIOS_PIN(TEST_SPI_DEV_0), 0x10, "");
2207 zassert_equal(DT_SPI_DEV_CS_GPIOS_FLAGS(TEST_SPI_DEV_0), 0x20, "");
2208 }
2209
ZTEST(devicetree_api,test_chosen)2210 ZTEST(devicetree_api, test_chosen)
2211 {
2212 zassert_equal(DT_HAS_CHOSEN(ztest_xxxx), 0, "");
2213 zassert_equal(DT_HAS_CHOSEN(ztest_gpio), 1, "");
2214 zassert_true(!strcmp(TO_STRING(DT_CHOSEN(ztest_gpio)),
2215 "DT_N_S_test_S_gpio_deadbeef"), "");
2216 }
2217
2218 #define TO_MY_ENUM(token) TO_MY_ENUM_2(token) /* force another expansion */
2219 #define TO_MY_ENUM_2(token) MY_ENUM_ ## token
ZTEST(devicetree_api,test_enums)2220 ZTEST(devicetree_api, test_enums)
2221 {
2222 enum {
2223 MY_ENUM_zero = 0xff,
2224 MY_ENUM_ZERO = 0xaa,
2225 };
2226
2227 /* DT_ENUM_IDX and DT_ENUM_HAS_VALUE on string enum */
2228 zassert_equal(DT_ENUM_IDX(TEST_ENUM_0, val), 0, "0");
2229 zassert_true(DT_ENUM_HAS_VALUE(TEST_ENUM_0, val, zero), "");
2230 zassert_false(DT_ENUM_HAS_VALUE(TEST_ENUM_0, val, one), "");
2231 zassert_false(DT_ENUM_HAS_VALUE(TEST_ENUM_0, val, two), "");
2232
2233 /* DT_ENUM_IDX and DT_ENUM_HAS_VALUE on int enum */
2234 zassert_equal(DT_ENUM_IDX(DT_NODELABEL(test_enum_int_default_0), val), 0, "0");
2235 zassert_true(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_int_default_0), val, 5), "");
2236 zassert_false(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_int_default_0), val, 6), "");
2237 zassert_false(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_int_default_0), val, 7), "");
2238
2239 /* DT_ENUM_IDX_BY_IDX and DT_ENUM_HAS_VALUE_BY_IDX on string-array enum */
2240 zassert_equal(DT_ENUM_IDX_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 0), 0);
2241 zassert_equal(DT_ENUM_IDX_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 1), 3);
2242 zassert_equal(DT_ENUM_IDX_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 2), 0);
2243 zassert_true(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 0, foo));
2244 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 0, bar));
2245 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 0, baz));
2246 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 0, zoo));
2247 zassert_true(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 1, zoo));
2248 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 1, foo));
2249 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 1, bar));
2250 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 1, baz));
2251 zassert_true(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 2, foo));
2252 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 2, baz));
2253 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 2, bar));
2254 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_string_array), val, 2, zoo));
2255
2256 /* DT_ENUM_HAS_VALUE on string-array enum */
2257 zassert_true(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_string_array), val, foo));
2258 zassert_true(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_string_array), val, zoo));
2259 zassert_true(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_string_array), val, foo));
2260 zassert_false(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_string_array), val, baz));
2261
2262 /* DT_ENUM_IDX_BY_IDX and DT_ENUM_HAS_VALUE_BY_IDX on int-array enum */
2263 zassert_equal(DT_ENUM_IDX_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 0), 3);
2264 zassert_equal(DT_ENUM_IDX_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 1), 4);
2265 zassert_equal(DT_ENUM_IDX_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 2), 3);
2266 zassert_equal(DT_ENUM_IDX_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 3), 7);
2267 zassert_true(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 0, 4));
2268 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 0, 5));
2269 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 0, 6));
2270 zassert_true(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 1, 3));
2271 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 1, 0));
2272 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 1, 1));
2273 zassert_true(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 2, 4));
2274 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 2, 3));
2275 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 2, 7));
2276 zassert_true(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 3, 0));
2277 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 3, 2));
2278 zassert_false(DT_ENUM_HAS_VALUE_BY_IDX(DT_NODELABEL(test_enum_int_array), val, 3, 1));
2279
2280 /* DT_ENUM_HAS_VALUE on int-array enum */
2281 zassert_true(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_int_array), val, 0));
2282 zassert_false(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_int_array), val, 1));
2283 zassert_false(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_int_array), val, 2));
2284 zassert_true(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_int_array), val, 3));
2285 zassert_true(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_int_array), val, 4));
2286 zassert_false(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_int_array), val, 5));
2287 zassert_false(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_int_array), val, 6));
2288 zassert_false(DT_ENUM_HAS_VALUE(DT_NODELABEL(test_enum_int_array), val, 7));
2289 }
2290 #undef TO_MY_ENUM
2291 #undef TO_MY_ENUM_2
2292
ZTEST(devicetree_api,test_enums_required_false)2293 ZTEST(devicetree_api, test_enums_required_false)
2294 {
2295 /* DT_ENUM_IDX_OR on string value */
2296 zassert_equal(DT_ENUM_IDX_OR(DT_NODELABEL(test_enum_default_0), val, 2),
2297 1, "");
2298 zassert_equal(DT_ENUM_IDX_OR(DT_NODELABEL(test_enum_default_1), val, 2),
2299 2, "");
2300 /* DT_ENUM_IDX_OR on int value */
2301 zassert_equal(DT_ENUM_IDX_OR(DT_NODELABEL(test_enum_int_default_0),
2302 val, 4),
2303 0, "");
2304 zassert_equal(DT_ENUM_IDX_OR(DT_NODELABEL(test_enum_int_default_1),
2305 val, 4),
2306 4, "");
2307 /* DT_ENUM_IDX_OR on string-array value */
2308 zassert_equal(DT_ENUM_IDX_BY_IDX_OR(DT_NODELABEL(test_enum_string_array), val, 0, 2),
2309 0, "");
2310 zassert_equal(DT_ENUM_IDX_BY_IDX_OR(DT_NODELABEL(test_enum_string_array), val, 5, 2),
2311 2, "");
2312 /* DT_ENUM_IDX_OR on int-array value */
2313 zassert_equal(DT_ENUM_IDX_BY_IDX_OR(DT_NODELABEL(test_enum_int_array),
2314 val, 0, 7),
2315 3, "");
2316 zassert_equal(DT_ENUM_IDX_BY_IDX_OR(DT_NODELABEL(test_enum_int_array),
2317 val, 4, 7),
2318 7, "");
2319 }
2320
ZTEST(devicetree_api,test_inst_enums)2321 ZTEST(devicetree_api, test_inst_enums)
2322 {
2323 #undef DT_DRV_COMPAT
2324 #define DT_DRV_COMPAT vnd_enum_holder_inst
2325 zassert_equal(DT_INST_ENUM_IDX(0, val), 0, "");
2326 zassert_equal(DT_INST_ENUM_IDX_OR(0, val, 2), 0, "");
2327 zassert_true(DT_INST_ENUM_HAS_VALUE(0, val, zero), "");
2328 zassert_false(DT_INST_ENUM_HAS_VALUE(0, val, one), "");
2329 zassert_false(DT_INST_ENUM_HAS_VALUE(0, val, two), "");
2330
2331 #undef DT_DRV_COMPAT
2332 #define DT_DRV_COMPAT vnd_enum_required_false_holder_inst
2333 zassert_equal(DT_INST_ENUM_IDX_OR(0, val, 2), 2, "");
2334 zassert_false(DT_INST_ENUM_HAS_VALUE(0, val, zero), "");
2335 zassert_false(DT_INST_ENUM_HAS_VALUE(0, val, one), "");
2336 zassert_false(DT_INST_ENUM_HAS_VALUE(0, val, two), "");
2337
2338 /* Also add tests for these:
2339 * DT_INST_ENUM_IDX_BY_IDX
2340 * DT_INST_ENUM_IDX_BY_IDX_OR
2341 * DT_INST_ENUM_HAS_VALUE_BY_IDX
2342 */
2343 #undef DT_DRV_COMPAT
2344 #define DT_DRV_COMPAT vnd_enum_string_array_holder
2345 zassert_equal(DT_INST_ENUM_IDX_BY_IDX(0, val, 0), 0, "");
2346 zassert_equal(DT_INST_ENUM_IDX_BY_IDX(0, val, 1), 3, "");
2347 zassert_true(DT_INST_ENUM_HAS_VALUE_BY_IDX(0, val, 0, foo), "");
2348 zassert_false(DT_INST_ENUM_HAS_VALUE_BY_IDX(0, val, 0, zoo), "");
2349 zassert_true(DT_INST_ENUM_HAS_VALUE_BY_IDX(0, val, 1, zoo), "");
2350 zassert_false(DT_INST_ENUM_HAS_VALUE_BY_IDX(0, val, 2, baz), "");
2351 zassert_equal(DT_INST_ENUM_IDX_BY_IDX_OR(0, val, 0, 10), 0, "");
2352 zassert_equal(DT_INST_ENUM_IDX_BY_IDX_OR(0, val, 4, 10), 10, "");
2353
2354 #undef DT_DRV_COMPAT
2355 #define DT_DRV_COMPAT vnd_enum_int_array_holder
2356 zassert_equal(DT_INST_ENUM_IDX_BY_IDX(0, val, 0), 3, "");
2357 zassert_equal(DT_INST_ENUM_IDX_BY_IDX(0, val, 3), 7, "");
2358 zassert_equal(DT_INST_ENUM_IDX_BY_IDX_OR(0, val, 1, 10), 4, "");
2359 zassert_equal(DT_INST_ENUM_IDX_BY_IDX_OR(0, val, 123654, 10), 10, "");
2360 }
2361
2362 #undef DT_DRV_COMPAT
2363 #define DT_DRV_COMPAT vnd_adc_temp_sensor
ZTEST(devicetree_api,test_clocks)2364 ZTEST(devicetree_api, test_clocks)
2365 {
2366 /* DT_CLOCKS_CTLR_BY_IDX */
2367 zassert_true(DT_SAME_NODE(DT_CLOCKS_CTLR_BY_IDX(TEST_TEMP, 1),
2368 DT_NODELABEL(test_fixed_clk)), "");
2369
2370 /* DT_CLOCKS_CTLR */
2371 zassert_true(DT_SAME_NODE(DT_CLOCKS_CTLR(TEST_TEMP),
2372 DT_NODELABEL(test_clk)), "");
2373
2374 /* DT_CLOCKS_CTLR_BY_NAME */
2375 zassert_true(DT_SAME_NODE(DT_CLOCKS_CTLR_BY_NAME(TEST_TEMP, clk_b),
2376 DT_NODELABEL(test_clk)), "");
2377
2378 /* DT_NUM_CLOCKS */
2379 zassert_equal(DT_NUM_CLOCKS(TEST_TEMP), 3, "");
2380
2381 /* DT_CLOCKS_HAS_IDX */
2382 zassert_true(DT_CLOCKS_HAS_IDX(TEST_TEMP, 2), "");
2383 zassert_false(DT_CLOCKS_HAS_IDX(TEST_TEMP, 3), "");
2384
2385 /* DT_CLOCKS_HAS_NAME */
2386 zassert_true(DT_CLOCKS_HAS_NAME(TEST_TEMP, clk_a), "");
2387 zassert_false(DT_CLOCKS_HAS_NAME(TEST_TEMP, clk_z), "");
2388
2389 /* DT_CLOCKS_CELL_BY_IDX */
2390 zassert_equal(DT_CLOCKS_CELL_BY_IDX(TEST_TEMP, 2, bits), 2, "");
2391 zassert_equal(DT_CLOCKS_CELL_BY_IDX(TEST_TEMP, 2, bus), 8, "");
2392
2393 /* DT_CLOCKS_CELL_BY_NAME */
2394 zassert_equal(DT_CLOCKS_CELL_BY_NAME(TEST_TEMP, clk_a, bits), 7, "");
2395 zassert_equal(DT_CLOCKS_CELL_BY_NAME(TEST_TEMP, clk_b, bus), 8, "");
2396
2397 /* DT_CLOCKS_CELL */
2398 zassert_equal(DT_CLOCKS_CELL(TEST_TEMP, bits), 7, "");
2399 zassert_equal(DT_CLOCKS_CELL(TEST_TEMP, bus), 3, "");
2400
2401 /* clock-freq on fixed clock */
2402 zassert_equal(DT_PROP_BY_PHANDLE_IDX(TEST_TEMP, clocks, 1,
2403 clock_frequency),
2404 25000000, "");
2405
2406 /* DT_INST */
2407 zassert_equal(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT), 1, "");
2408
2409 /* DT_INST_CLOCKS_CTLR_BY_IDX */
2410 zassert_true(DT_SAME_NODE(DT_INST_CLOCKS_CTLR_BY_IDX(0, 1),
2411 DT_NODELABEL(test_fixed_clk)), "");
2412
2413 /* DT_INST_CLOCKS_CTLR */
2414 zassert_true(DT_SAME_NODE(DT_INST_CLOCKS_CTLR(0),
2415 DT_NODELABEL(test_clk)), "");
2416
2417 /* DT_INST_CLOCKS_CTLR_BY_NAME */
2418 zassert_true(DT_SAME_NODE(DT_INST_CLOCKS_CTLR_BY_NAME(0, clk_b),
2419 DT_NODELABEL(test_clk)), "");
2420
2421 /* DT_INST_NUM_CLOCKS */
2422 zassert_equal(DT_INST_NUM_CLOCKS(0), 3, "");
2423
2424 /* DT_INST_CLOCKS_HAS_IDX */
2425 zassert_true(DT_INST_CLOCKS_HAS_IDX(0, 2), "");
2426 zassert_false(DT_INST_CLOCKS_HAS_IDX(0, 3), "");
2427
2428 /* DT_INST_CLOCKS_HAS_NAME */
2429 zassert_true(DT_INST_CLOCKS_HAS_NAME(0, clk_a), "");
2430 zassert_false(DT_INST_CLOCKS_HAS_NAME(0, clk_z), "");
2431
2432 /* DT_INST_CLOCKS_CELL_BY_IDX */
2433 zassert_equal(DT_INST_CLOCKS_CELL_BY_IDX(0, 2, bits), 2, "");
2434 zassert_equal(DT_INST_CLOCKS_CELL_BY_IDX(0, 2, bus), 8, "");
2435
2436 /* DT_INST_CLOCKS_CELL_BY_NAME */
2437 zassert_equal(DT_INST_CLOCKS_CELL_BY_NAME(0, clk_a, bits), 7, "");
2438 zassert_equal(DT_INST_CLOCKS_CELL_BY_NAME(0, clk_b, bus), 8, "");
2439
2440 /* DT_INST_CLOCKS_CELL */
2441 zassert_equal(DT_INST_CLOCKS_CELL(0, bits), 7, "");
2442 zassert_equal(DT_INST_CLOCKS_CELL(0, bus), 3, "");
2443
2444 /* clock-freq on fixed clock */
2445 zassert_equal(DT_INST_PROP_BY_PHANDLE_IDX(0, clocks, 1,
2446 clock_frequency),
2447 25000000, "");
2448 }
2449
2450 #undef DT_DRV_COMPAT
2451 #define DT_DRV_COMPAT vnd_spi_device
ZTEST(devicetree_api,test_parent)2452 ZTEST(devicetree_api, test_parent)
2453 {
2454 zassert_true(DT_SAME_NODE(DT_PARENT(TEST_SPI_DEV_0), TEST_SPI_BUS_0), "");
2455
2456 /*
2457 * The parent's label for the first instance of vnd,spi-device,
2458 * child of TEST_SPI, is the same as TEST_SPI.
2459 */
2460 zassert_true(DT_SAME_NODE(DT_INST_PARENT(0), TEST_SPI), "");
2461 /*
2462 * We should be able to use DT_PARENT() even with nodes, like /test,
2463 * that have no matching compatible.
2464 */
2465 zassert_true(DT_SAME_NODE(DT_CHILD(DT_PARENT(TEST_SPI_BUS_0), spi_33334444),
2466 TEST_SPI_BUS_0), "");
2467 }
2468
2469 #undef DT_DRV_COMPAT
2470 #define DT_DRV_COMPAT vnd_parent_bindings
ZTEST(devicetree_api,test_parent_nodes_list)2471 ZTEST(devicetree_api, test_parent_nodes_list)
2472 {
2473 /* When traversing upwards, there are no fixed attributes and labels */
2474 #define TEST_FUNC(parent) { /* No operation */ }
2475 #define TEST_FUNC_AND_COMMA(parent) TEST_FUNC(parent),
2476
2477 struct vnd_parent_binding {
2478 int val;
2479 };
2480
2481 struct vnd_parent_binding vals_a[] = {
2482 DT_FOREACH_ANCESTOR(DT_NODELABEL(test_parent_a), TEST_FUNC_AND_COMMA)};
2483
2484 struct vnd_parent_binding vals_b[] = {
2485 DT_FOREACH_ANCESTOR(DT_NODELABEL(test_parent_b), TEST_FUNC_AND_COMMA)};
2486
2487 zassert_equal(ARRAY_SIZE(vals_a), 3, "");
2488 zassert_equal(ARRAY_SIZE(vals_b), 4, "");
2489
2490 #undef TEST_FUNC_AND_COMMA
2491 #undef TEST_FUNC
2492 }
2493
2494 #undef DT_DRV_COMPAT
2495 #define DT_DRV_COMPAT vnd_i2c_mux_controller
ZTEST(devicetree_api,test_gparent)2496 ZTEST(devicetree_api, test_gparent)
2497 {
2498 zassert_true(DT_SAME_NODE(DT_GPARENT(TEST_I2C_MUX_CTLR_1), TEST_I2C), "");
2499 zassert_true(DT_SAME_NODE(DT_INST_GPARENT(0), TEST_I2C), "");
2500 zassert_true(DT_SAME_NODE(DT_INST_GPARENT(1), TEST_I2C), "");
2501 }
2502
2503 #undef DT_DRV_COMPAT
2504 #define DT_DRV_COMPAT vnd_child_bindings
ZTEST(devicetree_api,test_children)2505 ZTEST(devicetree_api, test_children)
2506 {
2507 zassert_equal(DT_PROP(DT_CHILD(DT_NODELABEL(test_children), child_a),
2508 val), 0, "");
2509 zassert_equal(DT_PROP(DT_CHILD(DT_NODELABEL(test_children), child_b),
2510 val), 1, "");
2511 zassert_equal(DT_PROP(DT_CHILD(DT_NODELABEL(test_children), child_c),
2512 val), 2, "");
2513
2514 zassert_equal(DT_PROP(DT_INST_CHILD(0, child_a), val), 0, "");
2515 zassert_equal(DT_PROP(DT_INST_CHILD(0, child_b), val), 1, "");
2516 zassert_equal(DT_PROP(DT_INST_CHILD(0, child_c), val), 2, "");
2517
2518 zassert_equal(DT_PROP(DT_CHILD_BY_UNIT_ADDR_INT(DT_NODELABEL(test_children), 10), val), 0);
2519 zassert_equal(DT_PROP(DT_CHILD_BY_UNIT_ADDR_INT(DT_NODELABEL(test_children), 11), val), 1);
2520 zassert_equal(DT_PROP(DT_CHILD_BY_UNIT_ADDR_INT(DT_NODELABEL(test_children), 12), val), 2);
2521
2522 zassert_equal(DT_PROP(DT_INST_CHILD_BY_UNIT_ADDR_INT(0, 10), val), 0);
2523 zassert_equal(DT_PROP(DT_INST_CHILD_BY_UNIT_ADDR_INT(0, 11), val), 1);
2524 zassert_equal(DT_PROP(DT_INST_CHILD_BY_UNIT_ADDR_INT(0, 12), val), 2);
2525 }
2526
2527 #undef DT_DRV_COMPAT
2528 #define DT_DRV_COMPAT vnd_child_bindings
ZTEST(devicetree_api,test_child_nodes_list)2529 ZTEST(devicetree_api, test_child_nodes_list)
2530 {
2531 #define TEST_FUNC(child) { DT_PROP(child, val) }
2532 #define TEST_FUNC_AND_COMMA(child) TEST_FUNC(child),
2533 #define TEST_PARENT DT_PARENT(DT_NODELABEL(test_child_a))
2534
2535 struct vnd_child_binding {
2536 int val;
2537 };
2538
2539 struct vnd_child_binding vals[] = {
2540 DT_FOREACH_CHILD(TEST_PARENT, TEST_FUNC_AND_COMMA)
2541 };
2542
2543 struct vnd_child_binding vals_sep[] = {
2544 DT_FOREACH_CHILD_SEP(TEST_PARENT, TEST_FUNC, (,))
2545 };
2546
2547 struct vnd_child_binding vals_inst[] = {
2548 DT_INST_FOREACH_CHILD(0, TEST_FUNC_AND_COMMA)
2549 };
2550
2551 struct vnd_child_binding vals_inst_sep[] = {
2552 DT_INST_FOREACH_CHILD_SEP(0, TEST_FUNC, (,))
2553 };
2554
2555 struct vnd_child_binding vals_status_okay[] = {
2556 DT_FOREACH_CHILD_STATUS_OKAY(TEST_PARENT, TEST_FUNC_AND_COMMA)
2557 };
2558
2559 struct vnd_child_binding vals_status_okay_inst[] = {
2560 DT_INST_FOREACH_CHILD_STATUS_OKAY(0, TEST_FUNC_AND_COMMA)
2561 };
2562
2563 struct vnd_child_binding vals_status_okay_sep[] = {
2564 DT_FOREACH_CHILD_STATUS_OKAY_SEP(TEST_PARENT, TEST_FUNC, (,))
2565 };
2566
2567 struct vnd_child_binding vals_status_okay_inst_sep[] = {
2568 DT_INST_FOREACH_CHILD_STATUS_OKAY_SEP(0, TEST_FUNC, (,))
2569 };
2570
2571 zassert_equal(ARRAY_SIZE(vals), 3, "");
2572 zassert_equal(ARRAY_SIZE(vals_sep), 3, "");
2573 zassert_equal(ARRAY_SIZE(vals_inst), 3, "");
2574 zassert_equal(ARRAY_SIZE(vals_inst_sep), 3, "");
2575 zassert_equal(ARRAY_SIZE(vals_status_okay), 2, "");
2576 zassert_equal(ARRAY_SIZE(vals_status_okay_inst), 2, "");
2577 zassert_equal(ARRAY_SIZE(vals_status_okay_sep), 2, "");
2578 zassert_equal(ARRAY_SIZE(vals_status_okay_inst_sep), 2, "");
2579
2580 zassert_equal(vals[0].val, 0, "");
2581 zassert_equal(vals[1].val, 1, "");
2582 zassert_equal(vals[2].val, 2, "");
2583 zassert_equal(vals_sep[0].val, 0, "");
2584 zassert_equal(vals_sep[1].val, 1, "");
2585 zassert_equal(vals_sep[2].val, 2, "");
2586 zassert_equal(vals_inst[0].val, 0, "");
2587 zassert_equal(vals_inst[1].val, 1, "");
2588 zassert_equal(vals_inst[2].val, 2, "");
2589 zassert_equal(vals_inst_sep[0].val, 0, "");
2590 zassert_equal(vals_inst_sep[1].val, 1, "");
2591 zassert_equal(vals_inst_sep[2].val, 2, "");
2592 zassert_equal(vals_status_okay[0].val, 0, "");
2593 zassert_equal(vals_status_okay[1].val, 1, "");
2594 zassert_equal(vals_status_okay_inst[0].val, 0, "");
2595 zassert_equal(vals_status_okay_inst[1].val, 1, "");
2596 zassert_equal(vals_status_okay_sep[0].val, 0, "");
2597 zassert_equal(vals_status_okay_sep[1].val, 1, "");
2598 zassert_equal(vals_status_okay_inst_sep[0].val, 0, "");
2599 zassert_equal(vals_status_okay_inst_sep[1].val, 1, "");
2600
2601 #undef TEST_PARENT
2602 #undef TEST_FUNC_AND_COMMA
2603 #undef TEST_FUNC
2604 }
2605
2606 #undef DT_DRV_COMPAT
2607 #define DT_DRV_COMPAT vnd_child_bindings
ZTEST(devicetree_api,test_child_nodes_list_varg)2608 ZTEST(devicetree_api, test_child_nodes_list_varg)
2609 {
2610 #define TEST_FUNC(child, arg) { DT_PROP(child, val) + arg }
2611 #define TEST_FUNC_AND_COMMA(child, arg) TEST_FUNC(child, arg),
2612 #define TEST_PARENT DT_PARENT(DT_NODELABEL(test_child_a))
2613
2614 struct vnd_child_binding {
2615 int val;
2616 };
2617
2618 struct vnd_child_binding vals[] = {
2619 DT_FOREACH_CHILD_VARGS(TEST_PARENT, TEST_FUNC_AND_COMMA, 1)
2620 };
2621
2622 struct vnd_child_binding vals_sep[] = {
2623 DT_FOREACH_CHILD_SEP_VARGS(TEST_PARENT, TEST_FUNC, (,), 1)
2624 };
2625
2626 struct vnd_child_binding vals_inst[] = {
2627 DT_INST_FOREACH_CHILD_VARGS(0, TEST_FUNC_AND_COMMA, 1)
2628 };
2629
2630 struct vnd_child_binding vals_inst_sep[] = {
2631 DT_INST_FOREACH_CHILD_SEP_VARGS(0, TEST_FUNC, (,), 1)
2632 };
2633
2634 struct vnd_child_binding vals_status_okay[] = {
2635 DT_FOREACH_CHILD_STATUS_OKAY_VARGS(TEST_PARENT, TEST_FUNC_AND_COMMA, 1)
2636 };
2637
2638 struct vnd_child_binding vals_status_okay_inst[] = {
2639 DT_INST_FOREACH_CHILD_STATUS_OKAY_VARGS(0, TEST_FUNC_AND_COMMA, 1)
2640 };
2641
2642 struct vnd_child_binding vals_status_okay_sep[] = {
2643 DT_FOREACH_CHILD_STATUS_OKAY_SEP_VARGS(TEST_PARENT, TEST_FUNC, (,), 1)
2644 };
2645
2646 struct vnd_child_binding vals_status_okay_inst_sep[] = {
2647 DT_INST_FOREACH_CHILD_STATUS_OKAY_SEP_VARGS(0, TEST_FUNC, (,), 1)
2648 };
2649
2650 zassert_equal(ARRAY_SIZE(vals), 3, "");
2651 zassert_equal(ARRAY_SIZE(vals_sep), 3, "");
2652 zassert_equal(ARRAY_SIZE(vals_inst), 3, "");
2653 zassert_equal(ARRAY_SIZE(vals_inst_sep), 3, "");
2654 zassert_equal(ARRAY_SIZE(vals_status_okay), 2, "");
2655 zassert_equal(ARRAY_SIZE(vals_status_okay_inst), 2, "");
2656 zassert_equal(ARRAY_SIZE(vals_status_okay_sep), 2, "");
2657 zassert_equal(ARRAY_SIZE(vals_status_okay_inst_sep), 2, "");
2658
2659 zassert_equal(vals[0].val, 1, "");
2660 zassert_equal(vals[1].val, 2, "");
2661 zassert_equal(vals[2].val, 3, "");
2662 zassert_equal(vals_sep[0].val, 1, "");
2663 zassert_equal(vals_sep[1].val, 2, "");
2664 zassert_equal(vals_sep[2].val, 3, "");
2665 zassert_equal(vals_inst[0].val, 1, "");
2666 zassert_equal(vals_inst[1].val, 2, "");
2667 zassert_equal(vals_inst[2].val, 3, "");
2668 zassert_equal(vals_inst_sep[0].val, 1, "");
2669 zassert_equal(vals_inst_sep[1].val, 2, "");
2670 zassert_equal(vals_inst_sep[2].val, 3, "");
2671 zassert_equal(vals_status_okay[0].val, 1, "");
2672 zassert_equal(vals_status_okay[1].val, 2, "");
2673 zassert_equal(vals_status_okay_inst[0].val, 1, "");
2674 zassert_equal(vals_status_okay_inst[1].val, 2, "");
2675 zassert_equal(vals_status_okay_sep[0].val, 1, "");
2676 zassert_equal(vals_status_okay_sep[1].val, 2, "");
2677 zassert_equal(vals_status_okay_inst_sep[0].val, 1, "");
2678 zassert_equal(vals_status_okay_inst_sep[1].val, 2, "");
2679
2680 #undef TEST_PARENT
2681 #undef TEST_FUNC_AND_COMMA
2682 #undef TEST_FUNC
2683 }
2684
2685 #undef DT_DRV_COMPAT
2686 #define DT_DRV_COMPAT vnd_child_bindings
ZTEST(devicetree_api,test_child_nodes_number)2687 ZTEST(devicetree_api, test_child_nodes_number)
2688 {
2689 zassert_equal(DT_CHILD_NUM(TEST_CHILDREN), 3, "");
2690 zassert_equal(DT_INST_CHILD_NUM(0), 3, "");
2691 zassert_equal(DT_CHILD_NUM_STATUS_OKAY(TEST_CHILDREN), 2, "");
2692 zassert_equal(DT_INST_CHILD_NUM_STATUS_OKAY(0), 2, "");
2693 }
2694
ZTEST(devicetree_api,test_great_grandchild)2695 ZTEST(devicetree_api, test_great_grandchild)
2696 {
2697 zassert_equal(DT_PROP(DT_NODELABEL(test_ggc), ggc_prop), 42, "");
2698 }
2699
2700 #undef DT_DRV_COMPAT
2701 #define DT_DRV_COMPAT vnd_test_ranges_pcie
ZTEST(devicetree_api,test_ranges_pcie)2702 ZTEST(devicetree_api, test_ranges_pcie)
2703 {
2704 #define FLAGS(node_id, idx) \
2705 DT_RANGES_CHILD_BUS_FLAGS_BY_IDX(node_id, idx),
2706 #define CHILD_BUS_ADDR(node_id, idx) \
2707 DT_RANGES_CHILD_BUS_ADDRESS_BY_IDX(node_id, idx),
2708 #define PARENT_BUS_ADDR(node_id, idx) \
2709 DT_RANGES_PARENT_BUS_ADDRESS_BY_IDX(node_id, idx),
2710 #define LENGTH(node_id, idx) DT_RANGES_LENGTH_BY_IDX(node_id, idx),
2711
2712 unsigned int count = DT_NUM_RANGES(TEST_RANGES_PCIE);
2713
2714 const uint64_t ranges_pcie_flags[] = {
2715 DT_FOREACH_RANGE(TEST_RANGES_PCIE, FLAGS)
2716 };
2717
2718 const uint64_t ranges_child_bus_addr[] = {
2719 DT_FOREACH_RANGE(TEST_RANGES_PCIE, CHILD_BUS_ADDR)
2720 };
2721
2722 const uint64_t ranges_parent_bus_addr[] = {
2723 DT_FOREACH_RANGE(TEST_RANGES_PCIE, PARENT_BUS_ADDR)
2724 };
2725
2726 const uint64_t ranges_length[] = {
2727 DT_FOREACH_RANGE(TEST_RANGES_PCIE, LENGTH)
2728 };
2729
2730 zassert_equal(count, 3, "");
2731
2732 zassert_equal(DT_RANGES_HAS_IDX(TEST_RANGES_PCIE, 0), 1, "");
2733 zassert_equal(DT_RANGES_HAS_IDX(TEST_RANGES_PCIE, 1), 1, "");
2734 zassert_equal(DT_RANGES_HAS_IDX(TEST_RANGES_PCIE, 2), 1, "");
2735 zassert_equal(DT_RANGES_HAS_IDX(TEST_RANGES_PCIE, 3), 0, "");
2736
2737 zassert_equal(DT_RANGES_HAS_CHILD_BUS_FLAGS_AT_IDX(TEST_RANGES_PCIE, 0),
2738 1, "");
2739 zassert_equal(DT_RANGES_HAS_CHILD_BUS_FLAGS_AT_IDX(TEST_RANGES_PCIE, 1),
2740 1, "");
2741 zassert_equal(DT_RANGES_HAS_CHILD_BUS_FLAGS_AT_IDX(TEST_RANGES_PCIE, 2),
2742 1, "");
2743 zassert_equal(DT_RANGES_HAS_CHILD_BUS_FLAGS_AT_IDX(TEST_RANGES_PCIE, 3),
2744 0, "");
2745
2746 zassert_equal(ranges_pcie_flags[0], 0x1000000, "");
2747 zassert_equal(ranges_pcie_flags[1], 0x2000000, "");
2748 zassert_equal(ranges_pcie_flags[2], 0x3000000, "");
2749 zassert_equal(ranges_child_bus_addr[0], 0, "");
2750 zassert_equal(ranges_child_bus_addr[1], 0x10000000, "");
2751 zassert_equal(ranges_child_bus_addr[2], 0x8000000000, "");
2752 zassert_equal(ranges_parent_bus_addr[0], 0x3eff0000, "");
2753 zassert_equal(ranges_parent_bus_addr[1], 0x10000000, "");
2754 zassert_equal(ranges_parent_bus_addr[2], 0x8000000000, "");
2755 zassert_equal(ranges_length[0], 0x10000, "");
2756 zassert_equal(ranges_length[1], 0x2eff0000, "");
2757 zassert_equal(ranges_length[2], 0x8000000000, "");
2758
2759 #undef FLAGS
2760 #undef CHILD_BUS_ADDR
2761 #undef PARENT_BUS_ADDR
2762 #undef LENGTH
2763 }
2764
ZTEST(devicetree_api,test_ranges_other)2765 ZTEST(devicetree_api, test_ranges_other)
2766 {
2767 #define HAS_FLAGS(node_id, idx) \
2768 DT_RANGES_HAS_CHILD_BUS_FLAGS_AT_IDX(node_id, idx)
2769 #define FLAGS(node_id, idx) \
2770 DT_RANGES_CHILD_BUS_FLAGS_BY_IDX(node_id, idx),
2771 #define CHILD_BUS_ADDR(node_id, idx) \
2772 DT_RANGES_CHILD_BUS_ADDRESS_BY_IDX(node_id, idx),
2773 #define PARENT_BUS_ADDR(node_id, idx) \
2774 DT_RANGES_PARENT_BUS_ADDRESS_BY_IDX(node_id, idx),
2775 #define LENGTH(node_id, idx) DT_RANGES_LENGTH_BY_IDX(node_id, idx),
2776
2777 unsigned int count = DT_NUM_RANGES(TEST_RANGES_OTHER);
2778
2779 const uint32_t ranges_child_bus_addr[] = {
2780 DT_FOREACH_RANGE(TEST_RANGES_OTHER, CHILD_BUS_ADDR)
2781 };
2782
2783 const uint32_t ranges_parent_bus_addr[] = {
2784 DT_FOREACH_RANGE(TEST_RANGES_OTHER, PARENT_BUS_ADDR)
2785 };
2786
2787 const uint32_t ranges_length[] = {
2788 DT_FOREACH_RANGE(TEST_RANGES_OTHER, LENGTH)
2789 };
2790
2791 zassert_equal(count, 2, "");
2792
2793 zassert_equal(DT_RANGES_HAS_IDX(TEST_RANGES_OTHER, 0), 1, "");
2794 zassert_equal(DT_RANGES_HAS_IDX(TEST_RANGES_OTHER, 1), 1, "");
2795 zassert_equal(DT_RANGES_HAS_IDX(TEST_RANGES_OTHER, 2), 0, "");
2796 zassert_equal(DT_RANGES_HAS_IDX(TEST_RANGES_OTHER, 3), 0, "");
2797
2798 zassert_equal(HAS_FLAGS(TEST_RANGES_OTHER, 0), 0, "");
2799 zassert_equal(HAS_FLAGS(TEST_RANGES_OTHER, 1), 0, "");
2800 zassert_equal(HAS_FLAGS(TEST_RANGES_OTHER, 2), 0, "");
2801 zassert_equal(HAS_FLAGS(TEST_RANGES_OTHER, 3), 0, "");
2802
2803 zassert_equal(ranges_child_bus_addr[0], 0, "");
2804 zassert_equal(ranges_child_bus_addr[1], 0x10000000, "");
2805 zassert_equal(ranges_parent_bus_addr[0], 0x3eff0000, "");
2806 zassert_equal(ranges_parent_bus_addr[1], 0x10000000, "");
2807 zassert_equal(ranges_length[0], 0x10000, "");
2808 zassert_equal(ranges_length[1], 0x2eff0000, "");
2809
2810 #undef HAS_FLAGS
2811 #undef FLAGS
2812 #undef CHILD_BUS_ADDR
2813 #undef PARENT_BUS_ADDR
2814 #undef LENGTH
2815 }
2816
ZTEST(devicetree_api,test_ranges_empty)2817 ZTEST(devicetree_api, test_ranges_empty)
2818 {
2819 zassert_equal(DT_NODE_HAS_PROP(TEST_RANGES_EMPTY, ranges), 1, "");
2820
2821 zassert_equal(DT_NUM_RANGES(TEST_RANGES_EMPTY), 0, "");
2822
2823 zassert_equal(DT_RANGES_HAS_IDX(TEST_RANGES_EMPTY, 0), 0, "");
2824 zassert_equal(DT_RANGES_HAS_IDX(TEST_RANGES_EMPTY, 1), 0, "");
2825
2826 #define FAIL(node_id, idx) ztest_test_fail();
2827
2828 DT_FOREACH_RANGE(TEST_RANGES_EMPTY, FAIL);
2829
2830 #undef FAIL
2831 }
2832
ZTEST(devicetree_api,test_compat_get_any_status_okay)2833 ZTEST(devicetree_api, test_compat_get_any_status_okay)
2834 {
2835 zassert_true(
2836 DT_SAME_NODE(
2837 DT_COMPAT_GET_ANY_STATUS_OKAY(vnd_reg_holder),
2838 TEST_REG),
2839 "");
2840
2841 /*
2842 * DT_SAME_NODE requires that both its arguments are valid
2843 * node identifiers, so we can't pass it DT_INVALID_NODE,
2844 * which is what this DT_COMPAT_GET_ANY_STATUS_OKAY() expands to.
2845 */
2846 zassert_false(
2847 DT_NODE_EXISTS(
2848 DT_COMPAT_GET_ANY_STATUS_OKAY(this_is_not_a_real_compat)),
2849 "");
2850 }
2851
ord_in_array(unsigned int ord,unsigned int * array,size_t array_size)2852 static bool ord_in_array(unsigned int ord, unsigned int *array,
2853 size_t array_size)
2854 {
2855 size_t i;
2856
2857 for (i = 0; i < array_size; i++) {
2858 if (array[i] == ord) {
2859 return true;
2860 }
2861 }
2862
2863 return false;
2864 }
2865
2866 /* Magic numbers used by COMBINED_ORD_ARRAY. Must be invalid dependency
2867 * ordinals.
2868 */
2869 #define ORD_LIST_SEP 0xFFFF0000
2870 #define ORD_LIST_END 0xFFFF0001
2871 #define INJECTED_DEP_0 0xFFFF0002
2872 #define INJECTED_DEP_1 0xFFFF0003
2873
2874 #define DEP_ORD_AND_COMMA(node_id) DT_DEP_ORD(node_id),
2875 #define CHILD_ORDINALS(node_id) DT_FOREACH_CHILD(node_id, DEP_ORD_AND_COMMA)
2876
2877 #define COMBINED_ORD_ARRAY(node_id) \
2878 { \
2879 DT_DEP_ORD(node_id), \
2880 DT_DEP_ORD(DT_PARENT(node_id)), \
2881 CHILD_ORDINALS(node_id) \
2882 ORD_LIST_SEP, \
2883 DT_REQUIRES_DEP_ORDS(node_id) \
2884 INJECTED_DEP_0, \
2885 INJECTED_DEP_1, \
2886 ORD_LIST_SEP, \
2887 DT_SUPPORTS_DEP_ORDS(node_id) \
2888 ORD_LIST_END \
2889 }
2890
ZTEST(devicetree_api,test_dep_ord)2891 ZTEST(devicetree_api, test_dep_ord)
2892 {
2893 #define ORD_IN_ARRAY(ord, array) ord_in_array(ord, array, ARRAY_SIZE(array))
2894
2895 unsigned int root_ord = DT_DEP_ORD(DT_ROOT),
2896 test_ord = DT_DEP_ORD(DT_PATH(test)),
2897 root_requires[] = { DT_REQUIRES_DEP_ORDS(DT_ROOT) },
2898 test_requires[] = { DT_REQUIRES_DEP_ORDS(DT_PATH(test)) },
2899 root_supports[] = { DT_SUPPORTS_DEP_ORDS(DT_ROOT) },
2900 test_supports[] = { DT_SUPPORTS_DEP_ORDS(DT_PATH(test)) },
2901 children_ords[] = {
2902 DT_FOREACH_CHILD(TEST_CHILDREN, DEP_ORD_AND_COMMA)
2903 },
2904 children_combined_ords[] = COMBINED_ORD_ARRAY(TEST_CHILDREN),
2905 child_a_combined_ords[] =
2906 COMBINED_ORD_ARRAY(DT_NODELABEL(test_child_a));
2907 size_t i;
2908
2909 /* DT_DEP_ORD */
2910 zassert_equal(root_ord, 0, "");
2911 zassert_true(DT_DEP_ORD(DT_NODELABEL(test_child_a)) >
2912 DT_DEP_ORD(DT_NODELABEL(test_children)), "");
2913 zassert_true(DT_DEP_ORD(DT_NODELABEL(test_irq)) >
2914 DT_DEP_ORD(DT_NODELABEL(test_intc)), "");
2915 zassert_true(DT_DEP_ORD(DT_NODELABEL(test_phandles)) >
2916 DT_DEP_ORD(DT_NODELABEL(test_gpio_1)), "");
2917
2918 /* DT_REQUIRES_DEP_ORDS */
2919 zassert_equal(ARRAY_SIZE(root_requires), 0, "");
2920 zassert_true(ORD_IN_ARRAY(root_ord, test_requires), "");
2921
2922 /* DT_SUPPORTS_DEP_ORDS */
2923 zassert_true(ORD_IN_ARRAY(test_ord, root_supports), "");
2924 zassert_false(ORD_IN_ARRAY(root_ord, test_supports), "");
2925
2926 unsigned int children_combined_ords_expected[] = {
2927 /*
2928 * Combined ordinals for /test/test-children are from
2929 * these nodes in this order:
2930 */
2931 DT_DEP_ORD(TEST_CHILDREN), /* node */
2932 DT_DEP_ORD(DT_PATH(test)), /* parent */
2933 DT_DEP_ORD(DT_NODELABEL(test_child_a)), /* children */
2934 DT_DEP_ORD(DT_NODELABEL(test_child_b)),
2935 DT_DEP_ORD(DT_NODELABEL(test_child_c)),
2936 ORD_LIST_SEP, /* separator */
2937 DT_DEP_ORD(DT_PATH(test)), /* requires */
2938 INJECTED_DEP_0, /* injected
2939 * dependencies
2940 */
2941 INJECTED_DEP_1,
2942 ORD_LIST_SEP, /* separator */
2943 DT_DEP_ORD(DT_NODELABEL(test_child_a)), /* supports */
2944 DT_DEP_ORD(DT_NODELABEL(test_child_b)),
2945 DT_DEP_ORD(DT_NODELABEL(test_child_c)),
2946 ORD_LIST_END, /* terminator */
2947 };
2948 zassert_equal(ARRAY_SIZE(children_combined_ords),
2949 ARRAY_SIZE(children_combined_ords_expected),
2950 "%zu", ARRAY_SIZE(children_combined_ords));
2951 for (i = 0; i < ARRAY_SIZE(children_combined_ords); i++) {
2952 zassert_equal(children_combined_ords[i],
2953 children_combined_ords_expected[i],
2954 "test-children at %zu", i);
2955 }
2956
2957 unsigned int child_a_combined_ords_expected[] = {
2958 /*
2959 * Combined ordinals for /test/test-children/child-a
2960 * are from these nodes in this order:
2961 */
2962 DT_DEP_ORD(DT_NODELABEL(test_child_a)), /* node */
2963 DT_DEP_ORD(TEST_CHILDREN), /* parent */
2964 /* children (none) */
2965 ORD_LIST_SEP, /* separator */
2966 DT_DEP_ORD(TEST_CHILDREN), /* requires */
2967 INJECTED_DEP_0, /* injected
2968 * dependencies
2969 */
2970 INJECTED_DEP_1,
2971 ORD_LIST_SEP, /* separator */
2972 /* supports (none) */
2973 ORD_LIST_END, /* terminator */
2974 };
2975 zassert_equal(ARRAY_SIZE(child_a_combined_ords),
2976 ARRAY_SIZE(child_a_combined_ords_expected),
2977 "%zu", ARRAY_SIZE(child_a_combined_ords));
2978 for (i = 0; i < ARRAY_SIZE(child_a_combined_ords); i++) {
2979 zassert_equal(child_a_combined_ords[i],
2980 child_a_combined_ords_expected[i],
2981 "child-a at %zu", i);
2982 }
2983
2984 #undef DT_DRV_COMPAT
2985 #define DT_DRV_COMPAT vnd_child_bindings
2986
2987 /* DT_INST_DEP_ORD */
2988 zassert_equal(DT_INST_DEP_ORD(0),
2989 DT_DEP_ORD(DT_NODELABEL(test_children)), "");
2990
2991 /* DT_INST_REQUIRES_DEP_ORDS */
2992 unsigned int inst_requires[] = { DT_INST_REQUIRES_DEP_ORDS(0) };
2993
2994 zassert_equal(ARRAY_SIZE(inst_requires), 1, "");
2995 zassert_equal(inst_requires[0], test_ord, "");
2996
2997 /* DT_INST_SUPPORTS_DEP_ORDS */
2998 unsigned int inst_supports[] = { DT_INST_SUPPORTS_DEP_ORDS(0) };
2999
3000 zassert_equal(ARRAY_SIZE(inst_supports), 3, "");
3001 for (i = 0; i < ARRAY_SIZE(inst_supports); i++) {
3002 zassert_true(ORD_IN_ARRAY(inst_supports[i], children_ords), "");
3003 }
3004 }
3005
ZTEST(devicetree_api,test_dep_ord_str_sortable)3006 ZTEST(devicetree_api, test_dep_ord_str_sortable)
3007 {
3008 const char *root_ord = STRINGIFY(DT_DEP_ORD_STR_SORTABLE(DT_ROOT));
3009
3010 /* Root ordinal is always 0 */
3011 zassert_mem_equal(root_ord, "00000", 6);
3012
3013 /* Test string sortable versions equal decimal values.
3014 * We go through the STRINGIFY()->atoi conversion cycle to avoid
3015 * the C compiler treating the number as octal due to leading zeros.
3016 * atoi() simply ignores them.
3017 */
3018 zassert_equal(atoi(STRINGIFY(DT_DEP_ORD_STR_SORTABLE(DT_ROOT))),
3019 DT_DEP_ORD(DT_ROOT), "Invalid sortable string");
3020 zassert_equal(atoi(STRINGIFY(DT_DEP_ORD_STR_SORTABLE(TEST_DEADBEEF))),
3021 DT_DEP_ORD(TEST_DEADBEEF), "Invalid sortable string");
3022 zassert_equal(atoi(STRINGIFY(DT_DEP_ORD_STR_SORTABLE(TEST_TEMP))),
3023 DT_DEP_ORD(TEST_TEMP), "Invalid sortable string");
3024 zassert_equal(atoi(STRINGIFY(DT_DEP_ORD_STR_SORTABLE(TEST_REG))),
3025 DT_DEP_ORD(TEST_REG), "Invalid sortable string");
3026 }
3027
ZTEST(devicetree_api,test_path)3028 ZTEST(devicetree_api, test_path)
3029 {
3030 zassert_true(!strcmp(DT_NODE_PATH(DT_ROOT), "/"), "");
3031 zassert_true(!strcmp(DT_NODE_PATH(TEST_DEADBEEF),
3032 "/test/gpio@deadbeef"), "");
3033 }
3034
ZTEST(devicetree_api,test_node_name)3035 ZTEST(devicetree_api, test_node_name)
3036 {
3037 zassert_true(!strcmp(DT_NODE_FULL_NAME(DT_ROOT), "/"), "");
3038 zassert_true(!strcmp(DT_NODE_FULL_NAME(TEST_DEADBEEF),
3039 "gpio@deadbeef"), "");
3040 zassert_true(!strcmp(DT_NODE_FULL_NAME(TEST_TEMP),
3041 "temperature-sensor"), "");
3042 zassert_true(strcmp(DT_NODE_FULL_NAME(TEST_REG),
3043 "reg-holder"), "");
3044 }
3045
ZTEST(devicetree_api,test_node_child_idx)3046 ZTEST(devicetree_api, test_node_child_idx)
3047 {
3048 zassert_equal(DT_NODE_CHILD_IDX(DT_NODELABEL(test_child_a)), 0, "");
3049 zassert_equal(DT_NODE_CHILD_IDX(DT_NODELABEL(test_child_b)), 1, "");
3050 zassert_equal(DT_NODE_CHILD_IDX(DT_NODELABEL(test_child_c)), 2, "");
3051 }
3052
ZTEST(devicetree_api,test_same_node)3053 ZTEST(devicetree_api, test_same_node)
3054 {
3055 zassert_true(DT_SAME_NODE(TEST_DEADBEEF, TEST_DEADBEEF), "");
3056 zassert_false(DT_SAME_NODE(TEST_DEADBEEF, TEST_ABCD1234), "");
3057 }
3058
ZTEST(devicetree_api,test_pinctrl)3059 ZTEST(devicetree_api, test_pinctrl)
3060 {
3061 #undef DT_DRV_COMPAT
3062 #define DT_DRV_COMPAT vnd_adc_temp_sensor
3063 /*
3064 * Tests when a node does have pinctrl properties.
3065 */
3066
3067 /*
3068 * node_id versions:
3069 */
3070
3071 zassert_true(DT_SAME_NODE(DT_PINCTRL_BY_IDX(TEST_TEMP, 0, 1),
3072 DT_NODELABEL(test_pincfg_b)), "");
3073 zassert_true(DT_SAME_NODE(DT_PINCTRL_BY_IDX(TEST_TEMP, 1, 0),
3074 DT_NODELABEL(test_pincfg_c)), "");
3075
3076 zassert_true(DT_SAME_NODE(DT_PINCTRL_0(TEST_TEMP, 0),
3077 DT_NODELABEL(test_pincfg_a)), "");
3078
3079 zassert_true(DT_SAME_NODE(DT_PINCTRL_BY_NAME(TEST_TEMP, default, 1),
3080 DT_NODELABEL(test_pincfg_b)), "");
3081 zassert_true(DT_SAME_NODE(DT_PINCTRL_BY_NAME(TEST_TEMP, sleep, 0),
3082 DT_NODELABEL(test_pincfg_c)), "");
3083 zassert_true(DT_SAME_NODE(DT_PINCTRL_BY_NAME(TEST_TEMP, f_o_o2, 0),
3084 DT_NODELABEL(test_pincfg_d)), "");
3085
3086 zassert_equal(DT_PINCTRL_NAME_TO_IDX(TEST_TEMP, default), 0, "");
3087 zassert_equal(DT_PINCTRL_NAME_TO_IDX(TEST_TEMP, sleep), 1, "");
3088 zassert_equal(DT_PINCTRL_NAME_TO_IDX(TEST_TEMP, f_o_o2), 2, "");
3089
3090 zassert_equal(DT_NUM_PINCTRLS_BY_IDX(TEST_TEMP, 0), 2, "");
3091
3092 zassert_equal(DT_NUM_PINCTRLS_BY_NAME(TEST_TEMP, default), 2, "");
3093 zassert_equal(DT_NUM_PINCTRLS_BY_NAME(TEST_TEMP, f_o_o2), 1, "");
3094
3095 zassert_equal(DT_NUM_PINCTRL_STATES(TEST_TEMP), 3, "");
3096
3097 zassert_equal(DT_PINCTRL_HAS_IDX(TEST_TEMP, 0), 1, "");
3098 zassert_equal(DT_PINCTRL_HAS_IDX(TEST_TEMP, 1), 1, "");
3099 zassert_equal(DT_PINCTRL_HAS_IDX(TEST_TEMP, 2), 1, "");
3100 zassert_equal(DT_PINCTRL_HAS_IDX(TEST_TEMP, 3), 0, "");
3101
3102 zassert_equal(DT_PINCTRL_HAS_NAME(TEST_TEMP, default), 1, "");
3103 zassert_equal(DT_PINCTRL_HAS_NAME(TEST_TEMP, sleep), 1, "");
3104 zassert_equal(DT_PINCTRL_HAS_NAME(TEST_TEMP, f_o_o2), 1, "");
3105 zassert_equal(DT_PINCTRL_HAS_NAME(TEST_TEMP, bar), 0, "");
3106
3107 #undef MAKE_TOKEN
3108 #define MAKE_TOKEN(pc_idx) \
3109 _CONCAT(NODE_ID_ENUM_, \
3110 DT_PINCTRL_IDX_TO_NAME_TOKEN(TEST_TEMP, pc_idx))
3111 #undef MAKE_UPPER_TOKEN
3112 #define MAKE_UPPER_TOKEN(pc_idx) \
3113 _CONCAT(NODE_ID_ENUM_, \
3114 DT_PINCTRL_IDX_TO_NAME_UPPER_TOKEN(TEST_TEMP, pc_idx))
3115 enum {
3116 MAKE_TOKEN(0) = 10,
3117 MAKE_TOKEN(1) = 11,
3118 MAKE_TOKEN(2) = 12,
3119 MAKE_TOKEN(3) = 13,
3120
3121 MAKE_UPPER_TOKEN(0) = 20,
3122 MAKE_UPPER_TOKEN(1) = 21,
3123 MAKE_UPPER_TOKEN(2) = 22,
3124 MAKE_UPPER_TOKEN(3) = 23,
3125 };
3126
3127 zassert_equal(NODE_ID_ENUM_default, 10, "");
3128 zassert_equal(NODE_ID_ENUM_sleep, 11, "");
3129 zassert_equal(NODE_ID_ENUM_f_o_o2, 12, "");
3130
3131 zassert_equal(NODE_ID_ENUM_DEFAULT, 20, "");
3132 zassert_equal(NODE_ID_ENUM_SLEEP, 21, "");
3133 zassert_equal(NODE_ID_ENUM_F_O_O2, 22, "");
3134
3135 /*
3136 * inst versions:
3137 */
3138
3139 zassert_true(DT_SAME_NODE(DT_INST_PINCTRL_BY_IDX(0, 0, 1),
3140 DT_NODELABEL(test_pincfg_b)), "");
3141 zassert_true(DT_SAME_NODE(DT_INST_PINCTRL_BY_IDX(0, 1, 0),
3142 DT_NODELABEL(test_pincfg_c)), "");
3143
3144 zassert_true(DT_SAME_NODE(DT_INST_PINCTRL_0(0, 0),
3145 DT_NODELABEL(test_pincfg_a)), "");
3146
3147 zassert_true(DT_SAME_NODE(DT_INST_PINCTRL_BY_NAME(0, default, 1),
3148 DT_NODELABEL(test_pincfg_b)), "");
3149 zassert_true(DT_SAME_NODE(DT_INST_PINCTRL_BY_NAME(0, sleep, 0),
3150 DT_NODELABEL(test_pincfg_c)), "");
3151 zassert_true(DT_SAME_NODE(DT_INST_PINCTRL_BY_NAME(0, f_o_o2, 0),
3152 DT_NODELABEL(test_pincfg_d)), "");
3153
3154 zassert_equal(DT_INST_PINCTRL_NAME_TO_IDX(0, default), 0, "");
3155 zassert_equal(DT_INST_PINCTRL_NAME_TO_IDX(0, sleep), 1, "");
3156 zassert_equal(DT_INST_PINCTRL_NAME_TO_IDX(0, f_o_o2), 2, "");
3157
3158 zassert_equal(DT_INST_NUM_PINCTRLS_BY_IDX(0, 0), 2, "");
3159
3160 zassert_equal(DT_INST_NUM_PINCTRLS_BY_NAME(0, default), 2, "");
3161 zassert_equal(DT_INST_NUM_PINCTRLS_BY_NAME(0, f_o_o2), 1, "");
3162
3163 zassert_equal(DT_INST_NUM_PINCTRL_STATES(0), 3, "");
3164
3165 zassert_equal(DT_INST_PINCTRL_HAS_IDX(0, 0), 1, "");
3166 zassert_equal(DT_INST_PINCTRL_HAS_IDX(0, 1), 1, "");
3167 zassert_equal(DT_INST_PINCTRL_HAS_IDX(0, 2), 1, "");
3168 zassert_equal(DT_INST_PINCTRL_HAS_IDX(0, 3), 0, "");
3169
3170 zassert_equal(DT_INST_PINCTRL_HAS_NAME(0, default), 1, "");
3171 zassert_equal(DT_INST_PINCTRL_HAS_NAME(0, sleep), 1, "");
3172 zassert_equal(DT_INST_PINCTRL_HAS_NAME(0, f_o_o2), 1, "");
3173 zassert_equal(DT_INST_PINCTRL_HAS_NAME(0, bar), 0, "");
3174
3175 #undef MAKE_TOKEN
3176 #define MAKE_TOKEN(pc_idx) \
3177 _CONCAT(INST_ENUM_, \
3178 DT_INST_PINCTRL_IDX_TO_NAME_TOKEN(0, pc_idx))
3179 #undef MAKE_UPPER_TOKEN
3180 #define MAKE_UPPER_TOKEN(pc_idx) \
3181 _CONCAT(INST_ENUM_, \
3182 DT_INST_PINCTRL_IDX_TO_NAME_UPPER_TOKEN(0, pc_idx))
3183 enum {
3184 MAKE_TOKEN(0) = 10,
3185 MAKE_TOKEN(1) = 11,
3186 MAKE_TOKEN(2) = 12,
3187
3188 MAKE_UPPER_TOKEN(0) = 20,
3189 MAKE_UPPER_TOKEN(1) = 21,
3190 MAKE_UPPER_TOKEN(2) = 22,
3191 };
3192
3193 zassert_equal(INST_ENUM_default, 10, "");
3194 zassert_equal(INST_ENUM_sleep, 11, "");
3195 zassert_equal(INST_ENUM_f_o_o2, 12, "");
3196
3197 zassert_equal(INST_ENUM_DEFAULT, 20, "");
3198 zassert_equal(INST_ENUM_SLEEP, 21, "");
3199 zassert_equal(INST_ENUM_F_O_O2, 22, "");
3200
3201 #undef DT_DRV_COMPAT
3202 #define DT_DRV_COMPAT vnd_reg_holder
3203 /*
3204 * Tests when a node does NOT have any pinctrl properties.
3205 */
3206
3207 /* node_id versions */
3208 zassert_equal(DT_NUM_PINCTRL_STATES(TEST_REG), 0, "");
3209 zassert_equal(DT_PINCTRL_HAS_IDX(TEST_REG, 0), 0, "");
3210 zassert_equal(DT_PINCTRL_HAS_NAME(TEST_REG, f_o_o2), 0, "");
3211
3212 /* inst versions */
3213 zassert_equal(DT_INST_NUM_PINCTRL_STATES(0), 0, "");
3214 zassert_equal(DT_INST_PINCTRL_HAS_IDX(0, 0), 0, "");
3215 zassert_equal(DT_INST_PINCTRL_HAS_NAME(0, f_o_o2), 0, "");
3216 }
3217
ZTEST(devicetree_api,test_mbox)3218 ZTEST(devicetree_api, test_mbox)
3219 {
3220 zassert_equal(DT_MBOX_CHANNEL_BY_NAME(TEST_TEMP, tx), 1, "");
3221 zassert_equal(DT_MBOX_CHANNEL_BY_NAME(TEST_TEMP, rx), 2, "");
3222
3223 zassert_true(DT_SAME_NODE(DT_MBOX_CTLR_BY_NAME(TEST_TEMP, tx),
3224 DT_NODELABEL(test_mbox)), "");
3225 zassert_true(DT_SAME_NODE(DT_MBOX_CTLR_BY_NAME(TEST_TEMP, rx),
3226 DT_NODELABEL(test_mbox)), "");
3227
3228 zassert_equal(DT_MBOX_CHANNEL_BY_NAME(TEST_TEMP, tx), 1, "");
3229 zassert_equal(DT_MBOX_CHANNEL_BY_NAME(TEST_TEMP, rx), 2, "");
3230
3231 zassert_equal(DT_MBOX_CHANNEL_BY_NAME(TEST_TEMP, zero), 0, "");
3232
3233 zassert_true(DT_SAME_NODE(DT_MBOX_CTLR_BY_NAME(TEST_TEMP, zero),
3234 DT_NODELABEL(test_mbox_zero_cell)), "");
3235 }
3236
ZTEST(devicetree_api,test_fixed_partitions)3237 ZTEST(devicetree_api, test_fixed_partitions)
3238 {
3239 /* Test finding fixed partitions by the 'label' property. */
3240 zassert_true(DT_HAS_FIXED_PARTITION_LABEL(test_partition_0));
3241 zassert_true(DT_HAS_FIXED_PARTITION_LABEL(test_partition_1));
3242 zassert_true(DT_HAS_FIXED_PARTITION_LABEL(test_partition_2));
3243
3244 zassert_true(DT_SAME_NODE(TEST_PARTITION_0,
3245 DT_NODE_BY_FIXED_PARTITION_LABEL(test_partition_0)));
3246 zassert_true(DT_SAME_NODE(TEST_PARTITION_1,
3247 DT_NODE_BY_FIXED_PARTITION_LABEL(test_partition_1)));
3248 zassert_true(DT_SAME_NODE(TEST_PARTITION_2,
3249 DT_NODE_BY_FIXED_PARTITION_LABEL(test_partition_2)));
3250
3251 zassert_true(DT_FIXED_PARTITION_EXISTS(TEST_PARTITION_0));
3252 zassert_true(DT_FIXED_PARTITION_EXISTS(TEST_PARTITION_1));
3253 zassert_true(DT_FIXED_PARTITION_EXISTS(TEST_PARTITION_2));
3254
3255 /* There should not be a node with `label = "test_partition_3"`. */
3256 zassert_false(DT_HAS_FIXED_PARTITION_LABEL(test_partition_3));
3257 zassert_false(DT_NODE_EXISTS(DT_NODE_BY_FIXED_PARTITION_LABEL(test_partition_3)));
3258
3259 /* There is a node with `label = "FOO"`, but it is not a fixed partition. */
3260 zassert_false(DT_HAS_FIXED_PARTITION_LABEL(FOO));
3261 zassert_false(DT_NODE_EXISTS(DT_NODE_BY_FIXED_PARTITION_LABEL(FOO)));
3262
3263 /* Test DT_MTD_FROM_FIXED_PARTITION. */
3264 zassert_true(DT_NODE_EXISTS(DT_MTD_FROM_FIXED_PARTITION(TEST_PARTITION_0)));
3265 zassert_true(DT_NODE_EXISTS(DT_MTD_FROM_FIXED_PARTITION(TEST_PARTITION_1)));
3266 zassert_true(DT_NODE_EXISTS(DT_MTD_FROM_FIXED_PARTITION(TEST_PARTITION_2)));
3267
3268 zassert_true(DT_SAME_NODE(TEST_MTD_0, DT_MTD_FROM_FIXED_PARTITION(TEST_PARTITION_0)));
3269 zassert_true(DT_SAME_NODE(TEST_MTD_0, DT_MTD_FROM_FIXED_PARTITION(TEST_PARTITION_1)));
3270 zassert_true(DT_SAME_NODE(TEST_MTD_1, DT_MTD_FROM_FIXED_PARTITION(TEST_PARTITION_2)));
3271
3272 /* Test DT_MEM_FROM_FIXED_PARTITION. */
3273 zassert_true(DT_NODE_EXISTS(DT_MEM_FROM_FIXED_PARTITION(TEST_PARTITION_0)));
3274 zassert_true(DT_NODE_EXISTS(DT_MEM_FROM_FIXED_PARTITION(TEST_PARTITION_1)));
3275 zassert_false(DT_NODE_EXISTS(DT_MEM_FROM_FIXED_PARTITION(TEST_PARTITION_2)));
3276
3277 zassert_true(DT_SAME_NODE(TEST_MEM_0, DT_MEM_FROM_FIXED_PARTITION(TEST_PARTITION_0)));
3278 zassert_true(DT_SAME_NODE(TEST_MEM_0, DT_MEM_FROM_FIXED_PARTITION(TEST_PARTITION_1)));
3279
3280 /* Test DT_FIXED_PARTITION_ADDR. */
3281 zassert_equal(DT_FIXED_PARTITION_ADDR(TEST_PARTITION_0), 0x20000000);
3282 zassert_equal(DT_FIXED_PARTITION_ADDR(TEST_PARTITION_1), 0x200000c0);
3283 zassert_equal(DT_FIXED_PARTITION_ADDR(TEST_PARTITION_2), 0x33291080);
3284
3285 /* Test that all DT_FIXED_PARTITION_ID are defined and unique. */
3286 #define FIXED_PARTITION_ID_COMMA(node_id) DT_FIXED_PARTITION_ID(node_id),
3287
3288 static const int ids[] = {
3289 DT_FOREACH_STATUS_OKAY_VARGS(fixed_partitions, DT_FOREACH_CHILD,
3290 FIXED_PARTITION_ID_COMMA)
3291 };
3292 bool found[ARRAY_SIZE(ids)] = { false };
3293
3294 for (int i = 0; i < ARRAY_SIZE(ids); i++) {
3295 zassert_between_inclusive(ids[i], 0, ARRAY_SIZE(ids) - 1, "");
3296 zassert_false(found[ids[i]]);
3297 found[ids[i]] = true;
3298 }
3299
3300 #undef FIXED_PARTITION_ID_COMMA
3301 }
3302
ZTEST(devicetree_api,test_fixed_subpartitions)3303 ZTEST(devicetree_api, test_fixed_subpartitions)
3304 {
3305 zassert_true(DT_FIXED_PARTITION_EXISTS(TEST_SUBPARTITION_COMBINED));
3306 zassert_true(DT_FIXED_SUBPARTITION_EXISTS(TEST_SUBPARTITION_0));
3307 zassert_true(DT_FIXED_SUBPARTITION_EXISTS(TEST_SUBPARTITION_1));
3308
3309 /* Test DT_MEM_FROM_FIXED_SUBPARTITION. */
3310 zassert_true(DT_NODE_EXISTS(DT_MEM_FROM_FIXED_PARTITION(TEST_SUBPARTITION_COMBINED)));
3311 zassert_true(DT_NODE_EXISTS(DT_MEM_FROM_FIXED_SUBPARTITION(TEST_SUBPARTITION_0)));
3312 zassert_true(DT_NODE_EXISTS(DT_MEM_FROM_FIXED_SUBPARTITION(TEST_SUBPARTITION_1)));
3313
3314 /* Test DT_MTD_FROM_FIXED_SUBPARTITION. */
3315 zassert_true(DT_NODE_EXISTS(DT_MTD_FROM_FIXED_PARTITION(TEST_SUBPARTITION_COMBINED)));
3316 zassert_true(DT_NODE_EXISTS(DT_MTD_FROM_FIXED_SUBPARTITION(TEST_SUBPARTITION_0)));
3317 zassert_true(DT_NODE_EXISTS(DT_MTD_FROM_FIXED_SUBPARTITION(TEST_SUBPARTITION_1)));
3318 zassert_true(DT_SAME_NODE(
3319 DT_MTD_FROM_FIXED_PARTITION(TEST_SUBPARTITION_COMBINED),
3320 DT_MTD_FROM_FIXED_SUBPARTITION(TEST_SUBPARTITION_1)));
3321
3322 /* Test DT_FIXED_SUBPARTITION_ADDR. */
3323 zassert_equal(DT_FIXED_PARTITION_ADDR(TEST_SUBPARTITION_COMBINED), 0x20000100);
3324 zassert_equal(DT_FIXED_SUBPARTITION_ADDR(TEST_SUBPARTITION_0),
3325 DT_FIXED_PARTITION_ADDR(TEST_SUBPARTITION_COMBINED));
3326 zassert_equal(DT_FIXED_SUBPARTITION_ADDR(TEST_SUBPARTITION_0), 0x20000100);
3327 zassert_equal(DT_FIXED_SUBPARTITION_ADDR(TEST_SUBPARTITION_1), 0x20000140);
3328
3329 /* Check sizes match */
3330 zassert_equal(DT_REG_SIZE(TEST_SUBPARTITION_COMBINED),
3331 (DT_REG_SIZE(TEST_SUBPARTITION_0) + DT_REG_SIZE(TEST_SUBPARTITION_1)));
3332 }
3333
ZTEST(devicetree_api,test_string_token)3334 ZTEST(devicetree_api, test_string_token)
3335 {
3336 #undef DT_DRV_COMPAT
3337 #define DT_DRV_COMPAT vnd_string_token
3338 enum {
3339 token_zero,
3340 token_one,
3341 token_two,
3342 token_no_inst,
3343 };
3344 enum {
3345 TOKEN_ZERO = token_no_inst + 1,
3346 TOKEN_ONE,
3347 TOKEN_TWO,
3348 TOKEN_NO_INST,
3349 };
3350 int i;
3351
3352 /* Test DT_INST_STRING_TOKEN */
3353 #define STRING_TOKEN_TEST_INST_EXPANSION(inst) \
3354 DT_INST_STRING_TOKEN(inst, val),
3355 int array_inst[] = {
3356 DT_INST_FOREACH_STATUS_OKAY(STRING_TOKEN_TEST_INST_EXPANSION)
3357 };
3358
3359 for (i = 0; i < ARRAY_SIZE(array_inst); i++) {
3360 zassert_between_inclusive(array_inst[i], token_zero, token_two, "");
3361 }
3362
3363 /* Test DT_INST_STRING_UPPER_TOKEN */
3364 #define STRING_UPPER_TOKEN_TEST_INST_EXPANSION(inst) \
3365 DT_INST_STRING_UPPER_TOKEN(inst, val),
3366 int array_inst_upper[] = {
3367 DT_INST_FOREACH_STATUS_OKAY(STRING_UPPER_TOKEN_TEST_INST_EXPANSION)
3368 };
3369
3370 for (i = 0; i < ARRAY_SIZE(array_inst_upper); i++) {
3371 zassert_between_inclusive(array_inst_upper[i], TOKEN_ZERO, TOKEN_TWO, "");
3372 }
3373
3374 /* Test DT_INST_STRING_TOKEN_OR when property is found */
3375 #define STRING_TOKEN_OR_TEST_INST_EXPANSION(inst) \
3376 DT_INST_STRING_TOKEN_OR(inst, val, token_no_inst),
3377 int array_inst_or[] = {
3378 DT_INST_FOREACH_STATUS_OKAY(STRING_TOKEN_OR_TEST_INST_EXPANSION)
3379 };
3380
3381 for (i = 0; i < ARRAY_SIZE(array_inst_or); i++) {
3382 zassert_between_inclusive(array_inst_or[i], token_zero, token_two, "");
3383 }
3384
3385 /* Test DT_INST_STRING_UPPER_TOKEN_OR when property is found */
3386 #define STRING_UPPER_TOKEN_OR_TEST_INST_EXPANSION(inst) \
3387 DT_INST_STRING_UPPER_TOKEN_OR(inst, val, TOKEN_NO_INST),
3388 int array_inst_upper_or[] = {
3389 DT_INST_FOREACH_STATUS_OKAY(STRING_UPPER_TOKEN_OR_TEST_INST_EXPANSION)
3390 };
3391
3392 for (i = 0; i < ARRAY_SIZE(array_inst_upper_or); i++) {
3393 zassert_between_inclusive(array_inst_upper_or[i], TOKEN_ZERO, TOKEN_TWO, "");
3394 }
3395
3396 /* Test DT_STRING_TOKEN_OR when property is found */
3397 zassert_equal(DT_STRING_TOKEN_OR(DT_NODELABEL(test_string_token_0),
3398 val, token_one), token_zero, "");
3399 zassert_equal(DT_STRING_TOKEN_OR(DT_NODELABEL(test_string_token_1),
3400 val, token_two), token_one, "");
3401
3402 /* Test DT_STRING_TOKEN_OR is not found */
3403 zassert_equal(DT_STRING_TOKEN_OR(DT_NODELABEL(test_string_token_1),
3404 no_inst, token_zero), token_zero, "");
3405
3406 /* Test DT_STRING_UPPER_TOKEN_OR when property is found */
3407 zassert_equal(DT_STRING_UPPER_TOKEN_OR(DT_NODELABEL(test_string_token_0),
3408 val, TOKEN_ONE), TOKEN_ZERO, "");
3409 zassert_equal(DT_STRING_UPPER_TOKEN_OR(DT_NODELABEL(test_string_token_1),
3410 val, TOKEN_TWO), TOKEN_ONE, "");
3411
3412 /* Test DT_STRING_UPPER_TOKEN_OR is not found */
3413 zassert_equal(DT_STRING_UPPER_TOKEN_OR(DT_NODELABEL(test_string_token_1),
3414 no_inst, TOKEN_ZERO), TOKEN_ZERO, "");
3415
3416 /* Test DT_INST_STRING_TOKEN_OR when property is not found */
3417 #define STRING_TOKEN_TEST_NO_INST_EXPANSION(inst) \
3418 DT_INST_STRING_TOKEN_OR(inst, no_inst, token_no_inst),
3419 int array_no_inst_or[] = {
3420 DT_INST_FOREACH_STATUS_OKAY(STRING_TOKEN_TEST_NO_INST_EXPANSION)
3421 };
3422 for (i = 0; i < ARRAY_SIZE(array_no_inst_or); i++) {
3423 zassert_equal(array_no_inst_or[i], token_no_inst, "");
3424 }
3425
3426 /* Test DT_INST_STRING_UPPER_TOKEN_OR when property is not found */
3427 #define STRING_UPPER_TOKEN_TEST_NO_INST_EXPANSION(inst) \
3428 DT_INST_STRING_UPPER_TOKEN_OR(inst, no_inst, TOKEN_NO_INST),
3429 int array_no_inst_upper_or[] = {
3430 DT_INST_FOREACH_STATUS_OKAY(STRING_UPPER_TOKEN_TEST_NO_INST_EXPANSION)
3431 };
3432 for (i = 0; i < ARRAY_SIZE(array_no_inst_upper_or); i++) {
3433 zassert_equal(array_no_inst_upper_or[i], TOKEN_NO_INST, "");
3434 }
3435 }
3436
3437 #undef DT_DRV_COMPAT
3438 #define DT_DRV_COMPAT vnd_string_array_token
ZTEST(devicetree_api,test_string_idx_token)3439 ZTEST(devicetree_api, test_string_idx_token)
3440 {
3441 /* The enum has 7 values in total - thus invalid idx starts with 16 */
3442 enum token_string_idx {
3443 token_idx_default,
3444 /* Tokens */
3445 token_first_idx_zero,
3446 token_first_idx_one,
3447 token_first_idx_two,
3448 token_second_idx_zero,
3449 token_second_idx_one,
3450 token_second_idx_two,
3451 token_second_idx_three,
3452 /* Upper tokens */
3453 TOKEN_FIRST_IDX_ZERO,
3454 TOKEN_FIRST_IDX_ONE,
3455 TOKEN_FIRST_IDX_TWO,
3456 TOKEN_SECOND_IDX_ZERO,
3457 TOKEN_SECOND_IDX_ONE,
3458 TOKEN_SECOND_IDX_TWO,
3459 TOKEN_SECOND_IDX_THREE
3460 };
3461
3462 /* Test direct idx access */
3463 zassert_equal(DT_STRING_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_0), val, 0),
3464 token_first_idx_zero, "");
3465 zassert_equal(DT_STRING_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_0), val, 1),
3466 token_first_idx_one, "");
3467 zassert_equal(DT_STRING_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_0), val, 2),
3468 token_first_idx_two, "");
3469 zassert_equal(DT_STRING_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_1), val, 0),
3470 token_second_idx_zero, "");
3471 zassert_equal(DT_STRING_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_1), val, 1),
3472 token_second_idx_one, "");
3473 zassert_equal(DT_STRING_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_1), val, 2),
3474 token_second_idx_two, "");
3475 zassert_equal(DT_STRING_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_1), val, 3),
3476 token_second_idx_three, "");
3477
3478 /* Index is in range */
3479 zassert_equal(DT_STRING_TOKEN_BY_IDX_OR(DT_NODELABEL(test_str_array_token_1), val, 3,
3480 token_idx_default),
3481 token_second_idx_three, "");
3482 /* Index is out of range */
3483 zassert_equal(DT_STRING_TOKEN_BY_IDX_OR(DT_NODELABEL(test_str_array_token_1), val, 42,
3484 token_idx_default),
3485 token_idx_default, "");
3486
3487 zassert_equal(DT_STRING_UPPER_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_0), val, 0),
3488 TOKEN_FIRST_IDX_ZERO, "");
3489 zassert_equal(DT_STRING_UPPER_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_0), val, 1),
3490 TOKEN_FIRST_IDX_ONE, "");
3491 zassert_equal(DT_STRING_UPPER_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_0), val, 2),
3492 TOKEN_FIRST_IDX_TWO, "");
3493 zassert_equal(DT_STRING_UPPER_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_1), val, 0),
3494 TOKEN_SECOND_IDX_ZERO, "");
3495 zassert_equal(DT_STRING_UPPER_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_1), val, 1),
3496 TOKEN_SECOND_IDX_ONE, "");
3497 zassert_equal(DT_STRING_UPPER_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_1), val, 2),
3498 TOKEN_SECOND_IDX_TWO, "");
3499 zassert_equal(DT_STRING_UPPER_TOKEN_BY_IDX(DT_NODELABEL(test_str_array_token_1), val, 3),
3500 TOKEN_SECOND_IDX_THREE, "");
3501
3502 /* Test instances */
3503 #define STRING_TOKEN_BY_IDX_VAR(node_id) _CONCAT(var_token_, node_id)
3504 #define STRING_TOKEN_BY_IDX_TEST_INST_EXPANSION(inst) \
3505 enum token_string_idx STRING_TOKEN_BY_IDX_VAR(DT_DRV_INST(inst))[] = { \
3506 DT_INST_STRING_TOKEN_BY_IDX(inst, val, 0), \
3507 DT_INST_STRING_TOKEN_BY_IDX(inst, val, 1), \
3508 DT_INST_STRING_TOKEN_BY_IDX(inst, val, 2) \
3509 };
3510 DT_INST_FOREACH_STATUS_OKAY(STRING_TOKEN_BY_IDX_TEST_INST_EXPANSION);
3511
3512 zassert_equal(STRING_TOKEN_BY_IDX_VAR(DT_NODELABEL(test_str_array_token_0))[0],
3513 token_first_idx_zero, "");
3514 zassert_equal(STRING_TOKEN_BY_IDX_VAR(DT_NODELABEL(test_str_array_token_0))[1],
3515 token_first_idx_one, "");
3516 zassert_equal(STRING_TOKEN_BY_IDX_VAR(DT_NODELABEL(test_str_array_token_0))[2],
3517 token_first_idx_two, "");
3518 zassert_equal(STRING_TOKEN_BY_IDX_VAR(DT_NODELABEL(test_str_array_token_1))[0],
3519 token_second_idx_zero, "");
3520 zassert_equal(STRING_TOKEN_BY_IDX_VAR(DT_NODELABEL(test_str_array_token_1))[1],
3521 token_second_idx_one, "");
3522 zassert_equal(STRING_TOKEN_BY_IDX_VAR(DT_NODELABEL(test_str_array_token_1))[2],
3523 token_second_idx_two, "");
3524
3525 /* Test instances - index is in range */
3526 #define STRING_TOKEN_BY_IDX_OR_VAR_IN_RANGE(node_id) _CONCAT(var_in_range_token_or_, node_id)
3527 #define STRING_TOKEN_BY_IDX_OR_TEST_INST_EXPANSION_IN_RANGE(inst) \
3528 enum token_string_idx STRING_TOKEN_BY_IDX_OR_VAR_IN_RANGE(DT_DRV_INST(inst))[] = { \
3529 DT_INST_STRING_TOKEN_BY_IDX_OR(inst, val, 0, token_idx_default), \
3530 DT_INST_STRING_TOKEN_BY_IDX_OR(inst, val, 1, token_idx_default), \
3531 DT_INST_STRING_TOKEN_BY_IDX_OR(inst, val, 2, token_idx_default)};
3532 DT_INST_FOREACH_STATUS_OKAY(STRING_TOKEN_BY_IDX_OR_TEST_INST_EXPANSION_IN_RANGE);
3533
3534 zassert_equal(STRING_TOKEN_BY_IDX_OR_VAR_IN_RANGE(DT_NODELABEL(test_str_array_token_0))[0],
3535 token_first_idx_zero, "");
3536 zassert_equal(STRING_TOKEN_BY_IDX_OR_VAR_IN_RANGE(DT_NODELABEL(test_str_array_token_0))[1],
3537 token_first_idx_one, "");
3538 zassert_equal(STRING_TOKEN_BY_IDX_OR_VAR_IN_RANGE(DT_NODELABEL(test_str_array_token_0))[2],
3539 token_first_idx_two, "");
3540 zassert_equal(STRING_TOKEN_BY_IDX_OR_VAR_IN_RANGE(DT_NODELABEL(test_str_array_token_1))[0],
3541 token_second_idx_zero, "");
3542 zassert_equal(STRING_TOKEN_BY_IDX_OR_VAR_IN_RANGE(DT_NODELABEL(test_str_array_token_1))[1],
3543 token_second_idx_one, "");
3544 zassert_equal(STRING_TOKEN_BY_IDX_OR_VAR_IN_RANGE(DT_NODELABEL(test_str_array_token_1))[2],
3545 token_second_idx_two, "");
3546
3547 /* Test instances - index is out of range */
3548 #define STRING_TOKEN_BY_IDX_OR_VAR_NOT_IN_RANGE(node_id) \
3549 _CONCAT(var_not_in_range_token_or_, node_id)
3550 #define STRING_TOKEN_BY_IDX_OR_TEST_INST_EXPANSION_NOT_IN_RANGE(inst) \
3551 enum token_string_idx STRING_TOKEN_BY_IDX_OR_VAR_NOT_IN_RANGE(DT_DRV_INST(inst))[] = { \
3552 DT_INST_STRING_TOKEN_BY_IDX_OR(inst, val, 15, token_idx_default), \
3553 DT_INST_STRING_TOKEN_BY_IDX_OR(inst, val, 16, token_idx_default), \
3554 DT_INST_STRING_TOKEN_BY_IDX_OR(inst, val, 17, token_idx_default)};
3555 DT_INST_FOREACH_STATUS_OKAY(STRING_TOKEN_BY_IDX_OR_TEST_INST_EXPANSION_NOT_IN_RANGE);
3556
3557 zassert_equal(
3558 STRING_TOKEN_BY_IDX_OR_VAR_NOT_IN_RANGE(DT_NODELABEL(test_str_array_token_0))[0],
3559 token_idx_default, "");
3560 zassert_equal(
3561 STRING_TOKEN_BY_IDX_OR_VAR_NOT_IN_RANGE(DT_NODELABEL(test_str_array_token_0))[1],
3562 token_idx_default, "");
3563 zassert_equal(
3564 STRING_TOKEN_BY_IDX_OR_VAR_NOT_IN_RANGE(DT_NODELABEL(test_str_array_token_0))[2],
3565 token_idx_default, "");
3566 zassert_equal(
3567 STRING_TOKEN_BY_IDX_OR_VAR_NOT_IN_RANGE(DT_NODELABEL(test_str_array_token_1))[0],
3568 token_idx_default, "");
3569 zassert_equal(
3570 STRING_TOKEN_BY_IDX_OR_VAR_NOT_IN_RANGE(DT_NODELABEL(test_str_array_token_1))[1],
3571 token_idx_default, "");
3572 zassert_equal(
3573 STRING_TOKEN_BY_IDX_OR_VAR_NOT_IN_RANGE(DT_NODELABEL(test_str_array_token_1))[2],
3574 token_idx_default, "");
3575
3576 #define STRING_UPPER_TOKEN_BY_IDX_VAR(node_id) _CONCAT(var_upper_token, node_id)
3577 #define STRING_UPPER_TOKEN_BY_IDX_TEST_INST_EXPANSION(inst) \
3578 enum token_string_idx STRING_UPPER_TOKEN_BY_IDX_VAR(DT_DRV_INST(inst))[] = { \
3579 DT_INST_STRING_UPPER_TOKEN_BY_IDX(inst, val, 0), \
3580 DT_INST_STRING_UPPER_TOKEN_BY_IDX(inst, val, 1), \
3581 DT_INST_STRING_UPPER_TOKEN_BY_IDX(inst, val, 2) \
3582 };
3583 DT_INST_FOREACH_STATUS_OKAY(STRING_UPPER_TOKEN_BY_IDX_TEST_INST_EXPANSION);
3584
3585 zassert_equal(STRING_UPPER_TOKEN_BY_IDX_VAR(DT_NODELABEL(test_str_array_token_0))[0],
3586 TOKEN_FIRST_IDX_ZERO, "");
3587 zassert_equal(STRING_UPPER_TOKEN_BY_IDX_VAR(DT_NODELABEL(test_str_array_token_0))[1],
3588 TOKEN_FIRST_IDX_ONE, "");
3589 zassert_equal(STRING_UPPER_TOKEN_BY_IDX_VAR(DT_NODELABEL(test_str_array_token_0))[2],
3590 TOKEN_FIRST_IDX_TWO, "");
3591 zassert_equal(STRING_UPPER_TOKEN_BY_IDX_VAR(DT_NODELABEL(test_str_array_token_1))[0],
3592 TOKEN_SECOND_IDX_ZERO, "");
3593 zassert_equal(STRING_UPPER_TOKEN_BY_IDX_VAR(DT_NODELABEL(test_str_array_token_1))[1],
3594 TOKEN_SECOND_IDX_ONE, "");
3595 zassert_equal(STRING_UPPER_TOKEN_BY_IDX_VAR(DT_NODELABEL(test_str_array_token_1))[2],
3596 TOKEN_SECOND_IDX_TWO, "");
3597 }
3598
3599 #undef DT_DRV_COMPAT
3600 #define DT_DRV_COMPAT vnd_string_unquoted
ZTEST(devicetree_api,test_string_unquoted)3601 ZTEST(devicetree_api, test_string_unquoted)
3602 {
3603 #define XA 12.0
3604 #define XB 34.0
3605 #define XPLUS +
3606 #define XSTR1 "one"
3607 #define XSTR2 "two"
3608 const double f0_expected = 0.1234;
3609 const double f1_expected = 0.9e-3;
3610 const double delta = 0.1e-4;
3611
3612 /* Test DT_STRING_UNQUOTED */
3613 zassert_within(DT_STRING_UNQUOTED(DT_NODELABEL(test_str_unquoted_f0), val),
3614 f0_expected, delta, "");
3615 zassert_within(DT_STRING_UNQUOTED(DT_NODELABEL(test_str_unquoted_f1), val),
3616 f1_expected, delta, "");
3617 zassert_within(DT_STRING_UNQUOTED(DT_NODELABEL(test_str_unquoted_t), val),
3618 XA XPLUS XB, delta, "");
3619 zassert_within(DT_STRING_UNQUOTED(DT_NODELABEL(test_str_unquoted_esc_t), val), XA XPLUS XB,
3620 delta, "");
3621 zassert_str_equal(DT_STRING_UNQUOTED(DT_NODELABEL(test_str_unquoted_esc_s), val),
3622 "one plus two");
3623 /* Test DT_STRING_UNQUOTED_OR */
3624 zassert_within(DT_STRING_UNQUOTED_OR(DT_NODELABEL(test_str_unquoted_f0), val, (0.0)),
3625 f0_expected, delta, "");
3626 zassert_within(DT_STRING_UNQUOTED_OR(DT_NODELABEL(test_str_unquoted_f1), val, (0.0)),
3627 f1_expected, delta, "");
3628 zassert_within(DT_STRING_UNQUOTED_OR(DT_NODELABEL(test_str_unquoted_t), val, (0.0)),
3629 XA XPLUS XB, delta, "");
3630 zassert_within(DT_STRING_UNQUOTED_OR(DT_NODELABEL(test_str_unquoted_esc_t), val, (0.0)),
3631 XA XPLUS XB, delta, "");
3632 zassert_str_equal(DT_STRING_UNQUOTED_OR(DT_NODELABEL(test_str_unquoted_esc_s), val, "nak"),
3633 "one plus two");
3634 zassert_within(DT_STRING_UNQUOTED_OR(DT_NODELABEL(test_str_unquoted_f0), nak, (0.0)),
3635 0.0, delta, "");
3636 zassert_within(DT_STRING_UNQUOTED_OR(DT_NODELABEL(test_str_unquoted_f1), nak, (0.0)),
3637 0.0, delta, "");
3638 zassert_within(DT_STRING_UNQUOTED_OR(DT_NODELABEL(test_str_unquoted_t), nak, (0.0)),
3639 0.0, delta, "");
3640 zassert_within(DT_STRING_UNQUOTED_OR(DT_NODELABEL(test_str_unquoted_esc_t), nak, (0.0)),
3641 0.0, delta, "");
3642 zassert_str_equal(DT_STRING_UNQUOTED_OR(DT_NODELABEL(test_str_unquoted_esc_s), nak, "nak"),
3643 "nak");
3644 /* Test DT_INST_STRING_UNQUOTED */
3645 #define STRING_UNQUOTED_VAR(node_id) _CONCAT(var_, node_id)
3646 #define STRING_UNQUOTED_TEST_INST_EXPANSION(inst) \
3647 double STRING_UNQUOTED_VAR(DT_DRV_INST(inst)) = DT_INST_STRING_UNQUOTED(inst, val);
3648 DT_INST_FOREACH_STATUS_OKAY(STRING_UNQUOTED_TEST_INST_EXPANSION);
3649
3650 zassert_within(STRING_UNQUOTED_VAR(DT_NODELABEL(test_str_unquoted_f0)),
3651 f0_expected, delta, "");
3652 zassert_within(STRING_UNQUOTED_VAR(DT_NODELABEL(test_str_unquoted_f1)),
3653 f1_expected, delta, "");
3654 zassert_within(STRING_UNQUOTED_VAR(DT_NODELABEL(test_str_unquoted_t)), XA XPLUS XB,
3655 delta, "");
3656 zassert_within(STRING_UNQUOTED_VAR(DT_NODELABEL(test_str_unquoted_esc_t)), XA XPLUS XB,
3657 delta, "");
3658
3659 /* Test DT_INST_STRING_UNQUOTED_OR */
3660 #define STRING_UNQUOTED_OR_VAR(node_id) _CONCAT(var_or_, node_id)
3661 #define STRING_UNQUOTED_OR_TEST_INST_EXPANSION(inst) \
3662 double STRING_UNQUOTED_OR_VAR(DT_DRV_INST(inst))[2] = { \
3663 DT_INST_STRING_UNQUOTED_OR(inst, val, (1.0e10)), \
3664 DT_INST_STRING_UNQUOTED_OR(inst, dummy, (1.0e10)) \
3665 };
3666 DT_INST_FOREACH_STATUS_OKAY(STRING_UNQUOTED_OR_TEST_INST_EXPANSION);
3667
3668 zassert_within(STRING_UNQUOTED_OR_VAR(DT_NODELABEL(test_str_unquoted_f0))[0],
3669 f0_expected, delta, "");
3670 zassert_within(STRING_UNQUOTED_OR_VAR(DT_NODELABEL(test_str_unquoted_f1))[0],
3671 f1_expected, delta, "");
3672 zassert_within(STRING_UNQUOTED_OR_VAR(DT_NODELABEL(test_str_unquoted_t))[0],
3673 XA XPLUS XB, delta, "");
3674 zassert_within(STRING_UNQUOTED_OR_VAR(DT_NODELABEL(test_str_unquoted_esc_t))[0],
3675 XA XPLUS XB, delta, "");
3676 zassert_within(STRING_UNQUOTED_OR_VAR(DT_NODELABEL(test_str_unquoted_f0))[1],
3677 1.0e10, delta, "");
3678 zassert_within(STRING_UNQUOTED_OR_VAR(DT_NODELABEL(test_str_unquoted_f1))[1],
3679 1.0e10, delta, "");
3680 zassert_within(STRING_UNQUOTED_OR_VAR(DT_NODELABEL(test_str_unquoted_t))[1],
3681 1.0e10, delta, "");
3682 zassert_within(STRING_UNQUOTED_OR_VAR(DT_NODELABEL(test_str_unquoted_esc_t))[1], 1.0e10,
3683 delta, "");
3684 #undef XA
3685 #undef XB
3686 #undef XPLUS
3687 #undef XSTR1
3688 #undef XSTR2
3689 }
3690
3691 #undef DT_DRV_COMPAT
3692 #define DT_DRV_COMPAT vnd_string_array_unquoted
ZTEST(devicetree_api,test_string_idx_unquoted)3693 ZTEST(devicetree_api, test_string_idx_unquoted)
3694 {
3695 #define XA 12.0
3696 #define XB 34.0
3697 #define XC 56.0
3698 #define XD 78.0
3699 #define XPLUS +
3700 #define XMINUS -
3701 #define XSTR1 "one"
3702 #define XSTR2 "two"
3703 const double delta = 0.1e-4;
3704
3705 /* DT_STRING_UNQUOTED_BY_IDX */
3706 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_f0), val, 0),
3707 1.0e2, delta, "");
3708 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_f0), val, 1),
3709 2.0e2, delta, "");
3710 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_f0), val, 2),
3711 3.0e2, delta, "");
3712 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_f0), val, 3),
3713 4.0e2, delta, "");
3714
3715 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_f1), val, 0),
3716 0.01, delta, "");
3717 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_f1), val, 1),
3718 0.1, delta, "");
3719 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_f1), val, 2),
3720 1.0, delta, "");
3721 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_f1), val, 3),
3722 10.0, delta, "");
3723
3724 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_t), val, 0),
3725 XA XPLUS XB, delta, "");
3726 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_t), val, 1),
3727 XC XPLUS XD, delta, "");
3728 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_t), val, 2),
3729 XA XMINUS XB, delta, "");
3730 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_t), val, 3),
3731 XC XMINUS XD, delta, "");
3732
3733 zassert_within(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_esc), val, 0),
3734 XA XPLUS XB, delta, "");
3735 zassert_str_equal(DT_STRING_UNQUOTED_BY_IDX(DT_NODELABEL(test_stra_unquoted_esc), val, 1),
3736 "one plus two");
3737
3738 #define STRING_UNQUOTED_BY_IDX_VAR(node_id) _CONCAT(var_, node_id)
3739 #define STRING_UNQUOTED_BY_IDX_TEST_INST_EXPANSION(inst) \
3740 double STRING_UNQUOTED_BY_IDX_VAR(DT_DRV_INST(inst))[] = { \
3741 DT_INST_STRING_UNQUOTED_BY_IDX(inst, val, 0), \
3742 DT_INST_STRING_UNQUOTED_BY_IDX(inst, val, 1), \
3743 DT_INST_STRING_UNQUOTED_BY_IDX(inst, val, 2), \
3744 DT_INST_STRING_UNQUOTED_BY_IDX(inst, val, 3), \
3745 };
3746 DT_INST_FOREACH_STATUS_OKAY(STRING_UNQUOTED_BY_IDX_TEST_INST_EXPANSION);
3747
3748 zassert_within(STRING_UNQUOTED_BY_IDX_VAR(DT_NODELABEL(test_stra_unquoted_f0))[0],
3749 1.0e2, delta, "");
3750 zassert_within(STRING_UNQUOTED_BY_IDX_VAR(DT_NODELABEL(test_stra_unquoted_f0))[1],
3751 2.0e2, delta, "");
3752 zassert_within(STRING_UNQUOTED_BY_IDX_VAR(DT_NODELABEL(test_stra_unquoted_f0))[2],
3753 3.0e2, delta, "");
3754 zassert_within(STRING_UNQUOTED_BY_IDX_VAR(DT_NODELABEL(test_stra_unquoted_f0))[3],
3755 4.0e2, delta, "");
3756
3757 zassert_within(STRING_UNQUOTED_BY_IDX_VAR(DT_NODELABEL(test_stra_unquoted_f1))[0],
3758 0.01, delta, "");
3759 zassert_within(STRING_UNQUOTED_BY_IDX_VAR(DT_NODELABEL(test_stra_unquoted_f1))[1],
3760 0.1, delta, "");
3761 zassert_within(STRING_UNQUOTED_BY_IDX_VAR(DT_NODELABEL(test_stra_unquoted_f1))[2],
3762 1.0, delta, "");
3763 zassert_within(STRING_UNQUOTED_BY_IDX_VAR(DT_NODELABEL(test_stra_unquoted_f1))[3],
3764 10.0, delta, "");
3765
3766 zassert_within(STRING_UNQUOTED_BY_IDX_VAR(DT_NODELABEL(test_stra_unquoted_t))[0],
3767 XA XPLUS XB, delta, "");
3768 zassert_within(STRING_UNQUOTED_BY_IDX_VAR(DT_NODELABEL(test_stra_unquoted_t))[1],
3769 XC XPLUS XD, delta, "");
3770 zassert_within(STRING_UNQUOTED_BY_IDX_VAR(DT_NODELABEL(test_stra_unquoted_t))[2],
3771 XA XMINUS XB, delta, "");
3772 zassert_within(STRING_UNQUOTED_BY_IDX_VAR(DT_NODELABEL(test_stra_unquoted_t))[3],
3773 XC XMINUS XD, delta, "");
3774 #undef XA
3775 #undef XB
3776 #undef XC
3777 #undef XD
3778 #undef XPLUS
3779 #undef XMINUS
3780 #undef XSTR1
3781 #undef XSTR2
3782 }
3783
3784 #undef DT_DRV_COMPAT
ZTEST(devicetree_api,test_string_escape)3785 ZTEST(devicetree_api, test_string_escape)
3786 {
3787 zassert_str_equal(DT_PROP(DT_NODELABEL(test_str_escape_0), val), "\a\b\f\n\r\t\v");
3788 zassert_str_equal(DT_PROP(DT_NODELABEL(test_str_escape_1), val), "\'single\' \"double\"");
3789 zassert_str_equal(DT_PROP(DT_NODELABEL(test_str_escape_2), val), "first\nsecond");
3790 zassert_str_equal(DT_PROP(DT_NODELABEL(test_str_escape_3), val), "\x01\x7F");
3791 }
3792
ZTEST(devicetree_api,test_string_array_escape)3793 ZTEST(devicetree_api, test_string_array_escape)
3794 {
3795 zassert_str_equal(DT_PROP_BY_IDX(DT_NODELABEL(test_stra_escape), val, 0), "\a\b\f\n\r\t\v");
3796 zassert_str_equal(DT_PROP_BY_IDX(DT_NODELABEL(test_stra_escape), val, 1),
3797 "\'single\' \"double\"");
3798 zassert_str_equal(DT_PROP_BY_IDX(DT_NODELABEL(test_stra_escape), val, 2), "first\nsecond");
3799 zassert_str_equal(DT_PROP_BY_IDX(DT_NODELABEL(test_stra_escape), val, 3), "\x01\x7F");
3800 }
3801
3802 #undef DT_DRV_COMPAT
3803 #define DT_DRV_COMPAT vnd_adc_temp_sensor
ZTEST(devicetree_api,test_reset)3804 ZTEST(devicetree_api, test_reset)
3805 {
3806 /* DT_RESET_CTLR_BY_IDX */
3807 zassert_true(DT_SAME_NODE(DT_RESET_CTLR_BY_IDX(TEST_TEMP, 1),
3808 DT_NODELABEL(test_reset)), "");
3809
3810 /* DT_RESET_CTLR */
3811 zassert_true(DT_SAME_NODE(DT_RESET_CTLR(TEST_TEMP),
3812 DT_NODELABEL(test_reset)), "");
3813
3814 /* DT_RESET_CTLR_BY_NAME */
3815 zassert_true(DT_SAME_NODE(DT_RESET_CTLR_BY_NAME(TEST_TEMP, reset_b),
3816 DT_NODELABEL(test_reset)), "");
3817
3818 /* DT_RESET_CELL_BY_IDX */
3819 zassert_equal(DT_RESET_CELL_BY_IDX(TEST_TEMP, 1, id), 20, "");
3820 zassert_equal(DT_RESET_CELL_BY_IDX(TEST_TEMP, 0, id), 10, "");
3821
3822 /* DT_RESET_CELL_BY_NAME */
3823 zassert_equal(DT_RESET_CELL_BY_NAME(TEST_TEMP, reset_a, id), 10, "");
3824 zassert_equal(DT_RESET_CELL_BY_NAME(TEST_TEMP, reset_b, id), 20, "");
3825
3826 /* DT_RESET_CELL */
3827 zassert_equal(DT_RESET_CELL(TEST_TEMP, id), 10, "");
3828
3829 /* reg-width on reset */
3830 zassert_equal(DT_PROP_BY_PHANDLE_IDX(TEST_TEMP, resets, 1, reg_width), 4, "");
3831
3832 /* DT_INST */
3833 zassert_equal(DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT), 1, "");
3834
3835 /* DT_INST_RESET_CTLR_BY_IDX */
3836 zassert_true(DT_SAME_NODE(DT_INST_RESET_CTLR_BY_IDX(0, 1),
3837 DT_NODELABEL(test_reset)), "");
3838
3839 /* DT_INST_RESET_CTLR */
3840 zassert_true(DT_SAME_NODE(DT_INST_RESET_CTLR(0),
3841 DT_NODELABEL(test_reset)), "");
3842
3843 /* DT_INST_RESET_CTLR_BY_NAME */
3844 zassert_true(DT_SAME_NODE(DT_INST_RESET_CTLR_BY_NAME(0, reset_b),
3845 DT_NODELABEL(test_reset)), "");
3846
3847 /* DT_INST_RESET_CELL_BY_IDX */
3848 zassert_equal(DT_INST_RESET_CELL_BY_IDX(0, 1, id), 20, "");
3849 zassert_equal(DT_INST_RESET_CELL_BY_IDX(0, 0, id), 10, "");
3850
3851 /* DT_INST_RESET_CELL_BY_NAME */
3852 zassert_equal(DT_INST_RESET_CELL_BY_NAME(0, reset_a, id), 10, "");
3853 zassert_equal(DT_INST_RESET_CELL_BY_NAME(0, reset_b, id), 20, "");
3854
3855 /* DT_INST_RESET_CELL */
3856 zassert_equal(DT_INST_RESET_CELL(0, id), 10, "");
3857
3858 /* reg-width on reset */
3859 zassert_equal(DT_INST_PROP_BY_PHANDLE_IDX(0, resets, 1, reg_width), 4, "");
3860
3861 /* DT_RESET_ID_BY_IDX */
3862 zassert_equal(DT_RESET_ID_BY_IDX(TEST_TEMP, 0), 10, "");
3863 zassert_equal(DT_RESET_ID_BY_IDX(TEST_TEMP, 1), 20, "");
3864
3865 /* DT_RESET_ID */
3866 zassert_equal(DT_RESET_ID(TEST_TEMP), 10, "");
3867
3868 /* DT_INST_RESET_ID_BY_IDX */
3869 zassert_equal(DT_INST_RESET_ID_BY_IDX(0, 0), 10, "");
3870 zassert_equal(DT_INST_RESET_ID_BY_IDX(0, 1), 20, "");
3871
3872 /* DT_INST_RESET_ID */
3873 zassert_equal(DT_INST_RESET_ID(0), 10, "");
3874 }
3875
3876 #undef DT_DRV_COMPAT
3877 #define DT_DRV_COMPAT vnd_interrupt_holder_extended
ZTEST(devicetree_api,test_interrupt_controller)3878 ZTEST(devicetree_api, test_interrupt_controller)
3879 {
3880 /* DT_IRQ_INTC_BY_IDX */
3881 zassert_true(DT_SAME_NODE(DT_IRQ_INTC_BY_IDX(TEST_IRQ_EXT, 0), TEST_INTC), "");
3882 zassert_true(DT_SAME_NODE(DT_IRQ_INTC_BY_IDX(TEST_IRQ_EXT, 1), TEST_GPIO_4), "");
3883
3884 /* DT_IRQ_INTC_BY_NAME */
3885 zassert_true(DT_SAME_NODE(DT_IRQ_INTC_BY_NAME(TEST_IRQ_EXT, int1), TEST_INTC), "");
3886 zassert_true(DT_SAME_NODE(DT_IRQ_INTC_BY_NAME(TEST_IRQ_EXT, int2), TEST_GPIO_4), "");
3887
3888 /* DT_IRQ_INTC */
3889 zassert_true(DT_SAME_NODE(DT_IRQ_INTC(TEST_IRQ_EXT), TEST_INTC), "");
3890
3891 /* DT_INST_IRQ_INTC_BY_IDX */
3892 zassert_true(DT_SAME_NODE(DT_INST_IRQ_INTC_BY_IDX(0, 0), TEST_INTC), "");
3893 zassert_true(DT_SAME_NODE(DT_INST_IRQ_INTC_BY_IDX(0, 1), TEST_GPIO_4), "");
3894
3895 /* DT_INST_IRQ_INTC_BY_NAME */
3896 zassert_true(DT_SAME_NODE(DT_INST_IRQ_INTC_BY_NAME(0, int1), TEST_INTC), "");
3897 zassert_true(DT_SAME_NODE(DT_INST_IRQ_INTC_BY_NAME(0, int2), TEST_GPIO_4), "");
3898
3899 /* DT_INST_IRQ_INTC */
3900 zassert_true(DT_SAME_NODE(DT_INST_IRQ_INTC(0), TEST_INTC), "");
3901 }
3902
ZTEST(devicetree_api,test_nvmem_devictree)3903 ZTEST(devicetree_api, test_nvmem_devictree)
3904 {
3905 zexpect_equal(DT_NVMEM_CELLS_HAS_IDX(DT_NODELABEL(test_nvmem_consumer), 0), 1);
3906 zexpect_equal(DT_NVMEM_CELLS_HAS_IDX(DT_NODELABEL(test_nvmem_consumer), 1), 1);
3907 zexpect_equal(DT_NVMEM_CELLS_HAS_IDX(DT_NODELABEL(test_nvmem_consumer), 2), 0);
3908
3909 zexpect_equal(DT_NVMEM_CELLS_HAS_NAME(DT_NODELABEL(test_nvmem_consumer), cell0), 1);
3910 zexpect_equal(DT_NVMEM_CELLS_HAS_NAME(DT_NODELABEL(test_nvmem_consumer), cell10), 1);
3911 zexpect_equal(DT_NVMEM_CELLS_HAS_NAME(DT_NODELABEL(test_nvmem_consumer), missing), 0);
3912
3913 zexpect_equal(DT_NUM_NVMEM_CELLS(DT_NODELABEL(test_nvmem_consumer)), 2);
3914
3915 zexpect_str_equal(DT_NODE_PATH(DT_NVMEM_CELL_BY_IDX(DT_NODELABEL(test_nvmem_consumer), 0)),
3916 "/test/test-nvmem-provider/nvmem-layout/cell@0");
3917 zexpect_str_equal(DT_NODE_PATH(DT_NVMEM_CELL_BY_IDX(DT_NODELABEL(test_nvmem_consumer), 1)),
3918 "/test/test-nvmem-provider/nvmem-layout/cell@10");
3919
3920 zexpect_str_equal(
3921 DT_NODE_PATH(DT_NVMEM_CELL_BY_NAME(DT_NODELABEL(test_nvmem_consumer), cell0)),
3922 "/test/test-nvmem-provider/nvmem-layout/cell@0");
3923 zexpect_str_equal(
3924 DT_NODE_PATH(DT_NVMEM_CELL_BY_NAME(DT_NODELABEL(test_nvmem_consumer), cell10)),
3925 "/test/test-nvmem-provider/nvmem-layout/cell@10");
3926
3927 zexpect_str_equal(DT_NODE_PATH(DT_MTD_FROM_NVMEM_CELL(
3928 DT_NVMEM_CELL(DT_NODELABEL(test_nvmem_consumer)))),
3929 "/test/test-nvmem-provider");
3930 }
3931
3932 #undef DT_DRV_COMPAT
3933 #define DT_DRV_COMPAT vnd_nvmem_consumer
ZTEST(devicetree_api,test_nvmem_devictree_inst)3934 ZTEST(devicetree_api, test_nvmem_devictree_inst)
3935 {
3936 zexpect_equal(DT_INST_NVMEM_CELLS_HAS_IDX(0, 0), 1);
3937 zexpect_equal(DT_INST_NVMEM_CELLS_HAS_IDX(0, 1), 1);
3938 zexpect_equal(DT_INST_NVMEM_CELLS_HAS_IDX(0, 2), 0);
3939
3940 zexpect_equal(DT_INST_NVMEM_CELLS_HAS_NAME(0, cell0), 1);
3941 zexpect_equal(DT_INST_NVMEM_CELLS_HAS_NAME(0, cell10), 1);
3942 zexpect_equal(DT_INST_NVMEM_CELLS_HAS_NAME(0, missing), 0);
3943
3944 zexpect_equal(DT_INST_NUM_NVMEM_CELLS(0), 2);
3945
3946 zexpect_str_equal(DT_NODE_PATH(DT_INST_NVMEM_CELL_BY_IDX(0, 0)),
3947 "/test/test-nvmem-provider/nvmem-layout/cell@0");
3948 zexpect_str_equal(DT_NODE_PATH(DT_INST_NVMEM_CELL_BY_IDX(0, 1)),
3949 "/test/test-nvmem-provider/nvmem-layout/cell@10");
3950
3951 zexpect_str_equal(DT_NODE_PATH(DT_INST_NVMEM_CELL_BY_NAME(0, cell0)),
3952 "/test/test-nvmem-provider/nvmem-layout/cell@0");
3953 zexpect_str_equal(DT_NODE_PATH(DT_INST_NVMEM_CELL_BY_NAME(0, cell10)),
3954 "/test/test-nvmem-provider/nvmem-layout/cell@10");
3955
3956 zexpect_str_equal(DT_NODE_PATH(DT_MTD_FROM_NVMEM_CELL(DT_INST_NVMEM_CELL(0))),
3957 "/test/test-nvmem-provider");
3958 }
3959
3960 ZTEST_SUITE(devicetree_api, NULL, NULL, NULL, NULL, NULL);
3961
