test/dm/ofnode.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright 2022 Google LLC
   4  *
   5  * There are two types of tests in this file:
   6  * - normal ones which act on the control FDT (gd->fdt_blob or gd->of_root)
   7  * - 'other' ones which act on the 'other' FDT (other.dts)
   8  *
   9  * The 'other' ones have an _ot suffix.
  10  *
  11  * The latter are used to check behaviour with multiple device trees,
  12  * particularly with flat tree, where a tree ID is included in ofnode as part of
  13  * the node offset. These tests are typically just for making sure that the
  14  * offset makes it to libfdt correctly and that the resulting return value is
  15  * correctly turned into an ofnode. The 'other' tests do not fully check the
  16  * behaviour of each ofnode function, since that is done by the normal ones.
  17  */
  18
  19 #include <common.h>
  20 #include <dm.h>
  21 #include <log.h>
  22 #include <of_live.h>
  23 #include <dm/device-internal.h>
  24 #include <dm/lists.h>
  25 #include <dm/of_extra.h>
  26 #include <dm/root.h>
  27 #include <dm/test.h>
  28 #include <dm/uclass-internal.h>
  29 #include <test/test.h>
  30 #include <test/ut.h>
  31
  32 /**
  33  * get_other_oftree() - Convert a flat tree into an oftree object
  34  *
  35  * @uts: Test state
  36  * @return: oftree object for the 'other' FDT (see sandbox' other.dts)
  37  */
  38 oftree get_other_oftree(struct unit_test_state *uts)
  39 {
  40         oftree tree;
  41
  42         if (of_live_active())
  43                 tree = oftree_from_np(uts->of_other);
  44         else
  45                 tree = oftree_from_fdt(uts->other_fdt);
  46
  47         /* An invalid tree may cause failure or crashes */
  48         if (!oftree_valid(tree))
  49                 ut_reportf("test needs the UT_TESTF_OTHER_FDT flag");
  50
  51         return tree;
  52 }
  53
  54 /**
  55  * get_oftree() - Convert a flat tree into an oftree object
  56  *
  57  * @uts: Test state
  58  * @fdt: Pointer to flat tree
  59  * @treep: Returns the tree, on success
  60  * Return: 0 if OK, 1 if the tree failed to unflatten, -EOVERFLOW if there are
  61  * too many flat trees to allow another one to be registers (see
  62  * oftree_ensure())
  63  */
  64 int get_oftree(struct unit_test_state *uts, void *fdt, oftree *treep)
  65 {
  66         oftree tree;
  67
  68         if (of_live_active()) {
  69                 struct device_node *root;
  70
  71                 ut_assertok(unflatten_device_tree(fdt, &root));
  72                 tree = oftree_from_np(root);
  73         } else {
  74                 tree = oftree_from_fdt(fdt);
  75                 if (!oftree_valid(tree))
  76                         return -EOVERFLOW;
  77         }
  78         *treep = tree;
  79
  80         return 0;
  81 }
  82
  83 /**
  84  * free_oftree() - Free memory used by get_oftree()
  85  *
  86  * @tree: Tree to free
  87  */
  88 void free_oftree(oftree tree)
  89 {
  90         if (of_live_active())
  91                 free(tree.np);
  92 }
  93
  94 static int dm_test_ofnode_compatible(struct unit_test_state *uts)
  95 {
  96         ofnode root_node = ofnode_path("/");
  97
  98         ut_assert(ofnode_valid(root_node));
  99         ut_assert(ofnode_device_is_compatible(root_node, "sandbox"));
 100
 101         return 0;
 102 }
 103 DM_TEST(dm_test_ofnode_compatible,
 104         UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 105
 106 /* check ofnode_device_is_compatible() with the 'other' FDT */
 107 static int dm_test_ofnode_compatible_ot(struct unit_test_state *uts)
 108 {
 109         oftree otree = get_other_oftree(uts);
 110         ofnode oroot = oftree_root(otree);
 111
 112         ut_assert(ofnode_valid(oroot));
 113         ut_assert(ofnode_device_is_compatible(oroot, "sandbox-other"));
 114
 115         return 0;
 116 }
 117 DM_TEST(dm_test_ofnode_compatible_ot, UT_TESTF_OTHER_FDT);
 118
 119 static int dm_test_ofnode_get_by_phandle(struct unit_test_state *uts)
 120 {
 121         /* test invalid phandle */
 122         ut_assert(!ofnode_valid(ofnode_get_by_phandle(0)));
 123         ut_assert(!ofnode_valid(ofnode_get_by_phandle(-1)));
 124
 125         /* test first valid phandle */
 126         ut_assert(ofnode_valid(ofnode_get_by_phandle(1)));
 127
 128         /* test unknown phandle */
 129         ut_assert(!ofnode_valid(ofnode_get_by_phandle(0x1000000)));
 130
 131         ut_assert(ofnode_valid(oftree_get_by_phandle(oftree_default(), 1)));
 132
 133         return 0;
 134 }
 135 DM_TEST(dm_test_ofnode_get_by_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 136
 137 static int dm_test_ofnode_get_by_phandle_ot(struct unit_test_state *uts)
 138 {
 139         oftree otree = get_other_oftree(uts);
 140         ofnode node;
 141
 142         ut_assert(ofnode_valid(oftree_get_by_phandle(oftree_default(), 1)));
 143         node = oftree_get_by_phandle(otree, 1);
 144         ut_assert(ofnode_valid(node));
 145         ut_asserteq_str("target", ofnode_get_name(node));
 146
 147         return 0;
 148 }
 149 DM_TEST(dm_test_ofnode_get_by_phandle_ot, UT_TESTF_OTHER_FDT);
 150
 151 static int check_prop_values(struct unit_test_state *uts, ofnode start,
 152                              const char *propname, const char *propval,
 153                              int expect_count)
 154 {
 155         int proplen = strlen(propval) + 1;
 156         const char *str;
 157         ofnode node;
 158         int count;
 159
 160         /* Find first matching node, there should be at least one */
 161         node = ofnode_by_prop_value(start, propname, propval, proplen);
 162         ut_assert(ofnode_valid(node));
 163         str = ofnode_read_string(node, propname);
 164         ut_assert(str && !strcmp(str, propval));
 165
 166         /* Find the rest of the matching nodes */
 167         count = 1;
 168         while (true) {
 169                 node = ofnode_by_prop_value(node, propname, propval, proplen);
 170                 if (!ofnode_valid(node))
 171                         break;
 172                 str = ofnode_read_string(node, propname);
 173                 ut_asserteq_str(propval, str);
 174                 count++;
 175         }
 176         ut_asserteq(expect_count, count);
 177
 178         return 0;
 179 }
 180
 181 static int dm_test_ofnode_by_prop_value(struct unit_test_state *uts)
 182 {
 183         ut_assertok(check_prop_values(uts, ofnode_null(), "compatible",
 184                                       "denx,u-boot-fdt-test", 11));
 185
 186         return 0;
 187 }
 188 DM_TEST(dm_test_ofnode_by_prop_value, UT_TESTF_SCAN_FDT);
 189
 190 static int dm_test_ofnode_by_prop_value_ot(struct unit_test_state *uts)
 191 {
 192         oftree otree = get_other_oftree(uts);
 193
 194         ut_assertok(check_prop_values(uts, oftree_root(otree), "str-prop",
 195                                       "other", 2));
 196
 197         return 0;
 198 }
 199 DM_TEST(dm_test_ofnode_by_prop_value_ot, UT_TESTF_OTHER_FDT);
 200
 201 static int dm_test_ofnode_fmap(struct unit_test_state *uts)
 202 {
 203         struct fmap_entry entry;
 204         ofnode node;
 205
 206         node = ofnode_path("/cros-ec/flash");
 207         ut_assert(ofnode_valid(node));
 208         ut_assertok(ofnode_read_fmap_entry(node, &entry));
 209         ut_asserteq(0x08000000, entry.offset);
 210         ut_asserteq(0x20000, entry.length);
 211
 212         return 0;
 213 }
 214 DM_TEST(dm_test_ofnode_fmap, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 215
 216 static int dm_test_ofnode_read(struct unit_test_state *uts)
 217 {
 218         const u32 *val;
 219         ofnode node;
 220         int size;
 221
 222         node = ofnode_path("/a-test");
 223         ut_assert(ofnode_valid(node));
 224
 225         val = ofnode_read_prop(node, "int-value", &size);
 226         ut_assertnonnull(val);
 227         ut_asserteq(4, size);
 228         ut_asserteq(1234, fdt32_to_cpu(val[0]));
 229
 230         val = ofnode_read_prop(node, "missing", &size);
 231         ut_assertnull(val);
 232         ut_asserteq(-FDT_ERR_NOTFOUND, size);
 233
 234         /* Check it works without a size parameter */
 235         val = ofnode_read_prop(node, "missing", NULL);
 236         ut_assertnull(val);
 237
 238         return 0;
 239 }
 240 DM_TEST(dm_test_ofnode_read, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 241
 242 static int dm_test_ofnode_read_ot(struct unit_test_state *uts)
 243 {
 244         oftree otree = get_other_oftree(uts);
 245         const char *val;
 246         ofnode node;
 247         int size;
 248
 249         node = oftree_path(otree, "/node/subnode");
 250         ut_assert(ofnode_valid(node));
 251
 252         val = ofnode_read_prop(node, "str-prop", &size);
 253         ut_assertnonnull(val);
 254         ut_asserteq_str("other", val);
 255         ut_asserteq(6, size);
 256
 257         return 0;
 258 }
 259 DM_TEST(dm_test_ofnode_read_ot, UT_TESTF_OTHER_FDT);
 260
 261 static int dm_test_ofnode_phandle(struct unit_test_state *uts)
 262 {
 263         struct ofnode_phandle_args args;
 264         ofnode node;
 265         int ret;
 266         const char prop[] = "test-gpios";
 267         const char cell[] = "#gpio-cells";
 268         const char prop2[] = "phandle-value";
 269
 270         node = ofnode_path("/a-test");
 271         ut_assert(ofnode_valid(node));
 272
 273         /* Test ofnode_count_phandle_with_args with cell name */
 274         ret = ofnode_count_phandle_with_args(node, "missing", cell, 0);
 275         ut_asserteq(-ENOENT, ret);
 276         ret = ofnode_count_phandle_with_args(node, prop, "#invalid", 0);
 277         ut_asserteq(-EINVAL, ret);
 278         ret = ofnode_count_phandle_with_args(node, prop, cell, 0);
 279         ut_asserteq(5, ret);
 280
 281         /* Test ofnode_parse_phandle_with_args with cell name */
 282         ret = ofnode_parse_phandle_with_args(node, "missing", cell, 0, 0,
 283                                              &args);
 284         ut_asserteq(-ENOENT, ret);
 285         ret = ofnode_parse_phandle_with_args(node, prop, "#invalid", 0, 0,
 286                                              &args);
 287         ut_asserteq(-EINVAL, ret);
 288         ret = ofnode_parse_phandle_with_args(node, prop, cell, 0, 0, &args);
 289         ut_assertok(ret);
 290         ut_asserteq(1, args.args_count);
 291         ut_asserteq(1, args.args[0]);
 292         ret = ofnode_parse_phandle_with_args(node, prop, cell, 0, 1, &args);
 293         ut_assertok(ret);
 294         ut_asserteq(1, args.args_count);
 295         ut_asserteq(4, args.args[0]);
 296         ret = ofnode_parse_phandle_with_args(node, prop, cell, 0, 2, &args);
 297         ut_assertok(ret);
 298         ut_asserteq(5, args.args_count);
 299         ut_asserteq(5, args.args[0]);
 300         ut_asserteq(1, args.args[4]);
 301         ret = ofnode_parse_phandle_with_args(node, prop, cell, 0, 3, &args);
 302         ut_asserteq(-ENOENT, ret);
 303         ret = ofnode_parse_phandle_with_args(node, prop, cell, 0, 4, &args);
 304         ut_assertok(ret);
 305         ut_asserteq(1, args.args_count);
 306         ut_asserteq(12, args.args[0]);
 307         ret = ofnode_parse_phandle_with_args(node, prop, cell, 0, 5, &args);
 308         ut_asserteq(-ENOENT, ret);
 309
 310         /* Test ofnode_count_phandle_with_args with cell count */
 311         ret = ofnode_count_phandle_with_args(node, "missing", NULL, 2);
 312         ut_asserteq(-ENOENT, ret);
 313         ret = ofnode_count_phandle_with_args(node, prop2, NULL, 1);
 314         ut_asserteq(3, ret);
 315
 316         /* Test ofnode_parse_phandle_with_args with cell count */
 317         ret = ofnode_parse_phandle_with_args(node, prop2, NULL, 1, 0, &args);
 318         ut_assertok(ret);
 319         ut_asserteq(1, ofnode_valid(args.node));
 320         ut_asserteq(1, args.args_count);
 321         ut_asserteq(10, args.args[0]);
 322         ret = ofnode_parse_phandle_with_args(node, prop2, NULL, 1, 1, &args);
 323         ut_asserteq(-EINVAL, ret);
 324         ret = ofnode_parse_phandle_with_args(node, prop2, NULL, 1, 2, &args);
 325         ut_assertok(ret);
 326         ut_asserteq(1, ofnode_valid(args.node));
 327         ut_asserteq(1, args.args_count);
 328         ut_asserteq(30, args.args[0]);
 329         ret = ofnode_parse_phandle_with_args(node, prop2, NULL, 1, 3, &args);
 330         ut_asserteq(-ENOENT, ret);
 331
 332         return 0;
 333 }
 334 DM_TEST(dm_test_ofnode_phandle, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 335
 336 static int dm_test_ofnode_phandle_ot(struct unit_test_state *uts)
 337 {
 338         oftree otree = get_other_oftree(uts);
 339         struct ofnode_phandle_args args;
 340         ofnode node;
 341         int ret;
 342
 343         node = oftree_path(otree, "/node");
 344
 345         /* Test ofnode_count_phandle_with_args with cell name */
 346         ret = ofnode_count_phandle_with_args(node, "missing", "#gpio-cells", 0);
 347         ut_asserteq(-ENOENT, ret);
 348         ret = ofnode_count_phandle_with_args(node, "target", "#invalid", 0);
 349         ut_asserteq(-EINVAL, ret);
 350         ret = ofnode_count_phandle_with_args(node, "target", "#gpio-cells", 0);
 351         ut_asserteq(1, ret);
 352
 353         ret = ofnode_parse_phandle_with_args(node, "target", "#gpio-cells", 0,
 354                                              0, &args);
 355         ut_assertok(ret);
 356         ut_asserteq(2, args.args_count);
 357         ut_asserteq(3, args.args[0]);
 358         ut_asserteq(4, args.args[1]);
 359
 360         return 0;
 361 }
 362 DM_TEST(dm_test_ofnode_phandle_ot, UT_TESTF_OTHER_FDT);
 363
 364 static int dm_test_ofnode_read_chosen(struct unit_test_state *uts)
 365 {
 366         const char *str;
 367         const u32 *val;
 368         ofnode node;
 369         int size;
 370
 371         str = ofnode_read_chosen_string("setting");
 372         ut_assertnonnull(str);
 373         ut_asserteq_str("sunrise ohoka", str);
 374         ut_asserteq_ptr(NULL, ofnode_read_chosen_string("no-setting"));
 375
 376         node = ofnode_get_chosen_node("other-node");
 377         ut_assert(ofnode_valid(node));
 378         ut_asserteq_str("c-test@5", ofnode_get_name(node));
 379
 380         node = ofnode_get_chosen_node("setting");
 381         ut_assert(!ofnode_valid(node));
 382
 383         val = ofnode_read_chosen_prop("int-values", &size);
 384         ut_assertnonnull(val);
 385         ut_asserteq(8, size);
 386         ut_asserteq(0x1937, fdt32_to_cpu(val[0]));
 387         ut_asserteq(72993, fdt32_to_cpu(val[1]));
 388
 389         return 0;
 390 }
 391 DM_TEST(dm_test_ofnode_read_chosen, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 392
 393 static int dm_test_ofnode_read_aliases(struct unit_test_state *uts)
 394 {
 395         const void *val;
 396         ofnode node;
 397         int size;
 398
 399         node = ofnode_get_aliases_node("ethernet3");
 400         ut_assert(ofnode_valid(node));
 401         ut_asserteq_str("sbe5", ofnode_get_name(node));
 402
 403         node = ofnode_get_aliases_node("unknown");
 404         ut_assert(!ofnode_valid(node));
 405
 406         val = ofnode_read_aliases_prop("spi0", &size);
 407         ut_assertnonnull(val);
 408         ut_asserteq(7, size);
 409         ut_asserteq_str("/spi@0", (const char *)val);
 410
 411         return 0;
 412 }
 413 DM_TEST(dm_test_ofnode_read_aliases, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 414
 415 static int dm_test_ofnode_get_child_count(struct unit_test_state *uts)
 416 {
 417         ofnode node, child_node;
 418         u32 val;
 419
 420         node = ofnode_path("/i-test");
 421         ut_assert(ofnode_valid(node));
 422
 423         val = ofnode_get_child_count(node);
 424         ut_asserteq(3, val);
 425
 426         child_node = ofnode_first_subnode(node);
 427         ut_assert(ofnode_valid(child_node));
 428         val = ofnode_get_child_count(child_node);
 429         ut_asserteq(0, val);
 430
 431         return 0;
 432 }
 433 DM_TEST(dm_test_ofnode_get_child_count,
 434         UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 435
 436 static int dm_test_ofnode_get_child_count_ot(struct unit_test_state *uts)
 437 {
 438         oftree otree = get_other_oftree(uts);
 439         ofnode node, child_node;
 440         u32 val;
 441
 442         node = oftree_path(otree, "/node");
 443         ut_assert(ofnode_valid(node));
 444
 445         val = ofnode_get_child_count(node);
 446         ut_asserteq(2, val);
 447
 448         child_node = ofnode_first_subnode(node);
 449         ut_assert(ofnode_valid(child_node));
 450         val = ofnode_get_child_count(child_node);
 451         ut_asserteq(0, val);
 452
 453         return 0;
 454 }
 455 DM_TEST(dm_test_ofnode_get_child_count_ot, UT_TESTF_OTHER_FDT);
 456
 457 static int dm_test_ofnode_is_enabled(struct unit_test_state *uts)
 458 {
 459         ofnode root_node = ofnode_path("/");
 460         ofnode node = ofnode_path("/usb@0");
 461
 462         ut_assert(ofnode_is_enabled(root_node));
 463         ut_assert(!ofnode_is_enabled(node));
 464
 465         return 0;
 466 }
 467 DM_TEST(dm_test_ofnode_is_enabled, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 468
 469 static int dm_test_ofnode_is_enabled_ot(struct unit_test_state *uts)
 470 {
 471         oftree otree = get_other_oftree(uts);
 472         ofnode root_node = oftree_root(otree);
 473         ofnode node = oftree_path(otree, "/target");
 474
 475         ut_assert(ofnode_is_enabled(root_node));
 476         ut_assert(!ofnode_is_enabled(node));
 477
 478         return 0;
 479 }
 480 DM_TEST(dm_test_ofnode_is_enabled_ot, UT_TESTF_OTHER_FDT);
 481
 482 static int dm_test_ofnode_get_reg(struct unit_test_state *uts)
 483 {
 484         ofnode node;
 485         fdt_addr_t addr;
 486         fdt_size_t size;
 487
 488         node = ofnode_path("/translation-test@8000");
 489         ut_assert(ofnode_valid(node));
 490         addr = ofnode_get_addr(node);
 491         size = ofnode_get_size(node);
 492         ut_asserteq(0x8000, addr);
 493         ut_asserteq(0x4000, size);
 494
 495         node = ofnode_path("/translation-test@8000/dev@1,100");
 496         ut_assert(ofnode_valid(node));
 497         addr = ofnode_get_addr(node);
 498         size = ofnode_get_size(node);
 499         ut_asserteq(0x9000, addr);
 500         ut_asserteq(0x1000, size);
 501
 502         node = ofnode_path("/emul-mux-controller");
 503         ut_assert(ofnode_valid(node));
 504         addr = ofnode_get_addr(node);
 505         size = ofnode_get_size(node);
 506         ut_asserteq_64(FDT_ADDR_T_NONE, addr);
 507         ut_asserteq(FDT_SIZE_T_NONE, size);
 508
 509         node = ofnode_path("/translation-test@8000/noxlatebus@3,300/dev@42");
 510         ut_assert(ofnode_valid(node));
 511         addr = ofnode_get_addr_size_index_notrans(node, 0, &size);
 512         ut_asserteq_64(0x42, addr);
 513
 514         return 0;
 515 }
 516 DM_TEST(dm_test_ofnode_get_reg, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 517
 518 static int dm_test_ofnode_get_reg_ot(struct unit_test_state *uts)
 519 {
 520         oftree otree = get_other_oftree(uts);
 521         ofnode node = oftree_path(otree, "/target");
 522         fdt_addr_t addr;
 523
 524         addr = ofnode_get_addr(node);
 525         ut_asserteq(0x8000, addr);
 526
 527         return 0;
 528 }
 529 DM_TEST(dm_test_ofnode_get_reg_ot, UT_TESTF_OTHER_FDT);
 530
 531 static int dm_test_ofnode_get_path(struct unit_test_state *uts)
 532 {
 533         const char *path = "/translation-test@8000/noxlatebus@3,300/dev@42";
 534         char buf[64];
 535         ofnode node;
 536
 537         node = ofnode_path(path);
 538         ut_assert(ofnode_valid(node));
 539
 540         ut_assertok(ofnode_get_path(node, buf, sizeof(buf)));
 541         ut_asserteq_str(path, buf);
 542
 543         ut_asserteq(-ENOSPC, ofnode_get_path(node, buf, 32));
 544
 545         ut_assertok(ofnode_get_path(ofnode_root(), buf, 32));
 546         ut_asserteq_str("/", buf);
 547
 548         return 0;
 549 }
 550 DM_TEST(dm_test_ofnode_get_path, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 551
 552 static int dm_test_ofnode_get_path_ot(struct unit_test_state *uts)
 553 {
 554         oftree otree = get_other_oftree(uts);
 555         const char *path = "/node/subnode";
 556         ofnode node = oftree_path(otree, path);
 557         char buf[64];
 558
 559         ut_assert(ofnode_valid(node));
 560
 561         ut_assertok(ofnode_get_path(node, buf, sizeof(buf)));
 562         ut_asserteq_str(path, buf);
 563
 564         ut_assertok(ofnode_get_path(oftree_root(otree), buf, 32));
 565         ut_asserteq_str("/", buf);
 566
 567         return 0;
 568 }
 569 DM_TEST(dm_test_ofnode_get_path_ot, UT_TESTF_OTHER_FDT);
 570
 571 static int dm_test_ofnode_conf(struct unit_test_state *uts)
 572 {
 573         ut_assert(!ofnode_conf_read_bool("missing"));
 574         ut_assert(ofnode_conf_read_bool("testing-bool"));
 575
 576         ut_asserteq(123, ofnode_conf_read_int("testing-int", 0));
 577         ut_asserteq(6, ofnode_conf_read_int("missing", 6));
 578
 579         ut_assertnull(ofnode_conf_read_str("missing"));
 580         ut_asserteq_str("testing", ofnode_conf_read_str("testing-str"));
 581
 582         return 0;
 583 }
 584 DM_TEST(dm_test_ofnode_conf, 0);
 585
 586 static int dm_test_ofnode_for_each_compatible_node(struct unit_test_state *uts)
 587 {
 588         const char compatible[] = "denx,u-boot-fdt-test";
 589         bool found = false;
 590         ofnode node;
 591
 592         ofnode_for_each_compatible_node(node, compatible) {
 593                 ut_assert(ofnode_device_is_compatible(node, compatible));
 594                 found = true;
 595         }
 596
 597         /* There should be at least one matching node */
 598         ut_assert(found);
 599
 600         return 0;
 601 }
 602 DM_TEST(dm_test_ofnode_for_each_compatible_node, UT_TESTF_SCAN_FDT);
 603
 604 static int dm_test_ofnode_string(struct unit_test_state *uts)
 605 {
 606         const char **val;
 607         const char *out;
 608         ofnode node;
 609
 610         node = ofnode_path("/a-test");
 611         ut_assert(ofnode_valid(node));
 612
 613         /* single string */
 614         ut_asserteq(1, ofnode_read_string_count(node, "str-value"));
 615         ut_assertok(ofnode_read_string_index(node, "str-value", 0, &out));
 616         ut_asserteq_str("test string", out);
 617         ut_asserteq(0, ofnode_stringlist_search(node, "str-value",
 618                                                 "test string"));
 619         ut_asserteq(1, ofnode_read_string_list(node, "str-value", &val));
 620         ut_asserteq_str("test string", val[0]);
 621         ut_assertnull(val[1]);
 622         free(val);
 623
 624         /* list of strings */
 625         ut_asserteq(5, ofnode_read_string_count(node, "mux-control-names"));
 626         ut_assertok(ofnode_read_string_index(node, "mux-control-names", 0,
 627                                              &out));
 628         ut_asserteq_str("mux0", out);
 629         ut_asserteq(0, ofnode_stringlist_search(node, "mux-control-names",
 630                                                 "mux0"));
 631         ut_asserteq(5, ofnode_read_string_list(node, "mux-control-names",
 632                                                &val));
 633         ut_asserteq_str("mux0", val[0]);
 634         ut_asserteq_str("mux1", val[1]);
 635         ut_asserteq_str("mux2", val[2]);
 636         ut_asserteq_str("mux3", val[3]);
 637         ut_asserteq_str("mux4", val[4]);
 638         ut_assertnull(val[5]);
 639         free(val);
 640
 641         ut_assertok(ofnode_read_string_index(node, "mux-control-names", 4,
 642                                              &out));
 643         ut_asserteq_str("mux4", out);
 644         ut_asserteq(4, ofnode_stringlist_search(node, "mux-control-names",
 645                                                 "mux4"));
 646
 647         return 0;
 648 }
 649 DM_TEST(dm_test_ofnode_string, 0);
 650
 651 static int dm_test_ofnode_string_err(struct unit_test_state *uts)
 652 {
 653         const char **val;
 654         const char *out;
 655         ofnode node;
 656
 657         /*
 658          * Test error codes only on livetree, as they are different with
 659          * flattree
 660          */
 661         node = ofnode_path("/a-test");
 662         ut_assert(ofnode_valid(node));
 663
 664         /* non-existent property */
 665         ut_asserteq(-EINVAL, ofnode_read_string_count(node, "missing"));
 666         ut_asserteq(-EINVAL, ofnode_read_string_index(node, "missing", 0,
 667                                                       &out));
 668         ut_asserteq(-EINVAL, ofnode_read_string_list(node, "missing", &val));
 669
 670         /* empty property */
 671         ut_asserteq(-ENODATA, ofnode_read_string_count(node, "bool-value"));
 672         ut_asserteq(-ENODATA, ofnode_read_string_index(node, "bool-value", 0,
 673                                                        &out));
 674         ut_asserteq(-ENODATA, ofnode_read_string_list(node, "bool-value",
 675                                                      &val));
 676
 677         /* badly formatted string list */
 678         ut_asserteq(-EILSEQ, ofnode_read_string_count(node, "int64-value"));
 679         ut_asserteq(-EILSEQ, ofnode_read_string_index(node, "int64-value", 0,
 680                                                        &out));
 681         ut_asserteq(-EILSEQ, ofnode_read_string_list(node, "int64-value",
 682                                                      &val));
 683
 684         /* out of range / not found */
 685         ut_asserteq(-ENODATA, ofnode_read_string_index(node, "str-value", 1,
 686                                                        &out));
 687         ut_asserteq(-ENODATA, ofnode_stringlist_search(node, "str-value",
 688                                                        "other"));
 689
 690         /* negative value for index is not allowed, so don't test for that */
 691
 692         ut_asserteq(-ENODATA, ofnode_read_string_index(node,
 693                                                        "mux-control-names", 5,
 694                                                        &out));
 695
 696         return 0;
 697 }
 698 DM_TEST(dm_test_ofnode_string_err, UT_TESTF_LIVE_TREE);
 699
 700 static int dm_test_ofnode_get_phy(struct unit_test_state *uts)
 701 {
 702         ofnode eth_node, phy_node;
 703         phy_interface_t mode;
 704         u32 reg;
 705
 706         eth_node = ofnode_path("/phy-test-eth");
 707         ut_assert(ofnode_valid(eth_node));
 708
 709         mode = ofnode_read_phy_mode(eth_node);
 710         ut_assert(mode == PHY_INTERFACE_MODE_2500BASEX);
 711
 712         phy_node = ofnode_get_phy_node(eth_node);
 713         ut_assert(ofnode_valid(phy_node));
 714
 715         reg = ofnode_read_u32_default(phy_node, "reg", -1U);
 716         ut_asserteq_64(0x1, reg);
 717
 718         return 0;
 719 }
 720 DM_TEST(dm_test_ofnode_get_phy, 0);
 721
 722 /**
 723  * make_ofnode_fdt() - Create an FDT for testing with ofnode
 724  *
 725  * The size is set to the minimum needed
 726  *
 727  * @uts: Test state
 728  * @fdt: Place to write FDT
 729  * @size: Maximum size of space for fdt
 730  * @id: id value to add to the tree ('id' property in root node)
 731  */
 732 static int make_ofnode_fdt(struct unit_test_state *uts, void *fdt, int size,
 733                            int id)
 734 {
 735         ut_assertok(fdt_create(fdt, size));
 736         ut_assertok(fdt_finish_reservemap(fdt));
 737         ut_assert(fdt_begin_node(fdt, "") >= 0);
 738
 739         ut_assertok(fdt_property_u32(fdt, "id", id));
 740
 741         ut_assert(fdt_begin_node(fdt, "aliases") >= 0);
 742         ut_assertok(fdt_property_string(fdt, "mmc0", "/new-mmc"));
 743         ut_assertok(fdt_end_node(fdt));
 744
 745         ut_assert(fdt_begin_node(fdt, "new-mmc") >= 0);
 746         ut_assertok(fdt_end_node(fdt));
 747
 748         ut_assertok(fdt_end_node(fdt));
 749         ut_assertok(fdt_finish(fdt));
 750
 751         return 0;
 752 }
 753
 754 static int dm_test_ofnode_root(struct unit_test_state *uts)
 755 {
 756         char fdt[256];
 757         oftree tree;
 758         ofnode node;
 759         int ret;
 760
 761         /* Check that aliases work on the control FDT */
 762         node = ofnode_get_aliases_node("ethernet3");
 763         ut_assert(ofnode_valid(node));
 764         ut_asserteq_str("sbe5", ofnode_get_name(node));
 765
 766         ut_assert(!oftree_valid(oftree_null()));
 767
 768         ut_assertok(make_ofnode_fdt(uts, fdt, sizeof(fdt), 0));
 769         ret = get_oftree(uts, fdt, &tree);
 770
 771         /* skip the rest of this test if multiple FDTs are not supported */
 772         if (ret == -EOVERFLOW)
 773                 return 0;
 774
 775         ut_assertok(ret);
 776         ut_assert(oftree_valid(tree));
 777
 778         /* Make sure they don't work on this new tree */
 779         node = oftree_path(tree, "mmc0");
 780         ut_assert(!ofnode_valid(node));
 781
 782         /* It should appear in the new tree */
 783         node = oftree_path(tree, "/new-mmc");
 784         ut_assert(ofnode_valid(node));
 785
 786         /* ...and not in the control FDT */
 787         node = oftree_path(oftree_default(), "/new-mmc");
 788         ut_assert(!ofnode_valid(node));
 789
 790         free_oftree(tree);
 791
 792         return 0;
 793 }
 794 DM_TEST(dm_test_ofnode_root, UT_TESTF_SCAN_FDT);
 795
 796 static int dm_test_ofnode_livetree_writing(struct unit_test_state *uts)
 797 {
 798         struct udevice *dev;
 799         ofnode node;
 800
 801         /* Test enabling devices */
 802         node = ofnode_path("/usb@2");
 803
 804         ut_assert(!ofnode_is_enabled(node));
 805         ut_assertok(ofnode_set_enabled(node, true));
 806         ut_asserteq(true, ofnode_is_enabled(node));
 807
 808         device_bind_driver_to_node(dm_root(), "usb_sandbox", "usb@2", node,
 809                                    &dev);
 810         ut_assertok(uclass_find_device_by_seq(UCLASS_USB, 2, &dev));
 811
 812         /* Test string property setting */
 813         ut_assert(device_is_compatible(dev, "sandbox,usb"));
 814         ofnode_write_string(node, "compatible", "gdsys,super-usb");
 815         ut_assert(device_is_compatible(dev, "gdsys,super-usb"));
 816         ofnode_write_string(node, "compatible", "sandbox,usb");
 817         ut_assert(device_is_compatible(dev, "sandbox,usb"));
 818
 819         /* Test setting generic properties */
 820
 821         /* Non-existent in DTB */
 822         ut_asserteq_64(FDT_ADDR_T_NONE, dev_read_addr(dev));
 823         /* reg = 0x42, size = 0x100 */
 824         ut_assertok(ofnode_write_prop(node, "reg",
 825                                       "\x00\x00\x00\x42\x00\x00\x01\x00", 8,
 826                                       false));
 827         ut_asserteq(0x42, dev_read_addr(dev));
 828
 829         /* Test disabling devices */
 830         device_remove(dev, DM_REMOVE_NORMAL);
 831         device_unbind(dev);
 832
 833         ut_assert(ofnode_is_enabled(node));
 834         ut_assertok(ofnode_set_enabled(node, false));
 835         ut_assert(!ofnode_is_enabled(node));
 836
 837         return 0;
 838 }
 839 DM_TEST(dm_test_ofnode_livetree_writing,
 840         UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 841
 842 static int check_write_prop(struct unit_test_state *uts, ofnode node)
 843 {
 844         char prop[] = "middle-name";
 845         char name[10];
 846         int len;
 847
 848         strcpy(name, "cecil");
 849         len = strlen(name) + 1;
 850         ut_assertok(ofnode_write_prop(node, prop, name, len, false));
 851         ut_asserteq_str(name, ofnode_read_string(node, prop));
 852
 853         /* change the underlying value, this should mess up the live tree */
 854         strcpy(name, "tony");
 855         if (of_live_active()) {
 856                 ut_asserteq_str(name, ofnode_read_string(node, prop));
 857         } else {
 858                 ut_asserteq_str("cecil", ofnode_read_string(node, prop));
 859         }
 860
 861         /* try again, this time copying the property */
 862         strcpy(name, "mary");
 863         ut_assertok(ofnode_write_prop(node, prop, name, len, true));
 864         ut_asserteq_str(name, ofnode_read_string(node, prop));
 865         strcpy(name, "leah");
 866
 867         /* both flattree and livetree behave the same */
 868         ut_asserteq_str("mary", ofnode_read_string(node, prop));
 869
 870         return 0;
 871 }
 872
 873 /* writing the tree with and without copying the property */
 874 static int dm_test_ofnode_write_copy(struct unit_test_state *uts)
 875 {
 876         ofnode node;
 877
 878         node = ofnode_path("/a-test");
 879         ut_assertok(check_write_prop(uts, node));
 880
 881         return 0;
 882 }
 883 DM_TEST(dm_test_ofnode_write_copy, UT_TESTF_SCAN_FDT);
 884
 885 static int dm_test_ofnode_write_copy_ot(struct unit_test_state *uts)
 886 {
 887         oftree otree = get_other_oftree(uts);
 888         ofnode node, check_node;
 889
 890         node = oftree_path(otree, "/node");
 891         ut_assertok(check_write_prop(uts, node));
 892
 893         /* make sure the control FDT is not touched */
 894         check_node = ofnode_path("/node");
 895         ut_assertnull(ofnode_read_string(check_node, "middle-name"));
 896
 897         return 0;
 898 }
 899 DM_TEST(dm_test_ofnode_write_copy_ot, UT_TESTF_OTHER_FDT);
 900
 901 static int dm_test_ofnode_u32(struct unit_test_state *uts)
 902 {
 903         ofnode node;
 904         u32 val;
 905
 906         node = ofnode_path("/lcd");
 907         ut_assert(ofnode_valid(node));
 908         ut_asserteq(1366, ofnode_read_u32_default(node, "xres", 123));
 909         ut_assertok(ofnode_write_u32(node, "xres", 1367));
 910         ut_asserteq(1367, ofnode_read_u32_default(node, "xres", 123));
 911         ut_assertok(ofnode_write_u32(node, "xres", 1366));
 912
 913         node = ofnode_path("/backlight");
 914         ut_assertok(ofnode_read_u32_index(node, "brightness-levels", 0, &val));
 915         ut_asserteq(0, val);
 916         ut_assertok(ofnode_read_u32_index(node, "brightness-levels", 1, &val));
 917         ut_asserteq(16, val);
 918         ut_assertok(ofnode_read_u32_index(node, "brightness-levels", 8, &val));
 919         ut_asserteq(255, val);
 920         ut_asserteq(-EOVERFLOW,
 921                     ofnode_read_u32_index(node, "brightness-levels", 9, &val));
 922         ut_asserteq(-EINVAL, ofnode_read_u32_index(node, "missing", 0, &val));
 923
 924         return 0;
 925 }
 926 DM_TEST(dm_test_ofnode_u32, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 927
 928 static int dm_test_ofnode_u32_array(struct unit_test_state *uts)
 929 {
 930         ofnode node;
 931         u32 val[10];
 932
 933         node = ofnode_path("/a-test");
 934         ut_assert(ofnode_valid(node));
 935         ut_assertok(ofnode_read_u32_array(node, "int-value", val, 1));
 936         ut_asserteq(-EINVAL, ofnode_read_u32_array(node, "missing", val, 1));
 937         ut_asserteq(-EOVERFLOW, ofnode_read_u32_array(node, "bool-value", val,
 938                                                       1));
 939
 940         memset(val, '\0', sizeof(val));
 941         ut_assertok(ofnode_read_u32_array(node, "int-array", val + 1, 3));
 942         ut_asserteq(0, val[0]);
 943         ut_asserteq(5678, val[1]);
 944         ut_asserteq(9123, val[2]);
 945         ut_asserteq(4567, val[3]);
 946         ut_asserteq(0, val[4]);
 947         ut_asserteq(-EOVERFLOW, ofnode_read_u32_array(node, "int-array", val,
 948                                                       4));
 949
 950         return 0;
 951 }
 952 DM_TEST(dm_test_ofnode_u32_array, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
 953
 954 static int dm_test_ofnode_u64(struct unit_test_state *uts)
 955 {
 956         ofnode node;
 957         u64 val;
 958
 959         node = ofnode_path("/a-test");
 960         ut_assert(ofnode_valid(node));
 961         ut_assertok(ofnode_read_u64(node, "int64-value", &val));
 962         ut_asserteq_64(0x1111222233334444, val);
 963         ut_asserteq(-EINVAL, ofnode_read_u64(node, "missing", &val));
 964
 965         return 0;
 966 }
 967 DM_TEST(dm_test_ofnode_u64, UT_TESTF_SCAN_FDT);
 968
 969 static int dm_test_ofnode_add_subnode(struct unit_test_state *uts)
 970 {
 971         ofnode node, check, subnode;
 972         char buf[128];
 973
 974         node = ofnode_path("/lcd");
 975         ut_assert(ofnode_valid(node));
 976         ut_assertok(ofnode_add_subnode(node, "edmund", &subnode));
 977         check = ofnode_path("/lcd/edmund");
 978         ut_asserteq(subnode.of_offset, check.of_offset);
 979         ut_assertok(ofnode_get_path(subnode, buf, sizeof(buf)));
 980         ut_asserteq_str("/lcd/edmund", buf);
 981
 982         if (of_live_active()) {
 983                 struct device_node *child;
 984
 985                 ut_assertok(of_add_subnode((void *)ofnode_to_np(node), "edmund",
 986                                            2, &child));
 987                 ut_asserteq_str("ed", child->name);
 988                 ut_asserteq_str("/lcd/ed", child->full_name);
 989                 check = ofnode_path("/lcd/ed");
 990                 ut_asserteq_ptr(child, check.np);
 991                 ut_assertok(ofnode_get_path(np_to_ofnode(child), buf,
 992                                             sizeof(buf)));
 993                 ut_asserteq_str("/lcd/ed", buf);
 994         }
 995
 996         /* An existing node should be returned with -EEXIST */
 997         ut_asserteq(-EEXIST, ofnode_add_subnode(node, "edmund", &check));
 998         ut_asserteq(subnode.of_offset, check.of_offset);
 999
1000         /* add a root node */
1001         node = ofnode_path("/");
1002         ut_assert(ofnode_valid(node));
1003         ut_assertok(ofnode_add_subnode(node, "lcd2", &subnode));
1004         check = ofnode_path("/lcd2");
1005         ut_asserteq(subnode.of_offset, check.of_offset);
1006         ut_assertok(ofnode_get_path(subnode, buf, sizeof(buf)));
1007         ut_asserteq_str("/lcd2", buf);
1008
1009         if (of_live_active()) {
1010                 ulong start;
1011                 int i;
1012
1013                 /*
1014                  * Make sure each of the three malloc()checks in
1015                  * of_add_subnode() work
1016                  */
1017                 for (i = 0; i < 3; i++) {
1018                         malloc_enable_testing(i);
1019                         start = ut_check_free();
1020                         ut_asserteq(-ENOMEM, ofnode_add_subnode(node, "anthony",
1021                                                                 &check));
1022                         ut_assertok(ut_check_delta(start));
1023                 }
1024
1025                 /* This should pass since we allow 3 allocations */
1026                 malloc_enable_testing(3);
1027                 ut_assertok(ofnode_add_subnode(node, "anthony", &check));
1028                 malloc_disable_testing();
1029         }
1030
1031         /* write to the empty node */
1032         ut_assertok(ofnode_write_string(subnode, "example", "text"));
1033
1034         return 0;
1035 }
1036 DM_TEST(dm_test_ofnode_add_subnode, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
1037
1038 static int dm_test_ofnode_for_each_prop(struct unit_test_state *uts)
1039 {
1040         ofnode node, subnode;
1041         struct ofprop prop;
1042         int count;
1043
1044         node = ofnode_path("/buttons");
1045         count = 0;
1046
1047         /* we expect "compatible" for each node */
1048         ofnode_for_each_prop(prop, node)
1049                 count++;
1050         ut_asserteq(1, count);
1051
1052         /* there are two nodes, each with 2 properties */
1053         ofnode_for_each_subnode(subnode, node)
1054                 ofnode_for_each_prop(prop, subnode)
1055                         count++;
1056         ut_asserteq(5, count);
1057
1058         return 0;
1059 }
1060 DM_TEST(dm_test_ofnode_for_each_prop, UT_TESTF_SCAN_FDT);
1061
1062 static int dm_test_ofnode_by_compatible(struct unit_test_state *uts)
1063 {
1064         const char *compat = "denx,u-boot-fdt-test";
1065         ofnode node;
1066         int count;
1067
1068         count = 0;
1069         for (node = ofnode_null();
1070              node = ofnode_by_compatible(node, compat), ofnode_valid(node);)
1071                 count++;
1072         ut_asserteq(11, count);
1073
1074         return 0;
1075 }
1076 DM_TEST(dm_test_ofnode_by_compatible, UT_TESTF_SCAN_FDT);
1077
1078 static int dm_test_ofnode_by_compatible_ot(struct unit_test_state *uts)
1079 {
1080         const char *compat = "sandbox-other2";
1081         oftree otree = get_other_oftree(uts);
1082         ofnode node;
1083         int count;
1084
1085         count = 0;
1086         for (node = oftree_root(otree);
1087              node = ofnode_by_compatible(node, compat), ofnode_valid(node);)
1088                 count++;
1089         ut_asserteq(2, count);
1090
1091         return 0;
1092 }
1093 DM_TEST(dm_test_ofnode_by_compatible_ot, UT_TESTF_OTHER_FDT);
1094
1095 static int dm_test_ofnode_find_subnode(struct unit_test_state *uts)
1096 {
1097         ofnode node, subnode;
1098
1099         node = ofnode_path("/buttons");
1100
1101         subnode = ofnode_find_subnode(node, "btn1");
1102         ut_assert(ofnode_valid(subnode));
1103         ut_asserteq_str("btn1", ofnode_get_name(subnode));
1104
1105         subnode = ofnode_find_subnode(node, "btn");
1106         ut_assert(!ofnode_valid(subnode));
1107
1108         return 0;
1109 }
1110 DM_TEST(dm_test_ofnode_find_subnode, UT_TESTF_SCAN_FDT);
1111
1112 static int dm_test_ofnode_find_subnode_ot(struct unit_test_state *uts)
1113 {
1114         oftree otree = get_other_oftree(uts);
1115         ofnode node, subnode;
1116
1117         node = oftree_path(otree, "/node");
1118
1119         subnode = ofnode_find_subnode(node, "subnode");
1120         ut_assert(ofnode_valid(subnode));
1121         ut_asserteq_str("subnode", ofnode_get_name(subnode));
1122
1123         subnode = ofnode_find_subnode(node, "btn");
1124         ut_assert(!ofnode_valid(subnode));
1125
1126         return 0;
1127 }
1128 DM_TEST(dm_test_ofnode_find_subnode_ot, UT_TESTF_OTHER_FDT);
1129
1130 static int dm_test_ofnode_get_name(struct unit_test_state *uts)
1131 {
1132         ofnode node;
1133
1134         node = ofnode_path("/buttons");
1135         ut_assert(ofnode_valid(node));
1136         ut_asserteq_str("buttons", ofnode_get_name(node));
1137         ut_asserteq_str("", ofnode_get_name(ofnode_root()));
1138
1139         return 0;
1140 }
1141 DM_TEST(dm_test_ofnode_get_name, UT_TESTF_SCAN_FDT);
1142
1143 /* try to access more FDTs than is supported */
1144 static int dm_test_ofnode_too_many(struct unit_test_state *uts)
1145 {
1146         const int max_trees = CONFIG_IS_ENABLED(OFNODE_MULTI_TREE,
1147                                         (CONFIG_OFNODE_MULTI_TREE_MAX), (1));
1148         const int fdt_size = 256;
1149         const int num_trees = max_trees + 1;
1150         char fdt[num_trees][fdt_size];
1151         int i;
1152
1153         for (i = 0; i < num_trees; i++) {
1154                 oftree tree;
1155                 int ret;
1156
1157                 ut_assertok(make_ofnode_fdt(uts, fdt[i], fdt_size, i));
1158                 ret = get_oftree(uts, fdt[i], &tree);
1159
1160                 /*
1161                  * With flat tree we have the control FDT using one slot. Live
1162                  * tree has no limit since it uses pointers, not integer tree
1163                  * IDs
1164                  */
1165                 if (of_live_active() || i < max_trees - 1) {
1166                         ut_assertok(ret);
1167                 } else {
1168                         /*
1169                          * tree should be invalid when we try to register too
1170                          * many trees
1171                          */
1172                         ut_asserteq(-EOVERFLOW, ret);
1173                 }
1174         }
1175
1176         return 0;
1177 }
1178 DM_TEST(dm_test_ofnode_too_many, UT_TESTF_SCAN_FDT);
1179
1180 static int check_copy_props(struct unit_test_state *uts, ofnode src,
1181                             ofnode dst)
1182 {
1183         u32 reg[2], val;
1184
1185         ut_assertok(ofnode_copy_props(src, dst));
1186
1187         ut_assertok(ofnode_read_u32(dst, "ping-expect", &val));
1188         ut_asserteq(3, val);
1189
1190         ut_asserteq_str("denx,u-boot-fdt-test",
1191                         ofnode_read_string(dst, "compatible"));
1192
1193         /* check that a property with the same name is overwritten */
1194         ut_assertok(ofnode_read_u32_array(dst, "reg", reg, ARRAY_SIZE(reg)));
1195         ut_asserteq(3, reg[0]);
1196         ut_asserteq(1, reg[1]);
1197
1198         /* reset the compatible so the live tree does not change */
1199         ut_assertok(ofnode_write_string(dst, "compatible", "nothing"));
1200
1201         return 0;
1202 }
1203
1204 static int dm_test_ofnode_copy_props(struct unit_test_state *uts)
1205 {
1206         ofnode src, dst;
1207
1208         /*
1209          * These nodes are chosen so that the src node is before the destination
1210          * node in the tree. This doesn't matter with livetree, but with
1211          * flattree any attempt to insert a property earlier in the tree will
1212          * mess up the offsets after it.
1213          */
1214         src = ofnode_path("/b-test");
1215         dst = ofnode_path("/some-bus");
1216
1217         ut_assertok(check_copy_props(uts, src, dst));
1218
1219         /* check a property that is in the destination already */
1220         ut_asserteq_str("mux0", ofnode_read_string(dst, "mux-control-names"));
1221
1222         return 0;
1223 }
1224 DM_TEST(dm_test_ofnode_copy_props, UT_TESTF_SCAN_FDT);
1225
1226 static int dm_test_ofnode_copy_props_ot(struct unit_test_state *uts)
1227 {
1228         ofnode src, dst;
1229         oftree otree = get_other_oftree(uts);
1230
1231         src = ofnode_path("/b-test");
1232         dst = oftree_path(otree, "/node/subnode2");
1233         ut_assertok(check_copy_props(uts, src, dst));
1234
1235         return 0;
1236 }
1237 DM_TEST(dm_test_ofnode_copy_props_ot, UT_TESTF_SCAN_FDT | UT_TESTF_OTHER_FDT);