Merge https://source.denx.de/u-boot/custodians/u-boot-sunxi

[platform/kernel/u-boot.git] / test / dm / core.c

diff --git a/test/dm/core.c b/test/dm/core.c
index 35ca689..48e66b7 100644 (file)
--- a/test/dm/core.c
+++ b/test/dm/core.c
@@ -117,14 +117,13 @@ int dm_leak_check_end(struct unit_test_state *uts)
 /* Test that binding with plat occurs correctly */
 static int dm_test_autobind(struct unit_test_state *uts)
 {
-       struct dm_test_state *dms = uts->priv;
        struct udevice *dev;
 
        /*
         * We should have a single class (UCLASS_ROOT) and a single root
         * device with no children.
         */
-       ut_assert(dms->root);
+       ut_assert(uts->root);
        ut_asserteq(1, list_count_items(gd->uclass_root));
        ut_asserteq(0, list_count_items(&gd->dm_root->child_head));
        ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_BIND]);
@@ -178,6 +177,20 @@ static int dm_test_autobind_uclass_pdata_alloc(struct unit_test_state *uts)
 }
 DM_TEST(dm_test_autobind_uclass_pdata_alloc, UT_TESTF_SCAN_PDATA);
 
+/* compare node names ignoring the unit address */
+static int dm_test_compare_node_name(struct unit_test_state *uts)
+{
+       ofnode node;
+
+       node = ofnode_path("/mmio-bus@0");
+       ut_assert(ofnode_valid(node));
+       ut_assert(ofnode_name_eq(node, "mmio-bus"));
+
+       return 0;
+}
+
+DM_TEST(dm_test_compare_node_name, UT_TESTF_SCAN_PDATA);
+
 /* Test that binding with uclass plat setting occurs correctly */
 static int dm_test_autobind_uclass_pdata_valid(struct unit_test_state *uts)
 {
@@ -207,7 +220,6 @@ DM_TEST(dm_test_autobind_uclass_pdata_valid, UT_TESTF_SCAN_PDATA);
 /* Test that autoprobe finds all the expected devices */
 static int dm_test_autoprobe(struct unit_test_state *uts)
 {
-       struct dm_test_state *dms = uts->priv;
        int expected_base_add;
        struct udevice *dev;
        struct uclass *uc;
@@ -221,7 +233,7 @@ static int dm_test_autoprobe(struct unit_test_state *uts)
        ut_asserteq(0, dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]);
 
        /* The root device should not be activated until needed */
-       ut_assert(dev_get_flags(dms->root) & DM_FLAG_ACTIVATED);
+       ut_assert(dev_get_flags(uts->root) & DM_FLAG_ACTIVATED);
 
        /*
         * We should be able to find the three test devices, and they should
@@ -241,7 +253,7 @@ static int dm_test_autoprobe(struct unit_test_state *uts)
 
                /* Activating a device should activate the root device */
                if (!i)
-                       ut_assert(dev_get_flags(dms->root) & DM_FLAG_ACTIVATED);
+                       ut_assert(dev_get_flags(uts->root) & DM_FLAG_ACTIVATED);
        }
 
        /*
@@ -293,7 +305,6 @@ DM_TEST(dm_test_plat, UT_TESTF_SCAN_PDATA);
 /* Test that we can bind, probe, remove, unbind a driver */
 static int dm_test_lifecycle(struct unit_test_state *uts)
 {
-       struct dm_test_state *dms = uts->priv;
        int op_count[DM_TEST_OP_COUNT];
        struct udevice *dev, *test_dev;
        int pingret;
@@ -301,7 +312,7 @@ static int dm_test_lifecycle(struct unit_test_state *uts)
 
        memcpy(op_count, dm_testdrv_op_count, sizeof(op_count));
 
-       ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
+       ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
                                        &dev));
        ut_assert(dev);
        ut_assert(dm_testdrv_op_count[DM_TEST_OP_BIND]
@@ -309,7 +320,7 @@ static int dm_test_lifecycle(struct unit_test_state *uts)
        ut_assert(!dev_get_priv(dev));
 
        /* Probe the device - it should fail allocating private data */
-       dms->force_fail_alloc = 1;
+       uts->force_fail_alloc = 1;
        ret = device_probe(dev);
        ut_assert(ret == -ENOMEM);
        ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE]
@@ -317,7 +328,7 @@ static int dm_test_lifecycle(struct unit_test_state *uts)
        ut_assert(!dev_get_priv(dev));
 
        /* Try again without the alloc failure */
-       dms->force_fail_alloc = 0;
+       uts->force_fail_alloc = 0;
        ut_assertok(device_probe(dev));
        ut_assert(dm_testdrv_op_count[DM_TEST_OP_PROBE]
                        == op_count[DM_TEST_OP_PROBE] + 2);
@@ -349,19 +360,18 @@ DM_TEST(dm_test_lifecycle, UT_TESTF_SCAN_PDATA | UT_TESTF_PROBE_TEST);
 /* Test that we can bind/unbind and the lists update correctly */
 static int dm_test_ordering(struct unit_test_state *uts)
 {
-       struct dm_test_state *dms = uts->priv;
        struct udevice *dev, *dev_penultimate, *dev_last, *test_dev;
        int pingret;
 
-       ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
+       ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
                                        &dev));
        ut_assert(dev);
 
        /* Bind two new devices (numbers 4 and 5) */
-       ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
+       ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
                                        &dev_penultimate));
        ut_assert(dev_penultimate);
-       ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
+       ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
                                        &dev_last));
        ut_assert(dev_last);
 
@@ -376,7 +386,7 @@ static int dm_test_ordering(struct unit_test_state *uts)
        ut_assert(dev_last == test_dev);
 
        /* Add back the original device 3, now in position 5 */
-       ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
+       ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
                                        &dev));
        ut_assert(dev);
 
@@ -568,7 +578,6 @@ static int create_children(struct unit_test_state *uts, struct udevice *parent,
 
 static int dm_test_children(struct unit_test_state *uts)
 {
-       struct dm_test_state *dms = uts->priv;
        struct udevice *top[NODE_COUNT];
        struct udevice *child[NODE_COUNT];
        struct udevice *grandchild[NODE_COUNT];
@@ -578,12 +587,12 @@ static int dm_test_children(struct unit_test_state *uts)
        int i;
 
        /* We don't care about the numbering for this test */
-       dms->skip_post_probe = 1;
+       uts->skip_post_probe = 1;
 
        ut_assert(NODE_COUNT > 5);
 
        /* First create 10 top-level children */
-       ut_assertok(create_children(uts, dms->root, NODE_COUNT, 0, top));
+       ut_assertok(create_children(uts, uts->root, NODE_COUNT, 0, top));
 
        /* Now a few have their own children */
        ut_assertok(create_children(uts, top[2], NODE_COUNT, 2, NULL));
@@ -654,7 +663,6 @@ DM_TEST(dm_test_children, 0);
 
 static int dm_test_device_reparent(struct unit_test_state *uts)
 {
-       struct dm_test_state *dms = uts->priv;
        struct udevice *top[NODE_COUNT];
        struct udevice *child[NODE_COUNT];
        struct udevice *grandchild[NODE_COUNT];
@@ -664,12 +672,12 @@ static int dm_test_device_reparent(struct unit_test_state *uts)
        int i;
 
        /* We don't care about the numbering for this test */
-       dms->skip_post_probe = 1;
+       uts->skip_post_probe = 1;
 
        ut_assert(NODE_COUNT > 5);
 
        /* First create 10 top-level children */
-       ut_assertok(create_children(uts, dms->root, NODE_COUNT, 0, top));
+       ut_assertok(create_children(uts, uts->root, NODE_COUNT, 0, top));
 
        /* Now a few have their own children */
        ut_assertok(create_children(uts, top[2], NODE_COUNT, 2, NULL));
@@ -815,15 +823,14 @@ DM_TEST(dm_test_device_reparent, 0);
 /* Test that pre-relocation devices work as expected */
 static int dm_test_pre_reloc(struct unit_test_state *uts)
 {
-       struct dm_test_state *dms = uts->priv;
        struct udevice *dev;
 
        /* The normal driver should refuse to bind before relocation */
-       ut_asserteq(-EPERM, device_bind_by_name(dms->root, true,
+       ut_asserteq(-EPERM, device_bind_by_name(uts->root, true,
                                                &driver_info_manual, &dev));
 
        /* But this one is marked pre-reloc */
-       ut_assertok(device_bind_by_name(dms->root, true,
+       ut_assertok(device_bind_by_name(uts->root, true,
                                        &driver_info_pre_reloc, &dev));
 
        return 0;
@@ -836,10 +843,9 @@ DM_TEST(dm_test_pre_reloc, 0);
  */
 static int dm_test_remove_active_dma(struct unit_test_state *uts)
 {
-       struct dm_test_state *dms = uts->priv;
        struct udevice *dev;
 
-       ut_assertok(device_bind_by_name(dms->root, false, &driver_info_act_dma,
+       ut_assertok(device_bind_by_name(uts->root, false, &driver_info_act_dma,
                                        &dev));
        ut_assert(dev);
 
@@ -872,7 +878,7 @@ static int dm_test_remove_active_dma(struct unit_test_state *uts)
         * the active DMA remove call
         */
        ut_assertok(device_unbind(dev));
-       ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
+       ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
                                        &dev));
        ut_assert(dev);
 
@@ -895,25 +901,24 @@ DM_TEST(dm_test_remove_active_dma, 0);
 /* Test removal of 'vital' devices */
 static int dm_test_remove_vital(struct unit_test_state *uts)
 {
-       struct dm_test_state *dms = uts->priv;
        struct udevice *normal, *dma, *vital, *dma_vital;
 
        /* Skip the behaviour in test_post_probe() */
-       dms->skip_post_probe = 1;
+       uts->skip_post_probe = 1;
 
-       ut_assertok(device_bind_by_name(dms->root, false, &driver_info_manual,
+       ut_assertok(device_bind_by_name(uts->root, false, &driver_info_manual,
                                        &normal));
        ut_assertnonnull(normal);
 
-       ut_assertok(device_bind_by_name(dms->root, false, &driver_info_act_dma,
+       ut_assertok(device_bind_by_name(uts->root, false, &driver_info_act_dma,
                                        &dma));
        ut_assertnonnull(dma);
 
-       ut_assertok(device_bind_by_name(dms->root, false,
+       ut_assertok(device_bind_by_name(uts->root, false,
                                        &driver_info_vital_clk, &vital));
        ut_assertnonnull(vital);
 
-       ut_assertok(device_bind_by_name(dms->root, false,
+       ut_assertok(device_bind_by_name(uts->root, false,
                                        &driver_info_act_dma_vital_clk,
                                        &dma_vital));
        ut_assertnonnull(dma_vital);
@@ -1133,11 +1138,10 @@ DM_TEST(dm_test_uclass_names, UT_TESTF_SCAN_PDATA);
 
 static int dm_test_inactive_child(struct unit_test_state *uts)
 {
-       struct dm_test_state *dms = uts->priv;
        struct udevice *parent, *dev1, *dev2;
 
        /* Skip the behaviour in test_post_probe() */
-       dms->skip_post_probe = 1;
+       uts->skip_post_probe = 1;
 
        ut_assertok(uclass_first_device_err(UCLASS_TEST, &parent));
 
@@ -1181,6 +1185,7 @@ static int dm_test_all_have_seq(struct unit_test_state *uts)
 }
 DM_TEST(dm_test_all_have_seq, UT_TESTF_SCAN_PDATA);
 
+#if CONFIG_IS_ENABLED(DM_DMA)
 static int dm_test_dma_offset(struct unit_test_state *uts)
 {
        struct udevice *dev;
@@ -1210,3 +1215,4 @@ static int dm_test_dma_offset(struct unit_test_state *uts)
        return 0;
 }
 DM_TEST(dm_test_dma_offset, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
+#endif