12#include "stk_config.h"
14#ifdef _STK_ARCH_ARM_CORTEX_M
16#ifdef _STK_CORTEX_M_TRUSTZONE
32#if !defined(_STK_CORTEX_M_TRUSTZONE_NON_SECURE)
37#error Expecting __CORTEX_M with value corresponding to Cortex-M model (0, 3, 4, 7, 33, ...)!
42 #error "SysTick peripheral definition is missing!"
46#if (__CORTEX_M > 1U) && STK_TICKLESS_USE_ARM_DWT && !defined(DWT)
47 #error "DWT peripheral definition is missing!"
51#define STK_CORTEX_M_FPU ((__FPU_PRESENT == 1U) && (__FPU_USED == 1U))
55 #define STK_CORTEX_M_MPU (__MPU_PRESENT == 1U)
57 #define STK_CORTEX_M_MPU (0)
61 #error "MPU is not present on this platform, STK_MPU feature is not supported!"
63 #if STK_MPU_STACK_GUARD
64 #error "MPU is not present on this platform, STK_MPU_STACK_GUARD feature is not supported!"
67#if STK_MPU_STACK_GUARD && !STK_MPU
68 #error "Enable MPU support (STK_MPU=1) to use per-task MPU feature (STK_MPU_STACK_GUARD=1)!"
83#ifndef STK_CORTEX_M_MPU_TASK_REGION_IDX
84 #define STK_CORTEX_M_MPU_TASK_REGION_IDX (STK_CORTEX_M_MPU_REGIONS_MAX - STK_MPU_TASK_REGIONS)
99#ifndef STK_CORTEX_M_MPU_TASK_REGION_IDX_NS
100 #define STK_CORTEX_M_MPU_TASK_REGION_IDX_NS (STK_CORTEX_M_MPU_REGIONS_MAX - STK_MPU_TASK_REGIONS_NS)
104#define STK_CORTEX_M_MANAGE_LR (__CORTEX_M >= 3U)
107#define STK_CORTEX_M_PAC (__ARM_FEATURE_PA_BITS && (__CORTEX_M >= 85U))
110#define STK_CORTEX_M_EXC_RETURN_THREAD_PSP (0xFFFFFFFDU)
113#define STK_CORTEX_M_ISR_PRIORITY_HIGHEST (0U)
114#define STK_CORTEX_M_ISR_PRIORITY_LOWEST (0xFFU)
116#ifdef CONTROL_nPRIV_Msk
119#define STK_CORTEX_M_BASEPRI_CS \
120 (static_cast<uint32_t>(STK_CORTEX_M_SVCALL_ISR_PRIORITY + 1U) << (8U - __NVIC_PRIO_BITS))
124#if STK_CORTEX_M_MANAGE_LR
125 #define STK_CORTEX_M_REGISTER_COUNT (17U)
127 #define STK_CORTEX_M_REGISTER_COUNT (16U)
139#ifdef _STK_CORTEX_M_TRUSTZONE
140 #define STK_CORTEX_M_TZ_REGISTER_COUNT (4U)
142 #define STK_CORTEX_M_TZ_REGISTER_COUNT (0U)
153#ifdef CONTROL_nPRIV_Msk
154 #define STK_CORTEX_M_PRIVILEGE_FRAME (1)
156 #define STK_CORTEX_M_PRIVILEGE_FRAME (0)
160#if STK_CORTEX_M_PRIVILEGE_FRAME
161 #define STK_CORTEX_M_PRIV_REGISTER_COUNT (1U)
163 #define STK_CORTEX_M_PRIV_REGISTER_COUNT (0U)
167#define STK_CORTEX_M_TOTAL_REGISTER_COUNT \
168 (STK_CORTEX_M_REGISTER_COUNT + STK_CORTEX_M_TZ_REGISTER_COUNT + STK_CORTEX_M_PRIV_REGISTER_COUNT)
171#ifndef STK_SYSTICK_HANDLER
172 #define STK_SYSTICK_HANDLER SysTick_Handler
176#ifndef STK_PENDSV_HANDLER
177 #define STK_PENDSV_HANDLER PendSV_Handler
181#ifndef STK_SVC_HANDLER
182 #define STK_SVC_HANDLER SVC_Handler
186#ifndef STK_USE_MEMMANAGE_HANDLER
187#define STK_USE_MEMMANAGE_HANDLER (0)
189#if STK_USE_MEMMANAGE_HANDLER
190 #ifndef STK_MEMMANAGE_HANDLER
191 #define STK_MEMMANAGE_HANDLER MemManage_Handler
196#ifndef STK_USE_HARDFAULT_HANDLER
197#define STK_USE_HARDFAULT_HANDLER (0)
199#if STK_USE_HARDFAULT_HANDLER
200 #ifndef STK_HARDFAULT_HANDLER
201 #define STK_HARDFAULT_HANDLER HardFault_Handler
212#ifndef STK_SPINLOCK_TIMEOUT_US
213 #define STK_SPINLOCK_TIMEOUT_US (5LL * 1000LL * 1000LL)
225#ifndef STK_SPINLOCK_MIN_CYCLES_PER_ITER
226 #define STK_SPINLOCK_MIN_CYCLES_PER_ITER (4U)
235enum ESvcCommandId : uint8_t
237 SVC_START_SCHEDULING = 0U,
247#define STK_ASM_EXIT_FROM_HANDLER "BX LR"
248#define STK_ASM_DISABLE_INTERRUPTS "CPSID i"
249#define STK_ASM_ENABLE_INTERRUPTS "CPSIE i"
252#if STK_SEGGER_SYSVIEW
255 SEGGER_SYSVIEW_RecordEnterISR();
272 MASK_THUMB_BIT = (1U << 0U)
278 return (REG_PC & ~
static_cast<Word>(ERegMask::MASK_THUMB_BIT));
287constexpr Word DEFAULT_INIT = 0U;
292 MASK_T_BIT = (1U << 24U)
298 return (REG_XPSR |
static_cast<Word>(ERegMask::MASK_T_BIT));
307constexpr Word DEFAULT_INIT = 0U;
312 MASK_nPRIV = (1U << 0),
313 MASK_SPSEL = (1U << 1),
314 MASK_FPCA = (1U << 2),
315 MASK_SFPA = (1U << 3)
321 return (REG_CONTROL |
static_cast<Word>(ERegMask::MASK_nPRIV));
327 return (REG_CONTROL & ~
static_cast<Word>(ERegMask::MASK_nPRIV));
333 return (REG_CONTROL |
static_cast<Word>(ERegMask::MASK_SPSEL));
364 RegionBounds result = { 0U, 0U,
false };
366 if ((cfg.size != 0U) && (cfg.access_perm != hw::mpu::EMpuAccess::ACCESS_NONE))
370 result.start = cfg.addr & ~31U;
371 result.end = result.start + cfg.size - 1U;
374 result.start = cfg.addr & ~(cfg.size - 1U);
375 result.end = result.start + cfg.size - 1U;
378 result.valid = (result.start < result.end);
384__stk_forceinline bool IsOverlapping(
const RegionBounds &a,
const RegionBounds &b)
388 return ((!a.valid || !b.valid) ?
false : (a.start <= b.end) && (b.start <= a.end));
397void ValidateNoOverlaps(
const MpuRegionConfig dynamic_cfg_list[],
size_t dynamic_cfg_count,
398 const MpuRegionConfig static_cfg_list[],
size_t static_cfg_count)
401 for (
size_t i = 0U; i < dynamic_cfg_count; ++i)
403 const RegionBounds bounds_i = GetRegionBounds(dynamic_cfg_list[i]);
409 for (
size_t j = i + 1U; j < dynamic_cfg_count; ++j)
411 const RegionBounds bounds_j = GetRegionBounds(dynamic_cfg_list[j]);
418 if (IsOverlapping(bounds_i, bounds_j))
425 if (static_cfg_list !=
nullptr)
427 for (
size_t k = 0U; k < static_cfg_count; ++k)
429 const RegionBounds static_bounds = GetRegionBounds(static_cfg_list[k]);
430 if (!static_bounds.valid)
436 if (IsOverlapping(bounds_i, static_bounds))
459#if defined(_STK_CORTEX_M_TRUSTZONE) && (STK_CORTEX_M_TZ_REGISTER_COUNT != 0U)
488#define STK_CORTEX_M_TRUSTZONE_FRAME (1)
490#define STK_CORTEX_M_TRUSTZONE_FRAME (0)
493#if STK_CORTEX_M_PRIVILEGE_FRAME
520#if STK_CORTEX_M_MANAGE_LR
523 hw::ExceptionFrame exc;
536void OnTaskRun(ITask *runnable);
538void OnSchedulerSleep();
539void OnSchedulerSleepOverride();
540void OnSchedulerExit();
541#if STK_SEGGER_SYSVIEW
569#if STK_CORE_FREQ_UNIFIED
570uint32_t s_StkSystemCoreClock[1U];
584uint32_t s_StkSpinlockTimeoutIters = 0xFFFFFFFU;
588volatile bool s_StkCortexmCsuLock =
false;
595 __asm
volatile(
"SVC %0"
597 :
"I"(SVC_START_SCHEDULING)
611 "I" (SVC_FORCE_SWITCH)
627 __asm
volatile(
"SVC %0"
629 :
"I"(SVC_ENTER_CRITICAL)
645 __asm
volatile(
"SVC %0"
647 :
"I"(SVC_EXIT_CRITICAL)
656#if (defined(__clang__) && defined(__ARMCOMPILER_VERSION)) || defined(__ICCARM__)
657 __asm
volatile(STK_ASM_DISABLE_INTERRUPTS :::
"memory");
667#if (defined(__clang__) && defined(__ARMCOMPILER_VERSION)) || defined(__ICCARM__)
668 __asm
volatile(STK_ASM_ENABLE_INTERRUPTS :::
"memory");
680#if (defined(__clang__) && defined(__ARMCOMPILER_VERSION)) || defined(__ICCARM__)
682 __asm
volatile(
"MRS %0, primask" :
"=r"(primask));
683 return ((primask & 1U) != 0U);
685 return ((__get_PRIMASK() & 1U) != 0U);
694 const uint32_t ses = __get_PRIMASK();
695 HW_DisableInterrupts();
720 SCB->SCR &= ~SCB_SCR_SLEEPDEEP_Msk;
727 #define __ATOMIC_RELAXED __MEMORY_ORDER_RELAXED__
728 #define __ATOMIC_CONSUME __MEMORY_ORDER_CONSUME__
729 #define __ATOMIC_ACQUIRE __MEMORY_ORDER_ACQUIRE__
730 #define __ATOMIC_RELEASE __MEMORY_ORDER_RELEASE__
731 #define __ATOMIC_ACQ_REL __MEMORY_ORDER_ACQ_REL__
732 #define __ATOMIC_SEQ_CST __MEMORY_ORDER_SEQ_CST__
740 return std::__iar_atomic_flag_test_and_set(ptr, memorder);
749 std::__iar_atomic_flag_clear(ptr, memorder);
753#ifdef CONTROL_nPRIV_Msk
768 return !__atomic_test_and_set(&slock, __ATOMIC_ACQUIRE);
795 __asm
volatile(
"dmb ishst" :::
"memory");
798 __atomic_clear(&slock, __ATOMIC_RELEASE);
800#elif defined(RP2040_H) || defined(RP2350_H)
802#define STK_SIO_SPINLOCK SIO->SPINLOCK31
821 bool success = (STK_SIO_SPINLOCK == 0 ? false : ((slock) =
true,
true));
850 STK_SIO_SPINLOCK = 1;
853#undef STK_SIO_SPINLOCK
872 const uint32_t ses = HW_CriticalSectionStart();
876 HW_CriticalSectionEnd(ses);
883 HW_CriticalSectionEnd(ses);
929 uint32_t timeout_itrs = s_StkSpinlockTimeoutIters;
930 while (!HW_SpinLockTryLock(slock))
932 if (--timeout_itrs == 0U)
954 return (HW_GetCurrentException() != 0U);
962#ifdef CONTROL_nPRIV_Msk
963 return ((__get_CONTROL() & CONTROL_nPRIV_Msk) == 0U);
976 __asm
volatile(
"MOV %0, SP" :
"=r" (sp));
984 SCB->ICSR = SCB_ICSR_PENDSVSET_Msk;
992 __set_CONTROL(__get_CONTROL() & ~CONTROL_FPCA_Msk);
1004void HW_EnableFullFpuAccess()
1006#if defined(STK_CORTEX_M_FPU) && (STK_CORTEX_M_FPU != 0)
1009 constexpr uint32_t SCB_CPACR_CP10_FULL_ACCESS = (3UL << 20U);
1010 constexpr uint32_t SCB_CPACR_CP11_FULL_ACCESS = (3UL << 22U);
1015 uint32_t cpacr_val = SCB->CPACR;
1016 cpacr_val |= (SCB_CPACR_CP10_FULL_ACCESS | SCB_CPACR_CP11_FULL_ACCESS);
1017 SCB->CPACR = cpacr_val;
1019#if defined(_STK_CORTEX_M_TRUSTZONE)
1020 constexpr uint32_t SCB_NSACR_CP10_ACCESS = (1UL << 10U);
1021 constexpr uint32_t SCB_NSACR_CP11_ACCESS = (1UL << 11U);
1028 uint32_t nsacr_val = SCB->NSACR;
1029 nsacr_val |= (SCB_NSACR_CP10_ACCESS | SCB_NSACR_CP11_ACCESS);
1030 SCB->NSACR = nsacr_val;
1033 uint32_t ns_cpacr_val = SCB_NS->CPACR;
1034 ns_cpacr_val |= (SCB_CPACR_CP10_FULL_ACCESS | SCB_CPACR_CP11_FULL_ACCESS);
1035 SCB_NS->CPACR = ns_cpacr_val;
1038 uint32_t fpccr_val = FPU->FPCCR;
1039 fpccr_val |= (
static_cast<uint32_t
>(FPU_FPCCR_ASPEN_Msk) |
static_cast<uint32_t
>(FPU_FPCCR_LSPEN_Msk));
1040 FPU->FPCCR = fpccr_val;
1042 uint32_t ns_fpccr_val = FPU_NS->FPCCR;
1043 ns_fpccr_val |= (
static_cast<uint32_t
>(FPU_FPCCR_ASPEN_Msk) |
static_cast<uint32_t
>(FPU_FPCCR_LSPEN_Msk));
1044 FPU_NS->FPCCR = ns_fpccr_val;
1050 uint32_t fpccr_val = FPU->FPCCR;
1051 fpccr_val |= (
static_cast<uint32_t
>(FPU_FPCCR_ASPEN_Msk) |
static_cast<uint32_t
>(FPU_FPCCR_LSPEN_Msk));
1052 FPU->FPCCR = fpccr_val;
1067#if STK_CORE_FREQ_UNIFIED
1068 return s_StkSystemCoreClock[0];
1078 SCB->ICSR = SCB_ICSR_PENDSVCLR_Msk;
1085 const Ticks period_ticks_64 =
static_cast<Ticks>(period_ticks);
1087 const uint32_t result = SysTick_Config(
static_cast<uint32_t
>(
ConvertTimeUsToClockCycles(HW_CoreClockFrequency(), period_ticks_64)));
1105 SCB->ICSR = SCB_ICSR_PENDSTCLR_Msk;
1113 SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
1121 return SysTick->VAL;
1135 uint32_t ticks = HW_SysTickValue();
1138 ticks = SysTick->LOAD;
1150 return SysTick->LOAD - ticks;
1159 SysTick->LOAD = ticks - 1U;
1161 SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
1169#if defined(CoreDebug)
1170 CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
1172 DCB->DEMCR |= DCB_DEMCR_TRCENA_Msk;
1178#if (__CORTEX_M == 7U)
1179 DWT->LAR = 0xC5ACCE55;
1185 if ((DWT->CTRL & DWT_CTRL_CYCCNTENA_Msk) != DWT_CTRL_CYCCNTENA_Msk)
1188 DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
1218void HW_InitSpinlockTimeout()
1221 const Cycles iters = cycles_budget / STK_SPINLOCK_MIN_CYCLES_PER_ITER;
1225 s_StkSpinlockTimeoutIters =
static_cast<uint32_t
>(
1269 Word R4, R5, R6, R7, R8, R9, R10, R11;
1295int32_t SaveJmp(JmpFrame &)
1300#if (__CORTEX_M >= 3U)
1302 "STMIA r0, {r4-r11} \n"
1303 "STR SP, [r0, #32] \n"
1304 "STR LR, [r0, #36] \n"
1307 "STR r4, [r0, #0] \n"
1308 "STR r5, [r0, #4] \n"
1309 "STR r6, [r0, #8] \n"
1310 "STR r7, [r0, #12] \n"
1312 "STR r1, [r0, #16] \n"
1314 "STR r1, [r0, #20] \n"
1316 "STR r1, [r0, #24] \n"
1318 "STR r1, [r0, #28] \n"
1320 "STR r1, [r0, #32] \n"
1322 "STR r1, [r0, #36] \n"
1327 "STR r1, [r0, #40] \n"
1331 "PAC r12, LR, SP \n"
1332 #if STK_CORTEX_M_FPU
1333 "STR r12, [r0, #44] \n"
1335 "STR r12, [r0, #40] \n"
1343#pragma diag_suppress=Pe940
1347#pragma diag_default=Pe940
1369void RestoreJmp(JmpFrame &, int32_t )
1374#if (__CORTEX_M >= 3U)
1376 "LDR sp, [r0, #32] \n"
1379 "LDR r2, [r0, #40] \n"
1384 #if STK_CORTEX_M_FPU
1385 "LDR r12, [r0, #44] \n"
1387 "LDR r12, [r0, #40] \n"
1391 "LDR r2, [r0, #36] \n"
1393 #if STK_CORTEX_M_PAC
1395 "AUT r12, LR, SP \n"
1399 "LDMIA r0, {r4-r11} \n"
1404 "LDR r2, [r0, #36] \n"
1406 "LDR r2, [r0, #32] \n"
1408 "LDR r2, [r0, #28] \n"
1410 "LDR r2, [r0, #24] \n"
1412 "LDR r2, [r0, #20] \n"
1414 "LDR r2, [r0, #16] \n"
1416 "LDR r4, [r0, #0] \n"
1417 "LDR r5, [r0, #4] \n"
1418 "LDR r6, [r0, #8] \n"
1419 "LDR r7, [r0, #12] \n"
1461struct ScopedPrivilegeBoost
1468 explicit ScopedPrivilegeBoost();
1476 ~ScopedPrivilegeBoost()
1479 __set_CONTROL(__get_CONTROL() | CONTROL_nPRIV_Msk);
1499ScopedPrivilegeBoost::ScopedPrivilegeBoost()
1505 :
"I"(SVC_BOOST_PRIV)
1541void ConfigureRegion(MpuRegion ®,
const struct MpuRegionConfig &cfg, uint32_t region_idx);
1554void ConfigureStatic(
const MpuRegionConfig cfg_list[],
size_t cfg_count, uint32_t control_flags,
1569void ConfigureDynamic(TaskMpu &task_mpu,
const struct MpuRegionConfig cfg_list[],
const size_t cfg_count,
1570 IPlatform::IEventOverrider *overrider,
bool non_secure);
1583void ApplyRegion(
const MpuRegion ®, uint32_t index,
bool non_secure);
1592void DisableRegion(uint32_t index,
bool non_secure);
1604void Enable(
bool enable, uint32_t control_flags,
bool non_secure);
1614constexpr uint32_t MAIR0_PMSAV8_INIT = 0xFF440400U;
1620constexpr uint32_t MAIR1_PMSAV8_INIT = 0x00000000U;
1626constexpr Word RLAR_ENABLE_FLAG = (1U << 0U);
1647constexpr Word RLAR_DISABLED_REGION = 0U;
1653constexpr Word RASR_ENABLE_FLAG = (1U << 0U);
1663constexpr Word RBAR_DISABLED_REGION(uint32_t region_idx) {
return (1U << 4U) | (region_idx & 0xFU); }
1670constexpr Word RASR_DISABLED_REGION = 0U;
1698 extern char __stk_mpu_shared_code_start[];
1699 extern char __stk_mpu_shared_code_end[];
1700 #if defined(DEBUG) || defined(_DEBUG)
1701 extern char __stk_mpu_shared_data_start[];
1702 extern char __stk_mpu_shared_data_end[];
1716constexpr MpuRegionConfig s_StkDisabledMpuRegion =
1720 .access_perm = hw::mpu::ACCESS_NONE,
1721 .mem_type = hw::mpu::TYPE_STRONGLY_ORDERED,
1722 .share = hw::mpu::SHARE_NON,
1723 .exec = hw::mpu::EXEC_ALLOWED
1730 typedef IPlatform::IEventOverrider eovrd_t;
1732 constexpr Context() : PlatformContext(), m_exit_buf(), m_overrider(nullptr),
1733 #if STK_CORTEX_M_TRUSTZONE_FRAME
1734 m_overrider_ns(nullptr),
1736 #if STK_TICKLESS_IDLE
1737 m_sleep_ticks(0), m_sleep_error(0U),
1739 m_csu(0U), m_csu_nesting(0U), m_started(false), m_exiting(false)
1742 void Initialize(IPlatform::IEventHandler *handler, IKernelService *service, Stack *exit_trap,
1743 uint32_t resolution_us)
1745 InitializeBase(handler, service, exit_trap, resolution_us);
1748 "expect Stack::SP member at offset of 0 (first member)");
1753 : ((STK_CORTEX_M_MPU_TASK_REGION_IDX % 4U) == 0U),
1754 "STK_CORTEX_M_MPU_TASK_REGION_IDX is not aligned correctly for the RNR-relative "
1755 "alias burst write at the configured STK_MPU_TASK_REGIONS width");
1759 "STK_MPU_TASK_REGIONS must be defined as 2, 4, 6, 8, 12 or 16");
1760 #ifdef _STK_CORTEX_M_TRUSTZONE
1764 : ((STK_CORTEX_M_MPU_TASK_REGION_IDX_NS % 4U) == 0U),
1765 "STK_CORTEX_M_MPU_TASK_REGION_IDX_NS is not aligned correctly for the RNR-relative "
1766 "alias burst write at the configured STK_MPU_TASK_REGIONS_NS width");
1770 "STK_MPU_TASK_REGIONS_NS must be defined as 2, 4, 6, 8, 12 or 16");
1774 STK_ASSERT(hw::PtrToWord(__stk_mpu_shared_code_end) - hw::PtrToWord(__stk_mpu_shared_code_start) > 0U);
1775 STK_ASSERT(hw::PtrToWord(__stk_mpu_shared_data_end) - hw::PtrToWord(__stk_mpu_shared_data_start) > 0U);
1778 STK_ASSERT(g_StkLastPanicId == KERNEL_PANIC_NONE);
1784 #if STK_TICKLESS_IDLE
1790 if (s_StkSystemCoreClock[0] == 0U)
1794 s_StkSystemCoreClock[i] = SystemCoreClock;
1798 HW_InitSpinlockTimeout();
1800 #if (__CORTEX_M > 1) && STK_TICKLESS_USE_ARM_DWT
1801 HW_DWTEnableCounter();
1804 #if STK_SEGGER_SYSVIEW
1805 SEGGER_SYSVIEW_Init(
1806 HW_CoreClockFrequency(),
1807 HW_CoreClockFrequency(),
1813#if STK_TICKLESS_IDLE
1819 if (m_handler->OnTick(m_stack_idle, m_stack_active
1820 #
if STK_TICKLESS_IDLE
1825 HW_ScheduleContextSwitch();
1831 HW_DisableInterrupts();
1833 #if STK_TICKLESS_IDLE
1834 Timeout ticks = m_sleep_ticks;
1839 if (ticks != m_sleep_ticks)
1841 m_sleep_ticks = ReloadTickPeriod(ticks);
1847 HW_EnableInterrupts();
1852 if (m_handler->OnForceContextSwitch(
id, m_stack_idle, m_stack_active))
1854 HW_ScheduleContextSwitch();
1860 if (m_csu_nesting == 0U)
1863 HW_SpinLockLock(s_StkCortexmCsuLock);
1866 m_csu = current_ses;
1879 bool released =
false;
1881 if (m_csu_nesting == 0U)
1888 if (m_csu_nesting == 0U)
1891 restore_ses = m_csu;
1894 HW_SpinLockUnlock(s_StkCortexmCsuLock);
1904 const uint32_t current_ses = HW_CriticalSectionStart();
1906 OnEnterCriticalSection(current_ses);
1911 uint32_t restore_ses;
1912 if (OnExitCriticalSection(restore_ses))
1914 HW_CriticalSectionEnd(restore_ses);
1918 void StartTickTimer(Timeout elapsed_ticks)
1920 #if STK_TICKLESS_IDLE
1922 m_sleep_ticks = elapsed_ticks;
1928 HW_SysTickStart(m_tick_resolution);
1931 NVIC_SetPriority(SysTick_IRQn, STK_CORTEX_M_ISR_PRIORITY_LOWEST);
1934#if STK_TLS && !STK_INLINE_TLS
1937 hw::CriticalSection::ScopedLock cs_;
1941 return m_stack_active->tls;
1944 void SetTls(Word tp)
1946 hw::CriticalSection::ScopedLock cs_;
1950 m_stack_active->tls = tp;
1954 void OnSleepOverride()
1956 #if STK_TICKLESS_IDLE
1957 const Timeout sleep_ticks = m_sleep_ticks;
1959 const Timeout sleep_ticks = 1;
1962 if (!m_overrider->OnSleep(sleep_ticks))
1964 HW_EnterSleepMode();
1968 uint32_t GetTickResolutionInClockCycles()
1970 const Ticks resolution_ticks =
static_cast<Ticks>(m_tick_resolution);
1971 return static_cast<uint32_t
>(ConvertTimeUsToClockCycles(HW_CoreClockFrequency(), resolution_ticks));
1975 void ConfigureMpuInstance(eovrd_t *overrider,
bool non_secure)
1978 if (overrider !=
nullptr)
1980 const MpuConfig *
const cfg = overrider->OnConfigureMpu();
1986 #if STK_CORTEX_M_TRUSTZONE_FRAME
1991 STK_ASSERT(non_secure == ((cfg->mode & hw::mpu::MPU_CFG_NONSECURE_MPU) != 0U));
1994 if ((cfg->mode & hw::mpu::MPU_CFG_CLEAR_ON_INIT) != 0U)
2001 hw_int::pmsa::DisableRegion(index, non_secure);
2005 uint32_t control_flags = 0U;
2007 if ((cfg->mode & hw::mpu::MPU_CFG_PRIVILEGED_BG_MEM) != 0U)
2009 control_flags |= MPU_CTRL_PRIVDEFENA_Msk;
2012 if ((cfg->mode & hw::mpu::MPU_CFG_IN_FAULTS) != 0U)
2014 control_flags |= MPU_CTRL_HFNMIENA_Msk;
2017 hw_int::pmsa::ConfigureStatic(cfg->regions.GetPtr(), cfg->regions.GetSize(), control_flags, non_secure);
2021 hw_int::pmsa::Enable(
false, 0, non_secure);
2031 ConfigureMpuInstance(m_overrider,
false);
2033 #if STK_CORTEX_M_TRUSTZONE_FRAME
2035 ConfigureMpuInstance(m_overrider_ns,
true);
2040 TId GetCurrentTId()
const
2042 #if STK_STACK_NEEDS_TASK_ID
2043 const TId tid = (m_stack_active !=
nullptr ? m_stack_active->tid : TID_NONE);
2045 const TId tid = TID_NONE;
2054#if STK_TICKLESS_IDLE
2055 Timeout ReloadTickPeriod(Timeout ticks_requested);
2057 void Resume(Timeout elapsed_ticks);
2060 drv::JmpFrame m_exit_buf;
2061 eovrd_t *m_overrider;
2062#if STK_CORTEX_M_TRUSTZONE_FRAME
2063 eovrd_t *m_overrider_ns;
2065#if STK_TICKLESS_IDLE
2067 uint32_t m_sleep_error;
2070 uint8_t m_csu_nesting;
2071 volatile bool m_started;
2089 g_StkLastPanicId = id;
2092 HW_DisableInterrupts();
2107#if STK_TICKLESS_IDLE
2112 const uint32_t SYSTICK_MAX_LOAD = 0x00FFFFFFU;
2113 const uint32_t tick_resolution = GetTickResolutionInClockCycles();
2114 if (tick_resolution != 0U)
2117 STK_ASSERT((
static_cast<uint64_t
>(ticks_requested) * tick_resolution) <= UINT32_MAX);
2122 const uint32_t max_ticks = SYSTICK_MAX_LOAD / tick_resolution;
2123 if (ticks_requested >
static_cast<Timeout>(max_ticks))
2125 clamped_ticks =
static_cast<Timeout>(max_ticks);
2129 clamped_ticks = ticks_requested;
2134 #if (__CORTEX_M > 1) && STK_TICKLESS_USE_ARM_DWT
2135 const uint32_t error = HW_DWTGetCounter();
2136 __stk_compiler_barrier();
2140 HW_SysTickDisable();
2144 const uint32_t elapsed_till_stop = HW_SysTickElapsed(HW_SysTickValueAfterDisable());
2147 STK_ASSERT(
static_cast<Timeout>(elapsed_till_stop / tick_resolution) <= clamped_ticks);
2149 const uint32_t cpu_ticks_requested =
static_cast<uint32_t
>(clamped_ticks) * tick_resolution;
2152 uint32_t new_load = cpu_ticks_requested - elapsed_till_stop - m_sleep_error;
2155 if (new_load > cpu_ticks_requested)
2157 new_load = cpu_ticks_requested;
2161 HW_SysTickRearm(new_load);
2163 #if (__CORTEX_M > 1) && STK_TICKLESS_USE_ARM_DWT
2165 m_sleep_error = HW_DWTGetCounter() - error;
2175 return clamped_ticks;
2179extern "C" void STK_SYSTICK_HANDLER()
2182#if STK_SEGGER_SYSVIEW
2183 SEGGER_SYSVIEW_RecordEnterISR();
2188#ifdef HAL_MODULE_ENABLED
2190#if STK_TICKLESS_IDLE
2191 const uint32_t sleep_ticks =
static_cast<uint32_t
>(ctx.m_sleep_ticks);
2192 uwTick += (sleep_ticks * ctx.m_tick_resolution);
2211#if STK_SEGGER_SYSVIEW
2212 SEGGER_SYSVIEW_RecordExitISR();
2213 SEGGER_SYSVIEW_IsStarted();
2217#if STK_SEGGER_SYSVIEW
2218 #define STK_SYSVIEW_CALL(func)\
2219 "PUSH {r0-r3, r7, r11, r12, LR} \n"\
2221 "POP {r0-r3, r7, r11, r12, LR} \n"
2224#if STK_SEGGER_SYSVIEW
2230 SEGGER_SYSVIEW_RecordExitISR();
2241 SEGGER_SYSVIEW_OnTaskStartExec(ctx.m_stack_active->tid);
2273#if (STK_MPU_TASK_REGIONS == 2U)
2274#define STK_ASM_BLOCK_MPU_S_STACK_GUARD\
2275 "LDR r0, =%[mpu_start_of] \n" \
2276 "ADD r12, r1, %[mpu_reg_of] \n" \
2277 "LDMIA r12, {r4-r7} \n" \
2278 "STMIA r0, {r4-r7} \n"
2279#elif (STK_MPU_TASK_REGIONS == 4U)
2280#define STK_ASM_BLOCK_MPU_S_STACK_GUARD\
2281 "LDR r0, =%[mpu_start_of] \n" \
2282 "ADD r12, r1, %[mpu_reg_of] \n" \
2283 "LDMIA r12, {r4-r11} \n" \
2284 "STMIA r0, {r4-r11} \n"
2285#elif (STK_MPU_TASK_REGIONS == 6U)
2286#define STK_ASM_BLOCK_MPU_S_STACK_GUARD\
2287 "LDR r0, =%[mpu_start_of] \n" \
2290 "ADD r12, r1, %[mpu_reg_of] \n" \
2291 "LDMIA r12, {r4-r11} \n" \
2292 "STMIA r0, {r4-r11} \n" \
2295 "LDR r12, =%[mpu_rnr_idx4] \n" \
2296 "STR r12, [r0, #-4] \n" \
2297 "ADD r12, r1, %[mpu_reg4_of] \n" \
2298 "LDMIA r12, {r4-r7} \n" \
2299 "STMIA r0, {r4-r7} \n" \
2302 "LDR r12, =%[mpu_rnr_idx] \n" \
2303 "STR r12, [r0, #-4] \n"
2304#elif (STK_MPU_TASK_REGIONS == 8U)
2305#define STK_ASM_BLOCK_MPU_S_STACK_GUARD\
2306 "LDR r0, =%[mpu_start_of] \n" \
2309 "ADD r12, r1, %[mpu_reg_of] \n" \
2310 "LDMIA r12, {r4-r11} \n" \
2311 "STMIA r0, {r4-r11} \n" \
2314 "LDR r12, =%[mpu_rnr_idx4] \n" \
2315 "STR r12, [r0, #-4] \n" \
2316 "ADD r12, r1, %[mpu_reg4_of] \n" \
2317 "LDMIA r12, {r4-r11} \n" \
2318 "STMIA r0, {r4-r11} \n" \
2321 "LDR r12, =%[mpu_rnr_idx] \n" \
2322 "STR r12, [r0, #-4] \n"
2323#elif (STK_MPU_TASK_REGIONS == 12U)
2324#define STK_ASM_BLOCK_MPU_S_STACK_GUARD\
2325 "LDR r0, =%[mpu_start_of] \n" \
2328 "ADD r12, r1, %[mpu_reg_of] \n" \
2329 "LDMIA r12, {r4-r11} \n" \
2330 "STMIA r0, {r4-r11} \n" \
2333 "LDR r12, =%[mpu_rnr_idx4] \n" \
2334 "STR r12, [r0, #-4] \n" \
2335 "ADD r12, r1, %[mpu_reg4_of] \n" \
2336 "LDMIA r12, {r4-r11} \n" \
2337 "STMIA r0, {r4-r11} \n" \
2340 "LDR r12, =%[mpu_rnr_idx8] \n" \
2341 "STR r12, [r0, #-4] \n" \
2342 "ADD r12, r1, %[mpu_reg8_of] \n" \
2343 "LDMIA r12, {r4-r11} \n" \
2344 "STMIA r0, {r4-r11} \n" \
2347 "LDR r12, =%[mpu_rnr_idx] \n" \
2348 "STR r12, [r0, #-4] \n"
2349#elif (STK_MPU_TASK_REGIONS == 16U)
2350#define STK_ASM_BLOCK_MPU_S_STACK_GUARD\
2351 "LDR r0, =%[mpu_start_of] \n" \
2354 "ADD r12, r1, %[mpu_reg_of] \n" \
2355 "LDMIA r12, {r4-r11} \n" \
2356 "STMIA r0, {r4-r11} \n" \
2359 "LDR r12, =%[mpu_rnr_idx4] \n" \
2360 "STR r12, [r0, #-4] \n" \
2361 "ADD r12, r1, %[mpu_reg4_of] \n" \
2362 "LDMIA r12, {r4-r11} \n" \
2363 "STMIA r0, {r4-r11} \n" \
2366 "LDR r12, =%[mpu_rnr_idx8] \n" \
2367 "STR r12, [r0, #-4] \n" \
2368 "ADD r12, r1, %[mpu_reg8_of] \n" \
2369 "LDMIA r12, {r4-r11} \n" \
2370 "STMIA r0, {r4-r11} \n" \
2373 "LDR r12, =%[mpu_rnr_idx12] \n" \
2374 "STR r12, [r0, #-4] \n" \
2375 "ADD r12, r1, %[mpu_reg12_of] \n" \
2376 "LDMIA r12, {r4-r11} \n" \
2377 "STMIA r0, {r4-r11} \n" \
2380 "LDR r12, =%[mpu_rnr_idx] \n" \
2381 "STR r12, [r0, #-4] \n"
2383 #error "Unsupported region count, allowed - 2, 4, 6, 8, 12, 16!"
2386#if STK_CORTEX_M_TRUSTZONE_FRAME
2387 #if (STK_MPU_TASK_REGIONS_NS == 2U)
2388 #define STK_ASM_BLOCK_MPU_NS_STACK_GUARD\
2391 "LDR r0, =%[mpu_ns_start_of] \n" \
2392 "ADD r12, r1, %[mpu_ns_reg_of] \n" \
2393 "LDMIA r12, {r4-r7} \n" \
2394 "STMIA r0, {r4-r7} \n"
2395 #elif (STK_MPU_TASK_REGIONS_NS == 4U)
2396 #define STK_ASM_BLOCK_MPU_NS_STACK_GUARD\
2399 "LDR r0, =%[mpu_ns_start_of] \n" \
2400 "ADD r12, r1, %[mpu_ns_reg_of] \n" \
2401 "LDMIA r12, {r4-r11} \n" \
2402 "STMIA r0, {r4-r11} \n"
2403 #elif (STK_MPU_TASK_REGIONS_NS == 6U)
2404 #define STK_ASM_BLOCK_MPU_NS_STACK_GUARD\
2407 "LDR r0, =%[mpu_ns_start_of] \n" \
2410 "ADD r12, r1, %[mpu_ns_reg_of] \n" \
2411 "LDMIA r12, {r4-r11} \n" \
2412 "STMIA r0, {r4-r11} \n" \
2415 "LDR r12, =%[mpu_ns_rnr_idx4] \n" \
2416 "STR r12, [r0, #-4] \n" \
2417 "ADD r12, r1, %[mpu_ns_reg4_of]\n" \
2418 "LDMIA r12, {r4-r7} \n" \
2419 "STMIA r0, {r4-r7} \n" \
2422 "LDR r12, =%[mpu_ns_rnr_idx] \n" \
2423 "STR r12, [r0, #-4] \n"
2424 #elif (STK_MPU_TASK_REGIONS_NS == 8U)
2425 #define STK_ASM_BLOCK_MPU_NS_STACK_GUARD\
2428 "LDR r0, =%[mpu_ns_start_of] \n" \
2431 "ADD r12, r1, %[mpu_ns_reg_of] \n" \
2432 "LDMIA r12, {r4-r11} \n" \
2433 "STMIA r0, {r4-r11} \n" \
2436 "LDR r12, =%[mpu_ns_rnr_idx4] \n" \
2437 "STR r12, [r0, #-4] \n" \
2438 "ADD r12, r1, %[mpu_ns_reg4_of]\n" \
2439 "LDMIA r12, {r4-r11} \n" \
2440 "STMIA r0, {r4-r11} \n" \
2443 "LDR r12, =%[mpu_ns_rnr_idx] \n" \
2444 "STR r12, [r0, #-4] \n"
2445 #elif (STK_MPU_TASK_REGIONS_NS == 12U)
2446 #define STK_ASM_BLOCK_MPU_NS_STACK_GUARD\
2449 "LDR r0, =%[mpu_ns_start_of] \n" \
2452 "ADD r12, r1, %[mpu_ns_reg_of] \n" \
2453 "LDMIA r12, {r4-r11} \n" \
2454 "STMIA r0, {r4-r11} \n" \
2457 "LDR r12, =%[mpu_ns_rnr_idx4] \n" \
2458 "STR r12, [r0, #-4] \n" \
2459 "ADD r12, r1, %[mpu_ns_reg4_of]\n" \
2460 "LDMIA r12, {r4-r11} \n" \
2461 "STMIA r0, {r4-r11} \n" \
2464 "LDR r12, =%[mpu_ns_rnr_idx8] \n" \
2465 "STR r12, [r0, #-4] \n" \
2466 "ADD r12, r1, %[mpu_ns_reg8_of]\n" \
2467 "LDMIA r12, {r4-r11} \n" \
2468 "STMIA r0, {r4-r11} \n" \
2471 "LDR r12, =%[mpu_ns_rnr_idx] \n" \
2472 "STR r12, [r0, #-4] \n"
2473 #elif (STK_MPU_TASK_REGIONS_NS == 16U)
2474 #define STK_ASM_BLOCK_MPU_NS_STACK_GUARD\
2477 "LDR r0, =%[mpu_ns_start_of] \n" \
2480 "ADD r12, r1, %[mpu_ns_reg_of] \n" \
2481 "LDMIA r12, {r4-r11} \n" \
2482 "STMIA r0, {r4-r11} \n" \
2485 "LDR r12, =%[mpu_ns_rnr_idx4] \n" \
2486 "STR r12, [r0, #-4] \n" \
2487 "ADD r12, r1, %[mpu_ns_reg4_of]\n" \
2488 "LDMIA r12, {r4-r11} \n" \
2489 "STMIA r0, {r4-r11} \n" \
2492 "LDR r12, =%[mpu_ns_rnr_idx8] \n" \
2493 "STR r12, [r0, #-4] \n" \
2494 "ADD r12, r1, %[mpu_ns_reg8_of]\n" \
2495 "LDMIA r12, {r4-r11} \n" \
2496 "STMIA r0, {r4-r11} \n" \
2499 "LDR r12, =%[mpu_ns_rnr_idx12] \n" \
2500 "STR r12, [r0, #-4] \n" \
2501 "ADD r12, r1, %[mpu_ns_reg12_of]\n" \
2502 "LDMIA r12, {r4-r11} \n" \
2503 "STMIA r0, {r4-r11} \n" \
2506 "LDR r12, =%[mpu_ns_rnr_idx] \n" \
2507 "STR r12, [r0, #-4] \n"
2509 #error "Unsupported region count, allowed - 2, 4, 6, 8, 12, 16!"
2513#if STK_CORTEX_M_TRUSTZONE_FRAME
2514 #define STK_ASM_BLOCK_MPU_STACK_GUARD\
2515 "MOV r1, %[st_active] \n" \
2516 STK_ASM_BLOCK_MPU_S_STACK_GUARD\
2517 STK_ASM_BLOCK_MPU_NS_STACK_GUARD
2519 #define STK_ASM_BLOCK_MPU_STACK_GUARD\
2520 "MOV r1, %[st_active] \n" \
2521 STK_ASM_BLOCK_MPU_S_STACK_GUARD
2526#if (STK_ARCH_CPU_COUNT > 1U)
2533 register Stack *p_st_idle = p_ctx->m_stack_idle;
2534 register Stack *p_st_active = p_ctx->m_stack_active;
2536 register Context *p_ctx __asm(
"r12") = &
GetContext();
2537 register Stack *p_st_idle __asm(
"r3") = p_ctx->m_stack_idle;
2538 register Stack *p_st_active __asm(
"r2") = p_ctx->m_stack_active;
2546 register Stack *p_st_active __asm(
"r2") =
GetContext().m_stack_active;
2553 STK_ASM_DISABLE_INTERRUPTS
" \n"
2556#if STK_SEGGER_SYSVIEW
2557 STK_SYSVIEW_CALL(StkSystemView_RecordEnterISR)
2573 "VMOVEQ.F32 s0, s0 \n"
2576 "VSTMDBEQ r0!, {s16-s31} \n"
2581#if STK_CORTEX_M_MANAGE_LR
2585 "STMDB r0!, {r4-r11, LR}\n"
2588 "SUBS r0, r0, #16 \n"
2589 "STMIA r0!, {r4-r7} \n"
2594 "SUBS r0, r0, #32 \n"
2595 "STMIA r0!, {r4-r7} \n"
2596 "SUBS r0, r0, #16 \n"
2604#if STK_CORTEX_M_TRUSTZONE_FRAME
2606 "MRS r12, PSPLIM_NS \n"
2607 "STR r12, [r0, #-4]! \n"
2608 "MRS r12, PSPLIM \n"
2609 "STR r12, [r0, #-4]! \n"
2612 "MRS r12, CONTROL_NS \n"
2613 "STR r12, [r0, #-4]! \n"
2614 "MRS r12, PSP_NS \n"
2615 "STR r12, [r0, #-4]! \n"
2620#if STK_CORTEX_M_PRIVILEGE_FRAME
2621 "MRS r12, CONTROL \n"
2622 "STR r12, [r0, #-4]! \n"
2626 "STR r0, [%[st_idle]] \n"
2629#if STK_MPU_STACK_GUARD
2630 STK_ASM_BLOCK_MPU_STACK_GUARD
2635 "LDR r0, [%[st_active]]\n"
2641#if STK_CORTEX_M_PRIVILEGE_FRAME
2642 "LDR r12, [r0], %[access_mode_of] \n"
2643 "MSR CONTROL, r12 \n"
2654#if STK_CORTEX_M_TRUSTZONE_FRAME
2655 "LDR r12, [r0], #4 \n"
2656 "MSR PSP_NS, r12 \n"
2657 "LDR r12, [r0], #4 \n"
2658 "MSR CONTROL_NS, r12 \n"
2660 "LDR r12, [r0], #4 \n"
2661 "MSR PSPLIM, r12 \n"
2662 "LDR r12, [r0], #4 \n"
2663 "MSR PSPLIM_NS, r12 \n"
2668#if STK_CORTEX_M_MANAGE_LR
2670 "LDMIA r0!, {r4-r11, LR}\n"
2673 "LDMIA r0!, {r4-r7} \n"
2678 "LDMIA r0!, {r4-r7} \n"
2685 "VLDMIAEQ r0!, {s16-s31} \n"
2692#if STK_SEGGER_SYSVIEW
2693 STK_SYSVIEW_CALL(StkSystemView_OnContextSwitch)
2696 STK_ASM_ENABLE_INTERRUPTS
" \n"
2698 STK_ASM_EXIT_FROM_HANDLER
" \n"
2701 : [access_mode_of]
"i" (offsetof(
Stack, access_mode))
2703 , [st_idle]
"r3" (p_st_idle)
2704 , [st_active]
"r2" (p_st_active)
2706 , [st_idle]
"r" (p_st_idle)
2707 , [st_active]
"r" (p_st_active)
2709#
if STK_MPU_STACK_GUARD
2710 , [mpu_start_of]
"i" (&MPU->RBAR)
2711 , [mpu_reg_of]
"i" (offsetof(
Stack, mpu.region[0].addr))
2713 , [mpu_rnr_idx]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX)
2714 , [mpu_reg4_of]
"i" (offsetof(
Stack, mpu.region[4].addr))
2715 , [mpu_rnr_idx4]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX + 4U)
2718 , [mpu_reg8_of]
"i" (offsetof(
Stack, mpu.region[8].addr))
2719 , [mpu_rnr_idx8]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX + 8U)
2721 #if (STK_MPU_TASK_REGIONS > 12U)
2722 , [mpu_reg12_of]
"i" (offsetof(
Stack, mpu.region[12].addr))
2723 , [mpu_rnr_idx12]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX + 12U)
2725 #if STK_CORTEX_M_TRUSTZONE_FRAME
2726 , [mpu_ns_start_of]
"i" (&MPU_NS->RBAR)
2727 , [mpu_ns_reg_of]
"i" (offsetof(
Stack, mpu_ns.region[0].addr))
2728 #if (STK_MPU_TASK_REGIONS_NS > 4U)
2729 , [mpu_ns_rnr_idx]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX_NS)
2730 , [mpu_ns_reg4_of]
"i" (offsetof(
Stack, mpu_ns.region[4].addr))
2731 , [mpu_ns_rnr_idx4]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX_NS + 4U)
2734 , [mpu_ns_reg8_of]
"i" (offsetof(
Stack, mpu_ns.region[8].addr))
2735 , [mpu_ns_rnr_idx8]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX_NS + 8U)
2737 #if (STK_MPU_TASK_REGIONS_NS > 12U)
2738 , [mpu_ns_reg12_of]
"i" (offsetof(
Stack, mpu_ns.region[12].addr))
2739 , [mpu_ns_rnr_idx12]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX_NS + 12U)
2744#if STK_MPU_STACK_GUARD
2748#if (STK_CORTEX_M_TRUSTZONE_FRAME || STK_MPU_STACK_GUARD || STK_CORTEX_M_PRIVILEGE_FRAME)
2765#if (STK_ARCH_CPU_COUNT > 1U)
2772 register Stack *p_st_active = p_ctx->m_stack_active;
2774 register Context *p_ctx __asm(
"r12") = &
GetContext();
2775 register Stack *p_st_active __asm(
"r2") = p_ctx->m_stack_active;
2781 register Stack *p_st_active __asm(
"r2") =
GetContext().m_stack_active;
2789#if STK_MPU_STACK_GUARD
2790 STK_ASM_BLOCK_MPU_STACK_GUARD
2795 "LDR r0, [%[st_active]]\n"
2799#if STK_CORTEX_M_PRIVILEGE_FRAME
2800 "LDR r12, [r0], %[access_mode_of] \n"
2801 "MSR CONTROL, r12 \n"
2806#if STK_CORTEX_M_TRUSTZONE_FRAME
2807 "LDR r12, [r0], #4 \n"
2808 "MSR PSP_NS, r12 \n"
2809 "LDR r12, [r0], #4 \n"
2810 "MSR CONTROL_NS, r12 \n"
2812 "LDR r12, [r0], #4 \n"
2813 "MSR PSPLIM, r12 \n"
2814 "LDR r12, [r0], #4 \n"
2815 "MSR PSPLIM_NS, r12 \n"
2820#if STK_CORTEX_M_MANAGE_LR
2822 "LDMIA r0!, {r4-r11, LR}\n"
2825 "LDMIA r0!, {r4-r7} \n"
2830 "LDMIA r0!, {r4-r7} \n"
2837 "VLDMIAEQ r0!, {s16-s31} \n"
2843#if !STK_CORTEX_M_MANAGE_LR
2845 "LDR r0, =%[exc_ret] \n"
2849 STK_ASM_ENABLE_INTERRUPTS
" \n"
2851 STK_ASM_EXIT_FROM_HANDLER
" \n"
2854 : [access_mode_of]
"i" (offsetof(
Stack, access_mode))
2856 , [st_active]
"r2" (p_st_active)
2858 , [st_active]
"r" (p_st_active)
2860#if !STK_CORTEX_M_MANAGE_LR
2861 , [exc_ret]
"i" (STK_CORTEX_M_EXC_RETURN_THREAD_PSP)
2863#if STK_MPU_STACK_GUARD
2864 , [mpu_start_of]
"i" (&MPU->RBAR)
2865 , [mpu_reg_of]
"i" (offsetof(
Stack, mpu.region[0].addr))
2866 #if (STK_MPU_TASK_REGIONS > 4U)
2867 , [mpu_rnr_idx]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX)
2868 , [mpu_reg4_of]
"i" (offsetof(
Stack, mpu.region[4].addr))
2869 , [mpu_rnr_idx4]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX + 4U)
2871 #if (STK_MPU_TASK_REGIONS > 8U)
2872 , [mpu_reg8_of]
"i" (offsetof(
Stack, mpu.region[8].addr))
2873 , [mpu_rnr_idx8]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX + 8U)
2875 #if (STK_MPU_TASK_REGIONS > 12U)
2876 , [mpu_reg12_of]
"i" (offsetof(
Stack, mpu.region[12].addr))
2877 , [mpu_rnr_idx12]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX + 12U)
2879 #if STK_CORTEX_M_TRUSTZONE_FRAME
2880 , [mpu_ns_start_of]
"i" (&MPU_NS->RBAR)
2881 , [mpu_ns_reg_of]
"i" (offsetof(
Stack, mpu_ns.region[0].addr))
2882 #if (STK_MPU_TASK_REGIONS_NS > 4U)
2883 , [mpu_ns_rnr_idx]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX_NS)
2884 , [mpu_ns_reg4_of]
"i" (offsetof(
Stack, mpu_ns.region[4].addr))
2885 , [mpu_ns_rnr_idx4]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX_NS + 4U)
2887 #if (STK_MPU_TASK_REGIONS_NS > 8U)
2888 , [mpu_ns_reg8_of]
"i" (offsetof(
Stack, mpu_ns.region[8].addr))
2889 , [mpu_ns_rnr_idx8]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX_NS + 8U)
2891 #if (STK_MPU_TASK_REGIONS_NS > 12U)
2892 , [mpu_ns_reg12_of]
"i" (offsetof(
Stack, mpu_ns.region[12].addr))
2893 , [mpu_ns_rnr_idx12]
"i" (STK_CORTEX_M_MPU_TASK_REGION_IDX_NS + 12U)
2898#if STK_MPU_STACK_GUARD
2902#if (STK_CORTEX_M_TRUSTZONE_FRAME || STK_MPU_STACK_GUARD || STK_CORTEX_M_PRIVILEGE_FRAME)
2915void Context::Start()
2920 HW_EnableFullFpuAccess();
2927 m_handler->OnStop();
2931 HW_StartScheduler();
2935void Context::OnStart()
2944 m_handler->OnStart(m_stack_active);
2952 NVIC_SetPriority(PendSV_IRQn, STK_CORTEX_M_ISR_PRIORITY_LOWEST);
2954#ifdef CONTROL_nPRIV_Msk
2961#if STK_SEGGER_SYSVIEW
2962 SEGGER_SYSVIEW_OnTaskStartExec(m_stack_active->tid);
2970#if STK_TICKLESS_IDLE
2975 const uint32_t tick_resolution = GetTickResolutionInClockCycles();
2976 if (tick_resolution != 0U)
2978 HW_DisableInterrupts();
2981 HW_SysTickDisable();
2985 const uint32_t elapsed = HW_SysTickElapsed(HW_SysTickValueAfterDisable());
2991 HW_ClearPendingSwitch();
2994 m_handler->OnSuspend(
true);
3003 const uint32_t elapsed_ticks = elapsed / tick_resolution;
3004 sleep_ticks =
Max(m_sleep_ticks -
static_cast<Timeout>(elapsed_ticks),
static_cast<Timeout>(0));
3006 HW_EnableInterrupts();
3018#if STK_TICKLESS_IDLE
3019void Context::Resume(
Timeout elapsed_ticks)
3021 HW_DisableInterrupts();
3024 m_handler->OnSuspend(
false);
3027 StartTickTimer(elapsed_ticks + 1);
3029 HW_EnableInterrupts();
3037#if STK_SEGGER_SYSVIEW
3038 SEGGER_SYSVIEW_RecordEnterISR();
3044 "Word must be uintptr_t width for safe pointer round-trip via exc_frame->PC");
3049 "NVIC priority bit width out of range");
3050#ifdef CONTROL_nPRIV_Msk
3052 "SVCall priority leaves no lower level to mask: BASEPRI would be 0 (masking disabled)");
3062 const ESvcCommandId command =
static_cast<ESvcCommandId
>(*insn_ptr);
3066 case SVC_START_SCHEDULING: {
3074 HW_DisableInterrupts();
3083 case SVC_FORCE_SWITCH: {
3088 ctx.OnForceContextSwitch(exc_frame->
R0);
3092 case SVC_BOOST_PRIV: {
3098 __set_CONTROL(__get_CONTROL() & ~CONTROL_nPRIV_Msk);
3107#ifdef CONTROL_nPRIV_Msk
3108 case SVC_ENTER_CRITICAL: {
3109 const uint32_t saved_basepri = __get_BASEPRI();
3110 __set_BASEPRI(STK_CORTEX_M_BASEPRI_CS);
3114 GetContext().OnEnterCriticalSection(saved_basepri);
3117 case SVC_EXIT_CRITICAL: {
3118 uint32_t saved_basepri;
3119 if (
GetContext().OnExitCriticalSection(saved_basepri))
3122 __set_BASEPRI(saved_basepri);
3135#if STK_SEGGER_SYSVIEW
3136 SEGGER_SYSVIEW_RecordExitISR();
3152 "LDR r1, =StkSVCHandlerMain \n"
3160#if (STK_USE_MEMMANAGE_HANDLER && defined(STK_MEMMANAGE_HANDLER)) ||\
3161 (STK_USE_HARDFAULT_HANDLER && defined(STK_HARDFAULT_HANDLER))
3163void StkExceptionHandlerMain(
const Word *stacked_regs,
Word exc_id)
3166 __asm
volatile (
"MOV %0, LR" :
"=r" (exc_return) ::
"memory");
3168 bool handled =
false;
3171 if (ctx.m_overrider !=
nullptr)
3174 fault_ctx.
Fill(stacked_regs, exc_return);
3176 handled = ctx.m_overrider->OnException(
static_cast<EHwException>(exc_id), ctx.GetCurrentTId(),
3193#if STK_USE_MEMMANAGE_HANDLER && defined(STK_MEMMANAGE_HANDLER)
3204 "LDR r2, =StkExceptionHandlerMain \n"
3216#if STK_USE_HARDFAULT_HANDLER && defined(STK_HARDFAULT_HANDLER)
3227 "LDR r2, =StkExceptionHandlerMain \n"
3240void drv::OnTaskRun(
ITask *runnable)
3247void drv::OnTaskExit()
3251 const uint32_t cs = HW_CriticalSectionStart();
3253 ctx.m_handler->OnTaskExit(ctx.m_stack_active);
3255 HW_CriticalSectionEnd(cs);
3257 if (HW_IsPrivilegedContext())
3262 HW_EnterSleepMode();
3276void drv::OnSchedulerSleep()
3284 #if STK_SEGGER_SYSVIEW
3285 SEGGER_SYSVIEW_OnIdle();
3288 HW_EnterSleepMode();
3293void drv::OnSchedulerSleepOverride()
3301 #if STK_SEGGER_SYSVIEW
3302 SEGGER_SYSVIEW_OnIdle();
3310void drv::OnSchedulerExit()
3322 GetContext().Initialize(event_handler, service, exit_trap, resolution_us);
3330#if STK_MPU_STACK_GUARD
3336 ITask *user_task,
bool non_secure)
3338#if !STK_CORTEX_M_TRUSTZONE_FRAME
3342 MpuRegionConfig task_mpu_cfg[TaskMpu::NUM_REGIONS];
3343 size_t cfg_count = 0U;
3348 if (user_task !=
nullptr)
3352 const MpuRegionList *
const regions = user_task->GetMpuRegions();
3353 if (regions !=
nullptr)
3356 const MpuRegionConfig stack_guard_cfg =
3360 .access_perm = hw::mpu::EMpuAccess::ACCESS_FULL,
3361 .mem_type = hw::mpu::EMpuType::TYPE_NORMAL_CACHEABLE,
3362 .share = hw::mpu::EMpuShare::SHARE_NON,
3363 .exec = hw::mpu::EMpuExec::EXEC_NEVER
3366 const hw_int::pmsa::RegionBounds bounds_s = hw_int::pmsa::GetRegionBounds(stack_guard_cfg);
3368 size_t regions_count = regions->GetSize();
3369 bool stack_guard_canceled =
false;
3371 for (
size_t i = 0U; i < regions_count; ++i)
3373 const hw_int::pmsa::RegionBounds bounds_i = hw_int::pmsa::GetRegionBounds((*regions)[i]);
3376 if (hw_int::pmsa::IsOverlapping(bounds_s, bounds_i))
3378 stack_guard_canceled =
true;
3384 const size_t max_user_regions = stack_guard_canceled ? TaskMpu::NUM_REGIONS : (TaskMpu::NUM_REGIONS - 1U);
3386 STK_ASSERT(regions_count <= max_user_regions);
3387 if (regions_count > max_user_regions)
3389 regions_count = max_user_regions;
3393 for (
size_t i = 0U; i < regions_count; ++i)
3395 task_mpu_cfg[cfg_count++] = (*regions)[i];
3399 if (!stack_guard_canceled)
3401 task_mpu_cfg[cfg_count++] = stack_guard_cfg;
3406#if STK_CORTEX_M_TRUSTZONE_FRAME
3407 TaskMpu &task_mpu = (non_secure ? stack->mpu_ns : stack->mpu);
3409 TaskMpu &task_mpu = stack->mpu;
3413 hw_int::pmsa::ConfigureDynamic(task_mpu, task_mpu_cfg, cfg_count, overrider, non_secure);
3421#if STK_CORTEX_M_TRUSTZONE_FRAME
3437 tz_frame->PSP_NS = 0U;
3438 tz_frame->CONTROL_NS = hw_int::reg::CONTROL::DEFAULT_INIT;
3439 tz_frame->PSPLIM = 0U;
3440 tz_frame->PSPLIM_NS = 0U;
3448 const Word ns_stack_top = Context::InitStackMemory(ns_stack_memory);
3452 hw_int::reg::CONTROL::SetPrivileged(tz_frame->CONTROL_NS) :
3453 hw_int::reg::CONTROL::SetUnprivileged(tz_frame->CONTROL_NS));
3456 tz_frame->CONTROL_NS = hw_int::reg::CONTROL::SetSPSelectionToPSP(tz_frame->CONTROL_NS);
3460 tz_frame->PSP_NS = ns_stack_top;
3485 "ExceptionFrame layout must match the ARMv7-M hardware exception frame exactly");
3490#ifdef _STK_CORTEX_M_TRUSTZONE
3491 bool is_non_secure_task =
false;
3495 if ((user_task !=
nullptr) && (user_task->GetSecureStackMemory() !=
nullptr))
3497 stack_memory = user_task->GetSecureStackMemory();
3498 is_non_secure_task =
true;
3505 const Word stack_top = Context::InitStackMemory(stack_memory);
3508 stack->
SP = stack_top - (STK_CORTEX_M_TOTAL_REGISTER_COUNT *
sizeof(
Word));
3526 task_frame->exc.PC =
hw::PtrToWord(ctx.m_overrider !=
nullptr ? &drv::OnSchedulerSleepOverride : &drv::OnSchedulerSleep);
3528 task_frame->exc.R0 = 0U;
3534 task_frame->exc.R0 = 0U;
3544 task_frame->exc.PC = hw_int::reg::PC::ClearThumbBit(task_frame->exc.PC);
3548 task_frame->exc.xPSR = hw_int::reg::XPSR::SetThumbExecution(hw_int::reg::XPSR::DEFAULT_INIT);
3550#if STK_CORTEX_M_MANAGE_LR
3555 task_frame->EXC_RETURN = STK_CORTEX_M_EXC_RETURN_THREAD_PSP;
3558#if STK_CORTEX_M_PRIVILEGE_FRAME
3568 hw_int::reg::CONTROL::SetPrivileged(hw_int::reg::CONTROL::DEFAULT_INIT) :
3569 hw_int::reg::CONTROL::SetUnprivileged(hw_int::reg::CONTROL::DEFAULT_INIT));
3574#if STK_CORTEX_M_TRUSTZONE_FRAME
3575 ConfigureTaskTrustZone(stack, stack_memory, user_task, is_non_secure_task);
3579#if STK_MPU_STACK_GUARD
3580 ConfigureTaskMpu(ctx.m_overrider, stack, stack_memory, user_task,
false);
3581 #if STK_CORTEX_M_TRUSTZONE_FRAME
3582 if (is_non_secure_task)
3584 ConfigureTaskMpu(ctx.m_overrider_ns, stack, user_task, user_task,
true);
3595#ifdef _STK_CORTEX_M_TRUSTZONE
3608 int flags = (CMSE_NONSECURE | CMSE_MPU_READWRITE);
3610 if ((HW_GetCurrentException() == 0U) && ((__TZ_get_CONTROL_NS() & CONTROL_nPRIV_Msk) != 0U))
3612 flags |= CMSE_MPU_UNPRIV;
3639 if ((sl !=
nullptr) && (cmse_check_pointed_object(sl, NSC_GetCallerAccessFlags()) !=
nullptr))
3650 if ((sl !=
nullptr) && (cmse_check_pointed_object(sl, NSC_GetCallerAccessFlags()) !=
nullptr))
3663 if ((sl !=
nullptr) && (cmse_check_pointed_object(sl, NSC_GetCallerAccessFlags()) !=
nullptr))
3681 if ((clk !=
nullptr) && (cmse_check_pointed_object(clk, NSC_GetCallerAccessFlags()) !=
nullptr))
3691uint32_t NSC_stk_hw_HiResClock_GetFrequency()
3693 return HW_CoreClockFrequency();
3705 if ((clk !=
nullptr) && (cmse_check_pointed_object(clk, NSC_GetCallerAccessFlags()) !=
nullptr))
3716bool NSC_stk_hw_IsInsideISR()
3724TId NSC_stk_debug_GetCurrentTId()
3733void Context::OnStop()
3735#if STK_SEGGER_SYSVIEW
3736 SEGGER_SYSVIEW_Stop();
3743 HW_ClearPendingSwitch();
3758 HW_DisableInterrupts();
3769 return static_cast<Cycles>(HW_SysTickValue());
3774 return HW_CoreClockFrequency();
3779 HW_ForceContextSwitch(
id);
3785 const Word isr = HW_GetCurrentException();
3800 result = ctx.m_handler->OnGetTid(HW_GetCallerSP());
3813 bool is_handled =
false;
3816 if (ctx.m_overrider !=
nullptr)
3818 is_handled = ctx.m_overrider->OnHardFault();
3833#if STK_CORTEX_M_TRUSTZONE_FRAME
3836 ctx.m_overrider_ns = overrider;
3843 ctx.m_overrider = overrider;
3849 return HW_GetCallerSP();
3854#if STK_TICKLESS_IDLE
3863#if STK_TICKLESS_IDLE
3874 if (core_id == 0xFFU)
3878 s_StkSystemCoreClock[i] = frequency;
3887 s_StkSystemCoreClock[core_id] = frequency;
3917 explicit KernelServiceSvcProxy() : IKernelService()
3936 void Wake(stk::ISyncObject *sobj,
bool all);
3953KernelServiceSvcProxy s_StkKernelServiceUnprivProxy;
3960stk::TId KernelServiceSvcProxy::GetTid()
const
3962 const mpu::ScopedPrivilegeBoost pb;
3967stk::Ticks KernelServiceSvcProxy::GetTicks()
const
3969 const mpu::ScopedPrivilegeBoost pb;
3974uint32_t KernelServiceSvcProxy::GetTickResolution()
const
3976 const mpu::ScopedPrivilegeBoost pb;
3981stk::Cycles KernelServiceSvcProxy::GetSysTimerCount()
const
3983 const mpu::ScopedPrivilegeBoost pb;
3984 return GetContext().m_service->GetSysTimerCount();
3988uint32_t KernelServiceSvcProxy::GetSysTimerFrequency()
const
3990 const mpu::ScopedPrivilegeBoost pb;
3991 return GetContext().m_service->GetSysTimerFrequency();
3997 const mpu::ScopedPrivilegeBoost pb;
4004 const mpu::ScopedPrivilegeBoost pb;
4009bool KernelServiceSvcProxy::SleepUntil(
stk::Ticks timestamp)
4011 const mpu::ScopedPrivilegeBoost pb;
4012 return GetContext().m_service->SleepUntil(timestamp);
4016void KernelServiceSvcProxy::SleepCancel(
stk::TId task_id)
4018 const mpu::ScopedPrivilegeBoost pb;
4019 GetContext().m_service->SleepCancel(task_id);
4023void KernelServiceSvcProxy::SwitchToNext()
4025 const mpu::ScopedPrivilegeBoost pb;
4030void KernelServiceSvcProxy::ExitTask()
4032 const mpu::ScopedPrivilegeBoost pb;
4039 const mpu::ScopedPrivilegeBoost pb;
4040 return GetContext().m_service->LockScheduler();
4044ELockResult KernelServiceSvcProxy::UnlockScheduler()
4046 const mpu::ScopedPrivilegeBoost pb;
4047 return GetContext().m_service->UnlockScheduler();
4051ELockResult KernelServiceSvcProxy::RestoreSchedulerLock(
bool locked)
4053 const mpu::ScopedPrivilegeBoost pb;
4054 return GetContext().m_service->RestoreSchedulerLock(locked);
4060 const mpu::ScopedPrivilegeBoost pb;
4061 return GetContext().m_service->Wait(sobj, mutex, timeout);
4067 const mpu::ScopedPrivilegeBoost pb;
4078void KernelServiceSvcProxy::Resume(
stk::Timeout elapsed_ticks)
4087 const mpu::ScopedPrivilegeBoost pb;
4088 GetContext().m_service->InheritWeight(tid, weight);
4094 const mpu::ScopedPrivilegeBoost pb;
4095 GetContext().m_service->RestoreWeight(tid, sobj);
4101 const mpu::ScopedPrivilegeBoost pb;
4102 return GetContext().m_service->SetWeight(tid, weight);
4108 const mpu::ScopedPrivilegeBoost pb;
4109 return GetContext().m_service->SetTimeSlice(tid, ticks);
4121 if (HW_IsPrivilegedContext() || HW_IsHandlerMode())
4127 service = &s_StkKernelServiceUnprivProxy;
4142 const bool is_priv_ctx = HW_IsPrivilegedContext();
4143 const bool is_handler = HW_IsHandlerMode();
4145 if (is_priv_ses && (is_priv_ctx || is_handler))
4152 HW_UnprivEnterCriticalSection();
4162 if ((ses & SESSION_FLAG_NPRIV) == 0U)
4168 HW_UnprivExitCriticalSection();
4175 HW_SpinLockLock(m_lock);
4181 HW_SpinLockUnlock(m_lock);
4187 return HW_SpinLockTryLock(m_lock);
4193 return HW_IsHandlerMode();
4199 return HW_IsPrivilegedContext();
4205#if (__CORTEX_M >= 3U)
4206 HW_DWTEnableCounter();
4207 m_prev = HW_DWTGetCounter();
4214#if (__CORTEX_M >= 3U)
4216 const uint32_t current = HW_DWTGetCounter();
4219 const uint32_t delta = current - m_prev;
4233 bool wrapped = ((SCB->ICSR & SCB_ICSR_PENDSTSET_Msk) != 0U);
4234 uint32_t val = HW_SysTickValue();
4235 if (!wrapped && ((SCB->ICSR & SCB_ICSR_PENDSTSET_Msk) != 0U))
4239 val = HW_SysTickValue();
4243 cycles += tick_cycles;
4246 const uint32_t load = SysTick->LOAD;
4247 const uint32_t delta = load - val;
4249 const Cycles delta_cycles =
static_cast<Cycles>(delta);
4252 return cycles + delta_cycles;
4259 const uint32_t freq = HW_CoreClockFrequency();
4264#if STK_TLS && !STK_INLINE_TLS
4265Word stk::hw::GetTls()
4270void stk::hw::SetTls(
Word tp)
4284void hw_int::pmsa::ConfigureRegion(MpuRegion ®,
const struct MpuRegionConfig &cfg, uint32_t region_idx)
4287 if ((cfg.size != 0U) && (cfg.access_perm != hw::mpu::EMpuAccess::ACCESS_NONE))
4294 reg.addr = (cfg.addr & ~31U) |
4295 static_cast<uint32_t
>(cfg.share) |
4296 static_cast<uint32_t
>(cfg.access_perm) |
4297 static_cast<uint32_t
>(cfg.exec);
4301 const uint32_t end_byte_addr = cfg.addr + cfg.size - 1U;
4303 const uint32_t limit_addr = end_byte_addr & ~31U;
4304 reg.attr = limit_addr | (
static_cast<uint32_t
>(cfg.mem_type) << 1U) | RLAR_ENABLE_FLAG;
4309 reg.addr = RBAR_DISABLED_REGION(region_idx);
4310 reg.attr = RLAR_DISABLED_REGION;
4314 if ((cfg.size != 0U) && (cfg.access_perm != hw::mpu::EMpuAccess::ACCESS_NONE))
4317 STK_ASSERT((cfg.size & (cfg.size - 1U)) == 0U);
4318 STK_ASSERT((cfg.addr & (cfg.size - 1U)) == 0U);
4321 reg.addr = (cfg.addr & ~(cfg.size - 1U)) | (1U << 4U) | (region_idx & 0xFU);
4324 const uint32_t size_field =
static_cast<uint32_t
>(31U -
CountLeadingZeros(cfg.size)) - 1U;
4327 const uint32_t ap_bits =
static_cast<uint32_t
>(cfg.access_perm) & 0x07000000U;
4329 const uint32_t attr = (ap_bits |
4330 static_cast<uint32_t
>(cfg.share) |
4331 static_cast<uint32_t
>(cfg.mem_type) |
4332 static_cast<uint32_t
>(cfg.exec));
4334 reg.attr = attr | (size_field << 1U) | RASR_ENABLE_FLAG;
4340 reg.addr = RBAR_DISABLED_REGION(region_idx);
4341 reg.attr = RASR_DISABLED_REGION;
4354#if STK_ARCH_ARMV8_M && STK_TZ_SECURE
4355 return non_secure ? MPU_NS : MPU;
4365#if STK_ARCH_ARMV8_M && STK_TZ_SECURE
4366 return non_secure ? SCB_NS : SCB;
4377void hw_int::pmsa::ApplyRegion(
const MpuRegion ®, uint32_t index,
bool non_secure)
4379 MPU_Type *
const MPU_ptr = GetMpu(non_secure);
4381 MPU_ptr->RNR = index;
4385 MPU_ptr->RBAR = reg.addr;
4387 MPU_ptr->RLAR = reg.attr;
4389 MPU_ptr->RASR = reg.attr;
4393void hw_int::pmsa::Enable(
bool enable, uint32_t control_flags,
bool non_secure)
4397 MPU_Type *
const MPU_ptr = GetMpu(non_secure);
4398 SCB_Type *
const SCB_ptr = GetScb(non_secure);
4402 #ifdef SCB_SHCSR_MEMFAULTENA_Msk
4403 SCB_ptr->SHCSR |= SCB_SHCSR_MEMFAULTENA_Msk;
4405 MPU_ptr->CTRL = control_flags | MPU_CTRL_ENABLE_Msk;
4409 #ifdef SCB_SHCSR_MEMFAULTENA_Msk
4410 SCB_ptr->SHCSR &= ~SCB_SHCSR_MEMFAULTENA_Msk;
4412 MPU_ptr->CTRL &= ~MPU_CTRL_ENABLE_Msk;
4419void hw_int::pmsa::DisableRegion(uint32_t index,
bool non_secure)
4421 MPU_Type *
const MPU_ptr = GetMpu(non_secure);
4423 MPU_ptr->RNR = index;
4426 MPU_ptr->RLAR = RLAR_DISABLED_REGION;
4428 MPU_ptr->RASR = RASR_DISABLED_REGION;
4432void hw_int::pmsa::ConfigureStatic(
const MpuRegionConfig cfg_list[],
size_t cfg_count, uint32_t control_flags,
4435 STK_ASSERT((cfg_list !=
nullptr) || (cfg_count == 0U));
4437 const size_t region_idx = (non_secure ? STK_CORTEX_M_MPU_TASK_REGION_IDX_NS : STK_CORTEX_M_MPU_TASK_REGION_IDX);
4438 STK_ASSERT((cfg_count <= region_idx) || (region_idx == 0U));
4441 ValidateNoOverlaps(
nullptr, 0U, cfg_list, cfg_count);
4443 Enable(
false, 0U, non_secure);
4449 for (; index < cfg_count; ++index)
4451 const MpuRegionConfig &cfg = cfg_list[index];
4454 ConfigureRegion(reg, cfg,
static_cast<uint32_t
>(index));
4455 ApplyRegion(reg,
static_cast<uint32_t
>(index), non_secure);
4461 for (; index < region_idx; ++index)
4464 ConfigureRegion(reg, s_StkDisabledMpuRegion,
static_cast<uint32_t
>(index));
4465 ApplyRegion(reg,
static_cast<uint32_t
>(index), non_secure);
4472 MPU_Type *
const MPU_ptr = GetMpu(non_secure);
4474 #if STK_ARCH_ARMV8_M
4476 MPU_ptr->MAIR0 = MAIR0_PMSAV8_INIT;
4477 MPU_ptr->MAIR1 = MAIR1_PMSAV8_INIT;
4481 MPU_ptr->RNR = region_idx;
4484 Enable(
true, control_flags, non_secure);
4487void hw_int::pmsa::ConfigureDynamic(TaskMpu &task_mpu,
const struct MpuRegionConfig cfg_list[],
4488 const size_t cfg_count, IPlatform::IEventOverrider *overrider,
bool non_secure)
4490 STK_ASSERT((cfg_list !=
nullptr) || (cfg_count == 0U));
4492 const size_t region_idx = (non_secure ? STK_CORTEX_M_MPU_TASK_REGION_IDX_NS : STK_CORTEX_M_MPU_TASK_REGION_IDX);
4493 const size_t task_mpu_regions = (non_secure ? TaskMpuNs::NUM_REGIONS : TaskMpu::NUM_REGIONS);
4496 const size_t clamped_count =
Min(cfg_count, task_mpu_regions);
4499 MpuRegionList static_regions(
nullptr, 0);
4500 if (overrider !=
nullptr)
4502 const MpuConfig *
const cfg = overrider->OnConfigureMpu();
4505 static_regions = cfg->regions;
4510 ValidateNoOverlaps(static_regions.GetPtr(), static_regions.GetSize(), cfg_list, clamped_count);
4514 size_t task_idx = 0U;
4515 for (; task_idx < clamped_count; ++task_idx)
4517 ConfigureRegion(task_mpu.region[task_idx], cfg_list[task_idx],
4518 static_cast<uint32_t
>(region_idx + task_idx));
4525 for (; task_idx < task_mpu_regions; ++task_idx)
4527 ConfigureRegion(task_mpu.region[task_idx], s_StkDisabledMpuRegion,
4528 static_cast<uint32_t
>(region_idx + task_idx));
4546 mpu_ctx.
CTRL = mpu_inst->CTRL;
4548 mpu_ctx.MAIR0 = mpu_inst->MAIR0;
4549 mpu_ctx.MAIR1 = mpu_inst->MAIR1;
4552 const Word saved_rnr = mpu_inst->RNR;
4555 mpu_inst->RNR =
static_cast<Word>(i);
4560 #if STK_ARCH_ARMV8_M
4566 mpu_inst->RNR = saved_rnr;
4573void FaultContext::Fill(
const Word *stacked_regs, Word exc_return)
4575 this->frame.R0 = stacked_regs[0];
4576 this->frame.R1 = stacked_regs[1];
4577 this->frame.R2 = stacked_regs[2];
4578 this->frame.R3 = stacked_regs[3];
4579 this->frame.R12 = stacked_regs[4];
4580 this->frame.LR = stacked_regs[5];
4581 this->frame.PC = stacked_regs[6];
4582 this->frame.xPSR = stacked_regs[7];
4584 this->EXC_RETURN = exc_return;
4585 this->CONTROL = __get_CONTROL();
4592 this->mmfar_valid =
false;
4593 this->bfar_valid =
false;
4598 this->CFSR = SCB->CFSR;
4599 this->HFSR = SCB->HFSR;
4600 this->AFSR = SCB->AFSR;
4601 this->mmfar_valid = ((this->CFSR & SCB_CFSR_MMARVALID_Msk) != 0U);
4602 this->bfar_valid = ((this->CFSR & SCB_CFSR_BFARVALID_Msk) != 0U);
4603 this->MMFAR = (this->mmfar_valid ? SCB->MMFAR : 0U);
4604 this->BFAR = (this->bfar_valid ? SCB->BFAR : 0U);
4608 FaultContext_FillMpu(this->mpu, MPU);
4609 #if STK_ARCH_ARMV8_M && STK_TZ_SECURE
4610 FaultContext_FillMpu(this->mpu_ns, MPU_NS);
#define STK_ASM_SYNTAX_UNIFIED
#define STK_ASM_EXTRACT_STACK_POINTER_TO_R0
#define STK_ASM_GLOBAL_SYMBOL(name)
Generates a toolchain-agnostic assembly directive to declare a global symbol.
static void __stk_dmb()
Hardware memory barrier: ensures visibility across cores and bus masters.
#define STK_TZ_NSC_GATEWAY
ARM TrustZone: declares a Non-Secure callable gateway function (extern "C", cmse_nonsecure_entry).
#define STK_CORTEX_M_MPU_REGIONS_MAX
Number of MPU regions supported by MPU peripheral.
#define STK_CORTEX_M_SVCALL_ISR_PRIORITY
Priority of the SVCall exception (the most urgent one used by the kernel).
Contains common inventory for platform implementation.
#define STK_ARCH_GET_CPU_ID()
Get CPU core id of the caller, e.g. if called while running on core 0 then returned value must be 0.
#define GetContext()
Get platform's context.
Top-level STK include. Provides the Kernel class template and all built-in task-switching strategies.
Hardware Abstraction Layer (HAL) declarations for the stk::hw namespace.
void STK_PANIC_HANDLER_DEFAULT(stk::EKernelPanicId id)
Default panic handler: disable interrupts, record the id, and spin in a tight loop - a defined,...
#define STK_MPU_SHARED_CODE_SECTION
#define STK_MPU_KERNEL_DATA_SECTION
#define STK_MPU_KERNEL_BSS_SECTION
#define STK_MPU_KERNEL_CODE_SECTION
#define STK_MPU_SHARED_DATA_SECTION
#define STK_UNUSED(X)
Explicitly marks a variable as unused to suppress compiler warnings.
#define __stk_attr_used
Marks a symbol as used, preventing the linker from discarding it even if no references are visible (d...
#define __stk_forceinline
Forces compiler to always inline the decorated function, regardless of optimisation level.
#define STK_SLEEP_TRAP_STACK_SIZE
Stack size for the sleep trap in elements of Word (default: STK_STACK_SIZE_MIN).
#define STK_CS_NESTINGS_MAX
Maximum allowable recursion depth for critical section entry (default: 16).
#define STK_ASSERT(e)
Runtime assertion. Halts execution if the expression e evaluates to false.
#define STK_STACK_SIZE_MIN
Minimum stack size in elements of Word, shared by all stack allocation lower-bound checks.
#define STK_MPU_TASK_REGIONS
Number of hardware MPU region slots reserved per task (stk::TaskMpu::NUM_REGIONS).
#define __stk_attr_noinline
Prevents compiler from inlining the decorated function (function prefix).
#define STK_STATIC_ASSERT_DESC_N(NAME, X, DESC)
Compile-time assertion with a name tag and a custom error description.
#define STK_ARCH_CPU_COUNT
Number of physical CPU cores available to the scheduler (default: 1).
#define __stk_attr_naked
Suppresses compiler-generated function prologue and epilogue (function prefix).
#define STK_MPU_TASK_REGIONS_NS
#define STK_STACK_MEMORY_FILLER
Sentinel value written to the entire stack region at initialization (stack watermark pattern).
#define __stk_attr_unused
Suppresses compiler warnings about an unused type, variable, or function (declaration prefix).
#define __stk_attr_noreturn
Declares that function never returns to its caller (function prefix).
static void __stk_debug_break()
#define STK_STATIC_ARRAY_SIZE(ARRAY)
Get size of the static array.
#define STK_STATIC_ASSERT(X)
Compile-time assertion. Produces a compilation error if X is false.
#define STK_VIRT_DTOR
Expands to nothing if STK_STRICT_COMPLIANCY=0 (non-virtual destructors, smaller objects),...
#define STK_PACKAGE_NAME
Name of package.
Namespace of STK package.
uintptr_t Word
Native processor word type.
static constexpr TId TID_ISR_N
Bitmask sentinel for ISR-context task identifiers.
void STK_KERNEL_PANIC(stk::EKernelPanicId id)
Called when the kernel detects an unrecoverable internal fault.
@ ACCESS_PRIVILEGED
Privileged access mode (access to hardware is fully unrestricted).
@ ACCESS_SECURE
Secure access mode (ARM TrustZone, Secure binary).
static constexpr Timeout NO_WAIT
Timeout value: return immediately if the synchronization object is not yet signaled (non-blocking pol...
EWaitResult
Wait result (see IKernelService::Wait).
static __stk_forceinline Cycles ConvertTimeUsToClockCycles(uint32_t clock_freq, Ticks time_us)
Convert time (microseconds) to core clock cycles.
int64_t Ticks
Ticks value.
EKernelPanicId
Identifies the source of a kernel panic.
@ KERNEL_PANIC_UNKNOWN_SVC
Unknown service command received by SVC handler.
@ KERNEL_PANIC_BAD_STACK_TYPE
Stack type is unknown.
@ KERNEL_PANIC_NS_ACCESS
Non-secure access to protected resource.
@ KERNEL_PANIC_HRT_HARD_FAULT
Kernel running in KERNEL_HRT mode reported deadline failure of the task.
@ KERNEL_PANIC_NONE
Panic is absent (no fault).
@ KERNEL_PANIC_SPINLOCK_DEADLOCK
Spin-lock timeout expired: lock owner never released.
int32_t Timeout
Timeout time (ticks).
constexpr T Max(T a, T b) noexcept
Compile-time maximum of two values.
constexpr T Min(T a, T b) noexcept
Compile-time minimum of two values.
uint32_t CountLeadingZeros(const uint32_t value) noexcept
Count leading zeros.
ELockResult
Result of IKernel::SetSchedulerLock(), IKernelService::LockScheduler(), UnlockScheduler() and Restore...
@ SYS_TASK_ID_SLEEP
Sleep trap.
static constexpr bool IsIsrTid(TId id)
Test whether a task identifier represents an ISR context.
static Ticks GetTicks()
Get number of ticks elapsed since kernel start.
static constexpr TId TID_NONE
Reserved task/thread id representing zero/none thread id.
@ TRACE_EVENT_SWITCH
Task blocked by the context switch.
@ STACK_SLEEP_TRAP
Stack of the Sleep trap.
@ STACK_USER_TASK
Stack of the user task.
@ STACK_EXIT_TRAP
Stack of the Exit trap.
uint64_t Cycles
Cycles value.
EHwException
Hardware exception id (see IPlatform::IEventOverrider::OnException).
@ HW_EXCEPT_MEMACCESS
MemManage on ARM / Page Fault or PMP violation on RISC-V.
@ HW_EXCEPT_FATAL
HardFault on ARM / Unhandled Fatal Trap on RISC-V.
Word TId
Task (thread) id.
int32_t Weight
Weight value (aka priority).
bool IsPrivilegedContext()
Check if caller context is Privileged.
static T * WordToPtr(Word value) noexcept
Cast a CPU register-width integer back to a pointer.
static Word PtrToWord(T *const ptr) noexcept
Cast a pointer to a CPU register-width integer.
bool IsInsideISR()
Check whether the CPU is currently executing inside a hardware interrupt service routine (ISR).
void ProcessTick() override
Process one tick.
Word GetCallerSP() const override
Get caller's Stack Pointer (SP).
void ProcessHardFault() override
Cause a hard fault of the system.
void ForceContextSwitch(TId id) override
Force context switch.
uint32_t GetTickResolution() const override
Get resolution of the system tick timer in microseconds. Resolution means a number of microseconds be...
Timeout Suspend() override
Suspend scheduling.
void Start() override
Start scheduling.
void SetCpuFrequency(uint8_t core_id, uint32_t frequency) override
Notify the scheduler of a CPU core's operating frequency.
void Stop() override
Stop scheduling.
TId GetTid() const override
Get thread Id.
void SetEventOverrider(IEventOverrider *overrider, bool non_secure) override
Set platform event overrider.
uint32_t GetSysTimerFrequency() const override
Get system timer frequency.
Cycles GetSysTimerCount() const override
Get system timer count value.
void InitStack(EStackType stack_type, Stack *stack, IStackMemory *stack_memory, ITask *user_task) override
Initialize stack memory of the user task.
void Resume(Timeout elapsed_ticks) override
Resume scheduling after a prior Suspend() call.
void Initialize(IEventHandler *event_handler, IKernelService *service, uint32_t resolution_us, Stack *exit_trap) override
Initialize scheduler's context.
ARMv7-M/ARMv8-M hardware exception frame (8 words, highest address on the stack).
ARMv7-M/ARMv8-M system fault exception context state capture.
void Fill(const Word *stacked_regs, Word exc_return)
Populate fault context registers and hardware MPU state from an exception stack frame.
Hardware Memory Protection Unit (MPU) status register snapshot.
Region regions[(8U)]
Active hardware MPU region register state table.
Word CTRL
MPU Control Register (MPU_CTRL).
Word RNR
Region Number Register (RNR).
Word ATTR
Region Attribute and Size Register (RASR / RLAR / MPU_RLAR).
Word RBAR
Region Base Address Register (RBAR).
Base platform context for all platform implementations.
static Session Enter(const Session ses=DEFAULT_SESSION)
Enter a critical section.
uint8_t Session
Opaque session token returned by Enter() and consumed by Exit().
static void Exit(const Session ses=DEFAULT_SESSION)
Exit a critical section.
@ SESSION_FLAG_NPRIV
Calling context is non-Privileged.
RAII instance that enters the critical section on construction and exits it on destruction.
Atomic busy-wait lock used as the global cross-core synchronisation primitive inside CriticalSection.
bool TryLock()
Attempt to acquire SpinLock in a single non-blocking attempt.
void Lock()
Acquire SpinLock, blocking until it is available.
void Unlock()
Release SpinLock, allowing another thread or core to acquire it.
High-resolution clock for high-precision measurements.
HiResClock()
Construct a clock instance.
uint32_t GetFrequency() const
Get clock frequency.
Cycles GetCycles()
Get number of clock cycles elapsed since the time origin (see the class description).
uint32_t access_mode
Bitfield with hardware access mode of the task (see EAccessMode).
Word SP
Offset 0: Stack Pointer (SP) register (note: must always be at offset 0).
Interface for a stack memory region.
virtual size_t GetStackSize() const =0
Get number of elements of the stack memory array.
virtual const Word * GetStack() const =0
Get pointer to the stack memory.
Synchronization object interface.
Interface for mutex synchronization primitive.
Interface for a user task.
virtual void Run()=0
Entry point of the user task.
Interface for a platform event overrider.
Interface for the kernel services exposed to the user processes during run-time when Kernel started s...
virtual TId GetTid() const =0
Get thread Id of the currently running task.
virtual Timeout SetTimeSlice(TId tid, Timeout ticks)=0
Change the time-slice quantum of the task at run-time and reload its slice.
virtual void Wake(ISyncObject *sobj, bool all)=0
Wake one or all tasks currently waiting on a synchronization object.
virtual ELockResult UnlockScheduler()=0
Enable task switching (equivalent of CMSIS-RTOS2 osKernelUnlock).
virtual void SleepCancel(TId task_id)=0
Cancel sleep of the task.
virtual void InheritWeight(TId tid, Weight weight)=0
Inherit weight for the task.
virtual bool Sleep(Timeout ticks)=0
Put calling process into a sleep state.
static IKernelService * GetInstance()
Get CPU-local instance of the kernel service.
virtual uint32_t GetTickResolution() const =0
Get number of microseconds in one tick.
virtual bool SleepUntil(Ticks timestamp)=0
Put calling process into a sleep state until the specified timestamp.
virtual Ticks GetTicks() const =0
Get number of ticks elapsed since kernel start.
virtual void SwitchToNext()=0
Notify scheduler to switch to the next task (yield).
virtual void Resume(Timeout elapsed_ticks)=0
Resume scheduling after a prior Suspend() call.
virtual Weight SetWeight(TId tid, Weight weight)=0
Change the base weight of the task at run-time (replaces ITask::GetWeight() value).
virtual void ExitTask()=0
Terminate the calling task: schedule its removal and switch it out. Does not return.
virtual EWaitResult Wait(ISyncObject *sobj, IMutex *mutex, Timeout timeout)=0
Put calling process into a waiting state until synchronization object is signaled or timeout occurs.
virtual ELockResult LockScheduler()=0
Disable task switching (equivalent of CMSIS-RTOS2 osKernelLock). Ticks, timeouts and ISRs keep runnin...
virtual ELockResult RestoreSchedulerLock(bool locked)=0
Set the lock state (equivalent of CMSIS-RTOS2 osKernelRestoreLock).
virtual Cycles GetSysTimerCount() const =0
Get system timer count value.
virtual uint32_t GetSysTimerFrequency() const =0
Get system timer frequency.
virtual Timeout Suspend()=0
Suspend scheduling.
virtual void RestoreWeight(TId tid, ISyncObject *sobj=nullptr)=0
Restore weight of the task to the original value.
virtual void Delay(Timeout ticks)=0
Delay calling process.