Merge tag 'ti-v2021.10-rc2' of https://source.denx.de/u-boot/custodians/u-boot-ti
[platform/kernel/u-boot.git] / test / dm / core.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Tests for the core driver model code
4  *
5  * Copyright (c) 2013 Google, Inc
6  */
7
8 #include <common.h>
9 #include <errno.h>
10 #include <dm.h>
11 #include <fdtdec.h>
12 #include <log.h>
13 #include <malloc.h>
14 #include <asm/global_data.h>
15 #include <dm/device-internal.h>
16 #include <dm/root.h>
17 #include <dm/util.h>
18 #include <dm/test.h>
19 #include <dm/uclass-internal.h>
20 #include <test/test.h>
21 #include <test/ut.h>
22
23 DECLARE_GLOBAL_DATA_PTR;
24
25 enum {
26         TEST_INTVAL1            = 0,
27         TEST_INTVAL2            = 3,
28         TEST_INTVAL3            = 6,
29         TEST_INTVAL_MANUAL      = 101112,
30         TEST_INTVAL_PRE_RELOC   = 7,
31 };
32
33 static const struct dm_test_pdata test_pdata[] = {
34         { .ping_add             = TEST_INTVAL1, },
35         { .ping_add             = TEST_INTVAL2, },
36         { .ping_add             = TEST_INTVAL3, },
37 };
38
39 static const struct dm_test_pdata test_pdata_manual = {
40         .ping_add               = TEST_INTVAL_MANUAL,
41 };
42
43 static const struct dm_test_pdata test_pdata_pre_reloc = {
44         .ping_add               = TEST_INTVAL_PRE_RELOC,
45 };
46
47 U_BOOT_DRVINFO(dm_test_info1) = {
48         .name = "test_drv",
49         .plat = &test_pdata[0],
50 };
51
52 U_BOOT_DRVINFO(dm_test_info2) = {
53         .name = "test_drv",
54         .plat = &test_pdata[1],
55 };
56
57 U_BOOT_DRVINFO(dm_test_info3) = {
58         .name = "test_drv",
59         .plat = &test_pdata[2],
60 };
61
62 static struct driver_info driver_info_manual = {
63         .name = "test_manual_drv",
64         .plat = &test_pdata_manual,
65 };
66
67 static struct driver_info driver_info_pre_reloc = {
68         .name = "test_pre_reloc_drv",
69         .plat = &test_pdata_pre_reloc,
70 };
71
72 static struct driver_info driver_info_act_dma = {
73         .name = "test_act_dma_drv",
74 };
75
76 static struct driver_info driver_info_vital_clk = {
77         .name = "test_vital_clk_drv",
78 };
79
80 static struct driver_info driver_info_act_dma_vital_clk = {
81         .name = "test_act_dma_vital_clk_drv",
82 };
83
84 void dm_leak_check_start(struct unit_test_state *uts)
85 {
86         uts->start = mallinfo();
87         if (!uts->start.uordblks)
88                 puts("Warning: Please add '#define DEBUG' to the top of common/dlmalloc.c\n");
89 }
90
91 int dm_leak_check_end(struct unit_test_state *uts)
92 {
93         struct mallinfo end;
94         int id, diff;
95
96         /* Don't delete the root class, since we started with that */
97         for (id = UCLASS_ROOT + 1; id < UCLASS_COUNT; id++) {
98                 struct uclass *uc;
99
100                 uc = uclass_find(id);
101                 if (!uc)
102                         continue;
103                 ut_assertok(uclass_destroy(uc));
104         }
105
106         end = mallinfo();
107         diff = end.uordblks - uts->start.uordblks;
108         if (diff > 0)
109                 printf("Leak: lost %#xd bytes\n", diff);
110         else if (diff < 0)
111                 printf("Leak: gained %#xd bytes\n", -diff);
112         ut_asserteq(uts->start.uordblks, end.uordblks);
113
114         return 0;
115 }
116
117 /* Test that binding with plat occurs correctly */
118 static int dm_test_autobind(struct unit_test_state *uts)
119 {
120         struct udevice *dev;
121
122         /*
123          * We should have a single class (UCLASS_ROOT) and a single root
124          * device with no children.
125          */
126         ut_assert(uts->root);
127         ut_asserteq(1, list_count_items(gd->uclass_root));
128         ut_asserteq(0, list_count_items(&gd->dm_root->child_head));
129         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_BIND]);
130
131         ut_assertok(dm_scan_plat(false));
132
133         /* We should have our test class now at least, plus more children */
134         ut_assert(1 < list_count_items(gd->uclass_root));
135         ut_assert(0 < list_count_items(&gd->dm_root->child_head));
136
137         /* Our 3 dm_test_infox children should be bound to the test uclass */
138         ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_POST_BIND]);
139
140         /* No devices should be probed */
141         list_for_each_entry(dev, &gd->dm_root->child_head, sibling_node)
142                 ut_assert(!(dev_get_flags(dev) & DM_FLAG_ACTIVATED));
143
144         /* Our test driver should have been bound 3 times */
145         ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND] == 3);
146
147         return 0;
148 }
149 DM_TEST(dm_test_autobind, 0);
150
151 /* Test that binding with uclass plat allocation occurs correctly */
152 static int dm_test_autobind_uclass_pdata_alloc(struct unit_test_state *uts)
153 {
154         struct dm_test_perdev_uc_pdata *uc_pdata;
155         struct udevice *dev;
156         struct uclass *uc;
157
158         ut_assertok(uclass_get(UCLASS_TEST, &uc));
159         ut_assert(uc);
160
161         /**
162          * Test if test uclass driver requires allocation for the uclass
163          * platform data and then check the dev->uclass_plat pointer.
164          */
165         ut_assert(uc->uc_drv->per_device_plat_auto);
166
167         for (uclass_find_first_device(UCLASS_TEST, &dev);
168              dev;
169              uclass_find_next_device(&dev)) {
170                 ut_assertnonnull(dev);
171
172                 uc_pdata = dev_get_uclass_plat(dev);
173                 ut_assert(uc_pdata);
174         }
175
176         return 0;
177 }
178 DM_TEST(dm_test_autobind_uclass_pdata_alloc, UT_TESTF_SCAN_PDATA);
179
180 /* compare node names ignoring the unit address */
181 static int dm_test_compare_node_name(struct unit_test_state *uts)
182 {
183         ofnode node;
184
185         node = ofnode_path("/mmio-bus@0");
186         ut_assert(ofnode_valid(node));
187         ut_assert(ofnode_name_eq(node, "mmio-bus"));
188
189         return 0;
190 }
191
192 DM_TEST(dm_test_compare_node_name, UT_TESTF_SCAN_PDATA);
193
194 /* Test that binding with uclass plat setting occurs correctly */
195 static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts)
196 {
197         struct dm_test_perdev_uc_pdata *uc_pdata;
198         struct udevice *dev;
199
200         /**
201          * In the test_postbind() method of test uclass driver, the uclass
202          * platform data should be set to three test int values - test it.
203          */
204         for (uclass_find_first_device(UCLASS_TEST, &dev);
205              dev;
206              uclass_find_next_device(&dev)) {
207                 ut_assertnonnull(dev);
208
209                 uc_pdata = dev_get_uclass_plat(dev);
210                 ut_assert(uc_pdata);
211                 ut_assert(uc_pdata->intval1 == TEST_UC_PDATA_INTVAL1);
212                 ut_assert(uc_pdata->intval2 == TEST_UC_PDATA_INTVAL2);
213                 ut_assert(uc_pdata->intval3 == TEST_UC_PDATA_INTVAL3);
214         }
215
216         return 0;
217 }
218 DM_TEST(dm_test_autobind_uclass_pdata_valid, UT_TESTF_SCAN_PDATA);
219
220 /* Test that autoprobe finds all the expected devices */
221 static int dm_test_autoprobe(struct unit_test_state *uts)
222 {
223         int expected_base_add;
224         struct udevice *dev;
225         struct uclass *uc;
226         int i;
227
228         ut_assertok(uclass_get(UCLASS_TEST, &uc));
229         ut_assert(uc);
230
231         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
232         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_PROBE]);
233         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]);
234
235         /* The root device should not be activated until needed */
236         ut_assert(dev_get_flags(uts->root) & DM_FLAG_ACTIVATED);
237
238         /*
239          * We should be able to find the three test devices, and they should
240          * all be activated as they are used (lazy activation, required by
241          * U-Boot)
242          */
243         for (i = 0; i < 3; i++) {
244                 ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
245                 ut_assert(dev);
246                 ut_assertf(!(dev_get_flags(dev) & DM_FLAG_ACTIVATED),
247                            "Driver %d/%s already activated", i, dev->name);
248
249                 /* This should activate it */
250                 ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev));
251                 ut_assert(dev);
252                 ut_assert(dev_get_flags(dev) & DM_FLAG_ACTIVATED);
253
254                 /* Activating a device should activate the root device */
255                 if (!i)
256                         ut_assert(dev_get_flags(uts->root) & DM_FLAG_ACTIVATED);
257         }
258
259         /*
260          * Our 3 dm_test_info children should be passed to pre_probe and
261          * post_probe
262          */
263         ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]);
264         ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_PRE_PROBE]);
265
266         /* Also we can check the per-device data */
267         expected_base_add = 0;
268         for (i = 0; i < 3; i++) {
269                 struct dm_test_uclass_perdev_priv *priv;
270                 struct dm_test_pdata *pdata;
271
272                 ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
273                 ut_assert(dev);
274
275                 priv = dev_get_uclass_priv(dev);
276                 ut_assert(priv);
277                 ut_asserteq(expected_base_add, priv->base_add);
278
279                 pdata = dev_get_plat(dev);
280                 expected_base_add += pdata->ping_add;
281         }
282
283         return 0;
284 }
285 DM_TEST(dm_test_autoprobe, UT_TESTF_SCAN_PDATA);
286
287 /* Check that we see the correct plat in each device */
288 static int dm_test_plat(struct unit_test_state *uts)
289 {
290         const struct dm_test_pdata *pdata;
291         struct udevice *dev;
292         int i;
293
294         for (i = 0; i < 3; i++) {
295                 ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
296                 ut_assert(dev);
297                 pdata = dev_get_plat(dev);
298                 ut_assert(pdata->ping_add == test_pdata[i].ping_add);
299         }
300
301         return 0;
302 }
303 DM_TEST(dm_test_plat, UT_TESTF_SCAN_PDATA);
304
305 /* Test that we can bind, probe, remove, unbind a driver */
306 static int dm_test_lifecycle(struct unit_test_state *uts)
307 {
308         int op_count[DM_TEST_OP_COUNT];
309         struct udevice *dev, *test_dev;
310         int pingret;
311         int ret;
312
313         memcpy(op_count, dm_testdrv_op_count, sizeof(op_count));
314
315         ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
316                                         &dev));
317         ut_assert(dev);
318         ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND]
319                         == op_count[DM_TEST_OP_BIND] + 1);
320         ut_assert(!dev_get_priv(dev));
321
322         /* Probe the device - it should fail allocating private data */
323         uts->force_fail_alloc = 1;
324         ret = device_probe(dev);
325         ut_assert(ret == -ENOMEM);
326         ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE]
327                         == op_count[DM_TEST_OP_PROBE] + 1);
328         ut_assert(!dev_get_priv(dev));
329
330         /* Try again without the alloc failure */
331         uts->force_fail_alloc = 0;
332         ut_assertok(device_probe(dev));
333         ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE]
334                         == op_count[DM_TEST_OP_PROBE] + 2);
335         ut_assert(dev_get_priv(dev));
336
337         /* This should be device 3 in the uclass */
338         ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
339         ut_assert(dev == test_dev);
340
341         /* Try ping */
342         ut_assertok(test_ping(dev, 100, &pingret));
343         ut_assert(pingret == 102);
344
345         /* Now remove device 3 */
346         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]);
347         ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
348         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]);
349
350         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
351         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]);
352         ut_assertok(device_unbind(dev));
353         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
354         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]);
355
356         return 0;
357 }
358 DM_TEST(dm_test_lifecycle, UT_TESTF_SCAN_PDATA | UT_TESTF_PROBE_TEST);
359
360 /* Test that we can bind/unbind and the lists update correctly */
361 static int dm_test_ordering(struct unit_test_state *uts)
362 {
363         struct udevice *dev, *dev_penultimate, *dev_last, *test_dev;
364         int pingret;
365
366         ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
367                                         &dev));
368         ut_assert(dev);
369
370         /* Bind two new devices (numbers 4 and 5) */
371         ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
372                                         &dev_penultimate));
373         ut_assert(dev_penultimate);
374         ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
375                                         &dev_last));
376         ut_assert(dev_last);
377
378         /* Now remove device 3 */
379         ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
380         ut_assertok(device_unbind(dev));
381
382         /* The device numbering should have shifted down one */
383         ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
384         ut_assert(dev_penultimate == test_dev);
385         ut_assertok(uclass_find_device(UCLASS_TEST, 4, &test_dev));
386         ut_assert(dev_last == test_dev);
387
388         /* Add back the original device 3, now in position 5 */
389         ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
390                                         &dev));
391         ut_assert(dev);
392
393         /* Try ping */
394         ut_assertok(test_ping(dev, 100, &pingret));
395         ut_assert(pingret == 102);
396
397         /* Remove 3 and 4 */
398         ut_assertok(device_remove(dev_penultimate, DM_REMOVE_NORMAL));
399         ut_assertok(device_unbind(dev_penultimate));
400         ut_assertok(device_remove(dev_last, DM_REMOVE_NORMAL));
401         ut_assertok(device_unbind(dev_last));
402
403         /* Our device should now be in position 3 */
404         ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
405         ut_assert(dev == test_dev);
406
407         /* Now remove device 3 */
408         ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
409         ut_assertok(device_unbind(dev));
410
411         return 0;
412 }
413 DM_TEST(dm_test_ordering, UT_TESTF_SCAN_PDATA);
414
415 /* Check that we can perform operations on a device (do a ping) */
416 int dm_check_operations(struct unit_test_state *uts, struct udevice *dev,
417                         uint32_t base, struct dm_test_priv *priv)
418 {
419         int expected;
420         int pingret;
421
422         /* Getting the child device should allocate plat / priv */
423         ut_assertok(testfdt_ping(dev, 10, &pingret));
424         ut_assert(dev_get_priv(dev));
425         ut_assert(dev_get_plat(dev));
426
427         expected = 10 + base;
428         ut_asserteq(expected, pingret);
429
430         /* Do another ping */
431         ut_assertok(testfdt_ping(dev, 20, &pingret));
432         expected = 20 + base;
433         ut_asserteq(expected, pingret);
434
435         /* Now check the ping_total */
436         priv = dev_get_priv(dev);
437         ut_asserteq(DM_TEST_START_TOTAL + 10 + 20 + base * 2,
438                     priv->ping_total);
439
440         return 0;
441 }
442
443 /* Check that we can perform operations on devices */
444 static int dm_test_operations(struct unit_test_state *uts)
445 {
446         struct udevice *dev;
447         int i;
448
449         /*
450          * Now check that the ping adds are what we expect. This is using the
451          * ping-add property in each node.
452          */
453         for (i = 0; i < ARRAY_SIZE(test_pdata); i++) {
454                 uint32_t base;
455
456                 ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev));
457
458                 /*
459                  * Get the 'reg' property, which tells us what the ping add
460                  * should be. We don't use the plat because we want
461                  * to test the code that sets that up (testfdt_drv_probe()).
462                  */
463                 base = test_pdata[i].ping_add;
464                 debug("dev=%d, base=%d\n", i, base);
465
466                 ut_assert(!dm_check_operations(uts, dev, base, dev_get_priv(dev)));
467         }
468
469         return 0;
470 }
471 DM_TEST(dm_test_operations, UT_TESTF_SCAN_PDATA);
472
473 /* Remove all drivers and check that things work */
474 static int dm_test_remove(struct unit_test_state *uts)
475 {
476         struct udevice *dev;
477         int i;
478
479         for (i = 0; i < 3; i++) {
480                 ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
481                 ut_assert(dev);
482                 ut_assertf(dev_get_flags(dev) & DM_FLAG_ACTIVATED,
483                            "Driver %d/%s not activated", i, dev->name);
484                 ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
485                 ut_assertf(!(dev_get_flags(dev) & DM_FLAG_ACTIVATED),
486                            "Driver %d/%s should have deactivated", i,
487                            dev->name);
488                 ut_assert(!dev_get_priv(dev));
489         }
490
491         return 0;
492 }
493 DM_TEST(dm_test_remove, UT_TESTF_SCAN_PDATA | UT_TESTF_PROBE_TEST);
494
495 /* Remove and recreate everything, check for memory leaks */
496 static int dm_test_leak(struct unit_test_state *uts)
497 {
498         int i;
499
500         for (i = 0; i < 2; i++) {
501                 struct udevice *dev;
502                 int ret;
503                 int id;
504
505                 dm_leak_check_start(uts);
506
507                 ut_assertok(dm_scan_plat(false));
508                 ut_assertok(dm_scan_fdt(false));
509
510                 /* Scanning the uclass is enough to probe all the devices */
511                 for (id = UCLASS_ROOT; id < UCLASS_COUNT; id++) {
512                         for (ret = uclass_first_device(UCLASS_TEST, &dev);
513                              dev;
514                              ret = uclass_next_device(&dev))
515                                 ;
516                         ut_assertok(ret);
517                 }
518
519                 ut_assertok(dm_leak_check_end(uts));
520         }
521
522         return 0;
523 }
524 DM_TEST(dm_test_leak, 0);
525
526 /* Test uclass init/destroy methods */
527 static int dm_test_uclass(struct unit_test_state *uts)
528 {
529         struct uclass *uc;
530
531         ut_assertok(uclass_get(UCLASS_TEST, &uc));
532         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
533         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_DESTROY]);
534         ut_assert(uclass_get_priv(uc));
535
536         ut_assertok(uclass_destroy(uc));
537         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
538         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_DESTROY]);
539
540         return 0;
541 }
542 DM_TEST(dm_test_uclass, 0);
543
544 /**
545  * create_children() - Create children of a parent node
546  *
547  * @dms:        Test system state
548  * @parent:     Parent device
549  * @count:      Number of children to create
550  * @key:        Key value to put in first child. Subsequence children
551  *              receive an incrementing value
552  * @child:      If not NULL, then the child device pointers are written into
553  *              this array.
554  * @return 0 if OK, -ve on error
555  */
556 static int create_children(struct unit_test_state *uts, struct udevice *parent,
557                            int count, int key, struct udevice *child[])
558 {
559         struct udevice *dev;
560         int i;
561
562         for (i = 0; i < count; i++) {
563                 struct dm_test_pdata *pdata;
564
565                 ut_assertok(device_bind_by_name(parent, false,
566                                                 &driver_info_manual, &dev));
567                 pdata = calloc(1, sizeof(*pdata));
568                 pdata->ping_add = key + i;
569                 dev_set_plat(dev, pdata);
570                 if (child)
571                         child[i] = dev;
572         }
573
574         return 0;
575 }
576
577 #define NODE_COUNT      10
578
579 static int dm_test_children(struct unit_test_state *uts)
580 {
581         struct udevice *top[NODE_COUNT];
582         struct udevice *child[NODE_COUNT];
583         struct udevice *grandchild[NODE_COUNT];
584         struct udevice *dev;
585         int total;
586         int ret;
587         int i;
588
589         /* We don't care about the numbering for this test */
590         uts->skip_post_probe = 1;
591
592         ut_assert(NODE_COUNT > 5);
593
594         /* First create 10 top-level children */
595         ut_assertok(create_children(uts, uts->root, NODE_COUNT, 0, top));
596
597         /* Now a few have their own children */
598         ut_assertok(create_children(uts, top[2], NODE_COUNT, 2, NULL));
599         ut_assertok(create_children(uts, top[5], NODE_COUNT, 5, child));
600
601         /* And grandchildren */
602         for (i = 0; i < NODE_COUNT; i++)
603                 ut_assertok(create_children(uts, child[i], NODE_COUNT, 50 * i,
604                                             i == 2 ? grandchild : NULL));
605
606         /* Check total number of devices */
607         total = NODE_COUNT * (3 + NODE_COUNT);
608         ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_BIND]);
609
610         /* Try probing one of the grandchildren */
611         ut_assertok(uclass_get_device(UCLASS_TEST,
612                                       NODE_COUNT * 3 + 2 * NODE_COUNT, &dev));
613         ut_asserteq_ptr(grandchild[0], dev);
614
615         /*
616          * This should have probed the child and top node also, for a total
617          * of 3 nodes.
618          */
619         ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
620
621         /* Probe the other grandchildren */
622         for (i = 1; i < NODE_COUNT; i++)
623                 ut_assertok(device_probe(grandchild[i]));
624
625         ut_asserteq(2 + NODE_COUNT, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
626
627         /* Probe everything */
628         for (ret = uclass_first_device(UCLASS_TEST, &dev);
629              dev;
630              ret = uclass_next_device(&dev))
631                 ;
632         ut_assertok(ret);
633
634         ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
635
636         /* Remove a top-level child and check that the children are removed */
637         ut_assertok(device_remove(top[2], DM_REMOVE_NORMAL));
638         ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_REMOVE]);
639         dm_testdrv_op_count[DM_TEST_OP_REMOVE] = 0;
640
641         /* Try one with grandchildren */
642         ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev));
643         ut_asserteq_ptr(dev, top[5]);
644         ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
645         ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT),
646                     dm_testdrv_op_count[DM_TEST_OP_REMOVE]);
647
648         /* Try the same with unbind */
649         ut_assertok(device_unbind(top[2]));
650         ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
651         dm_testdrv_op_count[DM_TEST_OP_UNBIND] = 0;
652
653         /* Try one with grandchildren */
654         ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev));
655         ut_asserteq_ptr(dev, top[6]);
656         ut_assertok(device_unbind(top[5]));
657         ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT),
658                     dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
659
660         return 0;
661 }
662 DM_TEST(dm_test_children, 0);
663
664 static int dm_test_device_reparent(struct unit_test_state *uts)
665 {
666         struct udevice *top[NODE_COUNT];
667         struct udevice *child[NODE_COUNT];
668         struct udevice *grandchild[NODE_COUNT];
669         struct udevice *dev;
670         int total;
671         int ret;
672         int i;
673
674         /* We don't care about the numbering for this test */
675         uts->skip_post_probe = 1;
676
677         ut_assert(NODE_COUNT > 5);
678
679         /* First create 10 top-level children */
680         ut_assertok(create_children(uts, uts->root, NODE_COUNT, 0, top));
681
682         /* Now a few have their own children */
683         ut_assertok(create_children(uts, top[2], NODE_COUNT, 2, NULL));
684         ut_assertok(create_children(uts, top[5], NODE_COUNT, 5, child));
685
686         /* And grandchildren */
687         for (i = 0; i < NODE_COUNT; i++)
688                 ut_assertok(create_children(uts, child[i], NODE_COUNT, 50 * i,
689                                             i == 2 ? grandchild : NULL));
690
691         /* Check total number of devices */
692         total = NODE_COUNT * (3 + NODE_COUNT);
693         ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_BIND]);
694
695         /* Probe everything */
696         for (i = 0; i < total; i++)
697                 ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev));
698
699         /* Re-parent top-level children with no grandchildren. */
700         ut_assertok(device_reparent(top[3], top[0]));
701         /* try to get devices */
702         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
703              dev;
704              ret = uclass_find_next_device(&dev)) {
705                 ut_assert(!ret);
706                 ut_assertnonnull(dev);
707         }
708
709         ut_assertok(device_reparent(top[4], top[0]));
710         /* try to get devices */
711         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
712              dev;
713              ret = uclass_find_next_device(&dev)) {
714                 ut_assert(!ret);
715                 ut_assertnonnull(dev);
716         }
717
718         /* Re-parent top-level children with grandchildren. */
719         ut_assertok(device_reparent(top[2], top[0]));
720         /* try to get devices */
721         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
722              dev;
723              ret = uclass_find_next_device(&dev)) {
724                 ut_assert(!ret);
725                 ut_assertnonnull(dev);
726         }
727
728         ut_assertok(device_reparent(top[5], top[2]));
729         /* try to get devices */
730         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
731              dev;
732              ret = uclass_find_next_device(&dev)) {
733                 ut_assert(!ret);
734                 ut_assertnonnull(dev);
735         }
736
737         /* Re-parent grandchildren. */
738         ut_assertok(device_reparent(grandchild[0], top[1]));
739         /* try to get devices */
740         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
741              dev;
742              ret = uclass_find_next_device(&dev)) {
743                 ut_assert(!ret);
744                 ut_assertnonnull(dev);
745         }
746
747         ut_assertok(device_reparent(grandchild[1], top[1]));
748         /* try to get devices */
749         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
750              dev;
751              ret = uclass_find_next_device(&dev)) {
752                 ut_assert(!ret);
753                 ut_assertnonnull(dev);
754         }
755
756         /* Remove re-pareneted devices. */
757         ut_assertok(device_remove(top[3], DM_REMOVE_NORMAL));
758         /* try to get devices */
759         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
760              dev;
761              ret = uclass_find_next_device(&dev)) {
762                 ut_assert(!ret);
763                 ut_assertnonnull(dev);
764         }
765
766         ut_assertok(device_remove(top[4], DM_REMOVE_NORMAL));
767         /* try to get devices */
768         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
769              dev;
770              ret = uclass_find_next_device(&dev)) {
771                 ut_assert(!ret);
772                 ut_assertnonnull(dev);
773         }
774
775         ut_assertok(device_remove(top[5], DM_REMOVE_NORMAL));
776         /* try to get devices */
777         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
778              dev;
779              ret = uclass_find_next_device(&dev)) {
780                 ut_assert(!ret);
781                 ut_assertnonnull(dev);
782         }
783
784         ut_assertok(device_remove(top[2], DM_REMOVE_NORMAL));
785         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
786              dev;
787              ret = uclass_find_next_device(&dev)) {
788                 ut_assert(!ret);
789                 ut_assertnonnull(dev);
790         }
791
792         ut_assertok(device_remove(grandchild[0], DM_REMOVE_NORMAL));
793         /* try to get devices */
794         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
795              dev;
796              ret = uclass_find_next_device(&dev)) {
797                 ut_assert(!ret);
798                 ut_assertnonnull(dev);
799         }
800
801         ut_assertok(device_remove(grandchild[1], DM_REMOVE_NORMAL));
802         /* try to get devices */
803         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
804              dev;
805              ret = uclass_find_next_device(&dev)) {
806                 ut_assert(!ret);
807                 ut_assertnonnull(dev);
808         }
809
810         /* Try the same with unbind */
811         ut_assertok(device_unbind(top[3]));
812         ut_assertok(device_unbind(top[4]));
813         ut_assertok(device_unbind(top[5]));
814         ut_assertok(device_unbind(top[2]));
815
816         ut_assertok(device_unbind(grandchild[0]));
817         ut_assertok(device_unbind(grandchild[1]));
818
819         return 0;
820 }
821 DM_TEST(dm_test_device_reparent, 0);
822
823 /* Test that pre-relocation devices work as expected */
824 static int dm_test_pre_reloc(struct unit_test_state *uts)
825 {
826         struct udevice *dev;
827
828         /* The normal driver should refuse to bind before relocation */
829         ut_asserteq(-EPERM, device_bind_by_name(uts->root, true,
830                                                 &driver_info_manual, &dev));
831
832         /* But this one is marked pre-reloc */
833         ut_assertok(device_bind_by_name(uts->root, true,
834                                         &driver_info_pre_reloc, &dev));
835
836         return 0;
837 }
838 DM_TEST(dm_test_pre_reloc, 0);
839
840 /*
841  * Test that removal of devices, either via the "normal" device_remove()
842  * API or via the device driver selective flag works as expected
843  */
844 static int dm_test_remove_active_dma(struct unit_test_state *uts)
845 {
846         struct udevice *dev;
847
848         ut_assertok(device_bind_by_name(uts->root, false, &driver_info_act_dma,
849                                         &dev));
850         ut_assert(dev);
851
852         /* Probe the device */
853         ut_assertok(device_probe(dev));
854
855         /* Test if device is active right now */
856         ut_asserteq(true, device_active(dev));
857
858         /* Remove the device via selective remove flag */
859         dm_remove_devices_flags(DM_REMOVE_ACTIVE_ALL);
860
861         /* Test if device is inactive right now */
862         ut_asserteq(false, device_active(dev));
863
864         /* Probe the device again */
865         ut_assertok(device_probe(dev));
866
867         /* Test if device is active right now */
868         ut_asserteq(true, device_active(dev));
869
870         /* Remove the device via "normal" remove API */
871         ut_assertok(device_remove(dev, DM_REMOVE_NORMAL));
872
873         /* Test if device is inactive right now */
874         ut_asserteq(false, device_active(dev));
875
876         /*
877          * Test if a device without the active DMA flags is not removed upon
878          * the active DMA remove call
879          */
880         ut_assertok(device_unbind(dev));
881         ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
882                                         &dev));
883         ut_assert(dev);
884
885         /* Probe the device */
886         ut_assertok(device_probe(dev));
887
888         /* Test if device is active right now */
889         ut_asserteq(true, device_active(dev));
890
891         /* Remove the device via selective remove flag */
892         dm_remove_devices_flags(DM_REMOVE_ACTIVE_ALL);
893
894         /* Test if device is still active right now */
895         ut_asserteq(true, device_active(dev));
896
897         return 0;
898 }
899 DM_TEST(dm_test_remove_active_dma, 0);
900
901 /* Test removal of 'vital' devices */
902 static int dm_test_remove_vital(struct unit_test_state *uts)
903 {
904         struct udevice *normal, *dma, *vital, *dma_vital;
905
906         /* Skip the behaviour in test_post_probe() */
907         uts->skip_post_probe = 1;
908
909         ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
910                                         &normal));
911         ut_assertnonnull(normal);
912
913         ut_assertok(device_bind_by_name(uts->root, false, &driver_info_act_dma,
914                                         &dma));
915         ut_assertnonnull(dma);
916
917         ut_assertok(device_bind_by_name(uts->root, false,
918                                         &driver_info_vital_clk, &vital));
919         ut_assertnonnull(vital);
920
921         ut_assertok(device_bind_by_name(uts->root, false,
922                                         &driver_info_act_dma_vital_clk,
923                                         &dma_vital));
924         ut_assertnonnull(dma_vital);
925
926         /* Probe the devices */
927         ut_assertok(device_probe(normal));
928         ut_assertok(device_probe(dma));
929         ut_assertok(device_probe(vital));
930         ut_assertok(device_probe(dma_vital));
931
932         /* Check that devices are active right now */
933         ut_asserteq(true, device_active(normal));
934         ut_asserteq(true, device_active(dma));
935         ut_asserteq(true, device_active(vital));
936         ut_asserteq(true, device_active(dma_vital));
937
938         /* Remove active devices via selective remove flag */
939         dm_remove_devices_flags(DM_REMOVE_NON_VITAL | DM_REMOVE_ACTIVE_ALL);
940
941         /*
942          * Check that this only has an effect on the dma device, since two
943          * devices are vital and the third does not have active DMA
944          */
945         ut_asserteq(true, device_active(normal));
946         ut_asserteq(false, device_active(dma));
947         ut_asserteq(true, device_active(vital));
948         ut_asserteq(true, device_active(dma_vital));
949
950         /* Remove active devices via selective remove flag */
951         ut_assertok(device_probe(dma));
952         dm_remove_devices_flags(DM_REMOVE_ACTIVE_ALL);
953
954         /* This should have affected both active-dma devices */
955         ut_asserteq(true, device_active(normal));
956         ut_asserteq(false, device_active(dma));
957         ut_asserteq(true, device_active(vital));
958         ut_asserteq(false, device_active(dma_vital));
959
960         /* Remove non-vital devices */
961         ut_assertok(device_probe(dma));
962         ut_assertok(device_probe(dma_vital));
963         dm_remove_devices_flags(DM_REMOVE_NON_VITAL);
964
965         /* This should have affected only non-vital devices */
966         ut_asserteq(false, device_active(normal));
967         ut_asserteq(false, device_active(dma));
968         ut_asserteq(true, device_active(vital));
969         ut_asserteq(true, device_active(dma_vital));
970
971         /* Remove vital devices via normal remove flag */
972         ut_assertok(device_probe(normal));
973         ut_assertok(device_probe(dma));
974         dm_remove_devices_flags(DM_REMOVE_NORMAL);
975
976         /* Check that all devices are inactive right now */
977         ut_asserteq(false, device_active(normal));
978         ut_asserteq(false, device_active(dma));
979         ut_asserteq(false, device_active(vital));
980         ut_asserteq(false, device_active(dma_vital));
981
982         return 0;
983 }
984 DM_TEST(dm_test_remove_vital, 0);
985
986 static int dm_test_uclass_before_ready(struct unit_test_state *uts)
987 {
988         struct uclass *uc;
989
990         ut_assertok(uclass_get(UCLASS_TEST, &uc));
991
992         gd->dm_root = NULL;
993         gd->dm_root_f = NULL;
994         memset(&gd->uclass_root, '\0', sizeof(gd->uclass_root));
995
996         ut_asserteq_ptr(NULL, uclass_find(UCLASS_TEST));
997
998         return 0;
999 }
1000 DM_TEST(dm_test_uclass_before_ready, 0);
1001
1002 static int dm_test_uclass_devices_find(struct unit_test_state *uts)
1003 {
1004         struct udevice *dev;
1005         int ret;
1006
1007         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
1008              dev;
1009              ret = uclass_find_next_device(&dev)) {
1010                 ut_assert(!ret);
1011                 ut_assertnonnull(dev);
1012         }
1013
1014         ut_assertok(uclass_find_first_device(UCLASS_TEST_DUMMY, &dev));
1015         ut_assertnull(dev);
1016
1017         return 0;
1018 }
1019 DM_TEST(dm_test_uclass_devices_find, UT_TESTF_SCAN_PDATA);
1020
1021 static int dm_test_uclass_devices_find_by_name(struct unit_test_state *uts)
1022 {
1023         struct udevice *finddev;
1024         struct udevice *testdev;
1025         int findret, ret;
1026
1027         /*
1028          * For each test device found in fdt like: "a-test", "b-test", etc.,
1029          * use its name and try to find it by uclass_find_device_by_name().
1030          * Then, on success check if:
1031          * - current 'testdev' name is equal to the returned 'finddev' name
1032          * - current 'testdev' pointer is equal to the returned 'finddev'
1033          *
1034          * We assume that, each uclass's device name is unique, so if not, then
1035          * this will fail on checking condition: testdev == finddev, since the
1036          * uclass_find_device_by_name(), returns the first device by given name.
1037         */
1038         for (ret = uclass_find_first_device(UCLASS_TEST_FDT, &testdev);
1039              testdev;
1040              ret = uclass_find_next_device(&testdev)) {
1041                 ut_assertok(ret);
1042                 ut_assertnonnull(testdev);
1043
1044                 findret = uclass_find_device_by_name(UCLASS_TEST_FDT,
1045                                                      testdev->name,
1046                                                      &finddev);
1047
1048                 ut_assertok(findret);
1049                 ut_assert(testdev);
1050                 ut_asserteq_str(testdev->name, finddev->name);
1051                 ut_asserteq_ptr(testdev, finddev);
1052         }
1053
1054         return 0;
1055 }
1056 DM_TEST(dm_test_uclass_devices_find_by_name, UT_TESTF_SCAN_FDT);
1057
1058 static int dm_test_uclass_devices_get(struct unit_test_state *uts)
1059 {
1060         struct udevice *dev;
1061         int ret;
1062
1063         for (ret = uclass_first_device(UCLASS_TEST, &dev);
1064              dev;
1065              ret = uclass_next_device(&dev)) {
1066                 ut_assert(!ret);
1067                 ut_assert(dev);
1068                 ut_assert(device_active(dev));
1069         }
1070
1071         return 0;
1072 }
1073 DM_TEST(dm_test_uclass_devices_get, UT_TESTF_SCAN_PDATA);
1074
1075 static int dm_test_uclass_devices_get_by_name(struct unit_test_state *uts)
1076 {
1077         struct udevice *finddev;
1078         struct udevice *testdev;
1079         int ret, findret;
1080
1081         /*
1082          * For each test device found in fdt like: "a-test", "b-test", etc.,
1083          * use its name and try to get it by uclass_get_device_by_name().
1084          * On success check if:
1085          * - returned finddev' is active
1086          * - current 'testdev' name is equal to the returned 'finddev' name
1087          * - current 'testdev' pointer is equal to the returned 'finddev'
1088          *
1089          * We asserts that the 'testdev' is active on each loop entry, so we
1090          * could be sure that the 'finddev' is activated too, but for sure
1091          * we check it again.
1092          *
1093          * We assume that, each uclass's device name is unique, so if not, then
1094          * this will fail on checking condition: testdev == finddev, since the
1095          * uclass_get_device_by_name(), returns the first device by given name.
1096         */
1097         for (ret = uclass_first_device(UCLASS_TEST_FDT, &testdev);
1098              testdev;
1099              ret = uclass_next_device(&testdev)) {
1100                 ut_assertok(ret);
1101                 ut_assert(testdev);
1102                 ut_assert(device_active(testdev));
1103
1104                 findret = uclass_get_device_by_name(UCLASS_TEST_FDT,
1105                                                     testdev->name,
1106                                                     &finddev);
1107
1108                 ut_assertok(findret);
1109                 ut_assert(finddev);
1110                 ut_assert(device_active(finddev));
1111                 ut_asserteq_str(testdev->name, finddev->name);
1112                 ut_asserteq_ptr(testdev, finddev);
1113         }
1114
1115         return 0;
1116 }
1117 DM_TEST(dm_test_uclass_devices_get_by_name, UT_TESTF_SCAN_FDT);
1118
1119 static int dm_test_device_get_uclass_id(struct unit_test_state *uts)
1120 {
1121         struct udevice *dev;
1122
1123         ut_assertok(uclass_get_device(UCLASS_TEST, 0, &dev));
1124         ut_asserteq(UCLASS_TEST, device_get_uclass_id(dev));
1125
1126         return 0;
1127 }
1128 DM_TEST(dm_test_device_get_uclass_id, UT_TESTF_SCAN_PDATA);
1129
1130 static int dm_test_uclass_names(struct unit_test_state *uts)
1131 {
1132         ut_asserteq_str("test", uclass_get_name(UCLASS_TEST));
1133         ut_asserteq(UCLASS_TEST, uclass_get_by_name("test"));
1134
1135         return 0;
1136 }
1137 DM_TEST(dm_test_uclass_names, UT_TESTF_SCAN_PDATA);
1138
1139 static int dm_test_inactive_child(struct unit_test_state *uts)
1140 {
1141         struct udevice *parent, *dev1, *dev2;
1142
1143         /* Skip the behaviour in test_post_probe() */
1144         uts->skip_post_probe = 1;
1145
1146         ut_assertok(uclass_first_device_err(UCLASS_TEST, &parent));
1147
1148         /*
1149          * Create a child but do not activate it. Calling the function again
1150          * should return the same child.
1151          */
1152         ut_asserteq(-ENODEV, device_find_first_inactive_child(parent,
1153                                                         UCLASS_TEST, &dev1));
1154         ut_assertok(device_bind(parent, DM_DRIVER_GET(test_drv),
1155                                 "test_child", 0, ofnode_null(), &dev1));
1156
1157         ut_assertok(device_find_first_inactive_child(parent, UCLASS_TEST,
1158                                                      &dev2));
1159         ut_asserteq_ptr(dev1, dev2);
1160
1161         ut_assertok(device_probe(dev1));
1162         ut_asserteq(-ENODEV, device_find_first_inactive_child(parent,
1163                                                         UCLASS_TEST, &dev2));
1164
1165         return 0;
1166 }
1167 DM_TEST(dm_test_inactive_child, UT_TESTF_SCAN_PDATA);
1168
1169 /* Make sure all bound devices have a sequence number */
1170 static int dm_test_all_have_seq(struct unit_test_state *uts)
1171 {
1172         struct udevice *dev;
1173         struct uclass *uc;
1174
1175         list_for_each_entry(uc, gd->uclass_root, sibling_node) {
1176                 list_for_each_entry(dev, &uc->dev_head, uclass_node) {
1177                         if (dev->seq_ == -1)
1178                                 printf("Device '%s' has no seq (%d)\n",
1179                                        dev->name, dev->seq_);
1180                         ut_assert(dev->seq_ != -1);
1181                 }
1182         }
1183
1184         return 0;
1185 }
1186 DM_TEST(dm_test_all_have_seq, UT_TESTF_SCAN_PDATA);
1187
1188 #if CONFIG_IS_ENABLED(DM_DMA)
1189 static int dm_test_dma_offset(struct unit_test_state *uts)
1190 {
1191        struct udevice *dev;
1192        ofnode node;
1193
1194        /* Make sure the bus's dma-ranges aren't taken into account here */
1195        node = ofnode_path("/mmio-bus@0");
1196        ut_assert(ofnode_valid(node));
1197        ut_assertok(uclass_get_device_by_ofnode(UCLASS_TEST_BUS, node, &dev));
1198        ut_asserteq_64(0, dev->dma_offset);
1199
1200        /* Device behind a bus with dma-ranges */
1201        node = ofnode_path("/mmio-bus@0/subnode@0");
1202        ut_assert(ofnode_valid(node));
1203        ut_assertok(uclass_get_device_by_ofnode(UCLASS_TEST_FDT, node, &dev));
1204        ut_asserteq_64(-0x10000000ULL, dev->dma_offset);
1205
1206        /* This one has no dma-ranges */
1207        node = ofnode_path("/mmio-bus@1");
1208        ut_assert(ofnode_valid(node));
1209        ut_assertok(uclass_get_device_by_ofnode(UCLASS_TEST_BUS, node, &dev));
1210        node = ofnode_path("/mmio-bus@1/subnode@0");
1211        ut_assert(ofnode_valid(node));
1212        ut_assertok(uclass_get_device_by_ofnode(UCLASS_TEST_FDT, node, &dev));
1213        ut_asserteq_64(0, dev->dma_offset);
1214
1215        return 0;
1216 }
1217 DM_TEST(dm_test_dma_offset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
1218 #endif