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