karo: tx28: explicitly configure pad config (voltage, pull, drive) for all pads

[karo-tx-uboot.git] / test / dm / bus.c

diff --git a/test/dm/bus.c b/test/dm/bus.c
index e9096970628e70ec0f0e6ce9f99c4eebef25b902..a215905add9b74be16c11f233e7e63d65c24833f 100644 (file)
--- a/test/dm/bus.c
+++ b/test/dm/bus.c
@@ -10,14 +10,15 @@
 #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;
 
 struct dm_test_parent_platdata {
        int count;
        int bind_flag;
+       int uclass_bind_flag;
 };
 
 enum {
@@ -38,6 +39,7 @@ static int testbus_child_post_bind(struct udevice *dev)
 
        plat = dev_get_parent_platdata(dev);
        plat->bind_flag = 1;
+       plat->uclass_bind_flag = 2;
 
        return 0;
 }
@@ -51,6 +53,15 @@ static int testbus_child_pre_probe(struct udevice *dev)
        return 0;
 }
 
+static int testbus_child_pre_probe_uclass(struct udevice *dev)
+{
+       struct dm_test_priv *priv = dev_get_priv(dev);
+
+       priv->uclass_flag++;
+
+       return 0;
+}
+
 static int testbus_child_post_remove(struct udevice *dev)
 {
        struct dm_test_parent_data *parent_data = dev_get_parentdata(dev);
@@ -89,10 +100,11 @@ UCLASS_DRIVER(testbus) = {
        .name           = "testbus",
        .id             = UCLASS_TEST_BUS,
        .flags          = DM_UC_FLAG_SEQ_ALIAS,
+       .child_pre_probe = testbus_child_pre_probe_uclass,
 };
 
 /* 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;
@@ -108,14 +120,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;
@@ -161,7 +173,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;
 
@@ -192,7 +204,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;
@@ -252,29 +264,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;
 }
@@ -282,9 +296,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;
 
@@ -319,7 +334,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;
@@ -392,29 +407,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;
 }
@@ -422,7 +439,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;
@@ -443,3 +460,63 @@ static int dm_test_bus_child_post_bind(struct dm_test_state *dms)
        return 0;
 }
 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 unit_test_state *uts)
+{
+       struct dm_test_parent_platdata *plat;
+       struct udevice *bus, *dev;
+       int child_count;
+
+       ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
+       for (device_find_first_child(bus, &dev), child_count = 0;
+            dev;
+            device_find_next_child(&dev)) {
+               /* Check that platform data is allocated */
+               plat = dev_get_parent_platdata(dev);
+               ut_assert(plat != NULL);
+               ut_asserteq(2, plat->uclass_bind_flag);
+               child_count++;
+       }
+       ut_asserteq(3, child_count);
+
+       return 0;
+}
+DM_TEST(dm_test_bus_child_post_bind_uclass,
+       DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);
+
+/*
+ * 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 unit_test_state *uts)
+{
+       struct udevice *bus, *dev;
+       int child_count;
+
+       /*
+        * See testfdt_drv_probe() which effectively checks that the uclass
+        * flag is set before that method is called
+        */
+       ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
+       for (device_find_first_child(bus, &dev), child_count = 0;
+            dev;
+            device_find_next_child(&dev)) {
+               struct dm_test_priv *priv = dev_get_priv(dev);
+
+               /* Check that things happened in the right order */
+               ut_asserteq_ptr(NULL, priv);
+               ut_assertok(device_probe(dev));
+
+               priv = dev_get_priv(dev);
+               ut_assert(priv != NULL);
+               ut_asserteq(1, priv->uclass_flag);
+               ut_asserteq(1, priv->uclass_total);
+               child_count++;
+       }
+       ut_asserteq(3, child_count);
+
+       return 0;
+}
+DM_TEST(dm_test_bus_child_pre_probe_uclass,
+       DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);