diff --git a/include/runtime_services/host_realm_managment/host_shared_data.h b/include/runtime_services/host_realm_managment/host_shared_data.h
index adf898b..5f58887 100644
--- a/include/runtime_services/host_realm_managment/host_shared_data.h
+++ b/include/runtime_services/host_realm_managment/host_shared_data.h
@@ -36,8 +36,9 @@
 
 	/* Buffer to save Realm command results */
 	uint8_t realm_cmd_output_buffer[REALM_CMD_BUFFER_SIZE];
-} host_shared_data_t;
+}host_shared_data_t;
 
+typedef host_shared_data_t (*host_shared_data_arr_t)[MAX_PLANE_COUNT][MAX_REC_COUNT];
 /*
  * Different commands that the Host can requests the Realm to perform
  */
@@ -100,25 +101,34 @@
 /*
  * Return shared buffer pointer mapped as host_shared_data_t structure
  */
-host_shared_data_t *host_get_shared_structure(struct realm *realm_ptr, unsigned int rec_num);
+host_shared_data_t *host_get_shared_structure(struct realm *realm_ptr,
+					      unsigned int plane_num,
+					      unsigned int rec_num);
 
 /*
  * Set data to be shared from Host to realm
  */
 void host_shared_data_set_host_val(struct realm *realm_ptr,
-		unsigned int rec_num, uint8_t index, u_register_t val);
+				   unsigned int plane_num,
+				   unsigned int rec_num,
+				   uint8_t index,
+				   u_register_t val);
 
 /*
  * Get data shared from realm to Host
  */
 u_register_t host_shared_data_get_realm_val(struct realm *realm_ptr,
-		unsigned int rec_num, uint8_t index);
+					    unsigned int plane_num,
+					    unsigned int rec_num,
+					    uint8_t index);
 
 /*
  * Set command to be send from Host to realm
  */
-void host_shared_data_set_realm_cmd(struct realm *realm_ptr, uint8_t cmd,
-		unsigned int rec_num);
+void host_shared_data_set_realm_cmd(struct realm *realm_ptr,
+				    uint8_t cmd,
+				    unsigned int plane_num,
+				    unsigned int rec_num);
 
 
 /****************************************
@@ -128,7 +138,7 @@
 /*
  * Set guest mapped shared buffer pointer
  */
-void realm_set_shared_structure(host_shared_data_t *ptr);
+void realm_set_shared_structure(u_register_t ptr);
 
 /*
  * Get guest mapped shared buffer pointer
@@ -150,4 +160,28 @@
  */
 void realm_shared_data_set_my_realm_val(uint8_t index, u_register_t val);
 
+/*
+ * Set data to be shared from Host/Plane0 to Plane N
+ */
+void realm_shared_data_set_plane_n_val(unsigned int plane_num,
+		unsigned int rec_num, uint8_t index, u_register_t val);
+
+/*
+ * Get data shared from Host/Plane0 to Plane N
+ */
+u_register_t realm_shared_data_get_plane_n_val(unsigned int plane_num,
+		unsigned int rec_num, uint8_t index);
+/*
+ * Get cmd shared from Host/Plane0 to Plane N
+ */
+u_register_t realm_shared_data_get_plane_n_cmd(unsigned int plane_num,
+		unsigned int rec_num, uint8_t index);
+
+/*
+ * Set command to be send from Host/Plane0 to Plane N
+ */
+void realm_shared_data_set_plane_n_cmd(uint8_t cmd,
+		 unsigned int plane_num,
+		unsigned int rec_num);
+
 #endif /* HOST_SHARED_DATA_H */
diff --git a/realm/realm_payload_main.c b/realm/realm_payload_main.c
index eb4c9aa..2556c11 100644
--- a/realm/realm_payload_main.c
+++ b/realm/realm_payload_main.c
@@ -270,7 +270,7 @@
 	/* No serror handler registered by default */
 	unregister_custom_serror_handler();
 
-	realm_set_shared_structure((host_shared_data_t *)realm_get_ns_buffer());
+	realm_set_shared_structure(realm_get_ns_buffer());
 
 	if (realm_get_my_shared_structure() != NULL) {
 		uint8_t cmd = realm_shared_data_get_my_realm_cmd();
diff --git a/realm/realm_shared_data.c b/realm/realm_shared_data.c
index db66520..c52072e 100644
--- a/realm/realm_shared_data.c
+++ b/realm/realm_shared_data.c
@@ -9,6 +9,7 @@
 #include <assert.h>
 #include <host_shared_data.h>
 #include <realm_def.h>
+#include <realm_helpers.h>
 
 /**
  *   @brief    - Returns the base address of the shared region
@@ -16,14 +17,14 @@
  *   @return   - Base address of the shared region
  **/
 
-static host_shared_data_t *guest_shared_data;
+static host_shared_data_arr_t guest_shared_data;
 
 /*
  * Set guest mapped shared buffer pointer
  */
-void realm_set_shared_structure(host_shared_data_t *ptr)
+void realm_set_shared_structure(u_register_t ptr)
 {
-	guest_shared_data = ptr;
+	guest_shared_data = (host_shared_data_arr_t)ptr;
 }
 
 /*
@@ -31,7 +32,7 @@
  */
 host_shared_data_t *realm_get_my_shared_structure(void)
 {
-	return &guest_shared_data[REC_IDX(read_mpidr_el1())];
+	return &(*guest_shared_data)[realm_get_my_plane_num()][REC_IDX(read_mpidr_el1())];
 }
 
 /*
@@ -40,7 +41,7 @@
 u_register_t realm_shared_data_get_my_host_val(uint8_t index)
 {
 	assert(index < MAX_DATA_SIZE);
-	return guest_shared_data[REC_IDX(read_mpidr_el1())].host_param_val[index];
+	return (*guest_shared_data)[realm_get_my_plane_num()][REC_IDX(read_mpidr_el1())].host_param_val[index];
 }
 
 /*
@@ -48,7 +49,7 @@
  */
 uint8_t realm_shared_data_get_my_realm_cmd(void)
 {
-	return guest_shared_data[REC_IDX(read_mpidr_el1())].realm_cmd;
+	return (*guest_shared_data)[realm_get_my_plane_num()][REC_IDX(read_mpidr_el1())].realm_cmd;
 }
 
 /*
@@ -57,5 +58,45 @@
 void realm_shared_data_set_my_realm_val(uint8_t index, u_register_t val)
 {
 	assert(index < MAX_DATA_SIZE);
-	guest_shared_data[REC_IDX(read_mpidr_el1())].realm_out_val[index] = val;
+	(*guest_shared_data)[realm_get_my_plane_num()][REC_IDX(read_mpidr_el1())].realm_out_val[index] = val;
+}
+
+void realm_shared_data_set_plane_n_val(unsigned int plane_num, unsigned int rec_num,
+		uint8_t index, u_register_t val)
+{
+	assert(index < MAX_DATA_SIZE);
+	assert(plane_num < MAX_PLANE_COUNT);
+	assert(rec_num < MAX_REC_COUNT);
+	assert(is_plane0);
+
+	(*guest_shared_data)[plane_num][rec_num].realm_out_val[index] = val;
+}
+
+u_register_t realm_shared_data_get_plane_n_val(unsigned int plane_num,
+		unsigned int rec_num, uint8_t index)
+{
+	assert(plane_num < MAX_PLANE_COUNT);
+	assert(rec_num < MAX_REC_COUNT);
+	assert(is_plane0);
+
+	return (*guest_shared_data)[plane_num][rec_num].realm_out_val[index];
+}
+
+u_register_t realm_shared_data_get_plane_n_cmd(unsigned int plane_num,
+		unsigned int rec_num, uint8_t index)
+{
+	assert(plane_num < MAX_PLANE_COUNT);
+	assert(rec_num < MAX_REC_COUNT);
+	assert(is_plane0);
+
+	return (*guest_shared_data)[plane_num][rec_num].realm_cmd;
+}
+
+void realm_shared_data_set_plane_n_cmd(uint8_t cmd, unsigned int plane_num, unsigned int rec_num)
+{
+	assert(plane_num < MAX_PLANE_COUNT);
+	assert(rec_num < MAX_REC_COUNT);
+	assert(is_plane0);
+
+	(*guest_shared_data)[plane_num][rec_num].realm_cmd = cmd;
 }
diff --git a/tftf/tests/runtime_services/host_realm_managment/host_realm_helper.c b/tftf/tests/runtime_services/host_realm_managment/host_realm_helper.c
index 1fed7cf..553bda1 100644
--- a/tftf/tests/runtime_services/host_realm_managment/host_realm_helper.c
+++ b/tftf/tests/runtime_services/host_realm_managment/host_realm_helper.c
@@ -52,7 +52,7 @@
 	char *log_buffer;
 
 	assert(realm_ptr != NULL);
-	host_shared_data = host_get_shared_structure(realm_ptr, rec_num);
+	host_shared_data = host_get_shared_structure(realm_ptr, plane_num, rec_num);
 	log_buffer = (char *)host_shared_data->log_buffer;
 	str_len = strlen((const char *)log_buffer);
 
@@ -69,21 +69,6 @@
 	}
 }
 
-/*
- * Initialisation function which will clear the shared region,
- * and try to find another CPU other than the lead one to
- * handle the Realm message logging.
- */
-static void host_init_realm_print_buffer(struct realm *realm_ptr)
-{
-	host_shared_data_t *host_shared_data;
-
-	for (unsigned int i = 0U; i < realm_ptr->rec_count; i++) {
-		host_shared_data = host_get_shared_structure(realm_ptr, i);
-		(void)memset((char *)host_shared_data, 0, sizeof(host_shared_data_t));
-	}
-}
-
 static bool host_enter_realm(struct realm *realm_ptr,
 			     u_register_t *exit_reason,
 			     unsigned int *host_call_result,
@@ -130,7 +115,6 @@
 	memset((void *)ns_shared_mem_adr, 0, (size_t)NS_REALM_SHARED_MEM_SIZE);
 	realm_ptr->host_shared_data = ns_shared_mem_adr;
 	realm_ptr->shared_mem_created = true;
-	host_init_realm_print_buffer(realm_ptr);
 
 	return true;
 }
@@ -434,7 +418,7 @@
 		ERROR("Invalid Rec Count\n");
 		return false;
 	}
-	host_shared_data_set_realm_cmd(realm_ptr, cmd, rec_num);
+	host_shared_data_set_realm_cmd(realm_ptr, cmd, PRIMARY_PLANE_ID, rec_num);
 	if (!host_enter_realm(realm_ptr, &realm_exit_reason, &host_call_result, rec_num)) {
 		return false;
 	}
diff --git a/tftf/tests/runtime_services/host_realm_managment/host_realm_rmi.c b/tftf/tests/runtime_services/host_realm_managment/host_realm_rmi.c
index 7b49f2a..337f2ab 100644
--- a/tftf/tests/runtime_services/host_realm_managment/host_realm_rmi.c
+++ b/tftf/tests/runtime_services/host_realm_managment/host_realm_rmi.c
@@ -1340,25 +1340,74 @@
 					u_register_t ns_shared_mem_adr,
 					u_register_t ns_shared_mem_size)
 {
-	u_register_t i = 0UL;
 	u_register_t ret;
 
 	realm->ipa_ns_buffer = ns_shared_mem_adr |
 			(1UL << (EXTRACT(RMI_FEATURE_REGISTER_0_S2SZ,
 			realm->rmm_feat_reg0) - 1));
 	realm->ns_buffer_size = ns_shared_mem_size;
+
 	/* MAP SHARED_NS region */
-	while (i < ns_shared_mem_size / PAGE_SIZE) {
-		ret = host_realm_map_unprotected(realm, ns_shared_mem_adr +
-						 (i * PAGE_SIZE), PAGE_SIZE);
+	for (unsigned int i = 0U; i < ns_shared_mem_size / PAGE_SIZE; i++) {
+		ret = host_realm_map_unprotected(realm,
+				ns_shared_mem_adr + (i * PAGE_SIZE),
+				PAGE_SIZE);
+
 		if (ret != RMI_SUCCESS) {
 			ERROR("%s() failed, par_base=0x%lx ret=0x%lx\n",
 				"host_realm_map_unprotected",
-				(ns_shared_mem_adr + i * PAGE_SIZE), ret);
+				(ns_shared_mem_adr + (i * PAGE_SIZE)), ret);
 			return REALM_ERROR;
 		}
-		i++;
 	}
+
+	/* AUX MAP NS buffer for all RTTs */
+	if (!realm->rtt_tree_single) {
+		for (unsigned int i = 0U; i < ns_shared_mem_size / PAGE_SIZE; i++) {
+			for (unsigned int j = 0U; j < realm->num_aux_planes; j++) {
+				u_register_t fail_index, level_pri, state;
+
+				ret = host_rmi_rtt_aux_map_unprotected(realm->rd,
+						realm->ipa_ns_buffer + (i * PAGE_SIZE),
+						j + 1, &fail_index, &level_pri, &state);
+
+				if (ret == RMI_SUCCESS) {
+					continue;
+				} else if (RMI_RETURN_STATUS(ret) == RMI_ERROR_RTT_AUX) {
+
+					/* Create Level and retry */
+					int8_t ulevel = RMI_RETURN_INDEX(ret);
+					long level = (long)ulevel;
+
+					ret = host_realm_create_rtt_aux_levels(realm,
+							realm->ipa_ns_buffer +
+							(i * PAGE_SIZE),
+							level, 3, j + 1);
+
+					if (ret != RMI_SUCCESS) {
+						return REALM_ERROR;
+					}
+
+					ret = host_rmi_rtt_aux_map_unprotected(realm->rd,
+							realm->ipa_ns_buffer +
+							(i * PAGE_SIZE),
+							j + 1, &fail_index,
+							&level_pri, &state);
+
+					if (ret == RMI_SUCCESS) {
+						continue;
+					}
+				}
+
+				ERROR("%s() failed, par_base=0x%lx ret=0x%lx\n",
+						"host_realm_aux_map_unprotected",
+						(ns_shared_mem_adr), ret);
+				return REALM_ERROR;
+
+			}
+		}
+	}
+
 	return REALM_SUCCESS;
 }
 
diff --git a/tftf/tests/runtime_services/host_realm_managment/host_shared_data.c b/tftf/tests/runtime_services/host_realm_managment/host_shared_data.c
index b3bfdae..eb75028 100644
--- a/tftf/tests/runtime_services/host_realm_managment/host_shared_data.c
+++ b/tftf/tests/runtime_services/host_realm_managment/host_shared_data.c
@@ -11,69 +11,65 @@
 #include <host_realm_rmi.h>
 #include <host_shared_data.h>
 
-/*
- * Currently we support only creation of a single Realm in TFTF.
- * Hence we can assume that Shared area should be sufficient for all
- * the RECs of this Realm.
- */
-CASSERT(NS_REALM_SHARED_MEM_SIZE > (MAX_REC_COUNT *
+CASSERT(NS_REALM_SHARED_MEM_SIZE > (MAX_REC_COUNT * MAX_PLANE_COUNT *
 				sizeof(host_shared_data_t)),
 		too_small_realm_shared_mem_size);
 
 /*
  * Return shared buffer pointer mapped as host_shared_data_t structure
  */
-host_shared_data_t *host_get_shared_structure(struct realm *realm_ptr, unsigned int rec_num)
+host_shared_data_t *host_get_shared_structure(struct realm *realm_ptr,
+		unsigned int plane_num, unsigned int rec_num)
 {
-	host_shared_data_t *host_shared_data;
+	host_shared_data_arr_t host_shared_data;
 
 	assert(realm_ptr != NULL);
 	assert(rec_num < MAX_REC_COUNT);
-	host_shared_data = (host_shared_data_t *)realm_ptr->host_shared_data;
-	return &host_shared_data[rec_num];
+	host_shared_data = (host_shared_data_arr_t)realm_ptr->host_shared_data;
+	return (host_shared_data_t *)&(*host_shared_data)[plane_num][rec_num];
 }
 
 /*
  * Set data to be shared from Host to realm
  */
 void host_shared_data_set_host_val(struct realm *realm_ptr,
-		unsigned int rec_num, uint8_t index, u_register_t val)
+		unsigned int plane_num, unsigned int rec_num, uint8_t index, u_register_t val)
 {
-	host_shared_data_t *host_shared_data;
+	host_shared_data_arr_t host_shared_data;
 
 	assert(realm_ptr != NULL);
 	assert(rec_num < MAX_REC_COUNT);
 	assert(index < MAX_DATA_SIZE);
-	host_shared_data = (host_shared_data_t *)realm_ptr->host_shared_data;
-	host_shared_data[rec_num].host_param_val[index] = val;
+	host_shared_data = (host_shared_data_arr_t)realm_ptr->host_shared_data;
+	(*host_shared_data)[plane_num][rec_num].host_param_val[index] = val;
 }
 
 /*
  * Return data shared by realm in realm_out_val.
  */
 u_register_t host_shared_data_get_realm_val(struct realm *realm_ptr,
-		unsigned int rec_num, uint8_t index)
+		unsigned int plane_num, unsigned int rec_num, uint8_t index)
 {
-	host_shared_data_t *host_shared_data;
+	host_shared_data_arr_t host_shared_data;
 
 	assert(realm_ptr != NULL);
 	assert(rec_num < MAX_REC_COUNT);
 	assert(index < MAX_DATA_SIZE);
-	host_shared_data = (host_shared_data_t *)realm_ptr->host_shared_data;
-	return host_shared_data[rec_num].realm_out_val[index];
+	host_shared_data = (host_shared_data_arr_t)realm_ptr->host_shared_data;
+	return (*host_shared_data)[plane_num][rec_num].realm_out_val[index];
 }
 
 /*
  * Set command to be send from Host to realm
  */
 void host_shared_data_set_realm_cmd(struct realm *realm_ptr,
-		uint8_t cmd, unsigned int rec_num)
+		uint8_t cmd, unsigned int plane_num, unsigned int rec_num)
 {
-	host_shared_data_t *host_shared_data;
+	host_shared_data_arr_t host_shared_data;
 
 	assert(realm_ptr != NULL);
 	assert(rec_num < MAX_REC_COUNT);
-	host_shared_data = (host_shared_data_t *)realm_ptr->host_shared_data;
-	host_shared_data[rec_num].realm_cmd = cmd;
+	host_shared_data = (host_shared_data_arr_t)realm_ptr->host_shared_data;
+	(*host_shared_data)[plane_num][rec_num].realm_cmd = cmd;
 }
 
diff --git a/tftf/tests/runtime_services/realm_payload/host_realm_payload_multiple_rec_tests.c b/tftf/tests/runtime_services/realm_payload/host_realm_payload_multiple_rec_tests.c
index 151e871..2aeca64 100644
--- a/tftf/tests/runtime_services/realm_payload/host_realm_payload_multiple_rec_tests.c
+++ b/tftf/tests/runtime_services/realm_payload/host_realm_payload_multiple_rec_tests.c
@@ -55,7 +55,9 @@
 	rec_num = (unsigned int)rand() % MAX_REC_COUNT;
 
 	for (unsigned int i = 0; i < MAX_REC_COUNT; i++) {
-		host_shared_data_set_host_val(&realm, rec_num, HOST_ARG1_INDEX, 10U);
+		host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID,
+				rec_num, HOST_ARG1_INDEX, 10U);
+
 		ret1 = host_enter_realm_execute(&realm, REALM_SLEEP_CMD,
 				RMI_EXIT_HOST_CALL, rec_num);
 		if (!ret1) {
@@ -368,7 +370,7 @@
 	is_secondary_cpu_on = 0U;
 	init_spinlock(&secondary_cpu_lock);
 	my_mpidr = read_mpidr_el1() & MPID_MASK;
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, rec_count);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG1_INDEX, rec_count);
 	ret1 = host_enter_realm_execute(&realm, REALM_MULTIPLE_REC_MULTIPLE_CPU_CMD,
 			RMI_EXIT_PSCI, 0U);
 	if (!ret1) {
@@ -510,7 +512,7 @@
 	}
 
 	/* Realm to request CPU_ON for rec 2 */
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, 2U);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG1_INDEX, 2U);
 	ret1 = host_enter_realm_execute(&realm, REALM_MULTIPLE_REC_MULTIPLE_CPU_CMD,
 			RMI_EXIT_PSCI, 0U);
 	if (!ret1) {
@@ -740,8 +742,11 @@
 
 	/* Pass num of PMU counters programmed to realm */
 	for (unsigned int j = 0U; j < rec_count; j++) {
-		host_shared_data_set_host_val(&realm, j, HOST_ARG1_INDEX, num_cnts);
-		host_shared_data_set_host_val(&realm1, j, HOST_ARG1_INDEX, num_cnts - 1U);
+		host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, j,
+				HOST_ARG1_INDEX, num_cnts);
+
+		host_shared_data_set_host_val(&realm1, PRIMARY_PLANE_ID, j,
+				HOST_ARG1_INDEX, num_cnts - 1U);
 	}
 
 	/*
diff --git a/tftf/tests/runtime_services/realm_payload/host_realm_payload_simd_tests.c b/tftf/tests/runtime_services/realm_payload/host_realm_payload_simd_tests.c
index 5304180..023ec1c 100644
--- a/tftf/tests/runtime_services/realm_payload/host_realm_payload_simd_tests.c
+++ b/tftf/tests/runtime_services/realm_payload/host_realm_payload_simd_tests.c
@@ -113,7 +113,7 @@
 	}
 
 	/* Check if rdvl matches the SVE VL created */
-	sd = host_get_shared_structure(&realm, 0U);
+	sd = host_get_shared_structure(&realm, PRIMARY_PLANE_ID, 0U);
 	rl_output = (struct sve_cmd_rdvl *)sd->realm_cmd_output_buffer;
 	rl_max_sve_vq = SVE_VL_TO_VQ(rl_output->rdvl);
 	if (sve_vq == rl_max_sve_vq) {
@@ -188,7 +188,7 @@
 		goto rm_realm;
 	}
 
-	sd = host_get_shared_structure(&realm, 0U);
+	sd = host_get_shared_structure(&realm, PRIMARY_PLANE_ID, 0U);
 	r_regs = (struct sve_cmd_id_regs *)sd->realm_cmd_output_buffer;
 
 	/* Check ID register SVE flags */
@@ -275,7 +275,7 @@
 		goto rm_realm;
 	}
 
-	sd = host_get_shared_structure(&realm, 0U);
+	sd = host_get_shared_structure(&realm, PRIMARY_PLANE_ID, 0U);
 	rl_output = (struct sve_cmd_probe_vl *)sd->realm_cmd_output_buffer;
 
 	INFO("Supported SVE vector length in bits (expected):\n");
@@ -649,7 +649,7 @@
 		goto rm_realm;
 	}
 
-	sd = host_get_shared_structure(&realm, 0U);
+	sd = host_get_shared_structure(&realm, PRIMARY_PLANE_ID, 0U);
 	r_regs = (struct sme_cmd_id_regs *)sd->realm_cmd_output_buffer;
 
 	/* Check ID register SME flags */
diff --git a/tftf/tests/runtime_services/realm_payload/host_realm_payload_tests.c b/tftf/tests/runtime_services/realm_payload/host_realm_payload_tests.c
index c25c58d..d1cef4b 100644
--- a/tftf/tests/runtime_services/realm_payload/host_realm_payload_tests.c
+++ b/tftf/tests/runtime_services/realm_payload/host_realm_payload_tests.c
@@ -63,7 +63,9 @@
 			return TEST_RESULT_FAIL;
 		}
 
-		host_shared_data_set_host_val(&realm, run_num, HOST_ARG1_INDEX, SLEEP_TIME_MS);
+		host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, run_num,
+				HOST_ARG1_INDEX, SLEEP_TIME_MS);
+
 		ret1 = host_enter_realm_execute(&realm, REALM_SLEEP_CMD, RMI_EXIT_HOST_CALL,
 						run_num);
 		ret2 = host_destroy_realm(&realm);
@@ -429,8 +431,9 @@
 
 	for (unsigned int j = 0U; j < MAX_REC_COUNT; j++) {
 		for (unsigned int i = 0U; i < MAX_REALM_COUNT; i++) {
-			host_shared_data_set_host_val(&realm[i], run_rec[i], HOST_ARG1_INDEX,
-							SLEEP_TIME_MS);
+			host_shared_data_set_host_val(&realm[i], PRIMARY_PLANE_ID, run_rec[i],
+					HOST_ARG1_INDEX, SLEEP_TIME_MS);
+
 			ret = host_enter_realm_execute(&realm[i], REALM_SLEEP_CMD,
 							RMI_EXIT_HOST_CALL, run_rec[i]);
 			if (!ret) {
@@ -489,11 +492,11 @@
 		return TEST_RESULT_FAIL;
 	}
 
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, 10U);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG1_INDEX, 10U);
 	ret1 = host_enter_realm_execute(&realm, REALM_SLEEP_CMD, RMI_EXIT_HOST_CALL, 0U);
 	base = (u_register_t)page_alloc(PAGE_SIZE * test_page_num);
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, base);
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG2_INDEX,
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG2_INDEX,
 			base + (PAGE_SIZE * test_page_num));
 
 	for (unsigned int i = 0U; i < test_page_num; i++) {
@@ -595,7 +598,7 @@
 		ERROR("host_realm_delegate_map_protected_data failede\n");
 		goto destroy_realm;
 	}
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG1_INDEX, base);
 	ret1 = host_enter_realm_execute(&realm, REALM_REJECT_SET_RIPAS_CMD,
 			RMI_EXIT_RIPAS_CHANGE, 0U);
 
@@ -681,8 +684,8 @@
 	}
 	INFO("Initial state base = 0x%lx rtt.state=0x%lx rtt.ripas=0x%lx\n",
 			base, rtt.state, rtt.ripas);
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, base);
-	host_shared_data_set_host_val(&realm, 1U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 1U, HOST_ARG1_INDEX, base);
 
 	ret = host_rmi_data_destroy(realm.rd, base, &data, &top);
 	if (ret != RMI_SUCCESS || data != base) {
@@ -811,8 +814,8 @@
 	}
 	INFO("Initial state base = 0x%lx rtt.state=0x%lx rtt.ripas=0x%lx\n",
 			base, rtt.state, rtt.ripas);
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, base);
-	host_shared_data_set_host_val(&realm, 1U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 1U, HOST_ARG1_INDEX, base);
 
 	/* Rec0 expect rec exit due to Instr Abort unassigned ram page */
 	ret1 = host_enter_realm_execute(&realm, REALM_INSTR_FETCH_CMD,
@@ -913,8 +916,8 @@
 	}
 	INFO("Initial state base = 0x%lx rtt.state=0x%lx rtt.ripas=0x%lx\n",
 			base, rtt.state, rtt.ripas);
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, base);
-	host_shared_data_set_host_val(&realm, 1U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 1U, HOST_ARG1_INDEX, base);
 
 	if (host_realm_activate(&realm) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_activate");
@@ -1038,10 +1041,10 @@
 		ERROR("wrong initial state\n");
 		goto destroy_realm;
 	}
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, base);
-	host_shared_data_set_host_val(&realm, 1U, HOST_ARG1_INDEX, base);
-	host_shared_data_set_host_val(&realm, 2U, HOST_ARG1_INDEX, base);
-	host_shared_data_set_host_val(&realm, 3U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 1U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 2U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 3U, HOST_ARG1_INDEX, base);
 
 	/* Rec0 expect IA due to SEA unassigned empty page */
 	ret1 = host_enter_realm_execute(&realm, REALM_INSTR_FETCH_CMD,
@@ -1052,7 +1055,7 @@
 	}
 
 	/* get ESR set by Realm exception handler */
-	esr = host_shared_data_get_realm_val(&realm, 0U, HOST_ARG2_INDEX);
+	esr = host_shared_data_get_realm_val(&realm, 0U, 0U, HOST_ARG2_INDEX);
 	if (((esr & ISS_IFSC_MASK) != IFSC_NO_WALK_SEA) || (EC_BITS(esr) != EC_IABORT_CUR_EL)) {
 		ERROR("Rec0 incorrect ESR=0x%lx\n", esr);
 		goto destroy_realm;
@@ -1068,7 +1071,7 @@
 	}
 
 	/* get ESR set by Realm exception handler */
-	esr = host_shared_data_get_realm_val(&realm, 1U, HOST_ARG2_INDEX);
+	esr = host_shared_data_get_realm_val(&realm, 0U, 1U, HOST_ARG2_INDEX);
 	if (((esr & ISS_DFSC_MASK) != DFSC_NO_WALK_SEA) || (EC_BITS(esr) != EC_DABORT_CUR_EL)) {
 		ERROR("Rec1 incorrect ESR=0x%lx\n", esr);
 		goto destroy_realm;
@@ -1100,7 +1103,7 @@
 	}
 
 	/* get ESR set by Realm exception handler */
-	esr = host_shared_data_get_realm_val(&realm, 2U, HOST_ARG2_INDEX);
+	esr = host_shared_data_get_realm_val(&realm, 0U, 2U, HOST_ARG2_INDEX);
 	if (((esr & ISS_IFSC_MASK) != IFSC_NO_WALK_SEA) || (EC_BITS(esr) != EC_IABORT_CUR_EL)) {
 		ERROR("Rec2 incorrect ESR=0x%lx\n", esr);
 		goto destroy_realm;
@@ -1116,7 +1119,7 @@
 	}
 
 	/* get ESR set by Realm exception handler */
-	esr = host_shared_data_get_realm_val(&realm, 3U, HOST_ARG2_INDEX);
+	esr = host_shared_data_get_realm_val(&realm, 0U, 3U, HOST_ARG2_INDEX);
 	if (((esr & ISS_DFSC_MASK) != DFSC_NO_WALK_SEA) || (EC_BITS(esr) != EC_DABORT_CUR_EL)) {
 		ERROR("Rec3 incorrect ESR=0x%lx\n", esr);
 	}
@@ -1185,8 +1188,8 @@
 	}
 
 	run = (struct rmi_rec_run *)realm.run[0];
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, base_ipa);
-	host_shared_data_set_host_val(&realm, 1U, HOST_ARG1_INDEX, base_ipa);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG1_INDEX, base_ipa);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 1U, HOST_ARG1_INDEX, base_ipa);
 
 	/* Rec0 expect SEA in realm due to IA unprotected IPA page */
 	ret1 = host_enter_realm_execute(&realm, REALM_INSTR_FETCH_CMD,
@@ -1197,7 +1200,7 @@
 	}
 
 	/* get ESR set by Realm exception handler */
-	esr = host_shared_data_get_realm_val(&realm, 0U, HOST_ARG2_INDEX);
+	esr = host_shared_data_get_realm_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG2_INDEX);
 	if (((esr & ISS_IFSC_MASK) != IFSC_NO_WALK_SEA) || (EC_BITS(esr) != EC_IABORT_CUR_EL)) {
 		ERROR("Rec0 incorrect ESR=0x%lx\n", esr);
 		goto destroy_realm;
@@ -1233,7 +1236,7 @@
 	}
 
 	/* get ESR set by Realm exception handler */
-	esr = host_shared_data_get_realm_val(&realm, 1U, HOST_ARG2_INDEX);
+	esr = host_shared_data_get_realm_val(&realm, PRIMARY_PLANE_ID, 1U, HOST_ARG2_INDEX);
 	if (((esr & ISS_DFSC_MASK) != DFSC_NO_WALK_SEA) || (EC_BITS(esr) != EC_DABORT_CUR_EL)) {
 		ERROR("Rec1 incorrect ESR=0x%lx\n", esr);
 		goto destroy_realm;
@@ -1283,7 +1286,7 @@
 	/* Enable FEAT_DIT on Host */
 	write_dit(DIT_BIT);
 	for (unsigned int i = 0; i < MAX_REC_COUNT; i++) {
-		host_shared_data_set_host_val(&realm, i, HOST_ARG1_INDEX, 10U);
+		host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, i, HOST_ARG1_INDEX, 10U);
 		ret1 = host_enter_realm_execute(&realm, REALM_DIT_CHECK_CMD,
 				RMI_EXIT_HOST_CALL, i);
 		if (!ret1) {
@@ -1747,8 +1750,8 @@
 	/* IPA outside Realm space */
 	base_ipa = base | (1UL << (EXTRACT(RMI_FEATURE_REGISTER_0_S2SZ,
 					realm.rmm_feat_reg0) + 1U));
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, base_ipa);
-	host_shared_data_set_host_val(&realm, 1U, HOST_ARG1_INDEX, base_ipa);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG1_INDEX, base_ipa);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 1U, HOST_ARG1_INDEX, base_ipa);
 
 	INFO("base_ipa=0x%lx\n", base_ipa);
 
@@ -1764,7 +1767,7 @@
 	}
 
 	/* get ESR set by Realm exception handler */
-	esr = host_shared_data_get_realm_val(&realm, 0U, HOST_ARG2_INDEX);
+	esr = host_shared_data_get_realm_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG2_INDEX);
 	if (((esr & ISS_DFSC_MASK) != DFSC_NO_WALK_SEA)
 			|| (EC_BITS(esr) != EC_DABORT_CUR_EL)
 			|| ((esr & (1UL << ESR_ISS_EABORT_EA_BIT)) == 0U)) {
@@ -1784,7 +1787,7 @@
 	}
 
 	/* get ESR set by Realm exception handler */
-	esr = host_shared_data_get_realm_val(&realm, 1U, HOST_ARG2_INDEX);
+	esr = host_shared_data_get_realm_val(&realm, PRIMARY_PLANE_ID, 1U, HOST_ARG2_INDEX);
 	if (((esr & ISS_DFSC_MASK) != IFSC_NO_WALK_SEA)
 			|| (EC_BITS(esr) != EC_IABORT_CUR_EL)
 			|| ((esr & (1UL << ESR_ISS_EABORT_EA_BIT)) == 0U)) {
@@ -1799,8 +1802,8 @@
 
 	INFO("base_ipa=0x%lx\n", base_ipa);
 
-	host_shared_data_set_host_val(&realm, 2U, HOST_ARG1_INDEX, base_ipa);
-	host_shared_data_set_host_val(&realm, 3U, HOST_ARG1_INDEX, base_ipa);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 2U, HOST_ARG1_INDEX, base_ipa);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 3U, HOST_ARG1_INDEX, base_ipa);
 
 	run = (struct rmi_rec_run *)realm.run[2];
 
@@ -1814,7 +1817,7 @@
 	}
 
 	/* get ESR set by Realm exception handler */
-	esr = host_shared_data_get_realm_val(&realm, 2U, HOST_ARG2_INDEX);
+	esr = host_shared_data_get_realm_val(&realm, PRIMARY_PLANE_ID, 2U, HOST_ARG2_INDEX);
 	if (((esr & ISS_DFSC_MASK) != DFSC_L0_ADR_SIZE_FAULT)
 			|| (EC_BITS(esr) != EC_DABORT_CUR_EL)
 			|| ((esr & (1UL << ESR_ISS_EABORT_EA_BIT)) != 0U)) {
@@ -1834,7 +1837,7 @@
 	}
 
 	/* get ESR set by Realm exception handler */
-	esr = host_shared_data_get_realm_val(&realm, 3U, HOST_ARG2_INDEX);
+	esr = host_shared_data_get_realm_val(&realm, PRIMARY_PLANE_ID, 3U, HOST_ARG2_INDEX);
 	if (((esr & ISS_IFSC_MASK) != IFSC_L0_ADR_SIZE_FAULT)
 			|| (EC_BITS(esr) != EC_IABORT_CUR_EL)
 			|| ((esr & (1UL << ESR_ISS_EABORT_EA_BIT)) != 0U)) {
@@ -2581,10 +2584,10 @@
 		return TEST_RESULT_FAIL;
 	}
 
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, base);
+	host_shared_data_set_host_val(&realm, 0U, 0U, HOST_ARG1_INDEX, base);
 
 	for (unsigned int i = 0U; i < 2U; i++) {
-		host_shared_data_set_host_val(&realm, 0U, HOST_ARG2_INDEX,
+		host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U, HOST_ARG2_INDEX,
 					      (unsigned long)i);
 
 		/* Rec0 expect IA due to SEA unassigned empty page */
diff --git a/tftf/tests/runtime_services/realm_payload/host_realm_spm.c b/tftf/tests/runtime_services/realm_payload/host_realm_spm.c
index 8649014..e81d82d 100644
--- a/tftf/tests/runtime_services/realm_payload/host_realm_spm.c
+++ b/tftf/tests/runtime_services/realm_payload/host_realm_spm.c
@@ -203,7 +203,9 @@
 	 * Spin Realm payload for REALM_TIME_SLEEP ms, This ensures secure wdog
 	 * timer triggers during this time.
 	 */
-	host_shared_data_set_host_val(&realm, 0U, HOST_ARG1_INDEX, REALM_TIME_SLEEP);
+	host_shared_data_set_host_val(&realm, PRIMARY_PLANE_ID, 0U,
+			HOST_ARG1_INDEX, REALM_TIME_SLEEP);
+
 	host_enter_realm_execute(&realm, REALM_SLEEP_CMD, RMI_EXIT_FIQ, 0U);
 
 	/*