12#include "stk_config.h"
14#ifdef _STK_ARCH_RISC_V
64#ifndef STK_RISCV_CLINT_BASE_ADDR
65 #define STK_RISCV_CLINT_BASE_ADDR (0x2000000U)
67#ifndef STK_RISCV_CLINT_MTIMECMP_ADDR
68 #define STK_RISCV_CLINT_MTIMECMP_ADDR (STK_RISCV_CLINT_BASE_ADDR + 0x4000U)
70#ifndef STK_RISCV_CLINT_MTIME_ADDR
71 #define STK_RISCV_CLINT_MTIME_ADDR (STK_RISCV_CLINT_BASE_ADDR + 0xBFF8U)
78#define STK_RISCV_ISR_STACK_SIZE 256U
83#ifndef STK_TIMER_CLOCK_FREQUENCY
84 #define STK_TIMER_CLOCK_FREQUENCY 1000000U
88#ifndef STK_SPINLOCK_TIMEOUT_US
89 #define STK_SPINLOCK_TIMEOUT_US (5U * 1000U * 1000U)
98#ifndef STK_SPINLOCK_MIN_CYCLES_PER_ITER
99 #define STK_SPINLOCK_MIN_CYCLES_PER_ITER (4U)
106#ifndef STK_RISCV_ISR_SECTION
107 #define STK_RISCV_ISR_SECTION
114#define STK_RISCV_ISR extern "C" STK_RISCV_ISR_SECTION __attribute__ ((interrupt("machine")))
117#define STK_ASM_EXIT_FROM_HANDLER "mret"
124#ifndef STK_RISCV_CLINT_MTIMECMP_PER_HART
125 #define STK_RISCV_CLINT_MTIMECMP_PER_HART 1
132#ifndef STK_ARCH_GET_CPU_ID
133 #define STK_ARCH_GET_CPU_ID() read_csr(mhartid)
137#if (__riscv_flen == 0)
138 #define STK_RISCV_FPU 0
140 #define STK_RISCV_FPU __riscv_flen
144#define XSTR(s) STR(s)
147#if (__riscv_xlen == 32)
148 #define REGBYTES XSTR(4)
149 #define LREG XSTR(lw)
150 #define SREG XSTR(sw)
151#elif (__riscv_xlen == 64)
152 #define REGBYTES XSTR(8)
153 #define LREG XSTR(ld)
154 #define SREG XSTR(sd)
156 #error Unsupported RISC-V platform!
159#if (STK_RISCV_FPU == 32)
160 #define FREGBYTES XSTR(4)
161 #define FLREG XSTR(flw)
162 #define FSREG XSTR(fsw)
163#elif (STK_RISCV_FPU == 64)
164 #define FREGBYTES XSTR(8)
165 #define FLREG XSTR(fld)
166 #define FSREG XSTR(fsd)
167#elif (STK_RISCV_FPU != 0)
168#error Unsupported FP register count!
172#if (__riscv_32e == 1)
173 #define STK_RISCV_REGISTER_COUNT (15U + (STK_RISCV_FPU != 0U ? 31U : 0U))
175 #define STK_RISCV_REGISTER_COUNT (31U + (STK_RISCV_FPU != 0U ? 31U : 0U))
178#define STK_SERVICE_SLOTS 2U
180#if (__riscv_32e == 1)
181 #define FOFFSET XSTR(68)
182 #if (STK_RISCV_FPU == 0)
183 #define REGSIZE XSTR(((15U + STK_SERVICE_SLOTS) * 4U))
185 #if (STK_RISCV_FPU == 32)
186 #define REGSIZE XSTR((((15U + STK_SERVICE_SLOTS) * 4U) + (31U * 4U)))
187 #elif (STK_RISCV_FPU == 64)
188 #define REGSIZE XSTR((((15U + STK_SERVICE_SLOTS) * 4U) + (31U * 8U)))
191#elif (__riscv_xlen == 32)
192 #define FOFFSET XSTR(132)
193 #if (STK_RISCV_FPU == 0)
194 #define REGSIZE XSTR(((31U + STK_SERVICE_SLOTS) * 4U))
196 #if (STK_RISCV_FPU == 32)
197 #define REGSIZE XSTR((((31U + STK_SERVICE_SLOTS) * 4U) + (31U * 4U)))
198 #elif (STK_RISCV_FPU == 64)
199 #define REGSIZE XSTR((((31U + STK_SERVICE_SLOTS) * 4U) + (31U * 8U)))
202#elif (__riscv_xlen == 64)
203 #define FOFFSET XSTR(264)
204 #if (STK_RISCV_FPU == 0)
205 #define REGSIZE XSTR(((31U + STK_SERVICE_SLOTS) * 8U))
207 #if (STK_RISCV_FPU == 32)
208 #define REGSIZE XSTR((((31U + STK_SERVICE_SLOTS) * 8U) + (31U * 4U)))
209 #elif (STK_RISCV_FPU == 64)
210 #define REGSIZE XSTR((((31U + STK_SERVICE_SLOTS) * 8U) + (31U * 8U)))
215#if (__riscv_xlen == 32)
216 #define REGBYTES_LOG2 "2"
217#elif (__riscv_xlen == 64)
218 #define REGBYTES_LOG2 "3"
227#ifndef STK_SYSTICK_HANDLER
228 #define STK_SYSTICK_HANDLER riscv_mtvec_mti
237#ifndef STK_SVC_HANDLER
238 #define STK_SVC_HANDLER riscv_mtvec_exception
248#ifndef STK_MSI_HANDLER
249 #define STK_MSI_HANDLER riscv_mtvec_msi
283#if (STK_RISCV_FPU != 0)
300#if (__riscv_32e != 1)
318#if (STK_RISCV_FPU != 0)
337void OnTaskRun(ITask *task);
339void OnSchedulerSleep();
340void OnSchedulerSleepOverride();
341void OnSchedulerExit();
376#ifdef _STK_RISCV_USE_PENDSV
405#ifdef _STK_RISCV_USE_PENDSV
421#if STK_CORE_FREQ_UNIFIED
422uint32_t s_StkSystemCoreClock[1U];
436uint32_t s_StkSpinlockTimeoutIters = 0xFFFFFFFU;
441volatile bool s_StkRiscvCsuLock =
false;
447 __asm
volatile(
"fence rw, rw" :::
"memory");
454#ifdef __riscv_zifencei
455 __asm
volatile(
"fence.i" :::
"memory");
457 __sync_synchronize();
465 __asm
volatile(
"wfi");
473 __asm
volatile(
"ecall");
487 __asm
volatile(
"csrrci zero, mstatus, %0"
497 __asm
volatile(
"csrrsi zero, mstatus, %0"
509 __asm
volatile(
"csrrci %0, mstatus, %1"
522 __asm
volatile(
"csrrs zero, mstatus, %0"
540 clear_csr(mie, MIP_MTIP);
549 volatile uint32_t *msip = (
volatile uint32_t *)(STK_RISCV_CLINT_BASE_ADDR);
561 clear_csr(mie, MIP_MSIP);
569#if STK_CORE_FREQ_UNIFIED
570 return s_StkSystemCoreClock[0];
582 return STK_TIMER_CLOCK_FREQUENCY;
592#if ( __riscv_xlen > 32)
595 const Word mtime_base = STK_RISCV_CLINT_MTIME_ADDR;
605 while (hi != (*mtime_hi));
607 return (
static_cast<uint64_t
>(hi) << 32) | lo;
616#if STK_RISCV_CLINT_MTIMECMP_PER_HART
617 const uint8_t hart = HW_GetHartId();
619 const uint8_t hart = 0U;
622#if (__riscv_xlen == 64)
625 const Word mtimecmp_base = STK_RISCV_CLINT_MTIMECMP_ADDR + (hart *
sizeof(uint64_t));
630 STK_ASSERT(((uintptr_t)mtimecmp_lo & (4U - 1U)) == 0U);
631 STK_ASSERT(((uintptr_t)mtimecmp_hi & (4U - 1U)) == 0U);
635 (*mtimecmp_hi) = ~0U;
637 (*mtimecmp_lo) = (uint32_t)(time_next & 0xFFFFFFFFU);
638 (*mtimecmp_hi) = (uint32_t)(time_next >> 32);
649 return HW_GetMtime() - since;
656 __asm
volatile(
"csrci mcountinhibit, 0x1");
664 uint32_t high, low, check;
667 __asm
volatile(
"csrr %0, mcycleh" :
"=r"(high));
668 __asm
volatile(
"csrr %0, mcycle" :
"=r"(low));
669 __asm
volatile(
"csrr %0, mcycleh" :
"=r"(check));
671 while (high != check);
673 return (
static_cast<Cycles>(high) << 32) | low;
681 __asm
volatile(
"mv %0, sp"
693 ses = HW_EnterCriticalSection();
707 HW_ExitCriticalSection(ses);
729 return !__atomic_test_and_set(&lock, __ATOMIC_ACQUIRE);
754 uint32_t timeout = s_StkSpinlockTimeoutIters;
755 while (!HW_SpinLockTryLock(lock))
793 __asm
volatile(
"fence rw, w" :::
"memory");
795 __atomic_clear(&lock, __ATOMIC_RELEASE);
810void HW_InitSpinlockTimeout()
813 const Cycles iters = cycles_budget / STK_SPINLOCK_MIN_CYCLES_PER_ITER;
817 s_StkSpinlockTimeoutIters =
static_cast<uint32_t
>(
870#if (STK_RISCV_FPU != 0)
890int32_t SaveJmp(JmpFrame &)
894 SREG
" ra, 0*" REGBYTES
"(a0) \n"
895 SREG
" sp, 1*" REGBYTES
"(a0) \n"
896 SREG
" s0, 2*" REGBYTES
"(a0) \n"
897 SREG
" s1, 3*" REGBYTES
"(a0) \n"
898 SREG
" s2, 4*" REGBYTES
"(a0) \n"
899 SREG
" s3, 5*" REGBYTES
"(a0) \n"
900 SREG
" s4, 6*" REGBYTES
"(a0) \n"
901 SREG
" s5, 7*" REGBYTES
"(a0) \n"
902 SREG
" s6, 8*" REGBYTES
"(a0) \n"
903 SREG
" s7, 9*" REGBYTES
"(a0) \n"
904 SREG
" s8, 10*" REGBYTES
"(a0) \n"
905 SREG
" s9, 11*" REGBYTES
"(a0) \n"
906 SREG
" s10, 12*" REGBYTES
"(a0) \n"
907 SREG
" s11, 13*" REGBYTES
"(a0) \n"
908#if (STK_RISCV_FPU != 0)
910 SREG
" t0, 14*" REGBYTES
"(a0) \n"
935void RestoreJmp(JmpFrame &, int32_t )
939 LREG
" ra, 0*" REGBYTES
"(a0) \n"
940 LREG
" sp, 1*" REGBYTES
"(a0) \n"
941 LREG
" s0, 2*" REGBYTES
"(a0) \n"
942 LREG
" s1, 3*" REGBYTES
"(a0) \n"
943 LREG
" s2, 4*" REGBYTES
"(a0) \n"
944 LREG
" s3, 5*" REGBYTES
"(a0) \n"
945 LREG
" s4, 6*" REGBYTES
"(a0) \n"
946 LREG
" s5, 7*" REGBYTES
"(a0) \n"
947 LREG
" s6, 8*" REGBYTES
"(a0) \n"
948 LREG
" s7, 9*" REGBYTES
"(a0) \n"
949 LREG
" s8, 10*" REGBYTES
"(a0) \n"
950 LREG
" s9, 11*" REGBYTES
"(a0) \n"
951 LREG
" s10, 12*" REGBYTES
"(a0) \n"
952 LREG
" s11, 13*" REGBYTES
"(a0) \n"
953#if (STK_RISCV_FPU != 0)
954 LREG
" t0, 14*" REGBYTES
"(a0) \n"
977 constexpr Context() : PlatformContext(), m_stack_main(), m_stack_isr(), m_stack_isr_mem(),
978 m_exit_buf(), m_overrider(nullptr), m_specific(nullptr), m_tick_period(0), m_last_mtime(0ULL),
979 #if STK_TICKLESS_IDLE
982 m_csu(0), m_csu_nesting(0),
983 m_starting(false), m_started(false), m_exiting(false)
987 void Initialize(IPlatform::IEventHandler *handler, IKernelService *service, Stack *exit_trap,
988 uint32_t resolution_us)
990 InitializeBase(handler, service, exit_trap, resolution_us);
993 "expect Stack::mode member at offset of 0 (first member)");
995 STK_ASSERT(g_StkLastPanicId == KERNEL_PANIC_NONE);
999 StackMemoryWrapper<STK_RISCV_ISR_STACK_SIZE> stack_isr_mem(&m_stack_isr_mem);
1000 m_stack_isr.SP = InitStackMemory(&stack_isr_mem);
1012 m_tick_period = ConvertTimeUsToClockCycles(STK_TIMER_CLOCK_FREQUENCY, resolution_us);
1013 m_last_mtime = 0ULL;
1019 if (s_StkSystemCoreClock[0] == 0U)
1032 HW_InitSpinlockTimeout();
1035 #if STK_SUBMICORSECOND_PRECISION_TIMER
1036 HW_EnableCycleCounter();
1044 HW_CriticalSectionStart(cs);
1046 #if STK_TICKLESS_IDLE
1047 Timeout ticks = m_sleep_ticks;
1050 if (m_handler->OnTick(m_stack_idle, m_stack_active
1051 #
if STK_TICKLESS_IDLE
1062 const uint8_t hart = HW_GetHartId();
1063 s_StkRiscvStackActive[hart] = m_stack_active;
1064 #ifdef _STK_RISCV_USE_PENDSV
1065 s_StkRiscvStackIdle[hart] = m_stack_idle;
1068 #if STK_SEGGER_SYSVIEW
1069 if (m_stack_idle->tid != SYS_TASK_ID_SLEEP)
1072 SEGGER_SYSVIEW_OnTaskStopReady(m_stack_idle->tid, TRACE_EVENT_SWITCH);
1075 if (m_stack_active->tid != SYS_TASK_ID_SLEEP)
1078 SEGGER_SYSVIEW_OnTaskStartExec(m_stack_active->tid);
1082 #ifdef _STK_RISCV_USE_PENDSV
1083 HW_ScheduleContextSwitch(hart);
1087 #if STK_TICKLESS_IDLE
1088 m_sleep_ticks = ticks;
1091 HW_CriticalSectionEnd(cs);
1098 HW_CriticalSectionStart(current_ses);
1100 if (m_csu_nesting == 0U)
1103 HW_SpinLockLock(s_StkRiscvCsuLock);
1106 m_csu = current_ses;
1122 if (m_csu_nesting == 0U)
1125 const Word ses_to_restore = m_csu;
1128 HW_SpinLockUnlock(s_StkRiscvCsuLock);
1131 HW_CriticalSectionEnd(ses_to_restore);
1135 uint64_t GetSleepTicksPrev()
1137 #if STK_TICKLESS_IDLE
1138 const uint64_t ticks = (
static_cast<uint64_t
>(m_sleep_ticks) *
static_cast<uint64_t
>(m_tick_period));
1140 const uint64_t ticks = (1U *
static_cast<uint64_t
>(m_tick_period));
1145 uint64_t GetTimeNow(uint64_t &error)
1147 const uint64_t mtime_now = HW_GetMtime();
1148 error = (mtime_now - m_last_mtime) - GetSleepTicksPrev();
1152 void RearmTimer(
const uint64_t mtime_now,
const uint64_t error)
1154 #if STK_TICKLESS_IDLE
1156 STK_ASSERT((
static_cast<uint64_t
>(m_sleep_ticks) *
static_cast<uint64_t
>(m_tick_period)) <= (UINT64_MAX - mtime_now));
1157 const uint64_t next_time = (
static_cast<uint64_t
>(m_sleep_ticks) *
static_cast<uint64_t
>(m_tick_period));
1159 const uint64_t next_time = (1U *
static_cast<uint64_t
>(m_tick_period));
1161 HW_SetMtimecmp(mtime_now + next_time - error);
1162 m_last_mtime = mtime_now;
1170 uint64_t error = 0U;
1171 const uint64_t mtime_now = GetTimeNow(error);
1172 __stk_compiler_barrier();
1183 RearmTimer(mtime_now, error);
1188 if (m_handler->OnForceContextSwitch(
id, m_stack_idle, m_stack_active))
1197 const uint8_t hart = HW_GetHartId();
1198 s_StkRiscvStackActive[hart] = m_stack_active;
1199 s_StkRiscvStackIdle[hart] = m_stack_idle;
1202 HW_ScheduleContextSwitch(hart);
1206 void StartTickTimer(Timeout elapsed_ticks)
1208 #if STK_TICKLESS_IDLE
1210 m_sleep_ticks = elapsed_ticks;
1216 m_last_mtime = HW_GetMtime();
1217 HW_SetMtimecmp(m_last_mtime + m_tick_period);
1220 set_csr(mie, MIP_MTIP);
1223 void OnSleepOverride()
1225 #if STK_TICKLESS_IDLE
1226 const Timeout sleep_ticks = m_sleep_ticks;
1228 const Timeout sleep_ticks = 1;
1231 if (!m_overrider->OnSleep(sleep_ticks))
1233 HW_EnterSleepMode();
1237#if STK_TLS && !STK_INLINE_TLS
1240 hw::CriticalSection::ScopedLock cs_;
1244 return m_stack_active->tls;
1247 void SetTls(Word tp)
1249 hw::CriticalSection::ScopedLock cs_;
1253 m_stack_active->tls = tp;
1260#if STK_TICKLESS_IDLE
1262 void Resume(Timeout elapsed_ticks);
1265 typedef IPlatform::IEventOverrider eovrd_t;
1266 typedef PlatformRiscV::ISpecificEventHandler sehndl_t;
1267 typedef StackMemoryWrapper<STK_RISCV_ISR_STACK_SIZE>::MemoryType isrmem_t;
1271 isrmem_t m_stack_isr_mem;
1272 drv::JmpFrame m_exit_buf;
1273 eovrd_t *m_overrider;
1274 sehndl_t *m_specific;
1275 uint32_t m_tick_period;
1276 uint64_t m_last_mtime;
1277#if STK_TICKLESS_IDLE
1281 uint8_t m_csu_nesting;
1284 volatile bool m_exiting;
1301 g_StkLastPanicId = id;
1304 HW_DisableInterrupts();
1316#ifdef _STK_RISCV_USE_PENDSV
1318 HW_CriticalSectionStart(cs);
1322 HW_CriticalSectionEnd(cs);
1329#define STK_ASM_SAVE_CONTEXT_BASE\
1330 SREG " x1, 2*" REGBYTES "(sp) \n"\
1333 SREG " x4, 5*" REGBYTES "(sp) \n"\
1334 SREG " x5, 6*" REGBYTES "(sp) \n"\
1335 SREG " x6, 7*" REGBYTES "(sp) \n"\
1336 SREG " x7, 8*" REGBYTES "(sp) \n"\
1337 SREG " x8, 9*" REGBYTES "(sp) \n"\
1338 SREG " x9, 10*" REGBYTES "(sp) \n"\
1339 SREG " x10, 11*" REGBYTES "(sp) \n"\
1340 SREG " x11, 12*" REGBYTES "(sp) \n"\
1341 SREG " x12, 13*" REGBYTES "(sp) \n"\
1342 SREG " x13, 14*" REGBYTES "(sp) \n"\
1343 SREG " x14, 15*" REGBYTES "(sp) \n"\
1344 SREG " x15, 16*" REGBYTES "(sp) \n"
1346#if (__riscv_32e != 1)
1347#define STK_ASM_SAVE_CONTEXT_RV32I_EXT\
1348 SREG " x16, 17*" REGBYTES "(sp) \n"\
1349 SREG " x17, 18*" REGBYTES "(sp) \n"\
1350 SREG " x18, 19*" REGBYTES "(sp) \n"\
1351 SREG " x19, 20*" REGBYTES "(sp) \n"\
1352 SREG " x20, 21*" REGBYTES "(sp) \n"\
1353 SREG " x21, 22*" REGBYTES "(sp) \n"\
1354 SREG " x22, 23*" REGBYTES "(sp) \n"\
1355 SREG " x23, 24*" REGBYTES "(sp) \n"\
1356 SREG " x24, 25*" REGBYTES "(sp) \n"\
1357 SREG " x25, 26*" REGBYTES "(sp) \n"\
1358 SREG " x26, 27*" REGBYTES "(sp) \n"\
1359 SREG " x27, 28*" REGBYTES "(sp) \n"\
1360 SREG " x28, 29*" REGBYTES "(sp) \n"\
1361 SREG " x29, 30*" REGBYTES "(sp) \n"\
1362 SREG " x30, 31*" REGBYTES "(sp) \n"\
1363 SREG " x31, 32*" REGBYTES "(sp) \n"
1365#define STK_ASM_SAVE_CONTEXT_RV32I_EXT
1368#if (STK_RISCV_FPU != 0)
1369#define STK_ASM_SAVE_CONTEXT_FP\
1370 FSREG " f0, " FOFFSET "+0*" FREGBYTES "(sp) \n"\
1371 FSREG " f1, " FOFFSET "+1*" FREGBYTES "(sp) \n"\
1372 FSREG " f2, " FOFFSET "+2*" FREGBYTES "(sp) \n"\
1373 FSREG " f3, " FOFFSET "+3*" FREGBYTES "(sp) \n"\
1374 FSREG " f4, " FOFFSET "+4*" FREGBYTES "(sp) \n"\
1375 FSREG " f5, " FOFFSET "+5*" FREGBYTES "(sp) \n"\
1376 FSREG " f6, " FOFFSET "+6*" FREGBYTES "(sp) \n"\
1377 FSREG " f7, " FOFFSET "+7*" FREGBYTES "(sp) \n"\
1378 FSREG " f8, " FOFFSET "+8*" FREGBYTES "(sp) \n"\
1379 FSREG " f9, " FOFFSET "+9*" FREGBYTES "(sp) \n"\
1380 FSREG " f10, " FOFFSET "+10*" FREGBYTES "(sp) \n"\
1381 FSREG " f11, " FOFFSET "+11*" FREGBYTES "(sp) \n"\
1382 FSREG " f12, " FOFFSET "+12*" FREGBYTES "(sp) \n"\
1383 FSREG " f13, " FOFFSET "+13*" FREGBYTES "(sp) \n"\
1384 FSREG " f14, " FOFFSET "+14*" FREGBYTES "(sp) \n"\
1385 FSREG " f15, " FOFFSET "+15*" FREGBYTES "(sp) \n"\
1386 FSREG " f16, " FOFFSET "+16*" FREGBYTES "(sp) \n"\
1387 FSREG " f17, " FOFFSET "+17*" FREGBYTES "(sp) \n"\
1388 FSREG " f18, " FOFFSET "+18*" FREGBYTES "(sp) \n"\
1389 FSREG " f19, " FOFFSET "+19*" FREGBYTES "(sp) \n"\
1390 FSREG " f20, " FOFFSET "+20*" FREGBYTES "(sp) \n"\
1391 FSREG " f21, " FOFFSET "+21*" FREGBYTES "(sp) \n"\
1392 FSREG " f22, " FOFFSET "+22*" FREGBYTES "(sp) \n"\
1393 FSREG " f23, " FOFFSET "+23*" FREGBYTES "(sp) \n"\
1394 FSREG " f24, " FOFFSET "+24*" FREGBYTES "(sp) \n"\
1395 FSREG " f25, " FOFFSET "+25*" FREGBYTES "(sp) \n"\
1396 FSREG " f26, " FOFFSET "+26*" FREGBYTES "(sp) \n"\
1397 FSREG " f27, " FOFFSET "+27*" FREGBYTES "(sp) \n"\
1398 FSREG " f28, " FOFFSET "+28*" FREGBYTES "(sp) \n"\
1399 FSREG " f29, " FOFFSET "+29*" FREGBYTES "(sp) \n"\
1400 FSREG " f30, " FOFFSET "+30*" FREGBYTES "(sp) \n"\
1401 FSREG " f31, " FOFFSET "+31*" FREGBYTES "(sp) \n"
1403#define STK_ASM_SAVE_CONTEXT_FP
1406#define STK_ASM_SAVE_CONTEXT_PC_STATUS\
1408 "csrr t1, mstatus \n"\
1409 SREG " t0, 0*" REGBYTES "(sp) \n"\
1410 SREG " t1, 1*" REGBYTES "(sp) \n"
1412#if (STK_RISCV_FPU != 0)
1413#define STK_ASM_SAVE_CONTEXT_FRCSR\
1415 SREG " t0, 4*" REGBYTES "(sp) \n"
1417#define STK_ASM_SAVE_CONTEXT_FRCSR
1420#define STK_ASM_SAVE_CONTEXT\
1421 "addi sp, sp, -" REGSIZE " \n" \
1422 STK_ASM_SAVE_CONTEXT_BASE\
1423 STK_ASM_SAVE_CONTEXT_RV32I_EXT\
1424 STK_ASM_SAVE_CONTEXT_FP\
1425 STK_ASM_SAVE_CONTEXT_PC_STATUS\
1426 STK_ASM_SAVE_CONTEXT_FRCSR
1428#define STK_ASM_LOAD_CONTEXT_BASE\
1429 LREG " x1, 2*" REGBYTES "(sp) \n"\
1432 LREG " x4, 5*" REGBYTES "(sp) \n"\
1433 LREG " x5, 6*" REGBYTES "(sp) \n"\
1434 LREG " x6, 7*" REGBYTES "(sp) \n"\
1435 LREG " x7, 8*" REGBYTES "(sp) \n"\
1436 LREG " x8, 9*" REGBYTES "(sp) \n"\
1437 LREG " x9, 10*" REGBYTES "(sp) \n"\
1438 LREG " x10, 11*" REGBYTES "(sp) \n"\
1439 LREG " x11, 12*" REGBYTES "(sp) \n"\
1440 LREG " x12, 13*" REGBYTES "(sp) \n"\
1441 LREG " x13, 14*" REGBYTES "(sp) \n"\
1442 LREG " x14, 15*" REGBYTES "(sp) \n"\
1443 LREG " x15, 16*" REGBYTES "(sp) \n"
1445#if (__riscv_32e != 1)
1446#define STK_ASM_LOAD_CONTEXT_RV32I_EXT\
1447 LREG " x16, 17*" REGBYTES "(sp) \n"\
1448 LREG " x17, 18*" REGBYTES "(sp) \n"\
1449 LREG " x18, 19*" REGBYTES "(sp) \n"\
1450 LREG " x19, 20*" REGBYTES "(sp) \n"\
1451 LREG " x20, 21*" REGBYTES "(sp) \n"\
1452 LREG " x21, 22*" REGBYTES "(sp) \n"\
1453 LREG " x22, 23*" REGBYTES "(sp) \n"\
1454 LREG " x23, 24*" REGBYTES "(sp) \n"\
1455 LREG " x24, 25*" REGBYTES "(sp) \n"\
1456 LREG " x25, 26*" REGBYTES "(sp) \n"\
1457 LREG " x26, 27*" REGBYTES "(sp) \n"\
1458 LREG " x27, 28*" REGBYTES "(sp) \n"\
1459 LREG " x28, 29*" REGBYTES "(sp) \n"\
1460 LREG " x29, 30*" REGBYTES "(sp) \n"\
1461 LREG " x30, 31*" REGBYTES "(sp) \n"\
1462 LREG " x31, 32*" REGBYTES "(sp) \n"
1464#define STK_ASM_LOAD_CONTEXT_RV32I_EXT
1467#if (STK_RISCV_FPU != 0)
1468#define STK_ASM_LOAD_CONTEXT_FP\
1469 FLREG " f0, " FOFFSET "+0*" FREGBYTES "(sp) \n"\
1470 FLREG " f1, " FOFFSET "+1*" FREGBYTES "(sp) \n"\
1471 FLREG " f2, " FOFFSET "+2*" FREGBYTES "(sp) \n"\
1472 FLREG " f3, " FOFFSET "+3*" FREGBYTES "(sp) \n"\
1473 FLREG " f4, " FOFFSET "+4*" FREGBYTES "(sp) \n"\
1474 FLREG " f5, " FOFFSET "+5*" FREGBYTES "(sp) \n"\
1475 FLREG " f6, " FOFFSET "+6*" FREGBYTES "(sp) \n"\
1476 FLREG " f7, " FOFFSET "+7*" FREGBYTES "(sp) \n"\
1477 FLREG " f8, " FOFFSET "+8*" FREGBYTES "(sp) \n"\
1478 FLREG " f9, " FOFFSET "+9*" FREGBYTES "(sp) \n"\
1479 FLREG " f10, " FOFFSET "+10*" FREGBYTES "(sp) \n"\
1480 FLREG " f11, " FOFFSET "+11*" FREGBYTES "(sp) \n"\
1481 FLREG " f12, " FOFFSET "+12*" FREGBYTES "(sp) \n"\
1482 FLREG " f13, " FOFFSET "+13*" FREGBYTES "(sp) \n"\
1483 FLREG " f14, " FOFFSET "+14*" FREGBYTES "(sp) \n"\
1484 FLREG " f15, " FOFFSET "+15*" FREGBYTES "(sp) \n"\
1485 FLREG " f16, " FOFFSET "+16*" FREGBYTES "(sp) \n"\
1486 FLREG " f17, " FOFFSET "+17*" FREGBYTES "(sp) \n"\
1487 FLREG " f18, " FOFFSET "+18*" FREGBYTES "(sp) \n"\
1488 FLREG " f19, " FOFFSET "+19*" FREGBYTES "(sp) \n"\
1489 FLREG " f20, " FOFFSET "+20*" FREGBYTES "(sp) \n"\
1490 FLREG " f21, " FOFFSET "+21*" FREGBYTES "(sp) \n"\
1491 FLREG " f22, " FOFFSET "+22*" FREGBYTES "(sp) \n"\
1492 FLREG " f23, " FOFFSET "+23*" FREGBYTES "(sp) \n"\
1493 FLREG " f24, " FOFFSET "+24*" FREGBYTES "(sp) \n"\
1494 FLREG " f25, " FOFFSET "+25*" FREGBYTES "(sp) \n"\
1495 FLREG " f26, " FOFFSET "+26*" FREGBYTES "(sp) \n"\
1496 FLREG " f27, " FOFFSET "+27*" FREGBYTES "(sp) \n"\
1497 FLREG " f28, " FOFFSET "+28*" FREGBYTES "(sp) \n"\
1498 FLREG " f29, " FOFFSET "+29*" FREGBYTES "(sp) \n"\
1499 FLREG " f30, " FOFFSET "+30*" FREGBYTES "(sp) \n"\
1500 FLREG " f31, " FOFFSET "+31*" FREGBYTES "(sp) \n"
1502#define STK_ASM_LOAD_CONTEXT_FP
1505#define STK_ASM_LOAD_CONTEXT_PC_STATUS\
1506 LREG " t0, 0*" REGBYTES "(sp) \n"\
1507 LREG " t1, 1*" REGBYTES "(sp) \n"\
1509 "csrw mstatus, t1 \n"
1511#if (STK_RISCV_FPU != 0)
1512#define STK_ASM_LOAD_CONTEXT_FRCSR\
1513 LREG " t0, 4*" REGBYTES "(sp) \n" \
1516#define STK_ASM_LOAD_CONTEXT_FRCSR
1519#define STK_ASM_LOAD_CONTEXT\
1520 STK_ASM_LOAD_CONTEXT_PC_STATUS\
1521 STK_ASM_LOAD_CONTEXT_FRCSR\
1522 STK_ASM_LOAD_CONTEXT_BASE\
1523 STK_ASM_LOAD_CONTEXT_RV32I_EXT\
1524 STK_ASM_LOAD_CONTEXT_FP\
1525 "addi sp, sp, " REGSIZE " \n"
1536 LREG
" sp, 0(t0) \n"
1538 STK_ASM_LOAD_CONTEXT
1539 STK_ASM_EXIT_FROM_HANDLER
" \n"
1543 :
"t0",
"t1",
"a2",
"a3",
"a4",
"a5",
"gp",
"memory");
1548#if (STK_RISCV_FPU != 0)
1552 :
"r"(MSTATUS_FS | MSTATUS_XS)
1559#if (STK_RISCV_FPU != 0)
1598 __asm
volatile(
"csrr %0, mcause" :
"=r"(mcause));
1604 const Word current_sp = HW_GetCallerSP();
1609 const Word isr_stack_top = isr_stack_base + (STK_RISCV_ISR_STACK_SIZE *
sizeof(
Word));
1611 return ((current_sp >= isr_stack_base) && (current_sp < isr_stack_top));
1616 HW_LoadContextAndExit();
1624extern "C" STK_RISCV_ISR_SECTION
__stk_attr_used void TrySwitchContext()
1629#ifdef _STK_RISCV_USE_PENDSV
1630extern "C" STK_RISCV_ISR_SECTION
__stk_attr_naked void STK_SYSTICK_HANDLER()
1634 STK_ASM_SAVE_CONTEXT
1637#if (STK_ARCH_CPU_COUNT > 1)
1638 "csrr t0, mhartid \n"
1639 "la t1, s_StkRiscvSpIsrInt \n"
1640 "slli t0, t0, " REGBYTES_LOG2
" \n"
1642 SREG
" sp, 0(t1) \n"
1644 "la t1, s_StkRiscvSpIsrInt \n"
1645 SREG
" sp, 0(t1) \n"
1649#if (STK_ARCH_CPU_COUNT > 1)
1650 "csrr t0, mhartid \n"
1651 "la t1, s_StkRiscvStackIsr \n"
1652 "slli t0, t0, " REGBYTES_LOG2
" \n"
1654 LREG
" t1, 0(t1) \n"
1656 "la t1, s_StkRiscvStackIsr \n"
1657 LREG
" t1, 0(t1) \n"
1659 LREG
" sp, 0(t1) \n"
1662 "jal ra, TrySwitchContext \n"
1665#if (STK_ARCH_CPU_COUNT > 1)
1666 "csrr t0, mhartid \n"
1667 "la t1, s_StkRiscvSpIsrInt \n"
1668 "slli t0, t0, " REGBYTES_LOG2
" \n"
1670 LREG
" sp, 0(t1) \n"
1672 "la t1, s_StkRiscvSpIsrInt \n"
1673 LREG
" sp, 0(t1) \n"
1677 STK_ASM_LOAD_CONTEXT
1680 STK_ASM_EXIT_FROM_HANDLER
" \n"
1713 STK_ASM_SAVE_CONTEXT
1719#if (STK_ARCH_CPU_COUNT > 1)
1720 "csrr t0, mhartid \n"
1721 "la t1, s_StkRiscvStackIdle \n"
1722 "slli t0, t0, " REGBYTES_LOG2
" \n"
1724 LREG
" t1, 0(t1) \n"
1726 "la t1, s_StkRiscvStackIdle \n"
1727 LREG
" t1, 0(t1) \n"
1729 SREG
" sp, 0(t1) \n"
1732#if (STK_ARCH_CPU_COUNT > 1)
1733 "csrr t0, mhartid \n"
1735 "li t1, %[clint_msip_base] \n"
1738 "li t0, %[clint_msip_base] \n"
1744#if (STK_ARCH_CPU_COUNT > 1)
1745 "csrr t0, mhartid \n"
1746 "la t1, s_StkRiscvStackActive \n"
1747 "slli t0, t0, " REGBYTES_LOG2
" \n"
1749 LREG
" t1, 0(t1) \n"
1751 "la t1, s_StkRiscvStackActive \n"
1752 LREG
" t1, 0(t1) \n"
1754 LREG
" sp, 0(t1) \n"
1757 STK_ASM_LOAD_CONTEXT
1760 STK_ASM_EXIT_FROM_HANDLER
" \n"
1763 : [clint_msip_base]
"i" (STK_RISCV_CLINT_BASE_ADDR)
1767#ifndef _STK_RISCV_USE_PENDSV
1809extern "C" STK_RISCV_ISR_SECTION
__stk_attr_naked void STK_SYSTICK_HANDLER()
1813 STK_ASM_SAVE_CONTEXT
1819#if (STK_ARCH_CPU_COUNT > 1)
1820 "csrr t0, mhartid \n"
1821 "la t1, s_StkRiscvStackActive \n"
1822 "slli t0, t0, " REGBYTES_LOG2
" \n"
1824 LREG
" t1, 0(t1) \n"
1826 "la t1, s_StkRiscvStackActive \n"
1827 LREG
" t1, 0(t1) \n"
1829 SREG
" sp, 0(t1) \n"
1832#if (STK_ARCH_CPU_COUNT > 1)
1833 "csrr t0, mhartid \n"
1834 "la t1, s_StkRiscvStackIsr \n"
1835 "slli t0, t0, " REGBYTES_LOG2
" \n"
1837 LREG
" t1, 0(t1) \n"
1839 "la t1, s_StkRiscvStackIsr \n"
1840 LREG
" t1, 0(t1) \n"
1842 LREG
" sp, 0(t1) \n"
1849 "jal ra, TrySwitchContext \n"
1854#if (STK_ARCH_CPU_COUNT > 1)
1855 "csrr t0, mhartid \n"
1856 "la t1, s_StkRiscvStackActive \n"
1857 "slli t0, t0, " REGBYTES_LOG2
" \n"
1859 LREG
" t1, 0(t1) \n"
1861 "la t1, s_StkRiscvStackActive \n"
1862 LREG
" t1, 0(t1) \n"
1864 LREG
" sp, 0(t1) \n"
1867 STK_ASM_LOAD_CONTEXT
1870 STK_ASM_EXIT_FROM_HANDLER
" \n"
1879void Context::OnStart()
1881 const uint8_t hart = HW_GetHartId();
1887 HW_EnableFullFpuAccess();
1893 m_handler->OnStart(m_stack_active);
1896 s_StkRiscvStackIsr[hart] = &m_stack_isr;
1897 s_StkRiscvStackActive[hart] = m_stack_active;
1898 s_StkRiscvStackIdle[hart] = m_stack_idle;
1908#if STK_SEGGER_SYSVIEW
1909 SEGGER_SYSVIEW_OnTaskStartExec(m_stack_active->tid);
1915 set_csr(mie, MIP_MSIP);
1918STK_RISCV_ISR
void STK_SVC_HANDLER()
1920 const Word cause = HW_GetCurrentException();
1933 if (cause == IRQ_M_EXT)
1936 if (!ctx.m_starting)
1939 if (ctx.m_specific !=
nullptr)
1941 ctx.m_specific->OnException(cause);
1945 write_csr(mepc, read_csr(mepc) +
sizeof(
Word));
1950 HW_DisableInterrupts();
1961 if (ctx.m_specific !=
nullptr)
1964 ctx.m_specific->OnException(cause);
1976void drv::OnTaskRun(
ITask *task)
1981void drv::OnTaskExit()
1986 HW_CriticalSectionStart(cs);
1988 ctx.m_handler->OnTaskExit(ctx.m_stack_active);
1990 HW_CriticalSectionEnd(cs);
1999STK_RISCV_ISR_SECTION
2000void drv::OnSchedulerSleep()
2007 #if STK_SEGGER_SYSVIEW
2008 SEGGER_SYSVIEW_OnIdle();
2011 HW_EnterSleepMode();
2015STK_RISCV_ISR_SECTION
2016void drv::OnSchedulerSleepOverride()
2023 #if STK_SEGGER_SYSVIEW
2024 SEGGER_SYSVIEW_OnIdle();
2031void drv::OnSchedulerExit()
2042 GetContext().Initialize(event_handler, service, exit_trap, resolution_us);
2045void Context::Start()
2054 m_handler->OnStop();
2059 HW_EnableFullFpuAccess();
2063 HW_StartScheduler();
2067#if STK_TICKLESS_IDLE
2071 if (resolution == 0U)
2077 HW_DisableInterrupts();
2083 HW_ClearPendingSwitch();
2087 const uint32_t elapsed = HW_GetMtime() - m_last_mtime;
2091 const Timeout elapsed_ticks =
static_cast<Timeout>(elapsed / resolution);
2092 const Timeout sleep_ticks =
Max(m_sleep_ticks - elapsed_ticks,
static_cast<Timeout>(0));
2095 m_handler->OnSuspend(
true);
2097 HW_EnableInterrupts();
2103#if STK_TICKLESS_IDLE
2104void Context::Resume(
Timeout elapsed_ticks)
2106 HW_DisableInterrupts();
2109 m_handler->OnSuspend(
false);
2112 StartTickTimer(elapsed_ticks + 1);
2114 HW_EnableInterrupts();
2127 "TaskFrame size must match REGSIZE: (REGISTER_COUNT + SERVICE_SLOTS) * REGBYTES");
2135 stack->
SP = stack_top - ((STK_RISCV_REGISTER_COUNT + STK_SERVICE_SLOTS) *
sizeof(
Word));
2150 task_frame->MEPC =
hw::PtrToWord(
GetContext().m_overrider !=
nullptr ? &drv::OnSchedulerSleepOverride : &drv::OnSchedulerSleep);
2166 task_frame->MSTATUS = MSTATUS_MPP | MSTATUS_MPIE | (STK_RISCV_FPU != 0U ? (MSTATUS_FS | MSTATUS_XS) : 0U);
2168#if (STK_RISCV_FPU != 0)
2169 task_frame->X3_FSR = 0U;
2173void Context::OnStop()
2179 HW_ClearPendingSwitch();
2194 HW_DisableInterrupts();
2205 return static_cast<Cycles>(HW_GetMtime());
2210 return HW_MtimeClockFrequency();
2216 HW_CriticalSectionStart(cs);
2221 ctx.OnForceContextSwitch(
id);
2223 HW_CriticalSectionEnd(cs);
2230 if (HW_IsHandlerMode())
2234 const Word exc = HW_GetCurrentException();
2235 const Word num = (exc & 0x7FFU);
2236 #if (__riscv_xlen > 32)
2237 const Word interrupt_bit = ((exc & (1ULL << (__riscv_xlen - 1))) ? 0x800U : 0);
2239 const Word interrupt_bit = ((exc & (1U << (__riscv_xlen - 1))) ? 0x800U : 0);
2252 result = ctx.m_handler->OnGetTid(HW_GetCallerSP());
2265#if STK_TICKLESS_IDLE
2274#if STK_TICKLESS_IDLE
2283 bool is_handled =
false;
2286 if (ctx.m_overrider !=
nullptr)
2288 is_handled = ctx.m_overrider->OnHardFault();
2307 return HW_GetCallerSP();
2314 if (core_id == 0xFFU)
2318 s_StkSystemCoreClock[i] = frequency;
2327 s_StkSystemCoreClock[core_id] = frequency;
2358 HW_SpinLockLock(m_lock);
2363 HW_SpinLockUnlock(m_lock);
2368 return HW_SpinLockTryLock(m_lock);
2373 return HW_IsHandlerMode();
2387#if STK_SUBMICORSECOND_PRECISION_TIMER
2388 return HW_GetCycleCounter();
2390 return HW_GetMtime();
2396#if STK_SUBMICORSECOND_PRECISION_TIMER
2397 const uint32_t freq = HW_CoreClockFrequency();
2399 const uint32_t freq = HW_MtimeClockFrequency();
2405#if STK_TLS && !STK_INLINE_TLS
2406Word stk::hw::GetTls()
2411void stk::hw::SetTls(
Word tp)
#define STK_SYSTEM_CORE_CLOCK_FREQUENCY
System clock frequency in Hz. Default: 150 MHz.
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.
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_KERNEL_DATA_SECTION
#define STK_MPU_KERNEL_BSS_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_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_STATIC_ASSERT_DESC(X, DESC)
Compile-time assertion with a custom error description. Produces a compilation error if X is false.
#define STK_STACK_MEMORY_FILLER
Sentinel value written to the entire stack region at initialization (stack watermark pattern).
#define __stk_attr_noreturn
Declares that function never returns to its caller (function prefix).
#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.
Contains helper implementations which simplify user-side code.
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).
static constexpr Timeout NO_WAIT
Timeout value: return immediately if the synchronization object is not yet signaled (non-blocking pol...
static __stk_forceinline Cycles ConvertTimeUsToClockCycles(uint32_t clock_freq, Ticks time_us)
Convert time (microseconds) to core clock cycles.
EKernelPanicId
Identifies the source of a kernel panic.
@ KERNEL_PANIC_BAD_STACK_TYPE
Stack type is unknown.
@ 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_CPU_EXCEPTION
CPU reported an exception and halted execution.
@ 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.
static constexpr bool IsIsrTid(TId id)
Test whether a task identifier represents an ISR context.
static constexpr TId TID_NONE
Reserved task/thread id representing zero/none thread id.
@ 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.
Word TId
Task (thread) id.
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).
Cycles GetSysTimerCount() const override
Get system timer count value.
Word GetCallerSP() const override
Get caller's Stack Pointer (SP).
void Resume(Timeout elapsed_ticks) override
Resume scheduling after a prior Suspend() call.
void Start() override
Start scheduling.
uint32_t GetTickResolution() const override
Get resolution of the system tick timer in microseconds. Resolution means a number of microseconds be...
uint32_t GetSysTimerFrequency() const override
Get system timer frequency.
void ProcessHardFault() override
Cause a hard fault of the system.
void InitStack(EStackType stack_type, Stack *stack, IStackMemory *stack_memory, ITask *user_task) override
Initialize stack memory of the user task.
void ProcessTick() override
Process one tick.
TId GetTid() const override
Get thread Id.
void ForceContextSwitch(TId id) override
Force context switch.
void SetSpecificEventHandler(ISpecificEventHandler *handler)
void SetCpuFrequency(uint8_t core_id, uint32_t frequency) override
Notify the scheduler of a CPU core's operating frequency.
void SetEventOverrider(IEventOverrider *overrider, bool non_secure) override
Set platform event overrider.
void Stop() override
Stop scheduling.
Timeout Suspend() override
Suspend scheduling.
void Initialize(IEventHandler *event_handler, IKernelService *service, uint32_t resolution_us, Stack *exit_trap) override
Initialize scheduler's context.
Base platform context for all platform implementations.
static Word InitStackMemory(IStackMemory *const memory)
Initialize stack memory by filling it with STK_STACK_MEMORY_FILLER.
static constexpr Session DEFAULT_SESSION
Default session value passed to Enter()/Exit() when the caller does not need to force a specific hand...
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.
RAII instance that enters the critical section on construction and exits it on destruction.
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.
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).
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.
Interface for a user task.
virtual void Run()=0
Entry point of the user task.
Interface for the kernel services exposed to the user processes during run-time when Kernel started s...
static IKernelService * GetInstance()
Get CPU-local instance of the kernel service.
static uint8_t stack_app_main[1024U] __attribute__((aligned(16)))