mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
83c686c744
- vTaskPreemptionDisable()/vTaskPreemptionEnable() are no longer available in single-core builds. - xTaskIncrementTick() calls must now be wrapped by critical section - Minimal Idle Task renamed to Passive Idle Task - Port critical section APIs updated
692 lines
29 KiB
C
692 lines
29 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2022-2024 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#include "sdkconfig.h"
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
#include "FreeRTOS.h"
|
|
#include "task.h" //For vApplicationStackOverflowHook
|
|
#include "port_systick.h"
|
|
#include "portmacro.h"
|
|
#include "spinlock.h"
|
|
#include "xt_instr_macros.h"
|
|
#include "xtensa_context.h"
|
|
#include "xtensa/corebits.h"
|
|
#include "xtensa/config/core.h"
|
|
#include "xtensa/config/core-isa.h"
|
|
#include "xtensa/xtruntime.h"
|
|
#include "esp_private/freertos_idf_additions_priv.h"
|
|
#include "esp_private/esp_int_wdt.h"
|
|
#include "esp_private/systimer.h"
|
|
#include "esp_private/periph_ctrl.h"
|
|
#include "esp_attr.h"
|
|
#include "esp_heap_caps.h"
|
|
#include "esp_system.h"
|
|
#include "esp_task.h"
|
|
#include "esp_log.h"
|
|
#include "esp_cpu.h"
|
|
#include "esp_rom_sys.h"
|
|
#include "esp_task_wdt.h"
|
|
#include "esp_heap_caps_init.h"
|
|
#include "esp_freertos_hooks.h"
|
|
#include "esp_intr_alloc.h"
|
|
#include "esp_memory_utils.h"
|
|
#ifdef CONFIG_FREERTOS_SYSTICK_USES_SYSTIMER
|
|
#include "soc/periph_defs.h"
|
|
#include "soc/system_reg.h"
|
|
#include "hal/systimer_hal.h"
|
|
#include "hal/systimer_ll.h"
|
|
#endif // CONFIG_FREERTOS_SYSTICK_USES_SYSTIMER
|
|
|
|
_Static_assert(portBYTE_ALIGNMENT == 16, "portBYTE_ALIGNMENT must be set to 16");
|
|
|
|
/**
|
|
* @brief Align stack pointer in a downward growing stack
|
|
*
|
|
* This macro is used to round a stack pointer downwards to the nearest n-byte boundary, where n is a power of 2.
|
|
* This macro is generally used when allocating aligned areas on a downward growing stack.
|
|
*/
|
|
#define STACKPTR_ALIGN_DOWN(n, ptr) ((ptr) & (~((n)-1)))
|
|
|
|
/* ---------------------------------------------------- Variables ------------------------------------------------------
|
|
* - Various variables used to maintain the FreeRTOS port's state. Used from both port.c and various .S files
|
|
* - Constant offsets are used by assembly to jump to particular TCB members or a stack area (such as the CPSA). We use
|
|
* C constants instead of preprocessor macros due to assembly lacking "offsetof()".
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
#if XCHAL_CP_NUM > 0
|
|
/* Offsets used to navigate to a task's CPSA on the stack */
|
|
const DRAM_ATTR uint32_t offset_pxEndOfStack = offsetof(StaticTask_t, pxDummy8);
|
|
const DRAM_ATTR uint32_t offset_cpsa = XT_CP_SIZE; /* Offset to start of the CPSA area on the stack. See uxInitialiseStackCPSA(). */
|
|
#if configNUM_CORES > 1
|
|
/* Offset to TCB_t.uxCoreAffinityMask member. Used to pin unpinned tasks that use the FPU. */
|
|
const DRAM_ATTR uint32_t offset_uxCoreAffinityMask = offsetof(StaticTask_t, uxDummy26);
|
|
#if configUSE_CORE_AFFINITY != 1
|
|
#error "configUSE_CORE_AFFINITY must be 1 on multicore targets with coprocessor support"
|
|
#endif
|
|
#endif /* configNUM_CORES > 1 */
|
|
#endif /* XCHAL_CP_NUM > 0 */
|
|
|
|
volatile unsigned port_xSchedulerRunning[portNUM_PROCESSORS] = {0}; // Indicates whether scheduler is running on a per-core basis
|
|
unsigned int port_interruptNesting[portNUM_PROCESSORS] = {0}; // Interrupt nesting level. Increased/decreased in portasm.c, _frxt_int_enter/_frxt_int_exit
|
|
#if ( configNUMBER_OF_CORES > 1 )
|
|
//FreeRTOS SMP Locks
|
|
portMUX_TYPE port_xTaskLock = portMUX_INITIALIZER_UNLOCKED;
|
|
portMUX_TYPE port_xISRLock = portMUX_INITIALIZER_UNLOCKED;
|
|
#endif /* configNUMBER_OF_CORES > 1 */
|
|
|
|
/* ------------------------------------------------ IDF Compatibility --------------------------------------------------
|
|
* - These need to be defined for IDF to compile
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
// --------------------- Interrupts ------------------------
|
|
|
|
BaseType_t IRAM_ATTR xPortInterruptedFromISRContext(void)
|
|
{
|
|
return (port_interruptNesting[xPortGetCoreID()] != 0);
|
|
}
|
|
|
|
// ------------------ Critical Sections --------------------
|
|
|
|
/*
|
|
Variables used by IDF critical sections only (SMP tracks critical nesting inside TCB now)
|
|
[refactor-todo] Figure out how IDF critical sections will be merged with SMP FreeRTOS critical sections
|
|
*/
|
|
BaseType_t port_uxCriticalNestingIDF[portNUM_PROCESSORS] = {0};
|
|
BaseType_t port_uxCriticalOldInterruptStateIDF[portNUM_PROCESSORS] = {0};
|
|
|
|
/*
|
|
*******************************************************************************
|
|
* Interrupt stack. The size of the interrupt stack is determined by the config
|
|
* parameter "configISR_STACK_SIZE" in FreeRTOSConfig.h
|
|
*******************************************************************************
|
|
*/
|
|
volatile StackType_t DRAM_ATTR __attribute__((aligned(16))) port_IntStack[portNUM_PROCESSORS][configISR_STACK_SIZE];
|
|
/* One flag for each individual CPU. */
|
|
volatile uint32_t port_switch_flag[portNUM_PROCESSORS];
|
|
|
|
BaseType_t xPortEnterCriticalTimeout(portMUX_TYPE *lock, BaseType_t timeout)
|
|
{
|
|
/* Interrupts may already be disabled (if this function is called in nested
|
|
* manner). However, there's no atomic operation that will allow us to check,
|
|
* thus we have to disable interrupts again anyways.
|
|
*
|
|
* However, if this is call is NOT nested (i.e., the first call to enter a
|
|
* critical section), we will save the previous interrupt level so that the
|
|
* saved level can be restored on the last call to exit the critical.
|
|
*/
|
|
BaseType_t xOldInterruptLevel = XTOS_SET_INTLEVEL(XCHAL_EXCM_LEVEL);
|
|
if (!spinlock_acquire(lock, timeout)) {
|
|
//Timed out attempting to get spinlock. Restore previous interrupt level and return
|
|
XTOS_RESTORE_JUST_INTLEVEL((int) xOldInterruptLevel);
|
|
return pdFAIL;
|
|
}
|
|
//Spinlock acquired. Increment the IDF critical nesting count.
|
|
BaseType_t coreID = xPortGetCoreID();
|
|
BaseType_t newNesting = port_uxCriticalNestingIDF[coreID] + 1;
|
|
port_uxCriticalNestingIDF[coreID] = newNesting;
|
|
//If this is the first entry to a critical section. Save the old interrupt level.
|
|
if ( newNesting == 1 ) {
|
|
port_uxCriticalOldInterruptStateIDF[coreID] = xOldInterruptLevel;
|
|
}
|
|
return pdPASS;
|
|
|
|
}
|
|
|
|
void vPortExitCriticalIDF(portMUX_TYPE *lock)
|
|
{
|
|
/* This function may be called in a nested manner. Therefore, we only need
|
|
* to reenable interrupts if this is the last call to exit the critical. We
|
|
* can use the nesting count to determine whether this is the last exit call.
|
|
*/
|
|
spinlock_release(lock);
|
|
BaseType_t coreID = xPortGetCoreID();
|
|
BaseType_t nesting = port_uxCriticalNestingIDF[coreID];
|
|
if (nesting > 0) {
|
|
nesting--;
|
|
port_uxCriticalNestingIDF[coreID] = nesting;
|
|
//This is the last exit call, restore the saved interrupt level
|
|
if ( nesting == 0 ) {
|
|
XTOS_RESTORE_JUST_INTLEVEL((int) port_uxCriticalOldInterruptStateIDF[coreID]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
In case any IDF libs called the port critical functions directly instead of through the macros.
|
|
Just inline call the IDF versions
|
|
*/
|
|
void vPortEnterCritical(portMUX_TYPE *lock)
|
|
{
|
|
vPortEnterCriticalIDF(lock);
|
|
}
|
|
|
|
void vPortExitCritical(portMUX_TYPE *lock)
|
|
{
|
|
vPortExitCriticalIDF(lock);
|
|
}
|
|
|
|
// ----------------------- System --------------------------
|
|
|
|
#define STACK_WATCH_POINT_NUMBER (SOC_CPU_WATCHPOINTS_NUM - 1)
|
|
|
|
void vPortSetStackWatchpoint( void *pxStackStart )
|
|
{
|
|
//Set watchpoint 1 to watch the last 32 bytes of the stack.
|
|
//Unfortunately, the Xtensa watchpoints can't set a watchpoint on a random [base - base+n] region because
|
|
//the size works by masking off the lowest address bits. For that reason, we futz a bit and watch the lowest 32
|
|
//bytes of the stack we can actually watch. In general, this can cause the watchpoint to be triggered at most
|
|
//28 bytes early. The value 32 is chosen because it's larger than the stack canary, which in FreeRTOS is 20 bytes.
|
|
//This way, we make sure we trigger before/when the stack canary is corrupted, not after.
|
|
int addr = (int)pxStackStart;
|
|
addr = (addr + 31) & (~31);
|
|
esp_cpu_set_watchpoint(STACK_WATCH_POINT_NUMBER, (char *)addr, 32, ESP_CPU_WATCHPOINT_STORE);
|
|
}
|
|
|
|
|
|
|
|
/* ---------------------------------------------- Port Implementations -------------------------------------------------
|
|
* Implementations of Porting Interface functions
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
// --------------------- Interrupts ------------------------
|
|
|
|
BaseType_t xPortCheckIfInISR(void)
|
|
{
|
|
//Disable interrupts so that reading port_interruptNesting is atomic
|
|
BaseType_t ret;
|
|
unsigned int prev_int_level = portDISABLE_INTERRUPTS();
|
|
ret = (port_interruptNesting[xPortGetCoreID()] != 0) ? pdTRUE : pdFALSE;
|
|
portRESTORE_INTERRUPTS(prev_int_level);
|
|
return ret;
|
|
}
|
|
|
|
// ------------------ Critical Sections --------------------
|
|
|
|
#if ( configNUMBER_OF_CORES > 1 )
|
|
void vPortTakeLock( portMUX_TYPE *lock )
|
|
{
|
|
spinlock_acquire( lock, portMUX_NO_TIMEOUT);
|
|
}
|
|
|
|
void vPortReleaseLock( portMUX_TYPE *lock )
|
|
{
|
|
spinlock_release( lock );
|
|
}
|
|
#endif /* configNUMBER_OF_CORES > 1 */
|
|
|
|
// ---------------------- Yielding -------------------------
|
|
|
|
// ----------------------- System --------------------------
|
|
|
|
// ------------------- Run Time Stats ----------------------
|
|
|
|
// --------------------- TCB Cleanup -----------------------
|
|
|
|
#if ( CONFIG_FREERTOS_TLSP_DELETION_CALLBACKS )
|
|
static void vPortTLSPointersDelCb( void *pxTCB )
|
|
{
|
|
/* Typecast pxTCB to StaticTask_t type to access TCB struct members.
|
|
* pvDummy15 corresponds to pvThreadLocalStoragePointers member of the TCB.
|
|
*/
|
|
StaticTask_t *tcb = ( StaticTask_t * )pxTCB;
|
|
|
|
/* The TLSP deletion callbacks are stored at an offset of (configNUM_THREAD_LOCAL_STORAGE_POINTERS/2) */
|
|
TlsDeleteCallbackFunction_t *pvThreadLocalStoragePointersDelCallback = ( TlsDeleteCallbackFunction_t * )( &( tcb->pvDummy15[ ( configNUM_THREAD_LOCAL_STORAGE_POINTERS / 2 ) ] ) );
|
|
|
|
/* We need to iterate over half the depth of the pvThreadLocalStoragePointers area
|
|
* to access all TLS pointers and their respective TLS deletion callbacks.
|
|
*/
|
|
for ( int x = 0; x < ( configNUM_THREAD_LOCAL_STORAGE_POINTERS / 2 ); x++ ) {
|
|
if ( pvThreadLocalStoragePointersDelCallback[ x ] != NULL ) { //If del cb is set
|
|
/* In case the TLSP deletion callback has been overwritten by a TLS pointer, gracefully abort. */
|
|
if ( !esp_ptr_executable( pvThreadLocalStoragePointersDelCallback[ x ] ) ) {
|
|
// We call EARLY log here as currently portCLEAN_UP_TCB() is called in a critical section
|
|
ESP_EARLY_LOGE("FreeRTOS", "Fatal error: TLSP deletion callback at index %d overwritten with non-excutable pointer %p", x, pvThreadLocalStoragePointersDelCallback[ x ]);
|
|
abort();
|
|
}
|
|
|
|
pvThreadLocalStoragePointersDelCallback[ x ]( x, tcb->pvDummy15[ x ] ); //Call del cb
|
|
}
|
|
}
|
|
}
|
|
#endif /* CONFIG_FREERTOS_TLSP_DELETION_CALLBACKS */
|
|
|
|
#if ( XCHAL_CP_NUM > 0 && configUSE_CORE_AFFINITY == 1 && configNUM_CORES > 1 )
|
|
static void vPortCleanUpCoprocArea( void *pxTCB )
|
|
{
|
|
UBaseType_t uxCoprocArea;
|
|
BaseType_t xTargetCoreID;
|
|
|
|
/* Get pointer to the task's coprocessor save area from TCB->pxEndOfStack. See uxInitialiseStackCPSA() */
|
|
uxCoprocArea = ( UBaseType_t ) ( ( ( StaticTask_t * ) pxTCB )->pxDummy8 ); /* Get TCB_t.pxEndOfStack */
|
|
uxCoprocArea = STACKPTR_ALIGN_DOWN(16, uxCoprocArea - XT_CP_SIZE);
|
|
|
|
/* Extract core ID from the affinity mask */
|
|
xTargetCoreID = ( ( StaticTask_t * ) pxTCB )->uxDummy26;
|
|
xTargetCoreID = ( BaseType_t ) __builtin_ffs( ( int ) xTargetCoreID );
|
|
assert( xTargetCoreID >= 1 ); // __builtin_ffs always returns first set index + 1
|
|
xTargetCoreID -= 1;
|
|
|
|
/* If task has live floating point registers somewhere, release them */
|
|
void _xt_coproc_release(volatile void *coproc_sa_base, BaseType_t xTargetCoreID);
|
|
_xt_coproc_release( (void *)uxCoprocArea, xTargetCoreID );
|
|
}
|
|
#endif /* ( XCHAL_CP_NUM > 0 && configUSE_CORE_AFFINITY == 1 && configNUM_CORES > 1 ) */
|
|
|
|
void vPortTCBPreDeleteHook( void *pxTCB )
|
|
{
|
|
#if ( CONFIG_FREERTOS_TASK_PRE_DELETION_HOOK )
|
|
/* Call the user defined task pre-deletion hook */
|
|
extern void vTaskPreDeletionHook( void * pxTCB );
|
|
vTaskPreDeletionHook( pxTCB );
|
|
#endif /* CONFIG_FREERTOS_TASK_PRE_DELETION_HOOK */
|
|
|
|
#if ( CONFIG_FREERTOS_ENABLE_STATIC_TASK_CLEAN_UP )
|
|
/*
|
|
* If the user is using the legacy task pre-deletion hook, call it.
|
|
* Todo: Will be removed in IDF-8097
|
|
*/
|
|
#warning "CONFIG_FREERTOS_ENABLE_STATIC_TASK_CLEAN_UP is deprecated. Use CONFIG_FREERTOS_TASK_PRE_DELETION_HOOK instead."
|
|
extern void vPortCleanUpTCB( void * pxTCB );
|
|
vPortCleanUpTCB( pxTCB );
|
|
#endif /* CONFIG_FREERTOS_ENABLE_STATIC_TASK_CLEAN_UP */
|
|
|
|
#if ( CONFIG_FREERTOS_TLSP_DELETION_CALLBACKS )
|
|
/* Call TLS pointers deletion callbacks */
|
|
vPortTLSPointersDelCb( pxTCB );
|
|
#endif /* CONFIG_FREERTOS_TLSP_DELETION_CALLBACKS */
|
|
|
|
#if ( XCHAL_CP_NUM > 0 && configUSE_CORE_AFFINITY == 1 && configNUM_CORES > 1 )
|
|
/* Cleanup coproc save area */
|
|
vPortCleanUpCoprocArea( pxTCB );
|
|
#endif /* ( XCHAL_CP_NUM > 0 && configUSE_CORE_AFFINITY == 1 && configNUM_CORES > 1 ) */
|
|
}
|
|
|
|
/* ------------------------------------------------ FreeRTOS Portable --------------------------------------------------
|
|
* - Provides implementation for functions required by FreeRTOS
|
|
* - Declared in portable.h
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
// ----------------- Scheduler Start/End -------------------
|
|
|
|
extern void _xt_coproc_init(void);
|
|
|
|
BaseType_t xPortStartScheduler( void )
|
|
{
|
|
portDISABLE_INTERRUPTS();
|
|
// Interrupts are disabled at this point and stack contains PS with enabled interrupts when task context is restored
|
|
|
|
#if XCHAL_CP_NUM > 0
|
|
/* Initialize co-processor management for tasks. Leave CPENABLE alone. */
|
|
_xt_coproc_init();
|
|
#endif
|
|
|
|
/* Setup the hardware to generate the tick. */
|
|
vPortSetupTimer();
|
|
|
|
port_xSchedulerRunning[xPortGetCoreID()] = 1;
|
|
|
|
#if configNUM_CORES > 1
|
|
// Workaround for non-thread safe multi-core OS startup (see IDF-4524)
|
|
if (xPortGetCoreID() != 0) {
|
|
prvStartSchedulerOtherCores();
|
|
}
|
|
#endif // configNUM_CORES > 1
|
|
|
|
// Cannot be directly called from C; never returns
|
|
__asm__ volatile ("call0 _frxt_dispatch\n");
|
|
|
|
/* Should not get here. */
|
|
return pdTRUE;
|
|
}
|
|
|
|
void vPortEndScheduler( void )
|
|
{
|
|
;
|
|
}
|
|
|
|
// ------------------------ Stack --------------------------
|
|
|
|
// User exception dispatcher when exiting
|
|
void _xt_user_exit(void);
|
|
|
|
#if CONFIG_FREERTOS_TASK_FUNCTION_WRAPPER
|
|
// Wrapper to allow task functions to return (increases stack overhead by 16 bytes)
|
|
static void vPortTaskWrapper(TaskFunction_t pxCode, void *pvParameters)
|
|
{
|
|
pxCode(pvParameters);
|
|
//FreeRTOS tasks should not return. Log the task name and abort.
|
|
char *pcTaskName = pcTaskGetName(NULL);
|
|
ESP_LOGE("FreeRTOS", "FreeRTOS Task \"%s\" should not return, Aborting now!", pcTaskName);
|
|
abort();
|
|
}
|
|
#endif
|
|
|
|
#if XCHAL_CP_NUM > 0
|
|
/**
|
|
* @brief Allocate and initialize coprocessor save area on the stack
|
|
*
|
|
* This function allocates the coprocessor save area on the stack (sized XT_CP_SIZE) which includes...
|
|
* - Individual save areas for each coprocessor (size XT_CPx_SA, inclusive of each area's alignment)
|
|
* - Coprocessor context switching flags (e.g., XT_CPENABLE, XT_CPSTORED, XT_CP_CS_ST, XT_CP_ASA).
|
|
*
|
|
* The coprocessor save area is aligned to a 16-byte boundary.
|
|
* The coprocessor context switching flags are then initialized
|
|
*
|
|
* @param[in] uxStackPointer Current stack pointer address
|
|
* @return Stack pointer that points to allocated and initialized the coprocessor save area
|
|
*/
|
|
FORCE_INLINE_ATTR UBaseType_t uxInitialiseStackCPSA(UBaseType_t uxStackPointer)
|
|
{
|
|
/*
|
|
HIGH ADDRESS
|
|
|-------------------| XT_CP_SIZE
|
|
| CPn SA | ^
|
|
| ... | |
|
|
| CP0 SA | |
|
|
| ----------------- | | ---- XCHAL_TOTAL_SA_ALIGN aligned
|
|
|-------------------| | 12 bytes
|
|
| XT_CP_ASA | | ^
|
|
| XT_CP_CS_ST | | |
|
|
| XT_CPSTORED | | |
|
|
| XT_CPENABLE | | |
|
|
|-------------------| ---------------------- 16 byte aligned
|
|
LOW ADDRESS
|
|
*/
|
|
|
|
// Allocate overall coprocessor save area, aligned down to 16 byte boundary
|
|
uxStackPointer = STACKPTR_ALIGN_DOWN(16, uxStackPointer - XT_CP_SIZE);
|
|
// Initialize the coprocessor context switching flags.
|
|
uint32_t *p = (uint32_t *)uxStackPointer;
|
|
p[0] = 0; // Clear XT_CPENABLE and XT_CPSTORED
|
|
p[1] = 0; // Clear XT_CP_CS_ST
|
|
// XT_CP_ASA points to the aligned start of the individual CP save areas (i.e., start of CP0 SA)
|
|
p[2] = (uint32_t)ALIGNUP(XCHAL_TOTAL_SA_ALIGN, (uint32_t)uxStackPointer + 12);
|
|
return uxStackPointer;
|
|
}
|
|
#endif /* XCHAL_CP_NUM > 0 */
|
|
|
|
/**
|
|
* @brief Allocate and initialize GCC TLS area
|
|
*
|
|
* This function allocates and initializes the area on the stack used to store GCC TLS (Thread Local Storage) variables.
|
|
* - The area's size is derived from the TLS section's linker variables, and rounded up to a multiple of 16 bytes
|
|
* - The allocated area is aligned to a 16-byte aligned address
|
|
* - The TLS variables in the area are then initialized
|
|
*
|
|
* Each task access the TLS variables using the THREADPTR register plus an offset to obtain the address of the variable.
|
|
* The value for the THREADPTR register is also calculated by this function, and that value should be use to initialize
|
|
* the THREADPTR register.
|
|
*
|
|
* @param[in] uxStackPointer Current stack pointer address
|
|
* @param[out] ret_threadptr_reg_init Calculated THREADPTR register initialization value
|
|
* @return Stack pointer that points to the TLS area
|
|
*/
|
|
FORCE_INLINE_ATTR UBaseType_t uxInitialiseStackTLS(UBaseType_t uxStackPointer, uint32_t *ret_threadptr_reg_init)
|
|
{
|
|
/*
|
|
TLS layout at link-time, where 0xNNN is the offset that the linker calculates to a particular TLS variable.
|
|
|
|
LOW ADDRESS
|
|
|---------------------------| Linker Symbols
|
|
| Section | --------------
|
|
| .flash.rodata |
|
|
0x0|---------------------------| <- _flash_rodata_start
|
|
^ | Other Data |
|
|
| |---------------------------| <- _thread_local_start
|
|
| | .tbss | ^
|
|
V | | |
|
|
0xNNN | int example; | | tls_area_size
|
|
| | |
|
|
| .tdata | V
|
|
|---------------------------| <- _thread_local_end
|
|
| Other data |
|
|
| ... |
|
|
|---------------------------|
|
|
HIGH ADDRESS
|
|
*/
|
|
// Calculate the TLS area's size (rounded up to multiple of 16 bytes).
|
|
extern int _thread_local_start, _thread_local_end, _flash_rodata_start, _flash_rodata_align;
|
|
const uint32_t tls_area_size = ALIGNUP(16, (uint32_t)&_thread_local_end - (uint32_t)&_thread_local_start);
|
|
// TODO: check that TLS area fits the stack
|
|
|
|
// Allocate space for the TLS area on the stack. The area must be allocated at a 16-byte aligned address
|
|
uxStackPointer = STACKPTR_ALIGN_DOWN(16, uxStackPointer - (UBaseType_t)tls_area_size);
|
|
// Initialize the TLS area with the initialization values of each TLS variable
|
|
memcpy((void *)uxStackPointer, &_thread_local_start, tls_area_size);
|
|
|
|
/*
|
|
Calculate the THREADPTR register's initialization value based on the link-time offset and the TLS area allocated on
|
|
the stack.
|
|
|
|
HIGH ADDRESS
|
|
|---------------------------|
|
|
| .tdata (*) |
|
|
^ | int example; |
|
|
| | |
|
|
| | .tbss (*) |
|
|
| |---------------------------| <- uxStackPointer (start of TLS area)
|
|
0xNNN | | | ^
|
|
| | | |
|
|
| ... | (_thread_local_start - _flash_rodata_start) + align_up(TCB_SIZE, tls_section_alignment)
|
|
| | | |
|
|
| | | V
|
|
V | | <- threadptr register's value
|
|
|
|
LOW ADDRESS
|
|
|
|
Note: Xtensa is slightly different compared to the RISC-V port as there is an implicit aligned TCB_SIZE added to
|
|
the offset. (search for 'tpoff' in elf32-xtensa.c in BFD):
|
|
- "offset = address - tls_section_vma + align_up(TCB_SIZE, tls_section_alignment)"
|
|
- TCB_SIZE is hardcoded to 8
|
|
*/
|
|
const uint32_t tls_section_align = (uint32_t)&_flash_rodata_align; // ALIGN value of .flash.rodata section
|
|
#define TCB_SIZE 8
|
|
const uint32_t base = ALIGNUP(tls_section_align, TCB_SIZE);
|
|
*ret_threadptr_reg_init = (uint32_t)uxStackPointer - ((uint32_t)&_thread_local_start - (uint32_t)&_flash_rodata_start) - base;
|
|
|
|
return uxStackPointer;
|
|
}
|
|
|
|
/**
|
|
* @brief Initialize the task's starting interrupt stack frame
|
|
*
|
|
* This function initializes the task's starting interrupt stack frame. The dispatcher will use this stack frame in a
|
|
* context restore routine. Therefore, the starting stack frame must be initialized as if the task was interrupted right
|
|
* before its first instruction is called.
|
|
*
|
|
* - The stack frame is allocated to a 16-byte aligned address
|
|
* - The THREADPTR register is saved in the extra storage area of the stack frame. This is also initialized
|
|
*
|
|
* @param[in] uxStackPointer Current stack pointer address
|
|
* @param[in] pxCode Task function
|
|
* @param[in] pvParameters Task function's parameter
|
|
* @param[in] threadptr_reg_init THREADPTR register initialization value
|
|
* @return Stack pointer that points to the stack frame
|
|
*/
|
|
FORCE_INLINE_ATTR UBaseType_t uxInitialiseStackFrame(UBaseType_t uxStackPointer, TaskFunction_t pxCode, void *pvParameters, uint32_t threadptr_reg_init)
|
|
{
|
|
/*
|
|
HIGH ADDRESS
|
|
|---------------------------| ^ XT_STK_FRMSZ
|
|
| | |
|
|
| Stack Frame Extra Storage | |
|
|
| | |
|
|
| ------------------------- | | ^ XT_STK_EXTRA
|
|
| | | |
|
|
| Intr/Exc Stack Frame | | |
|
|
| | V V
|
|
| ------------------------- | ---------------------- 16 byte aligned
|
|
LOW ADDRESS
|
|
*/
|
|
|
|
/*
|
|
Allocate space for the task's starting interrupt stack frame.
|
|
- The stack frame must be allocated to a 16-byte aligned address.
|
|
- We use XT_STK_FRMSZ (instead of sizeof(XtExcFrame)) as it...
|
|
- includes the size of the extra storage area
|
|
- includes the size for a base save area before the stack frame
|
|
- rounds up the total size to a multiple of 16
|
|
*/
|
|
UBaseType_t uxStackPointerPrevious = uxStackPointer;
|
|
uxStackPointer = STACKPTR_ALIGN_DOWN(16, uxStackPointer - XT_STK_FRMSZ);
|
|
|
|
// Clear the entire interrupt stack frame
|
|
memset((void *)uxStackPointer, 0, (size_t)(uxStackPointerPrevious - uxStackPointer));
|
|
|
|
XtExcFrame *frame = (XtExcFrame *)uxStackPointer;
|
|
|
|
/*
|
|
Initialize common registers
|
|
*/
|
|
frame->a0 = 0; // Set the return address to 0 terminate GDB backtrace
|
|
frame->a1 = uxStackPointer + XT_STK_FRMSZ; // Saved stack pointer should point to physical top of stack frame
|
|
frame->exit = (UBaseType_t) _xt_user_exit; // User exception exit dispatcher
|
|
|
|
/*
|
|
Initialize the task's entry point. This will differ depending on
|
|
- Whether the task's entry point is the wrapper function or pxCode
|
|
- Whether Windowed ABI is used (for windowed, we mimic the task entry point being call4'd )
|
|
*/
|
|
#if CONFIG_FREERTOS_TASK_FUNCTION_WRAPPER
|
|
frame->pc = (UBaseType_t) vPortTaskWrapper; // Task entry point is the wrapper function
|
|
#ifdef __XTENSA_CALL0_ABI__
|
|
frame->a2 = (UBaseType_t) pxCode; // Wrapper function's argument 0 (which is the task function)
|
|
frame->a3 = (UBaseType_t) pvParameters; // Wrapper function's argument 1 (which is the task function's argument)
|
|
#else // __XTENSA_CALL0_ABI__
|
|
frame->a6 = (UBaseType_t) pxCode; // Wrapper function's argument 0 (which is the task function), passed as if we call4'd
|
|
frame->a7 = (UBaseType_t) pvParameters; // Wrapper function's argument 1 (which is the task function's argument), passed as if we call4'd
|
|
#endif // __XTENSA_CALL0_ABI__
|
|
#else
|
|
frame->pc = (UBaseType_t) pxCode; // Task entry point is the provided task function
|
|
#ifdef __XTENSA_CALL0_ABI__
|
|
frame->a2 = (UBaseType_t) pvParameters; // Task function's argument
|
|
#else // __XTENSA_CALL0_ABI__
|
|
frame->a6 = (UBaseType_t) pvParameters; // Task function's argument, passed as if we call4'd
|
|
#endif // __XTENSA_CALL0_ABI__
|
|
#endif
|
|
|
|
/*
|
|
Set initial PS to int level 0, EXCM disabled ('rfe' will enable), user mode.
|
|
For windowed ABI also set WOE and CALLINC (pretend task was 'call4'd)
|
|
*/
|
|
#ifdef __XTENSA_CALL0_ABI__
|
|
frame->ps = PS_UM | PS_EXCM;
|
|
#else // __XTENSA_CALL0_ABI__
|
|
frame->ps = PS_UM | PS_EXCM | PS_WOE | PS_CALLINC(1);
|
|
#endif // __XTENSA_CALL0_ABI__
|
|
|
|
#ifdef XT_USE_SWPRI
|
|
// Set the initial virtual priority mask value to all 1's.
|
|
frame->vpri = 0xFFFFFFFF;
|
|
#endif
|
|
|
|
// Initialize the threadptr register in the extra save area of the stack frame
|
|
uint32_t *threadptr_reg = (uint32_t *)(uxStackPointer + XT_STK_EXTRA);
|
|
*threadptr_reg = threadptr_reg_init;
|
|
|
|
return uxStackPointer;
|
|
}
|
|
|
|
#if ( portHAS_STACK_OVERFLOW_CHECKING == 1 )
|
|
StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
|
|
StackType_t * pxEndOfStack,
|
|
TaskFunction_t pxCode,
|
|
void * pvParameters )
|
|
#else
|
|
StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
|
|
TaskFunction_t pxCode,
|
|
void * pvParameters )
|
|
#endif
|
|
{
|
|
#ifdef __clang_analyzer__
|
|
// Teach clang-tidy that pxTopOfStack cannot be a pointer to const
|
|
volatile StackType_t * pxTemp = pxTopOfStack;
|
|
pxTopOfStack = pxTemp;
|
|
#endif /*__clang_analyzer__ */
|
|
/*
|
|
HIGH ADDRESS
|
|
|---------------------------| <- pxTopOfStack on entry
|
|
| Coproc Save Area | (CPSA MUST BE FIRST)
|
|
| ------------------------- |
|
|
| TLS Variables |
|
|
| ------------------------- | <- Start of useable stack
|
|
| Starting stack frame |
|
|
| ------------------------- | <- pxTopOfStack on return (which is the tasks current SP)
|
|
| | |
|
|
| | |
|
|
| V |
|
|
----------------------------- <- Bottom of stack
|
|
LOW ADDRESS
|
|
|
|
- All stack areas are aligned to 16 byte boundary
|
|
- We use UBaseType_t for all of stack area initialization functions for more convenient pointer arithmetic
|
|
*/
|
|
|
|
UBaseType_t uxStackPointer = (UBaseType_t)pxTopOfStack;
|
|
configASSERT((uxStackPointer & portBYTE_ALIGNMENT_MASK) == 0);
|
|
|
|
#if XCHAL_CP_NUM > 0
|
|
// Initialize the coprocessor save area. THIS MUST BE THE FIRST AREA due to access from _frxt_task_coproc_state()
|
|
uxStackPointer = uxInitialiseStackCPSA(uxStackPointer);
|
|
configASSERT((uxStackPointer & portBYTE_ALIGNMENT_MASK) == 0);
|
|
#endif /* XCHAL_CP_NUM > 0 */
|
|
|
|
// Initialize the GCC TLS area
|
|
uint32_t threadptr_reg_init;
|
|
uxStackPointer = uxInitialiseStackTLS(uxStackPointer, &threadptr_reg_init);
|
|
configASSERT((uxStackPointer & portBYTE_ALIGNMENT_MASK) == 0);
|
|
|
|
// Initialize the starting interrupt stack frame
|
|
uxStackPointer = uxInitialiseStackFrame(uxStackPointer, pxCode, pvParameters, threadptr_reg_init);
|
|
configASSERT((uxStackPointer & portBYTE_ALIGNMENT_MASK) == 0);
|
|
|
|
// Return the task's current stack pointer address which should point to the starting interrupt stack frame
|
|
return (StackType_t *)uxStackPointer;
|
|
}
|
|
|
|
// ------------------- Hook Functions ----------------------
|
|
|
|
#include <stdlib.h>
|
|
|
|
#if ( configCHECK_FOR_STACK_OVERFLOW > 0 )
|
|
void __attribute__((weak)) vApplicationStackOverflowHook( TaskHandle_t xTask, char *pcTaskName )
|
|
{
|
|
#define ERR_STR1 "***ERROR*** A stack overflow in task "
|
|
#define ERR_STR2 " has been detected."
|
|
const char *str[] = {ERR_STR1, pcTaskName, ERR_STR2};
|
|
|
|
char buf[sizeof(ERR_STR1) + CONFIG_FREERTOS_MAX_TASK_NAME_LEN + sizeof(ERR_STR2) + 1 /* null char */] = { 0 };
|
|
|
|
char *dest = buf;
|
|
for (size_t i = 0 ; i < sizeof(str) / sizeof(str[0]); i++) {
|
|
dest = strcat(dest, str[i]);
|
|
}
|
|
esp_system_abort(buf);
|
|
}
|
|
#endif
|
|
|
|
extern void esp_vApplicationIdleHook(void);
|
|
#if CONFIG_FREERTOS_USE_PASSIVE_IDLE_HOOK
|
|
/*
|
|
By default, the port uses vApplicationPassiveIdleHook() to run IDF style idle
|
|
hooks. However, users may also want to provide their own vApplicationPassiveIdleHook().
|
|
In this case, we use to -Wl,--wrap option to wrap the user provided vApplicationPassiveIdleHook()
|
|
*/
|
|
extern void __real_vApplicationPassiveIdleHook( void );
|
|
void __wrap_vApplicationPassiveIdleHook( void )
|
|
{
|
|
esp_vApplicationIdleHook(); //Run IDF style hooks
|
|
__real_vApplicationPassiveIdleHook(); //Call the user provided vApplicationPassiveIdleHook()
|
|
}
|
|
#else // CONFIG_FREERTOS_USE_PASSIVE_IDLE_HOOK
|
|
void vApplicationPassiveIdleHook( void )
|
|
{
|
|
esp_vApplicationIdleHook(); //Run IDF style hooks
|
|
}
|
|
#endif // CONFIG_FREERTOS_USE_PASSIVE_IDLE_HOOK
|