mirror of
https://github.com/ARM-software/arm-trusted-firmware.git
synced 2025-04-17 10:04:26 +00:00
f74e27723b
Enable the SPMC to handle calls to FFA_PARTITION_INFO_GET. This allows the normal world to discover which partitions are running in the secure world including logical partitions in EL3. This implementation supports both the v1.0 and v1.1 implementations of the Partition Info Get Descriptor. The SPMC populates the appropriate descriptor in the partitions RX buffer, if requested, according to the version of FF-A that the caller is using. Additionally rename the common/uuid UUID_H include guard due to a conflict with another header file. Signed-off-by: Marc Bonnici <marc.bonnici@arm.com> Change-Id: I0a85f1dae50fae1fe47a3cafb765fbe9f40619e1
254 lines
6 KiB
C
254 lines
6 KiB
C
/*
|
|
* Copyright (c) 2022, ARM Limited and Contributors. All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: BSD-3-Clause
|
|
*/
|
|
|
|
#ifndef SPMC_H
|
|
#define SPMC_H
|
|
|
|
#include <stdint.h>
|
|
|
|
#include <lib/psci/psci.h>
|
|
#include <lib/spinlock.h>
|
|
#include <services/el3_spmc_logical_sp.h>
|
|
#include "spm_common.h"
|
|
|
|
/*
|
|
* Ranges of FF-A IDs for Normal world and Secure world components. The
|
|
* convention matches that used by other SPMCs i.e. Hafnium and OP-TEE.
|
|
*/
|
|
#define FFA_NWD_ID_BASE 0x0
|
|
#define FFA_NWD_ID_LIMIT 0x7FFF
|
|
#define FFA_SWD_ID_BASE 0x8000
|
|
#define FFA_SWD_ID_LIMIT SPMD_DIRECT_MSG_ENDPOINT_ID - 1
|
|
#define FFA_SWD_ID_MASK 0x8000
|
|
|
|
/* ID 0 is reserved for the normal world entity, (Hypervisor or OS Kernel). */
|
|
#define FFA_NWD_ID U(0)
|
|
/* First ID is reserved for the SPMC */
|
|
#define FFA_SPMC_ID U(FFA_SWD_ID_BASE)
|
|
/* SP IDs are allocated after the SPMC ID */
|
|
#define FFA_SP_ID_BASE (FFA_SPMC_ID + 1)
|
|
/* Align with Hafnium implementation */
|
|
#define INV_SP_ID 0x7FFF
|
|
|
|
/* FF-A warm boot types. */
|
|
#define FFA_WB_TYPE_S2RAM 0
|
|
#define FFA_WB_TYPE_NOTS2RAM 1
|
|
|
|
#define FFA_PAGE_SIZE (4096)
|
|
#define FFA_RXTX_PAGE_COUNT_MASK 0x1F
|
|
|
|
/* Ensure that the page size used by TF-A is 4k aligned. */
|
|
CASSERT((PAGE_SIZE % FFA_PAGE_SIZE) == 0, assert_aligned_page_size);
|
|
|
|
/*
|
|
* Runtime states of an execution context as per the FF-A v1.1 specification.
|
|
*/
|
|
enum sp_runtime_states {
|
|
RT_STATE_WAITING,
|
|
RT_STATE_RUNNING,
|
|
RT_STATE_PREEMPTED,
|
|
RT_STATE_BLOCKED
|
|
};
|
|
|
|
/*
|
|
* Runtime model of an execution context as per the FF-A v1.1 specification. Its
|
|
* value is valid only if the execution context is not in the waiting state.
|
|
*/
|
|
enum sp_runtime_model {
|
|
RT_MODEL_DIR_REQ,
|
|
RT_MODEL_RUN,
|
|
RT_MODEL_INIT,
|
|
RT_MODEL_INTR
|
|
};
|
|
|
|
enum sp_runtime_el {
|
|
EL1 = 0,
|
|
S_EL0,
|
|
S_EL1
|
|
};
|
|
|
|
enum sp_execution_state {
|
|
SP_STATE_AARCH64 = 0,
|
|
SP_STATE_AARCH32
|
|
};
|
|
|
|
enum mailbox_state {
|
|
/* There is no message in the mailbox. */
|
|
MAILBOX_STATE_EMPTY,
|
|
|
|
/* There is a message that has been populated in the mailbox. */
|
|
MAILBOX_STATE_FULL,
|
|
};
|
|
|
|
struct mailbox {
|
|
enum mailbox_state state;
|
|
|
|
/* RX/TX Buffers. */
|
|
void *rx_buffer;
|
|
const void *tx_buffer;
|
|
|
|
/* Size of RX/TX Buffer. */
|
|
uint32_t rxtx_page_count;
|
|
|
|
/* Lock access to mailbox. */
|
|
spinlock_t lock;
|
|
};
|
|
|
|
/*
|
|
* Execution context members for an SP. This is a bit like struct
|
|
* vcpu in a hypervisor.
|
|
*/
|
|
struct sp_exec_ctx {
|
|
/*
|
|
* Store the stack address to restore C runtime context from after
|
|
* returning from a synchronous entry into the SP.
|
|
*/
|
|
uint64_t c_rt_ctx;
|
|
|
|
/* Space to maintain the architectural state of an SP. */
|
|
cpu_context_t cpu_ctx;
|
|
|
|
/* Track the current runtime state of the SP. */
|
|
enum sp_runtime_states rt_state;
|
|
|
|
/* Track the current runtime model of the SP. */
|
|
enum sp_runtime_model rt_model;
|
|
};
|
|
|
|
/*
|
|
* Structure to describe the cumulative properties of an SP.
|
|
*/
|
|
struct secure_partition_desc {
|
|
/*
|
|
* Execution contexts allocated to this endpoint. Ideally,
|
|
* we need as many contexts as there are physical cpus only
|
|
* for a S-EL1 SP which is MP-pinned.
|
|
*/
|
|
struct sp_exec_ctx ec[PLATFORM_CORE_COUNT];
|
|
|
|
/* ID of the Secure Partition. */
|
|
uint16_t sp_id;
|
|
|
|
/* Runtime EL. */
|
|
enum sp_runtime_el runtime_el;
|
|
|
|
/* Partition UUID. */
|
|
uint32_t uuid[4];
|
|
|
|
/* Partition Properties. */
|
|
uint32_t properties;
|
|
|
|
/* Supported FF-A Version. */
|
|
uint32_t ffa_version;
|
|
|
|
/* Execution State. */
|
|
enum sp_execution_state execution_state;
|
|
|
|
/* Mailbox tracking. */
|
|
struct mailbox mailbox;
|
|
|
|
/* Secondary entrypoint. Only valid for a S-EL1 SP. */
|
|
uintptr_t secondary_ep;
|
|
};
|
|
|
|
/*
|
|
* This define identifies the only SP that will be initialised and participate
|
|
* in FF-A communication. The implementation leaves the door open for more SPs
|
|
* to be managed in future but for now it is reasonable to assume that either a
|
|
* single S-EL0 or a single S-EL1 SP will be supported. This define will be used
|
|
* to identify which SP descriptor to initialise and manage during SP runtime.
|
|
*/
|
|
#define ACTIVE_SP_DESC_INDEX 0
|
|
|
|
/*
|
|
* Structure to describe the cumulative properties of the Hypervisor and
|
|
* NS-Endpoints.
|
|
*/
|
|
struct ns_endpoint_desc {
|
|
/*
|
|
* ID of the NS-Endpoint or Hypervisor.
|
|
*/
|
|
uint16_t ns_ep_id;
|
|
|
|
/*
|
|
* Mailbox tracking.
|
|
*/
|
|
struct mailbox mailbox;
|
|
|
|
/*
|
|
* Supported FF-A Version
|
|
*/
|
|
uint32_t ffa_version;
|
|
};
|
|
|
|
/**
|
|
* Holds information returned for each partition by the FFA_PARTITION_INFO_GET
|
|
* interface.
|
|
*/
|
|
struct ffa_partition_info_v1_0 {
|
|
uint16_t ep_id;
|
|
uint16_t execution_ctx_count;
|
|
uint32_t properties;
|
|
};
|
|
|
|
/* Extended structure for v1.1. */
|
|
struct ffa_partition_info_v1_1 {
|
|
uint16_t ep_id;
|
|
uint16_t execution_ctx_count;
|
|
uint32_t properties;
|
|
uint32_t uuid[4];
|
|
};
|
|
|
|
/* Setup Function for different SP types. */
|
|
void spmc_sp_common_setup(struct secure_partition_desc *sp,
|
|
entry_point_info_t *ep_info);
|
|
void spmc_el1_sp_setup(struct secure_partition_desc *sp,
|
|
entry_point_info_t *ep_info);
|
|
void spmc_sp_common_ep_commit(struct secure_partition_desc *sp,
|
|
entry_point_info_t *ep_info);
|
|
|
|
/*
|
|
* Helper function to perform a synchronous entry into a SP.
|
|
*/
|
|
uint64_t spmc_sp_synchronous_entry(struct sp_exec_ctx *ec);
|
|
|
|
/*
|
|
* Helper function to obtain the descriptor of the current SP on a physical cpu.
|
|
*/
|
|
struct secure_partition_desc *spmc_get_current_sp_ctx(void);
|
|
|
|
/*
|
|
* Helper function to obtain the execution context of an SP on a
|
|
* physical cpu.
|
|
*/
|
|
struct sp_exec_ctx *spmc_get_sp_ec(struct secure_partition_desc *sp);
|
|
|
|
/*
|
|
* Helper function to obtain the index of the execution context of an SP on a
|
|
* physical cpu.
|
|
*/
|
|
unsigned int get_ec_index(struct secure_partition_desc *sp);
|
|
|
|
uint64_t spmc_ffa_error_return(void *handle, int error_code);
|
|
|
|
/*
|
|
* Ensure a partition ID does not clash and follows the secure world convention.
|
|
*/
|
|
bool is_ffa_secure_id_valid(uint16_t partition_id);
|
|
|
|
/*
|
|
* Helper function to obtain the array storing the EL3
|
|
* Logical Partition descriptors.
|
|
*/
|
|
struct el3_lp_desc *get_el3_lp_array(void);
|
|
|
|
/*
|
|
* Helper function to obtain the RX/TX buffer pair descriptor of the Hypervisor
|
|
* or OS kernel in the normal world or the last SP that was run.
|
|
*/
|
|
struct mailbox *spmc_get_mbox_desc(bool secure_origin);
|
|
|
|
#endif /* SPMC_H */
|