test/dm/test-fdt.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2013 Google, Inc
   4  */
   5
   6 #include <common.h>
   7 #include <dm.h>
   8 #include <errno.h>
   9 #include <fdtdec.h>
  10 #include <malloc.h>
  11 #include <asm/io.h>
  12 #include <dm/test.h>
  13 #include <dm/root.h>
  14 #include <dm/device-internal.h>
  15 #include <dm/uclass-internal.h>
  16 #include <dm/util.h>
  17 #include <dm/lists.h>
  18 #include <dm/of_access.h>
  19 #include <test/ut.h>
  20
  21 DECLARE_GLOBAL_DATA_PTR;
  22
  23 static int testfdt_drv_ping(struct udevice *dev, int pingval, int *pingret)
  24 {
  25         const struct dm_test_pdata *pdata = dev->platdata;
  26         struct dm_test_priv *priv = dev_get_priv(dev);
  27
  28         *pingret = pingval + pdata->ping_add;
  29         priv->ping_total += *pingret;
  30
  31         return 0;
  32 }
  33
  34 static const struct test_ops test_ops = {
  35         .ping = testfdt_drv_ping,
  36 };
  37
  38 static int testfdt_ofdata_to_platdata(struct udevice *dev)
  39 {
  40         struct dm_test_pdata *pdata = dev_get_platdata(dev);
  41
  42         pdata->ping_add = fdtdec_get_int(gd->fdt_blob, dev_of_offset(dev),
  43                                         "ping-add", -1);
  44         pdata->base = fdtdec_get_addr(gd->fdt_blob, dev_of_offset(dev),
  45                                       "ping-expect");
  46
  47         return 0;
  48 }
  49
  50 static int testfdt_drv_probe(struct udevice *dev)
  51 {
  52         struct dm_test_priv *priv = dev_get_priv(dev);
  53
  54         priv->ping_total += DM_TEST_START_TOTAL;
  55
  56         /*
  57          * If this device is on a bus, the uclass_flag will be set before
  58          * calling this function. In the meantime the uclass_postp is
  59          * initlized to a value -1. These are used respectively by
  60          * dm_test_bus_child_pre_probe_uclass() and
  61          * dm_test_bus_child_post_probe_uclass().
  62          */
  63         priv->uclass_total += priv->uclass_flag;
  64         priv->uclass_postp = -1;
  65
  66         return 0;
  67 }
  68
  69 static const struct udevice_id testfdt_ids[] = {
  70         {
  71                 .compatible = "denx,u-boot-fdt-test",
  72                 .data = DM_TEST_TYPE_FIRST },
  73         {
  74                 .compatible = "google,another-fdt-test",
  75                 .data = DM_TEST_TYPE_SECOND },
  76         { }
  77 };
  78
  79 U_BOOT_DRIVER(testfdt_drv) = {
  80         .name   = "testfdt_drv",
  81         .of_match       = testfdt_ids,
  82         .id     = UCLASS_TEST_FDT,
  83         .ofdata_to_platdata = testfdt_ofdata_to_platdata,
  84         .probe  = testfdt_drv_probe,
  85         .ops    = &test_ops,
  86         .priv_auto_alloc_size = sizeof(struct dm_test_priv),
  87         .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
  88 };
  89
  90 static const struct udevice_id testfdt1_ids[] = {
  91         {
  92                 .compatible = "denx,u-boot-fdt-test1",
  93                 .data = DM_TEST_TYPE_FIRST },
  94         { }
  95 };
  96
  97 U_BOOT_DRIVER(testfdt1_drv) = {
  98         .name   = "testfdt1_drv",
  99         .of_match       = testfdt1_ids,
 100         .id     = UCLASS_TEST_FDT,
 101         .ofdata_to_platdata = testfdt_ofdata_to_platdata,
 102         .probe  = testfdt_drv_probe,
 103         .ops    = &test_ops,
 104         .priv_auto_alloc_size = sizeof(struct dm_test_priv),
 105         .platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
 106         .flags = DM_FLAG_PRE_RELOC,
 107 };
 108
 109 /* From here is the testfdt uclass code */
 110 int testfdt_ping(struct udevice *dev, int pingval, int *pingret)
 111 {
 112         const struct test_ops *ops = device_get_ops(dev);
 113
 114         if (!ops->ping)
 115                 return -ENOSYS;
 116
 117         return ops->ping(dev, pingval, pingret);
 118 }
 119
 120 UCLASS_DRIVER(testfdt) = {
 121         .name           = "testfdt",
 122         .id             = UCLASS_TEST_FDT,
 123         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 124 };
 125
 126 struct dm_testprobe_pdata {
 127         int probe_err;
 128 };
 129
 130 static int testprobe_drv_probe(struct udevice *dev)
 131 {
 132         struct dm_testprobe_pdata *pdata = dev_get_platdata(dev);
 133
 134         return pdata->probe_err;
 135 }
 136
 137 static const struct udevice_id testprobe_ids[] = {
 138         { .compatible = "denx,u-boot-probe-test" },
 139         { }
 140 };
 141
 142 U_BOOT_DRIVER(testprobe_drv) = {
 143         .name   = "testprobe_drv",
 144         .of_match       = testprobe_ids,
 145         .id     = UCLASS_TEST_PROBE,
 146         .probe  = testprobe_drv_probe,
 147         .platdata_auto_alloc_size       = sizeof(struct dm_testprobe_pdata),
 148 };
 149
 150 UCLASS_DRIVER(testprobe) = {
 151         .name           = "testprobe",
 152         .id             = UCLASS_TEST_PROBE,
 153         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 154 };
 155
 156 int dm_check_devices(struct unit_test_state *uts, int num_devices)
 157 {
 158         struct udevice *dev;
 159         int ret;
 160         int i;
 161
 162         /*
 163          * Now check that the ping adds are what we expect. This is using the
 164          * ping-add property in each node.
 165          */
 166         for (i = 0; i < num_devices; i++) {
 167                 uint32_t base;
 168
 169                 ret = uclass_get_device(UCLASS_TEST_FDT, i, &dev);
 170                 ut_assert(!ret);
 171
 172                 /*
 173                  * Get the 'ping-expect' property, which tells us what the
 174                  * ping add should be. We don't use the platdata because we
 175                  * want to test the code that sets that up
 176                  * (testfdt_drv_probe()).
 177                  */
 178                 base = fdtdec_get_addr(gd->fdt_blob, dev_of_offset(dev),
 179                                        "ping-expect");
 180                 debug("dev=%d, base=%d: %s\n", i, base,
 181                       fdt_get_name(gd->fdt_blob, dev_of_offset(dev), NULL));
 182
 183                 ut_assert(!dm_check_operations(uts, dev, base,
 184                                                dev_get_priv(dev)));
 185         }
 186
 187         return 0;
 188 }
 189
 190 /* Test that FDT-based binding works correctly */
 191 static int dm_test_fdt(struct unit_test_state *uts)
 192 {
 193         const int num_devices = 8;
 194         struct udevice *dev;
 195         struct uclass *uc;
 196         int ret;
 197         int i;
 198
 199         ret = dm_scan_fdt(gd->fdt_blob, false);
 200         ut_assert(!ret);
 201
 202         ret = uclass_get(UCLASS_TEST_FDT, &uc);
 203         ut_assert(!ret);
 204
 205         /* These are num_devices compatible root-level device tree nodes */
 206         ut_asserteq(num_devices, list_count_items(&uc->dev_head));
 207
 208         /* Each should have platform data but no private data */
 209         for (i = 0; i < num_devices; i++) {
 210                 ret = uclass_find_device(UCLASS_TEST_FDT, i, &dev);
 211                 ut_assert(!ret);
 212                 ut_assert(!dev_get_priv(dev));
 213                 ut_assert(dev->platdata);
 214         }
 215
 216         ut_assertok(dm_check_devices(uts, num_devices));
 217
 218         return 0;
 219 }
 220 DM_TEST(dm_test_fdt, 0);
 221
 222 static int dm_test_alias_highest_id(struct unit_test_state *uts)
 223 {
 224         int ret;
 225
 226         ret = dev_read_alias_highest_id("eth");
 227         ut_asserteq(5, ret);
 228
 229         ret = dev_read_alias_highest_id("gpio");
 230         ut_asserteq(2, ret);
 231
 232         ret = dev_read_alias_highest_id("pci");
 233         ut_asserteq(2, ret);
 234
 235         ret = dev_read_alias_highest_id("i2c");
 236         ut_asserteq(0, ret);
 237
 238         ret = dev_read_alias_highest_id("deadbeef");
 239         ut_asserteq(-1, ret);
 240
 241         return 0;
 242 }
 243 DM_TEST(dm_test_alias_highest_id, 0);
 244
 245 static int dm_test_fdt_pre_reloc(struct unit_test_state *uts)
 246 {
 247         struct uclass *uc;
 248         int ret;
 249
 250         ret = dm_scan_fdt(gd->fdt_blob, true);
 251         ut_assert(!ret);
 252
 253         ret = uclass_get(UCLASS_TEST_FDT, &uc);
 254         ut_assert(!ret);
 255
 256         /*
 257          * These are 2 pre-reloc devices:
 258          * one with "u-boot,dm-pre-reloc" property (a-test node), and the other
 259          * one whose driver marked with DM_FLAG_PRE_RELOC flag (h-test node).
 260          */
 261         ut_asserteq(2, list_count_items(&uc->dev_head));
 262
 263         return 0;
 264 }
 265 DM_TEST(dm_test_fdt_pre_reloc, 0);
 266
 267 /* Test that sequence numbers are allocated properly */
 268 static int dm_test_fdt_uclass_seq(struct unit_test_state *uts)
 269 {
 270         struct udevice *dev;
 271
 272         /* A few basic santiy tests */
 273         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 3, true, &dev));
 274         ut_asserteq_str("b-test", dev->name);
 275
 276         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_FDT, 8, true, &dev));
 277         ut_asserteq_str("a-test", dev->name);
 278
 279         ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 5,
 280                                                        true, &dev));
 281         ut_asserteq_ptr(NULL, dev);
 282
 283         /* Test aliases */
 284         ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 6, &dev));
 285         ut_asserteq_str("e-test", dev->name);
 286
 287         ut_asserteq(-ENODEV, uclass_find_device_by_seq(UCLASS_TEST_FDT, 7,
 288                                                        true, &dev));
 289
 290         /*
 291          * Note that c-test nodes are not probed since it is not a top-level
 292          * node
 293          */
 294         ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 3, &dev));
 295         ut_asserteq_str("b-test", dev->name);
 296
 297         /*
 298          * d-test wants sequence number 3 also, but it can't have it because
 299          * b-test gets it first.
 300          */
 301         ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 2, &dev));
 302         ut_asserteq_str("d-test", dev->name);
 303
 304         /* d-test actually gets 0 */
 305         ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 0, &dev));
 306         ut_asserteq_str("d-test", dev->name);
 307
 308         /* initially no one wants seq 1 */
 309         ut_asserteq(-ENODEV, uclass_get_device_by_seq(UCLASS_TEST_FDT, 1,
 310                                                       &dev));
 311         ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 0, &dev));
 312         ut_assertok(uclass_get_device(UCLASS_TEST_FDT, 4, &dev));
 313
 314         /* But now that it is probed, we can find it */
 315         ut_assertok(uclass_get_device_by_seq(UCLASS_TEST_FDT, 1, &dev));
 316         ut_asserteq_str("f-test", dev->name);
 317
 318         return 0;
 319 }
 320 DM_TEST(dm_test_fdt_uclass_seq, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 321
 322 /* Test that we can find a device by device tree offset */
 323 static int dm_test_fdt_offset(struct unit_test_state *uts)
 324 {
 325         const void *blob = gd->fdt_blob;
 326         struct udevice *dev;
 327         int node;
 328
 329         node = fdt_path_offset(blob, "/e-test");
 330         ut_assert(node > 0);
 331         ut_assertok(uclass_get_device_by_of_offset(UCLASS_TEST_FDT, node,
 332                                                    &dev));
 333         ut_asserteq_str("e-test", dev->name);
 334
 335         /* This node should not be bound */
 336         node = fdt_path_offset(blob, "/junk");
 337         ut_assert(node > 0);
 338         ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT,
 339                                                             node, &dev));
 340
 341         /* This is not a top level node so should not be probed */
 342         node = fdt_path_offset(blob, "/some-bus/c-test@5");
 343         ut_assert(node > 0);
 344         ut_asserteq(-ENODEV, uclass_get_device_by_of_offset(UCLASS_TEST_FDT,
 345                                                             node, &dev));
 346
 347         return 0;
 348 }
 349 DM_TEST(dm_test_fdt_offset,
 350         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
 351
 352 /**
 353  * Test various error conditions with uclass_first_device() and
 354  * uclass_next_device()
 355  */
 356 static int dm_test_first_next_device(struct unit_test_state *uts)
 357 {
 358         struct dm_testprobe_pdata *pdata;
 359         struct udevice *dev, *parent = NULL;
 360         int count;
 361         int ret;
 362
 363         /* There should be 4 devices */
 364         for (ret = uclass_first_device(UCLASS_TEST_PROBE, &dev), count = 0;
 365              dev;
 366              ret = uclass_next_device(&dev)) {
 367                 count++;
 368                 parent = dev_get_parent(dev);
 369                 }
 370         ut_assertok(ret);
 371         ut_asserteq(4, count);
 372
 373         /* Remove them and try again, with an error on the second one */
 374         ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 1, &dev));
 375         pdata = dev_get_platdata(dev);
 376         pdata->probe_err = -ENOMEM;
 377         device_remove(parent, DM_REMOVE_NORMAL);
 378         ut_assertok(uclass_first_device(UCLASS_TEST_PROBE, &dev));
 379         ut_asserteq(-ENOMEM, uclass_next_device(&dev));
 380         ut_asserteq_ptr(dev, NULL);
 381
 382         /* Now an error on the first one */
 383         ut_assertok(uclass_get_device(UCLASS_TEST_PROBE, 0, &dev));
 384         pdata = dev_get_platdata(dev);
 385         pdata->probe_err = -ENOENT;
 386         device_remove(parent, DM_REMOVE_NORMAL);
 387         ut_asserteq(-ENOENT, uclass_first_device(UCLASS_TEST_PROBE, &dev));
 388
 389         return 0;
 390 }
 391 DM_TEST(dm_test_first_next_device, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 392
 393 /**
 394  * check_devices() - Check return values and pointers
 395  *
 396  * This runs through a full sequence of uclass_first_device_check()...
 397  * uclass_next_device_check() checking that the return values and devices
 398  * are correct.
 399  *
 400  * @uts: Test state
 401  * @devlist: List of expected devices
 402  * @mask: Indicates which devices should return an error. Device n should
 403  *        return error (-NOENT - n) if bit n is set, or no error (i.e. 0) if
 404  *        bit n is clear.
 405  */
 406 static int check_devices(struct unit_test_state *uts,
 407                          struct udevice *devlist[], int mask)
 408 {
 409         int expected_ret;
 410         struct udevice *dev;
 411         int i;
 412
 413         expected_ret = (mask & 1) ? -ENOENT : 0;
 414         mask >>= 1;
 415         ut_asserteq(expected_ret,
 416                     uclass_first_device_check(UCLASS_TEST_PROBE, &dev));
 417         for (i = 0; i < 4; i++) {
 418                 ut_asserteq_ptr(devlist[i], dev);
 419                 expected_ret = (mask & 1) ? -ENOENT - (i + 1) : 0;
 420                 mask >>= 1;
 421                 ut_asserteq(expected_ret, uclass_next_device_check(&dev));
 422         }
 423         ut_asserteq_ptr(NULL, dev);
 424
 425         return 0;
 426 }
 427
 428 /* Test uclass_first_device_check() and uclass_next_device_check() */
 429 static int dm_test_first_next_ok_device(struct unit_test_state *uts)
 430 {
 431         struct dm_testprobe_pdata *pdata;
 432         struct udevice *dev, *parent = NULL, *devlist[4];
 433         int count;
 434         int ret;
 435
 436         /* There should be 4 devices */
 437         count = 0;
 438         for (ret = uclass_first_device_check(UCLASS_TEST_PROBE, &dev);
 439              dev;
 440              ret = uclass_next_device_check(&dev)) {
 441                 ut_assertok(ret);
 442                 devlist[count++] = dev;
 443                 parent = dev_get_parent(dev);
 444                 }
 445         ut_asserteq(4, count);
 446         ut_assertok(uclass_first_device_check(UCLASS_TEST_PROBE, &dev));
 447         ut_assertok(check_devices(uts, devlist, 0));
 448
 449         /* Remove them and try again, with an error on the second one */
 450         pdata = dev_get_platdata(devlist[1]);
 451         pdata->probe_err = -ENOENT - 1;
 452         device_remove(parent, DM_REMOVE_NORMAL);
 453         ut_assertok(check_devices(uts, devlist, 1 << 1));
 454
 455         /* Now an error on the first one */
 456         pdata = dev_get_platdata(devlist[0]);
 457         pdata->probe_err = -ENOENT - 0;
 458         device_remove(parent, DM_REMOVE_NORMAL);
 459         ut_assertok(check_devices(uts, devlist, 3 << 0));
 460
 461         /* Now errors on all */
 462         pdata = dev_get_platdata(devlist[2]);
 463         pdata->probe_err = -ENOENT - 2;
 464         pdata = dev_get_platdata(devlist[3]);
 465         pdata->probe_err = -ENOENT - 3;
 466         device_remove(parent, DM_REMOVE_NORMAL);
 467         ut_assertok(check_devices(uts, devlist, 0xf << 0));
 468
 469         return 0;
 470 }
 471 DM_TEST(dm_test_first_next_ok_device, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 472
 473 static const struct udevice_id fdt_dummy_ids[] = {
 474         { .compatible = "denx,u-boot-fdt-dummy", },
 475         { }
 476 };
 477
 478 UCLASS_DRIVER(fdt_dummy) = {
 479         .name           = "fdt-dummy",
 480         .id             = UCLASS_TEST_DUMMY,
 481         .flags          = DM_UC_FLAG_SEQ_ALIAS,
 482 };
 483
 484 U_BOOT_DRIVER(fdt_dummy_drv) = {
 485         .name   = "fdt_dummy_drv",
 486         .of_match       = fdt_dummy_ids,
 487         .id     = UCLASS_TEST_DUMMY,
 488 };
 489
 490 static int dm_test_fdt_translation(struct unit_test_state *uts)
 491 {
 492         struct udevice *dev;
 493         fdt32_t dma_addr[2];
 494
 495         /* Some simple translations */
 496         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 497         ut_asserteq_str("dev@0,0", dev->name);
 498         ut_asserteq(0x8000, dev_read_addr(dev));
 499
 500         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, true, &dev));
 501         ut_asserteq_str("dev@1,100", dev->name);
 502         ut_asserteq(0x9000, dev_read_addr(dev));
 503
 504         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 2, true, &dev));
 505         ut_asserteq_str("dev@2,200", dev->name);
 506         ut_asserteq(0xA000, dev_read_addr(dev));
 507
 508         /* No translation for busses with #size-cells == 0 */
 509         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 3, true, &dev));
 510         ut_asserteq_str("dev@42", dev->name);
 511         ut_asserteq(0x42, dev_read_addr(dev));
 512
 513         /* dma address translation */
 514         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 515         dma_addr[0] = cpu_to_be32(0);
 516         dma_addr[1] = cpu_to_be32(0);
 517         ut_asserteq(0x10000000, dev_translate_dma_address(dev, dma_addr));
 518
 519         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, true, &dev));
 520         dma_addr[0] = cpu_to_be32(1);
 521         dma_addr[1] = cpu_to_be32(0x100);
 522         ut_asserteq(0x20000000, dev_translate_dma_address(dev, dma_addr));
 523
 524         return 0;
 525 }
 526 DM_TEST(dm_test_fdt_translation, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 527
 528 static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
 529 {
 530         struct udevice *dev;
 531         fdt_addr_t addr;
 532         void *paddr;
 533
 534         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 535
 536         addr = devfdt_get_addr(dev);
 537         ut_asserteq(0x8000, addr);
 538
 539         paddr = map_physmem(addr, 0, MAP_NOCACHE);
 540         ut_assertnonnull(paddr);
 541         ut_asserteq_ptr(paddr, devfdt_remap_addr(dev));
 542
 543         return 0;
 544 }
 545 DM_TEST(dm_test_fdt_remap_addr_flat,
 546         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
 547
 548 static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
 549 {
 550         struct udevice *dev;
 551         fdt_addr_t addr;
 552         void *paddr;
 553
 554         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 555
 556         addr = devfdt_get_addr_index(dev, 0);
 557         ut_asserteq(0x8000, addr);
 558
 559         paddr = map_physmem(addr, 0, MAP_NOCACHE);
 560         ut_assertnonnull(paddr);
 561         ut_asserteq_ptr(paddr, devfdt_remap_addr_index(dev, 0));
 562
 563         return 0;
 564 }
 565 DM_TEST(dm_test_fdt_remap_addr_index_flat,
 566         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
 567
 568 static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
 569 {
 570         struct udevice *dev;
 571         fdt_addr_t addr;
 572         void *paddr;
 573
 574         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 575
 576         addr = devfdt_get_addr_name(dev, "sandbox-dummy-0");
 577         ut_asserteq(0x8000, addr);
 578
 579         paddr = map_physmem(addr, 0, MAP_NOCACHE);
 580         ut_assertnonnull(paddr);
 581         ut_asserteq_ptr(paddr, devfdt_remap_addr_name(dev, "sandbox-dummy-0"));
 582
 583         return 0;
 584 }
 585 DM_TEST(dm_test_fdt_remap_addr_name_flat,
 586         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
 587
 588 static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
 589 {
 590         struct udevice *dev;
 591         fdt_addr_t addr;
 592         void *paddr;
 593
 594         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 595
 596         addr = dev_read_addr(dev);
 597         ut_asserteq(0x8000, addr);
 598
 599         paddr = map_physmem(addr, 0, MAP_NOCACHE);
 600         ut_assertnonnull(paddr);
 601         ut_asserteq_ptr(paddr, dev_remap_addr(dev));
 602
 603         return 0;
 604 }
 605 DM_TEST(dm_test_fdt_remap_addr_live,
 606         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 607
 608 static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
 609 {
 610         struct udevice *dev;
 611         fdt_addr_t addr;
 612         void *paddr;
 613
 614         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 615
 616         addr = dev_read_addr_index(dev, 0);
 617         ut_asserteq(0x8000, addr);
 618
 619         paddr = map_physmem(addr, 0, MAP_NOCACHE);
 620         ut_assertnonnull(paddr);
 621         ut_asserteq_ptr(paddr, dev_remap_addr_index(dev, 0));
 622
 623         return 0;
 624 }
 625 DM_TEST(dm_test_fdt_remap_addr_index_live,
 626         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 627
 628 static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
 629 {
 630         struct udevice *dev;
 631         fdt_addr_t addr;
 632         void *paddr;
 633
 634         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 635
 636         addr = dev_read_addr_name(dev, "sandbox-dummy-0");
 637         ut_asserteq(0x8000, addr);
 638
 639         paddr = map_physmem(addr, 0, MAP_NOCACHE);
 640         ut_assertnonnull(paddr);
 641         ut_asserteq_ptr(paddr, dev_remap_addr_name(dev, "sandbox-dummy-0"));
 642
 643         return 0;
 644 }
 645 DM_TEST(dm_test_fdt_remap_addr_name_live,
 646         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 647
 648 static int dm_test_fdt_livetree_writing(struct unit_test_state *uts)
 649 {
 650         struct udevice *dev;
 651         ofnode node;
 652
 653         if (!of_live_active()) {
 654                 printf("Live tree not active; ignore test\n");
 655                 return 0;
 656         }
 657
 658         /* Test enabling devices */
 659
 660         node = ofnode_path("/usb@2");
 661
 662         ut_assert(!of_device_is_available(ofnode_to_np(node)));
 663         ofnode_set_enabled(node, true);
 664         ut_assert(of_device_is_available(ofnode_to_np(node)));
 665
 666         device_bind_driver_to_node(dm_root(), "usb_sandbox", "usb@2", node,
 667                                    &dev);
 668         ut_assertok(uclass_find_device_by_seq(UCLASS_USB, 2, true, &dev));
 669
 670         /* Test string property setting */
 671
 672         ut_assert(device_is_compatible(dev, "sandbox,usb"));
 673         ofnode_write_string(node, "compatible", "gdsys,super-usb");
 674         ut_assert(device_is_compatible(dev, "gdsys,super-usb"));
 675         ofnode_write_string(node, "compatible", "sandbox,usb");
 676         ut_assert(device_is_compatible(dev, "sandbox,usb"));
 677
 678         /* Test setting generic properties */
 679
 680         /* Non-existent in DTB */
 681         ut_asserteq(FDT_ADDR_T_NONE, dev_read_addr(dev));
 682         /* reg = 0x42, size = 0x100 */
 683         ut_assertok(ofnode_write_prop(node, "reg", 8,
 684                                       "\x00\x00\x00\x42\x00\x00\x01\x00"));
 685         ut_asserteq(0x42, dev_read_addr(dev));
 686
 687         /* Test disabling devices */
 688
 689         device_remove(dev, DM_REMOVE_NORMAL);
 690         device_unbind(dev);
 691
 692         ut_assert(of_device_is_available(ofnode_to_np(node)));
 693         ofnode_set_enabled(node, false);
 694         ut_assert(!of_device_is_available(ofnode_to_np(node)));
 695
 696         return 0;
 697 }
 698 DM_TEST(dm_test_fdt_livetree_writing, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 699
 700 static int dm_test_fdt_disable_enable_by_path(struct unit_test_state *uts)
 701 {
 702         ofnode node;
 703
 704         if (!of_live_active()) {
 705                 printf("Live tree not active; ignore test\n");
 706                 return 0;
 707         }
 708
 709         node = ofnode_path("/usb@2");
 710
 711         /* Test enabling devices */
 712
 713         ut_assert(!of_device_is_available(ofnode_to_np(node)));
 714         dev_enable_by_path("/usb@2");
 715         ut_assert(of_device_is_available(ofnode_to_np(node)));
 716
 717         /* Test disabling devices */
 718
 719         ut_assert(of_device_is_available(ofnode_to_np(node)));
 720         dev_disable_by_path("/usb@2");
 721         ut_assert(!of_device_is_available(ofnode_to_np(node)));
 722
 723         return 0;
 724 }
 725 DM_TEST(dm_test_fdt_disable_enable_by_path, DM_TESTF_SCAN_PDATA |
 726                                             DM_TESTF_SCAN_FDT);
 727
 728 /* Test a few uclass phandle functions */
 729 static int dm_test_fdt_phandle(struct unit_test_state *uts)
 730 {
 731         struct udevice *back, *dev, *dev2;
 732
 733         ut_assertok(uclass_find_first_device(UCLASS_PANEL_BACKLIGHT, &back));
 734         ut_asserteq(-ENOENT, uclass_find_device_by_phandle(UCLASS_REGULATOR,
 735                                                         back, "missing", &dev));
 736         ut_assertok(uclass_find_device_by_phandle(UCLASS_REGULATOR, back,
 737                                                   "power-supply", &dev));
 738         ut_asserteq(0, device_active(dev));
 739         ut_asserteq_str("ldo1", dev->name);
 740         ut_assertok(uclass_get_device_by_phandle(UCLASS_REGULATOR, back,
 741                                                  "power-supply", &dev2));
 742         ut_asserteq_ptr(dev, dev2);
 743
 744         return 0;
 745 }
 746 DM_TEST(dm_test_fdt_phandle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 747
 748 /* Test device_find_first_child_by_uclass() */
 749 static int dm_test_first_child(struct unit_test_state *uts)
 750 {
 751         struct udevice *i2c, *dev, *dev2;
 752
 753         ut_assertok(uclass_first_device_err(UCLASS_I2C, &i2c));
 754         ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_RTC, &dev));
 755         ut_asserteq_str("rtc@43", dev->name);
 756         ut_assertok(device_find_child_by_name(i2c, "rtc@43", &dev2));
 757         ut_asserteq_ptr(dev, dev2);
 758         ut_assertok(device_find_child_by_name(i2c, "rtc@61", &dev2));
 759         ut_asserteq_str("rtc@61", dev2->name);
 760
 761         ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_I2C_EEPROM,
 762                                                       &dev));
 763         ut_asserteq_str("eeprom@2c", dev->name);
 764         ut_assertok(device_find_child_by_name(i2c, "eeprom@2c", &dev2));
 765         ut_asserteq_ptr(dev, dev2);
 766
 767         ut_asserteq(-ENODEV, device_find_first_child_by_uclass(i2c,
 768                                                         UCLASS_VIDEO, &dev));
 769         ut_asserteq(-ENODEV, device_find_child_by_name(i2c, "missing", &dev));
 770
 771         return 0;
 772 }
 773 DM_TEST(dm_test_first_child, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 774
 775 /* Test integer functions in dm_read_...() */
 776 static int dm_test_read_int(struct unit_test_state *uts)
 777 {
 778         struct udevice *dev;
 779         u32 val32;
 780         s32 sval;
 781         uint val;
 782
 783         ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
 784         ut_asserteq_str("a-test", dev->name);
 785         ut_assertok(dev_read_u32(dev, "int-value", &val32));
 786         ut_asserteq(1234, val32);
 787
 788         ut_asserteq(-EINVAL, dev_read_u32(dev, "missing", &val32));
 789         ut_asserteq(6, dev_read_u32_default(dev, "missing", 6));
 790
 791         ut_asserteq(1234, dev_read_u32_default(dev, "int-value", 6));
 792         ut_asserteq(1234, val32);
 793
 794         ut_asserteq(-EINVAL, dev_read_s32(dev, "missing", &sval));
 795         ut_asserteq(6, dev_read_s32_default(dev, "missing", 6));
 796
 797         ut_asserteq(-1234, dev_read_s32_default(dev, "uint-value", 6));
 798         ut_assertok(dev_read_s32(dev, "uint-value", &sval));
 799         ut_asserteq(-1234, sval);
 800
 801         val = 0;
 802         ut_asserteq(-EINVAL, dev_read_u32u(dev, "missing", &val));
 803         ut_assertok(dev_read_u32u(dev, "uint-value", &val));
 804         ut_asserteq(-1234, val);
 805
 806         return 0;
 807 }
 808 DM_TEST(dm_test_read_int, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);