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