test: dm: add MDIO test

[oweals/u-boot.git] / test / dm / test-fdt.c

diff --git a/test/dm/test-fdt.c b/test/dm/test-fdt.c
index e43acb21d5e710043be167ace4f3382682ddd860..be16c99e170eb6e1783ec5cd4b42a2d623a747ae 100644 (file)
--- a/test/dm/test-fdt.c
+++ b/test/dm/test-fdt.c
@@ -219,6 +219,29 @@ static int dm_test_fdt(struct unit_test_state *uts)
 }
 DM_TEST(dm_test_fdt, 0);
 
+static int dm_test_alias_highest_id(struct unit_test_state *uts)
+{
+       int ret;
+
+       ret = dev_read_alias_highest_id("eth");
+       ut_asserteq(5, ret);
+
+       ret = dev_read_alias_highest_id("gpio");
+       ut_asserteq(2, ret);
+
+       ret = dev_read_alias_highest_id("pci");
+       ut_asserteq(2, ret);
+
+       ret = dev_read_alias_highest_id("i2c");
+       ut_asserteq(0, ret);
+
+       ret = dev_read_alias_highest_id("deadbeef");
+       ut_asserteq(-1, ret);
+
+       return 0;
+}
+DM_TEST(dm_test_alias_highest_id, 0);
+
 static int dm_test_fdt_pre_reloc(struct unit_test_state *uts)
 {
        struct uclass *uc;
@@ -490,7 +513,6 @@ static int dm_test_fdt_translation(struct unit_test_state *uts)
 }
 DM_TEST(dm_test_fdt_translation, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 
-/* Test devfdt_remap_addr_index() */
 static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
 {
        struct udevice *dev;
@@ -511,7 +533,46 @@ static int dm_test_fdt_remap_addr_flat(struct unit_test_state *uts)
 DM_TEST(dm_test_fdt_remap_addr_flat,
        DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
 
-/* Test dev_remap_addr_index() */
+static int dm_test_fdt_remap_addr_index_flat(struct unit_test_state *uts)
+{
+       struct udevice *dev;
+       fdt_addr_t addr;
+       void *paddr;
+
+       ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
+
+       addr = devfdt_get_addr_index(dev, 0);
+       ut_asserteq(0x8000, addr);
+
+       paddr = map_physmem(addr, 0, MAP_NOCACHE);
+       ut_assertnonnull(paddr);
+       ut_asserteq_ptr(paddr, devfdt_remap_addr_index(dev, 0));
+
+       return 0;
+}
+DM_TEST(dm_test_fdt_remap_addr_index_flat,
+       DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
+
+static int dm_test_fdt_remap_addr_name_flat(struct unit_test_state *uts)
+{
+       struct udevice *dev;
+       fdt_addr_t addr;
+       void *paddr;
+
+       ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
+
+       addr = devfdt_get_addr_name(dev, "sandbox-dummy-0");
+       ut_asserteq(0x8000, addr);
+
+       paddr = map_physmem(addr, 0, MAP_NOCACHE);
+       ut_assertnonnull(paddr);
+       ut_asserteq_ptr(paddr, devfdt_remap_addr_name(dev, "sandbox-dummy-0"));
+
+       return 0;
+}
+DM_TEST(dm_test_fdt_remap_addr_name_flat,
+       DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT | DM_TESTF_FLAT_TREE);
+
 static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
 {
        struct udevice *dev;
@@ -532,6 +593,46 @@ static int dm_test_fdt_remap_addr_live(struct unit_test_state *uts)
 DM_TEST(dm_test_fdt_remap_addr_live,
        DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 
+static int dm_test_fdt_remap_addr_index_live(struct unit_test_state *uts)
+{
+       struct udevice *dev;
+       fdt_addr_t addr;
+       void *paddr;
+
+       ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
+
+       addr = dev_read_addr_index(dev, 0);
+       ut_asserteq(0x8000, addr);
+
+       paddr = map_physmem(addr, 0, MAP_NOCACHE);
+       ut_assertnonnull(paddr);
+       ut_asserteq_ptr(paddr, dev_remap_addr_index(dev, 0));
+
+       return 0;
+}
+DM_TEST(dm_test_fdt_remap_addr_index_live,
+       DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+
+static int dm_test_fdt_remap_addr_name_live(struct unit_test_state *uts)
+{
+       struct udevice *dev;
+       fdt_addr_t addr;
+       void *paddr;
+
+       ut_assertok(uclass_find_device_by_seq(UCLASS_TEST_DUMMY, 0, true, &dev));
+
+       addr = dev_read_addr_name(dev, "sandbox-dummy-0");
+       ut_asserteq(0x8000, addr);
+
+       paddr = map_physmem(addr, 0, MAP_NOCACHE);
+       ut_assertnonnull(paddr);
+       ut_asserteq_ptr(paddr, dev_remap_addr_name(dev, "sandbox-dummy-0"));
+
+       return 0;
+}
+DM_TEST(dm_test_fdt_remap_addr_name_live,
+       DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+
 static int dm_test_fdt_livetree_writing(struct unit_test_state *uts)
 {
        struct udevice *dev;
@@ -611,3 +712,85 @@ static int dm_test_fdt_disable_enable_by_path(struct unit_test_state *uts)
 }
 DM_TEST(dm_test_fdt_disable_enable_by_path, DM_TESTF_SCAN_PDATA |
                                            DM_TESTF_SCAN_FDT);
+
+/* Test a few uclass phandle functions */
+static int dm_test_fdt_phandle(struct unit_test_state *uts)
+{
+       struct udevice *back, *dev, *dev2;
+
+       ut_assertok(uclass_find_first_device(UCLASS_PANEL_BACKLIGHT, &back));
+       ut_asserteq(-ENOENT, uclass_find_device_by_phandle(UCLASS_REGULATOR,
+                                                       back, "missing", &dev));
+       ut_assertok(uclass_find_device_by_phandle(UCLASS_REGULATOR, back,
+                                                 "power-supply", &dev));
+       ut_asserteq(0, device_active(dev));
+       ut_asserteq_str("ldo1", dev->name);
+       ut_assertok(uclass_get_device_by_phandle(UCLASS_REGULATOR, back,
+                                                "power-supply", &dev2));
+       ut_asserteq_ptr(dev, dev2);
+
+       return 0;
+}
+DM_TEST(dm_test_fdt_phandle, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+
+/* Test device_find_first_child_by_uclass() */
+static int dm_test_first_child(struct unit_test_state *uts)
+{
+       struct udevice *i2c, *dev, *dev2;
+
+       ut_assertok(uclass_first_device_err(UCLASS_I2C, &i2c));
+       ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_RTC, &dev));
+       ut_asserteq_str("rtc@43", dev->name);
+       ut_assertok(device_find_child_by_name(i2c, "rtc@43", &dev2));
+       ut_asserteq_ptr(dev, dev2);
+       ut_assertok(device_find_child_by_name(i2c, "rtc@61", &dev2));
+       ut_asserteq_str("rtc@61", dev2->name);
+
+       ut_assertok(device_find_first_child_by_uclass(i2c, UCLASS_I2C_EEPROM,
+                                                     &dev));
+       ut_asserteq_str("eeprom@2c", dev->name);
+       ut_assertok(device_find_child_by_name(i2c, "eeprom@2c", &dev2));
+       ut_asserteq_ptr(dev, dev2);
+
+       ut_asserteq(-ENODEV, device_find_first_child_by_uclass(i2c,
+                                                       UCLASS_VIDEO, &dev));
+       ut_asserteq(-ENODEV, device_find_child_by_name(i2c, "missing", &dev));
+
+       return 0;
+}
+DM_TEST(dm_test_first_child, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+
+/* Test integer functions in dm_read_...() */
+static int dm_test_read_int(struct unit_test_state *uts)
+{
+       struct udevice *dev;
+       u32 val32;
+       s32 sval;
+       uint val;
+
+       ut_assertok(uclass_first_device_err(UCLASS_TEST_FDT, &dev));
+       ut_asserteq_str("a-test", dev->name);
+       ut_assertok(dev_read_u32(dev, "int-value", &val32));
+       ut_asserteq(1234, val32);
+
+       ut_asserteq(-EINVAL, dev_read_u32(dev, "missing", &val32));
+       ut_asserteq(6, dev_read_u32_default(dev, "missing", 6));
+
+       ut_asserteq(1234, dev_read_u32_default(dev, "int-value", 6));
+       ut_asserteq(1234, val32);
+
+       ut_asserteq(-EINVAL, dev_read_s32(dev, "missing", &sval));
+       ut_asserteq(6, dev_read_s32_default(dev, "missing", 6));
+
+       ut_asserteq(-1234, dev_read_s32_default(dev, "uint-value", 6));
+       ut_assertok(dev_read_s32(dev, "uint-value", &sval));
+       ut_asserteq(-1234, sval);
+
+       val = 0;
+       ut_asserteq(-EINVAL, dev_read_u32u(dev, "missing", &val));
+       ut_assertok(dev_read_u32u(dev, "uint-value", &val));
+       ut_asserteq(-1234, val);
+
+       return 0;
+}
+DM_TEST(dm_test_read_int, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);