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,