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
 494         /* Some simple translations */
 495         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 496         ut_asserteq_str("dev@0,0", dev->name);
 497         ut_asserteq(0x8000, dev_read_addr(dev));
 498
 499         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 1, true, &dev));
 500         ut_asserteq_str("dev@1,100", dev->name);
 501         ut_asserteq(0x9000, dev_read_addr(dev));
 502
 503         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 2, true, &dev));
 504         ut_asserteq_str("dev@2,200", dev->name);
 505         ut_asserteq(0xA000, dev_read_addr(dev));
 506
 507         /* No translation for busses with #size-cells == 0 */
 508         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 3, true, &dev));
 509         ut_asserteq_str("dev@42", dev->name);
 510         ut_asserteq(0x42, dev_read_addr(dev));
 511
 512         return 0;
 513 }
 514 DM_TEST(dm_test_fdt_translation, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 515
 516 static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
 517 {
 518         struct udevice *dev;
 519         fdt_addr_t addr;
 520         void *paddr;
 521
 522         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 523
 524         addr = devfdt_get_addr(dev);
 525         ut_asserteq(0x8000, addr);
 526
 527         paddr = map_physmem(addr, 0, MAP_NOCACHE);
 528         ut_assertnonnull(paddr);
 529         ut_asserteq_ptr(paddr, devfdt_remap_addr(dev));
 530
 531         return 0;
 532 }
 533 DM_TEST(dm_test_fdt_remap_addr_flat,
 534         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
 535
 536 static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
 537 {
 538         struct udevice *dev;
 539         fdt_addr_t addr;
 540         void *paddr;
 541
 542         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 543
 544         addr = devfdt_get_addr_index(dev, 0);
 545         ut_asserteq(0x8000, addr);
 546
 547         paddr = map_physmem(addr, 0, MAP_NOCACHE);
 548         ut_assertnonnull(paddr);
 549         ut_asserteq_ptr(paddr, devfdt_remap_addr_index(dev, 0));
 550
 551         return 0;
 552 }
 553 DM_TEST(dm_test_fdt_remap_addr_index_flat,
 554         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
 555
 556 static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
 557 {
 558         struct udevice *dev;
 559         fdt_addr_t addr;
 560         void *paddr;
 561
 562         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 563
 564         addr = devfdt_get_addr_name(dev, "sandbox-dummy-0");
 565         ut_asserteq(0x8000, addr);
 566
 567         paddr = map_physmem(addr, 0, MAP_NOCACHE);
 568         ut_assertnonnull(paddr);
 569         ut_asserteq_ptr(paddr, devfdt_remap_addr_name(dev, "sandbox-dummy-0"));
 570
 571         return 0;
 572 }
 573 DM_TEST(dm_test_fdt_remap_addr_name_flat,
 574         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
 575
 576 static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
 577 {
 578         struct udevice *dev;
 579         fdt_addr_t addr;
 580         void *paddr;
 581
 582         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 583
 584         addr = dev_read_addr(dev);
 585         ut_asserteq(0x8000, addr);
 586
 587         paddr = map_physmem(addr, 0, MAP_NOCACHE);
 588         ut_assertnonnull(paddr);
 589         ut_asserteq_ptr(paddr, dev_remap_addr(dev));
 590
 591         return 0;
 592 }
 593 DM_TEST(dm_test_fdt_remap_addr_live,
 594         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 595
 596 static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
 597 {
 598         struct udevice *dev;
 599         fdt_addr_t addr;
 600         void *paddr;
 601
 602         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 603
 604         addr = dev_read_addr_index(dev, 0);
 605         ut_asserteq(0x8000, addr);
 606
 607         paddr = map_physmem(addr, 0, MAP_NOCACHE);
 608         ut_assertnonnull(paddr);
 609         ut_asserteq_ptr(paddr, dev_remap_addr_index(dev, 0));
 610
 611         return 0;
 612 }
 613 DM_TEST(dm_test_fdt_remap_addr_index_live,
 614         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 615
 616 static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
 617 {
 618         struct udevice *dev;
 619         fdt_addr_t addr;
 620         void *paddr;
 621
 622         ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
 623
 624         addr = dev_read_addr_name(dev, "sandbox-dummy-0");
 625         ut_asserteq(0x8000, addr);
 626
 627         paddr = map_physmem(addr, 0, MAP_NOCACHE);
 628         ut_assertnonnull(paddr);
 629         ut_asserteq_ptr(paddr, dev_remap_addr_name(dev, "sandbox-dummy-0"));
 630
 631         return 0;
 632 }
 633 DM_TEST(dm_test_fdt_remap_addr_name_live,
 634         DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 635
 636 static int dm_test_fdt_livetree_writing(struct unit_test_state *uts)
 637 {
 638         struct udevice *dev;
 639         ofnode node;
 640
 641         if (!of_live_active()) {
 642                 printf("Live tree not active; ignore test\n");
 643                 return 0;
 644         }
 645
 646         /* Test enabling devices */
 647
 648         node = ofnode_path("/usb@2");
 649
 650         ut_assert(!of_device_is_available(ofnode_to_np(node)));
 651         ofnode_set_enabled(node, true);
 652         ut_assert(of_device_is_available(ofnode_to_np(node)));
 653
 654         device_bind_driver_to_node(dm_root(), "usb_sandbox", "usb@2", node,
 655                                    &dev);
 656         ut_assertok(uclass_find_device_by_seq(UCLASS_USB, 2, true, &dev));
 657
 658         /* Test string property setting */
 659
 660         ut_assert(device_is_compatible(dev, "sandbox,usb"));
 661         ofnode_write_string(node, "compatible", "gdsys,super-usb");
 662         ut_assert(device_is_compatible(dev, "gdsys,super-usb"));
 663         ofnode_write_string(node, "compatible", "sandbox,usb");
 664         ut_assert(device_is_compatible(dev, "sandbox,usb"));
 665
 666         /* Test setting generic properties */
 667
 668         /* Non-existent in DTB */
 669         ut_asserteq(FDT_ADDR_T_NONE, dev_read_addr(dev));
 670         /* reg = 0x42, size = 0x100 */
 671         ut_assertok(ofnode_write_prop(node, "reg", 8,
 672                                       "\x00\x00\x00\x42\x00\x00\x01\x00"));
 673         ut_asserteq(0x42, dev_read_addr(dev));
 674
 675         /* Test disabling devices */
 676
 677         device_remove(dev, DM_REMOVE_NORMAL);
 678         device_unbind(dev);
 679
 680         ut_assert(of_device_is_available(ofnode_to_np(node)));
 681         ofnode_set_enabled(node, false);
 682         ut_assert(!of_device_is_available(ofnode_to_np(node)));
 683
 684         return 0;
 685 }
 686 DM_TEST(dm_test_fdt_livetree_writing, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 687
 688 static int dm_test_fdt_disable_enable_by_path(struct unit_test_state *uts)
 689 {
 690         ofnode node;
 691
 692         if (!of_live_active()) {
 693                 printf("Live tree not active; ignore test\n");
 694                 return 0;
 695         }
 696
 697         node = ofnode_path("/usb@2");
 698
 699         /* Test enabling devices */
 700
 701         ut_assert(!of_device_is_available(ofnode_to_np(node)));
 702         dev_enable_by_path("/usb@2");
 703         ut_assert(of_device_is_available(ofnode_to_np(node)));
 704
 705         /* Test disabling devices */
 706
 707         ut_assert(of_device_is_available(ofnode_to_np(node)));
 708         dev_disable_by_path("/usb@2");
 709         ut_assert(!of_device_is_available(ofnode_to_np(node)));
 710
 711         return 0;
 712 }
 713 DM_TEST(dm_test_fdt_disable_enable_by_path, DM_TESTF_SCAN_PDATA |
 714                                             DM_TESTF_SCAN_FDT);
 715
 716 /* Test a few uclass phandle functions */
 717 static int dm_test_fdt_phandle(struct unit_test_state *uts)
 718 {
 719         struct udevice *back, *dev, *dev2;
 720
 721         ut_assertok(uclass_find_first_device(UCLASS_PANEL_BACKLIGHT, &back));
 722         ut_asserteq(-ENOENT, uclass_find_device_by_phandle(UCLASS_REGULATOR,
 723                                                         back, "missing", &dev));
 724         ut_assertok(uclass_find_device_by_phandle(UCLASS_REGULATOR, back,
 725                                                   "power-supply", &dev));
 726         ut_asserteq(0, device_active(dev));
 727         ut_asserteq_str("ldo1", dev->name);
 728         ut_assertok(uclass_get_device_by_phandle(UCLASS_REGULATOR, back,
 729                                                  "power-supply", &dev2));
 730         ut_asserteq_ptr(dev, dev2);
 731
 732         return 0;
 733 }
 734 DM_TEST(dm_test_fdt_phandle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 735
 736 /* Test device_find_first_child_by_uclass() */
 737 static int dm_test_first_child(struct unit_test_state *uts)
 738 {
 739         struct udevice *i2c, *dev, *dev2;
 740
 741         ut_assertok(uclass_first_device_err(UCLASS_I2C, &i2c));
 742         ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_RTC, &dev));
 743         ut_asserteq_str("rtc@43", dev->name);
 744         ut_assertok(device_find_child_by_name(i2c, "rtc@43", &dev2));
 745         ut_asserteq_ptr(dev, dev2);
 746         ut_assertok(device_find_child_by_name(i2c, "rtc@61", &dev2));
 747         ut_asserteq_str("rtc@61", dev2->name);
 748
 749         ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_I2C_EEPROM,
 750                                                       &dev));
 751         ut_asserteq_str("eeprom@2c", dev->name);
 752         ut_assertok(device_find_child_by_name(i2c, "eeprom@2c", &dev2));
 753         ut_asserteq_ptr(dev, dev2);
 754
 755         ut_asserteq(-ENODEV, device_find_first_child_by_uclass(i2c,
 756                                                         UCLASS_VIDEO, &dev));
 757         ut_asserteq(-ENODEV, device_find_child_by_name(i2c, "missing", &dev));
 758
 759         return 0;
 760 }
 761 DM_TEST(dm_test_first_child, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 762
 763 /* Test integer functions in dm_read_...() */
 764 static int dm_test_read_int(struct unit_test_state *uts)
 765 {
 766         struct udevice *dev;
 767         u32 val32;
 768         s32 sval;
 769         uint val;
 770
 771         ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
 772         ut_asserteq_str("a-test", dev->name);
 773         ut_assertok(dev_read_u32(dev, "int-value", &val32));
 774         ut_asserteq(1234, val32);
 775
 776         ut_asserteq(-EINVAL, dev_read_u32(dev, "missing", &val32));
 777         ut_asserteq(6, dev_read_u32_default(dev, "missing", 6));
 778
 779         ut_asserteq(1234, dev_read_u32_default(dev, "int-value", 6));
 780         ut_asserteq(1234, val32);
 781
 782         ut_asserteq(-EINVAL, dev_read_s32(dev, "missing", &sval));
 783         ut_asserteq(6, dev_read_s32_default(dev, "missing", 6));
 784
 785         ut_asserteq(-1234, dev_read_s32_default(dev, "uint-value", 6));
 786         ut_assertok(dev_read_s32(dev, "uint-value", &sval));
 787         ut_asserteq(-1234, sval);
 788
 789         val = 0;
 790         ut_asserteq(-EINVAL, dev_read_u32u(dev, "missing", &val));
 791         ut_assertok(dev_read_u32u(dev, "uint-value", &val));
 792         ut_asserteq(-1234, val);
 793
 794         return 0;
 795 }
 796 DM_TEST(dm_test_read_int, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);