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);