]> git.sur5r.net Git - u-boot/blob - test/dm/core.c
arm: mvebu: Disable L2 cache before enabling d-cache
[u-boot] / test / dm / core.c
1 /*
2  * Tests for the core driver model code
3  *
4  * Copyright (c) 2013 Google, Inc
5  *
6  * SPDX-License-Identifier:     GPL-2.0+
7  */
8
9 #include <common.h>
10 #include <errno.h>
11 #include <dm.h>
12 #include <fdtdec.h>
13 #include <malloc.h>
14 #include <dm/device-internal.h>
15 #include <dm/root.h>
16 #include <dm/util.h>
17 #include <dm/test.h>
18 #include <dm/uclass-internal.h>
19 #include <test/ut.h>
20
21 DECLARE_GLOBAL_DATA_PTR;
22
23 enum {
24         TEST_INTVAL1            = 0,
25         TEST_INTVAL2            = 3,
26         TEST_INTVAL3            = 6,
27         TEST_INTVAL_MANUAL      = 101112,
28         TEST_INTVAL_PRE_RELOC   = 7,
29 };
30
31 static const struct dm_test_pdata test_pdata[] = {
32         { .ping_add             = TEST_INTVAL1, },
33         { .ping_add             = TEST_INTVAL2, },
34         { .ping_add             = TEST_INTVAL3, },
35 };
36
37 static const struct dm_test_pdata test_pdata_manual = {
38         .ping_add               = TEST_INTVAL_MANUAL,
39 };
40
41 static const struct dm_test_pdata test_pdata_pre_reloc = {
42         .ping_add               = TEST_INTVAL_PRE_RELOC,
43 };
44
45 U_BOOT_DEVICE(dm_test_info1) = {
46         .name = "test_drv",
47         .platdata = &test_pdata[0],
48 };
49
50 U_BOOT_DEVICE(dm_test_info2) = {
51         .name = "test_drv",
52         .platdata = &test_pdata[1],
53 };
54
55 U_BOOT_DEVICE(dm_test_info3) = {
56         .name = "test_drv",
57         .platdata = &test_pdata[2],
58 };
59
60 static struct driver_info driver_info_manual = {
61         .name = "test_manual_drv",
62         .platdata = &test_pdata_manual,
63 };
64
65 static struct driver_info driver_info_pre_reloc = {
66         .name = "test_pre_reloc_drv",
67         .platdata = &test_pdata_manual,
68 };
69
70 void dm_leak_check_start(struct unit_test_state *uts)
71 {
72         uts->start = mallinfo();
73         if (!uts->start.uordblks)
74                 puts("Warning: Please add '#define DEBUG' to the top of common/dlmalloc.c\n");
75 }
76
77 int dm_leak_check_end(struct unit_test_state *uts)
78 {
79         struct mallinfo end;
80         int id;
81
82         /* Don't delete the root class, since we started with that */
83         for (id = UCLASS_ROOT + 1; id < UCLASS_COUNT; id++) {
84                 struct uclass *uc;
85
86                 uc = uclass_find(id);
87                 if (!uc)
88                         continue;
89                 ut_assertok(uclass_destroy(uc));
90         }
91
92         end = mallinfo();
93         ut_asserteq(uts->start.uordblks, end.uordblks);
94
95         return 0;
96 }
97
98 /* Test that binding with platdata occurs correctly */
99 static int dm_test_autobind(struct unit_test_state *uts)
100 {
101         struct dm_test_state *dms = uts->priv;
102         struct udevice *dev;
103
104         /*
105          * We should have a single class (UCLASS_ROOT) and a single root
106          * device with no children.
107          */
108         ut_assert(dms->root);
109         ut_asserteq(1, list_count_items(&gd->uclass_root));
110         ut_asserteq(0, list_count_items(&gd->dm_root->child_head));
111         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_BIND]);
112
113         ut_assertok(dm_scan_platdata(false));
114
115         /* We should have our test class now at least, plus more children */
116         ut_assert(1 < list_count_items(&gd->uclass_root));
117         ut_assert(0 < list_count_items(&gd->dm_root->child_head));
118
119         /* Our 3 dm_test_infox children should be bound to the test uclass */
120         ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_POST_BIND]);
121
122         /* No devices should be probed */
123         list_for_each_entry(dev, &gd->dm_root->child_head, sibling_node)
124                 ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
125
126         /* Our test driver should have been bound 3 times */
127         ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND] == 3);
128
129         return 0;
130 }
131 DM_TEST(dm_test_autobind, 0);
132
133 /* Test that binding with uclass platdata allocation occurs correctly */
134 static int dm_test_autobind_uclass_pdata_alloc(struct unit_test_state *uts)
135 {
136         struct dm_test_perdev_uc_pdata *uc_pdata;
137         struct udevice *dev;
138         struct uclass *uc;
139
140         ut_assertok(uclass_get(UCLASS_TEST, &uc));
141         ut_assert(uc);
142
143         /**
144          * Test if test uclass driver requires allocation for the uclass
145          * platform data and then check the dev->uclass_platdata pointer.
146          */
147         ut_assert(uc->uc_drv->per_device_platdata_auto_alloc_size);
148
149         for (uclass_find_first_device(UCLASS_TEST, &dev);
150              dev;
151              uclass_find_next_device(&dev)) {
152                 ut_assert(dev);
153
154                 uc_pdata = dev_get_uclass_platdata(dev);
155                 ut_assert(uc_pdata);
156         }
157
158         return 0;
159 }
160 DM_TEST(dm_test_autobind_uclass_pdata_alloc, DM_TESTF_SCAN_PDATA);
161
162 /* Test that binding with uclass platdata setting occurs correctly */
163 static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts)
164 {
165         struct dm_test_perdev_uc_pdata *uc_pdata;
166         struct udevice *dev;
167
168         /**
169          * In the test_postbind() method of test uclass driver, the uclass
170          * platform data should be set to three test int values - test it.
171          */
172         for (uclass_find_first_device(UCLASS_TEST, &dev);
173              dev;
174              uclass_find_next_device(&dev)) {
175                 ut_assert(dev);
176
177                 uc_pdata = dev_get_uclass_platdata(dev);
178                 ut_assert(uc_pdata);
179                 ut_assert(uc_pdata->intval1 == TEST_UC_PDATA_INTVAL1);
180                 ut_assert(uc_pdata->intval2 == TEST_UC_PDATA_INTVAL2);
181                 ut_assert(uc_pdata->intval3 == TEST_UC_PDATA_INTVAL3);
182         }
183
184         return 0;
185 }
186 DM_TEST(dm_test_autobind_uclass_pdata_valid, DM_TESTF_SCAN_PDATA);
187
188 /* Test that autoprobe finds all the expected devices */
189 static int dm_test_autoprobe(struct unit_test_state *uts)
190 {
191         struct dm_test_state *dms = uts->priv;
192         int expected_base_add;
193         struct udevice *dev;
194         struct uclass *uc;
195         int i;
196
197         ut_assertok(uclass_get(UCLASS_TEST, &uc));
198         ut_assert(uc);
199
200         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
201         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_PROBE]);
202         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]);
203
204         /* The root device should not be activated until needed */
205         ut_assert(dms->root->flags & DM_FLAG_ACTIVATED);
206
207         /*
208          * We should be able to find the three test devices, and they should
209          * all be activated as they are used (lazy activation, required by
210          * U-Boot)
211          */
212         for (i = 0; i < 3; i++) {
213                 ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
214                 ut_assert(dev);
215                 ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED),
216                            "Driver %d/%s already activated", i, dev->name);
217
218                 /* This should activate it */
219                 ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev));
220                 ut_assert(dev);
221                 ut_assert(dev->flags & DM_FLAG_ACTIVATED);
222
223                 /* Activating a device should activate the root device */
224                 if (!i)
225                         ut_assert(dms->root->flags & DM_FLAG_ACTIVATED);
226         }
227
228         /*
229          * Our 3 dm_test_info children should be passed to pre_probe and
230          * post_probe
231          */
232         ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]);
233         ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_PRE_PROBE]);
234
235         /* Also we can check the per-device data */
236         expected_base_add = 0;
237         for (i = 0; i < 3; i++) {
238                 struct dm_test_uclass_perdev_priv *priv;
239                 struct dm_test_pdata *pdata;
240
241                 ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
242                 ut_assert(dev);
243
244                 priv = dev_get_uclass_priv(dev);
245                 ut_assert(priv);
246                 ut_asserteq(expected_base_add, priv->base_add);
247
248                 pdata = dev->platdata;
249                 expected_base_add += pdata->ping_add;
250         }
251
252         return 0;
253 }
254 DM_TEST(dm_test_autoprobe, DM_TESTF_SCAN_PDATA);
255
256 /* Check that we see the correct platdata in each device */
257 static int dm_test_platdata(struct unit_test_state *uts)
258 {
259         const struct dm_test_pdata *pdata;
260         struct udevice *dev;
261         int i;
262
263         for (i = 0; i < 3; i++) {
264                 ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
265                 ut_assert(dev);
266                 pdata = dev->platdata;
267                 ut_assert(pdata->ping_add == test_pdata[i].ping_add);
268         }
269
270         return 0;
271 }
272 DM_TEST(dm_test_platdata, DM_TESTF_SCAN_PDATA);
273
274 /* Test that we can bind, probe, remove, unbind a driver */
275 static int dm_test_lifecycle(struct unit_test_state *uts)
276 {
277         struct dm_test_state *dms = uts->priv;
278         int op_count[DM_TEST_OP_COUNT];
279         struct udevice *dev, *test_dev;
280         int pingret;
281         int ret;
282
283         memcpy(op_count, dm_testdrv_op_count, sizeof(op_count));
284
285         ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
286                                         &dev));
287         ut_assert(dev);
288         ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND]
289                         == op_count[DM_TEST_OP_BIND] + 1);
290         ut_assert(!dev->priv);
291
292         /* Probe the device - it should fail allocating private data */
293         dms->force_fail_alloc = 1;
294         ret = device_probe(dev);
295         ut_assert(ret == -ENOMEM);
296         ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE]
297                         == op_count[DM_TEST_OP_PROBE] + 1);
298         ut_assert(!dev->priv);
299
300         /* Try again without the alloc failure */
301         dms->force_fail_alloc = 0;
302         ut_assertok(device_probe(dev));
303         ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE]
304                         == op_count[DM_TEST_OP_PROBE] + 2);
305         ut_assert(dev->priv);
306
307         /* This should be device 3 in the uclass */
308         ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
309         ut_assert(dev == test_dev);
310
311         /* Try ping */
312         ut_assertok(test_ping(dev, 100, &pingret));
313         ut_assert(pingret == 102);
314
315         /* Now remove device 3 */
316         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]);
317         ut_assertok(device_remove(dev));
318         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]);
319
320         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
321         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]);
322         ut_assertok(device_unbind(dev));
323         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
324         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]);
325
326         return 0;
327 }
328 DM_TEST(dm_test_lifecycle, DM_TESTF_SCAN_PDATA | DM_TESTF_PROBE_TEST);
329
330 /* Test that we can bind/unbind and the lists update correctly */
331 static int dm_test_ordering(struct unit_test_state *uts)
332 {
333         struct dm_test_state *dms = uts->priv;
334         struct udevice *dev, *dev_penultimate, *dev_last, *test_dev;
335         int pingret;
336
337         ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
338                                         &dev));
339         ut_assert(dev);
340
341         /* Bind two new devices (numbers 4 and 5) */
342         ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
343                                         &dev_penultimate));
344         ut_assert(dev_penultimate);
345         ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
346                                         &dev_last));
347         ut_assert(dev_last);
348
349         /* Now remove device 3 */
350         ut_assertok(device_remove(dev));
351         ut_assertok(device_unbind(dev));
352
353         /* The device numbering should have shifted down one */
354         ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
355         ut_assert(dev_penultimate == test_dev);
356         ut_assertok(uclass_find_device(UCLASS_TEST, 4, &test_dev));
357         ut_assert(dev_last == test_dev);
358
359         /* Add back the original device 3, now in position 5 */
360         ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
361                                         &dev));
362         ut_assert(dev);
363
364         /* Try ping */
365         ut_assertok(test_ping(dev, 100, &pingret));
366         ut_assert(pingret == 102);
367
368         /* Remove 3 and 4 */
369         ut_assertok(device_remove(dev_penultimate));
370         ut_assertok(device_unbind(dev_penultimate));
371         ut_assertok(device_remove(dev_last));
372         ut_assertok(device_unbind(dev_last));
373
374         /* Our device should now be in position 3 */
375         ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
376         ut_assert(dev == test_dev);
377
378         /* Now remove device 3 */
379         ut_assertok(device_remove(dev));
380         ut_assertok(device_unbind(dev));
381
382         return 0;
383 }
384 DM_TEST(dm_test_ordering, DM_TESTF_SCAN_PDATA);
385
386 /* Check that we can perform operations on a device (do a ping) */
387 int dm_check_operations(struct unit_test_state *uts, struct udevice *dev,
388                         uint32_t base, struct dm_test_priv *priv)
389 {
390         int expected;
391         int pingret;
392
393         /* Getting the child device should allocate platdata / priv */
394         ut_assertok(testfdt_ping(dev, 10, &pingret));
395         ut_assert(dev->priv);
396         ut_assert(dev->platdata);
397
398         expected = 10 + base;
399         ut_asserteq(expected, pingret);
400
401         /* Do another ping */
402         ut_assertok(testfdt_ping(dev, 20, &pingret));
403         expected = 20 + base;
404         ut_asserteq(expected, pingret);
405
406         /* Now check the ping_total */
407         priv = dev->priv;
408         ut_asserteq(DM_TEST_START_TOTAL + 10 + 20 + base * 2,
409                     priv->ping_total);
410
411         return 0;
412 }
413
414 /* Check that we can perform operations on devices */
415 static int dm_test_operations(struct unit_test_state *uts)
416 {
417         struct udevice *dev;
418         int i;
419
420         /*
421          * Now check that the ping adds are what we expect. This is using the
422          * ping-add property in each node.
423          */
424         for (i = 0; i < ARRAY_SIZE(test_pdata); i++) {
425                 uint32_t base;
426
427                 ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev));
428
429                 /*
430                  * Get the 'reg' property, which tells us what the ping add
431                  * should be. We don't use the platdata because we want
432                  * to test the code that sets that up (testfdt_drv_probe()).
433                  */
434                 base = test_pdata[i].ping_add;
435                 debug("dev=%d, base=%d\n", i, base);
436
437                 ut_assert(!dm_check_operations(uts, dev, base, dev->priv));
438         }
439
440         return 0;
441 }
442 DM_TEST(dm_test_operations, DM_TESTF_SCAN_PDATA);
443
444 /* Remove all drivers and check that things work */
445 static int dm_test_remove(struct unit_test_state *uts)
446 {
447         struct udevice *dev;
448         int i;
449
450         for (i = 0; i < 3; i++) {
451                 ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
452                 ut_assert(dev);
453                 ut_assertf(dev->flags & DM_FLAG_ACTIVATED,
454                            "Driver %d/%s not activated", i, dev->name);
455                 ut_assertok(device_remove(dev));
456                 ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED),
457                            "Driver %d/%s should have deactivated", i,
458                            dev->name);
459                 ut_assert(!dev->priv);
460         }
461
462         return 0;
463 }
464 DM_TEST(dm_test_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_PROBE_TEST);
465
466 /* Remove and recreate everything, check for memory leaks */
467 static int dm_test_leak(struct unit_test_state *uts)
468 {
469         int i;
470
471         for (i = 0; i < 2; i++) {
472                 struct udevice *dev;
473                 int ret;
474                 int id;
475
476                 dm_leak_check_start(uts);
477
478                 ut_assertok(dm_scan_platdata(false));
479                 ut_assertok(dm_scan_fdt(gd->fdt_blob, false));
480
481                 /* Scanning the uclass is enough to probe all the devices */
482                 for (id = UCLASS_ROOT; id < UCLASS_COUNT; id++) {
483                         for (ret = uclass_first_device(UCLASS_TEST, &dev);
484                              dev;
485                              ret = uclass_next_device(&dev))
486                                 ;
487                         ut_assertok(ret);
488                 }
489
490                 ut_assertok(dm_leak_check_end(uts));
491         }
492
493         return 0;
494 }
495 DM_TEST(dm_test_leak, 0);
496
497 /* Test uclass init/destroy methods */
498 static int dm_test_uclass(struct unit_test_state *uts)
499 {
500         struct uclass *uc;
501
502         ut_assertok(uclass_get(UCLASS_TEST, &uc));
503         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
504         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_DESTROY]);
505         ut_assert(uc->priv);
506
507         ut_assertok(uclass_destroy(uc));
508         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
509         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_DESTROY]);
510
511         return 0;
512 }
513 DM_TEST(dm_test_uclass, 0);
514
515 /**
516  * create_children() - Create children of a parent node
517  *
518  * @dms:        Test system state
519  * @parent:     Parent device
520  * @count:      Number of children to create
521  * @key:        Key value to put in first child. Subsequence children
522  *              receive an incrementing value
523  * @child:      If not NULL, then the child device pointers are written into
524  *              this array.
525  * @return 0 if OK, -ve on error
526  */
527 static int create_children(struct unit_test_state *uts, struct udevice *parent,
528                            int count, int key, struct udevice *child[])
529 {
530         struct udevice *dev;
531         int i;
532
533         for (i = 0; i < count; i++) {
534                 struct dm_test_pdata *pdata;
535
536                 ut_assertok(device_bind_by_name(parent, false,
537                                                 &driver_info_manual, &dev));
538                 pdata = calloc(1, sizeof(*pdata));
539                 pdata->ping_add = key + i;
540                 dev->platdata = pdata;
541                 if (child)
542                         child[i] = dev;
543         }
544
545         return 0;
546 }
547
548 #define NODE_COUNT      10
549
550 static int dm_test_children(struct unit_test_state *uts)
551 {
552         struct dm_test_state *dms = uts->priv;
553         struct udevice *top[NODE_COUNT];
554         struct udevice *child[NODE_COUNT];
555         struct udevice *grandchild[NODE_COUNT];
556         struct udevice *dev;
557         int total;
558         int ret;
559         int i;
560
561         /* We don't care about the numbering for this test */
562         dms->skip_post_probe = 1;
563
564         ut_assert(NODE_COUNT > 5);
565
566         /* First create 10 top-level children */
567         ut_assertok(create_children(uts, dms->root, NODE_COUNT, 0, top));
568
569         /* Now a few have their own children */
570         ut_assertok(create_children(uts, top[2], NODE_COUNT, 2, NULL));
571         ut_assertok(create_children(uts, top[5], NODE_COUNT, 5, child));
572
573         /* And grandchildren */
574         for (i = 0; i < NODE_COUNT; i++)
575                 ut_assertok(create_children(uts, child[i], NODE_COUNT, 50 * i,
576                                             i == 2 ? grandchild : NULL));
577
578         /* Check total number of devices */
579         total = NODE_COUNT * (3 + NODE_COUNT);
580         ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_BIND]);
581
582         /* Try probing one of the grandchildren */
583         ut_assertok(uclass_get_device(UCLASS_TEST,
584                                       NODE_COUNT * 3 + 2 * NODE_COUNT, &dev));
585         ut_asserteq_ptr(grandchild[0], dev);
586
587         /*
588          * This should have probed the child and top node also, for a total
589          * of 3 nodes.
590          */
591         ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
592
593         /* Probe the other grandchildren */
594         for (i = 1; i < NODE_COUNT; i++)
595                 ut_assertok(device_probe(grandchild[i]));
596
597         ut_asserteq(2 + NODE_COUNT, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
598
599         /* Probe everything */
600         for (ret = uclass_first_device(UCLASS_TEST, &dev);
601              dev;
602              ret = uclass_next_device(&dev))
603                 ;
604         ut_assertok(ret);
605
606         ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
607
608         /* Remove a top-level child and check that the children are removed */
609         ut_assertok(device_remove(top[2]));
610         ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_REMOVE]);
611         dm_testdrv_op_count[DM_TEST_OP_REMOVE] = 0;
612
613         /* Try one with grandchildren */
614         ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev));
615         ut_asserteq_ptr(dev, top[5]);
616         ut_assertok(device_remove(dev));
617         ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT),
618                     dm_testdrv_op_count[DM_TEST_OP_REMOVE]);
619
620         /* Try the same with unbind */
621         ut_assertok(device_unbind(top[2]));
622         ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
623         dm_testdrv_op_count[DM_TEST_OP_UNBIND] = 0;
624
625         /* Try one with grandchildren */
626         ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev));
627         ut_asserteq_ptr(dev, top[6]);
628         ut_assertok(device_unbind(top[5]));
629         ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT),
630                     dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
631
632         return 0;
633 }
634 DM_TEST(dm_test_children, 0);
635
636 /* Test that pre-relocation devices work as expected */
637 static int dm_test_pre_reloc(struct unit_test_state *uts)
638 {
639         struct dm_test_state *dms = uts->priv;
640         struct udevice *dev;
641
642         /* The normal driver should refuse to bind before relocation */
643         ut_asserteq(-EPERM, device_bind_by_name(dms->root, true,
644                                                 &driver_info_manual, &dev));
645
646         /* But this one is marked pre-reloc */
647         ut_assertok(device_bind_by_name(dms->root, true,
648                                         &driver_info_pre_reloc, &dev));
649
650         return 0;
651 }
652 DM_TEST(dm_test_pre_reloc, 0);
653
654 static int dm_test_uclass_before_ready(struct unit_test_state *uts)
655 {
656         struct uclass *uc;
657
658         ut_assertok(uclass_get(UCLASS_TEST, &uc));
659
660         gd->dm_root = NULL;
661         gd->dm_root_f = NULL;
662         memset(&gd->uclass_root, '\0', sizeof(gd->uclass_root));
663
664         ut_asserteq_ptr(NULL, uclass_find(UCLASS_TEST));
665
666         return 0;
667 }
668 DM_TEST(dm_test_uclass_before_ready, 0);
669
670 static int dm_test_uclass_devices_find(struct unit_test_state *uts)
671 {
672         struct udevice *dev;
673         int ret;
674
675         for (ret = uclass_find_first_device(UCLASS_TEST, &dev);
676              dev;
677              ret = uclass_find_next_device(&dev)) {
678                 ut_assert(!ret);
679                 ut_assert(dev);
680         }
681
682         return 0;
683 }
684 DM_TEST(dm_test_uclass_devices_find, DM_TESTF_SCAN_PDATA);
685
686 static int dm_test_uclass_devices_find_by_name(struct unit_test_state *uts)
687 {
688         struct udevice *finddev;
689         struct udevice *testdev;
690         int findret, ret;
691
692         /*
693          * For each test device found in fdt like: "a-test", "b-test", etc.,
694          * use its name and try to find it by uclass_find_device_by_name().
695          * Then, on success check if:
696          * - current 'testdev' name is equal to the returned 'finddev' name
697          * - current 'testdev' pointer is equal to the returned 'finddev'
698          *
699          * We assume that, each uclass's device name is unique, so if not, then
700          * this will fail on checking condition: testdev == finddev, since the
701          * uclass_find_device_by_name(), returns the first device by given name.
702         */
703         for (ret = uclass_find_first_device(UCLASS_TEST_FDT, &testdev);
704              testdev;
705              ret = uclass_find_next_device(&testdev)) {
706                 ut_assertok(ret);
707                 ut_assert(testdev);
708
709                 findret = uclass_find_device_by_name(UCLASS_TEST_FDT,
710                                                      testdev->name,
711                                                      &finddev);
712
713                 ut_assertok(findret);
714                 ut_assert(testdev);
715                 ut_asserteq_str(testdev->name, finddev->name);
716                 ut_asserteq_ptr(testdev, finddev);
717         }
718
719         return 0;
720 }
721 DM_TEST(dm_test_uclass_devices_find_by_name, DM_TESTF_SCAN_FDT);
722
723 static int dm_test_uclass_devices_get(struct unit_test_state *uts)
724 {
725         struct udevice *dev;
726         int ret;
727
728         for (ret = uclass_first_device(UCLASS_TEST, &dev);
729              dev;
730              ret = uclass_next_device(&dev)) {
731                 ut_assert(!ret);
732                 ut_assert(dev);
733                 ut_assert(device_active(dev));
734         }
735
736         return 0;
737 }
738 DM_TEST(dm_test_uclass_devices_get, DM_TESTF_SCAN_PDATA);
739
740 static int dm_test_uclass_devices_get_by_name(struct unit_test_state *uts)
741 {
742         struct udevice *finddev;
743         struct udevice *testdev;
744         int ret, findret;
745
746         /*
747          * For each test device found in fdt like: "a-test", "b-test", etc.,
748          * use its name and try to get it by uclass_get_device_by_name().
749          * On success check if:
750          * - returned finddev' is active
751          * - current 'testdev' name is equal to the returned 'finddev' name
752          * - current 'testdev' pointer is equal to the returned 'finddev'
753          *
754          * We asserts that the 'testdev' is active on each loop entry, so we
755          * could be sure that the 'finddev' is activated too, but for sure
756          * we check it again.
757          *
758          * We assume that, each uclass's device name is unique, so if not, then
759          * this will fail on checking condition: testdev == finddev, since the
760          * uclass_get_device_by_name(), returns the first device by given name.
761         */
762         for (ret = uclass_first_device(UCLASS_TEST_FDT, &testdev);
763              testdev;
764              ret = uclass_next_device(&testdev)) {
765                 ut_assertok(ret);
766                 ut_assert(testdev);
767                 ut_assert(device_active(testdev));
768
769                 findret = uclass_get_device_by_name(UCLASS_TEST_FDT,
770                                                     testdev->name,
771                                                     &finddev);
772
773                 ut_assertok(findret);
774                 ut_assert(finddev);
775                 ut_assert(device_active(finddev));
776                 ut_asserteq_str(testdev->name, finddev->name);
777                 ut_asserteq_ptr(testdev, finddev);
778         }
779
780         return 0;
781 }
782 DM_TEST(dm_test_uclass_devices_get_by_name, DM_TESTF_SCAN_FDT);
783
784 static int dm_test_device_get_uclass_id(struct unit_test_state *uts)
785 {
786         struct udevice *dev;
787
788         ut_assertok(uclass_get_device(UCLASS_TEST, 0, &dev));
789         ut_asserteq(UCLASS_TEST, device_get_uclass_id(dev));
790
791         return 0;
792 }
793 DM_TEST(dm_test_device_get_uclass_id, DM_TESTF_SCAN_PDATA);