On Wed, 12 Apr 2023 at 03:43, Abdellatif El Khlifi abdellatif.elkhlifi@arm.com wrote:
Add functional test cases for the FF-A support
These tests rely on the FF-A sandbox emulator and FF-A sandbox driver which help in inspecting the FF-A communication.
Signed-off-by: Abdellatif El Khlifi abdellatif.elkhlifi@arm.com Cc: Tom Rini trini@konsulko.com Cc: Simon Glass sjg@chromium.org Cc: Ilias Apalodimas ilias.apalodimas@linaro.org Cc: Jens Wiklander jens.wiklander@linaro.org Cc: Heinrich Schuchardt xypron.glpk@gmx.de
Changelog:
v11:
- drop unmapping test (taken care of by the DM when removing the device)
- address nits
v10:
- use the FF-A driver Uclass operations
- use uclass_first_device()
- replace CONFIG_SANDBOX_FFA with CONFIG_ARM_FFA_TRANSPORT
- address nits
v9: align FF-A sandbox tests with FF-A discovery through DM
v8:
- update partition_info_get() second argument to be an SP count
- pass NULL device pointer to the FF-A bus discovery and operations
v7: set the tests to use 64-bit direct messaging
v4: align sandbox tests with the new FF-A driver interfaces and new way of error handling
v1: introduce sandbox tests
MAINTAINERS | 1 + doc/arch/arm64.ffa.rst | 1 + test/dm/Makefile | 2 + test/dm/ffa.c | 258 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 262 insertions(+) create mode 100644 test/dm/ffa.c
Reviewed-by: Simon Glass sjg@chromium.org
nits below
diff --git a/MAINTAINERS b/MAINTAINERS index d7caad3bd4..cd99e655db 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -276,6 +276,7 @@ F: doc/arch/arm64.ffa.rst F: doc/usage/cmd/armffa.rst F: drivers/firmware/arm-ffa/ F: include/arm_ffa.h +F: test/dm/ffa.c
ARM FREESCALE IMX M: Stefano Babic sbabic@denx.de diff --git a/doc/arch/arm64.ffa.rst b/doc/arch/arm64.ffa.rst index 431c29f921..fdcb008d72 100644 --- a/doc/arch/arm64.ffa.rst +++ b/doc/arch/arm64.ffa.rst @@ -38,6 +38,7 @@ The U-Boot FF-A support provides the following parts: FF-A ABIs inspection methods.
- An FF-A sandbox device driver for FF-A communication with the emulated Secure World. The driver leverages the FF-A Uclass to establish FF-A communication.
+- Sandbox FF-A test cases.
FF-A and SMC specifications
diff --git a/test/dm/Makefile b/test/dm/Makefile index 7a79b6e1a2..45563bdfb4 100644 --- a/test/dm/Makefile +++ b/test/dm/Makefile @@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0+ # # Copyright (c) 2013 Google, Inc +# Copyright 2022-2023 Arm Limited and/or its affiliates open-source-office@arm.com
obj-$(CONFIG_UT_DM) += test-dm.o
@@ -85,6 +86,7 @@ obj-$(CONFIG_POWER_DOMAIN) += power-domain.o obj-$(CONFIG_ACPI_PMC) += pmc.o obj-$(CONFIG_DM_PMIC) += pmic.o obj-$(CONFIG_DM_PWM) += pwm.o +obj-$(CONFIG_ARM_FFA_TRANSPORT) += ffa.o obj-$(CONFIG_QFW) += qfw.o obj-$(CONFIG_RAM) += ram.o obj-y += regmap.o diff --git a/test/dm/ffa.c b/test/dm/ffa.c new file mode 100644 index 0000000000..ace2582e22 --- /dev/null +++ b/test/dm/ffa.c @@ -0,0 +1,258 @@ +// SPDX-License-Identifier: GPL-2.0+ +/*
- Functional tests for UCLASS_FFA class
- Copyright 2022-2023 Arm Limited and/or its affiliates open-source-office@arm.com
- Authors:
- Abdellatif El Khlifi abdellatif.elkhlifi@arm.com
- */
+#include <common.h> +#include <console.h> +#include <dm.h> +#include <asm/sandbox_arm_ffa.h> +#include <asm/sandbox_arm_ffa_priv.h> +#include <dm/test.h> +#include <test/test.h> +#include <test/ut.h>
+/* Functional tests for the UCLASS_FFA */
+static int check_fwk_version(struct ffa_priv *uc_priv, struct unit_test_state *uts) +{
struct ffa_sandbox_data func_data;u32 fwk_version = 0;func_data.data0 = &fwk_version;func_data.data0_size = sizeof(fwk_version);ut_assertok(sandbox_query_ffa_emul_state(FFA_VERSION, &func_data));ut_asserteq(uc_priv->dscvry_info.fwk_version, fwk_version);return 0;+}
+static int check_endpoint_id(struct ffa_priv *uc_priv, struct unit_test_state *uts) +{
ut_asserteq(0, uc_priv->id);return 0;+}
+static int check_rxtxbuf(struct ffa_priv *uc_priv, struct unit_test_state *uts) +{
ut_assertnonnull(uc_priv->pair.rxbuf);ut_assertnonnull(uc_priv->pair.txbuf);return 0;+}
+static int check_features(struct ffa_priv *uc_priv, struct unit_test_state *uts) +{
ut_assert(uc_priv->pair.rxtx_min_pages == RXTX_4K ||uc_priv->pair.rxtx_min_pages == RXTX_16K ||uc_priv->pair.rxtx_min_pages == RXTX_64K);return 0;+}
+static int check_rxbuf_mapped_flag(u32 queried_func_id,
u8 rxbuf_mapped,struct unit_test_state *uts)+{
switch (queried_func_id) {case FFA_RXTX_MAP:ut_asserteq(1, rxbuf_mapped);break;case FFA_RXTX_UNMAP:ut_asserteq(0, rxbuf_mapped);break;default:ut_assert(false);}return 0;+}
+static int check_rxbuf_release_flag(u8 rxbuf_owned, struct unit_test_state *uts) +{
ut_asserteq(0, rxbuf_owned);return 0;+}
+static int test_ffa_msg_send_direct_req(u16 part_id, struct unit_test_state *uts) +{
struct ffa_send_direct_data msg;u8 cnt;struct udevice *dev;ut_assertok(uclass_first_device_err(UCLASS_FFA, &dev));ut_assertok(ffa_sync_send_receive(dev, part_id, &msg, 1));for (cnt = 0; cnt < sizeof(struct ffa_send_direct_data) / sizeof(u64); cnt++)ut_asserteq_64(-1UL, ((u64 *)&msg)[cnt]);return 0;+}
+static int test_partitions_and_comms(const char *service_uuid,
struct unit_test_state *uts)+{
struct ffa_partition_info parts_info[SANDBOX_SP_COUNT_PER_VALID_SERVICE] = {0};u32 count, info_idx, exp_info_idx, valid_sps = 0;struct udevice *dev;struct ffa_sandbox_data func_data;struct ffa_partitions *partitions;ut_assertok(uclass_first_device_err(UCLASS_FFA, &dev));/* Get from the driver the count of the SPs matching the UUID */ut_assertok(ffa_partition_info_get(dev, service_uuid, &count, NULL));/* Make sure partitions are detected */ut_asserteq(SANDBOX_SP_COUNT_PER_VALID_SERVICE, count);/* Ask the driver to fill the buffer with the SPs info */ut_assertok(ffa_partition_info_get(dev, service_uuid, &count, parts_info));/* SPs found , verify the partitions information */func_data.data0 = &partitions;func_data.data0_size = sizeof(struct ffa_partitions *);ut_assertok(sandbox_query_ffa_emul_state(FFA_PARTITION_INFO_GET, &func_data));for (info_idx = 0; info_idx < count ; info_idx++) {
Use i as the index var ?
for (exp_info_idx = 0;exp_info_idx < partitions->count;exp_info_idx++) {if (parts_info[info_idx].id ==partitions->descs[exp_info_idx].info.id) {valid_sps++;ut_asserteq_mem(&parts_info[info_idx],&partitions->descs[exp_info_idx].info,sizeof(struct ffa_partition_info));/* Send and receive data from the current partition */test_ffa_msg_send_direct_req(parts_info[info_idx].id, uts);}}}/* Verify expected partitions found in the emulated secure world */ut_asserteq(SANDBOX_SP_COUNT_PER_VALID_SERVICE, valid_sps);return 0;+}
+static int dm_test_ffa_ack(struct unit_test_state *uts) +{
struct ffa_priv *uc_priv;struct ffa_sandbox_data func_data;u8 rxbuf_flag = 0;const char *svc1_uuid = SANDBOX_SERVICE1_UUID;const char *svc2_uuid = SANDBOX_SERVICE2_UUID;struct udevice *dev;/* Test probing the sandbox FF-A bus */ut_assertok(uclass_first_device_err(UCLASS_FFA, &dev));/* Get a pointer to the sandbox FF-A bus private data */uc_priv = dev_get_uclass_priv(dev);/* Make sure the private data pointer is retrieved */ut_assertnonnull(uc_priv);/* Test FFA_VERSION */check_fwk_version(uc_priv, uts);/* Test FFA_ID_GET */check_endpoint_id(uc_priv, uts);/* Test FFA_FEATURES */check_features(uc_priv, uts);/* Test RX/TX buffers */check_rxtxbuf(uc_priv, uts);/* Test FFA_RXTX_MAP */func_data.data0 = &rxbuf_flag;func_data.data0_size = sizeof(rxbuf_flag);rxbuf_flag = 0;sandbox_query_ffa_emul_state(FFA_RXTX_MAP, &func_data);check_rxbuf_mapped_flag(FFA_RXTX_MAP, rxbuf_flag, uts);/* FFA_PARTITION_INFO_GET / FFA_MSG_SEND_DIRECT_REQ */test_partitions_and_comms(svc1_uuid, uts);/* Test FFA_RX_RELEASE */rxbuf_flag = 1;sandbox_query_ffa_emul_state(FFA_RX_RELEASE, &func_data);check_rxbuf_release_flag(rxbuf_flag, uts);/* FFA_PARTITION_INFO_GET / FFA_MSG_SEND_DIRECT_REQ */test_partitions_and_comms(svc2_uuid, uts);/* Test FFA_RX_RELEASE */rxbuf_flag = 1;ut_assertok(sandbox_query_ffa_emul_state(FFA_RX_RELEASE, &func_data));check_rxbuf_release_flag(rxbuf_flag, uts);return 0;+}
+DM_TEST(dm_test_ffa_ack, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC);
+static int dm_test_ffa_nack(struct unit_test_state *uts) +{
struct ffa_priv *uc_priv;const char *valid_svc_uuid = SANDBOX_SERVICE1_UUID;const char *unvalid_svc_uuid = SANDBOX_SERVICE3_UUID;const char *unvalid_svc_uuid_str = SANDBOX_SERVICE4_UUID;struct ffa_send_direct_data msg;int ret;u32 count;u16 part_id = 0;struct udevice *dev;/* Test probing the sandbox FF-A bus */ut_assertok(uclass_first_device_err(UCLASS_FFA, &dev));/* Get a pointer to the sandbox FF-A bus private data */uc_priv = dev_get_uclass_priv(dev);/* Make sure the private data pointer is retrieved */ut_assertnonnull(uc_priv);/* Query partitions count using invalid arguments */ret = ffa_partition_info_get(dev, unvalid_svc_uuid, NULL, NULL);ut_asserteq(-EINVAL, ret);/* Query partitions count using an invalid UUID string */ret = ffa_partition_info_get(dev, unvalid_svc_uuid_str, &count, NULL);ut_asserteq(-EINVAL, ret);/* Query partitions count using an invalid UUID (no matching SP) */count = 0;ret = ffa_partition_info_get(dev, unvalid_svc_uuid, &count, NULL);ut_assertok(count);
ut_assertok() is supposed to be used for error returns. So this should be:
ut_asserteq(0, count)
/* Query partitions count using a valid UUID */count = 0;ut_assertok(ffa_partition_info_get(dev, valid_svc_uuid, &count, NULL));/* Make sure partitions are detected */ut_asserteq(SANDBOX_SP_COUNT_PER_VALID_SERVICE, count);/* Send data to an invalid partition */ret = ffa_sync_send_receive(dev, part_id, &msg, 1);ut_asserteq(-EINVAL, ret);/* Send data to a valid partition */part_id = uc_priv->partitions.descs[0].info.id;ut_assertok(ffa_sync_send_receive(dev, part_id, &msg, 1));return 0;+}
+DM_TEST(dm_test_ffa_nack, UT_TESTF_SCAN_FDT | UT_TESTF_CONSOLE_REC);
2.25.1
Regards, Simon