1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Kunit tests for ChromeOS Embedded Controller protocol.
   4 */
   5
   6#include <kunit/test.h>
   7
   8#include <asm-generic/unaligned.h>
 
   9#include <linux/platform_data/cros_ec_commands.h>
  10#include <linux/platform_data/cros_ec_proto.h>
  11
  12#include "cros_ec.h"
  13#include "cros_kunit_util.h"
  14
  15#define BUFSIZE 512
  16
  17struct cros_ec_proto_test_priv {
  18	struct cros_ec_device ec_dev;
  19	u8 dout[BUFSIZE];
  20	u8 din[BUFSIZE];
  21	struct cros_ec_command *msg;
  22	u8 _msg[BUFSIZE];
  23};
  24
  25static void cros_ec_proto_test_prepare_tx_legacy_normal(struct kunit *test)
  26{
  27	struct cros_ec_proto_test_priv *priv = test->priv;
  28	struct cros_ec_device *ec_dev = &priv->ec_dev;
  29	struct cros_ec_command *msg = priv->msg;
  30	int ret, i;
  31	u8 csum;
  32
  33	ec_dev->proto_version = 2;
  34
  35	msg->command = EC_CMD_HELLO;
  36	msg->outsize = EC_PROTO2_MAX_PARAM_SIZE;
  37	msg->data[0] = 0xde;
  38	msg->data[1] = 0xad;
  39	msg->data[2] = 0xbe;
  40	msg->data[3] = 0xef;
  41
  42	ret = cros_ec_prepare_tx(ec_dev, msg);
  43
  44	KUNIT_EXPECT_EQ(test, ret, EC_MSG_TX_PROTO_BYTES + EC_PROTO2_MAX_PARAM_SIZE);
  45	KUNIT_EXPECT_EQ(test, ec_dev->dout[0], EC_CMD_VERSION0);
  46	KUNIT_EXPECT_EQ(test, ec_dev->dout[1], EC_CMD_HELLO);
  47	KUNIT_EXPECT_EQ(test, ec_dev->dout[2], EC_PROTO2_MAX_PARAM_SIZE);
  48	KUNIT_EXPECT_EQ(test, EC_MSG_TX_HEADER_BYTES, 3);
  49	KUNIT_EXPECT_EQ(test, ec_dev->dout[EC_MSG_TX_HEADER_BYTES + 0], 0xde);
  50	KUNIT_EXPECT_EQ(test, ec_dev->dout[EC_MSG_TX_HEADER_BYTES + 1], 0xad);
  51	KUNIT_EXPECT_EQ(test, ec_dev->dout[EC_MSG_TX_HEADER_BYTES + 2], 0xbe);
  52	KUNIT_EXPECT_EQ(test, ec_dev->dout[EC_MSG_TX_HEADER_BYTES + 3], 0xef);
  53	for (i = 4; i < EC_PROTO2_MAX_PARAM_SIZE; ++i)
  54		KUNIT_EXPECT_EQ(test, ec_dev->dout[EC_MSG_TX_HEADER_BYTES + i], 0);
  55
  56	csum = EC_CMD_VERSION0;
  57	csum += EC_CMD_HELLO;
  58	csum += EC_PROTO2_MAX_PARAM_SIZE;
  59	csum += 0xde;
  60	csum += 0xad;
  61	csum += 0xbe;
  62	csum += 0xef;
  63	KUNIT_EXPECT_EQ(test,
  64			ec_dev->dout[EC_MSG_TX_HEADER_BYTES + EC_PROTO2_MAX_PARAM_SIZE],
  65			csum);
  66}
  67
  68static void cros_ec_proto_test_prepare_tx_legacy_bad_msg_outsize(struct kunit *test)
  69{
  70	struct cros_ec_proto_test_priv *priv = test->priv;
  71	struct cros_ec_device *ec_dev = &priv->ec_dev;
  72	struct cros_ec_command *msg = priv->msg;
  73	int ret;
  74
  75	ec_dev->proto_version = 2;
  76
  77	msg->outsize = EC_PROTO2_MAX_PARAM_SIZE + 1;
  78
  79	ret = cros_ec_prepare_tx(ec_dev, msg);
  80	KUNIT_EXPECT_EQ(test, ret, -EINVAL);
  81}
  82
  83static void cros_ec_proto_test_prepare_tx_normal(struct kunit *test)
  84{
  85	struct cros_ec_proto_test_priv *priv = test->priv;
  86	struct cros_ec_device *ec_dev = &priv->ec_dev;
  87	struct cros_ec_command *msg = priv->msg;
  88	struct ec_host_request *request = (struct ec_host_request *)ec_dev->dout;
  89	int ret, i;
  90	u8 csum;
  91
  92	msg->command = EC_CMD_HELLO;
  93	msg->outsize = 0x88;
  94	msg->data[0] = 0xde;
  95	msg->data[1] = 0xad;
  96	msg->data[2] = 0xbe;
  97	msg->data[3] = 0xef;
  98
  99	ret = cros_ec_prepare_tx(ec_dev, msg);
 100
 101	KUNIT_EXPECT_EQ(test, ret, sizeof(*request) + 0x88);
 102
 103	KUNIT_EXPECT_EQ(test, request->struct_version, EC_HOST_REQUEST_VERSION);
 104	KUNIT_EXPECT_EQ(test, request->command, EC_CMD_HELLO);
 105	KUNIT_EXPECT_EQ(test, request->command_version, 0);
 106	KUNIT_EXPECT_EQ(test, request->data_len, 0x88);
 107	KUNIT_EXPECT_EQ(test, ec_dev->dout[sizeof(*request) + 0], 0xde);
 108	KUNIT_EXPECT_EQ(test, ec_dev->dout[sizeof(*request) + 1], 0xad);
 109	KUNIT_EXPECT_EQ(test, ec_dev->dout[sizeof(*request) + 2], 0xbe);
 110	KUNIT_EXPECT_EQ(test, ec_dev->dout[sizeof(*request) + 3], 0xef);
 111	for (i = 4; i < 0x88; ++i)
 112		KUNIT_EXPECT_EQ(test, ec_dev->dout[sizeof(*request) + i], 0);
 113
 114	csum = EC_HOST_REQUEST_VERSION;
 115	csum += EC_CMD_HELLO;
 116	csum += 0x88;
 117	csum += 0xde;
 118	csum += 0xad;
 119	csum += 0xbe;
 120	csum += 0xef;
 121	KUNIT_EXPECT_EQ(test, request->checksum, (u8)-csum);
 122}
 123
 124static void cros_ec_proto_test_prepare_tx_bad_msg_outsize(struct kunit *test)
 125{
 126	struct cros_ec_proto_test_priv *priv = test->priv;
 127	struct cros_ec_device *ec_dev = &priv->ec_dev;
 128	struct cros_ec_command *msg = priv->msg;
 129	int ret;
 130
 131	msg->outsize = ec_dev->dout_size - sizeof(struct ec_host_request) + 1;
 132
 133	ret = cros_ec_prepare_tx(ec_dev, msg);
 134	KUNIT_EXPECT_EQ(test, ret, -EINVAL);
 135}
 136
 137static void cros_ec_proto_test_check_result(struct kunit *test)
 138{
 139	struct cros_ec_proto_test_priv *priv = test->priv;
 140	struct cros_ec_device *ec_dev = &priv->ec_dev;
 141	struct cros_ec_command *msg = priv->msg;
 142	int ret, i;
 143	static enum ec_status status[] = {
 144		EC_RES_SUCCESS,
 145		EC_RES_INVALID_COMMAND,
 146		EC_RES_ERROR,
 147		EC_RES_INVALID_PARAM,
 148		EC_RES_ACCESS_DENIED,
 149		EC_RES_INVALID_RESPONSE,
 150		EC_RES_INVALID_VERSION,
 151		EC_RES_INVALID_CHECKSUM,
 152		EC_RES_UNAVAILABLE,
 153		EC_RES_TIMEOUT,
 154		EC_RES_OVERFLOW,
 155		EC_RES_INVALID_HEADER,
 156		EC_RES_REQUEST_TRUNCATED,
 157		EC_RES_RESPONSE_TOO_BIG,
 158		EC_RES_BUS_ERROR,
 159		EC_RES_BUSY,
 160		EC_RES_INVALID_HEADER_VERSION,
 161		EC_RES_INVALID_HEADER_CRC,
 162		EC_RES_INVALID_DATA_CRC,
 163		EC_RES_DUP_UNAVAILABLE,
 164	};
 165
 166	for (i = 0; i < ARRAY_SIZE(status); ++i) {
 167		msg->result = status[i];
 168		ret = cros_ec_check_result(ec_dev, msg);
 169		KUNIT_EXPECT_EQ(test, ret, 0);
 170	}
 171
 172	msg->result = EC_RES_IN_PROGRESS;
 173	ret = cros_ec_check_result(ec_dev, msg);
 174	KUNIT_EXPECT_EQ(test, ret, -EAGAIN);
 175}
 176
 177static void cros_ec_proto_test_query_all_pretest(struct kunit *test)
 178{
 179	struct cros_ec_proto_test_priv *priv = test->priv;
 180	struct cros_ec_device *ec_dev = &priv->ec_dev;
 181
 182	/*
 183	 * cros_ec_query_all() will free din and dout and allocate them again to fit the usage by
 184	 * calling devm_kfree() and devm_kzalloc().  Set them to NULL as they aren't managed by
 185	 * ec_dev->dev but allocated statically in struct cros_ec_proto_test_priv
 186	 * (see cros_ec_proto_test_init()).
 187	 */
 188	ec_dev->din = NULL;
 189	ec_dev->dout = NULL;
 190}
 191
 192static void cros_ec_proto_test_query_all_normal(struct kunit *test)
 193{
 194	struct cros_ec_proto_test_priv *priv = test->priv;
 195	struct cros_ec_device *ec_dev = &priv->ec_dev;
 196	struct ec_xfer_mock *mock;
 197	int ret;
 198
 199	/* For cros_ec_get_proto_info() without passthru. */
 200	{
 201		struct ec_response_get_protocol_info *data;
 202
 203		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 204		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 205
 206		data = (struct ec_response_get_protocol_info *)mock->o_data;
 207		data->protocol_versions = BIT(3) | BIT(2);
 208		data->max_request_packet_size = 0xbe;
 209		data->max_response_packet_size = 0xef;
 210	}
 211
 212	/* For cros_ec_get_proto_info() with passthru. */
 213	{
 214		struct ec_response_get_protocol_info *data;
 215
 216		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 217		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 218
 219		data = (struct ec_response_get_protocol_info *)mock->o_data;
 220		data->max_request_packet_size = 0xbf;
 221	}
 222
 223	/* For cros_ec_get_host_command_version_mask() for MKBP. */
 224	{
 225		struct ec_response_get_cmd_versions *data;
 226
 227		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 228		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 229
 230		data = (struct ec_response_get_cmd_versions *)mock->o_data;
 231		data->version_mask = BIT(6) | BIT(5);
 232	}
 233
 234	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
 235	{
 236		struct ec_response_get_cmd_versions *data;
 237
 238		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 239		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 240
 241		data = (struct ec_response_get_cmd_versions *)mock->o_data;
 242		data->version_mask = BIT(1);
 243	}
 244
 245	/* For cros_ec_get_host_event_wake_mask(). */
 246	{
 247		struct ec_response_host_event_mask *data;
 248
 249		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 250		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 251
 252		data = (struct ec_response_host_event_mask *)mock->o_data;
 253		data->mask = 0xbeef;
 254	}
 255
 256	cros_ec_proto_test_query_all_pretest(test);
 257	ret = cros_ec_query_all(ec_dev);
 258	KUNIT_EXPECT_EQ(test, ret, 0);
 259
 260	/* For cros_ec_get_proto_info() without passthru. */
 261	{
 262		mock = cros_kunit_ec_xfer_mock_next();
 263		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 264
 265		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 266		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
 267		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 268				sizeof(struct ec_response_get_protocol_info));
 269		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 270
 271		KUNIT_EXPECT_EQ(test, ec_dev->max_request, 0xbe - sizeof(struct ec_host_request));
 272		KUNIT_EXPECT_EQ(test, ec_dev->max_response, 0xef - sizeof(struct ec_host_response));
 273		KUNIT_EXPECT_EQ(test, ec_dev->proto_version, 3);
 274		KUNIT_EXPECT_EQ(test, ec_dev->din_size, 0xef + EC_MAX_RESPONSE_OVERHEAD);
 275		KUNIT_EXPECT_EQ(test, ec_dev->dout_size, 0xbe + EC_MAX_REQUEST_OVERHEAD);
 276	}
 277
 278	/* For cros_ec_get_proto_info() with passthru. */
 279	{
 280		mock = cros_kunit_ec_xfer_mock_next();
 281		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 282
 283		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 284		KUNIT_EXPECT_EQ(test, mock->msg.command,
 285				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
 286				EC_CMD_GET_PROTOCOL_INFO);
 287		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 288				sizeof(struct ec_response_get_protocol_info));
 289		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 290
 291		KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0xbf - sizeof(struct ec_host_request));
 292	}
 293
 294	/* For cros_ec_get_host_command_version_mask() for MKBP. */
 295	{
 296		struct ec_params_get_cmd_versions *data;
 297
 298		mock = cros_kunit_ec_xfer_mock_next();
 299		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 300
 301		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 302		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
 303		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 304				sizeof(struct ec_response_get_cmd_versions));
 305		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
 306
 307		data = (struct ec_params_get_cmd_versions *)mock->i_data;
 308		KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT);
 309
 310		KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 7);
 311	}
 312
 313	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
 314	{
 315		struct ec_params_get_cmd_versions *data;
 316
 317		mock = cros_kunit_ec_xfer_mock_next();
 318		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 319
 320		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 321		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
 322		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 323				sizeof(struct ec_response_get_cmd_versions));
 324		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
 325
 326		data = (struct ec_params_get_cmd_versions *)mock->i_data;
 327		KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_HOST_SLEEP_EVENT);
 328
 329		KUNIT_EXPECT_TRUE(test, ec_dev->host_sleep_v1);
 330	}
 331
 332	/* For cros_ec_get_host_event_wake_mask(). */
 333	{
 334		mock = cros_kunit_ec_xfer_mock_next();
 335		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 336
 337		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 338		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HOST_EVENT_GET_WAKE_MASK);
 339		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_host_event_mask));
 340		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 341
 342		KUNIT_EXPECT_EQ(test, ec_dev->host_event_wake_mask, 0xbeef);
 343	}
 344}
 345
 346static void cros_ec_proto_test_query_all_no_pd_return_error(struct kunit *test)
 347{
 348	struct cros_ec_proto_test_priv *priv = test->priv;
 349	struct cros_ec_device *ec_dev = &priv->ec_dev;
 350	struct ec_xfer_mock *mock;
 351	int ret;
 352
 353	/* Set some garbage bytes. */
 354	ec_dev->max_passthru = 0xbf;
 355
 356	/* For cros_ec_get_proto_info() without passthru. */
 357	{
 358		struct ec_response_get_protocol_info *data;
 359
 360		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 361		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 362
 363		/*
 364		 * Although it doesn't check the value, provides valid sizes so that
 365		 * cros_ec_query_all() allocates din and dout correctly.
 366		 */
 367		data = (struct ec_response_get_protocol_info *)mock->o_data;
 368		data->max_request_packet_size = 0xbe;
 369		data->max_response_packet_size = 0xef;
 370	}
 371
 372	/* For cros_ec_get_proto_info() with passthru. */
 373	{
 374		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
 375		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 376	}
 377
 378	cros_ec_proto_test_query_all_pretest(test);
 379	ret = cros_ec_query_all(ec_dev);
 380	KUNIT_EXPECT_EQ(test, ret, 0);
 381
 382	/* For cros_ec_get_proto_info() without passthru. */
 383	{
 384		mock = cros_kunit_ec_xfer_mock_next();
 385		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 386
 387		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 388		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
 389		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 390				sizeof(struct ec_response_get_protocol_info));
 391		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 392	}
 393
 394	/* For cros_ec_get_proto_info() with passthru. */
 395	{
 396		mock = cros_kunit_ec_xfer_mock_next();
 397		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 398
 399		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 400		KUNIT_EXPECT_EQ(test, mock->msg.command,
 401				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
 402				EC_CMD_GET_PROTOCOL_INFO);
 403		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 404				sizeof(struct ec_response_get_protocol_info));
 405		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 406
 407		KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0);
 408	}
 409}
 410
 411static void cros_ec_proto_test_query_all_no_pd_return0(struct kunit *test)
 412{
 413	struct cros_ec_proto_test_priv *priv = test->priv;
 414	struct cros_ec_device *ec_dev = &priv->ec_dev;
 415	struct ec_xfer_mock *mock;
 416	int ret;
 417
 418	/* Set some garbage bytes. */
 419	ec_dev->max_passthru = 0xbf;
 420
 421	/* For cros_ec_get_proto_info() without passthru. */
 422	{
 423		struct ec_response_get_protocol_info *data;
 424
 425		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 426		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 427
 428		/*
 429		 * Although it doesn't check the value, provides valid sizes so that
 430		 * cros_ec_query_all() allocates din and dout correctly.
 431		 */
 432		data = (struct ec_response_get_protocol_info *)mock->o_data;
 433		data->max_request_packet_size = 0xbe;
 434		data->max_response_packet_size = 0xef;
 435	}
 436
 437	/* For cros_ec_get_proto_info() with passthru. */
 438	{
 439		mock = cros_kunit_ec_xfer_mock_add(test, 0);
 440		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 441	}
 442
 443	cros_ec_proto_test_query_all_pretest(test);
 444	ret = cros_ec_query_all(ec_dev);
 445	KUNIT_EXPECT_EQ(test, ret, 0);
 446
 447	/* For cros_ec_get_proto_info() without passthru. */
 448	{
 449		mock = cros_kunit_ec_xfer_mock_next();
 450		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 451
 452		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 453		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
 454		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 455				sizeof(struct ec_response_get_protocol_info));
 456		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 457	}
 458
 459	/* For cros_ec_get_proto_info() with passthru. */
 460	{
 461		mock = cros_kunit_ec_xfer_mock_next();
 462		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 463
 464		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 465		KUNIT_EXPECT_EQ(test, mock->msg.command,
 466				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
 467				EC_CMD_GET_PROTOCOL_INFO);
 468		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 469				sizeof(struct ec_response_get_protocol_info));
 470		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 471
 472		KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0);
 473	}
 474}
 475
 476static void cros_ec_proto_test_query_all_legacy_normal_v3_return_error(struct kunit *test)
 477{
 478	struct cros_ec_proto_test_priv *priv = test->priv;
 479	struct cros_ec_device *ec_dev = &priv->ec_dev;
 480	struct ec_xfer_mock *mock;
 481	int ret;
 482
 483	/* For cros_ec_get_proto_info() without passthru. */
 484	{
 485		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
 486		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 487	}
 488
 489	/* For cros_ec_get_proto_info_legacy(). */
 490	{
 491		struct ec_response_hello *data;
 492
 493		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 494		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 495
 496		data = (struct ec_response_hello *)mock->o_data;
 497		data->out_data = 0xa1b2c3d4;
 498	}
 499
 500	cros_ec_proto_test_query_all_pretest(test);
 501	ret = cros_ec_query_all(ec_dev);
 502	KUNIT_EXPECT_EQ(test, ret, 0);
 503
 504	/* For cros_ec_get_proto_info() without passthru. */
 505	{
 506		mock = cros_kunit_ec_xfer_mock_next();
 507		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 508
 509		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 510		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
 511		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 512				sizeof(struct ec_response_get_protocol_info));
 513		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 514	}
 515
 516	/* For cros_ec_get_proto_info_legacy(). */
 517	{
 518		struct ec_params_hello *data;
 519
 520		mock = cros_kunit_ec_xfer_mock_next();
 521		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 522
 523		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 524		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
 525		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
 526		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
 527
 528		data = (struct ec_params_hello *)mock->i_data;
 529		KUNIT_EXPECT_EQ(test, data->in_data, 0xa0b0c0d0);
 530
 531		KUNIT_EXPECT_EQ(test, ec_dev->proto_version, 2);
 532		KUNIT_EXPECT_EQ(test, ec_dev->max_request, EC_PROTO2_MAX_PARAM_SIZE);
 533		KUNIT_EXPECT_EQ(test, ec_dev->max_response, EC_PROTO2_MAX_PARAM_SIZE);
 534		KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0);
 535		KUNIT_EXPECT_PTR_EQ(test, ec_dev->pkt_xfer, NULL);
 536		KUNIT_EXPECT_EQ(test, ec_dev->din_size, EC_PROTO2_MSG_BYTES);
 537		KUNIT_EXPECT_EQ(test, ec_dev->dout_size, EC_PROTO2_MSG_BYTES);
 538	}
 539}
 540
 541static void cros_ec_proto_test_query_all_legacy_normal_v3_return0(struct kunit *test)
 542{
 543	struct cros_ec_proto_test_priv *priv = test->priv;
 544	struct cros_ec_device *ec_dev = &priv->ec_dev;
 545	struct ec_xfer_mock *mock;
 546	int ret;
 547
 548	/* For cros_ec_get_proto_info() without passthru. */
 549	{
 550		mock = cros_kunit_ec_xfer_mock_add(test, 0);
 551		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 552	}
 553
 554	/* For cros_ec_get_proto_info_legacy(). */
 555	{
 556		struct ec_response_hello *data;
 557
 558		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 559		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 560
 561		data = (struct ec_response_hello *)mock->o_data;
 562		data->out_data = 0xa1b2c3d4;
 563	}
 564
 565	cros_ec_proto_test_query_all_pretest(test);
 566	ret = cros_ec_query_all(ec_dev);
 567	KUNIT_EXPECT_EQ(test, ret, 0);
 568
 569	/* For cros_ec_get_proto_info() without passthru. */
 570	{
 571		mock = cros_kunit_ec_xfer_mock_next();
 572		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 573
 574		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 575		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
 576		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 577				sizeof(struct ec_response_get_protocol_info));
 578		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 579	}
 580
 581	/* For cros_ec_get_proto_info_legacy(). */
 582	{
 583		struct ec_params_hello *data;
 584
 585		mock = cros_kunit_ec_xfer_mock_next();
 586		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 587
 588		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 589		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
 590		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
 591		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
 592
 593		data = (struct ec_params_hello *)mock->i_data;
 594		KUNIT_EXPECT_EQ(test, data->in_data, 0xa0b0c0d0);
 595
 596		KUNIT_EXPECT_EQ(test, ec_dev->proto_version, 2);
 597		KUNIT_EXPECT_EQ(test, ec_dev->max_request, EC_PROTO2_MAX_PARAM_SIZE);
 598		KUNIT_EXPECT_EQ(test, ec_dev->max_response, EC_PROTO2_MAX_PARAM_SIZE);
 599		KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0);
 600		KUNIT_EXPECT_PTR_EQ(test, ec_dev->pkt_xfer, NULL);
 601		KUNIT_EXPECT_EQ(test, ec_dev->din_size, EC_PROTO2_MSG_BYTES);
 602		KUNIT_EXPECT_EQ(test, ec_dev->dout_size, EC_PROTO2_MSG_BYTES);
 603	}
 604}
 605
 606static void cros_ec_proto_test_query_all_legacy_xfer_error(struct kunit *test)
 607{
 608	struct cros_ec_proto_test_priv *priv = test->priv;
 609	struct cros_ec_device *ec_dev = &priv->ec_dev;
 610	struct ec_xfer_mock *mock;
 611	int ret;
 612
 613	/* For cros_ec_get_proto_info() without passthru. */
 614	{
 615		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
 616		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 617	}
 618
 619	/* For cros_ec_get_proto_info_legacy(). */
 620	{
 621		mock = cros_kunit_ec_xfer_mock_addx(test, -EIO, EC_RES_SUCCESS, 0);
 622		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 623	}
 624
 625	cros_ec_proto_test_query_all_pretest(test);
 626	ret = cros_ec_query_all(ec_dev);
 627	KUNIT_EXPECT_EQ(test, ret, -EIO);
 628	KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
 629
 630	/* For cros_ec_get_proto_info() without passthru. */
 631	{
 632		mock = cros_kunit_ec_xfer_mock_next();
 633		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 634
 635		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 636		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
 637		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 638				sizeof(struct ec_response_get_protocol_info));
 639		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 640	}
 641
 642	/* For cros_ec_get_proto_info_legacy(). */
 643	{
 644		mock = cros_kunit_ec_xfer_mock_next();
 645		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 646
 647		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 648		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
 649		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
 650		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello));
 651	}
 652}
 653
 654static void cros_ec_proto_test_query_all_legacy_return_error(struct kunit *test)
 655{
 656	struct cros_ec_proto_test_priv *priv = test->priv;
 657	struct cros_ec_device *ec_dev = &priv->ec_dev;
 658	struct ec_xfer_mock *mock;
 659	int ret;
 660
 661	/* For cros_ec_get_proto_info() without passthru. */
 662	{
 663		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
 664		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 665	}
 666
 667	/* For cros_ec_get_proto_info_legacy(). */
 668	{
 669		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
 670		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 671	}
 672
 673	cros_ec_proto_test_query_all_pretest(test);
 674	ret = cros_ec_query_all(ec_dev);
 675	KUNIT_EXPECT_EQ(test, ret, -EOPNOTSUPP);
 676	KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
 677
 678	/* For cros_ec_get_proto_info() without passthru. */
 679	{
 680		mock = cros_kunit_ec_xfer_mock_next();
 681		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 682
 683		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 684		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
 685		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 686				sizeof(struct ec_response_get_protocol_info));
 687		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 688	}
 689
 690	/* For cros_ec_get_proto_info_legacy(). */
 691	{
 692		mock = cros_kunit_ec_xfer_mock_next();
 693		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 694
 695		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 696		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
 697		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
 698		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello));
 699	}
 700}
 701
 702static void cros_ec_proto_test_query_all_legacy_data_error(struct kunit *test)
 703{
 704	struct cros_ec_proto_test_priv *priv = test->priv;
 705	struct cros_ec_device *ec_dev = &priv->ec_dev;
 706	struct ec_xfer_mock *mock;
 707	int ret;
 708
 709	/* For cros_ec_get_proto_info() without passthru. */
 710	{
 711		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
 712		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 713	}
 714
 715	/* For cros_ec_get_proto_info_legacy(). */
 716	{
 717		struct ec_response_hello *data;
 718
 719		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 720		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 721
 722		data = (struct ec_response_hello *)mock->o_data;
 723		data->out_data = 0xbeefbfbf;
 724	}
 725
 726	cros_ec_proto_test_query_all_pretest(test);
 727	ret = cros_ec_query_all(ec_dev);
 728	KUNIT_EXPECT_EQ(test, ret, -EBADMSG);
 729	KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
 730
 731	/* For cros_ec_get_proto_info() without passthru. */
 732	{
 733		mock = cros_kunit_ec_xfer_mock_next();
 734		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 735
 736		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 737		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
 738		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 739				sizeof(struct ec_response_get_protocol_info));
 740		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 741	}
 742
 743	/* For cros_ec_get_proto_info_legacy(). */
 744	{
 745		mock = cros_kunit_ec_xfer_mock_next();
 746		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 747
 748		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 749		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
 750		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
 751		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello));
 752	}
 753}
 754
 755static void cros_ec_proto_test_query_all_legacy_return0(struct kunit *test)
 756{
 757	struct cros_ec_proto_test_priv *priv = test->priv;
 758	struct cros_ec_device *ec_dev = &priv->ec_dev;
 759	struct ec_xfer_mock *mock;
 760	int ret;
 761
 762	/* For cros_ec_get_proto_info() without passthru. */
 763	{
 764		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
 765		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 766	}
 767
 768	/* For cros_ec_get_proto_info_legacy(). */
 769	{
 770		mock = cros_kunit_ec_xfer_mock_add(test, 0);
 771		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 772	}
 773
 774	cros_ec_proto_test_query_all_pretest(test);
 775	ret = cros_ec_query_all(ec_dev);
 776	KUNIT_EXPECT_EQ(test, ret, -EPROTO);
 777	KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
 778
 779	/* For cros_ec_get_proto_info() without passthru. */
 780	{
 781		mock = cros_kunit_ec_xfer_mock_next();
 782		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 783
 784		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 785		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
 786		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 787				sizeof(struct ec_response_get_protocol_info));
 788		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 789	}
 790
 791	/* For cros_ec_get_proto_info_legacy(). */
 792	{
 793		mock = cros_kunit_ec_xfer_mock_next();
 794		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 795
 796		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 797		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
 798		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
 799		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello));
 800	}
 801}
 802
 803static void cros_ec_proto_test_query_all_no_mkbp(struct kunit *test)
 804{
 805	struct cros_ec_proto_test_priv *priv = test->priv;
 806	struct cros_ec_device *ec_dev = &priv->ec_dev;
 807	struct ec_xfer_mock *mock;
 808	int ret;
 809
 810	/* Set some garbage bytes. */
 811	ec_dev->mkbp_event_supported = 0xbf;
 812
 813	/* For cros_ec_get_proto_info() without passthru. */
 814	{
 815		struct ec_response_get_protocol_info *data;
 816
 817		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 818		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 819
 820		/*
 821		 * Although it doesn't check the value, provides valid sizes so that
 822		 * cros_ec_query_all() allocates din and dout correctly.
 823		 */
 824		data = (struct ec_response_get_protocol_info *)mock->o_data;
 825		data->max_request_packet_size = 0xbe;
 826		data->max_response_packet_size = 0xef;
 827	}
 828
 829	/* For cros_ec_get_proto_info() with passthru. */
 830	{
 831		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
 832		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 833	}
 834
 835	/* For cros_ec_get_host_command_version_mask() for MKBP. */
 836	{
 837		struct ec_response_get_cmd_versions *data;
 838
 839		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 840		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 841
 842		data = (struct ec_response_get_cmd_versions *)mock->o_data;
 843		data->version_mask = 0;
 844	}
 845
 846	cros_ec_proto_test_query_all_pretest(test);
 847	ret = cros_ec_query_all(ec_dev);
 848	KUNIT_EXPECT_EQ(test, ret, 0);
 849
 850	/* For cros_ec_get_proto_info() without passthru. */
 851	{
 852		mock = cros_kunit_ec_xfer_mock_next();
 853		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 854
 855		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 856		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
 857		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 858				sizeof(struct ec_response_get_protocol_info));
 859		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 860	}
 861
 862	/* For cros_ec_get_proto_info() with passthru. */
 863	{
 864		mock = cros_kunit_ec_xfer_mock_next();
 865		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 866
 867		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 868		KUNIT_EXPECT_EQ(test, mock->msg.command,
 869				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
 870				EC_CMD_GET_PROTOCOL_INFO);
 871		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 872				sizeof(struct ec_response_get_protocol_info));
 873		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 874	}
 875
 876	/* For cros_ec_get_host_command_version_mask() for MKBP. */
 877	{
 878		struct ec_params_get_cmd_versions *data;
 879
 880		mock = cros_kunit_ec_xfer_mock_next();
 881		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 882
 883		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 884		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
 885		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 886				sizeof(struct ec_response_get_cmd_versions));
 887		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
 888
 889		data = (struct ec_params_get_cmd_versions *)mock->i_data;
 890		KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT);
 891
 892		KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 0);
 893	}
 894}
 895
 896static void cros_ec_proto_test_query_all_no_mkbp_return_error(struct kunit *test)
 897{
 898	struct cros_ec_proto_test_priv *priv = test->priv;
 899	struct cros_ec_device *ec_dev = &priv->ec_dev;
 900	struct ec_xfer_mock *mock;
 901	int ret;
 902
 903	/* Set some garbage bytes. */
 904	ec_dev->mkbp_event_supported = 0xbf;
 905
 906	/* For cros_ec_get_proto_info() without passthru. */
 907	{
 908		struct ec_response_get_protocol_info *data;
 909
 910		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 911		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 912
 913		/*
 914		 * Although it doesn't check the value, provides valid sizes so that
 915		 * cros_ec_query_all() allocates din and dout correctly.
 916		 */
 917		data = (struct ec_response_get_protocol_info *)mock->o_data;
 918		data->max_request_packet_size = 0xbe;
 919		data->max_response_packet_size = 0xef;
 920	}
 921
 922	/* For cros_ec_get_proto_info() with passthru. */
 923	{
 924		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
 925		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 926	}
 927
 928	/* For cros_ec_get_host_command_version_mask() for MKBP. */
 929	{
 930		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
 931		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 932	}
 933
 934	cros_ec_proto_test_query_all_pretest(test);
 935	ret = cros_ec_query_all(ec_dev);
 936	KUNIT_EXPECT_EQ(test, ret, 0);
 937
 938	/* For cros_ec_get_proto_info() without passthru. */
 939	{
 940		mock = cros_kunit_ec_xfer_mock_next();
 941		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 942
 943		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 944		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
 945		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 946				sizeof(struct ec_response_get_protocol_info));
 947		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 948	}
 949
 950	/* For cros_ec_get_proto_info() with passthru. */
 951	{
 952		mock = cros_kunit_ec_xfer_mock_next();
 953		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 954
 955		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 956		KUNIT_EXPECT_EQ(test, mock->msg.command,
 957				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
 958				EC_CMD_GET_PROTOCOL_INFO);
 959		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 960				sizeof(struct ec_response_get_protocol_info));
 961		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 962	}
 963
 964	/* For cros_ec_get_host_command_version_mask() for MKBP. */
 965	{
 966		struct ec_params_get_cmd_versions *data;
 967
 968		mock = cros_kunit_ec_xfer_mock_next();
 969		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
 970
 971		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 972		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
 973		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 974				sizeof(struct ec_response_get_cmd_versions));
 975		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
 976
 977		data = (struct ec_params_get_cmd_versions *)mock->i_data;
 978		KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT);
 979
 980		KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 0);
 981	}
 982}
 983
 984static void cros_ec_proto_test_query_all_no_mkbp_return0(struct kunit *test)
 985{
 986	struct cros_ec_proto_test_priv *priv = test->priv;
 987	struct cros_ec_device *ec_dev = &priv->ec_dev;
 988	struct ec_xfer_mock *mock;
 989	int ret;
 990
 991	/* Set some garbage bytes. */
 992	ec_dev->mkbp_event_supported = 0xbf;
 993
 994	/* For cros_ec_get_proto_info() without passthru. */
 995	{
 996		struct ec_response_get_protocol_info *data;
 997
 998		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
 999		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1000
1001		/*
1002		 * Although it doesn't check the value, provides valid sizes so that
1003		 * cros_ec_query_all() allocates din and dout correctly.
1004		 */
1005		data = (struct ec_response_get_protocol_info *)mock->o_data;
1006		data->max_request_packet_size = 0xbe;
1007		data->max_response_packet_size = 0xef;
1008	}
1009
1010	/* For cros_ec_get_proto_info() with passthru. */
1011	{
1012		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
1013		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1014	}
1015
1016	/* For cros_ec_get_host_command_version_mask() for MKBP. */
1017	{
1018		mock = cros_kunit_ec_xfer_mock_add(test, 0);
1019		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1020	}
1021
1022	cros_ec_proto_test_query_all_pretest(test);
1023	ret = cros_ec_query_all(ec_dev);
1024	KUNIT_EXPECT_EQ(test, ret, 0);
1025
1026	/* For cros_ec_get_proto_info() without passthru. */
1027	{
1028		mock = cros_kunit_ec_xfer_mock_next();
1029		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1030
1031		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1032		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
1033		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1034				sizeof(struct ec_response_get_protocol_info));
1035		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1036	}
1037
1038	/* For cros_ec_get_proto_info() with passthru. */
1039	{
1040		mock = cros_kunit_ec_xfer_mock_next();
1041		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1042
1043		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1044		KUNIT_EXPECT_EQ(test, mock->msg.command,
1045				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
1046				EC_CMD_GET_PROTOCOL_INFO);
1047		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1048				sizeof(struct ec_response_get_protocol_info));
1049		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1050	}
1051
1052	/* For cros_ec_get_host_command_version_mask() for MKBP. */
1053	{
1054		struct ec_params_get_cmd_versions *data;
1055
1056		mock = cros_kunit_ec_xfer_mock_next();
1057		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1058
1059		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1060		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
1061		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1062				sizeof(struct ec_response_get_cmd_versions));
1063		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
1064
1065		data = (struct ec_params_get_cmd_versions *)mock->i_data;
1066		KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT);
1067
1068		KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 0);
1069	}
1070}
1071
1072static void cros_ec_proto_test_query_all_no_host_sleep(struct kunit *test)
1073{
1074	struct cros_ec_proto_test_priv *priv = test->priv;
1075	struct cros_ec_device *ec_dev = &priv->ec_dev;
1076	struct ec_xfer_mock *mock;
1077	int ret;
1078
1079	/* Set some garbage bytes. */
1080	ec_dev->host_sleep_v1 = true;
1081
1082	/* For cros_ec_get_proto_info() without passthru. */
1083	{
1084		struct ec_response_get_protocol_info *data;
1085
1086		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
1087		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1088
1089		/*
1090		 * Although it doesn't check the value, provides valid sizes so that
1091		 * cros_ec_query_all() allocates din and dout correctly.
1092		 */
1093		data = (struct ec_response_get_protocol_info *)mock->o_data;
1094		data->max_request_packet_size = 0xbe;
1095		data->max_response_packet_size = 0xef;
1096	}
1097
1098	/* For cros_ec_get_proto_info() with passthru. */
1099	{
1100		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
1101		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1102	}
1103
1104	/* For cros_ec_get_host_command_version_mask() for MKBP. */
1105	{
1106		mock = cros_kunit_ec_xfer_mock_add(test, 0);
1107		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1108	}
1109
1110	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
1111	{
1112		struct ec_response_get_cmd_versions *data;
1113
1114		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
1115		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1116
1117		data = (struct ec_response_get_cmd_versions *)mock->o_data;
1118		data->version_mask = 0;
1119	}
1120
1121	cros_ec_proto_test_query_all_pretest(test);
1122	ret = cros_ec_query_all(ec_dev);
1123	KUNIT_EXPECT_EQ(test, ret, 0);
1124
1125	/* For cros_ec_get_proto_info() without passthru. */
1126	{
1127		mock = cros_kunit_ec_xfer_mock_next();
1128		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1129
1130		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1131		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
1132		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1133				sizeof(struct ec_response_get_protocol_info));
1134		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1135	}
1136
1137	/* For cros_ec_get_proto_info() with passthru. */
1138	{
1139		mock = cros_kunit_ec_xfer_mock_next();
1140		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1141
1142		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1143		KUNIT_EXPECT_EQ(test, mock->msg.command,
1144				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
1145				EC_CMD_GET_PROTOCOL_INFO);
1146		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1147				sizeof(struct ec_response_get_protocol_info));
1148		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1149	}
1150
1151	/* For cros_ec_get_host_command_version_mask() for MKBP. */
1152	{
1153		mock = cros_kunit_ec_xfer_mock_next();
1154		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1155
1156		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1157		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
1158		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1159				sizeof(struct ec_response_get_cmd_versions));
1160		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
1161	}
1162
1163	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
1164	{
1165		mock = cros_kunit_ec_xfer_mock_next();
1166		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1167
1168		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1169		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
1170		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1171				sizeof(struct ec_response_get_cmd_versions));
1172		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
1173
1174		KUNIT_EXPECT_FALSE(test, ec_dev->host_sleep_v1);
1175	}
1176}
1177
1178static void cros_ec_proto_test_query_all_no_host_sleep_return0(struct kunit *test)
1179{
1180	struct cros_ec_proto_test_priv *priv = test->priv;
1181	struct cros_ec_device *ec_dev = &priv->ec_dev;
1182	struct ec_xfer_mock *mock;
1183	int ret;
1184
1185	/* Set some garbage bytes. */
1186	ec_dev->host_sleep_v1 = true;
1187
1188	/* For cros_ec_get_proto_info() without passthru. */
1189	{
1190		struct ec_response_get_protocol_info *data;
1191
1192		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
1193		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1194
1195		/*
1196		 * Although it doesn't check the value, provides valid sizes so that
1197		 * cros_ec_query_all() allocates din and dout correctly.
1198		 */
1199		data = (struct ec_response_get_protocol_info *)mock->o_data;
1200		data->max_request_packet_size = 0xbe;
1201		data->max_response_packet_size = 0xef;
1202	}
1203
1204	/* For cros_ec_get_proto_info() with passthru. */
1205	{
1206		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
1207		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1208	}
1209
1210	/* For cros_ec_get_host_command_version_mask() for MKBP. */
1211	{
1212		struct ec_response_get_cmd_versions *data;
1213
1214		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
1215		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1216
1217		/* In order to pollute next cros_ec_get_host_command_version_mask(). */
1218		data = (struct ec_response_get_cmd_versions *)mock->o_data;
1219		data->version_mask = 0xbeef;
1220	}
1221
1222	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
1223	{
1224		mock = cros_kunit_ec_xfer_mock_add(test, 0);
1225		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1226	}
1227
1228	cros_ec_proto_test_query_all_pretest(test);
1229	ret = cros_ec_query_all(ec_dev);
1230	KUNIT_EXPECT_EQ(test, ret, 0);
1231
1232	/* For cros_ec_get_proto_info() without passthru. */
1233	{
1234		mock = cros_kunit_ec_xfer_mock_next();
1235		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1236
1237		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1238		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
1239		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1240				sizeof(struct ec_response_get_protocol_info));
1241		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1242	}
1243
1244	/* For cros_ec_get_proto_info() with passthru. */
1245	{
1246		mock = cros_kunit_ec_xfer_mock_next();
1247		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1248
1249		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1250		KUNIT_EXPECT_EQ(test, mock->msg.command,
1251				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
1252				EC_CMD_GET_PROTOCOL_INFO);
1253		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1254				sizeof(struct ec_response_get_protocol_info));
1255		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1256	}
1257
1258	/* For cros_ec_get_host_command_version_mask() for MKBP. */
1259	{
1260		mock = cros_kunit_ec_xfer_mock_next();
1261		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1262
1263		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1264		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
1265		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1266				sizeof(struct ec_response_get_cmd_versions));
1267		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
1268	}
1269
1270	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
1271	{
1272		mock = cros_kunit_ec_xfer_mock_next();
1273		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1274
1275		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1276		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
1277		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1278				sizeof(struct ec_response_get_cmd_versions));
1279		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
1280
1281		KUNIT_EXPECT_FALSE(test, ec_dev->host_sleep_v1);
1282	}
1283}
1284
1285static void cros_ec_proto_test_query_all_default_wake_mask_return_error(struct kunit *test)
1286{
1287	struct cros_ec_proto_test_priv *priv = test->priv;
1288	struct cros_ec_device *ec_dev = &priv->ec_dev;
1289	struct ec_xfer_mock *mock;
1290	int ret;
1291
1292	/* Set some garbage bytes. */
1293	ec_dev->host_event_wake_mask = U32_MAX;
1294
1295	/* For cros_ec_get_proto_info() without passthru. */
1296	{
1297		struct ec_response_get_protocol_info *data;
1298
1299		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
1300		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1301
1302		/*
1303		 * Although it doesn't check the value, provides valid sizes so that
1304		 * cros_ec_query_all() allocates din and dout correctly.
1305		 */
1306		data = (struct ec_response_get_protocol_info *)mock->o_data;
1307		data->max_request_packet_size = 0xbe;
1308		data->max_response_packet_size = 0xef;
1309	}
1310
1311	/* For cros_ec_get_proto_info() with passthru. */
1312	{
1313		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
1314		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1315	}
1316
1317	/* For cros_ec_get_host_command_version_mask() for MKBP. */
1318	{
1319		mock = cros_kunit_ec_xfer_mock_add(test, 0);
1320		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1321	}
1322
1323	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
1324	{
1325		mock = cros_kunit_ec_xfer_mock_add(test, 0);
1326		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1327	}
1328
1329	/* For cros_ec_get_host_event_wake_mask(). */
1330	{
1331		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
1332		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1333	}
1334
1335	cros_ec_proto_test_query_all_pretest(test);
1336	ret = cros_ec_query_all(ec_dev);
1337	KUNIT_EXPECT_EQ(test, ret, 0);
1338
1339	/* For cros_ec_get_proto_info() without passthru. */
1340	{
1341		mock = cros_kunit_ec_xfer_mock_next();
1342		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1343
1344		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1345		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
1346		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1347				sizeof(struct ec_response_get_protocol_info));
1348		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1349	}
1350
1351	/* For cros_ec_get_proto_info() with passthru. */
1352	{
1353		mock = cros_kunit_ec_xfer_mock_next();
1354		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1355
1356		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1357		KUNIT_EXPECT_EQ(test, mock->msg.command,
1358				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
1359				EC_CMD_GET_PROTOCOL_INFO);
1360		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1361				sizeof(struct ec_response_get_protocol_info));
1362		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1363	}
1364
1365	/* For cros_ec_get_host_command_version_mask() for MKBP. */
1366	{
1367		mock = cros_kunit_ec_xfer_mock_next();
1368		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1369
1370		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1371		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
1372		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1373				sizeof(struct ec_response_get_cmd_versions));
1374		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
1375	}
1376
1377	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
1378	{
1379		mock = cros_kunit_ec_xfer_mock_next();
1380		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1381
1382		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1383		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
1384		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1385				sizeof(struct ec_response_get_cmd_versions));
1386		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
1387	}
1388
1389	/* For cros_ec_get_host_event_wake_mask(). */
1390	{
1391		u32 mask;
1392
1393		mock = cros_kunit_ec_xfer_mock_next();
1394		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1395
1396		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1397		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HOST_EVENT_GET_WAKE_MASK);
1398		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_host_event_mask));
1399		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1400
1401		mask = ec_dev->host_event_wake_mask;
1402		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_CLOSED), 0);
1403		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED), 0);
1404		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_LOW), 0);
1405		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_CRITICAL), 0);
1406		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY), 0);
1407		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_PD_MCU), 0);
1408		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_STATUS), 0);
1409	}
1410}
1411
1412static void cros_ec_proto_test_query_all_default_wake_mask_return0(struct kunit *test)
1413{
1414	struct cros_ec_proto_test_priv *priv = test->priv;
1415	struct cros_ec_device *ec_dev = &priv->ec_dev;
1416	struct ec_xfer_mock *mock;
1417	int ret;
1418
1419	/* Set some garbage bytes. */
1420	ec_dev->host_event_wake_mask = U32_MAX;
1421
1422	/* For cros_ec_get_proto_info() without passthru. */
1423	{
1424		struct ec_response_get_protocol_info *data;
1425
1426		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
1427		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1428
1429		/*
1430		 * Although it doesn't check the value, provides valid sizes so that
1431		 * cros_ec_query_all() allocates din and dout correctly.
1432		 */
1433		data = (struct ec_response_get_protocol_info *)mock->o_data;
1434		data->max_request_packet_size = 0xbe;
1435		data->max_response_packet_size = 0xef;
1436	}
1437
1438	/* For cros_ec_get_proto_info() with passthru. */
1439	{
1440		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
1441		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1442	}
1443
1444	/* For cros_ec_get_host_command_version_mask() for MKBP. */
1445	{
1446		mock = cros_kunit_ec_xfer_mock_add(test, 0);
1447		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1448	}
1449
1450	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
1451	{
1452		mock = cros_kunit_ec_xfer_mock_add(test, 0);
1453		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1454	}
1455
1456	/* For get_host_event_wake_mask(). */
1457	{
1458		mock = cros_kunit_ec_xfer_mock_add(test, 0);
1459		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1460	}
1461
1462	cros_ec_proto_test_query_all_pretest(test);
1463	ret = cros_ec_query_all(ec_dev);
1464	KUNIT_EXPECT_EQ(test, ret, 0);
1465
1466	/* For cros_ec_get_proto_info() without passthru. */
1467	{
1468		mock = cros_kunit_ec_xfer_mock_next();
1469		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1470
1471		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1472		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
1473		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1474				sizeof(struct ec_response_get_protocol_info));
1475		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1476	}
1477
1478	/* For cros_ec_get_proto_info() with passthru. */
1479	{
1480		mock = cros_kunit_ec_xfer_mock_next();
1481		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1482
1483		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1484		KUNIT_EXPECT_EQ(test, mock->msg.command,
1485				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
1486				EC_CMD_GET_PROTOCOL_INFO);
1487		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1488				sizeof(struct ec_response_get_protocol_info));
1489		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1490	}
1491
1492	/* For cros_ec_get_host_command_version_mask() for MKBP. */
1493	{
1494		mock = cros_kunit_ec_xfer_mock_next();
1495		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1496
1497		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1498		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
1499		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1500				sizeof(struct ec_response_get_cmd_versions));
1501		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
1502	}
1503
1504	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
1505	{
1506		mock = cros_kunit_ec_xfer_mock_next();
1507		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1508
1509		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1510		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
1511		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1512				sizeof(struct ec_response_get_cmd_versions));
1513		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
1514	}
1515
1516	/* For get_host_event_wake_mask(). */
1517	{
1518		u32 mask;
1519
1520		mock = cros_kunit_ec_xfer_mock_next();
1521		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1522
1523		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1524		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HOST_EVENT_GET_WAKE_MASK);
1525		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_host_event_mask));
1526		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1527
1528		mask = ec_dev->host_event_wake_mask;
1529		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_CLOSED), 0);
1530		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED), 0);
1531		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_LOW), 0);
1532		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_CRITICAL), 0);
1533		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY), 0);
1534		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_PD_MCU), 0);
1535		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_STATUS), 0);
1536	}
1537}
1538
1539static void cros_ec_proto_test_cmd_xfer_normal(struct kunit *test)
1540{
1541	struct cros_ec_proto_test_priv *priv = test->priv;
1542	struct cros_ec_device *ec_dev = &priv->ec_dev;
1543	struct ec_xfer_mock *mock;
1544	int ret;
1545	struct {
1546		struct cros_ec_command msg;
1547		u8 data[0x100];
1548	} __packed buf;
1549
1550	ec_dev->max_request = 0xff;
1551	ec_dev->max_response = 0xee;
1552	ec_dev->max_passthru = 0xdd;
1553
1554	buf.msg.version = 0;
1555	buf.msg.command = EC_CMD_HELLO;
1556	buf.msg.insize = 4;
1557	buf.msg.outsize = 2;
1558	buf.data[0] = 0x55;
1559	buf.data[1] = 0xaa;
1560
1561	{
1562		u8 *data;
1563
1564		mock = cros_kunit_ec_xfer_mock_add(test, 4);
1565		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1566
1567		data = (u8 *)mock->o_data;
1568		data[0] = 0xaa;
1569		data[1] = 0x55;
1570		data[2] = 0xcc;
1571		data[3] = 0x33;
1572	}
1573
1574	ret = cros_ec_cmd_xfer(ec_dev, &buf.msg);
1575	KUNIT_EXPECT_EQ(test, ret, 4);
1576
1577	{
1578		u8 *data;
1579
1580		mock = cros_kunit_ec_xfer_mock_next();
1581		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1582
1583		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1584		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
1585		KUNIT_EXPECT_EQ(test, mock->msg.insize, 4);
1586		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 2);
1587
1588		data = (u8 *)mock->i_data;
1589		KUNIT_EXPECT_EQ(test, data[0], 0x55);
1590		KUNIT_EXPECT_EQ(test, data[1], 0xaa);
1591
1592		KUNIT_EXPECT_EQ(test, buf.data[0], 0xaa);
1593		KUNIT_EXPECT_EQ(test, buf.data[1], 0x55);
1594		KUNIT_EXPECT_EQ(test, buf.data[2], 0xcc);
1595		KUNIT_EXPECT_EQ(test, buf.data[3], 0x33);
1596	}
1597}
1598
1599static void cros_ec_proto_test_cmd_xfer_excess_msg_insize(struct kunit *test)
1600{
1601	struct cros_ec_proto_test_priv *priv = test->priv;
1602	struct cros_ec_device *ec_dev = &priv->ec_dev;
1603	struct ec_xfer_mock *mock;
1604	int ret;
1605	struct {
1606		struct cros_ec_command msg;
1607		u8 data[0x100];
1608	} __packed buf;
1609
1610	ec_dev->max_request = 0xff;
1611	ec_dev->max_response = 0xee;
1612	ec_dev->max_passthru = 0xdd;
1613
1614	buf.msg.version = 0;
1615	buf.msg.command = EC_CMD_HELLO;
1616	buf.msg.insize = 0xee + 1;
1617	buf.msg.outsize = 2;
1618
1619	{
1620		mock = cros_kunit_ec_xfer_mock_add(test, 0xcc);
1621		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1622	}
1623
1624	ret = cros_ec_cmd_xfer(ec_dev, &buf.msg);
1625	KUNIT_EXPECT_EQ(test, ret, 0xcc);
1626
1627	{
1628		mock = cros_kunit_ec_xfer_mock_next();
1629		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1630
1631		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1632		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
1633		KUNIT_EXPECT_EQ(test, mock->msg.insize, 0xee);
1634		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 2);
1635	}
1636}
1637
1638static void cros_ec_proto_test_cmd_xfer_excess_msg_outsize_without_passthru(struct kunit *test)
1639{
1640	struct cros_ec_proto_test_priv *priv = test->priv;
1641	struct cros_ec_device *ec_dev = &priv->ec_dev;
1642	int ret;
1643	struct {
1644		struct cros_ec_command msg;
1645		u8 data[0x100];
1646	} __packed buf;
1647
1648	ec_dev->max_request = 0xff;
1649	ec_dev->max_response = 0xee;
1650	ec_dev->max_passthru = 0xdd;
1651
1652	buf.msg.version = 0;
1653	buf.msg.command = EC_CMD_HELLO;
1654	buf.msg.insize = 4;
1655	buf.msg.outsize = 0xff + 1;
1656
1657	ret = cros_ec_cmd_xfer(ec_dev, &buf.msg);
1658	KUNIT_EXPECT_EQ(test, ret, -EMSGSIZE);
1659}
1660
1661static void cros_ec_proto_test_cmd_xfer_excess_msg_outsize_with_passthru(struct kunit *test)
1662{
1663	struct cros_ec_proto_test_priv *priv = test->priv;
1664	struct cros_ec_device *ec_dev = &priv->ec_dev;
1665	int ret;
1666	struct {
1667		struct cros_ec_command msg;
1668		u8 data[0x100];
1669	} __packed buf;
1670
1671	ec_dev->max_request = 0xff;
1672	ec_dev->max_response = 0xee;
1673	ec_dev->max_passthru = 0xdd;
1674
1675	buf.msg.version = 0;
1676	buf.msg.command = EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) + EC_CMD_HELLO;
1677	buf.msg.insize = 4;
1678	buf.msg.outsize = 0xdd + 1;
1679
1680	ret = cros_ec_cmd_xfer(ec_dev, &buf.msg);
1681	KUNIT_EXPECT_EQ(test, ret, -EMSGSIZE);
1682}
1683
1684static void cros_ec_proto_test_cmd_xfer_protocol_v3_normal(struct kunit *test)
1685{
1686	struct cros_ec_proto_test_priv *priv = test->priv;
1687	struct cros_ec_device *ec_dev = &priv->ec_dev;
1688	int ret;
1689	struct cros_ec_command msg;
1690
1691	memset(&msg, 0, sizeof(msg));
1692
1693	ec_dev->proto_version = 3;
1694	ec_dev->cmd_xfer = cros_kunit_ec_cmd_xfer_mock;
1695	ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
1696
1697	ret = cros_ec_cmd_xfer(ec_dev, &msg);
1698	KUNIT_EXPECT_EQ(test, ret, 0);
1699
1700	KUNIT_EXPECT_EQ(test, cros_kunit_ec_cmd_xfer_mock_called, 0);
1701	KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 1);
1702}
1703
1704static void cros_ec_proto_test_cmd_xfer_protocol_v3_no_op(struct kunit *test)
1705{
1706	struct cros_ec_proto_test_priv *priv = test->priv;
1707	struct cros_ec_device *ec_dev = &priv->ec_dev;
1708	int ret;
1709	struct cros_ec_command msg;
1710
1711	memset(&msg, 0, sizeof(msg));
1712
1713	ec_dev->proto_version = 3;
1714	ec_dev->cmd_xfer = cros_kunit_ec_cmd_xfer_mock;
1715	ec_dev->pkt_xfer = NULL;
1716
1717	ret = cros_ec_cmd_xfer(ec_dev, &msg);
1718	KUNIT_EXPECT_EQ(test, ret, -EIO);
1719}
1720
1721static void cros_ec_proto_test_cmd_xfer_protocol_v2_normal(struct kunit *test)
1722{
1723	struct cros_ec_proto_test_priv *priv = test->priv;
1724	struct cros_ec_device *ec_dev = &priv->ec_dev;
1725	int ret;
1726	struct cros_ec_command msg;
1727
1728	memset(&msg, 0, sizeof(msg));
1729
1730	ec_dev->proto_version = 2;
1731	ec_dev->cmd_xfer = cros_kunit_ec_cmd_xfer_mock;
1732	ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
1733
1734	ret = cros_ec_cmd_xfer(ec_dev, &msg);
1735	KUNIT_EXPECT_EQ(test, ret, 0);
1736
1737	KUNIT_EXPECT_EQ(test, cros_kunit_ec_cmd_xfer_mock_called, 1);
1738	KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 0);
1739}
1740
1741static void cros_ec_proto_test_cmd_xfer_protocol_v2_no_op(struct kunit *test)
1742{
1743	struct cros_ec_proto_test_priv *priv = test->priv;
1744	struct cros_ec_device *ec_dev = &priv->ec_dev;
1745	int ret;
1746	struct cros_ec_command msg;
1747
1748	memset(&msg, 0, sizeof(msg));
1749
1750	ec_dev->proto_version = 2;
1751	ec_dev->cmd_xfer = NULL;
1752	ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
1753
1754	ret = cros_ec_cmd_xfer(ec_dev, &msg);
1755	KUNIT_EXPECT_EQ(test, ret, -EIO);
1756}
1757
1758static void cros_ec_proto_test_cmd_xfer_in_progress_normal(struct kunit *test)
1759{
1760	struct cros_ec_proto_test_priv *priv = test->priv;
1761	struct cros_ec_device *ec_dev = &priv->ec_dev;
1762	struct ec_xfer_mock *mock;
1763	int ret;
1764	struct cros_ec_command msg;
1765
1766	memset(&msg, 0, sizeof(msg));
1767
1768	ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
1769
1770	/* For the first host command to return EC_RES_IN_PROGRESS. */
1771	{
1772		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0);
1773		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1774	}
1775
1776	/* For EC_CMD_GET_COMMS_STATUS. */
1777	{
1778		struct ec_response_get_comms_status *data;
1779
1780		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
1781		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1782
1783		data = (struct ec_response_get_comms_status *)mock->o_data;
1784		data->flags = 0;
1785	}
1786
1787	ret = cros_ec_cmd_xfer(ec_dev, &msg);
1788	KUNIT_EXPECT_EQ(test, ret, sizeof(struct ec_response_get_comms_status));
1789
1790	KUNIT_EXPECT_EQ(test, msg.result, EC_RES_SUCCESS);
1791
1792	/* For the first host command to return EC_RES_IN_PROGRESS. */
1793	{
1794		mock = cros_kunit_ec_xfer_mock_next();
1795		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1796	}
1797
1798	/* For EC_CMD_GET_COMMS_STATUS. */
1799	{
1800		mock = cros_kunit_ec_xfer_mock_next();
1801		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
1802
1803		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
1804		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_COMMS_STATUS);
1805		KUNIT_EXPECT_EQ(test, mock->msg.insize,
1806				sizeof(struct ec_response_get_comms_status));
1807		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
1808	}
1809
1810	KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 2);
1811}
1812
1813static void cros_ec_proto_test_cmd_xfer_in_progress_retries_eagain(struct kunit *test)
1814{
1815	struct cros_ec_proto_test_priv *priv = test->priv;
1816	struct cros_ec_device *ec_dev = &priv->ec_dev;
1817	struct ec_xfer_mock *mock;
1818	int ret;
1819	struct cros_ec_command msg;
1820
1821	memset(&msg, 0, sizeof(msg));
1822
1823	ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
1824
1825	/* For the first host command to return EC_RES_IN_PROGRESS. */
1826	{
1827		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0);
1828		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1829	}
1830
1831	/* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */
1832	cros_kunit_ec_xfer_mock_default_ret = -EAGAIN;
1833
1834	ret = cros_ec_cmd_xfer(ec_dev, &msg);
1835	KUNIT_EXPECT_EQ(test, ret, -EAGAIN);
1836
1837	/* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */
1838	KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 51);
1839}
1840
1841static void cros_ec_proto_test_cmd_xfer_in_progress_retries_status_processing(struct kunit *test)
1842{
1843	struct cros_ec_proto_test_priv *priv = test->priv;
1844	struct cros_ec_device *ec_dev = &priv->ec_dev;
1845	struct ec_xfer_mock *mock;
1846	int ret;
1847	struct cros_ec_command msg;
1848
1849	memset(&msg, 0, sizeof(msg));
1850
1851	ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
1852
1853	/* For the first host command to return EC_RES_IN_PROGRESS. */
1854	{
1855		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0);
1856		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1857	}
1858
1859	/* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */
1860	{
1861		struct ec_response_get_comms_status *data;
1862		int i;
1863
1864		for (i = 0; i < 50; ++i) {
1865			mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
1866			KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1867
1868			data = (struct ec_response_get_comms_status *)mock->o_data;
1869			data->flags |= EC_COMMS_STATUS_PROCESSING;
1870		}
1871	}
1872
1873	ret = cros_ec_cmd_xfer(ec_dev, &msg);
1874	KUNIT_EXPECT_EQ(test, ret, -EAGAIN);
1875
1876	/* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */
1877	KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 51);
1878}
1879
1880static void cros_ec_proto_test_cmd_xfer_in_progress_xfer_error(struct kunit *test)
1881{
1882	struct cros_ec_proto_test_priv *priv = test->priv;
1883	struct cros_ec_device *ec_dev = &priv->ec_dev;
1884	struct ec_xfer_mock *mock;
1885	int ret;
1886	struct cros_ec_command msg;
1887
1888	memset(&msg, 0, sizeof(msg));
1889
1890	/* For the first host command to return EC_RES_IN_PROGRESS. */
1891	{
1892		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0);
1893		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1894	}
1895
1896	/* For EC_CMD_GET_COMMS_STATUS. */
1897	{
1898		mock = cros_kunit_ec_xfer_mock_addx(test, -EIO, EC_RES_SUCCESS, 0);
1899		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1900	}
1901
1902	ret = cros_ec_cmd_xfer(ec_dev, &msg);
1903	KUNIT_EXPECT_EQ(test, ret, -EIO);
1904}
1905
1906static void cros_ec_proto_test_cmd_xfer_in_progress_return_error(struct kunit *test)
1907{
1908	struct cros_ec_proto_test_priv *priv = test->priv;
1909	struct cros_ec_device *ec_dev = &priv->ec_dev;
1910	struct ec_xfer_mock *mock;
1911	int ret;
1912	struct cros_ec_command msg;
1913
1914	memset(&msg, 0, sizeof(msg));
1915
1916	ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
1917
1918	/* For the first host command to return EC_RES_IN_PROGRESS. */
1919	{
1920		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0);
1921		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1922	}
1923
1924	/* For EC_CMD_GET_COMMS_STATUS. */
1925	{
1926		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
1927		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1928	}
1929
1930	ret = cros_ec_cmd_xfer(ec_dev, &msg);
1931	KUNIT_EXPECT_EQ(test, ret, 0);
1932
1933	KUNIT_EXPECT_EQ(test, msg.result, EC_RES_INVALID_COMMAND);
1934
1935	KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 2);
1936}
1937
1938static void cros_ec_proto_test_cmd_xfer_in_progress_return0(struct kunit *test)
1939{
1940	struct cros_ec_proto_test_priv *priv = test->priv;
1941	struct cros_ec_device *ec_dev = &priv->ec_dev;
1942	struct ec_xfer_mock *mock;
1943	int ret;
1944	struct cros_ec_command msg;
1945
1946	memset(&msg, 0, sizeof(msg));
1947
1948	ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
1949
1950	/* For the first host command to return EC_RES_IN_PROGRESS. */
1951	{
1952		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0);
1953		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1954	}
1955
1956	/* For EC_CMD_GET_COMMS_STATUS. */
1957	{
1958		mock = cros_kunit_ec_xfer_mock_add(test, 0);
1959		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1960	}
1961
1962	ret = cros_ec_cmd_xfer(ec_dev, &msg);
1963	KUNIT_EXPECT_EQ(test, ret, -EPROTO);
1964
1965	KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 2);
1966}
1967
1968static void cros_ec_proto_test_cmd_xfer_status_normal(struct kunit *test)
1969{
1970	struct cros_ec_proto_test_priv *priv = test->priv;
1971	struct cros_ec_device *ec_dev = &priv->ec_dev;
1972	struct ec_xfer_mock *mock;
1973	int ret;
1974	struct cros_ec_command msg;
1975
1976	memset(&msg, 0, sizeof(msg));
1977
1978	/* For cros_ec_cmd_xfer(). */
1979	{
1980		mock = cros_kunit_ec_xfer_mock_add(test, 0);
1981		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
1982	}
1983
1984	ret = cros_ec_cmd_xfer_status(ec_dev, &msg);
1985	KUNIT_EXPECT_EQ(test, ret, 0);
1986}
1987
1988static void cros_ec_proto_test_cmd_xfer_status_xfer_error(struct kunit *test)
1989{
1990	struct cros_ec_proto_test_priv *priv = test->priv;
1991	struct cros_ec_device *ec_dev = &priv->ec_dev;
1992	struct ec_xfer_mock *mock;
1993	int ret;
1994	struct cros_ec_command msg;
1995
1996	memset(&msg, 0, sizeof(msg));
1997
1998	/* For cros_ec_cmd_xfer(). */
1999	{
2000		mock = cros_kunit_ec_xfer_mock_addx(test, -EPROTO, EC_RES_SUCCESS, 0);
2001		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
2002	}
2003
2004	ret = cros_ec_cmd_xfer_status(ec_dev, &msg);
2005	KUNIT_EXPECT_EQ(test, ret, -EPROTO);
2006}
2007
2008static void cros_ec_proto_test_cmd_xfer_status_return_error(struct kunit *test)
2009{
2010	struct cros_ec_proto_test_priv *priv = test->priv;
2011	struct cros_ec_device *ec_dev = &priv->ec_dev;
2012	struct ec_xfer_mock *mock;
2013	int ret, i;
2014	struct cros_ec_command msg;
2015	static const int map[] = {
2016		[EC_RES_SUCCESS] = 0,
2017		[EC_RES_INVALID_COMMAND] = -EOPNOTSUPP,
2018		[EC_RES_ERROR] = -EIO,
2019		[EC_RES_INVALID_PARAM] = -EINVAL,
2020		[EC_RES_ACCESS_DENIED] = -EACCES,
2021		[EC_RES_INVALID_RESPONSE] = -EPROTO,
2022		[EC_RES_INVALID_VERSION] = -ENOPROTOOPT,
2023		[EC_RES_INVALID_CHECKSUM] = -EBADMSG,
2024		/*
2025		 * EC_RES_IN_PROGRESS is special because cros_ec_send_command() has extra logic to
2026		 * handle it.  Note that default cros_kunit_ec_xfer_mock_default_ret == 0 thus
2027		 * cros_ec_xfer_command() in cros_ec_wait_until_complete() returns 0.  As a result,
2028		 * it returns -EPROTO without calling cros_ec_map_error().
2029		 */
2030		[EC_RES_IN_PROGRESS] = -EPROTO,
2031		[EC_RES_UNAVAILABLE] = -ENODATA,
2032		[EC_RES_TIMEOUT] = -ETIMEDOUT,
2033		[EC_RES_OVERFLOW] = -EOVERFLOW,
2034		[EC_RES_INVALID_HEADER] = -EBADR,
2035		[EC_RES_REQUEST_TRUNCATED] = -EBADR,
2036		[EC_RES_RESPONSE_TOO_BIG] = -EFBIG,
2037		[EC_RES_BUS_ERROR] = -EFAULT,
2038		[EC_RES_BUSY] = -EBUSY,
2039		[EC_RES_INVALID_HEADER_VERSION] = -EBADMSG,
2040		[EC_RES_INVALID_HEADER_CRC] = -EBADMSG,
2041		[EC_RES_INVALID_DATA_CRC] = -EBADMSG,
2042		[EC_RES_DUP_UNAVAILABLE] = -ENODATA,
2043	};
2044
2045	memset(&msg, 0, sizeof(msg));
2046
2047	for (i = 0; i < ARRAY_SIZE(map); ++i) {
2048		mock = cros_kunit_ec_xfer_mock_addx(test, 0, i, 0);
2049		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
2050
2051		ret = cros_ec_cmd_xfer_status(ec_dev, &msg);
2052		KUNIT_EXPECT_EQ(test, ret, map[i]);
2053	}
2054}
2055
2056static void cros_ec_proto_test_get_next_event_no_mkbp_event(struct kunit *test)
2057{
2058	struct cros_ec_proto_test_priv *priv = test->priv;
2059	struct cros_ec_device *ec_dev = &priv->ec_dev;
2060	struct ec_xfer_mock *mock;
2061	int ret;
2062	bool wake_event, more_events;
2063
2064	ec_dev->max_request = 0xff;
2065	ec_dev->max_response = 0xee;
2066	ec_dev->mkbp_event_supported = 0;
2067
2068	/* Set some garbage bytes. */
2069	wake_event = false;
2070	more_events = true;
2071
2072	/* For get_keyboard_state_event(). */
2073	{
2074		union ec_response_get_next_data_v1 *data;
2075
2076		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
2077		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
2078
2079		data = (union ec_response_get_next_data_v1 *)mock->o_data;
2080		data->host_event = 0xbeef;
2081	}
2082
2083	ret = cros_ec_get_next_event(ec_dev, &wake_event, &more_events);
2084	KUNIT_EXPECT_EQ(test, ret, sizeof(union ec_response_get_next_data_v1));
2085
2086	KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_KEY_MATRIX);
2087	KUNIT_EXPECT_EQ(test, ec_dev->event_data.data.host_event, 0xbeef);
2088
2089	KUNIT_EXPECT_TRUE(test, wake_event);
2090	KUNIT_EXPECT_FALSE(test, more_events);
2091
2092	/* For get_keyboard_state_event(). */
2093	{
2094		mock = cros_kunit_ec_xfer_mock_next();
2095		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
2096
2097		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
2098		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_MKBP_STATE);
2099		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(union ec_response_get_next_data_v1));
2100		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
2101	}
2102}
2103
2104static void cros_ec_proto_test_get_next_event_mkbp_event_ec_suspended(struct kunit *test)
2105{
2106	struct cros_ec_proto_test_priv *priv = test->priv;
2107	struct cros_ec_device *ec_dev = &priv->ec_dev;
2108	int ret;
2109
2110	ec_dev->mkbp_event_supported = 1;
2111	ec_dev->suspended = true;
2112
2113	ret = cros_ec_get_next_event(ec_dev, NULL, NULL);
2114	KUNIT_EXPECT_EQ(test, ret, -EHOSTDOWN);
2115}
2116
2117static void cros_ec_proto_test_get_next_event_mkbp_event_version0(struct kunit *test)
2118{
2119	struct cros_ec_proto_test_priv *priv = test->priv;
2120	struct cros_ec_device *ec_dev = &priv->ec_dev;
2121	struct ec_xfer_mock *mock;
2122	int ret;
2123	bool wake_event, more_events;
2124
2125	ec_dev->max_request = 0xff;
2126	ec_dev->max_response = 0xee;
2127	ec_dev->mkbp_event_supported = 1;
2128
2129	/* Set some garbage bytes. */
2130	wake_event = true;
2131	more_events = false;
2132
2133	/* For get_next_event_xfer(). */
2134	{
2135		struct ec_response_get_next_event *data;
2136
2137		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
2138		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
2139
2140		data = (struct ec_response_get_next_event *)mock->o_data;
2141		data->event_type = EC_MKBP_EVENT_SENSOR_FIFO | EC_MKBP_HAS_MORE_EVENTS;
2142		data->data.sysrq = 0xbeef;
2143	}
2144
2145	ret = cros_ec_get_next_event(ec_dev, &wake_event, &more_events);
2146	KUNIT_EXPECT_EQ(test, ret, sizeof(struct ec_response_get_next_event));
2147
2148	KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_SENSOR_FIFO);
2149	KUNIT_EXPECT_EQ(test, ec_dev->event_data.data.sysrq, 0xbeef);
2150
2151	KUNIT_EXPECT_FALSE(test, wake_event);
2152	KUNIT_EXPECT_TRUE(test, more_events);
2153
2154	/* For get_next_event_xfer(). */
2155	{
2156		mock = cros_kunit_ec_xfer_mock_next();
2157		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
2158
2159		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
2160		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_NEXT_EVENT);
2161		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_get_next_event));
2162		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
2163	}
2164}
2165
2166static void cros_ec_proto_test_get_next_event_mkbp_event_version2(struct kunit *test)
2167{
2168	struct cros_ec_proto_test_priv *priv = test->priv;
2169	struct cros_ec_device *ec_dev = &priv->ec_dev;
2170	struct ec_xfer_mock *mock;
2171	int ret;
2172	bool wake_event, more_events;
2173
2174	ec_dev->max_request = 0xff;
2175	ec_dev->max_response = 0xee;
2176	ec_dev->mkbp_event_supported = 3;
2177
2178	/* Set some garbage bytes. */
2179	wake_event = false;
2180	more_events = true;
2181
2182	/* For get_next_event_xfer(). */
2183	{
2184		struct ec_response_get_next_event_v1 *data;
2185
2186		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
2187		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
2188
2189		data = (struct ec_response_get_next_event_v1 *)mock->o_data;
2190		data->event_type = EC_MKBP_EVENT_FINGERPRINT;
2191		data->data.sysrq = 0xbeef;
2192	}
2193
2194	ret = cros_ec_get_next_event(ec_dev, &wake_event, &more_events);
2195	KUNIT_EXPECT_EQ(test, ret, sizeof(struct ec_response_get_next_event_v1));
2196
2197	KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_FINGERPRINT);
2198	KUNIT_EXPECT_EQ(test, ec_dev->event_data.data.sysrq, 0xbeef);
2199
2200	KUNIT_EXPECT_TRUE(test, wake_event);
2201	KUNIT_EXPECT_FALSE(test, more_events);
2202
2203	/* For get_next_event_xfer(). */
2204	{
2205		mock = cros_kunit_ec_xfer_mock_next();
2206		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
2207
2208		KUNIT_EXPECT_EQ(test, mock->msg.version, 2);
2209		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_NEXT_EVENT);
2210		KUNIT_EXPECT_EQ(test, mock->msg.insize,
2211				sizeof(struct ec_response_get_next_event_v1));
2212		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
2213	}
2214}
2215
2216static void cros_ec_proto_test_get_next_event_mkbp_event_host_event_rtc(struct kunit *test)
2217{
2218	struct cros_ec_proto_test_priv *priv = test->priv;
2219	struct cros_ec_device *ec_dev = &priv->ec_dev;
2220	struct ec_xfer_mock *mock;
2221	int ret;
2222	bool wake_event;
2223	struct ec_response_get_next_event_v1 *data;
2224
2225	ec_dev->max_request = 0xff;
2226	ec_dev->max_response = 0xee;
2227	ec_dev->mkbp_event_supported = 3;
2228	ec_dev->host_event_wake_mask = U32_MAX;
2229
2230	/* Set some garbage bytes. */
2231	wake_event = true;
2232
2233	/* For get_next_event_xfer(). */
2234	{
2235		mock = cros_kunit_ec_xfer_mock_add(test,
2236						   sizeof(data->event_type) +
2237						   sizeof(data->data.host_event));
2238		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
2239
2240		data = (struct ec_response_get_next_event_v1 *)mock->o_data;
2241		data->event_type = EC_MKBP_EVENT_HOST_EVENT;
2242		put_unaligned_le32(EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC), &data->data.host_event);
2243	}
2244
2245	ret = cros_ec_get_next_event(ec_dev, &wake_event, NULL);
2246	KUNIT_EXPECT_EQ(test, ret, sizeof(data->event_type) + sizeof(data->data.host_event));
2247
2248	KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_HOST_EVENT);
2249
2250	KUNIT_EXPECT_FALSE(test, wake_event);
2251
2252	/* For get_next_event_xfer(). */
2253	{
2254		mock = cros_kunit_ec_xfer_mock_next();
2255		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
2256
2257		KUNIT_EXPECT_EQ(test, mock->msg.version, 2);
2258		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_NEXT_EVENT);
2259		KUNIT_EXPECT_EQ(test, mock->msg.insize,
2260				sizeof(struct ec_response_get_next_event_v1));
2261		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
2262	}
2263}
2264
2265static void cros_ec_proto_test_get_next_event_mkbp_event_host_event_masked(struct kunit *test)
2266{
2267	struct cros_ec_proto_test_priv *priv = test->priv;
2268	struct cros_ec_device *ec_dev = &priv->ec_dev;
2269	struct ec_xfer_mock *mock;
2270	int ret;
2271	bool wake_event;
2272	struct ec_response_get_next_event_v1 *data;
2273
2274	ec_dev->max_request = 0xff;
2275	ec_dev->max_response = 0xee;
2276	ec_dev->mkbp_event_supported = 3;
2277	ec_dev->host_event_wake_mask = U32_MAX & ~EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED);
2278
2279	/* Set some garbage bytes. */
2280	wake_event = true;
2281
2282	/* For get_next_event_xfer(). */
2283	{
2284		mock = cros_kunit_ec_xfer_mock_add(test,
2285						   sizeof(data->event_type) +
2286						   sizeof(data->data.host_event));
2287		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
2288
2289		data = (struct ec_response_get_next_event_v1 *)mock->o_data;
2290		data->event_type = EC_MKBP_EVENT_HOST_EVENT;
2291		put_unaligned_le32(EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED),
2292				   &data->data.host_event);
2293	}
2294
2295	ret = cros_ec_get_next_event(ec_dev, &wake_event, NULL);
2296	KUNIT_EXPECT_EQ(test, ret, sizeof(data->event_type) + sizeof(data->data.host_event));
2297
2298	KUNIT_EXPECT_EQ(test, ec_dev->event_data.event_type, EC_MKBP_EVENT_HOST_EVENT);
2299
2300	KUNIT_EXPECT_FALSE(test, wake_event);
2301
2302	/* For get_next_event_xfer(). */
2303	{
2304		mock = cros_kunit_ec_xfer_mock_next();
2305		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
2306
2307		KUNIT_EXPECT_EQ(test, mock->msg.version, 2);
2308		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_NEXT_EVENT);
2309		KUNIT_EXPECT_EQ(test, mock->msg.insize,
2310				sizeof(struct ec_response_get_next_event_v1));
2311		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
2312	}
2313}
2314
2315static void cros_ec_proto_test_get_host_event_no_mkbp_event(struct kunit *test)
2316{
2317	struct cros_ec_proto_test_priv *priv = test->priv;
2318	struct cros_ec_device *ec_dev = &priv->ec_dev;
2319	int ret;
2320
2321	ec_dev->mkbp_event_supported = 0;
2322
2323	ret = cros_ec_get_host_event(ec_dev);
2324	KUNIT_EXPECT_EQ(test, ret, 0);
2325}
2326
2327static void cros_ec_proto_test_get_host_event_not_host_event(struct kunit *test)
2328{
2329	struct cros_ec_proto_test_priv *priv = test->priv;
2330	struct cros_ec_device *ec_dev = &priv->ec_dev;
2331	int ret;
2332
2333	ec_dev->mkbp_event_supported = 1;
2334	ec_dev->event_data.event_type = EC_MKBP_EVENT_FINGERPRINT;
2335
2336	ret = cros_ec_get_host_event(ec_dev);
2337	KUNIT_EXPECT_EQ(test, ret, 0);
2338}
2339
2340static void cros_ec_proto_test_get_host_event_wrong_event_size(struct kunit *test)
2341{
2342	struct cros_ec_proto_test_priv *priv = test->priv;
2343	struct cros_ec_device *ec_dev = &priv->ec_dev;
2344	int ret;
2345
2346	ec_dev->mkbp_event_supported = 1;
2347	ec_dev->event_data.event_type = EC_MKBP_EVENT_HOST_EVENT;
2348	ec_dev->event_size = 0xff;
2349
2350	ret = cros_ec_get_host_event(ec_dev);
2351	KUNIT_EXPECT_EQ(test, ret, 0);
2352}
2353
2354static void cros_ec_proto_test_get_host_event_normal(struct kunit *test)
2355{
2356	struct cros_ec_proto_test_priv *priv = test->priv;
2357	struct cros_ec_device *ec_dev = &priv->ec_dev;
2358	int ret;
2359
2360	ec_dev->mkbp_event_supported = 1;
2361	ec_dev->event_data.event_type = EC_MKBP_EVENT_HOST_EVENT;
2362	ec_dev->event_size = sizeof(ec_dev->event_data.data.host_event);
2363	put_unaligned_le32(EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC),
2364			   &ec_dev->event_data.data.host_event);
2365
2366	ret = cros_ec_get_host_event(ec_dev);
2367	KUNIT_EXPECT_EQ(test, ret, EC_HOST_EVENT_MASK(EC_HOST_EVENT_RTC));
2368}
2369
2370static void cros_ec_proto_test_check_features_cached(struct kunit *test)
2371{
2372	int ret, i;
2373	struct cros_ec_dev ec;
2374
2375	ec.features.flags[0] = EC_FEATURE_MASK_0(EC_FEATURE_FINGERPRINT);
2376	ec.features.flags[1] = EC_FEATURE_MASK_0(EC_FEATURE_SCP);
2377
2378	for (i = 0; i < EC_FEATURE_TYPEC_MUX_REQUIRE_AP_ACK; ++i) {
2379		ret = cros_ec_check_features(&ec, i);
2380		switch (i) {
2381		case EC_FEATURE_FINGERPRINT:
2382		case EC_FEATURE_SCP:
2383			KUNIT_EXPECT_TRUE(test, ret);
2384			break;
2385		default:
2386			KUNIT_EXPECT_FALSE(test, ret);
2387			break;
2388		}
2389	}
2390}
2391
2392static void cros_ec_proto_test_check_features_not_cached(struct kunit *test)
2393{
2394	struct cros_ec_proto_test_priv *priv = test->priv;
2395	struct cros_ec_device *ec_dev = &priv->ec_dev;
2396	struct ec_xfer_mock *mock;
2397	int ret, i;
2398	struct cros_ec_dev ec;
2399
2400	ec_dev->max_request = 0xff;
2401	ec_dev->max_response = 0xee;
2402	ec.ec_dev = ec_dev;
2403	ec.dev = ec_dev->dev;
2404	ec.cmd_offset = 0;
2405	ec.features.flags[0] = -1;
2406	ec.features.flags[1] = -1;
2407
2408	/* For EC_CMD_GET_FEATURES. */
2409	{
2410		struct ec_response_get_features *data;
2411
2412		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
2413		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
2414
2415		data = (struct ec_response_get_features *)mock->o_data;
2416		data->flags[0] = EC_FEATURE_MASK_0(EC_FEATURE_FINGERPRINT);
2417		data->flags[1] = EC_FEATURE_MASK_0(EC_FEATURE_SCP);
2418	}
2419
2420	for (i = 0; i < EC_FEATURE_TYPEC_MUX_REQUIRE_AP_ACK; ++i) {
2421		ret = cros_ec_check_features(&ec, i);
2422		switch (i) {
2423		case EC_FEATURE_FINGERPRINT:
2424		case EC_FEATURE_SCP:
2425			KUNIT_EXPECT_TRUE(test, ret);
2426			break;
2427		default:
2428			KUNIT_EXPECT_FALSE(test, ret);
2429			break;
2430		}
2431	}
2432
2433	/* For EC_CMD_GET_FEATURES. */
2434	{
2435		mock = cros_kunit_ec_xfer_mock_next();
2436		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
2437
2438		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
2439		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_FEATURES);
2440		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_get_features));
2441		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
2442	}
2443}
2444
2445static void cros_ec_proto_test_get_sensor_count_normal(struct kunit *test)
2446{
2447	struct cros_ec_proto_test_priv *priv = test->priv;
2448	struct cros_ec_device *ec_dev = &priv->ec_dev;
2449	struct ec_xfer_mock *mock;
2450	int ret;
2451	struct cros_ec_dev ec;
2452
2453	ec_dev->max_request = 0xff;
2454	ec_dev->max_response = 0xee;
2455	ec.ec_dev = ec_dev;
2456	ec.dev = ec_dev->dev;
2457	ec.cmd_offset = 0;
2458
2459	/* For EC_CMD_MOTION_SENSE_CMD. */
2460	{
2461		struct ec_response_motion_sense *data;
2462
2463		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
2464		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
2465
2466		data = (struct ec_response_motion_sense *)mock->o_data;
2467		data->dump.sensor_count = 0xbf;
2468	}
2469
2470	ret = cros_ec_get_sensor_count(&ec);
2471	KUNIT_EXPECT_EQ(test, ret, 0xbf);
2472
2473	/* For EC_CMD_MOTION_SENSE_CMD. */
2474	{
2475		struct ec_params_motion_sense *data;
2476
2477		mock = cros_kunit_ec_xfer_mock_next();
2478		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
2479
2480		KUNIT_EXPECT_EQ(test, mock->msg.version, 1);
2481		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_MOTION_SENSE_CMD);
2482		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_motion_sense));
2483		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
2484
2485		data = (struct ec_params_motion_sense *)mock->i_data;
2486		KUNIT_EXPECT_EQ(test, data->cmd, MOTIONSENSE_CMD_DUMP);
2487	}
2488}
2489
2490static void cros_ec_proto_test_get_sensor_count_xfer_error(struct kunit *test)
2491{
2492	struct cros_ec_proto_test_priv *priv = test->priv;
2493	struct cros_ec_device *ec_dev = &priv->ec_dev;
2494	struct ec_xfer_mock *mock;
2495	int ret;
2496	struct cros_ec_dev ec;
2497
2498	ec_dev->max_request = 0xff;
2499	ec_dev->max_response = 0xee;
2500	ec.ec_dev = ec_dev;
2501	ec.dev = ec_dev->dev;
2502	ec.cmd_offset = 0;
2503
2504	/* For EC_CMD_MOTION_SENSE_CMD. */
2505	{
2506		mock = cros_kunit_ec_xfer_mock_addx(test, -EPROTO, EC_RES_SUCCESS, 0);
2507		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
2508	}
2509
2510	ret = cros_ec_get_sensor_count(&ec);
2511	KUNIT_EXPECT_EQ(test, ret, -EPROTO);
2512
2513	/* For EC_CMD_MOTION_SENSE_CMD. */
2514	{
2515		struct ec_params_motion_sense *data;
2516
2517		mock = cros_kunit_ec_xfer_mock_next();
2518		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
2519
2520		KUNIT_EXPECT_EQ(test, mock->msg.version, 1);
2521		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_MOTION_SENSE_CMD);
2522		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_motion_sense));
2523		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
2524
2525		data = (struct ec_params_motion_sense *)mock->i_data;
2526		KUNIT_EXPECT_EQ(test, data->cmd, MOTIONSENSE_CMD_DUMP);
2527	}
2528}
2529
2530static void cros_ec_proto_test_get_sensor_count_legacy(struct kunit *test)
2531{
2532	struct cros_ec_proto_test_priv *priv = test->priv;
2533	struct cros_ec_device *ec_dev = &priv->ec_dev;
2534	struct ec_xfer_mock *mock;
2535	int ret, i;
2536	struct cros_ec_dev ec;
2537	struct {
2538		u8 readmem_data;
2539		int expected_result;
2540	} test_data[] = {
2541		{ 0, 0 },
2542		{ EC_MEMMAP_ACC_STATUS_PRESENCE_BIT, 2 },
2543	};
2544
2545	ec_dev->max_request = 0xff;
2546	ec_dev->max_response = 0xee;
2547	ec_dev->cmd_readmem = cros_kunit_readmem_mock;
2548	ec.ec_dev = ec_dev;
2549	ec.dev = ec_dev->dev;
2550	ec.cmd_offset = 0;
2551
2552	for (i = 0; i < ARRAY_SIZE(test_data); ++i) {
2553		/* For EC_CMD_MOTION_SENSE_CMD. */
2554		{
2555			mock = cros_kunit_ec_xfer_mock_addx(test, -EPROTO, EC_RES_SUCCESS, 0);
2556			KUNIT_ASSERT_PTR_NE(test, mock, NULL);
2557		}
2558
2559		/* For readmem. */
2560		{
2561			cros_kunit_readmem_mock_data = kunit_kzalloc(test, 1, GFP_KERNEL);
2562			KUNIT_ASSERT_PTR_NE(test, cros_kunit_readmem_mock_data, NULL);
2563			cros_kunit_readmem_mock_data[0] = test_data[i].readmem_data;
2564
2565			cros_kunit_ec_xfer_mock_default_ret = 1;
2566		}
2567
2568		ret = cros_ec_get_sensor_count(&ec);
2569		KUNIT_EXPECT_EQ(test, ret, test_data[i].expected_result);
2570
2571		/* For EC_CMD_MOTION_SENSE_CMD. */
2572		{
2573			struct ec_params_motion_sense *data;
2574
2575			mock = cros_kunit_ec_xfer_mock_next();
2576			KUNIT_EXPECT_PTR_NE(test, mock, NULL);
2577
2578			KUNIT_EXPECT_EQ(test, mock->msg.version, 1);
2579			KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_MOTION_SENSE_CMD);
2580			KUNIT_EXPECT_EQ(test, mock->msg.insize,
2581					sizeof(struct ec_response_motion_sense));
2582			KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
2583
2584			data = (struct ec_params_motion_sense *)mock->i_data;
2585			KUNIT_EXPECT_EQ(test, data->cmd, MOTIONSENSE_CMD_DUMP);
2586		}
2587
2588		/* For readmem. */
2589		{
2590			KUNIT_EXPECT_EQ(test, cros_kunit_readmem_mock_offset, EC_MEMMAP_ACC_STATUS);
2591		}
2592	}
2593}
2594
2595static void cros_ec_proto_test_ec_cmd(struct kunit *test)
2596{
2597	struct cros_ec_proto_test_priv *priv = test->priv;
2598	struct cros_ec_device *ec_dev = &priv->ec_dev;
2599	struct ec_xfer_mock *mock;
2600	int ret;
2601	u8 out[3], in[2];
2602
2603	ec_dev->max_request = 0xff;
2604	ec_dev->max_response = 0xee;
2605
2606	out[0] = 0xdd;
2607	out[1] = 0xcc;
2608	out[2] = 0xbb;
2609
2610	{
2611		u8 *data;
2612
2613		mock = cros_kunit_ec_xfer_mock_add(test, 2);
2614		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
2615
2616		data = (u8 *)mock->o_data;
2617		data[0] = 0xaa;
2618		data[1] = 0x99;
2619	}
2620
2621	ret = cros_ec_cmd(ec_dev, 0x88, 0x77, out, ARRAY_SIZE(out), in, ARRAY_SIZE(in));
2622	KUNIT_EXPECT_EQ(test, ret, 2);
2623
2624	{
2625		u8 *data;
2626
2627		mock = cros_kunit_ec_xfer_mock_next();
2628		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
2629
2630		KUNIT_EXPECT_EQ(test, mock->msg.version, 0x88);
2631		KUNIT_EXPECT_EQ(test, mock->msg.command, 0x77);
2632		KUNIT_EXPECT_EQ(test, mock->msg.insize, ARRAY_SIZE(in));
2633		KUNIT_EXPECT_EQ(test, mock->msg.outsize, ARRAY_SIZE(out));
2634
2635		data = (u8 *)mock->i_data;
2636		KUNIT_EXPECT_EQ(test, data[0], 0xdd);
2637		KUNIT_EXPECT_EQ(test, data[1], 0xcc);
2638		KUNIT_EXPECT_EQ(test, data[2], 0xbb);
2639	}
2640}
2641
2642static void cros_ec_proto_test_release(struct device *dev)
2643{
2644}
2645
2646static int cros_ec_proto_test_init(struct kunit *test)
2647{
2648	struct cros_ec_proto_test_priv *priv;
2649	struct cros_ec_device *ec_dev;
2650
2651	priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
2652	if (!priv)
2653		return -ENOMEM;
2654	test->priv = priv;
2655
2656	ec_dev = &priv->ec_dev;
2657	ec_dev->dout = (u8 *)priv->dout;
2658	ec_dev->dout_size = ARRAY_SIZE(priv->dout);
2659	ec_dev->din = (u8 *)priv->din;
2660	ec_dev->din_size = ARRAY_SIZE(priv->din);
2661	ec_dev->proto_version = EC_HOST_REQUEST_VERSION;
2662	ec_dev->dev = kunit_kzalloc(test, sizeof(*ec_dev->dev), GFP_KERNEL);
2663	if (!ec_dev->dev)
2664		return -ENOMEM;
2665	device_initialize(ec_dev->dev);
2666	dev_set_name(ec_dev->dev, "cros_ec_proto_test");
2667	ec_dev->dev->release = cros_ec_proto_test_release;
2668	ec_dev->cmd_xfer = cros_kunit_ec_xfer_mock;
2669	ec_dev->pkt_xfer = cros_kunit_ec_xfer_mock;
 
2670
2671	priv->msg = (struct cros_ec_command *)priv->_msg;
2672
2673	cros_kunit_mock_reset();
2674
2675	return 0;
2676}
2677
2678static void cros_ec_proto_test_exit(struct kunit *test)
2679{
2680	struct cros_ec_proto_test_priv *priv = test->priv;
2681	struct cros_ec_device *ec_dev = &priv->ec_dev;
2682
2683	put_device(ec_dev->dev);
2684}
2685
2686static struct kunit_case cros_ec_proto_test_cases[] = {
2687	KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_normal),
2688	KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_bad_msg_outsize),
2689	KUNIT_CASE(cros_ec_proto_test_prepare_tx_normal),
2690	KUNIT_CASE(cros_ec_proto_test_prepare_tx_bad_msg_outsize),
2691	KUNIT_CASE(cros_ec_proto_test_check_result),
2692	KUNIT_CASE(cros_ec_proto_test_query_all_normal),
2693	KUNIT_CASE(cros_ec_proto_test_query_all_no_pd_return_error),
2694	KUNIT_CASE(cros_ec_proto_test_query_all_no_pd_return0),
2695	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_normal_v3_return_error),
2696	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_normal_v3_return0),
2697	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_xfer_error),
2698	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return_error),
2699	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_data_error),
2700	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return0),
2701	KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp),
2702	KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp_return_error),
2703	KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp_return0),
2704	KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep),
2705	KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep_return0),
2706	KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error),
2707	KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return0),
2708	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_normal),
2709	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_excess_msg_insize),
2710	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_excess_msg_outsize_without_passthru),
2711	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_excess_msg_outsize_with_passthru),
2712	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v3_normal),
2713	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v3_no_op),
2714	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v2_normal),
2715	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v2_no_op),
2716	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_normal),
2717	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_retries_eagain),
2718	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_retries_status_processing),
2719	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_xfer_error),
2720	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_return_error),
2721	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_return0),
2722	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_status_normal),
2723	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_status_xfer_error),
2724	KUNIT_CASE(cros_ec_proto_test_cmd_xfer_status_return_error),
2725	KUNIT_CASE(cros_ec_proto_test_get_next_event_no_mkbp_event),
2726	KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_ec_suspended),
2727	KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_version0),
2728	KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_version2),
2729	KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_host_event_rtc),
2730	KUNIT_CASE(cros_ec_proto_test_get_next_event_mkbp_event_host_event_masked),
2731	KUNIT_CASE(cros_ec_proto_test_get_host_event_no_mkbp_event),
2732	KUNIT_CASE(cros_ec_proto_test_get_host_event_not_host_event),
2733	KUNIT_CASE(cros_ec_proto_test_get_host_event_wrong_event_size),
2734	KUNIT_CASE(cros_ec_proto_test_get_host_event_normal),
2735	KUNIT_CASE(cros_ec_proto_test_check_features_cached),
2736	KUNIT_CASE(cros_ec_proto_test_check_features_not_cached),
2737	KUNIT_CASE(cros_ec_proto_test_get_sensor_count_normal),
2738	KUNIT_CASE(cros_ec_proto_test_get_sensor_count_xfer_error),
2739	KUNIT_CASE(cros_ec_proto_test_get_sensor_count_legacy),
2740	KUNIT_CASE(cros_ec_proto_test_ec_cmd),
2741	{}
2742};
2743
2744static struct kunit_suite cros_ec_proto_test_suite = {
2745	.name = "cros_ec_proto_test",
2746	.init = cros_ec_proto_test_init,
2747	.exit = cros_ec_proto_test_exit,
2748	.test_cases = cros_ec_proto_test_cases,
2749};
2750
2751kunit_test_suite(cros_ec_proto_test_suite);
2752
2753MODULE_LICENSE("GPL");