include/runtime_services/cactus_test_cmds.h

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

#ifndef CACTUS_TEST_CMDS
#define CACTUS_TEST_CMDS

#include <ffa_helpers.h>
#include <spm_common.h>

/**
 * Success and error return to be sent over a msg response.
 */
#define CACTUS_SUCCESS		U(0)
#define CACTUS_ERROR		U(-1)

/**
 * Error codes.
 */
#define CACTUS_ERROR_INVALID		U(1)
#define CACTUS_ERROR_TEST		U(2)
#define CACTUS_ERROR_FFA_CALL		U(3)
#define CACTUS_ERROR_UNHANDLED		U(4)

#define ECHO_VAL1 U(0xa0a0a0a0)
#define ECHO_VAL2 U(0xb0b0b0b0)
#define ECHO_VAL3 U(0xc0c0c0c0)

/**
 * Get command from struct ffa_value.
 */
static inline uint64_t cactus_get_cmd(struct ffa_value ret)
{
	return (uint64_t)ret.arg3;
}

/**
 * Template for commands to be sent to CACTUS partitions over direct
 * messages interfaces.
 */
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)
{
	return 	ffa_msg_send_direct_req64(source, dest, cmd, val0, val1, val2,
					  val3);
}

/**
 * Template for responses to Cactus commands.
 * '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 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)
{
	return ffa_msg_send_direct_resp64(source, dest, resp, val0, val1,
					  val2, val3);
}

/**
 * For responses of one value only.
 */
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(struct ffa_value ret)
{
	return (uint32_t)ret.arg3;
}

/**
 * In a successful test, in case the SP needs to propagate an extra value
 * to conclude the test.
 * If more arguments are needed, a custom response should be defined for the
 * specific test.
 */
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,
				    0, 0, 0);
}

/**
 * In case the test fails on the SP side, the 'error_code' should help specify
 * the reason, which can be specific to the test, or general ones as defined
 * in the error code list.
 */
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(struct ffa_value ret)
{
	return (uint32_t) ret.arg4;
}

/**
 * With this test command the sender transmits a 64-bit value that it then
 * expects to receive on the respective command response.
 *
 * The id is the hex representation of the string 'echo'.
 */
#define CACTUS_ECHO_CMD U(0x6563686f)

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(struct ffa_value ret)
{
	return (uint64_t)ret.arg4;
}

/**
 * Command to request a cactus secure partition to send an echo command to
 * another partition.
 *
 * The sender of this command expects to receive CACTUS_SUCCESS if the requested
 * echo interaction happened successfully, or CACTUS_ERROR otherwise.
 */
#define CACTUS_REQ_ECHO_CMD (CACTUS_ECHO_CMD + 1)

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)
{
	return cactus_send_cmd(source, dest, CACTUS_REQ_ECHO_CMD, echo_val,
			       echo_dest, 0, 0);
}

static inline ffa_id_t cactus_req_echo_get_echo_dest(struct ffa_value ret)
{
	return (ffa_id_t)ret.arg5;
}

/**
 * Command to create a cyclic dependency between SPs, which could result in
 * a deadlock. This aims at proving such scenario cannot happen.
 * If the deadlock happens, the system will just hang.
 * If the deadlock is prevented, the last partition to use the command will
 * send response CACTUS_SUCCESS.
 *
 * The id is the hex representation of the string 'dead'.
 */
#define CACTUS_DEADLOCK_CMD U(0x64656164)

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(struct ffa_value ret)
{
	return (ffa_id_t)ret.arg4;
}

/**
 * Command to request a sequence CACTUS_DEADLOCK_CMD between the partitions
 * of specified IDs.
 */
#define CACTUS_REQ_DEADLOCK_CMD (CACTUS_DEADLOCK_CMD + 1)

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)
{
	return cactus_send_cmd(source, dest, CACTUS_REQ_DEADLOCK_CMD,
			       next_dest1, next_dest2, 0, 0);
}

/* To get next_dest1 use CACTUS_DEADLOCK_GET_NEXT_DEST */
static inline ffa_id_t cactus_deadlock_get_next_dest2(struct ffa_value ret)
{
	return (ffa_id_t)ret.arg5;
}

/**
 * Command to notify cactus of a memory management operation. The cmd value
 * should be the memory management smc function id.
 *
 * The id is the hex representation of the string "mem"
 */
#define CACTUS_MEM_SEND_CMD U(0x6d656d)

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,
	uint16_t word_to_write, bool expect_exception, bool is_normal_memory)
{
	uint64_t _expect_exception = expect_exception ? (1ULL << 32) : 0;
	uint64_t _is_normal_memory = is_normal_memory ? (1ULL << 33) : 0;
	uint64_t packed = (uint64_t)word_to_write | _expect_exception |
			  _is_normal_memory;

	return cactus_send_cmd(source, dest, CACTUS_MEM_SEND_CMD, mem_func,
			       handle, retrieve_flags, packed);
}

static inline ffa_memory_handle_t cactus_mem_send_get_handle(
	struct ffa_value ret)
{
	return (ffa_memory_handle_t)ret.arg5;
}

static inline ffa_memory_region_flags_t cactus_mem_send_get_retrv_flags(
	struct ffa_value ret)
{
	return (ffa_memory_region_flags_t)ret.arg6;
}

static inline uint16_t cactus_mem_send_words_to_write(struct ffa_value ret)
{
	return (uint16_t)ret.arg7 & 0xFFFFU;
}

static inline bool cactus_mem_send_expect_exception(struct ffa_value ret)
{
	return (bool)((ret.arg7 >> 32) & 0x1);
}

static inline bool cactus_mem_send_is_normal_memory(struct ffa_value ret)
{
	return (bool)((ret.arg7 >> 33) & 0x1);
}

/**
 * Command to request a memory management operation. The 'mem_func' argument
 * identifies the operation that is to be performend, and 'receiver' is the id
 * of the partition to receive the memory region.
 *
 * The command id is the hex representation of the string "memory".
 */
#define CACTUS_REQ_MEM_SEND_CMD U(0x6d656d6f7279)

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)
{
	return cactus_send_cmd(source, dest, CACTUS_REQ_MEM_SEND_CMD, mem_func,
			       receiver, non_secure, 0);
}

static inline uint32_t cactus_req_mem_send_get_mem_func(struct ffa_value ret)
{
	return (uint32_t)ret.arg4;
}

static inline ffa_id_t cactus_req_mem_send_get_receiver(struct ffa_value ret)
{
	return (ffa_id_t)ret.arg5;
}

static inline bool cactus_req_mem_send_get_non_secure(struct ffa_value ret)
{
	return (bool)ret.arg6;
}

/**
 * Request to fill SIMD vectors with dummy values with purpose to check a
 * save/restore routine during the context switches between secure world and
 * normal world.
 *
 * The command id is the hex representation of the string "SIMD"
 */
#define CACTUS_REQ_SIMD_FILL_CMD U(0x53494d44)

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,
			       0);
}

/**
 * Request to compare FPU state(SIMD vectors, FPCR, FPSR) content
 * with previous template values to check a save/restore routine during the
 * context switches between secure world and normal world.
 */
#define CACTUS_CMP_SIMD_VALUE_CMD (CACTUS_REQ_SIMD_FILL_CMD + 1)

static inline struct ffa_value cactus_req_simd_compare_send_cmd(
	ffa_id_t source, ffa_id_t dest)
{
	return cactus_send_cmd(source, dest, CACTUS_CMP_SIMD_VALUE_CMD, 0, 0, 0,
			       0);
}

/**
 * Command to request cactus to sleep for the given time in ms
 *
 * The command id is the hex representation of string "sleep"
 */
#define CACTUS_SLEEP_CMD U(0x736c656570)

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,
			       0);
}

/**
 * Command to request cactus to forward sleep command for the given time in ms
 *
 * The sender of this command expects to receive CACTUS_SUCCESS if the requested
 * echo interaction happened successfully, or CACTUS_ERROR otherwise.
 * Moreover, the sender can send a hint to the destination SP to expect that
 * the forwaded sleep command could be preempted by a non-secure interrupt.
 */
#define CACTUS_FWD_SLEEP_CMD (CACTUS_SLEEP_CMD + 1)

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, bool hint_interrupted)
{
	return cactus_send_cmd(source, dest, CACTUS_FWD_SLEEP_CMD, sleep_time,
			       fwd_dest, hint_interrupted, 0);
}

static inline uint32_t cactus_get_sleep_time(struct ffa_value ret)
{
	return (uint32_t)ret.arg4;
}

static inline ffa_id_t cactus_get_fwd_sleep_dest(struct ffa_value ret)
{
	return (ffa_id_t)ret.arg5;
}

static inline bool cactus_get_fwd_sleep_interrupted_hint(struct ffa_value ret)
{
	return (bool)ret.arg6;
}

/**
 * Command to request cactus to sleep for half the given time in ms, trigger
 * trusted watchdog timer and then sleep again for another half the given time.
 *
 * The sender of this command expects to receive CACTUS_SUCCESS if the requested
 * echo interaction happened successfully, or CACTUS_ERROR otherwise.
 */
#define CACTUS_SLEEP_TRIGGER_TWDOG_CMD (CACTUS_SLEEP_CMD + 2)

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)
{
	return cactus_send_cmd(source, dest, CACTUS_SLEEP_TRIGGER_TWDOG_CMD, sleep_time,
			       wdog_time, 0, 0);
}


static inline uint32_t cactus_get_wdog_trigger_duration(struct ffa_value ret)
{
	return (uint32_t)ret.arg5;
}

/**
 * Command to request cactus to enable/disable an interrupt
 *
 * The command id is the hex representation of string "intr"
 */
#define CACTUS_INTERRUPT_CMD U(0x696e7472)

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)
{
	return cactus_send_cmd(source, dest, CACTUS_INTERRUPT_CMD, interrupt_id,
			       enable, pin, 0);
}

static inline uint32_t cactus_get_interrupt_id(struct ffa_value ret)
{
	return (uint32_t)ret.arg4;
}

static inline bool cactus_get_interrupt_enable(struct ffa_value ret)
{
	return (bool)ret.arg5;
}

static inline enum interrupt_pin cactus_get_interrupt_pin(struct ffa_value ret)
{
	return (enum interrupt_pin)ret.arg6;
}

/**
 * Request to initiate DMA transaction by upstream peripheral.
 *
 * The command id is the hex representation of the string "SMMU"
 */
#define CACTUS_DMA_SMMUv3_CMD           (0x534d4d55)

static inline struct ffa_value cactus_send_dma_cmd(
	ffa_id_t source, ffa_id_t dest, uint32_t operation,
	uintptr_t base, size_t range, uint32_t attributes)
{
	return cactus_send_cmd(source, dest, CACTUS_DMA_SMMUv3_CMD,
			       (uint64_t)operation, (uint64_t)base,
			       (uint64_t)range, attributes);
}

/*
 * Request SP to bind a notification to a FF-A endpoint. In case of error
 * when using the FFA_NOTIFICATION_BIND interface, include the error code
 * in the response to the command's request. The receiver and sender arguments
 * are propagated through the command's arguments, to allow the test of
 * erroneous uses of the FFA_NOTIFICATION_BIND interface.
 *
 * The command id is the hex representation of the string "bind".
 */
#define CACTUS_NOTIFICATION_BIND_CMD U(0x62696e64)

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)
{
	return cactus_send_cmd(source, dest, CACTUS_NOTIFICATION_BIND_CMD,
			       receiver, sender, notifications, flags);
}

/**
 * Request to SP unbind a notification. In case of error when using the
 * FFA_NOTIFICATION_UNBIND interface, the test includes the error code in the
 * response. The receiver and sender arguments are propagated throught the
 * command's arguments, to allow the test of erroneous uses of the
 * FFA_NOTIFICATION_BIND interface.
 *
 * The command id is the hex representation of the string "unbind".
 */
#define CACTUS_NOTIFICATION_UNBIND_CMD U(0x756e62696e64)

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)
{
	return cactus_send_cmd(source, dest, CACTUS_NOTIFICATION_UNBIND_CMD,
			       receiver, sender, notifications, 0);
}

static inline ffa_id_t cactus_notification_get_receiver(struct ffa_value ret)
{
	return (ffa_id_t)ret.arg4;
}

static inline ffa_id_t cactus_notification_get_sender(struct ffa_value ret)
{
	return (ffa_id_t)ret.arg5;
}

static inline ffa_notification_bitmap_t cactus_notification_get_notifications(
	struct ffa_value ret)
{
	return (uint64_t)ret.arg6;
}

/**
 * Request SP to get notifications. The arguments to use in ffa_notification_get
 * are propagated on the command to test erroneous uses of the interface.
 * In a successful call to the interface, the SP's response payload should
 * include all bitmaps returned by the SPMC.
 *
 * The command id is the hex representation of the string "getnot".
 */
#define CACTUS_NOTIFICATION_GET_CMD U(0x6765746e6f74)

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)
{
	return cactus_send_cmd(source, dest, CACTUS_NOTIFICATION_GET_CMD,
			       receiver, vcpu_id, check_npi_handled, flags);
}

static inline uint32_t cactus_notification_get_vcpu(struct ffa_value ret)
{
	return (uint32_t)ret.arg5;
}

static inline uint32_t cactus_notification_get_flags(struct ffa_value ret)
{
	return (uint32_t)ret.arg7;
}

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)
{
	return cactus_send_response(source, dest, CACTUS_SUCCESS, from_sp,
				    from_vm, 0, 0);
}

static inline uint64_t cactus_notifications_get_from_sp(struct ffa_value ret)
{
	return (uint64_t)ret.arg4;
}

static inline uint64_t cactus_notifications_get_from_vm(struct ffa_value ret)
{
	return (uint64_t)ret.arg5;
}

static inline bool cactus_notifications_check_npi_handled(struct ffa_value ret)
{
	return (bool)ret.arg6;
}

/**
 * Request SP to set notifications. The arguments to use in ffa_notification_set
 * are propagated on the command to test erroneous uses of the interface.
 * In case of error while calling the interface, the response should include the
 * error code. If in the flags a delay SRI is requested, cactus should
 * send a CACTUS_ECHO_CMD to the SP specified as `echo_dest`. This should help
 * validate that the SRI is only sent when returning execution to the NWd.
 */
#define CACTUS_NOTIFICATIONS_SET_CMD U(0x6e6f74736574)

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)
{
	return cactus_send_cmd(source, dest, CACTUS_NOTIFICATIONS_SET_CMD,
			       (uint32_t)receiver | ((uint32_t)sender << 16),
			       echo_dest,
			       notifications, flags);
}

static inline ffa_id_t cactus_notifications_set_get_receiver(
	struct ffa_value ret)
{
	return (ffa_id_t)(ret.arg4 & 0xFFFFU);
}

static inline ffa_id_t cactus_notifications_set_get_sender(struct ffa_value ret)
{
	return (ffa_id_t)((ret.arg4 >> 16U) & 0xFFFFU);
}

/**
 * Request to start trusted watchdog timer.
 *
 * The command id is the hex representaton of the string "WDOG"
 */
#define CACTUS_TWDOG_START_CMD		U(0x57444f47)

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(struct ffa_value ret)
{
	return (uint32_t)ret.arg4;
}

/**
 * Request SP to return the current count of handled requests.
 *
 * The command id is the hex representation of the string "getnot".
 */
#define CACTUS_GET_REQ_COUNT_CMD U(0x726571636f756e74)

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(struct ffa_value ret)
{
	return (uint32_t)ret.arg4;
}

/**
 * Request SP to return the last serviced secure virtual interrupt.
 *
 * The command id is the hex representaton of the string "vINT"
 */
#define CACTUS_LAST_INTERRUPT_SERVICED_CMD U(0x76494e54)

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,
				 0, 0, 0, 0);
}

/**
 * Request SP to resume the task requested by current endpoint after managed
 * exit.
 *
 * The command id is the hex representation of the string "RAME" which denotes
 * (R)esume (A)fter (M)anaged (E)xit.
 */
#define CACTUS_RESUME_AFTER_MANAGED_EXIT U(0x52414d45)

static inline struct ffa_value cactus_resume_after_managed_exit(
	ffa_id_t source, ffa_id_t dest)
{
	return cactus_send_cmd(source, dest, CACTUS_RESUME_AFTER_MANAGED_EXIT,
				 0, 0, 0, 0);
}

/**
 * Request SP to pend an interrupt in the extended SPI range.
 *
 * The command is the hex representation of the string "espi".
 */
#define CACTUS_TRIGGER_ESPI_CMD U(0x65737069)
static inline struct ffa_value cactus_trigger_espi_cmd(
	ffa_id_t source, ffa_id_t dest, uint32_t espi_id)
{
	return cactus_send_cmd(source, dest, CACTUS_TRIGGER_ESPI_CMD,
				 espi_id, 0, 0, 0);
}

static inline uint32_t cactus_get_espi_id(struct ffa_value ret)
{
	return (uint32_t)ret.arg4;
}

/*
 * Request SP to mimic handling a RAS error delegated by an EL3 logical secure
 * partition.
 *
 * The command ID is the hex representation of the string 'rase' which
 * denotes RAS Error.
 */
#define CACTUS_RAS_DELEGATE_CMD U(0x72617365)

static inline struct ffa_value cactus_ras_delegate_send_cmd(
	ffa_id_t source, ffa_id_t dest, uint64_t event_id)
{
	return cactus_send_cmd(source, dest, CACTUS_RAS_DELEGATE_CMD, event_id, 0, 0,
			       0);
}

static inline uint64_t cactus_ras_get_event_id(struct ffa_value ret)
{
	return (uint64_t)ret.arg4;
}

/**
 * Request SP to send indirect message to FF-A endpoint.
 *
 * Command ID is string: MSGREQ.
 */
#define CACTUS_REQ_MSG_SEND_CMD U(0x4d5347524551a)

static inline struct ffa_value cactus_req_ind_msg_send_cmd(
	ffa_id_t source, ffa_id_t dest, ffa_id_t receiver,
	ffa_id_t sender, uint32_t flags)
{
	return cactus_send_cmd(source, dest, CACTUS_REQ_MSG_SEND_CMD,
			       flags, receiver, sender, 0);
}

static inline ffa_id_t cactus_msg_send_receiver(struct ffa_value ret)
{
	return (ffa_id_t)ret.arg5;
}

static inline ffa_id_t cactus_msg_send_sender(struct ffa_value ret)
{
	return (ffa_id_t)ret.arg6;
}

static inline uint64_t cactus_msg_send_flags(struct ffa_value ret)
{
	return (uint64_t)ret.arg4;
}

#endif