PSA: TFM import

components/TARGET_PSA/TARGET_TFM/COMPONENT_NSPE/interface/src/tfm_ns_lock_rtx.c

@@ -54,19 +54,23 @@ uint32_t tfm_ns_lock_dispatch(veneer_fn fn,
     }
 
     /* TFM request protected by NS lock */
-    osMutexAcquire(ns_lock.id,osWaitForever);
+    if (osMutexAcquire(ns_lock.id,osWaitForever) != osOK) {
+        return TFM_ERROR_GENERIC;
+    }
 
     result = fn(arg0, arg1, arg2, arg3);
 
-    osMutexRelease(ns_lock.id);
+    if (osMutexRelease(ns_lock.id) != osOK) {
+        return TFM_ERROR_GENERIC;
+    }
 
     return result;
 }
 
 /**
  * \brief NS world, Init NS lock
  */
-uint32_t tfm_ns_lock_init()
+enum tfm_status_e tfm_ns_lock_init()
 {
     if (ns_lock.init == false) {
         ns_lock.id = osMutexNew(&ns_lock_attrib);

components/TARGET_PSA/TARGET_TFM/COMPONENT_SPE/bl2/include/tfm_boot_status.h

@@ -197,6 +197,16 @@ struct shared_data_tlv_entry {
     uint16_t tlv_len; /* size of single TLV entry (including this header). */
 };
 
+/**
+ * \struct tfm_boot_data
+ *
+ * \brief Store the data for the runtime SW
+ */
+struct tfm_boot_data {
+    struct shared_data_tlv_header header;
+    uint8_t data[];
+};
+
 #define SHARED_DATA_ENTRY_HEADER_SIZE sizeof(struct shared_data_tlv_entry)
 #define SHARED_DATA_ENTRY_SIZE(size) (size + SHARED_DATA_ENTRY_HEADER_SIZE)
 

components/TARGET_PSA/TARGET_TFM/COMPONENT_SPE/secure_fw/core/ipc/include/tfm_spm.h

@@ -9,6 +9,7 @@
 
 #include <stdbool.h>
 #include "tfm_list.h"
+#include "tfm_secure_api.h"
 
 #ifndef TFM_SPM_MAX_ROT_SERV_NUM
 #define TFM_SPM_MAX_ROT_SERV_NUM        28
@@ -283,12 +284,15 @@ int32_t tfm_spm_check_client_version(struct tfm_spm_service_t *service,
  * \param[in] buffer        Pointer of memory reference
  * \param[in] len           Length of memory reference in bytes
  * \param[in] ns_caller     From non-secure caller
+ * \param[in] access        Type of access specified by the
+ *                          \ref tfm_memory_access_e
  *
  * \retval IPC_SUCCESS      Success
  * \retval IPC_ERROR_BAD_PARAMETERS Bad parameters input
  * \retval IPC_ERROR_MEMORY_CHECK Check failed
  */
-int32_t tfm_memory_check(void *buffer, size_t len, int32_t ns_caller);
+int32_t tfm_memory_check(void *buffer, size_t len, int32_t ns_caller,
+                         enum tfm_memory_access_e access);
 
 /* This function should be called before schedule function */
 void tfm_spm_init(void);

components/TARGET_PSA/TARGET_TFM/COMPONENT_SPE/secure_fw/core/ipc/psa_client.c

@@ -13,25 +13,25 @@
 __attribute__((naked))
 uint32_t psa_framework_version(void)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_FRAMEWORK_VERSION));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_FRAMEWORK_VERSION));
 }
 
 __attribute__((naked))
 uint32_t psa_version(uint32_t sid)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_VERSION));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_VERSION));
 }
 
 __attribute__((naked))
 psa_handle_t psa_connect(uint32_t sid, uint32_t minor_version)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_CONNECT));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_CONNECT));
 }
 
 __attribute__((naked))
@@ -41,15 +41,15 @@ psa_status_t psa_call(psa_handle_t handle,
                       psa_outvec *out_vec,
                       size_t out_len)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_CALL));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_CALL));
 }
 
 __attribute__((naked))
 void psa_close(psa_handle_t handle)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_CLOSE));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_CLOSE));
 }

components/TARGET_PSA/TARGET_TFM/COMPONENT_SPE/secure_fw/core/ipc/psa_service.c

@@ -15,82 +15,82 @@ __attribute__((naked))
 psa_signal_t psa_wait(psa_signal_t signal_mask, uint32_t timeout)
 
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_WAIT));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_WAIT));
 }
 
 __attribute__((naked))
 psa_status_t psa_get(psa_signal_t signal, psa_msg_t *msg)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_GET));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_GET));
 }
 
 __attribute__((naked))
 void psa_set_rhandle(psa_handle_t msg_handle, void *rhandle)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_SET_RHANDLE));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_SET_RHANDLE));
 }
 
 __attribute__((naked))
 size_t psa_read(psa_handle_t msg_handle, uint32_t invec_idx,
                 void *buffer, size_t num_bytes)
 
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_READ));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_READ));
 }
 
 __attribute__((naked))
 size_t psa_skip(psa_handle_t msg_handle, uint32_t invec_idx, size_t num_bytes)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_SKIP));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_SKIP));
 }
 
 __attribute__((naked))
 void psa_write(psa_handle_t msg_handle, uint32_t outvec_idx,
                const void *buffer, size_t num_bytes)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_WRITE));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_WRITE));
 }
 
 __attribute__((naked))
 void psa_reply(psa_handle_t msg_handle, psa_status_t retval)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_REPLY));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_REPLY));
 }
 
 __attribute__((naked))
 void psa_notify(int32_t partition_id)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_NOTIFY));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_NOTIFY));
 }
 
 __attribute__((naked))
 void psa_clear(void)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_CLEAR));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_CLEAR));
 }
 
 __attribute__((naked))
 void psa_eoi(psa_signal_t irq_signal)
 {
-    __ASM("SVC %0           \n"
-          "BX LR            \n"
-          : : "I" (TFM_SVC_PSA_EOI));
+    __ASM volatile("SVC %0           \n"
+                   "BX LR            \n"
+                   : : "I" (TFM_SVC_PSA_EOI));
 }

components/TARGET_PSA/TARGET_TFM/COMPONENT_SPE/secure_fw/core/ipc/tfm_arch_v8m.c

@@ -94,7 +94,7 @@ void tfm_initialize_context(struct tfm_state_context *ctx,
 #if defined(__ARM_ARCH_8M_MAIN__)
 __attribute__((naked)) void PendSV_Handler(void)
 {
-    __ASM(
+    __ASM volatile(
         "mrs     r0, psp                    \n"
         "mrs     r1, psplim                 \n"
         "push    {r0, r1, r2, lr}           \n"
@@ -111,7 +111,7 @@ __attribute__((naked)) void PendSV_Handler(void)
 #elif defined(__ARM_ARCH_8M_BASE__)
 __attribute__((naked)) void PendSV_Handler(void)
 {
-    __ASM(
+    __ASM volatile(
         "mrs     r0, psp                    \n"
         "mrs     r1, psplim                 \n"
         "push    {r0, r1, r2, lr}           \n"
@@ -143,14 +143,14 @@ __attribute__((naked)) void PendSV_Handler(void)
 /* Reserved for future usage */
 __attribute__((naked)) void MemManage_Handler(void)
 {
-    __ASM("b    .");
+    __ASM volatile("b    .");
 }
 
 __attribute__((naked)) void BusFault_Handler(void)
 {
-    __ASM("b    .");
+    __ASM volatile("b    .");
 }
 __attribute__((naked)) void UsageFault_Handler(void)
 {
-    __ASM("b    .");
+    __ASM volatile("b    .");
 }

components/TARGET_PSA/TARGET_TFM/COMPONENT_SPE/secure_fw/core/ipc/tfm_spm.c

@@ -12,6 +12,7 @@
 #include "psa_client.h"
 #include "psa_service.h"
 #include "tfm_utils.h"
+#include "platform/include/tfm_spm_hal.h"
 #include "spm_api.h"
 #include "spm_db.h"
 #include "spm_db_setup.h"
@@ -460,46 +461,11 @@ static uint32_t tfm_spm_partition_get_priority_ext(uint32_t partition_idx)
                     partition_priority;
 }
 
-/* Macros to pick linker symbols and allow references to sections in all level*/
-#define REGION_DECLARE_EXT(a, b, c) extern uint32_t REGION_NAME(a, b, c)
-
-REGION_DECLARE_EXT(Image$$, ARM_LIB_HEAP, $$ZI$$Base);
-REGION_DECLARE_EXT(Image$$, ARM_LIB_HEAP, $$ZI$$Limit);
-REGION_DECLARE_EXT(Image$$, ER_TFM_DATA, $$ZI$$Base);
-REGION_DECLARE_EXT(Image$$, ER_TFM_DATA, $$ZI$$Limit);
-REGION_DECLARE_EXT(Image$$, ER_TFM_DATA, $$RW$$Base);
-REGION_DECLARE_EXT(Image$$, ER_TFM_DATA, $$RW$$Limit);
-REGION_DECLARE_EXT(Image$$, TFM_SECURE_STACK, $$ZI$$Base);
-REGION_DECLARE_EXT(Image$$, TFM_SECURE_STACK, $$ZI$$Limit);
-REGION_DECLARE_EXT(Image$$, TFM_UNPRIV_SCRATCH, $$ZI$$Base);
-REGION_DECLARE_EXT(Image$$, TFM_UNPRIV_SCRATCH, $$ZI$$Limit);
-
-/*
- * \brief                         Check the memory whether in the given range.
- *
- * \param[in] buffer              Pointer of memory reference
- * \param[in] len                 Length of memory reference in bytes
- * \param[in] base                The base address
- * \param[in] limit               The limit address, the first byte of next
- *                                area memory
- *
- * \retval IPC_SUCCESS            Success
- * \retval IPC_ERROR_MEMORY_CHECK Check failed
- */
-static int32_t memory_check_range(const void *buffer, size_t len,
-                                  uintptr_t base, uintptr_t limit)
-{
-    if (((uintptr_t)buffer >= base) &&
-        ((uintptr_t)((uint8_t *)buffer + len - 1) < limit)) {
-        return IPC_SUCCESS;
-    }
-    return IPC_ERROR_MEMORY_CHECK;
-}
-
 /* FixMe: This is only valid for TFM LVL 1 now */
-int32_t tfm_memory_check(void *buffer, size_t len, int32_t ns_caller)
+int32_t tfm_memory_check(void *buffer, size_t len, int32_t ns_caller,
+                         enum tfm_memory_access_e access)
 {
-    uintptr_t base, limit;
+    int32_t err;
 
     /* If len is zero, this indicates an empty buffer and base is ignored */
     if (len == 0) {
@@ -514,55 +480,13 @@ int32_t tfm_memory_check(void *buffer, size_t len, int32_t ns_caller)
         return IPC_ERROR_MEMORY_CHECK;
     }
 
-    if (ns_caller) {
-        base = (uintptr_t)NS_DATA_START;
-        limit = (uintptr_t)(NS_DATA_START + NS_DATA_SIZE);
-        if (memory_check_range(buffer, len, base, limit) == IPC_SUCCESS) {
-            return IPC_SUCCESS;
-        }
-
-        base = (uintptr_t)NS_CODE_START;
-        limit = (uintptr_t)(NS_CODE_START + NS_CODE_SIZE);
-        if (memory_check_range(buffer, len, base, limit) == IPC_SUCCESS) {
-            return IPC_SUCCESS;
-        }
+    if (access == TFM_MEMORY_ACCESS_RW) {
+        err = tfm_core_has_write_access_to_region(buffer, len, ns_caller);
     } else {
-        base = (uintptr_t)&REGION_NAME(Image$$, ARM_LIB_HEAP, $$ZI$$Base);
-        limit = (uintptr_t)&REGION_NAME(Image$$, ARM_LIB_HEAP, $$ZI$$Limit);
-        if (memory_check_range(buffer, len, base, limit) == IPC_SUCCESS) {
-            return IPC_SUCCESS;
-        }
-
-        base = (uintptr_t)&REGION_NAME(Image$$, ER_TFM_DATA, $$RW$$Base);
-        limit = (uintptr_t)&REGION_NAME(Image$$, ER_TFM_DATA, $$RW$$Limit);
-        if (memory_check_range(buffer, len, base, limit) == IPC_SUCCESS) {
-            return IPC_SUCCESS;
-        }
-
-        base = (uintptr_t)&REGION_NAME(Image$$, ER_TFM_DATA, $$ZI$$Base);
-        limit = (uintptr_t)&REGION_NAME(Image$$, ER_TFM_DATA, $$ZI$$Limit);
-        if (memory_check_range(buffer, len, base, limit) == IPC_SUCCESS) {
-            return IPC_SUCCESS;
-        }
-
-        base = (uintptr_t)&REGION_NAME(Image$$, TFM_SECURE_STACK, $$ZI$$Base);
-        limit = (uintptr_t)&REGION_NAME(Image$$, TFM_SECURE_STACK, $$ZI$$Limit);
-        if (memory_check_range(buffer, len, base, limit) == IPC_SUCCESS) {
-            return IPC_SUCCESS;
-        }
-
-        base = (uintptr_t)&REGION_NAME(Image$$, TFM_UNPRIV_SCRATCH, $$ZI$$Base);
-        limit = (uintptr_t)&REGION_NAME(Image$$, TFM_UNPRIV_SCRATCH,
-                                        $$ZI$$Limit);
-        if (memory_check_range(buffer, len, base, limit) == IPC_SUCCESS) {
-            return IPC_SUCCESS;
-        }
-
-        base = (uintptr_t)S_CODE_START;
-        limit = (uintptr_t)(S_CODE_START + S_CODE_SIZE);
-        if (memory_check_range(buffer, len, base, limit) == IPC_SUCCESS) {
-            return IPC_SUCCESS;
-        }
+        err = tfm_core_has_read_access_to_region(buffer, len, ns_caller);
+    }
+    if (err == 1) {
+        return IPC_SUCCESS;
     }
 
     return IPC_ERROR_MEMORY_CHECK;