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
268268 source "drivers/platform/chrome/wilco_ec/Kconfig"
269269
270270 # Kunit test cases
271+config CROS_KUNIT
272+ tristate
273+ help
274+ ChromeOS Kunit.
275+
271276 config CROS_EC_PROTO_KUNIT_TEST
272277 tristate "Kunit tests for ChromeOS EC protocol" if !KUNIT_ALL_TESTS
273278 depends on KUNIT && CROS_EC
274279 default KUNIT_ALL_TESTS
275280 select CROS_EC_PROTO
281+ select CROS_KUNIT
276282 help
277283 Kunit tests for the ChromeOS Embedded Controller protocol.
278284
drivers/platform/chrome/Makefile+1−0
@@ -32,4 +32,5 @@ obj-$(CONFIG_CROS_USBPD_NOTIFY) += cros_usbpd_notify.o · 31 unmodified lines
3232 obj-$(CONFIG_WILCO_EC) += wilco_ec/
3333
3434 # Kunit test cases
35+obj-$(CONFIG_CROS_KUNIT) += cros_kunit_util.o
3536 obj-$(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
99 #include <linux/platform_data/cros_ec_proto.h>
1010
1111 #include "cros_ec.h"
12+#include "cros_kunit_util.h"
1213
1314 #define BUFSIZE 512
1415
@@ -172,6 +173,779 @@ static void cros_ec_proto_test_check_result(struct kunit *test) · 157 unmodified lines
172173 KUNIT_EXPECT_EQ(test, ret, -EAGAIN);
173174 }
174175
176+static 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+
191+static 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+
344+static 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+
408+static 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+
473+static 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+
521+static 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+
569+static 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+
622+static 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+
714+static 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+
819+static 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+
945+static void cros_ec_proto_test_release(struct device *dev)
946+{
947+}
948+
175949 static int cros_ec_proto_test_init(struct kunit *test)
176950 {
177951 struct cros_ec_proto_test_priv *priv;
@@ -188,24 +962,52 @@ static int cros_ec_proto_test_init(struct kunit *test) · 10 unmodified lines
188962 ec_dev->din = (u8 *)priv->din;
189963 ec_dev->din_size = ARRAY_SIZE(priv->din);
190964 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;
191973
192974 priv->msg = (struct cros_ec_command *)priv->_msg;
193975
976+ cros_kunit_mock_reset();
977+
194978 return 0;
195979 }
196980
981+static 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+
197989 static struct kunit_case cros_ec_proto_test_cases[] = {
198990 KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_normal),
199991 KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_bad_msg_outsize),
200992 KUNIT_CASE(cros_ec_proto_test_prepare_tx_normal),
201993 KUNIT_CASE(cros_ec_proto_test_prepare_tx_bad_msg_outsize),
202994 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),
2031004 {}
2041005 };
2051006
2061007 static struct kunit_suite cros_ec_proto_test_suite = {
2071008 .name = "cros_ec_proto_test",
2081009 .init = cros_ec_proto_test_init,
1010+ .exit = cros_ec_proto_test_exit,
2091011 .test_cases = cros_ec_proto_test_cases,
2101012 };
2111013
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+
16+int cros_kunit_ec_xfer_mock_default_ret;
17+EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_default_ret);
18+
19+static struct list_head cros_kunit_ec_xfer_mock_in;
20+static struct list_head cros_kunit_ec_xfer_mock_out;
21+
22+int 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+}
47+EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock);
48+
49+struct 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+}
53+EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_add);
54+
55+struct 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+}
76+EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_addx);
77+
78+struct 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+}
88+EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_next);
89+
90+void 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+}
96+EXPORT_SYMBOL_GPL(cros_kunit_mock_reset);
97+
98+MODULE_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+
11+struct 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+
26+extern int cros_kunit_ec_xfer_mock_default_ret;
27+
28+int cros_kunit_ec_xfer_mock(struct cros_ec_device *ec_dev, struct cros_ec_command *msg);
29+struct ec_xfer_mock *cros_kunit_ec_xfer_mock_add(struct kunit *test, size_t size);
30+struct ec_xfer_mock *cros_kunit_ec_xfer_mock_addx(struct kunit *test,
31+ int ret, int result, size_t size);
32+struct ec_xfer_mock *cros_kunit_ec_xfer_mock_next(void);
33+
34+void cros_kunit_mock_reset(void);
35+
36+#endif