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
));
165 DM_TEST(dm_test_bus_children_funcs
, DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
167 static int dm_test_bus_children_of_offset(struct unit_test_state
*uts
)
169 const void *blob
= gd
->fdt_blob
;
170 struct udevice
*bus
, *dev
;
173 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
174 ut_assertnonnull(bus
);
176 /* Find a valid child */
177 node
= fdt_path_offset(blob
, "/some-bus/c-test@1");
179 ut_assertok(device_find_child_by_of_offset(bus
, node
, &dev
));
180 ut_assertnonnull(dev
);
181 ut_assert(!(dev
->flags
& DM_FLAG_ACTIVATED
));
182 ut_assertok(device_get_child_by_of_offset(bus
, node
, &dev
));
183 ut_assertnonnull(dev
);
184 ut_assert(dev
->flags
& DM_FLAG_ACTIVATED
);
188 DM_TEST(dm_test_bus_children_of_offset
,
189 DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
| DM_TESTF_FLAT_TREE
);
191 /* Test that we can iterate through children */
192 static int dm_test_bus_children_iterators(struct unit_test_state
*uts
)
194 struct udevice
*bus
, *dev
, *child
;
196 /* Walk through the children one by one */
197 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
198 ut_assertok(device_find_first_child(bus
, &dev
));
199 ut_asserteq_str("c-test@5", dev
->name
);
200 ut_assertok(device_find_next_child(&dev
));
201 ut_asserteq_str("c-test@0", dev
->name
);
202 ut_assertok(device_find_next_child(&dev
));
203 ut_asserteq_str("c-test@1", dev
->name
);
204 ut_assertok(device_find_next_child(&dev
));
205 ut_asserteq_ptr(dev
, NULL
);
207 /* Move to the next child without using device_find_first_child() */
208 ut_assertok(device_find_child_by_seq(bus
, 5, true, &dev
));
209 ut_asserteq_str("c-test@5", dev
->name
);
210 ut_assertok(device_find_next_child(&dev
));
211 ut_asserteq_str("c-test@0", dev
->name
);
213 /* Try a device with no children */
214 ut_assertok(device_find_first_child(dev
, &child
));
215 ut_asserteq_ptr(child
, NULL
);
219 DM_TEST(dm_test_bus_children_iterators
,
220 DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
222 /* Test that the bus can store data about each child */
223 static int test_bus_parent_data(struct unit_test_state
*uts
)
225 struct dm_test_parent_data
*parent_data
;
226 struct udevice
*bus
, *dev
;
230 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
232 /* Check that parent data is allocated */
233 ut_assertok(device_find_child_by_seq(bus
, 0, true, &dev
));
234 ut_asserteq_ptr(NULL
, dev_get_parent_priv(dev
));
235 ut_assertok(device_get_child_by_seq(bus
, 0, &dev
));
236 parent_data
= dev_get_parent_priv(dev
);
237 ut_assert(NULL
!= parent_data
);
239 /* Check that it starts at 0 and goes away when device is removed */
240 parent_data
->sum
+= 5;
241 ut_asserteq(5, parent_data
->sum
);
242 device_remove(dev
, DM_REMOVE_NORMAL
);
243 ut_asserteq_ptr(NULL
, dev_get_parent_priv(dev
));
245 /* Check that we can do this twice */
246 ut_assertok(device_get_child_by_seq(bus
, 0, &dev
));
247 parent_data
= dev_get_parent_priv(dev
);
248 ut_assert(NULL
!= parent_data
);
249 parent_data
->sum
+= 5;
250 ut_asserteq(5, parent_data
->sum
);
252 /* Add parent data to all children */
253 ut_assertok(uclass_get(UCLASS_TEST_FDT
, &uc
));
255 uclass_foreach_dev(dev
, uc
) {
256 /* Ignore these if they are not on this bus */
257 if (dev
->parent
!= bus
) {
258 ut_asserteq_ptr(NULL
, dev_get_parent_priv(dev
));
261 ut_assertok(device_probe(dev
));
262 parent_data
= dev_get_parent_priv(dev
);
264 parent_data
->sum
= value
;
268 /* Check it is still there */
270 uclass_foreach_dev(dev
, uc
) {
271 /* Ignore these if they are not on this bus */
272 if (dev
->parent
!= bus
)
274 parent_data
= dev_get_parent_priv(dev
);
276 ut_asserteq(value
, parent_data
->sum
);
282 /* Test that the bus can store data about each child */
283 static int dm_test_bus_parent_data(struct unit_test_state
*uts
)
285 return test_bus_parent_data(uts
);
287 DM_TEST(dm_test_bus_parent_data
, DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
289 /* As above but the size is controlled by the uclass */
290 static int dm_test_bus_parent_data_uclass(struct unit_test_state
*uts
)
297 /* Set the driver size to 0 so that the uclass size is used */
298 ut_assertok(uclass_find_device(UCLASS_TEST_BUS
, 0, &bus
));
299 drv
= (struct driver
*)bus
->driver
;
300 size
= drv
->per_child_auto_alloc_size
;
301 bus
->uclass
->uc_drv
->per_child_auto_alloc_size
= size
;
302 drv
->per_child_auto_alloc_size
= 0;
303 ret
= test_bus_parent_data(uts
);
306 bus
->uclass
->uc_drv
->per_child_auto_alloc_size
= 0;
307 drv
->per_child_auto_alloc_size
= size
;
311 DM_TEST(dm_test_bus_parent_data_uclass
,
312 DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
314 /* Test that the bus ops are called when a child is probed/removed */
315 static int dm_test_bus_parent_ops(struct unit_test_state
*uts
)
317 struct dm_test_parent_data
*parent_data
;
318 struct dm_test_state
*dms
= uts
->priv
;
319 struct udevice
*bus
, *dev
;
323 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
324 ut_assertok(uclass_get(UCLASS_TEST_FDT
, &uc
));
326 uclass_foreach_dev(dev
, uc
) {
327 /* Ignore these if they are not on this bus */
328 if (dev
->parent
!= bus
)
330 ut_asserteq_ptr(NULL
, dev_get_parent_priv(dev
));
332 ut_assertok(device_probe(dev
));
333 parent_data
= dev_get_parent_priv(dev
);
334 ut_asserteq(FLAG_CHILD_PROBED
, parent_data
->flag
);
337 uclass_foreach_dev(dev
, uc
) {
338 /* Ignore these if they are not on this bus */
339 if (dev
->parent
!= bus
)
341 parent_data
= dev_get_parent_priv(dev
);
342 ut_asserteq(FLAG_CHILD_PROBED
, parent_data
->flag
);
343 ut_assertok(device_remove(dev
, DM_REMOVE_NORMAL
));
344 ut_asserteq_ptr(NULL
, dev_get_parent_priv(dev
));
345 ut_asserteq_ptr(dms
->removed
, dev
);
351 DM_TEST(dm_test_bus_parent_ops
, DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
353 static int test_bus_parent_platdata(struct unit_test_state
*uts
)
355 struct dm_test_parent_platdata
*plat
;
356 struct udevice
*bus
, *dev
;
359 /* Check that the bus has no children */
360 ut_assertok(uclass_find_device(UCLASS_TEST_BUS
, 0, &bus
));
361 device_find_first_child(bus
, &dev
);
362 ut_asserteq_ptr(NULL
, dev
);
364 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
366 for (device_find_first_child(bus
, &dev
), child_count
= 0;
368 device_find_next_child(&dev
)) {
369 /* Check that platform data is allocated */
370 plat
= dev_get_parent_platdata(dev
);
371 ut_assert(plat
!= NULL
);
374 * Check that it is not affected by the device being
378 ut_asserteq(1, plat
->count
);
380 device_remove(dev
, DM_REMOVE_NORMAL
);
382 ut_asserteq_ptr(plat
, dev_get_parent_platdata(dev
));
383 ut_asserteq(1, plat
->count
);
384 ut_assertok(device_probe(dev
));
387 ut_asserteq(3, child_count
);
389 /* Removing the bus should also have no effect (it is still bound) */
390 device_remove(bus
, DM_REMOVE_NORMAL
);
391 for (device_find_first_child(bus
, &dev
), child_count
= 0;
393 device_find_next_child(&dev
)) {
394 /* Check that platform data is allocated */
395 plat
= dev_get_parent_platdata(dev
);
396 ut_assert(plat
!= NULL
);
397 ut_asserteq(1, plat
->count
);
400 ut_asserteq(3, child_count
);
402 /* Unbind all the children */
404 device_find_first_child(bus
, &dev
);
409 /* Now the child platdata should be removed and re-added */
411 for (device_find_first_child(bus
, &dev
), child_count
= 0;
413 device_find_next_child(&dev
)) {
414 /* Check that platform data is allocated */
415 plat
= dev_get_parent_platdata(dev
);
416 ut_assert(plat
!= NULL
);
417 ut_asserteq(0, plat
->count
);
420 ut_asserteq(3, child_count
);
425 /* Test that the bus can store platform data about each child */
426 static int dm_test_bus_parent_platdata(struct unit_test_state
*uts
)
428 return test_bus_parent_platdata(uts
);
430 DM_TEST(dm_test_bus_parent_platdata
, DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
432 /* As above but the size is controlled by the uclass */
433 static int dm_test_bus_parent_platdata_uclass(struct unit_test_state
*uts
)
440 /* Set the driver size to 0 so that the uclass size is used */
441 ut_assertok(uclass_find_device(UCLASS_TEST_BUS
, 0, &bus
));
442 drv
= (struct driver
*)bus
->driver
;
443 size
= drv
->per_child_platdata_auto_alloc_size
;
444 bus
->uclass
->uc_drv
->per_child_platdata_auto_alloc_size
= size
;
445 drv
->per_child_platdata_auto_alloc_size
= 0;
446 ret
= test_bus_parent_platdata(uts
);
449 bus
->uclass
->uc_drv
->per_child_platdata_auto_alloc_size
= 0;
450 drv
->per_child_platdata_auto_alloc_size
= size
;
454 DM_TEST(dm_test_bus_parent_platdata_uclass
,
455 DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
457 /* Test that the child post_bind method is called */
458 static int dm_test_bus_child_post_bind(struct unit_test_state
*uts
)
460 struct dm_test_parent_platdata
*plat
;
461 struct udevice
*bus
, *dev
;
464 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
465 for (device_find_first_child(bus
, &dev
), child_count
= 0;
467 device_find_next_child(&dev
)) {
468 /* Check that platform data is allocated */
469 plat
= dev_get_parent_platdata(dev
);
470 ut_assert(plat
!= NULL
);
471 ut_asserteq(1, plat
->bind_flag
);
474 ut_asserteq(3, child_count
);
478 DM_TEST(dm_test_bus_child_post_bind
, DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
480 /* Test that the child post_bind method is called */
481 static int dm_test_bus_child_post_bind_uclass(struct unit_test_state
*uts
)
483 struct dm_test_parent_platdata
*plat
;
484 struct udevice
*bus
, *dev
;
487 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
488 for (device_find_first_child(bus
, &dev
), child_count
= 0;
490 device_find_next_child(&dev
)) {
491 /* Check that platform data is allocated */
492 plat
= dev_get_parent_platdata(dev
);
493 ut_assert(plat
!= NULL
);
494 ut_asserteq(2, plat
->uclass_bind_flag
);
497 ut_asserteq(3, child_count
);
501 DM_TEST(dm_test_bus_child_post_bind_uclass
,
502 DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);
505 * Test that the bus' uclass' child_pre_probe() is called before the
506 * device's probe() method
508 static int dm_test_bus_child_pre_probe_uclass(struct unit_test_state
*uts
)
510 struct udevice
*bus
, *dev
;
514 * See testfdt_drv_probe() which effectively checks that the uclass
515 * flag is set before that method is called
517 ut_assertok(uclass_get_device(UCLASS_TEST_BUS
, 0, &bus
));
518 for (device_find_first_child(bus
, &dev
), child_count
= 0;
520 device_find_next_child(&dev
)) {
521 struct dm_test_priv
*priv
= dev_get_priv(dev
);
523 /* Check that things happened in the right order */
524 ut_asserteq_ptr(NULL
, priv
);
525 ut_assertok(device_probe(dev
));
527 priv
= dev_get_priv(dev
);
528 ut_assert(priv
!= NULL
);
529 ut_asserteq(1, priv
->uclass_flag
);
530 ut_asserteq(1, priv
->uclass_total
);
533 ut_asserteq(3, child_count
);
537 DM_TEST(dm_test_bus_child_pre_probe_uclass
,
538 DM_TESTF_SCAN_PDATA
| DM_TESTF_SCAN_FDT
);