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

/*
 * Copyright (c) 2013 Google, Inc
 *
 * (C) Copyright 2012
 * Pavel Herrmann <morpheus.ibis@gmail.com>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <malloc.h>
#include <dm.h>
#include <errno.h>
#include <asm/io.h>
#include <dm/test.h>
#include <linux/list.h>
#include <test/ut.h>

static struct unit_test_state *uts = &global_dm_test_state;

int test_ping(struct udevice *dev, int pingval, int *pingret)
{
	const struct test_ops *ops = device_get_ops(dev);

	if (!ops->ping)
		return -ENOSYS;

	return ops->ping(dev, pingval, pingret);
}

static int test_post_bind(struct udevice *dev)
{
	struct dm_test_perdev_uc_pdata *uc_pdata;

	dm_testdrv_op_count[DM_TEST_OP_POST_BIND]++;
	ut_assert(!device_active(dev));

	uc_pdata = dev_get_uclass_platdata(dev);
	ut_assert(uc_pdata);

	uc_pdata->intval1 = TEST_UC_PDATA_INTVAL1;
	uc_pdata->intval2 = TEST_UC_PDATA_INTVAL2;
	uc_pdata->intval3 = TEST_UC_PDATA_INTVAL3;

	return 0;
}

static int test_pre_unbind(struct udevice *dev)
{
	dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]++;

	return 0;
}

static int test_pre_probe(struct udevice *dev)
{
	struct dm_test_uclass_perdev_priv *priv = dev_get_uclass_priv(dev);

	dm_testdrv_op_count[DM_TEST_OP_PRE_PROBE]++;
	ut_assert(priv);
	ut_assert(device_active(dev));

	return 0;
}

static int test_post_probe(struct udevice *dev)
{
	struct udevice *prev = list_entry(dev->uclass_node.prev,
					    struct udevice, uclass_node);

	struct dm_test_uclass_perdev_priv *priv = dev_get_uclass_priv(dev);
	struct uclass *uc = dev->uclass;
	struct dm_test_state *dms = uts->priv;

	dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]++;
	ut_assert(priv);
	ut_assert(device_active(dev));
	priv->base_add = 0;
	if (dms->skip_post_probe)
		return 0;
	if (&prev->uclass_node != &uc->dev_head) {
		struct dm_test_uclass_perdev_priv *prev_uc_priv
				= dev_get_uclass_priv(prev);
		struct dm_test_pdata *pdata = prev->platdata;

		ut_assert(pdata);
		ut_assert(prev_uc_priv);
		priv->base_add = prev_uc_priv->base_add + pdata->ping_add;
	}

	return 0;
}

static int test_pre_remove(struct udevice *dev)
{
	dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]++;

	return 0;
}

static int test_init(struct uclass *uc)
{
	dm_testdrv_op_count[DM_TEST_OP_INIT]++;
	ut_assert(uc->priv);

	return 0;
}

static int test_destroy(struct uclass *uc)
{
	dm_testdrv_op_count[DM_TEST_OP_DESTROY]++;

	return 0;
}

UCLASS_DRIVER(test) = {
	.name		= "test",
	.id		= UCLASS_TEST,
	.post_bind	= test_post_bind,
	.pre_unbind	= test_pre_unbind,
	.pre_probe	= test_pre_probe,
	.post_probe	= test_post_probe,
	.pre_remove	= test_pre_remove,
	.init		= test_init,
	.destroy	= test_destroy,
	.priv_auto_alloc_size	= sizeof(struct dm_test_uclass_priv),
	.per_device_auto_alloc_size = sizeof(struct dm_test_uclass_perdev_priv),
	.per_device_platdata_auto_alloc_size =
					sizeof(struct dm_test_perdev_uc_pdata),
};
Commit	Line	Data
2e7d35d2 SG	1	/*
	2	* Copyright (c) 2013 Google, Inc
	3	*
	4	* (C) Copyright 2012
	5	* Pavel Herrmann <morpheus.ibis@gmail.com>
	6	*
	7	* SPDX-License-Identifier: GPL-2.0+
	8	*/
	9
	10	#include <common.h>
	11	#include <malloc.h>
	12	#include <dm.h>
	13	#include <errno.h>
2e7d35d2	14	#include <asm/io.h>
e721b882	15	#include <dm/test.h>
2e7d35d2	16	#include <linux/list.h>
e721b882	17	#include <test/ut.h>
2e7d35d2	18
e721b882	19	static struct unit_test_state *uts = &global_dm_test_state;
2e7d35d2	20
54c5d08a	21	int test_ping(struct udevice dev, int pingval, int pingret)
2e7d35d2 SG	22	{
	23	const struct test_ops *ops = device_get_ops(dev);
	24
	25	if (!ops->ping)
	26	return -ENOSYS;
	27
	28	return ops->ping(dev, pingval, pingret);
	29	}
	30
54c5d08a	31	static int test_post_bind(struct udevice *dev)
2e7d35d2	32	{
754e71e8 PM	33	struct dm_test_perdev_uc_pdata *uc_pdata;
754e71e8 PM	34
2e7d35d2	35	dm_testdrv_op_count[DM_TEST_OP_POST_BIND]++;
206d4d2b	36	ut_assert(!device_active(dev));
2e7d35d2	37
754e71e8 PM	38	uc_pdata = dev_get_uclass_platdata(dev);
	39	ut_assert(uc_pdata);
	40
	41	uc_pdata->intval1 = TEST_UC_PDATA_INTVAL1;
	42	uc_pdata->intval2 = TEST_UC_PDATA_INTVAL2;
	43	uc_pdata->intval3 = TEST_UC_PDATA_INTVAL3;
	44
2e7d35d2 SG	45	return 0;
	46	}
	47
54c5d08a	48	static int test_pre_unbind(struct udevice *dev)
2e7d35d2 SG	49	{
	50	dm_testdrv_op_count[DM_TEST_OP_PRE_UNBIND]++;
	51
	52	return 0;
	53	}
	54
02c07b37 SG	55	static int test_pre_probe(struct udevice *dev)
	56	{
	57	struct dm_test_uclass_perdev_priv *priv = dev_get_uclass_priv(dev);
	58
	59	dm_testdrv_op_count[DM_TEST_OP_PRE_PROBE]++;
	60	ut_assert(priv);
206d4d2b	61	ut_assert(device_active(dev));
02c07b37 SG	62
	63	return 0;
	64	}
	65
54c5d08a	66	static int test_post_probe(struct udevice *dev)
2e7d35d2	67	{
54c5d08a HS	68	struct udevice *prev = list_entry(dev->uclass_node.prev,
	69	struct udevice, uclass_node);
	70
e564f054	71	struct dm_test_uclass_perdev_priv *priv = dev_get_uclass_priv(dev);
2e7d35d2	72	struct uclass *uc = dev->uclass;
e721b882	73	struct dm_test_state *dms = uts->priv;
2e7d35d2 SG	74
	75	dm_testdrv_op_count[DM_TEST_OP_POST_PROBE]++;
	76	ut_assert(priv);
	77	ut_assert(device_active(dev));
	78	priv->base_add = 0;
	79	if (dms->skip_post_probe)
	80	return 0;
	81	if (&prev->uclass_node != &uc->dev_head) {
	82	struct dm_test_uclass_perdev_priv *prev_uc_priv
e564f054	83	= dev_get_uclass_priv(prev);
2e7d35d2 SG	84	struct dm_test_pdata *pdata = prev->platdata;
	85
	86	ut_assert(pdata);
	87	ut_assert(prev_uc_priv);
	88	priv->base_add = prev_uc_priv->base_add + pdata->ping_add;
	89	}
	90
	91	return 0;
	92	}
	93
54c5d08a	94	static int test_pre_remove(struct udevice *dev)
2e7d35d2 SG	95	{
	96	dm_testdrv_op_count[DM_TEST_OP_PRE_REMOVE]++;
	97
	98	return 0;
	99	}
	100
	101	static int test_init(struct uclass *uc)
	102	{
	103	dm_testdrv_op_count[DM_TEST_OP_INIT]++;
	104	ut_assert(uc->priv);
	105
	106	return 0;
	107	}
	108
	109	static int test_destroy(struct uclass *uc)
	110	{
	111	dm_testdrv_op_count[DM_TEST_OP_DESTROY]++;
	112
	113	return 0;
	114	}
	115
	116	UCLASS_DRIVER(test) = {
	117	.name = "test",
	118	.id = UCLASS_TEST,
	119	.post_bind = test_post_bind,
	120	.pre_unbind = test_pre_unbind,
02c07b37	121	.pre_probe = test_pre_probe,
2e7d35d2 SG	122	.post_probe = test_post_probe,
	123	.pre_remove = test_pre_remove,
	124	.init = test_init,
	125	.destroy = test_destroy,
	126	.priv_auto_alloc_size = sizeof(struct dm_test_uclass_priv),
	127	.per_device_auto_alloc_size = sizeof(struct dm_test_uclass_perdev_priv),
754e71e8 PM	128	.per_device_platdata_auto_alloc_size =
754e71e8 PM	129	sizeof(struct dm_test_perdev_uc_pdata),
2e7d35d2	130	};