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

/*
 * Copyright (c) 2014 Google, Inc
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#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/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 {
	FLAG_CHILD_PROBED	= 10,
	FLAG_CHILD_REMOVED	= -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);
}

static int testbus_child_post_bind(struct udevice *dev)
{
	struct dm_test_parent_platdata *plat;

	plat = dev_get_parent_platdata(dev);
	plat->bind_flag = 1;
	plat->uclass_bind_flag = 2;

	return 0;
}

static int testbus_child_pre_probe(struct udevice *dev)
{
	struct dm_test_parent_data *parent_data = dev_get_parent_priv(dev);

	parent_data->flag += FLAG_CHILD_PROBED;

	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_parent_priv(dev);
	struct dm_test_state *dms = test_state;

	parent_data->flag += FLAG_CHILD_REMOVED;
	if (dms)
		dms->removed = dev;

	return 0;
}

static const struct udevice_id testbus_ids[] = {
	{
		.compatible = "denx,u-boot-test-bus",
		.data = DM_TEST_TYPE_FIRST },
	{ }
};

U_BOOT_DRIVER(testbus_drv) = {
	.name	= "testbus_drv",
	.of_match	= testbus_ids,
	.id	= UCLASS_TEST_BUS,
	.probe	= testbus_drv_probe,
	.child_post_bind = testbus_child_post_bind,
	.priv_auto_alloc_size = sizeof(struct dm_test_priv),
	.platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
	.per_child_auto_alloc_size = sizeof(struct dm_test_parent_data),
	.per_child_platdata_auto_alloc_size =
			sizeof(struct dm_test_parent_platdata),
	.child_pre_probe = testbus_child_pre_probe,
	.child_post_remove = testbus_child_post_remove,
};

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 unit_test_state *uts)
{
	int num_devices = 6;
	struct udevice *bus;
	struct uclass *uc;

	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
	ut_asserteq(num_devices, list_count_items(&uc->dev_head));

	/* Probe the bus, which should yield 3 more devices */
	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	num_devices += 3;

	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
	ut_asserteq(num_devices, list_count_items(&uc->dev_head));

	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 unit_test_state *uts)
{
	const void *blob = gd->fdt_blob;
	struct udevice *bus, *dev;
	int node;

	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));

	/* device_get_child() */
	ut_assertok(device_get_child(bus, 0, &dev));
	ut_asserteq(-ENODEV, device_get_child(bus, 4, &dev));
	ut_assertok(device_get_child_by_seq(bus, 5, &dev));
	ut_assert(dev->flags & DM_FLAG_ACTIVATED);
	ut_asserteq_str("c-test@5", dev->name);

	/* Device with sequence number 0 should be accessible */
	ut_asserteq(-ENODEV, device_find_child_by_seq(bus, -1, true, &dev));
	ut_assertok(device_find_child_by_seq(bus, 0, true, &dev));
	ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
	ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 0, false, &dev));
	ut_assertok(device_get_child_by_seq(bus, 0, &dev));
	ut_assert(dev->flags & DM_FLAG_ACTIVATED);

	/* There is no device with sequence number 2 */
	ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, false, &dev));
	ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, true, &dev));
	ut_asserteq(-ENODEV, device_get_child_by_seq(bus, 2, &dev));

	/* Looking for something that is not a child */
	node = fdt_path_offset(blob, "/junk");
	ut_asserteq(-ENODEV, device_find_child_by_of_offset(bus, node, &dev));
	node = fdt_path_offset(blob, "/d-test");
	ut_asserteq(-ENODEV, device_find_child_by_of_offset(bus, node, &dev));

	/* Find a valid child */
	node = fdt_path_offset(blob, "/some-bus/c-test@1");
	ut_assertok(device_find_child_by_of_offset(bus, node, &dev));
	ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
	ut_assertok(device_get_child_by_of_offset(bus, node, &dev));
	ut_assert(dev->flags & DM_FLAG_ACTIVATED);

	return 0;
}
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 unit_test_state *uts)
{
	struct udevice *bus, *dev, *child;

	/* Walk through the children one by one */
	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	ut_assertok(device_find_first_child(bus, &dev));
	ut_asserteq_str("c-test@5", dev->name);
	ut_assertok(device_find_next_child(&dev));
	ut_asserteq_str("c-test@0", dev->name);
	ut_assertok(device_find_next_child(&dev));
	ut_asserteq_str("c-test@1", dev->name);
	ut_assertok(device_find_next_child(&dev));
	ut_asserteq_ptr(dev, NULL);

	/* Move to the next child without using device_find_first_child() */
	ut_assertok(device_find_child_by_seq(bus, 5, true, &dev));
	ut_asserteq_str("c-test@5", dev->name);
	ut_assertok(device_find_next_child(&dev));
	ut_asserteq_str("c-test@0", dev->name);

	/* Try a device with no children */
	ut_assertok(device_find_first_child(dev, &child));
	ut_asserteq_ptr(child, NULL);

	return 0;
}
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 unit_test_state *uts)
{
	struct dm_test_parent_data *parent_data;
	struct udevice *bus, *dev;
	struct uclass *uc;
	int value;

	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));

	/* Check that parent data is allocated */
	ut_assertok(device_find_child_by_seq(bus, 0, true, &dev));
	ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
	ut_assertok(device_get_child_by_seq(bus, 0, &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_parent_priv(dev));

	/* Check that we can do this twice */
	ut_assertok(device_get_child_by_seq(bus, 0, &dev));
	parent_data = dev_get_parent_priv(dev);
	ut_assert(NULL != parent_data);
	parent_data->sum += 5;
	ut_asserteq(5, parent_data->sum);

	/* Add parent data to all children */
	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
	value = 5;
	uclass_foreach_dev(dev, uc) {
		/* Ignore these if they are not on this bus */
		if (dev->parent != bus) {
			ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
			continue;
		}
		ut_assertok(device_probe(dev));
		parent_data = dev_get_parent_priv(dev);

		parent_data->sum = value;
		value += 5;
	}

	/* Check it is still there */
	value = 5;
	uclass_foreach_dev(dev, uc) {
		/* Ignore these if they are not on this bus */
		if (dev->parent != bus)
			continue;
		parent_data = dev_get_parent_priv(dev);

		ut_asserteq(value, parent_data->sum);
		value += 5;
	}

	return 0;
}
/* Test that the bus can store data about each child */
static int dm_test_bus_parent_data(struct unit_test_state *uts)
{
	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 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));
	drv = (struct driver *)bus->driver;
	size = drv->per_child_auto_alloc_size;
	bus->uclass->uc_drv->per_child_auto_alloc_size = size;
	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;
	drv->per_child_auto_alloc_size = size;

	return 0;
}
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 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;

	test_state = dms;
	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));

	uclass_foreach_dev(dev, uc) {
		/* Ignore these if they are not on this bus */
		if (dev->parent != bus)
			continue;
		ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));

		ut_assertok(device_probe(dev));
		parent_data = dev_get_parent_priv(dev);
		ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
	}

	uclass_foreach_dev(dev, uc) {
		/* Ignore these if they are not on this bus */
		if (dev->parent != bus)
			continue;
		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_parent_priv(dev));
		ut_asserteq_ptr(dms->removed, dev);
	}
	test_state = NULL;

	return 0;
}
DM_TEST(dm_test_bus_parent_ops, DM_TESTF_SCAN_PDATA | DM_TESTF_SCAN_FDT);

static int test_bus_parent_platdata(struct unit_test_state *uts)
{
	struct dm_test_parent_platdata *plat;
	struct udevice *bus, *dev;
	int child_count;

	/* Check that the bus has no children */
	ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
	device_find_first_child(bus, &dev);
	ut_asserteq_ptr(NULL, dev);

	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);

		/*
		 * Check that it is not affected by the device being
		 * probed/removed
		 */
		plat->count++;
		ut_asserteq(1, plat->count);
		device_probe(dev);
		device_remove(dev);

		ut_asserteq_ptr(plat, dev_get_parent_platdata(dev));
		ut_asserteq(1, plat->count);
		ut_assertok(device_probe(dev));
		child_count++;
	}
	ut_asserteq(3, child_count);

	/* Removing the bus should also have no effect (it is still bound) */
	device_remove(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(1, plat->count);
		child_count++;
	}
	ut_asserteq(3, child_count);

	/* Unbind all the children */
	do {
		device_find_first_child(bus, &dev);
		if (dev)
			device_unbind(dev);
	} while (dev);

	/* Now the child platdata should be removed and re-added */
	device_probe(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(0, plat->count);
		child_count++;
	}
	ut_asserteq(3, child_count);

	return 0;
}

/* Test that the bus can store platform data about each child */
static int dm_test_bus_parent_platdata(struct unit_test_state *uts)
{
	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 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));
	drv = (struct driver *)bus->driver;
	size = drv->per_child_platdata_auto_alloc_size;
	bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = size;
	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;
	drv->per_child_platdata_auto_alloc_size = size;

	return 0;
}
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 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(1, plat->bind_flag);
		child_count++;
	}
	ut_asserteq(3, child_count);

	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);
Commit	Line	Data
1ca7e206 SG	1	/*
	2	* Copyright (c) 2014 Google, Inc
	3	*
	4	* SPDX-License-Identifier: GPL-2.0+
	5	*/
	6
	7	#include <common.h>
	8	#include <dm.h>
e59f458d	9	#include <dm/device-internal.h>
1ca7e206 SG	10	#include <dm/root.h>
1ca7e206 SG	11	#include <dm/test.h>
cdc133bd	12	#include <dm/uclass-internal.h>
1ca7e206	13	#include <dm/util.h>
e721b882	14	#include <test/ut.h>
1ca7e206 SG	15
	16	DECLARE_GLOBAL_DATA_PTR;
	17
cdc133bd SG	18	struct dm_test_parent_platdata {
cdc133bd SG	19	int count;
0118ce79	20	int bind_flag;
081f2fcb	21	int uclass_bind_flag;
cdc133bd SG	22	};
cdc133bd SG	23
a327dee0 SG	24	enum {
	25	FLAG_CHILD_PROBED = 10,
	26	FLAG_CHILD_REMOVED = -7,
	27	};
	28
	29	static struct dm_test_state *test_state;
	30
1ca7e206 SG	31	static int testbus_drv_probe(struct udevice *dev)
	32	{
	33	return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset, false);
	34	}
	35
0118ce79 SG	36	static int testbus_child_post_bind(struct udevice *dev)
	37	{
	38	struct dm_test_parent_platdata *plat;
	39
	40	plat = dev_get_parent_platdata(dev);
	41	plat->bind_flag = 1;
081f2fcb	42	plat->uclass_bind_flag = 2;
0118ce79 SG	43
	44	return 0;
	45	}
	46
a327dee0 SG	47	static int testbus_child_pre_probe(struct udevice *dev)
a327dee0 SG	48	{
bcbe3d15	49	struct dm_test_parent_data *parent_data = dev_get_parent_priv(dev);
a327dee0 SG	50
	51	parent_data->flag += FLAG_CHILD_PROBED;
	52
	53	return 0;
	54	}
	55
83c7e434 SG	56	static int testbus_child_pre_probe_uclass(struct udevice *dev)
	57	{
	58	struct dm_test_priv *priv = dev_get_priv(dev);
	59
	60	priv->uclass_flag++;
	61
	62	return 0;
	63	}
	64
a327dee0 SG	65	static int testbus_child_post_remove(struct udevice *dev)
a327dee0 SG	66	{
bcbe3d15	67	struct dm_test_parent_data *parent_data = dev_get_parent_priv(dev);
a327dee0 SG	68	struct dm_test_state *dms = test_state;
	69
	70	parent_data->flag += FLAG_CHILD_REMOVED;
	71	if (dms)
	72	dms->removed = dev;
	73
	74	return 0;
	75	}
	76
1ca7e206 SG	77	static const struct udevice_id testbus_ids[] = {
	78	{
	79	.compatible = "denx,u-boot-test-bus",
	80	.data = DM_TEST_TYPE_FIRST },
	81	{ }
	82	};
	83
	84	U_BOOT_DRIVER(testbus_drv) = {
	85	.name = "testbus_drv",
	86	.of_match = testbus_ids,
	87	.id = UCLASS_TEST_BUS,
	88	.probe = testbus_drv_probe,
0118ce79	89	.child_post_bind = testbus_child_post_bind,
1ca7e206 SG	90	.priv_auto_alloc_size = sizeof(struct dm_test_priv),
1ca7e206 SG	91	.platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
e59f458d	92	.per_child_auto_alloc_size = sizeof(struct dm_test_parent_data),
cdc133bd SG	93	.per_child_platdata_auto_alloc_size =
cdc133bd SG	94	sizeof(struct dm_test_parent_platdata),
a327dee0 SG	95	.child_pre_probe = testbus_child_pre_probe,
a327dee0 SG	96	.child_post_remove = testbus_child_post_remove,
1ca7e206 SG	97	};
	98
	99	UCLASS_DRIVER(testbus) = {
	100	.name = "testbus",
	101	.id = UCLASS_TEST_BUS,
9cc36a2b	102	.flags = DM_UC_FLAG_SEQ_ALIAS,
83c7e434	103	.child_pre_probe = testbus_child_pre_probe_uclass,
1ca7e206 SG	104	};
	105
	106	/* Test that we can probe for children */
e721b882	107	static int dm_test_bus_children(struct unit_test_state *uts)
1ca7e206	108	{
9cc36a2b	109	int num_devices = 6;
1ca7e206 SG	110	struct udevice *bus;
	111	struct uclass *uc;
	112
	113	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
	114	ut_asserteq(num_devices, list_count_items(&uc->dev_head));
	115
	116	/* Probe the bus, which should yield 3 more devices */
	117	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	118	num_devices += 3;
	119
	120	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
	121	ut_asserteq(num_devices, list_count_items(&uc->dev_head));
	122
e721b882	123	ut_assert(!dm_check_devices(uts, num_devices));
1ca7e206 SG	124
	125	return 0;
	126	}
	127	DM_TEST(dm_test_bus_children, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
997c87bb SG	128
997c87bb SG	129	/* Test our functions for accessing children */
e721b882	130	static int dm_test_bus_children_funcs(struct unit_test_state *uts)
997c87bb SG	131	{
	132	const void *blob = gd->fdt_blob;
	133	struct udevice bus, dev;
	134	int node;
	135
	136	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	137
	138	/* device_get_child() */
	139	ut_assertok(device_get_child(bus, 0, &dev));
	140	ut_asserteq(-ENODEV, device_get_child(bus, 4, &dev));
	141	ut_assertok(device_get_child_by_seq(bus, 5, &dev));
	142	ut_assert(dev->flags & DM_FLAG_ACTIVATED);
	143	ut_asserteq_str("c-test@5", dev->name);
	144
	145	/* Device with sequence number 0 should be accessible */
	146	ut_asserteq(-ENODEV, device_find_child_by_seq(bus, -1, true, &dev));
	147	ut_assertok(device_find_child_by_seq(bus, 0, true, &dev));
	148	ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
	149	ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 0, false, &dev));
	150	ut_assertok(device_get_child_by_seq(bus, 0, &dev));
	151	ut_assert(dev->flags & DM_FLAG_ACTIVATED);
	152
	153	/* There is no device with sequence number 2 */
	154	ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, false, &dev));
	155	ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, true, &dev));
	156	ut_asserteq(-ENODEV, device_get_child_by_seq(bus, 2, &dev));
	157
	158	/* Looking for something that is not a child */
	159	node = fdt_path_offset(blob, "/junk");
	160	ut_asserteq(-ENODEV, device_find_child_by_of_offset(bus, node, &dev));
	161	node = fdt_path_offset(blob, "/d-test");
	162	ut_asserteq(-ENODEV, device_find_child_by_of_offset(bus, node, &dev));
	163
	164	/* Find a valid child */
	165	node = fdt_path_offset(blob, "/some-bus/c-test@1");
	166	ut_assertok(device_find_child_by_of_offset(bus, node, &dev));
	167	ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
	168	ut_assertok(device_get_child_by_of_offset(bus, node, &dev));
	169	ut_assert(dev->flags & DM_FLAG_ACTIVATED);
	170
	171	return 0;
	172	}
	173	DM_TEST(dm_test_bus_children_funcs, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
e59f458d	174
a8981d4f	175	/* Test that we can iterate through children */
e721b882	176	static int dm_test_bus_children_iterators(struct unit_test_state *uts)
a8981d4f SG	177	{
	178	struct udevice bus, dev, *child;
	179
	180	/* Walk through the children one by one */
	181	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	182	ut_assertok(device_find_first_child(bus, &dev));
	183	ut_asserteq_str("c-test@5", dev->name);
	184	ut_assertok(device_find_next_child(&dev));
	185	ut_asserteq_str("c-test@0", dev->name);
	186	ut_assertok(device_find_next_child(&dev));
	187	ut_asserteq_str("c-test@1", dev->name);
	188	ut_assertok(device_find_next_child(&dev));
	189	ut_asserteq_ptr(dev, NULL);
	190
	191	/* Move to the next child without using device_find_first_child() */
	192	ut_assertok(device_find_child_by_seq(bus, 5, true, &dev));
	193	ut_asserteq_str("c-test@5", dev->name);
	194	ut_assertok(device_find_next_child(&dev));
	195	ut_asserteq_str("c-test@0", dev->name);
	196
	197	/* Try a device with no children */
	198	ut_assertok(device_find_first_child(dev, &child));
	199	ut_asserteq_ptr(child, NULL);
	200
	201	return 0;
	202	}
	203	DM_TEST(dm_test_bus_children_iterators,
	204	DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
	205
e59f458d	206	/* Test that the bus can store data about each child */
e721b882	207	static int test_bus_parent_data(struct unit_test_state *uts)
e59f458d SG	208	{
	209	struct dm_test_parent_data *parent_data;
	210	struct udevice bus, dev;
	211	struct uclass *uc;
	212	int value;
	213
	214	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	215
	216	/* Check that parent data is allocated */
	217	ut_assertok(device_find_child_by_seq(bus, 0, true, &dev));
bcbe3d15	218	ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
e59f458d	219	ut_assertok(device_get_child_by_seq(bus, 0, &dev));
bcbe3d15	220	parent_data = dev_get_parent_priv(dev);
e59f458d SG	221	ut_assert(NULL != parent_data);
	222
	223	/* Check that it starts at 0 and goes away when device is removed */
	224	parent_data->sum += 5;
	225	ut_asserteq(5, parent_data->sum);
	226	device_remove(dev);
bcbe3d15	227	ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
e59f458d SG	228
	229	/* Check that we can do this twice */
	230	ut_assertok(device_get_child_by_seq(bus, 0, &dev));
bcbe3d15	231	parent_data = dev_get_parent_priv(dev);
e59f458d SG	232	ut_assert(NULL != parent_data);
	233	parent_data->sum += 5;
	234	ut_asserteq(5, parent_data->sum);
	235
	236	/* Add parent data to all children */
	237	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
	238	value = 5;
	239	uclass_foreach_dev(dev, uc) {
	240	/* Ignore these if they are not on this bus */
	241	if (dev->parent != bus) {
bcbe3d15	242	ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
e59f458d SG	243	continue;
	244	}
	245	ut_assertok(device_probe(dev));
bcbe3d15	246	parent_data = dev_get_parent_priv(dev);
e59f458d SG	247
	248	parent_data->sum = value;
	249	value += 5;
	250	}
	251
	252	/* Check it is still there */
	253	value = 5;
	254	uclass_foreach_dev(dev, uc) {
	255	/* Ignore these if they are not on this bus */
	256	if (dev->parent != bus)
	257	continue;
bcbe3d15	258	parent_data = dev_get_parent_priv(dev);
e59f458d SG	259
	260	ut_asserteq(value, parent_data->sum);
	261	value += 5;
	262	}
	263
	264	return 0;
	265	}
dac8db2c	266	/* Test that the bus can store data about each child */
e721b882	267	static int dm_test_bus_parent_data(struct unit_test_state *uts)
dac8db2c	268	{
e721b882	269	return test_bus_parent_data(uts);
dac8db2c	270	}
e59f458d	271	DM_TEST(dm_test_bus_parent_data, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
a327dee0	272
dac8db2c	273	/* As above but the size is controlled by the uclass */
e721b882	274	static int dm_test_bus_parent_data_uclass(struct unit_test_state *uts)
dac8db2c	275	{
e23eb614	276	struct driver *drv;
dac8db2c SG	277	struct udevice *bus;
	278	int size;
	279	int ret;
	280
	281	/* Set the driver size to 0 so that the uclass size is used */
	282	ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
e23eb614 SG	283	drv = (struct driver *)bus->driver;
e23eb614 SG	284	size = drv->per_child_auto_alloc_size;
dac8db2c	285	bus->uclass->uc_drv->per_child_auto_alloc_size = size;
e23eb614	286	drv->per_child_auto_alloc_size = 0;
e721b882	287	ret = test_bus_parent_data(uts);
dac8db2c SG	288	if (ret)
	289	return ret;
	290	bus->uclass->uc_drv->per_child_auto_alloc_size = 0;
e23eb614	291	drv->per_child_auto_alloc_size = size;
dac8db2c SG	292
	293	return 0;
	294	}
	295	DM_TEST(dm_test_bus_parent_data_uclass,
	296	DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
	297
a327dee0	298	/* Test that the bus ops are called when a child is probed/removed */
e721b882	299	static int dm_test_bus_parent_ops(struct unit_test_state *uts)
a327dee0 SG	300	{
a327dee0 SG	301	struct dm_test_parent_data *parent_data;
e721b882	302	struct dm_test_state *dms = uts->priv;
a327dee0 SG	303	struct udevice bus, dev;
	304	struct uclass *uc;
	305
	306	test_state = dms;
	307	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	308	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
	309
	310	uclass_foreach_dev(dev, uc) {
	311	/* Ignore these if they are not on this bus */
	312	if (dev->parent != bus)
	313	continue;
bcbe3d15	314	ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
a327dee0 SG	315
a327dee0 SG	316	ut_assertok(device_probe(dev));
bcbe3d15	317	parent_data = dev_get_parent_priv(dev);
a327dee0 SG	318	ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
	319	}
	320
	321	uclass_foreach_dev(dev, uc) {
	322	/* Ignore these if they are not on this bus */
	323	if (dev->parent != bus)
	324	continue;
bcbe3d15	325	parent_data = dev_get_parent_priv(dev);
a327dee0 SG	326	ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
a327dee0 SG	327	ut_assertok(device_remove(dev));
bcbe3d15	328	ut_asserteq_ptr(NULL, dev_get_parent_priv(dev));
a327dee0 SG	329	ut_asserteq_ptr(dms->removed, dev);
	330	}
	331	test_state = NULL;
	332
	333	return 0;
	334	}
	335	DM_TEST(dm_test_bus_parent_ops, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
cdc133bd	336
e721b882	337	static int test_bus_parent_platdata(struct unit_test_state *uts)
cdc133bd SG	338	{
	339	struct dm_test_parent_platdata *plat;
	340	struct udevice bus, dev;
	341	int child_count;
	342
	343	/* Check that the bus has no children */
	344	ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
	345	device_find_first_child(bus, &dev);
	346	ut_asserteq_ptr(NULL, dev);
	347
	348	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	349
	350	for (device_find_first_child(bus, &dev), child_count = 0;
	351	dev;
	352	device_find_next_child(&dev)) {
	353	/* Check that platform data is allocated */
	354	plat = dev_get_parent_platdata(dev);
	355	ut_assert(plat != NULL);
	356
	357	/*
	358	* Check that it is not affected by the device being
	359	* probed/removed
	360	*/
	361	plat->count++;
	362	ut_asserteq(1, plat->count);
	363	device_probe(dev);
	364	device_remove(dev);
	365
	366	ut_asserteq_ptr(plat, dev_get_parent_platdata(dev));
	367	ut_asserteq(1, plat->count);
	368	ut_assertok(device_probe(dev));
	369	child_count++;
	370	}
	371	ut_asserteq(3, child_count);
	372
	373	/* Removing the bus should also have no effect (it is still bound) */
	374	device_remove(bus);
	375	for (device_find_first_child(bus, &dev), child_count = 0;
	376	dev;
	377	device_find_next_child(&dev)) {
	378	/* Check that platform data is allocated */
	379	plat = dev_get_parent_platdata(dev);
	380	ut_assert(plat != NULL);
	381	ut_asserteq(1, plat->count);
	382	child_count++;
	383	}
	384	ut_asserteq(3, child_count);
	385
	386	/* Unbind all the children */
	387	do {
	388	device_find_first_child(bus, &dev);
	389	if (dev)
	390	device_unbind(dev);
	391	} while (dev);
	392
	393	/* Now the child platdata should be removed and re-added */
	394	device_probe(bus);
	395	for (device_find_first_child(bus, &dev), child_count = 0;
	396	dev;
	397	device_find_next_child(&dev)) {
	398	/* Check that platform data is allocated */
	399	plat = dev_get_parent_platdata(dev);
	400	ut_assert(plat != NULL);
	401	ut_asserteq(0, plat->count);
402	child_count++;
403	}
404	ut_asserteq(3, child_count);
405
406	return 0;
407	}
ba8da9dc SG	408
ba8da9dc SG	409	/* Test that the bus can store platform data about each child */
e721b882	410	static int dm_test_bus_parent_platdata(struct unit_test_state *uts)
ba8da9dc	411	{
e721b882	412	return test_bus_parent_platdata(uts);
ba8da9dc	413	}
cdc133bd	414	DM_TEST(dm_test_bus_parent_platdata, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
ba8da9dc SG	415
ba8da9dc SG	416	/* As above but the size is controlled by the uclass */
e721b882	417	static int dm_test_bus_parent_platdata_uclass(struct unit_test_state *uts)
ba8da9dc SG	418	{
ba8da9dc SG	419	struct udevice *bus;
e23eb614	420	struct driver *drv;
ba8da9dc SG	421	int size;
	422	int ret;
	423
	424	/* Set the driver size to 0 so that the uclass size is used */
	425	ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
e23eb614 SG	426	drv = (struct driver *)bus->driver;
e23eb614 SG	427	size = drv->per_child_platdata_auto_alloc_size;
ba8da9dc	428	bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = size;
e23eb614	429	drv->per_child_platdata_auto_alloc_size = 0;
e721b882	430	ret = test_bus_parent_platdata(uts);
ba8da9dc SG	431	if (ret)
	432	return ret;
	433	bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = 0;
e23eb614	434	drv->per_child_platdata_auto_alloc_size = size;
ba8da9dc SG	435
	436	return 0;
	437	}
	438	DM_TEST(dm_test_bus_parent_platdata_uclass,
	439	DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
0118ce79 SG	440
0118ce79 SG	441	/* Test that the child post_bind method is called */
e721b882	442	static int dm_test_bus_child_post_bind(struct unit_test_state *uts)
0118ce79 SG	443	{
	444	struct dm_test_parent_platdata *plat;
	445	struct udevice bus, dev;
	446	int child_count;
	447
	448	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	449	for (device_find_first_child(bus, &dev), child_count = 0;
	450	dev;
	451	device_find_next_child(&dev)) {
	452	/* Check that platform data is allocated */
	453	plat = dev_get_parent_platdata(dev);
	454	ut_assert(plat != NULL);
	455	ut_asserteq(1, plat->bind_flag);
	456	child_count++;
	457	}
	458	ut_asserteq(3, child_count);
	459
	460	return 0;
	461	}
	462	DM_TEST(dm_test_bus_child_post_bind, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
081f2fcb SG	463
081f2fcb SG	464	/* Test that the child post_bind method is called */
e721b882	465	static int dm_test_bus_child_post_bind_uclass(struct unit_test_state *uts)
081f2fcb SG	466	{
	467	struct dm_test_parent_platdata *plat;
	468	struct udevice bus, dev;
	469	int child_count;
	470
	471	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	472	for (device_find_first_child(bus, &dev), child_count = 0;
	473	dev;
	474	device_find_next_child(&dev)) {
	475	/* Check that platform data is allocated */
	476	plat = dev_get_parent_platdata(dev);
	477	ut_assert(plat != NULL);
	478	ut_asserteq(2, plat->uclass_bind_flag);
	479	child_count++;
	480	}
	481	ut_asserteq(3, child_count);
	482
	483	return 0;
	484	}
	485	DM_TEST(dm_test_bus_child_post_bind_uclass,
	486	DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
83c7e434 SG	487
	488	/*
	489	* Test that the bus' uclass' child_pre_probe() is called before the
	490	* device's probe() method
	491	*/
e721b882	492	static int dm_test_bus_child_pre_probe_uclass(struct unit_test_state *uts)
83c7e434 SG	493	{
	494	struct udevice bus, dev;
	495	int child_count;
	496
	497	/*
	498	* See testfdt_drv_probe() which effectively checks that the uclass
	499	* flag is set before that method is called
	500	*/
	501	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	502	for (device_find_first_child(bus, &dev), child_count = 0;
	503	dev;
	504	device_find_next_child(&dev)) {
	505	struct dm_test_priv *priv = dev_get_priv(dev);
	506
	507	/* Check that things happened in the right order */
	508	ut_asserteq_ptr(NULL, priv);
	509	ut_assertok(device_probe(dev));
	510
	511	priv = dev_get_priv(dev);
	512	ut_assert(priv != NULL);
	513	ut_asserteq(1, priv->uclass_flag);
	514	ut_asserteq(1, priv->uclass_total);
	515	child_count++;
	516	}
	517	ut_asserteq(3, child_count);
	518
	519	return 0;
	520	}
	521	DM_TEST(dm_test_bus_child_pre_probe_uclass,
	522	DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);