[J-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/ut.h>
#include <dm/util.h>

DECLARE_GLOBAL_DATA_PTR;

struct dm_test_parent_platdata {
	int count;
	int 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;

	return 0;
}

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

	parent_data->flag += FLAG_CHILD_PROBED;

	return 0;
}

static int testbus_child_post_remove(struct udevice *dev)
{
	struct dm_test_parent_data *parent_data = dev_get_parentdata(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,
};

/* Test that we can probe for children */
static int dm_test_bus_children(struct dm_test_state *dms)
{
	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(dms, 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)
{
	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 dm_test_state *dms)
{
	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 dm_test_bus_parent_data(struct dm_test_state *dms)
{
	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_parentdata(dev));
	ut_assertok(device_get_child_by_seq(bus, 0, &dev));
	parent_data = dev_get_parentdata(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));

	/* Check that we can do this twice */
	ut_assertok(device_get_child_by_seq(bus, 0, &dev));
	parent_data = dev_get_parentdata(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_parentdata(dev));
			continue;
		}
		ut_assertok(device_probe(dev));
		parent_data = dev_get_parentdata(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_parentdata(dev);

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

	return 0;
}

DM_TEST(dm_test_bus_parent_data, 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)
{
	struct dm_test_parent_data *parent_data;
	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_parentdata(dev));

		ut_assertok(device_probe(dev));
		parent_data = dev_get_parentdata(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_parentdata(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(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 dm_test_state *dms)
{
	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 dm_test_state *dms)
{
	return test_bus_parent_platdata(dms);
}
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)
{
	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_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);
	if (ret)
		return ret;
	bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = 0;
	bus->driver->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 dm_test_state *dms)
{
	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);
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 SG	13	#include <dm/ut.h>
	14	#include <dm/util.h>
	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;
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)
	31	{
	32	return dm_scan_fdt_node(dev, gd->fdt_blob, dev->of_offset, false);
	33	}
	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;
	41
	42	return 0;
	43	}
	44
a327dee0 SG	45	static int testbus_child_pre_probe(struct udevice *dev)
	46	{
	47	struct dm_test_parent_data *parent_data = dev_get_parentdata(dev);
	48
	49	parent_data->flag += FLAG_CHILD_PROBED;
	50
	51	return 0;
	52	}
	53
	54	static int testbus_child_post_remove(struct udevice *dev)
	55	{
	56	struct dm_test_parent_data *parent_data = dev_get_parentdata(dev);
	57	struct dm_test_state *dms = test_state;
	58
	59	parent_data->flag += FLAG_CHILD_REMOVED;
	60	if (dms)
	61	dms->removed = dev;
	62
	63	return 0;
	64	}
	65
1ca7e206 SG	66	static const struct udevice_id testbus_ids[] = {
	67	{
	68	.compatible = "denx,u-boot-test-bus",
	69	.data = DM_TEST_TYPE_FIRST },
	70	{ }
	71	};
	72
	73	U_BOOT_DRIVER(testbus_drv) = {
	74	.name = "testbus_drv",
	75	.of_match = testbus_ids,
	76	.id = UCLASS_TEST_BUS,
	77	.probe = testbus_drv_probe,
0118ce79	78	.child_post_bind = testbus_child_post_bind,
1ca7e206 SG	79	.priv_auto_alloc_size = sizeof(struct dm_test_priv),
1ca7e206 SG	80	.platdata_auto_alloc_size = sizeof(struct dm_test_pdata),
e59f458d	81	.per_child_auto_alloc_size = sizeof(struct dm_test_parent_data),
cdc133bd SG	82	.per_child_platdata_auto_alloc_size =
cdc133bd SG	83	sizeof(struct dm_test_parent_platdata),
a327dee0 SG	84	.child_pre_probe = testbus_child_pre_probe,
a327dee0 SG	85	.child_post_remove = testbus_child_post_remove,
1ca7e206 SG	86	};
	87
	88	UCLASS_DRIVER(testbus) = {
	89	.name = "testbus",
	90	.id = UCLASS_TEST_BUS,
9cc36a2b	91	.flags = DM_UC_FLAG_SEQ_ALIAS,
1ca7e206 SG	92	};
	93
	94	/* Test that we can probe for children */
	95	static int dm_test_bus_children(struct dm_test_state *dms)
	96	{
9cc36a2b	97	int num_devices = 6;
1ca7e206 SG	98	struct udevice *bus;
	99	struct uclass *uc;
	100
	101	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
	102	ut_asserteq(num_devices, list_count_items(&uc->dev_head));
	103
	104	/* Probe the bus, which should yield 3 more devices */
	105	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	106	num_devices += 3;
	107
	108	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
	109	ut_asserteq(num_devices, list_count_items(&uc->dev_head));
	110
	111	ut_assert(!dm_check_devices(dms, num_devices));
	112
	113	return 0;
	114	}
	115	DM_TEST(dm_test_bus_children, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
997c87bb SG	116
	117	/* Test our functions for accessing children */
	118	static int dm_test_bus_children_funcs(struct dm_test_state *dms)
	119	{
	120	const void *blob = gd->fdt_blob;
	121	struct udevice bus, dev;
	122	int node;
	123
	124	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	125
	126	/* device_get_child() */
	127	ut_assertok(device_get_child(bus, 0, &dev));
	128	ut_asserteq(-ENODEV, device_get_child(bus, 4, &dev));
	129	ut_assertok(device_get_child_by_seq(bus, 5, &dev));
	130	ut_assert(dev->flags & DM_FLAG_ACTIVATED);
	131	ut_asserteq_str("c-test@5", dev->name);
	132
	133	/* Device with sequence number 0 should be accessible */
	134	ut_asserteq(-ENODEV, device_find_child_by_seq(bus, -1, true, &dev));
	135	ut_assertok(device_find_child_by_seq(bus, 0, true, &dev));
	136	ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
	137	ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 0, false, &dev));
	138	ut_assertok(device_get_child_by_seq(bus, 0, &dev));
	139	ut_assert(dev->flags & DM_FLAG_ACTIVATED);
	140
	141	/* There is no device with sequence number 2 */
	142	ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, false, &dev));
	143	ut_asserteq(-ENODEV, device_find_child_by_seq(bus, 2, true, &dev));
	144	ut_asserteq(-ENODEV, device_get_child_by_seq(bus, 2, &dev));
	145
	146	/* Looking for something that is not a child */
	147	node = fdt_path_offset(blob, "/junk");
	148	ut_asserteq(-ENODEV, device_find_child_by_of_offset(bus, node, &dev));
	149	node = fdt_path_offset(blob, "/d-test");
	150	ut_asserteq(-ENODEV, device_find_child_by_of_offset(bus, node, &dev));
	151
	152	/* Find a valid child */
	153	node = fdt_path_offset(blob, "/some-bus/c-test@1");
	154	ut_assertok(device_find_child_by_of_offset(bus, node, &dev));
	155	ut_assert(!(dev->flags & DM_FLAG_ACTIVATED));
	156	ut_assertok(device_get_child_by_of_offset(bus, node, &dev));
	157	ut_assert(dev->flags & DM_FLAG_ACTIVATED);
	158
	159	return 0;
	160	}
	161	DM_TEST(dm_test_bus_children_funcs, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
e59f458d	162
a8981d4f SG	163	/* Test that we can iterate through children */
	164	static int dm_test_bus_children_iterators(struct dm_test_state *dms)
	165	{
	166	struct udevice bus, dev, *child;
	167
	168	/* Walk through the children one by one */
	169	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	170	ut_assertok(device_find_first_child(bus, &dev));
	171	ut_asserteq_str("c-test@5", dev->name);
	172	ut_assertok(device_find_next_child(&dev));
	173	ut_asserteq_str("c-test@0", dev->name);
	174	ut_assertok(device_find_next_child(&dev));
	175	ut_asserteq_str("c-test@1", dev->name);
	176	ut_assertok(device_find_next_child(&dev));
	177	ut_asserteq_ptr(dev, NULL);
	178
	179	/* Move to the next child without using device_find_first_child() */
	180	ut_assertok(device_find_child_by_seq(bus, 5, true, &dev));
	181	ut_asserteq_str("c-test@5", dev->name);
	182	ut_assertok(device_find_next_child(&dev));
	183	ut_asserteq_str("c-test@0", dev->name);
	184
	185	/* Try a device with no children */
	186	ut_assertok(device_find_first_child(dev, &child));
	187	ut_asserteq_ptr(child, NULL);
	188
	189	return 0;
	190	}
	191	DM_TEST(dm_test_bus_children_iterators,
	192	DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
	193
e59f458d SG	194	/* Test that the bus can store data about each child */
	195	static int dm_test_bus_parent_data(struct dm_test_state *dms)
	196	{
	197	struct dm_test_parent_data *parent_data;
	198	struct udevice bus, dev;
	199	struct uclass *uc;
	200	int value;
	201
	202	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	203
	204	/* Check that parent data is allocated */
	205	ut_assertok(device_find_child_by_seq(bus, 0, true, &dev));
	206	ut_asserteq_ptr(NULL, dev_get_parentdata(dev));
	207	ut_assertok(device_get_child_by_seq(bus, 0, &dev));
	208	parent_data = dev_get_parentdata(dev);
	209	ut_assert(NULL != parent_data);
	210
	211	/* Check that it starts at 0 and goes away when device is removed */
	212	parent_data->sum += 5;
	213	ut_asserteq(5, parent_data->sum);
	214	device_remove(dev);
	215	ut_asserteq_ptr(NULL, dev_get_parentdata(dev));
	216
	217	/* Check that we can do this twice */
	218	ut_assertok(device_get_child_by_seq(bus, 0, &dev));
	219	parent_data = dev_get_parentdata(dev);
	220	ut_assert(NULL != parent_data);
	221	parent_data->sum += 5;
	222	ut_asserteq(5, parent_data->sum);
	223
	224	/* Add parent data to all children */
	225	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
	226	value = 5;
	227	uclass_foreach_dev(dev, uc) {
	228	/* Ignore these if they are not on this bus */
	229	if (dev->parent != bus) {
	230	ut_asserteq_ptr(NULL, dev_get_parentdata(dev));
	231	continue;
	232	}
	233	ut_assertok(device_probe(dev));
	234	parent_data = dev_get_parentdata(dev);
	235
	236	parent_data->sum = value;
	237	value += 5;
	238	}
	239
	240	/* Check it is still there */
	241	value = 5;
	242	uclass_foreach_dev(dev, uc) {
	243	/* Ignore these if they are not on this bus */
	244	if (dev->parent != bus)
	245	continue;
	246	parent_data = dev_get_parentdata(dev);
	247
	248	ut_asserteq(value, parent_data->sum);
	249	value += 5;
	250	}
	251
	252	return 0;
	253	}
	254
	255	DM_TEST(dm_test_bus_parent_data, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
a327dee0 SG	256
	257	/* Test that the bus ops are called when a child is probed/removed */
	258	static int dm_test_bus_parent_ops(struct dm_test_state *dms)
	259	{
	260	struct dm_test_parent_data *parent_data;
	261	struct udevice bus, dev;
	262	struct uclass *uc;
	263
	264	test_state = dms;
	265	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	266	ut_assertok(uclass_get(UCLASS_TEST_FDT, &uc));
	267
	268	uclass_foreach_dev(dev, uc) {
	269	/* Ignore these if they are not on this bus */
	270	if (dev->parent != bus)
	271	continue;
	272	ut_asserteq_ptr(NULL, dev_get_parentdata(dev));
	273
	274	ut_assertok(device_probe(dev));
	275	parent_data = dev_get_parentdata(dev);
	276	ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
	277	}
	278
	279	uclass_foreach_dev(dev, uc) {
	280	/* Ignore these if they are not on this bus */
	281	if (dev->parent != bus)
	282	continue;
	283	parent_data = dev_get_parentdata(dev);
	284	ut_asserteq(FLAG_CHILD_PROBED, parent_data->flag);
	285	ut_assertok(device_remove(dev));
	286	ut_asserteq_ptr(NULL, dev_get_parentdata(dev));
	287	ut_asserteq_ptr(dms->removed, dev);
	288	}
	289	test_state = NULL;
	290
	291	return 0;
	292	}
	293	DM_TEST(dm_test_bus_parent_ops, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
cdc133bd	294
ba8da9dc	295	static int test_bus_parent_platdata(struct dm_test_state *dms)
cdc133bd SG	296	{
	297	struct dm_test_parent_platdata *plat;
	298	struct udevice bus, dev;
	299	int child_count;
	300
	301	/* Check that the bus has no children */
	302	ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
	303	device_find_first_child(bus, &dev);
	304	ut_asserteq_ptr(NULL, dev);
	305
	306	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	307
	308	for (device_find_first_child(bus, &dev), child_count = 0;
	309	dev;
	310	device_find_next_child(&dev)) {
	311	/* Check that platform data is allocated */
	312	plat = dev_get_parent_platdata(dev);
	313	ut_assert(plat != NULL);
	314
	315	/*
	316	* Check that it is not affected by the device being
	317	* probed/removed
	318	*/
	319	plat->count++;
	320	ut_asserteq(1, plat->count);
	321	device_probe(dev);
	322	device_remove(dev);
	323
	324	ut_asserteq_ptr(plat, dev_get_parent_platdata(dev));
	325	ut_asserteq(1, plat->count);
	326	ut_assertok(device_probe(dev));
	327	child_count++;
	328	}
	329	ut_asserteq(3, child_count);
	330
	331	/* Removing the bus should also have no effect (it is still bound) */
	332	device_remove(bus);
	333	for (device_find_first_child(bus, &dev), child_count = 0;
	334	dev;
	335	device_find_next_child(&dev)) {
	336	/* Check that platform data is allocated */
	337	plat = dev_get_parent_platdata(dev);
	338	ut_assert(plat != NULL);
	339	ut_asserteq(1, plat->count);
	340	child_count++;
	341	}
	342	ut_asserteq(3, child_count);
	343
	344	/* Unbind all the children */
	345	do {
	346	device_find_first_child(bus, &dev);
	347	if (dev)
	348	device_unbind(dev);
	349	} while (dev);
	350
	351	/* Now the child platdata should be removed and re-added */
	352	device_probe(bus);
	353	for (device_find_first_child(bus, &dev), child_count = 0;
	354	dev;
	355	device_find_next_child(&dev)) {
	356	/* Check that platform data is allocated */
	357	plat = dev_get_parent_platdata(dev);
	358	ut_assert(plat != NULL);
	359	ut_asserteq(0, plat->count);
360	child_count++;
361	}
362	ut_asserteq(3, child_count);
363
364	return 0;
365	}
ba8da9dc SG	366
	367	/* Test that the bus can store platform data about each child */
	368	static int dm_test_bus_parent_platdata(struct dm_test_state *dms)
	369	{
	370	return test_bus_parent_platdata(dms);
	371	}
cdc133bd	372	DM_TEST(dm_test_bus_parent_platdata, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
ba8da9dc SG	373
	374	/* As above but the size is controlled by the uclass */
	375	static int dm_test_bus_parent_platdata_uclass(struct dm_test_state *dms)
	376	{
	377	struct udevice *bus;
	378	int size;
	379	int ret;
	380
	381	/* Set the driver size to 0 so that the uclass size is used */
	382	ut_assertok(uclass_find_device(UCLASS_TEST_BUS, 0, &bus));
	383	size = bus->driver->per_child_platdata_auto_alloc_size;
	384	bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = size;
	385	bus->driver->per_child_platdata_auto_alloc_size = 0;
	386	ret = test_bus_parent_platdata(dms);
	387	if (ret)
	388	return ret;
	389	bus->uclass->uc_drv->per_child_platdata_auto_alloc_size = 0;
	390	bus->driver->per_child_platdata_auto_alloc_size = size;
	391
	392	return 0;
	393	}
	394	DM_TEST(dm_test_bus_parent_platdata_uclass,
	395	DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);
0118ce79 SG	396
	397	/* Test that the child post_bind method is called */
	398	static int dm_test_bus_child_post_bind(struct dm_test_state *dms)
	399	{
	400	struct dm_test_parent_platdata *plat;
	401	struct udevice bus, dev;
	402	int child_count;
	403
	404	ut_assertok(uclass_get_device(UCLASS_TEST_BUS, 0, &bus));
	405	for (device_find_first_child(bus, &dev), child_count = 0;
	406	dev;
	407	device_find_next_child(&dev)) {
	408	/* Check that platform data is allocated */
	409	plat = dev_get_parent_platdata(dev);
	410	ut_assert(plat != NULL);
	411	ut_asserteq(1, plat->bind_flag);
	412	child_count++;
	413	}
	414	ut_asserteq(3, child_count);
	415
	416	return 0;
	417	}
	418	DM_TEST(dm_test_bus_child_post_bind, DM_TESTF_SCAN_PDATA \| DM_TESTF_SCAN_FDT);