[PATCH v11 07/10] arm_ffa: introduce sandbox test cases for UCLASS_FFA
Simon Glass
sjg at chromium.org
Wed Apr 19 03:50:01 CEST 2023
On Wed, 12 Apr 2023 at 03:43, Abdellatif El Khlifi
<abdellatif.elkhlifi at 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 at arm.com>
> Cc: Tom Rini <trini at konsulko.com>
> Cc: Simon Glass <sjg at chromium.org>
> Cc: Ilias Apalodimas <ilias.apalodimas at linaro.org>
> Cc: Jens Wiklander <jens.wiklander at linaro.org>
> Cc: Heinrich Schuchardt <xypron.glpk at 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 at 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 at 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 at 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 at arm.com>
> + *
> + * Authors:
> + * Abdellatif El Khlifi <abdellatif.elkhlifi at 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
More information about the U-Boot
mailing list