#include <setjmp.h>
#include <stdio.h>
#include <pico/runtime.h>
#include <pico/stdio.h>
#include <pico/unique_id.h>
#include <arch/arm/cortex-m/stk_arch_arm-tz.h>
#include "example.h"
#if (__ARM_FEATURE_CMSE & 1) == 0
#error "Need ARMv8-M security extensions"
#elif (__ARM_FEATURE_CMSE & 2) == 0
#error "Compile with --mcmse"
#endif
#if !STK_MPU || !STK_MPU_STACK_GUARD
#error "This example requires STK_MPU=1 and STK_MPU_STACK_GUARD=1 in stk_config.h"
#endif
#ifdef _PICO_H
#else
#endif
#define TASK_NS_COUNT (4U)
#define TASK_S_COUNT (1U)
#define TASK_COUNT (TASK_NS_COUNT + TASK_S_COUNT)
#define KERNEL_TYPE KERNEL_STATIC
__attribute__((section(
".secure_data"))) uint32_t s_Counter = 0U;
{
enum EId
{
CMD_NONE = 0,
CMD_LED_ON = 1
};
EId id;
};
{
}
{
}
{
uint32_t result = 0;
if (cmse_check_address_range(key, size, CMSE_NONSECURE | CMSE_MPU_READWRITE) != nullptr)
{
if (size == 4)
{
key[0] = 1;
key[1] = 2;
key[2] = 3;
key[3] = 4;
result = 4;
}
}
return result;
}
{
{
}
else
{
}
}
{
extern char __stk_mpu_shared_data_start[];
extern char __stk_mpu_shared_data_end[];
extern char __stk_mpu_shared_data_source__[];
extern char __stk_mpu_shared_bss_start[];
extern char __stk_mpu_shared_bss_end[];
const size_t data_size = __stk_mpu_shared_data_end - __stk_mpu_shared_data_start;
if (data_size > 0)
{
STK_MEMCPY(__stk_mpu_shared_data_start, __stk_mpu_shared_data_source__, data_size);
}
const size_t bss_size = __stk_mpu_shared_bss_end - __stk_mpu_shared_bss_start;
if (bss_size > 0)
{
STK_MEMSET(__stk_mpu_shared_bss_start, 0, bss_size);
}
}
{
extern char __secure_data_start[];
extern char __secure_data_end[];
extern char __secure_data_source__[];
const size_t data_size = __secure_data_end - __secure_data_start;
if (data_size > 0)
{
STK_MEMCPY(__secure_data_start, __secure_data_source__, data_size);
}
}
{
extern char __nsc_start[];
extern char __nsc_end[];
extern char __ns_ram_start[];
extern char __ns_flash_start[];
extern char __ns_flash_end[];
extern char __ns_scratch_start[];
extern char __ns_scratch_end[];
SAU->CTRL = 0U;
SAU->RNR = 0U;
SAU->RBAR = (uintptr_t)__nsc_start;
SAU->RLAR = (((uintptr_t)__nsc_end - 1U) & ~0x1FU) | 2U | 1U;
SAU->RNR = 1U;
SAU->RBAR = (uintptr_t)__ns_flash_start;
SAU->RLAR = (((uintptr_t)__ns_flash_end - 1U) & ~0x1FU) | 0U | 1U;
SAU->RNR = 2U;
SAU->RBAR = (uintptr_t)__ns_ram_start;
SAU->RLAR = (((uintptr_t)__ns_scratch_start - 1U) & ~0x1FU) | 0U | 1U;
SAU->RNR = 3U;
SAU->RBAR = (uintptr_t)__ns_scratch_start;
SAU->RLAR = (((uintptr_t)__ns_scratch_end - 1U) & ~0x1FU) | 0U | 1U;
for (uint32_t i = 4U; i < 8U; ++i)
{
SAU->RNR = i;
SAU->RBAR = 0U;
SAU->RLAR = 0U;
}
SAU->CTRL = 1U;
__DSB();
__ISB();
}
{
SCB->SHCSR |= SCB_SHCSR_SECUREFAULTENA_Msk |
SCB_SHCSR_BUSFAULTENA_Msk |
SCB_SHCSR_USGFAULTENA_Msk |
SCB_SHCSR_MEMFAULTENA_Msk;
}
{
extern char __ns_flash_start[];
__TZ_set_PSP_NS(0);
__set_PSP(0);
uint32_t *ns_vector_table = reinterpret_cast<uint32_t *>(__ns_flash_start);
uint32_t initial_msp_ns = ns_vector_table[0];
__TZ_set_MSP_NS(initial_msp_ns);
SCB_NS->VTOR = reinterpret_cast<uintptr_t>(__ns_flash_start);
__DSB();
__ISB();
uint32_t reset_handler_address = ns_vector_table[1];
NSFuncT ResetHandler_ns = reinterpret_cast<NSFuncT>(reset_handler_address & ~1UL);
{
ResetHandler_ns();
}
else
{
__TZ_set_PSP_NS(0);
}
}
template <stk::EAccessMode _AccessMode>
{
{
while (true)
{
HwCommand cmd;
{
{
++s_Counter;
break; }
default:
break;
}
}
}
}
};
{
{
using namespace stk;
enum EMemPartition : uint32_t
{
BOOTROM_BASE_ADDR = 0x00000000UL,
BOOTROM_SIZE = 32 * 1024,
FLASH_BASE_ADDR = 0x10000000UL,
FLASH_SIZE_BYTES = 4 * 1024 * 1024,
SRAM_BASE_ADDR = 0x20000000UL,
SRAM_SIZE_BYTES = 512 * 1024,
};
extern char __stk_mpu_shared_code_start[];
extern char __stk_mpu_shared_code_end[];
extern char __stk_mpu_shared_data_start[];
extern char __stk_mpu_shared_data_end[];
extern char __stk_mpu_shared_bss_start[];
extern char __stk_mpu_shared_bss_end[];
extern char __stk_mpu_ram_text_start[];
extern char __stk_mpu_ram_text_end[];
const Word shared_code_start = hw::PtrToWord(__stk_mpu_shared_code_start);
const Word shared_code_end = hw::PtrToWord(__stk_mpu_shared_code_end);
const Word flash_end = FLASH_BASE_ADDR + FLASH_SIZE_BYTES;
const Word ram_text_start = hw::PtrToWord(__stk_mpu_ram_text_start);
const Word ram_text_end = hw::PtrToWord(__stk_mpu_ram_text_end);
const size_t ram_text_size =
stk::Align<size_t>(
static_cast<size_t>(ram_text_end - ram_text_start), 32U);
static const stk::MpuRegionConfig mpu_table[] =
{
{
.addr = FLASH_BASE_ADDR,
.size = shared_code_start - FLASH_BASE_ADDR,
.access_perm = hw::mpu::ACCESS_PRIV_RO_USER_RO,
.mem_type = hw::mpu::TYPE_NORMAL_CACHEABLE,
.share = hw::mpu::SHARE_NON,
.exec = hw::mpu::EXEC_ALLOWED
},
{
.addr = shared_code_end,
.size = flash_end - shared_code_end,
.access_perm = hw::mpu::ACCESS_PRIV_RO_USER_RO,
.mem_type = hw::mpu::TYPE_NORMAL_CACHEABLE,
.share = hw::mpu::SHARE_NON,
.exec = hw::mpu::EXEC_ALLOWED
},
{
.addr = shared_code_start,
.size = shared_code_end - shared_code_start,
.access_perm = hw::mpu::ACCESS_PRIV_RO_USER_RO,
.mem_type = hw::mpu::TYPE_NORMAL_CACHEABLE,
.share = hw::mpu::SHARE_NON,
.exec = hw::mpu::EXEC_ALLOWED
},
{
.addr = hw::PtrToWord(__stk_mpu_shared_data_start),
.size = hw::PtrToWord(__stk_mpu_shared_bss_end) - hw::PtrToWord(__stk_mpu_shared_data_start),
.access_perm = hw::mpu::ACCESS_FULL,
.mem_type = hw::mpu::TYPE_NORMAL_CACHEABLE,
.share = hw::mpu::SHARE_NON,
.exec = hw::mpu::EXEC_NEVER
},
{
.addr = ram_text_start,
.size = ram_text_size,
.access_perm = hw::mpu::ACCESS_PRIV_RO_USER_RO,
.mem_type = hw::mpu::TYPE_NORMAL_CACHEABLE,
.share = hw::mpu::SHARE_NON,
.exec = hw::mpu::EXEC_ALLOWED
}
};
static const stk::MpuConfig mpu_config
(
(hw::mpu::MPU_CFG_PRIVILEGED_BG_MEM |
hw::mpu::MPU_CFG_CLEAR_ON_INIT)
);
return &mpu_config;
}
#if STK_MPU
static void PrintMpuConfig(const char *label, const stk::FaultContext::Mpu &mpu)
{
printf("--- %s MPU Status & Config ---\r\n", label);
printf(
"CTRL: 0x%08X\r\n", (
unsigned int)mpu.
CTRL);
#if STK_ARCH_ARMV8_M
printf("MAIR0: 0x%08X MAIR1: 0x%08X\r\n", (unsigned int)mpu.MAIR0, (unsigned int)mpu.MAIR1);
#endif
printf("--- %s MPU Regions Configuration ---\r\n", label);
{
printf(" Region %u -> RBAR: 0x%08X R%s: 0x%08X\r\n",
(unsigned int)i,
}
}
#endif
#ifdef DEBUG
{
{
printf("\r\n================ MEMMANAGE FAULT DETECTED ================\r\n");
printf("(Sandbox Violation: a task's Run() reached outside the MPU\r\n");
printf(" regions granted to it - see region dump below for what\r\n");
printf(" WAS active for this task at fault time)\r\n");
}
else
{
printf("\r\n================== HARD FAULT DETECTED ===================\r\n");
}
printf("ITask *: 0x%08X:\r\n", (unsigned int)tid);
printf(
"EXC_RETURN: 0x%08X\r\n\r\n", (
unsigned int)ctx->
EXC_RETURN);
printf("--- Stacked CPU Registers ---\r\n");
printf(
"R0: 0x%08X R1: 0x%08X R2: 0x%08X\r\n", (
unsigned int)ctx->
frame.
R0, (
unsigned int)ctx->
frame.
R1, (
unsigned int)ctx->
frame.
R2);
printf(
"R3: 0x%08X R12: 0x%08X LR: 0x%08X\r\n", (
unsigned int)ctx->
frame.
R3, (
unsigned int)ctx->
frame.
R12, (
unsigned int)ctx->
frame.
LR);
printf(
"PC: 0x%08X xPSR: 0x%08X\r\n\r\n", (
unsigned int)ctx->
frame.
PC, (
unsigned int)ctx->
frame.
xPSR);
printf("--- System Control Registers ---\r\n");
printf(
"CFSR: 0x%08X HFSR: 0x%08X AFSR: 0x%08X\r\n", (
unsigned int)ctx->
CFSR, (
unsigned int)ctx->
HFSR, (
unsigned int)ctx->
AFSR);
printf(
"MMFAR: 0x%08X (%s)\r\n", (
unsigned int)ctx->
MMFAR, ctx->
mmfar_valid ?
"VALID" :
"INVALID");
printf(
"BFAR: 0x%08X (%s)\r\n\r\n", (
unsigned int)ctx->
BFAR, ctx->
bfar_valid ?
"VALID" :
"INVALID");
printf(
"CONTROL: 0x%08X (nPRIV=%u)\r\n", (
unsigned int)ctx->
CONTROL, (
unsigned int)(ctx->
CONTROL & 1U));
#if STK_MPU
#if STK_ARCH_ARMV8_M && STK_TZ_SECURE
printf("\r\n");
PrintMpuConfig("Non-Secure", ctx->mpu_ns);
#endif
#endif
printf("=====================================================\r\n");
return false;
}
#endif
};
{
tz::sec::SetKernel(0, &kernel);
}
{
#ifdef DEBUG
stdio_init_all();
#endif
while (true)
{
#if (KERNEL_TYPE == KERNEL_STATIC)
#endif
}
}
#define __stk_tz_ns_call
ARM TrustZone: attribute for calling Non-Secure functions from Secure state.
#define __stk_tz_nsc_entry
ARM TrustZone: attribute for Non-Secure callable gateway functions.
#define STK_ARCH_ARMV8_M
ARMv8-M platform (Cortex-M23, Cortex-M33, Cortex-M55, Cortex-M85).
Top-level STK include. Provides the Kernel class template and all built-in task-switching strategies.
#define STK_MPU_SHARED_DATA_SECTION
#define STK_UNUSED(X)
Explicitly marks a variable as unused to suppress compiler warnings.
#define __stk_aligned(x)
Specifies minimum alignment in bytes for the decorated variable or struct member (data instance prefi...
#define STK_TZ_SECURE
ARM TrustZone: Defines Secure (1) build.
#define STK_ASSERT(e)
Runtime assertion. Halts execution if the expression e evaluates to false.
static void __stk_debug_break()
#define STK_STATIC_ARRAY_SIZE(ARRAY)
Get size of the static array.
Collection of synchronization primitives (stk::sync namespace).
Collection of time-related primitives (stk::time namespace).
Namespace of STK package.
uintptr_t Word
Native processor word type.
void STK_MEMCPY(void *const dest, const void *const src, size_t size)
Implementation of STK_MEMCPY.
void STK_MEMSET(void *const dest, uint8_t value, size_t size)
Implementation of STK_MEMSET.
constexpr T Align(T v, T align) noexcept
Aligns a value towards the next larger size multiple.
EHwException
Hardware exception id (see IPlatform::IEventOverrider::OnException).
@ HW_EXCEPT_MEMACCESS
MemManage on ARM / Page Fault or PMP violation on RISC-V.
Word TId
Task (thread) id.
@ KERNEL_TICKLESS
Tickless mode. To use this mode STK_TICKLESS_IDLE must be defined to 1 in stk_config....
@ KERNEL_SYNC
Synchronization support (see Event).
bool IsPrivilegedContext()
Check if caller context is Privileged.
Word BFAR
BusFault Address Register (BFAR).
Word AFSR
Auxiliary Fault Status Register (AFSR).
Word HFSR
HardFault Status Register (HFSR).
hw::ExceptionFrame frame
Saved hardware exception stack frame.
Word MMFAR
Memory Management Fault Address Register (MMFAR).
Word CFSR
Configurable Fault Status Register (CFSR: MemManage, BusFault, UsageFault).
Word CONTROL
Core CONTROL register state snapshot.
bool mmfar_valid
Flag indicating validity of MMFAR address value (derived from CFSR.MMARVALID).
Word EXC_RETURN
Exception return magic value (EXC_RETURN).
bool bfar_valid
Flag indicating validity of BFAR address value (derived from CFSR.BFARVALID).
Region regions[(8U)]
Active hardware MPU region register state table.
Word CTRL
MPU Control Register (MPU_CTRL).
Word ATTR
Region Attribute and Size Register (RASR / RLAR / MPU_RLAR).
Word RBAR
Region Base Address Register (RBAR).
Concrete implementation of IKernel.
EAddResult AddTask(ITask *user_task) override
Register task for a soft real-time (SRT) scheduling.
IPlatform * GetPlatform() override
Get platform driver instance owned by this kernel.
void Initialize(uint32_t resolution_us=PERIODICITY_DEFAULT) override
Initialize kernel.
virtual void SetEventOverrider(IEventOverrider *overrider, bool non_secure=false)=0
Set platform event overrider.
Interface for a platform event overrider.
Partial implementation of the user task.
Thread-safe, type-safe FIFO communication pipe with internal storage.
void Run() override
Entry point of the user task.
bool OnException(stk::EHwException exc_id, stk::TId tid, const struct stk::FaultContext *const ctx) override
const stk::MpuConfig * OnConfigureMpu() const override
static void InitAll(bool init_state)
static void SwitchOnExclusive(Id led)
void NSC_GetBoardUID(pico_unique_board_id_t *id_out)
uint32_t NSC_GetKey(uint8_t key[], uint32_t size)
void NSC_bsp_Led_SwitchOnExclusive(bsp::Led::Id led)
void pico_get_unique_board_id(pico_unique_board_id_t *id_out)
static jmp_buf s_NsExitEnv
static void CreateKernel()
static void InvokeNonSecureState()
static sync::PipeT< HwCommand, 4 > s_HwCmdQueue
static void Configure_SAU(void)
static void ConfigureSecureState()
static uint8_t stack_app_main[1024U] __attribute__((aligned(16)))
static void InitMpuSharedData()
PICO_RUNTIME_INIT_FUNC(InitMpuSharedData, "00100")
static void InitSecureData()
static STK_MPU_SHARED_DATA_SECTION stk::sync::PipeT< HwCommand, 4 > s_HwCmdQueue