Skip to contentSkip to conversation

platform/chrome: Kunit tests and refactor for cros_ec_query_all()

PATCH Superseded Tzung-Bi Shih 2 participants 42 messages Jun 8, 2022 – Jun 9, 2022

Subsystems (2)

v3 of 4 Superseded Latest is v4 →

lore
Share & tools
lore

Tzung-Bi Shih

author maintainer
#0 lore raw

v3 cover platform/chrome: Kunit tests and refactor for cros_ec_query_all()

The series adds Kunit tests, refactors, and clean-ups for cros_ec_query_all().

Tzung-Bi Shih (23):
platform/chrome: cros_ec_commands: fix compile errors
-> Fixes compile errors when including cros_ec_commands.h.

platform/chrome: cros_ec_proto: add Kunit tests for

    cros_ec_query_all()

-> Adds Kunit tests for cros_ec_query_all(). They are baseline tests
for the following refactor patches. They are designed to pass current code.

platform/chrome: use macros for passthru indexes platform/chrome: cros_ec_proto: assign buffer size from protocol info
-> Refactors.

platform/chrome: cros_ec_proto: remove redundant NULL check
-> Clean up.

platform/chrome: cros_ec_proto: use cros_ec_map_error()
-> Changes the internal return code.

platform/chrome: cros_ec_proto: separate cros_ec_get_proto_info()
-> Move refactor.

platform/chrome: cros_ec_proto: add Kunit tests for getting proto info platform/chrome: cros_ec_proto: handle empty payload in getting proto
info
-> Test and handle if send_command() returns 0 in cros_ec_get_proto_info().

platform/chrome: cros_ec_proto: separate
cros_ec_get_proto_info_legacy()
-> Move refactor.

platform/chrome: cros_ec_proto: add Kunit test for getting legacy info platform/chrome: cros_ec_proto: handle empty payload in getting info
legacy
-> Test and handle if send_command() returns 0 in
cros_ec_get_proto_info_legacy().

platform/chrome: cros_ec: don't allocate din and dout in
cros_ec_register()
-> Clean up.

platform/chrome: don't use devm variants for din and dout
-> Replace devm variants to non-devm.

platform/chrome: cros_ec_proto: don't show MKBP version if unsupported
-> Minor fix up.

platform/chrome: cros_ec_proto: return 0 on getting cmd mask success
-> Conform to kernel convention: return 0 on success;
otherwise, negative integers.

platform/chrome: cros_ec_proto: add Kunit test for getting cmd mask
error
platform/chrome: cros_ec_proto: check msg->result in getting cmd
mask
-> Test and handle if msg->result isn't EC_RES_SUCCESS in
cros_ec_get_host_command_version_mask().

platform/chrome: cros_ec_proto: add Kunit tests for getting cmd mask platform/chrome: cros_ec_proto: handle empty payload in getting cmd
mask
-> Test and handle if send_command() returns 0 in
cros_ec_get_host_command_version_mask().

platform/chrome: cros_ec_proto: return 0 on getting wake mask success
-> Conform to kernel convention: return 0 on success;
otherwise, negative integers.

platform/chrome: cros_ec_proto: add Kunit test for getting wake mask platform/chrome: cros_ec_proto: handle empty payload in getting wake
mask
-> Test and handle if send_command() returns 0 in
cros_ec_get_host_event_wake_mask().

 drivers/platform/chrome/Kconfig               |    6 +
 drivers/platform/chrome/Makefile              |    1 +
 drivers/platform/chrome/cros_ec.c             |   17 +-
 drivers/platform/chrome/cros_ec_proto.c       |  320 ++--
 drivers/platform/chrome/cros_ec_proto_test.c  | 1402 +++++++++++++++++
 drivers/platform/chrome/cros_ec_trace.h       |    8 +-
 drivers/platform/chrome/cros_kunit_util.c     |   98 ++
 drivers/platform/chrome/cros_kunit_util.h     |   36 +
 .../linux/platform_data/cros_ec_commands.h    |    4 +-
 include/linux/platform_data/cros_ec_proto.h   |    3 +
 10 files changed, 1717 insertions(+), 178 deletions(-)
 create mode 100644 drivers/platform/chrome/cros_kunit_util.c
 create mode 100644 drivers/platform/chrome/cros_kunit_util.h

Changes from v2:
(https://patchwork.kernel.org/project/chrome-platform/cover/[email protected]/)
- Split patches into smaller pieces.

Changes from v1:
(https://patchwork.kernel.org/project/chrome-platform/cover/[email protected]/)
- Fix review comments.
- Split and reorder patches.

base-commit: 4319cbd4ed99003e0c981728ab1626c25be7af4a

Signature · 1 line
2.36.1.255.ge46751e96f-goog
author maintainer
#1 lore raw

PATCH v3 1/23 platform/chrome: cros_ec_commands: fix compile errors

Fix compile errors when including cros_ec_commands.h solely.

1.
cros_ec_commands.h:587:9: error: unknown type name 'uint8_t'

  587 |         uint8_t flags;
      |         ^~~~~~~

2.
cros_ec_commands.h:1105:43: error: implicit declaration of function 'BIT'
1105 | EC_COMMS_STATUS_PROCESSING = BIT(0),
| ^~~

---
No change from v2.

Changes from v1:
- Add R-b tag.

 include/linux/platform_data/cros_ec_commands.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
include/linux/platform_data/cros_ec_commands.h +2 -2
index 8cfa8cfca77e..a5b749a85707 100644
@@ -13,8 +13,8 @@
 #ifndef __CROS_EC_COMMANDS_H
 #define __CROS_EC_COMMANDS_H
 
-
-
+#include <linux/bits.h>
+#include <linux/types.h>
 
 #define BUILD_ASSERT(_cond)
 
Signature · 1 line
2.36.1.255.ge46751e96f-goog
author maintainer
#2 lore raw

PATCH v3 2/23 platform/chrome: cros_ec_proto: add Kunit tests for cros_ec_query_all()

In reply to Tzung-Bi Shih

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.

---
No change from v2.

Changes from v1:
- Initialize the mock ec_dev->dev more to get rid of kernel WARN().
- Elaborate more on the test case names.

 drivers/platform/chrome/Kconfig              |   6 +
 drivers/platform/chrome/Makefile             |   1 +
 drivers/platform/chrome/cros_ec_proto_test.c | 802 +++++++++++++++++++
 drivers/platform/chrome/cros_kunit_util.c    |  98 +++
 drivers/platform/chrome/cros_kunit_util.h    |  36 +
 5 files changed, 943 insertions(+)
 create mode 100644 drivers/platform/chrome/cros_kunit_util.c
 create mode 100644 drivers/platform/chrome/cros_kunit_util.h
drivers/platform/chrome/Kconfig +6 -0
index 4b3d2427e8dd..0b069d874845 100644
@@ -268,11 +268,17 @@ config CHROMEOS_PRIVACY_SCREEN
 source "drivers/platform/chrome/wilco_ec/Kconfig"
 
 # Kunit test cases
+config CROS_KUNIT
+	tristate
+	help
+	  ChromeOS Kunit.
+
 config CROS_EC_PROTO_KUNIT_TEST
 	tristate "Kunit tests for ChromeOS EC protocol" if !KUNIT_ALL_TESTS
 	depends on KUNIT && CROS_EC
 	default KUNIT_ALL_TESTS
 	select CROS_EC_PROTO
+	select CROS_KUNIT
 	help
 	  Kunit tests for the ChromeOS Embedded Controller protocol.
 
drivers/platform/chrome/Makefile +1 -0
index 3c380066c6b6..a06bc56d12a8 100644
@@ -32,4 +32,5 @@ obj-$(CONFIG_CROS_USBPD_NOTIFY)		+= cros_usbpd_notify.o
 obj-$(CONFIG_WILCO_EC)			+= wilco_ec/
 
 # Kunit test cases
+obj-$(CONFIG_CROS_KUNIT)		+= cros_kunit_util.o
 obj-$(CONFIG_CROS_EC_PROTO_KUNIT_TEST)	+= cros_ec_proto_test.o
drivers/platform/chrome/cros_ec_proto_test.c +802 -0

838 lines not on this page · raw message

drivers/platform/chrome/cros_kunit_util.c new file +98 -0

98 lines not on this page · raw message

drivers/platform/chrome/cros_kunit_util.h new file +36 -0
new file mode 100644
index 000000000000..79c4525f873c
@@ -0,0 +1,36 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * CrOS Kunit tests utilities.
+ */
+
+#ifndef _CROS_KUNIT_UTIL_H_
+#define _CROS_KUNIT_UTIL_H_
+
+#include <linux/platform_data/cros_ec_proto.h>
+
+struct ec_xfer_mock {
+	struct list_head list;
+	struct kunit *test;
+
+	/* input */
+	struct cros_ec_command msg;
+	void *i_data;
+
+	/* output */
+	int ret;
+	int result;
+	void *o_data;
+	u32 o_data_len;
+};
+
+extern int cros_kunit_ec_xfer_mock_default_ret;
+
+int cros_kunit_ec_xfer_mock(struct cros_ec_device *ec_dev, struct cros_ec_command *msg);
+struct ec_xfer_mock *cros_kunit_ec_xfer_mock_add(struct kunit *test, size_t size);
+struct ec_xfer_mock *cros_kunit_ec_xfer_mock_addx(struct kunit *test,
+						  int ret, int result, size_t size);
+struct ec_xfer_mock *cros_kunit_ec_xfer_mock_next(void);
+
+void cros_kunit_mock_reset(void);
+
+#endif
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 2/23
#3 lore raw

Re: [PATCH v3 02/23] platform/chrome: cros_ec_proto: add Kunit tests for cros_ec_query_all()

Quoted 8 lines · Tzung-Bi Shih

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.

Quoted 1,042 lines

---
No change from v2.

Changes from v1:
- Initialize the mock ec_dev->dev more to get rid of kernel WARN().
- Elaborate more on the test case names.

 drivers/platform/chrome/Kconfig              |   6 +
 drivers/platform/chrome/Makefile             |   1 +
 drivers/platform/chrome/cros_ec_proto_test.c | 802 +++++++++++++++++++
 drivers/platform/chrome/cros_kunit_util.c    |  98 +++
 drivers/platform/chrome/cros_kunit_util.h    |  36 +
 5 files changed, 943 insertions(+)
 create mode 100644 drivers/platform/chrome/cros_kunit_util.c
 create mode 100644 drivers/platform/chrome/cros_kunit_util.h
drivers/platform/chrome/Kconfig +6 -0
index 4b3d2427e8dd..0b069d874845 100644
@@ -268,11 +268,17 @@ config CHROMEOS_PRIVACY_SCREEN
 source "drivers/platform/chrome/wilco_ec/Kconfig"
 
 # Kunit test cases
+config CROS_KUNIT
+       tristate
+       help
+         ChromeOS Kunit.
+
 config CROS_EC_PROTO_KUNIT_TEST
        tristate "Kunit tests for ChromeOS EC protocol" if !KUNIT_ALL_TESTS
        depends on KUNIT && CROS_EC
        default KUNIT_ALL_TESTS
        select CROS_EC_PROTO
+       select CROS_KUNIT
        help
          Kunit tests for the ChromeOS Embedded Controller protocol.
 
drivers/platform/chrome/Makefile +1 -0
index 3c380066c6b6..a06bc56d12a8 100644
@@ -32,4 +32,5 @@ obj-$(CONFIG_CROS_USBPD_NOTIFY)               += cros_usbpd_notify.o
 obj-$(CONFIG_WILCO_EC)                 += wilco_ec/
 
 # Kunit test cases
+obj-$(CONFIG_CROS_KUNIT)               += cros_kunit_util.o
 obj-$(CONFIG_CROS_EC_PROTO_KUNIT_TEST) += cros_ec_proto_test.o
drivers/platform/chrome/cros_ec_proto_test.c +802 -0
index 25c4fca5c165..675306c16d47 100644
@@ -9,6 +9,7 @@
 #include <linux/platform_data/cros_ec_proto.h>
 
 #include "cros_ec.h"
+#include "cros_kunit_util.h"
 
 #define BUFSIZE 512
 
@@ -172,6 +173,779 @@ static void cros_ec_proto_test_check_result(struct kunit *test)
        KUNIT_EXPECT_EQ(test, ret, -EAGAIN);
 }
 
+static void cros_ec_proto_test_query_all_pretest(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+
+       /*
+        * cros_ec_query_all() will free din and dout and allocate them again to fit the usage by
+        * calling devm_kfree() and devm_kzalloc().  Set them to NULL as they aren't managed by
+        * ec_dev->dev but allocated statically in struct cros_ec_proto_test_priv
+        * (see cros_ec_proto_test_init()).
+        */
+       ec_dev->din = NULL;
+       ec_dev->dout = NULL;
+}
+
+static void cros_ec_proto_test_query_all_normal(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               struct ec_response_get_protocol_info *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               data = (struct ec_response_get_protocol_info *)mock->o_data;
+               data->protocol_versions = BIT(3) | BIT(2);
+               data->max_request_packet_size = 0xbe;
+               data->max_response_packet_size = 0xef;
+       }
+
+       /* For cros_ec_host_command_proto_query() with passthru. */
+       {
+               struct ec_response_get_protocol_info *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               data = (struct ec_response_get_protocol_info *)mock->o_data;
+               data->max_request_packet_size = 0xbf;
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               struct ec_response_get_cmd_versions *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               data = (struct ec_response_get_cmd_versions *)mock->o_data;
+               data->version_mask = BIT(6) | BIT(5);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+       {
+               struct ec_response_get_cmd_versions *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               data = (struct ec_response_get_cmd_versions *)mock->o_data;
+               data->version_mask = BIT(1);
+       }
+
+       /* For cros_ec_get_host_event_wake_mask(). */
+       {
+               struct ec_response_host_event_mask *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               data = (struct ec_response_host_event_mask *)mock->o_data;
+               data->mask = 0xbeef;
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+
+               KUNIT_EXPECT_EQ(test, ec_dev->max_request, 0xbe - sizeof(struct ec_host_request));
+               KUNIT_EXPECT_EQ(test, ec_dev->max_response, 0xef - sizeof(struct ec_host_response));
+               KUNIT_EXPECT_EQ(test, ec_dev->proto_version, 3);
+               KUNIT_EXPECT_EQ(test, ec_dev->din_size, 0xef + EC_MAX_RESPONSE_OVERHEAD);
+               KUNIT_EXPECT_EQ(test, ec_dev->dout_size, 0xbe + EC_MAX_REQUEST_OVERHEAD);
+       }
+
+       /* For cros_ec_host_command_proto_query() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command,
+                               EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+
+               KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0xbf - sizeof(struct ec_host_request));
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               struct ec_params_get_cmd_versions *data;
+
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
+
+               data = (struct ec_params_get_cmd_versions *)mock->i_data;
+               KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT);
+
+               KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 7);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+       {
+               struct ec_params_get_cmd_versions *data;
+
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
+
+               data = (struct ec_params_get_cmd_versions *)mock->i_data;
+               KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_HOST_SLEEP_EVENT);
+
+               KUNIT_EXPECT_TRUE(test, ec_dev->host_sleep_v1);
+       }
+
+       /* For cros_ec_get_host_event_wake_mask(). */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HOST_EVENT_GET_WAKE_MASK);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_host_event_mask));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+
+               KUNIT_EXPECT_EQ(test, ec_dev->host_event_wake_mask, 0xbeef);
+       }
+}
+
+static void cros_ec_proto_test_query_all_no_pd_return_error(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* Set some garbage bytes. */
+       ec_dev->max_passthru = 0xbf;
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               struct ec_response_get_protocol_info *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               /*
+                * Although it doesn't check the value, provides valid sizes so that
+                * cros_ec_query_all() allocates din and dout correctly.
+                */
+               data = (struct ec_response_get_protocol_info *)mock->o_data;
+               data->max_request_packet_size = 0xbe;
+               data->max_response_packet_size = 0xef;
+       }
+
+       /* For cros_ec_host_command_proto_query() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_host_command_proto_query() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command,
+                               EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+
+               KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0);
+       }
+}
+
+static void cros_ec_proto_test_query_all_legacy_normal_v3_return_error(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_host_command_proto_query_v2(). */
+       {
+               struct ec_response_hello *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               data = (struct ec_response_hello *)mock->o_data;
+               data->out_data = 0xa1b2c3d4;
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_host_command_proto_query_v2(). */
+       {
+               struct ec_params_hello *data;
+
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
+
+               data = (struct ec_params_hello *)mock->i_data;
+               KUNIT_EXPECT_EQ(test, data->in_data, 0xa0b0c0d0);
+
+               KUNIT_EXPECT_EQ(test, ec_dev->proto_version, 2);
+               KUNIT_EXPECT_EQ(test, ec_dev->max_request, EC_PROTO2_MAX_PARAM_SIZE);
+               KUNIT_EXPECT_EQ(test, ec_dev->max_response, EC_PROTO2_MAX_PARAM_SIZE);
+               KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0);
+               KUNIT_EXPECT_PTR_EQ(test, ec_dev->pkt_xfer, NULL);
+               KUNIT_EXPECT_EQ(test, ec_dev->din_size, EC_PROTO2_MSG_BYTES);
+               KUNIT_EXPECT_EQ(test, ec_dev->dout_size, EC_PROTO2_MSG_BYTES);
+       }
+}
+
+static void cros_ec_proto_test_query_all_legacy_xfer_error(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_host_command_proto_query_v2(). */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, -EIO, EC_RES_SUCCESS, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, -EIO);
+       KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_host_command_proto_query_v2(). */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello));
+       }
+}
+
+static void cros_ec_proto_test_query_all_legacy_return_error(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_host_command_proto_query_v2(). */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, EC_RES_INVALID_COMMAND);
+       KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_host_command_proto_query_v2(). */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello));
+       }
+}
+
+static void cros_ec_proto_test_query_all_legacy_data_error(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_host_command_proto_query_v2(). */
+       {
+               struct ec_response_hello *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               data = (struct ec_response_hello *)mock->o_data;
+               data->out_data = 0xbeefbfbf;
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, -EBADMSG);
+       KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_host_command_proto_query_v2(). */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello));
+       }
+}
+
+static void cros_ec_proto_test_query_all_no_mkbp(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* Set some garbage bytes. */
+       ec_dev->mkbp_event_supported = 0xbf;
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               struct ec_response_get_protocol_info *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               /*
+                * Although it doesn't check the value, provides valid sizes so that
+                * cros_ec_query_all() allocates din and dout correctly.
+                */
+               data = (struct ec_response_get_protocol_info *)mock->o_data;
+               data->max_request_packet_size = 0xbe;
+               data->max_response_packet_size = 0xef;
+       }
+
+       /* For cros_ec_host_command_proto_query() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               struct ec_response_get_cmd_versions *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               data = (struct ec_response_get_cmd_versions *)mock->o_data;
+               data->version_mask = 0;
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_host_command_proto_query() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command,
+                               EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               struct ec_params_get_cmd_versions *data;
+
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
+
+               data = (struct ec_params_get_cmd_versions *)mock->i_data;
+               KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT);
+
+               KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 0);
+       }
+}
+
+static void cros_ec_proto_test_query_all_no_host_sleep(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* Set some garbage bytes. */
+       ec_dev->host_sleep_v1 = true;
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               struct ec_response_get_protocol_info *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               /*
+                * Although it doesn't check the value, provides valid sizes so that
+                * cros_ec_query_all() allocates din and dout correctly.
+                */
+               data = (struct ec_response_get_protocol_info *)mock->o_data;
+               data->max_request_packet_size = 0xbe;
+               data->max_response_packet_size = 0xef;
+       }
+
+       /* For cros_ec_host_command_proto_query() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               mock = cros_kunit_ec_xfer_mock_add(test, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+       {
+               struct ec_response_get_cmd_versions *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               data = (struct ec_response_get_cmd_versions *)mock->o_data;
+               data->version_mask = 0;
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_host_command_proto_query() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command,
+                               EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
+
+               KUNIT_EXPECT_FALSE(test, ec_dev->host_sleep_v1);
+       }
+}
+
+static void cros_ec_proto_test_query_all_default_wake_mask_return_error(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* Set some garbage bytes. */
+       ec_dev->host_event_wake_mask = U32_MAX;
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               struct ec_response_get_protocol_info *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               /*
+                * Although it doesn't check the value, provides valid sizes so that
+                * cros_ec_query_all() allocates din and dout correctly.
+                */
+               data = (struct ec_response_get_protocol_info *)mock->o_data;
+               data->max_request_packet_size = 0xbe;
+               data->max_response_packet_size = 0xef;
+       }
+
+       /* For cros_ec_host_command_proto_query() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               mock = cros_kunit_ec_xfer_mock_add(test, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+       {
+               mock = cros_kunit_ec_xfer_mock_add(test, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_get_host_event_wake_mask(). */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       /* For cros_ec_host_command_proto_query() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_host_command_proto_query() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command,
+                               EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
+       }
+
+       /* For cros_ec_get_host_event_wake_mask(). */
+       {
+               u32 mask;
+
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HOST_EVENT_GET_WAKE_MASK);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_host_event_mask));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+
+               mask = ec_dev->host_event_wake_mask;
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_CLOSED), 0);
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED), 0);
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_LOW), 0);
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_CRITICAL), 0);
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY), 0);
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_PD_MCU), 0);
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_STATUS), 0);
+       }
+}
+
+static void cros_ec_proto_test_release(struct device *dev)
+{
+}
+
 static int cros_ec_proto_test_init(struct kunit *test)
 {
        struct cros_ec_proto_test_priv *priv;
@@ -188,24 +962,52 @@ static int cros_ec_proto_test_init(struct kunit *test)
        ec_dev->din = (u8 *)priv->din;
        ec_dev->din_size = ARRAY_SIZE(priv->din);
        ec_dev->proto_version = EC_HOST_REQUEST_VERSION;
+       ec_dev->dev = kunit_kzalloc(test, sizeof(*ec_dev->dev), GFP_KERNEL);
+       if (!ec_dev->dev)
+               return -ENOMEM;
+       device_initialize(ec_dev->dev);
+       dev_set_name(ec_dev->dev, "cros_ec_proto_test");
+       ec_dev->dev->release = cros_ec_proto_test_release;
+       ec_dev->cmd_xfer = cros_kunit_ec_xfer_mock;
+       ec_dev->pkt_xfer = cros_kunit_ec_xfer_mock;
 
        priv->msg = (struct cros_ec_command *)priv->_msg;
 
+       cros_kunit_mock_reset();
+
        return 0;
 }
 
+static void cros_ec_proto_test_exit(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+
+       put_device(ec_dev->dev);
+}
+
 static struct kunit_case cros_ec_proto_test_cases[] = {
        KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_normal),
        KUNIT_CASE(cros_ec_proto_test_prepare_tx_legacy_bad_msg_outsize),
        KUNIT_CASE(cros_ec_proto_test_prepare_tx_normal),
        KUNIT_CASE(cros_ec_proto_test_prepare_tx_bad_msg_outsize),
        KUNIT_CASE(cros_ec_proto_test_check_result),
+       KUNIT_CASE(cros_ec_proto_test_query_all_normal),
+       KUNIT_CASE(cros_ec_proto_test_query_all_no_pd_return_error),
+       KUNIT_CASE(cros_ec_proto_test_query_all_legacy_normal_v3_return_error),
+       KUNIT_CASE(cros_ec_proto_test_query_all_legacy_xfer_error),
+       KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return_error),
+       KUNIT_CASE(cros_ec_proto_test_query_all_legacy_data_error),
+       KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp),
+       KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep),
+       KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error),
        {}
 };
 
 static struct kunit_suite cros_ec_proto_test_suite = {
        .name = "cros_ec_proto_test",
        .init = cros_ec_proto_test_init,
+       .exit = cros_ec_proto_test_exit,
        .test_cases = cros_ec_proto_test_cases,
 };
 
drivers/platform/chrome/cros_kunit_util.c new file +98 -0
new file mode 100644
index 000000000000..e031777dea87
@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * CrOS Kunit tests utilities.
+ */
+
+#include <kunit/test.h>
+
+#include <linux/list.h>
+#include <linux/minmax.h>
+#include <linux/platform_data/cros_ec_commands.h>
+#include <linux/platform_data/cros_ec_proto.h>
+
+#include "cros_ec.h"
+#include "cros_kunit_util.h"
+
+int cros_kunit_ec_xfer_mock_default_ret;
+EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_default_ret);
+
+static struct list_head cros_kunit_ec_xfer_mock_in;
+static struct list_head cros_kunit_ec_xfer_mock_out;
+
+int cros_kunit_ec_xfer_mock(struct cros_ec_device *ec_dev, struct cros_ec_command *msg)
+{
+       struct ec_xfer_mock *mock;
+
+       mock = list_first_entry_or_null(&cros_kunit_ec_xfer_mock_in, struct ec_xfer_mock, list);
+       if (!mock)
+               return cros_kunit_ec_xfer_mock_default_ret;
+
+       list_del(&mock->list);
+
+       memcpy(&mock->msg, msg, sizeof(*msg));
+       if (msg->outsize) {
+               mock->i_data = kunit_kzalloc(mock->test, msg->outsize, GFP_KERNEL);
+               if (mock->i_data)
+                       memcpy(mock->i_data, msg->data, msg->outsize);
+       }
+
+       msg->result = mock->result;
+       if (msg->insize)
+               memcpy(msg->data, mock->o_data, min(msg->insize, mock->o_data_len));
+
+       list_add_tail(&mock->list, &cros_kunit_ec_xfer_mock_out);
+
+       return mock->ret;
+}
+EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock);
+
+struct ec_xfer_mock *cros_kunit_ec_xfer_mock_add(struct kunit *test, size_t size)
+{
+       return cros_kunit_ec_xfer_mock_addx(test, size, EC_RES_SUCCESS, size);
+}
+EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_add);
+
+struct ec_xfer_mock *cros_kunit_ec_xfer_mock_addx(struct kunit *test,
+                                                 int ret, int result, size_t size)
+{
+       struct ec_xfer_mock *mock;
+
+       mock = kunit_kzalloc(test, sizeof(*mock), GFP_KERNEL);
+       if (!mock)
+               return NULL;
+
+       list_add_tail(&mock->list, &cros_kunit_ec_xfer_mock_in);
+       mock->test = test;
+
+       mock->ret = ret;
+       mock->result = result;
+       mock->o_data = kunit_kzalloc(test, size, GFP_KERNEL);
+       if (!mock->o_data)
+               return NULL;
+       mock->o_data_len = size;
+
+       return mock;
+}
+EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_addx);
+
+struct ec_xfer_mock *cros_kunit_ec_xfer_mock_next(void)
+{
+       struct ec_xfer_mock *mock;
+
+       mock = list_first_entry_or_null(&cros_kunit_ec_xfer_mock_out, struct ec_xfer_mock, list);
+       if (mock)
+               list_del(&mock->list);
+
+       return mock;
+}
+EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_next);
+
+void cros_kunit_mock_reset(void)
+{
+       cros_kunit_ec_xfer_mock_default_ret = 0;
+       INIT_LIST_HEAD(&cros_kunit_ec_xfer_mock_in);
+       INIT_LIST_HEAD(&cros_kunit_ec_xfer_mock_out);
+}
+EXPORT_SYMBOL_GPL(cros_kunit_mock_reset);
+
+MODULE_LICENSE("GPL");
drivers/platform/chrome/cros_kunit_util.h new file +36 -1
new file mode 100644
index 000000000000..79c4525f873c
@@ -0,0 +1,36 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * CrOS Kunit tests utilities.
+ */
+
+#ifndef _CROS_KUNIT_UTIL_H_
+#define _CROS_KUNIT_UTIL_H_
+
+#include <linux/platform_data/cros_ec_proto.h>
+
+struct ec_xfer_mock {
+       struct list_head list;
+       struct kunit *test;
+
+       /* input */
+       struct cros_ec_command msg;
+       void *i_data;
+
+       /* output */
+       int ret;
+       int result;
+       void *o_data;
+       u32 o_data_len;
+};
+
+extern int cros_kunit_ec_xfer_mock_default_ret;
+
+int cros_kunit_ec_xfer_mock(struct cros_ec_device *ec_dev, struct cros_ec_command *msg);
+struct ec_xfer_mock *cros_kunit_ec_xfer_mock_add(struct kunit *test, size_t size);
+struct ec_xfer_mock *cros_kunit_ec_xfer_mock_addx(struct kunit *test,
+                                                 int ret, int result, size_t size);
+struct ec_xfer_mock *cros_kunit_ec_xfer_mock_next(void);
+
+void cros_kunit_mock_reset(void);
+
+#endif
--

2.36.1.255.ge46751e96f-goog

author maintainer
#4 lore raw

PATCH v3 3/23 platform/chrome: use macros for passthru indexes

In reply to Tzung-Bi Shih

Move passthru indexes for EC and PD devices to common header. Also use them instead of literal constants.

---
No change from v2.

Changes from v1:
- Add R-b tag.

 drivers/platform/chrome/cros_ec.c            |  3 ---
 drivers/platform/chrome/cros_ec_proto.c      |  6 +++---
 drivers/platform/chrome/cros_ec_proto_test.c | 15 ++++++++++-----
 drivers/platform/chrome/cros_ec_trace.h      |  8 ++++----
 include/linux/platform_data/cros_ec_proto.h  |  3 +++
 5 files changed, 20 insertions(+), 15 deletions(-)
drivers/platform/chrome/cros_ec.c +0 -3
index b3e94cdf7d1a..e51a3f2176c7 100644
@@ -19,9 +19,6 @@
 
 #include "cros_ec.h"
 
-#define CROS_EC_DEV_EC_INDEX 0
-#define CROS_EC_DEV_PD_INDEX 1
-
 static struct cros_ec_platform ec_p = {
 	.ec_name = CROS_EC_DEV_NAME,
 	.cmd_offset = EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_EC_INDEX),
drivers/platform/chrome/cros_ec_proto.c +3 -3
index 13ced9d2dd71..65191af5139c 100644
@@ -433,7 +433,7 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
 
 	/* First try sending with proto v3. */
 	ec_dev->proto_version = 3;
-	ret = cros_ec_host_command_proto_query(ec_dev, 0, proto_msg);
+	ret = cros_ec_host_command_proto_query(ec_dev, CROS_EC_DEV_EC_INDEX, proto_msg);
 
 	if (ret == 0) {
 		proto_info = (struct ec_response_get_protocol_info *)
@@ -459,7 +459,7 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
 		/*
 		 * Check for PD
 		 */
-		ret = cros_ec_host_command_proto_query(ec_dev, 1, proto_msg);
+		ret = cros_ec_host_command_proto_query(ec_dev, CROS_EC_DEV_PD_INDEX, proto_msg);
 
 		if (ret) {
 			dev_dbg(ec_dev->dev, "no PD chip found: %d\n", ret);
@@ -609,7 +609,7 @@ int cros_ec_cmd_xfer(struct cros_ec_device *ec_dev, struct cros_ec_command *msg)
 		msg->insize = ec_dev->max_response;
 	}
 
-	if (msg->command < EC_CMD_PASSTHRU_OFFSET(1)) {
+	if (msg->command < EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX)) {
 		if (msg->outsize > ec_dev->max_request) {
 			dev_err(ec_dev->dev,
 				"request of size %u is too big (max: %u)\n",
drivers/platform/chrome/cros_ec_proto_test.c +10 -5
index 675306c16d47..f8dbfb0d8dc8 100644
@@ -281,7 +281,8 @@ static void cros_ec_proto_test_query_all_normal(struct kunit *test)
 
 		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 		KUNIT_EXPECT_EQ(test, mock->msg.command,
-				EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
+				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+				EC_CMD_GET_PROTOCOL_INFO);
 		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 				sizeof(struct ec_response_get_protocol_info));
 		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
@@ -396,7 +397,8 @@ static void cros_ec_proto_test_query_all_no_pd_return_error(struct kunit *test)
 
 		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 		KUNIT_EXPECT_EQ(test, mock->msg.command,
-				EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
+				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+				EC_CMD_GET_PROTOCOL_INFO);
 		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 				sizeof(struct ec_response_get_protocol_info));
 		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
@@ -685,7 +687,8 @@ static void cros_ec_proto_test_query_all_no_mkbp(struct kunit *test)
 
 		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 		KUNIT_EXPECT_EQ(test, mock->msg.command,
-				EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
+				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+				EC_CMD_GET_PROTOCOL_INFO);
 		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 				sizeof(struct ec_response_get_protocol_info));
 		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
@@ -783,7 +786,8 @@ static void cros_ec_proto_test_query_all_no_host_sleep(struct kunit *test)
 
 		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 		KUNIT_EXPECT_EQ(test, mock->msg.command,
-				EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
+				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+				EC_CMD_GET_PROTOCOL_INFO);
 		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 				sizeof(struct ec_response_get_protocol_info));
 		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
@@ -889,7 +893,8 @@ static void cros_ec_proto_test_query_all_default_wake_mask_return_error(struct k
 
 		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
 		KUNIT_EXPECT_EQ(test, mock->msg.command,
-				EC_CMD_PASSTHRU_OFFSET(1) | EC_CMD_GET_PROTOCOL_INFO);
+				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+				EC_CMD_GET_PROTOCOL_INFO);
 		KUNIT_EXPECT_EQ(test, mock->msg.insize,
 				sizeof(struct ec_response_get_protocol_info));
 		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
drivers/platform/chrome/cros_ec_trace.h +4 -4
index 9bb5cd2c98b8..d7e407de88df 100644
@@ -30,8 +30,8 @@ TRACE_EVENT(cros_ec_request_start,
 	),
 	TP_fast_assign(
 		__entry->version = cmd->version;
-		__entry->offset = cmd->command / EC_CMD_PASSTHRU_OFFSET(1);
-		__entry->command = cmd->command % EC_CMD_PASSTHRU_OFFSET(1);
+		__entry->offset = cmd->command / EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX);
+		__entry->command = cmd->command % EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX);
 		__entry->outsize = cmd->outsize;
 		__entry->insize = cmd->insize;
 	),
@@ -55,8 +55,8 @@ TRACE_EVENT(cros_ec_request_done,
 	),
 	TP_fast_assign(
 		__entry->version = cmd->version;
-		__entry->offset = cmd->command / EC_CMD_PASSTHRU_OFFSET(1);
-		__entry->command = cmd->command % EC_CMD_PASSTHRU_OFFSET(1);
+		__entry->offset = cmd->command / EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX);
+		__entry->command = cmd->command % EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX);
 		__entry->outsize = cmd->outsize;
 		__entry->insize = cmd->insize;
 		__entry->result = cmd->result;
include/linux/platform_data/cros_ec_proto.h +3 -0
index 138fd912c808..6475a8066f00 100644
@@ -21,6 +21,9 @@
 #define CROS_EC_DEV_SCP_NAME	"cros_scp"
 #define CROS_EC_DEV_TP_NAME	"cros_tp"
 
+#define CROS_EC_DEV_EC_INDEX 0
+#define CROS_EC_DEV_PD_INDEX 1
+
 /*
  * The EC is unresponsive for a time after a reboot command.  Add a
  * simple delay to make sure that the bus stays locked.
Signature · 1 line
2.36.1.255.ge46751e96f-goog
author maintainer
#5 lore raw

PATCH v3 4/23 platform/chrome: cros_ec_proto: assign buffer size from protocol info

In reply to Tzung-Bi Shih

din_size is calculated from ec_dev->max_response. ec_dev->max_response is further calculated from the protocol info.

To make it clear, assign din_size and dout_size from protocol info directly.

---
No change from v2.

Changes from v1:
- Add R-b tag.

 drivers/platform/chrome/cros_ec_proto.c | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +2 -6
index 65191af5139c..629dce3e6ab3 100644
@@ -449,12 +449,8 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
 			"using proto v%u\n",
 			ec_dev->proto_version);
 
-		ec_dev->din_size = ec_dev->max_response +
-			sizeof(struct ec_host_response) +
-			EC_MAX_RESPONSE_OVERHEAD;
-		ec_dev->dout_size = ec_dev->max_request +
-			sizeof(struct ec_host_request) +
-			EC_MAX_REQUEST_OVERHEAD;
+		ec_dev->din_size = proto_info->max_response_packet_size + EC_MAX_RESPONSE_OVERHEAD;
+		ec_dev->dout_size = proto_info->max_request_packet_size + EC_MAX_REQUEST_OVERHEAD;
 
 		/*
 		 * Check for PD
Signature · 1 line
2.36.1.255.ge46751e96f-goog
author maintainer
#6 lore raw

PATCH v3 5/23 platform/chrome: cros_ec_proto: remove redundant NULL check

In reply to Tzung-Bi Shih

send_command() already checks if ec_dev->pkt_xfer is NULL. Remove the redundant check.

---
No change from v2.

Changes from v1:
- Add R-b tag.

 drivers/platform/chrome/cros_ec_proto.c | 3 ---
 1 file changed, 3 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +0 -3
index 629dce3e6ab3..1b851dcd20c9 100644
@@ -281,9 +281,6 @@ static int cros_ec_host_command_proto_query(struct cros_ec_device *ec_dev,
 	 */
 	int ret;
 
-	if (!ec_dev->pkt_xfer)
-		return -EPROTONOSUPPORT;
-
 	memset(msg, 0, sizeof(*msg));
 	msg->command = EC_CMD_PASSTHRU_OFFSET(devidx) | EC_CMD_GET_PROTOCOL_INFO;
 	msg->insize = sizeof(struct ec_response_get_protocol_info);
Signature · 1 line
2.36.1.255.ge46751e96f-goog
author maintainer
#7 lore raw

PATCH v3 6/23 platform/chrome: cros_ec_proto: use cros_ec_map_error()

In reply to Tzung-Bi Shih

Use cros_ec_map_error() in cros_ec_get_host_event_wake_mask().

The behavior of cros_ec_get_host_event_wake_mask() slightly changed. It is acceptable because the caller only needs it returns negative integers for indicating errors. Especially, the EC_RES_INVALID_COMMAND still maps to -EOPNOTSUPP.

---
No change from v2.

Changes from v1:
- Add R-b tag.

 drivers/platform/chrome/cros_ec_proto.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +4 -5
index 1b851dcd20c9..71ba6a56ad7c 100644
@@ -247,7 +247,7 @@ static int cros_ec_get_host_event_wake_mask(struct cros_ec_device *ec_dev,
 					    uint32_t *mask)
 {
 	struct ec_response_host_event_mask *r;
-	int ret;
+	int ret, mapped;
 
 	msg->command = EC_CMD_HOST_EVENT_GET_WAKE_MASK;
 	msg->version = 0;
@@ -256,10 +256,9 @@ static int cros_ec_get_host_event_wake_mask(struct cros_ec_device *ec_dev,
 
 	ret = send_command(ec_dev, msg);
 	if (ret >= 0) {
-		if (msg->result == EC_RES_INVALID_COMMAND)
-			return -EOPNOTSUPP;
-		if (msg->result != EC_RES_SUCCESS)
-			return -EPROTO;
+		mapped = cros_ec_map_error(msg->result);
+		if (mapped)
+			return mapped;
 	}
 	if (ret > 0) {
 		r = (struct ec_response_host_event_mask *)msg->data;
Signature · 1 line
2.36.1.255.ge46751e96f-goog
author maintainer
#8 lore raw

PATCH v3 7/23 platform/chrome: cros_ec_proto: separate cros_ec_get_proto_info()

In reply to Tzung-Bi Shih

Rename cros_ec_host_command_proto_query() to cros_ec_get_proto_info() and make it responsible for setting ec_dev fields according to the response protocol info.

Also make cros_ec_get_host_event_wake_mask() allocate its own message buffer. It was lucky that size of struct ec_response_host_event_mask is less than struct ec_response_get_protocol_info. Thus, the buffer wasn't overflow.

---
Changes from v2:
- Add R-b tag.

Changes from v1:
- Preserve the "cros_ec_" prefix.

 drivers/platform/chrome/cros_ec_proto.c      | 134 +++++++++----------
 drivers/platform/chrome/cros_ec_proto_test.c |  56 ++++----
 2 files changed, 93 insertions(+), 97 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +65 -69
index 71ba6a56ad7c..893b76703da6 100644
@@ -242,47 +242,53 @@ EXPORT_SYMBOL(cros_ec_check_result);
  * the caller has ec_dev->lock mutex, or the caller knows there is
  * no other command in progress.
  */
-static int cros_ec_get_host_event_wake_mask(struct cros_ec_device *ec_dev,
-					    struct cros_ec_command *msg,
-					    uint32_t *mask)
+static int cros_ec_get_host_event_wake_mask(struct cros_ec_device *ec_dev, uint32_t *mask)
 {
+	struct cros_ec_command *msg;
 	struct ec_response_host_event_mask *r;
 	int ret, mapped;
 
+	msg = kzalloc(sizeof(*msg) + sizeof(*r), GFP_KERNEL);
+	if (!msg)
+		return -ENOMEM;
+
 	msg->command = EC_CMD_HOST_EVENT_GET_WAKE_MASK;
-	msg->version = 0;
-	msg->outsize = 0;
 	msg->insize = sizeof(*r);
 
 	ret = send_command(ec_dev, msg);
 	if (ret >= 0) {
 		mapped = cros_ec_map_error(msg->result);
-		if (mapped)
-			return mapped;
+		if (mapped) {
+			ret = mapped;
+			goto exit;
+		}
 	}
 	if (ret > 0) {
 		r = (struct ec_response_host_event_mask *)msg->data;
 		*mask = r->mask;
 	}
 
+exit:
+	kfree(msg);
 	return ret;
 }
 
-static int cros_ec_host_command_proto_query(struct cros_ec_device *ec_dev,
-					    int devidx,
-					    struct cros_ec_command *msg)
+static int cros_ec_get_proto_info(struct cros_ec_device *ec_dev, int devidx)
 {
-	/*
-	 * Try using v3+ to query for supported protocols. If this
-	 * command fails, fall back to v2. Returns the highest protocol
-	 * supported by the EC.
-	 * Also sets the max request/response/passthru size.
-	 */
-	int ret;
+	struct cros_ec_command *msg;
+	struct ec_response_get_protocol_info *info;
+	int ret, mapped;
+
+	ec_dev->proto_version = 3;
+	if (devidx > 0)
+		ec_dev->max_passthru = 0;
+
+	msg = kzalloc(sizeof(*msg) + sizeof(*info), GFP_KERNEL);
+	if (!msg)
+		return -ENOMEM;
 
-	memset(msg, 0, sizeof(*msg));
 	msg->command = EC_CMD_PASSTHRU_OFFSET(devidx) | EC_CMD_GET_PROTOCOL_INFO;
-	msg->insize = sizeof(struct ec_response_get_protocol_info);
+	msg->insize = sizeof(*info);
 
 	ret = send_command(ec_dev, msg);
 	/*
@@ -299,15 +305,45 @@ static int cros_ec_host_command_proto_query(struct cros_ec_device *ec_dev,
 		dev_dbg(ec_dev->dev,
 			"failed to check for EC[%d] protocol version: %d\n",
 			devidx, ret);
-		return ret;
+		goto exit;
+	}
+
+	mapped = cros_ec_map_error(msg->result);
+	if (mapped) {
+		ret = mapped;
+		goto exit;
 	}
 
-	if (devidx > 0 && msg->result == EC_RES_INVALID_COMMAND)
-		return -ENODEV;
-	else if (msg->result != EC_RES_SUCCESS)
-		return msg->result;
+	info = (struct ec_response_get_protocol_info *)msg->data;
+
+	switch (devidx) {
+	case CROS_EC_DEV_EC_INDEX:
+		ec_dev->max_request = info->max_request_packet_size -
+						sizeof(struct ec_host_request);
+		ec_dev->max_response = info->max_response_packet_size -
+						sizeof(struct ec_host_response);
+		ec_dev->proto_version = min(EC_HOST_REQUEST_VERSION,
+					    fls(info->protocol_versions) - 1);
+		ec_dev->din_size = info->max_response_packet_size + EC_MAX_RESPONSE_OVERHEAD;
+		ec_dev->dout_size = info->max_request_packet_size + EC_MAX_REQUEST_OVERHEAD;
+
+		dev_dbg(ec_dev->dev, "using proto v%u\n", ec_dev->proto_version);
+		break;
+	case CROS_EC_DEV_PD_INDEX:
+		ec_dev->max_passthru = info->max_request_packet_size -
+						sizeof(struct ec_host_request);
+
+		dev_dbg(ec_dev->dev, "found PD chip\n");
+		break;
+	default:
+		dev_dbg(ec_dev->dev, "unknwon passthru index: %d\n", devidx);
+		break;
+	}
 
-	return 0;
+	ret = 0;
+exit:
+	kfree(msg);
+	return ret;
 }
 
 static int cros_ec_host_command_proto_query_v2(struct cros_ec_device *ec_dev)
@@ -417,51 +453,13 @@ static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
 int cros_ec_query_all(struct cros_ec_device *ec_dev)
 {
 	struct device *dev = ec_dev->dev;
-	struct cros_ec_command *proto_msg;
-	struct ec_response_get_protocol_info *proto_info;
 	u32 ver_mask = 0;
 	int ret;
 
-	proto_msg = kzalloc(sizeof(*proto_msg) + sizeof(*proto_info),
-			    GFP_KERNEL);
-	if (!proto_msg)
-		return -ENOMEM;
-
 	/* First try sending with proto v3. */
-	ec_dev->proto_version = 3;
-	ret = cros_ec_host_command_proto_query(ec_dev, CROS_EC_DEV_EC_INDEX, proto_msg);
-
-	if (ret == 0) {
-		proto_info = (struct ec_response_get_protocol_info *)
-			proto_msg->data;
-		ec_dev->max_request = proto_info->max_request_packet_size -
-			sizeof(struct ec_host_request);
-		ec_dev->max_response = proto_info->max_response_packet_size -
-			sizeof(struct ec_host_response);
-		ec_dev->proto_version =
-			min(EC_HOST_REQUEST_VERSION,
-					fls(proto_info->protocol_versions) - 1);
-		dev_dbg(ec_dev->dev,
-			"using proto v%u\n",
-			ec_dev->proto_version);
-
-		ec_dev->din_size = proto_info->max_response_packet_size + EC_MAX_RESPONSE_OVERHEAD;
-		ec_dev->dout_size = proto_info->max_request_packet_size + EC_MAX_REQUEST_OVERHEAD;
-
-		/*
-		 * Check for PD
-		 */
-		ret = cros_ec_host_command_proto_query(ec_dev, CROS_EC_DEV_PD_INDEX, proto_msg);
-
-		if (ret) {
-			dev_dbg(ec_dev->dev, "no PD chip found: %d\n", ret);
-			ec_dev->max_passthru = 0;
-		} else {
-			dev_dbg(ec_dev->dev, "found PD chip\n");
-			ec_dev->max_passthru =
-				proto_info->max_request_packet_size -
-				sizeof(struct ec_host_request);
-		}
+	if (!cros_ec_get_proto_info(ec_dev, CROS_EC_DEV_EC_INDEX)) {
+		/* Check for PD. */
+		cros_ec_get_proto_info(ec_dev, CROS_EC_DEV_PD_INDEX);
 	} else {
 		/* Try querying with a v2 hello message. */
 		ec_dev->proto_version = 2;
@@ -524,8 +522,7 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
 	ec_dev->host_sleep_v1 = (ret >= 0 && (ver_mask & EC_VER_MASK(1)));
 
 	/* Get host event wake mask. */
-	ret = cros_ec_get_host_event_wake_mask(ec_dev, proto_msg,
-					       &ec_dev->host_event_wake_mask);
+	ret = cros_ec_get_host_event_wake_mask(ec_dev, &ec_dev->host_event_wake_mask);
 	if (ret < 0) {
 		/*
 		 * If the EC doesn't support EC_CMD_HOST_EVENT_GET_WAKE_MASK,
@@ -556,7 +553,6 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
 	ret = 0;
 
 exit:
-	kfree(proto_msg);
 	return ret;
 }
 EXPORT_SYMBOL(cros_ec_query_all);
drivers/platform/chrome/cros_ec_proto_test.c +28 -28

224 lines not on this page · raw message

Signature · 1 line
2.36.1.255.ge46751e96f-goog
author maintainer
#9 lore raw

PATCH v3 8/23 platform/chrome: cros_ec_proto: add Kunit tests for getting proto info

In reply to Tzung-Bi Shih

cros_ec_get_proto_info() expects to receive
sizeof(struct ec_response_get_protocol_info) from send_command(). The payload is valid only if the return value is positive.

Add Kunit tests for returning 0 from send_command() in cros_ec_get_proto_info().

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto_test.c | 132 +++++++++++++++++++
 1 file changed, 132 insertions(+)
drivers/platform/chrome/cros_ec_proto_test.c +132 -0
index 8b16666c1657..1378ac90e1cb 100644
@@ -407,6 +407,71 @@ static void cros_ec_proto_test_query_all_no_pd_return_error(struct kunit *test)
 	}
 }
 
+static void cros_ec_proto_test_query_all_no_pd_return0(struct kunit *test)
+{
+	struct cros_ec_proto_test_priv *priv = test->priv;
+	struct cros_ec_device *ec_dev = &priv->ec_dev;
+	struct ec_xfer_mock *mock;
+	int ret;
+
+	/* Set some garbage bytes. */
+	ec_dev->max_passthru = 0xbf;
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		struct ec_response_get_protocol_info *data;
+
+		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+		/*
+		 * Although it doesn't check the value, provides valid sizes so that
+		 * cros_ec_query_all() allocates din and dout correctly.
+		 */
+		data = (struct ec_response_get_protocol_info *)mock->o_data;
+		data->max_request_packet_size = 0xbe;
+		data->max_response_packet_size = 0xef;
+	}
+
+	/* For cros_ec_get_proto_info() with passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_add(test, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	cros_ec_proto_test_query_all_pretest(test);
+	ret = cros_ec_query_all(ec_dev);
+	KUNIT_EXPECT_EQ(test, ret, 0);
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_protocol_info));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+	}
+
+	/* For cros_ec_get_proto_info() with passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command,
+				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+				EC_CMD_GET_PROTOCOL_INFO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_protocol_info));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+
+		KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0);
+	}
+}
+
 static void cros_ec_proto_test_query_all_legacy_normal_v3_return_error(struct kunit *test)
 {
 	struct cros_ec_proto_test_priv *priv = test->priv;
@@ -472,6 +537,71 @@ static void cros_ec_proto_test_query_all_legacy_normal_v3_return_error(struct ku
 	}
 }
 
+static void cros_ec_proto_test_query_all_legacy_normal_v3_return0(struct kunit *test)
+{
+	struct cros_ec_proto_test_priv *priv = test->priv;
+	struct cros_ec_device *ec_dev = &priv->ec_dev;
+	struct ec_xfer_mock *mock;
+	int ret;
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_add(test, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	/* For cros_ec_host_command_proto_query_v2(). */
+	{
+		struct ec_response_hello *data;
+
+		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+		data = (struct ec_response_hello *)mock->o_data;
+		data->out_data = 0xa1b2c3d4;
+	}
+
+	cros_ec_proto_test_query_all_pretest(test);
+	ret = cros_ec_query_all(ec_dev);
+	KUNIT_EXPECT_EQ(test, ret, 0);
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_protocol_info));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+	}
+
+	/* For cros_ec_host_command_proto_query_v2(). */
+	{
+		struct ec_params_hello *data;
+
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
+
+		data = (struct ec_params_hello *)mock->i_data;
+		KUNIT_EXPECT_EQ(test, data->in_data, 0xa0b0c0d0);
+
+		KUNIT_EXPECT_EQ(test, ec_dev->proto_version, 2);
+		KUNIT_EXPECT_EQ(test, ec_dev->max_request, EC_PROTO2_MAX_PARAM_SIZE);
+		KUNIT_EXPECT_EQ(test, ec_dev->max_response, EC_PROTO2_MAX_PARAM_SIZE);
+		KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0);
+		KUNIT_EXPECT_PTR_EQ(test, ec_dev->pkt_xfer, NULL);
+		KUNIT_EXPECT_EQ(test, ec_dev->din_size, EC_PROTO2_MSG_BYTES);
+		KUNIT_EXPECT_EQ(test, ec_dev->dout_size, EC_PROTO2_MSG_BYTES);
+	}
+}
+
 static void cros_ec_proto_test_query_all_legacy_xfer_error(struct kunit *test)
 {
 	struct cros_ec_proto_test_priv *priv = test->priv;
@@ -999,7 +1129,9 @@ static struct kunit_case cros_ec_proto_test_cases[] = {
 	KUNIT_CASE(cros_ec_proto_test_check_result),
 	KUNIT_CASE(cros_ec_proto_test_query_all_normal),
 	KUNIT_CASE(cros_ec_proto_test_query_all_no_pd_return_error),
+	KUNIT_CASE(cros_ec_proto_test_query_all_no_pd_return0),
 	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_normal_v3_return_error),
+	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_normal_v3_return0),
 	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_xfer_error),
 	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return_error),
 	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_data_error),
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 8/23
#10 lore raw

Re: [PATCH v3 08/23] platform/chrome: cros_ec_proto: add Kunit tests for getting proto info

Quoted 9 lines · Tzung-Bi Shih

cros_ec_get_proto_info() expects to receive
sizeof(struct ec_response_get_protocol_info) from send_command(). The payload is valid only if the return value is positive.

Add Kunit tests for returning 0 from send_command() in cros_ec_get_proto_info().

Quoted 167 lines

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto_test.c | 132 +++++++++++++++++++
 1 file changed, 132 insertions(+)
drivers/platform/chrome/cros_ec_proto_test.c +132 -1
index 8b16666c1657..1378ac90e1cb 100644
@@ -407,6 +407,71 @@ static void cros_ec_proto_test_query_all_no_pd_return_error(struct kunit *test)
        }
 }
 
+static void cros_ec_proto_test_query_all_no_pd_return0(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* Set some garbage bytes. */
+       ec_dev->max_passthru = 0xbf;
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               struct ec_response_get_protocol_info *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               /*
+                * Although it doesn't check the value, provides valid sizes so that
+                * cros_ec_query_all() allocates din and dout correctly.
+                */
+               data = (struct ec_response_get_protocol_info *)mock->o_data;
+               data->max_request_packet_size = 0xbe;
+               data->max_response_packet_size = 0xef;
+       }
+
+       /* For cros_ec_get_proto_info() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_add(test, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_proto_info() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command,
+                               EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+                               EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+
+               KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0);
+       }
+}
+
 static void cros_ec_proto_test_query_all_legacy_normal_v3_return_error(struct kunit *test)
 {
        struct cros_ec_proto_test_priv *priv = test->priv;
@@ -472,6 +537,71 @@ static void cros_ec_proto_test_query_all_legacy_normal_v3_return_error(struct ku
        }
 }
 
+static void cros_ec_proto_test_query_all_legacy_normal_v3_return0(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_add(test, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_host_command_proto_query_v2(). */
+       {
+               struct ec_response_hello *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               data = (struct ec_response_hello *)mock->o_data;
+               data->out_data = 0xa1b2c3d4;
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_host_command_proto_query_v2(). */
+       {
+               struct ec_params_hello *data;
+
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
+
+               data = (struct ec_params_hello *)mock->i_data;
+               KUNIT_EXPECT_EQ(test, data->in_data, 0xa0b0c0d0);
+
+               KUNIT_EXPECT_EQ(test, ec_dev->proto_version, 2);
+               KUNIT_EXPECT_EQ(test, ec_dev->max_request, EC_PROTO2_MAX_PARAM_SIZE);
+               KUNIT_EXPECT_EQ(test, ec_dev->max_response, EC_PROTO2_MAX_PARAM_SIZE);
+               KUNIT_EXPECT_EQ(test, ec_dev->max_passthru, 0);
+               KUNIT_EXPECT_PTR_EQ(test, ec_dev->pkt_xfer, NULL);
+               KUNIT_EXPECT_EQ(test, ec_dev->din_size, EC_PROTO2_MSG_BYTES);
+               KUNIT_EXPECT_EQ(test, ec_dev->dout_size, EC_PROTO2_MSG_BYTES);
+       }
+}
+
 static void cros_ec_proto_test_query_all_legacy_xfer_error(struct kunit *test)
 {
        struct cros_ec_proto_test_priv *priv = test->priv;
@@ -999,7 +1129,9 @@ static struct kunit_case cros_ec_proto_test_cases[] = {
        KUNIT_CASE(cros_ec_proto_test_check_result),
        KUNIT_CASE(cros_ec_proto_test_query_all_normal),
        KUNIT_CASE(cros_ec_proto_test_query_all_no_pd_return_error),
+       KUNIT_CASE(cros_ec_proto_test_query_all_no_pd_return0),
        KUNIT_CASE(cros_ec_proto_test_query_all_legacy_normal_v3_return_error),
+       KUNIT_CASE(cros_ec_proto_test_query_all_legacy_normal_v3_return0),
        KUNIT_CASE(cros_ec_proto_test_query_all_legacy_xfer_error),
        KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return_error),
        KUNIT_CASE(cros_ec_proto_test_query_all_legacy_data_error),
--

2.36.1.255.ge46751e96f-goog

author maintainer
#11 lore raw

PATCH v3 9/23 platform/chrome: cros_ec_proto: handle empty payload in getting proto info

In reply to Tzung-Bi Shih

cros_ec_get_proto_info() expects to receive
sizeof(struct ec_response_get_protocol_info) from send_command(). The payload is valid only if the return value is positive.

Return -EPROTO if send_command() returns 0 in cros_ec_get_proto_info().

---
Changes from v2:
- Separate Kunit test to another patch.

 drivers/platform/chrome/cros_ec_proto.c | 5 +++++
 1 file changed, 5 insertions(+)
drivers/platform/chrome/cros_ec_proto.c +5 -0
index 893b76703da6..6f5be9e5ede4 100644
@@ -314,6 +314,11 @@ static int cros_ec_get_proto_info(struct cros_ec_device *ec_dev, int devidx)
 		goto exit;
 	}
 
+	if (ret == 0) {
+		ret = -EPROTO;
+		goto exit;
+	}
+
 	info = (struct ec_response_get_protocol_info *)msg->data;
 
 	switch (devidx) {
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 9/23
#12 lore raw

Re: [PATCH v3 09/23] platform/chrome: cros_ec_proto: handle empty payload in getting proto info

Quoted 8 lines · Tzung-Bi Shih

cros_ec_get_proto_info() expects to receive
sizeof(struct ec_response_get_protocol_info) from send_command(). The payload is valid only if the return value is positive.

Return -EPROTO if send_command() returns 0 in cros_ec_get_proto_info().

Quoted 26 lines

---
Changes from v2:
- Separate Kunit test to another patch.

 drivers/platform/chrome/cros_ec_proto.c | 5 +++++
 1 file changed, 5 insertions(+)
drivers/platform/chrome/cros_ec_proto.c +5 -1
index 893b76703da6..6f5be9e5ede4 100644
@@ -314,6 +314,11 @@ static int cros_ec_get_proto_info(struct cros_ec_device *ec_dev, int devidx)
                goto exit;
        }
 
+       if (ret == 0) {
+               ret = -EPROTO;
+               goto exit;
+       }
+
        info = (struct ec_response_get_protocol_info *)msg->data;
 
        switch (devidx) {
--

2.36.1.255.ge46751e96f-goog

author maintainer
#13 lore raw

PATCH v3 10/23 platform/chrome: cros_ec_proto: separate cros_ec_get_proto_info_legacy()

In reply to Tzung-Bi Shih

Rename cros_ec_host_command_proto_query_v2() to cros_ec_get_proto_info_legacy() and make it responsible for setting ec_dev fields for EC protocol v2.

---
Changes from v2:
- Add R-b tag.

Changes from v1:
- Preserve the "cros_ec_" prefix.

 drivers/platform/chrome/cros_ec_proto.c      | 72 +++++++++-----------
 drivers/platform/chrome/cros_ec_proto_test.c | 22 +++---
 2 files changed, 44 insertions(+), 50 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +33 -39
index 6f5be9e5ede4..04b9704ed302 100644
@@ -351,51 +351,57 @@ static int cros_ec_get_proto_info(struct cros_ec_device *ec_dev, int devidx)
 	return ret;
 }
 
-static int cros_ec_host_command_proto_query_v2(struct cros_ec_device *ec_dev)
+static int cros_ec_get_proto_info_legacy(struct cros_ec_device *ec_dev)
 {
 	struct cros_ec_command *msg;
-	struct ec_params_hello *hello_params;
-	struct ec_response_hello *hello_response;
+	struct ec_params_hello *params;
+	struct ec_response_hello *response;
 	int ret;
-	int len = max(sizeof(*hello_params), sizeof(*hello_response));
 
-	msg = kmalloc(sizeof(*msg) + len, GFP_KERNEL);
+	ec_dev->proto_version = 2;
+
+	msg = kzalloc(sizeof(*msg) + max(sizeof(*params), sizeof(*response)), GFP_KERNEL);
 	if (!msg)
 		return -ENOMEM;
 
-	msg->version = 0;
 	msg->command = EC_CMD_HELLO;
-	hello_params = (struct ec_params_hello *)msg->data;
-	msg->outsize = sizeof(*hello_params);
-	hello_response = (struct ec_response_hello *)msg->data;
-	msg->insize = sizeof(*hello_response);
+	msg->insize = sizeof(*response);
+	msg->outsize = sizeof(*params);
 
-	hello_params->in_data = 0xa0b0c0d0;
+	params = (struct ec_params_hello *)msg->data;
+	params->in_data = 0xa0b0c0d0;
 
 	ret = send_command(ec_dev, msg);
-
 	if (ret < 0) {
-		dev_dbg(ec_dev->dev,
-			"EC failed to respond to v2 hello: %d\n",
-			ret);
+		dev_dbg(ec_dev->dev, "EC failed to respond to v2 hello: %d\n", ret);
 		goto exit;
-	} else if (msg->result != EC_RES_SUCCESS) {
-		dev_err(ec_dev->dev,
-			"EC responded to v2 hello with error: %d\n",
-			msg->result);
-		ret = msg->result;
+	}
+
+	ret = cros_ec_map_error(msg->result);
+	if (ret) {
+		dev_err(ec_dev->dev, "EC responded to v2 hello with error: %d\n", msg->result);
 		goto exit;
-	} else if (hello_response->out_data != 0xa1b2c3d4) {
+	}
+
+	response = (struct ec_response_hello *)msg->data;
+	if (response->out_data != 0xa1b2c3d4) {
 		dev_err(ec_dev->dev,
 			"EC responded to v2 hello with bad result: %u\n",
-			hello_response->out_data);
+			response->out_data);
 		ret = -EBADMSG;
 		goto exit;
 	}
 
-	ret = 0;
+	ec_dev->max_request = EC_PROTO2_MAX_PARAM_SIZE;
+	ec_dev->max_response = EC_PROTO2_MAX_PARAM_SIZE;
+	ec_dev->max_passthru = 0;
+	ec_dev->pkt_xfer = NULL;
+	ec_dev->din_size = EC_PROTO2_MSG_BYTES;
+	ec_dev->dout_size = EC_PROTO2_MSG_BYTES;
 
- exit:
+	dev_dbg(ec_dev->dev, "falling back to proto v2\n");
+	ret = 0;
+exit:
 	kfree(msg);
 	return ret;
 }
@@ -467,20 +473,8 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
 		cros_ec_get_proto_info(ec_dev, CROS_EC_DEV_PD_INDEX);
 	} else {
 		/* Try querying with a v2 hello message. */
-		ec_dev->proto_version = 2;
-		ret = cros_ec_host_command_proto_query_v2(ec_dev);
-
-		if (ret == 0) {
-			/* V2 hello succeeded. */
-			dev_dbg(ec_dev->dev, "falling back to proto v2\n");
-
-			ec_dev->max_request = EC_PROTO2_MAX_PARAM_SIZE;
-			ec_dev->max_response = EC_PROTO2_MAX_PARAM_SIZE;
-			ec_dev->max_passthru = 0;
-			ec_dev->pkt_xfer = NULL;
-			ec_dev->din_size = EC_PROTO2_MSG_BYTES;
-			ec_dev->dout_size = EC_PROTO2_MSG_BYTES;
-		} else {
+		ret = cros_ec_get_proto_info_legacy(ec_dev);
+		if (ret) {
 			/*
 			 * It's possible for a test to occur too early when
 			 * the EC isn't listening. If this happens, we'll
@@ -488,7 +482,7 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
 			 */
 			ec_dev->proto_version = EC_PROTO_VERSION_UNKNOWN;
 			dev_dbg(ec_dev->dev, "EC query failed: %d\n", ret);
-			goto exit;
+			return ret;
 		}
 	}
 
drivers/platform/chrome/cros_ec_proto_test.c +11 -11
index 1378ac90e1cb..8e47cb70dc8b 100644
@@ -485,7 +485,7 @@ static void cros_ec_proto_test_query_all_legacy_normal_v3_return_error(struct ku
 		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 	}
 
-	/* For cros_ec_host_command_proto_query_v2(). */
+	/* For cros_ec_get_proto_info_legacy(). */
 	{
 		struct ec_response_hello *data;
 
@@ -512,7 +512,7 @@ static void cros_ec_proto_test_query_all_legacy_normal_v3_return_error(struct ku
 		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 	}
 
-	/* For cros_ec_host_command_proto_query_v2(). */
+	/* For cros_ec_get_proto_info_legacy(). */
 	{
 		struct ec_params_hello *data;
 
@@ -550,7 +550,7 @@ static void cros_ec_proto_test_query_all_legacy_normal_v3_return0(struct kunit *
 		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 	}
 
-	/* For cros_ec_host_command_proto_query_v2(). */
+	/* For cros_ec_get_proto_info_legacy(). */
 	{
 		struct ec_response_hello *data;
 
@@ -577,7 +577,7 @@ static void cros_ec_proto_test_query_all_legacy_normal_v3_return0(struct kunit *
 		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 	}
 
-	/* For cros_ec_host_command_proto_query_v2(). */
+	/* For cros_ec_get_proto_info_legacy(). */
 	{
 		struct ec_params_hello *data;
 
@@ -615,7 +615,7 @@ static void cros_ec_proto_test_query_all_legacy_xfer_error(struct kunit *test)
 		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 	}
 
-	/* For cros_ec_host_command_proto_query_v2(). */
+	/* For cros_ec_get_proto_info_legacy(). */
 	{
 		mock = cros_kunit_ec_xfer_mock_addx(test, -EIO, EC_RES_SUCCESS, 0);
 		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
@@ -638,7 +638,7 @@ static void cros_ec_proto_test_query_all_legacy_xfer_error(struct kunit *test)
 		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 	}
 
-	/* For cros_ec_host_command_proto_query_v2(). */
+	/* For cros_ec_get_proto_info_legacy(). */
 	{
 		mock = cros_kunit_ec_xfer_mock_next();
 		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
@@ -663,7 +663,7 @@ static void cros_ec_proto_test_query_all_legacy_return_error(struct kunit *test)
 		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 	}
 
-	/* For cros_ec_host_command_proto_query_v2(). */
+	/* For cros_ec_get_proto_info_legacy(). */
 	{
 		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
 		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
@@ -671,7 +671,7 @@ static void cros_ec_proto_test_query_all_legacy_return_error(struct kunit *test)
 
 	cros_ec_proto_test_query_all_pretest(test);
 	ret = cros_ec_query_all(ec_dev);
-	KUNIT_EXPECT_EQ(test, ret, EC_RES_INVALID_COMMAND);
+	KUNIT_EXPECT_EQ(test, ret, -EOPNOTSUPP);
 	KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
 
 	/* For cros_ec_get_proto_info() without passthru. */
@@ -686,7 +686,7 @@ static void cros_ec_proto_test_query_all_legacy_return_error(struct kunit *test)
 		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 	}
 
-	/* For cros_ec_host_command_proto_query_v2(). */
+	/* For cros_ec_get_proto_info_legacy(). */
 	{
 		mock = cros_kunit_ec_xfer_mock_next();
 		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
@@ -711,7 +711,7 @@ static void cros_ec_proto_test_query_all_legacy_data_error(struct kunit *test)
 		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
 	}
 
-	/* For cros_ec_host_command_proto_query_v2(). */
+	/* For cros_ec_get_proto_info_legacy(). */
 	{
 		struct ec_response_hello *data;
 
@@ -739,7 +739,7 @@ static void cros_ec_proto_test_query_all_legacy_data_error(struct kunit *test)
 		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
 	}
 
-	/* For cros_ec_host_command_proto_query_v2(). */
+	/* For cros_ec_get_proto_info_legacy(). */
 	{
 		mock = cros_kunit_ec_xfer_mock_next();
 		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
Signature · 1 line
2.36.1.255.ge46751e96f-goog
author maintainer
#14 lore raw

PATCH v3 11/23 platform/chrome: cros_ec_proto: add Kunit test for getting legacy info

In reply to Tzung-Bi Shih

cros_ec_get_proto_info_legacy() expects to receive sizeof(struct ec_response_hello) from send_command(). The payload is valid only if the return value is positive.

Add a Kunit test for returning 0 from send_command() in cros_ec_get_proto_info_legacy().

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto_test.c | 49 ++++++++++++++++++++
 1 file changed, 49 insertions(+)
drivers/platform/chrome/cros_ec_proto_test.c +49 -0
index 8e47cb70dc8b..63071af81c94 100644
@@ -751,6 +751,54 @@ static void cros_ec_proto_test_query_all_legacy_data_error(struct kunit *test)
 	}
 }
 
+static void cros_ec_proto_test_query_all_legacy_return0(struct kunit *test)
+{
+	struct cros_ec_proto_test_priv *priv = test->priv;
+	struct cros_ec_device *ec_dev = &priv->ec_dev;
+	struct ec_xfer_mock *mock;
+	int ret;
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	/* For cros_ec_get_proto_info_legacy(). */
+	{
+		mock = cros_kunit_ec_xfer_mock_add(test, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	cros_ec_proto_test_query_all_pretest(test);
+	ret = cros_ec_query_all(ec_dev);
+	KUNIT_EXPECT_EQ(test, ret, -EPROTO);
+	KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_protocol_info));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+	}
+
+	/* For cros_ec_get_proto_info_legacy(). */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello));
+	}
+}
+
 static void cros_ec_proto_test_query_all_no_mkbp(struct kunit *test)
 {
 	struct cros_ec_proto_test_priv *priv = test->priv;
@@ -1135,6 +1183,7 @@ static struct kunit_case cros_ec_proto_test_cases[] = {
 	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_xfer_error),
 	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return_error),
 	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_data_error),
+	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return0),
 	KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp),
 	KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep),
 	KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error),
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 11/23
#15 lore raw

Re: [PATCH v3 11/23] platform/chrome: cros_ec_proto: add Kunit test for getting legacy info

Quoted 9 lines · Tzung-Bi Shih

cros_ec_get_proto_info_legacy() expects to receive sizeof(struct ec_response_hello) from send_command(). The payload is valid only if the return value is positive.

Add a Kunit test for returning 0 from send_command() in cros_ec_get_proto_info_legacy().

Quoted 76 lines

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto_test.c | 49 ++++++++++++++++++++
 1 file changed, 49 insertions(+)
drivers/platform/chrome/cros_ec_proto_test.c +49 -1
index 8e47cb70dc8b..63071af81c94 100644
@@ -751,6 +751,54 @@ static void cros_ec_proto_test_query_all_legacy_data_error(struct kunit *test)
        }
 }
 
+static void cros_ec_proto_test_query_all_legacy_return0(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_get_proto_info_legacy(). */
+       {
+               mock = cros_kunit_ec_xfer_mock_add(test, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, -EPROTO);
+       KUNIT_EXPECT_EQ(test, ec_dev->proto_version, EC_PROTO_VERSION_UNKNOWN);
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_proto_info_legacy(). */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HELLO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_hello));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_hello));
+       }
+}
+
 static void cros_ec_proto_test_query_all_no_mkbp(struct kunit *test)
 {
        struct cros_ec_proto_test_priv *priv = test->priv;
@@ -1135,6 +1183,7 @@ static struct kunit_case cros_ec_proto_test_cases[] = {
        KUNIT_CASE(cros_ec_proto_test_query_all_legacy_xfer_error),
        KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return_error),
        KUNIT_CASE(cros_ec_proto_test_query_all_legacy_data_error),
+       KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return0),
        KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp),
        KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep),
        KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error),
--

2.36.1.255.ge46751e96f-goog

author maintainer
#16 lore raw

PATCH v3 12/23 platform/chrome: cros_ec_proto: handle empty payload in getting info legacy

In reply to Tzung-Bi Shih

cros_ec_get_proto_info_legacy() expects to receive sizeof(struct ec_response_hello) from send_command(). The payload is valid only if the return value is positive.

Return -EPROTO if send_command() returns 0 in
cros_ec_get_proto_info_legacy().

---
Changes from v2:
- Separate Kunit test to another patch.

 drivers/platform/chrome/cros_ec_proto.c | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +9 -3
index 04b9704ed302..473654f50bca 100644
@@ -356,7 +356,7 @@ static int cros_ec_get_proto_info_legacy(struct cros_ec_device *ec_dev)
 	struct cros_ec_command *msg;
 	struct ec_params_hello *params;
 	struct ec_response_hello *response;
-	int ret;
+	int ret, mapped;
 
 	ec_dev->proto_version = 2;
 
@@ -377,12 +377,18 @@ static int cros_ec_get_proto_info_legacy(struct cros_ec_device *ec_dev)
 		goto exit;
 	}
 
-	ret = cros_ec_map_error(msg->result);
-	if (ret) {
+	mapped = cros_ec_map_error(msg->result);
+	if (mapped) {
+		ret = mapped;
 		dev_err(ec_dev->dev, "EC responded to v2 hello with error: %d\n", msg->result);
 		goto exit;
 	}
 
+	if (ret == 0) {
+		ret = -EPROTO;
+		goto exit;
+	}
+
 	response = (struct ec_response_hello *)msg->data;
 	if (response->out_data != 0xa1b2c3d4) {
 		dev_err(ec_dev->dev,
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 12/23
#17 lore raw

Re: [PATCH v3 12/23] platform/chrome: cros_ec_proto: handle empty payload in getting info legacy

Quoted 9 lines · Tzung-Bi Shih

cros_ec_get_proto_info_legacy() expects to receive sizeof(struct ec_response_hello) from send_command(). The payload is valid only if the return value is positive.

Return -EPROTO if send_command() returns 0 in
cros_ec_get_proto_info_legacy().

Quoted 44 lines

---
Changes from v2:
- Separate Kunit test to another patch.

 drivers/platform/chrome/cros_ec_proto.c | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +9 -4
index 04b9704ed302..473654f50bca 100644
@@ -356,7 +356,7 @@ static int cros_ec_get_proto_info_legacy(struct cros_ec_device *ec_dev)
        struct cros_ec_command *msg;
        struct ec_params_hello *params;
        struct ec_response_hello *response;
-       int ret;
+       int ret, mapped;
 
        ec_dev->proto_version = 2;
 
@@ -377,12 +377,18 @@ static int cros_ec_get_proto_info_legacy(struct cros_ec_device *ec_dev)
                goto exit;
        }
 
-       ret = cros_ec_map_error(msg->result);
-       if (ret) {
+       mapped = cros_ec_map_error(msg->result);
+       if (mapped) {
+               ret = mapped;
                dev_err(ec_dev->dev, "EC responded to v2 hello with error: %d\n", msg->result);
                goto exit;
        }
 
+       if (ret == 0) {
+               ret = -EPROTO;
+               goto exit;
+       }
+
        response = (struct ec_response_hello *)msg->data;
        if (response->out_data != 0xa1b2c3d4) {
                dev_err(ec_dev->dev,
--

2.36.1.255.ge46751e96f-goog

author maintainer
#18 lore raw

PATCH v3 13/23 platform/chrome: cros_ec: don't allocate `din` and `dout` in cros_ec_register()

In reply to Tzung-Bi Shih

Don't allocate din and dout in cros_ec_register() as they will be allocated soon in cros_ec_query_all().

---
No change from v2.

 drivers/platform/chrome/cros_ec.c | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)
drivers/platform/chrome/cros_ec.c +2 -8
index e51a3f2176c7..29d3b544dafb 100644
@@ -188,14 +188,8 @@ int cros_ec_register(struct cros_ec_device *ec_dev)
 	ec_dev->max_passthru = 0;
 	ec_dev->ec = NULL;
 	ec_dev->pd = NULL;
-
-	ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL);
-	if (!ec_dev->din)
-		return -ENOMEM;
-
-	ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL);
-	if (!ec_dev->dout)
-		return -ENOMEM;
+	ec_dev->din = NULL;
+	ec_dev->dout = NULL;
 
 	mutex_init(&ec_dev->lock);
 
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 13/23
#19 lore raw

Re: [PATCH v3 13/23] platform/chrome: cros_ec: don't allocate `din` and `dout` in cros_ec_register()

Quoted 5 lines · Tzung-Bi Shih

Don't allocate din and dout in cros_ec_register() as they will be allocated soon in cros_ec_query_all().

Quoted 30 lines

---
No change from v2.

 drivers/platform/chrome/cros_ec.c | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)
drivers/platform/chrome/cros_ec.c +2 -9
index e51a3f2176c7..29d3b544dafb 100644
@@ -188,14 +188,8 @@ int cros_ec_register(struct cros_ec_device *ec_dev)
        ec_dev->max_passthru = 0;
        ec_dev->ec = NULL;
        ec_dev->pd = NULL;
-
-       ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL);
-       if (!ec_dev->din)
-               return -ENOMEM;
-
-       ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL);
-       if (!ec_dev->dout)
-               return -ENOMEM;
+       ec_dev->din = NULL;
+       ec_dev->dout = NULL;
 
        mutex_init(&ec_dev->lock);
 
--

2.36.1.255.ge46751e96f-goog

author maintainer
#20 lore raw

Re: [PATCH v3 13/23] platform/chrome: cros_ec: don't allocate `din` and `dout` in cros_ec_register()

Quoted 4 lines · Guenter Roeck
Quoted 3 lines · Tzung-Bi Shih

Don't allocate din and dout in cros_ec_register() as they will be allocated soon in cros_ec_query_all().

Pardon me, I should test them earlier.

I misunderstood. The patch will cause kernel crash (NULL dereference) because cros_ec_query_all() relies on din and dout for getting protocol info and then it reallocates the buffers according to the info later.

I think we should just leave them as they are. Will drop this patch and next patch ([v3,14/23] platform/chrome: don't use devm variants for din and dout).

author maintainer
#21 lore raw

PATCH v3 14/23 platform/chrome: don't use devm variants for `din` and `dout`

In reply to Tzung-Bi Shih

Don't use devm variants because the two buffers could be re-allocated multiple times during runtime. Their life cycles aren't quite aligned to the device's.

Normally, free the memory if any when the ec_dev gets unregistered in cros_ec_unregister().

No need to free memory if kmalloc() fails. They will be freed eventually in either of the following:
- Error handling path in cros_ec_register().
- In cros_ec_unregister().
- Next kmalloc() in cros_ec_query_all().

---
Changes from v2:
- Don't use realloc.

Changes from v1:
- Don't use devm.
- Free in cros_ec_unregister().

 drivers/platform/chrome/cros_ec.c            |  4 +++
 drivers/platform/chrome/cros_ec_proto.c      | 29 ++++++++------------
 drivers/platform/chrome/cros_ec_proto_test.c |  4 +--
 3 files changed, 17 insertions(+), 20 deletions(-)
drivers/platform/chrome/cros_ec.c +4 -0
index 29d3b544dafb..fb8cb8a73295 100644
@@ -285,6 +285,8 @@ int cros_ec_register(struct cros_ec_device *ec_dev)
 exit:
 	platform_device_unregister(ec_dev->ec);
 	platform_device_unregister(ec_dev->pd);
+	kfree(ec_dev->din);
+	kfree(ec_dev->dout);
 	return err;
 }
 EXPORT_SYMBOL(cros_ec_register);
@@ -302,6 +304,8 @@ void cros_ec_unregister(struct cros_ec_device *ec_dev)
 	if (ec_dev->pd)
 		platform_device_unregister(ec_dev->pd);
 	platform_device_unregister(ec_dev->ec);
+	kfree(ec_dev->din);
+	kfree(ec_dev->dout);
 }
 EXPORT_SYMBOL(cros_ec_unregister);
 
drivers/platform/chrome/cros_ec_proto.c +11 -18
index 473654f50bca..8a53e989c7e2 100644
@@ -469,7 +469,6 @@ static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
  */
 int cros_ec_query_all(struct cros_ec_device *ec_dev)
 {
-	struct device *dev = ec_dev->dev;
 	u32 ver_mask = 0;
 	int ret;
 
@@ -492,21 +491,18 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
 		}
 	}
 
-	devm_kfree(dev, ec_dev->din);
-	devm_kfree(dev, ec_dev->dout);
+	kfree(ec_dev->din);
+	ec_dev->din = NULL;
+	kfree(ec_dev->dout);
+	ec_dev->dout = NULL;
 
-	ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL);
-	if (!ec_dev->din) {
-		ret = -ENOMEM;
-		goto exit;
-	}
+	ec_dev->din = kmalloc(ec_dev->din_size, GFP_KERNEL);
+	if (!ec_dev->din)
+		return -ENOMEM;
 
-	ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL);
-	if (!ec_dev->dout) {
-		devm_kfree(dev, ec_dev->din);
-		ret = -ENOMEM;
-		goto exit;
-	}
+	ec_dev->dout = kmalloc(ec_dev->dout_size, GFP_KERNEL);
+	if (!ec_dev->dout)
+		return -ENOMEM;
 
 	/* Probe if MKBP event is supported */
 	ret = cros_ec_get_host_command_version_mask(ec_dev,
@@ -555,10 +551,7 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
 				"failed to retrieve wake mask: %d\n", ret);
 	}
 
-	ret = 0;
-
-exit:
-	return ret;
+	return 0;
 }
 EXPORT_SYMBOL(cros_ec_query_all);
 
drivers/platform/chrome/cros_ec_proto_test.c +2 -2
index 63071af81c94..ec106d0f5648 100644
@@ -180,8 +180,8 @@ static void cros_ec_proto_test_query_all_pretest(struct kunit *test)
 
 	/*
 	 * cros_ec_query_all() will free din and dout and allocate them again to fit the usage by
-	 * calling devm_kfree() and devm_kzalloc().  Set them to NULL as they aren't managed by
-	 * ec_dev->dev but allocated statically in struct cros_ec_proto_test_priv
+	 * calling kfree() and kmalloc().  Set them to NULL as they aren't allocated by kmalloc()
+	 * but allocated statically in struct cros_ec_proto_test_priv
 	 * (see cros_ec_proto_test_init()).
 	 */
 	ec_dev->din = NULL;
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 14/23
#22 lore raw

Re: [PATCH v3 14/23] platform/chrome: don't use devm variants for `din` and `dout`

Quoted 8 lines · Tzung-Bi Shih

Don't use devm variants because the two buffers could be re-allocated multiple times during runtime. Their life cycles aren't quite aligned to the device's.

Normally, free the memory if any when the ec_dev gets unregistered in cros_ec_unregister().

Quoted 7 lines

No need to free memory if kmalloc() fails. They will be freed eventually in either of the following:
- Error handling path in cros_ec_register().
- In cros_ec_unregister().
- Next kmalloc() in cros_ec_query_all().

Quoted 109 lines

---
Changes from v2:
- Don't use realloc.

Changes from v1:
- Don't use devm.
- Free in cros_ec_unregister().

 drivers/platform/chrome/cros_ec.c            |  4 +++
 drivers/platform/chrome/cros_ec_proto.c      | 29 ++++++++------------
 drivers/platform/chrome/cros_ec_proto_test.c |  4 +--
 3 files changed, 17 insertions(+), 20 deletions(-)
drivers/platform/chrome/cros_ec.c +4 -0
index 29d3b544dafb..fb8cb8a73295 100644
@@ -285,6 +285,8 @@ int cros_ec_register(struct cros_ec_device *ec_dev)
 exit:
        platform_device_unregister(ec_dev->ec);
        platform_device_unregister(ec_dev->pd);
+       kfree(ec_dev->din);
+       kfree(ec_dev->dout);
        return err;
 }
 EXPORT_SYMBOL(cros_ec_register);
@@ -302,6 +304,8 @@ void cros_ec_unregister(struct cros_ec_device *ec_dev)
        if (ec_dev->pd)
                platform_device_unregister(ec_dev->pd);
        platform_device_unregister(ec_dev->ec);
+       kfree(ec_dev->din);
+       kfree(ec_dev->dout);
 }
 EXPORT_SYMBOL(cros_ec_unregister);
 
drivers/platform/chrome/cros_ec_proto.c +11 -18
index 473654f50bca..8a53e989c7e2 100644
@@ -469,7 +469,6 @@ static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
  */
 int cros_ec_query_all(struct cros_ec_device *ec_dev)
 {
-       struct device *dev = ec_dev->dev;
        u32 ver_mask = 0;
        int ret;
 
@@ -492,21 +491,18 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
                }
        }
 
-       devm_kfree(dev, ec_dev->din);
-       devm_kfree(dev, ec_dev->dout);
+       kfree(ec_dev->din);
+       ec_dev->din = NULL;
+       kfree(ec_dev->dout);
+       ec_dev->dout = NULL;
 
-       ec_dev->din = devm_kzalloc(dev, ec_dev->din_size, GFP_KERNEL);
-       if (!ec_dev->din) {
-               ret = -ENOMEM;
-               goto exit;
-       }
+       ec_dev->din = kmalloc(ec_dev->din_size, GFP_KERNEL);
+       if (!ec_dev->din)
+               return -ENOMEM;
 
-       ec_dev->dout = devm_kzalloc(dev, ec_dev->dout_size, GFP_KERNEL);
-       if (!ec_dev->dout) {
-               devm_kfree(dev, ec_dev->din);
-               ret = -ENOMEM;
-               goto exit;
-       }
+       ec_dev->dout = kmalloc(ec_dev->dout_size, GFP_KERNEL);
+       if (!ec_dev->dout)
+               return -ENOMEM;
 
        /* Probe if MKBP event is supported */
        ret = cros_ec_get_host_command_version_mask(ec_dev,
@@ -555,10 +551,7 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
                                "failed to retrieve wake mask: %d\n", ret);
        }
 
-       ret = 0;
-
-exit:
-       return ret;
+       return 0;
 }
 EXPORT_SYMBOL(cros_ec_query_all);
 
drivers/platform/chrome/cros_ec_proto_test.c +2 -3
index 63071af81c94..ec106d0f5648 100644
@@ -180,8 +180,8 @@ static void cros_ec_proto_test_query_all_pretest(struct kunit *test)
 
        /*
         * cros_ec_query_all() will free din and dout and allocate them again to fit the usage by
-        * calling devm_kfree() and devm_kzalloc().  Set them to NULL as they aren't managed by
-        * ec_dev->dev but allocated statically in struct cros_ec_proto_test_priv
+        * calling kfree() and kmalloc().  Set them to NULL as they aren't allocated by kmalloc()
+        * but allocated statically in struct cros_ec_proto_test_priv
         * (see cros_ec_proto_test_init()).
         */
        ec_dev->din = NULL;
--

2.36.1.255.ge46751e96f-goog

author maintainer
#23 lore raw

PATCH v3 15/23 platform/chrome: cros_ec_proto: don't show MKBP version if unsupported

In reply to Tzung-Bi Shih

It wrongly showed the following message when it doesn't support MKBP:
"MKBP support version 4294967295".

Fix it.

---
Changes from v2:
- Add R-b tag.

 drivers/platform/chrome/cros_ec_proto.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +4 -4
index 8a53e989c7e2..efbabdcb31ae 100644
@@ -508,13 +508,13 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
 	ret = cros_ec_get_host_command_version_mask(ec_dev,
 						    EC_CMD_GET_NEXT_EVENT,
 						    &ver_mask);
-	if (ret < 0 || ver_mask == 0)
+	if (ret < 0 || ver_mask == 0) {
 		ec_dev->mkbp_event_supported = 0;
-	else
+	} else {
 		ec_dev->mkbp_event_supported = fls(ver_mask);
 
-	dev_dbg(ec_dev->dev, "MKBP support version %u\n",
-		ec_dev->mkbp_event_supported - 1);
+		dev_dbg(ec_dev->dev, "MKBP support version %u\n", ec_dev->mkbp_event_supported - 1);
+	}
 
 	/* Probe if host sleep v1 is supported for S0ix failure detection. */
 	ret = cros_ec_get_host_command_version_mask(ec_dev,
Signature · 1 line
2.36.1.255.ge46751e96f-goog
author maintainer
#24 lore raw

PATCH v3 16/23 platform/chrome: cros_ec_proto: return 0 on getting cmd mask success

In reply to Tzung-Bi Shih

cros_ec_get_host_command_version_mask() used to return value from send_command() which is number of available bytes for input payload on success (i.e. sizeof(struct ec_response_get_cmd_versions)).

However, the callers don't need to know how many bytes are available.

Don't return number of available bytes. Instead, return 0 on success; otherwise, negative integers on error.

Also remove the unneeded ver_mask initialization as the callers should take it only if cros_ec_get_host_command_version_mask() returns 0.

---
Changes from v2:
- Separate Kunit test to another patch.
- Rephrase the commit message.

Changes from v1:
- Return 0 on success; otherwise, negative intergers.

 drivers/platform/chrome/cros_ec_proto.c | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +5 -8
index efbabdcb31ae..06bc7db1213e 100644
@@ -453,6 +453,7 @@ static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
 	if (ret > 0) {
 		rver = (struct ec_response_get_cmd_versions *)msg->data;
 		*mask = rver->version_mask;
+		ret = 0;
 	}
 
 	kfree(msg);
@@ -469,7 +470,7 @@ static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
  */
 int cros_ec_query_all(struct cros_ec_device *ec_dev)
 {
-	u32 ver_mask = 0;
+	u32 ver_mask;
 	int ret;
 
 	/* First try sending with proto v3. */
@@ -505,9 +506,7 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
 		return -ENOMEM;
 
 	/* Probe if MKBP event is supported */
-	ret = cros_ec_get_host_command_version_mask(ec_dev,
-						    EC_CMD_GET_NEXT_EVENT,
-						    &ver_mask);
+	ret = cros_ec_get_host_command_version_mask(ec_dev, EC_CMD_GET_NEXT_EVENT, &ver_mask);
 	if (ret < 0 || ver_mask == 0) {
 		ec_dev->mkbp_event_supported = 0;
 	} else {
@@ -517,10 +516,8 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
 	}
 
 	/* Probe if host sleep v1 is supported for S0ix failure detection. */
-	ret = cros_ec_get_host_command_version_mask(ec_dev,
-						    EC_CMD_HOST_SLEEP_EVENT,
-						    &ver_mask);
-	ec_dev->host_sleep_v1 = (ret >= 0 && (ver_mask & EC_VER_MASK(1)));
+	ret = cros_ec_get_host_command_version_mask(ec_dev, EC_CMD_HOST_SLEEP_EVENT, &ver_mask);
+	ec_dev->host_sleep_v1 = (ret == 0 && (ver_mask & EC_VER_MASK(1)));
 
 	/* Get host event wake mask. */
 	ret = cros_ec_get_host_event_wake_mask(ec_dev, &ec_dev->host_event_wake_mask);
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 16/23
#25 lore raw

Re: [PATCH v3 16/23] platform/chrome: cros_ec_proto: return 0 on getting cmd mask success

Quoted 5 lines · Tzung-Bi Shih

cros_ec_get_host_command_version_mask() used to return value from send_command() which is number of available bytes for input payload on success (i.e. sizeof(struct ec_response_get_cmd_versions)).

Quoted 7 lines

However, the callers don't need to know how many bytes are available.

Don't return number of available bytes. Instead, return 0 on success; otherwise, negative integers on error.

Also remove the unneeded ver_mask initialization as the callers should take it only if cros_ec_get_host_command_version_mask() returns 0.

Make sure this compiles with W=1. Compilers may think that ver_mask may be uninitialized when used.

Quoted 2 lines

Otherwise

Quoted 59 lines

---
Changes from v2:
- Separate Kunit test to another patch.
- Rephrase the commit message.

Changes from v1:
- Return 0 on success; otherwise, negative intergers.

 drivers/platform/chrome/cros_ec_proto.c | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +5 -9
index efbabdcb31ae..06bc7db1213e 100644
@@ -453,6 +453,7 @@ static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
        if (ret > 0) {
                rver = (struct ec_response_get_cmd_versions *)msg->data;
                *mask = rver->version_mask;
+               ret = 0;
        }
 
        kfree(msg);
@@ -469,7 +470,7 @@ static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
  */
 int cros_ec_query_all(struct cros_ec_device *ec_dev)
 {
-       u32 ver_mask = 0;
+       u32 ver_mask;
        int ret;
 
        /* First try sending with proto v3. */
@@ -505,9 +506,7 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
                return -ENOMEM;
 
        /* Probe if MKBP event is supported */
-       ret = cros_ec_get_host_command_version_mask(ec_dev,
-                                                   EC_CMD_GET_NEXT_EVENT,
-                                                   &ver_mask);
+       ret = cros_ec_get_host_command_version_mask(ec_dev, EC_CMD_GET_NEXT_EVENT, &ver_mask);
        if (ret < 0 || ver_mask == 0) {
                ec_dev->mkbp_event_supported = 0;
        } else {
@@ -517,10 +516,8 @@ int cros_ec_query_all(struct cros_ec_device *ec_dev)
        }
 
        /* Probe if host sleep v1 is supported for S0ix failure detection. */
-       ret = cros_ec_get_host_command_version_mask(ec_dev,
-                                                   EC_CMD_HOST_SLEEP_EVENT,
-                                                   &ver_mask);
-       ec_dev->host_sleep_v1 = (ret >= 0 && (ver_mask & EC_VER_MASK(1)));
+       ret = cros_ec_get_host_command_version_mask(ec_dev, EC_CMD_HOST_SLEEP_EVENT, &ver_mask);
+       ec_dev->host_sleep_v1 = (ret == 0 && (ver_mask & EC_VER_MASK(1)));
 
        /* Get host event wake mask. */
        ret = cros_ec_get_host_event_wake_mask(ec_dev, &ec_dev->host_event_wake_mask);
--

2.36.1.255.ge46751e96f-goog

author maintainer
#26 lore raw

Re: [PATCH v3 16/23] platform/chrome: cros_ec_proto: return 0 on getting cmd mask success

Quoted 8 lines · Guenter Roeck
Quoted 7 lines · Tzung-Bi Shih

cros_ec_get_host_command_version_mask() used to return value from send_command() which is number of available bytes for input payload on success (i.e. sizeof(struct ec_response_get_cmd_versions)).

However, the callers don't need to know how many bytes are available.

Quoted 8 lines
Quoted 5 lines

Don't return number of available bytes. Instead, return 0 on success; otherwise, negative integers on error.

Also remove the unneeded ver_mask initialization as the callers should take it only if cros_ec_get_host_command_version_mask() returns 0.

Make sure this compiles with W=1. Compilers may think that ver_mask may be uninitialized when used.

If I tested it correctly, it compiles.

$ make mrproper
$ make allmodconfig
$ make W=1 drivers/platform/chrome/
...
  CC      drivers/platform/chrome/cros_ec_proto.o
  CC      drivers/platform/chrome/cros_ec_trace.o
  AR      drivers/platform/chrome/built-in.a
  CC [M]  drivers/platform/chrome/chromeos_acpi.o
  CC [M]  drivers/platform/chrome/chromeos_laptop.o
  CC [M]  drivers/platform/chrome/chromeos_privacy_screen.o
  CC [M]  drivers/platform/chrome/chromeos_pstore.o
  CC [M]  drivers/platform/chrome/chromeos_tbmc.o
  CC [M]  drivers/platform/chrome/cros_ec.o
...
author maintainer
#27 lore raw

PATCH v3 17/23 platform/chrome: cros_ec_proto: add Kunit test for getting cmd mask error

In reply to Tzung-Bi Shih

cros_ec_query_all() uses cros_ec_get_host_command_version_mask() to query the supported MKBP version; cros_ec_get_host_command_version_mask() uses send_command() for transfering the host command.

Returning >=0 from send_command() only denotes the transfer was success. cros_ec_get_host_command_version_mask() should check if EC wasn't happy by checking msg->result.

Add a Kunit test for returning error in msg->result in cros_ec_get_host_command_version_mask(). For the case, cros_ec_query_all() should find the EC device doesn't support MKBP.

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto_test.c | 89 ++++++++++++++++++++
 1 file changed, 89 insertions(+)
drivers/platform/chrome/cros_ec_proto_test.c +89 -0
index ec106d0f5648..eb6d77b95c9f 100644
@@ -892,6 +892,94 @@ static void cros_ec_proto_test_query_all_no_mkbp(struct kunit *test)
 	}
 }
 
+static void cros_ec_proto_test_query_all_no_mkbp_return_error(struct kunit *test)
+{
+	struct cros_ec_proto_test_priv *priv = test->priv;
+	struct cros_ec_device *ec_dev = &priv->ec_dev;
+	struct ec_xfer_mock *mock;
+	int ret;
+
+	/* Set some garbage bytes. */
+	ec_dev->mkbp_event_supported = 0xbf;
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		struct ec_response_get_protocol_info *data;
+
+		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+		/*
+		 * Although it doesn't check the value, provides valid sizes so that
+		 * cros_ec_query_all() allocates din and dout correctly.
+		 */
+		data = (struct ec_response_get_protocol_info *)mock->o_data;
+		data->max_request_packet_size = 0xbe;
+		data->max_response_packet_size = 0xef;
+	}
+
+	/* For cros_ec_get_proto_info() with passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	/* For cros_ec_get_host_command_version_mask() for MKBP. */
+	{
+		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	cros_ec_proto_test_query_all_pretest(test);
+	ret = cros_ec_query_all(ec_dev);
+	KUNIT_EXPECT_EQ(test, ret, 0);
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_protocol_info));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+	}
+
+	/* For cros_ec_get_proto_info() with passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command,
+				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+				EC_CMD_GET_PROTOCOL_INFO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_protocol_info));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+	}
+
+	/* For cros_ec_get_host_command_version_mask() for MKBP. */
+	{
+		struct ec_params_get_cmd_versions *data;
+
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_cmd_versions));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
+
+		data = (struct ec_params_get_cmd_versions *)mock->i_data;
+		KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT);
+
+		KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 0);
+	}
+}
+
 static void cros_ec_proto_test_query_all_no_host_sleep(struct kunit *test)
 {
 	struct cros_ec_proto_test_priv *priv = test->priv;
@@ -1185,6 +1273,7 @@ static struct kunit_case cros_ec_proto_test_cases[] = {
 	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_data_error),
 	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return0),
 	KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp),
+	KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp_return_error),
 	KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep),
 	KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error),
 	{}
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 17/23
#28 lore raw

Re: [PATCH v3 17/23] platform/chrome: cros_ec_proto: add Kunit test for getting cmd mask error

Quoted 9 lines · Tzung-Bi Shih

cros_ec_query_all() uses cros_ec_get_host_command_version_mask() to query the supported MKBP version; cros_ec_get_host_command_version_mask() uses send_command() for transfering the host command.

Returning >=0 from send_command() only denotes the transfer was success. cros_ec_get_host_command_version_mask() should check if EC wasn't happy by checking msg->result.

Quoted 5 lines

Add a Kunit test for returning error in msg->result in cros_ec_get_host_command_version_mask(). For the case, cros_ec_query_all() should find the EC device doesn't support MKBP.

Quoted 116 lines

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto_test.c | 89 ++++++++++++++++++++
 1 file changed, 89 insertions(+)
drivers/platform/chrome/cros_ec_proto_test.c +89 -1
index ec106d0f5648..eb6d77b95c9f 100644
@@ -892,6 +892,94 @@ static void cros_ec_proto_test_query_all_no_mkbp(struct kunit *test)
        }
 }
 
+static void cros_ec_proto_test_query_all_no_mkbp_return_error(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* Set some garbage bytes. */
+       ec_dev->mkbp_event_supported = 0xbf;
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               struct ec_response_get_protocol_info *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               /*
+                * Although it doesn't check the value, provides valid sizes so that
+                * cros_ec_query_all() allocates din and dout correctly.
+                */
+               data = (struct ec_response_get_protocol_info *)mock->o_data;
+               data->max_request_packet_size = 0xbe;
+               data->max_response_packet_size = 0xef;
+       }
+
+       /* For cros_ec_get_proto_info() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_proto_info() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command,
+                               EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+                               EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               struct ec_params_get_cmd_versions *data;
+
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
+
+               data = (struct ec_params_get_cmd_versions *)mock->i_data;
+               KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT);
+
+               KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 0);
+       }
+}
+
 static void cros_ec_proto_test_query_all_no_host_sleep(struct kunit *test)
 {
        struct cros_ec_proto_test_priv *priv = test->priv;
@@ -1185,6 +1273,7 @@ static struct kunit_case cros_ec_proto_test_cases[] = {
        KUNIT_CASE(cros_ec_proto_test_query_all_legacy_data_error),
        KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return0),
        KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp),
+       KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp_return_error),
        KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep),
        KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error),
        {}
--

2.36.1.255.ge46751e96f-goog

author maintainer
#29 lore raw

PATCH v3 18/23 platform/chrome: cros_ec_proto: check `msg->result` in getting cmd mask

In reply to Tzung-Bi Shih

cros_ec_get_host_command_version_mask() should check if EC wasn't happy by checking msg->result.

Use cros_ec_map_error() and return the error code if any.

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto.c | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +13 -8
index 06bc7db1213e..6a5771361383 100644
@@ -428,13 +428,12 @@ static int cros_ec_get_proto_info_legacy(struct cros_ec_device *ec_dev)
  * the caller has ec_dev->lock mutex or the caller knows there is
  * no other command in progress.
  */
-static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
-	u16 cmd, u32 *mask)
+static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev, u16 cmd, u32 *mask)
 {
 	struct ec_params_get_cmd_versions *pver;
 	struct ec_response_get_cmd_versions *rver;
 	struct cros_ec_command *msg;
-	int ret;
+	int ret, mapped;
 
 	msg = kmalloc(sizeof(*msg) + max(sizeof(*rver), sizeof(*pver)),
 		      GFP_KERNEL);
@@ -450,14 +449,20 @@ static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
 	pver->cmd = cmd;
 
 	ret = send_command(ec_dev, msg);
-	if (ret > 0) {
-		rver = (struct ec_response_get_cmd_versions *)msg->data;
-		*mask = rver->version_mask;
-		ret = 0;
+	if (ret < 0)
+		goto exit;
+
+	mapped = cros_ec_map_error(msg->result);
+	if (mapped) {
+		ret = mapped;
+		goto exit;
 	}
 
+	rver = (struct ec_response_get_cmd_versions *)msg->data;
+	*mask = rver->version_mask;
+	ret = 0;
+exit:
 	kfree(msg);
-
 	return ret;
 }
 
Signature · 1 line
2.36.1.255.ge46751e96f-goog
#30 lore raw

Re: [PATCH v3 18/23] platform/chrome: cros_ec_proto: check `msg->result` in getting cmd mask

Quoted 40 lines · Tzung-Bi Shih

cros_ec_get_host_command_version_mask() should check if EC wasn't happy by checking msg->result.

Use cros_ec_map_error() and return the error code if any.

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto.c | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +2 -6
index 06bc7db1213e..6a5771361383 100644
@@ -428,13 +428,12 @@ static int cros_ec_get_proto_info_legacy(struct cros_ec_device *ec_dev)
  * the caller has ec_dev->lock mutex or the caller knows there is
  * no other command in progress.
  */
-static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
-       u16 cmd, u32 *mask)
+static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev, u16 cmd, u32 *mask)
 {
        struct ec_params_get_cmd_versions *pver;
        struct ec_response_get_cmd_versions *rver;
        struct cros_ec_command *msg;
-       int ret;
+       int ret, mapped;
 
        msg = kmalloc(sizeof(*msg) + max(sizeof(*rver), sizeof(*pver)),
                      GFP_KERNEL);
@@ -450,14 +449,20 @@ static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
        pver->cmd = cmd;
 
        ret = send_command(ec_dev, msg);
-       if (ret > 0) {
-               rver = (struct ec_response_get_cmd_versions *)msg->data;
-               *mask = rver->version_mask;

drivers/platform/chrome/cros_ec_proto.c static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev, · line 460

Quoted 10 lines
drivers/platform/chrome/cros_ec_proto.c +7 -1
-               ret = 0;
+       if (ret < 0)
+               goto exit;
+
+       mapped = cros_ec_map_error(msg->result);
+       if (mapped) {
+               ret = mapped;
+               goto exit;
        }
 

What if ret == 0 ? Is that valid ?

Thanks,
Guenter

Quoted 12 lines
drivers/platform/chrome/cros_ec_proto.c +4 -2
+       rver = (struct ec_response_get_cmd_versions *)msg->data;
+       *mask = rver->version_mask;
+       ret = 0;
+exit:
        kfree(msg);
-
        return ret;
 }
 
--

2.36.1.255.ge46751e96f-goog

Reviewed-by
#31 lore raw

Re: [PATCH v3 18/23] platform/chrome: cros_ec_proto: check `msg->result` in getting cmd mask

Quoted 38 lines · Guenter Roeck
Quoted 36 lines · Tzung-Bi Shih

cros_ec_get_host_command_version_mask() should check if EC wasn't happy by checking msg->result.

Use cros_ec_map_error() and return the error code if any.

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto.c | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +2 -3
index 06bc7db1213e..6a5771361383 100644
@@ -428,13 +428,12 @@ static int cros_ec_get_proto_info_legacy(struct cros_ec_device *ec_dev)
  * the caller has ec_dev->lock mutex or the caller knows there is
  * no other command in progress.
  */
-static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
-       u16 cmd, u32 *mask)
+static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev, u16 cmd, u32 *mask)
 {
        struct ec_params_get_cmd_versions *pver;
        struct ec_response_get_cmd_versions *rver;
        struct cros_ec_command *msg;
-       int ret;
+       int ret, mapped;
 
        msg = kmalloc(sizeof(*msg) + max(sizeof(*rver), sizeof(*pver)),
                      GFP_KERNEL);
@@ -450,14 +449,20 @@ static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
        pver->cmd = cmd;
 
Quoted 16 lines
Quoted 4 lines
drivers/platform/chrome/cros_ec_proto.c +0 -3
        ret = send_command(ec_dev, msg);
-       if (ret > 0) {
-               rver = (struct ec_response_get_cmd_versions *)msg->data;
-               *mask = rver->version_mask;

drivers/platform/chrome/cros_ec_proto.c static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev, · line 460

Quoted 10 lines
drivers/platform/chrome/cros_ec_proto.c +7 -1
-               ret = 0;
+       if (ret < 0)
+               goto exit;
+
+       mapped = cros_ec_map_error(msg->result);
+       if (mapped) {
+               ret = mapped;
+               goto exit;
        }
 

What if ret == 0 ? Is that valid ?

Never mind, addressed in a follow-up patch.

Quoted 15 lines

Thanks,
Guenter

Quoted 12 lines
drivers/platform/chrome/cros_ec_proto.c +4 -2
+       rver = (struct ec_response_get_cmd_versions *)msg->data;
+       *mask = rver->version_mask;
+       ret = 0;
+exit:
        kfree(msg);
-
        return ret;
 }
 
--

2.36.1.255.ge46751e96f-goog

author maintainer
#32 lore raw

PATCH v3 19/23 platform/chrome: cros_ec_proto: add Kunit tests for getting cmd mask

In reply to Tzung-Bi Shih

cros_ec_get_host_command_version_mask() expects to receive sizeof(struct ec_response_get_cmd_versions) from send_command(). The payload is valid only if the return value is positive.

Add Kunit tests for returning 0 from send_command() in cros_ec_get_host_command_version_mask().

Note that because the 2 cros_ec_get_host_command_version_mask() use the same ver_mask. cros_ec_proto_test_query_all_no_host_sleep_return0() polluates the ver_mask and returns 0 on the second send_command() to make sure the second cros_ec_get_host_command_version_mask() doesn't take the garbage from the previous call.

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto_test.c | 197 +++++++++++++++++++
 1 file changed, 197 insertions(+)
drivers/platform/chrome/cros_ec_proto_test.c +197 -0
index eb6d77b95c9f..c988ff1e2a5a 100644
@@ -980,6 +980,94 @@ static void cros_ec_proto_test_query_all_no_mkbp_return_error(struct kunit *test
 	}
 }
 
+static void cros_ec_proto_test_query_all_no_mkbp_return0(struct kunit *test)
+{
+	struct cros_ec_proto_test_priv *priv = test->priv;
+	struct cros_ec_device *ec_dev = &priv->ec_dev;
+	struct ec_xfer_mock *mock;
+	int ret;
+
+	/* Set some garbage bytes. */
+	ec_dev->mkbp_event_supported = 0xbf;
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		struct ec_response_get_protocol_info *data;
+
+		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+		/*
+		 * Although it doesn't check the value, provides valid sizes so that
+		 * cros_ec_query_all() allocates din and dout correctly.
+		 */
+		data = (struct ec_response_get_protocol_info *)mock->o_data;
+		data->max_request_packet_size = 0xbe;
+		data->max_response_packet_size = 0xef;
+	}
+
+	/* For cros_ec_get_proto_info() with passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	/* For cros_ec_get_host_command_version_mask() for MKBP. */
+	{
+		mock = cros_kunit_ec_xfer_mock_add(test, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	cros_ec_proto_test_query_all_pretest(test);
+	ret = cros_ec_query_all(ec_dev);
+	KUNIT_EXPECT_EQ(test, ret, 0);
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_protocol_info));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+	}
+
+	/* For cros_ec_get_proto_info() with passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command,
+				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+				EC_CMD_GET_PROTOCOL_INFO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_protocol_info));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+	}
+
+	/* For cros_ec_get_host_command_version_mask() for MKBP. */
+	{
+		struct ec_params_get_cmd_versions *data;
+
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_cmd_versions));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
+
+		data = (struct ec_params_get_cmd_versions *)mock->i_data;
+		KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT);
+
+		KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 0);
+	}
+}
+
 static void cros_ec_proto_test_query_all_no_host_sleep(struct kunit *test)
 {
 	struct cros_ec_proto_test_priv *priv = test->priv;
@@ -1086,6 +1174,113 @@ static void cros_ec_proto_test_query_all_no_host_sleep(struct kunit *test)
 	}
 }
 
+static void cros_ec_proto_test_query_all_no_host_sleep_return0(struct kunit *test)
+{
+	struct cros_ec_proto_test_priv *priv = test->priv;
+	struct cros_ec_device *ec_dev = &priv->ec_dev;
+	struct ec_xfer_mock *mock;
+	int ret;
+
+	/* Set some garbage bytes. */
+	ec_dev->host_sleep_v1 = true;
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		struct ec_response_get_protocol_info *data;
+
+		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+		/*
+		 * Although it doesn't check the value, provides valid sizes so that
+		 * cros_ec_query_all() allocates din and dout correctly.
+		 */
+		data = (struct ec_response_get_protocol_info *)mock->o_data;
+		data->max_request_packet_size = 0xbe;
+		data->max_response_packet_size = 0xef;
+	}
+
+	/* For cros_ec_get_proto_info() with passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	/* For cros_ec_get_host_command_version_mask() for MKBP. */
+	{
+		struct ec_response_get_cmd_versions *data;
+
+		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+		/* In order to pollute next cros_ec_get_host_command_version_mask(). */
+		data = (struct ec_response_get_cmd_versions *)mock->o_data;
+		data->version_mask = 0xbeef;
+	}
+
+	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+	{
+		mock = cros_kunit_ec_xfer_mock_add(test, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	cros_ec_proto_test_query_all_pretest(test);
+	ret = cros_ec_query_all(ec_dev);
+	KUNIT_EXPECT_EQ(test, ret, 0);
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_protocol_info));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+	}
+
+	/* For cros_ec_get_proto_info() with passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command,
+				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+				EC_CMD_GET_PROTOCOL_INFO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_protocol_info));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+	}
+
+	/* For cros_ec_get_host_command_version_mask() for MKBP. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_cmd_versions));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
+	}
+
+	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_cmd_versions));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
+
+		KUNIT_EXPECT_FALSE(test, ec_dev->host_sleep_v1);
+	}
+}
+
 static void cros_ec_proto_test_query_all_default_wake_mask_return_error(struct kunit *test)
 {
 	struct cros_ec_proto_test_priv *priv = test->priv;
@@ -1274,7 +1469,9 @@ static struct kunit_case cros_ec_proto_test_cases[] = {
 	KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return0),
 	KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp),
 	KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp_return_error),
+	KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp_return0),
 	KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep),
+	KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep_return0),
 	KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error),
 	{}
 };
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 19/23
#33 lore raw

Re: [PATCH v3 19/23] platform/chrome: cros_ec_proto: add Kunit tests for getting cmd mask

Quoted 8 lines · Tzung-Bi Shih

cros_ec_get_host_command_version_mask() expects to receive sizeof(struct ec_response_get_cmd_versions) from send_command(). The payload is valid only if the return value is positive.

Add Kunit tests for returning 0 from send_command() in cros_ec_get_host_command_version_mask().

Quoted 7 lines

Note that because the 2 cros_ec_get_host_command_version_mask() use the same ver_mask. cros_ec_proto_test_query_all_no_host_sleep_return0() polluates the ver_mask and returns 0 on the second send_command() to make sure the second cros_ec_get_host_command_version_mask() doesn't take the garbage from the previous call.

Quoted 232 lines

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto_test.c | 197 +++++++++++++++++++
 1 file changed, 197 insertions(+)
drivers/platform/chrome/cros_ec_proto_test.c +197 -1
index eb6d77b95c9f..c988ff1e2a5a 100644
@@ -980,6 +980,94 @@ static void cros_ec_proto_test_query_all_no_mkbp_return_error(struct kunit *test
        }
 }
 
+static void cros_ec_proto_test_query_all_no_mkbp_return0(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* Set some garbage bytes. */
+       ec_dev->mkbp_event_supported = 0xbf;
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               struct ec_response_get_protocol_info *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               /*
+                * Although it doesn't check the value, provides valid sizes so that
+                * cros_ec_query_all() allocates din and dout correctly.
+                */
+               data = (struct ec_response_get_protocol_info *)mock->o_data;
+               data->max_request_packet_size = 0xbe;
+               data->max_response_packet_size = 0xef;
+       }
+
+       /* For cros_ec_get_proto_info() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               mock = cros_kunit_ec_xfer_mock_add(test, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_proto_info() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command,
+                               EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+                               EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               struct ec_params_get_cmd_versions *data;
+
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(*data));
+
+               data = (struct ec_params_get_cmd_versions *)mock->i_data;
+               KUNIT_EXPECT_EQ(test, data->cmd, EC_CMD_GET_NEXT_EVENT);
+
+               KUNIT_EXPECT_EQ(test, ec_dev->mkbp_event_supported, 0);
+       }
+}
+
 static void cros_ec_proto_test_query_all_no_host_sleep(struct kunit *test)
 {
        struct cros_ec_proto_test_priv *priv = test->priv;
@@ -1086,6 +1174,113 @@ static void cros_ec_proto_test_query_all_no_host_sleep(struct kunit *test)
        }
 }
 
+static void cros_ec_proto_test_query_all_no_host_sleep_return0(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* Set some garbage bytes. */
+       ec_dev->host_sleep_v1 = true;
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               struct ec_response_get_protocol_info *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               /*
+                * Although it doesn't check the value, provides valid sizes so that
+                * cros_ec_query_all() allocates din and dout correctly.
+                */
+               data = (struct ec_response_get_protocol_info *)mock->o_data;
+               data->max_request_packet_size = 0xbe;
+               data->max_response_packet_size = 0xef;
+       }
+
+       /* For cros_ec_get_proto_info() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               struct ec_response_get_cmd_versions *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               /* In order to pollute next cros_ec_get_host_command_version_mask(). */
+               data = (struct ec_response_get_cmd_versions *)mock->o_data;
+               data->version_mask = 0xbeef;
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+       {
+               mock = cros_kunit_ec_xfer_mock_add(test, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_proto_info() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command,
+                               EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+                               EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
+
+               KUNIT_EXPECT_FALSE(test, ec_dev->host_sleep_v1);
+       }
+}
+
 static void cros_ec_proto_test_query_all_default_wake_mask_return_error(struct kunit *test)
 {
        struct cros_ec_proto_test_priv *priv = test->priv;
@@ -1274,7 +1469,9 @@ static struct kunit_case cros_ec_proto_test_cases[] = {
        KUNIT_CASE(cros_ec_proto_test_query_all_legacy_return0),
        KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp),
        KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp_return_error),
+       KUNIT_CASE(cros_ec_proto_test_query_all_no_mkbp_return0),
        KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep),
+       KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep_return0),
        KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error),
        {}
 };
--

2.36.1.255.ge46751e96f-goog

author maintainer
#34 lore raw

PATCH v3 20/23 platform/chrome: cros_ec_proto: handle empty payload in getting cmd mask

In reply to Tzung-Bi Shih

cros_ec_get_host_command_version_mask() expects to receive sizeof(struct ec_response_get_cmd_versions) from send_command(). The payload is valid only if the return value is positive.

Return -EPROTO if send_command() returns 0 in
cros_ec_get_host_command_version_mask().

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto.c | 5 +++++
 1 file changed, 5 insertions(+)
drivers/platform/chrome/cros_ec_proto.c +5 -0
index 6a5771361383..9e95f9e4b2f8 100644
@@ -458,6 +458,11 @@ static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
 		goto exit;
 	}
 
+	if (ret == 0) {
+		ret = -EPROTO;
+		goto exit;
+	}
+
 	rver = (struct ec_response_get_cmd_versions *)msg->data;
 	*mask = rver->version_mask;
 	ret = 0;
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 20/23
#35 lore raw

Re: [PATCH v3 20/23] platform/chrome: cros_ec_proto: handle empty payload in getting cmd mask

Quoted 9 lines · Tzung-Bi Shih

cros_ec_get_host_command_version_mask() expects to receive sizeof(struct ec_response_get_cmd_versions) from send_command(). The payload is valid only if the return value is positive.

Return -EPROTO if send_command() returns 0 in
cros_ec_get_host_command_version_mask().

That answers my previous question.

Quoted 25 lines

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto.c | 5 +++++
 1 file changed, 5 insertions(+)
drivers/platform/chrome/cros_ec_proto.c +5 -1
index 6a5771361383..9e95f9e4b2f8 100644
@@ -458,6 +458,11 @@ static int cros_ec_get_host_command_version_mask(struct cros_ec_device *ec_dev,
                goto exit;
        }
 
+       if (ret == 0) {
+               ret = -EPROTO;
+               goto exit;
+       }
+
        rver = (struct ec_response_get_cmd_versions *)msg->data;
        *mask = rver->version_mask;
        ret = 0;
--

2.36.1.255.ge46751e96f-goog

author maintainer
#36 lore raw

PATCH v3 21/23 platform/chrome: cros_ec_proto: return 0 on getting wake mask success

In reply to Tzung-Bi Shih

cros_ec_get_host_event_wake_mask() used to return value from send_command() which is number of bytes for input payload on success (i.e. sizeof(struct ec_response_host_event_mask)).

However, the callers don't need to know how many bytes are available.

Don't return number of available bytes. Instead, return 0 on success; otherwise, negative integers on error.

---
Changes from v2:
- Separate Kunit test to another patch.

Changes from v1:
- Return 0 on success; otherwise, negative intergers.

 drivers/platform/chrome/cros_ec_proto.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/platform/chrome/cros_ec_proto.c +2 -1
index 9e95f9e4b2f8..68a411e84744 100644
@@ -236,7 +236,7 @@ EXPORT_SYMBOL(cros_ec_check_result);
  *
  * @ec_dev: EC device to call
  * @msg: message structure to use
- * @mask: result when function returns >=0.
+ * @mask: result when function returns 0.
  *
  * LOCKING:
  * the caller has ec_dev->lock mutex, or the caller knows there is
@@ -266,6 +266,7 @@ static int cros_ec_get_host_event_wake_mask(struct cros_ec_device *ec_dev, uint3
 	if (ret > 0) {
 		r = (struct ec_response_host_event_mask *)msg->data;
 		*mask = r->mask;
+		ret = 0;
 	}
 
 exit:
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 21/23
#37 lore raw

Re: [PATCH v3 21/23] platform/chrome: cros_ec_proto: return 0 on getting wake mask success

Quoted 11 lines · Tzung-Bi Shih

cros_ec_get_host_event_wake_mask() used to return value from send_command() which is number of bytes for input payload on success (i.e. sizeof(struct ec_response_host_event_mask)).

However, the callers don't need to know how many bytes are available.

Don't return number of available bytes. Instead, return 0 on success; otherwise, negative integers on error.

Quoted 34 lines

---
Changes from v2:
- Separate Kunit test to another patch.

Changes from v1:
- Return 0 on success; otherwise, negative intergers.

 drivers/platform/chrome/cros_ec_proto.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/platform/chrome/cros_ec_proto.c +2 -2
index 9e95f9e4b2f8..68a411e84744 100644
@@ -236,7 +236,7 @@ EXPORT_SYMBOL(cros_ec_check_result);
  *
  * @ec_dev: EC device to call
  * @msg: message structure to use
- * @mask: result when function returns >=0.
+ * @mask: result when function returns 0.
  *
  * LOCKING:
  * the caller has ec_dev->lock mutex, or the caller knows there is
@@ -266,6 +266,7 @@ static int cros_ec_get_host_event_wake_mask(struct cros_ec_device *ec_dev, uint3
        if (ret > 0) {
                r = (struct ec_response_host_event_mask *)msg->data;
                *mask = r->mask;
+               ret = 0;
        }
 
 exit:
--

2.36.1.255.ge46751e96f-goog

author maintainer
#38 lore raw

PATCH v3 22/23 platform/chrome: cros_ec_proto: add Kunit test for getting wake mask

In reply to Tzung-Bi Shih

cros_ec_get_host_event_wake_mask() expects to receive sizeof(struct ec_response_host_event_mask) from send_command(). The payload is valid only if the return value is positive.

Add Kunit tests for returning 0 from send_command() in cros_ec_get_host_event_wake_mask().

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto_test.c | 128 +++++++++++++++++++
 1 file changed, 128 insertions(+)
drivers/platform/chrome/cros_ec_proto_test.c +128 -0
index c988ff1e2a5a..6cd136ce9e50 100644
@@ -1408,6 +1408,133 @@ static void cros_ec_proto_test_query_all_default_wake_mask_return_error(struct k
 	}
 }
 
+static void cros_ec_proto_test_query_all_default_wake_mask_return0(struct kunit *test)
+{
+	struct cros_ec_proto_test_priv *priv = test->priv;
+	struct cros_ec_device *ec_dev = &priv->ec_dev;
+	struct ec_xfer_mock *mock;
+	int ret;
+
+	/* Set some garbage bytes. */
+	ec_dev->host_event_wake_mask = U32_MAX;
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		struct ec_response_get_protocol_info *data;
+
+		mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+		/*
+		 * Although it doesn't check the value, provides valid sizes so that
+		 * cros_ec_query_all() allocates din and dout correctly.
+		 */
+		data = (struct ec_response_get_protocol_info *)mock->o_data;
+		data->max_request_packet_size = 0xbe;
+		data->max_response_packet_size = 0xef;
+	}
+
+	/* For cros_ec_get_proto_info() with passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	/* For cros_ec_get_host_command_version_mask() for MKBP. */
+	{
+		mock = cros_kunit_ec_xfer_mock_add(test, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+	{
+		mock = cros_kunit_ec_xfer_mock_add(test, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	/* For get_host_event_wake_mask(). */
+	{
+		mock = cros_kunit_ec_xfer_mock_add(test, 0);
+		KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+	}
+
+	cros_ec_proto_test_query_all_pretest(test);
+	ret = cros_ec_query_all(ec_dev);
+	KUNIT_EXPECT_EQ(test, ret, 0);
+
+	/* For cros_ec_get_proto_info() without passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_protocol_info));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+	}
+
+	/* For cros_ec_get_proto_info() with passthru. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command,
+				EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+				EC_CMD_GET_PROTOCOL_INFO);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_protocol_info));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+	}
+
+	/* For cros_ec_get_host_command_version_mask() for MKBP. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_cmd_versions));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
+	}
+
+	/* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+	{
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize,
+				sizeof(struct ec_response_get_cmd_versions));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
+	}
+
+	/* For get_host_event_wake_mask(). */
+	{
+		u32 mask;
+
+		mock = cros_kunit_ec_xfer_mock_next();
+		KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+		KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+		KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HOST_EVENT_GET_WAKE_MASK);
+		KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_host_event_mask));
+		KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+
+		mask = ec_dev->host_event_wake_mask;
+		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_CLOSED), 0);
+		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED), 0);
+		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_LOW), 0);
+		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_CRITICAL), 0);
+		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY), 0);
+		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_PD_MCU), 0);
+		KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_STATUS), 0);
+	}
+}
+
 static void cros_ec_proto_test_release(struct device *dev)
 {
 }
@@ -1473,6 +1600,7 @@ static struct kunit_case cros_ec_proto_test_cases[] = {
 	KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep),
 	KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep_return0),
 	KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error),
+	KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return0),
 	{}
 };
 
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 22/23
#39 lore raw

Re: [PATCH v3 22/23] platform/chrome: cros_ec_proto: add Kunit test for getting wake mask

Quoted 9 lines · Tzung-Bi Shih

cros_ec_get_host_event_wake_mask() expects to receive sizeof(struct ec_response_host_event_mask) from send_command(). The payload is valid only if the return value is positive.

Add Kunit tests for returning 0 from send_command() in cros_ec_get_host_event_wake_mask().

Quoted 155 lines

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto_test.c | 128 +++++++++++++++++++
 1 file changed, 128 insertions(+)
drivers/platform/chrome/cros_ec_proto_test.c +128 -1
index c988ff1e2a5a..6cd136ce9e50 100644
@@ -1408,6 +1408,133 @@ static void cros_ec_proto_test_query_all_default_wake_mask_return_error(struct k
        }
 }
 
+static void cros_ec_proto_test_query_all_default_wake_mask_return0(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       struct ec_xfer_mock *mock;
+       int ret;
+
+       /* Set some garbage bytes. */
+       ec_dev->host_event_wake_mask = U32_MAX;
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               struct ec_response_get_protocol_info *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               /*
+                * Although it doesn't check the value, provides valid sizes so that
+                * cros_ec_query_all() allocates din and dout correctly.
+                */
+               data = (struct ec_response_get_protocol_info *)mock->o_data;
+               data->max_request_packet_size = 0xbe;
+               data->max_response_packet_size = 0xef;
+       }
+
+       /* For cros_ec_get_proto_info() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               mock = cros_kunit_ec_xfer_mock_add(test, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+       {
+               mock = cros_kunit_ec_xfer_mock_add(test, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For get_host_event_wake_mask(). */
+       {
+               mock = cros_kunit_ec_xfer_mock_add(test, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       cros_ec_proto_test_query_all_pretest(test);
+       ret = cros_ec_query_all(ec_dev);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       /* For cros_ec_get_proto_info() without passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_proto_info() with passthru. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command,
+                               EC_CMD_PASSTHRU_OFFSET(CROS_EC_DEV_PD_INDEX) |
+                               EC_CMD_GET_PROTOCOL_INFO);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_protocol_info));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for MKBP. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
+       }
+
+       /* For cros_ec_get_host_command_version_mask() for host sleep v1. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_GET_CMD_VERSIONS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_cmd_versions));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, sizeof(struct ec_params_get_cmd_versions));
+       }
+
+       /* For get_host_event_wake_mask(). */
+       {
+               u32 mask;
+
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+
+               KUNIT_EXPECT_EQ(test, mock->msg.version, 0);
+               KUNIT_EXPECT_EQ(test, mock->msg.command, EC_CMD_HOST_EVENT_GET_WAKE_MASK);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize, sizeof(struct ec_response_host_event_mask));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+
+               mask = ec_dev->host_event_wake_mask;
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_LID_CLOSED), 0);
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_AC_DISCONNECTED), 0);
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_LOW), 0);
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_CRITICAL), 0);
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY), 0);
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_PD_MCU), 0);
+               KUNIT_EXPECT_EQ(test, mask & EC_HOST_EVENT_MASK(EC_HOST_EVENT_BATTERY_STATUS), 0);
+       }
+}
+
 static void cros_ec_proto_test_release(struct device *dev)
 {
 }
@@ -1473,6 +1600,7 @@ static struct kunit_case cros_ec_proto_test_cases[] = {
        KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep),
        KUNIT_CASE(cros_ec_proto_test_query_all_no_host_sleep_return0),
        KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return_error),
+       KUNIT_CASE(cros_ec_proto_test_query_all_default_wake_mask_return0),
        {}
 };
 
--

2.36.1.255.ge46751e96f-goog

author maintainer
#40 lore raw

PATCH v3 23/23 platform/chrome: cros_ec_proto: handle empty payload in getting wake mask

In reply to Tzung-Bi Shih

cros_ec_get_host_event_wake_mask() expects to receive sizeof(struct ec_response_host_event_mask) from send_command(). The payload is valid only if the return value is positive.

Return -EPROTO if send_command() returns 0 in
cros_ec_get_host_event_wake_mask().

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto.c | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +14 -10
index 68a411e84744..5cbaaba26ff7 100644
@@ -256,19 +256,23 @@ static int cros_ec_get_host_event_wake_mask(struct cros_ec_device *ec_dev, uint3
 	msg->insize = sizeof(*r);
 
 	ret = send_command(ec_dev, msg);
-	if (ret >= 0) {
-		mapped = cros_ec_map_error(msg->result);
-		if (mapped) {
-			ret = mapped;
-			goto exit;
-		}
+	if (ret < 0)
+		goto exit;
+
+	mapped = cros_ec_map_error(msg->result);
+	if (mapped) {
+		ret = mapped;
+		goto exit;
 	}
-	if (ret > 0) {
-		r = (struct ec_response_host_event_mask *)msg->data;
-		*mask = r->mask;
-		ret = 0;
+
+	if (ret == 0) {
+		ret = -EPROTO;
+		goto exit;
 	}
 
+	r = (struct ec_response_host_event_mask *)msg->data;
+	*mask = r->mask;
+	ret = 0;
 exit:
 	kfree(msg);
 	return ret;
Signature · 1 line
2.36.1.255.ge46751e96f-goog
Reviewed-by on v3 23/23
#41 lore raw

Re: [PATCH v3 23/23] platform/chrome: cros_ec_proto: handle empty payload in getting wake mask

Quoted 9 lines · Tzung-Bi Shih

cros_ec_get_host_event_wake_mask() expects to receive sizeof(struct ec_response_host_event_mask) from send_command(). The payload is valid only if the return value is positive.

Return -EPROTO if send_command() returns 0 in
cros_ec_get_host_event_wake_mask().

Quoted 47 lines

---
No v2. New and separated from the original series.

 drivers/platform/chrome/cros_ec_proto.c | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)
drivers/platform/chrome/cros_ec_proto.c +14 -11
index 68a411e84744..5cbaaba26ff7 100644
@@ -256,19 +256,23 @@ static int cros_ec_get_host_event_wake_mask(struct cros_ec_device *ec_dev, uint3
        msg->insize = sizeof(*r);
 
        ret = send_command(ec_dev, msg);
-       if (ret >= 0) {
-               mapped = cros_ec_map_error(msg->result);
-               if (mapped) {
-                       ret = mapped;
-                       goto exit;
-               }
+       if (ret < 0)
+               goto exit;
+
+       mapped = cros_ec_map_error(msg->result);
+       if (mapped) {
+               ret = mapped;
+               goto exit;
        }
-       if (ret > 0) {
-               r = (struct ec_response_host_event_mask *)msg->data;
-               *mask = r->mask;
-               ret = 0;
+
+       if (ret == 0) {
+               ret = -EPROTO;
+               goto exit;
        }
 
+       r = (struct ec_response_host_event_mask *)msg->data;
+       *mask = r->mask;
+       ret = 0;
 exit:
        kfree(msg);
        return ret;
--

2.36.1.255.ge46751e96f-goog