tools: binman: change shebang from python into python2

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

diff --git a/test/dm/bus.c b/test/dm/bus.c
index faffe6a385b6f8ef9ee066ac705d959993232226..d94dcf7a60d87988d9c50dae5f959c056a3777be 100644 (file)
--- a/test/dm/bus.c
+++ b/test/dm/bus.c
@@ -7,11 +7,10 @@
 #include <common.h>
 #include <dm.h>
 #include <dm/device-internal.h>
-#include <dm/root.h>
 #include <dm/test.h>
 #include <dm/uclass-internal.h>
-#include <dm/ut.h>
 #include <dm/util.h>
+#include <test/ut.h>
 
 DECLARE_GLOBAL_DATA_PTR;
 
@@ -30,7 +29,7 @@ static struct dm_test_state *test_state;
 
 static int testbus_drv_probe(struct udevice *dev)
 {
-       return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset, false);
+       return dm_scan_fdt_dev(dev);
 }
 
 static int testbus_child_post_bind(struct udevice *dev)
@@ -46,7 +45,7 @@ static int testbus_child_post_bind(struct udevice *dev)
 
 static int testbus_child_pre_probe(struct udevice *dev)
 {
-       struct dm_test_parent_data *parent_data = dev_get_parentdata(dev);
+       struct dm_test_parent_data *parent_data = dev_get_parent_priv(dev);
 
        parent_data->flag += FLAG_CHILD_PROBED;
 
@@ -64,7 +63,7 @@ static int testbus_child_pre_probe_uclass(struct udevice *dev)
 
 static int testbus_child_post_remove(struct udevice *dev)
 {
-       struct dm_test_parent_data *parent_data = dev_get_parentdata(dev);
+       struct dm_test_parent_data *parent_data = dev_get_parent_priv(dev);
        struct dm_test_state *dms = test_state;
 
        parent_data->flag += FLAG_CHILD_REMOVED;
@@ -104,7 +103,7 @@ UCLASS_DRIVER(testbus) = {
 };
 
 /* Test that we can probe for children */
-static int dm_test_bus_children(struct dm_test_state *dms)
+static int dm_test_bus_children(struct unit_test_state *uts)
 {
        int num_devices = 6;
        struct udevice *bus;
@@ -120,14 +119,14 @@ static int dm_test_bus_children(struct dm_test_state *dms)
        ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
        ut_asserteq(num_devices, list_count_items(&uc->dev_head));
 
-       ut_assert(!dm_check_devices(dms, num_devices));
+       ut_assert(!dm_check_devices(uts, num_devices));
 
        return 0;
 }
 DM_TEST(dm_test_bus_children, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 
 /* Test our functions for accessing children */
-static int dm_test_bus_children_funcs(struct dm_test_state *dms)
+static int dm_test_bus_children_funcs(struct unit_test_state *uts)
 {
        const void *blob = gd->fdt_blob;
        struct udevice *bus, *dev;
@@ -173,7 +172,7 @@ static int dm_test_bus_children_funcs(struct dm_test_state *dms)
 DM_TEST(dm_test_bus_children_funcs, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 
 /* Test that we can iterate through children */
-static int dm_test_bus_children_iterators(struct dm_test_state *dms)
+static int dm_test_bus_children_iterators(struct unit_test_state *uts)
 {
        struct udevice *bus, *dev, *child;
 
@@ -204,7 +203,7 @@ DM_TEST(dm_test_bus_children_iterators,
        DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 
 /* Test that the bus can store data about each child */
-static int test_bus_parent_data(struct dm_test_state *dms)
+static int test_bus_parent_data(struct unit_test_state *uts)
 {
        struct dm_test_parent_data *parent_data;
        struct udevice *bus, *dev;
@@ -215,20 +214,20 @@ static int test_bus_parent_data(struct dm_test_state *dms)
 
        /* Check that parent data is allocated */
        ut_assertok(device_find_child_by_seq(bus, 0, true, &dev));
-       ut_asserteq_ptr(NULL, dev_get_parentdata(dev));
+       ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
        ut_assertok(device_get_child_by_seq(bus, 0, &dev));
-       parent_data = dev_get_parentdata(dev);
+       parent_data = dev_get_parent_priv(dev);
        ut_assert(NULL != parent_data);
 
        /* Check that it starts at 0 and goes away when device is removed */
        parent_data->sum += 5;
        ut_asserteq(5, parent_data->sum);
        device_remove(dev);
-       ut_asserteq_ptr(NULL, dev_get_parentdata(dev));
+       ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
 
        /* Check that we can do this twice */
        ut_assertok(device_get_child_by_seq(bus, 0, &dev));
-       parent_data = dev_get_parentdata(dev);
+       parent_data = dev_get_parent_priv(dev);
        ut_assert(NULL != parent_data);
        parent_data->sum += 5;
        ut_asserteq(5, parent_data->sum);
@@ -239,11 +238,11 @@ static int test_bus_parent_data(struct dm_test_state *dms)
        uclass_foreach_dev(dev, uc) {
                /* Ignore these if they are not on this bus */
                if (dev->parent != bus) {
-                       ut_asserteq_ptr(NULL, dev_get_parentdata(dev));
+                       ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
                        continue;
                }
                ut_assertok(device_probe(dev));
-               parent_data = dev_get_parentdata(dev);
+               parent_data = dev_get_parent_priv(dev);
 
                parent_data->sum = value;
                value += 5;
@@ -255,7 +254,7 @@ static int test_bus_parent_data(struct dm_test_state *dms)
                /* Ignore these if they are not on this bus */
                if (dev->parent != bus)
                        continue;
-               parent_data = dev_get_parentdata(dev);
+               parent_data = dev_get_parent_priv(dev);
 
                ut_asserteq(value, parent_data->sum);
                value += 5;
@@ -264,29 +263,31 @@ static int test_bus_parent_data(struct dm_test_state *dms)
        return 0;
 }
 /* Test that the bus can store data about each child */
-static int dm_test_bus_parent_data(struct dm_test_state *dms)
+static int dm_test_bus_parent_data(struct unit_test_state *uts)
 {
-       return test_bus_parent_data(dms);
+       return test_bus_parent_data(uts);
 }
 DM_TEST(dm_test_bus_parent_data, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 
 /* As above but the size is controlled by the uclass */
-static int dm_test_bus_parent_data_uclass(struct dm_test_state *dms)
+static int dm_test_bus_parent_data_uclass(struct unit_test_state *uts)
 {
+       struct driver *drv;
        struct udevice *bus;
        int size;
        int ret;
 
        /* Set the driver size to 0 so that the uclass size is used */
        ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
-       size = bus->driver->per_child_auto_alloc_size;
+       drv = (struct driver *)bus->driver;
+       size = drv->per_child_auto_alloc_size;
        bus->uclass->uc_drv->per_child_auto_alloc_size = size;
-       bus->driver->per_child_auto_alloc_size = 0;
-       ret = test_bus_parent_data(dms);
+       drv->per_child_auto_alloc_size = 0;
+       ret = test_bus_parent_data(uts);
        if (ret)
                return ret;
        bus->uclass->uc_drv->per_child_auto_alloc_size = 0;
-       bus->driver->per_child_auto_alloc_size = size;
+       drv->per_child_auto_alloc_size = size;
 
        return 0;
 }
@@ -294,9 +295,10 @@ DM_TEST(dm_test_bus_parent_data_uclass,
        DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 
 /* Test that the bus ops are called when a child is probed/removed */
-static int dm_test_bus_parent_ops(struct dm_test_state *dms)
+static int dm_test_bus_parent_ops(struct unit_test_state *uts)
 {
        struct dm_test_parent_data *parent_data;
+       struct dm_test_state *dms = uts->priv;
        struct udevice *bus, *dev;
        struct uclass *uc;
 
@@ -308,10 +310,10 @@ static int dm_test_bus_parent_ops(struct dm_test_state *dms)
                /* Ignore these if they are not on this bus */
                if (dev->parent != bus)
                        continue;
-               ut_asserteq_ptr(NULL, dev_get_parentdata(dev));
+               ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
 
                ut_assertok(device_probe(dev));
-               parent_data = dev_get_parentdata(dev);
+               parent_data = dev_get_parent_priv(dev);
                ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
        }
 
@@ -319,10 +321,10 @@ static int dm_test_bus_parent_ops(struct dm_test_state *dms)
                /* Ignore these if they are not on this bus */
                if (dev->parent != bus)
                        continue;
-               parent_data = dev_get_parentdata(dev);
+               parent_data = dev_get_parent_priv(dev);
                ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
                ut_assertok(device_remove(dev));
-               ut_asserteq_ptr(NULL, dev_get_parentdata(dev));
+               ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
                ut_asserteq_ptr(dms->removed, dev);
        }
        test_state = NULL;
@@ -331,7 +333,7 @@ static int dm_test_bus_parent_ops(struct dm_test_state *dms)
 }
 DM_TEST(dm_test_bus_parent_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 
-static int test_bus_parent_platdata(struct dm_test_state *dms)
+static int test_bus_parent_platdata(struct unit_test_state *uts)
 {
        struct dm_test_parent_platdata *plat;
        struct udevice *bus, *dev;
@@ -404,29 +406,31 @@ static int test_bus_parent_platdata(struct dm_test_state *dms)
 }
 
 /* Test that the bus can store platform data about each child */
-static int dm_test_bus_parent_platdata(struct dm_test_state *dms)
+static int dm_test_bus_parent_platdata(struct unit_test_state *uts)
 {
-       return test_bus_parent_platdata(dms);
+       return test_bus_parent_platdata(uts);
 }
 DM_TEST(dm_test_bus_parent_platdata, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 
 /* As above but the size is controlled by the uclass */
-static int dm_test_bus_parent_platdata_uclass(struct dm_test_state *dms)
+static int dm_test_bus_parent_platdata_uclass(struct unit_test_state *uts)
 {
        struct udevice *bus;
+       struct driver *drv;
        int size;
        int ret;
 
        /* Set the driver size to 0 so that the uclass size is used */
        ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
-       size = bus->driver->per_child_platdata_auto_alloc_size;
+       drv = (struct driver *)bus->driver;
+       size = drv->per_child_platdata_auto_alloc_size;
        bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = size;
-       bus->driver->per_child_platdata_auto_alloc_size = 0;
-       ret = test_bus_parent_platdata(dms);
+       drv->per_child_platdata_auto_alloc_size = 0;
+       ret = test_bus_parent_platdata(uts);
        if (ret)
                return ret;
        bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = 0;
-       bus->driver->per_child_platdata_auto_alloc_size = size;
+       drv->per_child_platdata_auto_alloc_size = size;
 
        return 0;
 }
@@ -434,7 +438,7 @@ DM_TEST(dm_test_bus_parent_platdata_uclass,
        DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 
 /* Test that the child post_bind method is called */
-static int dm_test_bus_child_post_bind(struct dm_test_state *dms)
+static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
 {
        struct dm_test_parent_platdata *plat;
        struct udevice *bus, *dev;
@@ -457,7 +461,7 @@ static int dm_test_bus_child_post_bind(struct dm_test_state *dms)
 DM_TEST(dm_test_bus_child_post_bind, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
 
 /* Test that the child post_bind method is called */
-static int dm_test_bus_child_post_bind_uclass(struct dm_test_state *dms)
+static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
 {
        struct dm_test_parent_platdata *plat;
        struct udevice *bus, *dev;
@@ -484,7 +488,7 @@ DM_TEST(dm_test_bus_child_post_bind_uclass,
  * Test that the bus' uclass' child_pre_probe() is called before the
  * device's probe() method
  */
-static int dm_test_bus_child_pre_probe_uclass(struct dm_test_state *dms)
+static int dm_test_bus_child_pre_probe_uclass(struct unit_test_state *uts)
 {
        struct udevice *bus, *dev;
        int child_count;