ofnode.c 3.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137
  1. // SPDX-License-Identifier: GPL-2.0+
  2. #include <common.h>
  3. #include <dm.h>
  4. #include <log.h>
  5. #include <dm/of_extra.h>
  6. #include <dm/test.h>
  7. #include <test/ut.h>
  8. static int dm_test_ofnode_compatible(struct unit_test_state *uts)
  9. {
  10. ofnode root_node = ofnode_path("/");
  11. ut_assert(ofnode_valid(root_node));
  12. ut_assert(ofnode_device_is_compatible(root_node, "sandbox"));
  13. return 0;
  14. }
  15. DM_TEST(dm_test_ofnode_compatible, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  16. static int dm_test_ofnode_by_prop_value(struct unit_test_state *uts)
  17. {
  18. const char propname[] = "compatible";
  19. const char propval[] = "denx,u-boot-fdt-test";
  20. const char *str;
  21. ofnode node = ofnode_null();
  22. /* Find first matching node, there should be at least one */
  23. node = ofnode_by_prop_value(node, propname, propval, sizeof(propval));
  24. ut_assert(ofnode_valid(node));
  25. str = ofnode_read_string(node, propname);
  26. ut_assert(str && !strcmp(str, propval));
  27. /* Find the rest of the matching nodes */
  28. while (true) {
  29. node = ofnode_by_prop_value(node, propname, propval,
  30. sizeof(propval));
  31. if (!ofnode_valid(node))
  32. break;
  33. str = ofnode_read_string(node, propname);
  34. ut_assert(str && !strcmp(str, propval));
  35. }
  36. return 0;
  37. }
  38. DM_TEST(dm_test_ofnode_by_prop_value, DM_TESTF_SCAN_FDT);
  39. static int dm_test_ofnode_fmap(struct unit_test_state *uts)
  40. {
  41. struct fmap_entry entry;
  42. ofnode node;
  43. node = ofnode_path("/cros-ec/flash");
  44. ut_assert(ofnode_valid(node));
  45. ut_assertok(ofnode_read_fmap_entry(node, &entry));
  46. ut_asserteq(0x08000000, entry.offset);
  47. ut_asserteq(0x20000, entry.length);
  48. return 0;
  49. }
  50. DM_TEST(dm_test_ofnode_fmap, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  51. static int dm_test_ofnode_read(struct unit_test_state *uts)
  52. {
  53. const u32 *val;
  54. ofnode node;
  55. int size;
  56. node = ofnode_path("/a-test");
  57. ut_assert(ofnode_valid(node));
  58. val = ofnode_read_prop(node, "int-value", &size);
  59. ut_assertnonnull(val);
  60. ut_asserteq(4, size);
  61. ut_asserteq(1234, fdt32_to_cpu(val[0]));
  62. val = ofnode_read_prop(node, "missing", &size);
  63. ut_assertnull(val);
  64. ut_asserteq(-FDT_ERR_NOTFOUND, size);
  65. /* Check it works without a size parameter */
  66. val = ofnode_read_prop(node, "missing", NULL);
  67. ut_assertnull(val);
  68. return 0;
  69. }
  70. DM_TEST(dm_test_ofnode_read, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  71. static int dm_test_ofnode_read_chosen(struct unit_test_state *uts)
  72. {
  73. const char *str;
  74. const u32 *val;
  75. ofnode node;
  76. int size;
  77. str = ofnode_read_chosen_string("setting");
  78. ut_assertnonnull(str);
  79. ut_asserteq_str("sunrise ohoka", str);
  80. ut_asserteq_ptr(NULL, ofnode_read_chosen_string("no-setting"));
  81. node = ofnode_get_chosen_node("other-node");
  82. ut_assert(ofnode_valid(node));
  83. ut_asserteq_str("c-test@5", ofnode_get_name(node));
  84. node = ofnode_get_chosen_node("setting");
  85. ut_assert(!ofnode_valid(node));
  86. val = ofnode_read_chosen_prop("int-values", &size);
  87. ut_assertnonnull(val);
  88. ut_asserteq(8, size);
  89. ut_asserteq(0x1937, fdt32_to_cpu(val[0]));
  90. ut_asserteq(72993, fdt32_to_cpu(val[1]));
  91. return 0;
  92. }
  93. DM_TEST(dm_test_ofnode_read_chosen, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
  94. static int dm_test_ofnode_get_child_count(struct unit_test_state *uts)
  95. {
  96. ofnode node, child_node;
  97. u32 val;
  98. node = ofnode_path("/i-test");
  99. ut_assert(ofnode_valid(node));
  100. val = ofnode_get_child_count(node);
  101. ut_asserteq(3, val);
  102. child_node = ofnode_first_subnode(node);
  103. ut_assert(ofnode_valid(child_node));
  104. val = ofnode_get_child_count(child_node);
  105. ut_asserteq(0, val);
  106. return 0;
  107. }
  108. DM_TEST(dm_test_ofnode_get_child_count,
  109. DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);