tftf/tests/runtime_services/host_realm_managment/host_realm_helper.c - TF-A/tf-a-tests.git - TrustedFirmware Git Browser

 /*
  * Copyright (c) 2022-2023, Arm Limited. All rights reserved.
  *
  * SPDX-License-Identifier: BSD-3-Clause
  *
  */

 #include <stdint.h>

 #include <arch_helpers.h>
 #include <debug.h>
 #include <events.h>
 #include <heap/page_alloc.h>
 #include <host_realm_helper.h>
 #include <host_realm_mem_layout.h>
 #include <host_realm_rmi.h>
 #include <host_shared_data.h>
 #include <plat_topology.h>
 #include <power_management.h>
 #include <realm_def.h>
 #include <test_helpers.h>
 #include <xlat_tables_v2.h>

 static struct realm realm;
 static bool realm_payload_created;
 static bool shared_mem_created;
 static volatile bool timer_enabled;

 #define RMI_EXIT(id)	\
 	[RMI_EXIT_##id] = #id

 const char *rmi_exit[] = {
 	RMI_EXIT(SYNC),
 	RMI_EXIT(IRQ),
 	RMI_EXIT(FIQ),
 	RMI_EXIT(FIQ),
 	RMI_EXIT(PSCI),
 	RMI_EXIT(RIPAS_CHANGE),
 	RMI_EXIT(HOST_CALL),
 	RMI_EXIT(SERROR)
 };

 /*
  * The function handler to print the Realm logged buffer,
  * executed by the secondary core
  */
 static inline test_result_t timer_handler(void)
 {
 	size_t str_len = 0UL;
 	host_shared_data_t *host_shared_data = host_get_shared_structure();
 	char *log_buffer = (char *)host_shared_data->log_buffer;

 	do {
 		spin_lock((spinlock_t *)&host_shared_data->printf_lock);
 		str_len = strlen((const char *)log_buffer);

 		/*
 		 * Read Realm message from shared printf location and print
 		 * them using UART
 		 */
 		if (str_len != 0UL) {
 			/* Avoid memory overflow */
 			log_buffer[MAX_BUF_SIZE - 1] = 0U;

 			mp_printf("%s", log_buffer);
 			(void)memset((char *)log_buffer, 0, MAX_BUF_SIZE);
 		}
 		spin_unlock((spinlock_t *)&host_shared_data->printf_lock);

 	} while ((timer_enabled || (str_len != 0UL)));

 	return TEST_RESULT_SUCCESS;
 }

 /*
  * 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.
  */
 void host_init_realm_print_buffer(void)
 {
 	u_register_t other_mpidr, my_mpidr;
 	host_shared_data_t *host_shared_data = host_get_shared_structure();
 	int ret;

 	(void)memset((char *)host_shared_data, 0, sizeof(host_shared_data_t));

 	/* Program timer */
 	timer_enabled = false;

 	/* Find a valid CPU to power on */
 	my_mpidr = read_mpidr_el1() & MPID_MASK;
 	other_mpidr = tftf_find_any_cpu_other_than(my_mpidr);
 	if (other_mpidr == INVALID_MPID) {
 		ERROR("Couldn't find a valid other CPU\n");
 		return;
 	}

 	/* Power on the other CPU */
 	ret = tftf_cpu_on(other_mpidr, (uintptr_t)timer_handler, 0);
 	if (ret != PSCI_E_SUCCESS) {
 		ERROR("Powering on %lx failed\n", other_mpidr);
 		return;
 	}
 	timer_enabled = true;
 }

 static bool host_enter_realm(u_register_t *exit_reason,
 				unsigned int *host_call_result)
 {
 	u_register_t ret;

 	if (!realm_payload_created) {
 		ERROR("%s() failed\n", "realm_payload_created");
 		return false;
 	}
 	if (!shared_mem_created) {
 		ERROR("%s() failed\n", "shared_mem_created");
 		return false;
 	}

 	/* Enter Realm */
 	ret = host_realm_rec_enter(&realm, exit_reason, host_call_result);
 	if (ret != REALM_SUCCESS) {
 		ERROR("%s() failed, ret=%lx\n", "host_realm_rec_enter", ret);

 		/* Free test resources */
 		if (host_realm_destroy(&realm) != REALM_SUCCESS) {
 			ERROR("%s() failed\n", "host_realm_destroy");
 		}
 		realm_payload_created = false;
 		return false;
 	}

 	return true;
 }

 bool host_create_realm_payload(u_register_t realm_payload_adr,
 				u_register_t plat_mem_pool_adr,
 				u_register_t plat_mem_pool_size,
 				u_register_t realm_pages_size,
 				u_register_t feature_flag)
 {
 	int8_t value;

 	if (realm_payload_adr == TFTF_BASE) {
 		ERROR("realm_payload_adr should be grater then TFTF_BASE\n");
 		return false;
 	}

 	if (plat_mem_pool_adr  == 0UL ||
 			plat_mem_pool_size == 0UL ||
 			realm_pages_size == 0UL) {
 		ERROR("plat_mem_pool_size or "
 			"plat_mem_pool_size or realm_pages_size is NULL\n");
 		return false;
 	}

 	INFO("Realm base adr=0x%lx\n", realm_payload_adr);
 	/* Initialize  Host NS heap memory to be used in Realm creation*/
 	if (page_pool_init(plat_mem_pool_adr, realm_pages_size)
 		!= HEAP_INIT_SUCCESS) {
 		ERROR("%s() failed\n", "page_pool_init");
 		return false;
 	}

 	/* Read Realm Feature Reg 0 */
 	if (host_rmi_features(0UL, &realm.rmm_feat_reg0) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_rmi_features");
 		return false;
 	}

 	/* Disable PMU if not required */
 	if ((feature_flag & RMI_FEATURE_REGISTER_0_PMU_EN) == 0UL) {
 		realm.rmm_feat_reg0 &= ~RMI_FEATURE_REGISTER_0_PMU_EN;
 		realm.pmu_num_ctrs = 0U;
 	} else {
 		value = EXTRACT(FEATURE_PMU_NUM_CTRS, feature_flag);
 		if (value != -1) {
 			realm.pmu_num_ctrs = (unsigned int)value;
 		} else {
 			realm.pmu_num_ctrs =
 				EXTRACT(RMI_FEATURE_REGISTER_0_PMU_NUM_CTRS,
 					realm.rmm_feat_reg0);
 		}
 	}

 	/* Disable SVE if not required */
 	if ((feature_flag & RMI_FEATURE_REGISTER_0_SVE_EN) == 0UL) {
 		realm.rmm_feat_reg0 &= ~RMI_FEATURE_REGISTER_0_SVE_EN;
 		realm.sve_vl = 0U;
 	} else {
 		realm.sve_vl = EXTRACT(FEATURE_SVE_VL, feature_flag);
 	}

 	/* Requested number of breakpoints */
 	value = EXTRACT(FEATURE_NUM_BPS, feature_flag);
 	if (value != -1) {
 		realm.num_bps = (unsigned int)value;
 	} else {
 		realm.num_bps = EXTRACT(RMI_FEATURE_REGISTER_0_NUM_BPS,
 					realm.rmm_feat_reg0);
 	}

 	/* Requested number of watchpoints */
 	value = EXTRACT(FEATURE_NUM_WPS, feature_flag);
 	if (value != -1) {
 		realm.num_wps = (unsigned int)value;
 	} else {
 		realm.num_wps = EXTRACT(RMI_FEATURE_REGISTER_0_NUM_WPS,
 					realm.rmm_feat_reg0);
 	}

 	/* Set SVE bits from feature_flag */
 	realm.rmm_feat_reg0 &= ~(RMI_FEATURE_REGISTER_0_SVE_EN |
 				 MASK(RMI_FEATURE_REGISTER_0_SVE_VL));
 	if ((feature_flag & RMI_FEATURE_REGISTER_0_SVE_EN) != 0UL) {
 		realm.rmm_feat_reg0 |= RMI_FEATURE_REGISTER_0_SVE_EN |
 				       INPLACE(RMI_FEATURE_REGISTER_0_SVE_VL,
 				       EXTRACT(RMI_FEATURE_REGISTER_0_SVE_VL,
 						feature_flag));
 	}

 	/* Create Realm */
 	if (host_realm_create(&realm) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_create");
 		return false;
 	}

 	if (host_realm_init_ipa_state(&realm, 0U, 0U, 1ULL << 32)
 		!= RMI_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_init_ipa_state");
 		goto destroy_realm;
 	}

 	/* RTT map Realm image */
 	if (host_realm_map_payload_image(&realm, realm_payload_adr) !=
 			REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_map_payload_image");
 		goto destroy_realm;
 	}

 	/* Create REC */
 	if (host_realm_rec_create(&realm) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_rec_create");
 		goto destroy_realm;
 	}

 	/* Activate Realm */
 	if (host_realm_activate(&realm) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_activate");
 		goto destroy_realm;
 	}

 	realm_payload_created = true;

 	return realm_payload_created;

 	/* Free test resources */
 destroy_realm:
 	if (host_realm_destroy(&realm) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_destroy");
 	}
 	realm_payload_created = false;

 	return realm_payload_created;
 }

 bool host_create_shared_mem(u_register_t ns_shared_mem_adr,
 	u_register_t ns_shared_mem_size)
 {
 	/* RTT map NS shared region */
 	if (host_realm_map_ns_shared(&realm, ns_shared_mem_adr,
 				ns_shared_mem_size) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_map_ns_shared");
 		shared_mem_created = false;
 		return false;
 	}

 	host_init_realm_print_buffer();
 	realm_shared_data_clear_realm_val();
 	shared_mem_created = true;

 	return shared_mem_created;
 }

 bool host_destroy_realm(void)
 {
 	/* Free test resources */
 	timer_enabled = false;
 	page_pool_reset();

 	if (!realm_payload_created) {
 		ERROR("%s() failed\n", "realm_payload_created");
 		return false;
 	}

 	realm_payload_created = false;
 	if (host_realm_destroy(&realm) != REALM_SUCCESS) {
 		ERROR("%s() failed\n", "host_realm_destroy");
 		return false;
 	}

 	return true;
 }

 bool host_enter_realm_execute(uint8_t cmd, struct realm **realm_ptr, int test_exit_reason)
 {
 	u_register_t exit_reason = RMI_EXIT_INVALID;
 	unsigned int host_call_result = TEST_RESULT_FAIL;

 	realm_shared_data_set_realm_cmd(cmd);
 	if (!host_enter_realm(&exit_reason, &host_call_result)) {
 		return false;
 	}

 	if (realm_ptr != NULL) {
 		*realm_ptr = &realm;
 	}

 	if ((exit_reason == RMI_EXIT_HOST_CALL) && (host_call_result == TEST_RESULT_SUCCESS)) {
 		return true;
 	}

 	if (test_exit_reason == exit_reason) {
 		 return true;
 	}

 	if (exit_reason <= RMI_EXIT_SERROR) {
 		ERROR("%s(%u) RMI_EXIT_%s host_call_result=%u\n",
 		__func__, cmd, rmi_exit[exit_reason], host_call_result);
 	} else {
 		ERROR("%s(%u) 0x%lx host_call_result=%u\n",
 		__func__, cmd, exit_reason, host_call_result);
 	}
 	return false;
 }

 test_result_t host_cmp_result(void)
 {
 	if (host_rmi_get_cmp_result()) {
 		return TEST_RESULT_SUCCESS;
 	}

 	ERROR("RMI registers comparison failed\n");
 	return TEST_RESULT_FAIL;
 }
	/*
	* Copyright (c) 2022-2023, Arm Limited. All rights reserved.
	*
	* SPDX-License-Identifier: BSD-3-Clause
	*
	*/

	#include <stdint.h>

	#include <arch_helpers.h>
	#include <debug.h>
	#include <events.h>
	#include <heap/page_alloc.h>
	#include <host_realm_helper.h>
	#include <host_realm_mem_layout.h>
	#include <host_realm_rmi.h>
	#include <host_shared_data.h>
	#include <plat_topology.h>
	#include <power_management.h>
	#include <realm_def.h>
	#include <test_helpers.h>
	#include <xlat_tables_v2.h>

	static struct realm realm;
	static bool realm_payload_created;
	static bool shared_mem_created;
	static volatile bool timer_enabled;

	#define RMI_EXIT(id) \
	[RMI_EXIT_##id] = #id

	const char *rmi_exit[] = {
	RMI_EXIT(SYNC),
	RMI_EXIT(IRQ),
	RMI_EXIT(FIQ),
	RMI_EXIT(FIQ),
	RMI_EXIT(PSCI),
	RMI_EXIT(RIPAS_CHANGE),
	RMI_EXIT(HOST_CALL),
	RMI_EXIT(SERROR)
	};

	/*
	* The function handler to print the Realm logged buffer,
	* executed by the secondary core
	*/
	static inline test_result_t timer_handler(void)
	{
	size_t str_len = 0UL;
	host_shared_data_t *host_shared_data = host_get_shared_structure();
	char log_buffer = (char )host_shared_data->log_buffer;

	do {
	spin_lock((spinlock_t *)&host_shared_data->printf_lock);
	str_len = strlen((const char *)log_buffer);

	/*
	* Read Realm message from shared printf location and print
	* them using UART
	*/
	if (str_len != 0UL) {
	/* Avoid memory overflow */
	log_buffer[MAX_BUF_SIZE - 1] = 0U;

	mp_printf("%s", log_buffer);
	(void)memset((char *)log_buffer, 0, MAX_BUF_SIZE);
	}
	spin_unlock((spinlock_t *)&host_shared_data->printf_lock);

	} while ((timer_enabled \|\| (str_len != 0UL)));

	return TEST_RESULT_SUCCESS;
	}

	/*
	* 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.
	*/
	void host_init_realm_print_buffer(void)
	{
	u_register_t other_mpidr, my_mpidr;
	host_shared_data_t *host_shared_data = host_get_shared_structure();
	int ret;

	(void)memset((char *)host_shared_data, 0, sizeof(host_shared_data_t));

	/* Program timer */
	timer_enabled = false;

	/* Find a valid CPU to power on */
	my_mpidr = read_mpidr_el1() & MPID_MASK;
	other_mpidr = tftf_find_any_cpu_other_than(my_mpidr);
	if (other_mpidr == INVALID_MPID) {
	ERROR("Couldn't find a valid other CPU\n");
	return;
	}

	/* Power on the other CPU */
	ret = tftf_cpu_on(other_mpidr, (uintptr_t)timer_handler, 0);
	if (ret != PSCI_E_SUCCESS) {
	ERROR("Powering on %lx failed\n", other_mpidr);
	return;
	}
	timer_enabled = true;
	}

	static bool host_enter_realm(u_register_t *exit_reason,
	unsigned int *host_call_result)
	{
	u_register_t ret;

	if (!realm_payload_created) {
	ERROR("%s() failed\n", "realm_payload_created");
	return false;
	}
	if (!shared_mem_created) {
	ERROR("%s() failed\n", "shared_mem_created");
	return false;
	}

	/* Enter Realm */
	ret = host_realm_rec_enter(&realm, exit_reason, host_call_result);
	if (ret != REALM_SUCCESS) {
	ERROR("%s() failed, ret=%lx\n", "host_realm_rec_enter", ret);

	/* Free test resources */
	if (host_realm_destroy(&realm) != REALM_SUCCESS) {
	ERROR("%s() failed\n", "host_realm_destroy");
	}
	realm_payload_created = false;
	return false;
	}

	return true;
	}

	bool host_create_realm_payload(u_register_t realm_payload_adr,
	u_register_t plat_mem_pool_adr,
	u_register_t plat_mem_pool_size,
	u_register_t realm_pages_size,
	u_register_t feature_flag)
	{
	int8_t value;

	if (realm_payload_adr == TFTF_BASE) {
	ERROR("realm_payload_adr should be grater then TFTF_BASE\n");
	return false;
	}

	if (plat_mem_pool_adr == 0UL \|\|
	plat_mem_pool_size == 0UL \|\|
	realm_pages_size == 0UL) {
	ERROR("plat_mem_pool_size or "
	"plat_mem_pool_size or realm_pages_size is NULL\n");
	return false;
	}

	INFO("Realm base adr=0x%lx\n", realm_payload_adr);
	/* Initialize Host NS heap memory to be used in Realm creation*/
	if (page_pool_init(plat_mem_pool_adr, realm_pages_size)
	!= HEAP_INIT_SUCCESS) {
	ERROR("%s() failed\n", "page_pool_init");
	return false;
	}

	/* Read Realm Feature Reg 0 */
	if (host_rmi_features(0UL, &realm.rmm_feat_reg0) != REALM_SUCCESS) {
	ERROR("%s() failed\n", "host_rmi_features");
	return false;
	}

	/* Disable PMU if not required */
	if ((feature_flag & RMI_FEATURE_REGISTER_0_PMU_EN) == 0UL) {
	realm.rmm_feat_reg0 &= ~RMI_FEATURE_REGISTER_0_PMU_EN;
	realm.pmu_num_ctrs = 0U;
	} else {
	value = EXTRACT(FEATURE_PMU_NUM_CTRS, feature_flag);
	if (value != -1) {
	realm.pmu_num_ctrs = (unsigned int)value;
	} else {
	realm.pmu_num_ctrs =
	EXTRACT(RMI_FEATURE_REGISTER_0_PMU_NUM_CTRS,
	realm.rmm_feat_reg0);
	}
	}

	/* Disable SVE if not required */
	if ((feature_flag & RMI_FEATURE_REGISTER_0_SVE_EN) == 0UL) {
	realm.rmm_feat_reg0 &= ~RMI_FEATURE_REGISTER_0_SVE_EN;
	realm.sve_vl = 0U;
	} else {
	realm.sve_vl = EXTRACT(FEATURE_SVE_VL, feature_flag);
	}

	/* Requested number of breakpoints */
	value = EXTRACT(FEATURE_NUM_BPS, feature_flag);
	if (value != -1) {
	realm.num_bps = (unsigned int)value;
	} else {
	realm.num_bps = EXTRACT(RMI_FEATURE_REGISTER_0_NUM_BPS,
	realm.rmm_feat_reg0);
	}

	/* Requested number of watchpoints */
	value = EXTRACT(FEATURE_NUM_WPS, feature_flag);
	if (value != -1) {
	realm.num_wps = (unsigned int)value;
	} else {
	realm.num_wps = EXTRACT(RMI_FEATURE_REGISTER_0_NUM_WPS,
	realm.rmm_feat_reg0);
	}

	/* Set SVE bits from feature_flag */
	realm.rmm_feat_reg0 &= ~(RMI_FEATURE_REGISTER_0_SVE_EN \|
	MASK(RMI_FEATURE_REGISTER_0_SVE_VL));
	if ((feature_flag & RMI_FEATURE_REGISTER_0_SVE_EN) != 0UL) {
	realm.rmm_feat_reg0 \|= RMI_FEATURE_REGISTER_0_SVE_EN \|
	INPLACE(RMI_FEATURE_REGISTER_0_SVE_VL,
	EXTRACT(RMI_FEATURE_REGISTER_0_SVE_VL,
	feature_flag));
	}

	/* Create Realm */
	if (host_realm_create(&realm) != REALM_SUCCESS) {
	ERROR("%s() failed\n", "host_realm_create");
	return false;
	}

	if (host_realm_init_ipa_state(&realm, 0U, 0U, 1ULL << 32)
	!= RMI_SUCCESS) {
	ERROR("%s() failed\n", "host_realm_init_ipa_state");
	goto destroy_realm;
	}

	/* RTT map Realm image */
	if (host_realm_map_payload_image(&realm, realm_payload_adr) !=
	REALM_SUCCESS) {
	ERROR("%s() failed\n", "host_realm_map_payload_image");
	goto destroy_realm;
	}

	/* Create REC */
	if (host_realm_rec_create(&realm) != REALM_SUCCESS) {
	ERROR("%s() failed\n", "host_realm_rec_create");
	goto destroy_realm;
	}

	/* Activate Realm */
	if (host_realm_activate(&realm) != REALM_SUCCESS) {
	ERROR("%s() failed\n", "host_realm_activate");
	goto destroy_realm;
	}

	realm_payload_created = true;

	return realm_payload_created;

	/* Free test resources */
	destroy_realm:
	if (host_realm_destroy(&realm) != REALM_SUCCESS) {
	ERROR("%s() failed\n", "host_realm_destroy");
	}
	realm_payload_created = false;

	return realm_payload_created;
	}

	bool host_create_shared_mem(u_register_t ns_shared_mem_adr,
	u_register_t ns_shared_mem_size)
	{
	/* RTT map NS shared region */
	if (host_realm_map_ns_shared(&realm, ns_shared_mem_adr,
	ns_shared_mem_size) != REALM_SUCCESS) {
	ERROR("%s() failed\n", "host_realm_map_ns_shared");
	shared_mem_created = false;
	return false;
	}

	host_init_realm_print_buffer();
	realm_shared_data_clear_realm_val();
	shared_mem_created = true;

	return shared_mem_created;
	}

	bool host_destroy_realm(void)
	{
	/* Free test resources */
	timer_enabled = false;
	page_pool_reset();

	if (!realm_payload_created) {
	ERROR("%s() failed\n", "realm_payload_created");
	return false;
	}

	realm_payload_created = false;
	if (host_realm_destroy(&realm) != REALM_SUCCESS) {
	ERROR("%s() failed\n", "host_realm_destroy");
	return false;
	}

	return true;
	}

	bool host_enter_realm_execute(uint8_t cmd, struct realm **realm_ptr, int test_exit_reason)
	{
	u_register_t exit_reason = RMI_EXIT_INVALID;
	unsigned int host_call_result = TEST_RESULT_FAIL;

	realm_shared_data_set_realm_cmd(cmd);
	if (!host_enter_realm(&exit_reason, &host_call_result)) {
	return false;
	}

	if (realm_ptr != NULL) {
	*realm_ptr = &realm;
	}

	if ((exit_reason == RMI_EXIT_HOST_CALL) && (host_call_result == TEST_RESULT_SUCCESS)) {
	return true;
	}

	if (test_exit_reason == exit_reason) {
	return true;
	}

	if (exit_reason <= RMI_EXIT_SERROR) {
	ERROR("%s(%u) RMI_EXIT_%s host_call_result=%u\n",
	__func__, cmd, rmi_exit[exit_reason], host_call_result);
	} else {
	ERROR("%s(%u) 0x%lx host_call_result=%u\n",
	__func__, cmd, exit_reason, host_call_result);
	}
	return false;
	}

	test_result_t host_cmp_result(void)
	{
	if (host_rmi_get_cmp_result()) {
	return TEST_RESULT_SUCCESS;
	}

	ERROR("RMI registers comparison failed\n");
	return TEST_RESULT_FAIL;
	}