[PATCH 3/6] arm_ffa: introduce the FF-A Sandbox driver

[abdellatif.elkhlifi@arm.com]

From: Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>

Provide a Sandbox driver to emulate the FF-A ABIs

The emulated ABIs are those supported by the FF-A core driver
and according to FF-A specification v1.0.

The Sandbox driver provides operations allowing the test
application to read the status of all the inspected ABIs
and perform functional tests based on that.

Signed-off-by: Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
Cc: Tom Rini <trini@konsulko.com>
---
 MAINTAINERS                           |   2 +
 arch/sandbox/dts/sandbox.dtsi         |  10 +
 arch/sandbox/dts/test.dts             |  10 +
 common/board_r.c                      |   2 +-
 configs/sandbox64_defconfig           |   2 +
 configs/sandbox_defconfig             |   2 +
 doc/arch/sandbox.rst                  |   1 +
 drivers/arm-ffa/Kconfig               |   8 +-
 drivers/arm-ffa/Makefile              |   1 +
 drivers/arm-ffa/arm-ffa-uclass.c      |  51 +-
 drivers/arm-ffa/core.c                |  94 +++-
 drivers/arm-ffa/sandbox.c             | 735 ++++++++++++++++++++++++++
 drivers/arm-ffa/sandbox_arm_ffa_prv.h | 128 +++++
 include/arm_ffa.h                     |   9 +-
 include/sandbox_arm_ffa.h             |  31 ++
 include/sandbox_arm_ffa_helper.h      |  26 +
 lib/arm-ffa/Makefile                  |   1 +
 lib/arm-ffa/arm_ffa_helper.c          |   6 +-
 lib/arm-ffa/sandbox_arm_ffa_helper.c  |  23 +
 lib/efi_loader/efi_boottime.c         |   4 +-
 20 files changed, 1102 insertions(+), 44 deletions(-)
 create mode 100644 drivers/arm-ffa/sandbox.c
 create mode 100644 drivers/arm-ffa/sandbox_arm_ffa_prv.h
 create mode 100644 include/sandbox_arm_ffa.h
 create mode 100644 include/sandbox_arm_ffa_helper.h
 create mode 100644 lib/arm-ffa/sandbox_arm_ffa_helper.c

diff --git a/MAINTAINERS b/MAINTAINERS
index 50ccd6a7ba..84524d7caf 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -239,6 +239,8 @@ F:	cmd/armffa.c
 F:	drivers/arm-ffa/
 F:	include/arm_ffa.h
 F:	include/arm_ffa_helper.h
+F:	include/sandbox_arm_ffa.h
+F:	include/sandbox_arm_ffa_helper.h
 F:	lib/arm-ffa/
 
 ARM FREESCALE IMX
diff --git a/arch/sandbox/dts/sandbox.dtsi b/arch/sandbox/dts/sandbox.dtsi
index 66b813faad..523ffcc27d 100644
--- a/arch/sandbox/dts/sandbox.dtsi
+++ b/arch/sandbox/dts/sandbox.dtsi
@@ -416,6 +416,16 @@
 	sandbox_tee {
 		compatible = "sandbox,tee";
 	};
+
+	arm_ffa {
+		compatible = "arm,ffa";
+		method = "smc";
+	};
+
+	sandbox_arm_ffa {
+		compatible = "sandbox,ffa";
+		method = "smc";
+	};
 };
 
 &cros_ec {
diff --git a/arch/sandbox/dts/test.dts b/arch/sandbox/dts/test.dts
index 3d206fdb3c..2c638af042 100644
--- a/arch/sandbox/dts/test.dts
+++ b/arch/sandbox/dts/test.dts
@@ -1598,6 +1598,16 @@
 			compatible = "sandbox,regmap_test";
 		};
 	};
+
+	arm_ffa {
+		compatible = "arm,ffa";
+		method = "smc";
+	};
+
+	sandbox_arm_ffa {
+		compatible = "sandbox,ffa";
+		method = "smc";
+	};
 };
 
 #include "sandbox_pmic.dtsi"
diff --git a/common/board_r.c b/common/board_r.c
index 7866ec3ad5..3b82f74bb0 100644
--- a/common/board_r.c
+++ b/common/board_r.c
@@ -775,7 +775,7 @@ static init_fnc_t init_sequence_r[] = {
 	INIT_FUNC_WATCHDOG_RESET
 	initr_net,
 #endif
-#ifdef CONFIG_ARM_FFA_TRANSPORT
+#if defined(CONFIG_ARM_FFA_TRANSPORT) && !defined(CONFIG_SANDBOX_FFA)
 	ffa_helper_init_device,
 #endif
 #ifdef CONFIG_POST
diff --git a/configs/sandbox64_defconfig b/configs/sandbox64_defconfig
index 40d1422a37..301c6f320f 100644
--- a/configs/sandbox64_defconfig
+++ b/configs/sandbox64_defconfig
@@ -252,3 +252,5 @@ CONFIG_TEST_FDTDEC=y
 CONFIG_UNIT_TEST=y
 CONFIG_UT_TIME=y
 CONFIG_UT_DM=y
+CONFIG_ARM_FFA_TRANSPORT=y
+CONFIG_SANDBOX_FFA=y
\ No newline at end of file
diff --git a/configs/sandbox_defconfig b/configs/sandbox_defconfig
index 0f43101ab5..a2f273056f 100644
--- a/configs/sandbox_defconfig
+++ b/configs/sandbox_defconfig
@@ -324,3 +324,5 @@ CONFIG_TEST_FDTDEC=y
 CONFIG_UNIT_TEST=y
 CONFIG_UT_TIME=y
 CONFIG_UT_DM=y
+CONFIG_ARM_FFA_TRANSPORT=y
+CONFIG_SANDBOX_FFA=y
\ No newline at end of file
diff --git a/doc/arch/sandbox.rst b/doc/arch/sandbox.rst
index f8804e1f41..7cb5ea307c 100644
--- a/doc/arch/sandbox.rst
+++ b/doc/arch/sandbox.rst
@@ -203,6 +203,7 @@ Supported Drivers
 
 U-Boot sandbox supports these emulations:
 
+- Arm FF-A
 - Block devices
 - Chrome OS EC
 - GPIO
diff --git a/drivers/arm-ffa/Kconfig b/drivers/arm-ffa/Kconfig
index 7b7cfe26b1..61103daa42 100644
--- a/drivers/arm-ffa/Kconfig
+++ b/drivers/arm-ffa/Kconfig
@@ -2,7 +2,7 @@
 
 config ARM_FFA_TRANSPORT
 	bool "Enable Arm Firmware Framework for Armv8-A driver"
-	depends on DM && ARM64
+	depends on DM && (ARM64 || SANDBOX)
 	select ARM_SMCCC if ARM64
 	select CMD_ARMFFA
 	select LIB_UUID
@@ -24,3 +24,9 @@ config ARM_FFA_TRANSPORT
 	  entity to communicate with. FF-A communication is handled by
 	  one device and one instance. This device takes care of
 	  all the interactions between Normal world and Secure World.
+
+config SANDBOX_FFA
+	bool "FF-A Sandbox driver"
+	depends on ARM_FFA_TRANSPORT && SANDBOX
+	help
+	  This emulates the FF-A handling under Sandbox and allows to test the FF-A driver
diff --git a/drivers/arm-ffa/Makefile b/drivers/arm-ffa/Makefile
index 7bc9a336a9..df1cfe6ef0 100644
--- a/drivers/arm-ffa/Makefile
+++ b/drivers/arm-ffa/Makefile
@@ -4,3 +4,4 @@
 #
 
 obj-y += arm-ffa-uclass.o core.o
+obj-$(CONFIG_SANDBOX_FFA) += sandbox.o
diff --git a/drivers/arm-ffa/arm-ffa-uclass.c b/drivers/arm-ffa/arm-ffa-uclass.c
index 0bf661d397..a5945afb9d 100644
--- a/drivers/arm-ffa/arm-ffa-uclass.c
+++ b/drivers/arm-ffa/arm-ffa-uclass.c
@@ -11,6 +11,10 @@
 #include <log.h>
 #include <asm/global_data.h>
 
+#if CONFIG_IS_ENABLED(SANDBOX_FFA)
+#include <sandbox_arm_ffa.h>
+#endif
+
 DECLARE_GLOBAL_DATA_PTR;
 
 UCLASS_DRIVER(ffa) = {
@@ -42,18 +46,42 @@ int __ffa_runtime ffa_get_invoke_func(u32 func_id, struct ffa_interface_data *fu
 	return ffa_device_get_ops()->invoke_func(func_id, func_data);
 }
 
+#if CONFIG_IS_ENABLED(SANDBOX_FFA)
+
 /**
- * ffa_init_device - probes the arm_ffa device
+ * sandbox_ffa_get_invoke_func - performs a call to the Sandbox FF-A driver dispatcher
+ * @func_id:	The FF-A function to be queried
+ * @func_data:  Pointer to the query arguments
+ *				container structure.
+ *
+ * This function passes the FF-A function ID to be queried during sandbox test cases
+ *  and its arguments to the Sandbox FF-A driver dispatcher.
+ * This function is called by the Sandbox FF-A helper function.
+ *
+ * Return:
  *
- * This boot time function makes sure the arm_ffa device is probed
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+int sandbox_ffa_get_invoke_func(u32 func_id, struct ffa_interface_data *func_data)
+{
+	if (!sandbox_ffa_device_get_ops()->invoke_func)
+		return -EINVAL;
+
+	return sandbox_ffa_device_get_ops()->invoke_func(func_id, func_data);
+}
+#endif
+
+/**
+ * ffa_init_device - probes the arm_ffa and sandbox_arm_ffa devices
+ *
+ * This boot time function makes sure the arm_ffa and sandbox_arm_ffa devices are probed
  * and ready for use.
  * This function is called automatically at initcalls
  * level (after u-boot relocation).
  *
- * Arm FF-A transport is implemented through a single u-boot
- * device (arm_ffa). So, there is only one device belonging to UCLASS_FFA.
- * All FF-A clients should use the arm_ffa device to use the FF-A
- * transport.
+ * Arm FF-A transport is implemented through arm_ffa u-boot device managing the FF-A
+ * communication. In Sandbox mode sandbox_arm_ffa is used to test arm_ffa driver.
+ * All FF-A clients should use the arm_ffa device to use the FF-A transport.
  *
  * Return:
  *
@@ -61,5 +89,14 @@ int __ffa_runtime ffa_get_invoke_func(u32 func_id, struct ffa_interface_data *fu
  */
 int ffa_init_device(void)
 {
-	return ffa_get_device();
+	int ret;
+
+	ret = ffa_get_device();
+
+#if CONFIG_IS_ENABLED(SANDBOX_FFA)
+	if (ret == FFA_ERR_STAT_SUCCESS)
+		ret = sandbox_ffa_get_device();
+#endif
+
+	return ret;
 }
diff --git a/drivers/arm-ffa/core.c b/drivers/arm-ffa/core.c
index 9d0dab1d36..a4d9c08482 100644
--- a/drivers/arm-ffa/core.c
+++ b/drivers/arm-ffa/core.c
@@ -5,6 +5,11 @@
  */
 
 #include "arm_ffa_prv.h"
+
+#if CONFIG_IS_ENABLED(SANDBOX_FFA)
+#include "sandbox_arm_ffa_prv.h"
+#endif
+
 #include <asm/global_data.h>
 #include <asm/io.h>
 #include <common.h>
@@ -82,8 +87,10 @@ static int ffa_get_version(void)
 
 	FFA_DECLARE_ARGS;
 
-	if (!ffa_priv_data.invoke_ffa_fn)
-		panic("[FFA] no private data found\n");
+	if (!ffa_priv_data.invoke_ffa_fn) {
+		ffa_panic("no private data found\n");
+		return -ENODEV;
+	}
 
 	a0 = FFA_VERSION;
 	a1 = FFA_VERSION_1_0;
@@ -126,8 +133,10 @@ static int ffa_get_endpoint_id(void)
 {
 	FFA_DECLARE_ARGS;
 
-	if (!ffa_priv_data.invoke_ffa_fn)
-		panic("[FFA] no private data found\n");
+	if (!ffa_priv_data.invoke_ffa_fn) {
+		ffa_panic("no private data found\n");
+		return -ENODEV;
+	}
 
 	a0 = FFA_ID_GET;
 
@@ -200,8 +209,10 @@ static int ffa_get_rxtx_map_features(void)
 {
 	FFA_DECLARE_ARGS;
 
-	if (!ffa_priv_data.invoke_ffa_fn)
-		panic("[FFA] no private data found\n");
+	if (!ffa_priv_data.invoke_ffa_fn) {
+		ffa_panic("no private data found\n");
+		return -ENODEV;
+	}
 
 	a0 = FFA_FEATURES;
 	a1 = FFA_RXTX_MAP;
@@ -427,8 +438,10 @@ static int ffa_map_rxtx_buffers(size_t buf_4k_pages)
 
 	FFA_DECLARE_ARGS;
 
-	if (!ffa_priv_data.invoke_ffa_fn)
-		panic("[FFA] no private data found\n");
+	if (!ffa_priv_data.invoke_ffa_fn) {
+		ffa_panic("no private data found\n");
+		return -ENODEV;
+	}
 
 	ret = ffa_alloc_rxtx_buffers(buf_4k_pages);
 	if (ret != FFA_ERR_STAT_SUCCESS)
@@ -496,8 +509,10 @@ static int ffa_unmap_rxtx_buffers(void)
 {
 	FFA_DECLARE_ARGS;
 
-	if (!ffa_priv_data.invoke_ffa_fn)
-		panic("[FFA] no private data found\n");
+	if (!ffa_priv_data.invoke_ffa_fn) {
+		ffa_panic("no private data found\n");
+		return -ENODEV;
+	}
 
 	a0 = FFA_RXTX_UNMAP;
 	a1 = PREP_SELF_ENDPOINT_ID(ffa_priv_data.id);
@@ -508,11 +523,12 @@ static int ffa_unmap_rxtx_buffers(void)
 	case FFA_ERROR:
 	{
 		if (((int)res.a2) == FFA_ERR_STAT_NOT_SUPPORTED)
-			panic("[FFA] FFA_RXTX_UNMAP is not implemented at this FF-A instance\n");
+			ffa_panic("FFA_RXTX_UNMAP is not implemented at this FF-A instance\n");
 		else if (((int)res.a2) == FFA_ERR_STAT_INVALID_PARAMETERS)
-			panic("[FFA] There is no buffer pair registered on behalf of the caller\n");
+			ffa_panic("There is no buffer pair registered on behalf of the caller\n");
 		else
-			panic("[FFA] Undefined error (%d)\n", ((int)res.a2));
+			ffa_panic("Undefined error (%d)\n", ((int)res.a2));
+		return -ENODEV;
 	}
 	case FFA_SUCCESS:
 	{
@@ -520,19 +536,24 @@ static int ffa_unmap_rxtx_buffers(void)
 		int ret;
 
 		ret = ffa_get_rxtx_buffers_pages_cnt(&buf_4k_pages);
-		if (ret != FFA_ERR_STAT_SUCCESS)
-			panic("[FFA] RX/TX buffers unmapped but failure in getting pages count\n");
+		if (ret != FFA_ERR_STAT_SUCCESS) {
+			ffa_panic("RX/TX buffers unmapped but failure in getting pages count\n");
+			return -ENODEV;
+		}
 
 		ret = ffa_free_rxtx_buffers(buf_4k_pages);
-		if (ret != FFA_ERR_STAT_SUCCESS)
-			panic("[FFA] RX/TX buffers unmapped but failure in freeing the memory\n");
+		if (ret != FFA_ERR_STAT_SUCCESS) {
+			ffa_panic("RX/TX buffers unmapped but failure in freeing the memory\n");
+			return -ENODEV;
+		}
 
 		ffa_info("RX/TX buffers unmapped and memory freed");
 
 		return FFA_ERR_STAT_SUCCESS;
 	}
 	default:
-		panic("[FFA] Undefined response function (0x%lx)", res.a0);
+		ffa_panic("Undefined response function (0x%lx)", res.a0);
+		return -ENODEV;
 	}
 }
 
@@ -550,8 +571,10 @@ static int ffa_release_rx_buffer(void)
 {
 	FFA_DECLARE_ARGS;
 
-	if (!ffa_priv_data.invoke_ffa_fn)
-		panic("[FFA] no private data found\n");
+	if (!ffa_priv_data.invoke_ffa_fn) {
+		ffa_panic("no private data found\n");
+		return -ENODEV;
+	}
 
 	a0 = FFA_RX_RELEASE;
 
@@ -561,17 +584,19 @@ static int ffa_release_rx_buffer(void)
 	case FFA_ERROR:
 	{
 		if (((int)res.a2) == FFA_ERR_STAT_NOT_SUPPORTED)
-			panic("[FFA] FFA_RX_RELEASE is not implemented at this FF-A instance\n");
+			ffa_panic("FFA_RX_RELEASE is not implemented at this FF-A instance\n");
 		else if (((int)res.a2) == FFA_ERR_STAT_DENIED)
-			panic("[FFA] Caller did not have ownership of the RX buffer\n");
+			ffa_panic("Caller did not have ownership of the RX buffer\n");
 		else
-			panic("[FFA] Undefined error (%d)\n", ((int)res.a2));
+			ffa_panic("Undefined error (%d)\n", ((int)res.a2));
+		return -ENODEV;
 	}
 	case FFA_SUCCESS:
 		return FFA_ERR_STAT_SUCCESS;
 
 	default:
-		panic("[FFA] Undefined response function (0x%lx)\n", res.a0);
+		ffa_panic("Undefined response function (0x%lx)\n", res.a0);
+		return -ENODEV;
 	}
 }
 
@@ -763,8 +788,10 @@ static int ffa_query_partitions_info(union ffa_partition_uuid *part_uuid,
 	unsigned long a7 = 0;
 	struct arm_smccc_res res = {0};
 
-	if (!ffa_priv_data.invoke_ffa_fn)
-		panic("[FFA] no private data found\n");
+	if (!ffa_priv_data.invoke_ffa_fn) {
+		ffa_panic("no private data found\n");
+		return -ENODEV;
+	}
 
 	a0 = FFA_PARTITION_INFO_GET;
 
@@ -840,7 +867,7 @@ static int ffa_query_partitions_info(union ffa_partition_uuid *part_uuid,
 		ret = ffa_release_rx_buffer();
 
 		if (!part_uuid && !res.a2) {
-			ffa_err("[FFA] no partition installed in the system");
+			ffa_err("no partition installed in the system");
 			return -ENODEV;
 		}
 
@@ -931,8 +958,10 @@ static int ffa_get_partitions_info(struct ffa_interface_data *func_data)
 		return -EINVAL;
 	}
 
-	if (!ffa_priv_data.partitions.count || !ffa_priv_data.partitions.descs)
-		panic("[FFA] No partition installed\n");
+	if (!ffa_priv_data.partitions.count || !ffa_priv_data.partitions.descs) {
+		ffa_panic("No partition installed\n");
+		return -ENODEV;
+	}
 
 	if (func_data->data0_size == sizeof(union ffa_partition_uuid) &&
 	    func_data->data0 &&
@@ -1170,6 +1199,7 @@ static int __ffa_runtime ffa_msg_send_direct_req(struct ffa_interface_data
 			/* Undefined error */
 			return -ENXIO;
 		}
+		return -ENODEV;
 	}
 	case FFA_SUCCESS:
 
@@ -1247,7 +1277,13 @@ static int ffa_init_private_data(struct udevice *dev)
 	ffa_priv_data.conduit = pdata->conduit;
 
 	if (ffa_priv_data.conduit == FFA_CONDUIT_SMC) {
+#if CONFIG_IS_ENABLED(SANDBOX_FFA)
+		ffa_priv_data.invoke_ffa_fn = sandbox_arm_ffa_smccc_smc;
+		ffa_info("Using SMC emulation");
+#else
 		ffa_priv_data.invoke_ffa_fn = arm_ffa_smccc_smc;
+#endif
+
 	} else {
 		ffa_err("Undefined FF-A conduit (%d)", ffa_priv_data.conduit);
 		return -EINVAL;
diff --git a/drivers/arm-ffa/sandbox.c b/drivers/arm-ffa/sandbox.c
new file mode 100644
index 0000000000..fcabd4b59b
--- /dev/null
+++ b/drivers/arm-ffa/sandbox.c
@@ -0,0 +1,735 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * (C) Copyright 2022 ARM Limited
+ * Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
+ */
+
+#include "sandbox_arm_ffa_prv.h"
+#include <asm/global_data.h>
+#include <common.h>
+#include <dm.h>
+#include <linux/errno.h>
+#include <linux/sizes.h>
+#include <mapmem.h>
+#include <string.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+/**
+ * The device private data structure containing all the emulated secure world data
+ */
+static struct sandbox_ffa_prvdata  sandbox_ffa_priv_data = {0};
+
+/* The partitions (SPs) table */
+static struct ffa_partition_desc sandbox_partitions[SANDBOX_PARTITIONS_CNT] = {
+	{
+		.info = { .id = 0x1245, .exec_ctxt = 0x5687, .properties = 0x89325621 },
+		.UUID = { .bytes = {SANDBOX_SERVICE1_UUID_DATA}}
+	},
+	{
+		.info = { .id = 0x9836, .exec_ctxt = 0x9587, .properties = 0x45325621 },
+		.UUID = { .bytes = {SANDBOX_SERVICE2_UUID_DATA}}
+	},
+	{
+		.info = { .id = 0x6452, .exec_ctxt = 0x7687, .properties = 0x23325621 },
+		.UUID = { .bytes = {SANDBOX_SERVICE1_UUID_DATA}}
+	},
+	{
+		.info = { .id = 0x7814, .exec_ctxt = 0x1487, .properties = 0x70325621 },
+		.UUID = { .bytes = {SANDBOX_SERVICE2_UUID_DATA}}
+	}
+
+};
+
+/*
+ * Driver functions
+ */
+
+/**
+ * sandbox_ffa_get_device - probes the sandbox_arm_ffa device
+ *
+ * This function makes sure the sandbox_arm_ffa device is probed
+ * and ready for use. This is done using uclass_get_device.
+ * The arm_ffa driver belongs to UCLASS_FFA.
+ * This function should be called before using the driver.
+ *
+ * sandbox_arm_ffa depends on arm_ffa device. This dependency is
+ * handled by ffa_init_device function. arm_ffa is probed first then
+ * it probes sandbox_arm_ffa using sandbox_ffa_get_device.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+int sandbox_ffa_get_device(void)
+{
+	int ret;
+	int devnum = 1;
+
+	if (sandbox_ffa_priv_data.dev)
+		return FFA_ERR_STAT_SUCCESS;
+
+	/*
+	 * searching and probing the device
+	 */
+	ret = uclass_get_device(UCLASS_FFA, devnum, &sandbox_ffa_priv_data.dev);
+	if (ret) {
+		ffa_err("[Sandbox] Can not find the FF-A Sandbox device");
+		sandbox_ffa_priv_data.dev = NULL;
+		return -ENODEV;
+	}
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_ffa_version - Emulated FFA_VERSION handler function
+ * @{a0-a7} , res: The SMC call arguments and return structure.
+ *
+ * This is the function that emulates FFA_VERSION FF-A function.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+SANDBOX_SMC_FFA_ABI(ffa_version)
+{
+	sandbox_ffa_priv_data.fwk_version = FFA_VERSION_1_0;
+	res->a0 = sandbox_ffa_priv_data.fwk_version;
+
+	/* w1-w7 MBZ */
+	memset(FFA_W1W7_MBZ_REG_START, 0, FFA_W1W7_MBZ_CNT * sizeof(unsigned long));
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_ffa_id_get - Emulated FFA_ID_GET handler function
+ * @{a0-a7} , res: The SMC call arguments and return structure.
+ *
+ * This is the function that emulates FFA_ID_GET FF-A function.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+SANDBOX_SMC_FFA_ABI(ffa_id_get)
+{
+	res->a0 = FFA_SUCCESS;
+	res->a1 = 0;
+
+	sandbox_ffa_priv_data.id = NS_PHYS_ENDPOINT_ID;
+	res->a2 = sandbox_ffa_priv_data.id;
+
+	/* w3-w7 MBZ */
+	memset(FFA_W3_MBZ_REG_START, 0, FFA_W3W7_MBZ_CNT * sizeof(unsigned long));
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_ffa_features - Emulated FFA_FEATURES handler function
+ * @{a0-a7} , res: The SMC call arguments and return structure.
+ *
+ * This is the function that emulates FFA_FEATURES FF-A function.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+SANDBOX_SMC_FFA_ABI(ffa_features)
+{
+	switch (a1) {
+	case FFA_RXTX_MAP:
+	{
+		res->a0 = FFA_SUCCESS;
+		res->a2 = RXTX_BUFFERS_MIN_SIZE;
+		res->a3 = 0;
+		/* w4-w7 MBZ */
+		memset(FFA_W4W7_MBZ_REG_START,
+		       0, FFA_W4W7_MBZ_CNT * sizeof(unsigned long));
+		break;
+	}
+	default:
+	{
+		res->a0 = FFA_ERROR;
+		res->a2 = FFA_ERR_STAT_NOT_SUPPORTED;
+		/* w3-w7 MBZ */
+		memset(FFA_W3_MBZ_REG_START,
+		       0, FFA_W3W7_MBZ_CNT * sizeof(unsigned long));
+		ffa_err("[Sandbox] FF-A interface 0x%lx not implemented", a1);
+	}
+	}
+
+	res->a1 = 0;
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_ffa_partition_info_get - Emulated FFA_PARTITION_INFO_GET handler function
+ * @{a0-a7} , res: The SMC call arguments and return structure.
+ *
+ * This is the function that emulates FFA_PARTITION_INFO_GET FF-A function.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+SANDBOX_SMC_FFA_ABI(ffa_partition_info_get)
+{
+	struct ffa_partition_info *rxbuf_desc_info = NULL;
+	u32 descs_cnt;
+	u32 descs_size_bytes;
+
+	res->a0 = FFA_ERROR;
+
+	if (!sandbox_ffa_priv_data.pair.rxbuf) {
+		res->a2 = FFA_ERR_STAT_DENIED;
+		goto cleanup;
+	}
+
+	if (sandbox_ffa_priv_data.pair_info.rxbuf_owned) {
+		res->a2 = FFA_ERR_STAT_BUSY;
+		goto cleanup;
+	}
+
+	if (!sandbox_ffa_priv_data.partitions.descs) {
+		sandbox_ffa_priv_data.partitions.descs = sandbox_partitions;
+		sandbox_ffa_priv_data.partitions.count = SANDBOX_PARTITIONS_CNT;
+	}
+
+	descs_size_bytes = SANDBOX_PARTITIONS_CNT * sizeof(struct ffa_partition_desc);
+
+	/* Abort if the RX buffer size is smaller than the descriptors buffer size */
+	if ((sandbox_ffa_priv_data.pair_info.rxtx_buf_size * SZ_4K) < descs_size_bytes) {
+		res->a2 = FFA_ERR_STAT_NO_MEMORY;
+		goto cleanup;
+	}
+
+	rxbuf_desc_info = (struct ffa_partition_info *)sandbox_ffa_priv_data.pair.rxbuf;
+
+	/* No UUID specified. Return the information of all partitions */
+	if (!a1 && !a2 && !a3 && !a4) {
+		for (descs_cnt = 0 ; descs_cnt < SANDBOX_PARTITIONS_CNT ; descs_cnt++)
+			*(rxbuf_desc_info++) =
+				sandbox_ffa_priv_data.partitions.descs[descs_cnt].info;
+
+		res->a0 = FFA_SUCCESS;
+		res->a2 = SANDBOX_PARTITIONS_CNT;
+		/* transfer ownership to the consumer: the non secure world */
+		sandbox_ffa_priv_data.pair_info.rxbuf_owned = 1;
+
+		goto cleanup;
+	}
+
+	/*
+	 * A UUID is specified. Return the information of all partitions matching
+	 * the UUID
+	 */
+
+	for (descs_cnt = 0 ; descs_cnt < SANDBOX_PARTITIONS_CNT ; descs_cnt++)
+		if (a1 == sandbox_ffa_priv_data.partitions.descs[descs_cnt].UUID.words.a1 &&
+		    a2 == sandbox_ffa_priv_data.partitions.descs[descs_cnt].UUID.words.a2 &&
+		    a3 == sandbox_ffa_priv_data.partitions.descs[descs_cnt].UUID.words.a3 &&
+		    a4 == sandbox_ffa_priv_data.partitions.descs[descs_cnt].UUID.words.a4) {
+			*(rxbuf_desc_info++) =
+				sandbox_ffa_priv_data.partitions.descs[descs_cnt].info;
+		}
+
+	if (rxbuf_desc_info != ((struct ffa_partition_info *)sandbox_ffa_priv_data.pair.rxbuf)) {
+		res->a0 = FFA_SUCCESS;
+		/* store the partitions count */
+		res->a2 = (unsigned long)
+			(rxbuf_desc_info - (struct ffa_partition_info *)
+			 sandbox_ffa_priv_data.pair.rxbuf);
+
+		/* transfer ownership to the consumer: the non secure world */
+		sandbox_ffa_priv_data.pair_info.rxbuf_owned = 1;
+	} else {
+		res->a2 = FFA_ERR_STAT_INVALID_PARAMETERS;
+	}
+
+cleanup:
+
+	ffa_err("[Sandbox] FFA_PARTITION_INFO_GET (%ld)", res->a2);
+
+	res->a1 = 0;
+
+	/* w3-w7 MBZ */
+	memset(FFA_W3_MBZ_REG_START, 0, FFA_W3W7_MBZ_CNT * sizeof(unsigned long));
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_ffa_rxtx_map - Emulated FFA_RXTX_MAP handler function
+ * @{a0-a7} , res: The SMC call arguments and return structure.
+ *
+ * This is the function that emulates FFA_RXTX_MAP FF-A function.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+SANDBOX_SMC_FFA_ABI(ffa_rxtx_map)
+{
+	res->a0 = FFA_ERROR;
+
+	if (sandbox_ffa_priv_data.pair.txbuf && sandbox_ffa_priv_data.pair.rxbuf) {
+		res->a2 = FFA_ERR_STAT_DENIED;
+		goto feedback;
+	}
+
+	if (a3 >= RXTX_BUFFERS_MIN_PAGES && a1 && a2) {
+		sandbox_ffa_priv_data.pair.txbuf = a1;
+		sandbox_ffa_priv_data.pair.rxbuf = a2;
+		sandbox_ffa_priv_data.pair_info.rxtx_buf_size = a3;
+		sandbox_ffa_priv_data.pair_info.rxbuf_mapped = 1;
+		res->a0 = FFA_SUCCESS;
+		res->a2 = 0;
+		goto feedback;
+	}
+
+	if (!a1 || !a2)
+		res->a2 = FFA_ERR_STAT_INVALID_PARAMETERS;
+	else
+		res->a2 = FFA_ERR_STAT_NO_MEMORY;
+
+	ffa_err("[Sandbox] error in FFA_RXTX_MAP arguments (%d)", (int)res->a2);
+
+feedback:
+
+	res->a1 = 0;
+
+	/* w3-w7 MBZ */
+	memset(FFA_W3_MBZ_REG_START,
+	       0, FFA_W3W7_MBZ_CNT * sizeof(unsigned long));
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_ffa_rxtx_unmap - Emulated FFA_RXTX_UNMAP handler function
+ * @{a0-a7} , res: The SMC call arguments and return structure.
+ *
+ * This is the function that emulates FFA_RXTX_UNMAP FF-A function.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+SANDBOX_SMC_FFA_ABI(ffa_rxtx_unmap)
+{
+	res->a0 = FFA_ERROR;
+	res->a2 = FFA_ERR_STAT_INVALID_PARAMETERS;
+
+	if (GET_NS_PHYS_ENDPOINT_ID(a1) != sandbox_ffa_priv_data.id)
+		goto feedback;
+
+	if (sandbox_ffa_priv_data.pair.txbuf && sandbox_ffa_priv_data.pair.rxbuf) {
+		sandbox_ffa_priv_data.pair.txbuf = 0;
+		sandbox_ffa_priv_data.pair.rxbuf = 0;
+		sandbox_ffa_priv_data.pair_info.rxtx_buf_size = 0;
+		sandbox_ffa_priv_data.pair_info.rxbuf_mapped = 0;
+		res->a0 = FFA_SUCCESS;
+		res->a2 = 0;
+		goto feedback;
+	}
+
+	ffa_err("[Sandbox] No buffer pair registered on behalf of the caller");
+
+feedback:
+
+	res->a1 = 0;
+
+	/* w3-w7 MBZ */
+	memset(FFA_W3_MBZ_REG_START,
+	       0, FFA_W3W7_MBZ_CNT * sizeof(unsigned long));
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_ffa_rx_release - Emulated FFA_RX_RELEASE handler function
+ * @{a0-a7} , res: The SMC call arguments and return structure.
+ *
+ * This is the function that emulates FFA_RX_RELEASE FF-A function.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+SANDBOX_SMC_FFA_ABI(ffa_rx_release)
+{
+	if (!sandbox_ffa_priv_data.pair_info.rxbuf_owned) {
+		res->a0 = FFA_ERROR;
+		res->a2 = FFA_ERR_STAT_DENIED;
+	} else {
+		sandbox_ffa_priv_data.pair_info.rxbuf_owned = 0;
+		res->a0 = FFA_SUCCESS;
+		res->a2 = 0;
+	}
+
+	res->a1 = 0;
+
+	/* w3-w7 MBZ */
+	memset(FFA_W3_MBZ_REG_START,
+	       0, FFA_W3W7_MBZ_CNT * sizeof(unsigned long));
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_ffa_sp_valid - Checks SP validity
+ * @part_id: partition ID to check
+ *
+ * This is the function searches the input ID in the descriptors table.
+ *
+ * Return:
+ *
+ * 1 on success (Partition found). Otherwise, failure
+ */
+int sandbox_ffa_sp_valid(u16 part_id)
+{
+	u32 descs_cnt;
+
+	for (descs_cnt = 0 ; descs_cnt < SANDBOX_PARTITIONS_CNT ; descs_cnt++)
+		if (sandbox_ffa_priv_data.partitions.descs[descs_cnt].info.id == part_id)
+			return 1;
+
+	return 0;
+}
+
+/**
+ * sandbox_ffa_msg_send_direct_req - Emulated FFA_MSG_SEND_DIRECT_{REQ,RESP} handler function
+ * @{a0-a7} , res: The SMC call arguments and return structure.
+ *
+ * This is the function that emulates FFA_MSG_SEND_DIRECT_{REQ,RESP}
+ * FF-A functions.
+ *
+ * Emulating interrupts is not supported. So, FFA_RUN and FFA_INTERRUPT are not supported.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+SANDBOX_SMC_FFA_ABI(ffa_msg_send_direct_req)
+{
+	u16 part_id;
+
+	part_id = GET_DST_SP_ID(a1);
+
+	if ((GET_NS_PHYS_ENDPOINT_ID(a1) != sandbox_ffa_priv_data.id) ||
+	    !sandbox_ffa_sp_valid(part_id) ||
+		a2) {
+		res->a0 = FFA_ERROR;
+		res->a1 = 0;
+		res->a2 = FFA_ERR_STAT_INVALID_PARAMETERS;
+
+		/* w3-w7 MBZ */
+		memset(FFA_W3_MBZ_REG_START,
+		       0, FFA_W3W7_MBZ_CNT * sizeof(unsigned long));
+
+		return FFA_ERR_STAT_SUCCESS;
+	}
+
+	res->a0 = FFA_MSG_SEND_DIRECT_RESP;
+
+	res->a1 = PREP_SRC_SP_ID(part_id) |
+		PREP_NS_PHYS_ENDPOINT_ID(sandbox_ffa_priv_data.id);
+
+	res->a2 = 0;
+
+	/*
+	 * return 0xff bytes as a response
+	 */
+	res->a3 = 0xffffffff;
+	res->a4 = 0xffffffff;
+	res->a5 = 0xffffffff;
+	res->a6 = 0xffffffff;
+	res->a7 = 0xffffffff;
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_ffa_get_prv_data - Returns the pointer to FF-A core pivate data
+ * @func_data:  Pointer to the FF-A function arguments container structure
+ *
+ * This is the handler that returns the address of the FF-A core pivate data.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+int sandbox_ffa_get_prv_data(struct ffa_interface_data *func_data)
+{
+	if (!func_data)
+		return -EINVAL;
+
+	if (!func_data->data0 || func_data->data0_size != sizeof(struct ffa_prvdata **))
+		return -EINVAL;
+
+	if (!func_data->data1 || func_data->data1_size != sizeof(struct sandbox_ffa_prvdata **))
+		return -EINVAL;
+
+	*((struct ffa_prvdata **)func_data->data0) = &ffa_priv_data;
+	*((struct sandbox_ffa_prvdata **)func_data->data1) = &sandbox_ffa_priv_data;
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_ffa_get_rxbuf_flags - Reading the mapping/ownership flags
+ * @queried_func_id:	The FF-A function to be queried
+ * @func_data:  Pointer to the FF-A function arguments container structure
+ *
+ * This is the handler that queries the status flags of the following emulated ABIs:
+ * FFA_RXTX_MAP, FFA_RXTX_UNMAP, FFA_RX_RELEASE
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+int sandbox_ffa_get_rxbuf_flags(u32 queried_func_id, struct ffa_interface_data *func_data)
+{
+	if (!func_data)
+		return -EINVAL;
+
+	if (!func_data->data0 || func_data->data0_size != sizeof(u8))
+		return -EINVAL;
+
+	switch (queried_func_id) {
+	case FFA_RXTX_MAP:
+	case FFA_RXTX_UNMAP:
+		*((u8 *)func_data->data0) = sandbox_ffa_priv_data.pair_info.rxbuf_mapped;
+		return FFA_ERR_STAT_SUCCESS;
+	case FFA_RX_RELEASE:
+		*((u8 *)func_data->data0) = sandbox_ffa_priv_data.pair_info.rxbuf_owned;
+		return FFA_ERR_STAT_SUCCESS;
+	default:
+		ffa_err("[Sandbox] The querried  FF-A interface flag (%d) undefined",
+			queried_func_id);
+		return -EINVAL;
+	}
+}
+
+/**
+ * invoke_sandbox_ffa_drv_api - The driver dispatcher function
+ * @queried_func_id:	The FF-A function to be queried
+ * @func_data:  Pointer to the FF-A function arguments container structure
+ *
+ * The dispatcher function that selects the handler that queries the
+ * status of FF-A ABIs given in the input argument.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+int invoke_sandbox_ffa_drv_api(u32 queried_func_id, struct ffa_interface_data *func_data)
+{
+	switch (queried_func_id) {
+	case FFA_VERSION:
+	case FFA_ID_GET:
+	case FFA_FEATURES:
+		return sandbox_ffa_get_prv_data(func_data);
+	case FFA_RXTX_MAP:
+	case FFA_RXTX_UNMAP:
+	case FFA_RX_RELEASE:
+		return sandbox_ffa_get_rxbuf_flags(queried_func_id, func_data);
+	default:
+		ffa_err("[Sandbox] The querried  FF-A interface (%d) undefined", queried_func_id);
+		return -EINVAL;
+	}
+}
+
+/**
+ * sandbox_ffa_init_prv_data_from_dtb - init private data fields from DTB
+ * @dev:	the sandbox_arm_ffa device
+ *
+ * The value of the conduit field in the private data structure is read  from the DTB.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+static int sandbox_ffa_init_prv_data_from_dtb(struct udevice *dev)
+{
+	struct ffa_pdata *pdata = dev_get_plat(dev);
+
+	sandbox_ffa_priv_data.conduit = pdata->conduit;
+
+	if (sandbox_ffa_priv_data.conduit != FFA_CONDUIT_SMC) {
+		ffa_err("[Sandbox] Undefined FF-A conduit (%d)", sandbox_ffa_priv_data.conduit);
+		return -EINVAL;
+	}
+
+	ffa_info("[Sandbox] Conduit is SMC");
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_arm_ffa_smccc_smc - FF-A SMC call emulation
+ * @dev:	the SMC arguments to be passed to the FF-A ABI
+ *
+ * Sandbox driver emulates the FF-A ABIs SMC call using this function.
+ * The emulated FF-A ABI is identified and invoked.
+ * FF-A emulation is based on the FF-A specification 1.0
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure.
+ * FF-A protocol error codes are returned using the registers arguments as described
+ * by the specification
+ */
+void sandbox_arm_ffa_smccc_smc(unsigned long a0, unsigned long a1,
+			       unsigned long a2, unsigned long a3, unsigned long a4,
+			       unsigned long a5, unsigned long a6, unsigned long a7,
+			       struct arm_smccc_res *res)
+{
+	int ret = FFA_ERR_STAT_SUCCESS;
+
+	switch (a0) {
+	case FFA_VERSION:
+		ret = sandbox_ffa_version(a0, a1, a2, a3, a4, a5, a6, a7, res);
+		break;
+	case FFA_PARTITION_INFO_GET:
+		ret = sandbox_ffa_partition_info_get(a0, a1, a2, a3, a4, a5, a6, a7, res);
+		break;
+	case FFA_RXTX_UNMAP:
+		ret = sandbox_ffa_rxtx_unmap(a0, a1, a2, a3, a4, a5, a6, a7, res);
+		break;
+	case FFA_MSG_SEND_DIRECT_REQ:
+		ret = sandbox_ffa_msg_send_direct_req(a0, a1, a2, a3, a4, a5, a6, a7, res);
+		break;
+	case FFA_ID_GET:
+		ret = sandbox_ffa_id_get(a0, a1, a2, a3, a4, a5, a6, a7, res);
+		break;
+	case FFA_FEATURES:
+		ret = sandbox_ffa_features(a0, a1, a2, a3, a4, a5, a6, a7, res);
+		break;
+	case FFA_RXTX_MAP:
+		ret = sandbox_ffa_rxtx_map(a0, a1, a2, a3, a4, a5, a6, a7, res);
+		break;
+	case FFA_RX_RELEASE:
+		ret = sandbox_ffa_rx_release(a0, a1, a2, a3, a4, a5, a6, a7, res);
+		break;
+	default:
+		ffa_err("[Sandbox] Undefined FF-A interface (0x%x)", (unsigned int)a0);
+	}
+
+	if (ret != FFA_ERR_STAT_SUCCESS)
+		ffa_err("[Sandbox] FF-A ABI internal failure  (%d)", ret);
+}
+
+/**
+ * sandbox_ffa_bind - The driver bind function
+ * @dev:	the arm_ffa device
+ *
+ * Called when the driver is bound with the device based on the DTB node.
+ * The private data structure is cleared before use.
+ * This makes sure that when the device added/removed  multiple times the previous
+ * private structure is cleared.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS
+ */
+static int sandbox_ffa_bind(struct udevice *dev)
+{
+	memset(&sandbox_ffa_priv_data, 0, sizeof(sandbox_ffa_priv_data));
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_ffa_probe - The driver probe function
+ * @dev:	the sandbox_arm_ffa device
+ *
+ * Probing is triggered by the uclass device discovery.
+ * At probe level the device tree conduit in the private structure
+ * is read from the DTB.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+static int sandbox_ffa_probe(struct udevice *dev)
+{
+	return sandbox_ffa_init_prv_data_from_dtb(dev);
+}
+
+/**
+ * sandbox_ffa_of_to_plat - Reads the device tree node
+ * @dev:	the sandbox_arm_ffa device
+ *
+ * This function reads data from the device tree node and populates
+ * the platform data structure
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+static int sandbox_ffa_of_to_plat(struct udevice *dev)
+{
+	struct ffa_pdata *pdata = dev_get_plat(dev);
+	const char *conduit;
+
+	conduit = dev_read_string(dev, "method");
+
+	if (!conduit) {
+		ffa_err("[Sandbox] Failure to read the conduit from device tree");
+		return -EINVAL;
+	}
+
+	if (strcmp("smc", conduit)) {
+		ffa_err("[Sandbox] Unsupported conduit");
+		return -EINVAL;
+	}
+
+	pdata->conduit = FFA_CONDUIT_SMC;
+
+	return FFA_ERR_STAT_SUCCESS;
+}
+
+/**
+ * sandbox_ffa_drv_ops - The driver operations  structure
+ * @invoke_func:	The driver dispatcher
+ */
+struct ffa_ops  sandbox_ffa_drv_ops = {
+	.invoke_func = invoke_sandbox_ffa_drv_api
+};
+
+/**
+ * sandbox_ffa_device_get_ops - driver operations getter
+ *
+ * Return:
+ * This function returns a pointer to the driver operations structure
+ */
+const struct ffa_ops *sandbox_ffa_device_get_ops(void)
+{
+	return &sandbox_ffa_drv_ops;
+}
+
+/**
+ * Defining the device tree compatible string
+ */
+static const struct udevice_id sandbox_ffa_match_id[] = {
+	{"sandbox,ffa", 0},
+	{},
+};
+
+/**
+ * Declaring the sandbox_arm_ffa driver under UCLASS_FFA
+ */
+U_BOOT_DRIVER(sandbox_arm_ffa) = {
+	.name		= "sandbox_arm_ffa",
+	.of_match	= sandbox_ffa_match_id,
+	.id		= UCLASS_FFA,
+	.of_to_plat	= sandbox_ffa_of_to_plat,
+	.probe		= sandbox_ffa_probe,
+	.bind		= sandbox_ffa_bind,
+	.plat_auto	= sizeof(struct ffa_pdata),
+};
diff --git a/drivers/arm-ffa/sandbox_arm_ffa_prv.h b/drivers/arm-ffa/sandbox_arm_ffa_prv.h
new file mode 100644
index 0000000000..9f5085f098
--- /dev/null
+++ b/drivers/arm-ffa/sandbox_arm_ffa_prv.h
@@ -0,0 +1,128 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * (C) Copyright 2022 ARM Limited
+ * Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
+ */
+
+#ifndef __SANDBOX_ARM_FFA_PRV_H
+#define __SANDBOX_ARM_FFA_PRV_H
+
+#include "arm_ffa_prv.h"
+
+/*
+ * This header is private. It is exclusively used by the Sandbox FF-A driver
+ */
+
+/* Non-secure physical FF-A instance */
+#define NS_PHYS_ENDPOINT_ID (0)
+
+#define GET_NS_PHYS_ENDPOINT_ID_MASK		GENMASK(31, 16)
+#define GET_NS_PHYS_ENDPOINT_ID(x)		\
+			((u16)(FIELD_GET(GET_NS_PHYS_ENDPOINT_ID_MASK, (x))))
+
+/* Helper macro for reading the destination partition ID */
+#define GET_DST_SP_ID_MASK		GENMASK(15, 0)
+#define GET_DST_SP_ID(x)		\
+			((u16)(FIELD_GET(GET_DST_SP_ID_MASK, (x))))
+
+/* Helper macro for setting the source partition ID */
+#define PREP_SRC_SP_ID_MASK		GENMASK(31, 16)
+#define PREP_SRC_SP_ID(x)		\
+			(FIELD_PREP(PREP_SRC_SP_ID_MASK, (x)))
+
+/* Helper macro for setting the destination endpoint ID */
+#define PREP_NS_PHYS_ENDPOINT_ID_MASK		GENMASK(15, 0)
+#define PREP_NS_PHYS_ENDPOINT_ID(x)		\
+			(FIELD_PREP(PREP_NS_PHYS_ENDPOINT_ID_MASK, (x)))
+
+/*  RX/TX buffers minimum size */
+#define RXTX_BUFFERS_MIN_SIZE (RXTX_4K)
+#define RXTX_BUFFERS_MIN_PAGES (1)
+
+/* MBZ registers info */
+
+/* w1-w7 MBZ */
+#define FFA_W1W7_MBZ_CNT (7)
+#define FFA_W1W7_MBZ_REG_START (&res->a1)
+
+/* w4-w7 MBZ */
+#define FFA_W4W7_MBZ_CNT (4)
+#define FFA_W4W7_MBZ_REG_START (&res->a4)
+
+/* w3-w7 MBZ */
+#define FFA_W3W7_MBZ_CNT (5)
+#define FFA_W3_MBZ_REG_START (&res->a3)
+
+/* secure partitions count */
+#define SANDBOX_PARTITIONS_CNT (4)
+
+/* service 1  UUID binary data (little-endian format) */
+#define SANDBOX_SERVICE1_UUID_DATA	\
+	0xed, 0x32, 0xd5, 0x33,	\
+	0x99, 0xe6, 0x42, 0x09,	\
+	0x9c, 0xc0, 0x2d, 0x72,	\
+	0xcd, 0xd9, 0x98, 0xa7
+
+/* service 2 UUID binary data (little-endian format) */
+#define SANDBOX_SERVICE2_UUID_DATA	\
+	0xab, 0xcd, 0xd5, 0x33,	\
+	0x99, 0xe6, 0x42, 0x09,	\
+	0x9c, 0xc0, 0x2d, 0x72,	\
+	0xcd, 0xd9, 0x98, 0xa7
+
+/**
+ * struct ffa_rxtxpair_info - structure hosting the RX/TX buffers flags
+ * @rxbuf_owned:	RX buffer ownership flag (the owner is non secure world: the consumer)
+ * @rxbuf_mapped:	RX buffer mapping flag
+ * @txbuf_owned	TX buffer ownership flag
+ * @txbuf_mapped:	TX buffer mapping flag
+ * @rxtx_buf_size:	RX/TX buffers size as set by the FF-A core driver
+ *
+ * Data structure hosting the ownership/mapping flags of the RX/TX buffers
+ * When a buffer is owned/mapped its corresponding flag is set to 1 otherwise 0.
+ */
+struct ffa_rxtxpair_info {
+	u8 rxbuf_owned;
+	u8 rxbuf_mapped;
+	u8 txbuf_owned;
+	u8 txbuf_mapped;
+	u32 rxtx_buf_size;
+};
+
+/**
+ * struct sandbox_ffa_prvdata - the driver private data structure
+ *
+ * @dev:	The arm_ffa device under u-boot driver model
+ * @fwk_version:	FF-A framework version
+ * @id:	u-boot endpoint ID
+ * @partitions:	The partitions descriptors structure
+ * @pair:	The RX/TX buffers pair
+ * @pair_info:	The RX/TX buffers pair flags and size
+ * @conduit:	The selected conduit
+ *
+ * The driver data structure hosting all the emulated secure world data.
+ */
+struct sandbox_ffa_prvdata {
+	struct udevice *dev;
+	u32 fwk_version;
+	u16 id;
+	struct ffa_partitions partitions;
+	struct ffa_rxtxpair pair;
+	struct ffa_rxtxpair_info pair_info;
+	enum ffa_conduit conduit;
+};
+
+void sandbox_arm_ffa_smccc_smc(unsigned long a0, unsigned long a1,
+			       unsigned long a2, unsigned long a3, unsigned long a4,
+			       unsigned long a5, unsigned long a6, unsigned long a7,
+			       struct arm_smccc_res *res);
+
+#define SANDBOX_SMC_FFA_ABI(ffabi) static int sandbox_##ffabi(unsigned long a0, unsigned long a1, \
+				    unsigned long a2, unsigned long a3, unsigned long a4, \
+				    unsigned long a5, unsigned long a6, unsigned long a7, \
+				    struct arm_smccc_res *res)
+
+/* The core FF-A private data structure to inspect */
+extern struct ffa_prvdata ffa_priv_data;
+
+#endif
diff --git a/include/arm_ffa.h b/include/arm_ffa.h
index 5a2151f8e4..bff565f2af 100644
--- a/include/arm_ffa.h
+++ b/include/arm_ffa.h
@@ -22,6 +22,13 @@
 #define ffa_info(fmt, ...)  pr_info("[FFA] " fmt "\n", ##__VA_ARGS__)
 #define ffa_err(fmt, ...)  pr_err("[FFA] " fmt "\n", ##__VA_ARGS__)
 
+/* panic only on real HW. On sandbox mode return an error code */
+#if CONFIG_IS_ENABLED(SANDBOX_FFA)
+#define ffa_panic(fmt, ...) ffa_err("[FFA] " fmt "\n", ##__VA_ARGS__)
+#else
+#define ffa_panic(fmt, ...) panic("[FFA] " fmt "\n", ##__VA_ARGS__)
+#endif
+
 /*
  * The driver operations success error code
  */
@@ -184,7 +191,7 @@ const struct ffa_ops * __ffa_runtime ffa_device_get_ops(void);
 int ffa_get_device(void);
 
 /**
- * ffa_init_device - probes the arm_ffa device
+ * ffa_init_device - probes the arm_ffa and arm_ffa devices
  */
 int ffa_init_device(void);
 #endif
diff --git a/include/sandbox_arm_ffa.h b/include/sandbox_arm_ffa.h
new file mode 100644
index 0000000000..fc681018ff
--- /dev/null
+++ b/include/sandbox_arm_ffa.h
@@ -0,0 +1,31 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * (C) Copyright 2022 ARM Limited
+ * Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
+ */
+
+#ifndef __SANDBOX_ARM_FFA_H
+#define __SANDBOX_ARM_FFA_H
+
+#include <arm_ffa.h>
+
+/**
+ * The device driver and the Uclass driver public functions
+ */
+
+/**
+ * sandbox_ffa_get_invoke_func - performs a call to the Sandbox FF-A driver dispatcher
+ */
+int sandbox_ffa_get_invoke_func(u32 func_id, struct ffa_interface_data *func_data);
+
+/**
+ * sandbox_ffa_device_get_ops - driver operations getter
+ */
+const struct ffa_ops *sandbox_ffa_device_get_ops(void);
+
+/**
+ * sandbox_ffa_get_device - probes the sandbox_arm_ffa device
+ */
+int sandbox_ffa_get_device(void);
+
+#endif
diff --git a/include/sandbox_arm_ffa_helper.h b/include/sandbox_arm_ffa_helper.h
new file mode 100644
index 0000000000..f0fcd04536
--- /dev/null
+++ b/include/sandbox_arm_ffa_helper.h
@@ -0,0 +1,26 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * (C) Copyright 2022 ARM Limited
+ * Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
+ */
+
+#ifndef __SANDBOX_ARM_FFA_HELPER_H
+#define __SANDBOX_ARM_FFA_HELPER_H
+
+#include <arm_ffa_helper.h>
+#include <sandbox_arm_ffa.h>
+#include "../drivers/arm-ffa/sandbox_arm_ffa_prv.h"
+
+/*
+ * This header is public. Including this header provides all FF-A Sandbox data structures
+ * It also provides the helper function allowing to pass data and invoke Sandbox  FF-A functions
+ * used for testing the FF-A core driver
+ */
+
+/**
+ * sandbox_ffa_helper_query_core_state - Wrapper function for
+ *  reading the FF-A core driver data
+ */
+int sandbox_ffa_helper_query_core_state(u32 queried_func_id, struct ffa_interface_data *func_data);
+
+#endif
diff --git a/lib/arm-ffa/Makefile b/lib/arm-ffa/Makefile
index cba625fde4..04159da8eb 100644
--- a/lib/arm-ffa/Makefile
+++ b/lib/arm-ffa/Makefile
@@ -6,3 +6,4 @@
 # This file only gets included when CONFIG_ARM_FFA_TRANSPORT_HELPERS is set
 
 obj-y += arm_ffa_helper.o
+obj-$(CONFIG_SANDBOX_FFA) += sandbox_arm_ffa_helper.o
diff --git a/lib/arm-ffa/arm_ffa_helper.c b/lib/arm-ffa/arm_ffa_helper.c
index 67a3a4e9ab..32ee3b4486 100644
--- a/lib/arm-ffa/arm_ffa_helper.c
+++ b/lib/arm-ffa/arm_ffa_helper.c
@@ -105,10 +105,10 @@ int __ffa_runtime ffa_helper_msg_send_direct_req(struct ffa_interface_data
 }
 
 /**
- * ffa_helper_init_device - Wrapper function for probing the arm_ffa device
+ * ffa_helper_init_device - Wrapper function for probing the arm_ffa and sandbox_arm_ffa devices
  *
- * This boot time function should be called to probe the arm_ffa device so
- * it becomes ready for use.
+ * This boot time function should be called to probe the arm_ffa and sandbox_arm_ffa devices so
+ * they become ready for use.
  * To achieve that, this function is called automatically at initcalls
  * level (after u-boot relocation).
  *
diff --git a/lib/arm-ffa/sandbox_arm_ffa_helper.c b/lib/arm-ffa/sandbox_arm_ffa_helper.c
new file mode 100644
index 0000000000..7859f30fc7
--- /dev/null
+++ b/lib/arm-ffa/sandbox_arm_ffa_helper.c
@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * (C) Copyright 2022 ARM Limited
+ * Abdellatif El Khlifi <abdellatif.elkhlifi@arm.com>
+ */
+
+#include <common.h>
+#include <sandbox_arm_ffa_helper.h>
+
+/**
+ * sandbox_ffa_helper_query_core_state - Wrapper function for querying FF-A implementation
+ *
+ * A helper function used for querying the status of FF-A ABIs given in the input argument
+ * and the FF-A core driver.
+ *
+ * Return:
+ *
+ * FFA_ERR_STAT_SUCCESS on success. Otherwise, failure
+ */
+int sandbox_ffa_helper_query_core_state(u32 queried_func_id, struct ffa_interface_data *func_data)
+{
+	return sandbox_ffa_get_invoke_func(queried_func_id, func_data);
+}
diff --git a/lib/efi_loader/efi_boottime.c b/lib/efi_loader/efi_boottime.c
index cffa2c69d6..12fc28fd82 100644
--- a/lib/efi_loader/efi_boottime.c
+++ b/lib/efi_loader/efi_boottime.c
@@ -2118,7 +2118,7 @@ static efi_status_t EFIAPI efi_exit_boot_services(efi_handle_t image_handle,
 	struct efi_event *evt, *next_event;
 	efi_status_t ret = EFI_SUCCESS;
 
-#if defined(CONFIG_ARM_FFA_TRANSPORT)
+#if defined(CONFIG_ARM_FFA_TRANSPORT) && !defined(CONFIG_SANDBOX_FFA)
 	int ffa_ret;
 #endif
 
@@ -2182,7 +2182,7 @@ static efi_status_t EFIAPI efi_exit_boot_services(efi_handle_t image_handle,
 		dm_remove_devices_flags(DM_REMOVE_ACTIVE_ALL);
 	}
 
-#if defined(CONFIG_ARM_FFA_TRANSPORT)
+#if defined(CONFIG_ARM_FFA_TRANSPORT) && !defined(CONFIG_SANDBOX_FFA)
 	/* unmap FF-A RX/TX buffers */
 	ffa_ret = ffa_helper_unmap_rxtx_buffers();
 	if (ffa_ret)
-- 
2.17.1