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

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright 2021 Google LLC
 */

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

static int dm_test_cros_ec_hello(struct unit_test_state *uts)
{
	struct udevice *dev;
	uint val;

	ut_assertok(uclass_first_device_err(UCLASS_CROS_EC, &dev));

	ut_assertok(cros_ec_hello(dev, NULL));

	val = 0xdead1357;
	ut_assertok(cros_ec_hello(dev, &val));
	ut_asserteq(0xdead1357, val);

	sandbox_cros_ec_set_test_flags(dev, CROSECT_BREAK_HELLO);
	ut_asserteq(-ENOTSYNC, cros_ec_hello(dev, &val));
	ut_asserteq(0x12345678, val);

	return 0;
}
DM_TEST(dm_test_cros_ec_hello, UT_TESTF_SCAN_FDT);

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

	ut_assertok(uclass_first_device_err(UCLASS_CROS_EC, &dev));
	ut_asserteq(1234, cros_ec_get_sku_id(dev));

	/* try the command */
	console_record_reset();
	ut_assertok(run_command("crosec sku", 0));
	ut_assert_nextline("1234");
	ut_assert_console_end();

	return 0;
}
DM_TEST(dm_test_cros_ec_sku_id, UT_TESTF_SCAN_FDT);

static int dm_test_cros_ec_features(struct unit_test_state *uts)
{
	struct udevice *dev;
	u64 feat;

	ut_assertok(uclass_first_device_err(UCLASS_CROS_EC, &dev));
	ut_assertok(cros_ec_get_features(dev, &feat));
	ut_asserteq_64(1U << EC_FEATURE_FLASH | 1U << EC_FEATURE_I2C |
		1u << EC_FEATURE_VSTORE |
		1ULL << EC_FEATURE_UNIFIED_WAKE_MASKS | 1ULL << EC_FEATURE_ISH,
		feat);

	ut_asserteq(true, cros_ec_check_feature(dev, EC_FEATURE_I2C));
	ut_asserteq(false, cros_ec_check_feature(dev, EC_FEATURE_MOTION_SENSE));
	ut_asserteq(true, cros_ec_check_feature(dev, EC_FEATURE_ISH));

	/* try the command */
	console_record_reset();
	ut_assertok(run_command("crosec features", 0));
	ut_assert_nextline("flash");
	ut_assert_nextline("i2c");
	ut_assert_nextline("vstore");
	ut_assert_nextline("unified_wake_masks");
	ut_assert_nextline("ish");
	ut_assert_console_end();

	return 0;
}
DM_TEST(dm_test_cros_ec_features, UT_TESTF_SCAN_FDT);

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

	ut_assertok(uclass_first_device_err(UCLASS_CROS_EC, &dev));
	ut_asserteq(0, cros_ec_get_switches(dev));

	/* try the command */
	console_record_reset();
	ut_assertok(run_command("crosec switches", 0));
	ut_assert_console_end();

	/* Open the lid and check the switch changes */
	sandbox_cros_ec_set_test_flags(dev, CROSECT_LID_OPEN);
	ut_asserteq(EC_SWITCH_LID_OPEN, cros_ec_get_switches(dev));

	/* try the command */
	console_record_reset();
	ut_assertok(run_command("crosec switches", 0));
	ut_assert_nextline("lid open");
	ut_assert_console_end();

	return 0;
}
DM_TEST(dm_test_cros_ec_switches, UT_TESTF_SCAN_FDT);

static int dm_test_cros_ec_events(struct unit_test_state *uts)
{
	struct udevice *dev;
	u32 events;

	ut_assertok(uclass_first_device_err(UCLASS_CROS_EC, &dev));
	ut_assertok(cros_ec_get_host_events(dev, &events));
	ut_asserteq(0, events);

	/* try the command */
	console_record_reset();
	ut_assertok(run_command("crosec events", 0));
	ut_assert_nextline("00000000");
	ut_assert_console_end();

	/* Open the lid and check the event appears */
	sandbox_cros_ec_set_test_flags(dev, CROSECT_LID_OPEN);
	ut_assertok(cros_ec_get_host_events(dev, &events));
	ut_asserteq(EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_OPEN), events);

	/* try the command */
	console_record_reset();
	ut_assertok(run_command("crosec events", 0));
	ut_assert_nextline("00000002");
	ut_assert_nextline("lid_open");
	ut_assert_console_end();

	/* Clear the event */
	ut_assertok(cros_ec_clear_host_events(dev,
		EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_OPEN)));
	ut_assertok(cros_ec_get_host_events(dev, &events));
	ut_asserteq(0, events);

	return 0;
}
DM_TEST(dm_test_cros_ec_events, UT_TESTF_SCAN_FDT);

static int dm_test_cros_ec_vstore(struct unit_test_state *uts)
{
	const int size = EC_VSTORE_SLOT_SIZE;
	u8 test_data[size], data[size];
	struct udevice *dev;
	u32 locked;
	int i;

	ut_assertok(uclass_first_device_err(UCLASS_CROS_EC, &dev));
	ut_asserteq(true, cros_ec_vstore_supported(dev));

	ut_asserteq(4, cros_ec_vstore_info(dev, &locked));
	ut_asserteq(0, locked);

	/* Write some data */
	for (i = 0; i < size; i++)
		test_data[i] = ' ' + i;
	ut_assertok(cros_ec_vstore_write(dev, 2, test_data, size));

	/* Check it is locked */
	ut_asserteq(4, cros_ec_vstore_info(dev, &locked));
	ut_asserteq(1 << 2, locked);

	/* Read it back and compare */
	ut_assertok(cros_ec_vstore_read(dev, 2, data));
	ut_asserteq_mem(test_data, data, size);

	/* Try another slot to make sure it is empty */
	ut_assertok(cros_ec_vstore_read(dev, 0, data));
	for (i = 0; i < size; i++)
		ut_asserteq(0, data[i]);

	return 0;
}
DM_TEST(dm_test_cros_ec_vstore, UT_TESTF_SCAN_FDT);
Commit	Line	Data
d8e9a938 SG	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* Copyright 2021 Google LLC
	4	*/
	5
d678a59d	6	#include <common.h>
d8e9a938 SG	7	#include <cros_ec.h>
	8	#include <dm.h>
	9	#include <asm/test.h>
	10	#include <dm/test.h>
	11	#include <test/ut.h>
	12
	13	static int dm_test_cros_ec_hello(struct unit_test_state *uts)
	14	{
	15	struct udevice *dev;
	16	uint val;
	17
	18	ut_assertok(uclass_first_device_err(UCLASS_CROS_EC, &dev));
	19
	20	ut_assertok(cros_ec_hello(dev, NULL));
	21
	22	val = 0xdead1357;
	23	ut_assertok(cros_ec_hello(dev, &val));
	24	ut_asserteq(0xdead1357, val);
	25
	26	sandbox_cros_ec_set_test_flags(dev, CROSECT_BREAK_HELLO);
	27	ut_asserteq(-ENOTSYNC, cros_ec_hello(dev, &val));
	28	ut_asserteq(0x12345678, val);
	29
	30	return 0;
	31	}
	32	DM_TEST(dm_test_cros_ec_hello, UT_TESTF_SCAN_FDT);
7791df57 SG	33
	34	static int dm_test_cros_ec_sku_id(struct unit_test_state *uts)
	35	{
	36	struct udevice *dev;
	37
	38	ut_assertok(uclass_first_device_err(UCLASS_CROS_EC, &dev));
	39	ut_asserteq(1234, cros_ec_get_sku_id(dev));
	40
	41	/* try the command */
	42	console_record_reset();
	43	ut_assertok(run_command("crosec sku", 0));
	44	ut_assert_nextline("1234");
	45	ut_assert_console_end();
	46
	47	return 0;
	48	}
	49	DM_TEST(dm_test_cros_ec_sku_id, UT_TESTF_SCAN_FDT);
8aec32f6 SG	50
	51	static int dm_test_cros_ec_features(struct unit_test_state *uts)
	52	{
	53	struct udevice *dev;
	54	u64 feat;
	55
	56	ut_assertok(uclass_first_device_err(UCLASS_CROS_EC, &dev));
	57	ut_assertok(cros_ec_get_features(dev, &feat));
	58	ut_asserteq_64(1U << EC_FEATURE_FLASH \| 1U << EC_FEATURE_I2C \|
10f74659	59	1u << EC_FEATURE_VSTORE \|
8aec32f6 SG	60	1ULL << EC_FEATURE_UNIFIED_WAKE_MASKS \| 1ULL << EC_FEATURE_ISH,
	61	feat);
	62
	63	ut_asserteq(true, cros_ec_check_feature(dev, EC_FEATURE_I2C));
	64	ut_asserteq(false, cros_ec_check_feature(dev, EC_FEATURE_MOTION_SENSE));
	65	ut_asserteq(true, cros_ec_check_feature(dev, EC_FEATURE_ISH));
	66
	67	/* try the command */
	68	console_record_reset();
	69	ut_assertok(run_command("crosec features", 0));
	70	ut_assert_nextline("flash");
	71	ut_assert_nextline("i2c");
10f74659	72	ut_assert_nextline("vstore");
8aec32f6 SG	73	ut_assert_nextline("unified_wake_masks");
	74	ut_assert_nextline("ish");
	75	ut_assert_console_end();
	76
	77	return 0;
	78	}
	79	DM_TEST(dm_test_cros_ec_features, UT_TESTF_SCAN_FDT);
3a6c994f SG	80
	81	static int dm_test_cros_ec_switches(struct unit_test_state *uts)
	82	{
	83	struct udevice *dev;
	84
	85	ut_assertok(uclass_first_device_err(UCLASS_CROS_EC, &dev));
	86	ut_asserteq(0, cros_ec_get_switches(dev));
	87
	88	/* try the command */
	89	console_record_reset();
	90	ut_assertok(run_command("crosec switches", 0));
	91	ut_assert_console_end();
	92
	93	/* Open the lid and check the switch changes */
	94	sandbox_cros_ec_set_test_flags(dev, CROSECT_LID_OPEN);
	95	ut_asserteq(EC_SWITCH_LID_OPEN, cros_ec_get_switches(dev));
	96
	97	/* try the command */
	98	console_record_reset();
	99	ut_assertok(run_command("crosec switches", 0));
	100	ut_assert_nextline("lid open");
	101	ut_assert_console_end();
	102
	103	return 0;
	104	}
	105	DM_TEST(dm_test_cros_ec_switches, UT_TESTF_SCAN_FDT);
3ae33829 SG	106
	107	static int dm_test_cros_ec_events(struct unit_test_state *uts)
	108	{
	109	struct udevice *dev;
	110	u32 events;
	111
	112	ut_assertok(uclass_first_device_err(UCLASS_CROS_EC, &dev));
	113	ut_assertok(cros_ec_get_host_events(dev, &events));
	114	ut_asserteq(0, events);
	115
	116	/* try the command */
	117	console_record_reset();
	118	ut_assertok(run_command("crosec events", 0));
	119	ut_assert_nextline("00000000");
	120	ut_assert_console_end();
	121
	122	/* Open the lid and check the event appears */
	123	sandbox_cros_ec_set_test_flags(dev, CROSECT_LID_OPEN);
	124	ut_assertok(cros_ec_get_host_events(dev, &events));
	125	ut_asserteq(EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_OPEN), events);
	126
	127	/* try the command */
	128	console_record_reset();
	129	ut_assertok(run_command("crosec events", 0));
	130	ut_assert_nextline("00000002");
	131	ut_assert_nextline("lid_open");
	132	ut_assert_console_end();
	133
	134	/* Clear the event */
	135	ut_assertok(cros_ec_clear_host_events(dev,
	136	EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_OPEN)));
	137	ut_assertok(cros_ec_get_host_events(dev, &events));
	138	ut_asserteq(0, events);
	139
	140	return 0;
	141	}
	142	DM_TEST(dm_test_cros_ec_events, UT_TESTF_SCAN_FDT);
10f74659 SG	143
	144	static int dm_test_cros_ec_vstore(struct unit_test_state *uts)
	145	{
	146	const int size = EC_VSTORE_SLOT_SIZE;
	147	u8 test_data[size], data[size];
	148	struct udevice *dev;
	149	u32 locked;
	150	int i;
	151
	152	ut_assertok(uclass_first_device_err(UCLASS_CROS_EC, &dev));
	153	ut_asserteq(true, cros_ec_vstore_supported(dev));
	154
	155	ut_asserteq(4, cros_ec_vstore_info(dev, &locked));
	156	ut_asserteq(0, locked);
	157
	158	/* Write some data */
	159	for (i = 0; i < size; i++)
	160	test_data[i] = ' ' + i;
	161	ut_assertok(cros_ec_vstore_write(dev, 2, test_data, size));
	162
	163	/* Check it is locked */
	164	ut_asserteq(4, cros_ec_vstore_info(dev, &locked));
	165	ut_asserteq(1 << 2, locked);
	166
	167	/* Read it back and compare */
	168	ut_assertok(cros_ec_vstore_read(dev, 2, data));
	169	ut_asserteq_mem(test_data, data, size);
	170
	171	/* Try another slot to make sure it is empty */
	172	ut_assertok(cros_ec_vstore_read(dev, 0, data));
	173	for (i = 0; i < size; i++)
	174	ut_asserteq(0, data[i]);
	175
	176	return 0;
	177	}
	178	DM_TEST(dm_test_cros_ec_vstore, UT_TESTF_SCAN_FDT);