History

platform/chrome: cros_ec_proto: add Kunit tests for cros_ec_query_all()

cros_ec_query_all() sends multiple host commands to EC for querying supported protocols and settings. Add required mock for interacting with cros_ec_query_all() and Kunit tests.

Tzung-Bi Shih committed 4 years ago

Commit b99eb591 parent ea7f0f75 files · +943 −0Browse files

Unified · Split

5 files
  1. drivers/platform/chrome/Kconfig +6 −0
  2. drivers/platform/chrome/Makefile +1 −0
  3. drivers/platform/chrome/cros_ec_proto_test.c +802 −0
  4. drivers/platform/chrome/cros_kunit_util.c +98 −0
  5. drivers/platform/chrome/cros_kunit_util.h +36 −0
drivers/platform/chrome/Kconfig+6−0
@@ -268,11 +268,17 @@ config CHROMEOS_PRIVACY_SCREEN · 267 unmodified lines
268source "drivers/platform/chrome/wilco_ec/Kconfig"268source "drivers/platform/chrome/wilco_ec/Kconfig"
269 269
270# Kunit test cases270# Kunit test cases
271config CROS_KUNIT
272 tristate
273 help
274 ChromeOS Kunit.
275
271config CROS_EC_PROTO_KUNIT_TEST276config CROS_EC_PROTO_KUNIT_TEST
272 tristate "Kunit tests for ChromeOS EC protocol" if !KUNIT_ALL_TESTS277 tristate "Kunit tests for ChromeOS EC protocol" if !KUNIT_ALL_TESTS
273 depends on KUNIT && CROS_EC278 depends on KUNIT && CROS_EC
274 default KUNIT_ALL_TESTS279 default KUNIT_ALL_TESTS
275 select CROS_EC_PROTO280 select CROS_EC_PROTO
281 select CROS_KUNIT
276 help282 help
277 Kunit tests for the ChromeOS Embedded Controller protocol.283 Kunit tests for the ChromeOS Embedded Controller protocol.
278 284
drivers/platform/chrome/Makefile+1−0
@@ -32,4 +32,5 @@ obj-$(CONFIG_CROS_USBPD_NOTIFY) += cros_usbpd_notify.o · 31 unmodified lines
32obj-$(CONFIG_WILCO_EC) += wilco_ec/32obj-$(CONFIG_WILCO_EC) += wilco_ec/
33 33
34# Kunit test cases34# Kunit test cases
35obj-$(CONFIG_CROS_KUNIT) += cros_kunit_util.o
35obj-$(CONFIG_CROS_EC_PROTO_KUNIT_TEST) += cros_ec_proto_test.o36obj-$(CONFIG_CROS_EC_PROTO_KUNIT_TEST) += cros_ec_proto_test.o
drivers/platform/chrome/cros_ec_proto_test.c+802−0
@@ -9,6 +9,7 @@ · 8 unmodified lines
9#include <linux/platform_data/cros_ec_proto.h>9#include <linux/platform_data/cros_ec_proto.h>
10 10
11#include "cros_ec.h"11#include "cros_ec.h"
12#include "cros_kunit_util.h"
12 13
13#define BUFSIZE 51214#define BUFSIZE 512
14 15
@@ -172,6 +173,779 @@ static void cros_ec_proto_test_check_result(struct kunit *test) · 157 unmodified lines
172 KUNIT_EXPECT_EQ(test, ret, -EAGAIN);173 KUNIT_EXPECT_EQ(test, ret, -EAGAIN);
173}174}
174 175
176static void cros_ec_proto_test_query_all_pretest(struct kunit *test)
177{
178 struct cros_ec_proto_test_priv *priv = test->priv;
179 struct cros_ec_device *ec_dev = &priv->ec_dev;
180
181 /*
182 * cros_ec_query_all() will free din and dout and allocate them again to fit the usage by
183 * calling devm_kfree() and devm_kzalloc(). Set them to NULL as they aren't managed by
184 * ec_dev->dev but allocated statically in struct cros_ec_proto_test_priv
185 * (see cros_ec_proto_test_init()).
186 */
187 ec_dev->din = NULL;
188 ec_dev->dout = NULL;
189}
190
191static void cros_ec_proto_test_query_all_normal(struct kunit *test)
192{
193 struct cros_ec_proto_test_priv *priv = test->priv;
194 struct cros_ec_device *ec_dev = &priv->ec_dev;
195 struct ec_xfer_mock *mock;
196 int ret;
197
198 /* For cros_ec_host_command_proto_query() without passthru. */
199 {
200 struct ec_response_get_protocol_info *data;
201
202 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
203 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
204
205 data = (struct ec_response_get_protocol_info *)mock->o_data;
206 data->protocol_versions = BIT(3) | BIT(2);
207 data->max_request_packet_size = 0xbe;
208 data->max_response_packet_size = 0xef;
209 }
210
211 /* For cros_ec_host_command_proto_query() with passthru. */
212 {
213 struct ec_response_get_protocol_info *data;
214
215 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
216 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
217
218 data = (struct ec_response_get_protocol_info *)mock->o_data;
219 data->max_request_packet_size = 0xbf;
220 }
221
222 /* For cros_ec_get_host_command_version_mask() for MKBP. */
223 {
224 struct ec_response_get_cmd_versions *data;
225
226 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
227 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
228
229 data = (struct ec_response_get_cmd_versions *)mock->o_data;
230 data->version_mask = BIT(6) | BIT(5);
231 }
232
233 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
234 {
235 struct ec_response_get_cmd_versions *data;
236
237 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
238 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
239
240 data = (struct ec_response_get_cmd_versions *)mock->o_data;
241 data->version_mask = BIT(1);
242 }
243
244 /* For cros_ec_get_host_event_wake_mask(). */
245 {
246 struct ec_response_host_event_mask *data;
247
248 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
249 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
250
251 data = (struct ec_response_host_event_mask *)mock->o_data;
252 data->mask = 0xbeef;
253 }
254
255 cros_ec_proto_test_query_all_pretest(test);
256 ret = cros_ec_query_all(ec_dev);
257 KUNIT_EXPECT_EQ(test, ret, 0);
258
259 /* For cros_ec_host_command_proto_query() without passthru. */
260 {
261 mock = cros_kunit_ec_xfer_mock_next();
262 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
263
264 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
265 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
266 KUNIT_EXPECT_EQ(test, mock->msg.insize,
267 sizeof(struct ec_response_get_protocol_info));
268 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
269
270 KUNIT_EXPECT_EQ(test, ec_dev->max_request, 0xbe - sizeof(struct ec_host_request));
271 KUNIT_EXPECT_EQ(test, ec_dev->max_response, 0xef - sizeof(struct ec_host_response));
272 KUNIT_EXPECT_EQ(test, ec_dev->proto_version, 3);
273 KUNIT_EXPECT_EQ(test, ec_dev->din_size, 0xef + EC_MAX_RESPONSE_OVERHEAD);
274 KUNIT_EXPECT_EQ(test, ec_dev->dout_size, 0xbe + EC_MAX_REQUEST_OVERHEAD);
275 }
276
277 /* For cros_ec_host_command_proto_query() with passthru. */
278 {
279 mock = cros_kunit_ec_xfer_mock_next();
280 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
281
282 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
283 KUNIT_EXPECT_EQ(test, mock->msg.command,
284 EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
285 KUNIT_EXPECT_EQ(test, mock->msg.insize,
286 sizeof(struct ec_response_get_protocol_info));
287 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
288
289 KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0xbf - sizeof(struct ec_host_request));
290 }
291
292 /* For cros_ec_get_host_command_version_mask() for MKBP. */
293 {
294 struct ec_params_get_cmd_versions *data;
295
296 mock = cros_kunit_ec_xfer_mock_next();
297 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
298
299 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
300 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
301 KUNIT_EXPECT_EQ(test, mock->msg.insize,
302 sizeof(struct ec_response_get_cmd_versions));
303 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
304
305 data = (struct ec_params_get_cmd_versions *)mock->i_data;
306 KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT);
307
308 KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 7);
309 }
310
311 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
312 {
313 struct ec_params_get_cmd_versions *data;
314
315 mock = cros_kunit_ec_xfer_mock_next();
316 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
317
318 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
319 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
320 KUNIT_EXPECT_EQ(test, mock->msg.insize,
321 sizeof(struct ec_response_get_cmd_versions));
322 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
323
324 data = (struct ec_params_get_cmd_versions *)mock->i_data;
325 KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_HOST_SLEEP_EVENT);
326
327 KUNIT_EXPECT_TRUE(test, ec_dev->host_sleep_v1);
328 }
329
330 /* For cros_ec_get_host_event_wake_mask(). */
331 {
332 mock = cros_kunit_ec_xfer_mock_next();
333 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
334
335 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
336 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HOST_EVENT_GET_WAKE_MASK);
337 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_host_event_mask));
338 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
339
340 KUNIT_EXPECT_EQ(test, ec_dev->host_event_wake_mask, 0xbeef);
341 }
342}
343
344static void cros_ec_proto_test_query_all_no_pd_return_error(struct kunit *test)
345{
346 struct cros_ec_proto_test_priv *priv = test->priv;
347 struct cros_ec_device *ec_dev = &priv->ec_dev;
348 struct ec_xfer_mock *mock;
349 int ret;
350
351 /* Set some garbage bytes. */
352 ec_dev->max_passthru = 0xbf;
353
354 /* For cros_ec_host_command_proto_query() without passthru. */
355 {
356 struct ec_response_get_protocol_info *data;
357
358 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
359 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
360
361 /*
362 * Although it doesn't check the value, provides valid sizes so that
363 * cros_ec_query_all() allocates din and dout correctly.
364 */
365 data = (struct ec_response_get_protocol_info *)mock->o_data;
366 data->max_request_packet_size = 0xbe;
367 data->max_response_packet_size = 0xef;
368 }
369
370 /* For cros_ec_host_command_proto_query() with passthru. */
371 {
372 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
373 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
374 }
375
376 cros_ec_proto_test_query_all_pretest(test);
377 ret = cros_ec_query_all(ec_dev);
378 KUNIT_EXPECT_EQ(test, ret, 0);
379
380 /* For cros_ec_host_command_proto_query() without passthru. */
381 {
382 mock = cros_kunit_ec_xfer_mock_next();
383 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
384
385 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
386 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
387 KUNIT_EXPECT_EQ(test, mock->msg.insize,
388 sizeof(struct ec_response_get_protocol_info));
389 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
390 }
391
392 /* For cros_ec_host_command_proto_query() with passthru. */
393 {
394 mock = cros_kunit_ec_xfer_mock_next();
395 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
396
397 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
398 KUNIT_EXPECT_EQ(test, mock->msg.command,
399 EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
400 KUNIT_EXPECT_EQ(test, mock->msg.insize,
401 sizeof(struct ec_response_get_protocol_info));
402 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
403
404 KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0);
405 }
406}
407
408static void cros_ec_proto_test_query_all_legacy_normal_v3_return_error(struct kunit *test)
409{
410 struct cros_ec_proto_test_priv *priv = test->priv;
411 struct cros_ec_device *ec_dev = &priv->ec_dev;
412 struct ec_xfer_mock *mock;
413 int ret;
414
415 /* For cros_ec_host_command_proto_query() without passthru. */
416 {
417 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
418 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
419 }
420
421 /* For cros_ec_host_command_proto_query_v2(). */
422 {
423 struct ec_response_hello *data;
424
425 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
426 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
427
428 data = (struct ec_response_hello *)mock->o_data;
429 data->out_data = 0xa1b2c3d4;
430 }
431
432 cros_ec_proto_test_query_all_pretest(test);
433 ret = cros_ec_query_all(ec_dev);
434 KUNIT_EXPECT_EQ(test, ret, 0);
435
436 /* For cros_ec_host_command_proto_query() without passthru. */
437 {
438 mock = cros_kunit_ec_xfer_mock_next();
439 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
440
441 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
442 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
443 KUNIT_EXPECT_EQ(test, mock->msg.insize,
444 sizeof(struct ec_response_get_protocol_info));
445 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
446 }
447
448 /* For cros_ec_host_command_proto_query_v2(). */
449 {
450 struct ec_params_hello *data;
451
452 mock = cros_kunit_ec_xfer_mock_next();
453 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
454
455 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
456 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
457 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
458 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
459
460 data = (struct ec_params_hello *)mock->i_data;
461 KUNIT_EXPECT_EQ(test, data->in_data, 0xa0b0c0d0);
462
463 KUNIT_EXPECT_EQ(test, ec_dev->proto_version, 2);
464 KUNIT_EXPECT_EQ(test, ec_dev->max_request, EC_PROTO2_MAX_PARAM_SIZE);
465 KUNIT_EXPECT_EQ(test, ec_dev->max_response, EC_PROTO2_MAX_PARAM_SIZE);
466 KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0);
467 KUNIT_EXPECT_PTR_EQ(test, ec_dev->pkt_xfer, NULL);
468 KUNIT_EXPECT_EQ(test, ec_dev->din_size, EC_PROTO2_MSG_BYTES);
469 KUNIT_EXPECT_EQ(test, ec_dev->dout_size, EC_PROTO2_MSG_BYTES);
470 }
471}
472
473static void cros_ec_proto_test_query_all_legacy_xfer_error(struct kunit *test)
474{
475 struct cros_ec_proto_test_priv *priv = test->priv;
476 struct cros_ec_device *ec_dev = &priv->ec_dev;
477 struct ec_xfer_mock *mock;
478 int ret;
479
480 /* For cros_ec_host_command_proto_query() without passthru. */
481 {
482 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
483 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
484 }
485
486 /* For cros_ec_host_command_proto_query_v2(). */
487 {
488 mock = cros_kunit_ec_xfer_mock_addx(test, -EIO, EC_RES_SUCCESS, 0);
489 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
490 }
491
492 cros_ec_proto_test_query_all_pretest(test);
493 ret = cros_ec_query_all(ec_dev);
494 KUNIT_EXPECT_EQ(test, ret, -EIO);
495 KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
496
497 /* For cros_ec_host_command_proto_query() without passthru. */
498 {
499 mock = cros_kunit_ec_xfer_mock_next();
500 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
501
502 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
503 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
504 KUNIT_EXPECT_EQ(test, mock->msg.insize,
505 sizeof(struct ec_response_get_protocol_info));
506 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
507 }
508
509 /* For cros_ec_host_command_proto_query_v2(). */
510 {
511 mock = cros_kunit_ec_xfer_mock_next();
512 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
513
514 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
515 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
516 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
517 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello));
518 }
519}
520
521static void cros_ec_proto_test_query_all_legacy_return_error(struct kunit *test)
522{
523 struct cros_ec_proto_test_priv *priv = test->priv;
524 struct cros_ec_device *ec_dev = &priv->ec_dev;
525 struct ec_xfer_mock *mock;
526 int ret;
527
528 /* For cros_ec_host_command_proto_query() without passthru. */
529 {
530 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
531 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
532 }
533
534 /* For cros_ec_host_command_proto_query_v2(). */
535 {
536 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
537 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
538 }
539
540 cros_ec_proto_test_query_all_pretest(test);
541 ret = cros_ec_query_all(ec_dev);
542 KUNIT_EXPECT_EQ(test, ret, EC_RES_INVALID_COMMAND);
543 KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
544
545 /* For cros_ec_host_command_proto_query() without passthru. */
546 {
547 mock = cros_kunit_ec_xfer_mock_next();
548 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
549
550 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
551 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
552 KUNIT_EXPECT_EQ(test, mock->msg.insize,
553 sizeof(struct ec_response_get_protocol_info));
554 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
555 }
556
557 /* For cros_ec_host_command_proto_query_v2(). */
558 {
559 mock = cros_kunit_ec_xfer_mock_next();
560 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
561
562 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
563 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
564 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
565 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello));
566 }
567}
568
569static void cros_ec_proto_test_query_all_legacy_data_error(struct kunit *test)
570{
571 struct cros_ec_proto_test_priv *priv = test->priv;
572 struct cros_ec_device *ec_dev = &priv->ec_dev;
573 struct ec_xfer_mock *mock;
574 int ret;
575
576 /* For cros_ec_host_command_proto_query() without passthru. */
577 {
578 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
579 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
580 }
581
582 /* For cros_ec_host_command_proto_query_v2(). */
583 {
584 struct ec_response_hello *data;
585
586 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
587 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
588
589 data = (struct ec_response_hello *)mock->o_data;
590 data->out_data = 0xbeefbfbf;
591 }
592
593 cros_ec_proto_test_query_all_pretest(test);
594 ret = cros_ec_query_all(ec_dev);
595 KUNIT_EXPECT_EQ(test, ret, -EBADMSG);
596 KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
597
598 /* For cros_ec_host_command_proto_query() without passthru. */
599 {
600 mock = cros_kunit_ec_xfer_mock_next();
601 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
602
603 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
604 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
605 KUNIT_EXPECT_EQ(test, mock->msg.insize,
606 sizeof(struct ec_response_get_protocol_info));
607 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
608 }
609
610 /* For cros_ec_host_command_proto_query_v2(). */
611 {
612 mock = cros_kunit_ec_xfer_mock_next();
613 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
614
615 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
616 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
617 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
618 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello));
619 }
620}
621
622static void cros_ec_proto_test_query_all_no_mkbp(struct kunit *test)
623{
624 struct cros_ec_proto_test_priv *priv = test->priv;
625 struct cros_ec_device *ec_dev = &priv->ec_dev;
626 struct ec_xfer_mock *mock;
627 int ret;
628
629 /* Set some garbage bytes. */
630 ec_dev->mkbp_event_supported = 0xbf;
631
632 /* For cros_ec_host_command_proto_query() without passthru. */
633 {
634 struct ec_response_get_protocol_info *data;
635
636 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
637 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
638
639 /*
640 * Although it doesn't check the value, provides valid sizes so that
641 * cros_ec_query_all() allocates din and dout correctly.
642 */
643 data = (struct ec_response_get_protocol_info *)mock->o_data;
644 data->max_request_packet_size = 0xbe;
645 data->max_response_packet_size = 0xef;
646 }
647
648 /* For cros_ec_host_command_proto_query() with passthru. */
649 {
650 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
651 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
652 }
653
654 /* For cros_ec_get_host_command_version_mask() for MKBP. */
655 {
656 struct ec_response_get_cmd_versions *data;
657
658 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
659 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
660
661 data = (struct ec_response_get_cmd_versions *)mock->o_data;
662 data->version_mask = 0;
663 }
664
665 cros_ec_proto_test_query_all_pretest(test);
666 ret = cros_ec_query_all(ec_dev);
667 KUNIT_EXPECT_EQ(test, ret, 0);
668
669 /* For cros_ec_host_command_proto_query() without passthru. */
670 {
671 mock = cros_kunit_ec_xfer_mock_next();
672 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
673
674 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
675 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
676 KUNIT_EXPECT_EQ(test, mock->msg.insize,
677 sizeof(struct ec_response_get_protocol_info));
678 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
679 }
680
681 /* For cros_ec_host_command_proto_query() with passthru. */
682 {
683 mock = cros_kunit_ec_xfer_mock_next();
684 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
685
686 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
687 KUNIT_EXPECT_EQ(test, mock->msg.command,
688 EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
689 KUNIT_EXPECT_EQ(test, mock->msg.insize,
690 sizeof(struct ec_response_get_protocol_info));
691 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
692 }
693
694 /* For cros_ec_get_host_command_version_mask() for MKBP. */
695 {
696 struct ec_params_get_cmd_versions *data;
697
698 mock = cros_kunit_ec_xfer_mock_next();
699 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
700
701 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
702 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
703 KUNIT_EXPECT_EQ(test, mock->msg.insize,
704 sizeof(struct ec_response_get_cmd_versions));
705 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
706
707 data = (struct ec_params_get_cmd_versions *)mock->i_data;
708 KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT);
709
710 KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 0);
711 }
712}
713
714static void cros_ec_proto_test_query_all_no_host_sleep(struct kunit *test)
715{
716 struct cros_ec_proto_test_priv *priv = test->priv;
717 struct cros_ec_device *ec_dev = &priv->ec_dev;
718 struct ec_xfer_mock *mock;
719 int ret;
720
721 /* Set some garbage bytes. */
722 ec_dev->host_sleep_v1 = true;
723
724 /* For cros_ec_host_command_proto_query() without passthru. */
725 {
726 struct ec_response_get_protocol_info *data;
727
728 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
729 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
730
731 /*
732 * Although it doesn't check the value, provides valid sizes so that
733 * cros_ec_query_all() allocates din and dout correctly.
734 */
735 data = (struct ec_response_get_protocol_info *)mock->o_data;
736 data->max_request_packet_size = 0xbe;
737 data->max_response_packet_size = 0xef;
738 }
739
740 /* For cros_ec_host_command_proto_query() with passthru. */
741 {
742 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
743 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
744 }
745
746 /* For cros_ec_get_host_command_version_mask() for MKBP. */
747 {
748 mock = cros_kunit_ec_xfer_mock_add(test, 0);
749 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
750 }
751
752 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
753 {
754 struct ec_response_get_cmd_versions *data;
755
756 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
757 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
758
759 data = (struct ec_response_get_cmd_versions *)mock->o_data;
760 data->version_mask = 0;
761 }
762
763 cros_ec_proto_test_query_all_pretest(test);
764 ret = cros_ec_query_all(ec_dev);
765 KUNIT_EXPECT_EQ(test, ret, 0);
766
767 /* For cros_ec_host_command_proto_query() without passthru. */
768 {
769 mock = cros_kunit_ec_xfer_mock_next();
770 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
771
772 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
773 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
774 KUNIT_EXPECT_EQ(test, mock->msg.insize,
775 sizeof(struct ec_response_get_protocol_info));
776 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
777 }
778
779 /* For cros_ec_host_command_proto_query() with passthru. */
780 {
781 mock = cros_kunit_ec_xfer_mock_next();
782 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
783
784 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
785 KUNIT_EXPECT_EQ(test, mock->msg.command,
786 EC_CMD_PASSTHRU_OFFSET(1) | 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_host_command_version_mask() for MKBP. */
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_GET_CMD_VERSIONS);
799 KUNIT_EXPECT_EQ(test, mock->msg.insize,
800 sizeof(struct ec_response_get_cmd_versions));
801 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
802 }
803
804 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
805 {
806 mock = cros_kunit_ec_xfer_mock_next();
807 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
808
809 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
810 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
811 KUNIT_EXPECT_EQ(test, mock->msg.insize,
812 sizeof(struct ec_response_get_cmd_versions));
813 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
814
815 KUNIT_EXPECT_FALSE(test, ec_dev->host_sleep_v1);
816 }
817}
818
819static void cros_ec_proto_test_query_all_default_wake_mask_return_error(struct kunit *test)
820{
821 struct cros_ec_proto_test_priv *priv = test->priv;
822 struct cros_ec_device *ec_dev = &priv->ec_dev;
823 struct ec_xfer_mock *mock;
824 int ret;
825
826 /* Set some garbage bytes. */
827 ec_dev->host_event_wake_mask = U32_MAX;
828
829 /* For cros_ec_host_command_proto_query() without passthru. */
830 {
831 struct ec_response_get_protocol_info *data;
832
833 mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
834 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
835
836 /*
837 * Although it doesn't check the value, provides valid sizes so that
838 * cros_ec_query_all() allocates din and dout correctly.
839 */
840 data = (struct ec_response_get_protocol_info *)mock->o_data;
841 data->max_request_packet_size = 0xbe;
842 data->max_response_packet_size = 0xef;
843 }
844
845 /* For cros_ec_host_command_proto_query() with passthru. */
846 {
847 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
848 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
849 }
850
851 /* For cros_ec_get_host_command_version_mask() for MKBP. */
852 {
853 mock = cros_kunit_ec_xfer_mock_add(test, 0);
854 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
855 }
856
857 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
858 {
859 mock = cros_kunit_ec_xfer_mock_add(test, 0);
860 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
861 }
862
863 /* For cros_ec_get_host_event_wake_mask(). */
864 {
865 mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
866 KUNIT_ASSERT_PTR_NE(test, mock, NULL);
867 }
868
869 cros_ec_proto_test_query_all_pretest(test);
870 ret = cros_ec_query_all(ec_dev);
871 KUNIT_EXPECT_EQ(test, ret, 0);
872
873 /* For cros_ec_host_command_proto_query() without passthru. */
874 {
875 mock = cros_kunit_ec_xfer_mock_next();
876 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
877
878 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
879 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
880 KUNIT_EXPECT_EQ(test, mock->msg.insize,
881 sizeof(struct ec_response_get_protocol_info));
882 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
883 }
884
885 /* For cros_ec_host_command_proto_query() with passthru. */
886 {
887 mock = cros_kunit_ec_xfer_mock_next();
888 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
889
890 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
891 KUNIT_EXPECT_EQ(test, mock->msg.command,
892 EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
893 KUNIT_EXPECT_EQ(test, mock->msg.insize,
894 sizeof(struct ec_response_get_protocol_info));
895 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
896 }
897
898 /* For cros_ec_get_host_command_version_mask() for MKBP. */
899 {
900 mock = cros_kunit_ec_xfer_mock_next();
901 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
902
903 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
904 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
905 KUNIT_EXPECT_EQ(test, mock->msg.insize,
906 sizeof(struct ec_response_get_cmd_versions));
907 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
908 }
909
910 /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
911 {
912 mock = cros_kunit_ec_xfer_mock_next();
913 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
914
915 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
916 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
917 KUNIT_EXPECT_EQ(test, mock->msg.insize,
918 sizeof(struct ec_response_get_cmd_versions));
919 KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
920 }
921
922 /* For cros_ec_get_host_event_wake_mask(). */
923 {
924 u32 mask;
925
926 mock = cros_kunit_ec_xfer_mock_next();
927 KUNIT_EXPECT_PTR_NE(test, mock, NULL);
928
929 KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
930 KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HOST_EVENT_GET_WAKE_MASK);
931 KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_host_event_mask));
932 KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
933
934 mask = ec_dev->host_event_wake_mask;
935 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_CLOSED), 0);
936 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED), 0);
937 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_LOW), 0);
938 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_CRITICAL), 0);
939 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY), 0);
940 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_PD_MCU), 0);
941 KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_STATUS), 0);
942 }
943}
944
945static void cros_ec_proto_test_release(struct device *dev)
946{
947}
948
175static int cros_ec_proto_test_init(struct kunit *test)949static int cros_ec_proto_test_init(struct kunit *test)
176{950{
177 struct cros_ec_proto_test_priv *priv;951 struct cros_ec_proto_test_priv *priv;
@@ -188,24 +962,52 @@ static int cros_ec_proto_test_init(struct kunit *test) · 10 unmodified lines
188 ec_dev->din = (u8 *)priv->din;962 ec_dev->din = (u8 *)priv->din;
189 ec_dev->din_size = ARRAY_SIZE(priv->din);963 ec_dev->din_size = ARRAY_SIZE(priv->din);
190 ec_dev->proto_version = EC_HOST_REQUEST_VERSION;964 ec_dev->proto_version = EC_HOST_REQUEST_VERSION;
965 ec_dev->dev = kunit_kzalloc(test, sizeof(*ec_dev->dev), GFP_KERNEL);
966 if (!ec_dev->dev)
967 return -ENOMEM;
968 device_initialize(ec_dev->dev);
969 dev_set_name(ec_dev->dev, "cros_ec_proto_test");
970 ec_dev->dev->release = cros_ec_proto_test_release;
971 ec_dev->cmd_xfer = cros_kunit_ec_xfer_mock;
972 ec_dev->pkt_xfer = cros_kunit_ec_xfer_mock;
191 973
192 priv->msg = (struct cros_ec_command *)priv->_msg;974 priv->msg = (struct cros_ec_command *)priv->_msg;
193 975
976 cros_kunit_mock_reset();
977
194 return 0;978 return 0;
195}979}
196 980
981static void cros_ec_proto_test_exit(struct kunit *test)
982{
983 struct cros_ec_proto_test_priv *priv = test->priv;
984 struct cros_ec_device *ec_dev = &priv->ec_dev;
985
986 put_device(ec_dev->dev);
987}
988
197static struct kunit_case cros_ec_proto_test_cases[] = {989static struct kunit_case cros_ec_proto_test_cases[] = {
198 KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_normal),990 KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_normal),
199 KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_bad_msg_outsize),991 KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_bad_msg_outsize),
200 KUNIT_CASE(cros_ec_proto_test_prepare_tx_normal),992 KUNIT_CASE(cros_ec_proto_test_prepare_tx_normal),
201 KUNIT_CASE(cros_ec_proto_test_prepare_tx_bad_msg_outsize),993 KUNIT_CASE(cros_ec_proto_test_prepare_tx_bad_msg_outsize),
202 KUNIT_CASE(cros_ec_proto_test_check_result),994 KUNIT_CASE(cros_ec_proto_test_check_result),
995 KUNIT_CASE(cros_ec_proto_test_query_all_normal),
996 KUNIT_CASE(cros_ec_proto_test_query_all_no_pd_return_error),
997 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_normal_v3_return_error),
998 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_xfer_error),
999 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return_error),
1000 KUNIT_CASE(cros_ec_proto_test_query_all_legacy_data_error),
1001 KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp),
1002 KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep),
1003 KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error),
203 {}1004 {}
204};1005};
205 1006
206static struct kunit_suite cros_ec_proto_test_suite = {1007static struct kunit_suite cros_ec_proto_test_suite = {
207 .name = "cros_ec_proto_test",1008 .name = "cros_ec_proto_test",
208 .init = cros_ec_proto_test_init,1009 .init = cros_ec_proto_test_init,
1010 .exit = cros_ec_proto_test_exit,
209 .test_cases = cros_ec_proto_test_cases,1011 .test_cases = cros_ec_proto_test_cases,
210};1012};
211 1013
drivers/platform/chrome/cros_kunit_util.c+98−0
@@ -0,0 +1,98 @@
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * CrOS Kunit tests utilities.
4 */
5
6#include <kunit/test.h>
7
8#include <linux/list.h>
9#include <linux/minmax.h>
10#include <linux/platform_data/cros_ec_commands.h>
11#include <linux/platform_data/cros_ec_proto.h>
12
13#include "cros_ec.h"
14#include "cros_kunit_util.h"
15
16int cros_kunit_ec_xfer_mock_default_ret;
17EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_default_ret);
18
19static struct list_head cros_kunit_ec_xfer_mock_in;
20static struct list_head cros_kunit_ec_xfer_mock_out;
21
22int cros_kunit_ec_xfer_mock(struct cros_ec_device *ec_dev, struct cros_ec_command *msg)
23{
24 struct ec_xfer_mock *mock;
25
26 mock = list_first_entry_or_null(&cros_kunit_ec_xfer_mock_in, struct ec_xfer_mock, list);
27 if (!mock)
28 return cros_kunit_ec_xfer_mock_default_ret;
29
30 list_del(&mock->list);
31
32 memcpy(&mock->msg, msg, sizeof(*msg));
33 if (msg->outsize) {
34 mock->i_data = kunit_kzalloc(mock->test, msg->outsize, GFP_KERNEL);
35 if (mock->i_data)
36 memcpy(mock->i_data, msg->data, msg->outsize);
37 }
38
39 msg->result = mock->result;
40 if (msg->insize)
41 memcpy(msg->data, mock->o_data, min(msg->insize, mock->o_data_len));
42
43 list_add_tail(&mock->list, &cros_kunit_ec_xfer_mock_out);
44
45 return mock->ret;
46}
47EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock);
48
49struct ec_xfer_mock *cros_kunit_ec_xfer_mock_add(struct kunit *test, size_t size)
50{
51 return cros_kunit_ec_xfer_mock_addx(test, size, EC_RES_SUCCESS, size);
52}
53EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_add);
54
55struct ec_xfer_mock *cros_kunit_ec_xfer_mock_addx(struct kunit *test,
56 int ret, int result, size_t size)
57{
58 struct ec_xfer_mock *mock;
59
60 mock = kunit_kzalloc(test, sizeof(*mock), GFP_KERNEL);
61 if (!mock)
62 return NULL;
63
64 list_add_tail(&mock->list, &cros_kunit_ec_xfer_mock_in);
65 mock->test = test;
66
67 mock->ret = ret;
68 mock->result = result;
69 mock->o_data = kunit_kzalloc(test, size, GFP_KERNEL);
70 if (!mock->o_data)
71 return NULL;
72 mock->o_data_len = size;
73
74 return mock;
75}
76EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_addx);
77
78struct ec_xfer_mock *cros_kunit_ec_xfer_mock_next(void)
79{
80 struct ec_xfer_mock *mock;
81
82 mock = list_first_entry_or_null(&cros_kunit_ec_xfer_mock_out, struct ec_xfer_mock, list);
83 if (mock)
84 list_del(&mock->list);
85
86 return mock;
87}
88EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_next);
89
90void cros_kunit_mock_reset(void)
91{
92 cros_kunit_ec_xfer_mock_default_ret = 0;
93 INIT_LIST_HEAD(&cros_kunit_ec_xfer_mock_in);
94 INIT_LIST_HEAD(&cros_kunit_ec_xfer_mock_out);
95}
96EXPORT_SYMBOL_GPL(cros_kunit_mock_reset);
97
98MODULE_LICENSE("GPL");
drivers/platform/chrome/cros_kunit_util.h+36−0
@@ -0,0 +1,36 @@
1/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * CrOS Kunit tests utilities.
4 */
5
6#ifndef _CROS_KUNIT_UTIL_H_
7#define _CROS_KUNIT_UTIL_H_
8
9#include <linux/platform_data/cros_ec_proto.h>
10
11struct ec_xfer_mock {
12 struct list_head list;
13 struct kunit *test;
14
15 /* input */
16 struct cros_ec_command msg;
17 void *i_data;
18
19 /* output */
20 int ret;
21 int result;
22 void *o_data;
23 u32 o_data_len;
24};
25
26extern int cros_kunit_ec_xfer_mock_default_ret;
27
28int cros_kunit_ec_xfer_mock(struct cros_ec_device *ec_dev, struct cros_ec_command *msg);
29struct ec_xfer_mock *cros_kunit_ec_xfer_mock_add(struct kunit *test, size_t size);
30struct ec_xfer_mock *cros_kunit_ec_xfer_mock_addx(struct kunit *test,
31 int ret, int result, size_t size);
32struct ec_xfer_mock *cros_kunit_ec_xfer_mock_next(void);
33
34void cros_kunit_mock_reset(void);
35
36#endif