diff options
Diffstat (limited to 'meta-arm/meta-arm-bsp/recipes-bsp/u-boot/u-boot/corstone1000/0004-FF-A-v15-arm_ffa-introduce-Arm-FF-A-support.patch')
-rw-r--r-- | meta-arm/meta-arm-bsp/recipes-bsp/u-boot/u-boot/corstone1000/0004-FF-A-v15-arm_ffa-introduce-Arm-FF-A-support.patch | 2132 |
1 files changed, 2132 insertions, 0 deletions
diff --git a/meta-arm/meta-arm-bsp/recipes-bsp/u-boot/u-boot/corstone1000/0004-FF-A-v15-arm_ffa-introduce-Arm-FF-A-support.patch b/meta-arm/meta-arm-bsp/recipes-bsp/u-boot/u-boot/corstone1000/0004-FF-A-v15-arm_ffa-introduce-Arm-FF-A-support.patch new file mode 100644 index 0000000000..f0d67639fc --- /dev/null +++ b/meta-arm/meta-arm-bsp/recipes-bsp/u-boot/u-boot/corstone1000/0004-FF-A-v15-arm_ffa-introduce-Arm-FF-A-support.patch @@ -0,0 +1,2132 @@ +From e8b71ec24884a0c973ac663e6802ff529a8be349 Mon Sep 17 00:00:00 2001 +From: Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com> +Date: Mon, 17 Jul 2023 15:11:43 +0100 +Subject: [PATCH 04/33] FF-A v15: arm_ffa: introduce Arm FF-A support + +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> +Upstream-Status: Submitted [cover letter: https://lore.kernel.org/all/20230713132847.176000-1-abdellatif.elkhlifi@arm.com/] +--- + 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 a1122afb01..9c5ebf312c 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 29be78a3f2..6094fac50d 100644 +--- a/drivers/Makefile ++++ b/drivers/Makefile +@@ -114,6 +114,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 + |