kopia lustrzana https://github.com/espressif/esp-idf
450 wiersze
18 KiB
C
450 wiersze
18 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2023-2024 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#pragma once
|
|
|
|
#include "sdkconfig.h"
|
|
#include <stdint.h>
|
|
#include "spinlock.h"
|
|
#include "xtensa/xtruntime.h"
|
|
#include "xtensa/config/core.h"
|
|
#include "xtensa/config/core-isa.h"
|
|
#include "xtensa/config/specreg.h"
|
|
#include "xt_instr_macros.h"
|
|
#include "portbenchmark.h"
|
|
#include "esp_macros.h"
|
|
#include "esp_cpu.h"
|
|
#include "esp_private/crosscore_int.h"
|
|
#include "esp_memory_utils.h"
|
|
|
|
/*
|
|
Note: We should not include any FreeRTOS headers (directly or indirectly) here as this will create a reverse dependency
|
|
- FreeRTOS pulls in "portmacro.h" via
|
|
- source.c <- FreeRTOS.h <- portable.h <- portmacro.h
|
|
|
|
- If we need types of task.h (such as TaskHandle_t), best put the feature somewhere else
|
|
- Be careful as some parts of C Standard Library Headers will pull in FreeRTOS headers
|
|
*/
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/* --------------------------------------------------- Port Types ------------------------------------------------------
|
|
* - Port specific types.
|
|
* - The settings in this file configure FreeRTOS correctly for the given hardware and compiler.
|
|
* - These settings should not be altered.
|
|
* - The port types must come before first as they are used further down the file
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
#define portCHAR int8_t
|
|
#define portFLOAT float
|
|
#define portDOUBLE double
|
|
#define portLONG int32_t
|
|
#define portSHORT int16_t
|
|
#define portSTACK_TYPE uint8_t
|
|
#define portBASE_TYPE int
|
|
|
|
typedef portSTACK_TYPE StackType_t;
|
|
typedef portBASE_TYPE BaseType_t;
|
|
typedef unsigned portBASE_TYPE UBaseType_t;
|
|
|
|
#if( configUSE_16_BIT_TICKS == 1 )
|
|
typedef uint16_t TickType_t;
|
|
#define portMAX_DELAY ( TickType_t ) 0xffff
|
|
#else
|
|
typedef uint32_t TickType_t;
|
|
#define portMAX_DELAY ( TickType_t ) 0xffffffffUL
|
|
#endif
|
|
|
|
/* Task function macros as described on the FreeRTOS.org WEB site. */
|
|
#define portTASK_FUNCTION_PROTO( vFunction, pvParameters ) void vFunction( void *pvParameters )
|
|
#define portTASK_FUNCTION( vFunction, pvParameters ) void vFunction( void *pvParameters )
|
|
|
|
/* ----------------------------------------------- Port Configurations -------------------------------------------------
|
|
* - Configurations values supplied by each port
|
|
* - Required by FreeRTOS
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
#define portCRITICAL_NESTING_IN_TCB 1
|
|
#define portSTACK_GROWTH ( -1 )
|
|
#define portTICK_PERIOD_MS ( ( TickType_t ) 1000 / configTICK_RATE_HZ )
|
|
#define portBYTE_ALIGNMENT 16 // Xtensa Windowed ABI requires the stack pointer to always be 16-byte aligned. See "isa_rm.pdf 8.1.1 Windowed Register Usage and Stack Layout"
|
|
#define portNOP() XT_NOP() //Todo: Check if XT_NOP exists
|
|
|
|
/* ---------------------------------------------- Forward Declarations -------------------------------------------------
|
|
* - Forward declarations of all the port functions and macros need to implement the FreeRTOS porting interface
|
|
* - These must come before definition/declaration of the FreeRTOS porting interface
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
// ---------------------- Spinlocks ------------------------
|
|
|
|
typedef spinlock_t portMUX_TYPE; /**< Spinlock type used by FreeRTOS critical sections */
|
|
#define portMUX_INITIALIZER_UNLOCKED SPINLOCK_INITIALIZER /**< Spinlock initializer */
|
|
#define portMUX_FREE_VAL SPINLOCK_FREE /**< Spinlock is free. [refactor-todo] check if this is still required */
|
|
#define portMUX_NO_TIMEOUT SPINLOCK_WAIT_FOREVER /**< When passed for 'timeout_cycles', spin forever if necessary. [refactor-todo] check if this is still required */
|
|
#define portMUX_TRY_LOCK SPINLOCK_NO_WAIT /**< Try to acquire the spinlock a single time only. [refactor-todo] check if this is still required */
|
|
#define portMUX_INITIALIZE(mux) spinlock_initialize(mux) /*< Initialize a spinlock to its unlocked state */
|
|
|
|
// ----------------------- Memory --------------------------
|
|
|
|
// --------------------- Interrupts ------------------------
|
|
|
|
BaseType_t xPortCheckIfInISR(void);
|
|
|
|
// ------------------ Critical Sections --------------------
|
|
|
|
UBaseType_t uxPortEnterCriticalFromISR( void );
|
|
void vPortExitCriticalFromISR( UBaseType_t level );
|
|
|
|
#if ( configNUMBER_OF_CORES > 1 )
|
|
/*
|
|
These are always called with interrupts already disabled. We simply need to get/release the spinlocks
|
|
*/
|
|
extern portMUX_TYPE port_xTaskLock;
|
|
extern portMUX_TYPE port_xISRLock;
|
|
|
|
void vPortTakeLock( portMUX_TYPE *lock );
|
|
void vPortReleaseLock( portMUX_TYPE *lock );
|
|
#endif /* configNUMBER_OF_CORES > 1 */
|
|
|
|
// ---------------------- Yielding -------------------------
|
|
|
|
void vPortYield( void );
|
|
static inline void __attribute__((always_inline)) vPortYieldCore( BaseType_t xCoreID );
|
|
static inline void __attribute__((always_inline)) vPortYieldFromISR( void );
|
|
|
|
#define portYIELD_FROM_ISR_CHECK(x) ({ \
|
|
if ( (x) == pdTRUE ) { \
|
|
vPortYieldFromISR(); \
|
|
} \
|
|
})
|
|
#define portYIELD_FROM_ISR_NO_CHECK() vPortYieldFromISR()
|
|
|
|
// ----------------------- System --------------------------
|
|
|
|
static inline BaseType_t __attribute__((always_inline)) xPortGetCoreID( void );
|
|
|
|
// --------------------- TCB Cleanup -----------------------
|
|
|
|
/**
|
|
* @brief TCB cleanup hook
|
|
*
|
|
* The portCLEAN_UP_TCB() macro is called in prvDeleteTCB() right before a
|
|
* deleted task's memory is freed. We map that macro to this internal function
|
|
* so that IDF FreeRTOS ports can inject some task pre-deletion operations.
|
|
*
|
|
* @note We can't use vPortCleanUpTCB() due to API compatibility issues. See
|
|
* CONFIG_FREERTOS_ENABLE_STATIC_TASK_CLEAN_UP. Todo: IDF-8097
|
|
*/
|
|
void vPortTCBPreDeleteHook( void *pxTCB );
|
|
|
|
|
|
/* ----------------------------------------- FreeRTOS SMP Porting Interface --------------------------------------------
|
|
* - Contains all the mappings of the macros required by FreeRTOS SMP
|
|
* - Must come after forward declare as some porting macros map to declared functions
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
// ----------------------- Memory --------------------------
|
|
|
|
// --------------------- Interrupts ------------------------
|
|
|
|
#define portSET_INTERRUPT_MASK() ({ \
|
|
unsigned int prev_level = XTOS_SET_INTLEVEL(XCHAL_EXCM_LEVEL); \
|
|
portbenchmarkINTERRUPT_DISABLE(); \
|
|
prev_level = ((prev_level >> XCHAL_PS_INTLEVEL_SHIFT) & XCHAL_PS_INTLEVEL_MASK); \
|
|
prev_level; \
|
|
})
|
|
#define portSET_INTERRUPT_MASK_FROM_ISR() portSET_INTERRUPT_MASK()
|
|
#define portDISABLE_INTERRUPTS() portSET_INTERRUPT_MASK()
|
|
|
|
/*
|
|
Note: XTOS_RESTORE_INTLEVEL() will overwrite entire PS register on XEA2. So we need to set the value of the INTLEVEL field ourselves
|
|
*/
|
|
#define portCLEAR_INTERRUPT_MASK(x) ({ \
|
|
unsigned int ps_reg; \
|
|
RSR(PS, ps_reg); \
|
|
ps_reg = (ps_reg & ~XCHAL_PS_INTLEVEL_MASK); \
|
|
ps_reg |= ((x << XCHAL_PS_INTLEVEL_SHIFT) & XCHAL_PS_INTLEVEL_MASK); \
|
|
XTOS_RESTORE_INTLEVEL(ps_reg); \
|
|
})
|
|
#define portCLEAR_INTERRUPT_MASK_FROM_ISR(x) portCLEAR_INTERRUPT_MASK(x)
|
|
#define portENABLE_INTERRUPTS() ({ \
|
|
portbenchmarkINTERRUPT_RESTORE(0); \
|
|
XTOS_SET_INTLEVEL(0); \
|
|
})
|
|
|
|
/* Compatibility */
|
|
#define portRESTORE_INTERRUPTS(x) portCLEAR_INTERRUPT_MASK(x)
|
|
|
|
// ------------------ Critical Sections --------------------
|
|
|
|
#if ( configNUMBER_OF_CORES > 1 )
|
|
#define portGET_TASK_LOCK() vPortTakeLock(&port_xTaskLock)
|
|
#define portRELEASE_TASK_LOCK() vPortReleaseLock(&port_xTaskLock)
|
|
#define portGET_ISR_LOCK() vPortTakeLock(&port_xISRLock)
|
|
#define portRELEASE_ISR_LOCK() vPortReleaseLock(&port_xISRLock)
|
|
#endif /* configNUMBER_OF_CORES > 1 */
|
|
|
|
//Critical sections used by FreeRTOS SMP
|
|
extern void vTaskEnterCritical( void );
|
|
extern void vTaskExitCritical( void );
|
|
#define portENTER_CRITICAL_SMP() vTaskEnterCritical();
|
|
#define portEXIT_CRITICAL_SMP() vTaskExitCritical();
|
|
|
|
#if defined(__cplusplus) && (__cplusplus > 201703L)
|
|
#define portENTER_CRITICAL(...) CHOOSE_MACRO_VA_ARG(portENTER_CRITICAL_IDF, portENTER_CRITICAL_SMP __VA_OPT__(,) __VA_ARGS__)(__VA_ARGS__)
|
|
#define portEXIT_CRITICAL(...) CHOOSE_MACRO_VA_ARG(portEXIT_CRITICAL_IDF, portEXIT_CRITICAL_SMP __VA_OPT__(,) __VA_ARGS__)(__VA_ARGS__)
|
|
#else
|
|
#define portENTER_CRITICAL(...) CHOOSE_MACRO_VA_ARG(portENTER_CRITICAL_IDF, portENTER_CRITICAL_SMP, ##__VA_ARGS__)(__VA_ARGS__)
|
|
#define portEXIT_CRITICAL(...) CHOOSE_MACRO_VA_ARG(portEXIT_CRITICAL_IDF, portEXIT_CRITICAL_SMP, ##__VA_ARGS__)(__VA_ARGS__)
|
|
#endif
|
|
|
|
extern UBaseType_t vTaskEnterCriticalFromISR( void );
|
|
extern void vTaskExitCriticalFromISR( UBaseType_t uxSavedInterruptStatus );
|
|
#define portENTER_CRITICAL_FROM_ISR() vTaskEnterCriticalFromISR()
|
|
#define portEXIT_CRITICAL_FROM_ISR(x) vTaskExitCriticalFromISR(x)
|
|
|
|
// ---------------------- Yielding -------------------------
|
|
|
|
#define portYIELD() vPortYield()
|
|
#if defined(__cplusplus) && (__cplusplus > 201703L)
|
|
#define portYIELD_FROM_ISR(...) CHOOSE_MACRO_VA_ARG(portYIELD_FROM_ISR_CHECK, portYIELD_FROM_ISR_NO_CHECK __VA_OPT__(,) __VA_ARGS__)(__VA_ARGS__)
|
|
#else
|
|
#define portYIELD_FROM_ISR(...) CHOOSE_MACRO_VA_ARG(portYIELD_FROM_ISR_CHECK, portYIELD_FROM_ISR_NO_CHECK, ##__VA_ARGS__)(__VA_ARGS__)
|
|
#endif
|
|
#define portYIELD_CORE(x) vPortYieldCore(x)
|
|
|
|
// ----------------------- System --------------------------
|
|
|
|
#define portGET_CORE_ID() xPortGetCoreID()
|
|
#define portCHECK_IF_IN_ISR() xPortCheckIfInISR()
|
|
|
|
// ------------------- Run Time Stats ----------------------
|
|
|
|
//Timers are already configured, so nothing to do for configuration of run time stats timer
|
|
#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()
|
|
#ifdef CONFIG_FREERTOS_RUN_TIME_STATS_USING_ESP_TIMER
|
|
#define portGET_RUN_TIME_COUNTER_VALUE() ((configRUN_TIME_COUNTER_TYPE) esp_timer_get_time())
|
|
#else // Uses CCOUNT
|
|
#define portGET_RUN_TIME_COUNTER_VALUE() ((configRUN_TIME_COUNTER_TYPE) xthal_get_ccount())
|
|
#endif // CONFIG_FREERTOS_RUN_TIME_STATS_USING_ESP_TIMER
|
|
|
|
// --------------------- TCB Cleanup -----------------------
|
|
|
|
#define portCLEAN_UP_TCB( pxTCB ) vPortTCBPreDeleteHook( pxTCB )
|
|
|
|
/* --------------------------------------------- Inline Implementations ------------------------------------------------
|
|
* - Implementation of inline functions of the forward declares
|
|
* - Should come after forward declare and FreeRTOS Porting interface, as implementation may use both.
|
|
* - For implementation of non-inlined functions, see port.c
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
// --------------------- Interrupts ------------------------
|
|
|
|
// ------------------ Critical Sections --------------------
|
|
|
|
// ---------------------- Yielding -------------------------
|
|
|
|
extern void _frxt_setup_switch( void ); //Defined in portasm.S
|
|
|
|
static inline void __attribute__((always_inline)) vPortYieldCore( BaseType_t xCoreID )
|
|
{
|
|
esp_crosscore_int_send_yield( xCoreID );
|
|
}
|
|
|
|
static inline void __attribute__((always_inline)) vPortYieldFromISR( void )
|
|
{
|
|
//traceISR_EXIT_TO_SCHEDULER();
|
|
_frxt_setup_switch();
|
|
}
|
|
|
|
// ----------------------- System --------------------------
|
|
|
|
static inline BaseType_t __attribute__((always_inline)) xPortGetCoreID( void )
|
|
{
|
|
return (BaseType_t) esp_cpu_get_core_id();
|
|
}
|
|
|
|
/* ------------------------------------------------ IDF Compatibility --------------------------------------------------
|
|
* - These macros and functions need to be defined for IDF to compile
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
// --------------------- Interrupts ------------------------
|
|
|
|
static inline BaseType_t xPortInIsrContext(void)
|
|
{
|
|
//Just call the FreeRTOS port interface version
|
|
return xPortCheckIfInISR();
|
|
}
|
|
|
|
BaseType_t xPortInterruptedFromISRContext(void);
|
|
|
|
static inline UBaseType_t xPortSetInterruptMaskFromISR(void)
|
|
{
|
|
UBaseType_t prev_int_level = XTOS_SET_INTLEVEL(XCHAL_EXCM_LEVEL);
|
|
portbenchmarkINTERRUPT_DISABLE();
|
|
return prev_int_level;
|
|
}
|
|
|
|
static inline void vPortClearInterruptMaskFromISR(UBaseType_t prev_level)
|
|
{
|
|
portbenchmarkINTERRUPT_RESTORE(prev_level);
|
|
XTOS_RESTORE_JUST_INTLEVEL((int) prev_level);
|
|
}
|
|
|
|
// ---------------------- Spinlocks ------------------------
|
|
|
|
static inline bool __attribute__((always_inline)) vPortCPUAcquireMutexTimeout(portMUX_TYPE *mux, int timeout)
|
|
{
|
|
return (spinlock_acquire(mux, timeout));
|
|
}
|
|
|
|
static inline void __attribute__((always_inline)) vPortCPUReleaseMutex(portMUX_TYPE *mux)
|
|
{
|
|
spinlock_release(mux);
|
|
}
|
|
|
|
// ------------------ Critical Sections --------------------
|
|
|
|
BaseType_t xPortEnterCriticalTimeout(portMUX_TYPE *lock, BaseType_t timeout);
|
|
|
|
static inline void __attribute__((always_inline)) vPortEnterCriticalIDF(portMUX_TYPE *lock)
|
|
{
|
|
xPortEnterCriticalTimeout(lock, portMUX_NO_TIMEOUT);
|
|
}
|
|
|
|
void vPortExitCriticalIDF(portMUX_TYPE *lock);
|
|
|
|
/*
|
|
In case any IDF libs called the port critical functions directly instead of through the macros.
|
|
The will just call the vPort...CriticalIDF() functions
|
|
*/
|
|
void vPortEnterCritical(portMUX_TYPE *lock);
|
|
void vPortExitCritical(portMUX_TYPE *lock);
|
|
|
|
//IDF task critical sections
|
|
#define portTRY_ENTER_CRITICAL(lock, timeout) xPortEnterCriticalTimeout(lock, timeout)
|
|
#define portENTER_CRITICAL_IDF(lock) vPortEnterCriticalIDF(lock)
|
|
#define portEXIT_CRITICAL_IDF(lock) vPortExitCriticalIDF(lock)
|
|
//IDF ISR critical sections
|
|
#define portTRY_ENTER_CRITICAL_ISR(lock, timeout) xPortEnterCriticalTimeout(lock, timeout)
|
|
#define portENTER_CRITICAL_ISR(lock) vPortEnterCriticalIDF(lock)
|
|
#define portEXIT_CRITICAL_ISR(lock) vPortExitCriticalIDF(lock)
|
|
//IDF safe critical sections (they're the same)
|
|
#define portENTER_CRITICAL_SAFE(lock) vPortEnterCriticalIDF(lock)
|
|
#define portEXIT_CRITICAL_SAFE(lock) vPortExitCriticalIDF(lock)
|
|
|
|
// ---------------------- Yielding -------------------------
|
|
|
|
static inline bool IRAM_ATTR xPortCanYield(void)
|
|
{
|
|
uint32_t ps_reg = 0;
|
|
|
|
//Get the current value of PS (processor status) register
|
|
RSR(PS, ps_reg);
|
|
|
|
/*
|
|
* intlevel = (ps_reg & 0xf);
|
|
* excm = (ps_reg >> 4) & 0x1;
|
|
* CINTLEVEL is max(excm * EXCMLEVEL, INTLEVEL), where EXCMLEVEL is 3.
|
|
* However, just return true, only intlevel is zero.
|
|
*/
|
|
|
|
return ((ps_reg & PS_INTLEVEL_MASK) == 0);
|
|
}
|
|
|
|
// Defined even for configNUMBER_OF_CORES > 1 for IDF compatibility
|
|
#define portYIELD_WITHIN_API() esp_crosscore_int_send_yield(xPortGetCoreID())
|
|
|
|
// ----------------------- System --------------------------
|
|
|
|
void vPortSetStackWatchpoint(void *pxStackStart);
|
|
|
|
// -------------------- Heap Related -----------------------
|
|
|
|
/**
|
|
* @brief Checks if a given piece of memory can be used to store a FreeRTOS list
|
|
*
|
|
* - Defined in heap_idf.c
|
|
*
|
|
* @param ptr Pointer to memory
|
|
* @return true Memory can be used to store a List
|
|
* @return false Otherwise
|
|
*/
|
|
bool xPortCheckValidListMem(const void *ptr);
|
|
|
|
/**
|
|
* @brief Checks if a given piece of memory can be used to store a task's TCB
|
|
*
|
|
* - Defined in heap_idf.c
|
|
*
|
|
* @param ptr Pointer to memory
|
|
* @return true Memory can be used to store a TCB
|
|
* @return false Otherwise
|
|
*/
|
|
bool xPortCheckValidTCBMem(const void *ptr);
|
|
|
|
/**
|
|
* @brief Checks if a given piece of memory can be used to store a task's stack
|
|
*
|
|
* - Defined in heap_idf.c
|
|
*
|
|
* @param ptr Pointer to memory
|
|
* @return true Memory can be used to store a task stack
|
|
* @return false Otherwise
|
|
*/
|
|
bool xPortcheckValidStackMem(const void *ptr);
|
|
|
|
#define portVALID_LIST_MEM(ptr) xPortCheckValidListMem(ptr)
|
|
#define portVALID_TCB_MEM(ptr) xPortCheckValidTCBMem(ptr)
|
|
#define portVALID_STACK_MEM(ptr) xPortcheckValidStackMem(ptr)
|
|
|
|
/* ------------------------------------------------------ Misc ---------------------------------------------------------
|
|
* - Miscellaneous porting macros
|
|
* - These are not part of the FreeRTOS porting interface, but are used by other FreeRTOS dependent components
|
|
* ------------------------------------------------------------------------------------------------------------------ */
|
|
|
|
// --------------------- App-Trace -------------------------
|
|
|
|
#if CONFIG_APPTRACE_SV_ENABLE
|
|
extern volatile BaseType_t xPortSwitchFlag;
|
|
#define os_task_switch_is_pended(_cpu_) (xPortSwitchFlag)
|
|
#else
|
|
#define os_task_switch_is_pended(_cpu_) (false)
|
|
#endif
|
|
|
|
// --------------- Compatibility Includes ------------------
|
|
/*
|
|
ESP-IDF currently does not have a "Include what you use" policy. A lot of files implicitly pull in API through
|
|
portmacro.h. Therefore, we need to keep these headers around for now to allow the rest of IDF to compile.
|
|
|
|
[refactor-todo] Clean up ESP-IDF inclusion dependencies and add a inclusion check.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdbool.h>
|
|
#include <stdarg.h>
|
|
#include <xtensa/hal.h>
|
|
#include "esp_attr.h"
|
|
#include "esp_newlib.h"
|
|
#include "esp_heap_caps.h"
|
|
#include "esp_rom_sys.h"
|
|
#include "esp_system.h"
|
|
#include "portbenchmark.h"
|
|
#include <limits.h>
|
|
#include <xtensa/config/system.h>
|
|
#include <xtensa_api.h>
|
|
|
|
/* [refactor-todo] introduce a port wrapper function to avoid including esp_timer.h into the public header */
|
|
#if CONFIG_FREERTOS_RUN_TIME_STATS_USING_ESP_TIMER
|
|
#include "esp_timer.h"
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|