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

27 Jul 2023

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].
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

    