[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/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_dev(dev);
}

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