[people/ms/u-boot.git] / test / dm / test-driver.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 <dm.h>
#include <errno.h>
#include <malloc.h>
#include <dm/test.h>
#include <test/ut.h>
#include <asm/io.h>

int dm_testdrv_op_count[DM_TEST_OP_COUNT];
static struct unit_test_state *uts = &global_dm_test_state;

static int testdrv_ping(struct udevice *dev, int pingval, int *pingret)
{
	const struct dm_test_pdata *pdata = dev_get_platdata(dev);
	struct dm_test_priv *priv = dev_get_priv(dev);

	*pingret = pingval + pdata->ping_add;
	priv->ping_total += *pingret;

	return 0;
}

static const struct test_ops test_ops = {
	.ping = testdrv_ping,
};

static int test_bind(struct udevice *dev)
{
	/* Private data should not be allocated */
	ut_assert(!dev_get_priv(dev));

	dm_testdrv_op_count[DM_TEST_OP_BIND]++;
	return 0;
}

static int test_probe(struct udevice *dev)
{
	struct dm_test_priv *priv = dev_get_priv(dev);

	/* Private data should be allocated */
	ut_assert(priv);

	dm_testdrv_op_count[DM_TEST_OP_PROBE]++;
	priv->ping_total += DM_TEST_START_TOTAL;
	return 0;
}

static int test_remove(struct udevice *dev)
{
	/* Private data should still be allocated */
	ut_assert(dev_get_priv(dev));

	dm_testdrv_op_count[DM_TEST_OP_REMOVE]++;
	return 0;
}

static int test_unbind(struct udevice *dev)
{
	/* Private data should not be allocated */
	ut_assert(!dev->priv);

	dm_testdrv_op_count[DM_TEST_OP_UNBIND]++;
	return 0;
}

U_BOOT_DRIVER(test_drv) = {
	.name	= "test_drv",
	.id	= UCLASS_TEST,
	.ops	= &test_ops,
	.bind	= test_bind,
	.probe	= test_probe,
	.remove	= test_remove,
	.unbind	= test_unbind,
	.priv_auto_alloc_size = sizeof(struct dm_test_priv),
};

U_BOOT_DRIVER(test2_drv) = {
	.name	= "test2_drv",
	.id	= UCLASS_TEST,
	.ops	= &test_ops,
	.bind	= test_bind,
	.probe	= test_probe,
	.remove	= test_remove,
	.unbind	= test_unbind,
	.priv_auto_alloc_size = sizeof(struct dm_test_priv),
};

static int test_manual_drv_ping(struct udevice *dev, int pingval, int *pingret)
{
	*pingret = pingval + 2;

	return 0;
}

static const struct test_ops test_manual_ops = {
	.ping = test_manual_drv_ping,
};

static int test_manual_bind(struct udevice *dev)
{
	dm_testdrv_op_count[DM_TEST_OP_BIND]++;

	return 0;
}

static int test_manual_probe(struct udevice *dev)
{
	struct dm_test_state *dms = uts->priv;

	dm_testdrv_op_count[DM_TEST_OP_PROBE]++;
	if (!dms->force_fail_alloc)
		dev->priv = calloc(1, sizeof(struct dm_test_priv));
	if (!dev->priv)
		return -ENOMEM;

	return 0;
}

static int test_manual_remove(struct udevice *dev)
{
	dm_testdrv_op_count[DM_TEST_OP_REMOVE]++;
	return 0;
}

static int test_manual_unbind(struct udevice *dev)
{
	dm_testdrv_op_count[DM_TEST_OP_UNBIND]++;
	return 0;
}

U_BOOT_DRIVER(test_manual_drv) = {
	.name	= "test_manual_drv",
	.id	= UCLASS_TEST,
	.ops	= &test_manual_ops,
	.bind	= test_manual_bind,
	.probe	= test_manual_probe,
	.remove	= test_manual_remove,
	.unbind	= test_manual_unbind,
};

U_BOOT_DRIVER(test_pre_reloc_drv) = {
	.name	= "test_pre_reloc_drv",
	.id	= UCLASS_TEST,
	.ops	= &test_manual_ops,
	.bind	= test_manual_bind,
	.probe	= test_manual_probe,
	.remove	= test_manual_remove,
	.unbind	= test_manual_unbind,
	.flags	= DM_FLAG_PRE_RELOC,
};

U_BOOT_DRIVER(test_act_dma_drv) = {
	.name	= "test_act_dma_drv",
	.id	= UCLASS_TEST,
	.ops	= &test_manual_ops,
	.bind	= test_manual_bind,
	.probe	= test_manual_probe,
	.remove	= test_manual_remove,
	.unbind	= test_manual_unbind,
	.flags	= DM_FLAG_ACTIVE_DMA,
};
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 <dm.h>
	12	#include <errno.h>
	13	#include <malloc.h>
	14	#include <dm/test.h>
e721b882	15	#include <test/ut.h>
2e7d35d2 SG	16	#include <asm/io.h>
	17
	18	int dm_testdrv_op_count[DM_TEST_OP_COUNT];
e721b882	19	static struct unit_test_state *uts = &global_dm_test_state;
2e7d35d2	20
54c5d08a	21	static int testdrv_ping(struct udevice dev, int pingval, int pingret)
2e7d35d2 SG	22	{
	23	const struct dm_test_pdata *pdata = dev_get_platdata(dev);
	24	struct dm_test_priv *priv = dev_get_priv(dev);
	25
	26	*pingret = pingval + pdata->ping_add;
	27	priv->ping_total += *pingret;
	28
	29	return 0;
	30	}
	31
	32	static const struct test_ops test_ops = {
	33	.ping = testdrv_ping,
	34	};
	35
54c5d08a	36	static int test_bind(struct udevice *dev)
2e7d35d2 SG	37	{
	38	/* Private data should not be allocated */
	39	ut_assert(!dev_get_priv(dev));
	40
	41	dm_testdrv_op_count[DM_TEST_OP_BIND]++;
	42	return 0;
	43	}
	44
54c5d08a	45	static int test_probe(struct udevice *dev)
2e7d35d2 SG	46	{
	47	struct dm_test_priv *priv = dev_get_priv(dev);
	48
	49	/* Private data should be allocated */
	50	ut_assert(priv);
	51
	52	dm_testdrv_op_count[DM_TEST_OP_PROBE]++;
	53	priv->ping_total += DM_TEST_START_TOTAL;
	54	return 0;
	55	}
	56
54c5d08a	57	static int test_remove(struct udevice *dev)
2e7d35d2 SG	58	{
	59	/* Private data should still be allocated */
	60	ut_assert(dev_get_priv(dev));
	61
	62	dm_testdrv_op_count[DM_TEST_OP_REMOVE]++;
	63	return 0;
	64	}
	65
54c5d08a	66	static int test_unbind(struct udevice *dev)
2e7d35d2 SG	67	{
	68	/* Private data should not be allocated */
	69	ut_assert(!dev->priv);
	70
	71	dm_testdrv_op_count[DM_TEST_OP_UNBIND]++;
	72	return 0;
	73	}
	74
	75	U_BOOT_DRIVER(test_drv) = {
	76	.name = "test_drv",
	77	.id = UCLASS_TEST,
	78	.ops = &test_ops,
	79	.bind = test_bind,
	80	.probe = test_probe,
	81	.remove = test_remove,
	82	.unbind = test_unbind,
	83	.priv_auto_alloc_size = sizeof(struct dm_test_priv),
	84	};
	85
	86	U_BOOT_DRIVER(test2_drv) = {
	87	.name = "test2_drv",
	88	.id = UCLASS_TEST,
	89	.ops = &test_ops,
	90	.bind = test_bind,
	91	.probe = test_probe,
	92	.remove = test_remove,
	93	.unbind = test_unbind,
	94	.priv_auto_alloc_size = sizeof(struct dm_test_priv),
	95	};
	96
54c5d08a	97	static int test_manual_drv_ping(struct udevice dev, int pingval, int pingret)
2e7d35d2 SG	98	{
	99	*pingret = pingval + 2;
	100
	101	return 0;
	102	}
	103
	104	static const struct test_ops test_manual_ops = {
	105	.ping = test_manual_drv_ping,
	106	};
	107
54c5d08a	108	static int test_manual_bind(struct udevice *dev)
2e7d35d2 SG	109	{
	110	dm_testdrv_op_count[DM_TEST_OP_BIND]++;
	111
	112	return 0;
	113	}
	114
54c5d08a	115	static int test_manual_probe(struct udevice *dev)
2e7d35d2	116	{
e721b882 JH	117	struct dm_test_state *dms = uts->priv;
e721b882 JH	118
2e7d35d2 SG	119	dm_testdrv_op_count[DM_TEST_OP_PROBE]++;
	120	if (!dms->force_fail_alloc)
	121	dev->priv = calloc(1, sizeof(struct dm_test_priv));
	122	if (!dev->priv)
	123	return -ENOMEM;
	124
	125	return 0;
	126	}
	127
54c5d08a	128	static int test_manual_remove(struct udevice *dev)
2e7d35d2 SG	129	{
	130	dm_testdrv_op_count[DM_TEST_OP_REMOVE]++;
	131	return 0;
	132	}
	133
54c5d08a	134	static int test_manual_unbind(struct udevice *dev)
2e7d35d2 SG	135	{
	136	dm_testdrv_op_count[DM_TEST_OP_UNBIND]++;
	137	return 0;
	138	}
	139
	140	U_BOOT_DRIVER(test_manual_drv) = {
	141	.name = "test_manual_drv",
	142	.id = UCLASS_TEST,
	143	.ops = &test_manual_ops,
	144	.bind = test_manual_bind,
	145	.probe = test_manual_probe,
	146	.remove = test_manual_remove,
	147	.unbind = test_manual_unbind,
	148	};
00606d7e SG	149
	150	U_BOOT_DRIVER(test_pre_reloc_drv) = {
	151	.name = "test_pre_reloc_drv",
	152	.id = UCLASS_TEST,
	153	.ops = &test_manual_ops,
	154	.bind = test_manual_bind,
	155	.probe = test_manual_probe,
	156	.remove = test_manual_remove,
	157	.unbind = test_manual_unbind,
	158	.flags = DM_FLAG_PRE_RELOC,
	159	};
24f927c5 SR	160
	161	U_BOOT_DRIVER(test_act_dma_drv) = {
	162	.name = "test_act_dma_drv",
	163	.id = UCLASS_TEST,
	164	.ops = &test_manual_ops,
	165	.bind = test_manual_bind,
	166	.probe = test_manual_probe,
	167	.remove = test_manual_remove,
	168	.unbind = test_manual_unbind,
	169	.flags = DM_FLAG_ACTIVE_DMA,
	170	};