diff --git a/include/runtime_services/ffa_helpers.h b/include/runtime_services/ffa_helpers.h
index 90bb30f..f265fe8 100644
--- a/include/runtime_services/ffa_helpers.h
+++ b/include/runtime_services/ffa_helpers.h
@@ -641,9 +641,8 @@
 
 uint32_t ffa_memory_retrieve_request_init(
 	struct ffa_memory_region *memory_region, ffa_memory_handle_t handle,
-	ffa_id_t sender, ffa_id_t receiver, uint32_t tag,
-	ffa_memory_region_flags_t flags, enum ffa_data_access data_access,
-	enum ffa_instruction_access instruction_access,
+	ffa_id_t sender, struct ffa_memory_access receivers[],
+	uint32_t receiver_count, uint32_t tag, ffa_memory_region_flags_t flags,
 	enum ffa_memory_type type, enum ffa_memory_cacheability cacheability,
 	enum ffa_memory_shareability shareability);
 
@@ -652,12 +651,12 @@
 
 uint32_t ffa_memory_region_init(
 	struct ffa_memory_region *memory_region, size_t memory_region_max_size,
-	ffa_id_t sender, ffa_id_t receiver,
+	ffa_id_t sender, struct ffa_memory_access receivers[],
+	uint32_t receiver_count,
 	const struct ffa_memory_region_constituent constituents[],
 	uint32_t constituent_count, uint32_t tag,
-	ffa_memory_region_flags_t flags, enum ffa_data_access data_access,
-	enum ffa_instruction_access instruction_access,
-	enum ffa_memory_type type, enum ffa_memory_cacheability cacheability,
+	ffa_memory_region_flags_t flags, enum ffa_memory_type type,
+	enum ffa_memory_cacheability cacheability,
 	enum ffa_memory_shareability shareability, uint32_t *total_length,
 	uint32_t *fragment_length);
 
diff --git a/include/runtime_services/spm_common.h b/include/runtime_services/spm_common.h
index e9c845d..6494947 100644
--- a/include/runtime_services/spm_common.h
+++ b/include/runtime_services/spm_common.h
@@ -109,8 +109,9 @@
  */
 bool memory_retrieve(struct mailbox_buffers *mb,
 		     struct ffa_memory_region **retrieved, uint64_t handle,
-		     ffa_id_t sender, ffa_id_t receiver,
-		     ffa_memory_region_flags_t flags, uint32_t mem_func);
+		     ffa_id_t sender, struct ffa_memory_access receivers[],
+		     uint32_t receiver_count, ffa_memory_region_flags_t flags,
+		     uint32_t mem_func);
 
 bool hypervisor_retrieve_request(struct mailbox_buffers *mb, uint64_t handle,
 				 void *out, uint32_t out_size);
@@ -128,8 +129,9 @@
 
 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,
+	ffa_id_t sender, struct ffa_memory_access receivers[],
+	uint32_t receiver_count,
+	const struct ffa_memory_region_constituent *constituents,
 	uint32_t constituents_count, uint32_t mem_func, struct ffa_value *ret);
 
 bool ffa_partition_info_helper(struct mailbox_buffers *mb,
diff --git a/spm/cactus/cactus_tests/cactus_test_memory_sharing.c b/spm/cactus/cactus_tests/cactus_test_memory_sharing.c
index 294f577..ef49d21 100644
--- a/spm/cactus/cactus_tests/cactus_test_memory_sharing.c
+++ b/spm/cactus/cactus_tests/cactus_test_memory_sharing.c
@@ -81,8 +81,16 @@
 					 cactus_mem_send_get_retrv_flags(*args);
 	uint32_t words_to_write = cactus_mem_send_words_to_write(*args);
 
-	expect(memory_retrieve(mb, &m, handle, source, vm_id,
-			       retrv_flags, mem_func), true);
+	struct ffa_memory_access receiver = ffa_memory_access_init_permissions(
+		vm_id, FFA_DATA_ACCESS_RW,
+		(mem_func == FFA_MEM_SHARE_SMC32)
+			? FFA_INSTRUCTION_ACCESS_NOT_SPECIFIED
+			: FFA_INSTRUCTION_ACCESS_NX,
+		0);
+
+	expect(memory_retrieve(mb, &m, handle, source, &receiver, 1,
+			       retrv_flags, mem_func),
+	       true);
 
 	composite = ffa_memory_region_get_composite(m, 0);
 
@@ -180,7 +188,7 @@
 {
 	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_id_t receiver_id = cactus_req_mem_send_get_receiver(*args);
 	ffa_memory_handle_t handle;
 	ffa_id_t vm_id = ffa_dir_msg_dest(*args);
 	ffa_id_t source = ffa_dir_msg_source(*args);
@@ -190,6 +198,10 @@
 	unsigned int mem_attrs;
 	int ret;
 
+	struct ffa_memory_access receiver =
+		ffa_memory_access_init_permissions_from_mem_func(receiver_id,
+								 mem_func);
+
 	VERBOSE("%x requested to send memory to %x (func: %x), page: %llx\n",
 		source, receiver, mem_func, (uint64_t)share_page_addr);
 
@@ -220,10 +232,10 @@
 					 CACTUS_ERROR_TEST);
 	}
 
-	handle = memory_init_and_send(
-		(struct ffa_memory_region *)mb->send, PAGE_SIZE,
-		vm_id, receiver, constituents,
-		constituents_count, mem_func, &ffa_ret);
+	handle = memory_init_and_send((struct ffa_memory_region *)mb->send,
+				      PAGE_SIZE, vm_id, &receiver, 1,
+				      constituents, constituents_count,
+				      mem_func, &ffa_ret);
 
 	/*
 	 * If returned an invalid handle, we should break the test.
@@ -234,8 +246,8 @@
 					 ffa_error_code(ffa_ret));
 	}
 
-	ffa_ret = cactus_mem_send_cmd(vm_id, receiver, mem_func, handle,
-				      0, 10);
+	ffa_ret = cactus_mem_send_cmd(vm_id, receiver_id, mem_func, handle, 0,
+				      10);
 
 	if (!is_ffa_direct_response(ffa_ret)) {
 		return cactus_error_resp(vm_id, source, CACTUS_ERROR_FFA_CALL);
diff --git a/tftf/tests/misc_tests/test_invalid_access.c b/tftf/tests/misc_tests/test_invalid_access.c
index 343a553..353162b 100644
--- a/tftf/tests/misc_tests/test_invalid_access.c
+++ b/tftf/tests/misc_tests/test_invalid_access.c
@@ -1,9 +1,10 @@
 /*
- * Copyright (c) 2022, Arm Limited. All rights reserved.
+ * Copyright (c) 2022-2023, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
+#include "ffa_helpers.h"
 #include <plat/common/platform.h>
 
 #include <arch.h>
@@ -293,6 +294,10 @@
 	struct mailbox_buffers mb;
 	struct ffa_value ret;
 
+	struct ffa_memory_access receiver =
+		ffa_memory_access_init_permissions_from_mem_func(
+			RECEIVER, FFA_MEM_SHARE_SMC32);
+
 	if (get_armv9_2_feat_rme_support() == 0U) {
 		return TEST_RESULT_SKIPPED;
 	}
@@ -302,9 +307,9 @@
 	GET_TFTF_MAILBOX(mb);
 
 	handle = memory_init_and_send((struct ffa_memory_region *)mb.send,
-					PAGE_SIZE, SENDER, RECEIVER,
-					constituents, constituents_count,
-					FFA_MEM_SHARE_SMC32, &ret);
+				      PAGE_SIZE, SENDER, &receiver, 1,
+				      constituents, constituents_count,
+				      FFA_MEM_SHARE_SMC32, &ret);
 
 	if (handle == FFA_MEMORY_HANDLE_INVALID) {
 		return TEST_RESULT_SUCCESS;
diff --git a/tftf/tests/runtime_services/secure_service/ffa_helpers.c b/tftf/tests/runtime_services/secure_service/ffa_helpers.c
index e5f93f1..82413a2 100644
--- a/tftf/tests/runtime_services/secure_service/ffa_helpers.c
+++ b/tftf/tests/runtime_services/secure_service/ffa_helpers.c
@@ -142,16 +142,12 @@
 	return ffa_service_call(&args);
 }
 
-
-/**
- * Initialises the header of the given `ffa_memory_region`, not including the
- * composite memory region offset.
- */
-static void ffa_memory_region_init_header(
-	struct ffa_memory_region *memory_region, ffa_id_t sender,
-	ffa_memory_attributes_t attributes, ffa_memory_region_flags_t flags,
-	ffa_memory_handle_t handle, uint32_t tag, ffa_id_t receiver,
-	ffa_memory_access_permissions_t permissions)
+void ffa_memory_region_init_header(struct ffa_memory_region *memory_region,
+				   ffa_id_t sender,
+				   ffa_memory_attributes_t attributes,
+				   ffa_memory_region_flags_t flags,
+				   ffa_memory_handle_t handle, uint32_t tag,
+				   uint32_t receiver_count)
 {
 	memory_region->sender = sender;
 	memory_region->attributes = attributes;
@@ -160,66 +156,47 @@
 	memory_region->tag = tag;
 	memory_region->memory_access_desc_size =
 		sizeof(struct ffa_memory_access);
-	memory_region->receiver_count = 1;
-	memory_region->receivers[0].receiver_permissions.receiver = receiver;
-	memory_region->receivers[0].receiver_permissions.permissions =
-		permissions;
-	memory_region->receivers[0].receiver_permissions.flags = 0;
-	memory_region->receivers[0].reserved_0 = 0;
-	/* Receivers at the end of the `ffa_memory_region` structure. */
-	memory_region->receivers_offset = sizeof(struct ffa_memory_region);
+	memory_region->receiver_count = receiver_count;
+	memory_region->receivers_offset =
+		offsetof(struct ffa_memory_region, receivers);
 	memset(memory_region->reserved, 0, sizeof(memory_region->reserved));
 }
 
 /**
- * Initialises the given `ffa_memory_region` and copies as many as possible of
- * the given constituents to it.
+ * Copies as many as possible of the given constituents to the respective
+ * memory region and sets the respective offset.
  *
  * Returns the number of constituents remaining which wouldn't fit, and (via
  * return parameters) the size in bytes of the first fragment of data copied to
  * `memory_region` (attributes, constituents and memory region header size), and
  * the total size of the memory sharing message including all constituents.
  */
-uint32_t ffa_memory_region_init(
+static uint32_t ffa_memory_region_init_constituents(
 	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 constituent_count, uint32_t tag,
-	ffa_memory_region_flags_t flags, enum ffa_data_access data_access,
-	enum ffa_instruction_access instruction_access,
-	enum ffa_memory_type type, enum ffa_memory_cacheability cacheability,
-	enum ffa_memory_shareability shareability, uint32_t *total_length,
+	uint32_t constituent_count, uint32_t *total_length,
 	uint32_t *fragment_length)
 {
 	struct ffa_composite_memory_region *composite_memory_region;
 	uint32_t fragment_max_constituents;
-	uint32_t count_to_copy;
-	uint32_t i;
 	uint32_t constituents_offset;
+	uint32_t count_to_copy;
 
-	ffa_memory_access_permissions_t permissions = {
-		.data_access = data_access,
-		.instruction_access = instruction_access,
-	};
-	ffa_memory_attributes_t attributes = {
-		.type = type,
-		.cacheability = cacheability,
-		.shareability = shareability,
-	};
-
-	ffa_memory_region_init_header(memory_region, sender, attributes, flags,
-				      0, tag, receiver, permissions);
 	/*
 	 * Note that `sizeof(struct_ffa_memory_region)` and `sizeof(struct
 	 * ffa_memory_access)` must both be multiples of 16 (as verified by the
 	 * asserts in `ffa_memory.c`, so it is guaranteed that the offset we
 	 * calculate here is aligned to a 64-bit boundary and so 64-bit values
 	 * can be copied without alignment faults.
+	 * If there are multiple receiver endpoints, their respective access
+	 * structure should point to the same offset value.
 	 */
-	memory_region->receivers[0].composite_memory_region_offset =
-		sizeof(struct ffa_memory_region) +
-		memory_region->receiver_count *
-			sizeof(struct ffa_memory_access);
+	for (uint32_t i = 0; i < memory_region->receiver_count; i++) {
+		memory_region->receivers[i].composite_memory_region_offset =
+			sizeof(struct ffa_memory_region) +
+			memory_region->receiver_count *
+				sizeof(struct ffa_memory_access);
+	}
 
 	composite_memory_region =
 		ffa_memory_region_get_composite(memory_region, 0);
@@ -239,7 +216,7 @@
 		count_to_copy = fragment_max_constituents;
 	}
 
-	for (i = 0; i < constituent_count; ++i) {
+	for (uint32_t i = 0; i < constituent_count; ++i) {
 		if (i < count_to_copy) {
 			composite_memory_region->constituents[i] =
 				constituents[i];
@@ -267,22 +244,25 @@
 /**
  * Initialises the given `ffa_memory_region` to be used for an
  * `FFA_MEM_RETRIEVE_REQ` by the receiver of a memory transaction.
+ * Initialises the given `ffa_memory_region` and copies as many as possible of
+ * the given constituents to it.
  *
- * Returns the size of the message written.
+ * Returns the number of constituents remaining which wouldn't fit, and (via
+ * return parameters) the size in bytes of the first fragment of data copied to
+ * `memory_region` (attributes, constituents and memory region header size), and
+ * the total size of the memory sharing message including all constituents.
  */
-uint32_t ffa_memory_retrieve_request_init(
-	struct ffa_memory_region *memory_region, ffa_memory_handle_t handle,
-	ffa_id_t sender, ffa_id_t receiver, uint32_t tag,
-	ffa_memory_region_flags_t flags, enum ffa_data_access data_access,
-	enum ffa_instruction_access instruction_access,
-	enum ffa_memory_type type, enum ffa_memory_cacheability cacheability,
-	enum ffa_memory_shareability shareability)
+uint32_t ffa_memory_region_init(
+	struct ffa_memory_region *memory_region, size_t memory_region_max_size,
+	ffa_id_t sender, struct ffa_memory_access receivers[],
+	uint32_t receiver_count,
+	const struct ffa_memory_region_constituent constituents[],
+	uint32_t constituent_count, uint32_t tag,
+	ffa_memory_region_flags_t flags, enum ffa_memory_type type,
+	enum ffa_memory_cacheability cacheability,
+	enum ffa_memory_shareability shareability, uint32_t *total_length,
+	uint32_t *fragment_length)
 {
-	ffa_memory_access_permissions_t permissions = {
-		.data_access = data_access,
-		.instruction_access = instruction_access,
-	};
-
 	ffa_memory_attributes_t attributes = {
 		.type = type,
 		.cacheability = cacheability,
@@ -290,14 +270,50 @@
 	};
 
 	ffa_memory_region_init_header(memory_region, sender, attributes, flags,
-					handle, tag, receiver, permissions);
+				      0, tag, receiver_count);
+
+	memcpy(memory_region->receivers, receivers,
+	       receiver_count * sizeof(struct ffa_memory_access));
+
+	return ffa_memory_region_init_constituents(
+		memory_region, memory_region_max_size, constituents,
+		constituent_count, total_length, fragment_length);
+}
+
+/**
+ * Initialises the given `ffa_memory_region` to be used for an
+ * `FFA_MEM_RETRIEVE_REQ` by the receiver of a memory transaction.
+ *
+ * Returns the size of the message written.
+ */
+uint32_t ffa_memory_retrieve_request_init(
+	struct ffa_memory_region *memory_region, ffa_memory_handle_t handle,
+	ffa_id_t sender, struct ffa_memory_access receivers[],
+	uint32_t receiver_count, uint32_t tag, ffa_memory_region_flags_t flags,
+	enum ffa_memory_type type, enum ffa_memory_cacheability cacheability,
+	enum ffa_memory_shareability shareability)
+{
+	ffa_memory_attributes_t attributes = {
+		.type = type,
+		.cacheability = cacheability,
+		.shareability = shareability,
+	};
+
+	ffa_memory_region_init_header(memory_region, sender, attributes, flags,
+				      handle, tag, receiver_count);
+
+	memcpy(memory_region->receivers, receivers,
+	       receiver_count * sizeof(struct ffa_memory_access));
+
 	/*
 	 * Offset 0 in this case means that the hypervisor should allocate the
 	 * address ranges. This is the only configuration supported by Hafnium,
 	 * as it enforces 1:1 mappings in the stage 2 page tables.
 	 */
-	memory_region->receivers[0].composite_memory_region_offset = 0;
-	memory_region->receivers[0].reserved_0 = 0;
+	for (uint32_t i = 0; i < receiver_count; i++) {
+		memory_region->receivers[i].composite_memory_region_offset = 0;
+		memory_region->receivers[i].reserved_0 = 0;
+	}
 
 	return sizeof(struct ffa_memory_region) +
 	       memory_region->receiver_count * sizeof(struct ffa_memory_access);
diff --git a/tftf/tests/runtime_services/secure_service/spm_common.c b/tftf/tests/runtime_services/secure_service/spm_common.c
index c4323e0..e75be35 100644
--- a/tftf/tests/runtime_services/secure_service/spm_common.c
+++ b/tftf/tests/runtime_services/secure_service/spm_common.c
@@ -211,18 +211,14 @@
 
 bool memory_retrieve(struct mailbox_buffers *mb,
 		     struct ffa_memory_region **retrieved, uint64_t handle,
-		     ffa_id_t sender, ffa_id_t receiver,
-		     ffa_memory_region_flags_t flags,
+		     ffa_id_t sender, struct ffa_memory_access receivers[],
+		     uint32_t receiver_count, ffa_memory_region_flags_t flags,
 		     uint32_t mem_func)
 {
 	struct ffa_value ret;
 	uint32_t fragment_size;
 	uint32_t total_size;
 	uint32_t descriptor_size;
-	const enum ffa_instruction_access inst_access =
-				(mem_func == FFA_MEM_SHARE_SMC32)
-					? FFA_INSTRUCTION_ACCESS_NOT_SPECIFIED
-					: FFA_INSTRUCTION_ACCESS_NX;
 
 	if (retrieved == NULL || mb == NULL) {
 		ERROR("Invalid parameters!\n");
@@ -230,12 +226,9 @@
 	}
 
 	descriptor_size = ffa_memory_retrieve_request_init(
-	    mb->send, handle, sender, receiver, 0, flags,
-	    FFA_DATA_ACCESS_RW,
-	    inst_access,
-	    FFA_MEMORY_NORMAL_MEM,
-	    FFA_MEMORY_CACHE_WRITE_BACK,
-	    FFA_MEMORY_INNER_SHAREABLE);
+		mb->send, handle, sender, receivers, receiver_count, 0, flags,
+		FFA_MEMORY_NORMAL_MEM, FFA_MEMORY_CACHE_WRITE_BACK,
+		FFA_MEMORY_INNER_SHAREABLE);
 
 	ret = ffa_mem_retrieve_req(descriptor_size, descriptor_size);
 
@@ -422,7 +415,8 @@
  */
 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,
+	ffa_id_t sender, struct ffa_memory_access receivers[],
+	uint32_t receiver_count,
 	const struct ffa_memory_region_constituent *constituents,
 	uint32_t constituents_count, uint32_t mem_func, struct ffa_value *ret)
 {
@@ -430,23 +424,14 @@
 	uint32_t total_length;
 	uint32_t fragment_length;
 
-	enum ffa_data_access data_access = (mem_func == FFA_MEM_DONATE_SMC32) ?
-						FFA_DATA_ACCESS_NOT_SPECIFIED :
-						FFA_DATA_ACCESS_RW;
+	enum ffa_memory_type type =
+		(receiver_count == 1 && mem_func != FFA_MEM_SHARE_SMC32)
+			? FFA_MEMORY_NOT_SPECIFIED_MEM
+			: FFA_MEMORY_NORMAL_MEM;
 
-	/*
-	 * Initialize memory region structure for the respective memory send
-	 * operation. Note that memory type shall only be specified for memory
-	 * share, for memory lend and memory donate these shall remain
-	 * unspecified.
-	 */
 	remaining_constituent_count = ffa_memory_region_init(
-		memory_region, memory_region_max_size, sender, receiver, constituents,
-		constituents_count, 0, 0, data_access,
-		FFA_INSTRUCTION_ACCESS_NOT_SPECIFIED,
-		mem_func == FFA_MEM_SHARE_SMC32
-			? FFA_MEMORY_NORMAL_MEM
-			: FFA_MEMORY_NOT_SPECIFIED_MEM,
+		memory_region, memory_region_max_size, sender, receivers,
+		receiver_count, constituents, constituents_count, 0, 0, type,
 		FFA_MEMORY_CACHE_WRITE_BACK, FFA_MEMORY_INNER_SHAREABLE,
 		&total_length, &fragment_length);
 
@@ -460,7 +445,7 @@
 	}
 
 	return memory_send(memory_region, mem_func, fragment_length,
-			       total_length, ret);
+			   total_length, ret);
 }
 
 static bool ffa_uuid_equal(const struct ffa_uuid uuid1,
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 5cb6dd4..6b16da4 100644
--- a/tftf/tests/runtime_services/secure_service/test_ffa_exceptions.c
+++ b/tftf/tests/runtime_services/secure_service/test_ffa_exceptions.c
@@ -1,10 +1,11 @@
 /*
- * Copyright (c) 2022, Arm Limited. All rights reserved.
+ * Copyright (c) 2022-2023, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
 
 #include <arch_helpers.h>
+#include "ffa_helpers.h"
 #include <cactus_test_cmds.h>
 #include <debug.h>
 #include <ffa_endpoints.h>
@@ -51,6 +52,10 @@
 	struct ffa_value ret;
 	u_register_t retmm;
 
+	struct ffa_memory_access receiver =
+		ffa_memory_access_init_permissions_from_mem_func(
+			RECEIVER, FFA_MEM_SHARE_SMC32);
+
 	if (get_armv9_2_feat_rme_support() == 0U) {
 		return TEST_RESULT_SKIPPED;
 	}
@@ -60,9 +65,9 @@
 	GET_TFTF_MAILBOX(mb);
 
 	handle = memory_init_and_send((struct ffa_memory_region *)mb.send,
-					PAGE_SIZE, SENDER, RECEIVER,
-					constituents, constituents_count,
-					FFA_MEM_SHARE_SMC32, &ret);
+				      PAGE_SIZE, SENDER, &receiver, 1,
+				      constituents, constituents_count,
+				      FFA_MEM_SHARE_SMC32, &ret);
 
 	if (handle == FFA_MEMORY_HANDLE_INVALID) {
 		return TEST_RESULT_FAIL;
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 5b80825..42e1948 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
@@ -56,10 +56,15 @@
 
 	const uint32_t constituents_count = sizeof(constituents) /
 			sizeof(struct ffa_memory_region_constituent);
+
+	struct ffa_memory_access receiver =
+		ffa_memory_access_init_permissions_from_mem_func(borrower,
+								 mem_func);
+
 	GET_TFTF_MAILBOX(mb);
 
 	handle = memory_init_and_send((struct ffa_memory_region *)mb.send,
-					MAILBOX_SIZE, SENDER, borrower,
+					MAILBOX_SIZE, SENDER, &receiver, 1,
 					constituents, constituents_count,
 					mem_func, &ret);
 
@@ -134,6 +139,10 @@
 	/* Arbitrarily write 5 words after using memory. */
 	const uint32_t nr_words_to_write = 5;
 
+	struct ffa_memory_access receiver =
+		ffa_memory_access_init_permissions_from_mem_func(borrower,
+								 mem_func);
+
 	/***********************************************************************
 	 * Check if SPMC has ffa_version and expected FFA endpoints are deployed.
 	 **********************************************************************/
@@ -150,7 +159,7 @@
 	}
 
 	handle = memory_init_and_send((struct ffa_memory_region *)mb.send,
-					MAILBOX_SIZE, SENDER, borrower,
+					MAILBOX_SIZE, SENDER, &receiver, 1,
 					constituents, constituents_count,
 					mem_func, &ret);
 
@@ -404,15 +413,18 @@
 	/* Arbitrarily write 10 words after using shared memory. */
 	const uint32_t nr_words_to_write = 10U;
 
+	struct ffa_memory_access receiver =
+		ffa_memory_access_init_permissions_from_mem_func(
+			RECEIVER, FFA_MEM_LEND_SMC32);
+
 	CHECK_SPMC_TESTING_SETUP(1, 1, expected_sp_uuids);
 
 	GET_TFTF_MAILBOX(mb);
 
 	remaining_constituent_count = ffa_memory_region_init(
 		(struct ffa_memory_region *)mb.send, MAILBOX_SIZE, SENDER,
-		RECEIVER, constituents, constituents_count, 0,
-		FFA_MEMORY_REGION_FLAG_CLEAR, FFA_DATA_ACCESS_RW,
-		FFA_INSTRUCTION_ACCESS_NOT_SPECIFIED,
+		&receiver, 1, constituents, constituents_count, 0,
+		FFA_MEMORY_REGION_FLAG_CLEAR,
 		FFA_MEMORY_NOT_SPECIFIED_MEM, 0, 0,
 		&total_length, &fragment_length);
 
@@ -644,6 +656,9 @@
 				: FFA_MEMORY_NORMAL_MEM,
 	};
 
+	struct ffa_memory_access receiver =
+		ffa_memory_access_init_permissions_from_mem_func(SP_ID(1), mem_func);
+
 	CHECK_SPMC_TESTING_SETUP(1, 2, expected_sp_uuids);
 	GET_TFTF_MAILBOX(mb);
 
@@ -662,7 +677,7 @@
 		panic();
 	}
 
-	handle = memory_init_and_send(mb.send, MAILBOX_SIZE, SENDER, RECEIVER,
+	handle = memory_init_and_send(mb.send, MAILBOX_SIZE, SENDER, &receiver, 1,
 				      sent_constituents,
 				      sent_constituents_count, mem_func, &ret);
 	if (handle == FFA_MEMORY_HANDLE_INVALID) {