2 * Copyright (c) 2014 Google, Inc
4 * SPDX-License-Identifier: GPL-2.0+
9 #include <dm/device-internal.h>
11 #include <dm/uclass-internal.h>
15 DECLARE_GLOBAL_DATA_PTR
;
17 struct dm_test_parent_platdata
{
24 FLAG_CHILD_PROBED
= 10,
25 FLAG_CHILD_REMOVED
= -7,
28 static struct dm_test_state
*test_state
;
30 static int testbus_drv_probe(struct udevice
*dev
)
32 return dm_scan_fdt_dev(dev
);
35 static int testbus_child_post_bind(struct udevice
*dev
)
37 struct dm_test_parent_platdata
*plat
;
39 plat
= dev_get_parent_platdata(dev
);
41 plat
->uclass_bind_flag
= 2;
46 static int testbus_child_pre_probe(struct udevice
*dev
)
48 struct dm_test_parent_data
*parent_data
= dev_get_parent_priv(dev
);
50 parent_data
->flag
+= FLAG_CHILD_PROBED
;
55 static int testbus_child_pre_probe_uclass(struct udevice
*dev
)
57 struct dm_test_priv
*priv
= dev_get_priv(dev
);
64 static int testbus_child_post_remove(struct udevice
*dev
)
66 struct dm_test_parent_data
*parent_data
= dev_get_parent_priv(dev
);
67 struct dm_test_state
*dms
= test_state
;
69 parent_data
->flag
+= FLAG_CHILD_REMOVED
;
76 static const struct udevice_id testbus_ids
[] = {
78 .compatible
= "denx,u-boot-test-bus",
79 .data
= DM_TEST_TYPE_FIRST
},
83 U_BOOT_DRIVER(testbus_drv
) = {
84 .name
= "testbus_drv",
85 .of_match
= testbus_ids
,
86 .id
= UCLASS_TEST_BUS
,
87 .probe
= testbus_drv_probe
,
88 .child_post_bind
= testbus_child_post_bind
,
89 .priv_auto_alloc_size
= sizeof(struct dm_test_priv
),
90 .platdata_auto_alloc_size
= sizeof(struct dm_test_pdata
),
91 .per_child_auto_alloc_size
= sizeof(struct dm_test_parent_data
),
92 .per_child_platdata_auto_alloc_size
=
93 sizeof(struct dm_test_parent_platdata
),
94 .child_pre_probe
= testbus_child_pre_probe
,
95 .child_post_remove
= testbus_child_post_remove
,
98 UCLASS_DRIVER(testbus
) = {
100 .id
= UCLASS_TEST_BUS
,
101 .flags
= DM_UC_FLAG_SEQ_ALIAS
,
102 .child_pre_probe
= testbus_child_pre_probe_uclass
,
105 /* Test that we can probe for children */
106 static int dm_test_bus_children(struct unit_test_state
*uts
)
112 ut_assertok(uclass_get(UCLASS_TEST_FDT
, &uc
));
113 ut_asserteq(num_devices
, list_count_items(&uc
->dev_head
));
115 /* Probe the bus, which should yield 3 more devices */
116 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
119 ut_assertok(uclass_get(UCLASS_TEST_FDT
, &uc
));
120 ut_asserteq(num_devices
, list_count_items(&uc
->dev_head
));
122 ut_assert(!dm_check_devices(uts
, num_devices
));
126 DM_TEST(dm_test_bus_children
, DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
128 /* Test our functions for accessing children */
129 static int dm_test_bus_children_funcs(struct unit_test_state
*uts
)
131 const void *blob
= gd
->fdt_blob
;
132 struct udevice
*bus
, *dev
;
135 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
137 /* device_get_child() */
138 ut_assertok(device_get_child(bus
, 0, &dev
));
139 ut_asserteq(-ENODEV
, device_get_child(bus
, 4, &dev
));
140 ut_assertok(device_get_child_by_seq(bus
, 5, &dev
));
141 ut_assert(dev
->flags
& DM_FLAG_ACTIVATED
);
142 ut_asserteq_str("c-test@5", dev
->name
);
144 /* Device with sequence number 0 should be accessible */
145 ut_asserteq(-ENODEV
, device_find_child_by_seq(bus
, -1, true, &dev
));
146 ut_assertok(device_find_child_by_seq(bus
, 0, true, &dev
));
147 ut_assert(!(dev
->flags
& DM_FLAG_ACTIVATED
));
148 ut_asserteq(-ENODEV
, device_find_child_by_seq(bus
, 0, false, &dev
));
149 ut_assertok(device_get_child_by_seq(bus
, 0, &dev
));
150 ut_assert(dev
->flags
& DM_FLAG_ACTIVATED
);
152 /* There is no device with sequence number 2 */
153 ut_asserteq(-ENODEV
, device_find_child_by_seq(bus
, 2, false, &dev
));
154 ut_asserteq(-ENODEV
, device_find_child_by_seq(bus
, 2, true, &dev
));
155 ut_asserteq(-ENODEV
, device_get_child_by_seq(bus
, 2, &dev
));
157 /* Looking for something that is not a child */
158 node
= fdt_path_offset(blob
, "/junk");
159 ut_asserteq(-ENODEV
, device_find_child_by_of_offset(bus
, node
, &dev
));
160 node
= fdt_path_offset(blob
, "/d-test");
161 ut_asserteq(-ENODEV
, device_find_child_by_of_offset(bus
, node
, &dev
));
163 /* Find a valid child */
164 node
= fdt_path_offset(blob
, "/some-bus/c-test@1");
165 ut_assertok(device_find_child_by_of_offset(bus
, node
, &dev
));
166 ut_assert(!(dev
->flags
& DM_FLAG_ACTIVATED
));
167 ut_assertok(device_get_child_by_of_offset(bus
, node
, &dev
));
168 ut_assert(dev
->flags
& DM_FLAG_ACTIVATED
);
172 DM_TEST(dm_test_bus_children_funcs
, DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
174 /* Test that we can iterate through children */
175 static int dm_test_bus_children_iterators(struct unit_test_state
*uts
)
177 struct udevice
*bus
, *dev
, *child
;
179 /* Walk through the children one by one */
180 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
181 ut_assertok(device_find_first_child(bus
, &dev
));
182 ut_asserteq_str("c-test@5", dev
->name
);
183 ut_assertok(device_find_next_child(&dev
));
184 ut_asserteq_str("c-test@0", dev
->name
);
185 ut_assertok(device_find_next_child(&dev
));
186 ut_asserteq_str("c-test@1", dev
->name
);
187 ut_assertok(device_find_next_child(&dev
));
188 ut_asserteq_ptr(dev
, NULL
);
190 /* Move to the next child without using device_find_first_child() */
191 ut_assertok(device_find_child_by_seq(bus
, 5, true, &dev
));
192 ut_asserteq_str("c-test@5", dev
->name
);
193 ut_assertok(device_find_next_child(&dev
));
194 ut_asserteq_str("c-test@0", dev
->name
);
196 /* Try a device with no children */
197 ut_assertok(device_find_first_child(dev
, &child
));
198 ut_asserteq_ptr(child
, NULL
);
202 DM_TEST(dm_test_bus_children_iterators
,
203 DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
205 /* Test that the bus can store data about each child */
206 static int test_bus_parent_data(struct unit_test_state
*uts
)
208 struct dm_test_parent_data
*parent_data
;
209 struct udevice
*bus
, *dev
;
213 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
215 /* Check that parent data is allocated */
216 ut_assertok(device_find_child_by_seq(bus
, 0, true, &dev
));
217 ut_asserteq_ptr(NULL
, dev_get_parent_priv(dev
));
218 ut_assertok(device_get_child_by_seq(bus
, 0, &dev
));
219 parent_data
= dev_get_parent_priv(dev
);
220 ut_assert(NULL
!= parent_data
);
222 /* Check that it starts at 0 and goes away when device is removed */
223 parent_data
->sum
+= 5;
224 ut_asserteq(5, parent_data
->sum
);
226 ut_asserteq_ptr(NULL
, dev_get_parent_priv(dev
));
228 /* Check that we can do this twice */
229 ut_assertok(device_get_child_by_seq(bus
, 0, &dev
));
230 parent_data
= dev_get_parent_priv(dev
);
231 ut_assert(NULL
!= parent_data
);
232 parent_data
->sum
+= 5;
233 ut_asserteq(5, parent_data
->sum
);
235 /* Add parent data to all children */
236 ut_assertok(uclass_get(UCLASS_TEST_FDT
, &uc
));
238 uclass_foreach_dev(dev
, uc
) {
239 /* Ignore these if they are not on this bus */
240 if (dev
->parent
!= bus
) {
241 ut_asserteq_ptr(NULL
, dev_get_parent_priv(dev
));
244 ut_assertok(device_probe(dev
));
245 parent_data
= dev_get_parent_priv(dev
);
247 parent_data
->sum
= value
;
251 /* Check it is still there */
253 uclass_foreach_dev(dev
, uc
) {
254 /* Ignore these if they are not on this bus */
255 if (dev
->parent
!= bus
)
257 parent_data
= dev_get_parent_priv(dev
);
259 ut_asserteq(value
, parent_data
->sum
);
265 /* Test that the bus can store data about each child */
266 static int dm_test_bus_parent_data(struct unit_test_state
*uts
)
268 return test_bus_parent_data(uts
);
270 DM_TEST(dm_test_bus_parent_data
, DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
272 /* As above but the size is controlled by the uclass */
273 static int dm_test_bus_parent_data_uclass(struct unit_test_state
*uts
)
280 /* Set the driver size to 0 so that the uclass size is used */
281 ut_assertok(uclass_find_device(UCLASS_TEST_BUS
, 0, &bus
));
282 drv
= (struct driver
*)bus
->driver
;
283 size
= drv
->per_child_auto_alloc_size
;
284 bus
->uclass
->uc_drv
->per_child_auto_alloc_size
= size
;
285 drv
->per_child_auto_alloc_size
= 0;
286 ret
= test_bus_parent_data(uts
);
289 bus
->uclass
->uc_drv
->per_child_auto_alloc_size
= 0;
290 drv
->per_child_auto_alloc_size
= size
;
294 DM_TEST(dm_test_bus_parent_data_uclass
,
295 DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
297 /* Test that the bus ops are called when a child is probed/removed */
298 static int dm_test_bus_parent_ops(struct unit_test_state
*uts
)
300 struct dm_test_parent_data
*parent_data
;
301 struct dm_test_state
*dms
= uts
->priv
;
302 struct udevice
*bus
, *dev
;
306 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
307 ut_assertok(uclass_get(UCLASS_TEST_FDT
, &uc
));
309 uclass_foreach_dev(dev
, uc
) {
310 /* Ignore these if they are not on this bus */
311 if (dev
->parent
!= bus
)
313 ut_asserteq_ptr(NULL
, dev_get_parent_priv(dev
));
315 ut_assertok(device_probe(dev
));
316 parent_data
= dev_get_parent_priv(dev
);
317 ut_asserteq(FLAG_CHILD_PROBED
, parent_data
->flag
);
320 uclass_foreach_dev(dev
, uc
) {
321 /* Ignore these if they are not on this bus */
322 if (dev
->parent
!= bus
)
324 parent_data
= dev_get_parent_priv(dev
);
325 ut_asserteq(FLAG_CHILD_PROBED
, parent_data
->flag
);
326 ut_assertok(device_remove(dev
));
327 ut_asserteq_ptr(NULL
, dev_get_parent_priv(dev
));
328 ut_asserteq_ptr(dms
->removed
, dev
);
334 DM_TEST(dm_test_bus_parent_ops
, DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
336 static int test_bus_parent_platdata(struct unit_test_state
*uts
)
338 struct dm_test_parent_platdata
*plat
;
339 struct udevice
*bus
, *dev
;
342 /* Check that the bus has no children */
343 ut_assertok(uclass_find_device(UCLASS_TEST_BUS
, 0, &bus
));
344 device_find_first_child(bus
, &dev
);
345 ut_asserteq_ptr(NULL
, dev
);
347 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
349 for (device_find_first_child(bus
, &dev
), child_count
= 0;
351 device_find_next_child(&dev
)) {
352 /* Check that platform data is allocated */
353 plat
= dev_get_parent_platdata(dev
);
354 ut_assert(plat
!= NULL
);
357 * Check that it is not affected by the device being
361 ut_asserteq(1, plat
->count
);
365 ut_asserteq_ptr(plat
, dev_get_parent_platdata(dev
));
366 ut_asserteq(1, plat
->count
);
367 ut_assertok(device_probe(dev
));
370 ut_asserteq(3, child_count
);
372 /* Removing the bus should also have no effect (it is still bound) */
374 for (device_find_first_child(bus
, &dev
), child_count
= 0;
376 device_find_next_child(&dev
)) {
377 /* Check that platform data is allocated */
378 plat
= dev_get_parent_platdata(dev
);
379 ut_assert(plat
!= NULL
);
380 ut_asserteq(1, plat
->count
);
383 ut_asserteq(3, child_count
);
385 /* Unbind all the children */
387 device_find_first_child(bus
, &dev
);
392 /* Now the child platdata should be removed and re-added */
394 for (device_find_first_child(bus
, &dev
), child_count
= 0;
396 device_find_next_child(&dev
)) {
397 /* Check that platform data is allocated */
398 plat
= dev_get_parent_platdata(dev
);
399 ut_assert(plat
!= NULL
);
400 ut_asserteq(0, plat
->count
);
403 ut_asserteq(3, child_count
);
408 /* Test that the bus can store platform data about each child */
409 static int dm_test_bus_parent_platdata(struct unit_test_state
*uts
)
411 return test_bus_parent_platdata(uts
);
413 DM_TEST(dm_test_bus_parent_platdata
, DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
415 /* As above but the size is controlled by the uclass */
416 static int dm_test_bus_parent_platdata_uclass(struct unit_test_state
*uts
)
423 /* Set the driver size to 0 so that the uclass size is used */
424 ut_assertok(uclass_find_device(UCLASS_TEST_BUS
, 0, &bus
));
425 drv
= (struct driver
*)bus
->driver
;
426 size
= drv
->per_child_platdata_auto_alloc_size
;
427 bus
->uclass
->uc_drv
->per_child_platdata_auto_alloc_size
= size
;
428 drv
->per_child_platdata_auto_alloc_size
= 0;
429 ret
= test_bus_parent_platdata(uts
);
432 bus
->uclass
->uc_drv
->per_child_platdata_auto_alloc_size
= 0;
433 drv
->per_child_platdata_auto_alloc_size
= size
;
437 DM_TEST(dm_test_bus_parent_platdata_uclass
,
438 DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
440 /* Test that the child post_bind method is called */
441 static int dm_test_bus_child_post_bind(struct unit_test_state
*uts
)
443 struct dm_test_parent_platdata
*plat
;
444 struct udevice
*bus
, *dev
;
447 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
448 for (device_find_first_child(bus
, &dev
), child_count
= 0;
450 device_find_next_child(&dev
)) {
451 /* Check that platform data is allocated */
452 plat
= dev_get_parent_platdata(dev
);
453 ut_assert(plat
!= NULL
);
454 ut_asserteq(1, plat
->bind_flag
);
457 ut_asserteq(3, child_count
);
461 DM_TEST(dm_test_bus_child_post_bind
, DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
463 /* Test that the child post_bind method is called */
464 static int dm_test_bus_child_post_bind_uclass(struct unit_test_state
*uts
)
466 struct dm_test_parent_platdata
*plat
;
467 struct udevice
*bus
, *dev
;
470 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
471 for (device_find_first_child(bus
, &dev
), child_count
= 0;
473 device_find_next_child(&dev
)) {
474 /* Check that platform data is allocated */
475 plat
= dev_get_parent_platdata(dev
);
476 ut_assert(plat
!= NULL
);
477 ut_asserteq(2, plat
->uclass_bind_flag
);
480 ut_asserteq(3, child_count
);
484 DM_TEST(dm_test_bus_child_post_bind_uclass
,
485 DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
488 * Test that the bus' uclass' child_pre_probe() is called before the
489 * device's probe() method
491 static int dm_test_bus_child_pre_probe_uclass(struct unit_test_state
*uts
)
493 struct udevice
*bus
, *dev
;
497 * See testfdt_drv_probe() which effectively checks that the uclass
498 * flag is set before that method is called
500 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
501 for (device_find_first_child(bus
, &dev
), child_count
= 0;
503 device_find_next_child(&dev
)) {
504 struct dm_test_priv
*priv
= dev_get_priv(dev
);
506 /* Check that things happened in the right order */
507 ut_asserteq_ptr(NULL
, priv
);
508 ut_assertok(device_probe(dev
));
510 priv
= dev_get_priv(dev
);
511 ut_assert(priv
!= NULL
);
512 ut_asserteq(1, priv
->uclass_flag
);
513 ut_asserteq(1, priv
->uclass_total
);
516 ut_asserteq(3, child_count
);
520 DM_TEST(dm_test_bus_child_pre_probe_uclass
,
521 DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);