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