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