diff --git a/include/common/test_helpers.h b/include/common/test_helpers.h
index c808df1..40cc96f 100644
--- a/include/common/test_helpers.h
+++ b/include/common/test_helpers.h
@@ -8,6 +8,7 @@
 #define TEST_HELPERS_H__
 
 #include <arch_features.h>
+#include <ffa_helpers.h>
 #include <ffa_svc.h>
 #include <events.h>
 #include <plat_topology.h>
@@ -182,16 +183,16 @@
 
 #define SKIP_TEST_IF_FFA_VERSION_LESS_THAN(major, minor)			\
 	do {									\
-		smc_ret_values smc_ret = ffa_version(				\
+		struct ffa_value ret = ffa_version(				\
 					MAKE_FFA_VERSION(major, minor));	\
-		uint32_t version = smc_ret.ret0;				\
+		uint32_t version = ret.fid;					\
 										\
 		if (version == FFA_ERROR_NOT_SUPPORTED) {			\
 			tftf_testcase_printf("FFA_VERSION not supported.\n");	\
 			return TEST_RESULT_SKIPPED;				\
 		}								\
 										\
-		if ((version & FFA_VERSION_BIT31_MASK) != 0U) {				\
+		if ((version & FFA_VERSION_BIT31_MASK) != 0U) {			\
 			tftf_testcase_printf("FFA_VERSION bad response: %x\n",	\
 					version);				\
 			return TEST_RESULT_FAIL;				\
@@ -222,13 +223,13 @@
 
 #define SKIP_TEST_IF_FFA_ENDPOINT_NOT_DEPLOYED(mb, ffa_uuid)			\
 	do {									\
-		smc_ret_values smc_ret = ffa_partition_info_get(ffa_uuid);	\
+		struct ffa_value sc_ret = ffa_partition_info_get(ffa_uuid);	\
 		ffa_rx_release();						\
-		if (ffa_func_id(smc_ret) == FFA_ERROR && 			\
-		    ffa_error_code(smc_ret) == FFA_ERROR_INVALID_PARAMETER) {	\
+		if (ffa_func_id(sc_ret) == FFA_ERROR && 			\
+		    ffa_error_code(sc_ret) == FFA_ERROR_INVALID_PARAMETER) {	\
 			tftf_testcase_printf("FFA endpoint not deployed!\n");	\
 			return TEST_RESULT_SKIPPED;				\
-		} else if (smc_ret.ret0 != FFA_SUCCESS_SMC32) {			\
+		} else if (ffa_func_id(sc_ret) != FFA_SUCCESS_SMC32) {		\
 			ERROR("ffa_partition_info_get failed!\n");		\
 			return TEST_RESULT_FAIL;				\
 		}								\
diff --git a/include/runtime_services/cactus_message_loop.h b/include/runtime_services/cactus_message_loop.h
index d69e77c..4d963ac 100644
--- a/include/runtime_services/cactus_message_loop.h
+++ b/include/runtime_services/cactus_message_loop.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2021-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -12,8 +12,8 @@
  */
 struct cactus_cmd_handler {
 	const uint64_t id;
-	smc_ret_values (*fn)(const smc_ret_values *args,
-			     struct mailbox_buffers *mb);
+	struct ffa_value (*fn)(const struct ffa_value *args,
+			       struct mailbox_buffers *mb);
 };
 
 /**
@@ -25,8 +25,8 @@
  * Define handler's function signature.
  */
 #define CACTUS_HANDLER_FN(name)						\
-	static smc_ret_values CACTUS_HANDLER_FN_NAME(name)(		\
-		const smc_ret_values *args, struct mailbox_buffers *mb)
+	static struct ffa_value CACTUS_HANDLER_FN_NAME(name)(		\
+		const struct ffa_value *args, struct mailbox_buffers *mb)
 
 /**
  * Helper to define Cactus command handler, and pair it with a command ID.
@@ -40,5 +40,5 @@
 	};								\
 	CACTUS_HANDLER_FN(name)
 
-bool cactus_handle_cmd(smc_ret_values *cmd_args, smc_ret_values *ret,
+bool cactus_handle_cmd(struct ffa_value *cmd_args, struct ffa_value *ret,
 		       struct mailbox_buffers *mb);
diff --git a/include/runtime_services/cactus_test_cmds.h b/include/runtime_services/cactus_test_cmds.h
index 435d270..1e60e0e 100644
--- a/include/runtime_services/cactus_test_cmds.h
+++ b/include/runtime_services/cactus_test_cmds.h
@@ -25,18 +25,18 @@
 #define CACTUS_ERROR_UNHANDLED		U(4)
 
 /**
- * Get command from struct smc_ret_values.
+ * Get command from struct ffa_value.
  */
-static inline uint64_t cactus_get_cmd(smc_ret_values ret)
+static inline uint64_t cactus_get_cmd(struct ffa_value ret)
 {
-	return (uint64_t)ret.ret3;
+	return (uint64_t)ret.arg3;
 }
 
 /**
  * Template for commands to be sent to CACTUS partitions over direct
  * messages interfaces.
  */
-static inline smc_ret_values cactus_send_cmd(
+static inline struct ffa_value cactus_send_cmd(
 	ffa_id_t source, ffa_id_t dest, uint64_t cmd, uint64_t val0,
 	uint64_t val1, uint64_t val2, uint64_t val3)
 {
@@ -49,7 +49,7 @@
  * 'cactus_send_response' is the template for custom responses, in case there is
  * a need to propagate more than one value in the response of a command.
  */
-static inline smc_ret_values cactus_send_response(
+static inline struct ffa_value cactus_send_response(
 	ffa_id_t source, ffa_id_t dest, uint32_t resp, uint64_t val0,
 	uint64_t val1, uint64_t val2, uint64_t val3)
 {
@@ -60,15 +60,15 @@
 /**
  * For responses of one value only.
  */
-static inline smc_ret_values cactus_response(
+static inline struct ffa_value cactus_response(
 	ffa_id_t source, ffa_id_t dest, uint32_t response)
 {
 	return cactus_send_response(source, dest, response, 0, 0, 0, 0);
 }
 
-static inline uint32_t cactus_get_response(smc_ret_values ret)
+static inline uint32_t cactus_get_response(struct ffa_value ret)
 {
-	return (uint32_t)ret.ret3;
+	return (uint32_t)ret.arg3;
 }
 
 /**
@@ -77,7 +77,7 @@
  * If more arguments are needed, a custom response should be defined for the
  * specific test.
  */
-static inline smc_ret_values cactus_success_resp(
+static inline struct ffa_value cactus_success_resp(
 		ffa_id_t source, ffa_id_t dest, uint64_t value)
 {
 	return cactus_send_response(source, dest, CACTUS_SUCCESS, value,
@@ -89,16 +89,16 @@
  * the reason, which can be specific to the test, or general ones as defined
  * in the error code list.
  */
-static inline smc_ret_values cactus_error_resp(
+static inline struct ffa_value cactus_error_resp(
 		ffa_id_t source, ffa_id_t dest, uint32_t error_code)
 {
 	return cactus_send_response(source, dest, CACTUS_ERROR, error_code,
 				    0, 0, 0);
 }
 
-static inline uint32_t cactus_error_code(smc_ret_values ret)
+static inline uint32_t cactus_error_code(struct ffa_value ret)
 {
-	return (uint32_t) ret.ret4;
+	return (uint32_t) ret.arg4;
 }
 
 /**
@@ -109,16 +109,16 @@
  */
 #define CACTUS_ECHO_CMD U(0x6563686f)
 
-static inline smc_ret_values cactus_echo_send_cmd(
+static inline struct ffa_value cactus_echo_send_cmd(
 	ffa_id_t source, ffa_id_t dest, uint64_t echo_val)
 {
 	return cactus_send_cmd(source, dest, CACTUS_ECHO_CMD, echo_val, 0, 0,
 			       0);
 }
 
-static inline uint64_t cactus_echo_get_val(smc_ret_values ret)
+static inline uint64_t cactus_echo_get_val(struct ffa_value ret)
 {
-	return (uint64_t)ret.ret4;
+	return (uint64_t)ret.arg4;
 }
 
 /**
@@ -130,7 +130,7 @@
  */
 #define CACTUS_REQ_ECHO_CMD (CACTUS_ECHO_CMD + 1)
 
-static inline smc_ret_values cactus_req_echo_send_cmd(
+static inline struct ffa_value cactus_req_echo_send_cmd(
 	ffa_id_t source, ffa_id_t dest, ffa_id_t echo_dest,
 	uint64_t echo_val)
 {
@@ -138,9 +138,9 @@
 			       echo_dest, 0, 0);
 }
 
-static inline ffa_id_t cactus_req_echo_get_echo_dest(smc_ret_values ret)
+static inline ffa_id_t cactus_req_echo_get_echo_dest(struct ffa_value ret)
 {
-	return (ffa_id_t)ret.ret5;
+	return (ffa_id_t)ret.arg5;
 }
 
 /**
@@ -154,16 +154,16 @@
  */
 #define CACTUS_DEADLOCK_CMD U(0x64656164)
 
-static inline smc_ret_values cactus_deadlock_send_cmd(
+static inline struct ffa_value cactus_deadlock_send_cmd(
 	ffa_id_t source, ffa_id_t dest, ffa_id_t next_dest)
 {
 	return cactus_send_cmd(source, dest, CACTUS_DEADLOCK_CMD, next_dest, 0,
 			       0, 0);
 }
 
-static inline ffa_id_t cactus_deadlock_get_next_dest(smc_ret_values ret)
+static inline ffa_id_t cactus_deadlock_get_next_dest(struct ffa_value ret)
 {
-	return (ffa_id_t)ret.ret4;
+	return (ffa_id_t)ret.arg4;
 }
 
 /**
@@ -172,7 +172,7 @@
  */
 #define CACTUS_REQ_DEADLOCK_CMD (CACTUS_DEADLOCK_CMD + 1)
 
-static inline smc_ret_values cactus_req_deadlock_send_cmd(
+static inline struct ffa_value cactus_req_deadlock_send_cmd(
 	ffa_id_t source, ffa_id_t dest, ffa_id_t next_dest1,
 	ffa_id_t next_dest2)
 {
@@ -181,9 +181,9 @@
 }
 
 /* To get next_dest1 use CACTUS_DEADLOCK_GET_NEXT_DEST */
-static inline ffa_id_t cactus_deadlock_get_next_dest2(smc_ret_values ret)
+static inline ffa_id_t cactus_deadlock_get_next_dest2(struct ffa_value ret)
 {
-	return (ffa_id_t)ret.ret5;
+	return (ffa_id_t)ret.arg5;
 }
 
 /**
@@ -194,7 +194,7 @@
  */
 #define CACTUS_MEM_SEND_CMD U(0x6d656d)
 
-static inline smc_ret_values cactus_mem_send_cmd(
+static inline struct ffa_value cactus_mem_send_cmd(
 	ffa_id_t source, ffa_id_t dest, uint32_t mem_func,
 	ffa_memory_handle_t handle, ffa_memory_region_flags_t retrieve_flags,
 	bool non_secure, uint16_t word_to_write)
@@ -208,25 +208,26 @@
 			       handle, retrieve_flags, val3);
 }
 
-static inline ffa_memory_handle_t cactus_mem_send_get_handle(smc_ret_values ret)
+static inline ffa_memory_handle_t cactus_mem_send_get_handle(
+	struct ffa_value ret)
 {
-	return (ffa_memory_handle_t)ret.ret5;
+	return (ffa_memory_handle_t)ret.arg5;
 }
 
 static inline ffa_memory_region_flags_t cactus_mem_send_get_retrv_flags(
-	smc_ret_values ret)
+	struct ffa_value ret)
 {
-	return (ffa_memory_region_flags_t)ret.ret6;
+	return (ffa_memory_region_flags_t)ret.arg6;
 }
 
-static inline uint16_t cactus_mem_send_words_to_write(smc_ret_values ret)
+static inline uint16_t cactus_mem_send_words_to_write(struct ffa_value ret)
 {
-	return (uint16_t)ret.ret7;
+	return (uint16_t)ret.arg7;
 }
 
-static inline bool cactus_mem_send_get_non_secure(smc_ret_values ret)
+static inline bool cactus_mem_send_get_non_secure(struct ffa_value ret)
 {
-	return (bool)(ret.ret7 >> 16);
+	return (bool)(ret.arg7 >> 16);
 }
 
 /**
@@ -238,7 +239,7 @@
  */
 #define CACTUS_REQ_MEM_SEND_CMD U(0x6d656d6f7279)
 
-static inline smc_ret_values cactus_req_mem_send_send_cmd(
+static inline struct ffa_value cactus_req_mem_send_send_cmd(
 	ffa_id_t source, ffa_id_t dest, uint32_t mem_func,
 	ffa_id_t receiver, bool non_secure)
 {
@@ -246,19 +247,19 @@
 			       receiver, non_secure, 0);
 }
 
-static inline uint32_t cactus_req_mem_send_get_mem_func(smc_ret_values ret)
+static inline uint32_t cactus_req_mem_send_get_mem_func(struct ffa_value ret)
 {
-	return (uint32_t)ret.ret4;
+	return (uint32_t)ret.arg4;
 }
 
-static inline ffa_id_t cactus_req_mem_send_get_receiver(smc_ret_values ret)
+static inline ffa_id_t cactus_req_mem_send_get_receiver(struct ffa_value ret)
 {
-	return (ffa_id_t)ret.ret5;
+	return (ffa_id_t)ret.arg5;
 }
 
-static inline bool cactus_req_mem_send_get_non_secure(smc_ret_values ret)
+static inline bool cactus_req_mem_send_get_non_secure(struct ffa_value ret)
 {
-	return (bool)ret.ret6;
+	return (bool)ret.arg6;
 }
 
 /**
@@ -270,7 +271,7 @@
  */
 #define CACTUS_REQ_SIMD_FILL_CMD U(0x53494d44)
 
-static inline smc_ret_values cactus_req_simd_fill_send_cmd(
+static inline struct ffa_value cactus_req_simd_fill_send_cmd(
 	ffa_id_t source, ffa_id_t dest)
 {
 	return cactus_send_cmd(source, dest, CACTUS_REQ_SIMD_FILL_CMD, 0, 0, 0,
@@ -284,7 +285,7 @@
  */
 #define CACTUS_SLEEP_CMD U(0x736c656570)
 
-static inline smc_ret_values cactus_sleep_cmd(
+static inline struct ffa_value cactus_sleep_cmd(
 	ffa_id_t source, ffa_id_t dest, uint32_t sleep_time)
 {
 	return cactus_send_cmd(source, dest, CACTUS_SLEEP_CMD, sleep_time, 0, 0,
@@ -299,7 +300,7 @@
  */
 #define CACTUS_FWD_SLEEP_CMD (CACTUS_SLEEP_CMD + 1)
 
-static inline smc_ret_values cactus_fwd_sleep_cmd(
+static inline struct ffa_value cactus_fwd_sleep_cmd(
 	ffa_id_t source, ffa_id_t dest, ffa_id_t fwd_dest,
 	uint32_t sleep_time)
 {
@@ -307,14 +308,14 @@
 			       fwd_dest, 0, 0);
 }
 
-static inline uint32_t cactus_get_sleep_time(smc_ret_values ret)
+static inline uint32_t cactus_get_sleep_time(struct ffa_value ret)
 {
-	return (uint32_t)ret.ret4;
+	return (uint32_t)ret.arg4;
 }
 
-static inline ffa_id_t cactus_get_fwd_sleep_dest(smc_ret_values ret)
+static inline ffa_id_t cactus_get_fwd_sleep_dest(struct ffa_value ret)
 {
-	return (ffa_id_t)ret.ret5;
+	return (ffa_id_t)ret.arg5;
 }
 
 /**
@@ -326,7 +327,7 @@
  */
 #define CACTUS_SLEEP_TRIGGER_TWDOG_CMD (CACTUS_SLEEP_CMD + 2)
 
-static inline smc_ret_values cactus_sleep_trigger_wdog_cmd(
+static inline struct ffa_value cactus_sleep_trigger_wdog_cmd(
 	ffa_id_t source, ffa_id_t dest, uint32_t sleep_time,
 	uint64_t wdog_time)
 {
@@ -335,9 +336,9 @@
 }
 
 
-static inline uint32_t cactus_get_wdog_trigger_duration(smc_ret_values ret)
+static inline uint32_t cactus_get_wdog_trigger_duration(struct ffa_value ret)
 {
-	return (uint32_t)ret.ret5;
+	return (uint32_t)ret.arg5;
 }
 
 /**
@@ -347,7 +348,7 @@
  */
 #define CACTUS_INTERRUPT_CMD U(0x696e7472)
 
-static inline smc_ret_values cactus_interrupt_cmd(
+static inline struct ffa_value cactus_interrupt_cmd(
 	ffa_id_t source, ffa_id_t dest, uint32_t interrupt_id,
 	bool enable, uint32_t pin)
 {
@@ -355,19 +356,19 @@
 			       enable, pin, 0);
 }
 
-static inline uint32_t cactus_get_interrupt_id(smc_ret_values ret)
+static inline uint32_t cactus_get_interrupt_id(struct ffa_value ret)
 {
-	return (uint32_t)ret.ret4;
+	return (uint32_t)ret.arg4;
 }
 
-static inline bool cactus_get_interrupt_enable(smc_ret_values ret)
+static inline bool cactus_get_interrupt_enable(struct ffa_value ret)
 {
-	return (bool)ret.ret5;
+	return (bool)ret.arg5;
 }
 
-static inline enum interrupt_pin cactus_get_interrupt_pin(smc_ret_values ret)
+static inline enum interrupt_pin cactus_get_interrupt_pin(struct ffa_value ret)
 {
-	return (enum interrupt_pin)ret.ret6;
+	return (enum interrupt_pin)ret.arg6;
 }
 
 /**
@@ -377,7 +378,7 @@
  */
 #define CACTUS_DMA_SMMUv3_CMD           (0x534d4d55)
 
-static inline smc_ret_values cactus_send_dma_cmd(
+static inline struct ffa_value cactus_send_dma_cmd(
 	ffa_id_t source, ffa_id_t dest)
 {
 	return cactus_send_cmd(source, dest, CACTUS_DMA_SMMUv3_CMD, 0, 0, 0,
@@ -395,7 +396,7 @@
  */
 #define CACTUS_NOTIFICATION_BIND_CMD U(0x62696e64)
 
-static inline smc_ret_values cactus_notification_bind_send_cmd(
+static inline struct ffa_value cactus_notification_bind_send_cmd(
 	ffa_id_t source, ffa_id_t dest, ffa_id_t receiver,
 	ffa_id_t sender, ffa_notification_bitmap_t notifications, uint32_t flags)
 {
@@ -414,7 +415,7 @@
  */
 #define CACTUS_NOTIFICATION_UNBIND_CMD U(0x756e62696e64)
 
-static inline smc_ret_values cactus_notification_unbind_send_cmd(
+static inline struct ffa_value cactus_notification_unbind_send_cmd(
 	ffa_id_t source, ffa_id_t dest, ffa_id_t receiver,
 	ffa_id_t sender, ffa_notification_bitmap_t notifications)
 {
@@ -422,22 +423,20 @@
 			       receiver, sender, notifications, 0);
 }
 
-static inline ffa_id_t cactus_notification_get_receiver(
-	smc_ret_values ret)
+static inline ffa_id_t cactus_notification_get_receiver(struct ffa_value ret)
 {
-	return (ffa_id_t)ret.ret4;
+	return (ffa_id_t)ret.arg4;
 }
 
-static inline ffa_id_t cactus_notification_get_sender(
-	smc_ret_values ret)
+static inline ffa_id_t cactus_notification_get_sender(struct ffa_value ret)
 {
-	return (ffa_id_t)ret.ret5;
+	return (ffa_id_t)ret.arg5;
 }
 
 static inline ffa_notification_bitmap_t cactus_notification_get_notifications(
-	smc_ret_values ret)
+	struct ffa_value ret)
 {
-	return (uint64_t)ret.ret6;
+	return (uint64_t)ret.arg6;
 }
 
 /**
@@ -450,7 +449,7 @@
  */
 #define CACTUS_NOTIFICATION_GET_CMD U(0x6765746e6f74)
 
-static inline smc_ret_values cactus_notification_get_send_cmd(
+static inline struct ffa_value cactus_notification_get_send_cmd(
 	ffa_id_t source, ffa_id_t dest, ffa_id_t receiver,
 	uint32_t vcpu_id, uint32_t flags, bool check_npi_handled)
 {
@@ -458,17 +457,17 @@
 			       receiver, vcpu_id, check_npi_handled, flags);
 }
 
-static inline uint32_t cactus_notification_get_vcpu(smc_ret_values ret)
+static inline uint32_t cactus_notification_get_vcpu(struct ffa_value ret)
 {
-	return (uint32_t)ret.ret5;
+	return (uint32_t)ret.arg5;
 }
 
-static inline uint32_t cactus_notification_get_flags(smc_ret_values ret)
+static inline uint32_t cactus_notification_get_flags(struct ffa_value ret)
 {
-	return (uint32_t)ret.ret7;
+	return (uint32_t)ret.arg7;
 }
 
-static inline smc_ret_values cactus_notifications_get_success_resp(
+static inline struct ffa_value cactus_notifications_get_success_resp(
 	ffa_id_t source, ffa_id_t dest, uint64_t from_sp,
 	uint64_t from_vm)
 {
@@ -476,19 +475,19 @@
 				    from_vm, 0, 0);
 }
 
-static inline uint64_t cactus_notifications_get_from_sp(smc_ret_values ret)
+static inline uint64_t cactus_notifications_get_from_sp(struct ffa_value ret)
 {
-	return (uint64_t)ret.ret4;
+	return (uint64_t)ret.arg4;
 }
 
-static inline uint64_t cactus_notifications_get_from_vm(smc_ret_values ret)
+static inline uint64_t cactus_notifications_get_from_vm(struct ffa_value ret)
 {
-	return (uint64_t)ret.ret5;
+	return (uint64_t)ret.arg5;
 }
 
-static inline bool cactus_notifications_check_npi_handled(smc_ret_values ret)
+static inline bool cactus_notifications_check_npi_handled(struct ffa_value ret)
 {
-	return (bool)ret.ret6;
+	return (bool)ret.arg6;
 }
 
 /**
@@ -501,7 +500,7 @@
  */
 #define CACTUS_NOTIFICATIONS_SET_CMD U(0x6e6f74736574)
 
-static inline smc_ret_values cactus_notifications_set_send_cmd(
+static inline struct ffa_value cactus_notifications_set_send_cmd(
 	ffa_id_t source, ffa_id_t dest, ffa_id_t receiver,
 	ffa_id_t sender, uint32_t flags, ffa_notification_bitmap_t notifications,
 	ffa_id_t echo_dest)
@@ -512,14 +511,15 @@
 			       notifications, flags);
 }
 
-static inline ffa_id_t cactus_notifications_set_get_receiver(smc_ret_values ret)
+static inline ffa_id_t cactus_notifications_set_get_receiver(
+	struct ffa_value ret)
 {
-	return (ffa_id_t)(ret.ret4 & 0xFFFFU);
+	return (ffa_id_t)(ret.arg4 & 0xFFFFU);
 }
 
-static inline ffa_id_t cactus_notifications_set_get_sender(smc_ret_values ret)
+static inline ffa_id_t cactus_notifications_set_get_sender(struct ffa_value ret)
 {
-	return (ffa_id_t)((ret.ret4 >> 16U) & 0xFFFFU);
+	return (ffa_id_t)((ret.arg4 >> 16U) & 0xFFFFU);
 }
 
 /**
@@ -529,16 +529,16 @@
  */
 #define CACTUS_TWDOG_START_CMD		U(0x57444f47)
 
-static inline smc_ret_values cactus_send_twdog_cmd(
+static inline struct ffa_value cactus_send_twdog_cmd(
 	ffa_id_t source, ffa_id_t dest, uint64_t time)
 {
 	return cactus_send_cmd(source, dest, CACTUS_TWDOG_START_CMD, time, 0, 0,
 			       0);
 }
 
-static inline uint32_t cactus_get_wdog_duration(smc_ret_values ret)
+static inline uint32_t cactus_get_wdog_duration(struct ffa_value ret)
 {
-	return (uint32_t)ret.ret4;
+	return (uint32_t)ret.arg4;
 }
 
 /**
@@ -548,16 +548,16 @@
  */
 #define CACTUS_GET_REQ_COUNT_CMD U(0x726571636f756e74)
 
-static inline smc_ret_values cactus_get_req_count_send_cmd(
+static inline struct ffa_value cactus_get_req_count_send_cmd(
 	ffa_id_t source, ffa_id_t dest)
 {
 	return cactus_send_cmd(source, dest, CACTUS_GET_REQ_COUNT_CMD, 0, 0, 0,
 			       0);
 }
 
-static inline uint32_t cactus_get_req_count(smc_ret_values ret)
+static inline uint32_t cactus_get_req_count(struct ffa_value ret)
 {
-	return (uint32_t)ret.ret4;
+	return (uint32_t)ret.arg4;
 }
 
 /**
@@ -567,7 +567,7 @@
  */
 #define CACTUS_LAST_INTERRUPT_SERVICED_CMD U(0x76494e54)
 
-static inline smc_ret_values cactus_get_last_interrupt_cmd(
+static inline struct ffa_value cactus_get_last_interrupt_cmd(
 	ffa_id_t source, ffa_id_t dest)
 {
 	return cactus_send_cmd(source, dest, CACTUS_LAST_INTERRUPT_SERVICED_CMD,
diff --git a/include/runtime_services/ffa_helpers.h b/include/runtime_services/ffa_helpers.h
index 8232128..1250673 100644
--- a/include/runtime_services/ffa_helpers.h
+++ b/include/runtime_services/ffa_helpers.h
@@ -172,28 +172,57 @@
 	uint32_t properties;
 };
 
-static inline uint32_t ffa_func_id(smc_ret_values val)
+struct ffa_value {
+	u_register_t fid;
+	u_register_t arg1;
+	u_register_t arg2;
+	u_register_t arg3;
+	u_register_t arg4;
+	u_register_t arg5;
+	u_register_t arg6;
+	u_register_t arg7;
+};
+
+/* Function to make an SMC or SVC service call depending on the exception
+ * level of the SP.
+ */
+struct ffa_value ffa_service_call(struct ffa_value *args);
+
+/*
+ * Functions to trigger a service call.
+ *
+ * The arguments to pass through the service call must be stored in the
+ * ffa_value structure. The return values of the service call will be stored
+ * in the same structure (overriding the input arguments).
+ *
+ * Return the first return value. It is equivalent to args.fid but is also
+ * provided as the return value for convenience.
+ */
+u_register_t ffa_svc(struct ffa_value *args);
+u_register_t ffa_smc(struct ffa_value *args);
+
+static inline uint32_t ffa_func_id(struct ffa_value val)
 {
-	return (uint32_t) val.ret0;
+	return (uint32_t)val.fid;
 }
 
-static inline int32_t ffa_error_code(smc_ret_values val)
+static inline int32_t ffa_error_code(struct ffa_value val)
 {
-	return (int32_t) val.ret2;
+	return (int32_t)val.arg2;
 }
 
-static inline ffa_id_t ffa_endpoint_id(smc_ret_values val) {
-	return (ffa_id_t) val.ret2 & 0xffff;
+static inline ffa_id_t ffa_endpoint_id(struct ffa_value val) {
+	return (ffa_id_t)val.arg2 & 0xffff;
 }
 
-static inline uint32_t ffa_partition_info_count(smc_ret_values val)
+static inline uint32_t ffa_partition_info_count(struct ffa_value val)
 {
-	return (uint32_t) val.ret2;
+	return (uint32_t)val.arg2;
 }
 
-static inline uint32_t ffa_feature_intid(smc_ret_values val)
+static inline uint32_t ffa_feature_intid(struct ffa_value val)
 {
-	return (uint32_t)val.ret2;
+	return (uint32_t)val.arg2;
 }
 
 typedef uint64_t ffa_notification_bitmap_t;
@@ -226,14 +255,16 @@
 
 #define FFA_NOTIFICATIONS_FLAGS_VCPU_ID(id) UINT32_C((id & 0xFFFF) << 16)
 
-static inline ffa_notification_bitmap_t ffa_notifications_get_from_sp(smc_ret_values val)
+static inline ffa_notification_bitmap_t ffa_notifications_get_from_sp(
+       struct ffa_value val)
 {
-	return FFA_NOTIFICATIONS_BITMAP(val.ret2, val.ret3);
+	return FFA_NOTIFICATIONS_BITMAP(val.arg2, val.arg3);
 }
 
-static inline ffa_notification_bitmap_t ffa_notifications_get_from_vm(smc_ret_values val)
+static inline ffa_notification_bitmap_t ffa_notifications_get_from_vm(
+       struct ffa_value val)
 {
-	return FFA_NOTIFICATIONS_BITMAP(val.ret4, val.ret5);
+	return FFA_NOTIFICATIONS_BITMAP(val.arg4, val.arg5);
 }
 
 /*
@@ -250,22 +281,22 @@
 #define FFA_NOTIFICATIONS_LIST_SIZE_MASK 		0x3U
 
 static inline uint32_t ffa_notifications_info_get_lists_count(
-	smc_ret_values ret)
+	struct ffa_value ret)
 {
-	return (uint32_t)(ret.ret2 >> FFA_NOTIFICATIONS_LISTS_COUNT_SHIFT)
+	return (uint32_t)(ret.arg2 >> FFA_NOTIFICATIONS_LISTS_COUNT_SHIFT)
 	       & FFA_NOTIFICATIONS_LISTS_COUNT_MASK;
 }
 
 static inline uint32_t ffa_notifications_info_get_list_size(
-	smc_ret_values ret, uint32_t list)
+	struct ffa_value ret, uint32_t list)
 {
-	return (uint32_t)(ret.ret2 >> FFA_NOTIFICATIONS_LIST_SHIFT(list)) &
+	return (uint32_t)(ret.arg2 >> FFA_NOTIFICATIONS_LIST_SHIFT(list)) &
 	       FFA_NOTIFICATIONS_LIST_SIZE_MASK;
 }
 
-static inline bool ffa_notifications_info_get_more_pending(smc_ret_values ret)
+static inline bool ffa_notifications_info_get_more_pending(struct ffa_value ret)
 {
-	return (ret.ret2 & FFA_NOTIFICATIONS_INFO_GET_FLAG_MORE_PENDING) != 0U;
+	return (ret.arg2 & FFA_NOTIFICATIONS_INFO_GET_FLAG_MORE_PENDING) != 0U;
 }
 
 enum ffa_data_access {
@@ -531,9 +562,9 @@
 	       (ffa_notification_bitmap_t)h2 << 32;
 }
 
-static inline ffa_memory_handle_t ffa_mem_success_handle(smc_ret_values r)
+static inline ffa_memory_handle_t ffa_mem_success_handle(struct ffa_value r)
 {
-	return ffa_assemble_handle(r.ret2, r.ret3);
+	return ffa_assemble_handle(r.arg2, r.arg3);
 }
 
 /**
@@ -586,69 +617,69 @@
 	enum ffa_memory_shareability shareability, uint32_t *total_length,
 	uint32_t *fragment_length);
 
-static inline ffa_id_t ffa_dir_msg_dest(smc_ret_values val) {
-	return (ffa_id_t)val.ret1 & U(0xFFFF);
+static inline ffa_id_t ffa_dir_msg_dest(struct ffa_value val) {
+	return (ffa_id_t)val.arg1 & U(0xFFFF);
 }
 
-static inline ffa_id_t ffa_dir_msg_source(smc_ret_values val) {
-	return (ffa_id_t)(val.ret1 >> 16U);
+static inline ffa_id_t ffa_dir_msg_source(struct ffa_value val) {
+	return (ffa_id_t)(val.arg1 >> 16U);
 }
 
-smc_ret_values ffa_msg_send_direct_req64(ffa_id_t source_id,
-					 ffa_id_t dest_id, uint64_t arg0,
-					 uint64_t arg1, uint64_t arg2,
-					 uint64_t arg3, uint64_t arg4);
+struct ffa_value ffa_msg_send_direct_req64(ffa_id_t source_id,
+					   ffa_id_t dest_id, uint64_t arg0,
+					   uint64_t arg1, uint64_t arg2,
+					   uint64_t arg3, uint64_t arg4);
 
-smc_ret_values ffa_msg_send_direct_req32(ffa_id_t source_id,
-					 ffa_id_t dest_id, uint32_t arg0,
-					 uint32_t arg1, uint32_t arg2,
-					 uint32_t arg3, uint32_t arg4);
+struct ffa_value ffa_msg_send_direct_req32(ffa_id_t source_id,
+					   ffa_id_t dest_id, uint32_t arg0,
+					   uint32_t arg1, uint32_t arg2,
+					   uint32_t arg3, uint32_t arg4);
 
-smc_ret_values ffa_msg_send_direct_resp64(ffa_id_t source_id,
-					  ffa_id_t dest_id, uint64_t arg0,
-					  uint64_t arg1, uint64_t arg2,
-					  uint64_t arg3, uint64_t arg4);
+struct ffa_value ffa_msg_send_direct_resp64(ffa_id_t source_id,
+					    ffa_id_t dest_id, uint64_t arg0,
+					    uint64_t arg1, uint64_t arg2,
+					    uint64_t arg3, uint64_t arg4);
 
-smc_ret_values ffa_msg_send_direct_resp32(ffa_id_t source_id,
-					  ffa_id_t dest_id, uint32_t arg0,
-					  uint32_t arg1, uint32_t arg2,
-					  uint32_t arg3, uint32_t arg4);
+struct ffa_value ffa_msg_send_direct_resp32(ffa_id_t source_id,
+					    ffa_id_t dest_id, uint32_t arg0,
+					    uint32_t arg1, uint32_t arg2,
+					    uint32_t arg3, uint32_t arg4);
 
-smc_ret_values ffa_run(uint32_t dest_id, uint32_t vcpu_id);
-smc_ret_values ffa_version(uint32_t input_version);
-smc_ret_values ffa_id_get(void);
-smc_ret_values ffa_spm_id_get(void);
-smc_ret_values ffa_msg_wait(void);
-smc_ret_values ffa_error(int32_t error_code);
-smc_ret_values ffa_features(uint32_t feature);
-smc_ret_values ffa_partition_info_get(const struct ffa_uuid uuid);
-smc_ret_values ffa_rx_release(void);
-smc_ret_values ffa_rxtx_map(uintptr_t send, uintptr_t recv, uint32_t pages);
-smc_ret_values ffa_rxtx_unmap(void);
-smc_ret_values ffa_mem_donate(uint32_t descriptor_length,
+struct ffa_value ffa_run(uint32_t dest_id, uint32_t vcpu_id);
+struct ffa_value ffa_version(uint32_t input_version);
+struct ffa_value ffa_id_get(void);
+struct ffa_value ffa_spm_id_get(void);
+struct ffa_value ffa_msg_wait(void);
+struct ffa_value ffa_error(int32_t error_code);
+struct ffa_value ffa_features(uint32_t feature);
+struct ffa_value ffa_partition_info_get(const struct ffa_uuid uuid);
+struct ffa_value ffa_rx_release(void);
+struct ffa_value ffa_rxtx_map(uintptr_t send, uintptr_t recv, uint32_t pages);
+struct ffa_value ffa_rxtx_unmap(void);
+struct ffa_value ffa_mem_donate(uint32_t descriptor_length,
+				uint32_t fragment_length);
+struct ffa_value ffa_mem_lend(uint32_t descriptor_length,
 			      uint32_t fragment_length);
-smc_ret_values ffa_mem_lend(uint32_t descriptor_length,
-			    uint32_t fragment_length);
-smc_ret_values ffa_mem_share(uint32_t descriptor_length,
-			     uint32_t fragment_length);
-smc_ret_values ffa_mem_retrieve_req(uint32_t descriptor_length,
-			            uint32_t fragment_length);
-smc_ret_values ffa_mem_relinquish(void);
-smc_ret_values ffa_mem_reclaim(uint64_t handle, uint32_t flags);
-smc_ret_values ffa_notification_bitmap_create(ffa_id_t vm_id,
-					      ffa_vcpu_count_t vcpu_count);
-smc_ret_values ffa_notification_bitmap_destroy(ffa_id_t vm_id);
-smc_ret_values ffa_notification_bind(ffa_id_t sender, ffa_id_t receiver,
-				     uint32_t flags,
-				     ffa_notification_bitmap_t notifications);
-smc_ret_values ffa_notification_unbind(ffa_id_t sender, ffa_id_t receiver,
+struct ffa_value ffa_mem_share(uint32_t descriptor_length,
+			       uint32_t fragment_length);
+struct ffa_value ffa_mem_retrieve_req(uint32_t descriptor_length,
+				      uint32_t fragment_length);
+struct ffa_value ffa_mem_relinquish(void);
+struct ffa_value ffa_mem_reclaim(uint64_t handle, uint32_t flags);
+struct ffa_value ffa_notification_bitmap_create(ffa_id_t vm_id,
+						ffa_vcpu_count_t vcpu_count);
+struct ffa_value ffa_notification_bitmap_destroy(ffa_id_t vm_id);
+struct ffa_value ffa_notification_bind(ffa_id_t sender, ffa_id_t receiver,
+				       uint32_t flags,
 				       ffa_notification_bitmap_t notifications);
-smc_ret_values ffa_notification_set(ffa_id_t sender, ffa_id_t receiver,
-				    uint32_t flags,
-				    ffa_notification_bitmap_t bitmap);
-smc_ret_values ffa_notification_get(ffa_id_t receiver, uint32_t vcpu_id,
-				    uint32_t flags);
-smc_ret_values ffa_notification_info_get(void);
+struct ffa_value ffa_notification_unbind(ffa_id_t sender, ffa_id_t receiver,
+				  ffa_notification_bitmap_t notifications);
+struct ffa_value ffa_notification_set(ffa_id_t sender, ffa_id_t receiver,
+				      uint32_t flags,
+				      ffa_notification_bitmap_t bitmap);
+struct ffa_value ffa_notification_get(ffa_id_t receiver, uint32_t vcpu_id,
+				      uint32_t flags);
+struct ffa_value ffa_notification_info_get(void);
 #endif /* __ASSEMBLY__ */
 
 #endif /* FFA_HELPERS_H */
diff --git a/include/runtime_services/spm_common.h b/include/runtime_services/spm_common.h
index f187ed7..6dc0e22 100644
--- a/include/runtime_services/spm_common.h
+++ b/include/runtime_services/spm_common.h
@@ -83,13 +83,13 @@
 /**
  * Helpers to evaluate returns of FF-A calls.
  */
-bool is_ffa_call_error(smc_ret_values val);
-bool is_expected_ffa_error(smc_ret_values ret, int32_t error_code);
-bool is_ffa_direct_response(smc_ret_values ret);
-bool is_expected_ffa_return(smc_ret_values ret, uint32_t func_id);
-bool is_expected_cactus_response(smc_ret_values ret, uint32_t expected_resp,
+bool is_ffa_call_error(struct ffa_value val);
+bool is_expected_ffa_error(struct ffa_value ret, int32_t error_code);
+bool is_ffa_direct_response(struct ffa_value ret);
+bool is_expected_ffa_return(struct ffa_value ret, uint32_t func_id);
+bool is_expected_cactus_response(struct ffa_value ret, uint32_t expected_resp,
 				 uint32_t arg);
-void dump_smc_ret_values(smc_ret_values ret);
+void dump_ffa_value(struct ffa_value ret);
 
 /*
  * Vector length:
@@ -140,13 +140,13 @@
 
 ffa_memory_handle_t memory_send(
 	struct ffa_memory_region *memory_region, uint32_t mem_func,
-	uint32_t fragment_length, uint32_t total_length, smc_ret_values *ret);
+	uint32_t fragment_length, uint32_t total_length, struct ffa_value *ret);
 
 ffa_memory_handle_t memory_init_and_send(
 	struct ffa_memory_region *memory_region, size_t memory_region_max_size,
 	ffa_id_t sender, ffa_id_t receiver,
 	const struct ffa_memory_region_constituent* constituents,
-	uint32_t constituents_count, uint32_t mem_func, smc_ret_values *ret);
+	uint32_t constituents_count, uint32_t mem_func, struct ffa_value *ret);
 
 bool ffa_partition_info_helper(struct mailbox_buffers *mb,
 			const struct ffa_uuid uuid,
diff --git a/spm/cactus/cactus.mk b/spm/cactus/cactus.mk
index 74baee5..6e6f2da 100644
--- a/spm/cactus/cactus.mk
+++ b/spm/cactus/cactus.mk
@@ -37,7 +37,6 @@
 		cactus_main.c				\
 	)						\
 	$(addprefix spm/common/,			\
-		aarch64/sp_arch_helpers.S		\
 		sp_debug.c				\
 		sp_helpers.c				\
 		spm_helpers.c				\
@@ -54,11 +53,12 @@
 	)
 
 # TODO: Remove dependency on TFTF files.
-CACTUS_SOURCES	+=					\
-	tftf/framework/debug.c				\
-	tftf/framework/${ARCH}/asm_debug.S		\
-	tftf/tests/runtime_services/secure_service/ffa_helpers.c \
-	tftf/tests/runtime_services/secure_service/spm_common.c	\
+CACTUS_SOURCES	+=							\
+	tftf/framework/debug.c						\
+	tftf/framework/${ARCH}/asm_debug.S				\
+	tftf/tests/runtime_services/secure_service/${ARCH}/ffa_arch_helpers.S \
+	tftf/tests/runtime_services/secure_service/ffa_helpers.c 	\
+	tftf/tests/runtime_services/secure_service/spm_common.c		\
 	tftf/framework/${ARCH}/exception_report.c
 
 CACTUS_SOURCES	+= 	drivers/arm/pl011/${ARCH}/pl011_console.S	\
diff --git a/spm/cactus/cactus_main.c b/spm/cactus/cactus_main.c
index 8138565..56cf21d 100644
--- a/spm/cactus/cactus_main.c
+++ b/spm/cactus/cactus_main.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2018-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -17,6 +17,7 @@
 #include <lib/xlat_tables/xlat_mmu_helpers.h>
 #include <lib/xlat_tables/xlat_tables_v2.h>
 
+#include <ffa_helpers.h>
 #include <plat_arm.h>
 #include <plat/common/platform.h>
 #include <platform_def.h>
@@ -49,7 +50,7 @@
 
 static void __dead2 message_loop(ffa_id_t vm_id, struct mailbox_buffers *mb)
 {
-	smc_ret_values ffa_ret;
+	struct ffa_value ffa_ret;
 	ffa_id_t destination;
 
 	/*
@@ -226,10 +227,10 @@
 	assert(IS_IN_EL1() != 0);
 
 	struct mailbox_buffers mb;
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	/* Get current FFA id */
-	smc_ret_values ffa_id_ret = ffa_id_get();
+	struct ffa_value ffa_id_ret = ffa_id_get();
 	ffa_id_t ffa_id = ffa_endpoint_id(ffa_id_ret);
 	if (ffa_func_id(ffa_id_ret) != FFA_SUCCESS_SMC32) {
 		ERROR("FFA_ID_GET failed.\n");
diff --git a/spm/cactus/cactus_tests/cactus_message_loop.c b/spm/cactus/cactus_tests/cactus_message_loop.c
index 750c954..2cd54c1 100644
--- a/spm/cactus/cactus_tests/cactus_message_loop.c
+++ b/spm/cactus/cactus_tests/cactus_message_loop.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2021-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -35,7 +35,7 @@
  * Traverses command table from section ".cactus_handler", searches for a
  * registered command and invokes the respective handler.
  */
-bool cactus_handle_cmd(smc_ret_values *cmd_args, smc_ret_values *ret,
+bool cactus_handle_cmd(struct ffa_value *cmd_args, struct ffa_value *ret,
 		       struct mailbox_buffers *mb)
 {
 	uint64_t in_cmd;
diff --git a/spm/cactus/cactus_tests/cactus_test_direct_messaging.c b/spm/cactus/cactus_tests/cactus_test_direct_messaging.c
index 9b9d1aa..93bcba1 100644
--- a/spm/cactus/cactus_tests/cactus_test_direct_messaging.c
+++ b/spm/cactus/cactus_tests/cactus_test_direct_messaging.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2021-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -23,7 +23,7 @@
 
 CACTUS_CMD_HANDLER(req_echo_cmd, CACTUS_REQ_ECHO_CMD)
 {
-	smc_ret_values ffa_ret;
+	struct ffa_value ffa_ret;
 	ffa_id_t vm_id = ffa_dir_msg_dest(*args);
 	ffa_id_t echo_dest = cactus_req_echo_get_echo_dest(*args);
 	uint64_t echo_val = cactus_echo_get_val(*args);
@@ -48,12 +48,12 @@
 	return cactus_success_resp(vm_id, ffa_dir_msg_source(*args), 0);
 }
 
-static smc_ret_values base_deadlock_handler(ffa_id_t vm_id,
-					    ffa_id_t source,
-					    ffa_id_t deadlock_dest,
-					    ffa_id_t deadlock_next_dest)
+static struct ffa_value base_deadlock_handler(ffa_id_t vm_id,
+					      ffa_id_t source,
+					      ffa_id_t deadlock_dest,
+					      ffa_id_t deadlock_next_dest)
 {
-	smc_ret_values ffa_ret;
+	struct ffa_value ffa_ret;
 
 	ffa_ret = cactus_deadlock_send_cmd(vm_id, deadlock_dest,
 					   deadlock_next_dest);
diff --git a/spm/cactus/cactus_tests/cactus_test_ffa.c b/spm/cactus/cactus_tests/cactus_test_ffa.c
index bca3984..7e6bf9e 100644
--- a/spm/cactus/cactus_tests/cactus_test_ffa.c
+++ b/spm/cactus/cactus_tests/cactus_test_ffa.c
@@ -71,7 +71,7 @@
 static void ffa_features_test(void)
 {
 	const char *test_features = "FFA Features interface";
-	smc_ret_values ffa_ret;
+	struct ffa_value ffa_ret;
 	unsigned int expected_ret;
 	const struct ffa_features_test *ffa_feature_test_target;
 	unsigned int i, test_target_size =
@@ -109,7 +109,7 @@
 
 	announce_test_start(test_wrong_uuid);
 
-	smc_ret_values ret = ffa_partition_info_get(uuid);
+	struct ffa_value ret = ffa_partition_info_get(uuid);
 	expect(ffa_func_id(ret), FFA_ERROR);
 	expect(ffa_error_code(ret), FFA_ERROR_INVALID_PARAMETER);
 
@@ -146,8 +146,10 @@
 
 	announce_test_start(test_ffa_version);
 
-	smc_ret_values ret = ffa_version(MAKE_FFA_VERSION(FFA_MAJOR, FFA_MINOR));
-	spm_version = (uint32_t)ret.ret0;
+	struct ffa_value ret = ffa_version(MAKE_FFA_VERSION(FFA_MAJOR,
+							    FFA_MINOR));
+
+	spm_version = (uint32_t)ret.fid;
 
 	bool ffa_version_compatible =
 		((spm_version >> FFA_VERSION_MAJOR_SHIFT) == FFA_MAJOR &&
@@ -170,7 +172,7 @@
 	announce_test_start(test_spm_id_get);
 
 	if (spm_version >= MAKE_FFA_VERSION(1, 1)) {
-		smc_ret_values ret = ffa_spm_id_get();
+		struct ffa_value ret = ffa_spm_id_get();
 
 		expect(ffa_func_id(ret), FFA_SUCCESS_SMC32);
 
diff --git a/spm/cactus/cactus_tests/cactus_test_interrupts.c b/spm/cactus/cactus_tests/cactus_test_interrupts.c
index dc64512..31ba7ca 100644
--- a/spm/cactus/cactus_tests/cactus_test_interrupts.c
+++ b/spm/cactus/cactus_tests/cactus_test_interrupts.c
@@ -44,7 +44,7 @@
 
 CACTUS_CMD_HANDLER(sleep_fwd_cmd, CACTUS_FWD_SLEEP_CMD)
 {
-	smc_ret_values ffa_ret;
+	struct ffa_value ffa_ret;
 	ffa_id_t vm_id = ffa_dir_msg_dest(*args);
 	ffa_id_t fwd_dest = cactus_get_fwd_sleep_dest(*args);
 	uint32_t sleep_ms = cactus_get_sleep_time(*args);
@@ -54,7 +54,7 @@
 
 	ffa_ret = cactus_sleep_cmd(vm_id, fwd_dest, sleep_ms);
 
-	while (ffa_ret.ret0 == FFA_INTERRUPT) {
+	while (ffa_func_id(ffa_ret) == FFA_INTERRUPT) {
 		/* Received FFA_INTERRUPT in blocked state. */
 		VERBOSE("Processing FFA_INTERRUPT while blocked on direct response\n");
 		unsigned int my_core_pos = platform_get_core_pos(read_mpidr_el1());
diff --git a/spm/cactus/cactus_tests/cactus_test_memory_sharing.c b/spm/cactus/cactus_tests/cactus_test_memory_sharing.c
index 884240b..e67ff42 100644
--- a/spm/cactus/cactus_tests/cactus_test_memory_sharing.c
+++ b/spm/cactus/cactus_tests/cactus_test_memory_sharing.c
@@ -181,7 +181,7 @@
 
 CACTUS_CMD_HANDLER(req_mem_send_cmd, CACTUS_REQ_MEM_SEND_CMD)
 {
-	smc_ret_values ffa_ret;
+	struct ffa_value ffa_ret;
 	uint32_t mem_func = cactus_req_mem_send_get_mem_func(*args);
 	ffa_id_t receiver = cactus_req_mem_send_get_receiver(*args);
 	ffa_memory_handle_t handle;
diff --git a/spm/cactus/cactus_tests/cactus_test_notifications.c b/spm/cactus/cactus_tests/cactus_test_notifications.c
index bd293f9..947c8e0 100644
--- a/spm/cactus/cactus_tests/cactus_test_notifications.c
+++ b/spm/cactus/cactus_tests/cactus_test_notifications.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2021-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -51,7 +51,7 @@
 	ffa_notification_bitmap_t notifications =
 		cactus_notification_get_notifications(*args);
 	uint32_t flags = cactus_notification_get_flags(*args);
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	VERBOSE("Partition %x requested to bind notifications '%llx' to %x\n",
 		source, notifications, receiver);
@@ -73,7 +73,7 @@
 	ffa_id_t sender = cactus_notification_get_sender(*args);
 	ffa_notification_bitmap_t notifications =
 		cactus_notification_get_notifications(*args);
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	VERBOSE("Partition %x requested to unbind notifications '%llx' to %x\n",
 	     source, notifications, receiver);
@@ -95,7 +95,7 @@
 				cactus_notification_get_receiver(*args);
 	uint32_t flags = cactus_notification_get_flags(*args);
 	uint32_t vcpu_id = cactus_notification_get_vcpu(*args);
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	VERBOSE("Partition %x requested to get notifications.\n", source);
 
@@ -139,7 +139,7 @@
 	ffa_id_t sender = cactus_notifications_set_get_sender(*args);
 	ffa_id_t echo_dest = cactus_req_echo_get_echo_dest(*args);
 	uint32_t flags = cactus_notification_get_flags(*args);
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	VERBOSE("Partition %x requested to set notifications.\n", source);
 
diff --git a/spm/cactus/cactus_tests/cactus_tests_smmuv3.c b/spm/cactus/cactus_tests/cactus_tests_smmuv3.c
index fbf46c8..fac9514 100644
--- a/spm/cactus/cactus_tests/cactus_tests_smmuv3.c
+++ b/spm/cactus/cactus_tests/cactus_tests_smmuv3.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2021-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -150,7 +150,7 @@
 
 CACTUS_CMD_HANDLER(smmuv3_cmd, CACTUS_DMA_SMMUv3_CMD)
 {
-	smc_ret_values ffa_ret;
+	struct ffa_value ffa_ret;
 	ffa_id_t vm_id = ffa_dir_msg_dest(*args);
 	ffa_id_t source = ffa_dir_msg_source(*args);
 
diff --git a/spm/common/sp_debug.c b/spm/common/sp_debug.c
index 396253b..2e67be3 100644
--- a/spm/common/sp_debug.c
+++ b/spm/common/sp_debug.c
@@ -1,13 +1,13 @@
 /*
- * Copyright (c) 2020-2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2020-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include <drivers/arm/pl011.h>
 #include <drivers/console.h>
+#include <ffa_helpers.h>
 #include <sp_debug.h>
-#include <sp_helpers.h>
 #include <spm_helpers.h>
 
 static int (*putc_impl)(int);
@@ -21,12 +21,11 @@
 
 static int putc_svccall(int c)
 {
-	/* TODO svc call */
-	svc_args args = {
+	struct ffa_value args = {
 		.fid = SPM_DEBUG_LOG,
 		.arg1 = c
 	};
-	sp_svc(&args);
+	ffa_svc(&args);
 
 	return c;
 }
diff --git a/spm/ivy/app/ivy_main.c b/spm/ivy/app/ivy_main.c
index 232ab2e..1aafb57 100644
--- a/spm/ivy/app/ivy_main.c
+++ b/spm/ivy/app/ivy_main.c
@@ -9,7 +9,6 @@
 #include <errno.h>
 #include <ffa_helpers.h>
 #include <sp_debug.h>
-#include <sp_helpers.h>
 
 #include "ivy.h"
 
@@ -19,46 +18,35 @@
 
 void __dead2 ivy_main(void)
 {
-	u_register_t ret;
-	svc_args args;
+	struct ffa_value ret;
 	ffa_id_t my_id;
 
 	set_putc_impl(SVC_CALL_AS_STDOUT);
 
 	/* Get FF-A id. */
-	args = (svc_args){.fid = FFA_ID_GET};
-	ret = sp_svc(&args);
-	if (ret != FFA_SUCCESS_SMC32) {
+	ret = ffa_id_get();
+	if (ffa_func_id(ret) != FFA_SUCCESS_SMC32) {
 		ERROR("Cannot get FF-A id.\n");
 		panic();
 	}
-	my_id = (ffa_id_t)args.arg2;
+	my_id = ffa_endpoint_id(ret);
 
 	NOTICE("Booting Secure Partition (ID: %x)\n", my_id);
 	NOTICE("%s\n", build_message);
 	NOTICE("%s\n", version_string);
 
 init:
-	args = (svc_args) {.fid = FFA_MSG_WAIT};
-	ret = sp_svc(&args);
+	ret = ffa_msg_wait();
 
 	while (1) {
-		ffa_id_t req_sender = (ffa_id_t)(args.arg1 >> 16);
-
-		if (ret != FFA_MSG_SEND_DIRECT_REQ_SMC32) {
-			ERROR("unknown FF-A request %lx\n", ret);
+		if (ffa_func_id(ret) != FFA_MSG_SEND_DIRECT_REQ_SMC32) {
+			ERROR("unknown FF-A request %x\n", ffa_func_id(ret));
 			goto init;
 		}
 
-		VERBOSE("Received request: %lx\n", args.arg3);
+		VERBOSE("Received request: %lx\n", ret.ret3);
 
-
-		args.fid = FFA_MSG_SEND_DIRECT_RESP_SMC32;
-		args.arg1 = ((u_register_t)my_id) << 16 |
-			    (u_register_t)req_sender;
-		args.arg2 = 0;
-		args.arg3 = 0;
-
-		ret = sp_svc(&args);
+		ret = ffa_msg_send_direct_resp32(my_id, ffa_dir_msg_source(ret),
+						 0, 0, 0, 0, 0);
 	}
 }
diff --git a/spm/ivy/ivy.mk b/spm/ivy/ivy.mk
index 9531f9b..e996a7c 100644
--- a/spm/ivy/ivy.mk
+++ b/spm/ivy/ivy.mk
@@ -42,7 +42,6 @@
 		ivy_main.c				\
 	)						\
 	$(addprefix spm/common/,			\
-		aarch64/sp_arch_helpers.S		\
 		sp_debug.c				\
 		sp_helpers.c				\
 		spm_helpers.c				\
@@ -61,6 +60,7 @@
 IVY_SOURCES	+=					\
 	tftf/framework/debug.c				\
 	tftf/framework/${ARCH}/asm_debug.S		\
+	tftf/tests/runtime_services/secure_service/${ARCH}/ffa_arch_helpers.S \
 	tftf/tests/runtime_services/secure_service/ffa_helpers.c
 
 IVY_SOURCES	+= 	drivers/arm/pl011/${ARCH}/pl011_console.S	\
diff --git a/tftf/tests/common/test_helpers.c b/tftf/tests/common/test_helpers.c
index 1a6ea64..6b966da 100644
--- a/tftf/tests/common/test_helpers.c
+++ b/tftf/tests/common/test_helpers.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2020-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -229,7 +229,7 @@
 	 */
 	if (sp_id != SP_ID(1)) {
 		uint32_t core_pos = get_current_core_id();
-		smc_ret_values ret = ffa_run(sp_id, core_pos);
+		struct ffa_value ret = ffa_run(sp_id, core_pos);
 
 		if (ffa_func_id(ret) != FFA_MSG_WAIT) {
 			ERROR("Failed to run SP%x on core %u\n",
@@ -243,7 +243,7 @@
 
 bool spm_set_managed_exit_int(ffa_id_t sp_id, bool enable)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	ret = cactus_interrupt_cmd(HYP_ID, sp_id, MANAGED_EXIT_INTERRUPT_ID,
 				   enable, INTERRUPT_TYPE_FIQ);
@@ -263,7 +263,7 @@
  */
 bool mailbox_init(struct mailbox_buffers mb)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	ffa_rxtx_unmap();
 	CONFIGURE_AND_MAP_MAILBOX(mb, PAGE_SIZE, ret);
diff --git a/tftf/tests/misc_tests/test_invalid_access.c b/tftf/tests/misc_tests/test_invalid_access.c
index 8b79caf..14be340 100644
--- a/tftf/tests/misc_tests/test_invalid_access.c
+++ b/tftf/tests/misc_tests/test_invalid_access.c
@@ -301,7 +301,7 @@
 		sizeof(struct ffa_memory_region_constituent);
 	ffa_memory_handle_t handle;
 	struct mailbox_buffers mb;
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	if (get_armv9_2_feat_rme_support() == 0U) {
 		return TEST_RESULT_SKIPPED;
diff --git a/tftf/tests/runtime_services/realm_payload/realm_payload_spm_test.c b/tftf/tests/runtime_services/realm_payload/realm_payload_spm_test.c
index d11c1c9..22c1752 100644
--- a/tftf/tests/runtime_services/realm_payload/realm_payload_spm_test.c
+++ b/tftf/tests/runtime_services/realm_payload/realm_payload_spm_test.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2021-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -114,7 +114,7 @@
 					  ffa_id_t dest,
 					  uint64_t value)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 	ret = cactus_echo_send_cmd(sender, dest, value);
 
 	/*
@@ -144,7 +144,7 @@
 	unsigned int mpid = read_mpidr_el1() & MPID_MASK;
 	unsigned int core_pos = platform_get_core_pos(mpid);
 	test_result_t ret = TEST_RESULT_SUCCESS;
-	smc_ret_values ffa_ret;
+	struct ffa_value ffa_ret;
 
 	/*
 	 * Send a direct message request to SP1 (MP SP) from current physical
diff --git a/tftf/tests/runtime_services/secure_service/aarch32/ffa_arch_helpers.S b/tftf/tests/runtime_services/secure_service/aarch32/ffa_arch_helpers.S
new file mode 100644
index 0000000..0d5395f
--- /dev/null
+++ b/tftf/tests/runtime_services/secure_service/aarch32/ffa_arch_helpers.S
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2022, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <asm_macros.S>
+
+	.macro service_call _conduit
+	/* Push r9 to keep the stack pointer aligned to 64 bit. */
+	push	{r4 - r9}
+
+	/*
+	 * Save the ffa_value pointer in a callee saved register.
+	 */
+	mov	r8, r0
+
+	/* Load the argument values into the appropriate registers. */
+	ldm	r0, {r0 - r7}
+
+	\_conduit	#0
+
+	/*
+	 * The return values are stored in x0-x7, put them in the ffa_value
+	 * return structure.
+	 */
+	stm	r8, {r0 - r7}
+
+	pop	{r4 - r9}
+	.endm
+
+.globl ffa_svc
+func ffa_svc
+	service_call svc
+	bx	lr
+endfunc ffa_svc
+
+.globl ffa_smc
+func ffa_smc
+	service_call smc
+	bx	lr
+endfunc ffa_smc
diff --git a/tftf/tests/runtime_services/secure_service/aarch64/ffa_arch_helpers.S b/tftf/tests/runtime_services/secure_service/aarch64/ffa_arch_helpers.S
new file mode 100644
index 0000000..0e35a38
--- /dev/null
+++ b/tftf/tests/runtime_services/secure_service/aarch64/ffa_arch_helpers.S
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2022, Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: BSD-3-Clause
+ */
+
+#include <asm_macros.S>
+
+	.macro service_call _conduit
+	/*
+	 * Save the address of the ffa_value structure on the stack.
+	 *
+	 * Although x0 contains an 8-byte value, we are allocating 16 bytes
+	 * on the stack to respect the 16-byte stack-alignment.
+	 */
+	str	x0, [sp, #-16]!
+
+	/* Load the argument values into the appropriate registers. */
+	ldp	x6, x7, [x0, #48]
+	ldp	x4, x5, [x0, #32]
+	ldp	x2, x3, [x0, #16]
+	ldp	x0, x1, [x0, #0]
+
+	\_conduit	#0
+
+	/*
+	 * Pop the ffa_value structure address from the stack into a
+	 * caller-saved register.
+	 */
+	ldr	x9, [sp], #16
+
+	/*
+	 * The return values are stored in x0-x7, put them in the ffa_value
+	 * return structure.
+	 */
+	stp	x0, x1, [x9, #0]
+	stp	x2, x3, [x9, #16]
+	stp	x4, x5, [x9, #32]
+	stp	x6, x7, [x9, #48]
+
+	.endm
+
+.globl ffa_svc
+func ffa_svc
+	service_call svc
+	ret
+endfunc ffa_svc
+
+.globl ffa_smc
+func ffa_smc
+	service_call smc
+	ret
+endfunc ffa_smc
diff --git a/tftf/tests/runtime_services/secure_service/ffa_helpers.c b/tftf/tests/runtime_services/secure_service/ffa_helpers.c
index 4525d6e..e5c2590 100644
--- a/tftf/tests/runtime_services/secure_service/ffa_helpers.c
+++ b/tftf/tests/runtime_services/secure_service/ffa_helpers.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2018-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -9,6 +9,16 @@
 #include <ffa_helpers.h>
 #include <ffa_svc.h>
 
+struct ffa_value ffa_service_call(struct ffa_value *args)
+{
+#if IMAGE_IVY
+	ffa_svc(args);
+#else
+	ffa_smc(args);
+#endif
+	return *args;
+}
+
 /*-----------------------------------------------------------------------------
  * FFA_RUN
  *
@@ -26,15 +36,15 @@
  *     -BUSY: vCPU is busy and caller must retry later
  *     -ABORTED: vCPU or VM ran into an unexpected error and has aborted
  */
-smc_ret_values ffa_run(uint32_t dest_id, uint32_t vcpu_id)
+struct ffa_value ffa_run(uint32_t dest_id, uint32_t vcpu_id)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		FFA_MSG_RUN,
 		(dest_id << 16) | vcpu_id,
 		0, 0, 0, 0, 0, 0
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /*-----------------------------------------------------------------------------
@@ -55,12 +65,12 @@
  *     -BUSY: Message target is busy
  *     -ABORTED: Message target ran into an unexpected error and has aborted
  */
-smc_ret_values ffa_msg_send_direct_req64(ffa_id_t source_id,
-					 ffa_id_t dest_id, uint64_t arg0,
-					 uint64_t arg1, uint64_t arg2,
-					 uint64_t arg3, uint64_t arg4)
+struct ffa_value ffa_msg_send_direct_req64(ffa_id_t source_id,
+					   ffa_id_t dest_id, uint64_t arg0,
+					   uint64_t arg1, uint64_t arg2,
+					   uint64_t arg3, uint64_t arg4)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_MSG_SEND_DIRECT_REQ_SMC64,
 		.arg1 = ((uint32_t)(source_id << 16)) | (dest_id),
 		.arg2 = 0,
@@ -71,15 +81,15 @@
 		.arg7 = arg4,
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
-smc_ret_values ffa_msg_send_direct_req32(ffa_id_t source_id,
-					 ffa_id_t dest_id, uint32_t arg0,
-					 uint32_t arg1, uint32_t arg2,
-					 uint32_t arg3, uint32_t arg4)
+struct ffa_value ffa_msg_send_direct_req32(ffa_id_t source_id,
+					   ffa_id_t dest_id, uint32_t arg0,
+					   uint32_t arg1, uint32_t arg2,
+					   uint32_t arg3, uint32_t arg4)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_MSG_SEND_DIRECT_REQ_SMC32,
 		.arg1 = ((uint32_t)(source_id << 16)) | (dest_id),
 		.arg2 = 0,
@@ -90,15 +100,15 @@
 		.arg7 = arg4,
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
-smc_ret_values ffa_msg_send_direct_resp64(ffa_id_t source_id,
-					  ffa_id_t dest_id, uint64_t arg0,
-					  uint64_t arg1, uint64_t arg2,
-					  uint64_t arg3, uint64_t arg4)
+struct ffa_value ffa_msg_send_direct_resp64(ffa_id_t source_id,
+					    ffa_id_t dest_id, uint64_t arg0,
+					    uint64_t arg1, uint64_t arg2,
+					    uint64_t arg3, uint64_t arg4)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_MSG_SEND_DIRECT_RESP_SMC64,
 		.arg1 = ((uint32_t)(source_id << 16)) | (dest_id),
 		.arg2 = 0,
@@ -109,15 +119,15 @@
 		.arg7 = arg4,
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
-smc_ret_values ffa_msg_send_direct_resp32(ffa_id_t source_id,
-					  ffa_id_t dest_id, uint32_t arg0,
-					  uint32_t arg1, uint32_t arg2,
-					  uint32_t arg3, uint32_t arg4)
+struct ffa_value ffa_msg_send_direct_resp32(ffa_id_t source_id,
+					    ffa_id_t dest_id, uint32_t arg0,
+					    uint32_t arg1, uint32_t arg2,
+					    uint32_t arg3, uint32_t arg4)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_MSG_SEND_DIRECT_RESP_SMC32,
 		.arg1 = ((uint32_t)(source_id << 16)) | (dest_id),
 		.arg2 = 0,
@@ -128,7 +138,7 @@
 		.arg7 = arg4,
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 
@@ -297,69 +307,69 @@
  *	-Bits[30:16]: Major version.
  *	-Bits[15:0]: Minor version.
  */
-smc_ret_values ffa_version(uint32_t input_version)
+struct ffa_value ffa_version(uint32_t input_version)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_VERSION,
 		.arg1 = input_version
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
-smc_ret_values ffa_id_get(void)
+struct ffa_value ffa_id_get(void)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_ID_GET
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
-smc_ret_values ffa_spm_id_get(void)
+struct ffa_value ffa_spm_id_get(void)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_SPM_ID_GET
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
-smc_ret_values ffa_msg_wait(void)
+struct ffa_value ffa_msg_wait(void)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_MSG_WAIT
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
-smc_ret_values ffa_error(int32_t error_code)
+struct ffa_value ffa_error(int32_t error_code)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_ERROR,
 		.arg1 = 0,
 		.arg2 = error_code
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /* Query the higher EL if the requested FF-A feature is implemented. */
-smc_ret_values ffa_features(uint32_t feature)
+struct ffa_value ffa_features(uint32_t feature)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_FEATURES,
 		.arg1 = feature
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /* Get information about VMs or SPs based on UUID */
-smc_ret_values ffa_partition_info_get(const struct ffa_uuid uuid)
+struct ffa_value ffa_partition_info_get(const struct ffa_uuid uuid)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_PARTITION_INFO_GET,
 		.arg1 = uuid.uuid[0],
 		.arg2 = uuid.uuid[1],
@@ -367,23 +377,23 @@
 		.arg4 = uuid.uuid[3]
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /* Query SPMD that the rx buffer of the partition can be released */
-smc_ret_values ffa_rx_release(void)
+struct ffa_value ffa_rx_release(void)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_RX_RELEASE
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /* Map the RXTX buffer */
-smc_ret_values ffa_rxtx_map(uintptr_t send, uintptr_t recv, uint32_t pages)
+struct ffa_value ffa_rxtx_map(uintptr_t send, uintptr_t recv, uint32_t pages)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_RXTX_MAP_SMC64,
 		.arg1 = send,
 		.arg2 = recv,
@@ -394,13 +404,13 @@
 		.arg7 = FFA_PARAM_MBZ
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /* Unmap the RXTX buffer allocated by the given FF-A component */
-smc_ret_values ffa_rxtx_unmap(void)
+struct ffa_value ffa_rxtx_unmap(void)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_RXTX_UNMAP,
 		.arg1 = FFA_PARAM_MBZ,
 		.arg2 = FFA_PARAM_MBZ,
@@ -411,14 +421,14 @@
 		.arg7 = FFA_PARAM_MBZ
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /* Donate memory to another partition */
-smc_ret_values ffa_mem_donate(uint32_t descriptor_length,
+struct ffa_value ffa_mem_donate(uint32_t descriptor_length,
 				uint32_t fragment_length)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_MEM_DONATE_SMC32,
 		.arg1 = descriptor_length,
 		.arg2 = fragment_length,
@@ -426,14 +436,14 @@
 		.arg4 = FFA_PARAM_MBZ
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /* Lend memory to another partition */
-smc_ret_values ffa_mem_lend(uint32_t descriptor_length,
-				uint32_t fragment_length)
+struct ffa_value ffa_mem_lend(uint32_t descriptor_length,
+			      uint32_t fragment_length)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_MEM_LEND_SMC32,
 		.arg1 = descriptor_length,
 		.arg2 = fragment_length,
@@ -441,14 +451,14 @@
 		.arg4 = FFA_PARAM_MBZ
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /* Share memory with another partition */
-smc_ret_values ffa_mem_share(uint32_t descriptor_length,
-				uint32_t fragment_length)
+struct ffa_value ffa_mem_share(uint32_t descriptor_length,
+			       uint32_t fragment_length)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_MEM_SHARE_SMC32,
 		.arg1 = descriptor_length,
 		.arg2 = fragment_length,
@@ -456,14 +466,14 @@
 		.arg4 = FFA_PARAM_MBZ
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /* Retrieve memory shared by another partition */
-smc_ret_values ffa_mem_retrieve_req(uint32_t descriptor_length,
-					uint32_t fragment_length)
+struct ffa_value ffa_mem_retrieve_req(uint32_t descriptor_length,
+				      uint32_t fragment_length)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_MEM_RETRIEVE_REQ_SMC32,
 		.arg1 = descriptor_length,
 		.arg2 = fragment_length,
@@ -474,37 +484,37 @@
 		.arg7 = FFA_PARAM_MBZ
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /* Relinquish access to memory region */
-smc_ret_values ffa_mem_relinquish(void)
+struct ffa_value ffa_mem_relinquish(void)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_MEM_RELINQUISH,
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /* Reclaim exclusive access to owned memory region */
-smc_ret_values ffa_mem_reclaim(uint64_t handle, uint32_t flags)
+struct ffa_value ffa_mem_reclaim(uint64_t handle, uint32_t flags)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_MEM_RECLAIM,
 		.arg1 = (uint32_t) handle,
 		.arg2 = (uint32_t) (handle >> 32),
 		.arg3 = flags
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /** Create Notifications Bitmap for the given VM */
-smc_ret_values ffa_notification_bitmap_create(ffa_id_t vm_id,
-					      ffa_vcpu_count_t vcpu_count)
+struct ffa_value ffa_notification_bitmap_create(ffa_id_t vm_id,
+						ffa_vcpu_count_t vcpu_count)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_NOTIFICATION_BITMAP_CREATE,
 		.arg1 = vm_id,
 		.arg2 = vcpu_count,
@@ -515,13 +525,13 @@
 		.arg7 = FFA_PARAM_MBZ,
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /** Destroy Notifications Bitmap for the given VM */
-smc_ret_values ffa_notification_bitmap_destroy(ffa_id_t vm_id)
+struct ffa_value ffa_notification_bitmap_destroy(ffa_id_t vm_id)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_NOTIFICATION_BITMAP_DESTROY,
 		.arg1 = vm_id,
 		.arg2 = FFA_PARAM_MBZ,
@@ -532,15 +542,15 @@
 		.arg7 = FFA_PARAM_MBZ,
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /** Bind VM to all the notifications in the bitmap */
-smc_ret_values ffa_notification_bind(ffa_id_t sender, ffa_id_t receiver,
-				     uint32_t flags,
-				     ffa_notification_bitmap_t bitmap)
+struct ffa_value ffa_notification_bind(ffa_id_t sender, ffa_id_t receiver,
+				       uint32_t flags,
+				       ffa_notification_bitmap_t bitmap)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_NOTIFICATION_BIND,
 		.arg1 = (sender << 16) | (receiver),
 		.arg2 = flags,
@@ -551,15 +561,15 @@
 		.arg7 = FFA_PARAM_MBZ,
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
 /** Unbind previously bound VM from notifications in bitmap */
-smc_ret_values ffa_notification_unbind(ffa_id_t sender,
-				       ffa_id_t receiver,
-				       ffa_notification_bitmap_t bitmap)
+struct ffa_value ffa_notification_unbind(ffa_id_t sender,
+					 ffa_id_t receiver,
+					 ffa_notification_bitmap_t bitmap)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_NOTIFICATION_UNBIND,
 		.arg1 = (sender << 16) | (receiver),
 		.arg2 = FFA_PARAM_MBZ,
@@ -570,14 +580,14 @@
 		.arg7 = FFA_PARAM_MBZ,
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
-smc_ret_values ffa_notification_set(ffa_id_t sender, ffa_id_t receiver,
-				    uint32_t flags,
-				    ffa_notification_bitmap_t bitmap)
+struct ffa_value ffa_notification_set(ffa_id_t sender, ffa_id_t receiver,
+				      uint32_t flags,
+				      ffa_notification_bitmap_t bitmap)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_NOTIFICATION_SET,
 		.arg1 = (sender << 16) | (receiver),
 		.arg2 = flags,
@@ -588,13 +598,13 @@
 		.arg7 = FFA_PARAM_MBZ
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
-smc_ret_values ffa_notification_get(ffa_id_t receiver, uint32_t vcpu_id,
-				    uint32_t flags)
+struct ffa_value ffa_notification_get(ffa_id_t receiver, uint32_t vcpu_id,
+				      uint32_t flags)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_NOTIFICATION_GET,
 		.arg1 = (vcpu_id << 16) | (receiver),
 		.arg2 = flags,
@@ -605,12 +615,12 @@
 		.arg7 = FFA_PARAM_MBZ
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
 
-smc_ret_values ffa_notification_info_get(void)
+struct ffa_value ffa_notification_info_get(void)
 {
-	smc_args args = {
+	struct ffa_value args = {
 		.fid = FFA_NOTIFICATION_INFO_GET_SMC64,
 		.arg1 = FFA_PARAM_MBZ,
 		.arg2 = FFA_PARAM_MBZ,
@@ -621,5 +631,5 @@
 		.arg7 = FFA_PARAM_MBZ
 	};
 
-	return tftf_smc(&args);
+	return ffa_service_call(&args);
 }
diff --git a/tftf/tests/runtime_services/secure_service/spm_common.c b/tftf/tests/runtime_services/secure_service/spm_common.c
index 4181588..efdaa3f 100644
--- a/tftf/tests/runtime_services/secure_service/spm_common.c
+++ b/tftf/tests/runtime_services/secure_service/spm_common.c
@@ -23,7 +23,7 @@
 /**
  * Helper to log errors after FF-A calls.
  */
-bool is_ffa_call_error(smc_ret_values ret)
+bool is_ffa_call_error(struct ffa_value ret)
 {
 	if (ffa_func_id(ret) == FFA_ERROR) {
 		VERBOSE("FF-A call returned error (%x): %d\n",
@@ -33,7 +33,7 @@
 	return false;
 }
 
-bool is_expected_ffa_error(smc_ret_values ret, int32_t error_code)
+bool is_expected_ffa_error(struct ffa_value ret, int32_t error_code)
 {
 	if (ffa_func_id(ret) == FFA_ERROR &&
 	    ffa_error_code(ret) == error_code) {
@@ -51,7 +51,7 @@
  * Should be used after FFA_MSG_SEND_DIRECT_REQ, or after sending a test command
  * to an SP.
  */
-bool is_ffa_direct_response(smc_ret_values ret)
+bool is_ffa_direct_response(struct ffa_value ret)
 {
 	if ((ffa_func_id(ret) == FFA_MSG_SEND_DIRECT_RESP_SMC32) ||
 	    (ffa_func_id(ret) == FFA_MSG_SEND_DIRECT_RESP_SMC64)) {
@@ -68,7 +68,7 @@
 /**
  * Helper to check the return value of FF-A call is as expected.
  */
-bool is_expected_ffa_return(smc_ret_values ret, uint32_t func_id)
+bool is_expected_ffa_return(struct ffa_value ret, uint32_t func_id)
 {
 	if (ffa_func_id(ret) == func_id) {
 		return true;
@@ -79,7 +79,7 @@
 	return false;
 }
 
-bool is_expected_cactus_response(smc_ret_values ret, uint32_t expected_resp,
+bool is_expected_cactus_response(struct ffa_value ret, uint32_t expected_resp,
 				 uint32_t arg)
 {
 	if (!is_ffa_direct_response(ret)) {
@@ -87,28 +87,28 @@
 	}
 
 	if (cactus_get_response(ret) != expected_resp ||
-	    (uint32_t)ret.ret4 != arg) {
+	    (uint32_t)ret.arg4 != arg) {
 		ERROR("Expected response %x and %x; "
 		      "Obtained %x and %x\n",
 		      expected_resp, arg, cactus_get_response(ret),
-		      (int32_t)ret.ret4);
+		      (int32_t)ret.arg4);
 		return false;
 	}
 
 	return true;
 }
 
-void dump_smc_ret_values(smc_ret_values ret)
+void dump_ffa_value(struct ffa_value ret)
 {
 	NOTICE("FF-A value: %lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx\n",
-		ret.ret0,
-		ret.ret1,
-		ret.ret2,
-		ret.ret3,
-		ret.ret4,
-		ret.ret5,
-		ret.ret6,
-		ret.ret7);
+		ret.fid,
+		ret.arg1,
+		ret.arg2,
+		ret.arg3,
+		ret.arg4,
+		ret.arg5,
+		ret.arg6,
+		ret.arg7);
 }
 
 void fill_simd_vector_regs(const simd_vector_t v[SIMD_NUM_VECTORS])
@@ -261,7 +261,7 @@
 bool check_spmc_execution_level(void)
 {
 	unsigned int is_optee_spmc_criteria = 0U;
-	smc_ret_values ret_values;
+	struct ffa_value ret_values;
 
 	/*
 	 * Send a first OP-TEE-defined protocol message through
@@ -270,8 +270,8 @@
 	ret_values = ffa_msg_send_direct_req32(HYP_ID, SP_ID(1),
 					       OPTEE_FFA_GET_API_VERSION, 0,
 					       0, 0, 0);
-	if (ret_values.ret3 == 1 &&
-	    (ret_values.ret4 == 0 || ret_values.ret4 == 1)) {
+	if (ret_values.arg3 == 1 &&
+	    (ret_values.arg4 == 0 || ret_values.arg4 == 1)) {
 		is_optee_spmc_criteria++;
 	}
 
@@ -282,8 +282,8 @@
 	ret_values = ffa_msg_send_direct_req32(HYP_ID, SP_ID(1),
 					       OPTEE_FFA_GET_OS_VERSION,
 					       0, 0, 0, 0);
-	if ((ret_values.ret3 == OPTEE_FFA_GET_OS_VERSION_MAJOR) &&
-	    (ret_values.ret4 == OPTEE_FFA_GET_OS_VERSION_MINOR)) {
+	if ((ret_values.arg3 == OPTEE_FFA_GET_OS_VERSION_MAJOR) &&
+	    (ret_values.arg4 == OPTEE_FFA_GET_OS_VERSION_MINOR)) {
 		is_optee_spmc_criteria++;
 	}
 
@@ -353,7 +353,7 @@
 		     ffa_id_t sender, ffa_id_t receiver,
 		     ffa_memory_region_flags_t flags)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 	uint32_t fragment_size;
 	uint32_t total_size;
 	uint32_t descriptor_size;
@@ -388,8 +388,8 @@
 	 * successful ffa_mem_retrieve_req, total_size must be equal to
 	 * fragment_size.
 	 */
-	total_size = ret.ret1;
-	fragment_size = ret.ret2;
+	total_size = ret.arg1;
+	fragment_size = ret.arg2;
 
 	if (total_size != fragment_size) {
 		ERROR("Only expect one memory segment to be sent!\n");
@@ -417,7 +417,7 @@
 bool memory_relinquish(struct ffa_mem_relinquish *m, uint64_t handle,
 		       ffa_id_t id)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	ffa_mem_relinquish_init(m, handle, 0, id);
 	ret = ffa_mem_relinquish();
@@ -441,7 +441,7 @@
  */
 ffa_memory_handle_t memory_send(
 	struct ffa_memory_region *memory_region, uint32_t mem_func,
-	uint32_t fragment_length, uint32_t total_length, smc_ret_values *ret)
+	uint32_t fragment_length, uint32_t total_length, struct ffa_value *ret)
 {
 	if (fragment_length != total_length) {
 		ERROR("For now, fragment_length and total_length need to be"
@@ -460,7 +460,7 @@
 		*ret = ffa_mem_donate(total_length, fragment_length);
 		break;
 	default:
-		*ret = (smc_ret_values){0};
+		*ret = (struct ffa_value){0};
 		ERROR("TFTF - Invalid func id %x!\n", mem_func);
 		return FFA_MEMORY_HANDLE_INVALID;
 	}
@@ -485,7 +485,7 @@
 	struct ffa_memory_region *memory_region, size_t memory_region_max_size,
 	ffa_id_t sender, ffa_id_t receiver,
 	const struct ffa_memory_region_constituent *constituents,
-	uint32_t constituents_count, uint32_t mem_func, smc_ret_values *ret)
+	uint32_t constituents_count, uint32_t mem_func, struct ffa_value *ret)
 {
 	uint32_t remaining_constituent_count;
 	uint32_t total_length;
@@ -526,11 +526,12 @@
 			       const uint16_t expected_size)
 {
 	bool result = true;
-	smc_ret_values ret = ffa_partition_info_get(uuid);
+	struct ffa_value ret = ffa_partition_info_get(uuid);
 
 	if (ffa_func_id(ret) == FFA_SUCCESS_SMC32) {
 		if (ffa_partition_info_count(ret) != expected_size) {
-			ERROR("Unexpected number of partitions %ld\n", ret.ret2);
+			ERROR("Unexpected number of partitions %ld\n",
+			      ret.arg2);
 			return false;
 		}
 		const struct ffa_partition_info *info =
diff --git a/tftf/tests/runtime_services/secure_service/test_ffa_direct_messaging.c b/tftf/tests/runtime_services/secure_service/test_ffa_direct_messaging.c
index 2eb53ed..5e52f12 100644
--- a/tftf/tests/runtime_services/secure_service/test_ffa_direct_messaging.c
+++ b/tftf/tests/runtime_services/secure_service/test_ffa_direct_messaging.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018-2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2018-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -30,7 +30,7 @@
 					  ffa_id_t dest,
 					  uint64_t value)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 	ret = cactus_echo_send_cmd(sender, dest, value);
 
 	/*
@@ -96,7 +96,7 @@
 					      ffa_id_t echo_dest,
 					      uint64_t value)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	ret = cactus_req_echo_send_cmd(sender, dest, echo_dest, value);
 
@@ -141,7 +141,7 @@
 
 test_result_t test_ffa_sp_to_sp_deadlock(void)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	/**********************************************************************
 	 * Check SPMC has ffa_version and expected FFA endpoints are deployed.
@@ -169,7 +169,7 @@
 {
 	unsigned int core_pos = get_current_core_id();
 	test_result_t ret = TEST_RESULT_SUCCESS;
-	smc_ret_values ffa_ret;
+	struct ffa_value ffa_ret;
 
 	/*
 	 * Send a direct message request to SP1 (MP SP) from current physical
diff --git a/tftf/tests/runtime_services/secure_service/test_ffa_exceptions.c b/tftf/tests/runtime_services/secure_service/test_ffa_exceptions.c
index ffa2a6f..61cf2ad 100644
--- a/tftf/tests/runtime_services/secure_service/test_ffa_exceptions.c
+++ b/tftf/tests/runtime_services/secure_service/test_ffa_exceptions.c
@@ -47,7 +47,7 @@
 		sizeof(struct ffa_memory_region_constituent);
 	ffa_memory_handle_t handle;
 	struct mailbox_buffers mb;
-	smc_ret_values ret;
+	struct ffa_value ret;
 	u_register_t retmm;
 
 	if (get_armv9_2_feat_rme_support() == 0U) {
diff --git a/tftf/tests/runtime_services/secure_service/test_ffa_interrupts.c b/tftf/tests/runtime_services/secure_service/test_ffa_interrupts.c
index c92d683..1c17513 100644
--- a/tftf/tests/runtime_services/secure_service/test_ffa_interrupts.c
+++ b/tftf/tests/runtime_services/secure_service/test_ffa_interrupts.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2021-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -64,7 +64,7 @@
 test_result_t test_ffa_ns_interrupt(void)
 {
 	int ret;
-	smc_ret_values ret_values;
+	struct ffa_value ret_values;
 
 	CHECK_SPMC_TESTING_SETUP(1, 0, expected_sp_uuids);
 
diff --git a/tftf/tests/runtime_services/secure_service/test_ffa_memory_sharing.c b/tftf/tests/runtime_services/secure_service/test_ffa_memory_sharing.c
index 7f62ea5..b4d58b2 100644
--- a/tftf/tests/runtime_services/secure_service/test_ffa_memory_sharing.c
+++ b/tftf/tests/runtime_services/secure_service/test_ffa_memory_sharing.c
@@ -59,7 +59,7 @@
  */
 static test_result_t test_memory_send_sp(uint32_t mem_func)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 	ffa_memory_handle_t handle;
 	uint32_t *ptr;
 	struct mailbox_buffers mb;
@@ -146,7 +146,7 @@
 						ffa_id_t receiver_sp,
 						bool non_secure)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	/***********************************************************************
 	 * Check if SPMC's ffa_version and presence of expected FF-A endpoints.
@@ -178,7 +178,7 @@
 						ffa_id_t sender_sp,
 						ffa_id_t receiver_vm)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	/**********************************************************************
 	 * Check if SPMC's ffa_version and presence of expected FF-A endpoints.
@@ -259,7 +259,7 @@
 	uint32_t total_length;
 	uint32_t fragment_length;
 	ffa_memory_handle_t handle;
-	smc_ret_values ret;
+	struct ffa_value ret;
 	uint32_t *ptr;
 	/* Arbitrarily write 10 words after using shared memory. */
 	const uint32_t nr_words_to_write = 10U;
diff --git a/tftf/tests/runtime_services/secure_service/test_ffa_notifications.c b/tftf/tests/runtime_services/secure_service/test_ffa_notifications.c
index 7ed8f97..e900ae3 100644
--- a/tftf/tests/runtime_services/secure_service/test_ffa_notifications.c
+++ b/tftf/tests/runtime_services/secure_service/test_ffa_notifications.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2021-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -53,7 +53,7 @@
  */
 test_result_t test_notifications_retrieve_int_ids(void)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	SKIP_TEST_IF_FFA_VERSION_LESS_THAN(1, 1);
 
@@ -104,7 +104,8 @@
 {
 	VERBOSE("Creating bitmap for VM %x; cpu count: %u.\n",
 		vm_id, vcpu_count);
-	smc_ret_values ret = ffa_notification_bitmap_create(vm_id, vcpu_count);
+	struct ffa_value ret = ffa_notification_bitmap_create(vm_id,
+							      vcpu_count);
 
 	return !is_ffa_call_error(ret);
 }
@@ -115,7 +116,7 @@
 static bool notifications_bitmap_destroy(ffa_id_t vm_id)
 {
 	VERBOSE("Destroying bitmap of VM %x.\n", vm_id);
-	smc_ret_values ret = ffa_notification_bitmap_destroy(vm_id);
+	struct ffa_value ret = ffa_notification_bitmap_destroy(vm_id);
 
 	return !is_ffa_call_error(ret);
 }
@@ -157,7 +158,7 @@
 		return TEST_RESULT_SKIPPED;
 	}
 
-	smc_ret_values ret = ffa_notification_bitmap_destroy(VM_ID(1));
+	struct ffa_value ret = ffa_notification_bitmap_destroy(VM_ID(1));
 
 	if (!is_expected_ffa_error(ret, FFA_ERROR_DENIED)) {
 		return TEST_RESULT_FAIL;
@@ -172,7 +173,7 @@
  */
 test_result_t test_ffa_notifications_create_after_create(void)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 	const ffa_id_t vm_id = VM_ID(2);
 
 	SKIP_TEST_IF_FFA_VERSION_LESS_THAN(1, 1);
@@ -217,7 +218,7 @@
 	ffa_notification_bitmap_t notifications, uint32_t flags,
 	uint32_t expected_resp, uint32_t error_code)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	VERBOSE("TFTF requesting SP to bind notifications!\n");
 
@@ -248,7 +249,7 @@
 	ffa_notification_bitmap_t notifications, uint32_t expected_resp,
 	uint32_t error_code)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	VERBOSE("TFTF requesting SP to unbind notifications!\n");
 
@@ -307,7 +308,7 @@
 {
 	CHECK_SPMC_TESTING_SETUP(1, 1, expected_sp_uuids);
 	const ffa_id_t vm_id = VM_ID(1);
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	if (!notifications_bitmap_create(vm_id, 1)) {
 		return TEST_RESULT_FAIL;
@@ -340,7 +341,7 @@
 	CHECK_SPMC_TESTING_SETUP(1, 1, expected_sp_uuids);
 	const ffa_id_t vm_id = VM_ID(1);
 	const ffa_id_t sender_id = VM_ID(2);
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	if (!notifications_bitmap_create(vm_id, 1)) {
 		return TEST_RESULT_FAIL;
@@ -458,7 +459,7 @@
  */
 static bool request_notification_get(
 	ffa_id_t cmd_dest, ffa_id_t receiver, uint32_t vcpu_id, uint32_t flags,
-	bool check_npi_handled, smc_ret_values *response)
+	bool check_npi_handled, struct ffa_value *response)
 {
 	VERBOSE("TFTF requesting SP to get notifications!\n");
 
@@ -474,7 +475,7 @@
 	ffa_notification_bitmap_t notifications, ffa_id_t echo_dest,
 	uint32_t exp_resp, int32_t exp_error)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	VERBOSE("TFTF requesting SP %x (as %x) to set notifications to %x\n",
 		cmd_dest, sender, receiver);
@@ -501,7 +502,7 @@
 			     uint32_t flags,
 			     ffa_notification_bitmap_t notifications)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	/* Sender sets notifications to receiver. */
 	if (!IS_SP_ID(sender)) {
@@ -525,7 +526,7 @@
  * Check that SP's response to CACTUS_NOTIFICATION_GET_CMD is as expected.
  */
 static bool is_notifications_get_as_expected(
-	smc_ret_values *ret, uint64_t exp_from_sp, uint64_t exp_from_vm,
+	struct ffa_value *ret, uint64_t exp_from_sp, uint64_t exp_from_vm,
 	ffa_id_t receiver)
 {
 	uint64_t from_sp;
@@ -564,7 +565,7 @@
 }
 
 static bool is_notifications_info_get_as_expected(
-	smc_ret_values *ret, uint16_t *ids, uint32_t *lists_sizes,
+	struct ffa_value *ret, uint16_t *ids, uint32_t *lists_sizes,
 	const uint32_t max_ids_count, uint32_t lists_count, bool more_pending)
 {
 	if (lists_count != ffa_notifications_info_get_lists_count(*ret) ||
@@ -573,7 +574,7 @@
 		      "    Lists counts: %u; more pending %u\n",
 		      ffa_notifications_info_get_lists_count(*ret),
 		      ffa_notifications_info_get_more_pending(*ret));
-		dump_smc_ret_values(*ret);
+		dump_ffa_value(*ret);
 		return false;
 	}
 
@@ -590,7 +591,7 @@
 	}
 
 	/* Compare the IDs list */
-	if (memcmp(&ret->ret3, ids, sizeof(ids[0]) * max_ids_count) != 0) {
+	if (memcmp(&ret->arg3, ids, sizeof(ids[0]) * max_ids_count) != 0) {
 		ERROR("List of IDs not as expected\n");
 		return false;
 	}
@@ -608,7 +609,7 @@
 static bool notification_bind_and_set(ffa_id_t sender,
 	ffa_id_t receiver, ffa_notification_bitmap_t notifications, uint32_t flags)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 	uint32_t flags_bind = flags & FFA_NOTIFICATIONS_FLAG_PER_VCPU;
 
 	/* Receiver binds notifications to sender. */
@@ -639,7 +640,7 @@
 	ffa_notification_bitmap_t exp_from_vm, uint32_t vcpu_id,
 	uint32_t flags, bool check_npi_handled)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	/* Receiver gets pending notifications. */
 	if (IS_SP_ID(receiver)) {
@@ -658,7 +659,7 @@
 	uint32_t *expected_lists_sizes, const uint32_t max_ids_count,
 	bool expected_more_pending)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	VERBOSE("Getting pending notification's info.\n");
 
@@ -700,7 +701,7 @@
 						     bool enable)
 {
 	VERBOSE("Configuring NPI to receiver: %x\n", receiver);
-	smc_ret_values ret = cactus_interrupt_cmd(
+	struct ffa_value ret = cactus_interrupt_cmd(
 		HYP_ID, receiver, NOTIFICATION_PENDING_INTERRUPT_INTID,
 		enable, INTERRUPT_TYPE_IRQ);
 
@@ -836,7 +837,7 @@
 	const ffa_id_t sender = SP_ID(1);
 	const ffa_id_t receiver = VM_ID(1);
 	uint32_t get_flags = FFA_NOTIFICATIONS_FLAG_BITMAP_SP;
-	smc_ret_values ret;
+	struct ffa_value ret;
 	test_result_t result = TEST_RESULT_SUCCESS;
 
 	/* Variables to validate calls to FFA_NOTIFICATION_INFO_GET. */
@@ -961,7 +962,7 @@
 		return TEST_RESULT_SKIPPED;
 	}
 
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	ret = ffa_notification_info_get();
 
@@ -1265,7 +1266,7 @@
 	const bool exp_more_notif_pending = false;
 	test_result_t result = TEST_RESULT_SUCCESS;
 	uint64_t notifications_to_unbind = 0;
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	CHECK_SPMC_TESTING_SETUP(1, 1, expected_sp_uuids);
 
@@ -1339,7 +1340,7 @@
 	const ffa_id_t sender = SP_ID(1);
 	const ffa_id_t receiver = SP_ID(2);
 	uint32_t get_flags = FFA_NOTIFICATIONS_FLAG_BITMAP_SP;
-	smc_ret_values ret;
+	struct ffa_value ret;
 	test_result_t result = TEST_RESULT_SUCCESS;
 
 	/** Variables to validate calls to FFA_NOTIFICATION_INFO_GET. */
@@ -1431,7 +1432,7 @@
 	const ffa_id_t echo_dest = SP_ID(1);
 	uint32_t echo_dest_cmd_count = 0;
 	uint32_t get_flags = FFA_NOTIFICATIONS_FLAG_BITMAP_SP;
-	smc_ret_values ret;
+	struct ffa_value ret;
 	test_result_t result = TEST_RESULT_SUCCESS;
 
 	/** Variables to validate calls to FFA_NOTIFICATION_INFO_GET. */
diff --git a/tftf/tests/runtime_services/secure_service/test_ffa_secure_interrupts.c b/tftf/tests/runtime_services/secure_service/test_ffa_secure_interrupts.c
index 8ed590a..ac19c06 100644
--- a/tftf/tests/runtime_services/secure_service/test_ffa_secure_interrupts.c
+++ b/tftf/tests/runtime_services/secure_service/test_ffa_secure_interrupts.c
@@ -24,7 +24,7 @@
 static bool configure_trusted_wdog_interrupt(ffa_id_t source, ffa_id_t dest,
 				bool enable)
 {
-	smc_ret_values ret_values;
+	struct ffa_value ret_values;
 
 	ret_values = cactus_interrupt_cmd(source, dest, IRQ_TWDOG_INTID,
 					  enable, INTERRUPT_TYPE_IRQ);
@@ -96,7 +96,7 @@
 
 test_result_t test_ffa_sec_interrupt_sp_running(void)
 {
-	smc_ret_values ret_values;
+	struct ffa_value ret_values;
 
 	CHECK_SPMC_TESTING_SETUP(1, 1, expected_sp_uuids);
 
@@ -200,7 +200,7 @@
 	uint64_t time1;
 	volatile uint64_t time2, time_lapsed;
 	uint64_t timer_freq = read_cntfrq_el0();
-	smc_ret_values ret_values;
+	struct ffa_value ret_values;
 
 	CHECK_SPMC_TESTING_SETUP(1, 1, expected_sp_uuids);
 
@@ -299,7 +299,7 @@
  */
 test_result_t test_ffa_sec_interrupt_sp_blocked(void)
 {
-	smc_ret_values ret_values;
+	struct ffa_value ret_values;
 
 	CHECK_SPMC_TESTING_SETUP(1, 1, expected_sp_uuids);
 
@@ -399,7 +399,7 @@
  */
 test_result_t test_ffa_sec_interrupt_sp1_waiting_sp2_running(void)
 {
-	smc_ret_values ret_values;
+	struct ffa_value ret_values;
 
 	CHECK_SPMC_TESTING_SETUP(1, 1, expected_sp_uuids);
 
diff --git a/tftf/tests/runtime_services/secure_service/test_ffa_setup_and_discovery.c b/tftf/tests/runtime_services/secure_service/test_ffa_setup_and_discovery.c
index 1373adf..ad9da1a 100644
--- a/tftf/tests/runtime_services/secure_service/test_ffa_setup_and_discovery.c
+++ b/tftf/tests/runtime_services/secure_service/test_ffa_setup_and_discovery.c
@@ -76,7 +76,7 @@
 		return TEST_RESULT_SUCCESS;
 	}
 
-	smc_ret_values ffa_ret;
+	struct ffa_value ffa_ret;
 	unsigned int expected_ret;
 	const struct ffa_features_test *ffa_feature_test_target;
 	unsigned int i, test_target_size =
@@ -124,9 +124,9 @@
 		return TEST_RESULT_SKIPPED;
 	}
 
-	smc_ret_values ret_values = ffa_version(input_version);
+	struct ffa_value ret_values = ffa_version(input_version);
 
-	uint32_t spm_version = (uint32_t)(0xFFFFFFFF & ret_values.ret0);
+	uint32_t spm_version = (uint32_t)(0xFFFFFFFF & ret_values.fid);
 
 	if (spm_version == expected_return) {
 		return TEST_RESULT_SUCCESS;
@@ -199,7 +199,7 @@
 
 static test_result_t test_ffa_rxtx_map(uint32_t expected_return)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	/**********************************************************************
 	 * Verify that FFA is there and that it has the correct version.
@@ -246,7 +246,7 @@
 
 static test_result_t test_ffa_rxtx_unmap(uint32_t expected_return)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	/**********************************************************************
 	 * Verify that FFA is there and that it has the correct version.
@@ -309,7 +309,7 @@
 {
 	SKIP_TEST_IF_FFA_VERSION_LESS_THAN(1, 1);
 
-	smc_ret_values ffa_ret = ffa_spm_id_get();
+	struct ffa_value ffa_ret = ffa_spm_id_get();
 
 	if (is_ffa_call_error(ffa_ret)) {
 		ERROR("FFA_SPM_ID_GET call failed! Error code: 0x%x\n",
@@ -381,7 +381,7 @@
 	GET_TFTF_MAILBOX(mb);
 
 	test_result_t result = TEST_RESULT_SUCCESS;
-	smc_ret_values ret = ffa_partition_info_get(null_uuid);
+	struct ffa_value ret = ffa_partition_info_get(null_uuid);
 	uint64_t expected_size = ARRAY_SIZE(ffa_expected_partition_info);
 
 	if (ffa_func_id(ret) == FFA_SUCCESS_SMC32) {
diff --git a/tftf/tests/runtime_services/secure_service/test_spm_cpu_features.c b/tftf/tests/runtime_services/secure_service/test_spm_cpu_features.c
index 655f9d9..4924df4 100644
--- a/tftf/tests/runtime_services/secure_service/test_spm_cpu_features.c
+++ b/tftf/tests/runtime_services/secure_service/test_spm_cpu_features.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2021-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -46,7 +46,7 @@
 	}
 	fill_simd_vector_regs(simd_vectors_send);
 
-	smc_ret_values ret = cactus_req_simd_fill_send_cmd(SENDER, RECEIVER);
+	struct ffa_value ret = cactus_req_simd_fill_send_cmd(SENDER, RECEIVER);
 
 	if (!is_ffa_direct_response(ret)) {
 		return TEST_RESULT_FAIL;
@@ -89,7 +89,7 @@
 
 	fill_sve_vector_regs(sve_vectors_send);
 
-	smc_ret_values ret = cactus_req_simd_fill_send_cmd(SENDER, RECEIVER);
+	struct ffa_value ret = cactus_req_simd_fill_send_cmd(SENDER, RECEIVER);
 
 	if (!is_ffa_direct_response(ret)) {
 		return TEST_RESULT_FAIL;
diff --git a/tftf/tests/runtime_services/secure_service/test_spm_smmu.c b/tftf/tests/runtime_services/secure_service/test_spm_smmu.c
index b041a97..0f0a5d9 100644
--- a/tftf/tests/runtime_services/secure_service/test_spm_smmu.c
+++ b/tftf/tests/runtime_services/secure_service/test_spm_smmu.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Arm Limited. All rights reserved.
+ * Copyright (c) 2021-2022, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
@@ -18,7 +18,7 @@
  **************************************************************************/
 test_result_t test_smmu_spm(void)
 {
-	smc_ret_values ret;
+	struct ffa_value ret;
 
 	/**********************************************************************
 	 * Check SPMC has ffa_version and expected FFA endpoints are deployed.
diff --git a/tftf/tests/tests-invalid-access.mk b/tftf/tests/tests-invalid-access.mk
index b1df9ba..ffca79e 100644
--- a/tftf/tests/tests-invalid-access.mk
+++ b/tftf/tests/tests-invalid-access.mk
@@ -13,7 +13,8 @@
 
 TESTS_SOURCES	+=							\
 	$(addprefix tftf/tests/runtime_services/secure_service/,	\
+		${ARCH}/ffa_arch_helpers.S				\
 		ffa_helpers.c						\
 		spm_common.c						\
 		test_ffa_setup_and_discovery.c				\
-)
\ No newline at end of file
+)
diff --git a/tftf/tests/tests-spm.mk b/tftf/tests/tests-spm.mk
index 941758c..702c10c 100644
--- a/tftf/tests/tests-spm.mk
+++ b/tftf/tests/tests-spm.mk
@@ -1,11 +1,12 @@
 #
-# Copyright (c) 2018-2021, Arm Limited. All rights reserved.
+# Copyright (c) 2018-2022, Arm Limited. All rights reserved.
 #
 # SPDX-License-Identifier: BSD-3-Clause
 #
 
 TESTS_SOURCES	+=							\
 	$(addprefix tftf/tests/runtime_services/secure_service/,	\
+		${ARCH}/ffa_arch_helpers.S				\
 		ffa_helpers.c						\
 		spm_common.c						\
 		test_ffa_direct_messaging.c				\