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/ut.h>
  17 #include <dm/util.h>
  18 #include <dm/test.h>
  19 #include <dm/uclass-internal.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 /* Test that binding with platdata occurs correctly */
  71 static int dm_test_autobind(struct dm_test_state *dms)
  72 {
  73         struct udevice *dev;
  74
  75         /*
  76          * We should have a single class (UCLASS_ROOT) and a single root
  77          * device with no children.
  78          */
  79         ut_assert(dms->root);
  80         ut_asserteq(1, list_count_items(&gd->uclass_root));
  81         ut_asserteq(0, list_count_items(&gd->dm_root->child_head));
  82         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_BIND]);
  83
  84         ut_assertok(dm_scan_platdata(false));
  85
  86         /* We should have our test class now at least, plus more children */
  87         ut_assert(1 < list_count_items(&gd->uclass_root));
  88         ut_assert(0 < list_count_items(&gd->dm_root->child_head));
  89
  90         /* Our 3 dm_test_infox children should be bound to the test uclass */
  91         ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_POST_BIND]);
  92
  93         /* No devices should be probed */
  94         list_for_each_entry(dev, &gd->dm_root->child_head, sibling_node)
  95                 ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
  96
  97         /* Our test driver should have been bound 3 times */
  98         ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND] == 3);
  99
 100         return 0;
 101 }
 102 DM_TEST(dm_test_autobind, 0);
 103
 104 /* Test that autoprobe finds all the expected devices */
 105 static int dm_test_autoprobe(struct dm_test_state *dms)
 106 {
 107         int expected_base_add;
 108         struct udevice *dev;
 109         struct uclass *uc;
 110         int i;
 111
 112         ut_assertok(uclass_get(UCLASS_TEST, &uc));
 113         ut_assert(uc);
 114
 115         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
 116         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]);
 117
 118         /* The root device should not be activated until needed */
 119         ut_assert(dms->root->flags & DM_FLAG_ACTIVATED);
 120
 121         /*
 122          * We should be able to find the three test devices, and they should
 123          * all be activated as they are used (lazy activation, required by
 124          * U-Boot)
 125          */
 126         for (i = 0; i < 3; i++) {
 127                 ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
 128                 ut_assert(dev);
 129                 ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED),
 130                            "Driver %d/%s already activated", i, dev->name);
 131
 132                 /* This should activate it */
 133                 ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev));
 134                 ut_assert(dev);
 135                 ut_assert(dev->flags & DM_FLAG_ACTIVATED);
 136
 137                 /* Activating a device should activate the root device */
 138                 if (!i)
 139                         ut_assert(dms->root->flags & DM_FLAG_ACTIVATED);
 140         }
 141
 142         /* Our 3 dm_test_infox children should be passed to post_probe */
 143         ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]);
 144
 145         /* Also we can check the per-device data */
 146         expected_base_add = 0;
 147         for (i = 0; i < 3; i++) {
 148                 struct dm_test_uclass_perdev_priv *priv;
 149                 struct dm_test_pdata *pdata;
 150
 151                 ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
 152                 ut_assert(dev);
 153
 154                 priv = dev->uclass_priv;
 155                 ut_assert(priv);
 156                 ut_asserteq(expected_base_add, priv->base_add);
 157
 158                 pdata = dev->platdata;
 159                 expected_base_add += pdata->ping_add;
 160         }
 161
 162         return 0;
 163 }
 164 DM_TEST(dm_test_autoprobe, DM_TESTF_SCAN_PDATA);
 165
 166 /* Check that we see the correct platdata in each device */
 167 static int dm_test_platdata(struct dm_test_state *dms)
 168 {
 169         const struct dm_test_pdata *pdata;
 170         struct udevice *dev;
 171         int i;
 172
 173         for (i = 0; i < 3; i++) {
 174                 ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
 175                 ut_assert(dev);
 176                 pdata = dev->platdata;
 177                 ut_assert(pdata->ping_add == test_pdata[i].ping_add);
 178         }
 179
 180         return 0;
 181 }
 182 DM_TEST(dm_test_platdata, DM_TESTF_SCAN_PDATA);
 183
 184 /* Test that we can bind, probe, remove, unbind a driver */
 185 static int dm_test_lifecycle(struct dm_test_state *dms)
 186 {
 187         int op_count[DM_TEST_OP_COUNT];
 188         struct udevice *dev, *test_dev;
 189         int pingret;
 190         int ret;
 191
 192         memcpy(op_count, dm_testdrv_op_count, sizeof(op_count));
 193
 194         ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
 195                                         &dev));
 196         ut_assert(dev);
 197         ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND]
 198                         == op_count[DM_TEST_OP_BIND] + 1);
 199         ut_assert(!dev->priv);
 200
 201         /* Probe the device - it should fail allocating private data */
 202         dms->force_fail_alloc = 1;
 203         ret = device_probe(dev);
 204         ut_assert(ret == -ENOMEM);
 205         ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE]
 206                         == op_count[DM_TEST_OP_PROBE] + 1);
 207         ut_assert(!dev->priv);
 208
 209         /* Try again without the alloc failure */
 210         dms->force_fail_alloc = 0;
 211         ut_assertok(device_probe(dev));
 212         ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE]
 213                         == op_count[DM_TEST_OP_PROBE] + 2);
 214         ut_assert(dev->priv);
 215
 216         /* This should be device 3 in the uclass */
 217         ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
 218         ut_assert(dev == test_dev);
 219
 220         /* Try ping */
 221         ut_assertok(test_ping(dev, 100, &pingret));
 222         ut_assert(pingret == 102);
 223
 224         /* Now remove device 3 */
 225         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]);
 226         ut_assertok(device_remove(dev));
 227         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]);
 228
 229         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
 230         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]);
 231         ut_assertok(device_unbind(dev));
 232         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
 233         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]);
 234
 235         return 0;
 236 }
 237 DM_TEST(dm_test_lifecycle, DM_TESTF_SCAN_PDATA | DM_TESTF_PROBE_TEST);
 238
 239 /* Test that we can bind/unbind and the lists update correctly */
 240 static int dm_test_ordering(struct dm_test_state *dms)
 241 {
 242         struct udevice *dev, *dev_penultimate, *dev_last, *test_dev;
 243         int pingret;
 244
 245         ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
 246                                         &dev));
 247         ut_assert(dev);
 248
 249         /* Bind two new devices (numbers 4 and 5) */
 250         ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
 251                                         &dev_penultimate));
 252         ut_assert(dev_penultimate);
 253         ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
 254                                         &dev_last));
 255         ut_assert(dev_last);
 256
 257         /* Now remove device 3 */
 258         ut_assertok(device_remove(dev));
 259         ut_assertok(device_unbind(dev));
 260
 261         /* The device numbering should have shifted down one */
 262         ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
 263         ut_assert(dev_penultimate == test_dev);
 264         ut_assertok(uclass_find_device(UCLASS_TEST, 4, &test_dev));
 265         ut_assert(dev_last == test_dev);
 266
 267         /* Add back the original device 3, now in position 5 */
 268         ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
 269                                         &dev));
 270         ut_assert(dev);
 271
 272         /* Try ping */
 273         ut_assertok(test_ping(dev, 100, &pingret));
 274         ut_assert(pingret == 102);
 275
 276         /* Remove 3 and 4 */
 277         ut_assertok(device_remove(dev_penultimate));
 278         ut_assertok(device_unbind(dev_penultimate));
 279         ut_assertok(device_remove(dev_last));
 280         ut_assertok(device_unbind(dev_last));
 281
 282         /* Our device should now be in position 3 */
 283         ut_assertok(uclass_find_device(UCLASS_TEST, 3, &test_dev));
 284         ut_assert(dev == test_dev);
 285
 286         /* Now remove device 3 */
 287         ut_assertok(device_remove(dev));
 288         ut_assertok(device_unbind(dev));
 289
 290         return 0;
 291 }
 292 DM_TEST(dm_test_ordering, DM_TESTF_SCAN_PDATA);
 293
 294 /* Check that we can perform operations on a device (do a ping) */
 295 int dm_check_operations(struct dm_test_state *dms, struct udevice *dev,
 296                         uint32_t base, struct dm_test_priv *priv)
 297 {
 298         int expected;
 299         int pingret;
 300
 301         /* Getting the child device should allocate platdata / priv */
 302         ut_assertok(testfdt_ping(dev, 10, &pingret));
 303         ut_assert(dev->priv);
 304         ut_assert(dev->platdata);
 305
 306         expected = 10 + base;
 307         ut_asserteq(expected, pingret);
 308
 309         /* Do another ping */
 310         ut_assertok(testfdt_ping(dev, 20, &pingret));
 311         expected = 20 + base;
 312         ut_asserteq(expected, pingret);
 313
 314         /* Now check the ping_total */
 315         priv = dev->priv;
 316         ut_asserteq(DM_TEST_START_TOTAL + 10 + 20 + base * 2,
 317                     priv->ping_total);
 318
 319         return 0;
 320 }
 321
 322 /* Check that we can perform operations on devices */
 323 static int dm_test_operations(struct dm_test_state *dms)
 324 {
 325         struct udevice *dev;
 326         int i;
 327
 328         /*
 329          * Now check that the ping adds are what we expect. This is using the
 330          * ping-add property in each node.
 331          */
 332         for (i = 0; i < ARRAY_SIZE(test_pdata); i++) {
 333                 uint32_t base;
 334
 335                 ut_assertok(uclass_get_device(UCLASS_TEST, i, &dev));
 336
 337                 /*
 338                  * Get the 'reg' property, which tells us what the ping add
 339                  * should be. We don't use the platdata because we want
 340                  * to test the code that sets that up (testfdt_drv_probe()).
 341                  */
 342                 base = test_pdata[i].ping_add;
 343                 debug("dev=%d, base=%d\n", i, base);
 344
 345                 ut_assert(!dm_check_operations(dms, dev, base, dev->priv));
 346         }
 347
 348         return 0;
 349 }
 350 DM_TEST(dm_test_operations, DM_TESTF_SCAN_PDATA);
 351
 352 /* Remove all drivers and check that things work */
 353 static int dm_test_remove(struct dm_test_state *dms)
 354 {
 355         struct udevice *dev;
 356         int i;
 357
 358         for (i = 0; i < 3; i++) {
 359                 ut_assertok(uclass_find_device(UCLASS_TEST, i, &dev));
 360                 ut_assert(dev);
 361                 ut_assertf(dev->flags & DM_FLAG_ACTIVATED,
 362                            "Driver %d/%s not activated", i, dev->name);
 363                 ut_assertok(device_remove(dev));
 364                 ut_assertf(!(dev->flags & DM_FLAG_ACTIVATED),
 365                            "Driver %d/%s should have deactivated", i,
 366                            dev->name);
 367                 ut_assert(!dev->priv);
 368         }
 369
 370         return 0;
 371 }
 372 DM_TEST(dm_test_remove, DM_TESTF_SCAN_PDATA | DM_TESTF_PROBE_TEST);
 373
 374 /* Remove and recreate everything, check for memory leaks */
 375 static int dm_test_leak(struct dm_test_state *dms)
 376 {
 377         int i;
 378
 379         for (i = 0; i < 2; i++) {
 380                 struct mallinfo start, end;
 381                 struct udevice *dev;
 382                 int ret;
 383                 int id;
 384
 385                 start = mallinfo();
 386                 if (!start.uordblks)
 387                         puts("Warning: Please add '#define DEBUG' to the top of common/dlmalloc.c\n");
 388
 389                 ut_assertok(dm_scan_platdata(false));
 390                 ut_assertok(dm_scan_fdt(gd->fdt_blob, false));
 391
 392                 /* Scanning the uclass is enough to probe all the devices */
 393                 for (id = UCLASS_ROOT; id < UCLASS_COUNT; id++) {
 394                         for (ret = uclass_first_device(UCLASS_TEST, &dev);
 395                              dev;
 396                              ret = uclass_next_device(&dev))
 397                                 ;
 398                         ut_assertok(ret);
 399                 }
 400
 401                 /* Don't delete the root class, since we started with that */
 402                 for (id = UCLASS_ROOT + 1; id < UCLASS_COUNT; id++) {
 403                         struct uclass *uc;
 404
 405                         uc = uclass_find(id);
 406                         if (!uc)
 407                                 continue;
 408                         ut_assertok(uclass_destroy(uc));
 409                 }
 410
 411                 end = mallinfo();
 412                 ut_asserteq(start.uordblks, end.uordblks);
 413         }
 414
 415         return 0;
 416 }
 417 DM_TEST(dm_test_leak, 0);
 418
 419 /* Test uclass init/destroy methods */
 420 static int dm_test_uclass(struct dm_test_state *dms)
 421 {
 422         struct uclass *uc;
 423
 424         ut_assertok(uclass_get(UCLASS_TEST, &uc));
 425         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
 426         ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_DESTROY]);
 427         ut_assert(uc->priv);
 428
 429         ut_assertok(uclass_destroy(uc));
 430         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_INIT]);
 431         ut_asserteq(1, dm_testdrv_op_count[DM_TEST_OP_DESTROY]);
 432
 433         return 0;
 434 }
 435 DM_TEST(dm_test_uclass, 0);
 436
 437 /**
 438  * create_children() - Create children of a parent node
 439  *
 440  * @dms:        Test system state
 441  * @parent:     Parent device
 442  * @count:      Number of children to create
 443  * @key:        Key value to put in first child. Subsequence children
 444  *              receive an incrementing value
 445  * @child:      If not NULL, then the child device pointers are written into
 446  *              this array.
 447  * @return 0 if OK, -ve on error
 448  */
 449 static int create_children(struct dm_test_state *dms, struct udevice *parent,
 450                            int count, int key, struct udevice *child[])
 451 {
 452         struct udevice *dev;
 453         int i;
 454
 455         for (i = 0; i < count; i++) {
 456                 struct dm_test_pdata *pdata;
 457
 458                 ut_assertok(device_bind_by_name(parent, false,
 459                                                 &driver_info_manual, &dev));
 460                 pdata = calloc(1, sizeof(*pdata));
 461                 pdata->ping_add = key + i;
 462                 dev->platdata = pdata;
 463                 if (child)
 464                         child[i] = dev;
 465         }
 466
 467         return 0;
 468 }
 469
 470 #define NODE_COUNT      10
 471
 472 static int dm_test_children(struct dm_test_state *dms)
 473 {
 474         struct udevice *top[NODE_COUNT];
 475         struct udevice *child[NODE_COUNT];
 476         struct udevice *grandchild[NODE_COUNT];
 477         struct udevice *dev;
 478         int total;
 479         int ret;
 480         int i;
 481
 482         /* We don't care about the numbering for this test */
 483         dms->skip_post_probe = 1;
 484
 485         ut_assert(NODE_COUNT > 5);
 486
 487         /* First create 10 top-level children */
 488         ut_assertok(create_children(dms, dms->root, NODE_COUNT, 0, top));
 489
 490         /* Now a few have their own children */
 491         ut_assertok(create_children(dms, top[2], NODE_COUNT, 2, NULL));
 492         ut_assertok(create_children(dms, top[5], NODE_COUNT, 5, child));
 493
 494         /* And grandchildren */
 495         for (i = 0; i < NODE_COUNT; i++)
 496                 ut_assertok(create_children(dms, child[i], NODE_COUNT, 50 * i,
 497                                             i == 2 ? grandchild : NULL));
 498
 499         /* Check total number of devices */
 500         total = NODE_COUNT * (3 + NODE_COUNT);
 501         ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_BIND]);
 502
 503         /* Try probing one of the grandchildren */
 504         ut_assertok(uclass_get_device(UCLASS_TEST,
 505                                       NODE_COUNT * 3 + 2 * NODE_COUNT, &dev));
 506         ut_asserteq_ptr(grandchild[0], dev);
 507
 508         /*
 509          * This should have probed the child and top node also, for a total
 510          * of 3 nodes.
 511          */
 512         ut_asserteq(3, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
 513
 514         /* Probe the other grandchildren */
 515         for (i = 1; i < NODE_COUNT; i++)
 516                 ut_assertok(device_probe(grandchild[i]));
 517
 518         ut_asserteq(2 + NODE_COUNT, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
 519
 520         /* Probe everything */
 521         for (ret = uclass_first_device(UCLASS_TEST, &dev);
 522              dev;
 523              ret = uclass_next_device(&dev))
 524                 ;
 525         ut_assertok(ret);
 526
 527         ut_asserteq(total, dm_testdrv_op_count[DM_TEST_OP_PROBE]);
 528
 529         /* Remove a top-level child and check that the children are removed */
 530         ut_assertok(device_remove(top[2]));
 531         ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_REMOVE]);
 532         dm_testdrv_op_count[DM_TEST_OP_REMOVE] = 0;
 533
 534         /* Try one with grandchildren */
 535         ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev));
 536         ut_asserteq_ptr(dev, top[5]);
 537         ut_assertok(device_remove(dev));
 538         ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT),
 539                     dm_testdrv_op_count[DM_TEST_OP_REMOVE]);
 540
 541         /* Try the same with unbind */
 542         ut_assertok(device_unbind(top[2]));
 543         ut_asserteq(NODE_COUNT + 1, dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
 544         dm_testdrv_op_count[DM_TEST_OP_UNBIND] = 0;
 545
 546         /* Try one with grandchildren */
 547         ut_assertok(uclass_get_device(UCLASS_TEST, 5, &dev));
 548         ut_asserteq_ptr(dev, top[6]);
 549         ut_assertok(device_unbind(top[5]));
 550         ut_asserteq(1 + NODE_COUNT * (1 + NODE_COUNT),
 551                     dm_testdrv_op_count[DM_TEST_OP_UNBIND]);
 552
 553         return 0;
 554 }
 555 DM_TEST(dm_test_children, 0);
 556
 557 /* Test that pre-relocation devices work as expected */
 558 static int dm_test_pre_reloc(struct dm_test_state *dms)
 559 {
 560         struct udevice *dev;
 561
 562         /* The normal driver should refuse to bind before relocation */
 563         ut_asserteq(-EPERM, device_bind_by_name(dms->root, true,
 564                                                 &driver_info_manual, &dev));
 565
 566         /* But this one is marked pre-reloc */
 567         ut_assertok(device_bind_by_name(dms->root, true,
 568                                         &driver_info_pre_reloc, &dev));
 569
 570         return 0;
 571 }
 572 DM_TEST(dm_test_pre_reloc, 0);
 573
 574 static int dm_test_uclass_before_ready(struct dm_test_state *dms)
 575 {
 576         struct uclass *uc;
 577
 578         ut_assertok(uclass_get(UCLASS_TEST, &uc));
 579
 580         memset(gd, '\0', sizeof(*gd));
 581         ut_asserteq_ptr(NULL, uclass_find(UCLASS_TEST));
 582
 583         return 0;
 584 }
 585
 586 DM_TEST(dm_test_uclass_before_ready, 0);