Re: [PATCH v16 04/10] arm_ffa: introduce Arm FF-A support

Ilias Apalodimas
2023-07-27T09:57:10Z

On Wed, Jul 26, 2023 at 10:44:57AM +0100, Abdellatif El Khlifi wrote:
> Add Arm FF-A support implementing Arm Firmware Framework for Armv8-A v1.0
>
> The Firmware Framework for Arm A-profile processors (FF-A v1.0) [1]
> describes interfaces (ABIs) that standardize communication
> between the Secure World and Normal World leveraging TrustZone
> technology.
>
> This driver uses 64-bit registers as per SMCCCv1.2 spec and comes
> on top of the SMCCC layer. The driver provides the FF-A ABIs needed for
> querying the FF-A framework from the secure world.
>
> The driver uses SMC32 calling convention which means using the first
> 32-bit data of the Xn registers.
>
> All supported ABIs come with their 32-bit version except FFA_RXTX_MAP
> which has 64-bit version supported.
>
> Both 32-bit and 64-bit direct messaging are supported which allows both
> 32-bit and 64-bit clients to use the FF-A bus.
>
> FF-A is a discoverable bus and similar to architecture features.
> FF-A bus is discovered using ARM_SMCCC_FEATURES mechanism performed
> by the PSCI driver.
>
> Clients are able to probe then use the FF-A bus by calling the DM class
> searching APIs (e.g: uclass_first_device).
>
> The Secure World is considered as one entity to communicate with
> using the FF-A bus. FF-A communication is handled by one device and
> one instance (the bus). This FF-A driver takes care of all the
> interactions between Normal world and Secure World.
>
> The driver exports its operations to be used by upper layers.
>
> Exported operations:
>
> - ffa_partition_info_get
> - ffa_sync_send_receive
> - ffa_rxtx_unmap
>
> Generic FF-A methods are implemented in the Uclass (arm-ffa-uclass.c).
> Arm specific methods are implemented in the Arm driver (arm-ffa.c).
>
> For more details please refer to the driver documentation [2].
>
> [1]: https://developer.arm.com/documentation/den0077/latest/
> [2]: doc/arch/arm64.ffa.rst
>
> Signed-off-by: Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
> Reviewed-by: Simon Glass <sjg@chromium.org>
> Cc: Tom Rini <trini@konsulko.com>
> Cc: Ilias Apalodimas <ilias.apalodimas@linaro.org>
> Cc: Jens Wiklander <jens.wiklander@linaro.org>
> Cc: Heinrich Schuchardt <xypron.glpk@gmx.de>
>
> ---
>
> Changelog:
> ===============
>
> v13:
>
> * doc minor change: specify in the readme that the user
> should call ffa_rxtx_unmap() driver operation to unmap
> the RX/TX buffers on demand.
>
> v12:
>
> * remove dscvry_info
> * replace dscvry_info.invoke_ffa_fn() with a weak invoke_ffa_fn
> (user drivers can override it)
> * improve FFA_PARTITION_INFO_GET implementation
> (clients no longer need to calloc a buffer)
> * address nits
>
> v11:
>
> * move ffa_try_discovery() from the uclass to the Arm FF-A driver
> * rename ffa_try_discovery() to arm_ffa_discover()
> * pass dev as an argument of arm_ffa_discover()
> * add arm_ prefix to the Arm FF-A driver functions
> * add emul field in struct ffa_discovery_info
> * address nits
>
> v10:
>
> * provide the driver operations through the Uclass
> * move the generic FF-A methods to the Uclass
> * keep Arm specific methods in the Arm driver (arm-ffa.c)
> * rename core.c to arm-ffa.c
> * address nits
>
> v9:
>
> * integrate the FF-A bus discovery in the DM and use ARM_SMCCC_FEATURES for binding
>
> v8:
>
> * make ffa_get_partitions_info() second argument to be an SP count in both
> modes
> * update ffa_bus_prvdata_get() to return a pointer rather than a pointer
> address
> * remove packing from ffa_partition_info and ffa_send_direct_data structures
> * pass the FF-A bus device to the bus operations
>
> v7:
>
> * add support for 32-bit direct messaging
> * rename be_uuid_str_to_le_bin() to uuid_str_to_le_bin()
> * improve the declaration of error handling mapping
> * stating in doc/arch/arm64.ffa.rst that EFI runtime is not supported
>
> v6:
>
> * drop use of EFI runtime support (We decided with Linaro to add this later)
> * drop discovery from initcalls (discovery will be on demand by FF-A users)
> * set the alignment of the RX/TX buffers to the larger translation granule size
> * move FF-A RX/TX buffers unmapping at ExitBootServices() to a separate commit
> * update the documentation and move it to doc/arch/arm64.ffa.rst
>
> v4:
>
> * add doc/README.ffa.drv
> * moving the FF-A driver work to drivers/firmware/arm-ffa
> * use less #ifdefs in lib/efi_loader/efi_boottime.c and replace
> #if defined by #if CONFIG_IS_ENABLED
> * improving error handling by mapping the FF-A errors to standard errors
> and logs
> * replacing panics with an error log and returning an error code
> * improving features discovery in FFA_FEATURES by introducing
> rxtx_min_pages private data field
> * add ffa_remove and ffa_unbind functions
> * improve how the driver behaves when bus discovery is done more than
> once
>
> v3:
>
> * align the interfaces of the U-Boot FF-A driver with those in the linux
> FF-A driver
> * remove the FF-A helper layer
> * make the U-Boot FF-A driver independent from EFI
> * provide an optional config that enables copying the driver data to EFI
> runtime section at ExitBootServices service
> * use 64-bit version of FFA_RXTX_MAP, FFA_MSG_SEND_DIRECT_{REQ, RESP}
>
> v2:
>
> * make FF-A bus discoverable using device_{bind, probe} APIs
> * remove device tree support
>
> v1:
>
> * introduce FF-A bus driver with device tree support
>
> MAINTAINERS | 8 +
> doc/arch/arm64.ffa.rst | 238 ++++
> doc/arch/index.rst | 1 +
> drivers/Makefile | 1 +
> drivers/firmware/Kconfig | 1 +
> drivers/firmware/arm-ffa/Kconfig | 36 +
> drivers/firmware/arm-ffa/Makefile | 8 +
> drivers/firmware/arm-ffa/arm-ffa-uclass.c | 1065 +++++++++++++++++
> drivers/firmware/arm-ffa/arm-ffa.c | 104 ++
> .../firmware/arm-ffa/sandbox_arm_ffa_priv.h | 14 +
> include/arm_ffa.h | 213 ++++
> include/arm_ffa_priv.h | 246 ++++
> include/dm/uclass-id.h | 6 +
> 13 files changed, 1941 insertions(+)
> create mode 100644 doc/arch/arm64.ffa.rst
> create mode 100644 drivers/firmware/arm-ffa/Kconfig
> create mode 100644 drivers/firmware/arm-ffa/Makefile
> create mode 100644 drivers/firmware/arm-ffa/arm-ffa-uclass.c
> create mode 100644 drivers/firmware/arm-ffa/arm-ffa.c
> create mode 100644 drivers/firmware/arm-ffa/sandbox_arm_ffa_priv.h
> create mode 100644 include/arm_ffa.h
> create mode 100644 include/arm_ffa_priv.h
>
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 4324965d26..4fd5768de0 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -266,6 +266,14 @@ F: drivers/net/cortina_ni.h
> F: drivers/net/phy/ca_phy.c
> F: configs/cortina_presidio-asic-pnand_defconfig
>
> +ARM FF-A
> +M: Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
> +S: Maintained
> +F: doc/arch/arm64.ffa.rst
> +F: drivers/firmware/arm-ffa/
> +F: include/arm_ffa.h
> +F: include/sandbox_arm_ffa.h
> +
> ARM FREESCALE IMX
> M: Stefano Babic <sbabic@denx.de>
> M: Fabio Estevam <festevam@gmail.com>
> diff --git a/doc/arch/arm64.ffa.rst b/doc/arch/arm64.ffa.rst
> new file mode 100644
> index 0000000000..4f817f053c
> --- /dev/null
> +++ b/doc/arch/arm64.ffa.rst
> @@ -0,0 +1,238 @@
> +.. SPDX-License-Identifier: GPL-2.0+
> +
> +Arm FF-A Support
> +================
> +
> +Summary
> +-------
> +
> +FF-A stands for Firmware Framework for Arm A-profile processors.
> +
> +FF-A specifies interfaces that enable a pair of software execution environments aka partitions to
> +communicate with each other. A partition could be a VM in the Normal or Secure world, an
> +application in S-EL0, or a Trusted OS in S-EL1.
> +
> +The U-Boot FF-A support (the bus) implements the interfaces to communicate
> +with partitions in the Secure world aka Secure partitions (SPs).
> +
> +The FF-A support specifically focuses on communicating with SPs that
> +isolate portions of EFI runtime services that must run in a protected
> +environment which is inaccessible by the Host OS or Hypervisor.
> +Examples of such services are set/get variables.
> +
> +The FF-A support uses the SMC ABIs defined by the FF-A specification to:
> +
> +- Discover the presence of SPs of interest
> +- Access an SP's service through communication protocols
> + e.g. EFI MM communication protocol
> +
> +At this stage of development only EFI boot-time services are supported.
> +Runtime support will be added in future developments.
> +
> +The U-Boot FF-A support provides the following parts:
> +
> +- A Uclass driver providing generic FF-A methods.
> +- An Arm FF-A device driver providing Arm-specific methods and reusing the Uclass methods.
> +
> +FF-A and SMC specifications
> +-------------------------------------------
> +
> +The current implementation of the U-Boot FF-A support relies on
> +`FF-A v1.0 specification`_ and uses SMC32 calling convention which
> +means using the first 32-bit data of the Xn registers.
> +
> +At this stage we only need the FF-A v1.0 features.
> +
> +The FF-A support has been tested with OP-TEE which supports SMC32 calling
> +convention.
> +
> +Hypervisors are supported if they are configured to trap SMC calls.
> +
> +The FF-A support uses 64-bit registers as per `SMC Calling Convention v1.2 specification`_.
> +
> +Supported hardware
> +--------------------------------
> +
> +Aarch64 plaforms
> +
> +Configuration
> +----------------------
> +
> +CONFIG_ARM_FFA_TRANSPORT
> + Enables the FF-A support. Turn this on if you want to use FF-A
> + communication.
> + When using an Arm 64-bit platform, the Arm FF-A driver will be used.
> +
> +FF-A ABIs under the hood
> +---------------------------------------
> +
> +Invoking an FF-A ABI involves providing to the secure world/hypervisor the
> +expected arguments from the ABI.
> +
> +On an Arm 64-bit platform, the ABI arguments are stored in x0 to x7 registers.
> +Then, an SMC instruction is executed.
> +
> +At the secure side level or hypervisor the ABI is handled at a higher exception
> +level and the arguments are read and processed.
> +
> +The response is put back through x0 to x7 registers and control is given back
> +to the U-Boot Arm FF-A driver (non-secure world).
> +
> +The driver reads the response and processes it accordingly.
> +
> +This methodology applies to all the FF-A ABIs.
> +
> +FF-A bus discovery on Arm 64-bit platforms
> +---------------------------------------------
> +
> +When CONFIG_ARM_FFA_TRANSPORT is enabled, the FF-A bus is considered as
> +an architecture feature and discovered using ARM_SMCCC_FEATURES mechanism.
> +This discovery mechanism is performed by the PSCI driver.
> +
> +The PSCI driver comes with a PSCI device tree node which is the root node for all
> +architecture features including FF-A bus.
> +
> +::
> +
> + => dm tree
> +
> + Class Index Probed Driver Name
> + -----------------------------------------------------------
> + ...
> + firmware 0 [ + ] psci |-- psci
> + ffa 0 [ ] arm_ffa | `-- arm_ffa
> + ...
> +
> +The PSCI driver is bound to the PSCI device and when probed it tries to discover
> +the architecture features by calling a callback the features drivers provide.
> +
> +In case of FF-A, the callback is arm_ffa_is_supported() which tries to discover the
> +FF-A framework by querying the FF-A framework version from secure world using
> +FFA_VERSION ABI. When discovery is successful, the ARM_SMCCC_FEATURES
> +mechanism creates a U-Boot device for the FF-A bus and binds the Arm FF-A driver
> +with the device using device_bind_driver().
> +
> +At this stage the FF-A bus is registered with the DM and can be interacted with using
> +the DM APIs.
> +
> +Clients are able to probe then use the FF-A bus by calling uclass_first_device().
> +Please refer to the armffa command implementation as an example of how to probe
> +and interact with the FF-A bus.
> +
> +When calling uclass_first_device(), the FF-A driver is probed and ends up calling
> +ffa_do_probe() provided by the Uclass which does the following:
> +
> + - saving the FF-A framework version in uc_priv
> + - querying from secure world the u-boot endpoint ID
> + - querying from secure world the supported features of FFA_RXTX_MAP
> + - mapping the RX/TX buffers
> + - querying from secure world all the partitions information
> +
> +When one of the above actions fails, probing fails and the driver stays not active
> +and can be probed again if needed.
> +
> +Requirements for clients
> +-------------------------------------
> +
> +When using the FF-A bus with EFI, clients must query the SPs they are looking for
> +during EFI boot-time mode using the service UUID.
> +
> +The RX/TX buffers are only available at EFI boot-time. Querying partitions is
> +done at boot time and data is cached for future use.
> +
> +RX/TX buffers should be unmapped before EFI runtime mode starts.
> +The driver provides a bus operation for that called ffa_rxtx_unmap().
> +
> +The user should call ffa_rxtx_unmap() to unmap the RX/TX buffers when required
> +(e.g: at efi_exit_boot_services()).
> +
> +The Linux kernel allocates its own RX/TX buffers. To be able to register these kernel buffers
> +with secure world, the U-Boot's RX/TX buffers should be unmapped before EFI runtime starts.
> +
> +When invoking FF-A direct messaging, clients should specify which ABI protocol
> +they want to use (32-bit vs 64-bit). Selecting the protocol means using
> +the 32-bit or 64-bit version of FFA_MSG_SEND_DIRECT_{REQ, RESP}.
> +The calling convention between U-Boot and the secure world stays the same: SMC32.
> +
> +Requirements for user drivers
> +-------------------------------------
> +
> +Users who want to implement their custom FF-A device driver while reusing the FF-A Uclass can do so
> +by implementing their own invoke_ffa_fn() in the user driver.
> +
> +The bus driver layer
> +------------------------------
> +
> +FF-A support comes on top of the SMCCC layer and is implemented by the FF-A Uclass drivers/firmware/arm-ffa/arm-ffa-uclass.c
> +
> +The following features are provided:
> +
> +- Support for the 32-bit version of the following ABIs:
> +
> + - FFA_VERSION
> + - FFA_ID_GET
> + - FFA_FEATURES
> + - FFA_PARTITION_INFO_GET
> + - FFA_RXTX_UNMAP
> + - FFA_RX_RELEASE
> + - FFA_RUN
> + - FFA_ERROR
> + - FFA_SUCCESS
> + - FFA_INTERRUPT
> + - FFA_MSG_SEND_DIRECT_REQ
> + - FFA_MSG_SEND_DIRECT_RESP
> +
> +- Support for the 64-bit version of the following ABIs:
> +
> + - FFA_RXTX_MAP
> + - FFA_MSG_SEND_DIRECT_REQ
> + - FFA_MSG_SEND_DIRECT_RESP
> +
> +- Processing the received data from the secure world/hypervisor and caching it
> +
> +- Hiding from upper layers the FF-A protocol and registers details. Upper
> + layers focus on exchanged data, FF-A support takes care of how to transport
> + that to the secure world/hypervisor using FF-A
> +
> +- FF-A support provides driver operations to be used by upper layers:
> +
> + - ffa_partition_info_get
> + - ffa_sync_send_receive
> + - ffa_rxtx_unmap
> +
> +- FF-A bus discovery makes sure FF-A framework is responsive and compatible
> + with the driver
> +
> +- FF-A bus can be compiled and used without EFI
> +
> +Example of boot logs with FF-A enabled
> +--------------------------------------
> +
> +For example, when using FF-A with Corstone-1000 the logs are as follows:
> +
> +::
> +
> + U-Boot 2023.01 (May 10 2023 - 11:08:07 +0000) corstone1000 aarch64
> +
> + DRAM: 2 GiB
> + Arm FF-A framework discovery
> + FF-A driver 1.0
> + FF-A framework 1.0
> + FF-A versions are compatible
> + ...
> + FF-A driver 1.0
> + FF-A framework 1.0
> + FF-A versions are compatible
> + EFI: MM partition ID 0x8003
> + ...
> + EFI stub: Booting Linux Kernel...
> + ...
> + Linux version 6.1.9-yocto-standard (oe-user@oe-host) (aarch64-poky-linux-musl-gcc (GCC) 12.2.0, GNU ld (GNU Binutils) 2.40.202301193
> + Machine model: ARM Corstone1000 FPGA MPS3 board
> +
> +Contributors
> +------------
> + * Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
> +
> +.. _`FF-A v1.0 specification`: https://documentation-service.arm.com/static/5fb7e8a6ca04df4095c1d65e
> +.. _`SMC Calling Convention v1.2 specification`: https://documentation-service.arm.com/static/5f8edaeff86e16515cdbe4c6
> diff --git a/doc/arch/index.rst b/doc/arch/index.rst
> index b8da4b8c8e..2f916f4026 100644
> --- a/doc/arch/index.rst
> +++ b/doc/arch/index.rst
> @@ -8,6 +8,7 @@ Architecture-specific doc
>
> arc
> arm64
> + arm64.ffa
> m68k
> mips
> nios2
> diff --git a/drivers/Makefile b/drivers/Makefile
> index 78dcf62f76..5044f45253 100644
> --- a/drivers/Makefile
> +++ b/drivers/Makefile
> @@ -115,6 +115,7 @@ obj-y += iommu/
> obj-y += smem/
> obj-y += thermal/
> obj-$(CONFIG_TEE) += tee/
> +obj-$(CONFIG_ARM_FFA_TRANSPORT) += firmware/arm-ffa/
> obj-y += axi/
> obj-y += ufs/
> obj-$(CONFIG_W1) += w1/
> diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
> index eae1c8ddc9..8789b1ea14 100644
> --- a/drivers/firmware/Kconfig
> +++ b/drivers/firmware/Kconfig
> @@ -45,4 +45,5 @@ config ARM_SMCCC_FEATURES
> the PSCI driver is always probed and binds dirvers registered to the Arm SMCCC
> services if any and reported as supported by the SMCCC firmware.
>
> +source "drivers/firmware/arm-ffa/Kconfig"
> source "drivers/firmware/scmi/Kconfig"
> diff --git a/drivers/firmware/arm-ffa/Kconfig b/drivers/firmware/arm-ffa/Kconfig
> new file mode 100644
> index 0000000000..9200c8028b
> --- /dev/null
> +++ b/drivers/firmware/arm-ffa/Kconfig
> @@ -0,0 +1,36 @@
> +# SPDX-License-Identifier: GPL-2.0
> +
> +config ARM_FFA_TRANSPORT
> + bool "Enable Arm Firmware Framework for Armv8-A driver"
> + depends on DM && ARM64
> + select ARM_SMCCC
> + select ARM_SMCCC_FEATURES
> + select LIB_UUID
> + select DEVRES
> + help
> + The Firmware Framework for Arm A-profile processors (FF-A)
> + describes interfaces (ABIs) that standardize communication
> + between the Secure World and Normal World leveraging TrustZone
> + technology.
> +
> + The FF-A support in U-Boot is based on FF-A specification v1.0 and uses SMC32
> + calling convention.
> +
> + FF-A specification:
> +
> + https://developer.arm.com/documentation/den0077/a/?lang=en
> +
> + In U-Boot FF-A design, FF-A is considered as a discoverable bus.
> + FF-A bus is discovered using ARM_SMCCC_FEATURES mechanism performed
> + by the PSCI driver.
> + The Secure World is considered as one entity to communicate with
> + using the FF-A bus.
> + FF-A communication is handled by one device and one instance (the bus).
> + The FF-A support on U-Boot takes care of all the interactions between Normal
> + world and Secure World.
> +
> + Generic FF-A methods are implemented in the Uclass (arm-ffa-uclass.c).
> + Arm specific methods are implemented in the Arm driver (arm-ffa.c).
> +
> + For more details about the FF-A support, please refer to doc/arch/arm64.ffa.rst
> +
> diff --git a/drivers/firmware/arm-ffa/Makefile b/drivers/firmware/arm-ffa/Makefile
> new file mode 100644
> index 0000000000..11b1766285
> --- /dev/null
> +++ b/drivers/firmware/arm-ffa/Makefile
> @@ -0,0 +1,8 @@
> +# SPDX-License-Identifier: GPL-2.0+
> +#
> +# Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
> +#
> +# Authors:
> +# Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
> +
> +obj-y += arm-ffa-uclass.o arm-ffa.o
> diff --git a/drivers/firmware/arm-ffa/arm-ffa-uclass.c b/drivers/firmware/arm-ffa/arm-ffa-uclass.c
> new file mode 100644
> index 0000000000..ffa9d81fa7
> --- /dev/null
> +++ b/drivers/firmware/arm-ffa/arm-ffa-uclass.c
> @@ -0,0 +1,1065 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * 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 <arm_ffa.h>
> +#include <arm_ffa_priv.h>
> +#include <dm.h>
> +#include <log.h>
> +#include <malloc.h>
> +#include <string.h>
> +#include <uuid.h>
> +#include <asm/global_data.h>
> +#include <dm/device-internal.h>
> +#include <dm/devres.h>
> +#include <dm/root.h>
> +#include <linux/errno.h>
> +#include <linux/sizes.h>
> +
> +DECLARE_GLOBAL_DATA_PTR;
> +
> +/* Error mapping declarations */
> +
> +int ffa_to_std_errmap[MAX_NUMBER_FFA_ERR] = {
> + [NOT_SUPPORTED] = -EOPNOTSUPP,
> + [INVALID_PARAMETERS] = -EINVAL,
> + [NO_MEMORY] = -ENOMEM,
> + [BUSY] = -EBUSY,
> + [INTERRUPTED] = -EINTR,
> + [DENIED] = -EACCES,
> + [RETRY] = -EAGAIN,
> + [ABORTED] = -ECANCELED,
> +};
> +
> +static struct ffa_abi_errmap err_msg_map[FFA_ERRMAP_COUNT] = {
> + [FFA_ID_TO_ERRMAP_ID(FFA_VERSION)] = {
> + {
> + [NOT_SUPPORTED] =
> + "NOT_SUPPORTED: A Firmware Framework implementation does not exist",
> + },
> + },
> + [FFA_ID_TO_ERRMAP_ID(FFA_ID_GET)] = {
> + {
> + [NOT_SUPPORTED] =
> + "NOT_SUPPORTED: This function is not implemented at this FF-A instance",
> + },
> + },
> + [FFA_ID_TO_ERRMAP_ID(FFA_FEATURES)] = {
> + {
> + [NOT_SUPPORTED] =
> + "NOT_SUPPORTED: FFA_RXTX_MAP is not implemented at this FF-A instance",
> + },
> + },
> + [FFA_ID_TO_ERRMAP_ID(FFA_PARTITION_INFO_GET)] = {
> + {
> + [NOT_SUPPORTED] =
> + "NOT_SUPPORTED: This function is not implemented at this FF-A instance",
> + [INVALID_PARAMETERS] =
> + "INVALID_PARAMETERS: Unrecognized UUID",
> + [NO_MEMORY] =
> + "NO_MEMORY: Results cannot fit in RX buffer of the caller",
> + [BUSY] =
> + "BUSY: RX buffer of the caller is not free",
> + [DENIED] =
> + "DENIED: Callee is not in a state to handle this request",
> + },
> + },
> + [FFA_ID_TO_ERRMAP_ID(FFA_RXTX_UNMAP)] = {
> + {
> + [NOT_SUPPORTED] =
> + "NOT_SUPPORTED: FFA_RXTX_UNMAP is not implemented at this FF-A instance",
> + [INVALID_PARAMETERS] =
> + "INVALID_PARAMETERS: No buffer pair registered on behalf of the caller",
> + },
> + },
> + [FFA_ID_TO_ERRMAP_ID(FFA_RX_RELEASE)] = {
> + {
> + [NOT_SUPPORTED] =
> + "NOT_SUPPORTED: FFA_RX_RELEASE is not implemented at this FF-A instance",
> + [DENIED] =
> + "DENIED: Caller did not have ownership of the RX buffer",
> + },
> + },
> + [FFA_ID_TO_ERRMAP_ID(FFA_RXTX_MAP)] = {
> + {
> + [NOT_SUPPORTED] =
> + "NOT_SUPPORTED: This function is not implemented at this FF-A instance",
> + [INVALID_PARAMETERS] =
> + "INVALID_PARAMETERS: Field(s) in input parameters incorrectly encoded",
> + [NO_MEMORY] =
> + "NO_MEMORY: Not enough memory",
> + [DENIED] =
> + "DENIED: Buffer pair already registered",
> + },
> + },
> +};
> +
> +/**
> + * ffa_to_std_errno() - convert FF-A error code to standard error code
> + * @ffa_errno: Error code returned by the FF-A ABI
> + *
> + * Map the given FF-A error code as specified
> + * by the spec to a u-boot standard error code.
> + *
> + * Return:
> + *
> + * The standard error code on success. . Otherwise, failure
> + */
> +static int ffa_to_std_errno(int ffa_errno)
> +{
> + int err_idx = -ffa_errno;
> +
> + /* Map the FF-A error code to the standard u-boot error code */
> + if (err_idx > 0 && err_idx < MAX_NUMBER_FFA_ERR)
> + return ffa_to_std_errmap[err_idx];
> + return -EINVAL;
> +}
> +
> +/**
> + * ffa_print_error_log() - print the error log corresponding to the selected FF-A ABI
> + * @ffa_id: FF-A ABI ID
> + * @ffa_errno: Error code returned by the FF-A ABI
> + *
> + * Map the FF-A error code to the error log relevant to the
> + * selected FF-A ABI. Then the error log is printed.
> + *
> + * Return:
> + *
> + * 0 on success. . Otherwise, failure
> + */
> +static int ffa_print_error_log(u32 ffa_id, int ffa_errno)
> +{
> + int err_idx = -ffa_errno, abi_idx = 0;
> +
> + /* Map the FF-A error code to the corresponding error log */
> +
> + if (err_idx <= 0 || err_idx >= MAX_NUMBER_FFA_ERR)
> + return -EINVAL;
> +
> + if (ffa_id < FFA_FIRST_ID || ffa_id > FFA_LAST_ID)
> + return -EINVAL;
> +
> + abi_idx = FFA_ID_TO_ERRMAP_ID(ffa_id);
> + if (abi_idx < 0 || abi_idx >= FFA_ERRMAP_COUNT)
> + return -EINVAL;
> +
> + if (!err_msg_map[abi_idx].err_str[err_idx])
> + return -EINVAL;
> +
> + log_err("%s\n", err_msg_map[abi_idx].err_str[err_idx]);
> +
> + return 0;
> +}
> +
> +/* FF-A ABIs implementation (U-Boot side) */
> +
> +/**
> + * invoke_ffa_fn() - SMC wrapper
> + * @args: FF-A ABI arguments to be copied to Xn registers
> + * @res: FF-A ABI return data to be copied from Xn registers
> + *
> + * Calls low level SMC implementation.
> + * This function should be implemented by the user driver.
> + */
> +void __weak invoke_ffa_fn(ffa_value_t args, ffa_value_t *res)
> +{
> +}
> +
> +/**
> + * ffa_get_version_hdlr() - FFA_VERSION handler function
> + * @dev: The FF-A bus device
> + *
> + * Implement FFA_VERSION FF-A function
> + * to get from the secure world the FF-A framework version
> + * FFA_VERSION is used to discover the FF-A framework.
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +int ffa_get_version_hdlr(struct udevice *dev)
> +{
> + u16 major, minor;
> + ffa_value_t res = {0};
> + int ffa_errno;
> + struct ffa_priv *uc_priv;
> +
> + invoke_ffa_fn((ffa_value_t){
> + .a0 = FFA_SMC_32(FFA_VERSION), .a1 = FFA_VERSION_1_0,
> + }, &res);
> +
> + ffa_errno = res.a0;
> + if (ffa_errno < 0) {
> + ffa_print_error_log(FFA_VERSION, ffa_errno);
> + return ffa_to_std_errno(ffa_errno);
> + }
> +
> + major = GET_FFA_MAJOR_VERSION(res.a0);
> + minor = GET_FFA_MINOR_VERSION(res.a0);
> +
> + log_info("FF-A driver %d.%d\nFF-A framework %d.%d\n",
> + FFA_MAJOR_VERSION, FFA_MINOR_VERSION, major, minor);
> +
> + if (major == FFA_MAJOR_VERSION && minor >= FFA_MINOR_VERSION) {
> + log_info("FF-A versions are compatible\n");
> +
> + if (dev) {
> + uc_priv = dev_get_uclass_priv(dev);
> + if (uc_priv)
> + uc_priv->fwk_version = res.a0;
> + }
> +
> + return 0;
> + }
> +
> + log_err("versions are incompatible\nExpected: %d.%d , Found: %d.%d\n",
> + FFA_MAJOR_VERSION, FFA_MINOR_VERSION, major, minor);
> +
> + return -EPROTONOSUPPORT;
> +}
> +
> +/**
> + * ffa_get_endpoint_id() - FFA_ID_GET handler function
> + * @dev: The FF-A bus device
> + *
> + * Implement FFA_ID_GET FF-A function
> + * to get from the secure world u-boot endpoint ID
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +static int ffa_get_endpoint_id(struct udevice *dev)
> +{
> + ffa_value_t res = {0};
> + int ffa_errno;
> + struct ffa_priv *uc_priv = dev_get_uclass_priv(dev);
> +
> + invoke_ffa_fn((ffa_value_t){
> + .a0 = FFA_SMC_32(FFA_ID_GET),
> + }, &res);
> +
> + if (res.a0 == FFA_SMC_32(FFA_SUCCESS)) {
> + uc_priv->id = GET_SELF_ENDPOINT_ID((u32)res.a2);
> + log_debug("FF-A endpoint ID is %u\n", uc_priv->id);
> +
> + return 0;
> + }
> +
> + ffa_errno = res.a2;
> +
> + ffa_print_error_log(FFA_ID_GET, ffa_errno);
> +
> + return ffa_to_std_errno(ffa_errno);
> +}
> +
> +/**
> + * ffa_set_rxtx_buffers_pages_cnt() - set the minimum number of pages in each of the RX/TX buffers
> + * @dev: The FF-A bus device
> + * @prop_field: properties field obtained from FFA_FEATURES ABI
> + *
> + * Set the minimum number of pages in each of the RX/TX buffers in uc_priv
> + *
> + * Return:
> + *
> + * rxtx_min_pages field contains the returned number of pages
> + * 0 on success. Otherwise, failure
> + */
> +static int ffa_set_rxtx_buffers_pages_cnt(struct udevice *dev, u32 prop_field)
> +{
> + struct ffa_priv *uc_priv = dev_get_uclass_priv(dev);
> +
> + switch (prop_field) {
> + case RXTX_4K:
> + uc_priv->pair.rxtx_min_pages = 1;
> + break;
> + case RXTX_16K:
> + uc_priv->pair.rxtx_min_pages = 4;
> + break;
> + case RXTX_64K:
> + uc_priv->pair.rxtx_min_pages = 16;
> + break;
> + default:
> + log_err("RX/TX buffer size not supported\n");
> + return -EINVAL;
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * ffa_get_rxtx_map_features_hdlr() - FFA_FEATURES handler function with FFA_RXTX_MAP argument
> + * @dev: The FF-A bus device
> + *
> + * Implement FFA_FEATURES FF-A function to retrieve the FFA_RXTX_MAP features
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +static int ffa_get_rxtx_map_features_hdlr(struct udevice *dev)
> +{
> + ffa_value_t res = {0};
> + int ffa_errno;
> +
> + invoke_ffa_fn((ffa_value_t){
> + .a0 = FFA_SMC_32(FFA_FEATURES),
> + .a1 = FFA_SMC_64(FFA_RXTX_MAP),
> + }, &res);
> +
> + if (res.a0 == FFA_SMC_32(FFA_SUCCESS))
> + return ffa_set_rxtx_buffers_pages_cnt(dev, res.a2);
> +
> + ffa_errno = res.a2;
> + ffa_print_error_log(FFA_FEATURES, ffa_errno);
> +
> + return ffa_to_std_errno(ffa_errno);
> +}
> +
> +/**
> + * ffa_free_rxtx_buffers() - free the RX/TX buffers
> + * @dev: The FF-A bus device
> + *
> + * Free the RX/TX buffers
> + */
> +static void ffa_free_rxtx_buffers(struct udevice *dev)
> +{
> + struct ffa_priv *uc_priv = dev_get_uclass_priv(dev);
> +
> + log_debug("Freeing FF-A RX/TX buffers\n");
> +
> + if (uc_priv->pair.rxbuf) {
> + free(uc_priv->pair.rxbuf);
> + uc_priv->pair.rxbuf = NULL;
> + }
> +
> + if (uc_priv->pair.txbuf) {
> + free(uc_priv->pair.txbuf);
> + uc_priv->pair.txbuf = NULL;
> + }
> +}
> +
> +/**
> + * ffa_alloc_rxtx_buffers() - allocate the RX/TX buffers
> + * @dev: The FF-A bus device
> + *
> + * Used by ffa_map_rxtx_buffers to allocate
> + * the RX/TX buffers before mapping them. The allocated memory is physically
> + * contiguous since memalign ends up calling malloc which allocates
> + * contiguous memory in u-boot.
> + * The size of the memory allocated is the minimum allowed.
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +static int ffa_alloc_rxtx_buffers(struct udevice *dev)
> +{
> + u64 bytes;
> + struct ffa_priv *uc_priv = dev_get_uclass_priv(dev);
> +
> + log_debug("Using %lu 4KB page(s) for FF-A RX/TX buffers size\n",
> + uc_priv->pair.rxtx_min_pages);
> +
> + bytes = uc_priv->pair.rxtx_min_pages * SZ_4K;
> +
> + /*
> + * The alignment of the RX and TX buffers must be equal
> + * to the larger translation granule size
> + * Assumption: Memory allocated with memalign is always physically contiguous
> + */
> +
> + uc_priv->pair.rxbuf = memalign(bytes, bytes);
> + if (!uc_priv->pair.rxbuf) {
> + log_err("failure to allocate RX buffer\n");
> + return -ENOBUFS;
> + }
> +
> + log_debug("FF-A RX buffer at virtual address %p\n", uc_priv->pair.rxbuf);
> +
> + uc_priv->pair.txbuf = memalign(bytes, bytes);
> + if (!uc_priv->pair.txbuf) {
> + free(uc_priv->pair.rxbuf);
> + uc_priv->pair.rxbuf = NULL;
> + log_err("failure to allocate the TX buffer\n");
> + return -ENOBUFS;
> + }
> +
> + log_debug("FF-A TX buffer at virtual address %p\n", uc_priv->pair.txbuf);
> +
> + /* Make sure the buffers are cleared before use */
> + memset(uc_priv->pair.rxbuf, 0, bytes);
> + memset(uc_priv->pair.txbuf, 0, bytes);
> +
> + return 0;
> +}
> +
> +/**
> + * ffa_map_rxtx_buffers_hdlr() - FFA_RXTX_MAP handler function
> + * @dev: The FF-A bus device
> + *
> + * Implement FFA_RXTX_MAP FF-A function to map the RX/TX buffers
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +static int ffa_map_rxtx_buffers_hdlr(struct udevice *dev)
> +{
> + int ret;
> + ffa_value_t res = {0};
> + int ffa_errno;
> + struct ffa_priv *uc_priv = dev_get_uclass_priv(dev);
> +
> + ret = ffa_alloc_rxtx_buffers(dev);
> + if (ret)
> + return ret;
> +
> + /*
> + * we need to pass the physical addresses of the RX/TX buffers
> + * in u-boot physical/virtual mapping is 1:1
> + * no need to convert from virtual to physical
> + */
> +
> + invoke_ffa_fn((ffa_value_t){
> + .a0 = FFA_SMC_64(FFA_RXTX_MAP),
> + .a1 = map_to_sysmem(uc_priv->pair.txbuf),
> + .a2 = map_to_sysmem(uc_priv->pair.rxbuf),
> + .a3 = uc_priv->pair.rxtx_min_pages,
> + }, &res);
> +
> + if (res.a0 == FFA_SMC_32(FFA_SUCCESS)) {
> + log_debug("FF-A RX/TX buffers mapped\n");
> + return 0;
> + }
> +
> + ffa_errno = res.a2;
> + ffa_print_error_log(FFA_RXTX_MAP, ffa_errno);
> +
> + ffa_free_rxtx_buffers(dev);
> +
> + return ffa_to_std_errno(ffa_errno);
> +}
> +
> +/**
> + * ffa_unmap_rxtx_buffers_hdlr() - FFA_RXTX_UNMAP handler function
> + * @dev: The FF-A bus device
> + *
> + * Implement FFA_RXTX_UNMAP FF-A function to unmap the RX/TX buffers
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +int ffa_unmap_rxtx_buffers_hdlr(struct udevice *dev)
> +{
> + ffa_value_t res = {0};
> + int ffa_errno;
> + struct ffa_priv *uc_priv;
> +
> + log_debug("unmapping FF-A RX/TX buffers\n");
> +
> + uc_priv = dev_get_uclass_priv(dev);
> +
> + invoke_ffa_fn((ffa_value_t){
> + .a0 = FFA_SMC_32(FFA_RXTX_UNMAP),
> + .a1 = PREP_SELF_ENDPOINT_ID(uc_priv->id),
> + }, &res);
> +
> + if (res.a0 == FFA_SMC_32(FFA_SUCCESS)) {
> + ffa_free_rxtx_buffers(dev);
> + return 0;
> + }
> +
> + ffa_errno = res.a2;
> + ffa_print_error_log(FFA_RXTX_UNMAP, ffa_errno);
> +
> + return ffa_to_std_errno(ffa_errno);
> +}
> +
> +/**
> + * ffa_release_rx_buffer_hdlr() - FFA_RX_RELEASE handler function
> + * @dev: The FF-A bus device
> + *
> + * Invoke FFA_RX_RELEASE FF-A function to release the ownership of the RX buffer
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +static int ffa_release_rx_buffer_hdlr(struct udevice *dev)
> +{
> + ffa_value_t res = {0};
> + int ffa_errno;
> +
> + invoke_ffa_fn((ffa_value_t){
> + .a0 = FFA_SMC_32(FFA_RX_RELEASE),
> + }, &res);
> +
> + if (res.a0 == FFA_SMC_32(FFA_SUCCESS))
> + return 0;
> +
> + ffa_errno = res.a2;
> + ffa_print_error_log(FFA_RX_RELEASE, ffa_errno);
> +
> + return ffa_to_std_errno(ffa_errno);
> +}
> +
> +/**
> + * ffa_uuid_are_identical() - check whether two given UUIDs are identical
> + * @uuid1: first UUID
> + * @uuid2: second UUID
> + *
> + * Used by ffa_read_partitions_info to search for a UUID in the partitions descriptors table
> + *
> + * Return:
> + *
> + * 1 when UUIDs match. Otherwise, 0
> + */
> +static bool ffa_uuid_are_identical(const struct ffa_partition_uuid *uuid1,
> + const struct ffa_partition_uuid *uuid2)
> +{
> + if (!uuid1 || !uuid2)
> + return 0;
> +
> + return !memcmp(uuid1, uuid2, sizeof(struct ffa_partition_uuid));
> +}
> +
> +/**
> + * ffa_read_partitions_info() - read queried partition data
> + * @dev: The FF-A bus device
> + * @count: The number of partitions queried
> + * @part_uuid: Pointer to the partition(s) UUID
> + *
> + * Read the partitions information returned by the FFA_PARTITION_INFO_GET and saves it in uc_priv
> + *
> + * Return:
> + *
> + * uc_priv is updated with the partition(s) information
> + * 0 is returned on success. Otherwise, failure
> + */
> +static int ffa_read_partitions_info(struct udevice *dev, u32 count,
> + struct ffa_partition_uuid *part_uuid)
> +{
> + struct ffa_priv *uc_priv = dev_get_uclass_priv(dev);
> +
> + if (!count) {
> + log_err("no partition detected\n");
> + return -ENODATA;
> + }
> +
> + log_debug("Reading FF-A partitions data from the RX buffer\n");
> +
> + if (!part_uuid) {
> + /* Querying information of all partitions */
> + u64 buf_bytes;
> + u64 data_bytes;
> + u32 desc_idx;
> + struct ffa_partition_info *parts_info;
> +
> + data_bytes = count * sizeof(struct ffa_partition_desc);
> +
> + buf_bytes = uc_priv->pair.rxtx_min_pages * SZ_4K;
> +
> + if (data_bytes > buf_bytes) {
> + log_err("partitions data size exceeds the RX buffer size:\n");
> + log_err(" sizes in bytes: data %llu , RX buffer %llu\n",
> + data_bytes,
> + buf_bytes);
> +
> + return -ENOMEM;
> + }
> +
> + uc_priv->partitions.descs = devm_kmalloc(dev, data_bytes, __GFP_ZERO);
> + if (!uc_priv->partitions.descs) {
> + log_err("cannot allocate partitions data buffer\n");
> + return -ENOMEM;
> + }
> +
> + parts_info = uc_priv->pair.rxbuf;
> +
> + for (desc_idx = 0 ; desc_idx < count ; desc_idx++) {
> + uc_priv->partitions.descs[desc_idx].info =
> + parts_info[desc_idx];
> +
> + log_debug("FF-A partition ID %x : info cached\n",
> + uc_priv->partitions.descs[desc_idx].info.id);
> + }
> +
> + uc_priv->partitions.count = count;
> +
> + log_debug("%d FF-A partition(s) found and cached\n", count);
> +
> + } else {
> + u32 rx_desc_idx, cached_desc_idx;
> + struct ffa_partition_info *parts_info;
> + u8 desc_found;
> +
> + parts_info = uc_priv->pair.rxbuf;
> +
> + /*
> + * Search for the SP IDs read from the RX buffer
> + * in the already cached SPs.
> + * Update the UUID when ID found.
> + */
> + for (rx_desc_idx = 0; rx_desc_idx < count ; rx_desc_idx++) {
> + desc_found = 0;
> +
> + /* Search the current ID in the cached partitions */
> + for (cached_desc_idx = 0;
> + cached_desc_idx < uc_priv->partitions.count;
> + cached_desc_idx++) {
> + /* Save the UUID */
> + if (uc_priv->partitions.descs[cached_desc_idx].info.id ==
> + parts_info[rx_desc_idx].id) {
> + uc_priv->partitions.descs[cached_desc_idx].sp_uuid =
> + *part_uuid;
> +
> + desc_found = 1;
> + break;
> + }
> + }
> +
> + if (!desc_found)
> + return -ENODATA;
> + }
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * ffa_query_partitions_info() - invoke FFA_PARTITION_INFO_GET and save partitions data
> + * @dev: The FF-A bus device
> + * @part_uuid: Pointer to the partition(s) UUID
> + * @pcount: Pointer to the number of partitions variable filled when querying
> + *
> + * Execute the FFA_PARTITION_INFO_GET to query the partitions data.
> + * Then, call ffa_read_partitions_info to save the data in uc_priv.
> + *
> + * After reading the data the RX buffer is released using ffa_release_rx_buffer
> + *
> + * Return:
> + *
> + * When part_uuid is NULL, all partitions data are retrieved from secure world
> + * When part_uuid is non NULL, data for partitions matching the given UUID are
> + * retrieved and the number of partitions is returned
> + * 0 is returned on success. Otherwise, failure
> + */
> +static int ffa_query_partitions_info(struct udevice *dev, struct ffa_partition_uuid *part_uuid,
> + u32 *pcount)
> +{
> + struct ffa_partition_uuid query_uuid = {0};
> + ffa_value_t res = {0};
> + int ffa_errno;
> +
> + /*
> + * If a UUID is specified. Information for one or more
> + * partitions in the system is queried. Otherwise, information
> + * for all installed partitions is queried
> + */
> +
> + if (part_uuid) {
> + if (!pcount)
> + return -EINVAL;
> +
> + query_uuid = *part_uuid;
> + } else if (pcount) {
> + return -EINVAL;
> + }
> +
> + invoke_ffa_fn((ffa_value_t){
> + .a0 = FFA_SMC_32(FFA_PARTITION_INFO_GET),
> + .a1 = query_uuid.a1,
> + .a2 = query_uuid.a2,
> + .a3 = query_uuid.a3,
> + .a4 = query_uuid.a4,
> + }, &res);
> +
> + if (res.a0 == FFA_SMC_32(FFA_SUCCESS)) {
> + int ret;
> +
> + /*
> + * res.a2 contains the count of partition information descriptors
> + * populated in the RX buffer
> + */
> + if (res.a2) {
> + ret = ffa_read_partitions_info(dev, (u32)res.a2, part_uuid);
> + if (ret) {
> + log_err("failed reading SP(s) data , err (%d)\n", ret);
> + ffa_release_rx_buffer_hdlr(dev);
> + return -EINVAL;
> + }
> + }
> +
> + /* Return the SP count (when querying using a UUID) */
> + if (pcount)
> + *pcount = (u32)res.a2;
> +
> + /*
> + * After calling FFA_PARTITION_INFO_GET the buffer ownership
> + * is assigned to the consumer (u-boot). So, we need to give
> + * the ownership back to the SPM or hypervisor
> + */
> + ret = ffa_release_rx_buffer_hdlr(dev);
> +
> + return ret;
> + }
> +
> + ffa_errno = res.a2;
> + ffa_print_error_log(FFA_PARTITION_INFO_GET, ffa_errno);
> +
> + return ffa_to_std_errno(ffa_errno);
> +}
> +
> +/**
> + * ffa_get_partitions_info_hdlr() - FFA_PARTITION_INFO_GET handler function
> + * @uuid_str: pointer to the UUID string
> + * @sp_count: address of the variable containing the number of partitions matching the UUID
> + * The variable is set by the driver
> + * @sp_descs: address of the descriptors of the partitions matching the UUID
> + * The address is set by the driver
> + *
> + * Return the number of partitions and their descriptors matching the UUID
> + *
> + * Query the secure partition data from uc_priv.
> + * If not found, invoke FFA_PARTITION_INFO_GET FF-A function to query the partition information
> + * from secure world.
> + *
> + * A client of the FF-A driver should know the UUID of the service it wants to
> + * access. It should use the UUID to request the FF-A driver to provide the
> + * partition(s) information of the service. The FF-A driver uses
> + * PARTITION_INFO_GET to obtain this information. This is implemented through
> + * ffa_get_partitions_info_hdlr() function.
> + * If the partition(s) matching the UUID found, the partition(s) information and the
> + * number are returned.
> + * If no partition matching the UUID is found in the cached area, a new FFA_PARTITION_INFO_GET
> + * call is issued.
> + * If not done yet, the UUID is updated in the cached area.
> + * This assumes that partitions data does not change in the secure world.
> + * Otherwise u-boot will have an outdated partition data. The benefit of caching
> + * the information in the FF-A driver is to accommodate discovery after
> + * ExitBootServices().
> + *
> + * Return:
> + *
> + * @sp_count: the number of partitions
> + * @sp_descs: address of the partitions descriptors
> + *
> + * On success 0 is returned. Otherwise, failure
> + */
> +int ffa_get_partitions_info_hdlr(struct udevice *dev, const char *uuid_str,
> + u32 *sp_count, struct ffa_partition_desc **sp_descs)
> +{
> + u32 i;
> + struct ffa_partition_uuid part_uuid = {0};
> + struct ffa_priv *uc_priv;
> + struct ffa_partition_desc *rx_descs;
> +
> + uc_priv = dev_get_uclass_priv(dev);
> +
> + if (!uc_priv->partitions.count || !uc_priv->partitions.descs) {
> + log_err("no partition installed\n");
> + return -EINVAL;
> + }
> +
> + if (!uuid_str) {
> + log_err("no UUID provided\n");
> + return -EINVAL;
> + }
> +
> + if (!sp_count) {
> + log_err("no count argument provided\n");
> + return -EINVAL;
> + }
> +
> + if (!sp_descs) {
> + log_err("no info argument provided\n");
> + return -EINVAL;
> + }
> +
> + if (uuid_str_to_le_bin(uuid_str, (unsigned char *)&part_uuid)) {
> + log_err("invalid UUID\n");
> + return -EINVAL;
> + }
> +
> + log_debug("Searching FF-A partitions using the provided UUID\n");
> +
> + *sp_count = 0;
> + *sp_descs = uc_priv->pair.rxbuf;
> + rx_descs = *sp_descs;
> +
> + /* Search in the cached partitions */
> + for (i = 0; i < uc_priv->partitions.count; i++)
> + if (ffa_uuid_are_identical(&uc_priv->partitions.descs[i].sp_uuid,
> + &part_uuid)) {
> + log_debug("FF-A partition ID %x matches the provided UUID\n",
> + uc_priv->partitions.descs[i].info.id);
> +
> + (*sp_count)++;
> + *rx_descs++ = uc_priv->partitions.descs[i];
> + }
> +
> + if (!(*sp_count)) {
> + int ret;
> +
> + log_debug("No FF-A partition found. Querying framework ...\n");
> +
> + ret = ffa_query_partitions_info(dev, &part_uuid, sp_count);
> +
> + if (!ret) {
> + log_debug("Number of FF-A partition(s) matching the UUID: %d\n", *sp_count);
> +
> + if (*sp_count)
> + ret = ffa_get_partitions_info_hdlr(dev, uuid_str, sp_count,
> + sp_descs);
> + else
> + ret = -ENODATA;
> + }
> +
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * ffa_cache_partitions_info() - Query and saves all secure partitions data
> + * @dev: The FF-A bus device
> + *
> + * Invoke FFA_PARTITION_INFO_GET FF-A function to query from secure world
> + * all partitions information.
> + *
> + * The FFA_PARTITION_INFO_GET call is issued with nil UUID as an argument.
> + * All installed partitions information are returned. We cache them in uc_priv
> + * and we keep the UUID field empty (in FF-A 1.0 UUID is not provided by the partition descriptor)
> + *
> + * Called at the device probing level.
> + * ffa_cache_partitions_info uses ffa_query_partitions_info to get the data
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +static int ffa_cache_partitions_info(struct udevice *dev)
> +{
> + return ffa_query_partitions_info(dev, NULL, NULL);
> +}
> +
> +/**
> + * ffa_msg_send_direct_req_hdlr() - FFA_MSG_SEND_DIRECT_{REQ,RESP} handler function
> + * @dev: The FF-A bus device
> + * @dst_part_id: destination partition ID
> + * @msg: pointer to the message data preallocated by the client (in/out)
> + * @is_smc64: select 64-bit or 32-bit FF-A ABI
> + *
> + * Implement FFA_MSG_SEND_DIRECT_{REQ,RESP}
> + * FF-A functions.
> + *
> + * FFA_MSG_SEND_DIRECT_REQ is used to send the data to the secure partition.
> + * The response from the secure partition is handled by reading the
> + * FFA_MSG_SEND_DIRECT_RESP arguments.
> + *
> + * The maximum size of the data that can be exchanged is 40 bytes which is
> + * sizeof(struct ffa_send_direct_data) as defined by the FF-A specification 1.0
> + * in the section relevant to FFA_MSG_SEND_DIRECT_{REQ,RESP}
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +int ffa_msg_send_direct_req_hdlr(struct udevice *dev, u16 dst_part_id,
> + struct ffa_send_direct_data *msg, bool is_smc64)
> +{
> + ffa_value_t res = {0};
> + int ffa_errno;
> + u64 req_mode, resp_mode;
> + struct ffa_priv *uc_priv;
> +
> + uc_priv = dev_get_uclass_priv(dev);
> +
> + /* No partition installed */
> + if (!uc_priv->partitions.count || !uc_priv->partitions.descs)
> + return -ENODEV;
> +
> + if (is_smc64) {
> + req_mode = FFA_SMC_64(FFA_MSG_SEND_DIRECT_REQ);
> + resp_mode = FFA_SMC_64(FFA_MSG_SEND_DIRECT_RESP);
> + } else {
> + req_mode = FFA_SMC_32(FFA_MSG_SEND_DIRECT_REQ);
> + resp_mode = FFA_SMC_32(FFA_MSG_SEND_DIRECT_RESP);
> + }
> +
> + invoke_ffa_fn((ffa_value_t){
> + .a0 = req_mode,
> + .a1 = PREP_SELF_ENDPOINT_ID(uc_priv->id) |
> + PREP_PART_ENDPOINT_ID(dst_part_id),
> + .a2 = 0,
> + .a3 = msg->data0,
> + .a4 = msg->data1,
> + .a5 = msg->data2,
> + .a6 = msg->data3,
> + .a7 = msg->data4,
> + }, &res);
> +
> + while (res.a0 == FFA_SMC_32(FFA_INTERRUPT))
> + invoke_ffa_fn((ffa_value_t){
> + .a0 = FFA_SMC_32(FFA_RUN),
> + .a1 = res.a1,
> + }, &res);
> +
> + if (res.a0 == FFA_SMC_32(FFA_SUCCESS)) {
> + /* Message sent with no response */
> + return 0;
> + }
> +
> + if (res.a0 == resp_mode) {
> + /* Message sent with response extract the return data */
> + msg->data0 = res.a3;
> + msg->data1 = res.a4;
> + msg->data2 = res.a5;
> + msg->data3 = res.a6;
> + msg->data4 = res.a7;
> +
> + return 0;
> + }
> +
> + ffa_errno = res.a2;
> + return ffa_to_std_errno(ffa_errno);
> +}
> +
> +/* FF-A driver operations (used by clients for communicating with FF-A)*/
> +
> +/**
> + * ffa_partition_info_get() - FFA_PARTITION_INFO_GET driver operation
> + * @uuid_str: pointer to the UUID string
> + * @sp_count: address of the variable containing the number of partitions matching the UUID
> + * The variable is set by the driver
> + * @sp_descs: address of the descriptors of the partitions matching the UUID
> + * The address is set by the driver
> + *
> + * Driver operation for FFA_PARTITION_INFO_GET.
> + * Please see ffa_get_partitions_info_hdlr() description for more details.
> + *
> + * Return:
> + *
> + * @sp_count: the number of partitions
> + * @sp_descs: address of the partitions descriptors
> + *
> + * On success 0 is returned. Otherwise, failure
> + */
> +int ffa_partition_info_get(struct udevice *dev, const char *uuid_str,
> + u32 *sp_count, struct ffa_partition_desc **sp_descs)
> +{
> + struct ffa_bus_ops *ops = ffa_get_ops(dev);
> +
> + if (!ops->partition_info_get)
> + return -ENOSYS;
> +
> + return ops->partition_info_get(dev, uuid_str, sp_count, sp_descs);
> +}
> +
> +/**
> + * ffa_sync_send_receive() - FFA_MSG_SEND_DIRECT_{REQ,RESP} driver operation
> + * @dev: The FF-A bus device
> + * @dst_part_id: destination partition ID
> + * @msg: pointer to the message data preallocated by the client (in/out)
> + * @is_smc64: select 64-bit or 32-bit FF-A ABI
> + *
> + * Driver operation for FFA_MSG_SEND_DIRECT_{REQ,RESP}.
> + * Please see ffa_msg_send_direct_req_hdlr() description for more details.
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +int ffa_sync_send_receive(struct udevice *dev, u16 dst_part_id,
> + struct ffa_send_direct_data *msg, bool is_smc64)
> +{
> + struct ffa_bus_ops *ops = ffa_get_ops(dev);
> +
> + if (!ops->sync_send_receive)
> + return -ENOSYS;
> +
> + return ops->sync_send_receive(dev, dst_part_id, msg, is_smc64);
> +}
> +
> +/**
> + * ffa_rxtx_unmap() - FFA_RXTX_UNMAP driver operation
> + * @dev: The FF-A bus device
> + *
> + * Driver operation for FFA_RXTX_UNMAP.
> + * Please see ffa_unmap_rxtx_buffers_hdlr() description for more details.
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +int ffa_rxtx_unmap(struct udevice *dev)
> +{
> + struct ffa_bus_ops *ops = ffa_get_ops(dev);
> +
> + if (!ops->rxtx_unmap)
> + return -ENOSYS;
> +
> + return ops->rxtx_unmap(dev);
> +}
> +
> +/**
> + * ffa_do_probe() - probing FF-A framework
> + * @dev: the FF-A bus device (arm_ffa)
> + *
> + * Probing is triggered on demand by clients searching for the uclass.
> + * At probe level the following actions are done:
> + * - saving the FF-A framework version in uc_priv
> + * - querying from secure world the u-boot endpoint ID
> + * - querying from secure world the supported features of FFA_RXTX_MAP
> + * - mapping the RX/TX buffers
> + * - querying from secure world all the partitions information
> + *
> + * All data queried from secure world is saved in uc_priv.
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +static int ffa_do_probe(struct udevice *dev)
> +{
> + int ret;
> +
> + ret = ffa_get_version_hdlr(dev);
> + if (ret)
> + return ret;
> +
> + ret = ffa_get_endpoint_id(dev);
> + if (ret)
> + return ret;
> +
> + ret = ffa_get_rxtx_map_features_hdlr(dev);
> + if (ret)
> + return ret;
> +
> + ret = ffa_map_rxtx_buffers_hdlr(dev);
> + if (ret)
> + return ret;
> +
> + ret = ffa_cache_partitions_info(dev);
> + if (ret) {
> + ffa_unmap_rxtx_buffers_hdlr(dev);
> + return ret;
> + }
> +
> + return 0;
> +}
> +
> +UCLASS_DRIVER(ffa) = {
> + .name = "ffa",
> + .id = UCLASS_FFA,
> + .pre_probe = ffa_do_probe,
> + .pre_remove = ffa_unmap_rxtx_buffers_hdlr,
> + .per_device_auto = sizeof(struct ffa_priv)
> +};
> diff --git a/drivers/firmware/arm-ffa/arm-ffa.c b/drivers/firmware/arm-ffa/arm-ffa.c
> new file mode 100644
> index 0000000000..68df75bd9e
> --- /dev/null
> +++ b/drivers/firmware/arm-ffa/arm-ffa.c
> @@ -0,0 +1,104 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * 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 <arm_ffa.h>
> +#include <arm_ffa_priv.h>
> +#include <dm.h>
> +#include <log.h>
> +#include <asm/global_data.h>
> +#include <dm/device-internal.h>
> +#include <linux/errno.h>
> +
> +DECLARE_GLOBAL_DATA_PTR;
> +
> +/**
> + * invoke_ffa_fn() - SMC wrapper
> + * @args: FF-A ABI arguments to be copied to Xn registers
> + * @res: FF-A ABI return data to be copied from Xn registers
> + *
> + * Calls low level SMC assembly function
> + */
> +void invoke_ffa_fn(ffa_value_t args, ffa_value_t *res)
> +{
> + arm_smccc_1_2_smc(&args, res);
> +}
> +
> +/**
> + * arm_ffa_discover() - perform FF-A discovery
> + * @dev: The Arm FF-A bus device (arm_ffa)
> + * Try to discover the FF-A framework. Discovery is performed by
> + * querying the FF-A framework version from secure world using the FFA_VERSION ABI.
> + * Return:
> + *
> + * true on success. Otherwise, false.
> + */
> +static bool arm_ffa_discover(struct udevice *dev)
> +{
> + int ret;
> +
> + log_info("Arm FF-A framework discovery\n");
> +
> + ret = ffa_get_version_hdlr(dev);
> + if (ret)
> + return false;
> +
> + return true;
> +}
> +
> +/**
> + * arm_ffa_is_supported() - FF-A bus discovery callback
> + * @invoke_fn: legacy SMC invoke function (not used)
> + *
> + * Perform FF-A discovery by calling arm_ffa_discover().
> + * Discovery is performed by querying the FF-A framework version from
> + * secure world using the FFA_VERSION ABI.
> + *
> + * The FF-A driver is registered as an SMCCC feature driver. So, features discovery
> + * callbacks are called by the PSCI driver (PSCI device is the SMCCC features
> + * root device).
> + *
> + * The FF-A driver supports the SMCCCv1.2 extended input/output registers.
> + * So, the legacy SMC invocation is not used.
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +static bool arm_ffa_is_supported(void (*invoke_fn)(ulong a0, ulong a1,
> + ulong a2, ulong a3,
> + ulong a4, ulong a5,
> + ulong a6, ulong a7,
> + struct arm_smccc_res *res))
> +{
> + return arm_ffa_discover(NULL);
> +}
> +
> +/* Arm FF-A driver operations */
> +
> +static const struct ffa_bus_ops ffa_ops = {
> + .partition_info_get = ffa_get_partitions_info_hdlr,
> + .sync_send_receive = ffa_msg_send_direct_req_hdlr,
> + .rxtx_unmap = ffa_unmap_rxtx_buffers_hdlr,
> +};
> +
> +/* Registering the FF-A driver as an SMCCC feature driver */
> +
> +ARM_SMCCC_FEATURE_DRIVER(arm_ffa) = {
> + .driver_name = FFA_DRV_NAME,
> + .is_supported = arm_ffa_is_supported,
> +};
> +
> +/* Declaring the FF-A driver under UCLASS_FFA */
> +
> +U_BOOT_DRIVER(arm_ffa) = {
> + .name = FFA_DRV_NAME,
> + .id = UCLASS_FFA,
> + .flags = DM_REMOVE_OS_PREPARE,
> + .ops = &ffa_ops,
> +};
> diff --git a/drivers/firmware/arm-ffa/sandbox_arm_ffa_priv.h b/drivers/firmware/arm-ffa/sandbox_arm_ffa_priv.h
> new file mode 100644
> index 0000000000..4338f9c9b1
> --- /dev/null
> +++ b/drivers/firmware/arm-ffa/sandbox_arm_ffa_priv.h
> @@ -0,0 +1,14 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +/*
> + * Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
> + *
> + * Authors:
> + * Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
> + */
> +
> +#ifndef __SANDBOX_ARM_FFA_PRV_H
> +#define __SANDBOX_ARM_FFA_PRV_H
> +
> +/* Future sandbox support private declarations */
> +
> +#endif
> diff --git a/include/arm_ffa.h b/include/arm_ffa.h
> new file mode 100644
> index 0000000000..db9b1be995
> --- /dev/null
> +++ b/include/arm_ffa.h
> @@ -0,0 +1,213 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +/*
> + * Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
> + *
> + * Authors:
> + * Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
> + */
> +
> +#ifndef __ARM_FFA_H
> +#define __ARM_FFA_H
> +
> +#include <linux/printk.h>
> +
> +/*
> + * This header is public. It can be used by clients to access
> + * data structures and definitions they need
> + */
> +
> +/*
> + * struct ffa_partition_info - Partition information descriptor
> + * @id: Partition ID
> + * @exec_ctxt: Execution context count
> + * @properties: Partition properties
> + *
> + * Data structure containing information about partitions instantiated in the system
> + * This structure is filled with the data queried by FFA_PARTITION_INFO_GET
> + */
> +struct ffa_partition_info {
> + u16 id;
> + u16 exec_ctxt;
> +/* partition supports receipt of direct requests */
> +#define FFA_PARTITION_DIRECT_RECV BIT(0)
> +/* partition can send direct requests. */
> +#define FFA_PARTITION_DIRECT_SEND BIT(1)
> +/* partition can send and receive indirect messages. */
> +#define FFA_PARTITION_INDIRECT_MSG BIT(2)
> + u32 properties;
> +};
> +
> +/*
> + * struct ffa_partition_uuid - 16 bytes UUID transmitted by FFA_PARTITION_INFO_GET
> + * @a1-4: 32-bit words access to the UUID data
> + *
> + */
> +struct ffa_partition_uuid {
> + u32 a1; /* w1 */
> + u32 a2; /* w2 */
> + u32 a3; /* w3 */
> + u32 a4; /* w4 */
> +};
> +
> +/**
> + * struct ffa_partition_desc - the secure partition descriptor
> + * @info: partition information
> + * @sp_uuid: the secure partition UUID
> + *
> + * Each partition has its descriptor containing the partitions information and the UUID
> + */
> +struct ffa_partition_desc {
> + struct ffa_partition_info info;
> + struct ffa_partition_uuid sp_uuid;
> +};
> +
> +/*
> + * struct ffa_send_direct_data - Data structure hosting the data
> + * used by FFA_MSG_SEND_DIRECT_{REQ,RESP}
> + * @data0-4: Data read/written from/to x3-x7 registers
> + *
> + * Data structure containing the data to be sent by FFA_MSG_SEND_DIRECT_REQ
> + * or read from FFA_MSG_SEND_DIRECT_RESP
> + */
> +
> +/* For use with FFA_MSG_SEND_DIRECT_{REQ,RESP} which pass data via registers */
> +struct ffa_send_direct_data {
> + ulong data0; /* w3/x3 */
> + ulong data1; /* w4/x4 */
> + ulong data2; /* w5/x5 */
> + ulong data3; /* w6/x6 */
> + ulong data4; /* w7/x7 */
> +};
> +
> +struct udevice;
> +
> +/**
> + * struct ffa_bus_ops - Operations for FF-A
> + * @partition_info_get: callback for the FFA_PARTITION_INFO_GET
> + * @sync_send_receive: callback for the FFA_MSG_SEND_DIRECT_REQ
> + * @rxtx_unmap: callback for the FFA_RXTX_UNMAP
> + *
> + * The data structure providing all the operations supported by the driver.
> + * This structure is EFI runtime resident.
> + */
> +struct ffa_bus_ops {
> + int (*partition_info_get)(struct udevice *dev, const char *uuid_str,
> + u32 *sp_count, struct ffa_partition_desc **sp_descs);
> + int (*sync_send_receive)(struct udevice *dev, u16 dst_part_id,
> + struct ffa_send_direct_data *msg,
> + bool is_smc64);
> + int (*rxtx_unmap)(struct udevice *dev);
> +};
> +
> +#define ffa_get_ops(dev) ((struct ffa_bus_ops *)(dev)->driver->ops)
> +
> +/**
> + * ffa_rxtx_unmap() - FFA_RXTX_UNMAP driver operation
> + * Please see ffa_unmap_rxtx_buffers_hdlr() description for more details.
> + */
> +int ffa_rxtx_unmap(struct udevice *dev);
> +
> +/**
> + * ffa_unmap_rxtx_buffers_hdlr() - FFA_RXTX_UNMAP handler function
> + * @dev: The arm_ffa bus device
> + *
> + * This function implements FFA_RXTX_UNMAP FF-A function
> + * to unmap the RX/TX buffers
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +int ffa_unmap_rxtx_buffers_hdlr(struct udevice *dev);
> +
> +/**
> + * ffa_sync_send_receive() - FFA_MSG_SEND_DIRECT_{REQ,RESP} driver operation
> + * Please see ffa_msg_send_direct_req_hdlr() description for more details.
> + */
> +int ffa_sync_send_receive(struct udevice *dev, u16 dst_part_id,
> + struct ffa_send_direct_data *msg, bool is_smc64);
> +
> +/**
> + * ffa_msg_send_direct_req_hdlr() - FFA_MSG_SEND_DIRECT_{REQ,RESP} handler function
> + * @dev: The arm_ffa bus device
> + * @dst_part_id: destination partition ID
> + * @msg: pointer to the message data preallocated by the client (in/out)
> + * @is_smc64: select 64-bit or 32-bit FF-A ABI
> + *
> + * This function implements FFA_MSG_SEND_DIRECT_{REQ,RESP}
> + * FF-A functions.
> + *
> + * FFA_MSG_SEND_DIRECT_REQ is used to send the data to the secure partition.
> + * The response from the secure partition is handled by reading the
> + * FFA_MSG_SEND_DIRECT_RESP arguments.
> + *
> + * The maximum size of the data that can be exchanged is 40 bytes which is
> + * sizeof(struct ffa_send_direct_data) as defined by the FF-A specification 1.0
> + * in the section relevant to FFA_MSG_SEND_DIRECT_{REQ,RESP}
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +int ffa_msg_send_direct_req_hdlr(struct udevice *dev, u16 dst_part_id,
> + struct ffa_send_direct_data *msg, bool is_smc64);
> +
> +/**
> + * ffa_partition_info_get() - FFA_PARTITION_INFO_GET driver operation
> + * Please see ffa_get_partitions_info_hdlr() description for more details.
> + */
> +int ffa_partition_info_get(struct udevice *dev, const char *uuid_str,
> + u32 *sp_count, struct ffa_partition_desc **sp_descs);
> +
> +/**
> + * ffa_get_partitions_info_hdlr() - FFA_PARTITION_INFO_GET handler function
> + * @uuid_str: pointer to the UUID string
> + * @sp_count: address of the variable containing the number of partitions matching the UUID
> + * The variable is set by the driver
> + * @sp_descs: address of the descriptors of the partitions matching the UUID
> + * The address is set by the driver
> + *
> + * Return the number of partitions and their descriptors matching the UUID
> + *
> + * Query the secure partition data from uc_priv.
> + * If not found, invoke FFA_PARTITION_INFO_GET
> + * FF-A function to query the partition information from secure world.
> + *
> + * A client of the FF-A driver should know the UUID of the service it wants to
> + * access. It should use the UUID to request the FF-A driver to provide the
> + * partition(s) information of the service. The FF-A driver uses
> + * PARTITION_INFO_GET to obtain this information. This is implemented through
> + * ffa_get_partitions_info_hdlr() function.
> + * A new FFA_PARTITION_INFO_GET call is issued (first one performed through
> + * ffa_cache_partitions_info) allowing to retrieve the partition(s) information.
> + * They are not saved (already done). We only update the UUID in the cached area.
> + * This assumes that partitions data does not change in the secure world.
> + * Otherwise u-boot will have an outdated partition data. The benefit of caching
> + * the information in the FF-A driver is to accommodate discovery after
> + * ExitBootServices().
> + *
> + * Return:
> + *
> + * @sp_count: the number of partitions
> + * @sp_descs: address of the partitions descriptors
> + *
> + * On success 0 is returned. Otherwise, failure
> + */
> +int ffa_get_partitions_info_hdlr(struct udevice *dev, const char *uuid_str,
> + u32 *sp_count, struct ffa_partition_desc **sp_descs);
> +
> +struct ffa_priv;
> +
> +/**
> + * ffa_set_smc_conduit() - Set the SMC conduit
> + * @dev: The FF-A bus device
> + *
> + * Selects the SMC conduit by setting the FF-A ABI invoke function.
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +int ffa_set_smc_conduit(struct udevice *dev);
> +
> +#endif
> diff --git a/include/arm_ffa_priv.h b/include/arm_ffa_priv.h
> new file mode 100644
> index 0000000000..d564c33c64
> --- /dev/null
> +++ b/include/arm_ffa_priv.h
> @@ -0,0 +1,246 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +/*
> + * Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
> + *
> + * Authors:
> + * Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
> + */
> +
> +#ifndef __ARM_FFA_PRV_H
> +#define __ARM_FFA_PRV_H
> +
> +#include <mapmem.h>
> +#include <linux/bitfield.h>
> +#include <linux/bitops.h>
> +
> +/* This header is exclusively used by the FF-A Uclass and FF-A driver(s) */
> +
> +/* Arm FF-A driver name */
> +#define FFA_DRV_NAME "arm_ffa"
> +
> +/* The FF-A SMC function definitions */
> +
> +#if CONFIG_IS_ENABLED(SANDBOX)
> +
> +/* Providing Arm SMCCC declarations to sandbox */
> +
> +/**
> + * struct sandbox_smccc_1_2_regs - emulated SMC call arguments or results
> + * @a0-a17 argument values from registers 0 to 17
> + */
> +struct sandbox_smccc_1_2_regs {
> + ulong a0;
> + ulong a1;
> + ulong a2;
> + ulong a3;
> + ulong a4;
> + ulong a5;
> + ulong a6;
> + ulong a7;
> + ulong a8;
> + ulong a9;
> + ulong a10;
> + ulong a11;
> + ulong a12;
> + ulong a13;
> + ulong a14;
> + ulong a15;
> + ulong a16;
> + ulong a17;
> +};
> +
> +typedef struct sandbox_smccc_1_2_regs ffa_value_t;
> +
> +#define ARM_SMCCC_FAST_CALL 1UL
> +#define ARM_SMCCC_OWNER_STANDARD 4
> +#define ARM_SMCCC_SMC_32 0
> +#define ARM_SMCCC_SMC_64 1
> +#define ARM_SMCCC_TYPE_SHIFT 31
> +#define ARM_SMCCC_CALL_CONV_SHIFT 30
> +#define ARM_SMCCC_OWNER_MASK 0x3f
> +#define ARM_SMCCC_OWNER_SHIFT 24
> +#define ARM_SMCCC_FUNC_MASK 0xffff
> +
> +#define ARM_SMCCC_CALL_VAL(type, calling_convention, owner, func_num) \
> + (((type) << ARM_SMCCC_TYPE_SHIFT) | \
> + ((calling_convention) << ARM_SMCCC_CALL_CONV_SHIFT) | \
> + (((owner) & ARM_SMCCC_OWNER_MASK) << ARM_SMCCC_OWNER_SHIFT) | \
> + ((func_num) & ARM_SMCCC_FUNC_MASK))
> +
> +#else
> +/* CONFIG_ARM64 */
> +#include <linux/arm-smccc.h>
> +typedef struct arm_smccc_1_2_regs ffa_value_t;
> +#endif
> +
> +/* Defining the function pointer type for the function executing the FF-A ABIs */
> +typedef void (*invoke_ffa_fn_t)(ffa_value_t args, ffa_value_t *res);
> +
> +/* FF-A driver version definitions */
> +
> +#define MAJOR_VERSION_MASK GENMASK(30, 16)
> +#define MINOR_VERSION_MASK GENMASK(15, 0)
> +#define GET_FFA_MAJOR_VERSION(x) \
> + ((u16)(FIELD_GET(MAJOR_VERSION_MASK, (x))))
> +#define GET_FFA_MINOR_VERSION(x) \
> + ((u16)(FIELD_GET(MINOR_VERSION_MASK, (x))))
> +#define PACK_VERSION_INFO(major, minor) \
> + (FIELD_PREP(MAJOR_VERSION_MASK, (major)) | \
> + FIELD_PREP(MINOR_VERSION_MASK, (minor)))
> +
> +#define FFA_MAJOR_VERSION (1)
> +#define FFA_MINOR_VERSION (0)
> +#define FFA_VERSION_1_0 \
> + PACK_VERSION_INFO(FFA_MAJOR_VERSION, FFA_MINOR_VERSION)
> +
> +/* Endpoint ID mask (u-boot endpoint ID) */
> +
> +#define GET_SELF_ENDPOINT_ID_MASK GENMASK(15, 0)
> +#define GET_SELF_ENDPOINT_ID(x) \
> + ((u16)(FIELD_GET(GET_SELF_ENDPOINT_ID_MASK, (x))))
> +
> +#define PREP_SELF_ENDPOINT_ID_MASK GENMASK(31, 16)
> +#define PREP_SELF_ENDPOINT_ID(x) \
> + (FIELD_PREP(PREP_SELF_ENDPOINT_ID_MASK, (x)))
> +
> +/* Partition endpoint ID mask (partition with which u-boot communicates with) */
> +
> +#define PREP_PART_ENDPOINT_ID_MASK GENMASK(15, 0)
> +#define PREP_PART_ENDPOINT_ID(x) \
> + (FIELD_PREP(PREP_PART_ENDPOINT_ID_MASK, (x)))
> +
> +/* Definitions of the Arm FF-A interfaces supported by the Arm FF-A driver */
> +
> +#define FFA_SMC(calling_convention, func_num) \
> + ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL, (calling_convention), \
> + ARM_SMCCC_OWNER_STANDARD, (func_num))
> +
> +#define FFA_SMC_32(func_num) FFA_SMC(ARM_SMCCC_SMC_32, (func_num))
> +#define FFA_SMC_64(func_num) FFA_SMC(ARM_SMCCC_SMC_64, (func_num))
> +
> +enum ffa_abis {
> + FFA_ERROR = 0x60,
> + FFA_SUCCESS = 0x61,
> + FFA_INTERRUPT = 0x62,
> + FFA_VERSION = 0x63,
> + FFA_FEATURES = 0x64,
> + FFA_RX_RELEASE = 0x65,
> + FFA_RXTX_MAP = 0x66,
> + FFA_RXTX_UNMAP = 0x67,
> + FFA_PARTITION_INFO_GET = 0x68,
> + FFA_ID_GET = 0x69,
> + FFA_RUN = 0x6d,
> + FFA_MSG_SEND_DIRECT_REQ = 0x6f,
> + FFA_MSG_SEND_DIRECT_RESP = 0x70,
> +
> + /* To be updated when adding new FFA IDs */
> + FFA_FIRST_ID = FFA_ERROR, /* Lowest number ID */
> + FFA_LAST_ID = FFA_MSG_SEND_DIRECT_RESP, /* Highest number ID */
> +};
> +
> +enum ffa_abi_errcode {
> + NOT_SUPPORTED = 1,
> + INVALID_PARAMETERS,
> + NO_MEMORY,
> + BUSY,
> + INTERRUPTED,
> + DENIED,
> + RETRY,
> + ABORTED,
> + MAX_NUMBER_FFA_ERR
> +};
> +
> +extern int ffa_to_std_errmap[MAX_NUMBER_FFA_ERR];
> +
> +/* Container structure and helper macros to map between an FF-A error and relevant error log */
> +struct ffa_abi_errmap {
> + char *err_str[MAX_NUMBER_FFA_ERR];
> +};
> +
> +#define FFA_ERRMAP_COUNT (FFA_LAST_ID - FFA_FIRST_ID + 1)
> +#define FFA_ID_TO_ERRMAP_ID(ffa_id) ((ffa_id) - FFA_FIRST_ID)
> +
> +/**
> + * enum ffa_rxtx_buf_sizes - minimum sizes supported
> + * for the RX/TX buffers
> + */
> +enum ffa_rxtx_buf_sizes {
> + RXTX_4K,
> + RXTX_64K,
> + RXTX_16K
> +};
> +
> +/**
> + * struct ffa_rxtxpair - Hosts the RX/TX buffers virtual addresses
> + * @rxbuf: virtual address of the RX buffer
> + * @txbuf: virtual address of the TX buffer
> + * @rxtx_min_pages: RX/TX buffers minimum size in pages
> + *
> + * Hosts the virtual addresses of the mapped RX/TX buffers
> + * These addresses are used by the FF-A functions that use the RX/TX buffers
> + */
> +struct ffa_rxtxpair {
> + void *rxbuf; /* Virtual address returned by memalign */
> + void *txbuf; /* Virtual address returned by memalign */
> + size_t rxtx_min_pages; /* Minimum number of pages in each of the RX/TX buffers */
> +};
> +
> +struct ffa_partition_desc;
> +
> +/**
> + * struct ffa_partitions - descriptors for all secure partitions
> + * @count: The number of partitions descriptors
> + * @descs The partitions descriptors table
> + *
> + * Contains the partitions descriptors table
> + */
> +struct ffa_partitions {
> + u32 count;
> + struct ffa_partition_desc *descs; /* Virtual address */
> +};
> +
> +/**
> + * struct ffa_priv - the driver private data structure
> + *
> + * @fwk_version: FF-A framework version
> + * @emul: FF-A sandbox emulator
> + * @id: u-boot endpoint ID
> + * @partitions: The partitions descriptors structure
> + * @pair: The RX/TX buffers pair
> + *
> + * The device private data structure containing all the
> + * data read from secure world.
> + */
> +struct ffa_priv {
> + u32 fwk_version;
> + struct udevice *emul;
> + u16 id;
> + struct ffa_partitions partitions;
> + struct ffa_rxtxpair pair;
> +};
> +
> +/**
> + * ffa_get_version_hdlr() - FFA_VERSION handler function
> + * @dev: The FF-A bus device
> + *
> + * Implement FFA_VERSION FF-A function
> + * to get from the secure world the FF-A framework version
> + * FFA_VERSION is used to discover the FF-A framework.
> + *
> + * Return:
> + *
> + * 0 on success. Otherwise, failure
> + */
> +int ffa_get_version_hdlr(struct udevice *dev);
> +
> +/**
> + * invoke_ffa_fn() - SMC wrapper
> + * @args: FF-A ABI arguments to be copied to Xn registers
> + * @res: FF-A ABI return data to be copied from Xn registers
> + *
> + * Calls low level SMC implementation.
> + * This function should be implemented by the user driver.
> + */
> +void invoke_ffa_fn(ffa_value_t args, ffa_value_t *res);
> +
> +#endif
> diff --git a/include/dm/uclass-id.h b/include/dm/uclass-id.h
> index 307ad6931c..3c6af2e3d2 100644
> --- a/include/dm/uclass-id.h
> +++ b/include/dm/uclass-id.h
> @@ -4,6 +4,11 @@
> *
> * (C) Copyright 2012
> * Pavel Herrmann <morpheus.ibis@gmail.com>
> + *
> + * Copyright 2022-2023 Arm Limited and/or its affiliates <open-source-office@arm.com>
> + *
> + * Authors:
> + * Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
> */
>
> #ifndef _DM_UCLASS_ID_H
> @@ -57,6 +62,7 @@ enum uclass_id {
> UCLASS_ETH, /* Ethernet device */
> UCLASS_ETH_PHY, /* Ethernet PHY device */
> UCLASS_EXTCON, /* External Connector Class */
> + UCLASS_FFA, /* Arm Firmware Framework for Armv8-A */
> UCLASS_FIRMWARE, /* Firmware */
> UCLASS_FPGA, /* FPGA device */
> UCLASS_FUZZING_ENGINE, /* Fuzzing engine */
> --
> 2.25.1
>
Acked-by: Ilias Apalodimas <ilias.apalodimas@linaro.org>