[thirdparty/u-boot.git] / test / dm / sysreset.c

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

#include <common.h>
#include <dm.h>
#include <sysreset.h>
#include <asm/state.h>
#include <asm/test.h>
#include <dm/test.h>
#include <test/test.h>
#include <test/ut.h>

/* Test that we can use particular sysreset devices */
static int dm_test_sysreset_base(struct unit_test_state *uts)
{
	struct sandbox_state *state = state_get_current();
	struct udevice *dev;

	/* Device 0 is the platform data device - it should never respond */
	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 0, &dev));
	ut_asserteq(-ENODEV, sysreset_request(dev, SYSRESET_WARM));
	ut_asserteq(-ENODEV, sysreset_request(dev, SYSRESET_COLD));
	ut_asserteq(-ENODEV, sysreset_request(dev, SYSRESET_POWER));

	/* Device 1 is the warm sysreset device */
	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 1, &dev));
	ut_asserteq(-EACCES, sysreset_request(dev, SYSRESET_WARM));
	ut_asserteq(-EPROTONOSUPPORT, sysreset_request(dev, SYSRESET_COLD));
	ut_asserteq(-EPROTONOSUPPORT, sysreset_request(dev, SYSRESET_POWER));

	state->sysreset_allowed[SYSRESET_WARM] = true;
	ut_asserteq(-EINPROGRESS, sysreset_request(dev, SYSRESET_WARM));
	state->sysreset_allowed[SYSRESET_WARM] = false;

	/* Device 2 is the cold sysreset device */
	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 2, &dev));
	ut_asserteq(-EPROTONOSUPPORT, sysreset_request(dev, SYSRESET_WARM));
	state->sysreset_allowed[SYSRESET_COLD] = false;
	ut_asserteq(-EACCES, sysreset_request(dev, SYSRESET_COLD));
	state->sysreset_allowed[SYSRESET_COLD] = true;
	state->sysreset_allowed[SYSRESET_POWER] = false;
	ut_asserteq(-EACCES, sysreset_request(dev, SYSRESET_POWER));
	state->sysreset_allowed[SYSRESET_POWER] = true;

	return 0;
}
DM_TEST(dm_test_sysreset_base, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

static int dm_test_sysreset_get_status(struct unit_test_state *uts)
{
	struct udevice *dev;
	char msg[64];

	/* Device 1 is the warm sysreset device */
	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 1, &dev));
	ut_assertok(sysreset_get_status(dev, msg, sizeof(msg)));
	ut_asserteq_str("Reset Status: WARM", msg);

	/* Device 2 is the cold sysreset device */
	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 2, &dev));
	ut_assertok(sysreset_get_status(dev, msg, sizeof(msg)));
	ut_asserteq_str("Reset Status: COLD", msg);

	return 0;
}
DM_TEST(dm_test_sysreset_get_status, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

/* Test that we can walk through the sysreset devices */
static int dm_test_sysreset_walk(struct unit_test_state *uts)
{
	struct sandbox_state *state = state_get_current();

	/* If we generate a power sysreset, we will exit sandbox! */
	state->sysreset_allowed[SYSRESET_WARM] = false;
	state->sysreset_allowed[SYSRESET_COLD] = false;
	state->sysreset_allowed[SYSRESET_POWER] = false;
	state->sysreset_allowed[SYSRESET_POWER_OFF] = false;
	ut_asserteq(-EACCES, sysreset_walk(SYSRESET_WARM));
	ut_asserteq(-EACCES, sysreset_walk(SYSRESET_COLD));
	ut_asserteq(-EACCES, sysreset_walk(SYSRESET_POWER));
	ut_asserteq(-EACCES, sysreset_walk(SYSRESET_POWER_OFF));

	/*
	 * Enable cold system reset - this should make cold system reset work,
	 * plus a warm system reset should be promoted to cold, since this is
	 * the next step along.
	 */
	state->sysreset_allowed[SYSRESET_WARM] = true;
	ut_asserteq(-EINPROGRESS, sysreset_walk(SYSRESET_WARM));
	ut_asserteq(-EACCES, sysreset_walk(SYSRESET_COLD));
	ut_asserteq(-EACCES, sysreset_walk(SYSRESET_POWER));
	state->sysreset_allowed[SYSRESET_COLD] = true;
	state->sysreset_allowed[SYSRESET_POWER] = true;

	return 0;
}
DM_TEST(dm_test_sysreset_walk, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);

static int dm_test_sysreset_get_last(struct unit_test_state *uts)
{
	struct udevice *dev;

	/* Device 1 is the warm sysreset device */
	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 1, &dev));
	ut_asserteq(SYSRESET_WARM, sysreset_get_last(dev));

	/* Device 2 is the cold sysreset device */
	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 2, &dev));
	ut_asserteq(SYSRESET_POWER, sysreset_get_last(dev));

	/* This is device 0, the non-DT one */
	ut_asserteq(SYSRESET_POWER, sysreset_get_last_walk());

	return 0;
}
DM_TEST(dm_test_sysreset_get_last, UT_TESTF_SCAN_PDATA | UT_TESTF_SCAN_FDT);
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
11636258 SW	2	/*
11636258 SW	3	* Copyright (C) 2015 Google, Inc
11636258 SW	4	*/
11636258 SW	5
d678a59d	6	#include <common.h>
11636258 SW	7	#include <dm.h>
	8	#include <sysreset.h>
	9	#include <asm/state.h>
	10	#include <asm/test.h>
	11	#include <dm/test.h>
0e1fad43	12	#include <test/test.h>
11636258 SW	13	#include <test/ut.h>
	14
	15	/* Test that we can use particular sysreset devices */
	16	static int dm_test_sysreset_base(struct unit_test_state *uts)
	17	{
	18	struct sandbox_state *state = state_get_current();
	19	struct udevice *dev;
	20
	21	/* Device 0 is the platform data device - it should never respond */
	22	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 0, &dev));
	23	ut_asserteq(-ENODEV, sysreset_request(dev, SYSRESET_WARM));
	24	ut_asserteq(-ENODEV, sysreset_request(dev, SYSRESET_COLD));
	25	ut_asserteq(-ENODEV, sysreset_request(dev, SYSRESET_POWER));
	26
	27	/* Device 1 is the warm sysreset device */
	28	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 1, &dev));
	29	ut_asserteq(-EACCES, sysreset_request(dev, SYSRESET_WARM));
da35ab68 PB	30	ut_asserteq(-EPROTONOSUPPORT, sysreset_request(dev, SYSRESET_COLD));
da35ab68 PB	31	ut_asserteq(-EPROTONOSUPPORT, sysreset_request(dev, SYSRESET_POWER));
11636258 SW	32
	33	state->sysreset_allowed[SYSRESET_WARM] = true;
	34	ut_asserteq(-EINPROGRESS, sysreset_request(dev, SYSRESET_WARM));
	35	state->sysreset_allowed[SYSRESET_WARM] = false;
	36
	37	/* Device 2 is the cold sysreset device */
	38	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 2, &dev));
da35ab68	39	ut_asserteq(-EPROTONOSUPPORT, sysreset_request(dev, SYSRESET_WARM));
bf896a2f	40	state->sysreset_allowed[SYSRESET_COLD] = false;
11636258	41	ut_asserteq(-EACCES, sysreset_request(dev, SYSRESET_COLD));
bf896a2f	42	state->sysreset_allowed[SYSRESET_COLD] = true;
11636258 SW	43	state->sysreset_allowed[SYSRESET_POWER] = false;
	44	ut_asserteq(-EACCES, sysreset_request(dev, SYSRESET_POWER));
	45	state->sysreset_allowed[SYSRESET_POWER] = true;
	46
	47	return 0;
	48	}
e180c2b1	49	DM_TEST(dm_test_sysreset_base, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
11636258	50
cda4688c MS	51	static int dm_test_sysreset_get_status(struct unit_test_state *uts)
	52	{
	53	struct udevice *dev;
	54	char msg[64];
	55
	56	/* Device 1 is the warm sysreset device */
	57	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 1, &dev));
	58	ut_assertok(sysreset_get_status(dev, msg, sizeof(msg)));
	59	ut_asserteq_str("Reset Status: WARM", msg);
	60
	61	/* Device 2 is the cold sysreset device */
	62	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 2, &dev));
	63	ut_assertok(sysreset_get_status(dev, msg, sizeof(msg)));
	64	ut_asserteq_str("Reset Status: COLD", msg);
	65
	66	return 0;
	67	}
e180c2b1	68	DM_TEST(dm_test_sysreset_get_status, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
cda4688c	69
11636258 SW	70	/* Test that we can walk through the sysreset devices */
	71	static int dm_test_sysreset_walk(struct unit_test_state *uts)
	72	{
	73	struct sandbox_state *state = state_get_current();
	74
	75	/* If we generate a power sysreset, we will exit sandbox! */
bf896a2f HS	76	state->sysreset_allowed[SYSRESET_WARM] = false;
bf896a2f HS	77	state->sysreset_allowed[SYSRESET_COLD] = false;
11636258	78	state->sysreset_allowed[SYSRESET_POWER] = false;
751fed42	79	state->sysreset_allowed[SYSRESET_POWER_OFF] = false;
11636258 SW	80	ut_asserteq(-EACCES, sysreset_walk(SYSRESET_WARM));
	81	ut_asserteq(-EACCES, sysreset_walk(SYSRESET_COLD));
	82	ut_asserteq(-EACCES, sysreset_walk(SYSRESET_POWER));
bf896a2f	83	ut_asserteq(-EACCES, sysreset_walk(SYSRESET_POWER_OFF));
11636258 SW	84
	85	/*
	86	* Enable cold system reset - this should make cold system reset work,
	87	* plus a warm system reset should be promoted to cold, since this is
	88	* the next step along.
	89	*/
bf896a2f	90	state->sysreset_allowed[SYSRESET_WARM] = true;
11636258	91	ut_asserteq(-EINPROGRESS, sysreset_walk(SYSRESET_WARM));
bf896a2f	92	ut_asserteq(-EACCES, sysreset_walk(SYSRESET_COLD));
11636258	93	ut_asserteq(-EACCES, sysreset_walk(SYSRESET_POWER));
bf896a2f	94	state->sysreset_allowed[SYSRESET_COLD] = true;
11636258 SW	95	state->sysreset_allowed[SYSRESET_POWER] = true;
	96
	97	return 0;
	98	}
e180c2b1	99	DM_TEST(dm_test_sysreset_walk, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);
751fed42 SG	100
	101	static int dm_test_sysreset_get_last(struct unit_test_state *uts)
	102	{
	103	struct udevice *dev;
	104
	105	/* Device 1 is the warm sysreset device */
	106	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 1, &dev));
	107	ut_asserteq(SYSRESET_WARM, sysreset_get_last(dev));
	108
	109	/* Device 2 is the cold sysreset device */
	110	ut_assertok(uclass_get_device(UCLASS_SYSRESET, 2, &dev));
2a072690	111	ut_asserteq(SYSRESET_POWER, sysreset_get_last(dev));
751fed42 SG	112
751fed42 SG	113	/* This is device 0, the non-DT one */
2a072690	114	ut_asserteq(SYSRESET_POWER, sysreset_get_last_walk());
751fed42 SG	115
	116	return 0;
	117	}
e180c2b1	118	DM_TEST(dm_test_sysreset_get_last, UT_TESTF_SCAN_PDATA \| UT_TESTF_SCAN_FDT);