aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorMate Toth-Pal <mate.toth-pal@arm.com>2018-02-26 17:58:18 +0100
committerMate Toth-Pal <mate.toth-pal@arm.com>2018-03-21 09:40:16 +0100
commit18b83929f31b16cfb013a93ab1622939c46ce6d2 (patch)
tree485ad5877864615113137ae637b3921f3b151f20
parent7de74b504522a7a90f6ebe905a3a93311c92770d (diff)
downloadtrusted-firmware-m-tfm-prototype-v0_1.tar.gz
Core: Separate the partition db config to two partstfm-prototype-v0_1
The partition db of TF-M contains fields that remain constant during execution, and some of them are used to store dynamically changing context information. This change groups the two kinds of fields in separate structures to highlight the distinction. Change-Id: I869504cb36010b54409a9963556f96ec1381bfbe Signed-off-by: Mate Toth-Pal <mate.toth-pal@arm.com>
-rw-r--r--secure_fw/core/tfm_secure_api.c45
-rw-r--r--secure_fw/spm/spm_api.c143
-rw-r--r--secure_fw/spm/spm_api.h90
-rw-r--r--secure_fw/spm/spm_db.h267
4 files changed, 232 insertions, 313 deletions
diff --git a/secure_fw/core/tfm_secure_api.c b/secure_fw/core/tfm_secure_api.c
index dd67eb65..55cd1b13 100644
--- a/secure_fw/core/tfm_secure_api.c
+++ b/secure_fw/core/tfm_secure_api.c
@@ -65,6 +65,7 @@ static uint32_t *prepare_partition_ctx(
static int32_t tfm_push_lock(struct tfm_sfn_req_s *desc_ptr, uint32_t lr)
{
uint32_t caller_partition_id = tfm_spm_partition_get_running_partition_id();
+ const struct spm_partition_runtime_data_t *curr_part_data;
if (caller_partition_id >= TFM_SP_BASE &&
/* Also check partition state consistency */
@@ -73,7 +74,10 @@ static int32_t tfm_push_lock(struct tfm_sfn_req_s *desc_ptr, uint32_t lr)
register uint32_t partition_id = desc_ptr->ss_id;
uint32_t psp = __get_PSP();
uint32_t partition_psp, partition_psplim;
- uint32_t partition_state = tfm_spm_partition_get_state(partition_id);
+ uint32_t partition_state;
+
+ curr_part_data = tfm_spm_partition_get_runtime_data(partition_id);
+ partition_state = curr_part_data->partition_state;
if (partition_state == SPM_PARTITION_STATE_RUNNING ||
partition_state == SPM_PARTITION_STATE_SUSPENDED ||
@@ -98,7 +102,7 @@ static int32_t tfm_push_lock(struct tfm_sfn_req_s *desc_ptr, uint32_t lr)
*/
tfm_spm_partition_set_stack(caller_partition_id, psp);
}
- partition_psp = tfm_spm_partition_get_stack(partition_id);
+ partition_psp = curr_part_data->stack_ptr;
partition_psplim = tfm_spm_partition_get_stack_bottom(partition_id);
#endif
/* Stack the context for the partition call */
@@ -163,8 +167,10 @@ static int32_t tfm_pop_lock(uint32_t *lr_ptr)
{
uint32_t current_partition_id =
tfm_spm_partition_get_running_partition_id();
+ const struct spm_partition_runtime_data_t *curr_part_data =
+ tfm_spm_partition_get_runtime_data(current_partition_id);
uint32_t return_partition_id =
- tfm_spm_partition_get_caller_partition_id(current_partition_id);
+ curr_part_data->caller_partition_id;
if (current_partition_id < TFM_SP_BASE) {
return TFM_SECURE_UNLOCK_FAILED;
@@ -182,21 +188,19 @@ static int32_t tfm_pop_lock(uint32_t *lr_ptr)
tfm_spm_partition_sandbox_config(return_partition_id);
/* Restore share status */
tfm_spm_partition_set_share(return_partition_id,
- tfm_spm_partition_get_share(return_partition_id));
+ tfm_spm_partition_get_runtime_data(return_partition_id)->share);
}
#endif
#if TFM_LVL == 1
- if (tfm_spm_partition_get_caller_partition_id(current_partition_id) ==
- TFM_SP_NON_SECURE_ID) {
+ if (return_partition_id == TFM_SP_NON_SECURE_ID) {
/* In TFM level 1 context restore is only done when
* returning to NS
*/
/* Restore caller PSP and LR ptr */
- __set_PSP(tfm_spm_partition_get_orig_psp(current_partition_id));
- __set_PSPLIM(
- tfm_spm_partition_get_orig_psplim(current_partition_id));
- *lr_ptr = tfm_spm_partition_get_orig_lr(current_partition_id);
+ __set_PSP(curr_part_data->orig_psp);
+ __set_PSPLIM(curr_part_data->orig_psplim);
+ *lr_ptr = curr_part_data->orig_lr;
}
#else
uint32_t psp = __get_PSP();
@@ -206,9 +210,9 @@ static int32_t tfm_pop_lock(uint32_t *lr_ptr)
current_partition_id, psp + SVC_STACK_FRAME_SIZE);
/* Restore caller PSP and LR ptr */
- __set_PSP(tfm_spm_partition_get_orig_psp(current_partition_id));
- __set_PSPLIM(tfm_spm_partition_get_orig_psplim(current_partition_id));
- *lr_ptr = tfm_spm_partition_get_orig_lr(current_partition_id);
+ __set_PSP(curr_part_data->orig_psp);
+ __set_PSPLIM(curr_part_data->orig_psplim);
+ *lr_ptr = curr_part_data->orig_lr;
#endif
/* Clear the context entry in the context stack before returning */
@@ -460,6 +464,8 @@ void tfm_core_validate_secure_caller_handler(uint32_t *svc_args)
int32_t res = TFM_ERROR_GENERIC;
uint32_t running_partition_id =
tfm_spm_partition_get_running_partition_id();
+ const struct spm_partition_runtime_data_t *curr_part_data =
+ tfm_spm_partition_get_runtime_data(running_partition_id);
if (running_partition_id == TFM_SP_NON_SECURE_ID) {
/* This handler shouldn't be called from outside partition context.
@@ -470,8 +476,7 @@ void tfm_core_validate_secure_caller_handler(uint32_t *svc_args)
}
/* Store return value in r0 */
- if (tfm_spm_partition_get_caller_partition_id(running_partition_id) !=
- TFM_SP_NON_SECURE_ID) {
+ if (curr_part_data->caller_partition_id != TFM_SP_NON_SECURE_ID) {
res = TFM_SUCCESS;
}
svc_args[0] = res;
@@ -487,6 +492,8 @@ void tfm_core_memory_permission_check_handler(uint32_t *svc_args)
int32_t res;
uint32_t running_partition_id =
tfm_spm_partition_get_running_partition_id();
+ const struct spm_partition_runtime_data_t *curr_part_data =
+ tfm_spm_partition_get_runtime_data(running_partition_id);
if ((running_partition_id == TFM_SP_NON_SECURE_ID) || (size == 0)) {
/* This handler shouldn't be called from outside partition context.
@@ -498,8 +505,7 @@ void tfm_core_memory_permission_check_handler(uint32_t *svc_args)
int32_t flags = 0;
- if (tfm_spm_partition_get_share(running_partition_id) !=
- TFM_BUFFER_SHARE_PRIV) {
+ if (curr_part_data->share != TFM_BUFFER_SHARE_PRIV) {
flags |= CMSE_MPU_UNPRIV;
}
@@ -687,8 +693,9 @@ void tfm_core_set_buffer_area_handler(uint32_t *args)
enum tfm_buffer_share_region_e share;
uint32_t running_partition_id =
tfm_spm_partition_get_running_partition_id();
- uint32_t caller_partition_id =
- tfm_spm_partition_get_caller_partition_id(running_partition_id);
+ const struct spm_partition_runtime_data_t *curr_part_data =
+ tfm_spm_partition_get_runtime_data(running_partition_id);
+ uint32_t caller_partition_id = curr_part_data->caller_partition_id;
/* tfm_core_set_buffer_area() returns int32_t */
int32_t *res_ptr = (int32_t *)&args[0];
diff --git a/secure_fw/spm/spm_api.c b/secure_fw/spm/spm_api.c
index a8856453..642b5773 100644
--- a/secure_fw/spm/spm_api.c
+++ b/secure_fw/spm/spm_api.c
@@ -39,20 +39,20 @@ typedef enum {
* returned.
*/
static void tfm_spm_partition_err_handler(
- struct spm_partition_region_t *partition,
+ struct spm_partition_desc_t *partition,
ss_error_type_t err_type,
int32_t err_code)
{
#ifdef TFM_CORE_DEBUG
if (err_type == TFM_INIT_FAILURE) {
printf("Partition init failed for partition id 0x%08X\r\n",
- partition->partition_id);
+ partition->static_data.partition_id);
} else {
printf("Unknown partition error %d for partition id 0x%08X\r\n",
- err_type, partition->partition_id);
+ err_type, partition->static_data.partition_id);
}
#endif
- tfm_spm_partition_set_state(partition->partition_id,
+ tfm_spm_partition_set_state(partition->static_data.partition_id,
SPM_PARTITION_STATE_CLOSED);
}
@@ -182,7 +182,7 @@ static enum spm_err_t tfm_spm_set_share_region(
enum spm_err_t tfm_spm_partition_init(void)
{
- struct spm_partition_region_t *serv;
+ struct spm_partition_desc_t *part;
int32_t fail_cnt = 0;
uint32_t i;
@@ -192,22 +192,22 @@ enum spm_err_t tfm_spm_partition_init(void)
* proper isolation during init.
*/
for (i = 0; i < g_spm_partition_db.partition_count; ++i) {
- serv = &g_spm_partition_db.partitions[i];
- if (serv->periph_start) {
- ppc_configure_to_secure(serv->periph_ppc_bank,
- serv->periph_ppc_loc);
+ part = &g_spm_partition_db.partitions[i];
+ if (part->static_data.periph_start) {
+ ppc_configure_to_secure(part->static_data.periph_ppc_bank,
+ part->static_data.periph_ppc_loc);
}
- if (serv->partition_init == NULL) {
- tfm_spm_partition_set_state(serv->partition_id,
+ if (part->static_data.partition_init == NULL) {
+ tfm_spm_partition_set_state(part->static_data.partition_id,
SPM_PARTITION_STATE_IDLE);
} else {
- int32_t ret = serv->partition_init();
+ int32_t ret = part->static_data.partition_init();
if (ret == TFM_SUCCESS) {
- tfm_spm_partition_set_state(
- serv->partition_id, SPM_PARTITION_STATE_IDLE);
+ tfm_spm_partition_set_state(part->static_data.partition_id,
+ SPM_PARTITION_STATE_IDLE);
} else {
- tfm_spm_partition_err_handler(serv, TFM_INIT_FAILURE, ret);
+ tfm_spm_partition_err_handler(part, TFM_INIT_FAILURE, ret);
fail_cnt++;
}
}
@@ -227,7 +227,7 @@ enum spm_err_t tfm_spm_partition_sandbox_config(uint32_t partition_id)
* SPM partition for that partition
*/
- struct spm_partition_region_t *serv;
+ struct spm_partition_desc_t *part;
struct mpu_armv8m_region_cfg_t region_cfg;
if (!g_spm_partition_db.is_init) {
@@ -235,7 +235,7 @@ enum spm_err_t tfm_spm_partition_sandbox_config(uint32_t partition_id)
}
/*brute force id*/
- serv = &g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)];
+ part = &g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)];
mpu_armv8m_disable(&dev_mpu_s);
@@ -243,8 +243,8 @@ enum spm_err_t tfm_spm_partition_sandbox_config(uint32_t partition_id)
/* RO region*/
region_cfg.region_nr = PARTITION_REGION_RO;
- region_cfg.region_base = serv->ro_start;
- region_cfg.region_limit = serv->ro_limit;
+ region_cfg.region_base = part->static_data.ro_start;
+ region_cfg.region_limit = part->static_data.ro_limit;
region_cfg.attr_access = MPU_ARMV8M_AP_RO_PRIV_UNPRIV;
region_cfg.attr_sh = MPU_ARMV8M_SH_NONE;
region_cfg.attr_exec = MPU_ARMV8M_XN_EXEC_OK;
@@ -253,25 +253,26 @@ enum spm_err_t tfm_spm_partition_sandbox_config(uint32_t partition_id)
/* RW, ZI and stack as one region*/
region_cfg.region_nr = PARTITION_REGION_RW_STACK;
- region_cfg.region_base = serv->rw_start;
- region_cfg.region_limit = serv->stack_top;
+ region_cfg.region_base = part->static_data.rw_start;
+ region_cfg.region_limit = part->static_data.stack_top;
region_cfg.attr_access = MPU_ARMV8M_AP_RW_PRIV_UNPRIV;
region_cfg.attr_sh = MPU_ARMV8M_SH_NONE;
region_cfg.attr_exec = MPU_ARMV8M_XN_EXEC_NEVER;
mpu_armv8m_region_enable(&dev_mpu_s, &region_cfg);
- if (serv->periph_start) {
+ if (part->static_data.periph_start) {
/* Peripheral */
region_cfg.region_nr = PARTITION_REGION_PERIPH;
- region_cfg.region_base = serv->periph_start;
- region_cfg.region_limit = serv->periph_limit;
+ region_cfg.region_base = part->static_data.periph_start;
+ region_cfg.region_limit = part->static_data.periph_limit;
region_cfg.attr_access = MPU_ARMV8M_AP_RW_PRIV_UNPRIV;
region_cfg.attr_sh = MPU_ARMV8M_SH_NONE;
region_cfg.attr_exec = MPU_ARMV8M_XN_EXEC_NEVER;
mpu_armv8m_region_enable(&dev_mpu_s, &region_cfg);
- ppc_en_secure_unpriv(serv->periph_ppc_bank, serv->periph_ppc_loc);
+ ppc_en_secure_unpriv(part->static_data.periph_ppc_bank,
+ part->static_data.periph_ppc_loc);
}
mpu_armv8m_enable(&dev_mpu_s, 1, 1);
@@ -313,13 +314,14 @@ enum spm_err_t tfm_spm_partition_sandbox_deconfig(uint32_t partition_id)
__ISB();
#endif
- struct spm_partition_region_t *serv;
+ struct spm_partition_desc_t *part;
- serv = &g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)];
+ part = &g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)];
- if (serv->periph_start) {
+ if (part->static_data.periph_start) {
/* Peripheral */
- ppc_clr_secure_unpriv(serv->periph_ppc_bank, serv->periph_ppc_loc);
+ ppc_clr_secure_unpriv(part->static_data.periph_ppc_bank,
+ part->static_data.periph_ppc_loc);
}
mpu_armv8m_disable(&dev_mpu_s);
@@ -332,70 +334,38 @@ enum spm_err_t tfm_spm_partition_sandbox_deconfig(uint32_t partition_id)
return SPM_ERR_OK;
}
-uint32_t tfm_spm_partition_get_stack(uint32_t partition_id)
-{
- return g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
- stack_ptr;
-}
-
uint32_t tfm_spm_partition_get_stack_bottom(uint32_t partition_id)
{
return g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
- stack_bottom;
+ static_data.stack_bottom;
}
uint32_t tfm_spm_partition_get_stack_top(uint32_t partition_id)
{
return
- g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].stack_top;
+ g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
+ static_data.stack_top;
}
void tfm_spm_partition_set_stack(uint32_t partition_id, uint32_t stack_ptr)
{
- g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].stack_ptr =
- stack_ptr;
+ g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
+ runtime_data.stack_ptr = stack_ptr;
}
#endif
-uint32_t tfm_spm_partition_get_state(uint32_t partition_id)
-{
- return g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
- partition_state;
-}
-
-uint32_t tfm_spm_partition_get_caller_partition_id(uint32_t partition_id)
-{
- return g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
- caller_partition_id;
-}
-uint32_t tfm_spm_partition_get_orig_psp(uint32_t partition_id)
+const struct spm_partition_runtime_data_t *
+ tfm_spm_partition_get_runtime_data(uint32_t partition_id)
{
- return
- g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].orig_psp;
-}
-
-uint32_t tfm_spm_partition_get_orig_psplim(uint32_t partition_id)
-{
- return g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
- orig_psplim;
-}
-
-uint32_t tfm_spm_partition_get_orig_lr(uint32_t partition_id)
-{
- return g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
- orig_lr;
-}
-
-uint32_t tfm_spm_partition_get_share(uint32_t partition_id)
-{
- return g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].share;
+ return &(g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
+ runtime_data);
}
void tfm_spm_partition_set_state(uint32_t partition_id, uint32_t state)
{
g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
- partition_state = state;
+ runtime_data.partition_state = state;
if (state == SPM_PARTITION_STATE_RUNNING) {
g_spm_partition_db.running_partition_id = partition_id;
}
@@ -405,27 +375,27 @@ void tfm_spm_partition_set_caller_partition_id(uint32_t partition_id,
uint32_t caller_partition_id)
{
g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
- caller_partition_id = caller_partition_id;
+ runtime_data.caller_partition_id = caller_partition_id;
}
void tfm_spm_partition_set_orig_psp(uint32_t partition_id,
uint32_t orig_psp)
{
- g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].orig_psp =
- orig_psp;
+ g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
+ runtime_data.orig_psp = orig_psp;
}
void tfm_spm_partition_set_orig_psplim(uint32_t partition_id,
uint32_t orig_psplim)
{
- g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].orig_psplim =
- orig_psplim;
+ g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
+ runtime_data.orig_psplim = orig_psplim;
}
void tfm_spm_partition_set_orig_lr(uint32_t partition_id, uint32_t orig_lr)
{
- g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].orig_lr =
- orig_lr;
+ g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
+ runtime_data.orig_lr = orig_lr;
}
enum spm_err_t tfm_spm_partition_set_share(uint32_t partition_id,
@@ -439,8 +409,8 @@ enum spm_err_t tfm_spm_partition_set_share(uint32_t partition_id,
#endif
if (ret == SPM_ERR_OK) {
- g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].share =
- share;
+ g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)].
+ runtime_data.share = share;
}
return ret;
}
@@ -452,12 +422,11 @@ uint32_t tfm_spm_partition_get_running_partition_id(void)
void tfm_spm_partition_cleanup_context(uint32_t partition_id)
{
- struct spm_partition_region_t *partition =
+ struct spm_partition_desc_t *partition =
&g_spm_partition_db.partitions[PARTITION_ID_GET(partition_id)];
- partition->partition_state = 0;
- partition->caller_partition_id = 0;
- partition->orig_psp = 0;
- partition->orig_psplim = 0;
- partition->orig_lr = 0;
- partition->share = 0;
+ partition->runtime_data.caller_partition_id = 0;
+ partition->runtime_data.orig_psp = 0;
+ partition->runtime_data.orig_psplim = 0;
+ partition->runtime_data.orig_lr = 0;
+ partition->runtime_data.share = 0;
}
diff --git a/secure_fw/spm/spm_api.h b/secure_fw/spm/spm_api.h
index ca4994c8..039506c5 100644
--- a/secure_fw/spm/spm_api.h
+++ b/secure_fw/spm/spm_api.h
@@ -30,6 +30,21 @@ enum spm_part_state_t {
};
/**
+ * \brief Runtime context information of a partition
+ */
+struct spm_partition_runtime_data_t {
+ uint32_t partition_state;
+ uint32_t caller_partition_id;
+ uint32_t orig_psp;
+ uint32_t orig_psplim;
+ uint32_t orig_lr;
+ uint32_t share;
+#if TFM_LVL != 1
+ uint32_t stack_ptr;
+#endif
+};
+
+/**
* \brief Configure isolated sandbox for a partition
*
* \param[in] partition_id Partition id
@@ -52,17 +67,6 @@ enum spm_err_t tfm_spm_partition_sandbox_config(uint32_t partition_id);
enum spm_err_t tfm_spm_partition_sandbox_deconfig(uint32_t partition_id);
/**
- * \brief Get saved stack pointer for a partition
- *
- * \param[in] partition_id Partition id
- *
- * \return Stack pointer value
- *
- * \note This function doesn't check if partition_id is valid.
- */
-uint32_t tfm_spm_partition_get_stack(uint32_t partition_id);
-
-/**
* \brief Get bottom of stack region for a partition
*
* \param[in] partition_id Partition id
@@ -85,72 +89,16 @@ uint32_t tfm_spm_partition_get_stack_bottom(uint32_t partition_id);
uint32_t tfm_spm_partition_get_stack_top(uint32_t partition_id);
/**
- * \brief Get the current state of a partition
- *
- * \param[in] partition_id Partition id
- *
- * \return The state of the specified partition
- *
- * \note This function doesn't check if partition_id is valid.
- * \note The returned value has the value set of \ref spm_part_state_t.
- */
-uint32_t tfm_spm_partition_get_state(uint32_t partition_id);
-
-/**
- * \brief Get the Id of the caller of the partition given
- *
- * \param[in] partition_id Partition id to get the caller of
- *
- * \return The Id of the caller partition
- *
- * \note This function doesn't check if partition_id is valid.
- */
-uint32_t tfm_spm_partition_get_caller_partition_id(uint32_t partition_id);
-
-/**
- * \brief Get the original PSP of the partition
- *
- * \param[in] partition_id Partition id
- *
- * \return The original PSP of the partition
- *
- * \note This function doesn't check if partition_id is valid.
- */
-uint32_t tfm_spm_partition_get_orig_psp(uint32_t partition_id);
-
-/**
- * \brief Get the original PSP limit of the partition
- *
- * \param[in] partition_id Partition id
- *
- * \return The original PSP limit of the partition
- *
- * \note This function doesn't check if partition_id is valid.
- */
-uint32_t tfm_spm_partition_get_orig_psplim(uint32_t partition_id);
-
-/**
- * \brief Get the original link register value of the partition
- *
- * \param[in] partition_id Partition id
- *
- * \return The original link register value of the partition
- *
- * \note This function doesn't check if partition_id is valid.
- */
-uint32_t tfm_spm_partition_get_orig_lr(uint32_t partition_id);
-
-/**
- * \brief Get the buffer share region of the partition
+ * \brief Get the current runtime data of a partition
*
* \param[in] partition_id Partition id
*
- * \return The buffer share region of the partition
+ * \return The runtime data of the specified partition
*
* \note This function doesn't check if partition_id is valid.
- * \note The returned value has the value set of \ref tfm_buffer_share_region_e
*/
-uint32_t tfm_spm_partition_get_share(uint32_t partition_id);
+const struct spm_partition_runtime_data_t *
+ tfm_spm_partition_get_runtime_data(uint32_t partition_id);
/**
* \brief Returns the id of the partition that has running state
diff --git a/secure_fw/spm/spm_db.h b/secure_fw/spm/spm_db.h
index 5c6d1b4d..01aed35b 100644
--- a/secure_fw/spm/spm_db.h
+++ b/secure_fw/spm/spm_db.h
@@ -20,31 +20,9 @@
typedef int32_t(*sp_init_function)(void);
-#if TFM_LVL == 1
-struct spm_partition_region_t {
+struct spm_partition_static_data_t {
uint32_t partition_id;
- uint32_t partition_state;
- uint32_t caller_partition_id;
- uint32_t orig_psp;
- uint32_t orig_psplim;
- uint32_t orig_lr;
- uint32_t share;
- uint32_t stack_ptr;
- uint32_t periph_start;
- uint32_t periph_limit;
- uint16_t periph_ppc_bank;
- uint16_t periph_ppc_loc;
- sp_init_function partition_init;
-};
-#else
-struct spm_partition_region_t {
- uint32_t partition_id;
- uint32_t partition_state;
- uint32_t caller_partition_id;
- uint32_t orig_psp;
- uint32_t orig_psplim;
- uint32_t orig_lr;
- uint32_t share;
+#if TFM_LVL != 1
uint32_t code_start;
uint32_t code_limit;
uint32_t ro_start;
@@ -55,20 +33,24 @@ struct spm_partition_region_t {
uint32_t zi_limit;
uint32_t stack_bottom;
uint32_t stack_top;
- uint32_t stack_ptr;
+#endif
uint32_t periph_start;
uint32_t periph_limit;
uint16_t periph_ppc_bank;
uint16_t periph_ppc_loc;
sp_init_function partition_init;
};
-#endif
+
+struct spm_partition_desc_t {
+ struct spm_partition_static_data_t static_data;
+ struct spm_partition_runtime_data_t runtime_data;
+};
struct spm_partition_db_t {
uint32_t is_init;
uint32_t partition_count;
uint32_t running_partition_id;
- struct spm_partition_region_t partitions[SPM_MAX_PARTITIONS];
+ struct spm_partition_desc_t partitions[SPM_MAX_PARTITIONS];
};
/* Macros to pick linker symbols and allow to form the partition data base */
@@ -78,6 +60,8 @@ struct spm_partition_db_t {
#define REGION_DECLARE(a, b, c)
#else
#define REGION_DECLARE(a, b, c) extern uint32_t REGION_NAME(a, b, c)
+#define PART_REGION_ADDR(partition, region) \
+ (uint32_t)&REGION_NAME(Image$$, partition, region)
#endif
#define PARTITION_DECLARE(partition) \
@@ -94,123 +78,134 @@ struct spm_partition_db_t {
#if TFM_LVL == 1
-#define PARTITION_ADD(partition) { \
- if (index >= max_partitions) { \
- return max_partitions; \
- } \
- db_ptr = (uint32_t *)&(db->partitions[index]); \
- *db_ptr++ = partition##_ID; \
- *db_ptr++ = SPM_PARTITION_STATE_UNINIT; /* partition_state */ \
- *db_ptr++ = 0U; /* caller partition id */ \
- *db_ptr++ = 0U; /* original psp */ \
- *db_ptr++ = 0U; /* original psplim */ \
- *db_ptr++ = 0U; /* original lr */ \
- *db_ptr++ = 0U; /* share */ \
- *db_ptr++ = 0U; /* stack pointer on partition enter */ \
- *db_ptr++ = 0U; /* peripheral start */ \
- *db_ptr++ = 0U; /* peripheral limit */ \
- *db_ptr++ = 0U; /* uint16_t[2] peripheral bank/loc */ \
- *db_ptr++ = 0U; /* partition init function*/ \
- index++; \
- }
+#define PARTITION_INIT_STATIC_DATA(data, partition) \
+ data.partition_id = partition##_ID; \
+ data.periph_start = 0U; \
+ data.periph_limit = 0U; \
+ data.periph_ppc_bank = 0U; \
+ data.periph_ppc_loc = 0U; \
+ data.partition_init = 0U
#else
-#define PARTITION_ADD(partition) { \
- if (index >= max_partitions) { \
- return max_partitions; \
- } \
- db_ptr = (uint32_t *)&(db->partitions[index]); \
- *db_ptr++ = partition##_ID; \
- *db_ptr++ = SPM_PARTITION_STATE_UNINIT; /* partition_state */ \
- *db_ptr++ = 0U; /* caller partition id */ \
- *db_ptr++ = 0U; /* original psp */ \
- *db_ptr++ = 0U; /* original psplim */ \
- *db_ptr++ = 0U; /* original lr */ \
- *db_ptr++ = 0U; /* share */ \
- *db_ptr++ = (uint32_t)&REGION_NAME(Image$$, partition, $$Base); \
- *db_ptr++ = (uint32_t)&REGION_NAME(Image$$, partition, $$Limit); \
- *db_ptr++ = (uint32_t)&REGION_NAME(Image$$, partition, $$RO$$Base); \
- *db_ptr++ = (uint32_t)&REGION_NAME(Image$$, partition, $$RO$$Limit); \
- *db_ptr++ = (uint32_t)&REGION_NAME(Image$$, partition, _DATA$$RW$$Base); \
- *db_ptr++ = (uint32_t)&REGION_NAME(Image$$, partition, _DATA$$RW$$Limit); \
- *db_ptr++ = (uint32_t)&REGION_NAME(Image$$, partition, _DATA$$ZI$$Base); \
- *db_ptr++ = (uint32_t)&REGION_NAME(Image$$, partition, _DATA$$ZI$$Limit); \
- *db_ptr++ = (uint32_t)&REGION_NAME(Image$$, partition, _STACK$$ZI$$Base); \
- *db_ptr++ = (uint32_t)&REGION_NAME(Image$$, partition, _STACK$$ZI$$Limit); \
- *db_ptr++ = (uint32_t)&REGION_NAME(Image$$, partition, _STACK$$ZI$$Limit); \
- *db_ptr++ = 0U; /* peripheral start */ \
- *db_ptr++ = 0U; /* peripheral limit */ \
- *db_ptr++ = 0U; /* uint16_t[2] peripheral bank/loc */ \
- *db_ptr++ = 0U; /* partition init function*/ \
- index++; \
-}
+#define PARTITION_INIT_STATIC_DATA(data, partition) \
+ data.partition_id = partition##_ID; \
+ data.code_start = PART_REGION_ADDR(partition, $$Base); \
+ data.code_limit = PART_REGION_ADDR(partition, $$Limit); \
+ data.ro_start = PART_REGION_ADDR(partition, $$RO$$Base); \
+ data.ro_limit = PART_REGION_ADDR(partition, $$RO$$Limit); \
+ data.rw_start = PART_REGION_ADDR(partition, _DATA$$RW$$Base); \
+ data.rw_limit = PART_REGION_ADDR(partition, _DATA$$RW$$Limit); \
+ data.zi_start = PART_REGION_ADDR(partition, _DATA$$ZI$$Base); \
+ data.zi_limit = PART_REGION_ADDR(partition, _DATA$$ZI$$Limit); \
+ data.stack_bottom = PART_REGION_ADDR(partition, _STACK$$ZI$$Base); \
+ data.stack_top = PART_REGION_ADDR(partition, _STACK$$ZI$$Limit); \
+ data.periph_start = 0U; \
+ data.periph_limit = 0U; \
+ data.periph_ppc_bank = 0U; \
+ data.periph_ppc_loc = 0U; \
+ data.partition_init = 0U
#endif
#if TFM_LVL == 1
-#define DUMMY_PARTITION_ADD(partition) { \
- if (index >= max_partitions) { \
- return max_partitions; \
- } \
- db_ptr = (uint32_t *)&(db->partitions[index]); \
- *db_ptr++ = partition##_ID; \
- *db_ptr++ = SPM_PARTITION_STATE_UNINIT; /* partition_state */ \
- *db_ptr++ = 0U; /* caller partition id */ \
- *db_ptr++ = 0U; /* original psp */ \
- *db_ptr++ = 0U; /* original psplim */ \
- *db_ptr++ = 0U; /* original lr */ \
- *db_ptr++ = 0U; /* share */ \
- *db_ptr++ = 0U; /* stack pointer on partition enter */ \
- *db_ptr++ = 0U; /* peripheral start */ \
- *db_ptr++ = 0U; /* peripheral limit */ \
- *db_ptr++ = 0U; /* uint16_t[2] peripheral bank/loc */ \
- *db_ptr++ = 0U; /* partition init function*/ \
- index++; \
- }
+#define DUMMY_PARTITION_INIT_STATIC_DATA(data, partition) \
+ /* In case of TFM_LVL1 the static data is initialised the same way */ \
+ PARTITION_INIT_STATIC_DATA(data, partition)
#else
-#define DUMMY_PARTITION_ADD(partition) { \
- if (index >= max_partitions) { \
- return max_partitions; \
- } \
- db_ptr = (uint32_t *)&(db->partitions[index]); \
- *db_ptr++ = partition##_ID; \
- *db_ptr++ = SPM_PARTITION_STATE_UNINIT; /* partition_state */ \
- *db_ptr++ = 0U; /* caller partition id */ \
- *db_ptr++ = 0U; /* original_psp */ \
- *db_ptr++ = 0U; /* original_psplim */ \
- *db_ptr++ = 0U; /* original_lr */ \
- *db_ptr++ = 0U; /* share */ \
- *db_ptr++ = 0U; \
- *db_ptr++ = 0U; \
- *db_ptr++ = 0U; \
- *db_ptr++ = 0U; \
- *db_ptr++ = 0U; \
- *db_ptr++ = 0U; \
- *db_ptr++ = 0U; \
- *db_ptr++ = 0U; \
- *db_ptr++ = 0U; \
- *db_ptr++ = 0U; \
- *db_ptr++ = 0U; \
- *db_ptr++ = 0U; /* peripheral start */ \
- *db_ptr++ = 0U; /* peripheral limit */ \
- *db_ptr++ = 0U; /* uint16_t[2] peripheral bank/loc */ \
- *db_ptr++ = 0U; /* partition init function*/ \
- index++; \
-}
+#define DUMMY_PARTITION_INIT_STATIC_DATA(data, partition) \
+ data.partition_id = partition##_ID; \
+ data.code_start = 0U; \
+ data.code_limit = 0U; \
+ data.ro_start = 0U; \
+ data.ro_limit = 0U; \
+ data.rw_start = 0U; \
+ data.rw_limit = 0U; \
+ data.zi_start = 0U; \
+ data.zi_limit = 0U; \
+ data.stack_bottom = 0U; \
+ data.stack_top = 0U; \
+ data.periph_start = 0U; \
+ data.periph_limit = 0U; \
+ data.periph_ppc_bank = 0U; \
+ data.periph_ppc_loc = 0U; \
+ data.partition_init = 0U
+#endif
+
+
+#if TFM_LVL == 1
+#define PARTITION_INIT_RUNTIME_DATA(data, partition) \
+ data.partition_state = SPM_PARTITION_STATE_UNINIT; \
+ data.caller_partition_id = 0U; \
+ data.orig_psp = 0U; \
+ data.orig_psplim = 0U; \
+ data.orig_lr = 0U; \
+ data.share = 0U
+#else
+#define PARTITION_INIT_RUNTIME_DATA(data, partition) \
+ data.partition_state = SPM_PARTITION_STATE_UNINIT; \
+ data.caller_partition_id = 0U; \
+ data.orig_psp = 0U; \
+ data.orig_psplim = 0U; \
+ data.orig_lr = 0U; \
+ data.share = 0U; \
+ data.stack_ptr = PART_REGION_ADDR(partition, _STACK$$ZI$$Limit)
#endif
-#define PARTITION_ADD_PERIPHERAL(partition, start, limit, bank, loc) { \
- db_ptr = \
- (uint32_t *)&(db->partitions[PARTITION_ID_GET(partition##_ID)]);\
- ((struct spm_partition_region_t *)db_ptr)->periph_start = start; \
- ((struct spm_partition_region_t *)db_ptr)->periph_limit = limit; \
- ((struct spm_partition_region_t *)db_ptr)->periph_ppc_bank = bank; \
- ((struct spm_partition_region_t *)db_ptr)->periph_ppc_loc = loc; \
+#if TFM_LVL == 1
+#define DUMMY_PARTITION_INIT_RUNTIME_DATA(data, partition) \
+ data.partition_state = SPM_PARTITION_STATE_UNINIT; \
+ data.caller_partition_id = 0U; \
+ data.orig_psp = 0U; \
+ data.orig_psplim = 0U; \
+ data.orig_lr = 0U; \
+ data.share = 0U
+#else
+#define DUMMY_PARTITION_INIT_RUNTIME_DATA(data, partition) \
+ data.partition_state = SPM_PARTITION_STATE_UNINIT; \
+ data.caller_partition_id = 0U; \
+ data.orig_psp = 0U; \
+ data.orig_psplim = 0U; \
+ data.orig_lr = 0U; \
+ data.share = 0U; \
+ data.stack_ptr = 0U
+#endif
+
+#define PARTITION_ADD(partition) { \
+ if (index >= max_partitions) { \
+ return max_partitions; \
+ } \
+ part_ptr = (struct spm_partition_desc_t *)&(db->partitions[index]); \
+ PARTITION_INIT_STATIC_DATA(part_ptr->static_data, partition); \
+ PARTITION_INIT_RUNTIME_DATA(part_ptr->runtime_data, partition); \
+ index++; \
+ }
+
+#define DUMMY_PARTITION_ADD(partition) { \
+ if (index >= max_partitions) { \
+ return max_partitions; \
+ } \
+ part_ptr = (struct spm_partition_desc_t *)&(db->partitions[index]); \
+ DUMMY_PARTITION_INIT_STATIC_DATA(part_ptr->static_data, partition); \
+ /* The runtime data is the same for the dummy partitions*/ \
+ DUMMY_PARTITION_INIT_RUNTIME_DATA(part_ptr->runtime_data, partition); \
+ index++; \
+ }
+
+#define PARTITION_ADD_PERIPHERAL(partition, start, limit, bank, loc) { \
+ part_ptr = &(db->partitions[PARTITION_ID_GET(partition##_ID)]); \
+ ((struct spm_partition_desc_t *)part_ptr)-> \
+ static_data.periph_start = start; \
+ ((struct spm_partition_desc_t *)part_ptr)-> \
+ static_data.periph_limit = limit; \
+ ((struct spm_partition_desc_t *)part_ptr)-> \
+ static_data.periph_ppc_bank = bank; \
+ ((struct spm_partition_desc_t *)part_ptr)-> \
+ static_data.periph_ppc_loc = loc; \
}
-#define PARTITION_ADD_INIT_FUNC(partition, init_func) { \
- extern int32_t init_func(void); \
- db_ptr = \
- (uint32_t *)&(db->partitions[PARTITION_ID_GET(partition##_ID)]);\
- ((struct spm_partition_region_t *)db_ptr)->partition_init = init_func; \
+#define PARTITION_ADD_INIT_FUNC(partition, init_func) { \
+ extern int32_t init_func(void); \
+ part_ptr = &(db->partitions[PARTITION_ID_GET(partition##_ID)]); \
+ ((struct spm_partition_desc_t *)part_ptr)-> \
+ static_data.partition_init = init_func; \
}
/*This file is meant to be included twice*/
@@ -222,7 +217,7 @@ uint32_t create_user_partition_db(struct spm_partition_db_t *db,
uint32_t max_partitions)
{
uint32_t index = 0;
- uint32_t *db_ptr;
+ struct spm_partition_desc_t *part_ptr;
#include "user_service_defines.inc"