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

cros_ec_cmd_xfer() is the only exported function that calls static
function cros_ec_send_command().

Add Kunit tests for cros_ec_send_command() through calling
cros_ec_cmd_xfer().

Reviewed-by: Guenter Roeck <groeck@chromium.org>
Signed-off-by: Tzung-Bi Shih <tzungbi@kernel.org>
Link: https://lore.kernel.org/r/20220718050914.2267370-5-tzungbi@kernel.org

diff --git a/drivers/platform/chrome/cros_ec_proto_test.c b/drivers/platform/chrome/cros_ec_proto_test.c
index 33721607a5b9e7cfc19f0a86212e9f5cf33acf02..64100fd81c6aded230c9ac957fe71dcf9440d507 100644 (file)
--- a/drivers/platform/chrome/cros_ec_proto_test.c
+++ b/drivers/platform/chrome/cros_ec_proto_test.c
@@ -1680,6 +1680,262 @@ static void cros_ec_proto_test_cmd_xfer_excess_msg_outsize_with_passthru(struct
        KUNIT_EXPECT_EQ(test, ret, -EMSGSIZE);
 }
 
+static void cros_ec_proto_test_cmd_xfer_protocol_v3_normal(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       int ret;
+       struct cros_ec_command msg;
+
+       memset(&msg, 0, sizeof(msg));
+
+       ec_dev->proto_version = 3;
+       ec_dev->cmd_xfer = cros_kunit_ec_cmd_xfer_mock;
+       ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
+
+       ret = cros_ec_cmd_xfer(ec_dev, &msg);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       KUNIT_EXPECT_EQ(test, cros_kunit_ec_cmd_xfer_mock_called, 0);
+       KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 1);
+}
+
+static void cros_ec_proto_test_cmd_xfer_protocol_v3_no_op(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       int ret;
+       struct cros_ec_command msg;
+
+       memset(&msg, 0, sizeof(msg));
+
+       ec_dev->proto_version = 3;
+       ec_dev->cmd_xfer = cros_kunit_ec_cmd_xfer_mock;
+       ec_dev->pkt_xfer = NULL;
+
+       ret = cros_ec_cmd_xfer(ec_dev, &msg);
+       KUNIT_EXPECT_EQ(test, ret, -EIO);
+}
+
+static void cros_ec_proto_test_cmd_xfer_protocol_v2_normal(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       int ret;
+       struct cros_ec_command msg;
+
+       memset(&msg, 0, sizeof(msg));
+
+       ec_dev->proto_version = 2;
+       ec_dev->cmd_xfer = cros_kunit_ec_cmd_xfer_mock;
+       ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
+
+       ret = cros_ec_cmd_xfer(ec_dev, &msg);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       KUNIT_EXPECT_EQ(test, cros_kunit_ec_cmd_xfer_mock_called, 1);
+       KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 0);
+}
+
+static void cros_ec_proto_test_cmd_xfer_protocol_v2_no_op(struct kunit *test)
+{
+       struct cros_ec_proto_test_priv *priv = test->priv;
+       struct cros_ec_device *ec_dev = &priv->ec_dev;
+       int ret;
+       struct cros_ec_command msg;
+
+       memset(&msg, 0, sizeof(msg));
+
+       ec_dev->proto_version = 2;
+       ec_dev->cmd_xfer = NULL;
+       ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
+
+       ret = cros_ec_cmd_xfer(ec_dev, &msg);
+       KUNIT_EXPECT_EQ(test, ret, -EIO);
+}
+
+static void cros_ec_proto_test_cmd_xfer_in_progress_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;
+       struct cros_ec_command msg;
+
+       memset(&msg, 0, sizeof(msg));
+
+       ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
+
+       /* For the first host command to return EC_RES_IN_PROGRESS. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For EC_CMD_GET_COMMS_STATUS. */
+       {
+               struct ec_response_get_comms_status *data;
+
+               mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+               data = (struct ec_response_get_comms_status *)mock->o_data;
+               data->flags = 0;
+       }
+
+       ret = cros_ec_cmd_xfer(ec_dev, &msg);
+       KUNIT_EXPECT_EQ(test, ret, sizeof(struct ec_response_get_comms_status));
+
+       KUNIT_EXPECT_EQ(test, msg.result, EC_RES_SUCCESS);
+
+       /* For the first host command to return EC_RES_IN_PROGRESS. */
+       {
+               mock = cros_kunit_ec_xfer_mock_next();
+               KUNIT_EXPECT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For EC_CMD_GET_COMMS_STATUS. */
+       {
+               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_COMMS_STATUS);
+               KUNIT_EXPECT_EQ(test, mock->msg.insize,
+                               sizeof(struct ec_response_get_comms_status));
+               KUNIT_EXPECT_EQ(test, mock->msg.outsize, 0);
+       }
+
+       KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 2);
+}
+
+static void cros_ec_proto_test_cmd_xfer_in_progress_retries_eagain(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;
+       struct cros_ec_command msg;
+
+       memset(&msg, 0, sizeof(msg));
+
+       ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
+
+       /* For the first host command to return EC_RES_IN_PROGRESS. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */
+       cros_kunit_ec_xfer_mock_default_ret = -EAGAIN;
+
+       ret = cros_ec_cmd_xfer(ec_dev, &msg);
+       KUNIT_EXPECT_EQ(test, ret, -EAGAIN);
+
+       /* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */
+       KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 51);
+}
+
+static void cros_ec_proto_test_cmd_xfer_in_progress_retries_status_processing(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;
+       struct cros_ec_command msg;
+
+       memset(&msg, 0, sizeof(msg));
+
+       ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
+
+       /* For the first host command to return EC_RES_IN_PROGRESS. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */
+       {
+               struct ec_response_get_comms_status *data;
+               int i;
+
+               for (i = 0; i < 50; ++i) {
+                       mock = cros_kunit_ec_xfer_mock_add(test, sizeof(*data));
+                       KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+
+                       data = (struct ec_response_get_comms_status *)mock->o_data;
+                       data->flags |= EC_COMMS_STATUS_PROCESSING;
+               }
+       }
+
+       ret = cros_ec_cmd_xfer(ec_dev, &msg);
+       KUNIT_EXPECT_EQ(test, ret, sizeof(struct ec_response_get_comms_status));
+
+       KUNIT_EXPECT_EQ(test, msg.result, EC_RES_SUCCESS);
+
+       /* For EC_CMD_GET_COMMS_STATUS EC_COMMAND_RETRIES times. */
+       KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 51);
+}
+
+static void cros_ec_proto_test_cmd_xfer_in_progress_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;
+       struct cros_ec_command msg;
+
+       memset(&msg, 0, sizeof(msg));
+
+       /* For the first host command to return EC_RES_IN_PROGRESS. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For EC_CMD_GET_COMMS_STATUS. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, -EIO, EC_RES_SUCCESS, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       ret = cros_ec_cmd_xfer(ec_dev, &msg);
+       KUNIT_EXPECT_EQ(test, ret, -EIO);
+}
+
+static void cros_ec_proto_test_cmd_xfer_in_progress_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;
+       struct cros_ec_command msg;
+
+       memset(&msg, 0, sizeof(msg));
+
+       ec_dev->pkt_xfer = cros_kunit_ec_pkt_xfer_mock;
+
+       /* For the first host command to return EC_RES_IN_PROGRESS. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_IN_PROGRESS, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       /* For EC_CMD_GET_COMMS_STATUS. */
+       {
+               mock = cros_kunit_ec_xfer_mock_addx(test, 0, EC_RES_INVALID_COMMAND, 0);
+               KUNIT_ASSERT_PTR_NE(test, mock, NULL);
+       }
+
+       ret = cros_ec_cmd_xfer(ec_dev, &msg);
+       KUNIT_EXPECT_EQ(test, ret, 0);
+
+       KUNIT_EXPECT_EQ(test, msg.result, EC_RES_INVALID_COMMAND);
+
+       KUNIT_EXPECT_EQ(test, cros_kunit_ec_pkt_xfer_mock_called, 2);
+}
+
 static void cros_ec_proto_test_release(struct device *dev)
 {
 }
@@ -1750,6 +2006,15 @@ static struct kunit_case cros_ec_proto_test_cases[] = {
        KUNIT_CASE(cros_ec_proto_test_cmd_xfer_excess_msg_insize),
        KUNIT_CASE(cros_ec_proto_test_cmd_xfer_excess_msg_outsize_without_passthru),
        KUNIT_CASE(cros_ec_proto_test_cmd_xfer_excess_msg_outsize_with_passthru),
+       KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v3_normal),
+       KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v3_no_op),
+       KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v2_normal),
+       KUNIT_CASE(cros_ec_proto_test_cmd_xfer_protocol_v2_no_op),
+       KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_normal),
+       KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_retries_eagain),
+       KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_retries_status_processing),
+       KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_xfer_error),
+       KUNIT_CASE(cros_ec_proto_test_cmd_xfer_in_progress_return_error),
        {}
 };
 

diff --git a/drivers/platform/chrome/cros_kunit_util.c b/drivers/platform/chrome/cros_kunit_util.c
index e031777dea87c3d96d7837748183690be65fad65..3ede971e82eed6ccff5ad836e19c883f75bdd9da 100644 (file)
--- a/drivers/platform/chrome/cros_kunit_util.c
+++ b/drivers/platform/chrome/cros_kunit_util.c
@@ -15,6 +15,10 @@
 
 int cros_kunit_ec_xfer_mock_default_ret;
 EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_default_ret);
+int cros_kunit_ec_cmd_xfer_mock_called;
+EXPORT_SYMBOL_GPL(cros_kunit_ec_cmd_xfer_mock_called);
+int cros_kunit_ec_pkt_xfer_mock_called;
+EXPORT_SYMBOL_GPL(cros_kunit_ec_pkt_xfer_mock_called);
 
 static struct list_head cros_kunit_ec_xfer_mock_in;
 static struct list_head cros_kunit_ec_xfer_mock_out;
@@ -46,6 +50,20 @@ int cros_kunit_ec_xfer_mock(struct cros_ec_device *ec_dev, struct cros_ec_comman
 }
 EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock);
 
+int cros_kunit_ec_cmd_xfer_mock(struct cros_ec_device *ec_dev, struct cros_ec_command *msg)
+{
+       ++cros_kunit_ec_cmd_xfer_mock_called;
+       return cros_kunit_ec_xfer_mock(ec_dev, msg);
+}
+EXPORT_SYMBOL_GPL(cros_kunit_ec_cmd_xfer_mock);
+
+int cros_kunit_ec_pkt_xfer_mock(struct cros_ec_device *ec_dev, struct cros_ec_command *msg)
+{
+       ++cros_kunit_ec_pkt_xfer_mock_called;
+       return cros_kunit_ec_xfer_mock(ec_dev, msg);
+}
+EXPORT_SYMBOL_GPL(cros_kunit_ec_pkt_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);
@@ -90,6 +108,8 @@ EXPORT_SYMBOL_GPL(cros_kunit_ec_xfer_mock_next);
 void cros_kunit_mock_reset(void)
 {
        cros_kunit_ec_xfer_mock_default_ret = 0;
+       cros_kunit_ec_cmd_xfer_mock_called = 0;
+       cros_kunit_ec_pkt_xfer_mock_called = 0;
        INIT_LIST_HEAD(&cros_kunit_ec_xfer_mock_in);
        INIT_LIST_HEAD(&cros_kunit_ec_xfer_mock_out);
 }

diff --git a/drivers/platform/chrome/cros_kunit_util.h b/drivers/platform/chrome/cros_kunit_util.h
index 79c4525f873cc1d51e775a725c9afda81e29246a..ae4080cb13f14e8e0c63eaf5e1a81406e5c4e704 100644 (file)
--- a/drivers/platform/chrome/cros_kunit_util.h
+++ b/drivers/platform/chrome/cros_kunit_util.h
@@ -24,8 +24,12 @@ struct ec_xfer_mock {
 };
 
 extern int cros_kunit_ec_xfer_mock_default_ret;
+extern int cros_kunit_ec_cmd_xfer_mock_called;
+extern int cros_kunit_ec_pkt_xfer_mock_called;
 
 int cros_kunit_ec_xfer_mock(struct cros_ec_device *ec_dev, struct cros_ec_command *msg);
+int cros_kunit_ec_cmd_xfer_mock(struct cros_ec_device *ec_dev, struct cros_ec_command *msg);
+int cros_kunit_ec_pkt_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);