Merge tag 'v2022.01-rc3' into next
[platform/kernel/u-boot.git] / test / dm / ofnode.c
index e0b525e..5e7c968 100644 (file)
@@ -213,7 +213,7 @@ static int dm_test_ofnode_read_aliases(struct unit_test_state *uts)
        ofnode node;
        int size;
 
-       node = ofnode_get_aliases_node("eth3");
+       node = ofnode_get_aliases_node("ethernet3");
        ut_assert(ofnode_valid(node));
        ut_asserteq_str("sbe5", ofnode_get_name(node));
 
@@ -289,6 +289,161 @@ static int dm_test_ofnode_get_reg(struct unit_test_state *uts)
        ut_asserteq(FDT_ADDR_T_NONE, addr);
        ut_asserteq(FDT_SIZE_T_NONE, size);
 
+       node = ofnode_path("/translation-test@8000/noxlatebus@3,300/dev@42");
+       ut_assert(ofnode_valid(node));
+       addr = ofnode_get_addr_size_index_notrans(node, 0, &size);
+       ut_asserteq_64(0x42, addr);
+
        return 0;
 }
 DM_TEST(dm_test_ofnode_get_reg, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
+
+static int dm_test_ofnode_get_path(struct unit_test_state *uts)
+{
+       const char *path = "/translation-test@8000/noxlatebus@3,300/dev@42";
+       char buf[64];
+       ofnode node;
+       int res;
+
+       node = ofnode_path(path);
+       ut_assert(ofnode_valid(node));
+
+       res = ofnode_get_path(node, buf, 64);
+       ut_asserteq(0, res);
+       ut_asserteq_str(path, buf);
+
+       res = ofnode_get_path(node, buf, 32);
+       ut_asserteq(-ENOSPC, res);
+
+       return 0;
+}
+DM_TEST(dm_test_ofnode_get_path, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
+
+static int dm_test_ofnode_conf(struct unit_test_state *uts)
+{
+       ut_assert(!ofnode_conf_read_bool("missing"));
+       ut_assert(ofnode_conf_read_bool("testing-bool"));
+
+       ut_asserteq(123, ofnode_conf_read_int("testing-int", 0));
+       ut_asserteq(6, ofnode_conf_read_int("missing", 6));
+
+       ut_assertnull(ofnode_conf_read_str("missing"));
+       ut_asserteq_str("testing", ofnode_conf_read_str("testing-str"));
+
+       return 0;
+}
+DM_TEST(dm_test_ofnode_conf, 0);
+
+static int dm_test_ofnode_for_each_compatible_node(struct unit_test_state *uts)
+{
+       const char compatible[] = "denx,u-boot-fdt-test";
+       bool found = false;
+       ofnode node;
+
+       ofnode_for_each_compatible_node(node, compatible) {
+               ut_assert(ofnode_device_is_compatible(node, compatible));
+               found = true;
+       }
+
+       /* There should be at least one matching node */
+       ut_assert(found);
+
+       return 0;
+}
+DM_TEST(dm_test_ofnode_for_each_compatible_node, UT_TESTF_SCAN_FDT);
+
+static int dm_test_ofnode_string(struct unit_test_state *uts)
+{
+       const char **val;
+       const char *out;
+       ofnode node;
+
+       node = ofnode_path("/a-test");
+       ut_assert(ofnode_valid(node));
+
+       /* single string */
+       ut_asserteq(1, ofnode_read_string_count(node, "str-value"));
+       ut_assertok(ofnode_read_string_index(node, "str-value", 0, &out));
+       ut_asserteq_str("test string", out);
+       ut_asserteq(0, ofnode_stringlist_search(node, "str-value",
+                                               "test string"));
+       ut_asserteq(1, ofnode_read_string_list(node, "str-value", &val));
+       ut_asserteq_str("test string", val[0]);
+       ut_assertnull(val[1]);
+       free(val);
+
+       /* list of strings */
+       ut_asserteq(5, ofnode_read_string_count(node, "mux-control-names"));
+       ut_assertok(ofnode_read_string_index(node, "mux-control-names", 0,
+                                            &out));
+       ut_asserteq_str("mux0", out);
+       ut_asserteq(0, ofnode_stringlist_search(node, "mux-control-names",
+                                               "mux0"));
+       ut_asserteq(5, ofnode_read_string_list(node, "mux-control-names",
+                                              &val));
+       ut_asserteq_str("mux0", val[0]);
+       ut_asserteq_str("mux1", val[1]);
+       ut_asserteq_str("mux2", val[2]);
+       ut_asserteq_str("mux3", val[3]);
+       ut_asserteq_str("mux4", val[4]);
+       ut_assertnull(val[5]);
+       free(val);
+
+       ut_assertok(ofnode_read_string_index(node, "mux-control-names", 4,
+                                            &out));
+       ut_asserteq_str("mux4", out);
+       ut_asserteq(4, ofnode_stringlist_search(node, "mux-control-names",
+                                               "mux4"));
+
+       return 0;
+}
+DM_TEST(dm_test_ofnode_string, 0);
+
+static int dm_test_ofnode_string_err(struct unit_test_state *uts)
+{
+       const char **val;
+       const char *out;
+       ofnode node;
+
+       /*
+        * Test error codes only on livetree, as they are different with
+        * flattree
+        */
+       node = ofnode_path("/a-test");
+       ut_assert(ofnode_valid(node));
+
+       /* non-existent property */
+       ut_asserteq(-EINVAL, ofnode_read_string_count(node, "missing"));
+       ut_asserteq(-EINVAL, ofnode_read_string_index(node, "missing", 0,
+                                                     &out));
+       ut_asserteq(-EINVAL, ofnode_read_string_list(node, "missing", &val));
+
+       /* empty property */
+       ut_asserteq(-ENODATA, ofnode_read_string_count(node, "bool-value"));
+       ut_asserteq(-ENODATA, ofnode_read_string_index(node, "bool-value", 0,
+                                                      &out));
+       ut_asserteq(-ENODATA, ofnode_read_string_list(node, "bool-value",
+                                                    &val));
+
+       /* badly formatted string list */
+       ut_asserteq(-EILSEQ, ofnode_read_string_count(node, "int64-value"));
+       ut_asserteq(-EILSEQ, ofnode_read_string_index(node, "int64-value", 0,
+                                                      &out));
+       ut_asserteq(-EILSEQ, ofnode_read_string_list(node, "int64-value",
+                                                    &val));
+
+       /* out of range / not found */
+       ut_asserteq(-ENODATA, ofnode_read_string_index(node, "str-value", 1,
+                                                      &out));
+       ut_asserteq(-ENODATA, ofnode_stringlist_search(node, "str-value",
+                                                      "other"));
+
+       /* negative value for index is not allowed, so don't test for that */
+
+       ut_asserteq(-ENODATA, ofnode_read_string_index(node,
+                                                      "mux-control-names", 5,
+                                                      &out));
+
+       return 0;
+}
+DM_TEST(dm_test_ofnode_string_err, UT_TESTF_LIVE_TREE);