first commit
This commit is contained in:
commit
92cbe97616
1978 files changed
+1688498
No files matched your search
@@ -0,0 +1,289 @@
|
||||
cmake_minimum_required(VERSION 3.15)
|
||||
|
||||
# User is responsible to one mandatory option:
|
||||
# FREERTOS_PORT, if not specified and native port detected, uses the native compile.
|
||||
#
|
||||
# User is responsible for one library target:
|
||||
# freertos_config ,typically an INTERFACE library
|
||||
#
|
||||
# DEPRECATED: FREERTOS_CONFIG_FILE_DIRECTORY - but still supported if no freertos_config defined for now.
|
||||
# May be removed at some point in the future.
|
||||
#
|
||||
# User can choose which heap implementation to use (either the implementations
|
||||
# included with FreeRTOS [1..5] or a custom implementation) by providing the
|
||||
# option FREERTOS_HEAP. When dynamic allocation is used, the user must specify a
|
||||
# heap implementation. If the option is not set, the cmake will use no heap
|
||||
# implementation (e.g. when only static allocation is used).
|
||||
|
||||
# `freertos_config` target defines the path to FreeRTOSConfig.h and optionally other freertos based config files
|
||||
if(NOT TARGET freertos_config )
|
||||
if (NOT DEFINED FREERTOS_CONFIG_FILE_DIRECTORY )
|
||||
|
||||
message(FATAL_ERROR " freertos_config target not specified. Please specify a cmake target that defines the include directory for FreeRTOSConfig.h:\n"
|
||||
" add_library(freertos_config INTERFACE)\n"
|
||||
" target_include_directories(freertos_config SYSTEM\n"
|
||||
" INTERFACE\n"
|
||||
" include) # The config file directory\n"
|
||||
" target_compile_definitions(freertos_config\n"
|
||||
" PUBLIC\n"
|
||||
" projCOVERAGE_TEST=0)\n")
|
||||
else()
|
||||
message(WARNING " Using deprecated 'FREERTOS_CONFIG_FILE_DIRECTORY' - please update your project CMakeLists.txt file:\n"
|
||||
" add_library(freertos_config INTERFACE)\n"
|
||||
" target_include_directories(freertos_config SYSTEM\n"
|
||||
" INTERFACE\n"
|
||||
" include) # The config file directory\n"
|
||||
" target_compile_definitions(freertos_config\n"
|
||||
" PUBLIC\n"
|
||||
" projCOVERAGE_TEST=0)\n")
|
||||
endif()
|
||||
endif()
|
||||
|
||||
# FreeRTOS port option
|
||||
if(NOT FREERTOS_PORT)
|
||||
message(WARNING " FREERTOS_PORT is not set. Please specify it from top-level CMake file (example):\n"
|
||||
" set(FREERTOS_PORT GCC_ARM_CM4F CACHE STRING \"\")\n"
|
||||
" or from CMake command line option:\n"
|
||||
" -DFREERTOS_PORT=GCC_ARM_CM4F\n"
|
||||
" \n"
|
||||
" Available port options:\n"
|
||||
" A_CUSTOM_PORT - Compiler: User Defined Target: User Defined\n"
|
||||
" BCC_16BIT_DOS_FLSH186 - Compiler: BCC Target: 16 bit DOS Flsh186\n"
|
||||
" BCC_16BIT_DOS_PC - Compiler: BCC Target: 16 bit DOS PC\n"
|
||||
" CCS_ARM_CM3 - Compiler: CCS Target: ARM Cortex-M3\n"
|
||||
" CCS_ARM_CM4F - Compiler: CCS Target: ARM Cortex-M4 with FPU\n"
|
||||
" CCS_ARM_CR4 - Compiler: CCS Target: ARM Cortex-R4\n"
|
||||
" CCS_MSP430X - Compiler: CCS Target: MSP430X\n"
|
||||
" CODEWARRIOR_COLDFIRE_V1 - Compiler: CoreWarrior Target: ColdFire V1\n"
|
||||
" CODEWARRIOR_COLDFIRE_V2 - Compiler: CoreWarrior Target: ColdFire V2\n"
|
||||
" CODEWARRIOR_HCS12 - Compiler: CoreWarrior Target: HCS12\n"
|
||||
" GCC_ARM_CA9 - Compiler: GCC Target: ARM Cortex-A9\n"
|
||||
" GCC_ARM_AARCH64 - Compiler: GCC Target: ARM v8-A\n"
|
||||
" GCC_ARM_AARCH64_SRE - Compiler: GCC Target: ARM v8-A SRE\n"
|
||||
" GCC_ARM_CM0 - Compiler: GCC Target: ARM Cortex-M0\n"
|
||||
" GCC_ARM_CM3 - Compiler: GCC Target: ARM Cortex-M3\n"
|
||||
" GCC_ARM_CM3_MPU - Compiler: GCC Target: ARM Cortex-M3 with MPU\n"
|
||||
" GCC_ARM_CM4_MPU - Compiler: GCC Target: ARM Cortex-M4 with MPU\n"
|
||||
" GCC_ARM_CM4F - Compiler: GCC Target: ARM Cortex-M4 with FPU\n"
|
||||
" GCC_ARM_CM7 - Compiler: GCC Target: ARM Cortex-M7\n"
|
||||
" GCC_ARM_CM23_NONSECURE - Compiler: GCC Target: ARM Cortex-M23 non-secure\n"
|
||||
" GCC_ARM_CM23_SECURE - Compiler: GCC Target: ARM Cortex-M23 secure\n"
|
||||
" GCC_ARM_CM23_NTZ_NONSECURE - Compiler: GCC Target: ARM Cortex-M23 non-trustzone non-secure\n"
|
||||
" GCC_ARM_CM33_NONSECURE - Compiler: GCC Target: ARM Cortex-M33 non-secure\n"
|
||||
" GCC_ARM_CM33_SECURE - Compiler: GCC Target: ARM Cortex-M33 secure\n"
|
||||
" GCC_ARM_CM33_NTZ_NONSECURE - Compiler: GCC Target: ARM Cortex-M33 non-trustzone non-secure\n"
|
||||
" GCC_ARM_CM33_TFM - Compiler: GCC Target: ARM Cortex-M33 non-secure for TF-M\n"
|
||||
" GCC_ARM_CM35P_NONSECURE - Compiler: GCC Target: ARM Cortex-M35P non-secure\n"
|
||||
" GCC_ARM_CM35P_SECURE - Compiler: GCC Target: ARM Cortex-M35P secure\n"
|
||||
" GCC_ARM_CM35P_NTZ_NONSECURE - Compiler: GCC Target: ARM Cortex-M35P non-trustzone non-secure\n"
|
||||
" GCC_ARM_CM52_NONSECURE - Compiler: GCC Target: ARM Cortex-M52 non-secure\n"
|
||||
" GCC_ARM_CM52_SECURE - Compiler: GCC Target: ARM Cortex-M52 secure\n"
|
||||
" GCC_ARM_CM52_NTZ_NONSECURE - Compiler: GCC Target: ARM Cortex-M52 non-trustzone non-secure\n"
|
||||
" GCC_ARM_CM52_TFM - Compiler: GCC Target: ARM Cortex-M52 non-secure for TF-M\n"
|
||||
" GCC_ARM_CM55_NONSECURE - Compiler: GCC Target: ARM Cortex-M55 non-secure\n"
|
||||
" GCC_ARM_CM55_SECURE - Compiler: GCC Target: ARM Cortex-M55 secure\n"
|
||||
" GCC_ARM_CM55_NTZ_NONSECURE - Compiler: GCC Target: ARM Cortex-M55 non-trustzone non-secure\n"
|
||||
" GCC_ARM_CM55_TFM - Compiler: GCC Target: ARM Cortex-M55 non-secure for TF-M\n"
|
||||
" GCC_ARM_CM85_NONSECURE - Compiler: GCC Target: ARM Cortex-M85 non-secure\n"
|
||||
" GCC_ARM_CM85_SECURE - Compiler: GCC Target: ARM Cortex-M85 secure\n"
|
||||
" GCC_ARM_CM85_NTZ_NONSECURE - Compiler: GCC Target: ARM Cortex-M85 non-trustzone non-secure\n"
|
||||
" GCC_ARM_CM85_TFM - Compiler: GCC Target: ARM Cortex-M85 non-secure for TF-M\n"
|
||||
" GCC_ARM_STAR_MC3_NONSECURE - Compiler: GCC Target: Arm China STAR-MC3 non-secure\n"
|
||||
" GCC_ARM_STAR_MC3_SECURE - Compiler: GCC Target: Arm China STAR-MC3 secure\n"
|
||||
" GCC_ARM_STAR_MC3_NTZ_NONSECURE - Compiler: GCC Target: Arm China STAR-MC3 non-trustzone non-secure\n"
|
||||
" GCC_ARM_STAR_MC3_TFM - Compiler: GCC Target: Arm China STAR-MC3 non-secure for TF-M\n"
|
||||
" GCC_ARM_CR5 - Compiler: GCC Target: ARM Cortex-R5\n"
|
||||
" GCC_ARM_CRX_MPU - Compiler: GCC Target: ARM Cortex-Rx with MPU\n"
|
||||
" GCC_ARM_CRX_NOGIC - Compiler: GCC Target: ARM Cortex-Rx no GIC\n"
|
||||
" GCC_ARM_CR82 - Compiler: GCC Target: ARM Cortex-R82\n"
|
||||
" GCC_ARM7_AT91FR40008 - Compiler: GCC Target: ARM7 Atmel AT91R40008\n"
|
||||
" GCC_ARM7_AT91SAM7S - Compiler: GCC Target: ARM7 Atmel AT91SAM7S\n"
|
||||
" GCC_ARM7_LPC2000 - Compiler: GCC Target: ARM7 LPC2000\n"
|
||||
" GCC_ARM7_LPC23XX - Compiler: GCC Target: ARM7 LPC23xx\n"
|
||||
" GCC_ATMEGA323 - Compiler: GCC Target: ATMega323\n"
|
||||
" GCC_AVR32_UC3 - Compiler: GCC Target: AVR32 UC3\n"
|
||||
" GCC_COLDFIRE_V2 - Compiler: GCC Target: ColdFire V2\n"
|
||||
" GCC_CORTUS_APS3 - Compiler: GCC Target: CORTUS APS3\n"
|
||||
" GCC_H8S2329 - Compiler: GCC Target: H8S2329\n"
|
||||
" GCC_HCS12 - Compiler: GCC Target: HCS12\n"
|
||||
" GCC_IA32_FLAT - Compiler: GCC Target: IA32 flat\n"
|
||||
" GCC_MICROBLAZE - Compiler: GCC Target: MicroBlaze\n"
|
||||
" GCC_MICROBLAZE_V8 - Compiler: GCC Target: MicroBlaze V8\n"
|
||||
" GCC_MICROBLAZE_V9 - Compiler: GCC Target: MicroBlaze V9\n"
|
||||
" GCC_MSP430F449 - Compiler: GCC Target: MSP430F449\n"
|
||||
" GCC_NIOSII - Compiler: GCC Target: NiosII\n"
|
||||
" GCC_PPC405_XILINX - Compiler: GCC Target: Xilinx PPC405\n"
|
||||
" GCC_PPC440_XILINX - Compiler: GCC Target: Xilinx PPC440\n"
|
||||
" GCC_RISC_V - Compiler: GCC Target: RISC-V\n"
|
||||
" GCC_RISC_V_PULPINO_VEGA_RV32M1RM - Compiler: GCC Target: RISC-V Pulpino Vega RV32M1RM\n"
|
||||
" GCC_RISC_V_GENERIC - Compiler: GCC Target: RISC-V with FREERTOS_RISCV_EXTENSION\n"
|
||||
" GCC_RL78 - Compiler: GCC Target: Renesas RL78\n"
|
||||
" GCC_RX100 - Compiler: GCC Target: Renesas RX100\n"
|
||||
" GCC_RX200 - Compiler: GCC Target: Renesas RX200\n"
|
||||
" GCC_RX600 - Compiler: GCC Target: Renesas RX600\n"
|
||||
" GCC_RX600_V2 - Compiler: GCC Target: Renesas RX600 v2\n"
|
||||
" GCC_RX700_V3_DPFPU - Compiler: GCC Target: Renesas RX700 v3 with DPFPU\n"
|
||||
" GCC_STR75X - Compiler: GCC Target: STR75x\n"
|
||||
" GCC_TRICORE_1782 - Compiler: GCC Target: TriCore 1782\n"
|
||||
" GCC_ARC_EM_HS - Compiler: GCC Target: DesignWare ARC EM HS\n"
|
||||
" GCC_ARC_V1 - Compiler: GCC Target: DesignWare ARC v1\n"
|
||||
" GCC_ATMEGA - Compiler: GCC Target: ATmega\n"
|
||||
" GCC_POSIX - Compiler: GCC Target: Posix\n"
|
||||
" GCC_RP2040 - Compiler: GCC Target: RP2040 ARM Cortex-M0+\n"
|
||||
" GCC_XTENSA_ESP32 - Compiler: GCC Target: Xtensa ESP32\n"
|
||||
" GCC_AVRDX - Compiler: GCC Target: AVRDx\n"
|
||||
" GCC_AVR_MEGA0 - Compiler: GCC Target: AVR Mega0\n"
|
||||
" IAR_78K0K - Compiler: IAR Target: Renesas 78K0K\n"
|
||||
" IAR_ARM_CA5_NOGIC - Compiler: IAR Target: ARM Cortex-A5 no GIC\n"
|
||||
" IAR_ARM_CA9 - Compiler: IAR Target: ARM Cortex-A9\n"
|
||||
" IAR_ARM_CM0 - Compiler: IAR Target: ARM Cortex-M0\n"
|
||||
" IAR_ARM_CM3 - Compiler: IAR Target: ARM Cortex-M3\n"
|
||||
" IAR_ARM_CM4F - Compiler: IAR Target: ARM Cortex-M4 with FPU\n"
|
||||
" IAR_ARM_CM4F_MPU - Compiler: IAR Target: ARM Cortex-M4 with FPU and MPU\n"
|
||||
" IAR_ARM_CM7 - Compiler: IAR Target: ARM Cortex-M7\n"
|
||||
" IAR_ARM_CM23_NONSECURE - Compiler: IAR Target: ARM Cortex-M23 non-secure\n"
|
||||
" IAR_ARM_CM23_SECURE - Compiler: IAR Target: ARM Cortex-M23 secure\n"
|
||||
" IAR_ARM_CM23_NTZ_NONSECURE - Compiler: IAR Target: ARM Cortex-M23 non-trustzone non-secure\n"
|
||||
" IAR_ARM_CM33_NONSECURE - Compiler: IAR Target: ARM Cortex-M33 non-secure\n"
|
||||
" IAR_ARM_CM33_SECURE - Compiler: IAR Target: ARM Cortex-M33 secure\n"
|
||||
" IAR_ARM_CM33_NTZ_NONSECURE - Compiler: IAR Target: ARM Cortex-M33 non-trustzone non-secure\n"
|
||||
" IAR_ARM_CM33_TFM - Compiler: IAR Target: ARM Cortex-M33 non-secure for TF-M\n"
|
||||
" IAR_ARM_CM35P_NONSECURE - Compiler: IAR Target: ARM Cortex-M35P non-secure\n"
|
||||
" IAR_ARM_CM35P_SECURE - Compiler: IAR Target: ARM Cortex-M35P secure\n"
|
||||
" IAR_ARM_CM35P_NTZ_NONSECURE - Compiler: IAR Target: ARM Cortex-M35P non-trustzone non-secure\n"
|
||||
" IAR_ARM_CM52_NONSECURE - Compiler: IAR Target: ARM Cortex-M52 non-secure\n"
|
||||
" IAR_ARM_CM52_SECURE - Compiler: IAR Target: ARM Cortex-M52 secure\n"
|
||||
" IAR_ARM_CM52_NTZ_NONSECURE - Compiler: IAR Target: ARM Cortex-M52 non-trustzone non-secure\n"
|
||||
" IAR_ARM_CM52_TFM - Compiler: IAR Target: ARM Cortex-M52 non-secure for TF-M\n"
|
||||
" IAR_ARM_CM55_NONSECURE - Compiler: IAR Target: ARM Cortex-M55 non-secure\n"
|
||||
" IAR_ARM_CM55_SECURE - Compiler: IAR Target: ARM Cortex-M55 secure\n"
|
||||
" IAR_ARM_CM55_NTZ_NONSECURE - Compiler: IAR Target: ARM Cortex-M55 non-trustzone non-secure\n"
|
||||
" IAR_ARM_CM55_TFM - Compiler: IAR Target: ARM Cortex-M55 non-secure for TF-M\n"
|
||||
" IAR_ARM_CM85_NONSECURE - Compiler: IAR Target: ARM Cortex-M85 non-secure\n"
|
||||
" IAR_ARM_CM85_SECURE - Compiler: IAR Target: ARM Cortex-M85 secure\n"
|
||||
" IAR_ARM_CM85_NTZ_NONSECURE - Compiler: IAR Target: ARM Cortex-M85 non-trustzone non-secure\n"
|
||||
" IAR_ARM_CM85_TFM - Compiler: IAR Target: ARM Cortex-M85 non-secure for TF-M\n"
|
||||
" IAR_ARM_STAR_MC3_NONSECURE - Compiler: IAR Target: Arm China STAR-MC3 non-secure\n"
|
||||
" IAR_ARM_STAR_MC3_SECURE - Compiler: IAR Target: Arm China STAR-MC3 secure\n"
|
||||
" IAR_ARM_STAR_MC3_NTZ_NONSECURE - Compiler: IAR Target: Arm China STAR-MC3 non-trustzone non-secure\n"
|
||||
" IAR_ARM_STAR_MC3_TFM - Compiler: IAR Target: Arm China STAR-MC3 non-secure for TF-M\n"
|
||||
" IAR_ARM_CRX_NOGIC - Compiler: IAR Target: ARM Cortex-Rx no GIC\n"
|
||||
" IAR_ATMEGA323 - Compiler: IAR Target: ATMega323\n"
|
||||
" IAR_ATMEL_SAM7S64 - Compiler: IAR Target: Atmel SAM7S64\n"
|
||||
" IAR_ATMEL_SAM9XE - Compiler: IAR Target: Atmel SAM9XE\n"
|
||||
" IAR_AVR_AVRDX - Compiler: IAR Target: AVRDx\n"
|
||||
" IAR_AVR_MEGA0 - Compiler: IAR Target: AVR Mega0\n"
|
||||
" IAR_AVR32_UC3 - Compiler: IAR Target: AVR32 UC3\n"
|
||||
" IAR_LPC2000 - Compiler: IAR Target: LPC2000\n"
|
||||
" IAR_MSP430 - Compiler: IAR Target: MSP430\n"
|
||||
" IAR_MSP430X - Compiler: IAR Target: MSP430X\n"
|
||||
" IAR_RISC_V - Compiler: IAR Target: RISC-V\n"
|
||||
" IAR_RISC_V_GENERIC - Compiler: IAR Target: RISC-V with FREERTOS_RISCV_EXTENSION\n"
|
||||
" IAR_RL78 - Compiler: IAR Target: Renesas RL78\n"
|
||||
" IAR_RX100 - Compiler: IAR Target: Renesas RX100\n"
|
||||
" IAR_RX600 - Compiler: IAR Target: Renesas RX600\n"
|
||||
" IAR_RX700_V3_DPFPU - Compiler: IAR Target: Renesas RX700 v3 with DPFPU\n"
|
||||
" IAR_RX_V2 - Compiler: IAR Target: Renesas RX v2\n"
|
||||
" IAR_STR71X - Compiler: IAR Target: STR71x\n"
|
||||
" IAR_STR75X - Compiler: IAR Target: STR75x\n"
|
||||
" IAR_STR91X - Compiler: IAR Target: STR91x\n"
|
||||
" IAR_V850ES_FX3 - Compiler: IAR Target: Renesas V850ES/Fx3\n"
|
||||
" IAR_V850ES_HX3 - Compiler: IAR Target: Renesas V850ES/Hx3\n"
|
||||
" MIKROC_ARM_CM4F - Compiler: MikroC Target: ARM Cortex-M4 with FPU\n"
|
||||
" MPLAB_PIC18F - Compiler: MPLAB Target: PIC18F\n"
|
||||
" MPLAB_PIC24 - Compiler: MPLAB Target: PIC24\n"
|
||||
" MPLAB_PIC32MEC14XX - Compiler: MPLAB Target: PIC32MEC14xx\n"
|
||||
" MPLAB_PIC32MX - Compiler: MPLAB Target: PIC32MX\n"
|
||||
" MPLAB_PIC32MZ - Compiler: MPLAB Target: PIC32MZ\n"
|
||||
" MSVC_MINGW - Compiler: MSVC or MinGW Target: x86\n"
|
||||
" OWATCOM_16BIT_DOS_FLSH186 - Compiler: Open Watcom Target: 16 bit DOS Flsh186\n"
|
||||
" OWATCOM_16BIT_DOS_PC - Compiler: Open Watcom Target: 16 bit DOS PC\n"
|
||||
" PARADIGM_TERN_EE_LARGE - Compiler: Paradigm Target: Tern EE large\n"
|
||||
" PARADIGM_TERN_EE_SMALL - Compiler: Paradigm Target: Tern EE small\n"
|
||||
" RENESAS_RX100 - Compiler: Renesas Target: RX100\n"
|
||||
" RENESAS_RX200 - Compiler: Renesas Target: RX200\n"
|
||||
" RENESAS_RX600 - Compiler: Renesas Target: RX600\n"
|
||||
" RENESAS_RX600_V2 - Compiler: Renesas Target: RX600 v2\n"
|
||||
" RENESAS_RX700_V3_DPFPU - Compiler: Renesas Target: RX700 v3 with DPFPU\n"
|
||||
" RENESAS_SH2A_FPU - Compiler: Renesas Target: SH2A with FPU\n"
|
||||
" ROWLEY_MSP430F449 - Compiler: Rowley Target: MSP430F449\n"
|
||||
" RVDS_ARM_CA9 - Compiler: RVDS Target: ARM Cortex-A9\n"
|
||||
" RVDS_ARM_CM0 - Compiler: RVDS Target: ARM Cortex-M0\n"
|
||||
" RVDS_ARM_CM3 - Compiler: RVDS Target: ARM Cortex-M3\n"
|
||||
" RVDS_ARM_CM4_MPU - Compiler: RVDS Target: ARM Cortex-M4 with MPU\n"
|
||||
" RVDS_ARM_CM4F - Compiler: RVDS Target: ARM Cortex-M4 with FPU\n"
|
||||
" RVDS_ARM_CM7 - Compiler: RVDS Target: ARM Cortex-M7\n"
|
||||
" RVDS_ARM7_LPC21XX - Compiler: RVDS Target: ARM7 LPC21xx\n"
|
||||
" SDCC_CYGNAL - Compiler: SDCC Target: Cygnal\n"
|
||||
" SOFTUNE_MB91460 - Compiler: Softune Target: MB91460\n"
|
||||
" SOFTUNE_MB96340 - Compiler: Softune Target: MB96340\n"
|
||||
" TASKING_ARM_CM4F - Compiler: Tasking Target: ARM Cortex-M4 with FPU\n"
|
||||
" TEMPLATE - Compiler: HOST Target: None\n"
|
||||
" CDK_THEAD_CK802 - Compiler: CDK Target: T-head CK802\n"
|
||||
" XCC_XTENSA - Compiler: XCC Target: Xtensa\n"
|
||||
" WIZC_PIC18 - Compiler: WizC Target: PIC18")
|
||||
# Native FREERTOS_PORT for Linux and Windows MINGW builds
|
||||
if(UNIX)
|
||||
message(STATUS " Auto-Detected Unix, setting FREERTOS_PORT=GCC_POSIX")
|
||||
set(FREERTOS_PORT GCC_POSIX CACHE STRING "FreeRTOS port name")
|
||||
elseif(MINGW)
|
||||
message(STATUS " Auto-Detected MINGW, setting FREERTOS_PORT=MSVC_MINGW")
|
||||
set(FREERTOS_PORT MSVC_MINGW CACHE STRING "FreeRTOS port name")
|
||||
endif()
|
||||
elseif((FREERTOS_PORT STREQUAL "A_CUSTOM_PORT") AND (NOT TARGET freertos_kernel_port) )
|
||||
message(FATAL_ERROR " FREERTOS_PORT is set to A_CUSTOM_PORT. Please specify the custom port target with all necessary files. For example:\n"
|
||||
" Assuming a directory of:\n"
|
||||
" FreeRTOSCustomPort/\n"
|
||||
" CMakeLists.txt\n"
|
||||
" port.c\n"
|
||||
" portmacro.h\n"
|
||||
" Where FreeRTOSCustomPort/CMakeLists.txt is a modified version of:\n"
|
||||
" add_library(freertos_kernel_port OBJECT)\n"
|
||||
" target_sources(freertos_kernel_port\n"
|
||||
" PRIVATE\n"
|
||||
" port.c\n"
|
||||
" portmacro.h)\n"
|
||||
" add_library(freertos_kernel_port_headers INTERFACE)\n"
|
||||
" target_include_directories(freertos_kernel_port_headers INTERFACE \n"
|
||||
" .)\n"
|
||||
" target_link_libraries(freertos_kernel_port\n"
|
||||
" PRIVATE\n"
|
||||
" freertos_kernel_port_headers\n"
|
||||
" freertos_kernel_include)")
|
||||
endif()
|
||||
|
||||
add_library(freertos_kernel STATIC)
|
||||
|
||||
########################################################################
|
||||
add_subdirectory(include)
|
||||
add_subdirectory(portable)
|
||||
|
||||
target_sources(freertos_kernel PRIVATE
|
||||
croutine.c
|
||||
event_groups.c
|
||||
list.c
|
||||
queue.c
|
||||
stream_buffer.c
|
||||
tasks.c
|
||||
timers.c
|
||||
)
|
||||
|
||||
if (DEFINED FREERTOS_HEAP )
|
||||
# User specified a heap implementation add heap implementation to freertos_kernel.
|
||||
target_sources(freertos_kernel PRIVATE
|
||||
# If FREERTOS_HEAP is digit between 1 .. 5 - it is heap number, otherwise - it is path to custom heap source file
|
||||
$<IF:$<BOOL:$<FILTER:${FREERTOS_HEAP},EXCLUDE,^[1-5]$>>,${FREERTOS_HEAP},portable/MemMang/heap_${FREERTOS_HEAP}.c>
|
||||
)
|
||||
endif()
|
||||
|
||||
|
||||
target_link_libraries(freertos_kernel
|
||||
PUBLIC
|
||||
freertos_kernel_include
|
||||
freertos_kernel_port_headers
|
||||
PRIVATE
|
||||
freertos_kernel_port
|
||||
|
||||
)
|
||||
|
||||
########################################################################
|
||||
+6230
File diff suppressed because it is too large.
Load diff
+15102
File diff suppressed because it is too large.
Load diff
+13323
File diff suppressed because it is too large.
Load diff
+9629
File diff suppressed because it is too large.
Load diff
+7
@@ -0,0 +1,7 @@
|
||||
[{000214A0-0000-0000-C000-000000000046}]
|
||||
Prop3=19,2
|
||||
[InternetShortcut]
|
||||
URL=https://github.com/FreeRTOS/FreeRTOS-Kernel
|
||||
IconIndex=0
|
||||
IDList=
|
||||
HotKey=0
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,19 @@
|
||||
MIT License
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@@ -0,0 +1,233 @@
|
||||
# MISRA Compliance
|
||||
|
||||
FreeRTOS-Kernel conforms to [MISRA C:2012](https://www.misra.org.uk/misra-c)
|
||||
guidelines, with the deviations listed below. Compliance is checked with
|
||||
Coverity static analysis version 2023.6.1. Since the FreeRTOS kernel is
|
||||
designed for small-embedded devices, it needs to have a very small memory
|
||||
footprint and has to be efficient. To achieve that and to increase the
|
||||
performance, it deviates from some MISRA rules. The specific deviations,
|
||||
suppressed inline, are listed below.
|
||||
|
||||
Additionally, [MISRA configuration file](examples/coverity/coverity_misra.config)
|
||||
contains project wide deviations.
|
||||
|
||||
### Suppressed with Coverity Comments
|
||||
To find the violation references in the source files run grep on the source code
|
||||
with ( Assuming rule 8.4 violation; with justification in point 1 ):
|
||||
```
|
||||
grep 'MISRA Ref 8.4.1' . -rI
|
||||
```
|
||||
|
||||
#### Dir 4.7
|
||||
|
||||
MISRA C:2012 Dir 4.7: If a function returns error information, then that error
|
||||
information shall be tested.
|
||||
|
||||
_Ref 4.7.1_
|
||||
- `taskENTER_CRITICAL_FROM_ISR` returns the interrupt mask and not any error
|
||||
information. Therefore, there is no need test the return value.
|
||||
|
||||
#### Rule 8.4
|
||||
|
||||
MISRA C:2012 Rule 8.4: A compatible declaration shall be visible when an
|
||||
object or function with external linkage is defined.
|
||||
|
||||
_Ref 8.4.1_
|
||||
- pxCurrentTCB(s) is defined with external linkage but it is only referenced
|
||||
from the assembly code in the port files. Therefore, adding a declaration in
|
||||
header file is not useful as the assembly code will still need to declare it
|
||||
separately.
|
||||
|
||||
_Ref 8.4.2_
|
||||
- xQueueRegistry is defined with external linkage because it is accessed by the
|
||||
kernel unit tests. It is not meant to be directly accessed by the application
|
||||
and therefore, not declared in a header file.
|
||||
|
||||
#### Rule 8.6
|
||||
|
||||
MISRA C:2012 Rule 8.6: An identifier with external linkage shall have exactly
|
||||
one external definition.
|
||||
|
||||
_Ref 8.6.1_
|
||||
- This rule prohibits an identifier with external linkage to have multiple
|
||||
definitions or no definition. FreeRTOS hook functions are implemented in
|
||||
the application and therefore, have no definition in the Kernel code.
|
||||
|
||||
#### Rule 11.1
|
||||
MISRA C:2012 Rule 11.1: Conversions shall not be performed between a pointer to
|
||||
function and any other type.
|
||||
|
||||
_Ref 11.1.1_
|
||||
- The pointer to function is casted into void to avoid unused parameter
|
||||
compiler warning when Stream Buffer's Tx and Rx Completed callback feature is
|
||||
not used.
|
||||
|
||||
#### Rule 11.3
|
||||
|
||||
MISRA C:2012 Rule 11.3: A cast shall not be performed between a pointer to
|
||||
object type and a pointer to a different object type.
|
||||
|
||||
_Ref 11.3.1_
|
||||
- This rule prohibits casting a pointer to object into a pointer to a
|
||||
different object because it may result in an incorrectly aligned pointer,
|
||||
leading to undefined behavior. Even if the casting produces a correctly
|
||||
aligned pointer, the behavior may be still undefined if the pointer is
|
||||
used to access an object. FreeRTOS deliberately creates external aliases
|
||||
for all the kernel object types (StaticEventGroup_t, StaticQueue_t,
|
||||
StaticStreamBuffer_t, StaticTimer_t and StaticTask_t) for data hiding
|
||||
purposes. The internal object types and the corresponding external
|
||||
aliases are guaranteed to have the same size and alignment which is
|
||||
checked using configASSERT.
|
||||
|
||||
|
||||
#### Rule 11.5
|
||||
|
||||
MISRA C:2012 Rule 11.5: A conversion should not be performed from pointer to
|
||||
void into pointer to object.
|
||||
This rule prohibits conversion of a pointer to void into a pointer to
|
||||
object because it may result in an incorrectly aligned pointer leading
|
||||
to undefined behavior.
|
||||
|
||||
_Ref 11.5.1_
|
||||
- The memory blocks returned by pvPortMalloc() are guaranteed to meet the
|
||||
architecture alignment requirements specified by portBYTE_ALIGNMENT.
|
||||
The casting of the pointer to void returned by pvPortMalloc() is,
|
||||
therefore, safe because it is guaranteed to be aligned.
|
||||
|
||||
_Ref 11.5.2_
|
||||
- The conversion from a pointer to void into a pointer to EventGroup_t is
|
||||
safe because it is a pointer to EventGroup_t, which is returned to the
|
||||
application at the time of event group creation for data hiding
|
||||
purposes.
|
||||
|
||||
_Ref 11.5.3_
|
||||
- The conversion from a pointer to void in list macros for list item owner
|
||||
is safe because the type of the pointer stored and retrieved is the
|
||||
same.
|
||||
|
||||
_Ref 11.5.4_
|
||||
- The conversion from a pointer to void into a pointer to EventGroup_t is
|
||||
safe because it is a pointer to EventGroup_t, which is passed as a
|
||||
parameter to the xTimerPendFunctionCallFromISR API when the callback is
|
||||
pended.
|
||||
|
||||
_Ref 11.5.5_
|
||||
- The conversion from a pointer to void into a pointer to uint8_t is safe
|
||||
because data storage buffers are implemented as uint8_t arrays for the
|
||||
ease of sizing, alignment and access.
|
||||
|
||||
#### Rule 14.3
|
||||
|
||||
MISRA C-2012 Rule 14.3: Controlling expressions shall not be invariant.
|
||||
|
||||
_Ref 14.3_
|
||||
- The `configMAX_TASK_NAME_LEN` , `taskRESERVED_TASK_NAME_LENGTH` and `SIZE_MAX`
|
||||
are evaluated to constants at compile time and may vary based on the build
|
||||
configuration.
|
||||
|
||||
#### Rule 18.1
|
||||
|
||||
MISRA C-2012 Rule 18.1: A pointer resulting from arithmetic on a pointer operand
|
||||
shall address an element of the same array as that pointer operand.
|
||||
|
||||
_Ref 18.1_
|
||||
- Array access remains within bounds since either the null terminator in
|
||||
the IDLE task name will break the loop, or the loop will break normally
|
||||
if the array size is smaller than the IDLE task name length.
|
||||
|
||||
#### Rule 21.6
|
||||
|
||||
MISRA C-2012 Rule 21.6: The Standard Library input/output functions shall not
|
||||
be used.
|
||||
|
||||
_Ref 21.6.1_
|
||||
- The Standard Library function snprintf is used in vTaskListTasks and
|
||||
vTaskGetRunTimeStatistics APIs, both of which are utility functions only and
|
||||
are not considered part of core kernel implementation.
|
||||
|
||||
### Unsuppressed Deviations
|
||||
|
||||
Certain deviating code is left unsuppressed for awareness. These violations
|
||||
will be reported when audited by a MISRA-checking static analysis tool.
|
||||
|
||||
Some of these unsuppressed exceptions correspond to example code provided
|
||||
either for demonstration or verification of the FreeRTOS kernel. This code
|
||||
is not considered part of the kernel implementation and should not be used
|
||||
in an application.
|
||||
|
||||
Other unsuppressed violations are left present in the kernel implementation
|
||||
as implementations, code, or other missing functionality being flagged for
|
||||
violations will be present with the porting layer provided by the
|
||||
application. The presence of these errors after providing a port indicates
|
||||
a valid MISRA issue.
|
||||
|
||||
#### Rule 2.1
|
||||
|
||||
MISRA C:2012 Dir 2.1: A project shall not contain unreachable code
|
||||
|
||||
_Ref 2.1_
|
||||
- Simplified example contains unreachable code for demonstration of
|
||||
FreeRTOS scheduler. A production implementation should not contain
|
||||
this.
|
||||
|
||||
Affected Files:
|
||||
- examples/cmake_example/main.c
|
||||
|
||||
#### Rule 2.2
|
||||
|
||||
MISRA C:2012 Dir 2.2: There shall be no dead code.
|
||||
|
||||
_Ref 2.2_
|
||||
- `vPortEndScheduler` is erroneously determined to be dead code due to
|
||||
the use of a simplified verification port.
|
||||
|
||||
Affected Files:
|
||||
- tasks.c
|
||||
|
||||
#### Dir 4.12
|
||||
|
||||
MISRA C:2012 Dir 4.12: Dynamic allocation shall not be used
|
||||
|
||||
_Ref 4.12_
|
||||
- Heap memory solutions utilize pvPortMalloc/vPortFree to provide heap
|
||||
memory for dynamic object allocation. These functions may rely upon
|
||||
the malloc/free of the underlying port. Static allocation is recommended
|
||||
for MISRA compliant applications.
|
||||
|
||||
Affected Files:
|
||||
- portable/MemMang/heap_*.c
|
||||
|
||||
|
||||
#### Rule 8.6
|
||||
|
||||
MISRA C:2012 Rule 8.6: An identifier with external linkage shall have exactly
|
||||
one external definition.
|
||||
|
||||
_Ref 8.6.1_
|
||||
- Port layer function declarations are provided without corresponding
|
||||
implementations to provide for ease of porting to a device. These definitions
|
||||
cannot be implemented until a port is selected.
|
||||
|
||||
#### Rule 21.3
|
||||
|
||||
MISRA C-2012 Rule 21.3: The memory allocation and deallocation functions of
|
||||
<stdlib.h> shall not be used.
|
||||
|
||||
_Ref 21.3_
|
||||
- See justification from Directive 4.12
|
||||
|
||||
Affected Files:
|
||||
- portable/MemMang/heap_*.c
|
||||
|
||||
#### Rule 21.6
|
||||
|
||||
MISRA C-2012 Rule 21.6: The Standard Library input/output functions shall not
|
||||
be used.
|
||||
|
||||
_Ref 21.6.1_
|
||||
- The Standard Library function `printf` is used in examples to provide a
|
||||
simple getting started demonstration. This example is not considered part
|
||||
of the kernel implementation.
|
||||
|
||||
Affected Files:
|
||||
- examples/cmake_example/main.c
|
||||
@@ -0,0 +1,5 @@
|
||||
[InternetShortcut]
|
||||
URL=https://www.FreeRTOS.org/FreeRTOS-quick-start-guide.html
|
||||
IDList=
|
||||
[{000214A0-0000-0000-C000-000000000046}]
|
||||
Prop3=19,2
|
||||
@@ -0,0 +1,192 @@
|
||||
[](https://github.com/FreeRTOS/FreeRTOS-Kernel/actions/workflows/unit-tests.yml?query=branch%3Amain+event%3Apush+workflow%3A%22CMock+Unit+Tests%22++)
|
||||
[](https://codecov.io/gh/FreeRTOS/FreeRTOS-Kernel)
|
||||
|
||||
## Getting started
|
||||
|
||||
This repository contains FreeRTOS kernel source/header files and kernel
|
||||
ports only. This repository is referenced as a submodule in
|
||||
[FreeRTOS/FreeRTOS](https://github.com/FreeRTOS/FreeRTOS)
|
||||
repository, which contains pre-configured demo application projects under
|
||||
```FreeRTOS/Demo``` directory.
|
||||
|
||||
The easiest way to use FreeRTOS is to start with one of the pre-configured demo
|
||||
application projects. That way you will have the correct FreeRTOS source files
|
||||
included, and the correct include paths configured. Once a demo application is
|
||||
building and executing you can remove the demo application files, and start to
|
||||
add in your own application source files. See the
|
||||
[FreeRTOS Kernel Quick Start Guide](https://www.freertos.org/Documentation/01-FreeRTOS-quick-start/01-Beginners-guide/02-Quick-start-guide)
|
||||
for detailed instructions and other useful links.
|
||||
|
||||
Additionally, for FreeRTOS kernel feature information refer to the
|
||||
[Developer Documentation](https://www.freertos.org/Documentation/02-Kernel/02-Kernel-features/00-Developer-docs),
|
||||
and [API Reference](https://www.freertos.org/Documentation/02-Kernel/04-API-references/01-Task-creation/00-TaskHandle).
|
||||
|
||||
Also for contributing and creating a Pull Request please refer to
|
||||
[the instructions here](.github/CONTRIBUTING.md#contributing-via-pull-request).
|
||||
|
||||
**FreeRTOS-Kernel V11.1.0
|
||||
[source code](https://github.com/FreeRTOS/FreeRTOS-Kernel/tree/V11.1.0) is part
|
||||
of the
|
||||
[FreeRTOS 202406.00 LTS](https://github.com/FreeRTOS/FreeRTOS-LTS/tree/202406-LTS)
|
||||
release.**
|
||||
|
||||
### Getting help
|
||||
|
||||
If you have any questions or need assistance troubleshooting your FreeRTOS project,
|
||||
we have an active community that can help on the
|
||||
[FreeRTOS Community Support Forum](https://forums.freertos.org).
|
||||
|
||||
## To consume FreeRTOS-Kernel
|
||||
|
||||
### Consume with CMake
|
||||
|
||||
If using CMake, it is recommended to use this repository using FetchContent.
|
||||
Add the following into your project's main or a subdirectory's `CMakeLists.txt`:
|
||||
|
||||
- Define the source and version/tag you want to use:
|
||||
|
||||
```cmake
|
||||
FetchContent_Declare( freertos_kernel
|
||||
GIT_REPOSITORY https://github.com/FreeRTOS/FreeRTOS-Kernel.git
|
||||
GIT_TAG main #Note: Best practice to use specific git-hash or tagged version
|
||||
)
|
||||
```
|
||||
|
||||
In case you prefer to add it as a git submodule, do:
|
||||
|
||||
```bash
|
||||
git submodule add https://github.com/FreeRTOS/FreeRTOS-Kernel.git <path of the submodule>
|
||||
git submodule update --init
|
||||
```
|
||||
|
||||
- Add a freertos_config library (typically an INTERFACE library) The following assumes the directory structure:
|
||||
- `include/FreeRTOSConfig.h`
|
||||
|
||||
```cmake
|
||||
add_library(freertos_config INTERFACE)
|
||||
|
||||
target_include_directories(freertos_config SYSTEM
|
||||
INTERFACE
|
||||
include
|
||||
)
|
||||
|
||||
target_compile_definitions(freertos_config
|
||||
INTERFACE
|
||||
projCOVERAGE_TEST=0
|
||||
)
|
||||
```
|
||||
|
||||
In case you installed FreeRTOS-Kernel as a submodule, you will have to add it as a subdirectory:
|
||||
|
||||
```cmake
|
||||
add_subdirectory(${FREERTOS_PATH})
|
||||
```
|
||||
|
||||
- Configure the FreeRTOS-Kernel and make it available
|
||||
- this particular example supports a native and cross-compiled build option.
|
||||
|
||||
```cmake
|
||||
set( FREERTOS_HEAP "4" CACHE STRING "" FORCE)
|
||||
# Select the native compile PORT
|
||||
set( FREERTOS_PORT "GCC_POSIX" CACHE STRING "" FORCE)
|
||||
# Select the cross-compile PORT
|
||||
if (CMAKE_CROSSCOMPILING)
|
||||
set(FREERTOS_PORT "GCC_ARM_CA9" CACHE STRING "" FORCE)
|
||||
endif()
|
||||
|
||||
FetchContent_MakeAvailable(freertos_kernel)
|
||||
```
|
||||
|
||||
- In case of cross compilation, you should also add the following to `freertos_config`:
|
||||
|
||||
```cmake
|
||||
target_compile_definitions(freertos_config INTERFACE ${definitions})
|
||||
target_compile_options(freertos_config INTERFACE ${options})
|
||||
```
|
||||
|
||||
### Consuming stand-alone - Cloning this repository
|
||||
|
||||
To clone using HTTPS:
|
||||
|
||||
```
|
||||
git clone https://github.com/FreeRTOS/FreeRTOS-Kernel.git
|
||||
```
|
||||
|
||||
Using SSH:
|
||||
|
||||
```
|
||||
git clone git@github.com:FreeRTOS/FreeRTOS-Kernel.git
|
||||
```
|
||||
|
||||
## Repository structure
|
||||
|
||||
- The root of this repository contains the three files that are common to
|
||||
every port - list.c, queue.c and tasks.c. The kernel is contained within these
|
||||
three files. croutine.c implements the optional co-routine functionality - which
|
||||
is normally only used on very memory limited systems.
|
||||
|
||||
- The ```./portable``` directory contains the files that are specific to a particular microcontroller and/or compiler.
|
||||
See the readme file in the ```./portable``` directory for more information.
|
||||
|
||||
- The ```./include``` directory contains the real time kernel header files.
|
||||
|
||||
- The ```./template_configuration``` directory contains a sample `FreeRTOSConfig.h` to help jumpstart a new project.
|
||||
See the [FreeRTOSConfig.h](examples/template_configuration/FreeRTOSConfig.h) file for instructions.
|
||||
|
||||
### Code Formatting
|
||||
|
||||
FreeRTOS files are formatted using the
|
||||
"[uncrustify](https://github.com/uncrustify/uncrustify)" tool.
|
||||
The configuration file used by uncrustify can be found in the
|
||||
[FreeRTOS/CI-CD-GitHub-Actions's](https://github.com/FreeRTOS/CI-CD-Github-Actions)
|
||||
[uncrustify.cfg](https://github.com/FreeRTOS/CI-CD-Github-Actions/tree/main/formatting)
|
||||
file.
|
||||
|
||||
### Line Endings
|
||||
|
||||
File checked into the FreeRTOS-Kernel repository use unix-style LF line endings
|
||||
for the best compatibility with git.
|
||||
|
||||
For optimal compatibility with Microsoft Windows tools, it is best to enable
|
||||
the git autocrlf feature. You can enable this setting for the current
|
||||
repository using the following command:
|
||||
|
||||
```
|
||||
git config core.autocrlf true
|
||||
```
|
||||
|
||||
### Git History Optimizations
|
||||
|
||||
Some commits in this repository perform large refactors which touch many lines
|
||||
and lead to unwanted behavior when using the `git blame` command. You can
|
||||
configure git to ignore the list of large refactor commits in this repository
|
||||
with the following command:
|
||||
|
||||
```
|
||||
git config blame.ignoreRevsFile .git-blame-ignore-revs
|
||||
```
|
||||
|
||||
### Spelling and Formatting
|
||||
|
||||
We recommend using [Visual Studio Code](https://code.visualstudio.com),
|
||||
commonly referred to as VSCode, when working on the FreeRTOS-Kernel.
|
||||
The FreeRTOS-Kernel also uses [cSpell](https://cspell.org/) as part of its
|
||||
spelling check. The config file for which can be found at [cspell.config.yaml](cspell.config.yaml)
|
||||
There is additionally a
|
||||
[cSpell plugin for VSCode](https://marketplace.visualstudio.com/items?itemName=streetsidesoftware.code-spell-checker)
|
||||
that can be used as well.
|
||||
*[.cSpellWords.txt](.github/.cSpellWords.txt)* contains words that are not
|
||||
traditionally found in an English dictionary. It is used by the spellchecker
|
||||
to verify the various jargon, variable names, and other odd words used in the
|
||||
FreeRTOS code base are correct. If your pull request fails to pass the spelling
|
||||
and you believe this is a mistake, then add the word to
|
||||
*[.cSpellWords.txt](.github/.cSpellWords.txt)*. When adding a word please
|
||||
then sort the list, which can be done by running the bash command:
|
||||
`sort -u .cSpellWords.txt -o .cSpellWords.txt`
|
||||
Note that only the FreeRTOS-Kernel Source Files, [include](include),
|
||||
[portable/MemMang](portable/MemMang), and [portable/Common](portable/Common)
|
||||
files are checked for proper spelling, and formatting at this time.
|
||||
|
||||
## Third Party Tools
|
||||
Visit [this link](.github/third_party_tools.md) for detailed information about
|
||||
third-party tools with FreeRTOS support.
|
||||
@@ -0,0 +1,405 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
#include "croutine.h"
|
||||
|
||||
/* Remove the whole file if co-routines are not being used. */
|
||||
#if ( configUSE_CO_ROUTINES != 0 )
|
||||
|
||||
/*
|
||||
* Some kernel aware debuggers require data to be viewed to be global, rather
|
||||
* than file scope.
|
||||
*/
|
||||
#ifdef portREMOVE_STATIC_QUALIFIER
|
||||
#define static
|
||||
#endif
|
||||
|
||||
|
||||
/* Lists for ready and blocked co-routines. --------------------*/
|
||||
static List_t pxReadyCoRoutineLists[ configMAX_CO_ROUTINE_PRIORITIES ]; /**< Prioritised ready co-routines. */
|
||||
static List_t xDelayedCoRoutineList1; /**< Delayed co-routines. */
|
||||
static List_t xDelayedCoRoutineList2; /**< Delayed co-routines (two lists are used - one for delays that have overflowed the current tick count. */
|
||||
static List_t * pxDelayedCoRoutineList = NULL; /**< Points to the delayed co-routine list currently being used. */
|
||||
static List_t * pxOverflowDelayedCoRoutineList = NULL; /**< Points to the delayed co-routine list currently being used to hold co-routines that have overflowed the current tick count. */
|
||||
static List_t xPendingReadyCoRoutineList; /**< Holds co-routines that have been readied by an external event. They cannot be added directly to the ready lists as the ready lists cannot be accessed by interrupts. */
|
||||
|
||||
/* Other file private variables. --------------------------------*/
|
||||
CRCB_t * pxCurrentCoRoutine = NULL;
|
||||
static UBaseType_t uxTopCoRoutineReadyPriority = ( UBaseType_t ) 0U;
|
||||
static TickType_t xCoRoutineTickCount = ( TickType_t ) 0U;
|
||||
static TickType_t xLastTickCount = ( TickType_t ) 0U;
|
||||
static TickType_t xPassedTicks = ( TickType_t ) 0U;
|
||||
|
||||
/* The initial state of the co-routine when it is created. */
|
||||
#define corINITIAL_STATE ( 0 )
|
||||
|
||||
/*
|
||||
* Place the co-routine represented by pxCRCB into the appropriate ready queue
|
||||
* for the priority. It is inserted at the end of the list.
|
||||
*
|
||||
* This macro accesses the co-routine ready lists and therefore must not be
|
||||
* used from within an ISR.
|
||||
*/
|
||||
#define prvAddCoRoutineToReadyQueue( pxCRCB ) \
|
||||
do { \
|
||||
if( ( pxCRCB )->uxPriority > uxTopCoRoutineReadyPriority ) \
|
||||
{ \
|
||||
uxTopCoRoutineReadyPriority = ( pxCRCB )->uxPriority; \
|
||||
} \
|
||||
vListInsertEnd( ( List_t * ) &( pxReadyCoRoutineLists[ ( pxCRCB )->uxPriority ] ), &( ( pxCRCB )->xGenericListItem ) ); \
|
||||
} while( 0 )
|
||||
|
||||
/*
|
||||
* Utility to ready all the lists used by the scheduler. This is called
|
||||
* automatically upon the creation of the first co-routine.
|
||||
*/
|
||||
static void prvInitialiseCoRoutineLists( void );
|
||||
|
||||
/*
|
||||
* Co-routines that are readied by an interrupt cannot be placed directly into
|
||||
* the ready lists (there is no mutual exclusion). Instead they are placed in
|
||||
* in the pending ready list in order that they can later be moved to the ready
|
||||
* list by the co-routine scheduler.
|
||||
*/
|
||||
static void prvCheckPendingReadyList( void );
|
||||
|
||||
/*
|
||||
* Macro that looks at the list of co-routines that are currently delayed to
|
||||
* see if any require waking.
|
||||
*
|
||||
* Co-routines are stored in the queue in the order of their wake time -
|
||||
* meaning once one co-routine has been found whose timer has not expired
|
||||
* we need not look any further down the list.
|
||||
*/
|
||||
static void prvCheckDelayedList( void );
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
BaseType_t xCoRoutineCreate( crCOROUTINE_CODE pxCoRoutineCode,
|
||||
UBaseType_t uxPriority,
|
||||
UBaseType_t uxIndex )
|
||||
{
|
||||
BaseType_t xReturn;
|
||||
CRCB_t * pxCoRoutine;
|
||||
|
||||
traceENTER_xCoRoutineCreate( pxCoRoutineCode, uxPriority, uxIndex );
|
||||
|
||||
/* Allocate the memory that will store the co-routine control block. */
|
||||
/* MISRA Ref 11.5.1 [Malloc memory assignment] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
|
||||
/* coverity[misra_c_2012_rule_11_5_violation] */
|
||||
pxCoRoutine = ( CRCB_t * ) pvPortMalloc( sizeof( CRCB_t ) );
|
||||
|
||||
if( pxCoRoutine )
|
||||
{
|
||||
/* If pxCurrentCoRoutine is NULL then this is the first co-routine to
|
||||
* be created and the co-routine data structures need initialising. */
|
||||
if( pxCurrentCoRoutine == NULL )
|
||||
{
|
||||
pxCurrentCoRoutine = pxCoRoutine;
|
||||
prvInitialiseCoRoutineLists();
|
||||
}
|
||||
|
||||
/* Check the priority is within limits. */
|
||||
if( uxPriority >= configMAX_CO_ROUTINE_PRIORITIES )
|
||||
{
|
||||
uxPriority = configMAX_CO_ROUTINE_PRIORITIES - 1;
|
||||
}
|
||||
|
||||
/* Fill out the co-routine control block from the function parameters. */
|
||||
pxCoRoutine->uxState = corINITIAL_STATE;
|
||||
pxCoRoutine->uxPriority = uxPriority;
|
||||
pxCoRoutine->uxIndex = uxIndex;
|
||||
pxCoRoutine->pxCoRoutineFunction = pxCoRoutineCode;
|
||||
|
||||
/* Initialise all the other co-routine control block parameters. */
|
||||
vListInitialiseItem( &( pxCoRoutine->xGenericListItem ) );
|
||||
vListInitialiseItem( &( pxCoRoutine->xEventListItem ) );
|
||||
|
||||
/* Set the co-routine control block as a link back from the ListItem_t.
|
||||
* This is so we can get back to the containing CRCB from a generic item
|
||||
* in a list. */
|
||||
listSET_LIST_ITEM_OWNER( &( pxCoRoutine->xGenericListItem ), pxCoRoutine );
|
||||
listSET_LIST_ITEM_OWNER( &( pxCoRoutine->xEventListItem ), pxCoRoutine );
|
||||
|
||||
/* Event lists are always in priority order. */
|
||||
listSET_LIST_ITEM_VALUE( &( pxCoRoutine->xEventListItem ), ( ( TickType_t ) configMAX_CO_ROUTINE_PRIORITIES - ( TickType_t ) uxPriority ) );
|
||||
|
||||
/* Now the co-routine has been initialised it can be added to the ready
|
||||
* list at the correct priority. */
|
||||
prvAddCoRoutineToReadyQueue( pxCoRoutine );
|
||||
|
||||
xReturn = pdPASS;
|
||||
}
|
||||
else
|
||||
{
|
||||
xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
|
||||
}
|
||||
|
||||
traceRETURN_xCoRoutineCreate( xReturn );
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vCoRoutineAddToDelayedList( TickType_t xTicksToDelay,
|
||||
List_t * pxEventList )
|
||||
{
|
||||
TickType_t xTimeToWake;
|
||||
|
||||
traceENTER_vCoRoutineAddToDelayedList( xTicksToDelay, pxEventList );
|
||||
|
||||
/* Calculate the time to wake - this may overflow but this is
|
||||
* not a problem. */
|
||||
xTimeToWake = xCoRoutineTickCount + xTicksToDelay;
|
||||
|
||||
/* We must remove ourselves from the ready list before adding
|
||||
* ourselves to the blocked list as the same list item is used for
|
||||
* both lists. */
|
||||
( void ) uxListRemove( ( ListItem_t * ) &( pxCurrentCoRoutine->xGenericListItem ) );
|
||||
|
||||
/* The list item will be inserted in wake time order. */
|
||||
listSET_LIST_ITEM_VALUE( &( pxCurrentCoRoutine->xGenericListItem ), xTimeToWake );
|
||||
|
||||
if( xTimeToWake < xCoRoutineTickCount )
|
||||
{
|
||||
/* Wake time has overflowed. Place this item in the
|
||||
* overflow list. */
|
||||
vListInsert( ( List_t * ) pxOverflowDelayedCoRoutineList, ( ListItem_t * ) &( pxCurrentCoRoutine->xGenericListItem ) );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The wake time has not overflowed, so we can use the
|
||||
* current block list. */
|
||||
vListInsert( ( List_t * ) pxDelayedCoRoutineList, ( ListItem_t * ) &( pxCurrentCoRoutine->xGenericListItem ) );
|
||||
}
|
||||
|
||||
if( pxEventList )
|
||||
{
|
||||
/* Also add the co-routine to an event list. If this is done then the
|
||||
* function must be called with interrupts disabled. */
|
||||
vListInsert( pxEventList, &( pxCurrentCoRoutine->xEventListItem ) );
|
||||
}
|
||||
|
||||
traceRETURN_vCoRoutineAddToDelayedList();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void prvCheckPendingReadyList( void )
|
||||
{
|
||||
/* Are there any co-routines waiting to get moved to the ready list? These
|
||||
* are co-routines that have been readied by an ISR. The ISR cannot access
|
||||
* the ready lists itself. */
|
||||
while( listLIST_IS_EMPTY( &xPendingReadyCoRoutineList ) == pdFALSE )
|
||||
{
|
||||
CRCB_t * pxUnblockedCRCB;
|
||||
|
||||
/* The pending ready list can be accessed by an ISR. */
|
||||
portDISABLE_INTERRUPTS();
|
||||
{
|
||||
pxUnblockedCRCB = ( CRCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &xPendingReadyCoRoutineList ) );
|
||||
( void ) uxListRemove( &( pxUnblockedCRCB->xEventListItem ) );
|
||||
}
|
||||
portENABLE_INTERRUPTS();
|
||||
|
||||
( void ) uxListRemove( &( pxUnblockedCRCB->xGenericListItem ) );
|
||||
prvAddCoRoutineToReadyQueue( pxUnblockedCRCB );
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void prvCheckDelayedList( void )
|
||||
{
|
||||
CRCB_t * pxCRCB;
|
||||
|
||||
xPassedTicks = xTaskGetTickCount() - xLastTickCount;
|
||||
|
||||
while( xPassedTicks )
|
||||
{
|
||||
xCoRoutineTickCount++;
|
||||
xPassedTicks--;
|
||||
|
||||
/* If the tick count has overflowed we need to swap the ready lists. */
|
||||
if( xCoRoutineTickCount == 0 )
|
||||
{
|
||||
List_t * pxTemp;
|
||||
|
||||
/* Tick count has overflowed so we need to swap the delay lists. If there are
|
||||
* any items in pxDelayedCoRoutineList here then there is an error! */
|
||||
pxTemp = pxDelayedCoRoutineList;
|
||||
pxDelayedCoRoutineList = pxOverflowDelayedCoRoutineList;
|
||||
pxOverflowDelayedCoRoutineList = pxTemp;
|
||||
}
|
||||
|
||||
/* See if this tick has made a timeout expire. */
|
||||
while( listLIST_IS_EMPTY( pxDelayedCoRoutineList ) == pdFALSE )
|
||||
{
|
||||
pxCRCB = ( CRCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedCoRoutineList );
|
||||
|
||||
if( xCoRoutineTickCount < listGET_LIST_ITEM_VALUE( &( pxCRCB->xGenericListItem ) ) )
|
||||
{
|
||||
/* Timeout not yet expired. */
|
||||
break;
|
||||
}
|
||||
|
||||
portDISABLE_INTERRUPTS();
|
||||
{
|
||||
/* The event could have occurred just before this critical
|
||||
* section. If this is the case then the generic list item will
|
||||
* have been moved to the pending ready list and the following
|
||||
* line is still valid. Also the pvContainer parameter will have
|
||||
* been set to NULL so the following lines are also valid. */
|
||||
( void ) uxListRemove( &( pxCRCB->xGenericListItem ) );
|
||||
|
||||
/* Is the co-routine waiting on an event also? */
|
||||
if( pxCRCB->xEventListItem.pxContainer )
|
||||
{
|
||||
( void ) uxListRemove( &( pxCRCB->xEventListItem ) );
|
||||
}
|
||||
}
|
||||
portENABLE_INTERRUPTS();
|
||||
|
||||
prvAddCoRoutineToReadyQueue( pxCRCB );
|
||||
}
|
||||
}
|
||||
|
||||
xLastTickCount = xCoRoutineTickCount;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vCoRoutineSchedule( void )
|
||||
{
|
||||
traceENTER_vCoRoutineSchedule();
|
||||
|
||||
/* Only run a co-routine after prvInitialiseCoRoutineLists() has been
|
||||
* called. prvInitialiseCoRoutineLists() is called automatically when a
|
||||
* co-routine is created. */
|
||||
if( pxDelayedCoRoutineList != NULL )
|
||||
{
|
||||
/* See if any co-routines readied by events need moving to the ready lists. */
|
||||
prvCheckPendingReadyList();
|
||||
|
||||
/* See if any delayed co-routines have timed out. */
|
||||
prvCheckDelayedList();
|
||||
|
||||
/* Find the highest priority queue that contains ready co-routines. */
|
||||
while( listLIST_IS_EMPTY( &( pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ] ) ) )
|
||||
{
|
||||
if( uxTopCoRoutineReadyPriority == 0 )
|
||||
{
|
||||
/* No more co-routines to check. */
|
||||
return;
|
||||
}
|
||||
|
||||
--uxTopCoRoutineReadyPriority;
|
||||
}
|
||||
|
||||
/* listGET_OWNER_OF_NEXT_ENTRY walks through the list, so the co-routines
|
||||
* of the same priority get an equal share of the processor time. */
|
||||
listGET_OWNER_OF_NEXT_ENTRY( pxCurrentCoRoutine, &( pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ] ) );
|
||||
|
||||
/* Call the co-routine. */
|
||||
( pxCurrentCoRoutine->pxCoRoutineFunction )( pxCurrentCoRoutine, pxCurrentCoRoutine->uxIndex );
|
||||
}
|
||||
|
||||
traceRETURN_vCoRoutineSchedule();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void prvInitialiseCoRoutineLists( void )
|
||||
{
|
||||
UBaseType_t uxPriority;
|
||||
|
||||
for( uxPriority = 0; uxPriority < configMAX_CO_ROUTINE_PRIORITIES; uxPriority++ )
|
||||
{
|
||||
vListInitialise( ( List_t * ) &( pxReadyCoRoutineLists[ uxPriority ] ) );
|
||||
}
|
||||
|
||||
vListInitialise( ( List_t * ) &xDelayedCoRoutineList1 );
|
||||
vListInitialise( ( List_t * ) &xDelayedCoRoutineList2 );
|
||||
vListInitialise( ( List_t * ) &xPendingReadyCoRoutineList );
|
||||
|
||||
/* Start with pxDelayedCoRoutineList using list1 and the
|
||||
* pxOverflowDelayedCoRoutineList using list2. */
|
||||
pxDelayedCoRoutineList = &xDelayedCoRoutineList1;
|
||||
pxOverflowDelayedCoRoutineList = &xDelayedCoRoutineList2;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
BaseType_t xCoRoutineRemoveFromEventList( const List_t * pxEventList )
|
||||
{
|
||||
CRCB_t * pxUnblockedCRCB;
|
||||
BaseType_t xReturn;
|
||||
|
||||
traceENTER_xCoRoutineRemoveFromEventList( pxEventList );
|
||||
|
||||
/* This function is called from within an interrupt. It can only access
|
||||
* event lists and the pending ready list. This function assumes that a
|
||||
* check has already been made to ensure pxEventList is not empty. */
|
||||
pxUnblockedCRCB = ( CRCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxEventList );
|
||||
( void ) uxListRemove( &( pxUnblockedCRCB->xEventListItem ) );
|
||||
vListInsertEnd( ( List_t * ) &( xPendingReadyCoRoutineList ), &( pxUnblockedCRCB->xEventListItem ) );
|
||||
|
||||
if( pxUnblockedCRCB->uxPriority >= pxCurrentCoRoutine->uxPriority )
|
||||
{
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
xReturn = pdFALSE;
|
||||
}
|
||||
|
||||
traceRETURN_xCoRoutineRemoveFromEventList( xReturn );
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Reset state in this file. This state is normally initialized at start up.
|
||||
* This function must be called by the application before restarting the
|
||||
* scheduler.
|
||||
*/
|
||||
void vCoRoutineResetState( void )
|
||||
{
|
||||
/* Lists for ready and blocked co-routines. */
|
||||
pxDelayedCoRoutineList = NULL;
|
||||
pxOverflowDelayedCoRoutineList = NULL;
|
||||
|
||||
/* Other file private variables. */
|
||||
pxCurrentCoRoutine = NULL;
|
||||
uxTopCoRoutineReadyPriority = ( UBaseType_t ) 0U;
|
||||
xCoRoutineTickCount = ( TickType_t ) 0U;
|
||||
xLastTickCount = ( TickType_t ) 0U;
|
||||
xPassedTicks = ( TickType_t ) 0U;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#endif /* configUSE_CO_ROUTINES == 0 */
|
||||
@@ -0,0 +1,31 @@
|
||||
---
|
||||
$schema: https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json
|
||||
version: '0.2'
|
||||
# Allows things like stringLength
|
||||
allowCompoundWords: true
|
||||
|
||||
# Read files not to spell check from the git ignore
|
||||
useGitignore: true
|
||||
|
||||
# Language settings for C
|
||||
languageSettings:
|
||||
- caseSensitive: false
|
||||
enabled: true
|
||||
languageId: c
|
||||
locale: "*"
|
||||
|
||||
# Add a dictionary, and the path to the word list
|
||||
dictionaryDefinitions:
|
||||
- name: freertos-words
|
||||
path: '.github/.cSpellWords.txt'
|
||||
addWords: true
|
||||
|
||||
dictionaries:
|
||||
- freertos-words
|
||||
|
||||
# Paths and files to ignore
|
||||
ignorePaths:
|
||||
- 'dependency'
|
||||
- 'docs'
|
||||
- 'ThirdParty'
|
||||
- 'History.txt'
|
||||
@@ -0,0 +1,887 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdlib.h>
|
||||
|
||||
/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
|
||||
* all the API functions to use the MPU wrappers. That should only be done when
|
||||
* task.h is included from an application file. */
|
||||
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
#include "timers.h"
|
||||
#include "event_groups.h"
|
||||
|
||||
/* The MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined
|
||||
* for the header files above, but not in this file, in order to generate the
|
||||
* correct privileged Vs unprivileged linkage and placement. */
|
||||
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
/* This entire source file will be skipped if the application is not configured
|
||||
* to include event groups functionality. This #if is closed at the very bottom
|
||||
* of this file. If you want to include event groups then ensure
|
||||
* configUSE_EVENT_GROUPS is set to 1 in FreeRTOSConfig.h. */
|
||||
#if ( configUSE_EVENT_GROUPS == 1 )
|
||||
|
||||
typedef struct EventGroupDef_t
|
||||
{
|
||||
EventBits_t uxEventBits;
|
||||
List_t xTasksWaitingForBits; /**< List of tasks waiting for a bit to be set. */
|
||||
|
||||
#if ( configUSE_TRACE_FACILITY == 1 )
|
||||
UBaseType_t uxEventGroupNumber;
|
||||
#endif
|
||||
|
||||
#if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
|
||||
uint8_t ucStaticallyAllocated; /**< Set to pdTRUE if the event group is statically allocated to ensure no attempt is made to free the memory. */
|
||||
#endif
|
||||
} EventGroup_t;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Test the bits set in uxCurrentEventBits to see if the wait condition is met.
|
||||
* The wait condition is defined by xWaitForAllBits. If xWaitForAllBits is
|
||||
* pdTRUE then the wait condition is met if all the bits set in uxBitsToWaitFor
|
||||
* are also set in uxCurrentEventBits. If xWaitForAllBits is pdFALSE then the
|
||||
* wait condition is met if any of the bits set in uxBitsToWaitFor are also set
|
||||
* in uxCurrentEventBits.
|
||||
*/
|
||||
static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits,
|
||||
const EventBits_t uxBitsToWaitFor,
|
||||
const BaseType_t xWaitForAllBits ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
|
||||
|
||||
EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer )
|
||||
{
|
||||
EventGroup_t * pxEventBits;
|
||||
|
||||
traceENTER_xEventGroupCreateStatic( pxEventGroupBuffer );
|
||||
|
||||
/* A StaticEventGroup_t object must be provided. */
|
||||
configASSERT( pxEventGroupBuffer );
|
||||
|
||||
#if ( configASSERT_DEFINED == 1 )
|
||||
{
|
||||
/* Sanity check that the size of the structure used to declare a
|
||||
* variable of type StaticEventGroup_t equals the size of the real
|
||||
* event group structure. */
|
||||
volatile size_t xSize = sizeof( StaticEventGroup_t );
|
||||
configASSERT( xSize == sizeof( EventGroup_t ) );
|
||||
}
|
||||
#endif /* configASSERT_DEFINED */
|
||||
|
||||
/* The user has provided a statically allocated event group - use it. */
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
pxEventBits = ( EventGroup_t * ) pxEventGroupBuffer;
|
||||
|
||||
if( pxEventBits != NULL )
|
||||
{
|
||||
pxEventBits->uxEventBits = 0;
|
||||
vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );
|
||||
|
||||
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
|
||||
{
|
||||
/* Both static and dynamic allocation can be used, so note that
|
||||
* this event group was created statically in case the event group
|
||||
* is later deleted. */
|
||||
pxEventBits->ucStaticallyAllocated = pdTRUE;
|
||||
}
|
||||
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
|
||||
|
||||
traceEVENT_GROUP_CREATE( pxEventBits );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* xEventGroupCreateStatic should only ever be called with
|
||||
* pxEventGroupBuffer pointing to a pre-allocated (compile time
|
||||
* allocated) StaticEventGroup_t variable. */
|
||||
traceEVENT_GROUP_CREATE_FAILED();
|
||||
}
|
||||
|
||||
traceRETURN_xEventGroupCreateStatic( pxEventBits );
|
||||
|
||||
return pxEventBits;
|
||||
}
|
||||
|
||||
#endif /* configSUPPORT_STATIC_ALLOCATION */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
|
||||
|
||||
EventGroupHandle_t xEventGroupCreate( void )
|
||||
{
|
||||
EventGroup_t * pxEventBits;
|
||||
|
||||
traceENTER_xEventGroupCreate();
|
||||
|
||||
/* MISRA Ref 11.5.1 [Malloc memory assignment] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
|
||||
/* coverity[misra_c_2012_rule_11_5_violation] */
|
||||
pxEventBits = ( EventGroup_t * ) pvPortMalloc( sizeof( EventGroup_t ) );
|
||||
|
||||
if( pxEventBits != NULL )
|
||||
{
|
||||
pxEventBits->uxEventBits = 0;
|
||||
vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );
|
||||
|
||||
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
|
||||
{
|
||||
/* Both static and dynamic allocation can be used, so note this
|
||||
* event group was allocated statically in case the event group is
|
||||
* later deleted. */
|
||||
pxEventBits->ucStaticallyAllocated = pdFALSE;
|
||||
}
|
||||
#endif /* configSUPPORT_STATIC_ALLOCATION */
|
||||
|
||||
traceEVENT_GROUP_CREATE( pxEventBits );
|
||||
}
|
||||
else
|
||||
{
|
||||
traceEVENT_GROUP_CREATE_FAILED();
|
||||
}
|
||||
|
||||
traceRETURN_xEventGroupCreate( pxEventBits );
|
||||
|
||||
return pxEventBits;
|
||||
}
|
||||
|
||||
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToSet,
|
||||
const EventBits_t uxBitsToWaitFor,
|
||||
TickType_t xTicksToWait )
|
||||
{
|
||||
EventBits_t uxOriginalBitValue, uxReturn;
|
||||
EventGroup_t * pxEventBits = xEventGroup;
|
||||
BaseType_t xAlreadyYielded;
|
||||
BaseType_t xTimeoutOccurred = pdFALSE;
|
||||
|
||||
traceENTER_xEventGroupSync( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTicksToWait );
|
||||
|
||||
configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
|
||||
configASSERT( uxBitsToWaitFor != 0 );
|
||||
#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
|
||||
{
|
||||
configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
|
||||
}
|
||||
#endif
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
uxOriginalBitValue = pxEventBits->uxEventBits;
|
||||
|
||||
( void ) xEventGroupSetBits( xEventGroup, uxBitsToSet );
|
||||
|
||||
if( ( ( uxOriginalBitValue | uxBitsToSet ) & uxBitsToWaitFor ) == uxBitsToWaitFor )
|
||||
{
|
||||
/* All the rendezvous bits are now set - no need to block. */
|
||||
uxReturn = ( uxOriginalBitValue | uxBitsToSet );
|
||||
|
||||
/* Rendezvous always clear the bits. They will have been cleared
|
||||
* already unless this is the only task in the rendezvous. */
|
||||
pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
|
||||
|
||||
xTicksToWait = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if( xTicksToWait != ( TickType_t ) 0 )
|
||||
{
|
||||
traceEVENT_GROUP_SYNC_BLOCK( xEventGroup, uxBitsToSet, uxBitsToWaitFor );
|
||||
|
||||
/* Store the bits that the calling task is waiting for in the
|
||||
* task's event list item so the kernel knows when a match is
|
||||
* found. Then enter the blocked state. */
|
||||
vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | eventCLEAR_EVENTS_ON_EXIT_BIT | eventWAIT_FOR_ALL_BITS ), xTicksToWait );
|
||||
|
||||
/* This assignment is obsolete as uxReturn will get set after
|
||||
* the task unblocks, but some compilers mistakenly generate a
|
||||
* warning about uxReturn being returned without being set if the
|
||||
* assignment is omitted. */
|
||||
uxReturn = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The rendezvous bits were not set, but no block time was
|
||||
* specified - just return the current event bit value. */
|
||||
uxReturn = pxEventBits->uxEventBits;
|
||||
xTimeoutOccurred = pdTRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
xAlreadyYielded = xTaskResumeAll();
|
||||
|
||||
if( xTicksToWait != ( TickType_t ) 0 )
|
||||
{
|
||||
if( xAlreadyYielded == pdFALSE )
|
||||
{
|
||||
taskYIELD_WITHIN_API();
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
/* The task blocked to wait for its required bits to be set - at this
|
||||
* point either the required bits were set or the block time expired. If
|
||||
* the required bits were set they will have been stored in the task's
|
||||
* event list item, and they should now be retrieved then cleared. */
|
||||
uxReturn = uxTaskResetEventItemValue();
|
||||
|
||||
if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )
|
||||
{
|
||||
/* The task timed out, just return the current event bit value. */
|
||||
taskENTER_CRITICAL();
|
||||
{
|
||||
uxReturn = pxEventBits->uxEventBits;
|
||||
|
||||
/* Although the task got here because it timed out before the
|
||||
* bits it was waiting for were set, it is possible that since it
|
||||
* unblocked another task has set the bits. If this is the case
|
||||
* then it needs to clear the bits before exiting. */
|
||||
if( ( uxReturn & uxBitsToWaitFor ) == uxBitsToWaitFor )
|
||||
{
|
||||
pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
taskEXIT_CRITICAL();
|
||||
|
||||
xTimeoutOccurred = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The task unblocked because the bits were set. */
|
||||
}
|
||||
|
||||
/* Control bits might be set as the task had blocked should not be
|
||||
* returned. */
|
||||
uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;
|
||||
}
|
||||
|
||||
traceEVENT_GROUP_SYNC_END( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred );
|
||||
|
||||
/* Prevent compiler warnings when trace macros are not used. */
|
||||
( void ) xTimeoutOccurred;
|
||||
|
||||
traceRETURN_xEventGroupSync( uxReturn );
|
||||
|
||||
return uxReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToWaitFor,
|
||||
const BaseType_t xClearOnExit,
|
||||
const BaseType_t xWaitForAllBits,
|
||||
TickType_t xTicksToWait )
|
||||
{
|
||||
EventGroup_t * pxEventBits = xEventGroup;
|
||||
EventBits_t uxReturn, uxControlBits = 0;
|
||||
BaseType_t xWaitConditionMet, xAlreadyYielded;
|
||||
BaseType_t xTimeoutOccurred = pdFALSE;
|
||||
|
||||
traceENTER_xEventGroupWaitBits( xEventGroup, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait );
|
||||
|
||||
/* Check the user is not attempting to wait on the bits used by the kernel
|
||||
* itself, and that at least one bit is being requested. */
|
||||
configASSERT( xEventGroup );
|
||||
configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
|
||||
configASSERT( uxBitsToWaitFor != 0 );
|
||||
#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
|
||||
{
|
||||
configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
|
||||
}
|
||||
#endif
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
const EventBits_t uxCurrentEventBits = pxEventBits->uxEventBits;
|
||||
|
||||
/* Check to see if the wait condition is already met or not. */
|
||||
xWaitConditionMet = prvTestWaitCondition( uxCurrentEventBits, uxBitsToWaitFor, xWaitForAllBits );
|
||||
|
||||
if( xWaitConditionMet != pdFALSE )
|
||||
{
|
||||
/* The wait condition has already been met so there is no need to
|
||||
* block. */
|
||||
uxReturn = uxCurrentEventBits;
|
||||
xTicksToWait = ( TickType_t ) 0;
|
||||
|
||||
/* Clear the wait bits if requested to do so. */
|
||||
if( xClearOnExit != pdFALSE )
|
||||
{
|
||||
pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else if( xTicksToWait == ( TickType_t ) 0 )
|
||||
{
|
||||
/* The wait condition has not been met, but no block time was
|
||||
* specified, so just return the current value. */
|
||||
uxReturn = uxCurrentEventBits;
|
||||
xTimeoutOccurred = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The task is going to block to wait for its required bits to be
|
||||
* set. uxControlBits are used to remember the specified behaviour of
|
||||
* this call to xEventGroupWaitBits() - for use when the event bits
|
||||
* unblock the task. */
|
||||
if( xClearOnExit != pdFALSE )
|
||||
{
|
||||
uxControlBits |= eventCLEAR_EVENTS_ON_EXIT_BIT;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
if( xWaitForAllBits != pdFALSE )
|
||||
{
|
||||
uxControlBits |= eventWAIT_FOR_ALL_BITS;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
/* Store the bits that the calling task is waiting for in the
|
||||
* task's event list item so the kernel knows when a match is
|
||||
* found. Then enter the blocked state. */
|
||||
vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | uxControlBits ), xTicksToWait );
|
||||
|
||||
/* This is obsolete as it will get set after the task unblocks, but
|
||||
* some compilers mistakenly generate a warning about the variable
|
||||
* being returned without being set if it is not done. */
|
||||
uxReturn = 0;
|
||||
|
||||
traceEVENT_GROUP_WAIT_BITS_BLOCK( xEventGroup, uxBitsToWaitFor );
|
||||
}
|
||||
}
|
||||
xAlreadyYielded = xTaskResumeAll();
|
||||
|
||||
if( xTicksToWait != ( TickType_t ) 0 )
|
||||
{
|
||||
if( xAlreadyYielded == pdFALSE )
|
||||
{
|
||||
taskYIELD_WITHIN_API();
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
/* The task blocked to wait for its required bits to be set - at this
|
||||
* point either the required bits were set or the block time expired. If
|
||||
* the required bits were set they will have been stored in the task's
|
||||
* event list item, and they should now be retrieved then cleared. */
|
||||
uxReturn = uxTaskResetEventItemValue();
|
||||
|
||||
if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )
|
||||
{
|
||||
taskENTER_CRITICAL();
|
||||
{
|
||||
/* The task timed out, just return the current event bit value. */
|
||||
uxReturn = pxEventBits->uxEventBits;
|
||||
|
||||
/* It is possible that the event bits were updated between this
|
||||
* task leaving the Blocked state and running again. */
|
||||
if( prvTestWaitCondition( uxReturn, uxBitsToWaitFor, xWaitForAllBits ) != pdFALSE )
|
||||
{
|
||||
if( xClearOnExit != pdFALSE )
|
||||
{
|
||||
pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
xTimeoutOccurred = pdTRUE;
|
||||
}
|
||||
taskEXIT_CRITICAL();
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The task unblocked because the bits were set. */
|
||||
}
|
||||
|
||||
/* The task blocked so control bits may have been set. */
|
||||
uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;
|
||||
}
|
||||
|
||||
traceEVENT_GROUP_WAIT_BITS_END( xEventGroup, uxBitsToWaitFor, xTimeoutOccurred );
|
||||
|
||||
/* Prevent compiler warnings when trace macros are not used. */
|
||||
( void ) xTimeoutOccurred;
|
||||
|
||||
traceRETURN_xEventGroupWaitBits( uxReturn );
|
||||
|
||||
return uxReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToClear )
|
||||
{
|
||||
EventGroup_t * pxEventBits = xEventGroup;
|
||||
EventBits_t uxReturn;
|
||||
|
||||
traceENTER_xEventGroupClearBits( xEventGroup, uxBitsToClear );
|
||||
|
||||
/* Check the user is not attempting to clear the bits used by the kernel
|
||||
* itself. */
|
||||
configASSERT( xEventGroup );
|
||||
configASSERT( ( uxBitsToClear & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
|
||||
|
||||
taskENTER_CRITICAL();
|
||||
{
|
||||
traceEVENT_GROUP_CLEAR_BITS( xEventGroup, uxBitsToClear );
|
||||
|
||||
/* The value returned is the event group value prior to the bits being
|
||||
* cleared. */
|
||||
uxReturn = pxEventBits->uxEventBits;
|
||||
|
||||
/* Clear the bits. */
|
||||
pxEventBits->uxEventBits &= ~uxBitsToClear;
|
||||
}
|
||||
taskEXIT_CRITICAL();
|
||||
|
||||
traceRETURN_xEventGroupClearBits( uxReturn );
|
||||
|
||||
return uxReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
|
||||
|
||||
BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToClear )
|
||||
{
|
||||
BaseType_t xReturn;
|
||||
|
||||
traceENTER_xEventGroupClearBitsFromISR( xEventGroup, uxBitsToClear );
|
||||
|
||||
traceEVENT_GROUP_CLEAR_BITS_FROM_ISR( xEventGroup, uxBitsToClear );
|
||||
xReturn = xTimerPendFunctionCallFromISR( &vEventGroupClearBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToClear, NULL );
|
||||
|
||||
traceRETURN_xEventGroupClearBitsFromISR( xReturn );
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
|
||||
#endif /* if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup )
|
||||
{
|
||||
UBaseType_t uxSavedInterruptStatus;
|
||||
EventGroup_t const * const pxEventBits = xEventGroup;
|
||||
EventBits_t uxReturn;
|
||||
|
||||
traceENTER_xEventGroupGetBitsFromISR( xEventGroup );
|
||||
|
||||
/* MISRA Ref 4.7.1 [Return value shall be checked] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#dir-47 */
|
||||
/* coverity[misra_c_2012_directive_4_7_violation] */
|
||||
uxSavedInterruptStatus = taskENTER_CRITICAL_FROM_ISR();
|
||||
{
|
||||
uxReturn = pxEventBits->uxEventBits;
|
||||
}
|
||||
taskEXIT_CRITICAL_FROM_ISR( uxSavedInterruptStatus );
|
||||
|
||||
traceRETURN_xEventGroupGetBitsFromISR( uxReturn );
|
||||
|
||||
return uxReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToSet )
|
||||
{
|
||||
ListItem_t * pxListItem;
|
||||
ListItem_t * pxNext;
|
||||
ListItem_t const * pxListEnd;
|
||||
List_t const * pxList;
|
||||
EventBits_t uxBitsToClear = 0, uxBitsWaitedFor, uxControlBits, uxReturnBits;
|
||||
EventGroup_t * pxEventBits = xEventGroup;
|
||||
BaseType_t xMatchFound = pdFALSE;
|
||||
|
||||
traceENTER_xEventGroupSetBits( xEventGroup, uxBitsToSet );
|
||||
|
||||
/* Check the user is not attempting to set the bits used by the kernel
|
||||
* itself. */
|
||||
configASSERT( xEventGroup );
|
||||
configASSERT( ( uxBitsToSet & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
|
||||
|
||||
pxList = &( pxEventBits->xTasksWaitingForBits );
|
||||
pxListEnd = listGET_END_MARKER( pxList );
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
traceEVENT_GROUP_SET_BITS( xEventGroup, uxBitsToSet );
|
||||
|
||||
pxListItem = listGET_HEAD_ENTRY( pxList );
|
||||
|
||||
/* Set the bits. */
|
||||
pxEventBits->uxEventBits |= uxBitsToSet;
|
||||
|
||||
/* See if the new bit value should unblock any tasks. */
|
||||
while( pxListItem != pxListEnd )
|
||||
{
|
||||
pxNext = listGET_NEXT( pxListItem );
|
||||
uxBitsWaitedFor = listGET_LIST_ITEM_VALUE( pxListItem );
|
||||
xMatchFound = pdFALSE;
|
||||
|
||||
/* Split the bits waited for from the control bits. */
|
||||
uxControlBits = uxBitsWaitedFor & eventEVENT_BITS_CONTROL_BYTES;
|
||||
uxBitsWaitedFor &= ~eventEVENT_BITS_CONTROL_BYTES;
|
||||
|
||||
if( ( uxControlBits & eventWAIT_FOR_ALL_BITS ) == ( EventBits_t ) 0 )
|
||||
{
|
||||
/* Just looking for single bit being set. */
|
||||
if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) != ( EventBits_t ) 0 )
|
||||
{
|
||||
xMatchFound = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) == uxBitsWaitedFor )
|
||||
{
|
||||
/* All bits are set. */
|
||||
xMatchFound = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Need all bits to be set, but not all the bits were set. */
|
||||
}
|
||||
|
||||
if( xMatchFound != pdFALSE )
|
||||
{
|
||||
/* The bits match. Should the bits be cleared on exit? */
|
||||
if( ( uxControlBits & eventCLEAR_EVENTS_ON_EXIT_BIT ) != ( EventBits_t ) 0 )
|
||||
{
|
||||
uxBitsToClear |= uxBitsWaitedFor;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
/* Store the actual event flag value in the task's event list
|
||||
* item before removing the task from the event list. The
|
||||
* eventUNBLOCKED_DUE_TO_BIT_SET bit is set so the task knows
|
||||
* that is was unblocked due to its required bits matching, rather
|
||||
* than because it timed out. */
|
||||
vTaskRemoveFromUnorderedEventList( pxListItem, pxEventBits->uxEventBits | eventUNBLOCKED_DUE_TO_BIT_SET );
|
||||
}
|
||||
|
||||
/* Move onto the next list item. Note pxListItem->pxNext is not
|
||||
* used here as the list item may have been removed from the event list
|
||||
* and inserted into the ready/pending reading list. */
|
||||
pxListItem = pxNext;
|
||||
}
|
||||
|
||||
/* Clear any bits that matched when the eventCLEAR_EVENTS_ON_EXIT_BIT
|
||||
* bit was set in the control word. */
|
||||
pxEventBits->uxEventBits &= ~uxBitsToClear;
|
||||
|
||||
/* Snapshot resulting bits. */
|
||||
uxReturnBits = pxEventBits->uxEventBits;
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
|
||||
traceRETURN_xEventGroupSetBits( uxReturnBits );
|
||||
|
||||
return uxReturnBits;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vEventGroupDelete( EventGroupHandle_t xEventGroup )
|
||||
{
|
||||
EventGroup_t * pxEventBits = xEventGroup;
|
||||
const List_t * pxTasksWaitingForBits;
|
||||
|
||||
traceENTER_vEventGroupDelete( xEventGroup );
|
||||
|
||||
configASSERT( pxEventBits );
|
||||
|
||||
pxTasksWaitingForBits = &( pxEventBits->xTasksWaitingForBits );
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
traceEVENT_GROUP_DELETE( xEventGroup );
|
||||
|
||||
while( listCURRENT_LIST_LENGTH( pxTasksWaitingForBits ) > ( UBaseType_t ) 0 )
|
||||
{
|
||||
/* Unblock the task, returning 0 as the event list is being deleted
|
||||
* and cannot therefore have any bits set. */
|
||||
configASSERT( pxTasksWaitingForBits->xListEnd.pxNext != ( const ListItem_t * ) &( pxTasksWaitingForBits->xListEnd ) );
|
||||
vTaskRemoveFromUnorderedEventList( pxTasksWaitingForBits->xListEnd.pxNext, eventUNBLOCKED_DUE_TO_BIT_SET );
|
||||
}
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
|
||||
#if ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )
|
||||
{
|
||||
/* The event group can only have been allocated dynamically - free
|
||||
* it again. */
|
||||
vPortFree( pxEventBits );
|
||||
}
|
||||
#elif ( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
|
||||
{
|
||||
/* The event group could have been allocated statically or
|
||||
* dynamically, so check before attempting to free the memory. */
|
||||
if( pxEventBits->ucStaticallyAllocated == ( uint8_t ) pdFALSE )
|
||||
{
|
||||
vPortFree( pxEventBits );
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
|
||||
|
||||
traceRETURN_vEventGroupDelete();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
|
||||
BaseType_t xEventGroupGetStaticBuffer( EventGroupHandle_t xEventGroup,
|
||||
StaticEventGroup_t ** ppxEventGroupBuffer )
|
||||
{
|
||||
BaseType_t xReturn;
|
||||
EventGroup_t * pxEventBits = xEventGroup;
|
||||
|
||||
traceENTER_xEventGroupGetStaticBuffer( xEventGroup, ppxEventGroupBuffer );
|
||||
|
||||
configASSERT( pxEventBits );
|
||||
configASSERT( ppxEventGroupBuffer );
|
||||
|
||||
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
|
||||
{
|
||||
/* Check if the event group was statically allocated. */
|
||||
if( pxEventBits->ucStaticallyAllocated == ( uint8_t ) pdTRUE )
|
||||
{
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
*ppxEventGroupBuffer = ( StaticEventGroup_t * ) pxEventBits;
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
xReturn = pdFALSE;
|
||||
}
|
||||
}
|
||||
#else /* configSUPPORT_DYNAMIC_ALLOCATION */
|
||||
{
|
||||
/* Event group must have been statically allocated. */
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
*ppxEventGroupBuffer = ( StaticEventGroup_t * ) pxEventBits;
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
|
||||
|
||||
traceRETURN_xEventGroupGetStaticBuffer( xReturn );
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
#endif /* configSUPPORT_STATIC_ALLOCATION */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* For internal use only - execute a 'set bits' command that was pended from
|
||||
* an interrupt. */
|
||||
void vEventGroupSetBitsCallback( void * pvEventGroup,
|
||||
uint32_t ulBitsToSet )
|
||||
{
|
||||
traceENTER_vEventGroupSetBitsCallback( pvEventGroup, ulBitsToSet );
|
||||
|
||||
/* MISRA Ref 11.5.4 [Callback function parameter] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
|
||||
/* coverity[misra_c_2012_rule_11_5_violation] */
|
||||
( void ) xEventGroupSetBits( pvEventGroup, ( EventBits_t ) ulBitsToSet );
|
||||
|
||||
traceRETURN_vEventGroupSetBitsCallback();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* For internal use only - execute a 'clear bits' command that was pended from
|
||||
* an interrupt. */
|
||||
void vEventGroupClearBitsCallback( void * pvEventGroup,
|
||||
uint32_t ulBitsToClear )
|
||||
{
|
||||
traceENTER_vEventGroupClearBitsCallback( pvEventGroup, ulBitsToClear );
|
||||
|
||||
/* MISRA Ref 11.5.4 [Callback function parameter] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
|
||||
/* coverity[misra_c_2012_rule_11_5_violation] */
|
||||
( void ) xEventGroupClearBits( pvEventGroup, ( EventBits_t ) ulBitsToClear );
|
||||
|
||||
traceRETURN_vEventGroupClearBitsCallback();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits,
|
||||
const EventBits_t uxBitsToWaitFor,
|
||||
const BaseType_t xWaitForAllBits )
|
||||
{
|
||||
BaseType_t xWaitConditionMet = pdFALSE;
|
||||
|
||||
if( xWaitForAllBits == pdFALSE )
|
||||
{
|
||||
/* Task only has to wait for one bit within uxBitsToWaitFor to be
|
||||
* set. Is one already set? */
|
||||
if( ( uxCurrentEventBits & uxBitsToWaitFor ) != ( EventBits_t ) 0 )
|
||||
{
|
||||
xWaitConditionMet = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Task has to wait for all the bits in uxBitsToWaitFor to be set.
|
||||
* Are they set already? */
|
||||
if( ( uxCurrentEventBits & uxBitsToWaitFor ) == uxBitsToWaitFor )
|
||||
{
|
||||
xWaitConditionMet = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
|
||||
return xWaitConditionMet;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
|
||||
|
||||
BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToSet,
|
||||
BaseType_t * pxHigherPriorityTaskWoken )
|
||||
{
|
||||
BaseType_t xReturn;
|
||||
|
||||
traceENTER_xEventGroupSetBitsFromISR( xEventGroup, uxBitsToSet, pxHigherPriorityTaskWoken );
|
||||
|
||||
traceEVENT_GROUP_SET_BITS_FROM_ISR( xEventGroup, uxBitsToSet );
|
||||
xReturn = xTimerPendFunctionCallFromISR( &vEventGroupSetBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToSet, pxHigherPriorityTaskWoken );
|
||||
|
||||
traceRETURN_xEventGroupSetBitsFromISR( xReturn );
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
|
||||
#endif /* if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( configUSE_TRACE_FACILITY == 1 )
|
||||
|
||||
UBaseType_t uxEventGroupGetNumber( void * xEventGroup )
|
||||
{
|
||||
UBaseType_t xReturn;
|
||||
|
||||
/* MISRA Ref 11.5.2 [Opaque pointer] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
|
||||
/* coverity[misra_c_2012_rule_11_5_violation] */
|
||||
EventGroup_t const * pxEventBits = ( EventGroup_t * ) xEventGroup;
|
||||
|
||||
traceENTER_uxEventGroupGetNumber( xEventGroup );
|
||||
|
||||
if( xEventGroup == NULL )
|
||||
{
|
||||
xReturn = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
xReturn = pxEventBits->uxEventGroupNumber;
|
||||
}
|
||||
|
||||
traceRETURN_uxEventGroupGetNumber( xReturn );
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
|
||||
#endif /* configUSE_TRACE_FACILITY */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( configUSE_TRACE_FACILITY == 1 )
|
||||
|
||||
void vEventGroupSetNumber( void * xEventGroup,
|
||||
UBaseType_t uxEventGroupNumber )
|
||||
{
|
||||
traceENTER_vEventGroupSetNumber( xEventGroup, uxEventGroupNumber );
|
||||
|
||||
/* MISRA Ref 11.5.2 [Opaque pointer] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Kernel/blob/main/MISRA.md#rule-115 */
|
||||
/* coverity[misra_c_2012_rule_11_5_violation] */
|
||||
( ( EventGroup_t * ) xEventGroup )->uxEventGroupNumber = uxEventGroupNumber;
|
||||
|
||||
traceRETURN_vEventGroupSetNumber();
|
||||
}
|
||||
|
||||
#endif /* configUSE_TRACE_FACILITY */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* This entire source file will be skipped if the application is not configured
|
||||
* to include event groups functionality. If you want to include event groups
|
||||
* then ensure configUSE_EVENT_GROUPS is set to 1 in FreeRTOSConfig.h. */
|
||||
#endif /* configUSE_EVENT_GROUPS == 1 */
|
||||
@@ -0,0 +1,15 @@
|
||||
# FreeRTOS internal cmake file. Do not use it in user top-level project
|
||||
|
||||
add_library(freertos_kernel_include INTERFACE)
|
||||
|
||||
target_include_directories(freertos_kernel_include
|
||||
INTERFACE
|
||||
.
|
||||
# Note: DEPRECATED but still supported, may be removed in a future release.
|
||||
$<$<NOT:$<TARGET_EXISTS:freertos_config>>:${FREERTOS_CONFIG_FILE_DIRECTORY}>
|
||||
)
|
||||
|
||||
target_link_libraries(freertos_kernel_include
|
||||
INTERFACE
|
||||
$<$<TARGET_EXISTS:freertos_config>:freertos_config>
|
||||
)
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifndef _MSC_VER /* Visual Studio doesn't support #warning. */
|
||||
#warning The name of this file has changed to stack_macros.h. Please update your code accordingly. This source file (which has the original name) will be removed in a future release.
|
||||
#endif
|
||||
|
||||
#include "stack_macros.h"
|
||||
@@ -0,0 +1,427 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file atomic.h
|
||||
* @brief FreeRTOS atomic operation support.
|
||||
*
|
||||
* This file implements atomic functions by disabling interrupts globally.
|
||||
* Implementations with architecture specific atomic instructions can be
|
||||
* provided under each compiler directory.
|
||||
*
|
||||
* The atomic interface can be used in FreeRTOS tasks on all FreeRTOS ports. It
|
||||
* can also be used in Interrupt Service Routines (ISRs) on FreeRTOS ports that
|
||||
* support nested interrupts (i.e. portHAS_NESTED_INTERRUPTS is set to 1). The
|
||||
* atomic interface must not be used in ISRs on FreeRTOS ports that do not
|
||||
* support nested interrupts (i.e. portHAS_NESTED_INTERRUPTS is set to 0)
|
||||
* because ISRs on these ports cannot be interrupted and therefore, do not need
|
||||
* atomics in ISRs.
|
||||
*/
|
||||
|
||||
#ifndef ATOMIC_H
|
||||
#define ATOMIC_H
|
||||
|
||||
#ifndef INC_FREERTOS_H
|
||||
#error "include FreeRTOS.h must appear in source files before include atomic.h"
|
||||
#endif
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/*
|
||||
* Port specific definitions -- entering/exiting critical section.
|
||||
* Refer template -- ./lib/FreeRTOS/portable/Compiler/Arch/portmacro.h
|
||||
*
|
||||
* Every call to ATOMIC_EXIT_CRITICAL() must be closely paired with
|
||||
* ATOMIC_ENTER_CRITICAL().
|
||||
*
|
||||
*/
|
||||
#if ( portHAS_NESTED_INTERRUPTS == 1 )
|
||||
|
||||
/* Nested interrupt scheme is supported in this port. */
|
||||
#define ATOMIC_ENTER_CRITICAL() \
|
||||
UBaseType_t uxCriticalSectionType = portSET_INTERRUPT_MASK_FROM_ISR()
|
||||
|
||||
#define ATOMIC_EXIT_CRITICAL() \
|
||||
portCLEAR_INTERRUPT_MASK_FROM_ISR( uxCriticalSectionType )
|
||||
|
||||
#else
|
||||
|
||||
/* Nested interrupt scheme is NOT supported in this port. */
|
||||
#define ATOMIC_ENTER_CRITICAL() portENTER_CRITICAL()
|
||||
#define ATOMIC_EXIT_CRITICAL() portEXIT_CRITICAL()
|
||||
|
||||
#endif /* portSET_INTERRUPT_MASK_FROM_ISR() */
|
||||
|
||||
/*
|
||||
* Port specific definition -- "always inline".
|
||||
* Inline is compiler specific, and may not always get inlined depending on your
|
||||
* optimization level. Also, inline is considered as performance optimization
|
||||
* for atomic. Thus, if portFORCE_INLINE is not provided by portmacro.h,
|
||||
* instead of resulting error, simply define it away.
|
||||
*/
|
||||
#ifndef portFORCE_INLINE
|
||||
#define portFORCE_INLINE
|
||||
#endif
|
||||
|
||||
#define ATOMIC_COMPARE_AND_SWAP_SUCCESS 0x1U /**< Compare and swap succeeded, swapped. */
|
||||
#define ATOMIC_COMPARE_AND_SWAP_FAILURE 0x0U /**< Compare and swap failed, did not swap. */
|
||||
|
||||
/*----------------------------- Swap && CAS ------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic compare-and-swap
|
||||
*
|
||||
* @brief Performs an atomic compare-and-swap operation on the specified values.
|
||||
*
|
||||
* @param[in, out] pulDestination Pointer to memory location from where value is
|
||||
* to be loaded and checked.
|
||||
* @param[in] ulExchange If condition meets, write this value to memory.
|
||||
* @param[in] ulComparand Swap condition.
|
||||
*
|
||||
* @return Unsigned integer of value 1 or 0. 1 for swapped, 0 for not swapped.
|
||||
*
|
||||
* @note This function only swaps *pulDestination with ulExchange, if previous
|
||||
* *pulDestination value equals ulComparand.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_CompareAndSwap_u32( uint32_t volatile * pulDestination,
|
||||
uint32_t ulExchange,
|
||||
uint32_t ulComparand )
|
||||
{
|
||||
uint32_t ulReturnValue;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
{
|
||||
if( *pulDestination == ulComparand )
|
||||
{
|
||||
*pulDestination = ulExchange;
|
||||
ulReturnValue = ATOMIC_COMPARE_AND_SWAP_SUCCESS;
|
||||
}
|
||||
else
|
||||
{
|
||||
ulReturnValue = ATOMIC_COMPARE_AND_SWAP_FAILURE;
|
||||
}
|
||||
}
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulReturnValue;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic swap (pointers)
|
||||
*
|
||||
* @brief Atomically sets the address pointed to by *ppvDestination to the value
|
||||
* of *pvExchange.
|
||||
*
|
||||
* @param[in, out] ppvDestination Pointer to memory location from where a pointer
|
||||
* value is to be loaded and written back to.
|
||||
* @param[in] pvExchange Pointer value to be written to *ppvDestination.
|
||||
*
|
||||
* @return The initial value of *ppvDestination.
|
||||
*/
|
||||
static portFORCE_INLINE void * Atomic_SwapPointers_p32( void * volatile * ppvDestination,
|
||||
void * pvExchange )
|
||||
{
|
||||
void * pReturnValue;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
{
|
||||
pReturnValue = *ppvDestination;
|
||||
*ppvDestination = pvExchange;
|
||||
}
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return pReturnValue;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic compare-and-swap (pointers)
|
||||
*
|
||||
* @brief Performs an atomic compare-and-swap operation on the specified pointer
|
||||
* values.
|
||||
*
|
||||
* @param[in, out] ppvDestination Pointer to memory location from where a pointer
|
||||
* value is to be loaded and checked.
|
||||
* @param[in] pvExchange If condition meets, write this value to memory.
|
||||
* @param[in] pvComparand Swap condition.
|
||||
*
|
||||
* @return Unsigned integer of value 1 or 0. 1 for swapped, 0 for not swapped.
|
||||
*
|
||||
* @note This function only swaps *ppvDestination with pvExchange, if previous
|
||||
* *ppvDestination value equals pvComparand.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_CompareAndSwapPointers_p32( void * volatile * ppvDestination,
|
||||
void * pvExchange,
|
||||
void * pvComparand )
|
||||
{
|
||||
uint32_t ulReturnValue = ATOMIC_COMPARE_AND_SWAP_FAILURE;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
{
|
||||
if( *ppvDestination == pvComparand )
|
||||
{
|
||||
*ppvDestination = pvExchange;
|
||||
ulReturnValue = ATOMIC_COMPARE_AND_SWAP_SUCCESS;
|
||||
}
|
||||
}
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulReturnValue;
|
||||
}
|
||||
|
||||
|
||||
/*----------------------------- Arithmetic ------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic add
|
||||
*
|
||||
* @brief Atomically adds count to the value of the specified pointer points to.
|
||||
*
|
||||
* @param[in,out] pulAddend Pointer to memory location from where value is to be
|
||||
* loaded and written back to.
|
||||
* @param[in] ulCount Value to be added to *pulAddend.
|
||||
*
|
||||
* @return previous *pulAddend value.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_Add_u32( uint32_t volatile * pulAddend,
|
||||
uint32_t ulCount )
|
||||
{
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
{
|
||||
ulCurrent = *pulAddend;
|
||||
*pulAddend += ulCount;
|
||||
}
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic subtract
|
||||
*
|
||||
* @brief Atomically subtracts count from the value of the specified pointer
|
||||
* pointers to.
|
||||
*
|
||||
* @param[in,out] pulAddend Pointer to memory location from where value is to be
|
||||
* loaded and written back to.
|
||||
* @param[in] ulCount Value to be subtract from *pulAddend.
|
||||
*
|
||||
* @return previous *pulAddend value.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_Subtract_u32( uint32_t volatile * pulAddend,
|
||||
uint32_t ulCount )
|
||||
{
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
{
|
||||
ulCurrent = *pulAddend;
|
||||
*pulAddend -= ulCount;
|
||||
}
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic increment
|
||||
*
|
||||
* @brief Atomically increments the value of the specified pointer points to.
|
||||
*
|
||||
* @param[in,out] pulAddend Pointer to memory location from where value is to be
|
||||
* loaded and written back to.
|
||||
*
|
||||
* @return *pulAddend value before increment.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_Increment_u32( uint32_t volatile * pulAddend )
|
||||
{
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
{
|
||||
ulCurrent = *pulAddend;
|
||||
*pulAddend += 1;
|
||||
}
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic decrement
|
||||
*
|
||||
* @brief Atomically decrements the value of the specified pointer points to
|
||||
*
|
||||
* @param[in,out] pulAddend Pointer to memory location from where value is to be
|
||||
* loaded and written back to.
|
||||
*
|
||||
* @return *pulAddend value before decrement.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_Decrement_u32( uint32_t volatile * pulAddend )
|
||||
{
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
{
|
||||
ulCurrent = *pulAddend;
|
||||
*pulAddend -= 1;
|
||||
}
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
}
|
||||
|
||||
/*----------------------------- Bitwise Logical ------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic OR
|
||||
*
|
||||
* @brief Performs an atomic OR operation on the specified values.
|
||||
*
|
||||
* @param [in, out] pulDestination Pointer to memory location from where value is
|
||||
* to be loaded and written back to.
|
||||
* @param [in] ulValue Value to be ORed with *pulDestination.
|
||||
*
|
||||
* @return The original value of *pulDestination.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_OR_u32( uint32_t volatile * pulDestination,
|
||||
uint32_t ulValue )
|
||||
{
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
{
|
||||
ulCurrent = *pulDestination;
|
||||
*pulDestination |= ulValue;
|
||||
}
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic AND
|
||||
*
|
||||
* @brief Performs an atomic AND operation on the specified values.
|
||||
*
|
||||
* @param [in, out] pulDestination Pointer to memory location from where value is
|
||||
* to be loaded and written back to.
|
||||
* @param [in] ulValue Value to be ANDed with *pulDestination.
|
||||
*
|
||||
* @return The original value of *pulDestination.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_AND_u32( uint32_t volatile * pulDestination,
|
||||
uint32_t ulValue )
|
||||
{
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
{
|
||||
ulCurrent = *pulDestination;
|
||||
*pulDestination &= ulValue;
|
||||
}
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic NAND
|
||||
*
|
||||
* @brief Performs an atomic NAND operation on the specified values.
|
||||
*
|
||||
* @param [in, out] pulDestination Pointer to memory location from where value is
|
||||
* to be loaded and written back to.
|
||||
* @param [in] ulValue Value to be NANDed with *pulDestination.
|
||||
*
|
||||
* @return The original value of *pulDestination.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_NAND_u32( uint32_t volatile * pulDestination,
|
||||
uint32_t ulValue )
|
||||
{
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
{
|
||||
ulCurrent = *pulDestination;
|
||||
*pulDestination = ~( ulCurrent & ulValue );
|
||||
}
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* Atomic XOR
|
||||
*
|
||||
* @brief Performs an atomic XOR operation on the specified values.
|
||||
*
|
||||
* @param [in, out] pulDestination Pointer to memory location from where value is
|
||||
* to be loaded and written back to.
|
||||
* @param [in] ulValue Value to be XORed with *pulDestination.
|
||||
*
|
||||
* @return The original value of *pulDestination.
|
||||
*/
|
||||
static portFORCE_INLINE uint32_t Atomic_XOR_u32( uint32_t volatile * pulDestination,
|
||||
uint32_t ulValue )
|
||||
{
|
||||
uint32_t ulCurrent;
|
||||
|
||||
ATOMIC_ENTER_CRITICAL();
|
||||
{
|
||||
ulCurrent = *pulDestination;
|
||||
*pulDestination ^= ulValue;
|
||||
}
|
||||
ATOMIC_EXIT_CRITICAL();
|
||||
|
||||
return ulCurrent;
|
||||
}
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
#endif /* ATOMIC_H */
|
||||
@@ -0,0 +1,765 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef CO_ROUTINE_H
|
||||
#define CO_ROUTINE_H
|
||||
|
||||
#ifndef INC_FREERTOS_H
|
||||
#error "include FreeRTOS.h must appear in source files before include croutine.h"
|
||||
#endif
|
||||
|
||||
#include "list.h"
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/* Used to hide the implementation of the co-routine control block. The
|
||||
* control block structure however has to be included in the header due to
|
||||
* the macro implementation of the co-routine functionality. */
|
||||
typedef void * CoRoutineHandle_t;
|
||||
|
||||
/* Defines the prototype to which co-routine functions must conform. */
|
||||
typedef void (* crCOROUTINE_CODE)( CoRoutineHandle_t xHandle,
|
||||
UBaseType_t uxIndex );
|
||||
|
||||
typedef struct corCoRoutineControlBlock
|
||||
{
|
||||
crCOROUTINE_CODE pxCoRoutineFunction;
|
||||
ListItem_t xGenericListItem; /**< List item used to place the CRCB in ready and blocked queues. */
|
||||
ListItem_t xEventListItem; /**< List item used to place the CRCB in event lists. */
|
||||
UBaseType_t uxPriority; /**< The priority of the co-routine in relation to other co-routines. */
|
||||
UBaseType_t uxIndex; /**< Used to distinguish between co-routines when multiple co-routines use the same co-routine function. */
|
||||
uint16_t uxState; /**< Used internally by the co-routine implementation. */
|
||||
} CRCB_t; /* Co-routine control block. Note must be identical in size down to uxPriority with TCB_t. */
|
||||
|
||||
/**
|
||||
* croutine. h
|
||||
* @code{c}
|
||||
* BaseType_t xCoRoutineCreate(
|
||||
* crCOROUTINE_CODE pxCoRoutineCode,
|
||||
* UBaseType_t uxPriority,
|
||||
* UBaseType_t uxIndex
|
||||
* );
|
||||
* @endcode
|
||||
*
|
||||
* Create a new co-routine and add it to the list of co-routines that are
|
||||
* ready to run.
|
||||
*
|
||||
* @param pxCoRoutineCode Pointer to the co-routine function. Co-routine
|
||||
* functions require special syntax - see the co-routine section of the WEB
|
||||
* documentation for more information.
|
||||
*
|
||||
* @param uxPriority The priority with respect to other co-routines at which
|
||||
* the co-routine will run.
|
||||
*
|
||||
* @param uxIndex Used to distinguish between different co-routines that
|
||||
* execute the same function. See the example below and the co-routine section
|
||||
* of the WEB documentation for further information.
|
||||
*
|
||||
* @return pdPASS if the co-routine was successfully created and added to a ready
|
||||
* list, otherwise an error code defined with ProjDefs.h.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* // Co-routine to be created.
|
||||
* void vFlashCoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
|
||||
* {
|
||||
* // Variables in co-routines must be declared static if they must maintain value across a blocking call.
|
||||
* // This may not be necessary for const variables.
|
||||
* static const char cLedToFlash[ 2 ] = { 5, 6 };
|
||||
* static const TickType_t uxFlashRates[ 2 ] = { 200, 400 };
|
||||
*
|
||||
* // Must start every co-routine with a call to crSTART();
|
||||
* crSTART( xHandle );
|
||||
*
|
||||
* for( ;; )
|
||||
* {
|
||||
* // This co-routine just delays for a fixed period, then toggles
|
||||
* // an LED. Two co-routines are created using this function, so
|
||||
* // the uxIndex parameter is used to tell the co-routine which
|
||||
* // LED to flash and how int32_t to delay. This assumes xQueue has
|
||||
* // already been created.
|
||||
* vParTestToggleLED( cLedToFlash[ uxIndex ] );
|
||||
* crDELAY( xHandle, uxFlashRates[ uxIndex ] );
|
||||
* }
|
||||
*
|
||||
* // Must end every co-routine with a call to crEND();
|
||||
* crEND();
|
||||
* }
|
||||
*
|
||||
* // Function that creates two co-routines.
|
||||
* void vOtherFunction( void )
|
||||
* {
|
||||
* uint8_t ucParameterToPass;
|
||||
* TaskHandle_t xHandle;
|
||||
*
|
||||
* // Create two co-routines at priority 0. The first is given index 0
|
||||
* // so (from the code above) toggles LED 5 every 200 ticks. The second
|
||||
* // is given index 1 so toggles LED 6 every 400 ticks.
|
||||
* for( uxIndex = 0; uxIndex < 2; uxIndex++ )
|
||||
* {
|
||||
* xCoRoutineCreate( vFlashCoRoutine, 0, uxIndex );
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup xCoRoutineCreate xCoRoutineCreate
|
||||
* \ingroup Tasks
|
||||
*/
|
||||
BaseType_t xCoRoutineCreate( crCOROUTINE_CODE pxCoRoutineCode,
|
||||
UBaseType_t uxPriority,
|
||||
UBaseType_t uxIndex );
|
||||
|
||||
|
||||
/**
|
||||
* croutine. h
|
||||
* @code{c}
|
||||
* void vCoRoutineSchedule( void );
|
||||
* @endcode
|
||||
*
|
||||
* Run a co-routine.
|
||||
*
|
||||
* vCoRoutineSchedule() executes the highest priority co-routine that is able
|
||||
* to run. The co-routine will execute until it either blocks, yields or is
|
||||
* preempted by a task. Co-routines execute cooperatively so one
|
||||
* co-routine cannot be preempted by another, but can be preempted by a task.
|
||||
*
|
||||
* If an application comprises of both tasks and co-routines then
|
||||
* vCoRoutineSchedule should be called from the idle task (in an idle task
|
||||
* hook).
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* // This idle task hook will schedule a co-routine each time it is called.
|
||||
* // The rest of the idle task will execute between co-routine calls.
|
||||
* void vApplicationIdleHook( void )
|
||||
* {
|
||||
* vCoRoutineSchedule();
|
||||
* }
|
||||
*
|
||||
* // Alternatively, if you do not require any other part of the idle task to
|
||||
* // execute, the idle task hook can call vCoRoutineSchedule() within an
|
||||
* // infinite loop.
|
||||
* void vApplicationIdleHook( void )
|
||||
* {
|
||||
* for( ;; )
|
||||
* {
|
||||
* vCoRoutineSchedule();
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup vCoRoutineSchedule vCoRoutineSchedule
|
||||
* \ingroup Tasks
|
||||
*/
|
||||
void vCoRoutineSchedule( void );
|
||||
|
||||
/**
|
||||
* croutine. h
|
||||
* @code{c}
|
||||
* crSTART( CoRoutineHandle_t xHandle );
|
||||
* @endcode
|
||||
*
|
||||
* This macro MUST always be called at the start of a co-routine function.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* // Co-routine to be created.
|
||||
* void vACoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
|
||||
* {
|
||||
* // Variables in co-routines must be declared static if they must maintain value across a blocking call.
|
||||
* static int32_t ulAVariable;
|
||||
*
|
||||
* // Must start every co-routine with a call to crSTART();
|
||||
* crSTART( xHandle );
|
||||
*
|
||||
* for( ;; )
|
||||
* {
|
||||
* // Co-routine functionality goes here.
|
||||
* }
|
||||
*
|
||||
* // Must end every co-routine with a call to crEND();
|
||||
* crEND();
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup crSTART crSTART
|
||||
* \ingroup Tasks
|
||||
*/
|
||||
#define crSTART( pxCRCB ) \
|
||||
switch( ( ( CRCB_t * ) ( pxCRCB ) )->uxState ) { \
|
||||
case 0:
|
||||
|
||||
/**
|
||||
* croutine. h
|
||||
* @code{c}
|
||||
* crEND();
|
||||
* @endcode
|
||||
*
|
||||
* This macro MUST always be called at the end of a co-routine function.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* // Co-routine to be created.
|
||||
* void vACoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
|
||||
* {
|
||||
* // Variables in co-routines must be declared static if they must maintain value across a blocking call.
|
||||
* static int32_t ulAVariable;
|
||||
*
|
||||
* // Must start every co-routine with a call to crSTART();
|
||||
* crSTART( xHandle );
|
||||
*
|
||||
* for( ;; )
|
||||
* {
|
||||
* // Co-routine functionality goes here.
|
||||
* }
|
||||
*
|
||||
* // Must end every co-routine with a call to crEND();
|
||||
* crEND();
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup crSTART crSTART
|
||||
* \ingroup Tasks
|
||||
*/
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#define crEND() }
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/*
|
||||
* These macros are intended for internal use by the co-routine implementation
|
||||
* only. The macros should not be used directly by application writers.
|
||||
*/
|
||||
#define crSET_STATE0( xHandle ) \
|
||||
( ( CRCB_t * ) ( xHandle ) )->uxState = ( __LINE__ * 2 ); return; \
|
||||
case ( __LINE__ * 2 ):
|
||||
#define crSET_STATE1( xHandle ) \
|
||||
( ( CRCB_t * ) ( xHandle ) )->uxState = ( ( __LINE__ * 2 ) + 1 ); return; \
|
||||
case ( ( __LINE__ * 2 ) + 1 ):
|
||||
|
||||
/**
|
||||
* croutine. h
|
||||
* @code{c}
|
||||
* crDELAY( CoRoutineHandle_t xHandle, TickType_t xTicksToDelay );
|
||||
* @endcode
|
||||
*
|
||||
* Delay a co-routine for a fixed period of time.
|
||||
*
|
||||
* crDELAY can only be called from the co-routine function itself - not
|
||||
* from within a function called by the co-routine function. This is because
|
||||
* co-routines do not maintain their own stack.
|
||||
*
|
||||
* @param xHandle The handle of the co-routine to delay. This is the xHandle
|
||||
* parameter of the co-routine function.
|
||||
*
|
||||
* @param xTickToDelay The number of ticks that the co-routine should delay
|
||||
* for. The actual amount of time this equates to is defined by
|
||||
* configTICK_RATE_HZ (set in FreeRTOSConfig.h). The constant portTICK_PERIOD_MS
|
||||
* can be used to convert ticks to milliseconds.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* // Co-routine to be created.
|
||||
* void vACoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
|
||||
* {
|
||||
* // Variables in co-routines must be declared static if they must maintain value across a blocking call.
|
||||
* // This may not be necessary for const variables.
|
||||
* // We are to delay for 200ms.
|
||||
* static const xTickType xDelayTime = 200 / portTICK_PERIOD_MS;
|
||||
*
|
||||
* // Must start every co-routine with a call to crSTART();
|
||||
* crSTART( xHandle );
|
||||
*
|
||||
* for( ;; )
|
||||
* {
|
||||
* // Delay for 200ms.
|
||||
* crDELAY( xHandle, xDelayTime );
|
||||
*
|
||||
* // Do something here.
|
||||
* }
|
||||
*
|
||||
* // Must end every co-routine with a call to crEND();
|
||||
* crEND();
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup crDELAY crDELAY
|
||||
* \ingroup Tasks
|
||||
*/
|
||||
#define crDELAY( xHandle, xTicksToDelay ) \
|
||||
do { \
|
||||
if( ( xTicksToDelay ) > 0 ) \
|
||||
{ \
|
||||
vCoRoutineAddToDelayedList( ( xTicksToDelay ), NULL ); \
|
||||
} \
|
||||
crSET_STATE0( ( xHandle ) ); \
|
||||
} while( 0 )
|
||||
|
||||
/**
|
||||
* @code{c}
|
||||
* crQUEUE_SEND(
|
||||
* CoRoutineHandle_t xHandle,
|
||||
* QueueHandle_t pxQueue,
|
||||
* void *pvItemToQueue,
|
||||
* TickType_t xTicksToWait,
|
||||
* BaseType_t *pxResult
|
||||
* )
|
||||
* @endcode
|
||||
*
|
||||
* The macro's crQUEUE_SEND() and crQUEUE_RECEIVE() are the co-routine
|
||||
* equivalent to the xQueueSend() and xQueueReceive() functions used by tasks.
|
||||
*
|
||||
* crQUEUE_SEND and crQUEUE_RECEIVE can only be used from a co-routine whereas
|
||||
* xQueueSend() and xQueueReceive() can only be used from tasks.
|
||||
*
|
||||
* crQUEUE_SEND can only be called from the co-routine function itself - not
|
||||
* from within a function called by the co-routine function. This is because
|
||||
* co-routines do not maintain their own stack.
|
||||
*
|
||||
* See the co-routine section of the WEB documentation for information on
|
||||
* passing data between tasks and co-routines and between ISR's and
|
||||
* co-routines.
|
||||
*
|
||||
* @param xHandle The handle of the calling co-routine. This is the xHandle
|
||||
* parameter of the co-routine function.
|
||||
*
|
||||
* @param pxQueue The handle of the queue on which the data will be posted.
|
||||
* The handle is obtained as the return value when the queue is created using
|
||||
* the xQueueCreate() API function.
|
||||
*
|
||||
* @param pvItemToQueue A pointer to the data being posted onto the queue.
|
||||
* The number of bytes of each queued item is specified when the queue is
|
||||
* created. This number of bytes is copied from pvItemToQueue into the queue
|
||||
* itself.
|
||||
*
|
||||
* @param xTickToDelay The number of ticks that the co-routine should block
|
||||
* to wait for space to become available on the queue, should space not be
|
||||
* available immediately. The actual amount of time this equates to is defined
|
||||
* by configTICK_RATE_HZ (set in FreeRTOSConfig.h). The constant
|
||||
* portTICK_PERIOD_MS can be used to convert ticks to milliseconds (see example
|
||||
* below).
|
||||
*
|
||||
* @param pxResult The variable pointed to by pxResult will be set to pdPASS if
|
||||
* data was successfully posted onto the queue, otherwise it will be set to an
|
||||
* error defined within ProjDefs.h.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* // Co-routine function that blocks for a fixed period then posts a number onto
|
||||
* // a queue.
|
||||
* static void prvCoRoutineFlashTask( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
|
||||
* {
|
||||
* // Variables in co-routines must be declared static if they must maintain value across a blocking call.
|
||||
* static BaseType_t xNumberToPost = 0;
|
||||
* static BaseType_t xResult;
|
||||
*
|
||||
* // Co-routines must begin with a call to crSTART().
|
||||
* crSTART( xHandle );
|
||||
*
|
||||
* for( ;; )
|
||||
* {
|
||||
* // This assumes the queue has already been created.
|
||||
* crQUEUE_SEND( xHandle, xCoRoutineQueue, &xNumberToPost, NO_DELAY, &xResult );
|
||||
*
|
||||
* if( xResult != pdPASS )
|
||||
* {
|
||||
* // The message was not posted!
|
||||
* }
|
||||
*
|
||||
* // Increment the number to be posted onto the queue.
|
||||
* xNumberToPost++;
|
||||
*
|
||||
* // Delay for 100 ticks.
|
||||
* crDELAY( xHandle, 100 );
|
||||
* }
|
||||
*
|
||||
* // Co-routines must end with a call to crEND().
|
||||
* crEND();
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup crQUEUE_SEND crQUEUE_SEND
|
||||
* \ingroup Tasks
|
||||
*/
|
||||
#define crQUEUE_SEND( xHandle, pxQueue, pvItemToQueue, xTicksToWait, pxResult ) \
|
||||
do { \
|
||||
*( pxResult ) = xQueueCRSend( ( pxQueue ), ( pvItemToQueue ), ( xTicksToWait ) ); \
|
||||
if( *( pxResult ) == errQUEUE_BLOCKED ) \
|
||||
{ \
|
||||
crSET_STATE0( ( xHandle ) ); \
|
||||
*pxResult = xQueueCRSend( ( pxQueue ), ( pvItemToQueue ), 0 ); \
|
||||
} \
|
||||
if( *pxResult == errQUEUE_YIELD ) \
|
||||
{ \
|
||||
crSET_STATE1( ( xHandle ) ); \
|
||||
*pxResult = pdPASS; \
|
||||
} \
|
||||
} while( 0 )
|
||||
|
||||
/**
|
||||
* croutine. h
|
||||
* @code{c}
|
||||
* crQUEUE_RECEIVE(
|
||||
* CoRoutineHandle_t xHandle,
|
||||
* QueueHandle_t pxQueue,
|
||||
* void *pvBuffer,
|
||||
* TickType_t xTicksToWait,
|
||||
* BaseType_t *pxResult
|
||||
* )
|
||||
* @endcode
|
||||
*
|
||||
* The macro's crQUEUE_SEND() and crQUEUE_RECEIVE() are the co-routine
|
||||
* equivalent to the xQueueSend() and xQueueReceive() functions used by tasks.
|
||||
*
|
||||
* crQUEUE_SEND and crQUEUE_RECEIVE can only be used from a co-routine whereas
|
||||
* xQueueSend() and xQueueReceive() can only be used from tasks.
|
||||
*
|
||||
* crQUEUE_RECEIVE can only be called from the co-routine function itself - not
|
||||
* from within a function called by the co-routine function. This is because
|
||||
* co-routines do not maintain their own stack.
|
||||
*
|
||||
* See the co-routine section of the WEB documentation for information on
|
||||
* passing data between tasks and co-routines and between ISR's and
|
||||
* co-routines.
|
||||
*
|
||||
* @param xHandle The handle of the calling co-routine. This is the xHandle
|
||||
* parameter of the co-routine function.
|
||||
*
|
||||
* @param pxQueue The handle of the queue from which the data will be received.
|
||||
* The handle is obtained as the return value when the queue is created using
|
||||
* the xQueueCreate() API function.
|
||||
*
|
||||
* @param pvBuffer The buffer into which the received item is to be copied.
|
||||
* The number of bytes of each queued item is specified when the queue is
|
||||
* created. This number of bytes is copied into pvBuffer.
|
||||
*
|
||||
* @param xTickToDelay The number of ticks that the co-routine should block
|
||||
* to wait for data to become available from the queue, should data not be
|
||||
* available immediately. The actual amount of time this equates to is defined
|
||||
* by configTICK_RATE_HZ (set in FreeRTOSConfig.h). The constant
|
||||
* portTICK_PERIOD_MS can be used to convert ticks to milliseconds (see the
|
||||
* crQUEUE_SEND example).
|
||||
*
|
||||
* @param pxResult The variable pointed to by pxResult will be set to pdPASS if
|
||||
* data was successfully retrieved from the queue, otherwise it will be set to
|
||||
* an error code as defined within ProjDefs.h.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* // A co-routine receives the number of an LED to flash from a queue. It
|
||||
* // blocks on the queue until the number is received.
|
||||
* static void prvCoRoutineFlashWorkTask( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
|
||||
* {
|
||||
* // Variables in co-routines must be declared static if they must maintain value across a blocking call.
|
||||
* static BaseType_t xResult;
|
||||
* static UBaseType_t uxLEDToFlash;
|
||||
*
|
||||
* // All co-routines must start with a call to crSTART().
|
||||
* crSTART( xHandle );
|
||||
*
|
||||
* for( ;; )
|
||||
* {
|
||||
* // Wait for data to become available on the queue.
|
||||
* crQUEUE_RECEIVE( xHandle, xCoRoutineQueue, &uxLEDToFlash, portMAX_DELAY, &xResult );
|
||||
*
|
||||
* if( xResult == pdPASS )
|
||||
* {
|
||||
* // We received the LED to flash - flash it!
|
||||
* vParTestToggleLED( uxLEDToFlash );
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* crEND();
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup crQUEUE_RECEIVE crQUEUE_RECEIVE
|
||||
* \ingroup Tasks
|
||||
*/
|
||||
#define crQUEUE_RECEIVE( xHandle, pxQueue, pvBuffer, xTicksToWait, pxResult ) \
|
||||
do { \
|
||||
*( pxResult ) = xQueueCRReceive( ( pxQueue ), ( pvBuffer ), ( xTicksToWait ) ); \
|
||||
if( *( pxResult ) == errQUEUE_BLOCKED ) \
|
||||
{ \
|
||||
crSET_STATE0( ( xHandle ) ); \
|
||||
*( pxResult ) = xQueueCRReceive( ( pxQueue ), ( pvBuffer ), 0 ); \
|
||||
} \
|
||||
if( *( pxResult ) == errQUEUE_YIELD ) \
|
||||
{ \
|
||||
crSET_STATE1( ( xHandle ) ); \
|
||||
*( pxResult ) = pdPASS; \
|
||||
} \
|
||||
} while( 0 )
|
||||
|
||||
/**
|
||||
* croutine. h
|
||||
* @code{c}
|
||||
* crQUEUE_SEND_FROM_ISR(
|
||||
* QueueHandle_t pxQueue,
|
||||
* void *pvItemToQueue,
|
||||
* BaseType_t xCoRoutinePreviouslyWoken
|
||||
* )
|
||||
* @endcode
|
||||
*
|
||||
* The macro's crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() are the
|
||||
* co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR()
|
||||
* functions used by tasks.
|
||||
*
|
||||
* crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() can only be used to
|
||||
* pass data between a co-routine and and ISR, whereas xQueueSendFromISR() and
|
||||
* xQueueReceiveFromISR() can only be used to pass data between a task and and
|
||||
* ISR.
|
||||
*
|
||||
* crQUEUE_SEND_FROM_ISR can only be called from an ISR to send data to a queue
|
||||
* that is being used from within a co-routine.
|
||||
*
|
||||
* See the co-routine section of the WEB documentation for information on
|
||||
* passing data between tasks and co-routines and between ISR's and
|
||||
* co-routines.
|
||||
*
|
||||
* @param xQueue The handle to the queue on which the item is to be posted.
|
||||
*
|
||||
* @param pvItemToQueue A pointer to the item that is to be placed on the
|
||||
* queue. The size of the items the queue will hold was defined when the
|
||||
* queue was created, so this many bytes will be copied from pvItemToQueue
|
||||
* into the queue storage area.
|
||||
*
|
||||
* @param xCoRoutinePreviouslyWoken This is included so an ISR can post onto
|
||||
* the same queue multiple times from a single interrupt. The first call
|
||||
* should always pass in pdFALSE. Subsequent calls should pass in
|
||||
* the value returned from the previous call.
|
||||
*
|
||||
* @return pdTRUE if a co-routine was woken by posting onto the queue. This is
|
||||
* used by the ISR to determine if a context switch may be required following
|
||||
* the ISR.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* // A co-routine that blocks on a queue waiting for characters to be received.
|
||||
* static void vReceivingCoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
|
||||
* {
|
||||
* char cRxedChar;
|
||||
* BaseType_t xResult;
|
||||
*
|
||||
* // All co-routines must start with a call to crSTART().
|
||||
* crSTART( xHandle );
|
||||
*
|
||||
* for( ;; )
|
||||
* {
|
||||
* // Wait for data to become available on the queue. This assumes the
|
||||
* // queue xCommsRxQueue has already been created!
|
||||
* crQUEUE_RECEIVE( xHandle, xCommsRxQueue, &uxLEDToFlash, portMAX_DELAY, &xResult );
|
||||
*
|
||||
* // Was a character received?
|
||||
* if( xResult == pdPASS )
|
||||
* {
|
||||
* // Process the character here.
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* // All co-routines must end with a call to crEND().
|
||||
* crEND();
|
||||
* }
|
||||
*
|
||||
* // An ISR that uses a queue to send characters received on a serial port to
|
||||
* // a co-routine.
|
||||
* void vUART_ISR( void )
|
||||
* {
|
||||
* char cRxedChar;
|
||||
* BaseType_t xCRWokenByPost = pdFALSE;
|
||||
*
|
||||
* // We loop around reading characters until there are none left in the UART.
|
||||
* while( UART_RX_REG_NOT_EMPTY() )
|
||||
* {
|
||||
* // Obtain the character from the UART.
|
||||
* cRxedChar = UART_RX_REG;
|
||||
*
|
||||
* // Post the character onto a queue. xCRWokenByPost will be pdFALSE
|
||||
* // the first time around the loop. If the post causes a co-routine
|
||||
* // to be woken (unblocked) then xCRWokenByPost will be set to pdTRUE.
|
||||
* // In this manner we can ensure that if more than one co-routine is
|
||||
* // blocked on the queue only one is woken by this ISR no matter how
|
||||
* // many characters are posted to the queue.
|
||||
* xCRWokenByPost = crQUEUE_SEND_FROM_ISR( xCommsRxQueue, &cRxedChar, xCRWokenByPost );
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup crQUEUE_SEND_FROM_ISR crQUEUE_SEND_FROM_ISR
|
||||
* \ingroup Tasks
|
||||
*/
|
||||
#define crQUEUE_SEND_FROM_ISR( pxQueue, pvItemToQueue, xCoRoutinePreviouslyWoken ) \
|
||||
xQueueCRSendFromISR( ( pxQueue ), ( pvItemToQueue ), ( xCoRoutinePreviouslyWoken ) )
|
||||
|
||||
|
||||
/**
|
||||
* croutine. h
|
||||
* @code{c}
|
||||
* crQUEUE_SEND_FROM_ISR(
|
||||
* QueueHandle_t pxQueue,
|
||||
* void *pvBuffer,
|
||||
* BaseType_t * pxCoRoutineWoken
|
||||
* )
|
||||
* @endcode
|
||||
*
|
||||
* The macro's crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() are the
|
||||
* co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR()
|
||||
* functions used by tasks.
|
||||
*
|
||||
* crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() can only be used to
|
||||
* pass data between a co-routine and and ISR, whereas xQueueSendFromISR() and
|
||||
* xQueueReceiveFromISR() can only be used to pass data between a task and and
|
||||
* ISR.
|
||||
*
|
||||
* crQUEUE_RECEIVE_FROM_ISR can only be called from an ISR to receive data
|
||||
* from a queue that is being used from within a co-routine (a co-routine
|
||||
* posted to the queue).
|
||||
*
|
||||
* See the co-routine section of the WEB documentation for information on
|
||||
* passing data between tasks and co-routines and between ISR's and
|
||||
* co-routines.
|
||||
*
|
||||
* @param xQueue The handle to the queue on which the item is to be posted.
|
||||
*
|
||||
* @param pvBuffer A pointer to a buffer into which the received item will be
|
||||
* placed. The size of the items the queue will hold was defined when the
|
||||
* queue was created, so this many bytes will be copied from the queue into
|
||||
* pvBuffer.
|
||||
*
|
||||
* @param pxCoRoutineWoken A co-routine may be blocked waiting for space to become
|
||||
* available on the queue. If crQUEUE_RECEIVE_FROM_ISR causes such a
|
||||
* co-routine to unblock *pxCoRoutineWoken will get set to pdTRUE, otherwise
|
||||
* *pxCoRoutineWoken will remain unchanged.
|
||||
*
|
||||
* @return pdTRUE an item was successfully received from the queue, otherwise
|
||||
* pdFALSE.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* // A co-routine that posts a character to a queue then blocks for a fixed
|
||||
* // period. The character is incremented each time.
|
||||
* static void vSendingCoRoutine( CoRoutineHandle_t xHandle, UBaseType_t uxIndex )
|
||||
* {
|
||||
* // cChar holds its value while this co-routine is blocked and must therefore
|
||||
* // be declared static.
|
||||
* static char cCharToTx = 'a';
|
||||
* BaseType_t xResult;
|
||||
*
|
||||
* // All co-routines must start with a call to crSTART().
|
||||
* crSTART( xHandle );
|
||||
*
|
||||
* for( ;; )
|
||||
* {
|
||||
* // Send the next character to the queue.
|
||||
* crQUEUE_SEND( xHandle, xCoRoutineQueue, &cCharToTx, NO_DELAY, &xResult );
|
||||
*
|
||||
* if( xResult == pdPASS )
|
||||
* {
|
||||
* // The character was successfully posted to the queue.
|
||||
* }
|
||||
* else
|
||||
* {
|
||||
* // Could not post the character to the queue.
|
||||
* }
|
||||
*
|
||||
* // Enable the UART Tx interrupt to cause an interrupt in this
|
||||
* // hypothetical UART. The interrupt will obtain the character
|
||||
* // from the queue and send it.
|
||||
* ENABLE_RX_INTERRUPT();
|
||||
*
|
||||
* // Increment to the next character then block for a fixed period.
|
||||
* // cCharToTx will maintain its value across the delay as it is
|
||||
* // declared static.
|
||||
* cCharToTx++;
|
||||
* if( cCharToTx > 'x' )
|
||||
* {
|
||||
* cCharToTx = 'a';
|
||||
* }
|
||||
* crDELAY( 100 );
|
||||
* }
|
||||
*
|
||||
* // All co-routines must end with a call to crEND().
|
||||
* crEND();
|
||||
* }
|
||||
*
|
||||
* // An ISR that uses a queue to receive characters to send on a UART.
|
||||
* void vUART_ISR( void )
|
||||
* {
|
||||
* char cCharToTx;
|
||||
* BaseType_t xCRWokenByPost = pdFALSE;
|
||||
*
|
||||
* while( UART_TX_REG_EMPTY() )
|
||||
* {
|
||||
* // Are there any characters in the queue waiting to be sent?
|
||||
* // xCRWokenByPost will automatically be set to pdTRUE if a co-routine
|
||||
* // is woken by the post - ensuring that only a single co-routine is
|
||||
* // woken no matter how many times we go around this loop.
|
||||
* if( crQUEUE_RECEIVE_FROM_ISR( pxQueue, &cCharToTx, &xCRWokenByPost ) )
|
||||
* {
|
||||
* SEND_CHARACTER( cCharToTx );
|
||||
* }
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup crQUEUE_RECEIVE_FROM_ISR crQUEUE_RECEIVE_FROM_ISR
|
||||
* \ingroup Tasks
|
||||
*/
|
||||
#define crQUEUE_RECEIVE_FROM_ISR( pxQueue, pvBuffer, pxCoRoutineWoken ) \
|
||||
xQueueCRReceiveFromISR( ( pxQueue ), ( pvBuffer ), ( pxCoRoutineWoken ) )
|
||||
|
||||
/*
|
||||
* This function is intended for internal use by the co-routine macros only.
|
||||
* The macro nature of the co-routine implementation requires that the
|
||||
* prototype appears here. The function should not be used by application
|
||||
* writers.
|
||||
*
|
||||
* Removes the current co-routine from its ready list and places it in the
|
||||
* appropriate delayed list.
|
||||
*/
|
||||
void vCoRoutineAddToDelayedList( TickType_t xTicksToDelay,
|
||||
List_t * pxEventList );
|
||||
|
||||
/*
|
||||
* This function is intended for internal use by the queue implementation only.
|
||||
* The function should not be used by application writers.
|
||||
*
|
||||
* Removes the highest priority co-routine from the event list and places it in
|
||||
* the pending ready list.
|
||||
*/
|
||||
BaseType_t xCoRoutineRemoveFromEventList( const List_t * pxEventList );
|
||||
|
||||
|
||||
/*
|
||||
* This function resets the internal state of the coroutine module. It must be
|
||||
* called by the application before restarting the scheduler.
|
||||
*/
|
||||
void vCoRoutineResetState( void ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
#endif /* CO_ROUTINE_H */
|
||||
+281
@@ -0,0 +1,281 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef DEPRECATED_DEFINITIONS_H
|
||||
#define DEPRECATED_DEFINITIONS_H
|
||||
|
||||
|
||||
/* Each FreeRTOS port has a unique portmacro.h header file. Originally a
|
||||
* pre-processor definition was used to ensure the pre-processor found the correct
|
||||
* portmacro.h file for the port being used. That scheme was deprecated in favour
|
||||
* of setting the compiler's include path such that it found the correct
|
||||
* portmacro.h file - removing the need for the constant and allowing the
|
||||
* portmacro.h file to be located anywhere in relation to the port being used. The
|
||||
* definitions below remain in the code for backward compatibility only. New
|
||||
* projects should not use them. */
|
||||
|
||||
#ifdef OPEN_WATCOM_INDUSTRIAL_PC_PORT
|
||||
#include "..\..\Source\portable\owatcom\16bitdos\pc\portmacro.h"
|
||||
typedef void ( __interrupt __far * pxISR )();
|
||||
#endif
|
||||
|
||||
#ifdef OPEN_WATCOM_FLASH_LITE_186_PORT
|
||||
#include "..\..\Source\portable\owatcom\16bitdos\flsh186\portmacro.h"
|
||||
typedef void ( __interrupt __far * pxISR )();
|
||||
#endif
|
||||
|
||||
#ifdef GCC_MEGA_AVR
|
||||
#include "../portable/GCC/ATMega323/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef IAR_MEGA_AVR
|
||||
#include "../portable/IAR/ATMega323/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef MPLAB_PIC24_PORT
|
||||
#include "../../Source/portable/MPLAB/PIC24_dsPIC/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef MPLAB_DSPIC_PORT
|
||||
#include "../../Source/portable/MPLAB/PIC24_dsPIC/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef MPLAB_PIC18F_PORT
|
||||
#include "../../Source/portable/MPLAB/PIC18F/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef MPLAB_PIC32MX_PORT
|
||||
#include "../../Source/portable/MPLAB/PIC32MX/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef _FEDPICC
|
||||
#include "libFreeRTOS/Include/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef SDCC_CYGNAL
|
||||
#include "../../Source/portable/SDCC/Cygnal/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef GCC_ARM7
|
||||
#include "../../Source/portable/GCC/ARM7_LPC2000/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef GCC_ARM7_ECLIPSE
|
||||
#include "portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef ROWLEY_LPC23xx
|
||||
#include "../../Source/portable/GCC/ARM7_LPC23xx/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef IAR_MSP430
|
||||
#include "..\..\Source\portable\IAR\MSP430\portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef GCC_MSP430
|
||||
#include "../../Source/portable/GCC/MSP430F449/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef ROWLEY_MSP430
|
||||
#include "../../Source/portable/Rowley/MSP430F449/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef ARM7_LPC21xx_KEIL_RVDS
|
||||
#include "..\..\Source\portable\RVDS\ARM7_LPC21xx\portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef SAM7_GCC
|
||||
#include "../../Source/portable/GCC/ARM7_AT91SAM7S/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef SAM7_IAR
|
||||
#include "..\..\Source\portable\IAR\AtmelSAM7S64\portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef SAM9XE_IAR
|
||||
#include "..\..\Source\portable\IAR\AtmelSAM9XE\portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef LPC2000_IAR
|
||||
#include "..\..\Source\portable\IAR\LPC2000\portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef STR71X_IAR
|
||||
#include "..\..\Source\portable\IAR\STR71x\portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef STR75X_IAR
|
||||
#include "..\..\Source\portable\IAR\STR75x\portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef STR75X_GCC
|
||||
#include "..\..\Source\portable\GCC\STR75x\portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef STR91X_IAR
|
||||
#include "..\..\Source\portable\IAR\STR91x\portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef GCC_H8S
|
||||
#include "../../Source/portable/GCC/H8S2329/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef GCC_AT91FR40008
|
||||
#include "../../Source/portable/GCC/ARM7_AT91FR40008/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef RVDS_ARMCM3_LM3S102
|
||||
#include "../../Source/portable/RVDS/ARM_CM3/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef GCC_ARMCM3_LM3S102
|
||||
#include "../../Source/portable/GCC/ARM_CM3/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef GCC_ARMCM3
|
||||
#include "../../Source/portable/GCC/ARM_CM3/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef IAR_ARM_CM3
|
||||
#include "../../Source/portable/IAR/ARM_CM3/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef IAR_ARMCM3_LM
|
||||
#include "../../Source/portable/IAR/ARM_CM3/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef HCS12_CODE_WARRIOR
|
||||
#include "../../Source/portable/CodeWarrior/HCS12/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef MICROBLAZE_GCC
|
||||
#include "../../Source/portable/GCC/MicroBlaze/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef TERN_EE
|
||||
#include "..\..\Source\portable\Paradigm\Tern_EE\small\portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef GCC_HCS12
|
||||
#include "../../Source/portable/GCC/HCS12/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef GCC_MCF5235
|
||||
#include "../../Source/portable/GCC/MCF5235/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef COLDFIRE_V2_GCC
|
||||
#include "../../../Source/portable/GCC/ColdFire_V2/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef COLDFIRE_V2_CODEWARRIOR
|
||||
#include "../../Source/portable/CodeWarrior/ColdFire_V2/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef GCC_PPC405
|
||||
#include "../../Source/portable/GCC/PPC405_Xilinx/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef GCC_PPC440
|
||||
#include "../../Source/portable/GCC/PPC440_Xilinx/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef _16FX_SOFTUNE
|
||||
#include "..\..\Source\portable\Softune\MB96340\portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef BCC_INDUSTRIAL_PC_PORT
|
||||
|
||||
/* A short file name has to be used in place of the normal
|
||||
* FreeRTOSConfig.h when using the Borland compiler. */
|
||||
#include "frconfig.h"
|
||||
#include "..\portable\BCC\16BitDOS\PC\prtmacro.h"
|
||||
typedef void ( __interrupt __far * pxISR )();
|
||||
#endif
|
||||
|
||||
#ifdef BCC_FLASH_LITE_186_PORT
|
||||
|
||||
/* A short file name has to be used in place of the normal
|
||||
* FreeRTOSConfig.h when using the Borland compiler. */
|
||||
#include "frconfig.h"
|
||||
#include "..\portable\BCC\16BitDOS\flsh186\prtmacro.h"
|
||||
typedef void ( __interrupt __far * pxISR )();
|
||||
#endif
|
||||
|
||||
#ifdef __GNUC__
|
||||
#ifdef __AVR32_AVR32A__
|
||||
#include "portmacro.h"
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __ICCAVR32__
|
||||
#ifdef __CORE__
|
||||
#if __CORE__ == __AVR32A__
|
||||
#include "portmacro.h"
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __91467D
|
||||
#include "portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef __96340
|
||||
#include "portmacro.h"
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __IAR_V850ES_Fx3__
|
||||
#include "../../Source/portable/IAR/V850ES/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef __IAR_V850ES_Jx3__
|
||||
#include "../../Source/portable/IAR/V850ES/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef __IAR_V850ES_Jx3_L__
|
||||
#include "../../Source/portable/IAR/V850ES/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef __IAR_V850ES_Jx2__
|
||||
#include "../../Source/portable/IAR/V850ES/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef __IAR_V850ES_Hx2__
|
||||
#include "../../Source/portable/IAR/V850ES/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef __IAR_78K0R_Kx3__
|
||||
#include "../../Source/portable/IAR/78K0R/portmacro.h"
|
||||
#endif
|
||||
|
||||
#ifdef __IAR_78K0R_Kx3L__
|
||||
#include "../../Source/portable/IAR/78K0R/portmacro.h"
|
||||
#endif
|
||||
|
||||
#endif /* DEPRECATED_DEFINITIONS_H */
|
||||
+848
@@ -0,0 +1,848 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef EVENT_GROUPS_H
|
||||
#define EVENT_GROUPS_H
|
||||
|
||||
#ifndef INC_FREERTOS_H
|
||||
#error "include FreeRTOS.h" must appear in source files before "include event_groups.h"
|
||||
#endif
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "timers.h"
|
||||
|
||||
/* The following bit fields convey control information in a task's event list
|
||||
* item value. It is important they don't clash with the
|
||||
* taskEVENT_LIST_ITEM_VALUE_IN_USE definition. */
|
||||
#if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS )
|
||||
#define eventCLEAR_EVENTS_ON_EXIT_BIT ( ( uint16_t ) 0x0100U )
|
||||
#define eventUNBLOCKED_DUE_TO_BIT_SET ( ( uint16_t ) 0x0200U )
|
||||
#define eventWAIT_FOR_ALL_BITS ( ( uint16_t ) 0x0400U )
|
||||
#define eventEVENT_BITS_CONTROL_BYTES ( ( uint16_t ) 0xff00U )
|
||||
#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_32_BITS )
|
||||
#define eventCLEAR_EVENTS_ON_EXIT_BIT ( ( uint32_t ) 0x01000000U )
|
||||
#define eventUNBLOCKED_DUE_TO_BIT_SET ( ( uint32_t ) 0x02000000U )
|
||||
#define eventWAIT_FOR_ALL_BITS ( ( uint32_t ) 0x04000000U )
|
||||
#define eventEVENT_BITS_CONTROL_BYTES ( ( uint32_t ) 0xff000000U )
|
||||
#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_64_BITS )
|
||||
#define eventCLEAR_EVENTS_ON_EXIT_BIT ( ( uint64_t ) 0x0100000000000000U )
|
||||
#define eventUNBLOCKED_DUE_TO_BIT_SET ( ( uint64_t ) 0x0200000000000000U )
|
||||
#define eventWAIT_FOR_ALL_BITS ( ( uint64_t ) 0x0400000000000000U )
|
||||
#define eventEVENT_BITS_CONTROL_BYTES ( ( uint64_t ) 0xff00000000000000U )
|
||||
#endif /* if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS ) */
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/**
|
||||
* An event group is a collection of bits to which an application can assign a
|
||||
* meaning. For example, an application may create an event group to convey
|
||||
* the status of various CAN bus related events in which bit 0 might mean "A CAN
|
||||
* message has been received and is ready for processing", bit 1 might mean "The
|
||||
* application has queued a message that is ready for sending onto the CAN
|
||||
* network", and bit 2 might mean "It is time to send a SYNC message onto the
|
||||
* CAN network" etc. A task can then test the bit values to see which events
|
||||
* are active, and optionally enter the Blocked state to wait for a specified
|
||||
* bit or a group of specified bits to be active. To continue the CAN bus
|
||||
* example, a CAN controlling task can enter the Blocked state (and therefore
|
||||
* not consume any processing time) until either bit 0, bit 1 or bit 2 are
|
||||
* active, at which time the bit that was actually active would inform the task
|
||||
* which action it had to take (process a received message, send a message, or
|
||||
* send a SYNC).
|
||||
*
|
||||
* The event groups implementation contains intelligence to avoid race
|
||||
* conditions that would otherwise occur were an application to use a simple
|
||||
* variable for the same purpose. This is particularly important with respect
|
||||
* to when a bit within an event group is to be cleared, and when bits have to
|
||||
* be set and then tested atomically - as is the case where event groups are
|
||||
* used to create a synchronisation point between multiple tasks (a
|
||||
* 'rendezvous').
|
||||
*/
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
*
|
||||
* Type by which event groups are referenced. For example, a call to
|
||||
* xEventGroupCreate() returns an EventGroupHandle_t variable that can then
|
||||
* be used as a parameter to other event group functions.
|
||||
*
|
||||
* \defgroup EventGroupHandle_t EventGroupHandle_t
|
||||
* \ingroup EventGroup
|
||||
*/
|
||||
struct EventGroupDef_t;
|
||||
typedef struct EventGroupDef_t * EventGroupHandle_t;
|
||||
|
||||
/*
|
||||
* The type that holds event bits always matches TickType_t - therefore the
|
||||
* number of bits it holds is set by configTICK_TYPE_WIDTH_IN_BITS (16 bits if set to 0,
|
||||
* 32 bits if set to 1, 64 bits if set to 2.
|
||||
*
|
||||
* \defgroup EventBits_t EventBits_t
|
||||
* \ingroup EventGroup
|
||||
*/
|
||||
typedef TickType_t EventBits_t;
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
* @code{c}
|
||||
* EventGroupHandle_t xEventGroupCreate( void );
|
||||
* @endcode
|
||||
*
|
||||
* Create a new event group.
|
||||
*
|
||||
* Internally, within the FreeRTOS implementation, event groups use a [small]
|
||||
* block of memory, in which the event group's structure is stored. If an event
|
||||
* groups is created using xEventGroupCreate() then the required memory is
|
||||
* automatically dynamically allocated inside the xEventGroupCreate() function.
|
||||
* (see https://www.FreeRTOS.org/a00111.html). If an event group is created
|
||||
* using xEventGroupCreateStatic() then the application writer must instead
|
||||
* provide the memory that will get used by the event group.
|
||||
* xEventGroupCreateStatic() therefore allows an event group to be created
|
||||
* without using any dynamic memory allocation.
|
||||
*
|
||||
* Although event groups are not related to ticks, for internal implementation
|
||||
* reasons the number of bits available for use in an event group is dependent
|
||||
* on the configTICK_TYPE_WIDTH_IN_BITS setting in FreeRTOSConfig.h. If
|
||||
* configTICK_TYPE_WIDTH_IN_BITS is 0 then each event group contains 8 usable bits (bit
|
||||
* 0 to bit 7). If configTICK_TYPE_WIDTH_IN_BITS is set to 1 then each event group has
|
||||
* 24 usable bits (bit 0 to bit 23). If configTICK_TYPE_WIDTH_IN_BITS is set to 2 then
|
||||
* each event group has 56 usable bits (bit 0 to bit 53). The EventBits_t type
|
||||
* is used to store event bits within an event group.
|
||||
*
|
||||
* The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupCreate()
|
||||
* to be available.
|
||||
*
|
||||
* @return If the event group was created then a handle to the event group is
|
||||
* returned. If there was insufficient FreeRTOS heap available to create the
|
||||
* event group then NULL is returned. See https://www.FreeRTOS.org/a00111.html
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* // Declare a variable to hold the created event group.
|
||||
* EventGroupHandle_t xCreatedEventGroup;
|
||||
*
|
||||
* // Attempt to create the event group.
|
||||
* xCreatedEventGroup = xEventGroupCreate();
|
||||
*
|
||||
* // Was the event group created successfully?
|
||||
* if( xCreatedEventGroup == NULL )
|
||||
* {
|
||||
* // The event group was not created because there was insufficient
|
||||
* // FreeRTOS heap available.
|
||||
* }
|
||||
* else
|
||||
* {
|
||||
* // The event group was created.
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup xEventGroupCreate xEventGroupCreate
|
||||
* \ingroup EventGroup
|
||||
*/
|
||||
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
|
||||
EventGroupHandle_t xEventGroupCreate( void ) PRIVILEGED_FUNCTION;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
* @code{c}
|
||||
* EventGroupHandle_t xEventGroupCreateStatic( EventGroupHandle_t * pxEventGroupBuffer );
|
||||
* @endcode
|
||||
*
|
||||
* Create a new event group.
|
||||
*
|
||||
* Internally, within the FreeRTOS implementation, event groups use a [small]
|
||||
* block of memory, in which the event group's structure is stored. If an event
|
||||
* groups is created using xEventGroupCreate() then the required memory is
|
||||
* automatically dynamically allocated inside the xEventGroupCreate() function.
|
||||
* (see https://www.FreeRTOS.org/a00111.html). If an event group is created
|
||||
* using xEventGroupCreateStatic() then the application writer must instead
|
||||
* provide the memory that will get used by the event group.
|
||||
* xEventGroupCreateStatic() therefore allows an event group to be created
|
||||
* without using any dynamic memory allocation.
|
||||
*
|
||||
* Although event groups are not related to ticks, for internal implementation
|
||||
* reasons the number of bits available for use in an event group is dependent
|
||||
* on the configTICK_TYPE_WIDTH_IN_BITS setting in FreeRTOSConfig.h. If
|
||||
* configTICK_TYPE_WIDTH_IN_BITS is 0 then each event group contains 8 usable bits (bit
|
||||
* 0 to bit 7). If configTICK_TYPE_WIDTH_IN_BITS is set to 1 then each event group has
|
||||
* 24 usable bits (bit 0 to bit 23). If configTICK_TYPE_WIDTH_IN_BITS is set to 2 then
|
||||
* each event group has 56 usable bits (bit 0 to bit 53). The EventBits_t type
|
||||
* is used to store event bits within an event group.
|
||||
*
|
||||
* The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupCreateStatic()
|
||||
* to be available.
|
||||
*
|
||||
* @param pxEventGroupBuffer pxEventGroupBuffer must point to a variable of type
|
||||
* StaticEventGroup_t, which will be then be used to hold the event group's data
|
||||
* structures, removing the need for the memory to be allocated dynamically.
|
||||
*
|
||||
* @return If the event group was created then a handle to the event group is
|
||||
* returned. If pxEventGroupBuffer was NULL then NULL is returned.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* // StaticEventGroup_t is a publicly accessible structure that has the same
|
||||
* // size and alignment requirements as the real event group structure. It is
|
||||
* // provided as a mechanism for applications to know the size of the event
|
||||
* // group (which is dependent on the architecture and configuration file
|
||||
* // settings) without breaking the strict data hiding policy by exposing the
|
||||
* // real event group internals. This StaticEventGroup_t variable is passed
|
||||
* // into the xSemaphoreCreateEventGroupStatic() function and is used to store
|
||||
* // the event group's data structures
|
||||
* StaticEventGroup_t xEventGroupBuffer;
|
||||
*
|
||||
* // Create the event group without dynamically allocating any memory.
|
||||
* xEventGroup = xEventGroupCreateStatic( &xEventGroupBuffer );
|
||||
* @endcode
|
||||
*/
|
||||
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
|
||||
EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) PRIVILEGED_FUNCTION;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
* @code{c}
|
||||
* EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
|
||||
* const EventBits_t uxBitsToWaitFor,
|
||||
* const BaseType_t xClearOnExit,
|
||||
* const BaseType_t xWaitForAllBits,
|
||||
* const TickType_t xTicksToWait );
|
||||
* @endcode
|
||||
*
|
||||
* [Potentially] block to wait for one or more bits to be set within a
|
||||
* previously created event group.
|
||||
*
|
||||
* This function cannot be called from an interrupt.
|
||||
*
|
||||
* The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupWaitBits()
|
||||
* to be available.
|
||||
*
|
||||
* @param xEventGroup The event group in which the bits are being tested. The
|
||||
* event group must have previously been created using a call to
|
||||
* xEventGroupCreate().
|
||||
*
|
||||
* @param uxBitsToWaitFor A bitwise value that indicates the bit or bits to test
|
||||
* inside the event group. For example, to wait for bit 0 and/or bit 2 set
|
||||
* uxBitsToWaitFor to 0x05. To wait for bits 0 and/or bit 1 and/or bit 2 set
|
||||
* uxBitsToWaitFor to 0x07. Etc.
|
||||
*
|
||||
* @param xClearOnExit If xClearOnExit is set to pdTRUE then any bits within
|
||||
* uxBitsToWaitFor that are set within the event group will be cleared before
|
||||
* xEventGroupWaitBits() returns if the wait condition was met (if the function
|
||||
* returns for a reason other than a timeout). If xClearOnExit is set to
|
||||
* pdFALSE then the bits set in the event group are not altered when the call to
|
||||
* xEventGroupWaitBits() returns.
|
||||
*
|
||||
* @param xWaitForAllBits If xWaitForAllBits is set to pdTRUE then
|
||||
* xEventGroupWaitBits() will return when either all the bits in uxBitsToWaitFor
|
||||
* are set or the specified block time expires. If xWaitForAllBits is set to
|
||||
* pdFALSE then xEventGroupWaitBits() will return when any one of the bits set
|
||||
* in uxBitsToWaitFor is set or the specified block time expires. The block
|
||||
* time is specified by the xTicksToWait parameter.
|
||||
*
|
||||
* @param xTicksToWait The maximum amount of time (specified in 'ticks') to wait
|
||||
* for one/all (depending on the xWaitForAllBits value) of the bits specified by
|
||||
* uxBitsToWaitFor to become set. A value of portMAX_DELAY can be used to block
|
||||
* indefinitely (provided INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h).
|
||||
*
|
||||
* @return The value of the event group at the time either the bits being waited
|
||||
* for became set, or the block time expired. Test the return value to know
|
||||
* which bits were set. If xEventGroupWaitBits() returned because its timeout
|
||||
* expired then not all the bits being waited for will be set. If
|
||||
* xEventGroupWaitBits() returned because the bits it was waiting for were set
|
||||
* then the returned value is the event group value before any bits were
|
||||
* automatically cleared in the case that xClearOnExit parameter was set to
|
||||
* pdTRUE.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* #define BIT_0 ( 1 << 0 )
|
||||
* #define BIT_4 ( 1 << 4 )
|
||||
*
|
||||
* void aFunction( EventGroupHandle_t xEventGroup )
|
||||
* {
|
||||
* EventBits_t uxBits;
|
||||
* const TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;
|
||||
*
|
||||
* // Wait a maximum of 100ms for either bit 0 or bit 4 to be set within
|
||||
* // the event group. Clear the bits before exiting.
|
||||
* uxBits = xEventGroupWaitBits(
|
||||
* xEventGroup, // The event group being tested.
|
||||
* BIT_0 | BIT_4, // The bits within the event group to wait for.
|
||||
* pdTRUE, // BIT_0 and BIT_4 should be cleared before returning.
|
||||
* pdFALSE, // Don't wait for both bits, either bit will do.
|
||||
* xTicksToWait ); // Wait a maximum of 100ms for either bit to be set.
|
||||
*
|
||||
* if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
|
||||
* {
|
||||
* // xEventGroupWaitBits() returned because both bits were set.
|
||||
* }
|
||||
* else if( ( uxBits & BIT_0 ) != 0 )
|
||||
* {
|
||||
* // xEventGroupWaitBits() returned because just BIT_0 was set.
|
||||
* }
|
||||
* else if( ( uxBits & BIT_4 ) != 0 )
|
||||
* {
|
||||
* // xEventGroupWaitBits() returned because just BIT_4 was set.
|
||||
* }
|
||||
* else
|
||||
* {
|
||||
* // xEventGroupWaitBits() returned because xTicksToWait ticks passed
|
||||
* // without either BIT_0 or BIT_4 becoming set.
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup xEventGroupWaitBits xEventGroupWaitBits
|
||||
* \ingroup EventGroup
|
||||
*/
|
||||
EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToWaitFor,
|
||||
const BaseType_t xClearOnExit,
|
||||
const BaseType_t xWaitForAllBits,
|
||||
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
* @code{c}
|
||||
* EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear );
|
||||
* @endcode
|
||||
*
|
||||
* Clear bits within an event group. This function cannot be called from an
|
||||
* interrupt.
|
||||
*
|
||||
* The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupClearBits()
|
||||
* to be available.
|
||||
*
|
||||
* @param xEventGroup The event group in which the bits are to be cleared.
|
||||
*
|
||||
* @param uxBitsToClear A bitwise value that indicates the bit or bits to clear
|
||||
* in the event group. For example, to clear bit 3 only, set uxBitsToClear to
|
||||
* 0x08. To clear bit 3 and bit 0 set uxBitsToClear to 0x09.
|
||||
*
|
||||
* @return The value of the event group before the specified bits were cleared.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* #define BIT_0 ( 1 << 0 )
|
||||
* #define BIT_4 ( 1 << 4 )
|
||||
*
|
||||
* void aFunction( EventGroupHandle_t xEventGroup )
|
||||
* {
|
||||
* EventBits_t uxBits;
|
||||
*
|
||||
* // Clear bit 0 and bit 4 in xEventGroup.
|
||||
* uxBits = xEventGroupClearBits(
|
||||
* xEventGroup, // The event group being updated.
|
||||
* BIT_0 | BIT_4 );// The bits being cleared.
|
||||
*
|
||||
* if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
|
||||
* {
|
||||
* // Both bit 0 and bit 4 were set before xEventGroupClearBits() was
|
||||
* // called. Both will now be clear (not set).
|
||||
* }
|
||||
* else if( ( uxBits & BIT_0 ) != 0 )
|
||||
* {
|
||||
* // Bit 0 was set before xEventGroupClearBits() was called. It will
|
||||
* // now be clear.
|
||||
* }
|
||||
* else if( ( uxBits & BIT_4 ) != 0 )
|
||||
* {
|
||||
* // Bit 4 was set before xEventGroupClearBits() was called. It will
|
||||
* // now be clear.
|
||||
* }
|
||||
* else
|
||||
* {
|
||||
* // Neither bit 0 nor bit 4 were set in the first place.
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup xEventGroupClearBits xEventGroupClearBits
|
||||
* \ingroup EventGroup
|
||||
*/
|
||||
EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToClear ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
* @code{c}
|
||||
* BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
|
||||
* @endcode
|
||||
*
|
||||
* A version of xEventGroupClearBits() that can be called from an interrupt.
|
||||
*
|
||||
* Setting bits in an event group is not a deterministic operation because there
|
||||
* are an unknown number of tasks that may be waiting for the bit or bits being
|
||||
* set. FreeRTOS does not allow nondeterministic operations to be performed
|
||||
* while interrupts are disabled, so protects event groups that are accessed
|
||||
* from tasks by suspending the scheduler rather than disabling interrupts. As
|
||||
* a result event groups cannot be accessed directly from an interrupt service
|
||||
* routine. Therefore xEventGroupClearBitsFromISR() sends a message to the
|
||||
* timer task to have the clear operation performed in the context of the timer
|
||||
* task.
|
||||
*
|
||||
* @note If this function returns pdPASS then the timer task is ready to run
|
||||
* and a portYIELD_FROM_ISR(pdTRUE) should be executed to perform the needed
|
||||
* clear on the event group. This behavior is different from
|
||||
* xEventGroupSetBitsFromISR because the parameter xHigherPriorityTaskWoken is
|
||||
* not present.
|
||||
*
|
||||
* @param xEventGroup The event group in which the bits are to be cleared.
|
||||
*
|
||||
* @param uxBitsToClear A bitwise value that indicates the bit or bits to clear.
|
||||
* For example, to clear bit 3 only, set uxBitsToClear to 0x08. To clear bit 3
|
||||
* and bit 0 set uxBitsToClear to 0x09.
|
||||
*
|
||||
* @return If the request to execute the function was posted successfully then
|
||||
* pdPASS is returned, otherwise pdFALSE is returned. pdFALSE will be returned
|
||||
* if the timer service queue was full.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* #define BIT_0 ( 1 << 0 )
|
||||
* #define BIT_4 ( 1 << 4 )
|
||||
*
|
||||
* // An event group which it is assumed has already been created by a call to
|
||||
* // xEventGroupCreate().
|
||||
* EventGroupHandle_t xEventGroup;
|
||||
*
|
||||
* void anInterruptHandler( void )
|
||||
* {
|
||||
* // Clear bit 0 and bit 4 in xEventGroup.
|
||||
* xResult = xEventGroupClearBitsFromISR(
|
||||
* xEventGroup, // The event group being updated.
|
||||
* BIT_0 | BIT_4 ); // The bits being set.
|
||||
*
|
||||
* if( xResult == pdPASS )
|
||||
* {
|
||||
* // The message was posted successfully.
|
||||
* portYIELD_FROM_ISR(pdTRUE);
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup xEventGroupClearBitsFromISR xEventGroupClearBitsFromISR
|
||||
* \ingroup EventGroup
|
||||
*/
|
||||
#if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
|
||||
BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToClear ) PRIVILEGED_FUNCTION;
|
||||
#endif /* if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
* @code{c}
|
||||
* EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet );
|
||||
* @endcode
|
||||
*
|
||||
* Set bits within an event group.
|
||||
* This function cannot be called from an interrupt. xEventGroupSetBitsFromISR()
|
||||
* is a version that can be called from an interrupt.
|
||||
*
|
||||
* Setting bits in an event group will automatically unblock tasks that are
|
||||
* blocked waiting for the bits.
|
||||
*
|
||||
* The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupSetBits()
|
||||
* to be available.
|
||||
*
|
||||
* @param xEventGroup The event group in which the bits are to be set.
|
||||
*
|
||||
* @param uxBitsToSet A bitwise value that indicates the bit or bits to set.
|
||||
* For example, to set bit 3 only, set uxBitsToSet to 0x08. To set bit 3
|
||||
* and bit 0 set uxBitsToSet to 0x09.
|
||||
*
|
||||
* @return The value of the event group at the time the call to
|
||||
* xEventGroupSetBits() returns. Returned value might have the bits specified
|
||||
* by the uxBitsToSet parameter cleared if setting a bit results in a task
|
||||
* that was waiting for the bit leaving the blocked state then it is possible
|
||||
* the bit will be cleared automatically (see the xClearBitOnExit parameter
|
||||
* of xEventGroupWaitBits()).
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* #define BIT_0 ( 1 << 0 )
|
||||
* #define BIT_4 ( 1 << 4 )
|
||||
*
|
||||
* void aFunction( EventGroupHandle_t xEventGroup )
|
||||
* {
|
||||
* EventBits_t uxBits;
|
||||
*
|
||||
* // Set bit 0 and bit 4 in xEventGroup.
|
||||
* uxBits = xEventGroupSetBits(
|
||||
* xEventGroup, // The event group being updated.
|
||||
* BIT_0 | BIT_4 );// The bits being set.
|
||||
*
|
||||
* if( ( uxBits & ( BIT_0 | BIT_4 ) ) == ( BIT_0 | BIT_4 ) )
|
||||
* {
|
||||
* // Both bit 0 and bit 4 remained set when the function returned.
|
||||
* }
|
||||
* else if( ( uxBits & BIT_0 ) != 0 )
|
||||
* {
|
||||
* // Bit 0 remained set when the function returned, but bit 4 was
|
||||
* // cleared. It might be that bit 4 was cleared automatically as a
|
||||
* // task that was waiting for bit 4 was removed from the Blocked
|
||||
* // state.
|
||||
* }
|
||||
* else if( ( uxBits & BIT_4 ) != 0 )
|
||||
* {
|
||||
* // Bit 4 remained set when the function returned, but bit 0 was
|
||||
* // cleared. It might be that bit 0 was cleared automatically as a
|
||||
* // task that was waiting for bit 0 was removed from the Blocked
|
||||
* // state.
|
||||
* }
|
||||
* else
|
||||
* {
|
||||
* // Neither bit 0 nor bit 4 remained set. It might be that a task
|
||||
* // was waiting for both of the bits to be set, and the bits were
|
||||
* // cleared as the task left the Blocked state.
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup xEventGroupSetBits xEventGroupSetBits
|
||||
* \ingroup EventGroup
|
||||
*/
|
||||
EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToSet ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
* @code{c}
|
||||
* BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, BaseType_t *pxHigherPriorityTaskWoken );
|
||||
* @endcode
|
||||
*
|
||||
* A version of xEventGroupSetBits() that can be called from an interrupt.
|
||||
*
|
||||
* Setting bits in an event group is not a deterministic operation because there
|
||||
* are an unknown number of tasks that may be waiting for the bit or bits being
|
||||
* set. FreeRTOS does not allow nondeterministic operations to be performed in
|
||||
* interrupts or from critical sections. Therefore xEventGroupSetBitsFromISR()
|
||||
* sends a message to the timer task to have the set operation performed in the
|
||||
* context of the timer task - where a scheduler lock is used in place of a
|
||||
* critical section.
|
||||
*
|
||||
* @param xEventGroup The event group in which the bits are to be set.
|
||||
*
|
||||
* @param uxBitsToSet A bitwise value that indicates the bit or bits to set.
|
||||
* For example, to set bit 3 only, set uxBitsToSet to 0x08. To set bit 3
|
||||
* and bit 0 set uxBitsToSet to 0x09.
|
||||
*
|
||||
* @param pxHigherPriorityTaskWoken As mentioned above, calling this function
|
||||
* will result in a message being sent to the timer daemon task. If the
|
||||
* priority of the timer daemon task is higher than the priority of the
|
||||
* currently running task (the task the interrupt interrupted) then
|
||||
* *pxHigherPriorityTaskWoken will be set to pdTRUE by
|
||||
* xEventGroupSetBitsFromISR(), indicating that a context switch should be
|
||||
* requested before the interrupt exits. For that reason
|
||||
* *pxHigherPriorityTaskWoken must be initialised to pdFALSE. See the
|
||||
* example code below.
|
||||
*
|
||||
* @return If the request to execute the function was posted successfully then
|
||||
* pdPASS is returned, otherwise pdFALSE is returned. pdFALSE will be returned
|
||||
* if the timer service queue was full.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* #define BIT_0 ( 1 << 0 )
|
||||
* #define BIT_4 ( 1 << 4 )
|
||||
*
|
||||
* // An event group which it is assumed has already been created by a call to
|
||||
* // xEventGroupCreate().
|
||||
* EventGroupHandle_t xEventGroup;
|
||||
*
|
||||
* void anInterruptHandler( void )
|
||||
* {
|
||||
* BaseType_t xHigherPriorityTaskWoken, xResult;
|
||||
*
|
||||
* // xHigherPriorityTaskWoken must be initialised to pdFALSE.
|
||||
* xHigherPriorityTaskWoken = pdFALSE;
|
||||
*
|
||||
* // Set bit 0 and bit 4 in xEventGroup.
|
||||
* xResult = xEventGroupSetBitsFromISR(
|
||||
* xEventGroup, // The event group being updated.
|
||||
* BIT_0 | BIT_4 // The bits being set.
|
||||
* &xHigherPriorityTaskWoken );
|
||||
*
|
||||
* // Was the message posted successfully?
|
||||
* if( xResult == pdPASS )
|
||||
* {
|
||||
* // If xHigherPriorityTaskWoken is now set to pdTRUE then a context
|
||||
* // switch should be requested. The macro used is port specific and
|
||||
* // will be either portYIELD_FROM_ISR() or portEND_SWITCHING_ISR() -
|
||||
* // refer to the documentation page for the port being used.
|
||||
* portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup xEventGroupSetBitsFromISR xEventGroupSetBitsFromISR
|
||||
* \ingroup EventGroup
|
||||
*/
|
||||
#if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) )
|
||||
BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToSet,
|
||||
BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
|
||||
#endif /* if ( ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 1 ) ) */
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
* @code{c}
|
||||
* EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
|
||||
* const EventBits_t uxBitsToSet,
|
||||
* const EventBits_t uxBitsToWaitFor,
|
||||
* TickType_t xTicksToWait );
|
||||
* @endcode
|
||||
*
|
||||
* Atomically set bits within an event group, then wait for a combination of
|
||||
* bits to be set within the same event group. This functionality is typically
|
||||
* used to synchronise multiple tasks, where each task has to wait for the other
|
||||
* tasks to reach a synchronisation point before proceeding.
|
||||
*
|
||||
* This function cannot be used from an interrupt.
|
||||
*
|
||||
* The function will return before its block time expires if the bits specified
|
||||
* by the uxBitsToWait parameter are set, or become set within that time. In
|
||||
* this case all the bits specified by uxBitsToWait will be automatically
|
||||
* cleared before the function returns.
|
||||
*
|
||||
* The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupSync()
|
||||
* to be available.
|
||||
*
|
||||
* @param xEventGroup The event group in which the bits are being tested. The
|
||||
* event group must have previously been created using a call to
|
||||
* xEventGroupCreate().
|
||||
*
|
||||
* @param uxBitsToSet The bits to set in the event group before determining
|
||||
* if, and possibly waiting for, all the bits specified by the uxBitsToWait
|
||||
* parameter are set.
|
||||
*
|
||||
* @param uxBitsToWaitFor A bitwise value that indicates the bit or bits to test
|
||||
* inside the event group. For example, to wait for bit 0 and bit 2 set
|
||||
* uxBitsToWaitFor to 0x05. To wait for bits 0 and bit 1 and bit 2 set
|
||||
* uxBitsToWaitFor to 0x07. Etc.
|
||||
*
|
||||
* @param xTicksToWait The maximum amount of time (specified in 'ticks') to wait
|
||||
* for all of the bits specified by uxBitsToWaitFor to become set.
|
||||
*
|
||||
* @return The value of the event group at the time either the bits being waited
|
||||
* for became set, or the block time expired. Test the return value to know
|
||||
* which bits were set. If xEventGroupSync() returned because its timeout
|
||||
* expired then not all the bits being waited for will be set. If
|
||||
* xEventGroupSync() returned because all the bits it was waiting for were
|
||||
* set then the returned value is the event group value before any bits were
|
||||
* automatically cleared.
|
||||
*
|
||||
* Example usage:
|
||||
* @code{c}
|
||||
* // Bits used by the three tasks.
|
||||
* #define TASK_0_BIT ( 1 << 0 )
|
||||
* #define TASK_1_BIT ( 1 << 1 )
|
||||
* #define TASK_2_BIT ( 1 << 2 )
|
||||
*
|
||||
* #define ALL_SYNC_BITS ( TASK_0_BIT | TASK_1_BIT | TASK_2_BIT )
|
||||
*
|
||||
* // Use an event group to synchronise three tasks. It is assumed this event
|
||||
* // group has already been created elsewhere.
|
||||
* EventGroupHandle_t xEventBits;
|
||||
*
|
||||
* void vTask0( void *pvParameters )
|
||||
* {
|
||||
* EventBits_t uxReturn;
|
||||
* TickType_t xTicksToWait = 100 / portTICK_PERIOD_MS;
|
||||
*
|
||||
* for( ;; )
|
||||
* {
|
||||
* // Perform task functionality here.
|
||||
*
|
||||
* // Set bit 0 in the event flag to note this task has reached the
|
||||
* // sync point. The other two tasks will set the other two bits defined
|
||||
* // by ALL_SYNC_BITS. All three tasks have reached the synchronisation
|
||||
* // point when all the ALL_SYNC_BITS are set. Wait a maximum of 100ms
|
||||
* // for this to happen.
|
||||
* uxReturn = xEventGroupSync( xEventBits, TASK_0_BIT, ALL_SYNC_BITS, xTicksToWait );
|
||||
*
|
||||
* if( ( uxReturn & ALL_SYNC_BITS ) == ALL_SYNC_BITS )
|
||||
* {
|
||||
* // All three tasks reached the synchronisation point before the call
|
||||
* // to xEventGroupSync() timed out.
|
||||
* }
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* void vTask1( void *pvParameters )
|
||||
* {
|
||||
* for( ;; )
|
||||
* {
|
||||
* // Perform task functionality here.
|
||||
*
|
||||
* // Set bit 1 in the event flag to note this task has reached the
|
||||
* // synchronisation point. The other two tasks will set the other two
|
||||
* // bits defined by ALL_SYNC_BITS. All three tasks have reached the
|
||||
* // synchronisation point when all the ALL_SYNC_BITS are set. Wait
|
||||
* // indefinitely for this to happen.
|
||||
* xEventGroupSync( xEventBits, TASK_1_BIT, ALL_SYNC_BITS, portMAX_DELAY );
|
||||
*
|
||||
* // xEventGroupSync() was called with an indefinite block time, so
|
||||
* // this task will only reach here if the synchronisation was made by all
|
||||
* // three tasks, so there is no need to test the return value.
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* void vTask2( void *pvParameters )
|
||||
* {
|
||||
* for( ;; )
|
||||
* {
|
||||
* // Perform task functionality here.
|
||||
*
|
||||
* // Set bit 2 in the event flag to note this task has reached the
|
||||
* // synchronisation point. The other two tasks will set the other two
|
||||
* // bits defined by ALL_SYNC_BITS. All three tasks have reached the
|
||||
* // synchronisation point when all the ALL_SYNC_BITS are set. Wait
|
||||
* // indefinitely for this to happen.
|
||||
* xEventGroupSync( xEventBits, TASK_2_BIT, ALL_SYNC_BITS, portMAX_DELAY );
|
||||
*
|
||||
* // xEventGroupSync() was called with an indefinite block time, so
|
||||
* // this task will only reach here if the synchronisation was made by all
|
||||
* // three tasks, so there is no need to test the return value.
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* @endcode
|
||||
* \defgroup xEventGroupSync xEventGroupSync
|
||||
* \ingroup EventGroup
|
||||
*/
|
||||
EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToSet,
|
||||
const EventBits_t uxBitsToWaitFor,
|
||||
TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
|
||||
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
* @code{c}
|
||||
* EventBits_t xEventGroupGetBits( EventGroupHandle_t xEventGroup );
|
||||
* @endcode
|
||||
*
|
||||
* Returns the current value of the bits in an event group. This function
|
||||
* cannot be used from an interrupt.
|
||||
*
|
||||
* The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupGetBits()
|
||||
* to be available.
|
||||
*
|
||||
* @param xEventGroup The event group being queried.
|
||||
*
|
||||
* @return The event group bits at the time xEventGroupGetBits() was called.
|
||||
*
|
||||
* \defgroup xEventGroupGetBits xEventGroupGetBits
|
||||
* \ingroup EventGroup
|
||||
*/
|
||||
#define xEventGroupGetBits( xEventGroup ) xEventGroupClearBits( ( xEventGroup ), 0 )
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
* @code{c}
|
||||
* EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup );
|
||||
* @endcode
|
||||
*
|
||||
* A version of xEventGroupGetBits() that can be called from an ISR.
|
||||
*
|
||||
* The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupGetBitsFromISR()
|
||||
* to be available.
|
||||
*
|
||||
* @param xEventGroup The event group being queried.
|
||||
*
|
||||
* @return The event group bits at the time xEventGroupGetBitsFromISR() was called.
|
||||
*
|
||||
* \defgroup xEventGroupGetBitsFromISR xEventGroupGetBitsFromISR
|
||||
* \ingroup EventGroup
|
||||
*/
|
||||
EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
* @code{c}
|
||||
* void xEventGroupDelete( EventGroupHandle_t xEventGroup );
|
||||
* @endcode
|
||||
*
|
||||
* Delete an event group that was previously created by a call to
|
||||
* xEventGroupCreate(). Tasks that are blocked on the event group will be
|
||||
* unblocked and obtain 0 as the event group's value.
|
||||
*
|
||||
* The configUSE_EVENT_GROUPS configuration constant must be set to 1 for vEventGroupDelete()
|
||||
* to be available.
|
||||
*
|
||||
* @param xEventGroup The event group being deleted.
|
||||
*/
|
||||
void vEventGroupDelete( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/**
|
||||
* event_groups.h
|
||||
* @code{c}
|
||||
* BaseType_t xEventGroupGetStaticBuffer( EventGroupHandle_t xEventGroup,
|
||||
* StaticEventGroup_t ** ppxEventGroupBuffer );
|
||||
* @endcode
|
||||
*
|
||||
* Retrieve a pointer to a statically created event groups's data structure
|
||||
* buffer. It is the same buffer that is supplied at the time of creation.
|
||||
*
|
||||
* The configUSE_EVENT_GROUPS configuration constant must be set to 1 for xEventGroupGetStaticBuffer()
|
||||
* to be available.
|
||||
*
|
||||
* @param xEventGroup The event group for which to retrieve the buffer.
|
||||
*
|
||||
* @param ppxEventGroupBuffer Used to return a pointer to the event groups's
|
||||
* data structure buffer.
|
||||
*
|
||||
* @return pdTRUE if the buffer was retrieved, pdFALSE otherwise.
|
||||
*/
|
||||
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
|
||||
BaseType_t xEventGroupGetStaticBuffer( EventGroupHandle_t xEventGroup,
|
||||
StaticEventGroup_t ** ppxEventGroupBuffer ) PRIVILEGED_FUNCTION;
|
||||
#endif /* configSUPPORT_STATIC_ALLOCATION */
|
||||
|
||||
/* For internal use only. */
|
||||
void vEventGroupSetBitsCallback( void * pvEventGroup,
|
||||
uint32_t ulBitsToSet ) PRIVILEGED_FUNCTION;
|
||||
void vEventGroupClearBitsCallback( void * pvEventGroup,
|
||||
uint32_t ulBitsToClear ) PRIVILEGED_FUNCTION;
|
||||
|
||||
|
||||
#if ( configUSE_TRACE_FACILITY == 1 )
|
||||
UBaseType_t uxEventGroupGetNumber( void * xEventGroup ) PRIVILEGED_FUNCTION;
|
||||
void vEventGroupSetNumber( void * xEventGroup,
|
||||
UBaseType_t uxEventGroupNumber ) PRIVILEGED_FUNCTION;
|
||||
#endif
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
#endif /* EVENT_GROUPS_H */
|
||||
@@ -0,0 +1,511 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* This is the list implementation used by the scheduler. While it is tailored
|
||||
* heavily for the schedulers needs, it is also available for use by
|
||||
* application code.
|
||||
*
|
||||
* list_ts can only store pointers to list_item_ts. Each ListItem_t contains a
|
||||
* numeric value (xItemValue). Most of the time the lists are sorted in
|
||||
* ascending item value order.
|
||||
*
|
||||
* Lists are created already containing one list item. The value of this
|
||||
* item is the maximum possible that can be stored, it is therefore always at
|
||||
* the end of the list and acts as a marker. The list member pxHead always
|
||||
* points to this marker - even though it is at the tail of the list. This
|
||||
* is because the tail contains a wrap back pointer to the true head of
|
||||
* the list.
|
||||
*
|
||||
* In addition to it's value, each list item contains a pointer to the next
|
||||
* item in the list (pxNext), a pointer to the list it is in (pxContainer)
|
||||
* and a pointer back to the object that contains it. These later two
|
||||
* pointers are included for efficiency of list manipulation. There is
|
||||
* effectively a two way link between the object containing the list item and
|
||||
* the list item itself.
|
||||
*
|
||||
*
|
||||
* \page ListIntroduction List Implementation
|
||||
* \ingroup FreeRTOSIntro
|
||||
*/
|
||||
|
||||
|
||||
#ifndef LIST_H
|
||||
#define LIST_H
|
||||
|
||||
#ifndef INC_FREERTOS_H
|
||||
#error "FreeRTOS.h must be included before list.h"
|
||||
#endif
|
||||
|
||||
/*
|
||||
* The list structure members are modified from within interrupts, and therefore
|
||||
* by rights should be declared volatile. However, they are only modified in a
|
||||
* functionally atomic way (within critical sections of with the scheduler
|
||||
* suspended) and are either passed by reference into a function or indexed via
|
||||
* a volatile variable. Therefore, in all use cases tested so far, the volatile
|
||||
* qualifier can be omitted in order to provide a moderate performance
|
||||
* improvement without adversely affecting functional behaviour. The assembly
|
||||
* instructions generated by the IAR, ARM and GCC compilers when the respective
|
||||
* compiler's options were set for maximum optimisation has been inspected and
|
||||
* deemed to be as intended. That said, as compiler technology advances, and
|
||||
* especially if aggressive cross module optimisation is used (a use case that
|
||||
* has not been exercised to any great extend) then it is feasible that the
|
||||
* volatile qualifier will be needed for correct optimisation. It is expected
|
||||
* that a compiler removing essential code because, without the volatile
|
||||
* qualifier on the list structure members and with aggressive cross module
|
||||
* optimisation, the compiler deemed the code unnecessary will result in
|
||||
* complete and obvious failure of the scheduler. If this is ever experienced
|
||||
* then the volatile qualifier can be inserted in the relevant places within the
|
||||
* list structures by simply defining configLIST_VOLATILE to volatile in
|
||||
* FreeRTOSConfig.h (as per the example at the bottom of this comment block).
|
||||
* If configLIST_VOLATILE is not defined then the preprocessor directives below
|
||||
* will simply #define configLIST_VOLATILE away completely.
|
||||
*
|
||||
* To use volatile list structure members then add the following line to
|
||||
* FreeRTOSConfig.h (without the quotes):
|
||||
* "#define configLIST_VOLATILE volatile"
|
||||
*/
|
||||
#ifndef configLIST_VOLATILE
|
||||
#define configLIST_VOLATILE
|
||||
#endif /* configSUPPORT_CROSS_MODULE_OPTIMISATION */
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/* Macros that can be used to place known values within the list structures,
|
||||
* then check that the known values do not get corrupted during the execution of
|
||||
* the application. These may catch the list data structures being overwritten in
|
||||
* memory. They will not catch data errors caused by incorrect configuration or
|
||||
* use of FreeRTOS.*/
|
||||
#if ( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 0 )
|
||||
/* Define the macros to do nothing. */
|
||||
#define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE
|
||||
#define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE
|
||||
#define listFIRST_LIST_INTEGRITY_CHECK_VALUE
|
||||
#define listSECOND_LIST_INTEGRITY_CHECK_VALUE
|
||||
#define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
|
||||
#define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem )
|
||||
#define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList )
|
||||
#define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList )
|
||||
#define listTEST_LIST_ITEM_INTEGRITY( pxItem )
|
||||
#define listTEST_LIST_INTEGRITY( pxList )
|
||||
#else /* if ( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 0 ) */
|
||||
/* Define macros that add new members into the list structures. */
|
||||
#define listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE TickType_t xListItemIntegrityValue1;
|
||||
#define listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE TickType_t xListItemIntegrityValue2;
|
||||
#define listFIRST_LIST_INTEGRITY_CHECK_VALUE TickType_t xListIntegrityValue1;
|
||||
#define listSECOND_LIST_INTEGRITY_CHECK_VALUE TickType_t xListIntegrityValue2;
|
||||
|
||||
/* Define macros that set the new structure members to known values. */
|
||||
#define listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem ) ( pxItem )->xListItemIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
|
||||
#define listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem ) ( pxItem )->xListItemIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
|
||||
#define listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList ) ( pxList )->xListIntegrityValue1 = pdINTEGRITY_CHECK_VALUE
|
||||
#define listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList ) ( pxList )->xListIntegrityValue2 = pdINTEGRITY_CHECK_VALUE
|
||||
|
||||
/* Define macros that will assert if one of the structure members does not
|
||||
* contain its expected value. */
|
||||
#define listTEST_LIST_ITEM_INTEGRITY( pxItem ) configASSERT( ( ( pxItem )->xListItemIntegrityValue1 == pdINTEGRITY_CHECK_VALUE ) && ( ( pxItem )->xListItemIntegrityValue2 == pdINTEGRITY_CHECK_VALUE ) )
|
||||
#define listTEST_LIST_INTEGRITY( pxList ) configASSERT( ( ( pxList )->xListIntegrityValue1 == pdINTEGRITY_CHECK_VALUE ) && ( ( pxList )->xListIntegrityValue2 == pdINTEGRITY_CHECK_VALUE ) )
|
||||
#endif /* configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES */
|
||||
|
||||
|
||||
/*
|
||||
* Definition of the only type of object that a list can contain.
|
||||
*/
|
||||
struct xLIST;
|
||||
struct xLIST_ITEM
|
||||
{
|
||||
listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE /**< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
|
||||
configLIST_VOLATILE TickType_t xItemValue; /**< The value being listed. In most cases this is used to sort the list in ascending order. */
|
||||
struct xLIST_ITEM * configLIST_VOLATILE pxNext; /**< Pointer to the next ListItem_t in the list. */
|
||||
struct xLIST_ITEM * configLIST_VOLATILE pxPrevious; /**< Pointer to the previous ListItem_t in the list. */
|
||||
void * pvOwner; /**< Pointer to the object (normally a TCB) that contains the list item. There is therefore a two way link between the object containing the list item and the list item itself. */
|
||||
struct xLIST * configLIST_VOLATILE pxContainer; /**< Pointer to the list in which this list item is placed (if any). */
|
||||
listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE /**< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
|
||||
};
|
||||
typedef struct xLIST_ITEM ListItem_t;
|
||||
|
||||
#if ( configUSE_MINI_LIST_ITEM == 1 )
|
||||
struct xMINI_LIST_ITEM
|
||||
{
|
||||
listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE /**< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
|
||||
configLIST_VOLATILE TickType_t xItemValue;
|
||||
struct xLIST_ITEM * configLIST_VOLATILE pxNext;
|
||||
struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;
|
||||
};
|
||||
typedef struct xMINI_LIST_ITEM MiniListItem_t;
|
||||
#else
|
||||
typedef struct xLIST_ITEM MiniListItem_t;
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Definition of the type of queue used by the scheduler.
|
||||
*/
|
||||
typedef struct xLIST
|
||||
{
|
||||
listFIRST_LIST_INTEGRITY_CHECK_VALUE /**< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
|
||||
configLIST_VOLATILE UBaseType_t uxNumberOfItems;
|
||||
ListItem_t * configLIST_VOLATILE pxIndex; /**< Used to walk through the list. Points to the last item returned by a call to listGET_OWNER_OF_NEXT_ENTRY (). */
|
||||
MiniListItem_t xListEnd; /**< List item that contains the maximum possible item value meaning it is always at the end of the list and is therefore used as a marker. */
|
||||
listSECOND_LIST_INTEGRITY_CHECK_VALUE /**< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
|
||||
} List_t;
|
||||
|
||||
/*
|
||||
* Access macro to set the owner of a list item. The owner of a list item
|
||||
* is the object (usually a TCB) that contains the list item.
|
||||
*
|
||||
* \page listSET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#define listSET_LIST_ITEM_OWNER( pxListItem, pxOwner ) ( ( pxListItem )->pvOwner = ( void * ) ( pxOwner ) )
|
||||
|
||||
/*
|
||||
* Access macro to get the owner of a list item. The owner of a list item
|
||||
* is the object (usually a TCB) that contains the list item.
|
||||
*
|
||||
* \page listGET_LIST_ITEM_OWNER listSET_LIST_ITEM_OWNER
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#define listGET_LIST_ITEM_OWNER( pxListItem ) ( ( pxListItem )->pvOwner )
|
||||
|
||||
/*
|
||||
* Access macro to set the value of the list item. In most cases the value is
|
||||
* used to sort the list in ascending order.
|
||||
*
|
||||
* \page listSET_LIST_ITEM_VALUE listSET_LIST_ITEM_VALUE
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#define listSET_LIST_ITEM_VALUE( pxListItem, xValue ) ( ( pxListItem )->xItemValue = ( xValue ) )
|
||||
|
||||
/*
|
||||
* Access macro to retrieve the value of the list item. The value can
|
||||
* represent anything - for example the priority of a task, or the time at
|
||||
* which a task should be unblocked.
|
||||
*
|
||||
* \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#define listGET_LIST_ITEM_VALUE( pxListItem ) ( ( pxListItem )->xItemValue )
|
||||
|
||||
/*
|
||||
* Access macro to retrieve the value of the list item at the head of a given
|
||||
* list.
|
||||
*
|
||||
* \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#define listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxList ) ( ( ( pxList )->xListEnd ).pxNext->xItemValue )
|
||||
|
||||
/*
|
||||
* Return the list item at the head of the list.
|
||||
*
|
||||
* \page listGET_HEAD_ENTRY listGET_HEAD_ENTRY
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#define listGET_HEAD_ENTRY( pxList ) ( ( ( pxList )->xListEnd ).pxNext )
|
||||
|
||||
/*
|
||||
* Return the next list item.
|
||||
*
|
||||
* \page listGET_NEXT listGET_NEXT
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#define listGET_NEXT( pxListItem ) ( ( pxListItem )->pxNext )
|
||||
|
||||
/*
|
||||
* Return the list item that marks the end of the list
|
||||
*
|
||||
* \page listGET_END_MARKER listGET_END_MARKER
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#define listGET_END_MARKER( pxList ) ( ( ListItem_t const * ) ( &( ( pxList )->xListEnd ) ) )
|
||||
|
||||
/*
|
||||
* Access macro to determine if a list contains any items. The macro will
|
||||
* only have the value true if the list is empty.
|
||||
*
|
||||
* \page listLIST_IS_EMPTY listLIST_IS_EMPTY
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#define listLIST_IS_EMPTY( pxList ) ( ( ( pxList )->uxNumberOfItems == ( UBaseType_t ) 0 ) ? pdTRUE : pdFALSE )
|
||||
|
||||
/*
|
||||
* Access macro to return the number of items in the list.
|
||||
*/
|
||||
#define listCURRENT_LIST_LENGTH( pxList ) ( ( pxList )->uxNumberOfItems )
|
||||
|
||||
/*
|
||||
* Access function to obtain the owner of the next entry in a list.
|
||||
*
|
||||
* The list member pxIndex is used to walk through a list. Calling
|
||||
* listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list
|
||||
* and returns that entry's pxOwner parameter. Using multiple calls to this
|
||||
* function it is therefore possible to move through every item contained in
|
||||
* a list.
|
||||
*
|
||||
* The pxOwner parameter of a list item is a pointer to the object that owns
|
||||
* the list item. In the scheduler this is normally a task control block.
|
||||
* The pxOwner parameter effectively creates a two way link between the list
|
||||
* item and its owner.
|
||||
*
|
||||
* @param pxTCB pxTCB is set to the address of the owner of the next list item.
|
||||
* @param pxList The list from which the next item owner is to be returned.
|
||||
*
|
||||
* \page listGET_OWNER_OF_NEXT_ENTRY listGET_OWNER_OF_NEXT_ENTRY
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#if ( configNUMBER_OF_CORES == 1 )
|
||||
#define listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList ) \
|
||||
do { \
|
||||
List_t * const pxConstList = ( pxList ); \
|
||||
/* Increment the index to the next item and return the item, ensuring */ \
|
||||
/* we don't return the marker used at the end of the list. */ \
|
||||
( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext; \
|
||||
if( ( void * ) ( pxConstList )->pxIndex == ( void * ) &( ( pxConstList )->xListEnd ) ) \
|
||||
{ \
|
||||
( pxConstList )->pxIndex = ( pxConstList )->xListEnd.pxNext; \
|
||||
} \
|
||||
( pxTCB ) = ( pxConstList )->pxIndex->pvOwner; \
|
||||
} while( 0 )
|
||||
#else /* #if ( configNUMBER_OF_CORES == 1 ) */
|
||||
|
||||
/* This function is not required in SMP. FreeRTOS SMP scheduler doesn't use
|
||||
* pxIndex and it should always point to the xListEnd. Not defining this macro
|
||||
* here to prevent updating pxIndex.
|
||||
*/
|
||||
#endif /* #if ( configNUMBER_OF_CORES == 1 ) */
|
||||
|
||||
/*
|
||||
* Version of uxListRemove() that does not return a value. Provided as a slight
|
||||
* optimisation for xTaskIncrementTick() by being inline.
|
||||
*
|
||||
* Remove an item from a list. The list item has a pointer to the list that
|
||||
* it is in, so only the list item need be passed into the function.
|
||||
*
|
||||
* @param uxListRemove The item to be removed. The item will remove itself from
|
||||
* the list pointed to by it's pxContainer parameter.
|
||||
*
|
||||
* @return The number of items that remain in the list after the list item has
|
||||
* been removed.
|
||||
*
|
||||
* \page listREMOVE_ITEM listREMOVE_ITEM
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#define listREMOVE_ITEM( pxItemToRemove ) \
|
||||
do { \
|
||||
/* The list item knows which list it is in. Obtain the list from the list \
|
||||
* item. */ \
|
||||
List_t * const pxList = ( pxItemToRemove )->pxContainer; \
|
||||
\
|
||||
( pxItemToRemove )->pxNext->pxPrevious = ( pxItemToRemove )->pxPrevious; \
|
||||
( pxItemToRemove )->pxPrevious->pxNext = ( pxItemToRemove )->pxNext; \
|
||||
/* Make sure the index is left pointing to a valid item. */ \
|
||||
if( pxList->pxIndex == ( pxItemToRemove ) ) \
|
||||
{ \
|
||||
pxList->pxIndex = ( pxItemToRemove )->pxPrevious; \
|
||||
} \
|
||||
\
|
||||
( pxItemToRemove )->pxContainer = NULL; \
|
||||
( ( pxList )->uxNumberOfItems ) = ( UBaseType_t ) ( ( ( pxList )->uxNumberOfItems ) - 1U ); \
|
||||
} while( 0 )
|
||||
|
||||
/*
|
||||
* Inline version of vListInsertEnd() to provide slight optimisation for
|
||||
* xTaskIncrementTick().
|
||||
*
|
||||
* Insert a list item into a list. The item will be inserted in a position
|
||||
* such that it will be the last item within the list returned by multiple
|
||||
* calls to listGET_OWNER_OF_NEXT_ENTRY.
|
||||
*
|
||||
* The list member pxIndex is used to walk through a list. Calling
|
||||
* listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list.
|
||||
* Placing an item in a list using vListInsertEnd effectively places the item
|
||||
* in the list position pointed to by pxIndex. This means that every other
|
||||
* item within the list will be returned by listGET_OWNER_OF_NEXT_ENTRY before
|
||||
* the pxIndex parameter again points to the item being inserted.
|
||||
*
|
||||
* @param pxList The list into which the item is to be inserted.
|
||||
*
|
||||
* @param pxNewListItem The list item to be inserted into the list.
|
||||
*
|
||||
* \page listINSERT_END listINSERT_END
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#define listINSERT_END( pxList, pxNewListItem ) \
|
||||
do { \
|
||||
ListItem_t * const pxIndex = ( pxList )->pxIndex; \
|
||||
\
|
||||
/* Only effective when configASSERT() is also defined, these tests may catch \
|
||||
* the list data structures being overwritten in memory. They will not catch \
|
||||
* data errors caused by incorrect configuration or use of FreeRTOS. */ \
|
||||
listTEST_LIST_INTEGRITY( ( pxList ) ); \
|
||||
listTEST_LIST_ITEM_INTEGRITY( ( pxNewListItem ) ); \
|
||||
\
|
||||
/* Insert a new list item into ( pxList ), but rather than sort the list, \
|
||||
* makes the new list item the last item to be removed by a call to \
|
||||
* listGET_OWNER_OF_NEXT_ENTRY(). */ \
|
||||
( pxNewListItem )->pxNext = pxIndex; \
|
||||
( pxNewListItem )->pxPrevious = pxIndex->pxPrevious; \
|
||||
\
|
||||
pxIndex->pxPrevious->pxNext = ( pxNewListItem ); \
|
||||
pxIndex->pxPrevious = ( pxNewListItem ); \
|
||||
\
|
||||
/* Remember which list the item is in. */ \
|
||||
( pxNewListItem )->pxContainer = ( pxList ); \
|
||||
\
|
||||
( ( pxList )->uxNumberOfItems ) = ( UBaseType_t ) ( ( ( pxList )->uxNumberOfItems ) + 1U ); \
|
||||
} while( 0 )
|
||||
|
||||
/*
|
||||
* Access function to obtain the owner of the first entry in a list. Lists
|
||||
* are normally sorted in ascending item value order.
|
||||
*
|
||||
* This function returns the pxOwner member of the first item in the list.
|
||||
* The pxOwner parameter of a list item is a pointer to the object that owns
|
||||
* the list item. In the scheduler this is normally a task control block.
|
||||
* The pxOwner parameter effectively creates a two way link between the list
|
||||
* item and its owner.
|
||||
*
|
||||
* @param pxList The list from which the owner of the head item is to be
|
||||
* returned.
|
||||
*
|
||||
* \page listGET_OWNER_OF_HEAD_ENTRY listGET_OWNER_OF_HEAD_ENTRY
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
#define listGET_OWNER_OF_HEAD_ENTRY( pxList ) ( ( &( ( pxList )->xListEnd ) )->pxNext->pvOwner )
|
||||
|
||||
/*
|
||||
* Check to see if a list item is within a list. The list item maintains a
|
||||
* "container" pointer that points to the list it is in. All this macro does
|
||||
* is check to see if the container and the list match.
|
||||
*
|
||||
* @param pxList The list we want to know if the list item is within.
|
||||
* @param pxListItem The list item we want to know if is in the list.
|
||||
* @return pdTRUE if the list item is in the list, otherwise pdFALSE.
|
||||
*/
|
||||
#define listIS_CONTAINED_WITHIN( pxList, pxListItem ) ( ( ( pxListItem )->pxContainer == ( pxList ) ) ? ( pdTRUE ) : ( pdFALSE ) )
|
||||
|
||||
/*
|
||||
* Return the list a list item is contained within (referenced from).
|
||||
*
|
||||
* @param pxListItem The list item being queried.
|
||||
* @return A pointer to the List_t object that references the pxListItem
|
||||
*/
|
||||
#define listLIST_ITEM_CONTAINER( pxListItem ) ( ( pxListItem )->pxContainer )
|
||||
|
||||
/*
|
||||
* This provides a crude means of knowing if a list has been initialised, as
|
||||
* pxList->xListEnd.xItemValue is set to portMAX_DELAY by the vListInitialise()
|
||||
* function.
|
||||
*/
|
||||
#define listLIST_IS_INITIALISED( pxList ) ( ( pxList )->xListEnd.xItemValue == portMAX_DELAY )
|
||||
|
||||
/*
|
||||
* Must be called before a list is used! This initialises all the members
|
||||
* of the list structure and inserts the xListEnd item into the list as a
|
||||
* marker to the back of the list.
|
||||
*
|
||||
* @param pxList Pointer to the list being initialised.
|
||||
*
|
||||
* \page vListInitialise vListInitialise
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
void vListInitialise( List_t * const pxList ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/*
|
||||
* Must be called before a list item is used. This sets the list container to
|
||||
* null so the item does not think that it is already contained in a list.
|
||||
*
|
||||
* @param pxItem Pointer to the list item being initialised.
|
||||
*
|
||||
* \page vListInitialiseItem vListInitialiseItem
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
void vListInitialiseItem( ListItem_t * const pxItem ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/*
|
||||
* Insert a list item into a list. The item will be inserted into the list in
|
||||
* a position determined by its item value (ascending item value order).
|
||||
*
|
||||
* @param pxList The list into which the item is to be inserted.
|
||||
*
|
||||
* @param pxNewListItem The item that is to be placed in the list.
|
||||
*
|
||||
* \page vListInsert vListInsert
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
void vListInsert( List_t * const pxList,
|
||||
ListItem_t * const pxNewListItem ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/*
|
||||
* Insert a list item into a list. The item will be inserted in a position
|
||||
* such that it will be the last item within the list returned by multiple
|
||||
* calls to listGET_OWNER_OF_NEXT_ENTRY.
|
||||
*
|
||||
* The list member pxIndex is used to walk through a list. Calling
|
||||
* listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list.
|
||||
* Placing an item in a list using vListInsertEnd effectively places the item
|
||||
* in the list position pointed to by pxIndex. This means that every other
|
||||
* item within the list will be returned by listGET_OWNER_OF_NEXT_ENTRY before
|
||||
* the pxIndex parameter again points to the item being inserted.
|
||||
*
|
||||
* @param pxList The list into which the item is to be inserted.
|
||||
*
|
||||
* @param pxNewListItem The list item to be inserted into the list.
|
||||
*
|
||||
* \page vListInsertEnd vListInsertEnd
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
void vListInsertEnd( List_t * const pxList,
|
||||
ListItem_t * const pxNewListItem ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/*
|
||||
* Remove an item from a list. The list item has a pointer to the list that
|
||||
* it is in, so only the list item need be passed into the function.
|
||||
*
|
||||
* @param uxListRemove The item to be removed. The item will remove itself from
|
||||
* the list pointed to by it's pxContainer parameter.
|
||||
*
|
||||
* @return The number of items that remain in the list after the list item has
|
||||
* been removed.
|
||||
*
|
||||
* \page uxListRemove uxListRemove
|
||||
* \ingroup LinkedList
|
||||
*/
|
||||
UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
#endif /* ifndef LIST_H */
|
||||
+967
@@ -0,0 +1,967 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* Message buffers build functionality on top of FreeRTOS stream buffers.
|
||||
* Whereas stream buffers are used to send a continuous stream of data from one
|
||||
* task or interrupt to another, message buffers are used to send variable
|
||||
* length discrete messages from one task or interrupt to another. Their
|
||||
* implementation is light weight, making them particularly suited for interrupt
|
||||
* to task and core to core communication scenarios.
|
||||
*
|
||||
* ***NOTE***: Uniquely among FreeRTOS objects, the stream buffer
|
||||
* implementation (so also the message buffer implementation, as message buffers
|
||||
* are built on top of stream buffers) assumes there is only one task or
|
||||
* interrupt that will write to the buffer (the writer), and only one task or
|
||||
* interrupt that will read from the buffer (the reader). It is safe for the
|
||||
* writer and reader to be different tasks or interrupts, but, unlike other
|
||||
* FreeRTOS objects, it is not safe to have multiple different writers or
|
||||
* multiple different readers. If there are to be multiple different writers
|
||||
* then the application writer must serialize calls to writing API functions
|
||||
* (such as xStreamBufferSend()). Likewise, if there are to be multiple
|
||||
* different readers then the application writer must serialize calls to reading
|
||||
* API functions (such as xStreamBufferReceive()). One way to achieve such
|
||||
* serialization in single core or SMP kernel is to place each API call inside a
|
||||
* critical section and use a block time of 0.
|
||||
*
|
||||
* Message buffers hold variable length messages. To enable that, when a
|
||||
* message is written to the message buffer an additional sizeof( size_t ) bytes
|
||||
* are also written to store the message's length (that happens internally, with
|
||||
* the API function). sizeof( size_t ) is typically 4 bytes on a 32-bit
|
||||
* architecture, so writing a 10 byte message to a message buffer on a 32-bit
|
||||
* architecture will actually reduce the available space in the message buffer
|
||||
* by 14 bytes (10 byte are used by the message, and 4 bytes to hold the length
|
||||
* of the message).
|
||||
*/
|
||||
|
||||
#ifndef FREERTOS_MESSAGE_BUFFER_H
|
||||
#define FREERTOS_MESSAGE_BUFFER_H
|
||||
|
||||
#ifndef INC_FREERTOS_H
|
||||
#error "include FreeRTOS.h must appear in source files before include message_buffer.h"
|
||||
#endif
|
||||
|
||||
/* Message buffers are built onto of stream buffers. */
|
||||
#include "stream_buffer.h"
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#if defined( __cplusplus )
|
||||
extern "C" {
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/**
|
||||
* Type by which message buffers are referenced. For example, a call to
|
||||
* xMessageBufferCreate() returns an MessageBufferHandle_t variable that can
|
||||
* then be used as a parameter to xMessageBufferSend(), xMessageBufferReceive(),
|
||||
* etc. Message buffer is essentially built as a stream buffer hence its handle
|
||||
* is also set to same type as a stream buffer handle.
|
||||
*/
|
||||
typedef StreamBufferHandle_t MessageBufferHandle_t;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
*
|
||||
* @code{c}
|
||||
* MessageBufferHandle_t xMessageBufferCreate( size_t xBufferSizeBytes );
|
||||
* @endcode
|
||||
*
|
||||
* Creates a new message buffer using dynamically allocated memory. See
|
||||
* xMessageBufferCreateStatic() for a version that uses statically allocated
|
||||
* memory (memory that is allocated at compile time).
|
||||
*
|
||||
* configSUPPORT_DYNAMIC_ALLOCATION must be set to 1 or left undefined in
|
||||
* FreeRTOSConfig.h for xMessageBufferCreate() to be available.
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferCreate() to be available.
|
||||
*
|
||||
* @param xBufferSizeBytes The total number of bytes (not messages) the message
|
||||
* buffer will be able to hold at any one time. When a message is written to
|
||||
* the message buffer an additional sizeof( size_t ) bytes are also written to
|
||||
* store the message's length. sizeof( size_t ) is typically 4 bytes on a
|
||||
* 32-bit architecture, so on most 32-bit architectures a 10 byte message will
|
||||
* take up 14 bytes of message buffer space.
|
||||
*
|
||||
* @param pxSendCompletedCallback Callback invoked when a send operation to the
|
||||
* message buffer is complete. If the parameter is NULL or xMessageBufferCreate()
|
||||
* is called without the parameter, then it will use the default implementation
|
||||
* provided by sbSEND_COMPLETED macro. To enable the callback,
|
||||
* configUSE_SB_COMPLETED_CALLBACK must be set to 1 in FreeRTOSConfig.h.
|
||||
*
|
||||
* @param pxReceiveCompletedCallback Callback invoked when a receive operation from
|
||||
* the message buffer is complete. If the parameter is NULL or xMessageBufferCreate()
|
||||
* is called without the parameter, it will use the default implementation provided
|
||||
* by sbRECEIVE_COMPLETED macro. To enable the callback,
|
||||
* configUSE_SB_COMPLETED_CALLBACK must be set to 1 in FreeRTOSConfig.h.
|
||||
*
|
||||
* @return If NULL is returned, then the message buffer cannot be created
|
||||
* because there is insufficient heap memory available for FreeRTOS to allocate
|
||||
* the message buffer data structures and storage area. A non-NULL value being
|
||||
* returned indicates that the message buffer has been created successfully -
|
||||
* the returned value should be stored as the handle to the created message
|
||||
* buffer.
|
||||
*
|
||||
* Example use:
|
||||
* @code{c}
|
||||
*
|
||||
* void vAFunction( void )
|
||||
* {
|
||||
* MessageBufferHandle_t xMessageBuffer;
|
||||
* const size_t xMessageBufferSizeBytes = 100;
|
||||
*
|
||||
* // Create a message buffer that can hold 100 bytes. The memory used to hold
|
||||
* // both the message buffer structure and the messages themselves is allocated
|
||||
* // dynamically. Each message added to the buffer consumes an additional 4
|
||||
* // bytes which are used to hold the length of the message.
|
||||
* xMessageBuffer = xMessageBufferCreate( xMessageBufferSizeBytes );
|
||||
*
|
||||
* if( xMessageBuffer == NULL )
|
||||
* {
|
||||
* // There was not enough heap memory space available to create the
|
||||
* // message buffer.
|
||||
* }
|
||||
* else
|
||||
* {
|
||||
* // The message buffer was created successfully and can now be used.
|
||||
* }
|
||||
*
|
||||
* @endcode
|
||||
* \defgroup xMessageBufferCreate xMessageBufferCreate
|
||||
* \ingroup MessageBufferManagement
|
||||
*/
|
||||
#define xMessageBufferCreate( xBufferSizeBytes ) \
|
||||
xStreamBufferGenericCreate( ( xBufferSizeBytes ), ( size_t ) 0, sbTYPE_MESSAGE_BUFFER, NULL, NULL )
|
||||
|
||||
#if ( configUSE_SB_COMPLETED_CALLBACK == 1 )
|
||||
#define xMessageBufferCreateWithCallback( xBufferSizeBytes, pxSendCompletedCallback, pxReceiveCompletedCallback ) \
|
||||
xStreamBufferGenericCreate( ( xBufferSizeBytes ), ( size_t ) 0, sbTYPE_MESSAGE_BUFFER, ( pxSendCompletedCallback ), ( pxReceiveCompletedCallback ) )
|
||||
#endif
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
*
|
||||
* @code{c}
|
||||
* MessageBufferHandle_t xMessageBufferCreateStatic( size_t xBufferSizeBytes,
|
||||
* uint8_t *pucMessageBufferStorageArea,
|
||||
* StaticMessageBuffer_t *pxStaticMessageBuffer );
|
||||
* @endcode
|
||||
* Creates a new message buffer using statically allocated memory. See
|
||||
* xMessageBufferCreate() for a version that uses dynamically allocated memory.
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferCreateStatic() to be available.
|
||||
*
|
||||
* @param xBufferSizeBytes The size, in bytes, of the buffer pointed to by the
|
||||
* pucMessageBufferStorageArea parameter. When a message is written to the
|
||||
* message buffer an additional sizeof( size_t ) bytes are also written to store
|
||||
* the message's length. sizeof( size_t ) is typically 4 bytes on a 32-bit
|
||||
* architecture, so on most 32-bit architecture a 10 byte message will take up
|
||||
* 14 bytes of message buffer space. The maximum number of bytes that can be
|
||||
* stored in the message buffer is actually (xBufferSizeBytes - 1).
|
||||
*
|
||||
* @param pucMessageBufferStorageArea Must point to a uint8_t array that is at
|
||||
* least xBufferSizeBytes big. This is the array to which messages are
|
||||
* copied when they are written to the message buffer.
|
||||
*
|
||||
* @param pxStaticMessageBuffer Must point to a variable of type
|
||||
* StaticMessageBuffer_t, which will be used to hold the message buffer's data
|
||||
* structure.
|
||||
*
|
||||
* @param pxSendCompletedCallback Callback invoked when a new message is sent to the message buffer.
|
||||
* If the parameter is NULL or xMessageBufferCreate() is called without the parameter, then it will use the default
|
||||
* implementation provided by sbSEND_COMPLETED macro. To enable the callback,
|
||||
* configUSE_SB_COMPLETED_CALLBACK must be set to 1 in FreeRTOSConfig.h.
|
||||
*
|
||||
* @param pxReceiveCompletedCallback Callback invoked when a message is read from a
|
||||
* message buffer. If the parameter is NULL or xMessageBufferCreate() is called without the parameter, it will
|
||||
* use the default implementation provided by sbRECEIVE_COMPLETED macro. To enable the callback,
|
||||
* configUSE_SB_COMPLETED_CALLBACK must be set to 1 in FreeRTOSConfig.h.
|
||||
*
|
||||
* @return If the message buffer is created successfully then a handle to the
|
||||
* created message buffer is returned. If either pucMessageBufferStorageArea or
|
||||
* pxStaticmessageBuffer are NULL then NULL is returned.
|
||||
*
|
||||
* Example use:
|
||||
* @code{c}
|
||||
*
|
||||
* // Used to dimension the array used to hold the messages. The available space
|
||||
* // will actually be one less than this, so 999.
|
||||
#define STORAGE_SIZE_BYTES 1000
|
||||
*
|
||||
* // Defines the memory that will actually hold the messages within the message
|
||||
* // buffer.
|
||||
* static uint8_t ucStorageBuffer[ STORAGE_SIZE_BYTES ];
|
||||
*
|
||||
* // The variable used to hold the message buffer structure.
|
||||
* StaticMessageBuffer_t xMessageBufferStruct;
|
||||
*
|
||||
* void MyFunction( void )
|
||||
* {
|
||||
* MessageBufferHandle_t xMessageBuffer;
|
||||
*
|
||||
* xMessageBuffer = xMessageBufferCreateStatic( sizeof( ucStorageBuffer ),
|
||||
* ucStorageBuffer,
|
||||
* &xMessageBufferStruct );
|
||||
*
|
||||
* // As neither the pucMessageBufferStorageArea or pxStaticMessageBuffer
|
||||
* // parameters were NULL, xMessageBuffer will not be NULL, and can be used to
|
||||
* // reference the created message buffer in other message buffer API calls.
|
||||
*
|
||||
* // Other code that uses the message buffer can go here.
|
||||
* }
|
||||
*
|
||||
* @endcode
|
||||
* \defgroup xMessageBufferCreateStatic xMessageBufferCreateStatic
|
||||
* \ingroup MessageBufferManagement
|
||||
*/
|
||||
#define xMessageBufferCreateStatic( xBufferSizeBytes, pucMessageBufferStorageArea, pxStaticMessageBuffer ) \
|
||||
xStreamBufferGenericCreateStatic( ( xBufferSizeBytes ), 0, sbTYPE_MESSAGE_BUFFER, ( pucMessageBufferStorageArea ), ( pxStaticMessageBuffer ), NULL, NULL )
|
||||
|
||||
#if ( configUSE_SB_COMPLETED_CALLBACK == 1 )
|
||||
#define xMessageBufferCreateStaticWithCallback( xBufferSizeBytes, pucMessageBufferStorageArea, pxStaticMessageBuffer, pxSendCompletedCallback, pxReceiveCompletedCallback ) \
|
||||
xStreamBufferGenericCreateStatic( ( xBufferSizeBytes ), 0, sbTYPE_MESSAGE_BUFFER, ( pucMessageBufferStorageArea ), ( pxStaticMessageBuffer ), ( pxSendCompletedCallback ), ( pxReceiveCompletedCallback ) )
|
||||
#endif
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
*
|
||||
* @code{c}
|
||||
* BaseType_t xMessageBufferGetStaticBuffers( MessageBufferHandle_t xMessageBuffer,
|
||||
* uint8_t ** ppucMessageBufferStorageArea,
|
||||
* StaticMessageBuffer_t ** ppxStaticMessageBuffer );
|
||||
* @endcode
|
||||
*
|
||||
* Retrieve pointers to a statically created message buffer's data structure
|
||||
* buffer and storage area buffer. These are the same buffers that are supplied
|
||||
* at the time of creation.
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferGetStaticBuffers() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The message buffer for which to retrieve the buffers.
|
||||
*
|
||||
* @param ppucMessageBufferStorageArea Used to return a pointer to the
|
||||
* message buffer's storage area buffer.
|
||||
*
|
||||
* @param ppxStaticMessageBuffer Used to return a pointer to the message
|
||||
* buffer's data structure buffer.
|
||||
*
|
||||
* @return pdTRUE if buffers were retrieved, pdFALSE otherwise..
|
||||
*
|
||||
* \defgroup xMessageBufferGetStaticBuffers xMessageBufferGetStaticBuffers
|
||||
* \ingroup MessageBufferManagement
|
||||
*/
|
||||
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
|
||||
#define xMessageBufferGetStaticBuffers( xMessageBuffer, ppucMessageBufferStorageArea, ppxStaticMessageBuffer ) \
|
||||
xStreamBufferGetStaticBuffers( ( xMessageBuffer ), ( ppucMessageBufferStorageArea ), ( ppxStaticMessageBuffer ) )
|
||||
#endif /* configSUPPORT_STATIC_ALLOCATION */
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
*
|
||||
* @code{c}
|
||||
* size_t xMessageBufferSend( MessageBufferHandle_t xMessageBuffer,
|
||||
* const void *pvTxData,
|
||||
* size_t xDataLengthBytes,
|
||||
* TickType_t xTicksToWait );
|
||||
* @endcode
|
||||
*
|
||||
* Sends a discrete message to the message buffer. The message can be any
|
||||
* length that fits within the buffer's free space, and is copied into the
|
||||
* buffer.
|
||||
*
|
||||
* ***NOTE***: Uniquely among FreeRTOS objects, the stream buffer
|
||||
* implementation (so also the message buffer implementation, as message buffers
|
||||
* are built on top of stream buffers) assumes there is only one task or
|
||||
* interrupt that will write to the buffer (the writer), and only one task or
|
||||
* interrupt that will read from the buffer (the reader). It is safe for the
|
||||
* writer and reader to be different tasks or interrupts, but, unlike other
|
||||
* FreeRTOS objects, it is not safe to have multiple different writers or
|
||||
* multiple different readers. If there are to be multiple different writers
|
||||
* then the application writer must serialize calls to writing API functions
|
||||
* (such as xStreamBufferSend()). Likewise, if there are to be multiple
|
||||
* different readers then the application writer must serialize calls to reading
|
||||
* API functions (such as xStreamBufferReceive()). One way to achieve such
|
||||
* serialization in single core or SMP kernel is to place each API call inside a
|
||||
* critical section and use a block time of 0.
|
||||
*
|
||||
* Use xMessageBufferSend() to write to a message buffer from a task. Use
|
||||
* xMessageBufferSendFromISR() to write to a message buffer from an interrupt
|
||||
* service routine (ISR).
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferSend() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the message buffer to which a message is
|
||||
* being sent.
|
||||
*
|
||||
* @param pvTxData A pointer to the message that is to be copied into the
|
||||
* message buffer.
|
||||
*
|
||||
* @param xDataLengthBytes The length of the message. That is, the number of
|
||||
* bytes to copy from pvTxData into the message buffer. When a message is
|
||||
* written to the message buffer an additional sizeof( size_t ) bytes are also
|
||||
* written to store the message's length. sizeof( size_t ) is typically 4 bytes
|
||||
* on a 32-bit architecture, so on most 32-bit architecture setting
|
||||
* xDataLengthBytes to 20 will reduce the free space in the message buffer by 24
|
||||
* bytes (20 bytes of message data and 4 bytes to hold the message length).
|
||||
*
|
||||
* @param xTicksToWait The maximum amount of time the calling task should remain
|
||||
* in the Blocked state to wait for enough space to become available in the
|
||||
* message buffer, should the message buffer have insufficient space when
|
||||
* xMessageBufferSend() is called. The calling task will never block if
|
||||
* xTicksToWait is zero. The block time is specified in tick periods, so the
|
||||
* absolute time it represents is dependent on the tick frequency. The macro
|
||||
* pdMS_TO_TICKS() can be used to convert a time specified in milliseconds into
|
||||
* a time specified in ticks. Setting xTicksToWait to portMAX_DELAY will cause
|
||||
* the task to wait indefinitely (without timing out), provided
|
||||
* INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h. Tasks do not use any
|
||||
* CPU time when they are in the Blocked state.
|
||||
*
|
||||
* @return The number of bytes written to the message buffer. If the call to
|
||||
* xMessageBufferSend() times out before there was enough space to write the
|
||||
* message into the message buffer then zero is returned. If the call did not
|
||||
* time out then xDataLengthBytes is returned.
|
||||
*
|
||||
* Example use:
|
||||
* @code{c}
|
||||
* void vAFunction( MessageBufferHandle_t xMessageBuffer )
|
||||
* {
|
||||
* size_t xBytesSent;
|
||||
* uint8_t ucArrayToSend[] = { 0, 1, 2, 3 };
|
||||
* char *pcStringToSend = "String to send";
|
||||
* const TickType_t x100ms = pdMS_TO_TICKS( 100 );
|
||||
*
|
||||
* // Send an array to the message buffer, blocking for a maximum of 100ms to
|
||||
* // wait for enough space to be available in the message buffer.
|
||||
* xBytesSent = xMessageBufferSend( xMessageBuffer, ( void * ) ucArrayToSend, sizeof( ucArrayToSend ), x100ms );
|
||||
*
|
||||
* if( xBytesSent != sizeof( ucArrayToSend ) )
|
||||
* {
|
||||
* // The call to xMessageBufferSend() times out before there was enough
|
||||
* // space in the buffer for the data to be written.
|
||||
* }
|
||||
*
|
||||
* // Send the string to the message buffer. Return immediately if there is
|
||||
* // not enough space in the buffer.
|
||||
* xBytesSent = xMessageBufferSend( xMessageBuffer, ( void * ) pcStringToSend, strlen( pcStringToSend ), 0 );
|
||||
*
|
||||
* if( xBytesSent != strlen( pcStringToSend ) )
|
||||
* {
|
||||
* // The string could not be added to the message buffer because there was
|
||||
* // not enough free space in the buffer.
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup xMessageBufferSend xMessageBufferSend
|
||||
* \ingroup MessageBufferManagement
|
||||
*/
|
||||
#define xMessageBufferSend( xMessageBuffer, pvTxData, xDataLengthBytes, xTicksToWait ) \
|
||||
xStreamBufferSend( ( xMessageBuffer ), ( pvTxData ), ( xDataLengthBytes ), ( xTicksToWait ) )
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
*
|
||||
* @code{c}
|
||||
* size_t xMessageBufferSendFromISR( MessageBufferHandle_t xMessageBuffer,
|
||||
* const void *pvTxData,
|
||||
* size_t xDataLengthBytes,
|
||||
* BaseType_t *pxHigherPriorityTaskWoken );
|
||||
* @endcode
|
||||
*
|
||||
* Interrupt safe version of the API function that sends a discrete message to
|
||||
* the message buffer. The message can be any length that fits within the
|
||||
* buffer's free space, and is copied into the buffer.
|
||||
*
|
||||
* ***NOTE***: Uniquely among FreeRTOS objects, the stream buffer
|
||||
* implementation (so also the message buffer implementation, as message buffers
|
||||
* are built on top of stream buffers) assumes there is only one task or
|
||||
* interrupt that will write to the buffer (the writer), and only one task or
|
||||
* interrupt that will read from the buffer (the reader). It is safe for the
|
||||
* writer and reader to be different tasks or interrupts, but, unlike other
|
||||
* FreeRTOS objects, it is not safe to have multiple different writers or
|
||||
* multiple different readers. If there are to be multiple different writers
|
||||
* then the application writer must serialize calls to writing API functions
|
||||
* (such as xStreamBufferSend()). Likewise, if there are to be multiple
|
||||
* different readers then the application writer must serialize calls to reading
|
||||
* API functions (such as xStreamBufferReceive()). One way to achieve such
|
||||
* serialization in single core or SMP kernel is to place each API call inside a
|
||||
* critical section and use a block time of 0.
|
||||
*
|
||||
* Use xMessageBufferSend() to write to a message buffer from a task. Use
|
||||
* xMessageBufferSendFromISR() to write to a message buffer from an interrupt
|
||||
* service routine (ISR).
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferSendFromISR() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the message buffer to which a message is
|
||||
* being sent.
|
||||
*
|
||||
* @param pvTxData A pointer to the message that is to be copied into the
|
||||
* message buffer.
|
||||
*
|
||||
* @param xDataLengthBytes The length of the message. That is, the number of
|
||||
* bytes to copy from pvTxData into the message buffer. When a message is
|
||||
* written to the message buffer an additional sizeof( size_t ) bytes are also
|
||||
* written to store the message's length. sizeof( size_t ) is typically 4 bytes
|
||||
* on a 32-bit architecture, so on most 32-bit architecture setting
|
||||
* xDataLengthBytes to 20 will reduce the free space in the message buffer by 24
|
||||
* bytes (20 bytes of message data and 4 bytes to hold the message length).
|
||||
*
|
||||
* @param pxHigherPriorityTaskWoken It is possible that a message buffer will
|
||||
* have a task blocked on it waiting for data. Calling
|
||||
* xMessageBufferSendFromISR() can make data available, and so cause a task that
|
||||
* was waiting for data to leave the Blocked state. If calling
|
||||
* xMessageBufferSendFromISR() causes a task to leave the Blocked state, and the
|
||||
* unblocked task has a priority higher than the currently executing task (the
|
||||
* task that was interrupted), then, internally, xMessageBufferSendFromISR()
|
||||
* will set *pxHigherPriorityTaskWoken to pdTRUE. If
|
||||
* xMessageBufferSendFromISR() sets this value to pdTRUE, then normally a
|
||||
* context switch should be performed before the interrupt is exited. This will
|
||||
* ensure that the interrupt returns directly to the highest priority Ready
|
||||
* state task. *pxHigherPriorityTaskWoken should be set to pdFALSE before it
|
||||
* is passed into the function. See the code example below for an example.
|
||||
*
|
||||
* @return The number of bytes actually written to the message buffer. If the
|
||||
* message buffer didn't have enough free space for the message to be stored
|
||||
* then 0 is returned, otherwise xDataLengthBytes is returned.
|
||||
*
|
||||
* Example use:
|
||||
* @code{c}
|
||||
* // A message buffer that has already been created.
|
||||
* MessageBufferHandle_t xMessageBuffer;
|
||||
*
|
||||
* void vAnInterruptServiceRoutine( void )
|
||||
* {
|
||||
* size_t xBytesSent;
|
||||
* char *pcStringToSend = "String to send";
|
||||
* BaseType_t xHigherPriorityTaskWoken = pdFALSE; // Initialised to pdFALSE.
|
||||
*
|
||||
* // Attempt to send the string to the message buffer.
|
||||
* xBytesSent = xMessageBufferSendFromISR( xMessageBuffer,
|
||||
* ( void * ) pcStringToSend,
|
||||
* strlen( pcStringToSend ),
|
||||
* &xHigherPriorityTaskWoken );
|
||||
*
|
||||
* if( xBytesSent != strlen( pcStringToSend ) )
|
||||
* {
|
||||
* // The string could not be added to the message buffer because there was
|
||||
* // not enough free space in the buffer.
|
||||
* }
|
||||
*
|
||||
* // If xHigherPriorityTaskWoken was set to pdTRUE inside
|
||||
* // xMessageBufferSendFromISR() then a task that has a priority above the
|
||||
* // priority of the currently executing task was unblocked and a context
|
||||
* // switch should be performed to ensure the ISR returns to the unblocked
|
||||
* // task. In most FreeRTOS ports this is done by simply passing
|
||||
* // xHigherPriorityTaskWoken into portYIELD_FROM_ISR(), which will test the
|
||||
* // variables value, and perform the context switch if necessary. Check the
|
||||
* // documentation for the port in use for port specific instructions.
|
||||
* portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup xMessageBufferSendFromISR xMessageBufferSendFromISR
|
||||
* \ingroup MessageBufferManagement
|
||||
*/
|
||||
#define xMessageBufferSendFromISR( xMessageBuffer, pvTxData, xDataLengthBytes, pxHigherPriorityTaskWoken ) \
|
||||
xStreamBufferSendFromISR( ( xMessageBuffer ), ( pvTxData ), ( xDataLengthBytes ), ( pxHigherPriorityTaskWoken ) )
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
*
|
||||
* @code{c}
|
||||
* size_t xMessageBufferReceive( MessageBufferHandle_t xMessageBuffer,
|
||||
* void *pvRxData,
|
||||
* size_t xBufferLengthBytes,
|
||||
* TickType_t xTicksToWait );
|
||||
* @endcode
|
||||
*
|
||||
* Receives a discrete message from a message buffer. Messages can be of
|
||||
* variable length and are copied out of the buffer.
|
||||
*
|
||||
* ***NOTE***: Uniquely among FreeRTOS objects, the stream buffer
|
||||
* implementation (so also the message buffer implementation, as message buffers
|
||||
* are built on top of stream buffers) assumes there is only one task or
|
||||
* interrupt that will write to the buffer (the writer), and only one task or
|
||||
* interrupt that will read from the buffer (the reader). It is safe for the
|
||||
* writer and reader to be different tasks or interrupts, but, unlike other
|
||||
* FreeRTOS objects, it is not safe to have multiple different writers or
|
||||
* multiple different readers. If there are to be multiple different writers
|
||||
* then the application writer must serialize calls to writing API functions
|
||||
* (such as xStreamBufferSend()). Likewise, if there are to be multiple
|
||||
* different readers then the application writer must serialize calls to reading
|
||||
* API functions (such as xStreamBufferReceive()). One way to achieve such
|
||||
* serialization in single core or SMP kernel is to place each API call inside a
|
||||
* critical section and use a block time of 0.
|
||||
*
|
||||
* Use xMessageBufferReceive() to read from a message buffer from a task. Use
|
||||
* xMessageBufferReceiveFromISR() to read from a message buffer from an
|
||||
* interrupt service routine (ISR).
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferReceive() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the message buffer from which a message
|
||||
* is being received.
|
||||
*
|
||||
* @param pvRxData A pointer to the buffer into which the received message is
|
||||
* to be copied.
|
||||
*
|
||||
* @param xBufferLengthBytes The length of the buffer pointed to by the pvRxData
|
||||
* parameter. This sets the maximum length of the message that can be received.
|
||||
* If xBufferLengthBytes is too small to hold the next message then the message
|
||||
* will be left in the message buffer and 0 will be returned.
|
||||
*
|
||||
* @param xTicksToWait The maximum amount of time the task should remain in the
|
||||
* Blocked state to wait for a message, should the message buffer be empty.
|
||||
* xMessageBufferReceive() will return immediately if xTicksToWait is zero and
|
||||
* the message buffer is empty. The block time is specified in tick periods, so
|
||||
* the absolute time it represents is dependent on the tick frequency. The
|
||||
* macro pdMS_TO_TICKS() can be used to convert a time specified in milliseconds
|
||||
* into a time specified in ticks. Setting xTicksToWait to portMAX_DELAY will
|
||||
* cause the task to wait indefinitely (without timing out), provided
|
||||
* INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h. Tasks do not use any
|
||||
* CPU time when they are in the Blocked state.
|
||||
*
|
||||
* @return The length, in bytes, of the message read from the message buffer, if
|
||||
* any. If xMessageBufferReceive() times out before a message became available
|
||||
* then zero is returned. If the length of the message is greater than
|
||||
* xBufferLengthBytes then the message will be left in the message buffer and
|
||||
* zero is returned.
|
||||
*
|
||||
* Example use:
|
||||
* @code{c}
|
||||
* void vAFunction( MessageBuffer_t xMessageBuffer )
|
||||
* {
|
||||
* uint8_t ucRxData[ 20 ];
|
||||
* size_t xReceivedBytes;
|
||||
* const TickType_t xBlockTime = pdMS_TO_TICKS( 20 );
|
||||
*
|
||||
* // Receive the next message from the message buffer. Wait in the Blocked
|
||||
* // state (so not using any CPU processing time) for a maximum of 100ms for
|
||||
* // a message to become available.
|
||||
* xReceivedBytes = xMessageBufferReceive( xMessageBuffer,
|
||||
* ( void * ) ucRxData,
|
||||
* sizeof( ucRxData ),
|
||||
* xBlockTime );
|
||||
*
|
||||
* if( xReceivedBytes > 0 )
|
||||
* {
|
||||
* // A ucRxData contains a message that is xReceivedBytes long. Process
|
||||
* // the message here....
|
||||
* }
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup xMessageBufferReceive xMessageBufferReceive
|
||||
* \ingroup MessageBufferManagement
|
||||
*/
|
||||
#define xMessageBufferReceive( xMessageBuffer, pvRxData, xBufferLengthBytes, xTicksToWait ) \
|
||||
xStreamBufferReceive( ( xMessageBuffer ), ( pvRxData ), ( xBufferLengthBytes ), ( xTicksToWait ) )
|
||||
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
*
|
||||
* @code{c}
|
||||
* size_t xMessageBufferReceiveFromISR( MessageBufferHandle_t xMessageBuffer,
|
||||
* void *pvRxData,
|
||||
* size_t xBufferLengthBytes,
|
||||
* BaseType_t *pxHigherPriorityTaskWoken );
|
||||
* @endcode
|
||||
*
|
||||
* An interrupt safe version of the API function that receives a discrete
|
||||
* message from a message buffer. Messages can be of variable length and are
|
||||
* copied out of the buffer.
|
||||
*
|
||||
* ***NOTE***: Uniquely among FreeRTOS objects, the stream buffer
|
||||
* implementation (so also the message buffer implementation, as message buffers
|
||||
* are built on top of stream buffers) assumes there is only one task or
|
||||
* interrupt that will write to the buffer (the writer), and only one task or
|
||||
* interrupt that will read from the buffer (the reader). It is safe for the
|
||||
* writer and reader to be different tasks or interrupts, but, unlike other
|
||||
* FreeRTOS objects, it is not safe to have multiple different writers or
|
||||
* multiple different readers. If there are to be multiple different writers
|
||||
* then the application writer must serialize calls to writing API functions
|
||||
* (such as xStreamBufferSend()). Likewise, if there are to be multiple
|
||||
* different readers then the application writer must serialize calls to reading
|
||||
* API functions (such as xStreamBufferReceive()). One way to achieve such
|
||||
* serialization in single core or SMP kernel is to place each API call inside a
|
||||
* critical section and use a block time of 0.
|
||||
*
|
||||
* Use xMessageBufferReceive() to read from a message buffer from a task. Use
|
||||
* xMessageBufferReceiveFromISR() to read from a message buffer from an
|
||||
* interrupt service routine (ISR).
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferReceiveFromISR() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the message buffer from which a message
|
||||
* is being received.
|
||||
*
|
||||
* @param pvRxData A pointer to the buffer into which the received message is
|
||||
* to be copied.
|
||||
*
|
||||
* @param xBufferLengthBytes The length of the buffer pointed to by the pvRxData
|
||||
* parameter. This sets the maximum length of the message that can be received.
|
||||
* If xBufferLengthBytes is too small to hold the next message then the message
|
||||
* will be left in the message buffer and 0 will be returned.
|
||||
*
|
||||
* @param pxHigherPriorityTaskWoken It is possible that a message buffer will
|
||||
* have a task blocked on it waiting for space to become available. Calling
|
||||
* xMessageBufferReceiveFromISR() can make space available, and so cause a task
|
||||
* that is waiting for space to leave the Blocked state. If calling
|
||||
* xMessageBufferReceiveFromISR() causes a task to leave the Blocked state, and
|
||||
* the unblocked task has a priority higher than the currently executing task
|
||||
* (the task that was interrupted), then, internally,
|
||||
* xMessageBufferReceiveFromISR() will set *pxHigherPriorityTaskWoken to pdTRUE.
|
||||
* If xMessageBufferReceiveFromISR() sets this value to pdTRUE, then normally a
|
||||
* context switch should be performed before the interrupt is exited. That will
|
||||
* ensure the interrupt returns directly to the highest priority Ready state
|
||||
* task. *pxHigherPriorityTaskWoken should be set to pdFALSE before it is
|
||||
* passed into the function. See the code example below for an example.
|
||||
*
|
||||
* @return The length, in bytes, of the message read from the message buffer, if
|
||||
* any.
|
||||
*
|
||||
* Example use:
|
||||
* @code{c}
|
||||
* // A message buffer that has already been created.
|
||||
* MessageBuffer_t xMessageBuffer;
|
||||
*
|
||||
* void vAnInterruptServiceRoutine( void )
|
||||
* {
|
||||
* uint8_t ucRxData[ 20 ];
|
||||
* size_t xReceivedBytes;
|
||||
* BaseType_t xHigherPriorityTaskWoken = pdFALSE; // Initialised to pdFALSE.
|
||||
*
|
||||
* // Receive the next message from the message buffer.
|
||||
* xReceivedBytes = xMessageBufferReceiveFromISR( xMessageBuffer,
|
||||
* ( void * ) ucRxData,
|
||||
* sizeof( ucRxData ),
|
||||
* &xHigherPriorityTaskWoken );
|
||||
*
|
||||
* if( xReceivedBytes > 0 )
|
||||
* {
|
||||
* // A ucRxData contains a message that is xReceivedBytes long. Process
|
||||
* // the message here....
|
||||
* }
|
||||
*
|
||||
* // If xHigherPriorityTaskWoken was set to pdTRUE inside
|
||||
* // xMessageBufferReceiveFromISR() then a task that has a priority above the
|
||||
* // priority of the currently executing task was unblocked and a context
|
||||
* // switch should be performed to ensure the ISR returns to the unblocked
|
||||
* // task. In most FreeRTOS ports this is done by simply passing
|
||||
* // xHigherPriorityTaskWoken into portYIELD_FROM_ISR(), which will test the
|
||||
* // variables value, and perform the context switch if necessary. Check the
|
||||
* // documentation for the port in use for port specific instructions.
|
||||
* portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
|
||||
* }
|
||||
* @endcode
|
||||
* \defgroup xMessageBufferReceiveFromISR xMessageBufferReceiveFromISR
|
||||
* \ingroup MessageBufferManagement
|
||||
*/
|
||||
#define xMessageBufferReceiveFromISR( xMessageBuffer, pvRxData, xBufferLengthBytes, pxHigherPriorityTaskWoken ) \
|
||||
xStreamBufferReceiveFromISR( ( xMessageBuffer ), ( pvRxData ), ( xBufferLengthBytes ), ( pxHigherPriorityTaskWoken ) )
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
*
|
||||
* @code{c}
|
||||
* void vMessageBufferDelete( MessageBufferHandle_t xMessageBuffer );
|
||||
* @endcode
|
||||
*
|
||||
* Deletes a message buffer that was previously created using a call to
|
||||
* xMessageBufferCreate() or xMessageBufferCreateStatic(). If the message
|
||||
* buffer was created using dynamic memory (that is, by xMessageBufferCreate()),
|
||||
* then the allocated memory is freed.
|
||||
*
|
||||
* A message buffer handle must not be used after the message buffer has been
|
||||
* deleted.
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* vMessageBufferDelete() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the message buffer to be deleted.
|
||||
*
|
||||
*/
|
||||
#define vMessageBufferDelete( xMessageBuffer ) \
|
||||
vStreamBufferDelete( xMessageBuffer )
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
* @code{c}
|
||||
* BaseType_t xMessageBufferIsFull( MessageBufferHandle_t xMessageBuffer );
|
||||
* @endcode
|
||||
*
|
||||
* Tests to see if a message buffer is full. A message buffer is full if it
|
||||
* cannot accept any more messages, of any size, until space is made available
|
||||
* by a message being removed from the message buffer.
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferIsFull() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the message buffer being queried.
|
||||
*
|
||||
* @return If the message buffer referenced by xMessageBuffer is full then
|
||||
* pdTRUE is returned. Otherwise pdFALSE is returned.
|
||||
*/
|
||||
#define xMessageBufferIsFull( xMessageBuffer ) \
|
||||
xStreamBufferIsFull( xMessageBuffer )
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
* @code{c}
|
||||
* BaseType_t xMessageBufferIsEmpty( MessageBufferHandle_t xMessageBuffer );
|
||||
* @endcode
|
||||
*
|
||||
* Tests to see if a message buffer is empty (does not contain any messages).
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferIsEmpty() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the message buffer being queried.
|
||||
*
|
||||
* @return If the message buffer referenced by xMessageBuffer is empty then
|
||||
* pdTRUE is returned. Otherwise pdFALSE is returned.
|
||||
*
|
||||
*/
|
||||
#define xMessageBufferIsEmpty( xMessageBuffer ) \
|
||||
xStreamBufferIsEmpty( xMessageBuffer )
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
* @code{c}
|
||||
* BaseType_t xMessageBufferReset( MessageBufferHandle_t xMessageBuffer );
|
||||
* @endcode
|
||||
*
|
||||
* Resets a message buffer to its initial empty state, discarding any message it
|
||||
* contained.
|
||||
*
|
||||
* A message buffer can only be reset if there are no tasks blocked on it.
|
||||
*
|
||||
* Use xMessageBufferReset() to reset a message buffer from a task.
|
||||
* Use xMessageBufferResetFromISR() to reset a message buffer from an
|
||||
* interrupt service routine (ISR).
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferReset() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the message buffer being reset.
|
||||
*
|
||||
* @return If the message buffer was reset then pdPASS is returned. If the
|
||||
* message buffer could not be reset because either there was a task blocked on
|
||||
* the message queue to wait for space to become available, or to wait for a
|
||||
* a message to be available, then pdFAIL is returned.
|
||||
*
|
||||
* \defgroup xMessageBufferReset xMessageBufferReset
|
||||
* \ingroup MessageBufferManagement
|
||||
*/
|
||||
#define xMessageBufferReset( xMessageBuffer ) \
|
||||
xStreamBufferReset( xMessageBuffer )
|
||||
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
* @code{c}
|
||||
* BaseType_t xMessageBufferResetFromISR( MessageBufferHandle_t xMessageBuffer );
|
||||
* @endcode
|
||||
*
|
||||
* An interrupt safe version of the API function that resets the message buffer.
|
||||
* Resets a message buffer to its initial empty state, discarding any message it
|
||||
* contained.
|
||||
*
|
||||
* A message buffer can only be reset if there are no tasks blocked on it.
|
||||
*
|
||||
* Use xMessageBufferReset() to reset a message buffer from a task.
|
||||
* Use xMessageBufferResetFromISR() to reset a message buffer from an
|
||||
* interrupt service routine (ISR).
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferResetFromISR() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the message buffer being reset.
|
||||
*
|
||||
* @return If the message buffer was reset then pdPASS is returned. If the
|
||||
* message buffer could not be reset because either there was a task blocked on
|
||||
* the message queue to wait for space to become available, or to wait for a
|
||||
* a message to be available, then pdFAIL is returned.
|
||||
*
|
||||
* \defgroup xMessageBufferResetFromISR xMessageBufferResetFromISR
|
||||
* \ingroup MessageBufferManagement
|
||||
*/
|
||||
#define xMessageBufferResetFromISR( xMessageBuffer ) \
|
||||
xStreamBufferResetFromISR( xMessageBuffer )
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
* @code{c}
|
||||
* size_t xMessageBufferSpaceAvailable( MessageBufferHandle_t xMessageBuffer );
|
||||
* @endcode
|
||||
* Returns the number of bytes of free space in the message buffer.
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferSpaceAvailable() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the message buffer being queried.
|
||||
*
|
||||
* @return The number of bytes that can be written to the message buffer before
|
||||
* the message buffer would be full. When a message is written to the message
|
||||
* buffer an additional sizeof( size_t ) bytes are also written to store the
|
||||
* message's length. sizeof( size_t ) is typically 4 bytes on a 32-bit
|
||||
* architecture, so if xMessageBufferSpacesAvailable() returns 10, then the size
|
||||
* of the largest message that can be written to the message buffer is 6 bytes.
|
||||
*
|
||||
* \defgroup xMessageBufferSpaceAvailable xMessageBufferSpaceAvailable
|
||||
* \ingroup MessageBufferManagement
|
||||
*/
|
||||
#define xMessageBufferSpaceAvailable( xMessageBuffer ) \
|
||||
xStreamBufferSpacesAvailable( xMessageBuffer )
|
||||
#define xMessageBufferSpacesAvailable( xMessageBuffer ) \
|
||||
xStreamBufferSpacesAvailable( xMessageBuffer ) /* Corrects typo in original macro name. */
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
* @code{c}
|
||||
* size_t xMessageBufferNextLengthBytes( MessageBufferHandle_t xMessageBuffer );
|
||||
* @endcode
|
||||
* Returns the length (in bytes) of the next message in a message buffer.
|
||||
* Useful if xMessageBufferReceive() returned 0 because the size of the buffer
|
||||
* passed into xMessageBufferReceive() was too small to hold the next message.
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferNextLengthBytes() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the message buffer being queried.
|
||||
*
|
||||
* @return The length (in bytes) of the next message in the message buffer, or 0
|
||||
* if the message buffer is empty.
|
||||
*
|
||||
* \defgroup xMessageBufferNextLengthBytes xMessageBufferNextLengthBytes
|
||||
* \ingroup MessageBufferManagement
|
||||
*/
|
||||
#define xMessageBufferNextLengthBytes( xMessageBuffer ) \
|
||||
xStreamBufferNextMessageLengthBytes( xMessageBuffer )
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
*
|
||||
* @code{c}
|
||||
* BaseType_t xMessageBufferSendCompletedFromISR( MessageBufferHandle_t xMessageBuffer, BaseType_t *pxHigherPriorityTaskWoken );
|
||||
* @endcode
|
||||
*
|
||||
* For advanced users only.
|
||||
*
|
||||
* The sbSEND_COMPLETED() macro is called from within the FreeRTOS APIs when
|
||||
* data is sent to a message buffer or stream buffer. If there was a task that
|
||||
* was blocked on the message or stream buffer waiting for data to arrive then
|
||||
* the sbSEND_COMPLETED() macro sends a notification to the task to remove it
|
||||
* from the Blocked state. xMessageBufferSendCompletedFromISR() does the same
|
||||
* thing. It is provided to enable application writers to implement their own
|
||||
* version of sbSEND_COMPLETED(), and MUST NOT BE USED AT ANY OTHER TIME.
|
||||
*
|
||||
* See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for
|
||||
* additional information.
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferSendCompletedFromISR() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the stream buffer to which data was
|
||||
* written.
|
||||
*
|
||||
* @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be
|
||||
* initialised to pdFALSE before it is passed into
|
||||
* xMessageBufferSendCompletedFromISR(). If calling
|
||||
* xMessageBufferSendCompletedFromISR() removes a task from the Blocked state,
|
||||
* and the task has a priority above the priority of the currently running task,
|
||||
* then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a
|
||||
* context switch should be performed before exiting the ISR.
|
||||
*
|
||||
* @return If a task was removed from the Blocked state then pdTRUE is returned.
|
||||
* Otherwise pdFALSE is returned.
|
||||
*
|
||||
* \defgroup xMessageBufferSendCompletedFromISR xMessageBufferSendCompletedFromISR
|
||||
* \ingroup StreamBufferManagement
|
||||
*/
|
||||
#define xMessageBufferSendCompletedFromISR( xMessageBuffer, pxHigherPriorityTaskWoken ) \
|
||||
xStreamBufferSendCompletedFromISR( ( xMessageBuffer ), ( pxHigherPriorityTaskWoken ) )
|
||||
|
||||
/**
|
||||
* message_buffer.h
|
||||
*
|
||||
* @code{c}
|
||||
* BaseType_t xMessageBufferReceiveCompletedFromISR( MessageBufferHandle_t xMessageBuffer, BaseType_t *pxHigherPriorityTaskWoken );
|
||||
* @endcode
|
||||
*
|
||||
* For advanced users only.
|
||||
*
|
||||
* The sbRECEIVE_COMPLETED() macro is called from within the FreeRTOS APIs when
|
||||
* data is read out of a message buffer or stream buffer. If there was a task
|
||||
* that was blocked on the message or stream buffer waiting for data to arrive
|
||||
* then the sbRECEIVE_COMPLETED() macro sends a notification to the task to
|
||||
* remove it from the Blocked state. xMessageBufferReceiveCompletedFromISR()
|
||||
* does the same thing. It is provided to enable application writers to
|
||||
* implement their own version of sbRECEIVE_COMPLETED(), and MUST NOT BE USED AT
|
||||
* ANY OTHER TIME.
|
||||
*
|
||||
* See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for
|
||||
* additional information.
|
||||
*
|
||||
* configUSE_STREAM_BUFFERS must be set to 1 in for FreeRTOSConfig.h for
|
||||
* xMessageBufferReceiveCompletedFromISR() to be available.
|
||||
*
|
||||
* @param xMessageBuffer The handle of the stream buffer from which data was
|
||||
* read.
|
||||
*
|
||||
* @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be
|
||||
* initialised to pdFALSE before it is passed into
|
||||
* xMessageBufferReceiveCompletedFromISR(). If calling
|
||||
* xMessageBufferReceiveCompletedFromISR() removes a task from the Blocked state,
|
||||
* and the task has a priority above the priority of the currently running task,
|
||||
* then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a
|
||||
* context switch should be performed before exiting the ISR.
|
||||
*
|
||||
* @return If a task was removed from the Blocked state then pdTRUE is returned.
|
||||
* Otherwise pdFALSE is returned.
|
||||
*
|
||||
* \defgroup xMessageBufferReceiveCompletedFromISR xMessageBufferReceiveCompletedFromISR
|
||||
* \ingroup StreamBufferManagement
|
||||
*/
|
||||
#define xMessageBufferReceiveCompletedFromISR( xMessageBuffer, pxHigherPriorityTaskWoken ) \
|
||||
xStreamBufferReceiveCompletedFromISR( ( xMessageBuffer ), ( pxHigherPriorityTaskWoken ) )
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#if defined( __cplusplus )
|
||||
} /* extern "C" */
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
#endif /* !defined( FREERTOS_MESSAGE_BUFFER_H ) */
|
||||
+495
@@ -0,0 +1,495 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* When the MPU is used the standard (non MPU) API functions are mapped to
|
||||
* equivalents that start "MPU_", the prototypes for which are defined in this
|
||||
* header files. This will cause the application code to call the MPU_ version
|
||||
* which wraps the non-MPU version with privilege promoting then demoting code,
|
||||
* so the kernel code always runs will full privileges.
|
||||
*/
|
||||
|
||||
|
||||
#ifndef MPU_PROTOTYPES_H
|
||||
#define MPU_PROTOTYPES_H
|
||||
|
||||
typedef struct xTaskGenericNotifyParams
|
||||
{
|
||||
TaskHandle_t xTaskToNotify;
|
||||
UBaseType_t uxIndexToNotify;
|
||||
uint32_t ulValue;
|
||||
eNotifyAction eAction;
|
||||
uint32_t * pulPreviousNotificationValue;
|
||||
} xTaskGenericNotifyParams_t;
|
||||
|
||||
typedef struct xTaskGenericNotifyWaitParams
|
||||
{
|
||||
UBaseType_t uxIndexToWaitOn;
|
||||
uint32_t ulBitsToClearOnEntry;
|
||||
uint32_t ulBitsToClearOnExit;
|
||||
uint32_t * pulNotificationValue;
|
||||
TickType_t xTicksToWait;
|
||||
} xTaskGenericNotifyWaitParams_t;
|
||||
|
||||
typedef struct xTimerGenericCommandFromTaskParams
|
||||
{
|
||||
TimerHandle_t xTimer;
|
||||
BaseType_t xCommandID;
|
||||
TickType_t xOptionalValue;
|
||||
BaseType_t * pxHigherPriorityTaskWoken;
|
||||
TickType_t xTicksToWait;
|
||||
} xTimerGenericCommandFromTaskParams_t;
|
||||
|
||||
typedef struct xEventGroupWaitBitsParams
|
||||
{
|
||||
EventGroupHandle_t xEventGroup;
|
||||
EventBits_t uxBitsToWaitFor;
|
||||
BaseType_t xClearOnExit;
|
||||
BaseType_t xWaitForAllBits;
|
||||
TickType_t xTicksToWait;
|
||||
} xEventGroupWaitBitsParams_t;
|
||||
|
||||
/* MPU versions of task.h API functions. */
|
||||
void MPU_vTaskDelay( const TickType_t xTicksToDelay ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
|
||||
const TickType_t xTimeIncrement ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
|
||||
UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
|
||||
eTaskState MPU_eTaskGetState( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTaskGetInfo( TaskHandle_t xTask,
|
||||
TaskStatus_t * pxTaskStatus,
|
||||
BaseType_t xGetFreeStackSpace,
|
||||
eTaskState eState ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTaskSuspend( TaskHandle_t xTaskToSuspend ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTaskResume( TaskHandle_t xTaskToResume ) FREERTOS_SYSTEM_CALL;
|
||||
TickType_t MPU_xTaskGetTickCount( void ) FREERTOS_SYSTEM_CALL;
|
||||
UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) FREERTOS_SYSTEM_CALL;
|
||||
UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
|
||||
configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask,
|
||||
TaskHookFunction_t pxHookFunction ) FREERTOS_SYSTEM_CALL;
|
||||
TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet,
|
||||
BaseType_t xIndex,
|
||||
void * pvValue ) FREERTOS_SYSTEM_CALL;
|
||||
void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery,
|
||||
BaseType_t xIndex ) FREERTOS_SYSTEM_CALL;
|
||||
TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) FREERTOS_SYSTEM_CALL;
|
||||
UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray,
|
||||
const UBaseType_t uxArraySize,
|
||||
configRUN_TIME_COUNTER_TYPE * const pulTotalRunTime ) FREERTOS_SYSTEM_CALL;
|
||||
configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimeCounter( const TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
|
||||
configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetRunTimePercent( const TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;
|
||||
configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimeCounter( void ) FREERTOS_SYSTEM_CALL;
|
||||
configRUN_TIME_COUNTER_TYPE MPU_ulTaskGetIdleRunTimePercent( void ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify,
|
||||
UBaseType_t uxIndexToNotify,
|
||||
uint32_t ulValue,
|
||||
eNotifyAction eAction,
|
||||
uint32_t * pulPreviousNotificationValue ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTaskGenericNotifyEntry( const xTaskGenericNotifyParams_t * pxParams ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTaskGenericNotifyWait( UBaseType_t uxIndexToWaitOn,
|
||||
uint32_t ulBitsToClearOnEntry,
|
||||
uint32_t ulBitsToClearOnExit,
|
||||
uint32_t * pulNotificationValue,
|
||||
TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTaskGenericNotifyWaitEntry( const xTaskGenericNotifyWaitParams_t * pxParams ) FREERTOS_SYSTEM_CALL;
|
||||
uint32_t MPU_ulTaskGenericNotifyTake( UBaseType_t uxIndexToWaitOn,
|
||||
BaseType_t xClearCountOnExit,
|
||||
TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTaskGenericNotifyStateClear( TaskHandle_t xTask,
|
||||
UBaseType_t uxIndexToClear ) FREERTOS_SYSTEM_CALL;
|
||||
uint32_t MPU_ulTaskGenericNotifyValueClear( TaskHandle_t xTask,
|
||||
UBaseType_t uxIndexToClear,
|
||||
uint32_t ulBitsToClear ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut,
|
||||
TickType_t * const pxTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTaskGetSchedulerState( void ) FREERTOS_SYSTEM_CALL;
|
||||
|
||||
/* Privileged only wrappers for Task APIs. These are needed so that
|
||||
* the application can use opaque handles maintained in mpu_wrappers.c
|
||||
* with all the APIs. */
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 1 )
|
||||
|
||||
BaseType_t MPU_xTaskCreate( TaskFunction_t pxTaskCode,
|
||||
const char * const pcName,
|
||||
const configSTACK_DEPTH_TYPE uxStackDepth,
|
||||
void * const pvParameters,
|
||||
UBaseType_t uxPriority,
|
||||
TaskHandle_t * const pxCreatedTask ) FREERTOS_SYSTEM_CALL;
|
||||
TaskHandle_t MPU_xTaskCreateStatic( TaskFunction_t pxTaskCode,
|
||||
const char * const pcName,
|
||||
const configSTACK_DEPTH_TYPE uxStackDepth,
|
||||
void * const pvParameters,
|
||||
UBaseType_t uxPriority,
|
||||
StackType_t * const puxStackBuffer,
|
||||
StaticTask_t * const pxTaskBuffer ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTaskDelete( TaskHandle_t xTaskToDelete ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTaskPrioritySet( TaskHandle_t xTask,
|
||||
UBaseType_t uxNewPriority ) FREERTOS_SYSTEM_CALL;
|
||||
TaskHandle_t MPU_xTaskGetHandle( const char * pcNameToQuery ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask,
|
||||
void * pvParameter ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTaskGetRunTimeStatistics( char * pcWriteBuffer,
|
||||
size_t uxBufferLength ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTaskListTasks( char * pcWriteBuffer,
|
||||
size_t uxBufferLength ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTaskSuspendAll( void ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTaskResumeAll( void ) FREERTOS_SYSTEM_CALL;
|
||||
|
||||
#else /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
|
||||
|
||||
BaseType_t MPU_xTaskCreate( TaskFunction_t pxTaskCode,
|
||||
const char * const pcName,
|
||||
const configSTACK_DEPTH_TYPE uxStackDepth,
|
||||
void * const pvParameters,
|
||||
UBaseType_t uxPriority,
|
||||
TaskHandle_t * const pxCreatedTask ) PRIVILEGED_FUNCTION;
|
||||
TaskHandle_t MPU_xTaskCreateStatic( TaskFunction_t pxTaskCode,
|
||||
const char * const pcName,
|
||||
const configSTACK_DEPTH_TYPE uxStackDepth,
|
||||
void * const pvParameters,
|
||||
UBaseType_t uxPriority,
|
||||
StackType_t * const puxStackBuffer,
|
||||
StaticTask_t * const pxTaskBuffer ) PRIVILEGED_FUNCTION;
|
||||
void MPU_vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;
|
||||
void MPU_vTaskPrioritySet( TaskHandle_t xTask,
|
||||
UBaseType_t uxNewPriority ) PRIVILEGED_FUNCTION;
|
||||
TaskHandle_t MPU_xTaskGetHandle( const char * pcNameToQuery ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask,
|
||||
void * pvParameter ) PRIVILEGED_FUNCTION;
|
||||
|
||||
#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
|
||||
|
||||
char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition,
|
||||
TaskHandle_t * pxCreatedTask ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition,
|
||||
TaskHandle_t * pxCreatedTask ) PRIVILEGED_FUNCTION;
|
||||
void MPU_vTaskAllocateMPURegions( TaskHandle_t xTaskToModify,
|
||||
const MemoryRegion_t * const xRegions ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xTaskGetStaticBuffers( TaskHandle_t xTask,
|
||||
StackType_t ** ppuxStackBuffer,
|
||||
StaticTask_t ** ppxTaskBuffer ) PRIVILEGED_FUNCTION;
|
||||
UBaseType_t MPU_uxTaskPriorityGetFromISR( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
|
||||
UBaseType_t MPU_uxTaskBasePriorityGet( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
|
||||
UBaseType_t MPU_uxTaskBasePriorityGetFromISR( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xTaskResumeFromISR( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
|
||||
TaskHookFunction_t MPU_xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify,
|
||||
UBaseType_t uxIndexToNotify,
|
||||
uint32_t ulValue,
|
||||
eNotifyAction eAction,
|
||||
uint32_t * pulPreviousNotificationValue,
|
||||
BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
|
||||
void MPU_vTaskGenericNotifyGiveFromISR( TaskHandle_t xTaskToNotify,
|
||||
UBaseType_t uxIndexToNotify,
|
||||
BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/* MPU versions of queue.h API functions. */
|
||||
BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue,
|
||||
const void * const pvItemToQueue,
|
||||
TickType_t xTicksToWait,
|
||||
const BaseType_t xCopyPosition ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xQueueReceive( QueueHandle_t xQueue,
|
||||
void * const pvBuffer,
|
||||
TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue,
|
||||
void * const pvBuffer,
|
||||
TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue,
|
||||
TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
|
||||
UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
|
||||
TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex,
|
||||
TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vQueueAddToRegistry( QueueHandle_t xQueue,
|
||||
const char * pcName ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
|
||||
const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
|
||||
QueueSetHandle_t xQueueSet ) FREERTOS_SYSTEM_CALL;
|
||||
QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
|
||||
const TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vQueueSetQueueNumber( QueueHandle_t xQueue,
|
||||
UBaseType_t uxQueueNumber ) FREERTOS_SYSTEM_CALL;
|
||||
UBaseType_t MPU_uxQueueGetQueueNumber( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
|
||||
uint8_t MPU_ucQueueGetQueueType( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
|
||||
|
||||
/* Privileged only wrappers for Queue APIs. These are needed so that
|
||||
* the application can use opaque handles maintained in mpu_wrappers.c
|
||||
* with all the APIs. */
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 1 )
|
||||
|
||||
void MPU_vQueueDelete( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;
|
||||
QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) FREERTOS_SYSTEM_CALL;
|
||||
QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType,
|
||||
StaticQueue_t * pxStaticQueue ) FREERTOS_SYSTEM_CALL;
|
||||
QueueHandle_t MPU_xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount,
|
||||
const UBaseType_t uxInitialCount ) FREERTOS_SYSTEM_CALL;
|
||||
QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,
|
||||
const UBaseType_t uxInitialCount,
|
||||
StaticQueue_t * pxStaticQueue ) FREERTOS_SYSTEM_CALL;
|
||||
QueueHandle_t MPU_xQueueGenericCreate( const UBaseType_t uxQueueLength,
|
||||
const UBaseType_t uxItemSize,
|
||||
const uint8_t ucQueueType ) FREERTOS_SYSTEM_CALL;
|
||||
QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,
|
||||
const UBaseType_t uxItemSize,
|
||||
uint8_t * pucQueueStorage,
|
||||
StaticQueue_t * pxStaticQueue,
|
||||
const uint8_t ucQueueType ) FREERTOS_SYSTEM_CALL;
|
||||
QueueSetHandle_t MPU_xQueueCreateSet( const UBaseType_t uxEventQueueLength ) FREERTOS_SYSTEM_CALL;
|
||||
QueueSetHandle_t MPU_xQueueCreateSetStatic( const UBaseType_t uxEventQueueLength,
|
||||
uint8_t * pucQueueStorage,
|
||||
StaticQueue_t * pxStaticQueue ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
|
||||
QueueSetHandle_t xQueueSet ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xQueueGenericReset( QueueHandle_t xQueue,
|
||||
BaseType_t xNewQueue ) FREERTOS_SYSTEM_CALL;
|
||||
|
||||
#else /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
|
||||
|
||||
void MPU_vQueueDelete( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
|
||||
QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;
|
||||
QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType,
|
||||
StaticQueue_t * pxStaticQueue ) PRIVILEGED_FUNCTION;
|
||||
QueueHandle_t MPU_xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount,
|
||||
const UBaseType_t uxInitialCount ) PRIVILEGED_FUNCTION;
|
||||
QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount,
|
||||
const UBaseType_t uxInitialCount,
|
||||
StaticQueue_t * pxStaticQueue ) PRIVILEGED_FUNCTION;
|
||||
QueueHandle_t MPU_xQueueGenericCreate( const UBaseType_t uxQueueLength,
|
||||
const UBaseType_t uxItemSize,
|
||||
const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;
|
||||
QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength,
|
||||
const UBaseType_t uxItemSize,
|
||||
uint8_t * pucQueueStorage,
|
||||
StaticQueue_t * pxStaticQueue,
|
||||
const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;
|
||||
QueueSetHandle_t MPU_xQueueCreateSet( const UBaseType_t uxEventQueueLength ) PRIVILEGED_FUNCTION;
|
||||
QueueSetHandle_t MPU_xQueueCreateSetStatic( const UBaseType_t uxEventQueueLength,
|
||||
uint8_t * pucQueueStorage,
|
||||
StaticQueue_t * pxStaticQueue ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore,
|
||||
QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xQueueGenericReset( QueueHandle_t xQueue,
|
||||
BaseType_t xNewQueue ) PRIVILEGED_FUNCTION;
|
||||
|
||||
#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
|
||||
|
||||
BaseType_t MPU_xQueueGenericGetStaticBuffers( QueueHandle_t xQueue,
|
||||
uint8_t ** ppucQueueStorage,
|
||||
StaticQueue_t ** ppxStaticQueue ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xQueueGenericSendFromISR( QueueHandle_t xQueue,
|
||||
const void * const pvItemToQueue,
|
||||
BaseType_t * const pxHigherPriorityTaskWoken,
|
||||
const BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xQueueGiveFromISR( QueueHandle_t xQueue,
|
||||
BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xQueuePeekFromISR( QueueHandle_t xQueue,
|
||||
void * const pvBuffer ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xQueueReceiveFromISR( QueueHandle_t xQueue,
|
||||
void * const pvBuffer,
|
||||
BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xQueueIsQueueFullFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
|
||||
UBaseType_t MPU_uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;
|
||||
TaskHandle_t MPU_xQueueGetMutexHolderFromISR( QueueHandle_t xSemaphore ) PRIVILEGED_FUNCTION;
|
||||
QueueSetMemberHandle_t MPU_xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/* MPU versions of timers.h API functions. */
|
||||
void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTimerSetTimerID( TimerHandle_t xTimer,
|
||||
void * pvNewID ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
|
||||
TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTimerGenericCommandFromTask( TimerHandle_t xTimer,
|
||||
const BaseType_t xCommandID,
|
||||
const TickType_t xOptionalValue,
|
||||
BaseType_t * const pxHigherPriorityTaskWoken,
|
||||
const TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTimerGenericCommandFromTaskEntry( const xTimerGenericCommandFromTaskParams_t * pxParams ) FREERTOS_SYSTEM_CALL;
|
||||
const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vTimerSetReloadMode( TimerHandle_t xTimer,
|
||||
const BaseType_t xAutoReload ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xTimerGetReloadMode( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
|
||||
UBaseType_t MPU_uxTimerGetReloadMode( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
|
||||
TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
|
||||
TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;
|
||||
|
||||
/* Privileged only wrappers for Timer APIs. These are needed so that
|
||||
* the application can use opaque handles maintained in mpu_wrappers.c
|
||||
* with all the APIs. */
|
||||
TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName,
|
||||
const TickType_t xTimerPeriodInTicks,
|
||||
const BaseType_t xAutoReload,
|
||||
void * const pvTimerID,
|
||||
TimerCallbackFunction_t pxCallbackFunction ) PRIVILEGED_FUNCTION;
|
||||
TimerHandle_t MPU_xTimerCreateStatic( const char * const pcTimerName,
|
||||
const TickType_t xTimerPeriodInTicks,
|
||||
const BaseType_t xAutoReload,
|
||||
void * const pvTimerID,
|
||||
TimerCallbackFunction_t pxCallbackFunction,
|
||||
StaticTimer_t * pxTimerBuffer ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xTimerGetStaticBuffer( TimerHandle_t xTimer,
|
||||
StaticTimer_t ** ppxTimerBuffer ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xTimerGenericCommandFromISR( TimerHandle_t xTimer,
|
||||
const BaseType_t xCommandID,
|
||||
const TickType_t xOptionalValue,
|
||||
BaseType_t * const pxHigherPriorityTaskWoken,
|
||||
const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/* MPU versions of event_group.h API functions. */
|
||||
EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToWaitFor,
|
||||
const BaseType_t xClearOnExit,
|
||||
const BaseType_t xWaitForAllBits,
|
||||
TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
EventBits_t MPU_xEventGroupWaitBitsEntry( const xEventGroupWaitBitsParams_t * pxParams ) FREERTOS_SYSTEM_CALL;
|
||||
EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToClear ) FREERTOS_SYSTEM_CALL;
|
||||
EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToSet ) FREERTOS_SYSTEM_CALL;
|
||||
EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToSet,
|
||||
const EventBits_t uxBitsToWaitFor,
|
||||
TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
#if ( configUSE_TRACE_FACILITY == 1 )
|
||||
UBaseType_t MPU_uxEventGroupGetNumber( void * xEventGroup ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vEventGroupSetNumber( void * xEventGroup,
|
||||
UBaseType_t uxEventGroupNumber ) FREERTOS_SYSTEM_CALL;
|
||||
#endif /* #if ( configUSE_TRACE_FACILITY == 1 ) */
|
||||
|
||||
/* Privileged only wrappers for Event Group APIs. These are needed so that
|
||||
* the application can use opaque handles maintained in mpu_wrappers.c
|
||||
* with all the APIs. */
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 1 )
|
||||
|
||||
EventGroupHandle_t MPU_xEventGroupCreate( void ) FREERTOS_SYSTEM_CALL;
|
||||
EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) FREERTOS_SYSTEM_CALL;
|
||||
|
||||
#else /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
|
||||
|
||||
EventGroupHandle_t MPU_xEventGroupCreate( void ) PRIVILEGED_FUNCTION;
|
||||
EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t * pxEventGroupBuffer ) PRIVILEGED_FUNCTION;
|
||||
void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
|
||||
|
||||
#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
|
||||
|
||||
BaseType_t MPU_xEventGroupGetStaticBuffer( EventGroupHandle_t xEventGroup,
|
||||
StaticEventGroup_t ** ppxEventGroupBuffer ) PRIVILEGED_FUNCTION;
|
||||
EventBits_t MPU_xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
|
||||
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 0 )
|
||||
BaseType_t MPU_xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToClear ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
|
||||
const EventBits_t uxBitsToSet,
|
||||
BaseType_t * pxHigherPriorityTaskWoken ) FREERTOS_SYSTEM_CALL;
|
||||
#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
|
||||
|
||||
/* MPU versions of message/stream_buffer.h API functions. */
|
||||
size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,
|
||||
const void * pvTxData,
|
||||
size_t xDataLengthBytes,
|
||||
TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,
|
||||
void * pvRxData,
|
||||
size_t xBufferLengthBytes,
|
||||
TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
|
||||
size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
|
||||
size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer,
|
||||
size_t xTriggerLevel ) FREERTOS_SYSTEM_CALL;
|
||||
size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
|
||||
|
||||
/* Privileged only wrappers for Stream Buffer APIs. These are needed so that
|
||||
* the application can use opaque handles maintained in mpu_wrappers.c
|
||||
* with all the APIs. */
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 1 )
|
||||
|
||||
StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes,
|
||||
size_t xTriggerLevelBytes,
|
||||
BaseType_t xStreamBufferType,
|
||||
StreamBufferCallbackFunction_t pxSendCompletedCallback,
|
||||
StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) FREERTOS_SYSTEM_CALL;
|
||||
StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,
|
||||
size_t xTriggerLevelBytes,
|
||||
BaseType_t xStreamBufferType,
|
||||
uint8_t * const pucStreamBufferStorageArea,
|
||||
StaticStreamBuffer_t * const pxStaticStreamBuffer,
|
||||
StreamBufferCallbackFunction_t pxSendCompletedCallback,
|
||||
StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) FREERTOS_SYSTEM_CALL;
|
||||
void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
|
||||
BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;
|
||||
|
||||
#else /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
|
||||
|
||||
StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes,
|
||||
size_t xTriggerLevelBytes,
|
||||
BaseType_t xStreamBufferType,
|
||||
StreamBufferCallbackFunction_t pxSendCompletedCallback,
|
||||
StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) PRIVILEGED_FUNCTION;
|
||||
StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,
|
||||
size_t xTriggerLevelBytes,
|
||||
BaseType_t xStreamBufferType,
|
||||
uint8_t * const pucStreamBufferStorageArea,
|
||||
StaticStreamBuffer_t * const pxStaticStreamBuffer,
|
||||
StreamBufferCallbackFunction_t pxSendCompletedCallback,
|
||||
StreamBufferCallbackFunction_t pxReceiveCompletedCallback ) PRIVILEGED_FUNCTION;
|
||||
void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
|
||||
|
||||
#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
|
||||
|
||||
BaseType_t MPU_xStreamBufferGetStaticBuffers( StreamBufferHandle_t xStreamBuffers,
|
||||
uint8_t * ppucStreamBufferStorageArea,
|
||||
StaticStreamBuffer_t * ppxStaticStreamBuffer ) PRIVILEGED_FUNCTION;
|
||||
size_t MPU_xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer,
|
||||
const void * pvTxData,
|
||||
size_t xDataLengthBytes,
|
||||
BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
|
||||
size_t MPU_xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,
|
||||
void * pvRxData,
|
||||
size_t xBufferLengthBytes,
|
||||
BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer,
|
||||
BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuffer,
|
||||
BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;
|
||||
BaseType_t MPU_xStreamBufferResetFromISR( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;
|
||||
|
||||
#endif /* MPU_PROTOTYPES_H */
|
||||
+105
@@ -0,0 +1,105 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MPU_SYSCALL_NUMBERS_H
|
||||
#define MPU_SYSCALL_NUMBERS_H
|
||||
|
||||
/* Numbers assigned to various system calls. */
|
||||
#define SYSTEM_CALL_xTaskGenericNotify 0
|
||||
#define SYSTEM_CALL_xTaskGenericNotifyWait 1
|
||||
#define SYSTEM_CALL_xTimerGenericCommandFromTask 2
|
||||
#define SYSTEM_CALL_xEventGroupWaitBits 3
|
||||
#define SYSTEM_CALL_xTaskDelayUntil 4
|
||||
#define SYSTEM_CALL_xTaskAbortDelay 5
|
||||
#define SYSTEM_CALL_vTaskDelay 6
|
||||
#define SYSTEM_CALL_uxTaskPriorityGet 7
|
||||
#define SYSTEM_CALL_eTaskGetState 8
|
||||
#define SYSTEM_CALL_vTaskGetInfo 9
|
||||
#define SYSTEM_CALL_xTaskGetIdleTaskHandle 10
|
||||
#define SYSTEM_CALL_vTaskSuspend 11
|
||||
#define SYSTEM_CALL_vTaskResume 12
|
||||
#define SYSTEM_CALL_xTaskGetTickCount 13
|
||||
#define SYSTEM_CALL_uxTaskGetNumberOfTasks 14
|
||||
#define SYSTEM_CALL_ulTaskGetRunTimeCounter 15
|
||||
#define SYSTEM_CALL_ulTaskGetRunTimePercent 16
|
||||
#define SYSTEM_CALL_ulTaskGetIdleRunTimePercent 17
|
||||
#define SYSTEM_CALL_ulTaskGetIdleRunTimeCounter 18
|
||||
#define SYSTEM_CALL_vTaskSetApplicationTaskTag 19
|
||||
#define SYSTEM_CALL_xTaskGetApplicationTaskTag 20
|
||||
#define SYSTEM_CALL_vTaskSetThreadLocalStoragePointer 21
|
||||
#define SYSTEM_CALL_pvTaskGetThreadLocalStoragePointer 22
|
||||
#define SYSTEM_CALL_uxTaskGetSystemState 23
|
||||
#define SYSTEM_CALL_uxTaskGetStackHighWaterMark 24
|
||||
#define SYSTEM_CALL_uxTaskGetStackHighWaterMark2 25
|
||||
#define SYSTEM_CALL_xTaskGetCurrentTaskHandle 26
|
||||
#define SYSTEM_CALL_xTaskGetSchedulerState 27
|
||||
#define SYSTEM_CALL_vTaskSetTimeOutState 28
|
||||
#define SYSTEM_CALL_xTaskCheckForTimeOut 29
|
||||
#define SYSTEM_CALL_ulTaskGenericNotifyTake 30
|
||||
#define SYSTEM_CALL_xTaskGenericNotifyStateClear 31
|
||||
#define SYSTEM_CALL_ulTaskGenericNotifyValueClear 32
|
||||
#define SYSTEM_CALL_xQueueGenericSend 33
|
||||
#define SYSTEM_CALL_uxQueueMessagesWaiting 34
|
||||
#define SYSTEM_CALL_uxQueueSpacesAvailable 35
|
||||
#define SYSTEM_CALL_xQueueReceive 36
|
||||
#define SYSTEM_CALL_xQueuePeek 37
|
||||
#define SYSTEM_CALL_xQueueSemaphoreTake 38
|
||||
#define SYSTEM_CALL_xQueueGetMutexHolder 39
|
||||
#define SYSTEM_CALL_xQueueTakeMutexRecursive 40
|
||||
#define SYSTEM_CALL_xQueueGiveMutexRecursive 41
|
||||
#define SYSTEM_CALL_xQueueSelectFromSet 42
|
||||
#define SYSTEM_CALL_xQueueAddToSet 43
|
||||
#define SYSTEM_CALL_vQueueAddToRegistry 44
|
||||
#define SYSTEM_CALL_vQueueUnregisterQueue 45
|
||||
#define SYSTEM_CALL_pcQueueGetName 46
|
||||
#define SYSTEM_CALL_pvTimerGetTimerID 47
|
||||
#define SYSTEM_CALL_vTimerSetTimerID 48
|
||||
#define SYSTEM_CALL_xTimerIsTimerActive 49
|
||||
#define SYSTEM_CALL_xTimerGetTimerDaemonTaskHandle 50
|
||||
#define SYSTEM_CALL_pcTimerGetName 51
|
||||
#define SYSTEM_CALL_vTimerSetReloadMode 52
|
||||
#define SYSTEM_CALL_xTimerGetReloadMode 53
|
||||
#define SYSTEM_CALL_uxTimerGetReloadMode 54
|
||||
#define SYSTEM_CALL_xTimerGetPeriod 55
|
||||
#define SYSTEM_CALL_xTimerGetExpiryTime 56
|
||||
#define SYSTEM_CALL_xEventGroupClearBits 57
|
||||
#define SYSTEM_CALL_xEventGroupSetBits 58
|
||||
#define SYSTEM_CALL_xEventGroupSync 59
|
||||
#define SYSTEM_CALL_uxEventGroupGetNumber 60
|
||||
#define SYSTEM_CALL_vEventGroupSetNumber 61
|
||||
#define SYSTEM_CALL_xStreamBufferSend 62
|
||||
#define SYSTEM_CALL_xStreamBufferReceive 63
|
||||
#define SYSTEM_CALL_xStreamBufferIsFull 64
|
||||
#define SYSTEM_CALL_xStreamBufferIsEmpty 65
|
||||
#define SYSTEM_CALL_xStreamBufferSpacesAvailable 66
|
||||
#define SYSTEM_CALL_xStreamBufferBytesAvailable 67
|
||||
#define SYSTEM_CALL_xStreamBufferSetTriggerLevel 68
|
||||
#define SYSTEM_CALL_xStreamBufferNextMessageLengthBytes 69
|
||||
#define NUM_SYSTEM_CALLS 70 /* Total number of system calls. */
|
||||
|
||||
#endif /* MPU_SYSCALL_NUMBERS_H */
|
||||
+292
@@ -0,0 +1,292 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef MPU_WRAPPERS_H
|
||||
#define MPU_WRAPPERS_H
|
||||
|
||||
/* This file redefines API functions to be called through a wrapper macro, but
|
||||
* only for ports that are using the MPU. */
|
||||
#if ( portUSING_MPU_WRAPPERS == 1 )
|
||||
|
||||
/* MPU_WRAPPERS_INCLUDED_FROM_API_FILE will be defined when this file is
|
||||
* included from queue.c or task.c to prevent it from having an effect within
|
||||
* those files. */
|
||||
#ifndef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
/*
|
||||
* Map standard (non MPU) API functions to equivalents that start
|
||||
* "MPU_". This will cause the application code to call the MPU_
|
||||
* version, which wraps the non-MPU version with privilege promoting
|
||||
* then demoting code, so the kernel code always runs will full
|
||||
* privileges.
|
||||
*/
|
||||
|
||||
/* Map standard task.h API functions to the MPU equivalents. */
|
||||
#define vTaskDelay MPU_vTaskDelay
|
||||
#define xTaskDelayUntil MPU_xTaskDelayUntil
|
||||
#define xTaskAbortDelay MPU_xTaskAbortDelay
|
||||
#define uxTaskPriorityGet MPU_uxTaskPriorityGet
|
||||
#define eTaskGetState MPU_eTaskGetState
|
||||
#define vTaskGetInfo MPU_vTaskGetInfo
|
||||
#define vTaskSuspend MPU_vTaskSuspend
|
||||
#define vTaskResume MPU_vTaskResume
|
||||
#define xTaskGetTickCount MPU_xTaskGetTickCount
|
||||
#define uxTaskGetNumberOfTasks MPU_uxTaskGetNumberOfTasks
|
||||
#define uxTaskGetStackHighWaterMark MPU_uxTaskGetStackHighWaterMark
|
||||
#define uxTaskGetStackHighWaterMark2 MPU_uxTaskGetStackHighWaterMark2
|
||||
#define vTaskSetApplicationTaskTag MPU_vTaskSetApplicationTaskTag
|
||||
#define xTaskGetApplicationTaskTag MPU_xTaskGetApplicationTaskTag
|
||||
#define vTaskSetThreadLocalStoragePointer MPU_vTaskSetThreadLocalStoragePointer
|
||||
#define pvTaskGetThreadLocalStoragePointer MPU_pvTaskGetThreadLocalStoragePointer
|
||||
#define xTaskGetIdleTaskHandle MPU_xTaskGetIdleTaskHandle
|
||||
#define uxTaskGetSystemState MPU_uxTaskGetSystemState
|
||||
#define ulTaskGetIdleRunTimeCounter MPU_ulTaskGetIdleRunTimeCounter
|
||||
#define ulTaskGetIdleRunTimePercent MPU_ulTaskGetIdleRunTimePercent
|
||||
#define xTaskGenericNotify MPU_xTaskGenericNotify
|
||||
#define xTaskGenericNotifyWait MPU_xTaskGenericNotifyWait
|
||||
#define ulTaskGenericNotifyTake MPU_ulTaskGenericNotifyTake
|
||||
#define xTaskGenericNotifyStateClear MPU_xTaskGenericNotifyStateClear
|
||||
#define ulTaskGenericNotifyValueClear MPU_ulTaskGenericNotifyValueClear
|
||||
#define vTaskSetTimeOutState MPU_vTaskSetTimeOutState
|
||||
#define xTaskCheckForTimeOut MPU_xTaskCheckForTimeOut
|
||||
#define xTaskGetCurrentTaskHandle MPU_xTaskGetCurrentTaskHandle
|
||||
#define xTaskGetSchedulerState MPU_xTaskGetSchedulerState
|
||||
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 0 )
|
||||
#define ulTaskGetRunTimeCounter MPU_ulTaskGetRunTimeCounter
|
||||
#define ulTaskGetRunTimePercent MPU_ulTaskGetRunTimePercent
|
||||
#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
|
||||
|
||||
/* Privileged only wrappers for Task APIs. These are needed so that
|
||||
* the application can use opaque handles maintained in mpu_wrappers.c
|
||||
* with all the APIs. */
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 1 )
|
||||
|
||||
/* These are not needed in v2 because they do not take a task
|
||||
* handle and therefore, no lookup is needed. Needed in v1 because
|
||||
* these are available as system calls in v1. */
|
||||
#define vTaskGetRunTimeStatistics MPU_vTaskGetRunTimeStatistics
|
||||
#define vTaskListTasks MPU_vTaskListTasks
|
||||
#define vTaskSuspendAll MPU_vTaskSuspendAll
|
||||
#define xTaskCatchUpTicks MPU_xTaskCatchUpTicks
|
||||
#define xTaskResumeAll MPU_xTaskResumeAll
|
||||
#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 1 ) */
|
||||
|
||||
#define xTaskCreate MPU_xTaskCreate
|
||||
#define xTaskCreateStatic MPU_xTaskCreateStatic
|
||||
#define vTaskDelete MPU_vTaskDelete
|
||||
#define vTaskPrioritySet MPU_vTaskPrioritySet
|
||||
#define xTaskGetHandle MPU_xTaskGetHandle
|
||||
#define xTaskCallApplicationTaskHook MPU_xTaskCallApplicationTaskHook
|
||||
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 0 )
|
||||
#define pcTaskGetName MPU_pcTaskGetName
|
||||
#define xTaskCreateRestricted MPU_xTaskCreateRestricted
|
||||
#define xTaskCreateRestrictedStatic MPU_xTaskCreateRestrictedStatic
|
||||
#define vTaskAllocateMPURegions MPU_vTaskAllocateMPURegions
|
||||
#define xTaskGetStaticBuffers MPU_xTaskGetStaticBuffers
|
||||
#define uxTaskPriorityGetFromISR MPU_uxTaskPriorityGetFromISR
|
||||
#define uxTaskBasePriorityGet MPU_uxTaskBasePriorityGet
|
||||
#define uxTaskBasePriorityGetFromISR MPU_uxTaskBasePriorityGetFromISR
|
||||
#define xTaskResumeFromISR MPU_xTaskResumeFromISR
|
||||
#define xTaskGetApplicationTaskTagFromISR MPU_xTaskGetApplicationTaskTagFromISR
|
||||
#define xTaskGenericNotifyFromISR MPU_xTaskGenericNotifyFromISR
|
||||
#define vTaskGenericNotifyGiveFromISR MPU_vTaskGenericNotifyGiveFromISR
|
||||
#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
|
||||
|
||||
/* Map standard queue.h API functions to the MPU equivalents. */
|
||||
#define xQueueGenericSend MPU_xQueueGenericSend
|
||||
#define xQueueReceive MPU_xQueueReceive
|
||||
#define xQueuePeek MPU_xQueuePeek
|
||||
#define xQueueSemaphoreTake MPU_xQueueSemaphoreTake
|
||||
#define uxQueueMessagesWaiting MPU_uxQueueMessagesWaiting
|
||||
#define uxQueueSpacesAvailable MPU_uxQueueSpacesAvailable
|
||||
#define xQueueGetMutexHolder MPU_xQueueGetMutexHolder
|
||||
#define xQueueTakeMutexRecursive MPU_xQueueTakeMutexRecursive
|
||||
#define xQueueGiveMutexRecursive MPU_xQueueGiveMutexRecursive
|
||||
#define xQueueAddToSet MPU_xQueueAddToSet
|
||||
#define xQueueSelectFromSet MPU_xQueueSelectFromSet
|
||||
|
||||
#if ( configQUEUE_REGISTRY_SIZE > 0 )
|
||||
#define vQueueAddToRegistry MPU_vQueueAddToRegistry
|
||||
#define vQueueUnregisterQueue MPU_vQueueUnregisterQueue
|
||||
#define pcQueueGetName MPU_pcQueueGetName
|
||||
#endif /* #if ( configQUEUE_REGISTRY_SIZE > 0 ) */
|
||||
|
||||
/* Privileged only wrappers for Queue APIs. These are needed so that
|
||||
* the application can use opaque handles maintained in mpu_wrappers.c
|
||||
* with all the APIs. */
|
||||
#define vQueueDelete MPU_vQueueDelete
|
||||
#define xQueueCreateMutex MPU_xQueueCreateMutex
|
||||
#define xQueueCreateMutexStatic MPU_xQueueCreateMutexStatic
|
||||
#define xQueueCreateCountingSemaphore MPU_xQueueCreateCountingSemaphore
|
||||
#define xQueueCreateCountingSemaphoreStatic MPU_xQueueCreateCountingSemaphoreStatic
|
||||
#define xQueueGenericCreate MPU_xQueueGenericCreate
|
||||
#define xQueueGenericCreateStatic MPU_xQueueGenericCreateStatic
|
||||
#define xQueueGenericReset MPU_xQueueGenericReset
|
||||
#define xQueueCreateSet MPU_xQueueCreateSet
|
||||
#define xQueueCreateSetStatic MPU_xQueueCreateSetStatic
|
||||
#define xQueueRemoveFromSet MPU_xQueueRemoveFromSet
|
||||
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 0 )
|
||||
#define xQueueGenericGetStaticBuffers MPU_xQueueGenericGetStaticBuffers
|
||||
#define xQueueGenericSendFromISR MPU_xQueueGenericSendFromISR
|
||||
#define xQueueGiveFromISR MPU_xQueueGiveFromISR
|
||||
#define xQueuePeekFromISR MPU_xQueuePeekFromISR
|
||||
#define xQueueReceiveFromISR MPU_xQueueReceiveFromISR
|
||||
#define xQueueIsQueueEmptyFromISR MPU_xQueueIsQueueEmptyFromISR
|
||||
#define xQueueIsQueueFullFromISR MPU_xQueueIsQueueFullFromISR
|
||||
#define uxQueueMessagesWaitingFromISR MPU_uxQueueMessagesWaitingFromISR
|
||||
#define xQueueGetMutexHolderFromISR MPU_xQueueGetMutexHolderFromISR
|
||||
#define xQueueSelectFromSetFromISR MPU_xQueueSelectFromSetFromISR
|
||||
#endif /* if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
|
||||
|
||||
/* Map standard timer.h API functions to the MPU equivalents. */
|
||||
#define pvTimerGetTimerID MPU_pvTimerGetTimerID
|
||||
#define vTimerSetTimerID MPU_vTimerSetTimerID
|
||||
#define xTimerIsTimerActive MPU_xTimerIsTimerActive
|
||||
#define xTimerGetTimerDaemonTaskHandle MPU_xTimerGetTimerDaemonTaskHandle
|
||||
#define xTimerGenericCommandFromTask MPU_xTimerGenericCommandFromTask
|
||||
#define pcTimerGetName MPU_pcTimerGetName
|
||||
#define vTimerSetReloadMode MPU_vTimerSetReloadMode
|
||||
#define uxTimerGetReloadMode MPU_uxTimerGetReloadMode
|
||||
#define xTimerGetPeriod MPU_xTimerGetPeriod
|
||||
#define xTimerGetExpiryTime MPU_xTimerGetExpiryTime
|
||||
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 0 )
|
||||
#define xTimerGetReloadMode MPU_xTimerGetReloadMode
|
||||
#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
|
||||
|
||||
/* Privileged only wrappers for Timer APIs. These are needed so that
|
||||
* the application can use opaque handles maintained in mpu_wrappers.c
|
||||
* with all the APIs. */
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 0 )
|
||||
#define xTimerCreate MPU_xTimerCreate
|
||||
#define xTimerCreateStatic MPU_xTimerCreateStatic
|
||||
#define xTimerGetStaticBuffer MPU_xTimerGetStaticBuffer
|
||||
#define xTimerGenericCommandFromISR MPU_xTimerGenericCommandFromISR
|
||||
#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
|
||||
|
||||
/* Map standard event_group.h API functions to the MPU equivalents. */
|
||||
#define xEventGroupWaitBits MPU_xEventGroupWaitBits
|
||||
#define xEventGroupClearBits MPU_xEventGroupClearBits
|
||||
#define xEventGroupSetBits MPU_xEventGroupSetBits
|
||||
#define xEventGroupSync MPU_xEventGroupSync
|
||||
|
||||
#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) )
|
||||
#define uxEventGroupGetNumber MPU_uxEventGroupGetNumber
|
||||
#define vEventGroupSetNumber MPU_vEventGroupSetNumber
|
||||
#endif /* #if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) ) */
|
||||
|
||||
/* Privileged only wrappers for Event Group APIs. These are needed so that
|
||||
* the application can use opaque handles maintained in mpu_wrappers.c
|
||||
* with all the APIs. */
|
||||
#define xEventGroupCreate MPU_xEventGroupCreate
|
||||
#define xEventGroupCreateStatic MPU_xEventGroupCreateStatic
|
||||
#define vEventGroupDelete MPU_vEventGroupDelete
|
||||
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 0 )
|
||||
#define xEventGroupGetStaticBuffer MPU_xEventGroupGetStaticBuffer
|
||||
#define xEventGroupClearBitsFromISR MPU_xEventGroupClearBitsFromISR
|
||||
#define xEventGroupSetBitsFromISR MPU_xEventGroupSetBitsFromISR
|
||||
#define xEventGroupGetBitsFromISR MPU_xEventGroupGetBitsFromISR
|
||||
#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
|
||||
|
||||
/* Map standard message/stream_buffer.h API functions to the MPU
|
||||
* equivalents. */
|
||||
#define xStreamBufferSend MPU_xStreamBufferSend
|
||||
#define xStreamBufferReceive MPU_xStreamBufferReceive
|
||||
#define xStreamBufferIsFull MPU_xStreamBufferIsFull
|
||||
#define xStreamBufferIsEmpty MPU_xStreamBufferIsEmpty
|
||||
#define xStreamBufferSpacesAvailable MPU_xStreamBufferSpacesAvailable
|
||||
#define xStreamBufferBytesAvailable MPU_xStreamBufferBytesAvailable
|
||||
#define xStreamBufferSetTriggerLevel MPU_xStreamBufferSetTriggerLevel
|
||||
#define xStreamBufferNextMessageLengthBytes MPU_xStreamBufferNextMessageLengthBytes
|
||||
|
||||
/* Privileged only wrappers for Stream Buffer APIs. These are needed so that
|
||||
* the application can use opaque handles maintained in mpu_wrappers.c
|
||||
* with all the APIs. */
|
||||
|
||||
#define xStreamBufferGenericCreate MPU_xStreamBufferGenericCreate
|
||||
#define xStreamBufferGenericCreateStatic MPU_xStreamBufferGenericCreateStatic
|
||||
#define vStreamBufferDelete MPU_vStreamBufferDelete
|
||||
#define xStreamBufferReset MPU_xStreamBufferReset
|
||||
|
||||
#if ( configUSE_MPU_WRAPPERS_V1 == 0 )
|
||||
#define xStreamBufferGetStaticBuffers MPU_xStreamBufferGetStaticBuffers
|
||||
#define xStreamBufferSendFromISR MPU_xStreamBufferSendFromISR
|
||||
#define xStreamBufferReceiveFromISR MPU_xStreamBufferReceiveFromISR
|
||||
#define xStreamBufferSendCompletedFromISR MPU_xStreamBufferSendCompletedFromISR
|
||||
#define xStreamBufferReceiveCompletedFromISR MPU_xStreamBufferReceiveCompletedFromISR
|
||||
#define xStreamBufferResetFromISR MPU_xStreamBufferResetFromISR
|
||||
#endif /* #if ( configUSE_MPU_WRAPPERS_V1 == 0 ) */
|
||||
|
||||
#if ( ( configUSE_MPU_WRAPPERS_V1 == 0 ) && ( configENABLE_ACCESS_CONTROL_LIST == 1 ) )
|
||||
|
||||
#define vGrantAccessToTask( xTask, xTaskToGrantAccess ) vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xTaskToGrantAccess ) )
|
||||
#define vRevokeAccessToTask( xTask, xTaskToRevokeAccess ) vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xTaskToRevokeAccess ) )
|
||||
|
||||
#define vGrantAccessToSemaphore( xTask, xSemaphoreToGrantAccess ) vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xSemaphoreToGrantAccess ) )
|
||||
#define vRevokeAccessToSemaphore( xTask, xSemaphoreToRevokeAccess ) vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xSemaphoreToRevokeAccess ) )
|
||||
|
||||
#define vGrantAccessToQueue( xTask, xQueueToGrantAccess ) vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xQueueToGrantAccess ) )
|
||||
#define vRevokeAccessToQueue( xTask, xQueueToRevokeAccess ) vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xQueueToRevokeAccess ) )
|
||||
|
||||
#define vGrantAccessToQueueSet( xTask, xQueueSetToGrantAccess ) vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xQueueSetToGrantAccess ) )
|
||||
#define vRevokeAccessToQueueSet( xTask, xQueueSetToRevokeAccess ) vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xQueueSetToRevokeAccess ) )
|
||||
|
||||
#define vGrantAccessToEventGroup( xTask, xEventGroupToGrantAccess ) vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xEventGroupToGrantAccess ) )
|
||||
#define vRevokeAccessToEventGroup( xTask, xEventGroupToRevokeAccess ) vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xEventGroupToRevokeAccess ) )
|
||||
|
||||
#define vGrantAccessToStreamBuffer( xTask, xStreamBufferToGrantAccess ) vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xStreamBufferToGrantAccess ) )
|
||||
#define vRevokeAccessToStreamBuffer( xTask, xStreamBufferToRevokeAccess ) vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xStreamBufferToRevokeAccess ) )
|
||||
|
||||
#define vGrantAccessToMessageBuffer( xTask, xMessageBufferToGrantAccess ) vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xMessageBufferToGrantAccess ) )
|
||||
#define vRevokeAccessToMessageBuffer( xTask, xMessageBufferToRevokeAccess ) vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xMessageBufferToRevokeAccess ) )
|
||||
|
||||
#define vGrantAccessToTimer( xTask, xTimerToGrantAccess ) vGrantAccessToKernelObject( ( xTask ), ( int32_t ) ( xTimerToGrantAccess ) )
|
||||
#define vRevokeAccessToTimer( xTask, xTimerToRevokeAccess ) vRevokeAccessToKernelObject( ( xTask ), ( int32_t ) ( xTimerToRevokeAccess ) )
|
||||
|
||||
#endif /* #if ( ( configUSE_MPU_WRAPPERS_V1 == 0 ) && ( configENABLE_ACCESS_CONTROL_LIST == 1 ) ) */
|
||||
|
||||
#endif /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */
|
||||
|
||||
#define PRIVILEGED_FUNCTION __attribute__( ( section( "privileged_functions" ) ) )
|
||||
#define PRIVILEGED_DATA __attribute__( ( section( "privileged_data" ) ) )
|
||||
#define FREERTOS_SYSTEM_CALL __attribute__( ( section( "freertos_system_calls" ) ) )
|
||||
|
||||
#else /* portUSING_MPU_WRAPPERS */
|
||||
|
||||
#define PRIVILEGED_FUNCTION
|
||||
#define PRIVILEGED_DATA
|
||||
#define FREERTOS_SYSTEM_CALL
|
||||
|
||||
#endif /* portUSING_MPU_WRAPPERS */
|
||||
|
||||
|
||||
#endif /* MPU_WRAPPERS_H */
|
||||
+62
@@ -0,0 +1,62 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef INC_NEWLIB_FREERTOS_H
|
||||
#define INC_NEWLIB_FREERTOS_H
|
||||
|
||||
/* Note Newlib support has been included by popular demand, but is not
|
||||
* used by the FreeRTOS maintainers themselves. FreeRTOS is not
|
||||
* responsible for resulting newlib operation. User must be familiar with
|
||||
* newlib and must provide system-wide implementations of the necessary
|
||||
* stubs. Be warned that (at the time of writing) the current newlib design
|
||||
* implements a system-wide malloc() that must be provided with locks.
|
||||
*
|
||||
* See the third party link http://www.nadler.com/embedded/newlibAndFreeRTOS.html
|
||||
* for additional information. */
|
||||
|
||||
#include <reent.h>
|
||||
|
||||
#define configUSE_C_RUNTIME_TLS_SUPPORT 1
|
||||
|
||||
#ifndef configTLS_BLOCK_TYPE
|
||||
#define configTLS_BLOCK_TYPE struct _reent
|
||||
#endif
|
||||
|
||||
#ifndef configINIT_TLS_BLOCK
|
||||
#define configINIT_TLS_BLOCK( xTLSBlock, pxTopOfStack ) _REENT_INIT_PTR( &( xTLSBlock ) )
|
||||
#endif
|
||||
|
||||
#ifndef configSET_TLS_BLOCK
|
||||
#define configSET_TLS_BLOCK( xTLSBlock ) ( _impure_ptr = &( xTLSBlock ) )
|
||||
#endif
|
||||
|
||||
#ifndef configDEINIT_TLS_BLOCK
|
||||
#define configDEINIT_TLS_BLOCK( xTLSBlock ) _reclaim_reent( &( xTLSBlock ) )
|
||||
#endif
|
||||
|
||||
#endif /* INC_NEWLIB_FREERTOS_H */
|
||||
+91
@@ -0,0 +1,91 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef INC_PICOLIBC_FREERTOS_H
|
||||
#define INC_PICOLIBC_FREERTOS_H
|
||||
|
||||
/* Use picolibc TLS support to allocate space for __thread variables,
|
||||
* initialize them at thread creation and set the TLS context at
|
||||
* thread switch time.
|
||||
*
|
||||
* See the picolibc TLS docs:
|
||||
* https://github.com/picolibc/picolibc/blob/main/doc/tls.md
|
||||
* for additional information. */
|
||||
|
||||
#include <picotls.h>
|
||||
|
||||
#define configUSE_C_RUNTIME_TLS_SUPPORT 1
|
||||
|
||||
#define configTLS_BLOCK_TYPE void *
|
||||
|
||||
#define picolibcTLS_SIZE ( ( portPOINTER_SIZE_TYPE ) _tls_size() )
|
||||
#define picolibcSTACK_ALIGNMENT_MASK ( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK )
|
||||
|
||||
#if __PICOLIBC_MAJOR__ > 1 || __PICOLIBC_MINOR__ >= 8
|
||||
|
||||
/* Picolibc 1.8 and newer have explicit alignment values provided
|
||||
* by the _tls_align() inline */
|
||||
#define picolibcTLS_ALIGNMENT_MASK ( ( portPOINTER_SIZE_TYPE ) ( _tls_align() - 1 ) )
|
||||
#else
|
||||
|
||||
/* For older Picolibc versions, use the general port alignment value */
|
||||
#define picolibcTLS_ALIGNMENT_MASK ( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK )
|
||||
#endif
|
||||
|
||||
/* Allocate thread local storage block off the end of the
|
||||
* stack. The picolibcTLS_SIZE macro returns the size (in
|
||||
* bytes) of the total TLS area used by the application.
|
||||
* Calculate the top of stack address. */
|
||||
#if ( portSTACK_GROWTH < 0 )
|
||||
|
||||
#define configINIT_TLS_BLOCK( xTLSBlock, pxTopOfStack ) \
|
||||
do { \
|
||||
xTLSBlock = ( void * ) ( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) - \
|
||||
picolibcTLS_SIZE ) & \
|
||||
~picolibcTLS_ALIGNMENT_MASK ); \
|
||||
pxTopOfStack = ( StackType_t * ) ( ( ( ( portPOINTER_SIZE_TYPE ) xTLSBlock ) - 1 ) & \
|
||||
~picolibcSTACK_ALIGNMENT_MASK ); \
|
||||
_init_tls( xTLSBlock ); \
|
||||
} while( 0 )
|
||||
#else /* portSTACK_GROWTH */
|
||||
#define configINIT_TLS_BLOCK( xTLSBlock, pxTopOfStack ) \
|
||||
do { \
|
||||
xTLSBlock = ( void * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack + \
|
||||
picolibcTLS_ALIGNMENT_MASK ) & ~picolibcTLS_ALIGNMENT_MASK ); \
|
||||
pxTopOfStack = ( StackType_t * ) ( ( ( ( ( portPOINTER_SIZE_TYPE ) xTLSBlock ) + \
|
||||
picolibcTLS_SIZE ) + picolibcSTACK_ALIGNMENT_MASK ) & \
|
||||
~picolibcSTACK_ALIGNMENT_MASK ); \
|
||||
_init_tls( xTLSBlock ); \
|
||||
} while( 0 )
|
||||
#endif /* portSTACK_GROWTH */
|
||||
|
||||
#define configSET_TLS_BLOCK( xTLSBlock ) _set_tls( xTLSBlock )
|
||||
|
||||
#define configDEINIT_TLS_BLOCK( xTLSBlock )
|
||||
|
||||
#endif /* INC_PICOLIBC_FREERTOS_H */
|
||||
@@ -0,0 +1,290 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Portable layer API. Each function must be defined for each port.
|
||||
*----------------------------------------------------------*/
|
||||
|
||||
#ifndef PORTABLE_H
|
||||
#define PORTABLE_H
|
||||
|
||||
/* Each FreeRTOS port has a unique portmacro.h header file. Originally a
|
||||
* pre-processor definition was used to ensure the pre-processor found the correct
|
||||
* portmacro.h file for the port being used. That scheme was deprecated in favour
|
||||
* of setting the compiler's include path such that it found the correct
|
||||
* portmacro.h file - removing the need for the constant and allowing the
|
||||
* portmacro.h file to be located anywhere in relation to the port being used.
|
||||
* Purely for reasons of backward compatibility the old method is still valid, but
|
||||
* to make it clear that new projects should not use it, support for the port
|
||||
* specific constants has been moved into the deprecated_definitions.h header
|
||||
* file. */
|
||||
#include "deprecated_definitions.h"
|
||||
|
||||
/* If portENTER_CRITICAL is not defined then including deprecated_definitions.h
|
||||
* did not result in a portmacro.h header file being included - and it should be
|
||||
* included here. In this case the path to the correct portmacro.h header file
|
||||
* must be set in the compiler's include path. */
|
||||
#ifndef portENTER_CRITICAL
|
||||
#include "portmacro.h"
|
||||
#endif
|
||||
|
||||
#if portBYTE_ALIGNMENT == 32
|
||||
#define portBYTE_ALIGNMENT_MASK ( 0x001f )
|
||||
#elif portBYTE_ALIGNMENT == 16
|
||||
#define portBYTE_ALIGNMENT_MASK ( 0x000f )
|
||||
#elif portBYTE_ALIGNMENT == 8
|
||||
#define portBYTE_ALIGNMENT_MASK ( 0x0007 )
|
||||
#elif portBYTE_ALIGNMENT == 4
|
||||
#define portBYTE_ALIGNMENT_MASK ( 0x0003 )
|
||||
#elif portBYTE_ALIGNMENT == 2
|
||||
#define portBYTE_ALIGNMENT_MASK ( 0x0001 )
|
||||
#elif portBYTE_ALIGNMENT == 1
|
||||
#define portBYTE_ALIGNMENT_MASK ( 0x0000 )
|
||||
#else /* if portBYTE_ALIGNMENT == 32 */
|
||||
#error "Invalid portBYTE_ALIGNMENT definition"
|
||||
#endif /* if portBYTE_ALIGNMENT == 32 */
|
||||
|
||||
#ifndef portUSING_MPU_WRAPPERS
|
||||
#define portUSING_MPU_WRAPPERS 0
|
||||
#endif
|
||||
|
||||
#ifndef portNUM_CONFIGURABLE_REGIONS
|
||||
#define portNUM_CONFIGURABLE_REGIONS 1
|
||||
#endif
|
||||
|
||||
#ifndef portHAS_STACK_OVERFLOW_CHECKING
|
||||
#define portHAS_STACK_OVERFLOW_CHECKING 0
|
||||
#endif
|
||||
|
||||
#ifndef portARCH_NAME
|
||||
#define portARCH_NAME NULL
|
||||
#endif
|
||||
|
||||
#ifndef portBASE_TYPE_ENTER_CRITICAL
|
||||
#define portBASE_TYPE_ENTER_CRITICAL() taskENTER_CRITICAL()
|
||||
#endif
|
||||
|
||||
#ifndef portBASE_TYPE_EXIT_CRITICAL
|
||||
#define portBASE_TYPE_EXIT_CRITICAL() taskEXIT_CRITICAL()
|
||||
#endif
|
||||
|
||||
#ifndef configSTACK_DEPTH_TYPE
|
||||
#define configSTACK_DEPTH_TYPE StackType_t
|
||||
#endif
|
||||
|
||||
#ifndef configSTACK_ALLOCATION_FROM_SEPARATE_HEAP
|
||||
/* Defaults to 0 for backward compatibility. */
|
||||
#define configSTACK_ALLOCATION_FROM_SEPARATE_HEAP 0
|
||||
#endif
|
||||
|
||||
#include "mpu_wrappers.h"
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/*
|
||||
* Setup the stack of a new task so it is ready to be placed under the
|
||||
* scheduler control. The registers have to be placed on the stack in
|
||||
* the order that the port expects to find them.
|
||||
*
|
||||
*/
|
||||
#if ( portUSING_MPU_WRAPPERS == 1 )
|
||||
#if ( portHAS_STACK_OVERFLOW_CHECKING == 1 )
|
||||
StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
|
||||
StackType_t * pxEndOfStack,
|
||||
TaskFunction_t pxCode,
|
||||
void * pvParameters,
|
||||
BaseType_t xRunPrivileged,
|
||||
xMPU_SETTINGS * xMPUSettings ) PRIVILEGED_FUNCTION;
|
||||
#else
|
||||
StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
|
||||
TaskFunction_t pxCode,
|
||||
void * pvParameters,
|
||||
BaseType_t xRunPrivileged,
|
||||
xMPU_SETTINGS * xMPUSettings ) PRIVILEGED_FUNCTION;
|
||||
#endif /* if ( portHAS_STACK_OVERFLOW_CHECKING == 1 ) */
|
||||
#else /* if ( portUSING_MPU_WRAPPERS == 1 ) */
|
||||
#if ( portHAS_STACK_OVERFLOW_CHECKING == 1 )
|
||||
StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
|
||||
StackType_t * pxEndOfStack,
|
||||
TaskFunction_t pxCode,
|
||||
void * pvParameters ) PRIVILEGED_FUNCTION;
|
||||
#else
|
||||
StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
|
||||
TaskFunction_t pxCode,
|
||||
void * pvParameters ) PRIVILEGED_FUNCTION;
|
||||
#endif
|
||||
#endif /* if ( portUSING_MPU_WRAPPERS == 1 ) */
|
||||
|
||||
/* Used by heap_5.c to define the start address and size of each memory region
|
||||
* that together comprise the total FreeRTOS heap space. */
|
||||
typedef struct HeapRegion
|
||||
{
|
||||
uint8_t * pucStartAddress;
|
||||
size_t xSizeInBytes;
|
||||
} HeapRegion_t;
|
||||
|
||||
/* Used to pass information about the heap out of vPortGetHeapStats(). */
|
||||
typedef struct xHeapStats
|
||||
{
|
||||
size_t xAvailableHeapSpaceInBytes; /* The total heap size currently available - this is the sum of all the free blocks, not the largest block that can be allocated. */
|
||||
size_t xSizeOfLargestFreeBlockInBytes; /* The maximum size, in bytes, of all the free blocks within the heap at the time vPortGetHeapStats() is called. */
|
||||
size_t xSizeOfSmallestFreeBlockInBytes; /* The minimum size, in bytes, of all the free blocks within the heap at the time vPortGetHeapStats() is called. */
|
||||
size_t xNumberOfFreeBlocks; /* The number of free memory blocks within the heap at the time vPortGetHeapStats() is called. */
|
||||
size_t xMinimumEverFreeBytesRemaining; /* The minimum amount of total free memory (sum of all free blocks) there has been in the heap since the system booted. */
|
||||
size_t xNumberOfSuccessfulAllocations; /* The number of calls to pvPortMalloc() that have returned a valid memory block. */
|
||||
size_t xNumberOfSuccessfulFrees; /* The number of calls to vPortFree() that has successfully freed a block of memory. */
|
||||
} HeapStats_t;
|
||||
|
||||
/*
|
||||
* Used to define multiple heap regions for use by heap_5.c. This function
|
||||
* must be called before any calls to pvPortMalloc() - not creating a task,
|
||||
* queue, semaphore, mutex, software timer, event group, etc. will result in
|
||||
* pvPortMalloc being called.
|
||||
*
|
||||
* pxHeapRegions passes in an array of HeapRegion_t structures - each of which
|
||||
* defines a region of memory that can be used as the heap. The array is
|
||||
* terminated by a HeapRegions_t structure that has a size of 0. The region
|
||||
* with the lowest start address must appear first in the array.
|
||||
*/
|
||||
void vPortDefineHeapRegions( const HeapRegion_t * const pxHeapRegions ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/*
|
||||
* Returns a HeapStats_t structure filled with information about the current
|
||||
* heap state.
|
||||
*/
|
||||
void vPortGetHeapStats( HeapStats_t * pxHeapStats );
|
||||
|
||||
/*
|
||||
* Map to the memory management routines required for the port.
|
||||
*/
|
||||
void * pvPortMalloc( size_t xWantedSize ) PRIVILEGED_FUNCTION;
|
||||
void * pvPortCalloc( size_t xNum,
|
||||
size_t xSize ) PRIVILEGED_FUNCTION;
|
||||
void vPortFree( void * pv ) PRIVILEGED_FUNCTION;
|
||||
void vPortInitialiseBlocks( void ) PRIVILEGED_FUNCTION;
|
||||
size_t xPortGetFreeHeapSize( void ) PRIVILEGED_FUNCTION;
|
||||
size_t xPortGetMinimumEverFreeHeapSize( void ) PRIVILEGED_FUNCTION;
|
||||
void xPortResetHeapMinimumEverFreeHeapSize( void ) PRIVILEGED_FUNCTION;
|
||||
|
||||
#if ( configSTACK_ALLOCATION_FROM_SEPARATE_HEAP == 1 )
|
||||
void * pvPortMallocStack( size_t xSize ) PRIVILEGED_FUNCTION;
|
||||
void vPortFreeStack( void * pv ) PRIVILEGED_FUNCTION;
|
||||
#else
|
||||
#define pvPortMallocStack pvPortMalloc
|
||||
#define vPortFreeStack vPortFree
|
||||
#endif
|
||||
|
||||
/*
|
||||
* This function resets the internal state of the heap module. It must be called
|
||||
* by the application before restarting the scheduler.
|
||||
*/
|
||||
void vPortHeapResetState( void ) PRIVILEGED_FUNCTION;
|
||||
|
||||
#if ( configUSE_MALLOC_FAILED_HOOK == 1 )
|
||||
|
||||
/**
|
||||
* task.h
|
||||
* @code{c}
|
||||
* void vApplicationMallocFailedHook( void )
|
||||
* @endcode
|
||||
*
|
||||
* This hook function is called when allocation failed.
|
||||
*/
|
||||
void vApplicationMallocFailedHook( void );
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Setup the hardware ready for the scheduler to take control. This generally
|
||||
* sets up a tick interrupt and sets timers for the correct tick frequency.
|
||||
*/
|
||||
BaseType_t xPortStartScheduler( void ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/*
|
||||
* Undo any hardware/ISR setup that was performed by xPortStartScheduler() so
|
||||
* the hardware is left in its original condition after the scheduler stops
|
||||
* executing.
|
||||
*/
|
||||
void vPortEndScheduler( void ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/*
|
||||
* The structures and methods of manipulating the MPU are contained within the
|
||||
* port layer.
|
||||
*
|
||||
* Fills the xMPUSettings structure with the memory region information
|
||||
* contained in xRegions.
|
||||
*/
|
||||
#if ( portUSING_MPU_WRAPPERS == 1 )
|
||||
struct xMEMORY_REGION;
|
||||
void vPortStoreTaskMPUSettings( xMPU_SETTINGS * xMPUSettings,
|
||||
const struct xMEMORY_REGION * const xRegions,
|
||||
StackType_t * pxBottomOfStack,
|
||||
configSTACK_DEPTH_TYPE uxStackDepth ) PRIVILEGED_FUNCTION;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Checks if the calling task is authorized to access the given buffer.
|
||||
*
|
||||
* @param pvBuffer The buffer which the calling task wants to access.
|
||||
* @param ulBufferLength The length of the pvBuffer.
|
||||
* @param ulAccessRequested The permissions that the calling task wants.
|
||||
*
|
||||
* @return pdTRUE if the calling task is authorized to access the buffer,
|
||||
* pdFALSE otherwise.
|
||||
*/
|
||||
#if ( portUSING_MPU_WRAPPERS == 1 )
|
||||
BaseType_t xPortIsAuthorizedToAccessBuffer( const void * pvBuffer,
|
||||
uint32_t ulBufferLength,
|
||||
uint32_t ulAccessRequested ) PRIVILEGED_FUNCTION;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Checks if the calling task is authorized to access the given kernel object.
|
||||
*
|
||||
* @param lInternalIndexOfKernelObject The index of the kernel object in the kernel
|
||||
* object handle pool.
|
||||
*
|
||||
* @return pdTRUE if the calling task is authorized to access the kernel object,
|
||||
* pdFALSE otherwise.
|
||||
*/
|
||||
#if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configUSE_MPU_WRAPPERS_V1 == 0 ) )
|
||||
|
||||
BaseType_t xPortIsAuthorizedToAccessKernelObject( int32_t lInternalIndexOfKernelObject ) PRIVILEGED_FUNCTION;
|
||||
|
||||
#endif
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
#endif /* PORTABLE_H */
|
||||
@@ -0,0 +1,138 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef PROJDEFS_H
|
||||
#define PROJDEFS_H
|
||||
|
||||
/*
|
||||
* Defines the prototype to which task functions must conform. Defined in this
|
||||
* file to ensure the type is known before portable.h is included.
|
||||
*/
|
||||
typedef void (* TaskFunction_t)( void * arg );
|
||||
|
||||
/* Converts a time in milliseconds to a time in ticks. This macro can be
|
||||
* overridden by a macro of the same name defined in FreeRTOSConfig.h in case the
|
||||
* definition here is not suitable for your application. */
|
||||
#ifndef pdMS_TO_TICKS
|
||||
#define pdMS_TO_TICKS( xTimeInMs ) ( ( TickType_t ) ( ( ( uint64_t ) ( xTimeInMs ) * ( uint64_t ) configTICK_RATE_HZ ) / ( uint64_t ) 1000U ) )
|
||||
#endif
|
||||
|
||||
/* Converts a time in ticks to a time in milliseconds. This macro can be
|
||||
* overridden by a macro of the same name defined in FreeRTOSConfig.h in case the
|
||||
* definition here is not suitable for your application. */
|
||||
#ifndef pdTICKS_TO_MS
|
||||
#define pdTICKS_TO_MS( xTimeInTicks ) ( ( TickType_t ) ( ( ( uint64_t ) ( xTimeInTicks ) * ( uint64_t ) 1000U ) / ( uint64_t ) configTICK_RATE_HZ ) )
|
||||
#endif
|
||||
|
||||
#define pdFALSE ( ( BaseType_t ) 0 )
|
||||
#define pdTRUE ( ( BaseType_t ) 1 )
|
||||
#define pdFALSE_SIGNED ( ( BaseType_t ) 0 )
|
||||
#define pdTRUE_SIGNED ( ( BaseType_t ) 1 )
|
||||
#define pdFALSE_UNSIGNED ( ( UBaseType_t ) 0 )
|
||||
#define pdTRUE_UNSIGNED ( ( UBaseType_t ) 1 )
|
||||
|
||||
#define pdPASS ( pdTRUE )
|
||||
#define pdFAIL ( pdFALSE )
|
||||
#define errQUEUE_EMPTY ( ( BaseType_t ) 0 )
|
||||
#define errQUEUE_FULL ( ( BaseType_t ) 0 )
|
||||
|
||||
/* FreeRTOS error definitions. */
|
||||
#define errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY ( -1 )
|
||||
#define errQUEUE_BLOCKED ( -4 )
|
||||
#define errQUEUE_YIELD ( -5 )
|
||||
|
||||
/* Macros used for basic data corruption checks. */
|
||||
#ifndef configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES
|
||||
#define configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES 0
|
||||
#endif
|
||||
|
||||
#if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS )
|
||||
#define pdINTEGRITY_CHECK_VALUE 0x5a5a
|
||||
#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_32_BITS )
|
||||
#define pdINTEGRITY_CHECK_VALUE 0x5a5a5a5aUL
|
||||
#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_64_BITS )
|
||||
#define pdINTEGRITY_CHECK_VALUE 0x5a5a5a5a5a5a5a5aULL
|
||||
#else
|
||||
#error configTICK_TYPE_WIDTH_IN_BITS set to unsupported tick type width.
|
||||
#endif
|
||||
|
||||
/* The following errno values are used by FreeRTOS+ components, not FreeRTOS
|
||||
* itself. */
|
||||
#define pdFREERTOS_ERRNO_NONE 0 /* No errors */
|
||||
#define pdFREERTOS_ERRNO_ENOENT 2 /* No such file or directory */
|
||||
#define pdFREERTOS_ERRNO_EINTR 4 /* Interrupted system call */
|
||||
#define pdFREERTOS_ERRNO_EIO 5 /* I/O error */
|
||||
#define pdFREERTOS_ERRNO_ENXIO 6 /* No such device or address */
|
||||
#define pdFREERTOS_ERRNO_EBADF 9 /* Bad file number */
|
||||
#define pdFREERTOS_ERRNO_EAGAIN 11 /* No more processes */
|
||||
#define pdFREERTOS_ERRNO_EWOULDBLOCK 11 /* Operation would block */
|
||||
#define pdFREERTOS_ERRNO_ENOMEM 12 /* Not enough memory */
|
||||
#define pdFREERTOS_ERRNO_EACCES 13 /* Permission denied */
|
||||
#define pdFREERTOS_ERRNO_EFAULT 14 /* Bad address */
|
||||
#define pdFREERTOS_ERRNO_EBUSY 16 /* Mount device busy */
|
||||
#define pdFREERTOS_ERRNO_EEXIST 17 /* File exists */
|
||||
#define pdFREERTOS_ERRNO_EXDEV 18 /* Cross-device link */
|
||||
#define pdFREERTOS_ERRNO_ENODEV 19 /* No such device */
|
||||
#define pdFREERTOS_ERRNO_ENOTDIR 20 /* Not a directory */
|
||||
#define pdFREERTOS_ERRNO_EISDIR 21 /* Is a directory */
|
||||
#define pdFREERTOS_ERRNO_EINVAL 22 /* Invalid argument */
|
||||
#define pdFREERTOS_ERRNO_ENOSPC 28 /* No space left on device */
|
||||
#define pdFREERTOS_ERRNO_ESPIPE 29 /* Illegal seek */
|
||||
#define pdFREERTOS_ERRNO_EROFS 30 /* Read only file system */
|
||||
#define pdFREERTOS_ERRNO_EUNATCH 42 /* Protocol driver not attached */
|
||||
#define pdFREERTOS_ERRNO_EBADE 50 /* Invalid exchange */
|
||||
#define pdFREERTOS_ERRNO_EFTYPE 79 /* Inappropriate file type or format */
|
||||
#define pdFREERTOS_ERRNO_ENMFILE 89 /* No more files */
|
||||
#define pdFREERTOS_ERRNO_ENOTEMPTY 90 /* Directory not empty */
|
||||
#define pdFREERTOS_ERRNO_ENAMETOOLONG 91 /* File or path name too long */
|
||||
#define pdFREERTOS_ERRNO_EOPNOTSUPP 95 /* Operation not supported on transport endpoint */
|
||||
#define pdFREERTOS_ERRNO_EAFNOSUPPORT 97 /* Address family not supported by protocol */
|
||||
#define pdFREERTOS_ERRNO_ENOBUFS 105 /* No buffer space available */
|
||||
#define pdFREERTOS_ERRNO_ENOPROTOOPT 109 /* Protocol not available */
|
||||
#define pdFREERTOS_ERRNO_EADDRINUSE 112 /* Address already in use */
|
||||
#define pdFREERTOS_ERRNO_ETIMEDOUT 116 /* Connection timed out */
|
||||
#define pdFREERTOS_ERRNO_EINPROGRESS 119 /* Connection already in progress */
|
||||
#define pdFREERTOS_ERRNO_EALREADY 120 /* Socket already connected */
|
||||
#define pdFREERTOS_ERRNO_EADDRNOTAVAIL 125 /* Address not available */
|
||||
#define pdFREERTOS_ERRNO_EISCONN 127 /* Socket is already connected */
|
||||
#define pdFREERTOS_ERRNO_ENOTCONN 128 /* Socket is not connected */
|
||||
#define pdFREERTOS_ERRNO_ENOMEDIUM 135 /* No medium inserted */
|
||||
#define pdFREERTOS_ERRNO_EILSEQ 138 /* An invalid UTF-16 sequence was encountered. */
|
||||
#define pdFREERTOS_ERRNO_ECANCELED 140 /* Operation canceled. */
|
||||
|
||||
/* The following endian values are used by FreeRTOS+ components, not FreeRTOS
|
||||
* itself. */
|
||||
#define pdFREERTOS_LITTLE_ENDIAN 0
|
||||
#define pdFREERTOS_BIG_ENDIAN 1
|
||||
|
||||
/* Re-defining endian values for generic naming. */
|
||||
#define pdLITTLE_ENDIAN pdFREERTOS_LITTLE_ENDIAN
|
||||
#define pdBIG_ENDIAN pdFREERTOS_BIG_ENDIAN
|
||||
|
||||
|
||||
#endif /* PROJDEFS_H */
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
+155
@@ -0,0 +1,155 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef STACK_MACROS_H
|
||||
#define STACK_MACROS_H
|
||||
|
||||
/*
|
||||
* Call the stack overflow hook function if the stack of the task being swapped
|
||||
* out is currently overflowed, or looks like it might have overflowed in the
|
||||
* past.
|
||||
*
|
||||
* Setting configCHECK_FOR_STACK_OVERFLOW to 1 will cause the macro to check
|
||||
* the current stack state only - comparing the current top of stack value to
|
||||
* the stack limit. Setting configCHECK_FOR_STACK_OVERFLOW to greater than 1
|
||||
* will also cause the last few stack bytes to be checked to ensure the value
|
||||
* to which the bytes were set when the task was created have not been
|
||||
* overwritten. Note this second test does not guarantee that an overflowed
|
||||
* stack will always be recognised.
|
||||
*/
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* portSTACK_LIMIT_PADDING is a number of extra words to consider to be in
|
||||
* use on the stack.
|
||||
*/
|
||||
#ifndef portSTACK_LIMIT_PADDING
|
||||
#define portSTACK_LIMIT_PADDING 0
|
||||
#endif
|
||||
|
||||
/* Stack overflow check is not straight forward to implement for MPU ports
|
||||
* because of the following reasons:
|
||||
* 1. The context is stored in TCB and as a result, pxTopOfStack member points
|
||||
* to the context location in TCB.
|
||||
* 2. System calls are executed on a separate privileged only stack.
|
||||
*
|
||||
* It is still okay because an MPU region is used to protect task stack which
|
||||
* means task stack overflow will trigger an MPU fault for unprivileged tasks.
|
||||
* Additionally, architectures with hardware stack overflow checking support
|
||||
* (such as Armv8-M) will trigger a fault when a task's stack overflows.
|
||||
*/
|
||||
#if ( ( configCHECK_FOR_STACK_OVERFLOW == 1 ) && ( portSTACK_GROWTH < 0 ) && ( portUSING_MPU_WRAPPERS != 1 ) )
|
||||
|
||||
/* Only the current stack state is to be checked. */
|
||||
#define taskCHECK_FOR_STACK_OVERFLOW() \
|
||||
do \
|
||||
{ \
|
||||
/* Is the currently saved stack pointer within the stack limit? */ \
|
||||
if( pxCurrentTCB->pxTopOfStack <= pxCurrentTCB->pxStack + portSTACK_LIMIT_PADDING ) \
|
||||
{ \
|
||||
char * pcOverflowTaskName = pxCurrentTCB->pcTaskName; \
|
||||
vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pcOverflowTaskName ); \
|
||||
} \
|
||||
} while( 0 )
|
||||
|
||||
#endif /* configCHECK_FOR_STACK_OVERFLOW == 1 */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ( configCHECK_FOR_STACK_OVERFLOW == 1 ) && ( portSTACK_GROWTH > 0 ) && ( portUSING_MPU_WRAPPERS != 1 ) )
|
||||
|
||||
/* Only the current stack state is to be checked. */
|
||||
#define taskCHECK_FOR_STACK_OVERFLOW() \
|
||||
do \
|
||||
{ \
|
||||
/* Is the currently saved stack pointer within the stack limit? */ \
|
||||
if( pxCurrentTCB->pxTopOfStack >= pxCurrentTCB->pxEndOfStack - portSTACK_LIMIT_PADDING ) \
|
||||
{ \
|
||||
char * pcOverflowTaskName = pxCurrentTCB->pcTaskName; \
|
||||
vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pcOverflowTaskName ); \
|
||||
} \
|
||||
} while( 0 )
|
||||
|
||||
#endif /* configCHECK_FOR_STACK_OVERFLOW == 1 */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH < 0 ) && ( portUSING_MPU_WRAPPERS != 1 ) )
|
||||
|
||||
#define taskCHECK_FOR_STACK_OVERFLOW() \
|
||||
do \
|
||||
{ \
|
||||
const uint32_t * const pulStack = ( uint32_t * ) pxCurrentTCB->pxStack; \
|
||||
const uint32_t ulCheckValue = ( uint32_t ) 0xa5a5a5a5U; \
|
||||
\
|
||||
if( ( pxCurrentTCB->pxTopOfStack <= pxCurrentTCB->pxStack + portSTACK_LIMIT_PADDING ) || \
|
||||
( pulStack[ 0 ] != ulCheckValue ) || \
|
||||
( pulStack[ 1 ] != ulCheckValue ) || \
|
||||
( pulStack[ 2 ] != ulCheckValue ) || \
|
||||
( pulStack[ 3 ] != ulCheckValue ) ) \
|
||||
{ \
|
||||
char * pcOverflowTaskName = pxCurrentTCB->pcTaskName; \
|
||||
vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pcOverflowTaskName ); \
|
||||
} \
|
||||
} while( 0 )
|
||||
|
||||
#endif /* #if( configCHECK_FOR_STACK_OVERFLOW > 1 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH > 0 ) && ( portUSING_MPU_WRAPPERS != 1 ) )
|
||||
|
||||
#define taskCHECK_FOR_STACK_OVERFLOW() \
|
||||
do \
|
||||
{ \
|
||||
int8_t * pcEndOfStack = ( int8_t * ) pxCurrentTCB->pxEndOfStack; \
|
||||
static const uint8_t ucExpectedStackBytes[] = { tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \
|
||||
tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \
|
||||
tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \
|
||||
tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, \
|
||||
tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE }; \
|
||||
\
|
||||
pcEndOfStack -= sizeof( ucExpectedStackBytes ); \
|
||||
\
|
||||
if( ( pxCurrentTCB->pxTopOfStack >= pxCurrentTCB->pxEndOfStack - portSTACK_LIMIT_PADDING ) || \
|
||||
( memcmp( ( void * ) pcEndOfStack, ( void * ) ucExpectedStackBytes, sizeof( ucExpectedStackBytes ) ) != 0 ) ) \
|
||||
{ \
|
||||
char * pcOverflowTaskName = pxCurrentTCB->pcTaskName; \
|
||||
vApplicationStackOverflowHook( ( TaskHandle_t ) pxCurrentTCB, pcOverflowTaskName ); \
|
||||
} \
|
||||
} while( 0 )
|
||||
|
||||
#endif /* #if( configCHECK_FOR_STACK_OVERFLOW > 1 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Remove stack overflow macro if not being used. */
|
||||
#ifndef taskCHECK_FOR_STACK_OVERFLOW
|
||||
#define taskCHECK_FOR_STACK_OVERFLOW()
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#endif /* STACK_MACROS_H */
|
||||
@@ -0,0 +1,58 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef FREERTOS_STDINT
|
||||
#define FREERTOS_STDINT
|
||||
|
||||
/*******************************************************************************
|
||||
* THIS IS NOT A FULL stdint.h IMPLEMENTATION - It only contains the definitions
|
||||
* necessary to build the FreeRTOS code. It is provided to allow FreeRTOS to be
|
||||
* built using compilers that do not provide their own stdint.h definition.
|
||||
*
|
||||
* To use this file:
|
||||
*
|
||||
* 1) Copy this file into the directory that contains your FreeRTOSConfig.h
|
||||
* header file, as that directory will already be in the compiler's include
|
||||
* path.
|
||||
*
|
||||
* 2) Rename the copied file stdint.h.
|
||||
*
|
||||
*/
|
||||
|
||||
typedef signed char int8_t;
|
||||
typedef unsigned char uint8_t;
|
||||
typedef short int16_t;
|
||||
typedef unsigned short uint16_t;
|
||||
typedef long int32_t;
|
||||
typedef unsigned long uint32_t;
|
||||
|
||||
#ifndef SIZE_MAX
|
||||
#define SIZE_MAX ( ( size_t ) -1 )
|
||||
#endif
|
||||
|
||||
#endif /* FREERTOS_STDINT */
|
||||
+1280
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,248 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
|
||||
* all the API functions to use the MPU wrappers. That should only be done when
|
||||
* task.h is included from an application file. */
|
||||
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
#include "FreeRTOS.h"
|
||||
#include "list.h"
|
||||
|
||||
/* The MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be
|
||||
* defined for the header files above, but not in this file, in order to
|
||||
* generate the correct privileged Vs unprivileged linkage and placement. */
|
||||
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* PUBLIC LIST API documented in list.h
|
||||
*----------------------------------------------------------*/
|
||||
|
||||
void vListInitialise( List_t * const pxList )
|
||||
{
|
||||
traceENTER_vListInitialise( pxList );
|
||||
|
||||
/* The list structure contains a list item which is used to mark the
|
||||
* end of the list. To initialise the list the list end is inserted
|
||||
* as the only list entry. */
|
||||
pxList->pxIndex = ( ListItem_t * ) &( pxList->xListEnd );
|
||||
|
||||
listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( &( pxList->xListEnd ) );
|
||||
|
||||
/* The list end value is the highest possible value in the list to
|
||||
* ensure it remains at the end of the list. */
|
||||
pxList->xListEnd.xItemValue = portMAX_DELAY;
|
||||
|
||||
/* The list end next and previous pointers point to itself so we know
|
||||
* when the list is empty. */
|
||||
pxList->xListEnd.pxNext = ( ListItem_t * ) &( pxList->xListEnd );
|
||||
pxList->xListEnd.pxPrevious = ( ListItem_t * ) &( pxList->xListEnd );
|
||||
|
||||
/* Initialize the remaining fields of xListEnd when it is a proper ListItem_t */
|
||||
#if ( configUSE_MINI_LIST_ITEM == 0 )
|
||||
{
|
||||
pxList->xListEnd.pvOwner = NULL;
|
||||
pxList->xListEnd.pxContainer = NULL;
|
||||
listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( &( pxList->xListEnd ) );
|
||||
}
|
||||
#endif
|
||||
|
||||
pxList->uxNumberOfItems = ( UBaseType_t ) 0U;
|
||||
|
||||
/* Write known values into the list if
|
||||
* configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
|
||||
listSET_LIST_INTEGRITY_CHECK_1_VALUE( pxList );
|
||||
listSET_LIST_INTEGRITY_CHECK_2_VALUE( pxList );
|
||||
|
||||
traceRETURN_vListInitialise();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vListInitialiseItem( ListItem_t * const pxItem )
|
||||
{
|
||||
traceENTER_vListInitialiseItem( pxItem );
|
||||
|
||||
/* Make sure the list item is not recorded as being on a list. */
|
||||
pxItem->pxContainer = NULL;
|
||||
|
||||
/* Write known values into the list item if
|
||||
* configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
|
||||
listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
|
||||
listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
|
||||
|
||||
traceRETURN_vListInitialiseItem();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vListInsertEnd( List_t * const pxList,
|
||||
ListItem_t * const pxNewListItem )
|
||||
{
|
||||
ListItem_t * const pxIndex = pxList->pxIndex;
|
||||
|
||||
traceENTER_vListInsertEnd( pxList, pxNewListItem );
|
||||
|
||||
/* Only effective when configASSERT() is also defined, these tests may catch
|
||||
* the list data structures being overwritten in memory. They will not catch
|
||||
* data errors caused by incorrect configuration or use of FreeRTOS. */
|
||||
listTEST_LIST_INTEGRITY( pxList );
|
||||
listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );
|
||||
|
||||
/* Insert a new list item into pxList, but rather than sort the list,
|
||||
* makes the new list item the last item to be removed by a call to
|
||||
* listGET_OWNER_OF_NEXT_ENTRY(). */
|
||||
pxNewListItem->pxNext = pxIndex;
|
||||
pxNewListItem->pxPrevious = pxIndex->pxPrevious;
|
||||
|
||||
/* Only used during decision coverage testing. */
|
||||
mtCOVERAGE_TEST_DELAY();
|
||||
|
||||
pxIndex->pxPrevious->pxNext = pxNewListItem;
|
||||
pxIndex->pxPrevious = pxNewListItem;
|
||||
|
||||
/* Remember which list the item is in. */
|
||||
pxNewListItem->pxContainer = pxList;
|
||||
|
||||
( pxList->uxNumberOfItems ) = ( UBaseType_t ) ( pxList->uxNumberOfItems + 1U );
|
||||
|
||||
traceRETURN_vListInsertEnd();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vListInsert( List_t * const pxList,
|
||||
ListItem_t * const pxNewListItem )
|
||||
{
|
||||
ListItem_t * pxIterator;
|
||||
const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
|
||||
|
||||
traceENTER_vListInsert( pxList, pxNewListItem );
|
||||
|
||||
/* Only effective when configASSERT() is also defined, these tests may catch
|
||||
* the list data structures being overwritten in memory. They will not catch
|
||||
* data errors caused by incorrect configuration or use of FreeRTOS. */
|
||||
listTEST_LIST_INTEGRITY( pxList );
|
||||
listTEST_LIST_ITEM_INTEGRITY( pxNewListItem );
|
||||
|
||||
/* Insert the new list item into the list, sorted in xItemValue order.
|
||||
*
|
||||
* If the list already contains a list item with the same item value then the
|
||||
* new list item should be placed after it. This ensures that TCBs which are
|
||||
* stored in ready lists (all of which have the same xItemValue value) get a
|
||||
* share of the CPU. However, if the xItemValue is the same as the back marker
|
||||
* the iteration loop below will not end. Therefore the value is checked
|
||||
* first, and the algorithm slightly modified if necessary. */
|
||||
if( xValueOfInsertion == portMAX_DELAY )
|
||||
{
|
||||
pxIterator = pxList->xListEnd.pxPrevious;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* *** NOTE ***********************************************************
|
||||
* If you find your application is crashing here then likely causes are
|
||||
* listed below. In addition see https://www.freertos.org/Why-FreeRTOS/FAQs for
|
||||
* more tips, and ensure configASSERT() is defined!
|
||||
* https://www.FreeRTOS.org/a00110.html#configASSERT
|
||||
*
|
||||
* 1) Stack overflow -
|
||||
* see https://www.FreeRTOS.org/Stacks-and-stack-overflow-checking.html
|
||||
* 2) Incorrect interrupt priority assignment, especially on Cortex-M
|
||||
* parts where numerically high priority values denote low actual
|
||||
* interrupt priorities, which can seem counter intuitive. See
|
||||
* https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html and the definition
|
||||
* of configMAX_SYSCALL_INTERRUPT_PRIORITY on
|
||||
* https://www.FreeRTOS.org/a00110.html
|
||||
* 3) Calling an API function from within a critical section or when
|
||||
* the scheduler is suspended, or calling an API function that does
|
||||
* not end in "FromISR" from an interrupt.
|
||||
* 4) Using a queue or semaphore before it has been initialised or
|
||||
* before the scheduler has been started (are interrupts firing
|
||||
* before vTaskStartScheduler() has been called?).
|
||||
* 5) If the FreeRTOS port supports interrupt nesting then ensure that
|
||||
* the priority of the tick interrupt is at or below
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY.
|
||||
**********************************************************************/
|
||||
|
||||
for( pxIterator = ( ListItem_t * ) &( pxList->xListEnd ); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator = pxIterator->pxNext )
|
||||
{
|
||||
/* There is nothing to do here, just iterating to the wanted
|
||||
* insertion position.
|
||||
* IF YOU FIND YOUR CODE STUCK HERE, SEE THE NOTE JUST ABOVE.
|
||||
*/
|
||||
}
|
||||
}
|
||||
|
||||
pxNewListItem->pxNext = pxIterator->pxNext;
|
||||
pxNewListItem->pxNext->pxPrevious = pxNewListItem;
|
||||
pxNewListItem->pxPrevious = pxIterator;
|
||||
pxIterator->pxNext = pxNewListItem;
|
||||
|
||||
/* Remember which list the item is in. This allows fast removal of the
|
||||
* item later. */
|
||||
pxNewListItem->pxContainer = pxList;
|
||||
|
||||
( pxList->uxNumberOfItems ) = ( UBaseType_t ) ( pxList->uxNumberOfItems + 1U );
|
||||
|
||||
traceRETURN_vListInsert();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
|
||||
UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove )
|
||||
{
|
||||
/* The list item knows which list it is in. Obtain the list from the list
|
||||
* item. */
|
||||
List_t * const pxList = pxItemToRemove->pxContainer;
|
||||
|
||||
traceENTER_uxListRemove( pxItemToRemove );
|
||||
|
||||
pxItemToRemove->pxNext->pxPrevious = pxItemToRemove->pxPrevious;
|
||||
pxItemToRemove->pxPrevious->pxNext = pxItemToRemove->pxNext;
|
||||
|
||||
/* Only used during decision coverage testing. */
|
||||
mtCOVERAGE_TEST_DELAY();
|
||||
|
||||
/* Make sure the index is left pointing to a valid item. */
|
||||
if( pxList->pxIndex == pxItemToRemove )
|
||||
{
|
||||
pxList->pxIndex = pxItemToRemove->pxPrevious;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
pxItemToRemove->pxContainer = NULL;
|
||||
( pxList->uxNumberOfItems ) = ( UBaseType_t ) ( pxList->uxNumberOfItems - 1U );
|
||||
|
||||
traceRETURN_uxListRemove( pxList->uxNumberOfItems );
|
||||
|
||||
return pxList->uxNumberOfItems;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
@@ -0,0 +1,4 @@
|
||||
name : "FreeRTOS-Kernel"
|
||||
version: "V11.3.0"
|
||||
description: "FreeRTOS Kernel."
|
||||
license: "MIT"
|
||||
+1356
File diff suppressed because it is too large.
Load diff
+2581
File diff suppressed because it is too large.
Load diff
+5289
File diff suppressed because it is too large.
Load diff
+907
@@ -0,0 +1,907 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Implementation of functions defined in portable.h for the ARM CM4F port.
|
||||
*----------------------------------------------------------*/
|
||||
|
||||
/* Scheduler includes. */
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
|
||||
#ifndef __ARM_FP
|
||||
#error This port can only be used when the project options are configured to enable hardware floating point support.
|
||||
#endif
|
||||
|
||||
/* Prototype of all Interrupt Service Routines (ISRs). */
|
||||
typedef void ( * portISR_t )( void );
|
||||
|
||||
/* Constants required to manipulate the core. Registers first... */
|
||||
#define portNVIC_SYSTICK_CTRL_REG ( *( ( volatile uint32_t * ) 0xe000e010 ) )
|
||||
#define portNVIC_SYSTICK_LOAD_REG ( *( ( volatile uint32_t * ) 0xe000e014 ) )
|
||||
#define portNVIC_SYSTICK_CURRENT_VALUE_REG ( *( ( volatile uint32_t * ) 0xe000e018 ) )
|
||||
#define portNVIC_SHPR2_REG ( *( ( volatile uint32_t * ) 0xe000ed1c ) )
|
||||
#define portNVIC_SHPR3_REG ( *( ( volatile uint32_t * ) 0xe000ed20 ) )
|
||||
/* ...then bits in the registers. */
|
||||
#define portNVIC_SYSTICK_CLK_BIT ( 1UL << 2UL )
|
||||
#define portNVIC_SYSTICK_INT_BIT ( 1UL << 1UL )
|
||||
#define portNVIC_SYSTICK_ENABLE_BIT ( 1UL << 0UL )
|
||||
#define portNVIC_SYSTICK_COUNT_FLAG_BIT ( 1UL << 16UL )
|
||||
#define portNVIC_PENDSVCLEAR_BIT ( 1UL << 27UL )
|
||||
#define portNVIC_PEND_SYSTICK_SET_BIT ( 1UL << 26UL )
|
||||
#define portNVIC_PEND_SYSTICK_CLEAR_BIT ( 1UL << 25UL )
|
||||
|
||||
/* Constants used to detect a Cortex-M7 r0p1 core, which should use the ARM_CM7
|
||||
* r0p1 port. */
|
||||
#define portCPUID ( *( ( volatile uint32_t * ) 0xE000ed00 ) )
|
||||
#define portCORTEX_M7_r0p1_ID ( 0x410FC271UL )
|
||||
#define portCORTEX_M7_r0p0_ID ( 0x410FC270UL )
|
||||
|
||||
#define portMIN_INTERRUPT_PRIORITY ( 255UL )
|
||||
#define portNVIC_PENDSV_PRI ( ( ( uint32_t ) portMIN_INTERRUPT_PRIORITY ) << 16UL )
|
||||
#define portNVIC_SYSTICK_PRI ( ( ( uint32_t ) portMIN_INTERRUPT_PRIORITY ) << 24UL )
|
||||
|
||||
/* Constants used to check the installation of the FreeRTOS interrupt handlers. */
|
||||
#define portSCB_VTOR_REG ( *( ( portISR_t ** ) 0xE000ED08 ) )
|
||||
#define portVECTOR_INDEX_SVC ( 11 )
|
||||
#define portVECTOR_INDEX_PENDSV ( 14 )
|
||||
|
||||
/* Constants required to check the validity of an interrupt priority. */
|
||||
#define portFIRST_USER_INTERRUPT_NUMBER ( 16 )
|
||||
#define portNVIC_IP_REGISTERS_OFFSET_16 ( 0xE000E3F0 )
|
||||
#define portAIRCR_REG ( *( ( volatile uint32_t * ) 0xE000ED0C ) )
|
||||
#define portMAX_8_BIT_VALUE ( ( uint8_t ) 0xff )
|
||||
#define portTOP_BIT_OF_BYTE ( ( uint8_t ) 0x80 )
|
||||
#define portMAX_PRIGROUP_BITS ( ( uint8_t ) 7 )
|
||||
#define portPRIORITY_GROUP_MASK ( 0x07UL << 8UL )
|
||||
#define portPRIGROUP_SHIFT ( 8UL )
|
||||
|
||||
/* Masks off all bits but the VECTACTIVE bits in the ICSR register. */
|
||||
#define portVECTACTIVE_MASK ( 0xFFUL )
|
||||
|
||||
/* Constants required to manipulate the VFP. */
|
||||
#define portFPCCR ( ( volatile uint32_t * ) 0xe000ef34 ) /* Floating point context control register. */
|
||||
#define portASPEN_AND_LSPEN_BITS ( 0x3UL << 30UL )
|
||||
|
||||
/* Constants required to set up the initial stack. */
|
||||
#define portINITIAL_XPSR ( 0x01000000 )
|
||||
#define portINITIAL_EXC_RETURN ( 0xfffffffd )
|
||||
|
||||
/* The systick is a 24-bit counter. */
|
||||
#define portMAX_24_BIT_NUMBER ( 0xffffffUL )
|
||||
|
||||
/* For strict compliance with the Cortex-M spec the task start address should
|
||||
* have bit-0 clear, as it is loaded into the PC on exit from an ISR. */
|
||||
#define portSTART_ADDRESS_MASK ( ( StackType_t ) 0xfffffffeUL )
|
||||
|
||||
/* A fiddle factor to estimate the number of SysTick counts that would have
|
||||
* occurred while the SysTick counter is stopped during tickless idle
|
||||
* calculations. */
|
||||
#define portMISSED_COUNTS_FACTOR ( 94UL )
|
||||
|
||||
/* Let the user override the default SysTick clock rate. If defined by the
|
||||
* user, this symbol must equal the SysTick clock rate when the CLK bit is 0 in the
|
||||
* configuration register. */
|
||||
#ifndef configSYSTICK_CLOCK_HZ
|
||||
#define configSYSTICK_CLOCK_HZ ( configCPU_CLOCK_HZ )
|
||||
/* Ensure the SysTick is clocked at the same frequency as the core. */
|
||||
#define portNVIC_SYSTICK_CLK_BIT_CONFIG ( portNVIC_SYSTICK_CLK_BIT )
|
||||
#else
|
||||
/* Select the option to clock SysTick not at the same frequency as the core. */
|
||||
#define portNVIC_SYSTICK_CLK_BIT_CONFIG ( 0 )
|
||||
#endif
|
||||
|
||||
/* Let the user override the pre-loading of the initial LR with the address of
|
||||
* prvTaskExitError() in case it messes up unwinding of the stack in the
|
||||
* debugger. */
|
||||
#ifdef configTASK_RETURN_ADDRESS
|
||||
#define portTASK_RETURN_ADDRESS configTASK_RETURN_ADDRESS
|
||||
#else
|
||||
#define portTASK_RETURN_ADDRESS prvTaskExitError
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Setup the timer to generate the tick interrupts. The implementation in this
|
||||
* file is weak to allow application writers to change the timer used to
|
||||
* generate the tick interrupt.
|
||||
*/
|
||||
void vPortSetupTimerInterrupt( void );
|
||||
|
||||
/*
|
||||
* Exception handlers.
|
||||
*/
|
||||
void xPortPendSVHandler( void ) __attribute__( ( naked ) );
|
||||
void xPortSysTickHandler( void );
|
||||
void vPortSVCHandler( void ) __attribute__( ( naked ) );
|
||||
|
||||
/*
|
||||
* Start first task is a separate function so it can be tested in isolation.
|
||||
*/
|
||||
static void prvPortStartFirstTask( void ) __attribute__( ( naked ) );
|
||||
|
||||
/*
|
||||
* Function to enable the VFP.
|
||||
*/
|
||||
static void vPortEnableVFP( void ) __attribute__( ( naked ) );
|
||||
|
||||
/*
|
||||
* Used to catch tasks that attempt to return from their implementing function.
|
||||
*/
|
||||
static void prvTaskExitError( void );
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Each task maintains its own interrupt status in the critical nesting
|
||||
* variable. */
|
||||
static UBaseType_t uxCriticalNesting = 0xaaaaaaaa;
|
||||
|
||||
/*
|
||||
* The number of SysTick increments that make up one tick period.
|
||||
*/
|
||||
#if ( configUSE_TICKLESS_IDLE == 1 )
|
||||
static uint32_t ulTimerCountsForOneTick = 0;
|
||||
#endif /* configUSE_TICKLESS_IDLE */
|
||||
|
||||
/*
|
||||
* The maximum number of tick periods that can be suppressed is limited by the
|
||||
* 24 bit resolution of the SysTick timer.
|
||||
*/
|
||||
#if ( configUSE_TICKLESS_IDLE == 1 )
|
||||
static uint32_t xMaximumPossibleSuppressedTicks = 0;
|
||||
#endif /* configUSE_TICKLESS_IDLE */
|
||||
|
||||
/*
|
||||
* Compensate for the CPU cycles that pass while the SysTick is stopped (low
|
||||
* power functionality only.
|
||||
*/
|
||||
#if ( configUSE_TICKLESS_IDLE == 1 )
|
||||
static uint32_t ulStoppedTimerCompensation = 0;
|
||||
#endif /* configUSE_TICKLESS_IDLE */
|
||||
|
||||
/*
|
||||
* Used by the portASSERT_IF_INTERRUPT_PRIORITY_INVALID() macro to ensure
|
||||
* FreeRTOS API functions are not called from interrupts that have been assigned
|
||||
* a priority above configMAX_SYSCALL_INTERRUPT_PRIORITY.
|
||||
*/
|
||||
#if ( configASSERT_DEFINED == 1 )
|
||||
static uint8_t ucMaxSysCallPriority = 0;
|
||||
static uint32_t ulMaxPRIGROUPValue = 0;
|
||||
static const volatile uint8_t * const pcInterruptPriorityRegisters = ( const volatile uint8_t * const ) portNVIC_IP_REGISTERS_OFFSET_16;
|
||||
#endif /* configASSERT_DEFINED */
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* See header file for description.
|
||||
*/
|
||||
StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
|
||||
TaskFunction_t pxCode,
|
||||
void * pvParameters )
|
||||
{
|
||||
/* Simulate the stack frame as it would be created by a context switch
|
||||
* interrupt. */
|
||||
|
||||
/* Offset added to account for the way the MCU uses the stack on entry/exit
|
||||
* of interrupts, and to ensure alignment. */
|
||||
pxTopOfStack--;
|
||||
|
||||
*pxTopOfStack = portINITIAL_XPSR; /* xPSR */
|
||||
pxTopOfStack--;
|
||||
*pxTopOfStack = ( ( StackType_t ) pxCode ) & portSTART_ADDRESS_MASK; /* PC */
|
||||
pxTopOfStack--;
|
||||
*pxTopOfStack = ( StackType_t ) portTASK_RETURN_ADDRESS; /* LR */
|
||||
|
||||
/* Save code space by skipping register initialisation. */
|
||||
pxTopOfStack -= 5; /* R12, R3, R2 and R1. */
|
||||
*pxTopOfStack = ( StackType_t ) pvParameters; /* R0 */
|
||||
|
||||
/* A save method is being used that requires each task to maintain its
|
||||
* own exec return value. */
|
||||
pxTopOfStack--;
|
||||
*pxTopOfStack = portINITIAL_EXC_RETURN;
|
||||
|
||||
pxTopOfStack -= 8; /* R11, R10, R9, R8, R7, R6, R5 and R4. */
|
||||
|
||||
return pxTopOfStack;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void prvTaskExitError( void )
|
||||
{
|
||||
volatile uint32_t ulDummy = 0;
|
||||
|
||||
/* A function that implements a task must not exit or attempt to return to
|
||||
* its caller as there is nothing to return to. If a task wants to exit it
|
||||
* should instead call vTaskDelete( NULL ).
|
||||
*
|
||||
* Artificially force an assert() to be triggered if configASSERT() is
|
||||
* defined, then stop here so application writers can catch the error. */
|
||||
configASSERT( uxCriticalNesting == ~0UL );
|
||||
portDISABLE_INTERRUPTS();
|
||||
|
||||
while( ulDummy == 0 )
|
||||
{
|
||||
/* This file calls prvTaskExitError() after the scheduler has been
|
||||
* started to remove a compiler warning about the function being defined
|
||||
* but never called. ulDummy is used purely to quieten other warnings
|
||||
* about code appearing after this function is called - making ulDummy
|
||||
* volatile makes the compiler think the function could return and
|
||||
* therefore not output an 'unreachable code' warning for code that appears
|
||||
* after it. */
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortSVCHandler( void )
|
||||
{
|
||||
__asm volatile (
|
||||
" ldr r3, =pxCurrentTCB \n" /* Restore the context. */
|
||||
" ldr r1, [r3] \n" /* Get the pxCurrentTCB address. */
|
||||
" ldr r0, [r1] \n" /* The first item in pxCurrentTCB is the task top of stack. */
|
||||
" ldmia r0!, {r4-r11, r14} \n" /* Pop the registers that are not automatically saved on exception entry and the critical nesting count. */
|
||||
" msr psp, r0 \n" /* Restore the task stack pointer. */
|
||||
" isb \n"
|
||||
" mov r0, #0 \n"
|
||||
" msr basepri, r0 \n"
|
||||
" bx r14 \n"
|
||||
" \n"
|
||||
" .ltorg \n"
|
||||
);
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void prvPortStartFirstTask( void )
|
||||
{
|
||||
/* Start the first task. This also clears the bit that indicates the FPU is
|
||||
* in use in case the FPU was used before the scheduler was started - which
|
||||
* would otherwise result in the unnecessary leaving of space in the SVC stack
|
||||
* for lazy saving of FPU registers. */
|
||||
__asm volatile (
|
||||
" ldr r0, =0xE000ED08 \n" /* Use the NVIC offset register to locate the stack. */
|
||||
" ldr r0, [r0] \n"
|
||||
" ldr r0, [r0] \n"
|
||||
" msr msp, r0 \n" /* Set the msp back to the start of the stack. */
|
||||
" mov r0, #0 \n" /* Clear the bit that indicates the FPU is in use, see comment above. */
|
||||
" msr control, r0 \n"
|
||||
" cpsie i \n" /* Globally enable interrupts. */
|
||||
" cpsie f \n"
|
||||
" dsb \n"
|
||||
" isb \n"
|
||||
" svc 0 \n" /* System call to start first task. */
|
||||
" nop \n"
|
||||
" .ltorg \n"
|
||||
);
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* See header file for description.
|
||||
*/
|
||||
BaseType_t xPortStartScheduler( void )
|
||||
{
|
||||
/* This port can be used on all revisions of the Cortex-M7 core other than
|
||||
* the r0p1 parts. r0p1 parts should use the port from the
|
||||
* /source/portable/GCC/ARM_CM7/r0p1 directory. */
|
||||
configASSERT( portCPUID != portCORTEX_M7_r0p1_ID );
|
||||
configASSERT( portCPUID != portCORTEX_M7_r0p0_ID );
|
||||
|
||||
/* An application can install FreeRTOS interrupt handlers in one of the
|
||||
* following ways:
|
||||
* 1. Direct Routing - Install the functions vPortSVCHandler and
|
||||
* xPortPendSVHandler for SVCall and PendSV interrupts respectively.
|
||||
* 2. Indirect Routing - Install separate handlers for SVCall and PendSV
|
||||
* interrupts and route program control from those handlers to
|
||||
* vPortSVCHandler and xPortPendSVHandler functions.
|
||||
*
|
||||
* Applications that use Indirect Routing must set
|
||||
* configCHECK_HANDLER_INSTALLATION to 0 in their FreeRTOSConfig.h. Direct
|
||||
* routing, which is validated here when configCHECK_HANDLER_INSTALLATION
|
||||
* is 1, should be preferred when possible. */
|
||||
#if ( configCHECK_HANDLER_INSTALLATION == 1 )
|
||||
{
|
||||
const portISR_t * const pxVectorTable = portSCB_VTOR_REG;
|
||||
|
||||
/* Validate that the application has correctly installed the FreeRTOS
|
||||
* handlers for SVCall and PendSV interrupts. We do not check the
|
||||
* installation of the SysTick handler because the application may
|
||||
* choose to drive the RTOS tick using a timer other than the SysTick
|
||||
* timer by overriding the weak function vPortSetupTimerInterrupt().
|
||||
*
|
||||
* Assertion failures here indicate incorrect installation of the
|
||||
* FreeRTOS handlers. For help installing the FreeRTOS handlers, see
|
||||
* https://www.freertos.org/Why-FreeRTOS/FAQs.
|
||||
*
|
||||
* Systems with a configurable address for the interrupt vector table
|
||||
* can also encounter assertion failures or even system faults here if
|
||||
* VTOR is not set correctly to point to the application's vector table. */
|
||||
configASSERT( pxVectorTable[ portVECTOR_INDEX_SVC ] == vPortSVCHandler );
|
||||
configASSERT( pxVectorTable[ portVECTOR_INDEX_PENDSV ] == xPortPendSVHandler );
|
||||
}
|
||||
#endif /* configCHECK_HANDLER_INSTALLATION */
|
||||
|
||||
#if ( configASSERT_DEFINED == 1 )
|
||||
{
|
||||
volatile uint8_t ucOriginalPriority;
|
||||
volatile uint32_t ulImplementedPrioBits = 0;
|
||||
volatile uint8_t * const pucFirstUserPriorityRegister = ( volatile uint8_t * const ) ( portNVIC_IP_REGISTERS_OFFSET_16 + portFIRST_USER_INTERRUPT_NUMBER );
|
||||
volatile uint8_t ucMaxPriorityValue;
|
||||
|
||||
/* Determine the maximum priority from which ISR safe FreeRTOS API
|
||||
* functions can be called. ISR safe functions are those that end in
|
||||
* "FromISR". FreeRTOS maintains separate thread and ISR API functions to
|
||||
* ensure interrupt entry is as fast and simple as possible.
|
||||
*
|
||||
* Save the interrupt priority value that is about to be clobbered. */
|
||||
ucOriginalPriority = *pucFirstUserPriorityRegister;
|
||||
|
||||
/* Determine the number of priority bits available. First write to all
|
||||
* possible bits. */
|
||||
*pucFirstUserPriorityRegister = portMAX_8_BIT_VALUE;
|
||||
|
||||
/* Read the value back to see how many bits stuck. */
|
||||
ucMaxPriorityValue = *pucFirstUserPriorityRegister;
|
||||
|
||||
/* Use the same mask on the maximum system call priority. */
|
||||
ucMaxSysCallPriority = configMAX_SYSCALL_INTERRUPT_PRIORITY & ucMaxPriorityValue;
|
||||
|
||||
/* Check that the maximum system call priority is nonzero after
|
||||
* accounting for the number of priority bits supported by the
|
||||
* hardware. A priority of 0 is invalid because setting the BASEPRI
|
||||
* register to 0 unmasks all interrupts, and interrupts with priority 0
|
||||
* cannot be masked using BASEPRI.
|
||||
* See https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
|
||||
configASSERT( ucMaxSysCallPriority );
|
||||
|
||||
/* Check that the bits not implemented in hardware are zero in
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY. */
|
||||
configASSERT( ( configMAX_SYSCALL_INTERRUPT_PRIORITY & ( ~ucMaxPriorityValue ) ) == 0U );
|
||||
|
||||
/* Calculate the maximum acceptable priority group value for the number
|
||||
* of bits read back. */
|
||||
|
||||
while( ( ucMaxPriorityValue & portTOP_BIT_OF_BYTE ) == portTOP_BIT_OF_BYTE )
|
||||
{
|
||||
ulImplementedPrioBits++;
|
||||
ucMaxPriorityValue <<= ( uint8_t ) 0x01;
|
||||
}
|
||||
|
||||
if( ulImplementedPrioBits == 8 )
|
||||
{
|
||||
/* When the hardware implements 8 priority bits, there is no way for
|
||||
* the software to configure PRIGROUP to not have sub-priorities. As
|
||||
* a result, the least significant bit is always used for sub-priority
|
||||
* and there are 128 preemption priorities and 2 sub-priorities.
|
||||
*
|
||||
* This may cause some confusion in some cases - for example, if
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY is set to 5, both 5 and 4
|
||||
* priority interrupts will be masked in Critical Sections as those
|
||||
* are at the same preemption priority. This may appear confusing as
|
||||
* 4 is higher (numerically lower) priority than
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY and therefore, should not
|
||||
* have been masked. Instead, if we set configMAX_SYSCALL_INTERRUPT_PRIORITY
|
||||
* to 4, this confusion does not happen and the behaviour remains the same.
|
||||
*
|
||||
* The following assert ensures that the sub-priority bit in the
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY is clear to avoid the above mentioned
|
||||
* confusion. */
|
||||
configASSERT( ( configMAX_SYSCALL_INTERRUPT_PRIORITY & 0x1U ) == 0U );
|
||||
ulMaxPRIGROUPValue = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
ulMaxPRIGROUPValue = portMAX_PRIGROUP_BITS - ulImplementedPrioBits;
|
||||
}
|
||||
|
||||
/* Shift the priority group value back to its position within the AIRCR
|
||||
* register. */
|
||||
ulMaxPRIGROUPValue <<= portPRIGROUP_SHIFT;
|
||||
ulMaxPRIGROUPValue &= portPRIORITY_GROUP_MASK;
|
||||
|
||||
/* Restore the clobbered interrupt priority register to its original
|
||||
* value. */
|
||||
*pucFirstUserPriorityRegister = ucOriginalPriority;
|
||||
}
|
||||
#endif /* configASSERT_DEFINED */
|
||||
|
||||
/* Make PendSV and SysTick the lowest priority interrupts, and make SVCall
|
||||
* the highest priority. */
|
||||
portNVIC_SHPR3_REG |= portNVIC_PENDSV_PRI;
|
||||
portNVIC_SHPR3_REG |= portNVIC_SYSTICK_PRI;
|
||||
portNVIC_SHPR2_REG = 0;
|
||||
|
||||
/* Start the timer that generates the tick ISR. Interrupts are disabled
|
||||
* here already. */
|
||||
vPortSetupTimerInterrupt();
|
||||
|
||||
/* Initialise the critical nesting count ready for the first task. */
|
||||
uxCriticalNesting = 0;
|
||||
|
||||
/* Ensure the VFP is enabled - it should be anyway. */
|
||||
vPortEnableVFP();
|
||||
|
||||
/* Lazy save always. */
|
||||
*( portFPCCR ) |= portASPEN_AND_LSPEN_BITS;
|
||||
|
||||
/* Start the first task. */
|
||||
prvPortStartFirstTask();
|
||||
|
||||
/* Should never get here as the tasks will now be executing! Call the task
|
||||
* exit error function to prevent compiler warnings about a static function
|
||||
* not being called in the case that the application writer overrides this
|
||||
* functionality by defining configTASK_RETURN_ADDRESS. Call
|
||||
* vTaskSwitchContext() so link time optimisation does not remove the
|
||||
* symbol. */
|
||||
vTaskSwitchContext();
|
||||
prvTaskExitError();
|
||||
|
||||
/* Should not get here! */
|
||||
return 0;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortEndScheduler( void )
|
||||
{
|
||||
/* Not implemented in ports where there is nothing to return to.
|
||||
* Artificially force an assert. */
|
||||
configASSERT( uxCriticalNesting == 1000UL );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortEnterCritical( void )
|
||||
{
|
||||
portDISABLE_INTERRUPTS();
|
||||
uxCriticalNesting++;
|
||||
|
||||
/* This is not the interrupt safe version of the enter critical function so
|
||||
* assert() if it is being called from an interrupt context. Only API
|
||||
* functions that end in "FromISR" can be used in an interrupt. Only assert if
|
||||
* the critical nesting count is 1 to protect against recursive calls if the
|
||||
* assert function also uses a critical section. */
|
||||
if( uxCriticalNesting == 1 )
|
||||
{
|
||||
configASSERT( ( portNVIC_INT_CTRL_REG & portVECTACTIVE_MASK ) == 0 );
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortExitCritical( void )
|
||||
{
|
||||
configASSERT( uxCriticalNesting );
|
||||
uxCriticalNesting--;
|
||||
|
||||
if( uxCriticalNesting == 0 )
|
||||
{
|
||||
portENABLE_INTERRUPTS();
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void xPortPendSVHandler( void )
|
||||
{
|
||||
/* This is a naked function. */
|
||||
|
||||
__asm volatile
|
||||
(
|
||||
" mrs r0, psp \n"
|
||||
" isb \n"
|
||||
" \n"
|
||||
" ldr r3, =pxCurrentTCB \n" /* Get the location of the current TCB. */
|
||||
" ldr r2, [r3] \n"
|
||||
" \n"
|
||||
" tst r14, #0x10 \n" /* Is the task using the FPU context? If so, push high vfp registers. */
|
||||
" it eq \n"
|
||||
" vstmdbeq r0!, {s16-s31} \n"
|
||||
" \n"
|
||||
" stmdb r0!, {r4-r11, r14} \n" /* Save the core registers. */
|
||||
" str r0, [r2] \n" /* Save the new top of stack into the first member of the TCB. */
|
||||
" \n"
|
||||
" stmdb sp!, {r0, r3} \n"
|
||||
" mov r0, %0 \n"
|
||||
" msr basepri, r0 \n"
|
||||
" dsb \n"
|
||||
" isb \n"
|
||||
" bl vTaskSwitchContext \n"
|
||||
" mov r0, #0 \n"
|
||||
" msr basepri, r0 \n"
|
||||
" ldmia sp!, {r0, r3} \n"
|
||||
" \n"
|
||||
" ldr r1, [r3] \n" /* The first item in pxCurrentTCB is the task top of stack. */
|
||||
" ldr r0, [r1] \n"
|
||||
" \n"
|
||||
" ldmia r0!, {r4-r11, r14} \n" /* Pop the core registers. */
|
||||
" \n"
|
||||
" tst r14, #0x10 \n" /* Is the task using the FPU context? If so, pop the high vfp registers too. */
|
||||
" it eq \n"
|
||||
" vldmiaeq r0!, {s16-s31} \n"
|
||||
" \n"
|
||||
" msr psp, r0 \n"
|
||||
" isb \n"
|
||||
" \n"
|
||||
#ifdef WORKAROUND_PMU_CM001 /* XMC4000 specific errata workaround. */
|
||||
#if WORKAROUND_PMU_CM001 == 1
|
||||
" push { r14 } \n"
|
||||
" pop { pc } \n"
|
||||
#endif
|
||||
#endif
|
||||
" \n"
|
||||
" bx r14 \n"
|
||||
" \n"
|
||||
" .ltorg \n"
|
||||
::"i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY )
|
||||
);
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void xPortSysTickHandler( void )
|
||||
{
|
||||
/* The SysTick runs at the lowest interrupt priority, so when this interrupt
|
||||
* executes all interrupts must be unmasked. There is therefore no need to
|
||||
* save and then restore the interrupt mask value as its value is already
|
||||
* known. */
|
||||
portDISABLE_INTERRUPTS();
|
||||
traceISR_ENTER();
|
||||
{
|
||||
/* Increment the RTOS tick. */
|
||||
if( xTaskIncrementTick() != pdFALSE )
|
||||
{
|
||||
traceISR_EXIT_TO_SCHEDULER();
|
||||
|
||||
/* A context switch is required. Context switching is performed in
|
||||
* the PendSV interrupt. Pend the PendSV interrupt. */
|
||||
portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;
|
||||
}
|
||||
else
|
||||
{
|
||||
traceISR_EXIT();
|
||||
}
|
||||
}
|
||||
portENABLE_INTERRUPTS();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( configUSE_TICKLESS_IDLE == 1 )
|
||||
|
||||
__attribute__( ( weak ) ) void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime )
|
||||
{
|
||||
uint32_t ulReloadValue, ulCompleteTickPeriods, ulCompletedSysTickDecrements, ulSysTickDecrementsLeft;
|
||||
TickType_t xModifiableIdleTime;
|
||||
|
||||
/* Make sure the SysTick reload value does not overflow the counter. */
|
||||
if( xExpectedIdleTime > xMaximumPossibleSuppressedTicks )
|
||||
{
|
||||
xExpectedIdleTime = xMaximumPossibleSuppressedTicks;
|
||||
}
|
||||
|
||||
/* Enter a critical section but don't use the taskENTER_CRITICAL()
|
||||
* method as that will mask interrupts that should exit sleep mode. */
|
||||
__asm volatile ( "cpsid i" ::: "memory" );
|
||||
__asm volatile ( "dsb" );
|
||||
__asm volatile ( "isb" );
|
||||
|
||||
/* If a context switch is pending or a task is waiting for the scheduler
|
||||
* to be unsuspended then abandon the low power entry. */
|
||||
if( eTaskConfirmSleepModeStatus() == eAbortSleep )
|
||||
{
|
||||
/* Re-enable interrupts - see comments above the cpsid instruction
|
||||
* above. */
|
||||
__asm volatile ( "cpsie i" ::: "memory" );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Stop the SysTick momentarily. The time the SysTick is stopped for
|
||||
* is accounted for as best it can be, but using the tickless mode will
|
||||
* inevitably result in some tiny drift of the time maintained by the
|
||||
* kernel with respect to calendar time. */
|
||||
portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT );
|
||||
|
||||
/* Use the SysTick current-value register to determine the number of
|
||||
* SysTick decrements remaining until the next tick interrupt. If the
|
||||
* current-value register is zero, then there are actually
|
||||
* ulTimerCountsForOneTick decrements remaining, not zero, because the
|
||||
* SysTick requests the interrupt when decrementing from 1 to 0. */
|
||||
ulSysTickDecrementsLeft = portNVIC_SYSTICK_CURRENT_VALUE_REG;
|
||||
|
||||
if( ulSysTickDecrementsLeft == 0 )
|
||||
{
|
||||
ulSysTickDecrementsLeft = ulTimerCountsForOneTick;
|
||||
}
|
||||
|
||||
/* Calculate the reload value required to wait xExpectedIdleTime
|
||||
* tick periods. -1 is used because this code normally executes part
|
||||
* way through the first tick period. But if the SysTick IRQ is now
|
||||
* pending, then clear the IRQ, suppressing the first tick, and correct
|
||||
* the reload value to reflect that the second tick period is already
|
||||
* underway. The expected idle time is always at least two ticks. */
|
||||
ulReloadValue = ulSysTickDecrementsLeft + ( ulTimerCountsForOneTick * ( xExpectedIdleTime - 1UL ) );
|
||||
|
||||
if( ( portNVIC_INT_CTRL_REG & portNVIC_PEND_SYSTICK_SET_BIT ) != 0 )
|
||||
{
|
||||
portNVIC_INT_CTRL_REG = portNVIC_PEND_SYSTICK_CLEAR_BIT;
|
||||
ulReloadValue -= ulTimerCountsForOneTick;
|
||||
}
|
||||
|
||||
if( ulReloadValue > ulStoppedTimerCompensation )
|
||||
{
|
||||
ulReloadValue -= ulStoppedTimerCompensation;
|
||||
}
|
||||
|
||||
/* Set the new reload value. */
|
||||
portNVIC_SYSTICK_LOAD_REG = ulReloadValue;
|
||||
|
||||
/* Clear the SysTick count flag and set the count value back to
|
||||
* zero. */
|
||||
portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
|
||||
|
||||
/* Restart SysTick. */
|
||||
portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
|
||||
|
||||
/* Sleep until something happens. configPRE_SLEEP_PROCESSING() can
|
||||
* set its parameter to 0 to indicate that its implementation contains
|
||||
* its own wait for interrupt or wait for event instruction, and so wfi
|
||||
* should not be executed again. However, the original expected idle
|
||||
* time variable must remain unmodified, so a copy is taken. */
|
||||
xModifiableIdleTime = xExpectedIdleTime;
|
||||
configPRE_SLEEP_PROCESSING( xModifiableIdleTime );
|
||||
|
||||
if( xModifiableIdleTime > 0 )
|
||||
{
|
||||
__asm volatile ( "dsb" ::: "memory" );
|
||||
__asm volatile ( "wfi" );
|
||||
__asm volatile ( "isb" );
|
||||
}
|
||||
|
||||
configPOST_SLEEP_PROCESSING( xExpectedIdleTime );
|
||||
|
||||
/* Re-enable interrupts to allow the interrupt that brought the MCU
|
||||
* out of sleep mode to execute immediately. See comments above
|
||||
* the cpsid instruction above. */
|
||||
__asm volatile ( "cpsie i" ::: "memory" );
|
||||
__asm volatile ( "dsb" );
|
||||
__asm volatile ( "isb" );
|
||||
|
||||
/* Disable interrupts again because the clock is about to be stopped
|
||||
* and interrupts that execute while the clock is stopped will increase
|
||||
* any slippage between the time maintained by the RTOS and calendar
|
||||
* time. */
|
||||
__asm volatile ( "cpsid i" ::: "memory" );
|
||||
__asm volatile ( "dsb" );
|
||||
__asm volatile ( "isb" );
|
||||
|
||||
/* Disable the SysTick clock without reading the
|
||||
* portNVIC_SYSTICK_CTRL_REG register to ensure the
|
||||
* portNVIC_SYSTICK_COUNT_FLAG_BIT is not cleared if it is set. Again,
|
||||
* the time the SysTick is stopped for is accounted for as best it can
|
||||
* be, but using the tickless mode will inevitably result in some tiny
|
||||
* drift of the time maintained by the kernel with respect to calendar
|
||||
* time*/
|
||||
portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT );
|
||||
|
||||
/* Determine whether the SysTick has already counted to zero. */
|
||||
if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )
|
||||
{
|
||||
uint32_t ulCalculatedLoadValue;
|
||||
|
||||
/* The tick interrupt ended the sleep (or is now pending), and
|
||||
* a new tick period has started. Reset portNVIC_SYSTICK_LOAD_REG
|
||||
* with whatever remains of the new tick period. */
|
||||
ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );
|
||||
|
||||
/* Don't allow a tiny value, or values that have somehow
|
||||
* underflowed because the post sleep hook did something
|
||||
* that took too long or because the SysTick current-value register
|
||||
* is zero. */
|
||||
if( ( ulCalculatedLoadValue <= ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )
|
||||
{
|
||||
ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );
|
||||
}
|
||||
|
||||
portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;
|
||||
|
||||
/* As the pending tick will be processed as soon as this
|
||||
* function exits, the tick value maintained by the tick is stepped
|
||||
* forward by one less than the time spent waiting. */
|
||||
ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Something other than the tick interrupt ended the sleep. */
|
||||
|
||||
/* Use the SysTick current-value register to determine the
|
||||
* number of SysTick decrements remaining until the expected idle
|
||||
* time would have ended. */
|
||||
ulSysTickDecrementsLeft = portNVIC_SYSTICK_CURRENT_VALUE_REG;
|
||||
#if ( portNVIC_SYSTICK_CLK_BIT_CONFIG != portNVIC_SYSTICK_CLK_BIT )
|
||||
{
|
||||
/* If the SysTick is not using the core clock, the current-
|
||||
* value register might still be zero here. In that case, the
|
||||
* SysTick didn't load from the reload register, and there are
|
||||
* ulReloadValue decrements remaining in the expected idle
|
||||
* time, not zero. */
|
||||
if( ulSysTickDecrementsLeft == 0 )
|
||||
{
|
||||
ulSysTickDecrementsLeft = ulReloadValue;
|
||||
}
|
||||
}
|
||||
#endif /* portNVIC_SYSTICK_CLK_BIT_CONFIG */
|
||||
|
||||
/* Work out how long the sleep lasted rounded to complete tick
|
||||
* periods (not the ulReload value which accounted for part
|
||||
* ticks). */
|
||||
ulCompletedSysTickDecrements = ( xExpectedIdleTime * ulTimerCountsForOneTick ) - ulSysTickDecrementsLeft;
|
||||
|
||||
/* How many complete tick periods passed while the processor
|
||||
* was waiting? */
|
||||
ulCompleteTickPeriods = ulCompletedSysTickDecrements / ulTimerCountsForOneTick;
|
||||
|
||||
/* The reload value is set to whatever fraction of a single tick
|
||||
* period remains. */
|
||||
portNVIC_SYSTICK_LOAD_REG = ( ( ulCompleteTickPeriods + 1UL ) * ulTimerCountsForOneTick ) - ulCompletedSysTickDecrements;
|
||||
}
|
||||
|
||||
/* Restart SysTick so it runs from portNVIC_SYSTICK_LOAD_REG again,
|
||||
* then set portNVIC_SYSTICK_LOAD_REG back to its standard value. If
|
||||
* the SysTick is not using the core clock, temporarily configure it to
|
||||
* use the core clock. This configuration forces the SysTick to load
|
||||
* from portNVIC_SYSTICK_LOAD_REG immediately instead of at the next
|
||||
* cycle of the other clock. Then portNVIC_SYSTICK_LOAD_REG is ready
|
||||
* to receive the standard value immediately. */
|
||||
portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
|
||||
portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT;
|
||||
#if ( portNVIC_SYSTICK_CLK_BIT_CONFIG == portNVIC_SYSTICK_CLK_BIT )
|
||||
{
|
||||
portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
|
||||
}
|
||||
#else
|
||||
{
|
||||
/* The temporary usage of the core clock has served its purpose,
|
||||
* as described above. Resume usage of the other clock. */
|
||||
portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT;
|
||||
|
||||
if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )
|
||||
{
|
||||
/* The partial tick period already ended. Be sure the SysTick
|
||||
* counts it only once. */
|
||||
portNVIC_SYSTICK_CURRENT_VALUE_REG = 0;
|
||||
}
|
||||
|
||||
portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
|
||||
portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT;
|
||||
}
|
||||
#endif /* portNVIC_SYSTICK_CLK_BIT_CONFIG */
|
||||
|
||||
/* Step the tick to account for any tick periods that elapsed. */
|
||||
vTaskStepTick( ulCompleteTickPeriods );
|
||||
|
||||
/* Exit with interrupts enabled. */
|
||||
__asm volatile ( "cpsie i" ::: "memory" );
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* #if configUSE_TICKLESS_IDLE */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Setup the systick timer to generate the tick interrupts at the required
|
||||
* frequency.
|
||||
*/
|
||||
__attribute__( ( weak ) ) void vPortSetupTimerInterrupt( void )
|
||||
{
|
||||
/* Calculate the constants required to configure the tick interrupt. */
|
||||
#if ( configUSE_TICKLESS_IDLE == 1 )
|
||||
{
|
||||
ulTimerCountsForOneTick = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ );
|
||||
xMaximumPossibleSuppressedTicks = portMAX_24_BIT_NUMBER / ulTimerCountsForOneTick;
|
||||
ulStoppedTimerCompensation = portMISSED_COUNTS_FACTOR / ( configCPU_CLOCK_HZ / configSYSTICK_CLOCK_HZ );
|
||||
}
|
||||
#endif /* configUSE_TICKLESS_IDLE */
|
||||
|
||||
/* Stop and clear the SysTick. */
|
||||
portNVIC_SYSTICK_CTRL_REG = 0UL;
|
||||
portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
|
||||
|
||||
/* Configure SysTick to interrupt at the requested rate. */
|
||||
portNVIC_SYSTICK_LOAD_REG = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ) - 1UL;
|
||||
portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* This is a naked function. */
|
||||
static void vPortEnableVFP( void )
|
||||
{
|
||||
__asm volatile
|
||||
(
|
||||
" ldr.w r0, =0xE000ED88 \n" /* The FPU enable bits are in the CPACR. */
|
||||
" ldr r1, [r0] \n"
|
||||
" \n"
|
||||
" orr r1, r1, #( 0xf << 20 ) \n" /* Enable CP10 and CP11 coprocessors, then save back. */
|
||||
" str r1, [r0] \n"
|
||||
" bx r14 \n"
|
||||
" .ltorg \n"
|
||||
);
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( configASSERT_DEFINED == 1 )
|
||||
|
||||
void vPortValidateInterruptPriority( void )
|
||||
{
|
||||
uint32_t ulCurrentInterrupt;
|
||||
uint8_t ucCurrentPriority;
|
||||
|
||||
/* Obtain the number of the currently executing interrupt. */
|
||||
__asm volatile ( "mrs %0, ipsr" : "=r" ( ulCurrentInterrupt )::"memory" );
|
||||
|
||||
/* Is the interrupt number a user defined interrupt? */
|
||||
if( ulCurrentInterrupt >= portFIRST_USER_INTERRUPT_NUMBER )
|
||||
{
|
||||
/* Look up the interrupt's priority. */
|
||||
ucCurrentPriority = pcInterruptPriorityRegisters[ ulCurrentInterrupt ];
|
||||
|
||||
/* The following assertion will fail if a service routine (ISR) for
|
||||
* an interrupt that has been assigned a priority above
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY calls an ISR safe FreeRTOS API
|
||||
* function. ISR safe FreeRTOS API functions must *only* be called
|
||||
* from interrupts that have been assigned a priority at or below
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY.
|
||||
*
|
||||
* Numerically low interrupt priority numbers represent logically high
|
||||
* interrupt priorities, therefore the priority of the interrupt must
|
||||
* be set to a value equal to or numerically *higher* than
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY.
|
||||
*
|
||||
* Interrupts that use the FreeRTOS API must not be left at their
|
||||
* default priority of zero as that is the highest possible priority,
|
||||
* which is guaranteed to be above configMAX_SYSCALL_INTERRUPT_PRIORITY,
|
||||
* and therefore also guaranteed to be invalid.
|
||||
*
|
||||
* FreeRTOS maintains separate thread and ISR API functions to ensure
|
||||
* interrupt entry is as fast and simple as possible.
|
||||
*
|
||||
* The following links provide detailed information:
|
||||
* https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html
|
||||
* https://www.freertos.org/Why-FreeRTOS/FAQs */
|
||||
configASSERT( ucCurrentPriority >= ucMaxSysCallPriority );
|
||||
}
|
||||
|
||||
/* Priority grouping: The interrupt controller (NVIC) allows the bits
|
||||
* that define each interrupt's priority to be split between bits that
|
||||
* define the interrupt's pre-emption priority bits and bits that define
|
||||
* the interrupt's sub-priority. For simplicity all bits must be defined
|
||||
* to be pre-emption priority bits. The following assertion will fail if
|
||||
* this is not the case (if some bits represent a sub-priority).
|
||||
*
|
||||
* If the application only uses CMSIS libraries for interrupt
|
||||
* configuration then the correct setting can be achieved on all Cortex-M
|
||||
* devices by calling NVIC_SetPriorityGrouping( 0 ); before starting the
|
||||
* scheduler. Note however that some vendor specific peripheral libraries
|
||||
* assume a non-zero priority group setting, in which cases using a value
|
||||
* of zero will result in unpredictable behaviour. */
|
||||
configASSERT( ( portAIRCR_REG & portPRIORITY_GROUP_MASK ) <= ulMaxPRIGROUPValue );
|
||||
}
|
||||
|
||||
#endif /* configASSERT_DEFINED */
|
||||
+266
@@ -0,0 +1,266 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifndef PORTMACRO_H
|
||||
#define PORTMACRO_H
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Port specific definitions.
|
||||
*
|
||||
* The settings in this file configure FreeRTOS correctly for the
|
||||
* given hardware and compiler.
|
||||
*
|
||||
* These settings should not be altered.
|
||||
*-----------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* Type definitions. */
|
||||
#define portCHAR char
|
||||
#define portFLOAT float
|
||||
#define portDOUBLE double
|
||||
#define portLONG long
|
||||
#define portSHORT short
|
||||
#define portSTACK_TYPE uint32_t
|
||||
#define portBASE_TYPE long
|
||||
|
||||
typedef portSTACK_TYPE StackType_t;
|
||||
typedef long BaseType_t;
|
||||
typedef unsigned long UBaseType_t;
|
||||
|
||||
#if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS )
|
||||
typedef uint16_t TickType_t;
|
||||
#define portMAX_DELAY ( TickType_t ) 0xffff
|
||||
#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_32_BITS )
|
||||
typedef uint32_t TickType_t;
|
||||
#define portMAX_DELAY ( TickType_t ) 0xffffffffUL
|
||||
|
||||
/* 32-bit tick type on a 32-bit architecture, so reads of the tick count do
|
||||
* not need to be guarded with a critical section. */
|
||||
#define portTICK_TYPE_IS_ATOMIC 1
|
||||
#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_64_BITS )
|
||||
typedef uint64_t TickType_t;
|
||||
#define portMAX_DELAY ( TickType_t ) 0xffffffffffffffffULL
|
||||
#else /* if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS ) */
|
||||
#error configTICK_TYPE_WIDTH_IN_BITS set to unsupported tick type width.
|
||||
#endif /* if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Architecture specifics. */
|
||||
#define portSTACK_GROWTH ( -1 )
|
||||
#define portTICK_PERIOD_MS ( ( TickType_t ) 1000 / configTICK_RATE_HZ )
|
||||
#define portBYTE_ALIGNMENT 8
|
||||
#define portDONT_DISCARD __attribute__( ( used ) )
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Scheduler utilities. */
|
||||
#define portYIELD() \
|
||||
{ \
|
||||
/* Set a PendSV to request a context switch. */ \
|
||||
portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT; \
|
||||
\
|
||||
/* Barriers are normally not required but do ensure the code is completely \
|
||||
* within the specified behaviour for the architecture. */ \
|
||||
__asm volatile ( "dsb" ::: "memory" ); \
|
||||
__asm volatile ( "isb" ); \
|
||||
}
|
||||
|
||||
#define portNVIC_INT_CTRL_REG ( *( ( volatile uint32_t * ) 0xe000ed04 ) )
|
||||
#define portNVIC_PENDSVSET_BIT ( 1UL << 28UL )
|
||||
#define portEND_SWITCHING_ISR( xSwitchRequired ) \
|
||||
do \
|
||||
{ \
|
||||
if( xSwitchRequired != pdFALSE ) \
|
||||
{ \
|
||||
traceISR_EXIT_TO_SCHEDULER(); \
|
||||
portYIELD(); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
traceISR_EXIT(); \
|
||||
} \
|
||||
} while( 0 )
|
||||
#define portYIELD_FROM_ISR( x ) portEND_SWITCHING_ISR( x )
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Critical section management. */
|
||||
extern void vPortEnterCritical( void );
|
||||
extern void vPortExitCritical( void );
|
||||
#define portSET_INTERRUPT_MASK_FROM_ISR() ulPortRaiseBASEPRI()
|
||||
#define portCLEAR_INTERRUPT_MASK_FROM_ISR( x ) vPortSetBASEPRI( x )
|
||||
#define portDISABLE_INTERRUPTS() vPortRaiseBASEPRI()
|
||||
#define portENABLE_INTERRUPTS() vPortSetBASEPRI( 0 )
|
||||
#define portENTER_CRITICAL() vPortEnterCritical()
|
||||
#define portEXIT_CRITICAL() vPortExitCritical()
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Task function macros as described on the FreeRTOS.org WEB site. These are
|
||||
* not necessary for to use this port. They are defined so the common demo files
|
||||
* (which build with all the ports) will build. */
|
||||
#define portTASK_FUNCTION_PROTO( vFunction, pvParameters ) void vFunction( void * pvParameters )
|
||||
#define portTASK_FUNCTION( vFunction, pvParameters ) void vFunction( void * pvParameters )
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Tickless idle/low power functionality. */
|
||||
#ifndef portSUPPRESS_TICKS_AND_SLEEP
|
||||
extern void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime );
|
||||
#define portSUPPRESS_TICKS_AND_SLEEP( xExpectedIdleTime ) vPortSuppressTicksAndSleep( xExpectedIdleTime )
|
||||
#endif
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Architecture specific optimisations. */
|
||||
#ifndef configUSE_PORT_OPTIMISED_TASK_SELECTION
|
||||
#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1
|
||||
#endif
|
||||
|
||||
#if configUSE_PORT_OPTIMISED_TASK_SELECTION == 1
|
||||
|
||||
/* Generic helper function. */
|
||||
__attribute__( ( always_inline ) ) static inline uint8_t ucPortCountLeadingZeros( uint32_t ulBitmap )
|
||||
{
|
||||
uint8_t ucReturn;
|
||||
|
||||
__asm volatile ( "clz %0, %1" : "=r" ( ucReturn ) : "r" ( ulBitmap ) : "memory" );
|
||||
|
||||
return ucReturn;
|
||||
}
|
||||
|
||||
/* Check the configuration. */
|
||||
#if ( configMAX_PRIORITIES > 32 )
|
||||
#error configUSE_PORT_OPTIMISED_TASK_SELECTION can only be set to 1 when configMAX_PRIORITIES is less than or equal to 32. It is very rare that a system requires more than 10 to 15 difference priorities as tasks that share a priority will time slice.
|
||||
#endif
|
||||
|
||||
/* Store/clear the ready priorities in a bit map. */
|
||||
#define portRECORD_READY_PRIORITY( uxPriority, uxReadyPriorities ) ( uxReadyPriorities ) |= ( 1UL << ( uxPriority ) )
|
||||
#define portRESET_READY_PRIORITY( uxPriority, uxReadyPriorities ) ( uxReadyPriorities ) &= ~( 1UL << ( uxPriority ) )
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities ) uxTopPriority = ( 31UL - ( uint32_t ) ucPortCountLeadingZeros( ( uxReadyPriorities ) ) )
|
||||
|
||||
#endif /* configUSE_PORT_OPTIMISED_TASK_SELECTION */
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( configASSERT_DEFINED == 1 )
|
||||
void vPortValidateInterruptPriority( void );
|
||||
#define portASSERT_IF_INTERRUPT_PRIORITY_INVALID() vPortValidateInterruptPriority()
|
||||
#endif
|
||||
|
||||
/* portNOP() is not required by this port. */
|
||||
#define portNOP()
|
||||
|
||||
#define portINLINE __inline
|
||||
|
||||
#ifndef portFORCE_INLINE
|
||||
#define portFORCE_INLINE inline __attribute__( ( always_inline ) )
|
||||
#endif
|
||||
|
||||
portFORCE_INLINE static BaseType_t xPortIsInsideInterrupt( void )
|
||||
{
|
||||
uint32_t ulCurrentInterrupt;
|
||||
BaseType_t xReturn;
|
||||
|
||||
/* Obtain the number of the currently executing interrupt. */
|
||||
__asm volatile ( "mrs %0, ipsr" : "=r" ( ulCurrentInterrupt )::"memory" );
|
||||
|
||||
if( ulCurrentInterrupt == 0 )
|
||||
{
|
||||
xReturn = pdFALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
portFORCE_INLINE static void vPortRaiseBASEPRI( void )
|
||||
{
|
||||
uint32_t ulNewBASEPRI;
|
||||
|
||||
__asm volatile
|
||||
(
|
||||
" mov %0, %1 \n" \
|
||||
" msr basepri, %0 \n" \
|
||||
" isb \n" \
|
||||
" dsb \n" \
|
||||
: "=r" ( ulNewBASEPRI ) : "i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY ) : "memory"
|
||||
);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
portFORCE_INLINE static uint32_t ulPortRaiseBASEPRI( void )
|
||||
{
|
||||
uint32_t ulOriginalBASEPRI, ulNewBASEPRI;
|
||||
|
||||
__asm volatile
|
||||
(
|
||||
" mrs %0, basepri \n" \
|
||||
" mov %1, %2 \n" \
|
||||
" msr basepri, %1 \n" \
|
||||
" isb \n" \
|
||||
" dsb \n" \
|
||||
: "=r" ( ulOriginalBASEPRI ), "=r" ( ulNewBASEPRI ) : "i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY ) : "memory"
|
||||
);
|
||||
|
||||
/* This return will not be reached but is necessary to prevent compiler
|
||||
* warnings. */
|
||||
return ulOriginalBASEPRI;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
portFORCE_INLINE static void vPortSetBASEPRI( uint32_t ulNewMaskValue )
|
||||
{
|
||||
__asm volatile
|
||||
(
|
||||
" msr basepri, %0 " ::"r" ( ulNewMaskValue ) : "memory"
|
||||
);
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#define portMEMORY_BARRIER() __asm volatile ( "" ::: "memory" )
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
#endif /* PORTMACRO_H */
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
There are two options for running FreeRTOS on ARM Cortex-M7 microcontrollers.
|
||||
The best option depends on the revision of the ARM Cortex-M7 core in use. The
|
||||
revision is specified by an 'r' number, and a 'p' number, so will look something
|
||||
like 'r0p1'. Check the documentation for the microcontroller in use to find the
|
||||
revision of the Cortex-M7 core used in that microcontroller. If in doubt, use
|
||||
the FreeRTOS port provided specifically for r0p1 revisions, as that can be used
|
||||
with all core revisions.
|
||||
|
||||
The first option is to use the ARM Cortex-M4F port, and the second option is to
|
||||
use the Cortex-M7 r0p1 port - the latter containing a minor errata workaround.
|
||||
|
||||
If the revision of the ARM Cortex-M7 core is not r0p1 then either option can be
|
||||
used, but it is recommended to use the FreeRTOS ARM Cortex-M4F port located in
|
||||
the /FreeRTOS/Source/portable/GCC/ARM_CM4F directory.
|
||||
|
||||
If the revision of the ARM Cortex-M7 core is r0p1 then use the FreeRTOS ARM
|
||||
Cortex-M7 r0p1 port located in the /FreeRTOS/Source/portable/GCC/ARM_CM7/r0p1
|
||||
directory.
|
||||
+897
@@ -0,0 +1,897 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Implementation of functions defined in portable.h for the ARM CM7 port.
|
||||
*----------------------------------------------------------*/
|
||||
|
||||
/* Scheduler includes. */
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
|
||||
#ifndef __ARM_FP
|
||||
#error This port can only be used when the project options are configured to enable hardware floating point support.
|
||||
#endif
|
||||
|
||||
/* Prototype of all Interrupt Service Routines (ISRs). */
|
||||
typedef void ( * portISR_t )( void );
|
||||
|
||||
/* Constants required to manipulate the core. Registers first... */
|
||||
#define portNVIC_SYSTICK_CTRL_REG ( *( ( volatile uint32_t * ) 0xe000e010 ) )
|
||||
#define portNVIC_SYSTICK_LOAD_REG ( *( ( volatile uint32_t * ) 0xe000e014 ) )
|
||||
#define portNVIC_SYSTICK_CURRENT_VALUE_REG ( *( ( volatile uint32_t * ) 0xe000e018 ) )
|
||||
#define portNVIC_SHPR2_REG ( *( ( volatile uint32_t * ) 0xe000ed1c ) )
|
||||
#define portNVIC_SHPR3_REG ( *( ( volatile uint32_t * ) 0xe000ed20 ) )
|
||||
/* ...then bits in the registers. */
|
||||
#define portNVIC_SYSTICK_CLK_BIT ( 1UL << 2UL )
|
||||
#define portNVIC_SYSTICK_INT_BIT ( 1UL << 1UL )
|
||||
#define portNVIC_SYSTICK_ENABLE_BIT ( 1UL << 0UL )
|
||||
#define portNVIC_SYSTICK_COUNT_FLAG_BIT ( 1UL << 16UL )
|
||||
#define portNVIC_PENDSVCLEAR_BIT ( 1UL << 27UL )
|
||||
#define portNVIC_PEND_SYSTICK_SET_BIT ( 1UL << 26UL )
|
||||
#define portNVIC_PEND_SYSTICK_CLEAR_BIT ( 1UL << 25UL )
|
||||
|
||||
#define portMIN_INTERRUPT_PRIORITY ( 255UL )
|
||||
#define portNVIC_PENDSV_PRI ( ( ( uint32_t ) portMIN_INTERRUPT_PRIORITY ) << 16UL )
|
||||
#define portNVIC_SYSTICK_PRI ( ( ( uint32_t ) portMIN_INTERRUPT_PRIORITY ) << 24UL )
|
||||
|
||||
/* Constants used to check the installation of the FreeRTOS interrupt handlers. */
|
||||
#define portSCB_VTOR_REG ( *( ( portISR_t ** ) 0xE000ED08 ) )
|
||||
#define portVECTOR_INDEX_SVC ( 11 )
|
||||
#define portVECTOR_INDEX_PENDSV ( 14 )
|
||||
|
||||
/* Constants required to check the validity of an interrupt priority. */
|
||||
#define portFIRST_USER_INTERRUPT_NUMBER ( 16 )
|
||||
#define portNVIC_IP_REGISTERS_OFFSET_16 ( 0xE000E3F0 )
|
||||
#define portAIRCR_REG ( *( ( volatile uint32_t * ) 0xE000ED0C ) )
|
||||
#define portMAX_8_BIT_VALUE ( ( uint8_t ) 0xff )
|
||||
#define portTOP_BIT_OF_BYTE ( ( uint8_t ) 0x80 )
|
||||
#define portMAX_PRIGROUP_BITS ( ( uint8_t ) 7 )
|
||||
#define portPRIORITY_GROUP_MASK ( 0x07UL << 8UL )
|
||||
#define portPRIGROUP_SHIFT ( 8UL )
|
||||
|
||||
/* Masks off all bits but the VECTACTIVE bits in the ICSR register. */
|
||||
#define portVECTACTIVE_MASK ( 0xFFUL )
|
||||
|
||||
/* Constants required to manipulate the VFP. */
|
||||
#define portFPCCR ( ( volatile uint32_t * ) 0xe000ef34 ) /* Floating point context control register. */
|
||||
#define portASPEN_AND_LSPEN_BITS ( 0x3UL << 30UL )
|
||||
|
||||
/* Constants required to set up the initial stack. */
|
||||
#define portINITIAL_XPSR ( 0x01000000 )
|
||||
#define portINITIAL_EXC_RETURN ( 0xfffffffd )
|
||||
|
||||
/* The systick is a 24-bit counter. */
|
||||
#define portMAX_24_BIT_NUMBER ( 0xffffffUL )
|
||||
|
||||
/* For strict compliance with the Cortex-M spec the task start address should
|
||||
* have bit-0 clear, as it is loaded into the PC on exit from an ISR. */
|
||||
#define portSTART_ADDRESS_MASK ( ( StackType_t ) 0xfffffffeUL )
|
||||
|
||||
/* A fiddle factor to estimate the number of SysTick counts that would have
|
||||
* occurred while the SysTick counter is stopped during tickless idle
|
||||
* calculations. */
|
||||
#define portMISSED_COUNTS_FACTOR ( 94UL )
|
||||
|
||||
/* Let the user override the default SysTick clock rate. If defined by the
|
||||
* user, this symbol must equal the SysTick clock rate when the CLK bit is 0 in the
|
||||
* configuration register. */
|
||||
#ifndef configSYSTICK_CLOCK_HZ
|
||||
#define configSYSTICK_CLOCK_HZ ( configCPU_CLOCK_HZ )
|
||||
/* Ensure the SysTick is clocked at the same frequency as the core. */
|
||||
#define portNVIC_SYSTICK_CLK_BIT_CONFIG ( portNVIC_SYSTICK_CLK_BIT )
|
||||
#else
|
||||
/* Select the option to clock SysTick not at the same frequency as the core. */
|
||||
#define portNVIC_SYSTICK_CLK_BIT_CONFIG ( 0 )
|
||||
#endif
|
||||
|
||||
/* Let the user override the pre-loading of the initial LR with the address of
|
||||
* prvTaskExitError() in case it messes up unwinding of the stack in the
|
||||
* debugger. */
|
||||
#ifdef configTASK_RETURN_ADDRESS
|
||||
#define portTASK_RETURN_ADDRESS configTASK_RETURN_ADDRESS
|
||||
#else
|
||||
#define portTASK_RETURN_ADDRESS prvTaskExitError
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Setup the timer to generate the tick interrupts. The implementation in this
|
||||
* file is weak to allow application writers to change the timer used to
|
||||
* generate the tick interrupt.
|
||||
*/
|
||||
void vPortSetupTimerInterrupt( void );
|
||||
|
||||
/*
|
||||
* Exception handlers.
|
||||
*/
|
||||
void xPortPendSVHandler( void ) __attribute__( ( naked ) );
|
||||
void xPortSysTickHandler( void );
|
||||
void vPortSVCHandler( void ) __attribute__( ( naked ) );
|
||||
|
||||
/*
|
||||
* Start first task is a separate function so it can be tested in isolation.
|
||||
*/
|
||||
static void prvPortStartFirstTask( void ) __attribute__( ( naked ) );
|
||||
|
||||
/*
|
||||
* Function to enable the VFP.
|
||||
*/
|
||||
static void vPortEnableVFP( void ) __attribute__( ( naked ) );
|
||||
|
||||
/*
|
||||
* Used to catch tasks that attempt to return from their implementing function.
|
||||
*/
|
||||
static void prvTaskExitError( void );
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Each task maintains its own interrupt status in the critical nesting
|
||||
* variable. */
|
||||
static UBaseType_t uxCriticalNesting = 0xaaaaaaaa;
|
||||
|
||||
/*
|
||||
* The number of SysTick increments that make up one tick period.
|
||||
*/
|
||||
#if ( configUSE_TICKLESS_IDLE == 1 )
|
||||
static uint32_t ulTimerCountsForOneTick = 0;
|
||||
#endif /* configUSE_TICKLESS_IDLE */
|
||||
|
||||
/*
|
||||
* The maximum number of tick periods that can be suppressed is limited by the
|
||||
* 24 bit resolution of the SysTick timer.
|
||||
*/
|
||||
#if ( configUSE_TICKLESS_IDLE == 1 )
|
||||
static uint32_t xMaximumPossibleSuppressedTicks = 0;
|
||||
#endif /* configUSE_TICKLESS_IDLE */
|
||||
|
||||
/*
|
||||
* Compensate for the CPU cycles that pass while the SysTick is stopped (low
|
||||
* power functionality only.
|
||||
*/
|
||||
#if ( configUSE_TICKLESS_IDLE == 1 )
|
||||
static uint32_t ulStoppedTimerCompensation = 0;
|
||||
#endif /* configUSE_TICKLESS_IDLE */
|
||||
|
||||
/*
|
||||
* Used by the portASSERT_IF_INTERRUPT_PRIORITY_INVALID() macro to ensure
|
||||
* FreeRTOS API functions are not called from interrupts that have been assigned
|
||||
* a priority above configMAX_SYSCALL_INTERRUPT_PRIORITY.
|
||||
*/
|
||||
#if ( configASSERT_DEFINED == 1 )
|
||||
static uint8_t ucMaxSysCallPriority = 0;
|
||||
static uint32_t ulMaxPRIGROUPValue = 0;
|
||||
static const volatile uint8_t * const pcInterruptPriorityRegisters = ( const volatile uint8_t * const ) portNVIC_IP_REGISTERS_OFFSET_16;
|
||||
#endif /* configASSERT_DEFINED */
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* See header file for description.
|
||||
*/
|
||||
StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
|
||||
TaskFunction_t pxCode,
|
||||
void * pvParameters )
|
||||
{
|
||||
/* Simulate the stack frame as it would be created by a context switch
|
||||
* interrupt. */
|
||||
|
||||
/* Offset added to account for the way the MCU uses the stack on entry/exit
|
||||
* of interrupts, and to ensure alignment. */
|
||||
pxTopOfStack--;
|
||||
|
||||
*pxTopOfStack = portINITIAL_XPSR; /* xPSR */
|
||||
pxTopOfStack--;
|
||||
*pxTopOfStack = ( ( StackType_t ) pxCode ) & portSTART_ADDRESS_MASK; /* PC */
|
||||
pxTopOfStack--;
|
||||
*pxTopOfStack = ( StackType_t ) portTASK_RETURN_ADDRESS; /* LR */
|
||||
|
||||
/* Save code space by skipping register initialisation. */
|
||||
pxTopOfStack -= 5; /* R12, R3, R2 and R1. */
|
||||
*pxTopOfStack = ( StackType_t ) pvParameters; /* R0 */
|
||||
|
||||
/* A save method is being used that requires each task to maintain its
|
||||
* own exec return value. */
|
||||
pxTopOfStack--;
|
||||
*pxTopOfStack = portINITIAL_EXC_RETURN;
|
||||
|
||||
pxTopOfStack -= 8; /* R11, R10, R9, R8, R7, R6, R5 and R4. */
|
||||
|
||||
return pxTopOfStack;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void prvTaskExitError( void )
|
||||
{
|
||||
volatile uint32_t ulDummy = 0;
|
||||
|
||||
/* A function that implements a task must not exit or attempt to return to
|
||||
* its caller as there is nothing to return to. If a task wants to exit it
|
||||
* should instead call vTaskDelete( NULL ).
|
||||
*
|
||||
* Artificially force an assert() to be triggered if configASSERT() is
|
||||
* defined, then stop here so application writers can catch the error. */
|
||||
configASSERT( uxCriticalNesting == ~0UL );
|
||||
portDISABLE_INTERRUPTS();
|
||||
|
||||
while( ulDummy == 0 )
|
||||
{
|
||||
/* This file calls prvTaskExitError() after the scheduler has been
|
||||
* started to remove a compiler warning about the function being defined
|
||||
* but never called. ulDummy is used purely to quieten other warnings
|
||||
* about code appearing after this function is called - making ulDummy
|
||||
* volatile makes the compiler think the function could return and
|
||||
* therefore not output an 'unreachable code' warning for code that appears
|
||||
* after it. */
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortSVCHandler( void )
|
||||
{
|
||||
__asm volatile (
|
||||
" ldr r3, =pxCurrentTCB \n" /* Restore the context. */
|
||||
" ldr r1, [r3] \n" /* Get the pxCurrentTCB address. */
|
||||
" ldr r0, [r1] \n" /* The first item in pxCurrentTCB is the task top of stack. */
|
||||
" ldmia r0!, {r4-r11, r14} \n" /* Pop the registers that are not automatically saved on exception entry and the critical nesting count. */
|
||||
" msr psp, r0 \n" /* Restore the task stack pointer. */
|
||||
" isb \n"
|
||||
" mov r0, #0 \n"
|
||||
" msr basepri, r0 \n"
|
||||
" bx r14 \n"
|
||||
" \n"
|
||||
" .ltorg \n"
|
||||
);
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void prvPortStartFirstTask( void )
|
||||
{
|
||||
/* Start the first task. This also clears the bit that indicates the FPU is
|
||||
* in use in case the FPU was used before the scheduler was started - which
|
||||
* would otherwise result in the unnecessary leaving of space in the SVC stack
|
||||
* for lazy saving of FPU registers. */
|
||||
__asm volatile (
|
||||
" ldr r0, =0xE000ED08 \n" /* Use the NVIC offset register to locate the stack. */
|
||||
" ldr r0, [r0] \n"
|
||||
" ldr r0, [r0] \n"
|
||||
" msr msp, r0 \n" /* Set the msp back to the start of the stack. */
|
||||
" mov r0, #0 \n" /* Clear the bit that indicates the FPU is in use, see comment above. */
|
||||
" msr control, r0 \n"
|
||||
" cpsie i \n" /* Globally enable interrupts. */
|
||||
" cpsie f \n"
|
||||
" dsb \n"
|
||||
" isb \n"
|
||||
" svc 0 \n" /* System call to start first task. */
|
||||
" nop \n"
|
||||
" .ltorg \n"
|
||||
);
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* See header file for description.
|
||||
*/
|
||||
BaseType_t xPortStartScheduler( void )
|
||||
{
|
||||
/* An application can install FreeRTOS interrupt handlers in one of the
|
||||
* following ways:
|
||||
* 1. Direct Routing - Install the functions vPortSVCHandler and
|
||||
* xPortPendSVHandler for SVCall and PendSV interrupts respectively.
|
||||
* 2. Indirect Routing - Install separate handlers for SVCall and PendSV
|
||||
* interrupts and route program control from those handlers to
|
||||
* vPortSVCHandler and xPortPendSVHandler functions.
|
||||
*
|
||||
* Applications that use Indirect Routing must set
|
||||
* configCHECK_HANDLER_INSTALLATION to 0 in their FreeRTOSConfig.h. Direct
|
||||
* routing, which is validated here when configCHECK_HANDLER_INSTALLATION
|
||||
* is 1, should be preferred when possible. */
|
||||
#if ( configCHECK_HANDLER_INSTALLATION == 1 )
|
||||
{
|
||||
const portISR_t * const pxVectorTable = portSCB_VTOR_REG;
|
||||
|
||||
/* Validate that the application has correctly installed the FreeRTOS
|
||||
* handlers for SVCall and PendSV interrupts. We do not check the
|
||||
* installation of the SysTick handler because the application may
|
||||
* choose to drive the RTOS tick using a timer other than the SysTick
|
||||
* timer by overriding the weak function vPortSetupTimerInterrupt().
|
||||
*
|
||||
* Assertion failures here indicate incorrect installation of the
|
||||
* FreeRTOS handlers. For help installing the FreeRTOS handlers, see
|
||||
* https://www.freertos.org/Why-FreeRTOS/FAQs.
|
||||
*
|
||||
* Systems with a configurable address for the interrupt vector table
|
||||
* can also encounter assertion failures or even system faults here if
|
||||
* VTOR is not set correctly to point to the application's vector table. */
|
||||
configASSERT( pxVectorTable[ portVECTOR_INDEX_SVC ] == vPortSVCHandler );
|
||||
configASSERT( pxVectorTable[ portVECTOR_INDEX_PENDSV ] == xPortPendSVHandler );
|
||||
}
|
||||
#endif /* configCHECK_HANDLER_INSTALLATION */
|
||||
|
||||
#if ( configASSERT_DEFINED == 1 )
|
||||
{
|
||||
volatile uint8_t ucOriginalPriority;
|
||||
volatile uint32_t ulImplementedPrioBits = 0;
|
||||
volatile uint8_t * const pucFirstUserPriorityRegister = ( volatile uint8_t * const ) ( portNVIC_IP_REGISTERS_OFFSET_16 + portFIRST_USER_INTERRUPT_NUMBER );
|
||||
volatile uint8_t ucMaxPriorityValue;
|
||||
|
||||
/* Determine the maximum priority from which ISR safe FreeRTOS API
|
||||
* functions can be called. ISR safe functions are those that end in
|
||||
* "FromISR". FreeRTOS maintains separate thread and ISR API functions to
|
||||
* ensure interrupt entry is as fast and simple as possible.
|
||||
*
|
||||
* Save the interrupt priority value that is about to be clobbered. */
|
||||
ucOriginalPriority = *pucFirstUserPriorityRegister;
|
||||
|
||||
/* Determine the number of priority bits available. First write to all
|
||||
* possible bits. */
|
||||
*pucFirstUserPriorityRegister = portMAX_8_BIT_VALUE;
|
||||
|
||||
/* Read the value back to see how many bits stuck. */
|
||||
ucMaxPriorityValue = *pucFirstUserPriorityRegister;
|
||||
|
||||
/* Use the same mask on the maximum system call priority. */
|
||||
ucMaxSysCallPriority = configMAX_SYSCALL_INTERRUPT_PRIORITY & ucMaxPriorityValue;
|
||||
|
||||
/* Check that the maximum system call priority is nonzero after
|
||||
* accounting for the number of priority bits supported by the
|
||||
* hardware. A priority of 0 is invalid because setting the BASEPRI
|
||||
* register to 0 unmasks all interrupts, and interrupts with priority 0
|
||||
* cannot be masked using BASEPRI.
|
||||
* See https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
|
||||
configASSERT( ucMaxSysCallPriority );
|
||||
|
||||
/* Check that the bits not implemented in hardware are zero in
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY. */
|
||||
configASSERT( ( configMAX_SYSCALL_INTERRUPT_PRIORITY & ( ~ucMaxPriorityValue ) ) == 0U );
|
||||
|
||||
/* Calculate the maximum acceptable priority group value for the number
|
||||
* of bits read back. */
|
||||
|
||||
while( ( ucMaxPriorityValue & portTOP_BIT_OF_BYTE ) == portTOP_BIT_OF_BYTE )
|
||||
{
|
||||
ulImplementedPrioBits++;
|
||||
ucMaxPriorityValue <<= ( uint8_t ) 0x01;
|
||||
}
|
||||
|
||||
if( ulImplementedPrioBits == 8 )
|
||||
{
|
||||
/* When the hardware implements 8 priority bits, there is no way for
|
||||
* the software to configure PRIGROUP to not have sub-priorities. As
|
||||
* a result, the least significant bit is always used for sub-priority
|
||||
* and there are 128 preemption priorities and 2 sub-priorities.
|
||||
*
|
||||
* This may cause some confusion in some cases - for example, if
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY is set to 5, both 5 and 4
|
||||
* priority interrupts will be masked in Critical Sections as those
|
||||
* are at the same preemption priority. This may appear confusing as
|
||||
* 4 is higher (numerically lower) priority than
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY and therefore, should not
|
||||
* have been masked. Instead, if we set configMAX_SYSCALL_INTERRUPT_PRIORITY
|
||||
* to 4, this confusion does not happen and the behaviour remains the same.
|
||||
*
|
||||
* The following assert ensures that the sub-priority bit in the
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY is clear to avoid the above mentioned
|
||||
* confusion. */
|
||||
configASSERT( ( configMAX_SYSCALL_INTERRUPT_PRIORITY & 0x1U ) == 0U );
|
||||
ulMaxPRIGROUPValue = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
ulMaxPRIGROUPValue = portMAX_PRIGROUP_BITS - ulImplementedPrioBits;
|
||||
}
|
||||
|
||||
/* Shift the priority group value back to its position within the AIRCR
|
||||
* register. */
|
||||
ulMaxPRIGROUPValue <<= portPRIGROUP_SHIFT;
|
||||
ulMaxPRIGROUPValue &= portPRIORITY_GROUP_MASK;
|
||||
|
||||
/* Restore the clobbered interrupt priority register to its original
|
||||
* value. */
|
||||
*pucFirstUserPriorityRegister = ucOriginalPriority;
|
||||
}
|
||||
#endif /* configASSERT_DEFINED */
|
||||
|
||||
/* Make PendSV and SysTick the lowest priority interrupts, and make SVCall
|
||||
* the highest priority. */
|
||||
portNVIC_SHPR3_REG |= portNVIC_PENDSV_PRI;
|
||||
portNVIC_SHPR3_REG |= portNVIC_SYSTICK_PRI;
|
||||
portNVIC_SHPR2_REG = 0;
|
||||
|
||||
/* Start the timer that generates the tick ISR. Interrupts are disabled
|
||||
* here already. */
|
||||
vPortSetupTimerInterrupt();
|
||||
|
||||
/* Initialise the critical nesting count ready for the first task. */
|
||||
uxCriticalNesting = 0;
|
||||
|
||||
/* Ensure the VFP is enabled - it should be anyway. */
|
||||
vPortEnableVFP();
|
||||
|
||||
/* Lazy save always. */
|
||||
*( portFPCCR ) |= portASPEN_AND_LSPEN_BITS;
|
||||
|
||||
/* Start the first task. */
|
||||
prvPortStartFirstTask();
|
||||
|
||||
/* Should never get here as the tasks will now be executing! Call the task
|
||||
* exit error function to prevent compiler warnings about a static function
|
||||
* not being called in the case that the application writer overrides this
|
||||
* functionality by defining configTASK_RETURN_ADDRESS. Call
|
||||
* vTaskSwitchContext() so link time optimisation does not remove the
|
||||
* symbol. */
|
||||
vTaskSwitchContext();
|
||||
prvTaskExitError();
|
||||
|
||||
/* Should not get here! */
|
||||
return 0;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortEndScheduler( void )
|
||||
{
|
||||
/* Not implemented in ports where there is nothing to return to.
|
||||
* Artificially force an assert. */
|
||||
configASSERT( uxCriticalNesting == 1000UL );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortEnterCritical( void )
|
||||
{
|
||||
portDISABLE_INTERRUPTS();
|
||||
uxCriticalNesting++;
|
||||
|
||||
/* This is not the interrupt safe version of the enter critical function so
|
||||
* assert() if it is being called from an interrupt context. Only API
|
||||
* functions that end in "FromISR" can be used in an interrupt. Only assert if
|
||||
* the critical nesting count is 1 to protect against recursive calls if the
|
||||
* assert function also uses a critical section. */
|
||||
if( uxCriticalNesting == 1 )
|
||||
{
|
||||
configASSERT( ( portNVIC_INT_CTRL_REG & portVECTACTIVE_MASK ) == 0 );
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortExitCritical( void )
|
||||
{
|
||||
configASSERT( uxCriticalNesting );
|
||||
uxCriticalNesting--;
|
||||
|
||||
if( uxCriticalNesting == 0 )
|
||||
{
|
||||
portENABLE_INTERRUPTS();
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void xPortPendSVHandler( void )
|
||||
{
|
||||
/* This is a naked function. */
|
||||
|
||||
__asm volatile
|
||||
(
|
||||
" mrs r0, psp \n"
|
||||
" isb \n"
|
||||
" \n"
|
||||
" ldr r3, =pxCurrentTCB \n" /* Get the location of the current TCB. */
|
||||
" ldr r2, [r3] \n"
|
||||
" \n"
|
||||
" tst r14, #0x10 \n" /* Is the task using the FPU context? If so, push high vfp registers. */
|
||||
" it eq \n"
|
||||
" vstmdbeq r0!, {s16-s31} \n"
|
||||
" \n"
|
||||
" stmdb r0!, {r4-r11, r14} \n" /* Save the core registers. */
|
||||
" str r0, [r2] \n" /* Save the new top of stack into the first member of the TCB. */
|
||||
" \n"
|
||||
" stmdb sp!, {r0, r3} \n"
|
||||
" mov r0, %0 \n"
|
||||
" cpsid i \n" /* ARM Cortex-M7 r0p1 Errata 837070 workaround. */
|
||||
" msr basepri, r0 \n"
|
||||
" dsb \n"
|
||||
" isb \n"
|
||||
" cpsie i \n" /* ARM Cortex-M7 r0p1 Errata 837070 workaround. */
|
||||
" bl vTaskSwitchContext \n"
|
||||
" mov r0, #0 \n"
|
||||
" msr basepri, r0 \n"
|
||||
" ldmia sp!, {r0, r3} \n"
|
||||
" \n"
|
||||
" ldr r1, [r3] \n" /* The first item in pxCurrentTCB is the task top of stack. */
|
||||
" ldr r0, [r1] \n"
|
||||
" \n"
|
||||
" ldmia r0!, {r4-r11, r14} \n" /* Pop the core registers. */
|
||||
" \n"
|
||||
" tst r14, #0x10 \n" /* Is the task using the FPU context? If so, pop the high vfp registers too. */
|
||||
" it eq \n"
|
||||
" vldmiaeq r0!, {s16-s31} \n"
|
||||
" \n"
|
||||
" msr psp, r0 \n"
|
||||
" isb \n"
|
||||
" \n"
|
||||
#ifdef WORKAROUND_PMU_CM001 /* XMC4000 specific errata workaround. */
|
||||
#if WORKAROUND_PMU_CM001 == 1
|
||||
" push { r14 } \n"
|
||||
" pop { pc } \n"
|
||||
#endif
|
||||
#endif
|
||||
" \n"
|
||||
" bx r14 \n"
|
||||
" \n"
|
||||
" .ltorg \n"
|
||||
::"i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY )
|
||||
);
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void xPortSysTickHandler( void )
|
||||
{
|
||||
/* The SysTick runs at the lowest interrupt priority, so when this interrupt
|
||||
* executes all interrupts must be unmasked. There is therefore no need to
|
||||
* save and then restore the interrupt mask value as its value is already
|
||||
* known. */
|
||||
portDISABLE_INTERRUPTS();
|
||||
traceISR_ENTER();
|
||||
{
|
||||
/* Increment the RTOS tick. */
|
||||
if( xTaskIncrementTick() != pdFALSE )
|
||||
{
|
||||
traceISR_EXIT_TO_SCHEDULER();
|
||||
|
||||
/* A context switch is required. Context switching is performed in
|
||||
* the PendSV interrupt. Pend the PendSV interrupt. */
|
||||
portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;
|
||||
}
|
||||
else
|
||||
{
|
||||
traceISR_EXIT();
|
||||
}
|
||||
}
|
||||
portENABLE_INTERRUPTS();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( configUSE_TICKLESS_IDLE == 1 )
|
||||
|
||||
__attribute__( ( weak ) ) void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime )
|
||||
{
|
||||
uint32_t ulReloadValue, ulCompleteTickPeriods, ulCompletedSysTickDecrements, ulSysTickDecrementsLeft;
|
||||
TickType_t xModifiableIdleTime;
|
||||
|
||||
/* Make sure the SysTick reload value does not overflow the counter. */
|
||||
if( xExpectedIdleTime > xMaximumPossibleSuppressedTicks )
|
||||
{
|
||||
xExpectedIdleTime = xMaximumPossibleSuppressedTicks;
|
||||
}
|
||||
|
||||
/* Enter a critical section but don't use the taskENTER_CRITICAL()
|
||||
* method as that will mask interrupts that should exit sleep mode. */
|
||||
__asm volatile ( "cpsid i" ::: "memory" );
|
||||
__asm volatile ( "dsb" );
|
||||
__asm volatile ( "isb" );
|
||||
|
||||
/* If a context switch is pending or a task is waiting for the scheduler
|
||||
* to be unsuspended then abandon the low power entry. */
|
||||
if( eTaskConfirmSleepModeStatus() == eAbortSleep )
|
||||
{
|
||||
/* Re-enable interrupts - see comments above the cpsid instruction
|
||||
* above. */
|
||||
__asm volatile ( "cpsie i" ::: "memory" );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Stop the SysTick momentarily. The time the SysTick is stopped for
|
||||
* is accounted for as best it can be, but using the tickless mode will
|
||||
* inevitably result in some tiny drift of the time maintained by the
|
||||
* kernel with respect to calendar time. */
|
||||
portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT );
|
||||
|
||||
/* Use the SysTick current-value register to determine the number of
|
||||
* SysTick decrements remaining until the next tick interrupt. If the
|
||||
* current-value register is zero, then there are actually
|
||||
* ulTimerCountsForOneTick decrements remaining, not zero, because the
|
||||
* SysTick requests the interrupt when decrementing from 1 to 0. */
|
||||
ulSysTickDecrementsLeft = portNVIC_SYSTICK_CURRENT_VALUE_REG;
|
||||
|
||||
if( ulSysTickDecrementsLeft == 0 )
|
||||
{
|
||||
ulSysTickDecrementsLeft = ulTimerCountsForOneTick;
|
||||
}
|
||||
|
||||
/* Calculate the reload value required to wait xExpectedIdleTime
|
||||
* tick periods. -1 is used because this code normally executes part
|
||||
* way through the first tick period. But if the SysTick IRQ is now
|
||||
* pending, then clear the IRQ, suppressing the first tick, and correct
|
||||
* the reload value to reflect that the second tick period is already
|
||||
* underway. The expected idle time is always at least two ticks. */
|
||||
ulReloadValue = ulSysTickDecrementsLeft + ( ulTimerCountsForOneTick * ( xExpectedIdleTime - 1UL ) );
|
||||
|
||||
if( ( portNVIC_INT_CTRL_REG & portNVIC_PEND_SYSTICK_SET_BIT ) != 0 )
|
||||
{
|
||||
portNVIC_INT_CTRL_REG = portNVIC_PEND_SYSTICK_CLEAR_BIT;
|
||||
ulReloadValue -= ulTimerCountsForOneTick;
|
||||
}
|
||||
|
||||
if( ulReloadValue > ulStoppedTimerCompensation )
|
||||
{
|
||||
ulReloadValue -= ulStoppedTimerCompensation;
|
||||
}
|
||||
|
||||
/* Set the new reload value. */
|
||||
portNVIC_SYSTICK_LOAD_REG = ulReloadValue;
|
||||
|
||||
/* Clear the SysTick count flag and set the count value back to
|
||||
* zero. */
|
||||
portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
|
||||
|
||||
/* Restart SysTick. */
|
||||
portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;
|
||||
|
||||
/* Sleep until something happens. configPRE_SLEEP_PROCESSING() can
|
||||
* set its parameter to 0 to indicate that its implementation contains
|
||||
* its own wait for interrupt or wait for event instruction, and so wfi
|
||||
* should not be executed again. However, the original expected idle
|
||||
* time variable must remain unmodified, so a copy is taken. */
|
||||
xModifiableIdleTime = xExpectedIdleTime;
|
||||
configPRE_SLEEP_PROCESSING( xModifiableIdleTime );
|
||||
|
||||
if( xModifiableIdleTime > 0 )
|
||||
{
|
||||
__asm volatile ( "dsb" ::: "memory" );
|
||||
__asm volatile ( "wfi" );
|
||||
__asm volatile ( "isb" );
|
||||
}
|
||||
|
||||
configPOST_SLEEP_PROCESSING( xExpectedIdleTime );
|
||||
|
||||
/* Re-enable interrupts to allow the interrupt that brought the MCU
|
||||
* out of sleep mode to execute immediately. See comments above
|
||||
* the cpsid instruction above. */
|
||||
__asm volatile ( "cpsie i" ::: "memory" );
|
||||
__asm volatile ( "dsb" );
|
||||
__asm volatile ( "isb" );
|
||||
|
||||
/* Disable interrupts again because the clock is about to be stopped
|
||||
* and interrupts that execute while the clock is stopped will increase
|
||||
* any slippage between the time maintained by the RTOS and calendar
|
||||
* time. */
|
||||
__asm volatile ( "cpsid i" ::: "memory" );
|
||||
__asm volatile ( "dsb" );
|
||||
__asm volatile ( "isb" );
|
||||
|
||||
/* Disable the SysTick clock without reading the
|
||||
* portNVIC_SYSTICK_CTRL_REG register to ensure the
|
||||
* portNVIC_SYSTICK_COUNT_FLAG_BIT is not cleared if it is set. Again,
|
||||
* the time the SysTick is stopped for is accounted for as best it can
|
||||
* be, but using the tickless mode will inevitably result in some tiny
|
||||
* drift of the time maintained by the kernel with respect to calendar
|
||||
* time*/
|
||||
portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT );
|
||||
|
||||
/* Determine whether the SysTick has already counted to zero. */
|
||||
if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )
|
||||
{
|
||||
uint32_t ulCalculatedLoadValue;
|
||||
|
||||
/* The tick interrupt ended the sleep (or is now pending), and
|
||||
* a new tick period has started. Reset portNVIC_SYSTICK_LOAD_REG
|
||||
* with whatever remains of the new tick period. */
|
||||
ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );
|
||||
|
||||
/* Don't allow a tiny value, or values that have somehow
|
||||
* underflowed because the post sleep hook did something
|
||||
* that took too long or because the SysTick current-value register
|
||||
* is zero. */
|
||||
if( ( ulCalculatedLoadValue <= ulStoppedTimerCompensation ) || ( ulCalculatedLoadValue > ulTimerCountsForOneTick ) )
|
||||
{
|
||||
ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL );
|
||||
}
|
||||
|
||||
portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;
|
||||
|
||||
/* As the pending tick will be processed as soon as this
|
||||
* function exits, the tick value maintained by the tick is stepped
|
||||
* forward by one less than the time spent waiting. */
|
||||
ulCompleteTickPeriods = xExpectedIdleTime - 1UL;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Something other than the tick interrupt ended the sleep. */
|
||||
|
||||
/* Use the SysTick current-value register to determine the
|
||||
* number of SysTick decrements remaining until the expected idle
|
||||
* time would have ended. */
|
||||
ulSysTickDecrementsLeft = portNVIC_SYSTICK_CURRENT_VALUE_REG;
|
||||
#if ( portNVIC_SYSTICK_CLK_BIT_CONFIG != portNVIC_SYSTICK_CLK_BIT )
|
||||
{
|
||||
/* If the SysTick is not using the core clock, the current-
|
||||
* value register might still be zero here. In that case, the
|
||||
* SysTick didn't load from the reload register, and there are
|
||||
* ulReloadValue decrements remaining in the expected idle
|
||||
* time, not zero. */
|
||||
if( ulSysTickDecrementsLeft == 0 )
|
||||
{
|
||||
ulSysTickDecrementsLeft = ulReloadValue;
|
||||
}
|
||||
}
|
||||
#endif /* portNVIC_SYSTICK_CLK_BIT_CONFIG */
|
||||
|
||||
/* Work out how long the sleep lasted rounded to complete tick
|
||||
* periods (not the ulReload value which accounted for part
|
||||
* ticks). */
|
||||
ulCompletedSysTickDecrements = ( xExpectedIdleTime * ulTimerCountsForOneTick ) - ulSysTickDecrementsLeft;
|
||||
|
||||
/* How many complete tick periods passed while the processor
|
||||
* was waiting? */
|
||||
ulCompleteTickPeriods = ulCompletedSysTickDecrements / ulTimerCountsForOneTick;
|
||||
|
||||
/* The reload value is set to whatever fraction of a single tick
|
||||
* period remains. */
|
||||
portNVIC_SYSTICK_LOAD_REG = ( ( ulCompleteTickPeriods + 1UL ) * ulTimerCountsForOneTick ) - ulCompletedSysTickDecrements;
|
||||
}
|
||||
|
||||
/* Restart SysTick so it runs from portNVIC_SYSTICK_LOAD_REG again,
|
||||
* then set portNVIC_SYSTICK_LOAD_REG back to its standard value. If
|
||||
* the SysTick is not using the core clock, temporarily configure it to
|
||||
* use the core clock. This configuration forces the SysTick to load
|
||||
* from portNVIC_SYSTICK_LOAD_REG immediately instead of at the next
|
||||
* cycle of the other clock. Then portNVIC_SYSTICK_LOAD_REG is ready
|
||||
* to receive the standard value immediately. */
|
||||
portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
|
||||
portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT;
|
||||
#if ( portNVIC_SYSTICK_CLK_BIT_CONFIG == portNVIC_SYSTICK_CLK_BIT )
|
||||
{
|
||||
portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
|
||||
}
|
||||
#else
|
||||
{
|
||||
/* The temporary usage of the core clock has served its purpose,
|
||||
* as described above. Resume usage of the other clock. */
|
||||
portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT;
|
||||
|
||||
if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )
|
||||
{
|
||||
/* The partial tick period already ended. Be sure the SysTick
|
||||
* counts it only once. */
|
||||
portNVIC_SYSTICK_CURRENT_VALUE_REG = 0;
|
||||
}
|
||||
|
||||
portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;
|
||||
portNVIC_SYSTICK_CTRL_REG = portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT;
|
||||
}
|
||||
#endif /* portNVIC_SYSTICK_CLK_BIT_CONFIG */
|
||||
|
||||
/* Step the tick to account for any tick periods that elapsed. */
|
||||
vTaskStepTick( ulCompleteTickPeriods );
|
||||
|
||||
/* Exit with interrupts enabled. */
|
||||
__asm volatile ( "cpsie i" ::: "memory" );
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* #if configUSE_TICKLESS_IDLE */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Setup the systick timer to generate the tick interrupts at the required
|
||||
* frequency.
|
||||
*/
|
||||
__attribute__( ( weak ) ) void vPortSetupTimerInterrupt( void )
|
||||
{
|
||||
/* Calculate the constants required to configure the tick interrupt. */
|
||||
#if ( configUSE_TICKLESS_IDLE == 1 )
|
||||
{
|
||||
ulTimerCountsForOneTick = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ );
|
||||
xMaximumPossibleSuppressedTicks = portMAX_24_BIT_NUMBER / ulTimerCountsForOneTick;
|
||||
ulStoppedTimerCompensation = portMISSED_COUNTS_FACTOR / ( configCPU_CLOCK_HZ / configSYSTICK_CLOCK_HZ );
|
||||
}
|
||||
#endif /* configUSE_TICKLESS_IDLE */
|
||||
|
||||
/* Stop and clear the SysTick. */
|
||||
portNVIC_SYSTICK_CTRL_REG = 0UL;
|
||||
portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;
|
||||
|
||||
/* Configure SysTick to interrupt at the requested rate. */
|
||||
portNVIC_SYSTICK_LOAD_REG = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ) - 1UL;
|
||||
portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT_CONFIG | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* This is a naked function. */
|
||||
static void vPortEnableVFP( void )
|
||||
{
|
||||
__asm volatile
|
||||
(
|
||||
" ldr.w r0, =0xE000ED88 \n" /* The FPU enable bits are in the CPACR. */
|
||||
" ldr r1, [r0] \n"
|
||||
" \n"
|
||||
" orr r1, r1, #( 0xf << 20 ) \n" /* Enable CP10 and CP11 coprocessors, then save back. */
|
||||
" str r1, [r0] \n"
|
||||
" bx r14 \n"
|
||||
" .ltorg \n"
|
||||
);
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( configASSERT_DEFINED == 1 )
|
||||
|
||||
void vPortValidateInterruptPriority( void )
|
||||
{
|
||||
uint32_t ulCurrentInterrupt;
|
||||
uint8_t ucCurrentPriority;
|
||||
|
||||
/* Obtain the number of the currently executing interrupt. */
|
||||
__asm volatile ( "mrs %0, ipsr" : "=r" ( ulCurrentInterrupt )::"memory" );
|
||||
|
||||
/* Is the interrupt number a user defined interrupt? */
|
||||
if( ulCurrentInterrupt >= portFIRST_USER_INTERRUPT_NUMBER )
|
||||
{
|
||||
/* Look up the interrupt's priority. */
|
||||
ucCurrentPriority = pcInterruptPriorityRegisters[ ulCurrentInterrupt ];
|
||||
|
||||
/* The following assertion will fail if a service routine (ISR) for
|
||||
* an interrupt that has been assigned a priority above
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY calls an ISR safe FreeRTOS API
|
||||
* function. ISR safe FreeRTOS API functions must *only* be called
|
||||
* from interrupts that have been assigned a priority at or below
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY.
|
||||
*
|
||||
* Numerically low interrupt priority numbers represent logically high
|
||||
* interrupt priorities, therefore the priority of the interrupt must
|
||||
* be set to a value equal to or numerically *higher* than
|
||||
* configMAX_SYSCALL_INTERRUPT_PRIORITY.
|
||||
*
|
||||
* Interrupts that use the FreeRTOS API must not be left at their
|
||||
* default priority of zero as that is the highest possible priority,
|
||||
* which is guaranteed to be above configMAX_SYSCALL_INTERRUPT_PRIORITY,
|
||||
* and therefore also guaranteed to be invalid.
|
||||
*
|
||||
* FreeRTOS maintains separate thread and ISR API functions to ensure
|
||||
* interrupt entry is as fast and simple as possible.
|
||||
*
|
||||
* The following links provide detailed information:
|
||||
* https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html
|
||||
* https://www.freertos.org/Why-FreeRTOS/FAQs */
|
||||
configASSERT( ucCurrentPriority >= ucMaxSysCallPriority );
|
||||
}
|
||||
|
||||
/* Priority grouping: The interrupt controller (NVIC) allows the bits
|
||||
* that define each interrupt's priority to be split between bits that
|
||||
* define the interrupt's pre-emption priority bits and bits that define
|
||||
* the interrupt's sub-priority. For simplicity all bits must be defined
|
||||
* to be pre-emption priority bits. The following assertion will fail if
|
||||
* this is not the case (if some bits represent a sub-priority).
|
||||
*
|
||||
* If the application only uses CMSIS libraries for interrupt
|
||||
* configuration then the correct setting can be achieved on all Cortex-M
|
||||
* devices by calling NVIC_SetPriorityGrouping( 0 ); before starting the
|
||||
* scheduler. Note however that some vendor specific peripheral libraries
|
||||
* assume a non-zero priority group setting, in which cases using a value
|
||||
* of zero will result in unpredictable behaviour. */
|
||||
configASSERT( ( portAIRCR_REG & portPRIORITY_GROUP_MASK ) <= ulMaxPRIGROUPValue );
|
||||
}
|
||||
|
||||
#endif /* configASSERT_DEFINED */
|
||||
+267
@@ -0,0 +1,267 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
#ifndef PORTMACRO_H
|
||||
#define PORTMACRO_H
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/*-----------------------------------------------------------
|
||||
* Port specific definitions.
|
||||
*
|
||||
* The settings in this file configure FreeRTOS correctly for the
|
||||
* given hardware and compiler.
|
||||
*
|
||||
* These settings should not be altered.
|
||||
*-----------------------------------------------------------
|
||||
*/
|
||||
|
||||
/* Type definitions. */
|
||||
#define portCHAR char
|
||||
#define portFLOAT float
|
||||
#define portDOUBLE double
|
||||
#define portLONG long
|
||||
#define portSHORT short
|
||||
#define portSTACK_TYPE uint32_t
|
||||
#define portBASE_TYPE long
|
||||
|
||||
typedef portSTACK_TYPE StackType_t;
|
||||
typedef long BaseType_t;
|
||||
typedef unsigned long UBaseType_t;
|
||||
|
||||
#if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS )
|
||||
typedef uint16_t TickType_t;
|
||||
#define portMAX_DELAY ( TickType_t ) 0xffff
|
||||
#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_32_BITS )
|
||||
typedef uint32_t TickType_t;
|
||||
#define portMAX_DELAY ( TickType_t ) 0xffffffffUL
|
||||
|
||||
/* 32-bit tick type on a 32-bit architecture, so reads of the tick count do
|
||||
* not need to be guarded with a critical section. */
|
||||
#define portTICK_TYPE_IS_ATOMIC 1
|
||||
#else
|
||||
#error configTICK_TYPE_WIDTH_IN_BITS set to unsupported tick type width.
|
||||
#endif
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Architecture specifics. */
|
||||
#define portSTACK_GROWTH ( -1 )
|
||||
#define portTICK_PERIOD_MS ( ( TickType_t ) 1000 / configTICK_RATE_HZ )
|
||||
#define portBYTE_ALIGNMENT 8
|
||||
#define portDONT_DISCARD __attribute__( ( used ) )
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Scheduler utilities. */
|
||||
#define portYIELD() \
|
||||
{ \
|
||||
/* Set a PendSV to request a context switch. */ \
|
||||
portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT; \
|
||||
\
|
||||
/* Barriers are normally not required but do ensure the code is completely \
|
||||
* within the specified behaviour for the architecture. */ \
|
||||
__asm volatile ( "dsb" ::: "memory" ); \
|
||||
__asm volatile ( "isb" ); \
|
||||
}
|
||||
|
||||
#define portNVIC_INT_CTRL_REG ( *( ( volatile uint32_t * ) 0xe000ed04 ) )
|
||||
#define portNVIC_PENDSVSET_BIT ( 1UL << 28UL )
|
||||
#define portEND_SWITCHING_ISR( xSwitchRequired ) \
|
||||
do \
|
||||
{ \
|
||||
if( xSwitchRequired != pdFALSE ) \
|
||||
{ \
|
||||
traceISR_EXIT_TO_SCHEDULER(); \
|
||||
portYIELD(); \
|
||||
} \
|
||||
else \
|
||||
{ \
|
||||
traceISR_EXIT(); \
|
||||
} \
|
||||
} while( 0 )
|
||||
#define portYIELD_FROM_ISR( x ) portEND_SWITCHING_ISR( x )
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Critical section management. */
|
||||
extern void vPortEnterCritical( void );
|
||||
extern void vPortExitCritical( void );
|
||||
#define portSET_INTERRUPT_MASK_FROM_ISR() ulPortRaiseBASEPRI()
|
||||
#define portCLEAR_INTERRUPT_MASK_FROM_ISR( x ) vPortSetBASEPRI( x )
|
||||
#define portDISABLE_INTERRUPTS() vPortRaiseBASEPRI()
|
||||
#define portENABLE_INTERRUPTS() vPortSetBASEPRI( 0 )
|
||||
#define portENTER_CRITICAL() vPortEnterCritical()
|
||||
#define portEXIT_CRITICAL() vPortExitCritical()
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Task function macros as described on the FreeRTOS.org WEB site. These are
|
||||
* not necessary for to use this port. They are defined so the common demo files
|
||||
* (which build with all the ports) will build. */
|
||||
#define portTASK_FUNCTION_PROTO( vFunction, pvParameters ) void vFunction( void * pvParameters )
|
||||
#define portTASK_FUNCTION( vFunction, pvParameters ) void vFunction( void * pvParameters )
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Tickless idle/low power functionality. */
|
||||
#ifndef portSUPPRESS_TICKS_AND_SLEEP
|
||||
extern void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime );
|
||||
#define portSUPPRESS_TICKS_AND_SLEEP( xExpectedIdleTime ) vPortSuppressTicksAndSleep( xExpectedIdleTime )
|
||||
#endif
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Architecture specific optimisations. */
|
||||
#ifndef configUSE_PORT_OPTIMISED_TASK_SELECTION
|
||||
#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1
|
||||
#endif
|
||||
|
||||
#if configUSE_PORT_OPTIMISED_TASK_SELECTION == 1
|
||||
|
||||
/* Generic helper function. */
|
||||
__attribute__( ( always_inline ) ) static inline uint8_t ucPortCountLeadingZeros( uint32_t ulBitmap )
|
||||
{
|
||||
uint8_t ucReturn;
|
||||
|
||||
__asm volatile ( "clz %0, %1" : "=r" ( ucReturn ) : "r" ( ulBitmap ) : "memory" );
|
||||
|
||||
return ucReturn;
|
||||
}
|
||||
|
||||
/* Check the configuration. */
|
||||
#if ( configMAX_PRIORITIES > 32 )
|
||||
#error configUSE_PORT_OPTIMISED_TASK_SELECTION can only be set to 1 when configMAX_PRIORITIES is less than or equal to 32. It is very rare that a system requires more than 10 to 15 difference priorities as tasks that share a priority will time slice.
|
||||
#endif
|
||||
|
||||
/* Store/clear the ready priorities in a bit map. */
|
||||
#define portRECORD_READY_PRIORITY( uxPriority, uxReadyPriorities ) ( uxReadyPriorities ) |= ( 1UL << ( uxPriority ) )
|
||||
#define portRESET_READY_PRIORITY( uxPriority, uxReadyPriorities ) ( uxReadyPriorities ) &= ~( 1UL << ( uxPriority ) )
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities ) uxTopPriority = ( 31UL - ( uint32_t ) ucPortCountLeadingZeros( ( uxReadyPriorities ) ) )
|
||||
|
||||
#endif /* configUSE_PORT_OPTIMISED_TASK_SELECTION */
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( configASSERT_DEFINED == 1 )
|
||||
void vPortValidateInterruptPriority( void );
|
||||
#define portASSERT_IF_INTERRUPT_PRIORITY_INVALID() vPortValidateInterruptPriority()
|
||||
#endif
|
||||
|
||||
/* portNOP() is not required by this port. */
|
||||
#define portNOP()
|
||||
|
||||
#define portINLINE __inline
|
||||
|
||||
#ifndef portFORCE_INLINE
|
||||
#define portFORCE_INLINE inline __attribute__( ( always_inline ) )
|
||||
#endif
|
||||
|
||||
portFORCE_INLINE static BaseType_t xPortIsInsideInterrupt( void )
|
||||
{
|
||||
uint32_t ulCurrentInterrupt;
|
||||
BaseType_t xReturn;
|
||||
|
||||
/* Obtain the number of the currently executing interrupt. */
|
||||
__asm volatile ( "mrs %0, ipsr" : "=r" ( ulCurrentInterrupt )::"memory" );
|
||||
|
||||
if( ulCurrentInterrupt == 0 )
|
||||
{
|
||||
xReturn = pdFALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
portFORCE_INLINE static void vPortRaiseBASEPRI( void )
|
||||
{
|
||||
uint32_t ulNewBASEPRI;
|
||||
|
||||
__asm volatile
|
||||
(
|
||||
" mov %0, %1 \n" \
|
||||
" cpsid i \n" \
|
||||
" msr basepri, %0 \n" \
|
||||
" isb \n" \
|
||||
" dsb \n" \
|
||||
" cpsie i \n" \
|
||||
: "=r" ( ulNewBASEPRI ) : "i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY ) : "memory"
|
||||
);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
portFORCE_INLINE static uint32_t ulPortRaiseBASEPRI( void )
|
||||
{
|
||||
uint32_t ulOriginalBASEPRI, ulNewBASEPRI;
|
||||
|
||||
__asm volatile
|
||||
(
|
||||
" mrs %0, basepri \n" \
|
||||
" mov %1, %2 \n" \
|
||||
" cpsid i \n" \
|
||||
" msr basepri, %1 \n" \
|
||||
" isb \n" \
|
||||
" dsb \n" \
|
||||
" cpsie i \n" \
|
||||
: "=r" ( ulOriginalBASEPRI ), "=r" ( ulNewBASEPRI ) : "i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY ) : "memory"
|
||||
);
|
||||
|
||||
/* This return will not be reached but is necessary to prevent compiler
|
||||
* warnings. */
|
||||
return ulOriginalBASEPRI;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
portFORCE_INLINE static void vPortSetBASEPRI( uint32_t ulNewMaskValue )
|
||||
{
|
||||
__asm volatile
|
||||
(
|
||||
" msr basepri, %0 " ::"r" ( ulNewMaskValue ) : "memory"
|
||||
);
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#define portMEMORY_BARRIER() __asm volatile ( "" ::: "memory" )
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
/* *INDENT-ON* */
|
||||
|
||||
#endif /* PORTMACRO_H */
|
||||
+753
@@ -0,0 +1,753 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdio.h>
|
||||
|
||||
/* Scheduler includes. */
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
|
||||
#ifdef WIN32_LEAN_AND_MEAN
|
||||
#include <winsock2.h>
|
||||
#else
|
||||
#include <winsock.h>
|
||||
#endif
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#include <timeapi.h>
|
||||
#pragma comment(lib, "winmm.lib")
|
||||
#else
|
||||
#include <mmsystem.h>
|
||||
#endif
|
||||
|
||||
#define portMAX_INTERRUPTS ( ( uint32_t ) sizeof( uint32_t ) * 8UL ) /* The number of bits in an uint32_t. */
|
||||
#define portNO_CRITICAL_NESTING ( ( uint32_t ) 0 )
|
||||
|
||||
/* The priorities at which the various components of the simulation execute. */
|
||||
#define portDELETE_SELF_THREAD_PRIORITY THREAD_PRIORITY_TIME_CRITICAL /* Must be highest. */
|
||||
#define portSIMULATED_INTERRUPTS_THREAD_PRIORITY THREAD_PRIORITY_TIME_CRITICAL
|
||||
#define portSIMULATED_TIMER_THREAD_PRIORITY THREAD_PRIORITY_HIGHEST
|
||||
#define portTASK_THREAD_PRIORITY THREAD_PRIORITY_ABOVE_NORMAL
|
||||
|
||||
/*
|
||||
* Created as a high priority thread, this function uses a timer to simulate
|
||||
* a tick interrupt being generated on an embedded target. In this Windows
|
||||
* environment the timer does not achieve anything approaching real time
|
||||
* performance though.
|
||||
*/
|
||||
static DWORD WINAPI prvSimulatedPeripheralTimer( LPVOID lpParameter );
|
||||
|
||||
/*
|
||||
* Process all the simulated interrupts - each represented by a bit in
|
||||
* ulPendingInterrupts variable.
|
||||
*/
|
||||
static void prvProcessSimulatedInterrupts( void );
|
||||
|
||||
/*
|
||||
* Interrupt handlers used by the kernel itself. These are executed from the
|
||||
* simulated interrupt handler thread.
|
||||
*/
|
||||
static uint32_t prvProcessYieldInterrupt( void );
|
||||
static uint32_t prvProcessTickInterrupt( void );
|
||||
|
||||
/*
|
||||
* Exiting a critical section will cause the calling task to block on yield
|
||||
* event to wait for an interrupt to process if an interrupt was pended while
|
||||
* inside the critical section. This variable protects against a recursive
|
||||
* attempt to obtain pvInterruptEventMutex if a critical section is used inside
|
||||
* an interrupt handler itself.
|
||||
*/
|
||||
volatile BaseType_t xInsideInterrupt = pdFALSE;
|
||||
|
||||
/*
|
||||
* Called when the process exits to let Windows know the high timer resolution
|
||||
* is no longer required.
|
||||
*/
|
||||
static BOOL WINAPI prvEndProcess( DWORD dwCtrlType );
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* The WIN32 simulator runs each task in a thread. The context switching is
|
||||
* managed by the threads, so the task stack does not have to be managed directly,
|
||||
* although the task stack is still used to hold an xThreadState structure this is
|
||||
* the only thing it will ever hold. The structure indirectly maps the task handle
|
||||
* to a thread handle. */
|
||||
typedef struct
|
||||
{
|
||||
/* Handle of the thread that executes the task. */
|
||||
void * pvThread;
|
||||
|
||||
/* Event used to make sure the thread does not execute past a yield point
|
||||
* between the call to SuspendThread() to suspend the thread and the
|
||||
* asynchronous SuspendThread() operation actually being performed. */
|
||||
void * pvYieldEvent;
|
||||
} ThreadState_t;
|
||||
|
||||
/* Simulated interrupts waiting to be processed. This is a bit mask where each
|
||||
* bit represents one interrupt, so a maximum of 32 interrupts can be simulated. */
|
||||
static volatile uint32_t ulPendingInterrupts = 0UL;
|
||||
|
||||
/* An event used to inform the simulated interrupt processing thread (a high
|
||||
* priority thread that simulated interrupt processing) that an interrupt is
|
||||
* pending. */
|
||||
static void * pvInterruptEvent = NULL;
|
||||
|
||||
/* Mutex used to protect all the simulated interrupt variables that are accessed
|
||||
* by multiple threads. */
|
||||
static void * pvInterruptEventMutex = NULL;
|
||||
|
||||
/* The critical nesting count for the currently executing task. This is
|
||||
* initialised to a non-zero value so interrupts do not become enabled during
|
||||
* the initialisation phase. As each task has its own critical nesting value
|
||||
* ulCriticalNesting will get set to zero when the first task runs. This
|
||||
* initialisation is probably not critical in this simulated environment as the
|
||||
* simulated interrupt handlers do not get created until the FreeRTOS scheduler is
|
||||
* started anyway. */
|
||||
static volatile uint32_t ulCriticalNesting = 9999UL;
|
||||
|
||||
/* Handlers for all the simulated software interrupts. The first two positions
|
||||
* are used for the Yield and Tick interrupts so are handled slightly differently,
|
||||
* all the other interrupts can be user defined. */
|
||||
static uint32_t (* ulIsrHandler[ portMAX_INTERRUPTS ])( void ) = { 0 };
|
||||
|
||||
/* Pointer to the TCB of the currently executing task. */
|
||||
extern void * volatile pxCurrentTCB;
|
||||
|
||||
/* Used to ensure nothing is processed during the startup sequence. */
|
||||
static BaseType_t xPortRunning = pdFALSE;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static DWORD WINAPI prvSimulatedPeripheralTimer( LPVOID lpParameter )
|
||||
{
|
||||
TickType_t xMinimumWindowsBlockTime;
|
||||
TIMECAPS xTimeCaps;
|
||||
TickType_t xWaitTimeBetweenTicks = portTICK_PERIOD_MS;
|
||||
HANDLE hTimer = NULL;
|
||||
LARGE_INTEGER liDueTime;
|
||||
BOOL bSuccess;
|
||||
|
||||
/* Set the timer resolution to the maximum possible. */
|
||||
if( timeGetDevCaps( &xTimeCaps, sizeof( xTimeCaps ) ) == MMSYSERR_NOERROR )
|
||||
{
|
||||
xMinimumWindowsBlockTime = ( TickType_t ) xTimeCaps.wPeriodMin;
|
||||
timeBeginPeriod( xTimeCaps.wPeriodMin );
|
||||
|
||||
/* Register an exit handler so the timeBeginPeriod() function can be
|
||||
* matched with a timeEndPeriod() when the application exits. */
|
||||
SetConsoleCtrlHandler( prvEndProcess, TRUE );
|
||||
}
|
||||
else
|
||||
{
|
||||
xMinimumWindowsBlockTime = ( TickType_t ) 20;
|
||||
}
|
||||
|
||||
/* Just to prevent compiler warnings. */
|
||||
( void ) lpParameter;
|
||||
|
||||
/* Tick time for the timer is adjusted with the maximum available
|
||||
resolution. */
|
||||
if( portTICK_PERIOD_MS < xMinimumWindowsBlockTime )
|
||||
{
|
||||
xWaitTimeBetweenTicks = xMinimumWindowsBlockTime;
|
||||
}
|
||||
|
||||
/* Convert the tick time in milliseconds to nanoseconds resolution
|
||||
for the Waitable Timer. */
|
||||
liDueTime.u.LowPart = xWaitTimeBetweenTicks * 1000 * 1000;
|
||||
liDueTime.u.HighPart = 0;
|
||||
|
||||
/* Create a synchronization Waitable Timer.*/
|
||||
hTimer = CreateWaitableTimer( NULL, FALSE, NULL );
|
||||
|
||||
configASSERT( hTimer != NULL );
|
||||
|
||||
/* Set the Waitable Timer. The timer is set to run periodically at every
|
||||
xWaitTimeBetweenTicks milliseconds. */
|
||||
bSuccess = SetWaitableTimer( hTimer, &liDueTime, xWaitTimeBetweenTicks, NULL, NULL, 0 );
|
||||
configASSERT( bSuccess );
|
||||
|
||||
while( xPortRunning == pdTRUE )
|
||||
{
|
||||
/* Wait until the timer expires and we can access the simulated interrupt
|
||||
* variables. */
|
||||
|
||||
WaitForSingleObject( hTimer, INFINITE );
|
||||
|
||||
vPortGenerateSimulatedInterruptFromWindowsThread( portINTERRUPT_TICK );
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static BOOL WINAPI prvEndProcess( DWORD dwCtrlType )
|
||||
{
|
||||
TIMECAPS xTimeCaps;
|
||||
|
||||
( void ) dwCtrlType;
|
||||
|
||||
if( timeGetDevCaps( &xTimeCaps, sizeof( xTimeCaps ) ) == MMSYSERR_NOERROR )
|
||||
{
|
||||
/* Match the call to timeBeginPeriod( xTimeCaps.wPeriodMin ) made when
|
||||
* the process started with a timeEndPeriod() as the process exits. */
|
||||
timeEndPeriod( xTimeCaps.wPeriodMin );
|
||||
}
|
||||
|
||||
return pdFALSE;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
StackType_t * pxPortInitialiseStack( StackType_t * pxTopOfStack,
|
||||
TaskFunction_t pxCode,
|
||||
void * pvParameters )
|
||||
{
|
||||
ThreadState_t * pxThreadState = NULL;
|
||||
int8_t * pcTopOfStack = ( int8_t * ) pxTopOfStack;
|
||||
const SIZE_T xStackSize = 1024; /* Set the size to a small number which will get rounded up to the minimum possible. */
|
||||
|
||||
/* In this simulated case a stack is not initialised, but instead a thread
|
||||
* is created that will execute the task being created. The thread handles
|
||||
* the context switching itself. The ThreadState_t object is placed onto
|
||||
* the stack that was created for the task - so the stack buffer is still
|
||||
* used, just not in the conventional way. It will not be used for anything
|
||||
* other than holding this structure. */
|
||||
pxThreadState = ( ThreadState_t * ) ( pcTopOfStack - sizeof( ThreadState_t ) );
|
||||
|
||||
/* Create the event used to prevent the thread from executing past its yield
|
||||
* point if the SuspendThread() call that suspends the thread does not take
|
||||
* effect immediately (it is an asynchronous call). */
|
||||
pxThreadState->pvYieldEvent = CreateEvent( NULL, /* Default security attributes. */
|
||||
FALSE, /* Auto reset. */
|
||||
FALSE, /* Start not signalled. */
|
||||
NULL ); /* No name. */
|
||||
|
||||
|
||||
#ifdef __GNUC__
|
||||
/* GCC reports the warning for the cast operation from TaskFunction_t to LPTHREAD_START_ROUTINE. */
|
||||
/* Disable this warning here by the #pragma option. */
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wcast-function-type"
|
||||
#endif
|
||||
/* Create the thread itself. */
|
||||
pxThreadState->pvThread = CreateThread( NULL, xStackSize, ( LPTHREAD_START_ROUTINE ) pxCode, pvParameters, CREATE_SUSPENDED | STACK_SIZE_PARAM_IS_A_RESERVATION, NULL );
|
||||
#ifdef __GNUC__
|
||||
#pragma GCC diagnostic pop
|
||||
#endif
|
||||
|
||||
configASSERT( pxThreadState->pvThread ); /* See comment where TerminateThread() is called. */
|
||||
SetThreadAffinityMask( pxThreadState->pvThread, 0x01 );
|
||||
SetThreadPriorityBoost( pxThreadState->pvThread, TRUE );
|
||||
SetThreadPriority( pxThreadState->pvThread, portTASK_THREAD_PRIORITY );
|
||||
|
||||
return ( StackType_t * ) pxThreadState;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
BaseType_t xPortStartScheduler( void )
|
||||
{
|
||||
void * pvHandle = NULL;
|
||||
int32_t lSuccess;
|
||||
ThreadState_t * pxThreadState = NULL;
|
||||
SYSTEM_INFO xSystemInfo;
|
||||
|
||||
/* This port runs windows threads with extremely high priority. All the
|
||||
* threads execute on the same core - to prevent locking up the host only start
|
||||
* if the host has multiple cores. */
|
||||
GetSystemInfo( &xSystemInfo );
|
||||
|
||||
if( xSystemInfo.dwNumberOfProcessors <= 1 )
|
||||
{
|
||||
printf( "This version of the FreeRTOS Windows port can only be used on multi-core hosts.\r\n" );
|
||||
lSuccess = pdFAIL;
|
||||
}
|
||||
else
|
||||
{
|
||||
lSuccess = pdPASS;
|
||||
|
||||
/* The highest priority class is used to [try to] prevent other Windows
|
||||
* activity interfering with FreeRTOS timing too much. */
|
||||
if( SetPriorityClass( GetCurrentProcess(), REALTIME_PRIORITY_CLASS ) == 0 )
|
||||
{
|
||||
printf( "SetPriorityClass() failed\r\n" );
|
||||
}
|
||||
|
||||
/* Install the interrupt handlers used by the scheduler itself. */
|
||||
vPortSetInterruptHandler( portINTERRUPT_YIELD, prvProcessYieldInterrupt );
|
||||
vPortSetInterruptHandler( portINTERRUPT_TICK, prvProcessTickInterrupt );
|
||||
|
||||
/* Create the events and mutexes that are used to synchronise all the
|
||||
* threads. */
|
||||
pvInterruptEventMutex = CreateMutex( NULL, FALSE, NULL );
|
||||
pvInterruptEvent = CreateEvent( NULL, FALSE, FALSE, NULL );
|
||||
|
||||
if( ( pvInterruptEventMutex == NULL ) || ( pvInterruptEvent == NULL ) )
|
||||
{
|
||||
lSuccess = pdFAIL;
|
||||
}
|
||||
|
||||
/* Set the priority of this thread such that it is above the priority of
|
||||
* the threads that run tasks. This higher priority is required to ensure
|
||||
* simulated interrupts take priority over tasks. */
|
||||
pvHandle = GetCurrentThread();
|
||||
|
||||
if( pvHandle == NULL )
|
||||
{
|
||||
lSuccess = pdFAIL;
|
||||
}
|
||||
}
|
||||
|
||||
if( lSuccess == pdPASS )
|
||||
{
|
||||
if( SetThreadPriority( pvHandle, portSIMULATED_INTERRUPTS_THREAD_PRIORITY ) == 0 )
|
||||
{
|
||||
lSuccess = pdFAIL;
|
||||
}
|
||||
|
||||
SetThreadPriorityBoost( pvHandle, TRUE );
|
||||
SetThreadAffinityMask( pvHandle, 0x01 );
|
||||
}
|
||||
|
||||
if( lSuccess == pdPASS )
|
||||
{
|
||||
/* Start the thread that simulates the timer peripheral to generate
|
||||
* tick interrupts. The priority is set below that of the simulated
|
||||
* interrupt handler so the interrupt event mutex is used for the
|
||||
* handshake / overrun protection. */
|
||||
pvHandle = CreateThread( NULL, 0, prvSimulatedPeripheralTimer, NULL, CREATE_SUSPENDED, NULL );
|
||||
|
||||
if( pvHandle != NULL )
|
||||
{
|
||||
SetThreadPriority( pvHandle, portSIMULATED_TIMER_THREAD_PRIORITY );
|
||||
SetThreadPriorityBoost( pvHandle, TRUE );
|
||||
SetThreadAffinityMask( pvHandle, 0x01 );
|
||||
ResumeThread( pvHandle );
|
||||
}
|
||||
|
||||
/* Start the highest priority task by obtaining its associated thread
|
||||
* state structure, in which is stored the thread handle. */
|
||||
pxThreadState = ( ThreadState_t * ) *( ( size_t * ) pxCurrentTCB );
|
||||
ulCriticalNesting = portNO_CRITICAL_NESTING;
|
||||
|
||||
/* The scheduler is now running. */
|
||||
xPortRunning = pdTRUE;
|
||||
|
||||
/* Start the first task. */
|
||||
ResumeThread( pxThreadState->pvThread );
|
||||
|
||||
/* Handle all simulated interrupts - including yield requests and
|
||||
* simulated ticks. */
|
||||
prvProcessSimulatedInterrupts();
|
||||
}
|
||||
|
||||
/* Would not expect to return from prvProcessSimulatedInterrupts(), so should
|
||||
* not get here. */
|
||||
return 0;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static uint32_t prvProcessYieldInterrupt( void )
|
||||
{
|
||||
/* Always return true as this is a yield. */
|
||||
return pdTRUE;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static uint32_t prvProcessTickInterrupt( void )
|
||||
{
|
||||
uint32_t ulSwitchRequired;
|
||||
|
||||
/* Process the tick itself. */
|
||||
configASSERT( xPortRunning );
|
||||
ulSwitchRequired = ( uint32_t ) xTaskIncrementTick();
|
||||
|
||||
return ulSwitchRequired;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void prvProcessSimulatedInterrupts( void )
|
||||
{
|
||||
uint32_t ulSwitchRequired, i;
|
||||
ThreadState_t * pxThreadState;
|
||||
void * pvObjectList[ 2 ];
|
||||
CONTEXT xContext;
|
||||
DWORD xWinApiResult;
|
||||
const DWORD xTimeoutMilliseconds = 1000;
|
||||
|
||||
/* Going to block on the mutex that ensured exclusive access to the simulated
|
||||
* interrupt objects, and the event that signals that a simulated interrupt
|
||||
* should be processed. */
|
||||
pvObjectList[ 0 ] = pvInterruptEventMutex;
|
||||
pvObjectList[ 1 ] = pvInterruptEvent;
|
||||
|
||||
/* Create a pending tick to ensure the first task is started as soon as
|
||||
* this thread pends. */
|
||||
ulPendingInterrupts |= ( 1 << portINTERRUPT_TICK );
|
||||
SetEvent( pvInterruptEvent );
|
||||
|
||||
while( xPortRunning == pdTRUE )
|
||||
{
|
||||
xInsideInterrupt = pdFALSE;
|
||||
|
||||
/* Wait with timeout so that we can exit from this loop when
|
||||
* the scheduler is stopped by calling vPortEndScheduler. */
|
||||
xWinApiResult = WaitForMultipleObjects( sizeof( pvObjectList ) / sizeof( void * ), pvObjectList, TRUE, xTimeoutMilliseconds );
|
||||
|
||||
if( xWinApiResult != WAIT_TIMEOUT )
|
||||
{
|
||||
/* Cannot be in a critical section to get here. Tasks that exit a
|
||||
* critical section will block on a yield mutex to wait for an interrupt to
|
||||
* process if an interrupt was set pending while the task was inside the
|
||||
* critical section. xInsideInterrupt prevents interrupts that contain
|
||||
* critical sections from doing the same. */
|
||||
xInsideInterrupt = pdTRUE;
|
||||
|
||||
/* Used to indicate whether the simulated interrupt processing has
|
||||
* necessitated a context switch to another task/thread. */
|
||||
ulSwitchRequired = pdFALSE;
|
||||
|
||||
/* For each interrupt we are interested in processing, each of which is
|
||||
* represented by a bit in the 32bit ulPendingInterrupts variable. */
|
||||
for( i = 0; i < portMAX_INTERRUPTS; i++ )
|
||||
{
|
||||
/* Is the simulated interrupt pending? */
|
||||
if( ( ulPendingInterrupts & ( 1UL << i ) ) != 0 )
|
||||
{
|
||||
/* Is a handler installed? */
|
||||
if( ulIsrHandler[ i ] != NULL )
|
||||
{
|
||||
/* Run the actual handler. Handlers return pdTRUE if they
|
||||
* necessitate a context switch. */
|
||||
if( ulIsrHandler[ i ]() != pdFALSE )
|
||||
{
|
||||
/* A bit mask is used purely to help debugging. */
|
||||
ulSwitchRequired |= ( 1 << i );
|
||||
}
|
||||
}
|
||||
|
||||
/* Clear the interrupt pending bit. */
|
||||
ulPendingInterrupts &= ~( 1UL << i );
|
||||
}
|
||||
}
|
||||
|
||||
if( ulSwitchRequired != pdFALSE )
|
||||
{
|
||||
/* Suspend the old thread. */
|
||||
pxThreadState = ( ThreadState_t * ) *( ( size_t * ) pxCurrentTCB );
|
||||
SuspendThread( pxThreadState->pvThread );
|
||||
|
||||
/* Ensure the thread is actually suspended by performing a
|
||||
* synchronous operation that can only complete when the thread
|
||||
* is actually suspended. The below code asks for dummy register
|
||||
* data. Experimentation shows that these two lines don't appear
|
||||
* to do anything now, but according to
|
||||
* https://devblogs.microsoft.com/oldnewthing/20150205-00/?p=44743
|
||||
* they do - so as they do not harm (slight run-time hit). */
|
||||
xContext.ContextFlags = CONTEXT_INTEGER;
|
||||
( void ) GetThreadContext( pxThreadState->pvThread, &xContext );
|
||||
|
||||
/* Select the next task to run. */
|
||||
vTaskSwitchContext();
|
||||
|
||||
/* Obtain the state of the task now selected to enter the
|
||||
* Running state. */
|
||||
pxThreadState = ( ThreadState_t * ) ( *( size_t * ) pxCurrentTCB );
|
||||
|
||||
/* pxThreadState->pvThread can be NULL if the task deleted
|
||||
* itself - but a deleted task should never be resumed here. */
|
||||
configASSERT( pxThreadState->pvThread != NULL );
|
||||
ResumeThread( pxThreadState->pvThread );
|
||||
}
|
||||
|
||||
/* If the thread that is about to be resumed stopped running
|
||||
* because it yielded then it will wait on an event when it resumed
|
||||
* (to ensure it does not continue running after the call to
|
||||
* SuspendThread() above as SuspendThread() is asynchronous).
|
||||
* Signal the event to ensure the thread can proceed now it is
|
||||
* valid for it to do so. Signaling the event is benign in the case that
|
||||
* the task was switched out asynchronously by an interrupt as the event
|
||||
* is reset before the task blocks on it. */
|
||||
pxThreadState = ( ThreadState_t * ) ( *( size_t * ) pxCurrentTCB );
|
||||
SetEvent( pxThreadState->pvYieldEvent );
|
||||
ReleaseMutex( pvInterruptEventMutex );
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortDeleteThread( void * pvTaskToDelete )
|
||||
{
|
||||
ThreadState_t * pxThreadState;
|
||||
uint32_t ulErrorCode;
|
||||
|
||||
/* Remove compiler warnings if configASSERT() is not defined. */
|
||||
( void ) ulErrorCode;
|
||||
|
||||
/* Find the handle of the thread being deleted. */
|
||||
pxThreadState = ( ThreadState_t * ) ( *( size_t * ) pvTaskToDelete );
|
||||
|
||||
/* Check that the thread is still valid, it might have been closed by
|
||||
* vPortCloseRunningThread() - which will be the case if the task associated
|
||||
* with the thread originally deleted itself rather than being deleted by a
|
||||
* different task. */
|
||||
if( pxThreadState->pvThread != NULL )
|
||||
{
|
||||
WaitForSingleObject( pvInterruptEventMutex, INFINITE );
|
||||
|
||||
/* !!! This is not a nice way to terminate a thread, and will eventually
|
||||
* result in resources being depleted if tasks frequently delete other
|
||||
* tasks (rather than deleting themselves) as the task stacks will not be
|
||||
* freed. */
|
||||
ulErrorCode = TerminateThread( pxThreadState->pvThread, 0 );
|
||||
configASSERT( ulErrorCode );
|
||||
|
||||
ulErrorCode = CloseHandle( pxThreadState->pvThread );
|
||||
configASSERT( ulErrorCode );
|
||||
|
||||
ReleaseMutex( pvInterruptEventMutex );
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortCloseRunningThread( void * pvTaskToDelete,
|
||||
volatile BaseType_t * pxPendYield )
|
||||
{
|
||||
ThreadState_t * pxThreadState;
|
||||
void * pvThread;
|
||||
uint32_t ulErrorCode;
|
||||
|
||||
/* Remove compiler warnings if configASSERT() is not defined. */
|
||||
( void ) ulErrorCode;
|
||||
|
||||
/* Find the handle of the thread being deleted. */
|
||||
pxThreadState = ( ThreadState_t * ) ( *( size_t * ) pvTaskToDelete );
|
||||
pvThread = pxThreadState->pvThread;
|
||||
|
||||
/* Raise the Windows priority of the thread to ensure the FreeRTOS scheduler
|
||||
* does not run and swap it out before it is closed. If that were to happen
|
||||
* the thread would never run again and effectively be a thread handle and
|
||||
* memory leak. */
|
||||
SetThreadPriority( pvThread, portDELETE_SELF_THREAD_PRIORITY );
|
||||
|
||||
/* This function will not return, therefore a yield is set as pending to
|
||||
* ensure a context switch occurs away from this thread on the next tick. */
|
||||
*pxPendYield = pdTRUE;
|
||||
|
||||
/* Mark the thread associated with this task as invalid so
|
||||
* vPortDeleteThread() does not try to terminate it. */
|
||||
pxThreadState->pvThread = NULL;
|
||||
|
||||
/* Close the thread. */
|
||||
ulErrorCode = CloseHandle( pvThread );
|
||||
configASSERT( ulErrorCode );
|
||||
|
||||
/* This is called from a critical section, which must be exited before the
|
||||
* thread stops. */
|
||||
taskEXIT_CRITICAL();
|
||||
|
||||
/* Record that a yield is pending so that the next tick interrupt switches
|
||||
* out this thread regardless of the value of configUSE_PREEMPTION. This is
|
||||
* needed when a task deletes itself - the taskYIELD_WITHIN_API within
|
||||
* vTaskDelete does not get called because this function never returns. If
|
||||
* we do not pend portINTERRUPT_YIELD here, the next task is not scheduled
|
||||
* when configUSE_PREEMPTION is set to 0. */
|
||||
if( pvInterruptEventMutex != NULL )
|
||||
{
|
||||
WaitForSingleObject( pvInterruptEventMutex, INFINITE );
|
||||
ulPendingInterrupts |= ( 1 << portINTERRUPT_YIELD );
|
||||
ReleaseMutex( pvInterruptEventMutex );
|
||||
}
|
||||
|
||||
CloseHandle( pxThreadState->pvYieldEvent );
|
||||
ExitThread( 0 );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortEndScheduler( void )
|
||||
{
|
||||
xPortRunning = pdFALSE;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortGenerateSimulatedInterrupt( uint32_t ulInterruptNumber )
|
||||
{
|
||||
ThreadState_t * pxThreadState = ( ThreadState_t * ) *( ( size_t * ) pxCurrentTCB );
|
||||
|
||||
configASSERT( xPortRunning );
|
||||
|
||||
if( ( ulInterruptNumber < portMAX_INTERRUPTS ) && ( pvInterruptEventMutex != NULL ) )
|
||||
{
|
||||
WaitForSingleObject( pvInterruptEventMutex, INFINITE );
|
||||
ulPendingInterrupts |= ( 1 << ulInterruptNumber );
|
||||
|
||||
/* The simulated interrupt is now held pending, but don't actually
|
||||
* process it yet if this call is within a critical section. It is
|
||||
* possible for this to be in a critical section as calls to wait for
|
||||
* mutexes are accumulative. If in a critical section then the event
|
||||
* will get set when the critical section nesting count is wound back
|
||||
* down to zero. */
|
||||
if( ulCriticalNesting == portNO_CRITICAL_NESTING )
|
||||
{
|
||||
SetEvent( pvInterruptEvent );
|
||||
|
||||
/* Going to wait for an event - make sure the event is not already
|
||||
* signaled. */
|
||||
ResetEvent( pxThreadState->pvYieldEvent );
|
||||
}
|
||||
|
||||
ReleaseMutex( pvInterruptEventMutex );
|
||||
|
||||
if( ulCriticalNesting == portNO_CRITICAL_NESTING )
|
||||
{
|
||||
/* An interrupt was pended so ensure to block to allow it to
|
||||
* execute. In most cases the (simulated) interrupt will have
|
||||
* executed before the next line is reached - so this is just to make
|
||||
* sure. */
|
||||
WaitForSingleObject( pxThreadState->pvYieldEvent, INFINITE );
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortGenerateSimulatedInterruptFromWindowsThread( uint32_t ulInterruptNumber )
|
||||
{
|
||||
if( xPortRunning == pdTRUE )
|
||||
{
|
||||
/* Can't proceed if in a critical section as pvInterruptEventMutex won't
|
||||
* be available. */
|
||||
WaitForSingleObject( pvInterruptEventMutex, INFINITE );
|
||||
|
||||
/* Pending a user defined interrupt to be handled in simulated interrupt
|
||||
* handler thread. */
|
||||
ulPendingInterrupts |= ( 1 << ulInterruptNumber );
|
||||
|
||||
/* The interrupt is now pending - notify the simulated interrupt
|
||||
* handler thread. Must be outside of a critical section to get here so
|
||||
* the handler thread can execute immediately pvInterruptEventMutex is
|
||||
* released. */
|
||||
configASSERT( ulCriticalNesting == 0UL );
|
||||
SetEvent( pvInterruptEvent );
|
||||
|
||||
/* Give back the mutex so the simulated interrupt handler unblocks
|
||||
* and can access the interrupt handler variables. */
|
||||
ReleaseMutex( pvInterruptEventMutex );
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortSetInterruptHandler( uint32_t ulInterruptNumber,
|
||||
uint32_t ( * pvHandler )( void ) )
|
||||
{
|
||||
if( ulInterruptNumber < portMAX_INTERRUPTS )
|
||||
{
|
||||
if( pvInterruptEventMutex != NULL )
|
||||
{
|
||||
WaitForSingleObject( pvInterruptEventMutex, INFINITE );
|
||||
ulIsrHandler[ ulInterruptNumber ] = pvHandler;
|
||||
ReleaseMutex( pvInterruptEventMutex );
|
||||
}
|
||||
else
|
||||
{
|
||||
ulIsrHandler[ ulInterruptNumber ] = pvHandler;
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortEnterCritical( void )
|
||||
{
|
||||
if( xPortRunning == pdTRUE )
|
||||
{
|
||||
/* The interrupt event mutex is held for the entire critical section,
|
||||
* effectively disabling (simulated) interrupts. */
|
||||
WaitForSingleObject( pvInterruptEventMutex, INFINITE );
|
||||
}
|
||||
|
||||
ulCriticalNesting++;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortExitCritical( void )
|
||||
{
|
||||
int32_t lMutexNeedsReleasing;
|
||||
|
||||
/* The interrupt event mutex should already be held by this thread as it was
|
||||
* obtained on entry to the critical section. */
|
||||
lMutexNeedsReleasing = pdTRUE;
|
||||
|
||||
if( ulCriticalNesting > portNO_CRITICAL_NESTING )
|
||||
{
|
||||
ulCriticalNesting--;
|
||||
|
||||
/* Don't need to wait for any pending interrupts to execute if the
|
||||
* critical section was exited from inside an interrupt. */
|
||||
if( ( ulCriticalNesting == portNO_CRITICAL_NESTING ) && ( xInsideInterrupt == pdFALSE ) )
|
||||
{
|
||||
/* Were any interrupts set to pending while interrupts were
|
||||
* (simulated) disabled? */
|
||||
if( ulPendingInterrupts != 0UL )
|
||||
{
|
||||
ThreadState_t * pxThreadState = ( ThreadState_t * ) *( ( size_t * ) pxCurrentTCB );
|
||||
|
||||
configASSERT( xPortRunning );
|
||||
|
||||
/* The interrupt won't actually executed until
|
||||
* pvInterruptEventMutex is released as it waits on both
|
||||
* pvInterruptEventMutex and pvInterruptEvent.
|
||||
* pvInterruptEvent is only set when the simulated
|
||||
* interrupt is pended if the interrupt is pended
|
||||
* from outside a critical section - hence it is set
|
||||
* here. */
|
||||
SetEvent( pvInterruptEvent );
|
||||
|
||||
/* The calling task is going to wait for an event to ensure the
|
||||
* interrupt that is pending executes immediately after the
|
||||
* critical section is exited - so make sure the event is not
|
||||
* already signaled. */
|
||||
ResetEvent( pxThreadState->pvYieldEvent );
|
||||
|
||||
/* Mutex will be released now so the (simulated) interrupt can
|
||||
* execute, so does not require releasing on function exit. */
|
||||
lMutexNeedsReleasing = pdFALSE;
|
||||
ReleaseMutex( pvInterruptEventMutex );
|
||||
WaitForSingleObject( pxThreadState->pvYieldEvent, INFINITE );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if( pvInterruptEventMutex != NULL )
|
||||
{
|
||||
if( lMutexNeedsReleasing == pdTRUE )
|
||||
{
|
||||
configASSERT( xPortRunning );
|
||||
ReleaseMutex( pvInterruptEventMutex );
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
+218
@@ -0,0 +1,218 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef PORTMACRO_H
|
||||
#define PORTMACRO_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/******************************************************************************
|
||||
* Defines
|
||||
******************************************************************************/
|
||||
/* Type definitions. */
|
||||
#define portCHAR char
|
||||
#define portFLOAT float
|
||||
#define portDOUBLE double
|
||||
#define portLONG long
|
||||
#define portSHORT short
|
||||
#define portSTACK_TYPE size_t
|
||||
#define portPOINTER_SIZE_TYPE size_t
|
||||
|
||||
typedef portSTACK_TYPE StackType_t;
|
||||
|
||||
#if defined( __x86_64__ ) || defined( _M_X64 )
|
||||
#define portBASE_TYPE long long
|
||||
typedef long long BaseType_t;
|
||||
typedef unsigned long long UBaseType_t;
|
||||
#else
|
||||
#define portBASE_TYPE long
|
||||
typedef long BaseType_t;
|
||||
typedef unsigned long UBaseType_t;
|
||||
#endif
|
||||
|
||||
|
||||
#if ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_16_BITS )
|
||||
typedef uint16_t TickType_t;
|
||||
#define portMAX_DELAY ( TickType_t ) 0xffff
|
||||
#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_32_BITS )
|
||||
typedef uint32_t TickType_t;
|
||||
#define portMAX_DELAY ( TickType_t ) 0xffffffffUL
|
||||
|
||||
/* 32-bit tick type on a 32/64-bit architecture, so reads of the tick
|
||||
* count do not need to be guarded with a critical section. */
|
||||
#define portTICK_TYPE_IS_ATOMIC 1
|
||||
#elif ( configTICK_TYPE_WIDTH_IN_BITS == TICK_TYPE_WIDTH_64_BITS )
|
||||
typedef uint64_t TickType_t;
|
||||
#define portMAX_DELAY ( TickType_t ) 0xffffffffffffffffULL
|
||||
|
||||
#if defined( __x86_64__ ) || defined( _M_X64 )
|
||||
/* 64-bit tick type on a 64-bit architecture, so reads of the tick
|
||||
* count do not need to be guarded with a critical section. */
|
||||
#define portTICK_TYPE_IS_ATOMIC 1
|
||||
#endif
|
||||
#else
|
||||
#error configTICK_TYPE_WIDTH_IN_BITS set to unsupported tick type width.
|
||||
#endif
|
||||
|
||||
/* Hardware specifics. */
|
||||
#define portSTACK_GROWTH ( -1 )
|
||||
#define portTICK_PERIOD_MS ( ( TickType_t ) 1000 / configTICK_RATE_HZ )
|
||||
#define portINLINE __inline
|
||||
|
||||
#if defined( __x86_64__ ) || defined( _M_X64 )
|
||||
#define portBYTE_ALIGNMENT 8
|
||||
#else
|
||||
#define portBYTE_ALIGNMENT 4
|
||||
#endif
|
||||
|
||||
#define portYIELD() vPortGenerateSimulatedInterrupt( portINTERRUPT_YIELD )
|
||||
|
||||
|
||||
extern volatile BaseType_t xInsideInterrupt;
|
||||
#define portSOFTWARE_BARRIER() while( xInsideInterrupt != pdFALSE )
|
||||
|
||||
|
||||
/* Simulated interrupts return pdFALSE if no context switch should be performed,
|
||||
* or a non-zero number if a context switch should be performed. */
|
||||
#define portYIELD_FROM_ISR( x ) return x
|
||||
#define portEND_SWITCHING_ISR( x ) portYIELD_FROM_ISR( ( x ) )
|
||||
|
||||
void vPortCloseRunningThread( void * pvTaskToDelete,
|
||||
volatile BaseType_t * pxPendYield );
|
||||
void vPortDeleteThread( void * pvThreadToDelete );
|
||||
#define portCLEAN_UP_TCB( pxTCB ) vPortDeleteThread( pxTCB )
|
||||
#define portPRE_TASK_DELETE_HOOK( pvTaskToDelete, pxPendYield ) vPortCloseRunningThread( ( pvTaskToDelete ), ( pxPendYield ) )
|
||||
#define portDISABLE_INTERRUPTS() vPortEnterCritical()
|
||||
#define portENABLE_INTERRUPTS() vPortExitCritical()
|
||||
|
||||
/* Critical section handling. */
|
||||
void vPortEnterCritical( void );
|
||||
void vPortExitCritical( void );
|
||||
|
||||
#define portENTER_CRITICAL() vPortEnterCritical()
|
||||
#define portEXIT_CRITICAL() vPortExitCritical()
|
||||
|
||||
#ifndef configUSE_PORT_OPTIMISED_TASK_SELECTION
|
||||
#define configUSE_PORT_OPTIMISED_TASK_SELECTION 1
|
||||
#endif
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if configUSE_PORT_OPTIMISED_TASK_SELECTION == 1
|
||||
|
||||
/* Check the configuration. */
|
||||
#if ( configMAX_PRIORITIES > 32 )
|
||||
#error configUSE_PORT_OPTIMISED_TASK_SELECTION can only be set to 1 when configMAX_PRIORITIES is less than or equal to 32. It is very rare that a system requires more than 10 to 15 difference priorities as tasks that share a priority will time slice.
|
||||
#endif
|
||||
|
||||
/* Store/clear the ready priorities in a bit map. */
|
||||
#define portRECORD_READY_PRIORITY( uxPriority, uxReadyPriorities ) ( uxReadyPriorities ) |= ( ( ( UBaseType_t ) 1 ) << ( uxPriority ) )
|
||||
#define portRESET_READY_PRIORITY( uxPriority, uxReadyPriorities ) ( uxReadyPriorities ) &= ~( ( ( UBaseType_t ) 1 ) << ( uxPriority ) )
|
||||
|
||||
#ifdef __GNUC__
|
||||
|
||||
#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities ) \
|
||||
__asm volatile ( "bsr %1, %0\n\t" \
|
||||
: "=r" ( uxTopPriority ) \
|
||||
: "rm" ( uxReadyPriorities ) \
|
||||
: "cc" )
|
||||
|
||||
#else /* __GNUC__ */
|
||||
#include <intrin.h>
|
||||
|
||||
/* BitScanReverse returns the bit position of the most significant '1'
|
||||
* in the word. */
|
||||
#if defined( __x86_64__ ) || defined( _M_X64 )
|
||||
#pragma intrinsic(_BitScanReverse64)
|
||||
|
||||
#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities ) \
|
||||
do \
|
||||
{ \
|
||||
unsigned long ulTopPriority; \
|
||||
_BitScanReverse64( &ulTopPriority, ( uxReadyPriorities ) ); \
|
||||
uxTopPriority = ulTopPriority; \
|
||||
} while( 0 )
|
||||
|
||||
#else /* #if defined( __x86_64__ ) || defined( _M_X64 ) */
|
||||
#pragma intrinsic(_BitScanReverse)
|
||||
|
||||
#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities ) _BitScanReverse( ( unsigned long * ) &( uxTopPriority ), ( uxReadyPriorities ) )
|
||||
|
||||
#endif /* #if defined( __x86_64__ ) || defined( _M_X64 ) */
|
||||
|
||||
#endif /* __GNUC__ */
|
||||
|
||||
#endif /* configUSE_PORT_OPTIMISED_TASK_SELECTION */
|
||||
|
||||
#ifndef __GNUC__
|
||||
__pragma( warning( disable:4211 ) ) /* Nonstandard extension used, as extern is only nonstandard to MSVC. */
|
||||
#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 )
|
||||
|
||||
#define portINTERRUPT_YIELD ( 0UL )
|
||||
#define portINTERRUPT_TICK ( 1UL )
|
||||
#define portINTERRUPT_APPLICATION_DEFINED_START ( 2UL )
|
||||
|
||||
/*
|
||||
* Raise a simulated interrupt represented by the bit mask in ulInterruptMask.
|
||||
* Each bit can be used to represent an individual interrupt - with the first
|
||||
* two bits being used for the Yield and Tick interrupts respectively.
|
||||
*/
|
||||
void vPortGenerateSimulatedInterrupt( uint32_t ulInterruptNumber );
|
||||
|
||||
/*
|
||||
* Raise a simulated interrupt represented by the bit mask in ulInterruptMask.
|
||||
* Each bit can be used to represent an individual interrupt - with the first
|
||||
* two bits being used for the Yield and Tick interrupts respectively. This function
|
||||
* can be called in a windows thread.
|
||||
*/
|
||||
void vPortGenerateSimulatedInterruptFromWindowsThread( uint32_t ulInterruptNumber );
|
||||
|
||||
/*
|
||||
* Install an interrupt handler to be called by the simulated interrupt handler
|
||||
* thread. The interrupt number must be above any used by the kernel itself
|
||||
* (at the time of writing the kernel was using interrupt numbers 0, 1, and 2
|
||||
* as defined above). The number must also be lower than 32.
|
||||
*
|
||||
* Interrupt handler functions must return a non-zero value if executing the
|
||||
* handler resulted in a task switch being required.
|
||||
*/
|
||||
void vPortSetInterruptHandler( uint32_t ulInterruptNumber,
|
||||
uint32_t ( * pvHandler )( void ) );
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* ifndef PORTMACRO_H */
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
[{000214A0-0000-0000-C000-000000000046}]
|
||||
Prop3=19,2
|
||||
[InternetShortcut]
|
||||
URL=https://www.FreeRTOS.org/a00111.html
|
||||
IDList=
|
||||
+178
@@ -0,0 +1,178 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* The simplest possible implementation of pvPortMalloc(). Note that this
|
||||
* implementation does NOT allow allocated memory to be freed again.
|
||||
*
|
||||
* See heap_2.c, heap_3.c and heap_4.c for alternative implementations, and the
|
||||
* memory management pages of https://www.FreeRTOS.org for more information.
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
|
||||
/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
|
||||
* all the API functions to use the MPU wrappers. That should only be done when
|
||||
* task.h is included from an application file. */
|
||||
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
|
||||
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
|
||||
#error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
|
||||
#endif
|
||||
|
||||
/* A few bytes might be lost to byte aligning the heap start address. */
|
||||
#define configADJUSTED_HEAP_SIZE ( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT )
|
||||
|
||||
/* Max value that fits in a size_t type. */
|
||||
#define heapSIZE_MAX ( ~( ( size_t ) 0 ) )
|
||||
|
||||
/* Check if adding a and b will result in overflow. */
|
||||
#define heapADD_WILL_OVERFLOW( a, b ) ( ( a ) > ( heapSIZE_MAX - ( b ) ) )
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Allocate the memory for the heap. */
|
||||
#if ( configAPPLICATION_ALLOCATED_HEAP == 1 )
|
||||
|
||||
/* The application writer has already defined the array used for the RTOS
|
||||
* heap - probably so it can be placed in a special segment or address. */
|
||||
extern uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
|
||||
#else
|
||||
static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
|
||||
#endif /* configAPPLICATION_ALLOCATED_HEAP */
|
||||
|
||||
/* Index into the ucHeap array. */
|
||||
static size_t xNextFreeByte = ( size_t ) 0U;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void * pvPortMalloc( size_t xWantedSize )
|
||||
{
|
||||
void * pvReturn = NULL;
|
||||
static uint8_t * pucAlignedHeap = NULL;
|
||||
|
||||
/* Ensure that blocks are always aligned. */
|
||||
#if ( portBYTE_ALIGNMENT != 1 )
|
||||
{
|
||||
size_t xAdditionalRequiredSize;
|
||||
|
||||
if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
|
||||
{
|
||||
/* Byte alignment required. */
|
||||
xAdditionalRequiredSize = portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK );
|
||||
|
||||
if( heapADD_WILL_OVERFLOW( xWantedSize, xAdditionalRequiredSize ) == 0 )
|
||||
{
|
||||
xWantedSize += xAdditionalRequiredSize;
|
||||
}
|
||||
else
|
||||
{
|
||||
xWantedSize = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* if ( portBYTE_ALIGNMENT != 1 ) */
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
if( pucAlignedHeap == NULL )
|
||||
{
|
||||
/* Ensure the heap starts on a correctly aligned boundary. */
|
||||
pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) &( ucHeap[ portBYTE_ALIGNMENT - 1 ] ) ) &
|
||||
( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );
|
||||
}
|
||||
|
||||
/* Check there is enough room left for the allocation. */
|
||||
if( ( xWantedSize > 0 ) &&
|
||||
( heapADD_WILL_OVERFLOW( xNextFreeByte, xWantedSize ) == 0 ) &&
|
||||
( ( xNextFreeByte + xWantedSize ) < configADJUSTED_HEAP_SIZE ) )
|
||||
{
|
||||
/* Return the next free byte then increment the index past this
|
||||
* block. */
|
||||
pvReturn = pucAlignedHeap + xNextFreeByte;
|
||||
xNextFreeByte += xWantedSize;
|
||||
}
|
||||
|
||||
traceMALLOC( pvReturn, xWantedSize );
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
|
||||
#if ( configUSE_MALLOC_FAILED_HOOK == 1 )
|
||||
{
|
||||
if( pvReturn == NULL )
|
||||
{
|
||||
vApplicationMallocFailedHook();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
return pvReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortFree( void * pv )
|
||||
{
|
||||
/* Memory cannot be freed using this scheme. See heap_2.c, heap_3.c and
|
||||
* heap_4.c for alternative implementations, and the memory management pages of
|
||||
* https://www.FreeRTOS.org for more information. */
|
||||
( void ) pv;
|
||||
|
||||
/* Force an assert as it is invalid to call this function. */
|
||||
configASSERT( pv == NULL );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortInitialiseBlocks( void )
|
||||
{
|
||||
/* Only required when static memory is not cleared. */
|
||||
xNextFreeByte = ( size_t ) 0;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
size_t xPortGetFreeHeapSize( void )
|
||||
{
|
||||
return( configADJUSTED_HEAP_SIZE - xNextFreeByte );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Reset the state in this file. This state is normally initialized at start up.
|
||||
* This function must be called by the application before restarting the
|
||||
* scheduler.
|
||||
*/
|
||||
void vPortHeapResetState( void )
|
||||
{
|
||||
xNextFreeByte = ( size_t ) 0U;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
+407
@@ -0,0 +1,407 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* A sample implementation of pvPortMalloc() and vPortFree() that permits
|
||||
* allocated blocks to be freed, but does not combine adjacent free blocks
|
||||
* into a single larger block (and so will fragment memory). See heap_4.c for
|
||||
* an equivalent that does combine adjacent blocks into single larger blocks.
|
||||
*
|
||||
* See heap_1.c, heap_3.c and heap_4.c for alternative implementations, and the
|
||||
* memory management pages of https://www.FreeRTOS.org for more information.
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
|
||||
* all the API functions to use the MPU wrappers. That should only be done when
|
||||
* task.h is included from an application file. */
|
||||
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
|
||||
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
|
||||
#error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
|
||||
#endif
|
||||
|
||||
#ifndef configHEAP_CLEAR_MEMORY_ON_FREE
|
||||
#define configHEAP_CLEAR_MEMORY_ON_FREE 0
|
||||
#endif
|
||||
|
||||
/* A few bytes might be lost to byte aligning the heap start address. */
|
||||
#define configADJUSTED_HEAP_SIZE ( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT )
|
||||
|
||||
/* Assumes 8bit bytes! */
|
||||
#define heapBITS_PER_BYTE ( ( size_t ) 8 )
|
||||
|
||||
/* Max value that fits in a size_t type. */
|
||||
#define heapSIZE_MAX ( ~( ( size_t ) 0 ) )
|
||||
|
||||
/* Check if multiplying a and b will result in overflow. */
|
||||
#define heapMULTIPLY_WILL_OVERFLOW( a, b ) ( ( ( a ) > 0 ) && ( ( b ) > ( heapSIZE_MAX / ( a ) ) ) )
|
||||
|
||||
/* Check if adding a and b will result in overflow. */
|
||||
#define heapADD_WILL_OVERFLOW( a, b ) ( ( a ) > ( heapSIZE_MAX - ( b ) ) )
|
||||
|
||||
/* MSB of the xBlockSize member of an BlockLink_t structure is used to track
|
||||
* the allocation status of a block. When MSB of the xBlockSize member of
|
||||
* an BlockLink_t structure is set then the block belongs to the application.
|
||||
* When the bit is free the block is still part of the free heap space. */
|
||||
#define heapBLOCK_ALLOCATED_BITMASK ( ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 ) )
|
||||
#define heapBLOCK_SIZE_IS_VALID( xBlockSize ) ( ( ( xBlockSize ) & heapBLOCK_ALLOCATED_BITMASK ) == 0 )
|
||||
#define heapBLOCK_IS_ALLOCATED( pxBlock ) ( ( ( pxBlock->xBlockSize ) & heapBLOCK_ALLOCATED_BITMASK ) != 0 )
|
||||
#define heapALLOCATE_BLOCK( pxBlock ) ( ( pxBlock->xBlockSize ) |= heapBLOCK_ALLOCATED_BITMASK )
|
||||
#define heapFREE_BLOCK( pxBlock ) ( ( pxBlock->xBlockSize ) &= ~heapBLOCK_ALLOCATED_BITMASK )
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Allocate the memory for the heap. */
|
||||
#if ( configAPPLICATION_ALLOCATED_HEAP == 1 )
|
||||
|
||||
/* The application writer has already defined the array used for the RTOS
|
||||
* heap - probably so it can be placed in a special segment or address. */
|
||||
extern uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
|
||||
#else
|
||||
PRIVILEGED_DATA static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
|
||||
#endif /* configAPPLICATION_ALLOCATED_HEAP */
|
||||
|
||||
|
||||
/* Define the linked list structure. This is used to link free blocks in order
|
||||
* of their size. */
|
||||
typedef struct A_BLOCK_LINK
|
||||
{
|
||||
struct A_BLOCK_LINK * pxNextFreeBlock; /*<< The next free block in the list. */
|
||||
size_t xBlockSize; /*<< The size of the free block. */
|
||||
} BlockLink_t;
|
||||
|
||||
|
||||
static const size_t xHeapStructSize = ( ( sizeof( BlockLink_t ) + ( size_t ) ( portBYTE_ALIGNMENT - 1 ) ) & ~( ( size_t ) portBYTE_ALIGNMENT_MASK ) );
|
||||
#define heapMINIMUM_BLOCK_SIZE ( ( size_t ) ( xHeapStructSize * 2 ) )
|
||||
|
||||
/* Create a couple of list links to mark the start and end of the list. */
|
||||
PRIVILEGED_DATA static BlockLink_t xStart, xEnd;
|
||||
|
||||
/* Keeps track of the number of free bytes remaining, but says nothing about
|
||||
* fragmentation. */
|
||||
PRIVILEGED_DATA static size_t xFreeBytesRemaining = configADJUSTED_HEAP_SIZE;
|
||||
|
||||
/* Indicates whether the heap has been initialised or not. */
|
||||
PRIVILEGED_DATA static BaseType_t xHeapHasBeenInitialised = pdFALSE;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Initialises the heap structures before their first use.
|
||||
*/
|
||||
static void prvHeapInit( void ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* STATIC FUNCTIONS ARE DEFINED AS MACROS TO MINIMIZE THE FUNCTION CALL DEPTH. */
|
||||
|
||||
/*
|
||||
* Insert a block into the list of free blocks - which is ordered by size of
|
||||
* the block. Small blocks at the start of the list and large blocks at the end
|
||||
* of the list.
|
||||
*/
|
||||
#define prvInsertBlockIntoFreeList( pxBlockToInsert ) \
|
||||
{ \
|
||||
BlockLink_t * pxIterator; \
|
||||
size_t xBlockSize; \
|
||||
\
|
||||
xBlockSize = pxBlockToInsert->xBlockSize; \
|
||||
\
|
||||
/* Iterate through the list until a block is found that has a larger size */ \
|
||||
/* than the block we are inserting. */ \
|
||||
for( pxIterator = &xStart; pxIterator->pxNextFreeBlock->xBlockSize < xBlockSize; pxIterator = pxIterator->pxNextFreeBlock ) \
|
||||
{ \
|
||||
/* There is nothing to do here - just iterate to the correct position. */ \
|
||||
} \
|
||||
\
|
||||
/* Update the list to include the block being inserted in the correct */ \
|
||||
/* position. */ \
|
||||
pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock; \
|
||||
pxIterator->pxNextFreeBlock = pxBlockToInsert; \
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void * pvPortMalloc( size_t xWantedSize )
|
||||
{
|
||||
BlockLink_t * pxBlock;
|
||||
BlockLink_t * pxPreviousBlock;
|
||||
BlockLink_t * pxNewBlockLink;
|
||||
void * pvReturn = NULL;
|
||||
size_t xAdditionalRequiredSize;
|
||||
size_t xAllocatedBlockSize = 0;
|
||||
|
||||
if( xWantedSize > 0 )
|
||||
{
|
||||
/* The wanted size must be increased so it can contain a BlockLink_t
|
||||
* structure in addition to the requested amount of bytes. */
|
||||
if( heapADD_WILL_OVERFLOW( xWantedSize, xHeapStructSize ) == 0 )
|
||||
{
|
||||
xWantedSize += xHeapStructSize;
|
||||
|
||||
/* Ensure that blocks are always aligned to the required number
|
||||
* of bytes. */
|
||||
if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
|
||||
{
|
||||
/* Byte alignment required. */
|
||||
xAdditionalRequiredSize = portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK );
|
||||
|
||||
if( heapADD_WILL_OVERFLOW( xWantedSize, xAdditionalRequiredSize ) == 0 )
|
||||
{
|
||||
xWantedSize += xAdditionalRequiredSize;
|
||||
}
|
||||
else
|
||||
{
|
||||
xWantedSize = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
xWantedSize = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
/* If this is the first call to malloc then the heap will require
|
||||
* initialisation to setup the list of free blocks. */
|
||||
if( xHeapHasBeenInitialised == pdFALSE )
|
||||
{
|
||||
prvHeapInit();
|
||||
xHeapHasBeenInitialised = pdTRUE;
|
||||
}
|
||||
|
||||
/* Check the block size we are trying to allocate is not so large that the
|
||||
* top bit is set. The top bit of the block size member of the BlockLink_t
|
||||
* structure is used to determine who owns the block - the application or
|
||||
* the kernel, so it must be free. */
|
||||
if( heapBLOCK_SIZE_IS_VALID( xWantedSize ) != 0 )
|
||||
{
|
||||
if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
|
||||
{
|
||||
/* Blocks are stored in byte order - traverse the list from the start
|
||||
* (smallest) block until one of adequate size is found. */
|
||||
pxPreviousBlock = &xStart;
|
||||
pxBlock = xStart.pxNextFreeBlock;
|
||||
|
||||
while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )
|
||||
{
|
||||
pxPreviousBlock = pxBlock;
|
||||
pxBlock = pxBlock->pxNextFreeBlock;
|
||||
}
|
||||
|
||||
/* If we found the end marker then a block of adequate size was not found. */
|
||||
if( pxBlock != &xEnd )
|
||||
{
|
||||
/* Return the memory space - jumping over the BlockLink_t structure
|
||||
* at its start. */
|
||||
pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );
|
||||
|
||||
/* This block is being returned for use so must be taken out of the
|
||||
* list of free blocks. */
|
||||
pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;
|
||||
|
||||
/* If the block is larger than required it can be split into two. */
|
||||
if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
|
||||
{
|
||||
/* This block is to be split into two. Create a new block
|
||||
* following the number of bytes requested. The void cast is
|
||||
* used to prevent byte alignment warnings from the compiler. */
|
||||
pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
|
||||
|
||||
/* Calculate the sizes of two blocks split from the single
|
||||
* block. */
|
||||
pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
|
||||
pxBlock->xBlockSize = xWantedSize;
|
||||
|
||||
/* Insert the new block into the list of free blocks.
|
||||
* The list of free blocks is sorted by their size, we have to
|
||||
* iterate to find the right place to insert new block. */
|
||||
prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );
|
||||
}
|
||||
|
||||
xFreeBytesRemaining -= pxBlock->xBlockSize;
|
||||
|
||||
xAllocatedBlockSize = pxBlock->xBlockSize;
|
||||
|
||||
/* The block is being returned - it is allocated and owned
|
||||
* by the application and has no "next" block. */
|
||||
heapALLOCATE_BLOCK( pxBlock );
|
||||
pxBlock->pxNextFreeBlock = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
traceMALLOC( pvReturn, xAllocatedBlockSize );
|
||||
|
||||
/* Prevent compiler warnings when trace macros are not used. */
|
||||
( void ) xAllocatedBlockSize;
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
|
||||
#if ( configUSE_MALLOC_FAILED_HOOK == 1 )
|
||||
{
|
||||
if( pvReturn == NULL )
|
||||
{
|
||||
vApplicationMallocFailedHook();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
return pvReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortFree( void * pv )
|
||||
{
|
||||
uint8_t * puc = ( uint8_t * ) pv;
|
||||
BlockLink_t * pxLink;
|
||||
|
||||
if( pv != NULL )
|
||||
{
|
||||
/* The memory being freed will have an BlockLink_t structure immediately
|
||||
* before it. */
|
||||
puc -= xHeapStructSize;
|
||||
|
||||
/* This unexpected casting is to keep some compilers from issuing
|
||||
* byte alignment warnings. */
|
||||
pxLink = ( void * ) puc;
|
||||
|
||||
configASSERT( heapBLOCK_IS_ALLOCATED( pxLink ) != 0 );
|
||||
configASSERT( pxLink->pxNextFreeBlock == NULL );
|
||||
|
||||
if( heapBLOCK_IS_ALLOCATED( pxLink ) != 0 )
|
||||
{
|
||||
if( pxLink->pxNextFreeBlock == NULL )
|
||||
{
|
||||
/* The block is being returned to the heap - it is no longer
|
||||
* allocated. */
|
||||
heapFREE_BLOCK( pxLink );
|
||||
#if ( configHEAP_CLEAR_MEMORY_ON_FREE == 1 )
|
||||
{
|
||||
( void ) memset( puc + xHeapStructSize, 0, pxLink->xBlockSize - xHeapStructSize );
|
||||
}
|
||||
#endif
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
/* Add this block to the list of free blocks. */
|
||||
prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
|
||||
xFreeBytesRemaining += pxLink->xBlockSize;
|
||||
traceFREE( pv, pxLink->xBlockSize );
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
size_t xPortGetFreeHeapSize( void )
|
||||
{
|
||||
return xFreeBytesRemaining;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortInitialiseBlocks( void )
|
||||
{
|
||||
/* This just exists to keep the linker quiet. */
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void * pvPortCalloc( size_t xNum,
|
||||
size_t xSize )
|
||||
{
|
||||
void * pv = NULL;
|
||||
|
||||
if( heapMULTIPLY_WILL_OVERFLOW( xNum, xSize ) == 0 )
|
||||
{
|
||||
pv = pvPortMalloc( xNum * xSize );
|
||||
|
||||
if( pv != NULL )
|
||||
{
|
||||
( void ) memset( pv, 0, xNum * xSize );
|
||||
}
|
||||
}
|
||||
|
||||
return pv;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void prvHeapInit( void ) /* PRIVILEGED_FUNCTION */
|
||||
{
|
||||
BlockLink_t * pxFirstFreeBlock;
|
||||
uint8_t * pucAlignedHeap;
|
||||
|
||||
/* Ensure the heap starts on a correctly aligned boundary. */
|
||||
pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) & ucHeap[ portBYTE_ALIGNMENT - 1 ] ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );
|
||||
|
||||
/* xStart is used to hold a pointer to the first item in the list of free
|
||||
* blocks. The void cast is used to prevent compiler warnings. */
|
||||
xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;
|
||||
xStart.xBlockSize = ( size_t ) 0;
|
||||
|
||||
/* xEnd is used to mark the end of the list of free blocks. */
|
||||
xEnd.xBlockSize = configADJUSTED_HEAP_SIZE;
|
||||
xEnd.pxNextFreeBlock = NULL;
|
||||
|
||||
/* To start with there is a single free block that is sized to take up the
|
||||
* entire heap space. */
|
||||
pxFirstFreeBlock = ( BlockLink_t * ) pucAlignedHeap;
|
||||
pxFirstFreeBlock->xBlockSize = configADJUSTED_HEAP_SIZE;
|
||||
pxFirstFreeBlock->pxNextFreeBlock = &xEnd;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Reset the state in this file. This state is normally initialized at start up.
|
||||
* This function must be called by the application before restarting the
|
||||
* scheduler.
|
||||
*/
|
||||
void vPortHeapResetState( void )
|
||||
{
|
||||
xFreeBytesRemaining = configADJUSTED_HEAP_SIZE;
|
||||
|
||||
xHeapHasBeenInitialised = pdFALSE;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
+106
@@ -0,0 +1,106 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* Implementation of pvPortMalloc() and vPortFree() that relies on the
|
||||
* compilers own malloc() and free() implementations.
|
||||
*
|
||||
* This file can only be used if the linker is configured to to generate
|
||||
* a heap memory area.
|
||||
*
|
||||
* See heap_1.c, heap_2.c and heap_4.c for alternative implementations, and the
|
||||
* memory management pages of https://www.FreeRTOS.org for more information.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
|
||||
* all the API functions to use the MPU wrappers. That should only be done when
|
||||
* task.h is included from an application file. */
|
||||
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
|
||||
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
|
||||
#error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
|
||||
#endif
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void * pvPortMalloc( size_t xWantedSize )
|
||||
{
|
||||
void * pvReturn;
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
pvReturn = malloc( xWantedSize );
|
||||
traceMALLOC( pvReturn, xWantedSize );
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
|
||||
#if ( configUSE_MALLOC_FAILED_HOOK == 1 )
|
||||
{
|
||||
if( pvReturn == NULL )
|
||||
{
|
||||
vApplicationMallocFailedHook();
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
return pvReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortFree( void * pv )
|
||||
{
|
||||
if( pv != NULL )
|
||||
{
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
free( pv );
|
||||
traceFREE( pv, 0 );
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Reset the state in this file. This state is normally initialized at start up.
|
||||
* This function must be called by the application before restarting the
|
||||
* scheduler.
|
||||
*/
|
||||
void vPortHeapResetState( void )
|
||||
{
|
||||
/* No state needs to be re-initialised in heap_3. */
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
+638
@@ -0,0 +1,638 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* A sample implementation of pvPortMalloc() and vPortFree() that combines
|
||||
* (coalescences) adjacent memory blocks as they are freed, and in so doing
|
||||
* limits memory fragmentation.
|
||||
*
|
||||
* See heap_1.c, heap_2.c and heap_3.c for alternative implementations, and the
|
||||
* memory management pages of https://www.FreeRTOS.org for more information.
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
|
||||
* all the API functions to use the MPU wrappers. That should only be done when
|
||||
* task.h is included from an application file. */
|
||||
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
|
||||
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
|
||||
#error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
|
||||
#endif
|
||||
|
||||
#ifndef configHEAP_CLEAR_MEMORY_ON_FREE
|
||||
#define configHEAP_CLEAR_MEMORY_ON_FREE 0
|
||||
#endif
|
||||
|
||||
/* Block sizes must not get too small. */
|
||||
#define heapMINIMUM_BLOCK_SIZE ( ( size_t ) ( xHeapStructSize << 1 ) )
|
||||
|
||||
/* Assumes 8bit bytes! */
|
||||
#define heapBITS_PER_BYTE ( ( size_t ) 8 )
|
||||
|
||||
/* Max value that fits in a size_t type. */
|
||||
#define heapSIZE_MAX ( ~( ( size_t ) 0 ) )
|
||||
|
||||
/* Check if multiplying a and b will result in overflow. */
|
||||
#define heapMULTIPLY_WILL_OVERFLOW( a, b ) ( ( ( a ) > 0 ) && ( ( b ) > ( heapSIZE_MAX / ( a ) ) ) )
|
||||
|
||||
/* Check if adding a and b will result in overflow. */
|
||||
#define heapADD_WILL_OVERFLOW( a, b ) ( ( a ) > ( heapSIZE_MAX - ( b ) ) )
|
||||
|
||||
/* Check if the subtraction operation ( a - b ) will result in underflow. */
|
||||
#define heapSUBTRACT_WILL_UNDERFLOW( a, b ) ( ( a ) < ( b ) )
|
||||
|
||||
/* MSB of the xBlockSize member of an BlockLink_t structure is used to track
|
||||
* the allocation status of a block. When MSB of the xBlockSize member of
|
||||
* an BlockLink_t structure is set then the block belongs to the application.
|
||||
* When the bit is free the block is still part of the free heap space. */
|
||||
#define heapBLOCK_ALLOCATED_BITMASK ( ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 ) )
|
||||
#define heapBLOCK_SIZE_IS_VALID( xBlockSize ) ( ( ( xBlockSize ) & heapBLOCK_ALLOCATED_BITMASK ) == 0 )
|
||||
#define heapBLOCK_IS_ALLOCATED( pxBlock ) ( ( ( pxBlock->xBlockSize ) & heapBLOCK_ALLOCATED_BITMASK ) != 0 )
|
||||
#define heapALLOCATE_BLOCK( pxBlock ) ( ( pxBlock->xBlockSize ) |= heapBLOCK_ALLOCATED_BITMASK )
|
||||
#define heapFREE_BLOCK( pxBlock ) ( ( pxBlock->xBlockSize ) &= ~heapBLOCK_ALLOCATED_BITMASK )
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Allocate the memory for the heap. */
|
||||
#if ( configAPPLICATION_ALLOCATED_HEAP == 1 )
|
||||
|
||||
/* The application writer has already defined the array used for the RTOS
|
||||
* heap - probably so it can be placed in a special segment or address. */
|
||||
extern uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
|
||||
#else
|
||||
PRIVILEGED_DATA static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];
|
||||
#endif /* configAPPLICATION_ALLOCATED_HEAP */
|
||||
|
||||
/* Define the linked list structure. This is used to link free blocks in order
|
||||
* of their memory address. */
|
||||
typedef struct A_BLOCK_LINK
|
||||
{
|
||||
struct A_BLOCK_LINK * pxNextFreeBlock; /**< The next free block in the list. */
|
||||
size_t xBlockSize; /**< The size of the free block. */
|
||||
} BlockLink_t;
|
||||
|
||||
/* Setting configENABLE_HEAP_PROTECTOR to 1 enables heap block pointers
|
||||
* protection using an application supplied canary value to catch heap
|
||||
* corruption should a heap buffer overflow occur.
|
||||
*/
|
||||
#if ( configENABLE_HEAP_PROTECTOR == 1 )
|
||||
|
||||
/**
|
||||
* @brief Application provided function to get a random value to be used as canary.
|
||||
*
|
||||
* @param pxHeapCanary [out] Output parameter to return the canary value.
|
||||
*/
|
||||
extern void vApplicationGetRandomHeapCanary( portPOINTER_SIZE_TYPE * pxHeapCanary );
|
||||
|
||||
/* Canary value for protecting internal heap pointers. */
|
||||
PRIVILEGED_DATA static portPOINTER_SIZE_TYPE xHeapCanary;
|
||||
|
||||
/* Macro to load/store BlockLink_t pointers to memory. By XORing the
|
||||
* pointers with a random canary value, heap overflows will result
|
||||
* in randomly unpredictable pointer values which will be caught by
|
||||
* heapVALIDATE_BLOCK_POINTER assert. */
|
||||
#define heapPROTECT_BLOCK_POINTER( pxBlock ) ( ( BlockLink_t * ) ( ( ( portPOINTER_SIZE_TYPE ) ( pxBlock ) ) ^ xHeapCanary ) )
|
||||
#else
|
||||
|
||||
#define heapPROTECT_BLOCK_POINTER( pxBlock ) ( pxBlock )
|
||||
|
||||
#endif /* configENABLE_HEAP_PROTECTOR */
|
||||
|
||||
/* Assert that a heap block pointer is within the heap bounds. */
|
||||
#define heapVALIDATE_BLOCK_POINTER( pxBlock ) \
|
||||
configASSERT( ( ( uint8_t * ) ( pxBlock ) >= &( ucHeap[ 0 ] ) ) && \
|
||||
( ( uint8_t * ) ( pxBlock ) <= &( ucHeap[ configTOTAL_HEAP_SIZE - 1 ] ) ) )
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Inserts a block of memory that is being freed into the correct position in
|
||||
* the list of free memory blocks. The block being freed will be merged with
|
||||
* the block in front it and/or the block behind it if the memory blocks are
|
||||
* adjacent to each other.
|
||||
*/
|
||||
static void prvInsertBlockIntoFreeList( BlockLink_t * pxBlockToInsert ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/*
|
||||
* Called automatically to setup the required heap structures the first time
|
||||
* pvPortMalloc() is called.
|
||||
*/
|
||||
static void prvHeapInit( void ) PRIVILEGED_FUNCTION;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* The size of the structure placed at the beginning of each allocated memory
|
||||
* block must by correctly byte aligned. */
|
||||
static const size_t xHeapStructSize = ( sizeof( BlockLink_t ) + ( ( size_t ) ( portBYTE_ALIGNMENT - 1 ) ) ) & ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
|
||||
|
||||
/* Create a couple of list links to mark the start and end of the list. */
|
||||
PRIVILEGED_DATA static BlockLink_t xStart;
|
||||
PRIVILEGED_DATA static BlockLink_t * pxEnd = NULL;
|
||||
|
||||
/* Keeps track of the number of calls to allocate and free memory as well as the
|
||||
* number of free bytes remaining, but says nothing about fragmentation. */
|
||||
PRIVILEGED_DATA static size_t xFreeBytesRemaining = ( size_t ) 0U;
|
||||
PRIVILEGED_DATA static size_t xMinimumEverFreeBytesRemaining = ( size_t ) 0U;
|
||||
PRIVILEGED_DATA static size_t xNumberOfSuccessfulAllocations = ( size_t ) 0U;
|
||||
PRIVILEGED_DATA static size_t xNumberOfSuccessfulFrees = ( size_t ) 0U;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void * pvPortMalloc( size_t xWantedSize )
|
||||
{
|
||||
BlockLink_t * pxBlock;
|
||||
BlockLink_t * pxPreviousBlock;
|
||||
BlockLink_t * pxNewBlockLink;
|
||||
void * pvReturn = NULL;
|
||||
size_t xAdditionalRequiredSize;
|
||||
size_t xAllocatedBlockSize = 0;
|
||||
|
||||
if( xWantedSize > 0 )
|
||||
{
|
||||
/* The wanted size must be increased so it can contain a BlockLink_t
|
||||
* structure in addition to the requested amount of bytes. */
|
||||
if( heapADD_WILL_OVERFLOW( xWantedSize, xHeapStructSize ) == 0 )
|
||||
{
|
||||
xWantedSize += xHeapStructSize;
|
||||
|
||||
/* Ensure that blocks are always aligned to the required number
|
||||
* of bytes. */
|
||||
if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
|
||||
{
|
||||
/* Byte alignment required. */
|
||||
xAdditionalRequiredSize = portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK );
|
||||
|
||||
if( heapADD_WILL_OVERFLOW( xWantedSize, xAdditionalRequiredSize ) == 0 )
|
||||
{
|
||||
xWantedSize += xAdditionalRequiredSize;
|
||||
}
|
||||
else
|
||||
{
|
||||
xWantedSize = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
xWantedSize = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
/* If this is the first call to malloc then the heap will require
|
||||
* initialisation to setup the list of free blocks. */
|
||||
if( pxEnd == NULL )
|
||||
{
|
||||
prvHeapInit();
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
/* Check the block size we are trying to allocate is not so large that the
|
||||
* top bit is set. The top bit of the block size member of the BlockLink_t
|
||||
* structure is used to determine who owns the block - the application or
|
||||
* the kernel, so it must be free. */
|
||||
if( heapBLOCK_SIZE_IS_VALID( xWantedSize ) != 0 )
|
||||
{
|
||||
if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
|
||||
{
|
||||
/* Traverse the list from the start (lowest address) block until
|
||||
* one of adequate size is found. */
|
||||
pxPreviousBlock = &xStart;
|
||||
pxBlock = heapPROTECT_BLOCK_POINTER( xStart.pxNextFreeBlock );
|
||||
heapVALIDATE_BLOCK_POINTER( pxBlock );
|
||||
|
||||
while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != heapPROTECT_BLOCK_POINTER( NULL ) ) )
|
||||
{
|
||||
pxPreviousBlock = pxBlock;
|
||||
pxBlock = heapPROTECT_BLOCK_POINTER( pxBlock->pxNextFreeBlock );
|
||||
heapVALIDATE_BLOCK_POINTER( pxBlock );
|
||||
}
|
||||
|
||||
/* If the end marker was reached then a block of adequate size
|
||||
* was not found. */
|
||||
if( pxBlock != pxEnd )
|
||||
{
|
||||
/* Return the memory space pointed to - jumping over the
|
||||
* BlockLink_t structure at its start. */
|
||||
pvReturn = ( void * ) ( ( ( uint8_t * ) heapPROTECT_BLOCK_POINTER( pxPreviousBlock->pxNextFreeBlock ) ) + xHeapStructSize );
|
||||
heapVALIDATE_BLOCK_POINTER( pvReturn );
|
||||
|
||||
/* This block is being returned for use so must be taken out
|
||||
* of the list of free blocks. */
|
||||
pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;
|
||||
|
||||
/* If the block is larger than required it can be split into
|
||||
* two. */
|
||||
configASSERT( heapSUBTRACT_WILL_UNDERFLOW( pxBlock->xBlockSize, xWantedSize ) == 0 );
|
||||
|
||||
if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
|
||||
{
|
||||
/* This block is to be split into two. Create a new
|
||||
* block following the number of bytes requested. The void
|
||||
* cast is used to prevent byte alignment warnings from the
|
||||
* compiler. */
|
||||
pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
|
||||
configASSERT( ( ( ( size_t ) pxNewBlockLink ) & portBYTE_ALIGNMENT_MASK ) == 0 );
|
||||
|
||||
/* Calculate the sizes of two blocks split from the
|
||||
* single block. */
|
||||
pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
|
||||
pxBlock->xBlockSize = xWantedSize;
|
||||
|
||||
/* Insert the new block into the list of free blocks. */
|
||||
pxNewBlockLink->pxNextFreeBlock = pxPreviousBlock->pxNextFreeBlock;
|
||||
pxPreviousBlock->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( pxNewBlockLink );
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
xFreeBytesRemaining -= pxBlock->xBlockSize;
|
||||
|
||||
if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )
|
||||
{
|
||||
xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
xAllocatedBlockSize = pxBlock->xBlockSize;
|
||||
|
||||
/* The block is being returned - it is allocated and owned
|
||||
* by the application and has no "next" block. */
|
||||
heapALLOCATE_BLOCK( pxBlock );
|
||||
pxBlock->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( NULL );
|
||||
xNumberOfSuccessfulAllocations++;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
traceMALLOC( pvReturn, xAllocatedBlockSize );
|
||||
|
||||
/* Prevent compiler warnings when trace macros are not used. */
|
||||
( void ) xAllocatedBlockSize;
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
|
||||
#if ( configUSE_MALLOC_FAILED_HOOK == 1 )
|
||||
{
|
||||
if( pvReturn == NULL )
|
||||
{
|
||||
vApplicationMallocFailedHook();
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
#endif /* if ( configUSE_MALLOC_FAILED_HOOK == 1 ) */
|
||||
|
||||
configASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 );
|
||||
return pvReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortFree( void * pv )
|
||||
{
|
||||
uint8_t * puc = ( uint8_t * ) pv;
|
||||
BlockLink_t * pxLink;
|
||||
|
||||
if( pv != NULL )
|
||||
{
|
||||
/* The memory being freed will have an BlockLink_t structure immediately
|
||||
* before it. */
|
||||
puc -= xHeapStructSize;
|
||||
|
||||
/* This casting is to keep the compiler from issuing warnings. */
|
||||
pxLink = ( void * ) puc;
|
||||
|
||||
heapVALIDATE_BLOCK_POINTER( pxLink );
|
||||
configASSERT( heapBLOCK_IS_ALLOCATED( pxLink ) != 0 );
|
||||
configASSERT( pxLink->pxNextFreeBlock == heapPROTECT_BLOCK_POINTER( NULL ) );
|
||||
|
||||
if( heapBLOCK_IS_ALLOCATED( pxLink ) != 0 )
|
||||
{
|
||||
if( pxLink->pxNextFreeBlock == heapPROTECT_BLOCK_POINTER( NULL ) )
|
||||
{
|
||||
/* The block is being returned to the heap - it is no longer
|
||||
* allocated. */
|
||||
heapFREE_BLOCK( pxLink );
|
||||
#if ( configHEAP_CLEAR_MEMORY_ON_FREE == 1 )
|
||||
{
|
||||
/* Check for underflow as this can occur if xBlockSize is
|
||||
* overwritten in a heap block. */
|
||||
if( heapSUBTRACT_WILL_UNDERFLOW( pxLink->xBlockSize, xHeapStructSize ) == 0 )
|
||||
{
|
||||
( void ) memset( puc + xHeapStructSize, 0, pxLink->xBlockSize - xHeapStructSize );
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
/* Add this block to the list of free blocks. */
|
||||
xFreeBytesRemaining += pxLink->xBlockSize;
|
||||
traceFREE( pv, pxLink->xBlockSize );
|
||||
prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
|
||||
xNumberOfSuccessfulFrees++;
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
size_t xPortGetFreeHeapSize( void )
|
||||
{
|
||||
return xFreeBytesRemaining;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
size_t xPortGetMinimumEverFreeHeapSize( void )
|
||||
{
|
||||
return xMinimumEverFreeBytesRemaining;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void xPortResetHeapMinimumEverFreeHeapSize( void )
|
||||
{
|
||||
xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortInitialiseBlocks( void )
|
||||
{
|
||||
/* This just exists to keep the linker quiet. */
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void * pvPortCalloc( size_t xNum,
|
||||
size_t xSize )
|
||||
{
|
||||
void * pv = NULL;
|
||||
|
||||
if( heapMULTIPLY_WILL_OVERFLOW( xNum, xSize ) == 0 )
|
||||
{
|
||||
pv = pvPortMalloc( xNum * xSize );
|
||||
|
||||
if( pv != NULL )
|
||||
{
|
||||
( void ) memset( pv, 0, xNum * xSize );
|
||||
}
|
||||
}
|
||||
|
||||
return pv;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void prvHeapInit( void ) /* PRIVILEGED_FUNCTION */
|
||||
{
|
||||
BlockLink_t * pxFirstFreeBlock;
|
||||
portPOINTER_SIZE_TYPE uxStartAddress, uxEndAddress;
|
||||
size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;
|
||||
|
||||
/* Ensure the heap starts on a correctly aligned boundary. */
|
||||
uxStartAddress = ( portPOINTER_SIZE_TYPE ) ucHeap;
|
||||
|
||||
if( ( uxStartAddress & portBYTE_ALIGNMENT_MASK ) != 0 )
|
||||
{
|
||||
uxStartAddress += ( portBYTE_ALIGNMENT - 1 );
|
||||
uxStartAddress &= ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK );
|
||||
xTotalHeapSize -= ( size_t ) ( uxStartAddress - ( portPOINTER_SIZE_TYPE ) ucHeap );
|
||||
}
|
||||
|
||||
#if ( configENABLE_HEAP_PROTECTOR == 1 )
|
||||
{
|
||||
vApplicationGetRandomHeapCanary( &( xHeapCanary ) );
|
||||
}
|
||||
#endif
|
||||
|
||||
/* xStart is used to hold a pointer to the first item in the list of free
|
||||
* blocks. The void cast is used to prevent compiler warnings. */
|
||||
xStart.pxNextFreeBlock = ( void * ) heapPROTECT_BLOCK_POINTER( uxStartAddress );
|
||||
xStart.xBlockSize = ( size_t ) 0;
|
||||
|
||||
/* pxEnd is used to mark the end of the list of free blocks and is inserted
|
||||
* at the end of the heap space. */
|
||||
uxEndAddress = uxStartAddress + ( portPOINTER_SIZE_TYPE ) xTotalHeapSize;
|
||||
uxEndAddress -= ( portPOINTER_SIZE_TYPE ) xHeapStructSize;
|
||||
uxEndAddress &= ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK );
|
||||
pxEnd = ( BlockLink_t * ) uxEndAddress;
|
||||
pxEnd->xBlockSize = 0;
|
||||
pxEnd->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( NULL );
|
||||
|
||||
/* To start with there is a single free block that is sized to take up the
|
||||
* entire heap space, minus the space taken by pxEnd. */
|
||||
pxFirstFreeBlock = ( BlockLink_t * ) uxStartAddress;
|
||||
pxFirstFreeBlock->xBlockSize = ( size_t ) ( uxEndAddress - ( portPOINTER_SIZE_TYPE ) pxFirstFreeBlock );
|
||||
pxFirstFreeBlock->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( pxEnd );
|
||||
|
||||
/* Only one block exists - and it covers the entire usable heap space. */
|
||||
xMinimumEverFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
|
||||
xFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void prvInsertBlockIntoFreeList( BlockLink_t * pxBlockToInsert ) /* PRIVILEGED_FUNCTION */
|
||||
{
|
||||
BlockLink_t * pxIterator;
|
||||
uint8_t * puc;
|
||||
|
||||
/* Iterate through the list until a block is found that has a higher address
|
||||
* than the block being inserted. */
|
||||
for( pxIterator = &xStart; heapPROTECT_BLOCK_POINTER( pxIterator->pxNextFreeBlock ) < pxBlockToInsert; pxIterator = heapPROTECT_BLOCK_POINTER( pxIterator->pxNextFreeBlock ) )
|
||||
{
|
||||
/* Nothing to do here, just iterate to the right position. */
|
||||
}
|
||||
|
||||
if( pxIterator != &xStart )
|
||||
{
|
||||
heapVALIDATE_BLOCK_POINTER( pxIterator );
|
||||
}
|
||||
|
||||
/* Do the block being inserted, and the block it is being inserted after
|
||||
* make a contiguous block of memory? */
|
||||
puc = ( uint8_t * ) pxIterator;
|
||||
|
||||
if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )
|
||||
{
|
||||
pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;
|
||||
pxBlockToInsert = pxIterator;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
/* Do the block being inserted, and the block it is being inserted before
|
||||
* make a contiguous block of memory? */
|
||||
puc = ( uint8_t * ) pxBlockToInsert;
|
||||
|
||||
if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) heapPROTECT_BLOCK_POINTER( pxIterator->pxNextFreeBlock ) )
|
||||
{
|
||||
if( heapPROTECT_BLOCK_POINTER( pxIterator->pxNextFreeBlock ) != pxEnd )
|
||||
{
|
||||
/* Form one big block from the two blocks. */
|
||||
pxBlockToInsert->xBlockSize += heapPROTECT_BLOCK_POINTER( pxIterator->pxNextFreeBlock )->xBlockSize;
|
||||
pxBlockToInsert->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( pxIterator->pxNextFreeBlock )->pxNextFreeBlock;
|
||||
}
|
||||
else
|
||||
{
|
||||
pxBlockToInsert->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( pxEnd );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;
|
||||
}
|
||||
|
||||
/* If the block being inserted plugged a gap, so was merged with the block
|
||||
* before and the block after, then it's pxNextFreeBlock pointer will have
|
||||
* already been set, and should not be set here as that would make it point
|
||||
* to itself. */
|
||||
if( pxIterator != pxBlockToInsert )
|
||||
{
|
||||
pxIterator->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( pxBlockToInsert );
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortGetHeapStats( HeapStats_t * pxHeapStats )
|
||||
{
|
||||
BlockLink_t * pxBlock;
|
||||
size_t xBlocks = 0, xMaxSize = 0, xMinSize = SIZE_MAX;
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
pxBlock = heapPROTECT_BLOCK_POINTER( xStart.pxNextFreeBlock );
|
||||
|
||||
/* pxBlock will be NULL if the heap has not been initialised. The heap
|
||||
* is initialised automatically when the first allocation is made. */
|
||||
if( pxBlock != NULL )
|
||||
{
|
||||
while( pxBlock != pxEnd )
|
||||
{
|
||||
/* Increment the number of blocks and record the largest block seen
|
||||
* so far. */
|
||||
xBlocks++;
|
||||
|
||||
if( pxBlock->xBlockSize > xMaxSize )
|
||||
{
|
||||
xMaxSize = pxBlock->xBlockSize;
|
||||
}
|
||||
|
||||
if( pxBlock->xBlockSize < xMinSize )
|
||||
{
|
||||
xMinSize = pxBlock->xBlockSize;
|
||||
}
|
||||
|
||||
/* Move to the next block in the chain until the last block is
|
||||
* reached. */
|
||||
pxBlock = heapPROTECT_BLOCK_POINTER( pxBlock->pxNextFreeBlock );
|
||||
}
|
||||
}
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
|
||||
pxHeapStats->xSizeOfLargestFreeBlockInBytes = xMaxSize;
|
||||
pxHeapStats->xSizeOfSmallestFreeBlockInBytes = xMinSize;
|
||||
pxHeapStats->xNumberOfFreeBlocks = xBlocks;
|
||||
|
||||
taskENTER_CRITICAL();
|
||||
{
|
||||
pxHeapStats->xAvailableHeapSpaceInBytes = xFreeBytesRemaining;
|
||||
pxHeapStats->xNumberOfSuccessfulAllocations = xNumberOfSuccessfulAllocations;
|
||||
pxHeapStats->xNumberOfSuccessfulFrees = xNumberOfSuccessfulFrees;
|
||||
pxHeapStats->xMinimumEverFreeBytesRemaining = xMinimumEverFreeBytesRemaining;
|
||||
}
|
||||
taskEXIT_CRITICAL();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Reset the state in this file. This state is normally initialized at start up.
|
||||
* This function must be called by the application before restarting the
|
||||
* scheduler.
|
||||
*/
|
||||
void vPortHeapResetState( void )
|
||||
{
|
||||
pxEnd = NULL;
|
||||
|
||||
xFreeBytesRemaining = ( size_t ) 0U;
|
||||
xMinimumEverFreeBytesRemaining = ( size_t ) 0U;
|
||||
xNumberOfSuccessfulAllocations = ( size_t ) 0U;
|
||||
xNumberOfSuccessfulFrees = ( size_t ) 0U;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
+749
@@ -0,0 +1,749 @@
|
||||
/*
|
||||
* FreeRTOS Kernel V11.3.0
|
||||
* Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* https://www.FreeRTOS.org
|
||||
* https://github.com/FreeRTOS
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* A sample implementation of pvPortMalloc() that allows the heap to be defined
|
||||
* across multiple non-contiguous blocks and combines (coalescences) adjacent
|
||||
* memory blocks as they are freed.
|
||||
*
|
||||
* See heap_1.c, heap_2.c, heap_3.c and heap_4.c for alternative
|
||||
* implementations, and the memory management pages of https://www.FreeRTOS.org
|
||||
* for more information.
|
||||
*
|
||||
* Usage notes:
|
||||
*
|
||||
* vPortDefineHeapRegions() ***must*** be called before pvPortMalloc().
|
||||
* pvPortMalloc() will be called if any task objects (tasks, queues, event
|
||||
* groups, etc.) are created, therefore vPortDefineHeapRegions() ***must*** be
|
||||
* called before any other objects are defined.
|
||||
*
|
||||
* vPortDefineHeapRegions() takes a single parameter. The parameter is an array
|
||||
* of HeapRegion_t structures. HeapRegion_t is defined in portable.h as
|
||||
*
|
||||
* typedef struct HeapRegion
|
||||
* {
|
||||
* uint8_t *pucStartAddress; << Start address of a block of memory that will be part of the heap.
|
||||
* size_t xSizeInBytes; << Size of the block of memory.
|
||||
* } HeapRegion_t;
|
||||
*
|
||||
* The array is terminated using a NULL zero sized region definition, and the
|
||||
* memory regions defined in the array ***must*** appear in address order from
|
||||
* low address to high address. So the following is a valid example of how
|
||||
* to use the function.
|
||||
*
|
||||
* HeapRegion_t xHeapRegions[] =
|
||||
* {
|
||||
* { ( uint8_t * ) 0x80000000UL, 0x10000 }, << Defines a block of 0x10000 bytes starting at address 0x80000000
|
||||
* { ( uint8_t * ) 0x90000000UL, 0xa0000 }, << Defines a block of 0xa0000 bytes starting at address of 0x90000000
|
||||
* { NULL, 0 } << Terminates the array.
|
||||
* };
|
||||
*
|
||||
* vPortDefineHeapRegions( xHeapRegions ); << Pass the array into vPortDefineHeapRegions().
|
||||
*
|
||||
* Note 0x80000000 is the lower address so appears in the array first.
|
||||
*
|
||||
*/
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining
|
||||
* all the API functions to use the MPU wrappers. That should only be done when
|
||||
* task.h is included from an application file. */
|
||||
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
|
||||
#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
|
||||
|
||||
#if ( configSUPPORT_DYNAMIC_ALLOCATION == 0 )
|
||||
#error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0
|
||||
#endif
|
||||
|
||||
#ifndef configHEAP_CLEAR_MEMORY_ON_FREE
|
||||
#define configHEAP_CLEAR_MEMORY_ON_FREE 0
|
||||
#endif
|
||||
|
||||
/* Block sizes must not get too small. */
|
||||
#define heapMINIMUM_BLOCK_SIZE ( ( size_t ) ( xHeapStructSize << 1 ) )
|
||||
|
||||
/* Assumes 8bit bytes! */
|
||||
#define heapBITS_PER_BYTE ( ( size_t ) 8 )
|
||||
|
||||
/* Max value that fits in a size_t type. */
|
||||
#define heapSIZE_MAX ( ~( ( size_t ) 0 ) )
|
||||
|
||||
/* Check if multiplying a and b will result in overflow. */
|
||||
#define heapMULTIPLY_WILL_OVERFLOW( a, b ) ( ( ( a ) > 0 ) && ( ( b ) > ( heapSIZE_MAX / ( a ) ) ) )
|
||||
|
||||
/* Check if adding a and b will result in overflow. */
|
||||
#define heapADD_WILL_OVERFLOW( a, b ) ( ( a ) > ( heapSIZE_MAX - ( b ) ) )
|
||||
|
||||
/* Check if the subtraction operation ( a - b ) will result in underflow. */
|
||||
#define heapSUBTRACT_WILL_UNDERFLOW( a, b ) ( ( a ) < ( b ) )
|
||||
|
||||
/* MSB of the xBlockSize member of an BlockLink_t structure is used to track
|
||||
* the allocation status of a block. When MSB of the xBlockSize member of
|
||||
* an BlockLink_t structure is set then the block belongs to the application.
|
||||
* When the bit is free the block is still part of the free heap space. */
|
||||
#define heapBLOCK_ALLOCATED_BITMASK ( ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 ) )
|
||||
#define heapBLOCK_SIZE_IS_VALID( xBlockSize ) ( ( ( xBlockSize ) & heapBLOCK_ALLOCATED_BITMASK ) == 0 )
|
||||
#define heapBLOCK_IS_ALLOCATED( pxBlock ) ( ( ( pxBlock->xBlockSize ) & heapBLOCK_ALLOCATED_BITMASK ) != 0 )
|
||||
#define heapALLOCATE_BLOCK( pxBlock ) ( ( pxBlock->xBlockSize ) |= heapBLOCK_ALLOCATED_BITMASK )
|
||||
#define heapFREE_BLOCK( pxBlock ) ( ( pxBlock->xBlockSize ) &= ~heapBLOCK_ALLOCATED_BITMASK )
|
||||
|
||||
/* Setting configENABLE_HEAP_PROTECTOR to 1 enables heap block pointers
|
||||
* protection using an application supplied canary value to catch heap
|
||||
* corruption should a heap buffer overflow occur.
|
||||
*/
|
||||
#if ( configENABLE_HEAP_PROTECTOR == 1 )
|
||||
|
||||
/* Macro to load/store BlockLink_t pointers to memory. By XORing the
|
||||
* pointers with a random canary value, heap overflows will result
|
||||
* in randomly unpredictable pointer values which will be caught by
|
||||
* heapVALIDATE_BLOCK_POINTER assert. */
|
||||
#define heapPROTECT_BLOCK_POINTER( pxBlock ) ( ( BlockLink_t * ) ( ( ( portPOINTER_SIZE_TYPE ) ( pxBlock ) ) ^ xHeapCanary ) )
|
||||
|
||||
/* Assert that a heap block pointer is within the heap bounds.
|
||||
* Setting configVALIDATE_HEAP_BLOCK_POINTER to 1 enables customized heap block pointers
|
||||
* protection on heap_5. */
|
||||
#ifndef configVALIDATE_HEAP_BLOCK_POINTER
|
||||
#define heapVALIDATE_BLOCK_POINTER( pxBlock ) \
|
||||
configASSERT( ( pucHeapHighAddress != NULL ) && \
|
||||
( pucHeapLowAddress != NULL ) && \
|
||||
( ( uint8_t * ) ( pxBlock ) >= pucHeapLowAddress ) && \
|
||||
( ( uint8_t * ) ( pxBlock ) < pucHeapHighAddress ) )
|
||||
#else /* ifndef configVALIDATE_HEAP_BLOCK_POINTER */
|
||||
#define heapVALIDATE_BLOCK_POINTER( pxBlock ) \
|
||||
configVALIDATE_HEAP_BLOCK_POINTER( pxBlock )
|
||||
#endif /* configVALIDATE_HEAP_BLOCK_POINTER */
|
||||
|
||||
#else /* if ( configENABLE_HEAP_PROTECTOR == 1 ) */
|
||||
|
||||
#define heapPROTECT_BLOCK_POINTER( pxBlock ) ( pxBlock )
|
||||
|
||||
#define heapVALIDATE_BLOCK_POINTER( pxBlock )
|
||||
|
||||
#endif /* configENABLE_HEAP_PROTECTOR */
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Define the linked list structure. This is used to link free blocks in order
|
||||
* of their memory address. */
|
||||
typedef struct A_BLOCK_LINK
|
||||
{
|
||||
struct A_BLOCK_LINK * pxNextFreeBlock; /**< The next free block in the list. */
|
||||
size_t xBlockSize; /**< The size of the free block. */
|
||||
} BlockLink_t;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Inserts a block of memory that is being freed into the correct position in
|
||||
* the list of free memory blocks. The block being freed will be merged with
|
||||
* the block in front it and/or the block behind it if the memory blocks are
|
||||
* adjacent to each other.
|
||||
*/
|
||||
static void prvInsertBlockIntoFreeList( BlockLink_t * pxBlockToInsert ) PRIVILEGED_FUNCTION;
|
||||
void vPortDefineHeapRegions( const HeapRegion_t * const pxHeapRegions ) PRIVILEGED_FUNCTION;
|
||||
|
||||
#if ( configENABLE_HEAP_PROTECTOR == 1 )
|
||||
|
||||
/**
|
||||
* @brief Application provided function to get a random value to be used as canary.
|
||||
*
|
||||
* @param pxHeapCanary [out] Output parameter to return the canary value.
|
||||
*/
|
||||
extern void vApplicationGetRandomHeapCanary( portPOINTER_SIZE_TYPE * pxHeapCanary );
|
||||
#endif /* configENABLE_HEAP_PROTECTOR */
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* The size of the structure placed at the beginning of each allocated memory
|
||||
* block must by correctly byte aligned. */
|
||||
static const size_t xHeapStructSize = ( sizeof( BlockLink_t ) + ( ( size_t ) ( portBYTE_ALIGNMENT - 1 ) ) ) & ~( ( size_t ) portBYTE_ALIGNMENT_MASK );
|
||||
|
||||
/* Create a couple of list links to mark the start and end of the list. */
|
||||
PRIVILEGED_DATA static BlockLink_t xStart;
|
||||
PRIVILEGED_DATA static BlockLink_t * pxEnd = NULL;
|
||||
|
||||
/* Keeps track of the number of calls to allocate and free memory as well as the
|
||||
* number of free bytes remaining, but says nothing about fragmentation. */
|
||||
PRIVILEGED_DATA static size_t xFreeBytesRemaining = ( size_t ) 0U;
|
||||
PRIVILEGED_DATA static size_t xMinimumEverFreeBytesRemaining = ( size_t ) 0U;
|
||||
PRIVILEGED_DATA static size_t xNumberOfSuccessfulAllocations = ( size_t ) 0U;
|
||||
PRIVILEGED_DATA static size_t xNumberOfSuccessfulFrees = ( size_t ) 0U;
|
||||
|
||||
#if ( configENABLE_HEAP_PROTECTOR == 1 )
|
||||
|
||||
/* Canary value for protecting internal heap pointers. */
|
||||
PRIVILEGED_DATA static portPOINTER_SIZE_TYPE xHeapCanary;
|
||||
|
||||
/* Highest and lowest heap addresses used for heap block bounds checking. */
|
||||
PRIVILEGED_DATA static uint8_t * pucHeapHighAddress = NULL;
|
||||
PRIVILEGED_DATA static uint8_t * pucHeapLowAddress = NULL;
|
||||
|
||||
#endif /* configENABLE_HEAP_PROTECTOR */
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void * pvPortMalloc( size_t xWantedSize )
|
||||
{
|
||||
BlockLink_t * pxBlock;
|
||||
BlockLink_t * pxPreviousBlock;
|
||||
BlockLink_t * pxNewBlockLink;
|
||||
void * pvReturn = NULL;
|
||||
size_t xAdditionalRequiredSize;
|
||||
size_t xAllocatedBlockSize = 0;
|
||||
|
||||
/* The heap must be initialised before the first call to
|
||||
* pvPortMalloc(). */
|
||||
configASSERT( pxEnd );
|
||||
|
||||
if( xWantedSize > 0 )
|
||||
{
|
||||
/* The wanted size must be increased so it can contain a BlockLink_t
|
||||
* structure in addition to the requested amount of bytes. */
|
||||
if( heapADD_WILL_OVERFLOW( xWantedSize, xHeapStructSize ) == 0 )
|
||||
{
|
||||
xWantedSize += xHeapStructSize;
|
||||
|
||||
/* Ensure that blocks are always aligned to the required number
|
||||
* of bytes. */
|
||||
if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )
|
||||
{
|
||||
/* Byte alignment required. */
|
||||
xAdditionalRequiredSize = portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK );
|
||||
|
||||
if( heapADD_WILL_OVERFLOW( xWantedSize, xAdditionalRequiredSize ) == 0 )
|
||||
{
|
||||
xWantedSize += xAdditionalRequiredSize;
|
||||
}
|
||||
else
|
||||
{
|
||||
xWantedSize = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
xWantedSize = 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
/* Check the block size we are trying to allocate is not so large that the
|
||||
* top bit is set. The top bit of the block size member of the BlockLink_t
|
||||
* structure is used to determine who owns the block - the application or
|
||||
* the kernel, so it must be free. */
|
||||
if( heapBLOCK_SIZE_IS_VALID( xWantedSize ) != 0 )
|
||||
{
|
||||
if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )
|
||||
{
|
||||
/* Traverse the list from the start (lowest address) block until
|
||||
* one of adequate size is found. */
|
||||
pxPreviousBlock = &xStart;
|
||||
pxBlock = heapPROTECT_BLOCK_POINTER( xStart.pxNextFreeBlock );
|
||||
heapVALIDATE_BLOCK_POINTER( pxBlock );
|
||||
|
||||
while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != heapPROTECT_BLOCK_POINTER( NULL ) ) )
|
||||
{
|
||||
pxPreviousBlock = pxBlock;
|
||||
pxBlock = heapPROTECT_BLOCK_POINTER( pxBlock->pxNextFreeBlock );
|
||||
heapVALIDATE_BLOCK_POINTER( pxBlock );
|
||||
}
|
||||
|
||||
/* If the end marker was reached then a block of adequate size
|
||||
* was not found. */
|
||||
if( pxBlock != pxEnd )
|
||||
{
|
||||
/* Return the memory space pointed to - jumping over the
|
||||
* BlockLink_t structure at its start. */
|
||||
pvReturn = ( void * ) ( ( ( uint8_t * ) heapPROTECT_BLOCK_POINTER( pxPreviousBlock->pxNextFreeBlock ) ) + xHeapStructSize );
|
||||
heapVALIDATE_BLOCK_POINTER( pvReturn );
|
||||
|
||||
/* This block is being returned for use so must be taken out
|
||||
* of the list of free blocks. */
|
||||
pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;
|
||||
|
||||
/* If the block is larger than required it can be split into
|
||||
* two. */
|
||||
configASSERT( heapSUBTRACT_WILL_UNDERFLOW( pxBlock->xBlockSize, xWantedSize ) == 0 );
|
||||
|
||||
if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )
|
||||
{
|
||||
/* This block is to be split into two. Create a new
|
||||
* block following the number of bytes requested. The void
|
||||
* cast is used to prevent byte alignment warnings from the
|
||||
* compiler. */
|
||||
pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );
|
||||
configASSERT( ( ( ( size_t ) pxNewBlockLink ) & portBYTE_ALIGNMENT_MASK ) == 0 );
|
||||
|
||||
/* Calculate the sizes of two blocks split from the
|
||||
* single block. */
|
||||
pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;
|
||||
pxBlock->xBlockSize = xWantedSize;
|
||||
|
||||
/* Insert the new block into the list of free blocks. */
|
||||
pxNewBlockLink->pxNextFreeBlock = pxPreviousBlock->pxNextFreeBlock;
|
||||
pxPreviousBlock->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( pxNewBlockLink );
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
xFreeBytesRemaining -= pxBlock->xBlockSize;
|
||||
|
||||
if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )
|
||||
{
|
||||
xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
xAllocatedBlockSize = pxBlock->xBlockSize;
|
||||
|
||||
/* The block is being returned - it is allocated and owned
|
||||
* by the application and has no "next" block. */
|
||||
heapALLOCATE_BLOCK( pxBlock );
|
||||
pxBlock->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( NULL );
|
||||
xNumberOfSuccessfulAllocations++;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
traceMALLOC( pvReturn, xAllocatedBlockSize );
|
||||
|
||||
/* Prevent compiler warnings when trace macros are not used. */
|
||||
( void ) xAllocatedBlockSize;
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
|
||||
#if ( configUSE_MALLOC_FAILED_HOOK == 1 )
|
||||
{
|
||||
if( pvReturn == NULL )
|
||||
{
|
||||
vApplicationMallocFailedHook();
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
#endif /* if ( configUSE_MALLOC_FAILED_HOOK == 1 ) */
|
||||
|
||||
configASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 );
|
||||
return pvReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortFree( void * pv )
|
||||
{
|
||||
uint8_t * puc = ( uint8_t * ) pv;
|
||||
BlockLink_t * pxLink;
|
||||
|
||||
if( pv != NULL )
|
||||
{
|
||||
/* The memory being freed will have an BlockLink_t structure immediately
|
||||
* before it. */
|
||||
puc -= xHeapStructSize;
|
||||
|
||||
/* This casting is to keep the compiler from issuing warnings. */
|
||||
pxLink = ( void * ) puc;
|
||||
|
||||
heapVALIDATE_BLOCK_POINTER( pxLink );
|
||||
configASSERT( heapBLOCK_IS_ALLOCATED( pxLink ) != 0 );
|
||||
configASSERT( pxLink->pxNextFreeBlock == heapPROTECT_BLOCK_POINTER( NULL ) );
|
||||
|
||||
if( heapBLOCK_IS_ALLOCATED( pxLink ) != 0 )
|
||||
{
|
||||
if( pxLink->pxNextFreeBlock == heapPROTECT_BLOCK_POINTER( NULL ) )
|
||||
{
|
||||
/* The block is being returned to the heap - it is no longer
|
||||
* allocated. */
|
||||
heapFREE_BLOCK( pxLink );
|
||||
#if ( configHEAP_CLEAR_MEMORY_ON_FREE == 1 )
|
||||
{
|
||||
/* Check for underflow as this can occur if xBlockSize is
|
||||
* overwritten in a heap block. */
|
||||
if( heapSUBTRACT_WILL_UNDERFLOW( pxLink->xBlockSize, xHeapStructSize ) == 0 )
|
||||
{
|
||||
( void ) memset( puc + xHeapStructSize, 0, pxLink->xBlockSize - xHeapStructSize );
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
/* Add this block to the list of free blocks. */
|
||||
xFreeBytesRemaining += pxLink->xBlockSize;
|
||||
traceFREE( pv, pxLink->xBlockSize );
|
||||
prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );
|
||||
xNumberOfSuccessfulFrees++;
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
size_t xPortGetFreeHeapSize( void )
|
||||
{
|
||||
return xFreeBytesRemaining;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
size_t xPortGetMinimumEverFreeHeapSize( void )
|
||||
{
|
||||
return xMinimumEverFreeBytesRemaining;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void xPortResetHeapMinimumEverFreeHeapSize( void )
|
||||
{
|
||||
xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void * pvPortCalloc( size_t xNum,
|
||||
size_t xSize )
|
||||
{
|
||||
void * pv = NULL;
|
||||
|
||||
if( heapMULTIPLY_WILL_OVERFLOW( xNum, xSize ) == 0 )
|
||||
{
|
||||
pv = pvPortMalloc( xNum * xSize );
|
||||
|
||||
if( pv != NULL )
|
||||
{
|
||||
( void ) memset( pv, 0, xNum * xSize );
|
||||
}
|
||||
}
|
||||
|
||||
return pv;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void prvInsertBlockIntoFreeList( BlockLink_t * pxBlockToInsert ) /* PRIVILEGED_FUNCTION */
|
||||
{
|
||||
BlockLink_t * pxIterator;
|
||||
uint8_t * puc;
|
||||
|
||||
/* Iterate through the list until a block is found that has a higher address
|
||||
* than the block being inserted. */
|
||||
for( pxIterator = &xStart; heapPROTECT_BLOCK_POINTER( pxIterator->pxNextFreeBlock ) < pxBlockToInsert; pxIterator = heapPROTECT_BLOCK_POINTER( pxIterator->pxNextFreeBlock ) )
|
||||
{
|
||||
/* Nothing to do here, just iterate to the right position. */
|
||||
}
|
||||
|
||||
if( pxIterator != &xStart )
|
||||
{
|
||||
heapVALIDATE_BLOCK_POINTER( pxIterator );
|
||||
}
|
||||
|
||||
/* Do the block being inserted, and the block it is being inserted after
|
||||
* make a contiguous block of memory? */
|
||||
puc = ( uint8_t * ) pxIterator;
|
||||
|
||||
if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )
|
||||
{
|
||||
pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;
|
||||
pxBlockToInsert = pxIterator;
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
|
||||
/* Do the block being inserted, and the block it is being inserted before
|
||||
* make a contiguous block of memory? */
|
||||
puc = ( uint8_t * ) pxBlockToInsert;
|
||||
|
||||
if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) heapPROTECT_BLOCK_POINTER( pxIterator->pxNextFreeBlock ) )
|
||||
{
|
||||
if( heapPROTECT_BLOCK_POINTER( pxIterator->pxNextFreeBlock ) != pxEnd )
|
||||
{
|
||||
/* Form one big block from the two blocks. */
|
||||
pxBlockToInsert->xBlockSize += heapPROTECT_BLOCK_POINTER( pxIterator->pxNextFreeBlock )->xBlockSize;
|
||||
pxBlockToInsert->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( pxIterator->pxNextFreeBlock )->pxNextFreeBlock;
|
||||
}
|
||||
else
|
||||
{
|
||||
pxBlockToInsert->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( pxEnd );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;
|
||||
}
|
||||
|
||||
/* If the block being inserted plugged a gap, so was merged with the block
|
||||
* before and the block after, then it's pxNextFreeBlock pointer will have
|
||||
* already been set, and should not be set here as that would make it point
|
||||
* to itself. */
|
||||
if( pxIterator != pxBlockToInsert )
|
||||
{
|
||||
pxIterator->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( pxBlockToInsert );
|
||||
}
|
||||
else
|
||||
{
|
||||
mtCOVERAGE_TEST_MARKER();
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortDefineHeapRegions( const HeapRegion_t * const pxHeapRegions ) /* PRIVILEGED_FUNCTION */
|
||||
{
|
||||
BlockLink_t * pxFirstFreeBlockInRegion = NULL;
|
||||
BlockLink_t * pxPreviousFreeBlock;
|
||||
portPOINTER_SIZE_TYPE xAlignedHeap;
|
||||
size_t xTotalRegionSize, xTotalHeapSize = 0;
|
||||
BaseType_t xDefinedRegions = 0;
|
||||
portPOINTER_SIZE_TYPE xAddress;
|
||||
const HeapRegion_t * pxHeapRegion;
|
||||
|
||||
/* Can only call once! */
|
||||
configASSERT( pxEnd == NULL );
|
||||
|
||||
#if ( configENABLE_HEAP_PROTECTOR == 1 )
|
||||
{
|
||||
vApplicationGetRandomHeapCanary( &( xHeapCanary ) );
|
||||
}
|
||||
#endif
|
||||
|
||||
pxHeapRegion = &( pxHeapRegions[ xDefinedRegions ] );
|
||||
|
||||
while( pxHeapRegion->xSizeInBytes > 0 )
|
||||
{
|
||||
xTotalRegionSize = pxHeapRegion->xSizeInBytes;
|
||||
|
||||
/* Ensure the heap region starts on a correctly aligned boundary. */
|
||||
xAddress = ( portPOINTER_SIZE_TYPE ) pxHeapRegion->pucStartAddress;
|
||||
|
||||
if( ( xAddress & portBYTE_ALIGNMENT_MASK ) != 0 )
|
||||
{
|
||||
xAddress += ( portBYTE_ALIGNMENT - 1 );
|
||||
xAddress &= ~( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK;
|
||||
|
||||
/* Adjust the size for the bytes lost to alignment. */
|
||||
xTotalRegionSize -= ( size_t ) ( xAddress - ( portPOINTER_SIZE_TYPE ) pxHeapRegion->pucStartAddress );
|
||||
}
|
||||
|
||||
xAlignedHeap = xAddress;
|
||||
|
||||
/* Set xStart if it has not already been set. */
|
||||
if( xDefinedRegions == 0 )
|
||||
{
|
||||
/* xStart is used to hold a pointer to the first item in the list of
|
||||
* free blocks. The void cast is used to prevent compiler warnings. */
|
||||
xStart.pxNextFreeBlock = ( BlockLink_t * ) heapPROTECT_BLOCK_POINTER( xAlignedHeap );
|
||||
xStart.xBlockSize = ( size_t ) 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Should only get here if one region has already been added to the
|
||||
* heap. */
|
||||
configASSERT( pxEnd != heapPROTECT_BLOCK_POINTER( NULL ) );
|
||||
|
||||
/* Check blocks are passed in with increasing start addresses. */
|
||||
configASSERT( ( size_t ) xAddress > ( size_t ) pxEnd );
|
||||
}
|
||||
|
||||
#if ( configENABLE_HEAP_PROTECTOR == 1 )
|
||||
{
|
||||
if( ( pucHeapLowAddress == NULL ) ||
|
||||
( ( uint8_t * ) xAlignedHeap < pucHeapLowAddress ) )
|
||||
{
|
||||
pucHeapLowAddress = ( uint8_t * ) xAlignedHeap;
|
||||
}
|
||||
}
|
||||
#endif /* configENABLE_HEAP_PROTECTOR */
|
||||
|
||||
/* Remember the location of the end marker in the previous region, if
|
||||
* any. */
|
||||
pxPreviousFreeBlock = pxEnd;
|
||||
|
||||
/* pxEnd is used to mark the end of the list of free blocks and is
|
||||
* inserted at the end of the region space. */
|
||||
xAddress = xAlignedHeap + ( portPOINTER_SIZE_TYPE ) xTotalRegionSize;
|
||||
xAddress -= ( portPOINTER_SIZE_TYPE ) xHeapStructSize;
|
||||
xAddress &= ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK );
|
||||
pxEnd = ( BlockLink_t * ) xAddress;
|
||||
pxEnd->xBlockSize = 0;
|
||||
pxEnd->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( NULL );
|
||||
|
||||
/* To start with there is a single free block in this region that is
|
||||
* sized to take up the entire heap region minus the space taken by the
|
||||
* free block structure. */
|
||||
pxFirstFreeBlockInRegion = ( BlockLink_t * ) xAlignedHeap;
|
||||
pxFirstFreeBlockInRegion->xBlockSize = ( size_t ) ( xAddress - ( portPOINTER_SIZE_TYPE ) pxFirstFreeBlockInRegion );
|
||||
pxFirstFreeBlockInRegion->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( pxEnd );
|
||||
|
||||
/* If this is not the first region that makes up the entire heap space
|
||||
* then link the previous region to this region. */
|
||||
if( pxPreviousFreeBlock != NULL )
|
||||
{
|
||||
pxPreviousFreeBlock->pxNextFreeBlock = heapPROTECT_BLOCK_POINTER( pxFirstFreeBlockInRegion );
|
||||
}
|
||||
|
||||
xTotalHeapSize += pxFirstFreeBlockInRegion->xBlockSize;
|
||||
|
||||
#if ( configENABLE_HEAP_PROTECTOR == 1 )
|
||||
{
|
||||
if( ( pucHeapHighAddress == NULL ) ||
|
||||
( ( ( ( uint8_t * ) pxFirstFreeBlockInRegion ) + pxFirstFreeBlockInRegion->xBlockSize ) > pucHeapHighAddress ) )
|
||||
{
|
||||
pucHeapHighAddress = ( ( uint8_t * ) pxFirstFreeBlockInRegion ) + pxFirstFreeBlockInRegion->xBlockSize;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Move onto the next HeapRegion_t structure. */
|
||||
xDefinedRegions++;
|
||||
pxHeapRegion = &( pxHeapRegions[ xDefinedRegions ] );
|
||||
}
|
||||
|
||||
xMinimumEverFreeBytesRemaining = xTotalHeapSize;
|
||||
xFreeBytesRemaining = xTotalHeapSize;
|
||||
|
||||
/* Check something was actually defined before it is accessed. */
|
||||
configASSERT( xTotalHeapSize );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void vPortGetHeapStats( HeapStats_t * pxHeapStats )
|
||||
{
|
||||
BlockLink_t * pxBlock;
|
||||
size_t xBlocks = 0, xMaxSize = 0, xMinSize = SIZE_MAX;
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
pxBlock = heapPROTECT_BLOCK_POINTER( xStart.pxNextFreeBlock );
|
||||
|
||||
/* pxBlock will be NULL if the heap has not been initialised. The heap
|
||||
* is initialised automatically when the first allocation is made. */
|
||||
if( pxBlock != NULL )
|
||||
{
|
||||
while( pxBlock != pxEnd )
|
||||
{
|
||||
/* Increment the number of blocks and record the largest block seen
|
||||
* so far. */
|
||||
xBlocks++;
|
||||
|
||||
if( pxBlock->xBlockSize > xMaxSize )
|
||||
{
|
||||
xMaxSize = pxBlock->xBlockSize;
|
||||
}
|
||||
|
||||
/* Heap five will have a zero sized block at the end of each
|
||||
* each region - the block is only used to link to the next
|
||||
* heap region so it not a real block. */
|
||||
if( pxBlock->xBlockSize != 0 )
|
||||
{
|
||||
if( pxBlock->xBlockSize < xMinSize )
|
||||
{
|
||||
xMinSize = pxBlock->xBlockSize;
|
||||
}
|
||||
}
|
||||
|
||||
/* Move to the next block in the chain until the last block is
|
||||
* reached. */
|
||||
pxBlock = heapPROTECT_BLOCK_POINTER( pxBlock->pxNextFreeBlock );
|
||||
}
|
||||
}
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
|
||||
pxHeapStats->xSizeOfLargestFreeBlockInBytes = xMaxSize;
|
||||
pxHeapStats->xSizeOfSmallestFreeBlockInBytes = xMinSize;
|
||||
pxHeapStats->xNumberOfFreeBlocks = xBlocks;
|
||||
|
||||
taskENTER_CRITICAL();
|
||||
{
|
||||
pxHeapStats->xAvailableHeapSpaceInBytes = xFreeBytesRemaining;
|
||||
pxHeapStats->xNumberOfSuccessfulAllocations = xNumberOfSuccessfulAllocations;
|
||||
pxHeapStats->xNumberOfSuccessfulFrees = xNumberOfSuccessfulFrees;
|
||||
pxHeapStats->xMinimumEverFreeBytesRemaining = xMinimumEverFreeBytesRemaining;
|
||||
}
|
||||
taskEXIT_CRITICAL();
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Reset the state in this file. This state is normally initialized at start up.
|
||||
* This function must be called by the application before restarting the
|
||||
* scheduler.
|
||||
*/
|
||||
void vPortHeapResetState( void )
|
||||
{
|
||||
pxEnd = NULL;
|
||||
|
||||
xFreeBytesRemaining = ( size_t ) 0U;
|
||||
xMinimumEverFreeBytesRemaining = ( size_t ) 0U;
|
||||
xNumberOfSuccessfulAllocations = ( size_t ) 0U;
|
||||
xNumberOfSuccessfulFrees = ( size_t ) 0U;
|
||||
|
||||
#if ( configENABLE_HEAP_PROTECTOR == 1 )
|
||||
pucHeapHighAddress = NULL;
|
||||
pucHeapLowAddress = NULL;
|
||||
#endif /* #if ( configENABLE_HEAP_PROTECTOR == 1 ) */
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
@@ -0,0 +1,19 @@
|
||||
Each real time kernel port consists of three files that contain the core kernel
|
||||
components and are common to every port, and one or more files that are
|
||||
specific to a particular microcontroller and/or compiler.
|
||||
|
||||
|
||||
+ The FreeRTOS/Source/Portable/MemMang directory contains the five sample
|
||||
memory allocators as described on the https://www.FreeRTOS.org WEB site.
|
||||
|
||||
+ The other directories each contain files specific to a particular
|
||||
microcontroller or compiler, where the directory name denotes the compiler
|
||||
specific files the directory contains.
|
||||
|
||||
|
||||
|
||||
For example, if you are interested in the [compiler] port for the [architecture]
|
||||
microcontroller, then the port specific files are contained in
|
||||
FreeRTOS/Source/Portable/[compiler]/[architecture] directory. If this is the
|
||||
only port you are interested in then all the other directories can be
|
||||
ignored.
|
||||
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,188 @@
|
||||
|
||||
cmake_minimum_required(VERSION 3.21)
|
||||
cmake_policy(SET CMP0048 NEW) # project version
|
||||
cmake_policy(SET CMP0076 NEW) # full paths
|
||||
|
||||
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/cmake_modules")
|
||||
|
||||
########################################################################
|
||||
# Project Details
|
||||
project(FreeRTOS-Plus-TCP
|
||||
VERSION 3.1.0
|
||||
DESCRIPTION "FreeRTOS TCP/UDP Network Layer"
|
||||
HOMEPAGE_URL https://freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/index.html
|
||||
LANGUAGES C)
|
||||
|
||||
# Do not allow in-source build.
|
||||
if( ${PROJECT_SOURCE_DIR} STREQUAL ${PROJECT_BINARY_DIR} )
|
||||
message( FATAL_ERROR "In-source build is not allowed. Please build in a separate directory, such as ${PROJECT_SOURCE_DIR}/build." )
|
||||
endif()
|
||||
|
||||
# Options
|
||||
option(FREERTOS_PLUS_TCP_BUILD_TEST "Build the test for FreeRTOS Plus TCP" OFF)
|
||||
option(FREERTOS_PLUS_TCP_ENABLE_BUILD_CHECKS "Enable the build checks for FreeRTOS-Plus-TCP" OFF)
|
||||
|
||||
# Configuration
|
||||
# Override these at project level with:
|
||||
# Optional: set(FREERTOS_PLUS_TCP_BUFFER_ALLOCATION "1" CACHE STRING "" FORCE)
|
||||
# Optional: set(FREERTOS_PLUS_TCP_COMPILER "" CACHE STRING "" FORCE)
|
||||
# Required: set(FREERTOS_PLUS_TCP_NETWORK_IF "POSIX" CACHE STRING "" FORCE)
|
||||
|
||||
# Select the appropriate buffer allocation method.
|
||||
# See: https://freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/Embedded_Ethernet_Buffer_Management.html
|
||||
if (NOT FREERTOS_PLUS_TCP_BUFFER_ALLOCATION)
|
||||
message(STATUS "Using default FREERTOS_PLUS_TCP_BUFFER_ALLOCATION = 2")
|
||||
set(FREERTOS_PLUS_TCP_BUFFER_ALLOCATION "2" CACHE STRING "FreeRTOS buffer allocation model number. 1 .. 2.")
|
||||
endif()
|
||||
|
||||
# Select the Compiler - if left blank will detect using CMake
|
||||
# Note relies on CMake to detect over any setting here.
|
||||
# Valid options are:
|
||||
# FREERTOS_PLUS_TCP_COMPILER | Detected | CMake
|
||||
# -------------------------------------------------
|
||||
# CCS | No | ?TBD?
|
||||
# GCC | Yes | GNU
|
||||
# IAR | Yes | IAR
|
||||
# Keil | Yes | ARMCC
|
||||
# MSVC | Yes | MSVC # Note only for MinGW
|
||||
# Renesas | No | ?TBD?
|
||||
# Will always a attempt to detect and if detectable double checks that the compiler is set correctly.
|
||||
set(FREERTOS_PLUS_TCP_COMPILER "" CACHE STRING "FreeRTOS Plus TCP Compiler Selection")
|
||||
|
||||
|
||||
# Select the appropriate network interface
|
||||
# This will fail the CMake preparation step if not set to one of those values.
|
||||
set(FREERTOS_PLUS_TCP_NETWORK_IF "" CACHE STRING "FreeRTOS Plus TCP Network Interface selection")
|
||||
set(FREERTOS_PLUS_TCP_NETWORK_IF_LIST
|
||||
A_CUSTOM_NETWORK_IF
|
||||
ATSAM43 ATSAME5x # AT
|
||||
DRIVER_SAM
|
||||
ESP32
|
||||
KSZ8851SNL
|
||||
LIBSLIRP
|
||||
LOOPBACK
|
||||
LPC17xx LPC18xx LPC54018
|
||||
M487
|
||||
MPS2_AN385
|
||||
MPS3_AN552
|
||||
MW300_RD
|
||||
NXP1060
|
||||
PIC32MZEF_ETH PIC32MZEF_WIFI
|
||||
POSIX WIN_PCAP # Native Linux & Windows respectively
|
||||
RX
|
||||
SH2A
|
||||
STM32 # ST Micro
|
||||
MSP432
|
||||
TM4C
|
||||
XILINX_ULTRASCALE ZYNQ # AMD/Xilinx
|
||||
)
|
||||
|
||||
if(NOT FREERTOS_PLUS_TCP_NETWORK_IF)
|
||||
# Attempt to detect the system.
|
||||
if(UNIX)
|
||||
message(STATUS "Detected UNIX/Posix system setting FREERTOS_PLUS_TCP_NETWORK_IF = POSIX")
|
||||
set(FREERTOS_PLUS_TCP_NETWORK_IF POSIX)
|
||||
elseif(MINGW)
|
||||
message(STATUS "Detected Windows MinGW system setting FREERTOS_PLUS_TCP_NETWORK_IF = WIN_PCAP")
|
||||
set(FREERTOS_PLUS_TCP_NETWORK_IF WIN_PCAP)
|
||||
endif()
|
||||
endif()
|
||||
|
||||
if(NOT FREERTOS_PLUS_TCP_NETWORK_IF IN_LIST FREERTOS_PLUS_TCP_NETWORK_IF_LIST )
|
||||
message(FATAL_ERROR " FREERTOS_PLUS_TCP_NETWORK_IF is '${FREERTOS_PLUS_TCP_NETWORK_IF}'.\n"
|
||||
" Please specify it from top-level CMake file (example):\n"
|
||||
" set(FREERTOS_PLUS_TCP_NETWORK_IF POSIX CACHE STRING \"\")\n"
|
||||
" or from CMake command line option:\n"
|
||||
" -DFREERTOS_PLUS_TCP_NETWORK_IF=POSIX\n"
|
||||
" \n"
|
||||
" Available port options: (Tested means compiled with that variant)\n"
|
||||
" A_CUSTOM_NETWORK_IF Target: User Defined\n"
|
||||
" ATSAM4E Target: ATSAM4E Tested: TODO\n"
|
||||
" ATSAME5x Target: ATSAME5x Tested: TODO\n"
|
||||
" DRIVER_SAM Target: Driver SAM Tested: TODO\n"
|
||||
" ESP32 Target: ESP-32 Tested: TODO\n"
|
||||
" KSZ8851SNL Target: ksz8851snl Tested: TODO\n"
|
||||
" LIBSLIRP Target: libslirp Tested: TODO\n"
|
||||
" POSIX Target: linux/Posix\n"
|
||||
" LOOPBACK Target: loopback Tested: TODO\n"
|
||||
" LPC17xx Target: LPC17xx Tested: TODO\n"
|
||||
" LPC18xx Target: LPC18xx Tested: TODO\n"
|
||||
" LPC54018 Target: LPC54018 Tested: TODO\n"
|
||||
" M487 Target: M487 Tested: TODO\n"
|
||||
" MPS2_AN385 Target: MPS2_AN385 Tested: TODO\n"
|
||||
" MPS3_AN552 Target: MPS3_AN552"
|
||||
" MW300_RD Target: mw300_rd Tested: TODO\n"
|
||||
" NXP1060 Target: NXP1060 Tested: TODO\n"
|
||||
" PIC32MZEF_ETH Target: pic32mzef ethernet Tested: TODO\n"
|
||||
" PIC32MZEF_WIFI Target: pic32mzef Wifi Tested: TODO\n"
|
||||
" RX Target: RX Tested: TODO\n"
|
||||
" SH2A Target: SH2A Tested: TODO\n"
|
||||
" STM32 Target: STM32 Tested: TODO\n"
|
||||
" MSP432 Target: MSP432 Tested: TODO\n"
|
||||
" TM4C Target: TM4C Tested: TODO\n"
|
||||
" WIN_PCAP Target: Windows Tested: TODO\n"
|
||||
" XILINX_ULTRASCALE Target: Xilinx Ultrascale Tested: TODO\n"
|
||||
" ZYNQ Target: Xilinx Zynq")
|
||||
elseif((FREERTOS_PORT STREQUAL "A_CUSTOM_PORT") AND (NOT TARGET freertos_kernel_port) )
|
||||
message(FATAL_ERROR " FREERTOS_PLUS_TCP_NETWORK_IF is set to A_CUSTOM_NETWORK_IF.\n"
|
||||
" Please specify the custom network interface target with all necessary files.\n"
|
||||
" For example, assuming a directory of:\n"
|
||||
" FreeRTOSCustomNetworkInterface/\n"
|
||||
" CMakeLists.txt\n"
|
||||
" NetworkInterface.c\n\n"
|
||||
" Where FreeRTOSCustomNetworkInterface/CMakeLists.txt is a modified version of:\n"
|
||||
" add_library(freertos_plus_tcp_network_if STATIC)\n\n"
|
||||
" target_sources(freertos_plus_tcp_network_if\n"
|
||||
" PRIVATE\n"
|
||||
" NetworkInterface.c)\n\n"
|
||||
" target_include_directories(freertos_plus_tcp_network_if\n"
|
||||
" PUBLIC\n"
|
||||
" .)\n\n"
|
||||
" target_link_libraries(freertos_plus_tcp_network_if\n"
|
||||
" PUBLIC\n"
|
||||
" freertos_plus_tcp_port\n"
|
||||
" freertos_plus_tcp_network_if_common\n"
|
||||
" PRIVATE\n"
|
||||
" freertos_kernel)")
|
||||
endif()
|
||||
|
||||
# There is also the need to add a target - typically an interface library that describes the
|
||||
# Configuration for FreeRTOS-Kernel and FreeRTOS-Plus-TCP.
|
||||
# This is called freertos_config
|
||||
|
||||
########################################################################
|
||||
# External Dependencies
|
||||
# Note: For backwards compatibility - still have .gitmodules defining submodules
|
||||
# To support fetching content in a higher level project see
|
||||
# README.md `Consume with CMake`
|
||||
# This will allow you to upgrade submodules and have one common submodule for
|
||||
# all your builds despite multiple submodules having different versions.
|
||||
include(FetchContent)
|
||||
|
||||
FetchContent_Declare( freertos_kernel
|
||||
GIT_REPOSITORY https://github.com/FreeRTOS/FreeRTOS-Kernel.git
|
||||
GIT_TAG main
|
||||
)
|
||||
|
||||
FetchContent_Declare( cmock
|
||||
GIT_REPOSITORY https://github.com/ThrowTheSwitch/CMock
|
||||
GIT_TAG v2.5.3
|
||||
)
|
||||
|
||||
add_subdirectory(source)
|
||||
add_subdirectory(tools)
|
||||
if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/test")
|
||||
add_subdirectory(test)
|
||||
endif()
|
||||
|
||||
if(STANDALONE_TEST_BUILD_UNIX)
|
||||
add_library(freertos_config INTERFACE)
|
||||
target_include_directories(freertos_config INTERFACE
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/test/build-combination/Common
|
||||
)
|
||||
set(FREERTOS_PORT GCC_POSIX CACHE STRING "")
|
||||
endif()
|
||||
|
||||
if(PROJECT_IS_TOP_LEVEL)
|
||||
FetchContent_MakeAvailable(freertos_kernel cmock)
|
||||
endif()
|
||||
+239
@@ -0,0 +1,239 @@
|
||||
#!/usr/bin/env python3
|
||||
|
||||
# Prerequisits: Python 3.7 or greater.
|
||||
#
|
||||
# To run this script, go to the root of the FreeRTOS+TCP directory; that is the
|
||||
# directory in which this script is present. And then invoke it with:
|
||||
# `python3 your/path/to/GenerateOriginalFiles.py`
|
||||
#
|
||||
# After running this script, you will have 9 source files in the root directory
|
||||
# and two additional folders namely `include` and `portable``.
|
||||
|
||||
|
||||
# Import the shutil library to aid in copying of files and folders to different
|
||||
# location.
|
||||
import os
|
||||
import shutil
|
||||
import sys
|
||||
|
||||
# FreeRTOS Kernel includes. DO NOT change the order in the list.
|
||||
FreeRTOS_Kernel_Includes = [ 'FreeRTOS.h',
|
||||
'task.h',
|
||||
'queue.h',
|
||||
'semphr.h',
|
||||
'list.h',
|
||||
'event_groups.h',
|
||||
'timers.h' ]
|
||||
|
||||
# FreeRTOS+TCP include files. DO NOT change the order in the list.
|
||||
FreeRTOS_TCP_Includes = [ 'FreeRTOS_IP.h',
|
||||
'FreeRTOSIPConfigDefaults.h',
|
||||
'FreeRTOS_IP_Private.h',
|
||||
'FreeRTOS_IP_Utils.h',
|
||||
'FreeRTOS_IP_Timers.h',
|
||||
'FreeRTOS_ARP.h',
|
||||
'FreeRTOS_DHCP.h',
|
||||
'FreeRTOS_DNS.h',
|
||||
'FreeRTOS_DNS_Cache.h',
|
||||
'FreeRTOS_DNS_Callback.h',
|
||||
'FreeRTOS_DNS_Globals.h',
|
||||
'FreeRTOS_DNS_Networking.h',
|
||||
'FreeRTOS_DNS_Parser.h',
|
||||
'FreeRTOS_ICMP.h',
|
||||
'FreeRTOS_Sockets.h',
|
||||
'FreeRTOS_Stream_Buffer.h',
|
||||
'FreeRTOS_TCP_IP.h',
|
||||
'FreeRTOS_TCP_Reception.h',
|
||||
'FreeRTOS_TCP_State_Handling.h',
|
||||
'FreeRTOS_TCP_Transmission.h',
|
||||
'FreeRTOS_TCP_Utils.h',
|
||||
'FreeRTOS_TCP_WIN.h',
|
||||
'FreeRTOS_UDP_IP.h',
|
||||
'FreeRTOS_errno_TCP.h',
|
||||
'IPTraceMacroDefaults.h',
|
||||
'NetworkInterface.h',
|
||||
'NetworkBufferManagement.h' ]
|
||||
|
||||
# A dictionary to hold the modules to combine and the destination.
|
||||
MODULES_DICT = dict()
|
||||
|
||||
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_ARP.c
|
||||
ARP_modules_to_combine = [ 'source/FreeRTOS_ARP.c' ]
|
||||
|
||||
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_DHCP.c
|
||||
DHCP_modules_to_combine = [ 'source/FreeRTOS_DHCP.c' ]
|
||||
|
||||
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_DNS.c
|
||||
DNS_modules_to_combine = [ 'source/FreeRTOS_DNS.c',
|
||||
'source/FreeRTOS_DNS_Cache.c',
|
||||
'source/FreeRTOS_DNS_Callback.c',
|
||||
'source/FreeRTOS_DNS_Networking.c',
|
||||
'source/FreeRTOS_DNS_Parser.c' ]
|
||||
|
||||
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_IP.c
|
||||
IP_modules_to_combine = [ 'source/FreeRTOS_ICMP.c',
|
||||
'source/FreeRTOS_IP.c',
|
||||
'source/FreeRTOS_IP_Timers.c',
|
||||
'source/FreeRTOS_IP_Utils.c' ]
|
||||
|
||||
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_Sockets.c
|
||||
Socket_modules_to_combine = [ 'source/FreeRTOS_Sockets.c' ]
|
||||
|
||||
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_Stream_Buffer.c
|
||||
StreamBuffer_modules_to_combine = [ 'source/FreeRTOS_Stream_Buffer.c' ]
|
||||
|
||||
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_TCP_IP.c
|
||||
TCP_modules_to_combine = [ 'source/FreeRTOS_TCP_IP.c',
|
||||
'source/FreeRTOS_TCP_Reception.c',
|
||||
'source/FreeRTOS_TCP_State_Handling.c',
|
||||
'source/FreeRTOS_TCP_Transmission.c',
|
||||
'source/FreeRTOS_TCP_Utils.c' ]
|
||||
|
||||
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_TCP_WIN.c
|
||||
TCP_WIN_modules_to_combine = [ 'source/FreeRTOS_TCP_WIN.c',
|
||||
'source/FreeRTOS_Tiny_TCP.c' ]
|
||||
|
||||
# DO NOT MODIFY. The modules to combine to make up the original FreeRTOS_UDP_IP.c
|
||||
UDP_modules_to_combine = [ 'source/FreeRTOS_UDP_IP.c' ]
|
||||
|
||||
# Add all the modules and the destinations to the dictionary.
|
||||
MODULES_DICT['FreeRTOS_ARP.c'] = ARP_modules_to_combine
|
||||
MODULES_DICT['FreeRTOS_DHCP.c'] = DHCP_modules_to_combine
|
||||
MODULES_DICT['FreeRTOS_DNS.c'] = DNS_modules_to_combine
|
||||
MODULES_DICT['FreeRTOS_IP.c'] = IP_modules_to_combine
|
||||
MODULES_DICT['FreeRTOS_Sockets.c'] = Socket_modules_to_combine
|
||||
MODULES_DICT['FreeRTOS_Stream_Buffer.c'] = StreamBuffer_modules_to_combine
|
||||
MODULES_DICT['FreeRTOS_TCP_IP.c'] = TCP_modules_to_combine
|
||||
MODULES_DICT['FreeRTOS_TCP_WIN.c'] = TCP_WIN_modules_to_combine
|
||||
MODULES_DICT['FreeRTOS_UDP_IP.c'] = UDP_modules_to_combine
|
||||
|
||||
# Sorting function used to add Kernel includes. This is required as the includes
|
||||
# need to adhere to a specific order of inclusion.
|
||||
def KernelSortingFunction(element):
|
||||
return FreeRTOS_Kernel_Includes.index(element)
|
||||
|
||||
# Sorting function used to add FreeRTOS+TCP includes. This is required as the includes
|
||||
# need to adhere to a specific order of inclusion.
|
||||
def TCPSortingFunction(element):
|
||||
return FreeRTOS_TCP_Includes.index(element)
|
||||
|
||||
# Get all the includes in all the modules to combine first. This function does
|
||||
# remove the duplicates but does not sort the includes in any specific order.
|
||||
def GetIncludeList(ModulesToCombine):
|
||||
# This list is used for the FreeRTOS+TCP include files.
|
||||
TCP_include_list = list()
|
||||
# This list is used for FreeRTOS Kernel include files.
|
||||
Kernel_include_list = list()
|
||||
# This list is used for standard library include files.
|
||||
StdLib_include_list = list()
|
||||
|
||||
for filename in ModulesToCombine:
|
||||
f = open(filename, "r")
|
||||
for line in f.readlines():
|
||||
if line.lstrip().startswith('#include '):
|
||||
if '<' in line:
|
||||
#if this is a standard library include
|
||||
start_token = '<'
|
||||
end_token = '>'
|
||||
header = line.split(start_token)[1].split(end_token)[0]
|
||||
StdLib_include_list.append(header)
|
||||
else:
|
||||
start_token = '"'
|
||||
end_token = '"'
|
||||
header = line.split(start_token)[1]
|
||||
|
||||
if header in FreeRTOS_TCP_Includes:
|
||||
TCP_include_list.append(header)
|
||||
elif header in FreeRTOS_Kernel_Includes:
|
||||
Kernel_include_list.append(header)
|
||||
else:
|
||||
print("ERROR: Found " + header + " which is not in any list!")
|
||||
f.close()
|
||||
return list(set(StdLib_include_list)), list(set(Kernel_include_list)), list(set(TCP_include_list))
|
||||
|
||||
# Write the includes in a specific order to the destination file.
|
||||
def AddIncludesInFile(modules_to_combine, file_descriptor):
|
||||
StdLib_include_list_unique, Kernel_include_list_unique, TCP_include_list_unique = GetIncludeList(modules_to_combine)
|
||||
|
||||
for include in StdLib_include_list_unique:
|
||||
file_descriptor.write(f'#include <{include}>\n')
|
||||
|
||||
# Sort the Kernel includes in a specific order using KernelSortingFunction.
|
||||
Kernel_include_list_unique.sort(key=KernelSortingFunction)
|
||||
for include in Kernel_include_list_unique:
|
||||
file_descriptor.write(f'#include "{include}"\n')
|
||||
|
||||
# Sort the TCP includes in a specific order using TCPSortingFunction.
|
||||
TCP_include_list_unique.sort(key=TCPSortingFunction)
|
||||
for include in TCP_include_list_unique:
|
||||
file_descriptor.write(f'#include "{include}"\n')
|
||||
|
||||
# Function to add the copyright notice to the destination file.
|
||||
def AddCopyRightNotice(CopyRightNotice, file_descriptor):
|
||||
for line in CopyRightNotice:
|
||||
file_descriptor.write(f'{line}')
|
||||
|
||||
# Function to generate the original modules by adding the copyright notice,
|
||||
# includes and source to the destination modules.
|
||||
def GenerateOriginalModules():
|
||||
# Flag to note the first iteration.
|
||||
FirstIteration = True
|
||||
# Create a list to hold the multi-line copyright notice.
|
||||
CopyRightNotice = list()
|
||||
|
||||
for module in MODULES_DICT:
|
||||
# Store the copyright notice for future use.
|
||||
if FirstIteration:
|
||||
FirstIteration = False
|
||||
# Open the first module. All modules have copyright notices in them.
|
||||
with open(MODULES_DICT[module][0]) as f:
|
||||
for line in f.readlines():
|
||||
CopyRightNotice.append(line)
|
||||
|
||||
if '*/' in line:
|
||||
# Found the end of commented copyright notice. Break out
|
||||
# of the loop.
|
||||
break
|
||||
f.close()
|
||||
|
||||
# Combine modules only if they were split into multiple ones.
|
||||
if len(MODULES_DICT[module]) != 1:
|
||||
with open(module, 'w') as file_to_write:
|
||||
# Add the copyright notice to the destination module.
|
||||
AddCopyRightNotice(CopyRightNotice, file_to_write)
|
||||
|
||||
# Add the include files in the destination module.
|
||||
AddIncludesInFile(MODULES_DICT[module], file_to_write)
|
||||
|
||||
# Add the source from all the modules into the destination
|
||||
# module.
|
||||
for filename in MODULES_DICT[module]:
|
||||
ready_to_write = False
|
||||
with open(filename, "r") as f:
|
||||
for line in f.readlines():
|
||||
if ready_to_write:
|
||||
file_to_write.write(f'{line}')
|
||||
elif not line.lstrip().startswith('#include') and not line.lstrip().startswith(('*', '/*', '*/')):
|
||||
file_to_write.write(f'{line}')
|
||||
ready_to_write = True
|
||||
f.close()
|
||||
file_to_write.close()
|
||||
# Some modules are intact and there is no need to combine.
|
||||
# Just copy them to the root directory.
|
||||
else:
|
||||
shutil.copy2(MODULES_DICT[module][0] ,module)
|
||||
|
||||
# Function to copy the portable and include directories into the root of the
|
||||
# folder.
|
||||
def CopyIncludeAndPortableDirs():
|
||||
# Copy the include directory to the root of the folder.
|
||||
shutil.copytree('source/include', 'include')
|
||||
# Copy the portable directory to the root of the folder.
|
||||
shutil.copytree('source/portable', 'portable')
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Change the working directory to the root of repository.
|
||||
os.chdir(os.path.dirname(sys.argv[0]))
|
||||
|
||||
GenerateOriginalModules()
|
||||
CopyIncludeAndPortableDirs()
|
||||
@@ -0,0 +1,75 @@
|
||||
Moving to version 4.0.0 and later from 3.x.x:
|
||||
--------------------------------
|
||||
|
||||
Version 4.0.0 and later adds new files to support IPv6 functionality, breaking each file into logically separated IPv4 and IPv6 files. The folder structure of FreeRTOS-Plus-TCP remains unchanged. Build separation is added to make the library modular, enabling users to compile and create a low-footprint binary with only the required functionalities. For more details on supported build combinations, see [History.txt](https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/History.txt) .
|
||||
|
||||
Some of the APIs have changed which is illustrated in the section below. However, there is a backward compatibility mode provided as well.
|
||||
|
||||
Backward Compatibility Mode:
|
||||
---------------------------
|
||||
If you are moving your code from version 3.x.x to version 4.0.0 and later, then set the "ipconfigIPv4_BACKWARD_COMPATIBLE" macro to 1 in “FreeRTOSIPConfigDefaults.h” to run the code in backward compatible mode.
|
||||
The "Existing API's" defined in all the API changes below work only when the backward compatibility mode is enabled.
|
||||
|
||||
API changes in version 4.0.0 and later:
|
||||
----------------------
|
||||
|
||||
The changes mentioned below uses ipconfigIPv4_BACKWARD_COMPATIBLE flag to differentiate between old API and new API.
|
||||
|
||||
Change 1:
|
||||
|
||||
- Existing API: FreeRTOS_IPInit
|
||||
- Backward compatibility with the IPv4 FreeRTOS+TCP V3.x.x which only supports single network interface. This can be used for single interface IPv4 systems.
|
||||
- New API: FreeRTOS_IPInit_Multi
|
||||
- Supports multiple interfaces. Before calling this function, at least 1 interface and 1 end-point must have been set-up. FreeRTOS_IPInit_Multi() replaces the earlier FreeRTOS_IPInit().
|
||||
|
||||
Change 2:
|
||||
|
||||
- Existing API: FreeRTOS_GetAddressConfiguration/FreeRTOS_SetAddressConfiguration
|
||||
- Get/Set the address configuration from the global variables initialised during FreeRTOS_IPInit
|
||||
- New API: FreeRTOS_GetEndPointConfiguration/FreeRTOS_SetEndPointConfiguration
|
||||
- Get/Set the same address configuration from/to the end point
|
||||
|
||||
Change 3:
|
||||
|
||||
- Existing API: FreeRTOS_GetUDPPayloadBuffer
|
||||
- Backward compatibility with the IPv4 FreeRTOS+TCP V3.x.x. This can still be used for IPv4 use cases.
|
||||
- New API:FreeRTOS_GetUDPPayloadBuffer_Multi
|
||||
- A new argument (uint8_t ucIPType) to specify IP type to support both IPv4 and IPv6
|
||||
|
||||
Change 4:
|
||||
|
||||
- Existing API: pxFillInterfaceDescriptor
|
||||
- It is there for backward compatibility. The function FreeRTOS_IPInit() will call it to initialise the interface and end-point objects
|
||||
- New API: prefix_pxFillInterfaceDescriptor
|
||||
- where prefix = Network Interface Name
|
||||
- E.g pxWinPcap_FillInterfaceDescriptor
|
||||
- New function with the same functionality
|
||||
|
||||
Change 5:
|
||||
|
||||
- Existing API: vApplicationIPNetworkEventHook
|
||||
- New API: vApplicationIPNetworkEventHook_Multi
|
||||
- New argument “struct xNetworkInterface * pxNetworkInterface” added.
|
||||
|
||||
Change 6:
|
||||
|
||||
- Existing API: xApplicationDHCPHook
|
||||
- New API: xApplicationDHCPHook_Multi
|
||||
- New argument "struct xNetworkEndPoint * pxEndPoint" added.
|
||||
|
||||
Change 7:
|
||||
|
||||
- Existing API: xApplicationDNSQueryHook
|
||||
- New API: xApplicationDNSQueryHook_Multi
|
||||
- New argument "struct xNetworkEndPoint * pxEndPoint" added.
|
||||
|
||||
**NOTE** : We are NOT considering the APIs changes in FreeRTOS_IP_Private.h for backward compatibility as those are not part of published interface.
|
||||
|
||||
Running Demos:
|
||||
-------------
|
||||
The demos can be found on [this page](https://github.com/FreeRTOS/FreeRTOS/tree/main/FreeRTOS-Plus/Demo).
|
||||
|
||||
In all the demos, there is a backward compatibility mode which can be enabled by setting the flag “ipconfigIPv4_BACKWARD_COMPATIBLE” to 1 in the header file “FreeRTOSIPConfigDefaults.h”.
|
||||
This flag is by default set to zero.
|
||||
|
||||
New IPv6 WinSim Demo can be found on [this page](https://github.com/FreeRTOS/FreeRTOS/tree/main/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo).
|
||||
@@ -0,0 +1,668 @@
|
||||
Documentation and download available at https://www.FreeRTOS.org/
|
||||
|
||||
Changes between FreeRTOS-plus-TCP V4.4.1 and V4.4.0 released April 28, 2026:
|
||||
+ Fix heap OOB read in prvProcessICMPEchoReply() (#1335).
|
||||
+ Remove MAC-based loopback validation bypass (#1335).
|
||||
+ Fix size_t underflow in ICMPv6 echo reply handler (#1335).
|
||||
+ Fix DNS reply parsing loop and stall (#1335).
|
||||
+ Fix DHCPv6 sub-option default case skip (#1335).
|
||||
+ Validate PREFIX_INFORMATION option size in RA (#1335).
|
||||
+ Validate RA prefix length bounds (#1335).
|
||||
|
||||
Changes between FreeRTOS-plus-TCP V4.4.0 and V4.3.1 released February 25, 2026:
|
||||
+ [Security] Fix CWE-126/476/822: IPv6 buffer validation and bounds
|
||||
checking. Fix missing NULL pointer checks in ND, add ICMPv6 minimum
|
||||
packet size validation, move IPv6 version field check after buffer
|
||||
validation, and fix integer wrap-around in IPv6 payload length
|
||||
processing.
|
||||
+ [Security] Fix potential out of bounds write (CWE-787) when processing
|
||||
LLMNR or mDNS queries (#1258).
|
||||
+ Fix DHCP race condition (#1230).
|
||||
+ Fix possible network buffer leak in DHCP v4 and v6 state machines
|
||||
(#1231).
|
||||
+ Fix ARP lookups for gateway address when destination is outside of
|
||||
subnet (#1248). We thank @htibosch for their contribution.
|
||||
+ Fix endpoint mismatch in FreeRTOS_MatchingEndpoint (#1239).
|
||||
We thank @ravitd for their contribution.
|
||||
+ Fix compilation error if DNS features are disabled (#1243).
|
||||
We thank @MarcusBetter for their contribution.
|
||||
+ Fix buffer allocation failure handling in STM32 NetworkInterface.
|
||||
We thank @PhilGreenland for their contribution.
|
||||
+ Fix Windows Simulator demo build failures by adding missing windows.h
|
||||
includes (#1305).
|
||||
+ Fix TI CCS compiler errors (#1281).
|
||||
We thank @SvenP91 for their contribution.
|
||||
+ Fix warning concerning return value of non-void function (#1275).
|
||||
We thank @EmilioLopes for their contribution.
|
||||
+ Fix IPv4 and IPv6 broadcast address detection. We thank @evpopov for
|
||||
their contribution.
|
||||
+ Fix IPv6 loopback type detection (#1220). We thank @evpopov for their
|
||||
contribution.
|
||||
+ Fix Zynq network interface incoming packet filtering by correcting
|
||||
endianness.
|
||||
+ Fix printf format warnings by casting to unsigned long (#1222).
|
||||
We thank @concatime for their contribution.
|
||||
+ Fix smsc9220_eth_drv.c warnings from gcc -Wconversion (#1245).
|
||||
We thank @FlorianLaRoche for their contribution.
|
||||
+ Fix Coverity dead code and MISRA 10.4 findings.
|
||||
+ Use the expected sequence number for challenge ACK messages (#1236).
|
||||
We thank @MathiasJochum for their contribution.
|
||||
+ mDNS: when a reply do not repeat the questions, set authoritative
|
||||
flag (#1292). We thank @htibosch for their contribution.
|
||||
+ Allow the use of IP-clash detection, also when auto-IP is not enabled
|
||||
(#1299). We thank @htibosch for their contribution.
|
||||
+ Let valid broadcast packets in when endpoint is not yet up (#1240).
|
||||
+ Update IPv4 packet filtering to let packets destined to endpoint's
|
||||
MAC address when endpoint is not yet up (#1232).
|
||||
+ Add ipconfigIP_TASK_AFFINITY (#1288). We thank @mike919192 for their
|
||||
contribution.
|
||||
+ Add configuration option to prevent configASSERT checks on
|
||||
ipBUFFER_PADDING (#1271). We thank @DaveSkok for their contribution.
|
||||
+ Add #include "FreeRTOS_ARP.h" to loopbackNetworkInterface.c (#1290).
|
||||
We thank @NikolayPokhilchenko for their contribution.
|
||||
+ Alternative function for potential optimization of data copying in
|
||||
stream buffers (#1233). We thank @DenisZaikin for their contribution.
|
||||
+ Support ADIN1200 (#1280). We thank @GeorgeElliott-Hunter for their
|
||||
contribution.
|
||||
+ Rename ETH_TxPacketConfig in STM32F4 to match other STMs (#1278).
|
||||
We thank @GeorgeElliott-Hunter for their contribution.
|
||||
+ STM32H legacy driver: change parameter to pucGetRXBuffer() (#1285).
|
||||
We thank @htibosch for their contribution.
|
||||
+ Zynq driver: avoid race conditions (#1286). We thank @htibosch for
|
||||
their contribution.
|
||||
+ Zynq port: Add niEMAC_HANDLER_TASK_AFFINITY (#1291). We thank
|
||||
@mike919192 for their contribution.
|
||||
+ Update Zynq portable for Xilinx SDT drivers (#1227). We thank
|
||||
@mike919192 for their contribution.
|
||||
+ Workaround in Zynq port for missing macros when using SDT drivers.
|
||||
+ Remove unused variable in ultrascale port (ulDMAReg) (#1269).
|
||||
We thank @PeteBone for their contribution.
|
||||
+ Avoid portTICK_PERIOD_MS usage in library code (#1242). We thank
|
||||
@StefanBalt for their contribution.
|
||||
+ Remove redundant function declaration (#1241). We thank
|
||||
@FlorianLaRoche for their contribution.
|
||||
+ Improve maximum network buffer allocation size check when Buffer
|
||||
Allocation scheme 1 is used (#1263).
|
||||
+ Move FreeRTOS_printf from suspended scheduler region in
|
||||
prvAcceptWaitClient (#1250).
|
||||
+ Remove xHigherPriorityTaskWoken (#1215).
|
||||
+ Fix MISRA 2012 violations (#1272).
|
||||
+ Fix MISRA violations.
|
||||
+ Unittest: Fix, enable and forbid specific warnings (#1228). We thank
|
||||
@AndreasNordal for their contribution.
|
||||
+ Update scripts to run unit tests with respect to Ubuntu 24.04 (#1237).
|
||||
+ Update CI script to use latest lcov (#1251).
|
||||
+ Fix CI: replace hardcoded gcov-9 with gcov.
|
||||
+ Make CBMC use 64 core runners.
|
||||
+ Add CI build with compiler optimizations.
|
||||
|
||||
Changes between FreeRTOS-plus-TCP V4.3.1 and V4.3.0 released December 16, 2024:
|
||||
+ Update README.md with information related to migrating to V4.3.0 and above
|
||||
for users utilising the STM32 network interface.
|
||||
|
||||
Changes between FreeRTOS-plus-TCP V4.3.0 and V4.2.2 released December 10, 2024:
|
||||
+ Fix TCP RX sequence number when handling refusal of FIN packets.
|
||||
+ Fix unicast packets being sent over inactive endpoints. We thank
|
||||
@AlfaSegato for their contribution.
|
||||
+ Fix the initialization of the DNS callback list every time there is a
|
||||
Network-UP event. We thank @evpopov for their contribution.
|
||||
+ Full ARP/ND build level separation.
|
||||
We thank @HTRamsey for their contribution.
|
||||
+ Update the `eARPGetCacheEntry` to handle loopback addresses correctly
|
||||
and assign the loopback endpoint's MAC address as the lookup MAC address.
|
||||
We thank @htibosch for their contribution.
|
||||
+ Replace the costly `vTaskSuspendAll`/`xTaskResumeAll` locking
|
||||
mechanism with the more efficient `taskENTER_CRITICAL`/`taskEXIT_CRITICAL`
|
||||
pair in frequenly used `uxStreamBufferAdd()`.
|
||||
We thank @lzungri for their contribution.
|
||||
+ Improve frame filtering by expanding the checks in
|
||||
eConsiderFrameForProcessing to drop invalid frames earlier.
|
||||
We thank @HTRamsey for their contribution.
|
||||
+ Fix reception of multicast custom Ethernet frames, where custom multicast
|
||||
frames were filtered out. We thank @evpopov for their contribution.
|
||||
+ Update the Zynq Ultrascale port to support the V4.x.x version of
|
||||
FreeRTOS+TCP. We thank @StefanBalt and @pete-pjb for their contribution.
|
||||
+ New unified STM32 network interface for STM32 F4/F7/H5/H7.
|
||||
We thank @HTRamsey for their contribution.
|
||||
+ Fix ATSAME5x network interface related to incorrect detection of ICMP.
|
||||
We thank @cruxic for their contribution.
|
||||
+ Update Renesas portable layer for backward compatibility.
|
||||
We thank @xuan97z1 for their contribution.
|
||||
+ Replace any missing functions by assert-false in all CBMC proofs to
|
||||
improve tests. We thank @tautschnig for their contribution.
|
||||
+ Add ipconfigEMAC_TASK_HOOK macro to allow for a configurable
|
||||
watchdog timer for STMH7xx MCUs. We thank @kzorer for their contribution.
|
||||
+ Improve CMake to allow usage of `FetchContent` in external projects.
|
||||
We thank @nicovanduijn for their contribution.
|
||||
+ Add warning logs if the TCP stream buffer or window properties
|
||||
are changed. We thank @evpopov for their contribution.
|
||||
+ Remove unused `ipconfigHAS_ROUTING_STATISTICS` macro.
|
||||
We thank @HTRamsey for their contribution.
|
||||
+ Fix MISRA 2012 violations with the latest version of
|
||||
MISRA evalution tools.
|
||||
+ Adjust CBMC proof tooling to support CBMC v6.
|
||||
We thank @tautschnig for their contribution.
|
||||
|
||||
Changes between FreeRTOS-plus-TCP V4.2.2 and V4.2.1 released July 12, 2024:
|
||||
+ Update version information in public header file which were not present earlier.
|
||||
|
||||
Changes between FreeRTOS-plus-TCP V4.2.1 and V4.2.0 released June 27, 2024:
|
||||
+ Update version information in source files which were not present earlier.
|
||||
|
||||
Changes between FreeRTOS-plus-TCP V4.2.0 and V4.1.0 released June 24, 2024
|
||||
+ It was possible for a carefully crafted DNS response with domain name
|
||||
length value greater than the actual domain name length, to cause a buffer
|
||||
over-read within the DNS Response Parser. This issue affects applications
|
||||
using DNS functionality of the FreeRTOS-Plus-TCP stack.
|
||||
Applications that do not use DNS functionality are not affected,
|
||||
even when the DNS functionality is enabled.
|
||||
This issue has been fixed by modifying the code to ensure that the DNS
|
||||
Response Parser never attempts to read beyond the DNS
|
||||
response buffer boundary.
|
||||
We would like to thank Paschal Amusuo, James C. Davis, and
|
||||
Aravind Machiry of Purdue University, for reporting this issue.
|
||||
+ Fixed possible freed memory being reused while creating TCP sockets.
|
||||
We thank @htibosch for their contribution.
|
||||
+ Fixed possible NULL pointer dereference in TCP transmission.
|
||||
We thank @anordal for their contribution.
|
||||
+ Added network interface port for ARM Corstone-315 (MPS4_CS315).
|
||||
We thank @david-hazi-arm for their contribution.
|
||||
+ Fixed MISRA C 2012 issues in the code
|
||||
+ Replaced the usage strcpy with strncpy
|
||||
+ Improved memory allocation failure handling in `vDNSSetCallBack` by
|
||||
propagating error signal back. We thank @hlef for reporting this issue.
|
||||
+ Improved memory allocation failure handling in `prvCreateSectors` by
|
||||
propagating error signal back. We thank @hlef for reporting this issue.
|
||||
+ Enabled build on CI with sanitizers, fixed all AddressSanitizer
|
||||
and UB-Sanitizer errors. We thank @anordal for their contribution.
|
||||
+ Fixed mDNS lookups while parsing the mDNS answers.
|
||||
We thank @htibosch for their contribution.
|
||||
+ Fixed DNS name resolution responses when the device IP address
|
||||
is `0.0.0.0`. We thank @evpopov for their contribution.
|
||||
+ Avoided FreeRTOS-Plus-TCP forcing to use the compilation options
|
||||
set in the library CMake project in user projects.
|
||||
We thank @apcountryman for their contribution.
|
||||
+ Enabled user control of compiler analysis for non ISO statements.
|
||||
We thank @thirtytwobits for their contribution
|
||||
+ Fixed use of removed macro in ATSAME5x network interface.
|
||||
We thank @apcountryman for their contribution.
|
||||
+ Fixed inconsistent use of `ipconfigCOMPATIBLE_WITH_SINGLE`
|
||||
& `ipconfigIPv4_BACKWARD_COMPATIBLE`
|
||||
+ Resolved Unit Test Build Warnings
|
||||
+ Added network interface functions for multicast MAC address filtering.
|
||||
We thank @evpopov for their contribution.
|
||||
+ Fixed missing `ipconfigUSE_DNS_CACHE` check in FreeRTOS_DNS.c.
|
||||
+ Avoided compiler warnings about the printf formats in IPv6 modules.
|
||||
We thank @htibosch for their contribution.
|
||||
+ Removed deprecated macro `ipconfigMULTI_INTERFACE`.
|
||||
We thank @HTRamsey for their contribution.
|
||||
+ Removed unused function xProcessedTCPMessage.
|
||||
We thank @HTRamsey for their contribution.
|
||||
+ Removed deprecated macros ipLOCAL_MAC_ADDRESS and
|
||||
`ipLOCAL_IP_ADDRESS_POINTER`. We thank @HTRamsey for their contribution.
|
||||
+ Fixed eARPGetCacheEntryGateWay to properly report when no valid gateway is found
|
||||
for a packet that needs to be sent outside the local network.
|
||||
We thank @evpopov for their contribution.
|
||||
+ Combined duplicated IPv4/IPv6 TCP code.
|
||||
We thank @HTRamsey for their contribution.
|
||||
+ Improved validation of configuration macros in the default
|
||||
IP config using static compile time checks.
|
||||
We thank @HTRamsey for their contribution.
|
||||
+ Repaired ARP unit tests which were accessing packet memory
|
||||
outside of allocated bounds.
|
||||
+ Moved CMake compile options to test builds to avoid build issues in
|
||||
user projects that might be not be supporting compiler options used
|
||||
in the original Cmake. We thank @apcountryman for their contribution.
|
||||
+ Cleaned up CMake by adding: additional unit tests, incorporating missing
|
||||
network interface support, removing unused "config files" that are no longer
|
||||
required, and fixing file name issues in the unit testing framework.
|
||||
We thank @HTRamsey for their contribution.
|
||||
|
||||
Changes between FreeRTOS-plus-TCP V4.1.0 and V4.0.0 released March 8, 2024
|
||||
+ Add new Network Interface for Corstone-300 FVP (MPS3_AN552).
|
||||
We thank @urutva for their contribution.
|
||||
+ Add new loopback Network Interface.
|
||||
We thank @htibosch for their contribution.
|
||||
+ Add FreeRTOS_get_tx_base() API to return the TCP Tx stream buffer pointer.
|
||||
We thank @htibosch for their contribution.
|
||||
+ Add FreeRTOS_InterfaceEPInSameSubnet_IPv6 API to find an IPv6 endpoint on
|
||||
the given interface that is in the same subnet as the given IP address.
|
||||
+ Add checks to prevent potential integer overflow in the buffer
|
||||
allocation APIs.
|
||||
+ Improve performance by removing redundant critical sections.
|
||||
We thank @htibosch for their contribution.
|
||||
+ Improve performance on 64-bit targets by correctly setting
|
||||
ipBUFFER_PADDING to satisfy the architecture’s alignment requirements.
|
||||
We thank @htibosch for their contribution.
|
||||
+ Improve FreeRTOS_send() API performance by not iterating more times than
|
||||
necessary when trying to send data.
|
||||
We thank @htibosch for their contribution.
|
||||
+ Update the Neighbour Discovery cache behavior to overwrite the oldest
|
||||
entry when the cache is full. We thank @evpopov for their contribution.
|
||||
+ Update the FreeRTOS_get_tx_head() API to create the TCP Tx stream buffer
|
||||
if it wasn't already created for the given socket.
|
||||
+ FreeRTOS_GetIPType is now always available, regardless of the value of
|
||||
ipconfigUSE_TCP. We thank @HTRamsey for their contribution.
|
||||
+ Improve tracing support by adding more trace macros.
|
||||
We thank @HTRamsey for their contribution.
|
||||
+ Add support for multiple endpoints in STM32Hxx Network Interface.
|
||||
Earlier it was capable of handling upto 3 endpoints only.
|
||||
+ Fix potential NULL pointer dereference when a packet from a subnet other
|
||||
than the endpoint's subnet is received on an endpoint that has no gateway
|
||||
configured. We thank @htibosch for their contribution.
|
||||
+ Fix TCP zero-copy functionality by removing incorrect NULL check for
|
||||
pvBuffer parameter in the FreeRTOS_Send API.
|
||||
We thank @evpopov for their contribution.
|
||||
+ Fix the network buffer leak in the Neighbour Discovery (ND) code.
|
||||
We thank @htibosch for their contribution.
|
||||
+ ARP requests are now sent only on the endpoint with IP address in the same
|
||||
subnet as the ARP request’s target address. Earlier ARP requests were sent
|
||||
over all the available endpoints.
|
||||
We thank @evpopov for their contribution.
|
||||
+ Neighbor Solicitation (NS) responses are now correctly sent on the same
|
||||
endpoint on which the Neighbor Solicitation request is received.
|
||||
Earlier, it could be sent out on a wrong interface when multiple IPv6
|
||||
Link Local endpoints were present on different interfaces.
|
||||
We thank @evpopov for their contribution.
|
||||
+ Responses to mDNS/LLMNR/NBNS requests are now sent on the the same
|
||||
endpoint on which the request was received. Earlier, it could be sent out
|
||||
on a wrong endpoint. We thank @evpopov for their contribution.
|
||||
+ Fix size calculation in the neighbor solicitation handling code to avoid a
|
||||
buffer reallocation always. We thank @evpopov for their contribution.
|
||||
+ Fix FreeRTOS_getaddrinfo_a API to use the address family supplied in
|
||||
xHints parameter instead of always using IPv6.
|
||||
We thank @evpopov for their contribution.
|
||||
+ Fix IPv4 incoming packet filtering logic to correctly filter out unicast
|
||||
packets not destined to the device, when
|
||||
ipconfigETHERNET_DRIVER_FILTERS_FRAME_TYPES is enabled.
|
||||
We thank @evpopov for their contribution.
|
||||
+ Improve error handling in STM32H7xx Network Interface.
|
||||
We thank @htibosch for their contribution.
|
||||
+ Update the IPv4 packet filtering logic to correctly discard bad loopback
|
||||
packets originating outside of the network.
|
||||
+ Ensure that the hostname string in DNS resolution code is NULL terminated,
|
||||
even when the destination buffer is not large enough to hold the complete
|
||||
string. We thank @bjsowa for their contribution.
|
||||
+ Fix the network down and up process to correctly restart DHCP/RA timers.
|
||||
We thank @bjsowa for their contribution.
|
||||
+ Fix SAME70 Network Interface to correctly release Tx semaphore when the
|
||||
network interface fails to transmit.
|
||||
We thank @evpopov for their contribution.
|
||||
+ Update NXP1060 Network Interface to handle network cable disconnection.
|
||||
We thank @microcris for their contribution.
|
||||
+ Update the alignment specifier in TM4C Network Interface to make it
|
||||
compatible with both CCS and GCC compilers.
|
||||
We thank @jonathangjertsen for their contribution.
|
||||
+ Fix minimum length check for ICMP/ping packets.
|
||||
We thank @htibosch for their contribution.
|
||||
+ Fix received packet length calculation in the SAM Network Interface.
|
||||
We thank @htibosch for their contribution.
|
||||
+ Remove obsolete structs xNetworkAddressing and xDefaultAddressing.
|
||||
We thank @evpopov for their contribution.
|
||||
+ Fix compilation with Clang 17 and updated log output.
|
||||
We thank @Mixaill for their contribution.
|
||||
+ Fix compiler warnings with the -Wpedantic option.
|
||||
We thank @Mixaill for their contribution.
|
||||
+ Fix compiler warnings in the SAM Network Interface.
|
||||
We thank @Peter-Herrmann for their contribution.
|
||||
+ Streamline the usage of const in stream buffer APIs.
|
||||
We thank @HTRamsey for their contribution.
|
||||
+ Debug logs, printed using FreeRTOS_debug_printf, are now correctly
|
||||
guarded using the macro ipconfigHAS_DEBUG_PRINTF.
|
||||
We thank @microcris for their contribution.
|
||||
+ Add the LIBSLIRP Network Interface to be available in the CMakelists
|
||||
Network Interface selection. We thank @bjsowa for their contribution.
|
||||
+ Move static assert definition to a common header file to make it available
|
||||
to all the source files. Also, remove redundant macro check definitions.
|
||||
We thank @HTRamsey for their contribution.
|
||||
+ Remove the xCheckLoopback function. It is no longer needed as we now
|
||||
have a loopback interface. We thank @htiboschfor their contribution.
|
||||
|
||||
Changes between FreeRTOS-plus-TCP V4.0.0 and V3.1.0 released August 10, 2023
|
||||
+ Unified code for both IPv4 and IPv6 protocols.
|
||||
+ Multiple Interface and Multiple Endpoint support
|
||||
1. The stack supports multiple Physical Interfaces.
|
||||
2. The stack also supports multiple endpoints (or Virtual interfaces) on the same physical interface.
|
||||
+ New WinSim demo to support IPv4, IPv6 and multi-interface together.
|
||||
(Reference: https://github.com/FreeRTOS/FreeRTOS/tree/main/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo)
|
||||
+ Build separation feature introduced to achieve low memory footprint. Supported build combinations:
|
||||
1. IPv4 + UDP
|
||||
2. IPv4 + UDP + TCP
|
||||
3. IPv6 + UDP
|
||||
4. IPv6 + UDP + TCP
|
||||
5. IPv4 + IPv6 + UDP
|
||||
6. IPv4 + IPv6 + UDP + TCP
|
||||
+ Support added in FreeRTOS-plus-TCP git repository CI tool to validate various build configurations before PR merge.
|
||||
+ Achieved 100% unit test coverage for both IPv4 and IPv6.
|
||||
+ MISRA c-2012 compliance for both IPv4 and IPv6.
|
||||
+ Addressed several issues observed by Maxwell Protocol tester.
|
||||
+ Memory safety proofs for IPv6 code using[ CBMC automated reasoning tool ] (https://www.cprover.org/cbmc/).
|
||||
+ Stack is Penetration tested and a memory leak issue has been identified and fixed in the process.
|
||||
(Reference: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/pull/973)
|
||||
+ Improved Documentation:
|
||||
1. Multi-interface and Multi-endpoint documentation.
|
||||
2. Updated stack initialization documentation to support multi-interface and endpoint.
|
||||
(Reference: https://freertos-wordpress.corp.amazon.com/FreeRTOS-Plus/FreeRTOS_Plus_TCP/TCP_Networking_Tutorial_Initialising_TCP.updated.html)
|
||||
3. Code size details for various build configurations
|
||||
(Reference: https://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/index.html).
|
||||
4. Documentation added for IPv6 protocol support.
|
||||
5. Documentation added for various IPv6 functionalities like DHCPv6, ND (Neighbour Discovery), RA (Router Advertisement).
|
||||
6. README added for the network ports.
|
||||
|
||||
We thank the following people for their inputs in these enhancements:
|
||||
+ Add mDNS fixes for IPv6. Contributed by @evpopov.
|
||||
+ IP offset calculation improvement. Contributed by @evpopov.
|
||||
+ CCS compiler fix for packed structs. Contributed by @rahul-arasikere.
|
||||
+ Add tasking compiler support. Contributed by @go2sh.
|
||||
+ Add NetworkDown notification support to STM32FXX. Contributed by @zipperowiec.
|
||||
+ CMake changes. Contributed by @phelter.
|
||||
+ STM32Hxx porting fixes. Contributed by @miguelfreitas.
|
||||
+ Allow use of loopback addresses. Contributed by @adam-stamand.
|
||||
+ CBMC proof-running GitHub Action. Contributed by @karkhaz.
|
||||
+ CBMC XML output to enable VSCode debugger. Contributed by @karkhaz.
|
||||
+ vTaskDelay for sleep in the network-interface of xilinx_ultrascale.Contributed by @ChristosZosi.
|
||||
+ Read mac address using FreeRTOS_GetMACAddress(). Contributed by @sayyadumar.
|
||||
+ Minor warning fixes. Contributed by @ChristosZosi.
|
||||
+ Network-interface fix for Xilinx UltraScale port. Contributed by @ChristosZosi.
|
||||
|
||||
Changes between 4.0.0-RC3 and 4.0.0-RC2 releases:
|
||||
+ Added memory safety proofs for IPv6 using[ CBMC automated reasoning tool ] ( https:/*www.cprover.org/cbmc/)
|
||||
+ Introduced build separation feature to achieve low memory footprint. Supported build combinations:
|
||||
1. IPv4 + UDP
|
||||
2. IPv4 + UDP + TCP
|
||||
3. IPv6 + UDP
|
||||
4. IPv6 + UDP + TCP
|
||||
5. IPv4 + IPv6 + UDP
|
||||
6. IPv4 + IPv6 + UDP + TCP
|
||||
|
||||
Changes between 4.0.0-RC2 and 4.0.0-RC1 releases:
|
||||
+ Added changes to fix IPv6 issues observed by Maxwell protocol tester.
|
||||
|
||||
Changes between RC1 and V3.0.0 releases:
|
||||
+ Unified code for IPv4 and IPv6
|
||||
+ Multiple Interface/Endpoint support
|
||||
(Reference: https://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/freertostcp-multiple-interfaces.html).
|
||||
+ New WinSim demo to support both IPv4 and IPv6.
|
||||
**Note**- This release does not support ESP32/ M487/ mw300_rd ports yet. This will be released soon.
|
||||
|
||||
Changes between V3.0.0 and V3.1.0 releases:
|
||||
+ Fixed a bug in the Connect function where multiple SYN and RST packet combinations can
|
||||
lead to orphaned sockets.
|
||||
+ Added network interface support for NetifSlirp.
|
||||
|
||||
Changes between V3.0.0 and V2.4.0 releases:
|
||||
+ Split the source files according to the function the code performs.
|
||||
This makes the code modular making test coverage easier.
|
||||
+ Achieved 100% unit-test coverage.
|
||||
+ Improved RFC compliance.
|
||||
+ Improved MISRA c-2012 compliance.
|
||||
|
||||
Helpful links to help you upgrade to V3
|
||||
+ https://github.com/FreeRTOS/FreeRTOS-plus-tcp#generating-pre-v300-folder-structure-for-backward-compatibility
|
||||
+ https://www.freertos.org/2022/08/the-freertos-plus-tcp-library-is-now-more-robust-and-secure.html
|
||||
|
||||
Changes between V2.3.3 and V2.3.4 releases:
|
||||
+ Added a check in BufferAllocation_2.c to ensure adding (2 +
|
||||
ipBUFFER_PADDING) bytes to the requested allocation size does
|
||||
not cause an integer overflow. Thanks to Bernard Lebel
|
||||
(RMDS Innovation) reporting this potential issue.
|
||||
+ Updated FreeRTOS_inet_pton4() so it rejects IP addresses that
|
||||
have leading zeros. Previously, if the IP address had leading
|
||||
zeros, perhaps because it was entered in octal format, the
|
||||
address was interpreted as decimal (the leading zeros were
|
||||
stripped). That could result in the function returning an
|
||||
unexpected IP address.
|
||||
+ Added logic to clear flags of a stored TCP packet to avoid
|
||||
sending incorrect flags when receiving incorrect packets from
|
||||
the peer.
|
||||
+ Fixed the IP header checksum calculation of ICMP response.
|
||||
|
||||
Changes between V2.3.2 and V2.3.3 releases:
|
||||
+ When a listening socket is closed, all child sockets not yet owned by the
|
||||
application will be closed too. (Thanks Bernd Edlinger).
|
||||
+ Updated buffer allocation to return a zero length buffer when
|
||||
requested. (Thanks Thomas Pedersen).
|
||||
+ When there is insufficient space in the network event queue, closing of a
|
||||
socket will be deferred for a later time. (Thanks Bernd Edlinger).
|
||||
+ Allow IP-task to clean up while deleting socket-sets to avoid race
|
||||
conditions. (Thanks Bernd Edlinger).
|
||||
+ Added FreeRTOS+TCP version number macros.
|
||||
+ Repaired buffer leak in NBNS reply logic.
|
||||
+ Added a hook function which can be used to process unsupported ethernet
|
||||
frames.
|
||||
+ Added a check for ICMP packets with incorrect checksum.
|
||||
|
||||
Changes between V2.3.1 and V2.3.2 releases:
|
||||
+ When a protocol error occurs during the SYN-phase of a TCP connection, a
|
||||
child socket will now be closed ( calling FreeRTOS_closesocket() ),
|
||||
instead of being given the eCLOSE_WAIT status. A client socket, which calls
|
||||
connect() to establish a connection, will receive the eCLOSE_WAIT status,
|
||||
just like before.
|
||||
+ Fixed a race condition in DHCP state machine which occurred when the macro
|
||||
dhcpINITIAL_TIMER_PERIOD was set to a very low value.
|
||||
|
||||
Changes between V2.3.0 and V2.3.1 releases:
|
||||
+ Fixed UDP only compilation.
|
||||
+ Added description for functions and variables in Doxygen compatible format.
|
||||
+ Fixed asynchronous DNS lookup which was broken due to changed function
|
||||
signature of prvParseDNSReply.
|
||||
|
||||
Changes between V2.2.2 and V2.3.0 releases:
|
||||
+ Moved FreeRTOS+TCP source code to an independent repository
|
||||
FreeRTOS/FreeRTOS-Plus-TCP.
|
||||
|
||||
Changes between V2.2.1 and V2.2.2 releases:
|
||||
+ Updated the source code to adhere to stricter MISRA compliance.
|
||||
|
||||
Changes between V2.0.0 and V2.2.1 releases:
|
||||
+ Improved security by giving users the option to reject UDP packets with a
|
||||
checksum of zero even though the UDP spec allows it.
|
||||
+ Improved robustness by checking packet lengths in software even if the check
|
||||
has already been performed in the hardware.
|
||||
+ Added ipconfigIP_PASS_PACKETS_WITH_IP_OPTIONS macro to enable users to
|
||||
drop/accept IP Packets containing IP options (IP options are not supported).
|
||||
+ Modified xDataLength to always mean "total number of bytes" to impart more
|
||||
clarity.
|
||||
+ Replaced the ipconfigRAND32 macro with a function
|
||||
xApplicationGetRandomNumber(). The return value indicates if the randomiser
|
||||
is broken or working properly. Before this, a random value of 0 was treated
|
||||
as invalid, whereas 0 can be a proper random value.
|
||||
+ Made changes in DNS to make asynchronous lookup work.
|
||||
+ Made FreeRTOS_OutputARPRequest() available for application code. Now the
|
||||
application can start an ARP request directly by sending a UDP packet.
|
||||
+ Made Socket_t and SocketSet_t point to a struct in stead of void.
|
||||
+ Corrected the DNSs protocol-checksum calculation length.
|
||||
+ Corrected length-check in usGenerateProtocolChecksum().
|
||||
+ Modified pxGetNetworkBufferWithDescriptor() function to check if a counting
|
||||
semaphore has been created. Earlier when a user tried to get a Network
|
||||
Buffer before the IP-task started, the function could crash.
|
||||
+ Made TCP low-water/high-water limits configurable with a socket option.
|
||||
+ The 'ucFirstOptionByte' was counted twice in earlier releases, subtract 1
|
||||
byte to send the correct amount of bytes.
|
||||
+ Corrected the WIN size reporting to the TCP peer. The WIN size as reported
|
||||
to the TCP peer was sometimes running slightly behind.
|
||||
+ Added a function FreeRTOS_dnsclear() which invalidates the entire DNS cache.
|
||||
+ Added DNS response transaction ID check. The DNS cache shall only be updated
|
||||
when the ID in the reply comes from the device.
|
||||
|
||||
Changes between 180821 and V2.0.0 releases:
|
||||
+ Move the TCP source code from FreeRTOS/FreeRTOS-Labs to FreeRTOS/FreeRTOS
|
||||
repository.
|
||||
|
||||
Changes between 160919 and 180821 releases:
|
||||
|
||||
+ Multiple security improvements and fixes in packet parsing routines, DNS
|
||||
caching, and TCP sequence number and ID generation.
|
||||
+ Disable NBNS and LLMNR by default.
|
||||
+ Add TCP hang protection by default.
|
||||
|
||||
We thank Ori Karliner of Zimperium zLabs Team for reporting these issues.
|
||||
|
||||
Changes between 160908 and 160919 releases:
|
||||
|
||||
+ Add a NULL check before attempting to close the DHCP socket. [Prior to
|
||||
160823 the IP task closed the DHCP socket by calling a public API function
|
||||
- which checked for the socket being NULL. This was changed to call a
|
||||
local private function, which did not have a NULL check, in place of the
|
||||
public API function.]
|
||||
+ Various [internal only] naming changes to better comply with the FreeRTOS
|
||||
naming conventions.
|
||||
+ Improvements to the Zynq network driver. DMA transmission buffers now use
|
||||
a counting semaphore. When all TX-buffers are in-use, the IP-task will
|
||||
block momentarily until a TX-buffer becomes available.
|
||||
+ Experimental implementation of the TCP window scaling protocol. The
|
||||
scaling option will always be offered, at least with a factor 1. If the
|
||||
TCP sliding window size becomes more than 64KB, the factor will increase
|
||||
automatically.
|
||||
+ ipconfigETHERNET_MINIMUM_PACKET_BYTES is now applied for every protocol:
|
||||
TCP, UDP, and ARP.
|
||||
+ Updated the Zynq project to use BufferAllocation_1.c rather than
|
||||
BufferAllocation_2.c - which is a requirement with its current
|
||||
configuration (due to the alignment requirements on the combined cache and
|
||||
DMA configuration).
|
||||
|
||||
Changes between 160823 and 160908 releases:
|
||||
|
||||
+ Use ipconfigZERO_COPY_TX_DRIVER as the xReleaseAfterSend() parameter where
|
||||
prvTCPReturnPacket() is called in prvSendData() to prevent unnecessary
|
||||
copying of data.
|
||||
+ Remove the use of the uxGetRxEventCount variable, which was used to give
|
||||
priority to incoming messages, but could result in the IP task starving
|
||||
application tasks of processing time.
|
||||
|
||||
Changes between 160112 and 160823 releases
|
||||
|
||||
NOTE: The 160908 release is a maintenance release for the 160112 single
|
||||
interface labs release - not a release of the current development branch.
|
||||
|
||||
+ Various minor stability enhancements, including the ability to work with
|
||||
configTICK_RATE_HZ set to less than 1KHz, closing DHCP sockets directly
|
||||
rather than via FreeRTOS_closesocket(), and better handling of unknown
|
||||
TCP packets before an IP address has been assigned.
|
||||
+ ipBUFFER_PADDING is now configurable through the ipconfigBUFFER_PADDING
|
||||
constant to improve network buffer alignment handling capabilities (expert
|
||||
users/driver writers only).
|
||||
+ Multiple improvements to the FTP server, including to how read only and
|
||||
zero length files are handled.
|
||||
+ ipconfigFTP_HAS_USER_PROPERTIES_HOOK (to allow each user to have a
|
||||
different root directory and access rights) and
|
||||
ipconfigHTTP_HAS_HANDLE_REQUEST_HOOK (to handle AJAX style data)
|
||||
introduced, although these are not yet fully tested and the constant names
|
||||
are likely to change.
|
||||
+ Introduce ipconfigHAS_TX_CRC_OFFLOADING.
|
||||
+ ipconfigUSE_DHCP_HOOK is now called ipconfigUSE_DHCP_HOOK, and the name
|
||||
of the callback function has also changed. See the web documentation for
|
||||
details.
|
||||
+ ipconfigTCP_RX_BUF_LEN is now ipconfigTCP_RX_BUFFER_LENGTH, and
|
||||
ipconfigTCP_TX_BUF_LEN is now ipconfigTCP_TX_BUFFER_LENGTH, which is
|
||||
actually how they have always been documented.
|
||||
+ Added example TFTP server capable of receiving (not sending) files.
|
||||
Intended for bootloader type functionality.
|
||||
+ Various variable name changes for consistency (mainly ensuring UDP, TCP,
|
||||
DNS, etc. always use the same case letters, and type prefixes are correct).
|
||||
+ Various minor edits to improve types used by internal variables.
|
||||
+ Simplified mapping of standard library functions to their Visual Studio
|
||||
equivalents.
|
||||
+ Improve robustness of network drivers.
|
||||
+ Introduce pxResizeNetworkBufferWithDescriptor().
|
||||
+ Removed obsolete FreeRTOSIPConfig.h constants from
|
||||
FreeRTOSIPConfigDefaults.h.
|
||||
+ Added additional asserts() - predominantly to catch incorrect structure
|
||||
packing.
|
||||
|
||||
Changes between 160112 and 160111 releases
|
||||
|
||||
+ Updated the STM32 network driver so checksums are calculated by the
|
||||
hardware.
|
||||
+ Implemented a simple "quit" command in the TCP command console.
|
||||
|
||||
Changes between 150825 and 160111 releases
|
||||
|
||||
+ New device support: Demo applications and example drivers are provided
|
||||
for Atmel SAM4E and ST STM32F4 microcontrollers.
|
||||
+ Various updates to improve compliance with the FreeRTOS coding standard.
|
||||
+ Added a command console example that uses TCP/IP for input and output (the
|
||||
pre-existing command console example uses UDP/IP).
|
||||
+ Updated the UDP logging example so it will send log messages to the local
|
||||
UDP broadcast address if a specific IP address is not provided. This
|
||||
simplifies configuration, but note not all switches and routers will pass
|
||||
broadcast messages.
|
||||
+ Add TCP echo client and TCP echo server examples to the Zynq demo.
|
||||
+ Minor updates to the Zynq network driver.
|
||||
+ Update the Zynq project to use version 2015.4 of the Xilinx SDK.
|
||||
+ Introduce FreeRTOS_SignalSocket(), which can be used to interrupt a task
|
||||
that is blocked while reading from a socket ( FreeRTOS_recv[from] ).
|
||||
+ Make use of FreeRTOS_SignalSocket() in the FTP and HTTP servers.
|
||||
+ Major updates to the NTP client, although this is not included in any of
|
||||
the pre-configured demo applications yet.
|
||||
+ Added support for DHCP zero pad option.
|
||||
+ Added uxGetMinimumIPQueueSpace(), a function to monitor the minimum amount
|
||||
of space on the message queue.
|
||||
+ Better handling of zero length files in the FTP server.
|
||||
+ Fixed a bug reported by Andrey Ivanov from swissEmbedded that affects
|
||||
users of 'ipconfigZERO_COPY_TX_DRIVER'.
|
||||
|
||||
|
||||
Changes between 150825 150825 (?)
|
||||
|
||||
+ Added xApplicationDHCPUserHook() so a user defined hook will be
|
||||
called at certain points in the DHCP process if
|
||||
ipconfigDHCP_USES_USER_HOOK is set to 1.
|
||||
+ Added FreeRTOS_get_tx_head() to improve TCP zero copy behaviour - for
|
||||
expert use only.
|
||||
+ RST is no longer sent if only the ACK flag is set.
|
||||
+ Previously, an immediate ACK was only sent when buffer space was
|
||||
exhausted. Now, to improve performance, it is possible to send an
|
||||
immediate ACK earlier - dependent on the ipconfigTCP_ACK_EARLIER_PACKET
|
||||
setting.
|
||||
+ LLMNR and NBNS requests can now be sent to locate other devices -
|
||||
previously these protocols would only be replied to, not generated.
|
||||
+ Added Auto-IP functionality (still in test) in case DHCP fails. Dependent
|
||||
on the ipconfigDHCP_FALL_BACK_LINK_LAYER_ADDRESS and
|
||||
ipconfigARP_USE_CLASH_DETECTION settings.
|
||||
+ Added NTP code and demo.
|
||||
+ FTP can now STOR and RETR zero-length files.
|
||||
+ Added LLMNR demo to Win32 demo - so now the Win32 responds to
|
||||
"ping RTOSDemo".
|
||||
|
||||
Changes between 141019 and 150825
|
||||
|
||||
+ Added FTP server, which uses the new FreeRTOS+FAT component.
|
||||
+ Added basic HTTP server, which uses the new FreeRTOS+FAT component.
|
||||
+ Multiple definitions that are now common with FreeRTOS+FAT have been moved
|
||||
into FreeRTOS's ProjDefs.h header file, and so prefixed with 'pd'.
|
||||
+ Introduced ipconfigZERO_COPY_TX_DRIVER, which defines who is responsible
|
||||
for freeing a buffer sent to to the MAC driver for transmission, and
|
||||
facilitates the development of zero copy drivers.
|
||||
+ Introduced the FREERTOS_MSG_DONTWAIT flag. The flag can be used as a
|
||||
simpler and faster alternative to using FreeRTOS_setsockopt() to set the
|
||||
send or receive timeout to 0.
|
||||
+ A few functions that were previously all lower case are now mixed case, as
|
||||
lower case function names are only used when they are equivalent to a
|
||||
a Berkeley sockets API function of the same name.
|
||||
+ Introduced uxGetMinimumFreeNetworkBuffers() to return the minimum number
|
||||
of network buffers that have ever existed since the application started
|
||||
executing.
|
||||
+ Introduce ipconfigETHERNET_MINIMUM_PACKET_BYTES to allow the application
|
||||
writer to set their own minimum buffer size should the hardware not be
|
||||
capable of padding under-sized Ethernet frames.
|
||||
+ vNetworkBufferRelease() renamed vReleaseNetworkBuffer() - just for
|
||||
consistency with the names of other functions in the same file.
|
||||
+ Grouped DHCP status data into a structure.
|
||||
+ DHCP is now tried both with and without the broadcast flag.
|
||||
+ Replaced occurrences of configASSERT_VOID() with configASSERT().
|
||||
+ ipconfigDNS_USE_CALLBACKS introduced to allow FreeRTOS_gethostbyname() to
|
||||
be used without blocking.
|
||||
+ Fix: LLMNR and NBNS behaviour when the reply is in a larger buffer than the
|
||||
request, and BufferAllocation_2 was used.
|
||||
+ Introduced ipMAX_IP_TASK_SLEEP_TIME to allow the application writer to
|
||||
override the default value of 10 seconds.
|
||||
+ Fix: Correct error in *pxUDPPayloadBuffer_to_NetworkBuffer().
|
||||
+ FreeRTOS_recv() now recognizes the FREERTOS_ZERO_COPY flag, which, when
|
||||
set, the void *pvBuffer parameter is interpreted as void **pvBuffer.
|
||||
+ FreeRTOS_listen() now returns an error code. Previously it always
|
||||
returned 0.
|
||||
+ Fix: Previously if a listening socket was reused, and a connection
|
||||
failed, the TCP/IP stack closed the socket, now the socket is correctly
|
||||
left unclosed as it is owned by the application.
|
||||
+ Various other formatting and minor fix alterations.
|
||||
@@ -0,0 +1,19 @@
|
||||
MIT License
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
@@ -0,0 +1,255 @@
|
||||
# MISRA Compliance
|
||||
|
||||
The FreeRTOS-Plus-TCP library files conform to the
|
||||
[MISRA C:2012](https://www.misra.org.uk)
|
||||
guidelines, with the deviations listed below. Compliance is checked with
|
||||
Coverity static analysis. Since the FreeRTOS-Plus-TCP library is designed for
|
||||
small-embedded devices, it needs to have a very small memory footprint and has
|
||||
to be efficient. To achieve that and to increase the performace of the IP-stack,
|
||||
it deviates from some MISRA rules. The specific deviations, suppressed inline,
|
||||
are listed below.
|
||||
|
||||
Additionally,
|
||||
[MISRA configuration file](https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/test/Coverity/coverity_misra.config)
|
||||
contains the project wide deviations.
|
||||
|
||||
### Suppressed with Coverity Comments
|
||||
|
||||
To find the violation references in the source files run grep on the source code
|
||||
with ( Assuming rule 11.4 violation; with justification in point 2 ):
|
||||
|
||||
```
|
||||
grep 'MISRA Ref 11.4.2' . -rI
|
||||
```
|
||||
|
||||
#### Directive 4.7
|
||||
|
||||
_Ref 4.7.1_
|
||||
|
||||
- MISRA C:2012 Directive 4.7: Return value shall be checked.
|
||||
MISRA warns against not checking the return value of functions that
|
||||
does return. However, the violations reported in FreeRTOS-Plus-TCP
|
||||
library for this directive are for the cases where the validity of the
|
||||
subsequent expressions are validated by ways other than return
|
||||
value of the called function, for example pointer value
|
||||
that was passed as argument.
|
||||
|
||||
#### Directive 4.12
|
||||
|
||||
_Ref 4.12.1_
|
||||
|
||||
- MISRA C:2012 Directive 4.12: Dynamic memory allocation shall not be used.
|
||||
MISRA warns against the use of dynamic memory allocation as it might lead to
|
||||
undefined behavior if not used properly. However, the FreeRTOS-Plus-TCP
|
||||
library only uses the memory allocation primitives defined by the
|
||||
FreeRTOS-Kernel, which are deterministic. Additionally, proper care is taken
|
||||
in the code to not use free'd pointers and to check the validity of malloc'd
|
||||
memory before it is dereferenced or used.
|
||||
|
||||
#### Directive 4.14
|
||||
|
||||
_Ref 4.14.1_
|
||||
|
||||
- MISRA C:2012 Directive 4.14: The validity of values received from external
|
||||
sources shall be checked. In this case however, the value of `uxICMPSize` is
|
||||
checked to be within bounds of the network buffer size using the variable `uxNeededSize`. This is a false positive.
|
||||
|
||||
_Ref 4.14.2_
|
||||
|
||||
- MISRA C:2012 Directive 4.14: The validity of values received from external
|
||||
sources shall be checked. In this case however, the contents of `xReceiveBuffer.pucPayloadBuffer` is filled by `FreeRTOS_recvfrom` which performs the necessary
|
||||
checks required to validate the `xBytes` which is in turn assigned to
|
||||
`xReceiveBuffer.uxPayloadLength`.
|
||||
|
||||
#### Rule 2.2
|
||||
|
||||
_Ref 2.2.1_
|
||||
|
||||
- MISRA C-2012 Rule 2.2 Unions are used for checksum computation to speed up the
|
||||
process by utilizing the full length of registers (32-bits). After this, the
|
||||
16-bit union members are used to then compute the final checksum. Doing this
|
||||
is considered as 'overwriting the variable' by Coverity. Thus, it marks some
|
||||
statements as dead code. This is a false positive.
|
||||
|
||||
#### Rule 8.9
|
||||
|
||||
_Ref 8.9.1_
|
||||
|
||||
- MISRA C-2012 Rule 8.9 For unit-tests to be repeatable and independent of the
|
||||
order of execution, some variables have file scope definitions rather than
|
||||
function scope.
|
||||
|
||||
#### Rule 8.13
|
||||
|
||||
_Ref 8.13.1_
|
||||
|
||||
- MISRA C-2012 Rule 8.13 Parameter passed is never used, should be declared as
|
||||
const. The argument passed to the `prvIPTask` function is left unused which is
|
||||
considered as the variable not being used and thus warranting the use of
|
||||
`const`. However, the FreeRTOS-kernel function `xTaskCreate` expects a
|
||||
function signature of type `void vSomeFunction( void * pvArgs )`. To satisfy
|
||||
that requirement, the function signature of `prvIPTask` does not have a
|
||||
`const` qualifier in the parameter signature.
|
||||
|
||||
#### Rule 10.5
|
||||
|
||||
_Ref 10.5.1_
|
||||
|
||||
- MISRA C-2012 Rule 10.5 Converting from an unsigned to an enum type. The
|
||||
operation is safe to perform in that case, as we are using a generic API to
|
||||
send and receive data, in that case the exact data sent it is received.
|
||||
|
||||
#### Rule 10.8
|
||||
|
||||
_Ref 10.8.1_
|
||||
|
||||
- MISRA C-2012 Rule 10.8 Casting a composite expression from a signed to an
|
||||
unsigned type. The operation is safe to perform in this case as we have verified
|
||||
that the pointer being subtracted from is greater than or equal to the pointer
|
||||
being subtracted thereby making the result positive. This result can be safely
|
||||
casted to an unsigned type like size_t.
|
||||
|
||||
#### Rule 11.1
|
||||
|
||||
_Ref 11.1.1_
|
||||
|
||||
- MISRA C-2012 Rule 11.1 Converting from a void pointer to a function pointer.
|
||||
The `FreeRTOS_setsockopt` API allows users to configure sockets by setting
|
||||
various options. In order to do so, the function must accept one parameter
|
||||
which, based on the option value, can be casted to the corresponding socket
|
||||
field. To that end, that parameter is of `void *` type to accommodate all
|
||||
values. The caller of the API is responsible for providing correct function
|
||||
pointer to the API. Thus, this violation can be safely suppressed.
|
||||
|
||||
#### Rule 11.3
|
||||
|
||||
_Ref 11.3.1_
|
||||
|
||||
- MISRA C-2012 Rule 11.3 The data received/sent by the IP stack is represented
|
||||
as a byte stream. This byte stream needs to be casted to various data
|
||||
structures to access certain fields of the packet. However, when casting a
|
||||
byte stream to a structure, MISRA warns us that it can lead to unaligned
|
||||
access. But, in case of FreeRTOS+TCP, the buffer in which the packets are
|
||||
stored are always aligned to a 4 byte word boundary with an offset of 2
|
||||
bytes. The reason for this 2byte offset is that the ethernet header is of
|
||||
14 (12 + 2) bytes. Thus,everything except the ethernet header is properly
|
||||
aligned. There is one alignment exception, which is the sender protocol
|
||||
address in the ARP Header. To combat that, the sender protocol address field
|
||||
is declared as an array of 4 bytes instead of a `uint32_t`. More details can
|
||||
be found
|
||||
[here](https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/pull/512#pullrequestreview-1035211706).
|
||||
|
||||
#### Rule 11.4
|
||||
|
||||
_Ref 11.4.1_
|
||||
|
||||
- MISRA c-2012 Rule 11.4 Warns about conversion between a pointer and an
|
||||
integer. Whenever a socket is created using the `FreeRTOS_Socket` API, either
|
||||
a valid socket (a valid non-NULL pointer) is returned; or
|
||||
`FREERTOS_INVALID_SOCKET` is returned (which is essentially ~0U) to depict an
|
||||
error in the socket creation process. This conversion from ~0U to a pointer is
|
||||
used to convey the error to various functions. If the pointer is equal to
|
||||
`FREERTOS_INVALID_SOCKET`, then it is not dereferenced. Thus, this violation
|
||||
can be safely suppressed.
|
||||
|
||||
_Ref 11.4.2_
|
||||
|
||||
- MISRA Rule 11.4 The following statement may trigger a: warning: cast increases
|
||||
required alignment of target type [-Wcast-align]. It has been programatically
|
||||
checked that the pointer is well aligned before this point.
|
||||
|
||||
_Ref 11.4.3_
|
||||
|
||||
- MISRA Rule 11.4 warns about casting pointer to an integer and vice versa.
|
||||
Here, the pointer to the starting byte of the packet is cast to an integer
|
||||
which is then used to see whether the pointer is well aligned or not. It is
|
||||
not used to access any pointer values. Thus, this violation can be safely
|
||||
suppressed.
|
||||
|
||||
#### Rule 11.6
|
||||
|
||||
_Ref 11.6.1_
|
||||
|
||||
- When sending and receiving a DHCP event to the IP-stack, the events are
|
||||
converted to a void pointer and sent to the IP-task. The function used to send
|
||||
the events handles various events for the IP-task and thus only accepts void
|
||||
pointers. The IP-task converts the void pointer back to the original event.
|
||||
Thus, this rule can be safely suppressed.
|
||||
|
||||
_Ref 11.6.2_
|
||||
|
||||
- MISRA Rule 11.6 `uintptr_t` is guaranteed by the implementation to fit a
|
||||
pointer size of the platform. The pointer has to be moved backward by a
|
||||
constant offset to get to a 'hidden' pointer which is not available for the
|
||||
user to use. This conversion is done to achieve that while avoiding pointer
|
||||
arithmetic.
|
||||
|
||||
#### Rule 11.8
|
||||
|
||||
_Ref 11.8.1_
|
||||
|
||||
- MISRA c-2012 Rule 11.8 warns about removing the `const` qualifier when
|
||||
assigning one value to another. In this case however, a function pointer is
|
||||
being copied. It doesn't make sense in case of function pointers for the
|
||||
pointee to be const or mutable. Thus, this rule is safe to suppress. 1
|
||||
|
||||
#### Rule 14.3
|
||||
|
||||
_Ref 14.3.1_
|
||||
|
||||
- MISRA C-2012 Rule 14.3 False positive as the value might be changed depending
|
||||
on the conditionally compiled code
|
||||
- MISRA C-2012 Rule 14.3 The controlling expression compares sizeof against a
|
||||
configuration constant. The result is invariant for a given configuration but
|
||||
varies across different user configurations.
|
||||
|
||||
#### Rule 17.2
|
||||
|
||||
_Ref 17.2.1_
|
||||
|
||||
- MISRA C-2012 Rule 17.2 warns about using recursion in software as that can
|
||||
have severe implications on the stack usage and can lead to a serious issue.
|
||||
In this case however, the number of recursions are limited by design. Any
|
||||
socket spawned (child) by a socket in listening state (parent) cannot be in
|
||||
listening state. Thus it is not possible for the child to have a secondary
|
||||
child socket thereby limiting the number of recursive calls to one.
|
||||
|
||||
#### Rule 18.4
|
||||
|
||||
_Ref 18.4.1_
|
||||
|
||||
- MISRA C-2012 Rule 18.4 warns about using arithmetic operators such as `+`, `-`,
|
||||
`+=`, and `-=` not to be applied to an expression of pointer type. In this case
|
||||
however its ensured by review that, the explicitly calculated pointer value
|
||||
doesn't have the potential to access unintended or invalid memory addresses.
|
||||
|
||||
|
||||
#### Rule 20.5
|
||||
|
||||
_Ref 20.5.1_
|
||||
|
||||
- MISRA C-2012 Rule 20.5 warns against the use of #undef. FreeRTOS-Plus-TCP
|
||||
allows its users to set some configuration macros to modify the
|
||||
behavior/performance of the library according to their needs. However, the
|
||||
macros values must be within certain bounds. To achieve that, if the macro
|
||||
values lie outside of the bounds, they are undefined using `#undef` before
|
||||
being redefined to a proper value.
|
||||
|
||||
#### Rule 20.10
|
||||
|
||||
_Ref 20.10.1_
|
||||
|
||||
- MISRA C-2012 Rule 20.10 warns against the use of ## concatenation operator.
|
||||
However, in this case, it must be used to support compile time assertions in
|
||||
case the preprocessor does not suppport sizeof. This operation (assert) has no
|
||||
runtime execution.
|
||||
|
||||
#### Rule 21.6
|
||||
|
||||
_Ref 21.6.1_
|
||||
|
||||
- MISRA C-2012 Rule 21.6 warns about the use of standard library input/output
|
||||
functions as they might have implementation defined or undefined behaviour.
|
||||
The function `snprintf` is used to insert information in a logging string.
|
||||
This is only used in a utility function which aids in debugging and is not
|
||||
part of the 'core' code governing the functionality of the TCP/IP stack.
|
||||
@@ -0,0 +1,131 @@
|
||||
## FreeRTOS-Plus-TCP Library
|
||||
FreeRTOS-Plus-TCP is a lightweight TCP/IP stack for FreeRTOS. It provides a familiar Berkeley sockets interface, making it as simple to use and learn as possible. FreeRTOS-Plus-TCP's features and RAM footprint are fully scalable, making FreeRTOS-Plus-TCP equally applicable to smaller lower throughput microcontrollers as well as larger higher throughput microprocessors.
|
||||
|
||||
This library has undergone static code analysis and checks for compliance with the [MISRA coding standard](https://www.misra.org.uk/). Any deviations from the MISRA C:2012 guidelines are documented under [MISRA Deviations](https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md). The library is validated for memory safety and data structure invariance through the [CBMC automated reasoning tool](https://www.cprover.org/cbmc/) for the functions that parse data originating from the network. The library is also protocol tested using Maxwell protocol tester for both IPv4 and IPv6.
|
||||
|
||||
**FreeRTOS-Plus-TCP Library V4.2.2
|
||||
[source code](https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/tree/V4.2.2/source)
|
||||
is part of the
|
||||
[FreeRTOS 202406.01 LTS](https://github.com/FreeRTOS/FreeRTOS-LTS/tree/202406.01-LTS)
|
||||
release.**
|
||||
|
||||
## Getting started
|
||||
The easiest way to use version 4.0.0 and later of FreeRTOS-Plus-TCP is to refer the Getting started Guide (found [here](https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/GettingStarted.md))
|
||||
Another way is to start with the pre-configured IPv4 Windows Simulator demo (found in [this directory](https://github.com/FreeRTOS/FreeRTOS/tree/main/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_Minimal_Windows_Simulator)) or IPv6 Multi-endpoint Windows Simulator demo (found in [this directory](https://github.com/FreeRTOS/FreeRTOS/tree/main/FreeRTOS-Plus/Demo/FreeRTOS_Plus_TCP_IPv6_Demo/IPv6_Multi_WinSim_demo)). That way you will have the correct FreeRTOS source files included, and the correct include paths configured. Once a demo application is building and executing you can remove the demo application files, and start to add in your own application source files. See the [FreeRTOS Kernel Quick Start Guide](https://www.freertos.org/Documentation/01-FreeRTOS-quick-start/01-Beginners-guide/02-Quick-start-guide) for detailed instructions and other useful links.
|
||||
|
||||
Additionally, for FreeRTOS-Plus-TCP source code organization refer to the [Documentation](http://www.FreeRTOS.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/TCP_Networking_Tutorial.html), and [API Reference](https://freertos.org/Documentation/03-Libraries/02-FreeRTOS-plus/02-FreeRTOS-plus-TCP/09-API-reference/01-FreeRTOS-plus-TCP-APIs).
|
||||
|
||||
### Getting help
|
||||
If you have any questions or need assistance troubleshooting your FreeRTOS project, we have an active community that can help on the [FreeRTOS Community Support Forum](https://forums.freertos.org). Please also refer to [FAQ](https://www.freertos.org/Why-FreeRTOS/FAQs) for frequently asked questions.
|
||||
|
||||
Also see the [Submitting a bugs/feature request](https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/.github/CONTRIBUTING.md#submitting-a-bugsfeature-request) section of CONTRIBUTING.md for more details.
|
||||
|
||||
**Note:** All the remaining sections are generic and applies to all the versions from V3.0.0 onwards.
|
||||
|
||||
## Upgrading to V4.3.0 and above
|
||||
|
||||
For users of STM32 network interfaces:
|
||||
|
||||
Starting from version V4.3.0, the STM32 network interfaces have been consolidated into a single unified implementation located at `source/portable/NetworkInterface/STM32/NetworkInterface.c`, supporting STM32 F4, F7, and H7 series microcontrollers, with newly added support for STM32 H5. The new interface has been tested with the STM32 HAL Ethernet (ETH) drivers, available at `source/portable/NetworkInterface/STM32/Drivers`. For compatibility, the legacy interfaces (`STM32Fxx` and `STM32Hxx`) have been retained and relocated to `source/portable/NetworkInterface/STM32/Legacy`.
|
||||
|
||||
|
||||
## Upgrading to V3.0.0 and V3.1.0
|
||||
In version 3.0.0 or 3.1.0, the folder structure of FreeRTOS-Plus-TCP has changed and the files have been broken down into smaller logically separated modules. This change makes the code more modular and conducive to unit-tests. FreeRTOS-Plus-TCP V3.0.0 improves the robustness, security, and modularity of the library. Version 3.0.0 adds comprehensive unit test coverage for all lines and branches of code and has undergone protocol testing, and penetration testing by AWS Security to reduce the exposure to security vulnerabilities. Additionally, the source files have been moved to a `source` directory. This change requires modification of any existing project(s) to include the modified source files and directories.
|
||||
|
||||
**FreeRTOS-Plus-TCP V3.1.0 [source code](https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/tree/V3.1.0)(.c .h) is part of the [FreeRTOS 202210.00 LTS](https://github.com/FreeRTOS/FreeRTOS-LTS/tree/202210.00-LTS) release.**
|
||||
|
||||
### Generating pre V3.0.0 folder structure for backward compatibility:
|
||||
If you wish to continue using a version earlier than V3.0.0 i.e. continue to use your existing source code organization, a script is provided to generate the folder structure similar to [this](https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/tree/f118c8415b4373e3d6e6dbd2d5a116f7eaf27b63).
|
||||
|
||||
**Note:** After running the script, while the .c files will have same names as the pre V3.0.0 source, the files in the `include` directory will have different names and the number of files will differ as well. This should, however, not pose any problems to most projects as projects generally include all files in a given directory.
|
||||
|
||||
Running the script to generate pre V3.0.0 folder structure:
|
||||
For running the script, you will need Python version > 3.7. You can download/install it from [here](https://www.python.org/downloads/).
|
||||
|
||||
Once python is downloaded and installed, you can verify the version from your terminal/command window by typing `python --version`.
|
||||
|
||||
To run the script, you should switch to the FreeRTOS-Plus-TCP directory
|
||||
Then run `python <Path/to/the/script>/GenerateOriginalFiles.py`.
|
||||
|
||||
## To consume FreeRTOS+TCP
|
||||
|
||||
### Consume with CMake
|
||||
If using CMake, it is recommended to use this repository using FetchContent.
|
||||
Add the following into your project's main or a subdirectory's `CMakeLists.txt`:
|
||||
|
||||
- Define the source and version/tag you want to use:
|
||||
|
||||
```cmake
|
||||
FetchContent_Declare( freertos_plus_tcp
|
||||
GIT_REPOSITORY https://github.com/FreeRTOS/FreeRTOS-Plus-TCP.git
|
||||
GIT_TAG main #Note: Best practice to use specific git-hash or tagged version
|
||||
GIT_SUBMODULES "" # Don't grab any submodules since not latest
|
||||
)
|
||||
```
|
||||
|
||||
- Configure the FreeRTOS-Kernel and make it available
|
||||
- this particular example supports a native and cross-compiled build option.
|
||||
|
||||
```cmake
|
||||
# Select the native compile PORT
|
||||
set( FREERTOS_PLUS_TCP_NETWORK_IF "POSIX" CACHE STRING "" FORCE)
|
||||
# Or: select a cross-compile PORT
|
||||
if (CMAKE_CROSSCOMPILING)
|
||||
# Eg. STM32Hxx version of port
|
||||
set(FREERTOS_PLUS_TCP_NETWORK_IF "STM32HXX" CACHE STRING "" FORCE)
|
||||
endif()
|
||||
|
||||
FetchContent_MakeAvailable(freertos_plus_tcp)
|
||||
```
|
||||
|
||||
### Consuming stand-alone
|
||||
|
||||
This repository uses [Git Submodules](https://git-scm.com/book/en/v2/Git-Tools-Submodules) to bring in dependent components.
|
||||
|
||||
Note: If you download the ZIP file provided by GitHub UI, you will not get the contents of the submodules. (The ZIP file is also not a valid Git repository)
|
||||
|
||||
To clone using HTTPS:
|
||||
```
|
||||
git clone https://github.com/FreeRTOS/FreeRTOS-Plus-TCP.git ./FreeRTOS-Plus-TCP
|
||||
cd ./FreeRTOS-Plus-TCP
|
||||
git submodule update --checkout --init --recursive tools/CMock test/FreeRTOS-Kernel
|
||||
```
|
||||
Using SSH:
|
||||
```
|
||||
git clone git@github.com:FreeRTOS/FreeRTOS-Plus-TCP.git ./FreeRTOS-Plus-TCP
|
||||
cd ./FreeRTOS-Plus-TCP
|
||||
git submodule update --checkout --init --recursive tools/CMock test/FreeRTOS-Kernel
|
||||
```
|
||||
|
||||
## Porting
|
||||
The porting guide is available on [this page](https://www.freertos.org/Documentation/03-Libraries/02-FreeRTOS-plus/02-FreeRTOS-plus-TCP/10-Porting/01-FreeRTOS_TCP_Porting).
|
||||
|
||||
## Repository structure
|
||||
This repository contains the FreeRTOS-Plus-TCP repository and a number of supplementary libraries for testing/PR Checks.
|
||||
Below is the breakdown of what each directory contains:
|
||||
- tools
|
||||
- This directory contains the tools and related files (CMock/uncrustify) required to run tests/checks on the TCP source code.
|
||||
- tests
|
||||
- This directory contains all the tests (unit tests and CBMC) and the dependencies ([FreeRTOS-Kernel](https://github.com/FreeRTOS/FreeRTOS-Kernel)/[Litani-port](https://github.com/awslabs/aws-build-accumulator)) the tests require.
|
||||
- source/portable
|
||||
- This directory contains the portable files required to compile the FreeRTOS-Plus-TCP source code for different hardware/compilers.
|
||||
- source/include
|
||||
- The include directory has all the 'core' header files of FreeRTOS-Plus-TCP source.
|
||||
- source
|
||||
- This directory contains all the [.c] source files.
|
||||
|
||||
## Note
|
||||
At this time it is recommended to use BufferAllocation_2.c in which case it is essential to use the heap_4.c memory allocation scheme. See [memory management](http://www.FreeRTOS.org/a00111.html).
|
||||
|
||||
### Kernel sources
|
||||
The FreeRTOS Kernel Source is in [FreeRTOS/FreeRTOS-Kernel repository](https://github.com/FreeRTOS/FreeRTOS-Kernel), and it is consumed by testing/PR checks as a submodule in this repository.
|
||||
|
||||
The version of the FreeRTOS Kernel Source in use could be accessed at ```./test/FreeRTOS-Kernel``` directory.
|
||||
|
||||
## CBMC
|
||||
|
||||
The `test/cbmc/proofs` directory contains CBMC proofs.
|
||||
|
||||
To learn more about CBMC and proofs specifically, review the training material [here](https://model-checking.github.io/cbmc-training).
|
||||
|
||||
In order to run these proofs you will need to install CBMC and other tools by following the instructions [here](https://model-checking.github.io/cbmc-training/installation.html).
|
||||
@@ -0,0 +1,5 @@
|
||||
[{000214A0-0000-0000-C000-000000000046}]
|
||||
Prop3=19,2
|
||||
[InternetShortcut]
|
||||
URL=http://www.freertos.org/tcp
|
||||
IDList=
|
||||
@@ -0,0 +1,31 @@
|
||||
---
|
||||
$schema: https://raw.githubusercontent.com/streetsidesoftware/cspell/main/cspell.schema.json
|
||||
version: '0.2'
|
||||
# Allows things like stringLength
|
||||
allowCompoundWords: true
|
||||
|
||||
# Read files not to spell check from the git ignore
|
||||
useGitignore: true
|
||||
|
||||
# Language settings for C
|
||||
languageSettings:
|
||||
- caseSensitive: false
|
||||
enabled: true
|
||||
languageId: c
|
||||
locale: "*"
|
||||
|
||||
# Add a dictionary, and the path to the word list
|
||||
dictionaryDefinitions:
|
||||
- name: freertos-words
|
||||
path: '.github/.cSpellWords.txt'
|
||||
addWords: true
|
||||
|
||||
dictionaries:
|
||||
- freertos-words
|
||||
|
||||
# Paths and files to ignore
|
||||
ignorePaths:
|
||||
- 'dependency'
|
||||
- 'docs'
|
||||
- 'ThirdParty'
|
||||
- 'History.txt'
|
||||
+2782
File diff suppressed because it is too large.
Load diff
+228
@@ -0,0 +1,228 @@
|
||||
<doxygenlayout version="1.0">
|
||||
<!-- Generated by doxygen 1.8.20 -->
|
||||
<!-- Navigation index tabs for HTML output -->
|
||||
<navindex>
|
||||
<tab type="mainpage" visible="yes" title=""/>
|
||||
<tab type="pages" visible="yes" title="" intro=""/>
|
||||
<!-- Hide the default "Data Structures" tab and use the "Modules" tab for data
|
||||
structures. This allows internal data structures to be hidden. -->
|
||||
<tab type="modules" visible="yes" title="Data types and Constants" intro="This library defines the following data types and constants."/>
|
||||
<tab type="namespaces" visible="yes" title="">
|
||||
<tab type="namespacelist" visible="yes" title="" intro=""/>
|
||||
<tab type="namespacemembers" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="interfaces" visible="no" title="">
|
||||
<tab type="interfacelist" visible="no" title="" intro=""/>
|
||||
<tab type="interfaceindex" visible="no" title=""/>
|
||||
<tab type="interfacehierarchy" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="classes" visible="no" title="">
|
||||
<tab type="classlist" visible="no" title="" intro=""/>
|
||||
<tab type="classindex" visible="no" title=""/>
|
||||
<tab type="hierarchy" visible="no" title="" intro=""/>
|
||||
<tab type="classmembers" visible="no" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="structs" visible="no" title="">
|
||||
<tab type="structlist" visible="no" title="" intro=""/>
|
||||
<tab type="structindex" visible="no" title=""/>
|
||||
</tab>
|
||||
<tab type="exceptions" visible="no" title="">
|
||||
<tab type="exceptionlist" visible="no" title="" intro=""/>
|
||||
<tab type="exceptionindex" visible="no" title=""/>
|
||||
<tab type="exceptionhierarchy" visible="yes" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="files" visible="no" title="">
|
||||
<tab type="filelist" visible="yes" title="Files" intro="The following files are associated with this library."/>
|
||||
<tab type="globals" visible="no" title="" intro=""/>
|
||||
</tab>
|
||||
<tab type="examples" visible="yes" title="" intro=""/>
|
||||
</navindex>
|
||||
|
||||
<!-- Layout definition for a class page -->
|
||||
<class>
|
||||
<briefdescription visible="yes"/>
|
||||
<includes visible="$SHOW_INCLUDE_FILES"/>
|
||||
<inheritancegraph visible="$CLASS_GRAPH"/>
|
||||
<collaborationgraph visible="$COLLABORATION_GRAPH"/>
|
||||
<memberdecl>
|
||||
<nestedclasses visible="yes" title=""/>
|
||||
<publictypes title=""/>
|
||||
<services title=""/>
|
||||
<interfaces title=""/>
|
||||
<publicslots title=""/>
|
||||
<signals title=""/>
|
||||
<publicmethods title=""/>
|
||||
<publicstaticmethods title=""/>
|
||||
<publicattributes title=""/>
|
||||
<publicstaticattributes title=""/>
|
||||
<protectedtypes title=""/>
|
||||
<protectedslots title=""/>
|
||||
<protectedmethods title=""/>
|
||||
<protectedstaticmethods title=""/>
|
||||
<protectedattributes title=""/>
|
||||
<protectedstaticattributes title=""/>
|
||||
<packagetypes title=""/>
|
||||
<packagemethods title=""/>
|
||||
<packagestaticmethods title=""/>
|
||||
<packageattributes title=""/>
|
||||
<packagestaticattributes title=""/>
|
||||
<properties title=""/>
|
||||
<events title=""/>
|
||||
<privatetypes title=""/>
|
||||
<privateslots title=""/>
|
||||
<privatemethods title=""/>
|
||||
<privatestaticmethods title=""/>
|
||||
<privateattributes title=""/>
|
||||
<privatestaticattributes title=""/>
|
||||
<friends title=""/>
|
||||
<related title="" subtitle=""/>
|
||||
<membergroups visible="yes"/>
|
||||
</memberdecl>
|
||||
<detaileddescription title=""/>
|
||||
<memberdef>
|
||||
<inlineclasses title=""/>
|
||||
<typedefs title=""/>
|
||||
<enums title=""/>
|
||||
<services title=""/>
|
||||
<interfaces title=""/>
|
||||
<constructors title=""/>
|
||||
<functions title=""/>
|
||||
<related title=""/>
|
||||
<variables title=""/>
|
||||
<properties title=""/>
|
||||
<events title=""/>
|
||||
</memberdef>
|
||||
<allmemberslink visible="yes"/>
|
||||
<usedfiles visible="$SHOW_USED_FILES"/>
|
||||
<authorsection visible="yes"/>
|
||||
</class>
|
||||
|
||||
<!-- Layout definition for a namespace page -->
|
||||
<namespace>
|
||||
<briefdescription visible="yes"/>
|
||||
<memberdecl>
|
||||
<nestednamespaces visible="yes" title=""/>
|
||||
<constantgroups visible="yes" title=""/>
|
||||
<interfaces visible="yes" title=""/>
|
||||
<classes visible="yes" title=""/>
|
||||
<structs visible="yes" title=""/>
|
||||
<exceptions visible="yes" title=""/>
|
||||
<typedefs title=""/>
|
||||
<sequences title=""/>
|
||||
<dictionaries title=""/>
|
||||
<enums title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<membergroups visible="yes"/>
|
||||
</memberdecl>
|
||||
<detaileddescription title=""/>
|
||||
<memberdef>
|
||||
<inlineclasses title=""/>
|
||||
<typedefs title=""/>
|
||||
<sequences title=""/>
|
||||
<dictionaries title=""/>
|
||||
<enums title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
</memberdef>
|
||||
<authorsection visible="yes"/>
|
||||
</namespace>
|
||||
|
||||
<!-- Layout definition for a file page -->
|
||||
<file>
|
||||
<briefdescription visible="yes"/>
|
||||
<includes visible="$SHOW_INCLUDE_FILES"/>
|
||||
<includegraph visible="$INCLUDE_GRAPH"/>
|
||||
<includedbygraph visible="$INCLUDED_BY_GRAPH"/>
|
||||
<sourcelink visible="yes"/>
|
||||
<memberdecl>
|
||||
<interfaces visible="yes" title=""/>
|
||||
<classes visible="yes" title=""/>
|
||||
<structs visible="yes" title=""/>
|
||||
<exceptions visible="yes" title=""/>
|
||||
<namespaces visible="yes" title=""/>
|
||||
<constantgroups visible="yes" title=""/>
|
||||
<defines title=""/>
|
||||
<typedefs title=""/>
|
||||
<sequences title=""/>
|
||||
<dictionaries title=""/>
|
||||
<enums title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<membergroups visible="yes"/>
|
||||
</memberdecl>
|
||||
<detaileddescription title=""/>
|
||||
<memberdef>
|
||||
<inlineclasses title=""/>
|
||||
<defines title=""/>
|
||||
<typedefs title=""/>
|
||||
<sequences title=""/>
|
||||
<dictionaries title=""/>
|
||||
<enums title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
</memberdef>
|
||||
<authorsection/>
|
||||
</file>
|
||||
|
||||
<!-- Layout definition for a group page -->
|
||||
<group>
|
||||
<briefdescription visible="yes"/>
|
||||
<groupgraph visible="$GROUP_GRAPHS"/>
|
||||
<memberdecl>
|
||||
<nestedgroups visible="yes" title=""/>
|
||||
<dirs visible="yes" title=""/>
|
||||
<files visible="yes" title=""/>
|
||||
<namespaces visible="yes" title=""/>
|
||||
<classes visible="yes" title=""/>
|
||||
<defines title=""/>
|
||||
<typedefs title=""/>
|
||||
<sequences title=""/>
|
||||
<dictionaries title=""/>
|
||||
<enums title=""/>
|
||||
<enumvalues title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<signals title=""/>
|
||||
<publicslots title=""/>
|
||||
<protectedslots title=""/>
|
||||
<privateslots title=""/>
|
||||
<events title=""/>
|
||||
<properties title=""/>
|
||||
<friends title=""/>
|
||||
<membergroups visible="yes"/>
|
||||
</memberdecl>
|
||||
<detaileddescription title=""/>
|
||||
<memberdef>
|
||||
<pagedocs/>
|
||||
<inlineclasses title=""/>
|
||||
<defines title=""/>
|
||||
<typedefs title=""/>
|
||||
<sequences title=""/>
|
||||
<dictionaries title=""/>
|
||||
<enums title=""/>
|
||||
<enumvalues title=""/>
|
||||
<functions title=""/>
|
||||
<variables title=""/>
|
||||
<signals title=""/>
|
||||
<publicslots title=""/>
|
||||
<protectedslots title=""/>
|
||||
<privateslots title=""/>
|
||||
<events title=""/>
|
||||
<properties title=""/>
|
||||
<friends title=""/>
|
||||
</memberdef>
|
||||
<authorsection visible="yes"/>
|
||||
</group>
|
||||
|
||||
<!-- Layout definition for a directory page -->
|
||||
<directory>
|
||||
<briefdescription visible="yes"/>
|
||||
<directorygraph visible="yes"/>
|
||||
<memberdecl>
|
||||
<dirs visible="yes"/>
|
||||
<files visible="yes"/>
|
||||
</memberdecl>
|
||||
<detaileddescription title=""/>
|
||||
</directory>
|
||||
</doxygenlayout>
|
||||
+132
@@ -0,0 +1,132 @@
|
||||
/*
|
||||
* Stylesheet for Doxygen HTML output.
|
||||
*
|
||||
* This file defines styles for custom elements in the header/footer and
|
||||
* overrides some of the default Doxygen styles.
|
||||
*
|
||||
* Styles in this file do not affect the treeview sidebar.
|
||||
*/
|
||||
|
||||
/* Set the margins to place a small amount of whitespace on the left and right
|
||||
* side of the page. */
|
||||
div.contents {
|
||||
margin-left:4em;
|
||||
margin-right:4em;
|
||||
}
|
||||
|
||||
/* Justify text in paragraphs. */
|
||||
p {
|
||||
text-align: justify;
|
||||
}
|
||||
|
||||
/* Style of section headings. */
|
||||
h1 {
|
||||
border-bottom: 1px solid #879ECB;
|
||||
color: #354C7B;
|
||||
font-size: 160%;
|
||||
font-weight: normal;
|
||||
padding-bottom: 4px;
|
||||
padding-top: 8px;
|
||||
}
|
||||
|
||||
/* Style of subsection headings. */
|
||||
h2:not(.memtitle):not(.groupheader) {
|
||||
font-size: 125%;
|
||||
margin-bottom: 0px;
|
||||
margin-top: 16px;
|
||||
padding: 0px;
|
||||
}
|
||||
|
||||
/* Style of paragraphs immediately after subsection headings. */
|
||||
h2 + p {
|
||||
margin: 0px;
|
||||
padding: 0px;
|
||||
}
|
||||
|
||||
/* Style of subsection headings. */
|
||||
h3 {
|
||||
font-size: 100%;
|
||||
margin-bottom: 0px;
|
||||
margin-left: 2em;
|
||||
margin-right: 2em;
|
||||
}
|
||||
|
||||
/* Style of paragraphs immediately after subsubsection headings. */
|
||||
h3 + p {
|
||||
margin-top: 0px;
|
||||
margin-left: 2em;
|
||||
margin-right: 2em;
|
||||
}
|
||||
|
||||
/* Style of the prefix "AWS IoT Device SDK C" that appears in the header. */
|
||||
#csdkprefix {
|
||||
color: #757575;
|
||||
}
|
||||
|
||||
/* Style of the "Return to main page" link that appears in the header. */
|
||||
#returntomain {
|
||||
padding: 0.5em;
|
||||
}
|
||||
|
||||
/* Style of the dividers on Configuration Settings pages. */
|
||||
div.configpagedivider {
|
||||
margin-left: 0px !important;
|
||||
margin-right: 0px !important;
|
||||
margin-top: 20px !important;
|
||||
}
|
||||
|
||||
/* Style of configuration setting names. */
|
||||
dl.section.user ~ h1 {
|
||||
border-bottom: none;
|
||||
color: #000000;
|
||||
font-family: monospace, fixed;
|
||||
font-size: 16px;
|
||||
margin-bottom: 0px;
|
||||
margin-left: 2em;
|
||||
margin-top: 1.5em;
|
||||
}
|
||||
|
||||
/* Style of paragraphs on a configuration settings page. */
|
||||
dl.section.user ~ * {
|
||||
margin-bottom: 10px;
|
||||
margin-left: 4em;
|
||||
margin-right: 4em;
|
||||
margin-top: 0px;
|
||||
}
|
||||
|
||||
/* Hide the configuration setting marker. */
|
||||
dl.section.user {
|
||||
display: none;
|
||||
}
|
||||
|
||||
/* Overrides for code fragments and lines. */
|
||||
div.fragment {
|
||||
background: #ffffff;
|
||||
border: none;
|
||||
padding: 5px;
|
||||
}
|
||||
|
||||
div.line {
|
||||
color: #3a3a3a;
|
||||
}
|
||||
|
||||
/* Overrides for code syntax highlighting colors. */
|
||||
span.comment {
|
||||
color: #008000;
|
||||
}
|
||||
|
||||
span.keyword, span.keywordtype, span.keywordflow {
|
||||
color: #0000ff;
|
||||
}
|
||||
|
||||
span.preprocessor {
|
||||
color: #50015a;
|
||||
}
|
||||
|
||||
span.stringliteral, span.charliteral {
|
||||
color: #800c0c;
|
||||
}
|
||||
|
||||
a.code, a.code:visited, a.line, a.line:visited {
|
||||
color: #496194;
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
name: "FreeRTOS-Plus-TCP"
|
||||
version: "V4.4.1"
|
||||
description:
|
||||
"Thread safe FreeRTOS TCP/IP stack working on top of the FreeRTOS-Kernel to
|
||||
implement the TCP/IP protocol. Suitable for microcontrollers."
|
||||
license: "MIT"
|
||||
dependencies:
|
||||
- name: "FreeRTOS-Kernel"
|
||||
version: "V11.1.0"
|
||||
license: "MIT"
|
||||
repository:
|
||||
type: "git"
|
||||
url: "https://github.com/FreeRTOS/FreeRTOS-Kernel.git"
|
||||
path: "test/FreeRTOS-Kernel"
|
||||
branch: "main"
|
||||
|
||||
- name: "CMock"
|
||||
version: "afa2949"
|
||||
license: "MIT"
|
||||
repository:
|
||||
type: "git"
|
||||
url: "https://github.com/ThrowTheSwitch/CMock.git"
|
||||
path: "tools/CMock"
|
||||
@@ -0,0 +1,18 @@
|
||||
Contains the files that implement FreeRTOS+TCP.
|
||||
|
||||
User documentation, including an API reference is available on:
|
||||
http://www.FreeRTOS.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/
|
||||
|
||||
A description of the source code organisation is available on:
|
||||
http://www.FreeRTOS.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/TCP_Networking_Tutorial.html
|
||||
|
||||
The porting guide is available on:
|
||||
https://www.freertos.org/Documentation/03-Libraries/02-FreeRTOS-plus/02-FreeRTOS-plus-TCP/10-Porting/01-FreeRTOS_TCP_Porting
|
||||
|
||||
License information is available on:
|
||||
http://www.FreeRTOS.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/FreeRTOS_Plus_TCP_License.html
|
||||
|
||||
At this time it is recommended to use BufferAllocation_2.c in which case it is
|
||||
essential to use the heap_4.c memory allocation scheme:
|
||||
http://www.FreeRTOS.org/a00111.html
|
||||
|
||||
+111
@@ -0,0 +1,111 @@
|
||||
add_library( freertos_plus_tcp STATIC )
|
||||
|
||||
target_sources( freertos_plus_tcp
|
||||
PRIVATE
|
||||
include/FreeRTOS_ARP.h
|
||||
include/FreeRTOS_BitConfig.h
|
||||
include/FreeRTOS_DHCP.h
|
||||
include/FreeRTOS_DHCPv6.h
|
||||
include/FreeRTOS_DNS.h
|
||||
include/FreeRTOS_DNS_Cache.h
|
||||
include/FreeRTOS_DNS_Callback.h
|
||||
include/FreeRTOS_DNS_Globals.h
|
||||
include/FreeRTOS_DNS_Networking.h
|
||||
include/FreeRTOS_DNS_Parser.h
|
||||
include/FreeRTOS_ICMP.h
|
||||
include/FreeRTOS_IP.h
|
||||
include/FreeRTOS_IP_Common.h
|
||||
include/FreeRTOS_IP_Private.h
|
||||
include/FreeRTOS_IP_Timers.h
|
||||
include/FreeRTOS_IP_Utils.h
|
||||
include/FreeRTOS_IPv4.h
|
||||
include/FreeRTOS_IPv4_Private.h
|
||||
include/FreeRTOS_IPv4_Sockets.h
|
||||
include/FreeRTOS_IPv4_Utils.h
|
||||
include/FreeRTOS_IPv6.h
|
||||
include/FreeRTOS_IPv6_Private.h
|
||||
include/FreeRTOS_IPv6_Sockets.h
|
||||
include/FreeRTOS_IPv6_Utils.h
|
||||
include/FreeRTOS_ND.h
|
||||
include/FreeRTOS_Routing.h
|
||||
include/FreeRTOS_Sockets.h
|
||||
include/FreeRTOS_Stream_Buffer.h
|
||||
include/FreeRTOS_TCP_IP.h
|
||||
include/FreeRTOS_TCP_Reception.h
|
||||
include/FreeRTOS_TCP_State_Handling.h
|
||||
include/FreeRTOS_TCP_Transmission.h
|
||||
include/FreeRTOS_TCP_Utils.h
|
||||
include/FreeRTOS_TCP_WIN.h
|
||||
include/FreeRTOS_UDP_IP.h
|
||||
include/FreeRTOSIPConfigDefaults.h
|
||||
include/FreeRTOSIPDeprecatedDefinitions.h
|
||||
include/IPTraceMacroDefaults.h
|
||||
include/NetworkBufferManagement.h
|
||||
include/NetworkInterface.h
|
||||
|
||||
FreeRTOS_ARP.c
|
||||
FreeRTOS_BitConfig.c
|
||||
FreeRTOS_DHCP.c
|
||||
FreeRTOS_DHCPv6.c
|
||||
FreeRTOS_DNS.c
|
||||
FreeRTOS_DNS_Cache.c
|
||||
FreeRTOS_DNS_Callback.c
|
||||
FreeRTOS_DNS_Networking.c
|
||||
FreeRTOS_DNS_Parser.c
|
||||
FreeRTOS_ICMP.c
|
||||
FreeRTOS_IP.c
|
||||
FreeRTOS_IP_Timers.c
|
||||
FreeRTOS_IP_Utils.c
|
||||
FreeRTOS_IPv4.c
|
||||
FreeRTOS_IPv4_Sockets.c
|
||||
FreeRTOS_IPv4_Utils.c
|
||||
FreeRTOS_IPv6.c
|
||||
FreeRTOS_IPv6_Sockets.c
|
||||
FreeRTOS_IPv6_Utils.c
|
||||
FreeRTOS_ND.c
|
||||
FreeRTOS_RA.c
|
||||
FreeRTOS_Routing.c
|
||||
FreeRTOS_Sockets.c
|
||||
FreeRTOS_Stream_Buffer.c
|
||||
FreeRTOS_TCP_IP.c
|
||||
FreeRTOS_TCP_IP_IPv4.c
|
||||
FreeRTOS_TCP_IP_IPv6.c
|
||||
FreeRTOS_TCP_Reception.c
|
||||
FreeRTOS_TCP_State_Handling.c
|
||||
FreeRTOS_TCP_State_Handling_IPv4.c
|
||||
FreeRTOS_TCP_State_Handling_IPv6.c
|
||||
FreeRTOS_TCP_Transmission.c
|
||||
FreeRTOS_TCP_Transmission_IPv4.c
|
||||
FreeRTOS_TCP_Transmission_IPv6.c
|
||||
FreeRTOS_TCP_Utils.c
|
||||
FreeRTOS_TCP_Utils_IPv4.c
|
||||
FreeRTOS_TCP_Utils_IPv6.c
|
||||
FreeRTOS_TCP_WIN.c
|
||||
FreeRTOS_Tiny_TCP.c
|
||||
FreeRTOS_UDP_IP.c
|
||||
FreeRTOS_UDP_IPv4.c
|
||||
FreeRTOS_UDP_IPv6.c
|
||||
)
|
||||
|
||||
target_include_directories( freertos_plus_tcp
|
||||
PUBLIC
|
||||
include
|
||||
)
|
||||
|
||||
if(STANDALONE_TEST_BUILD_UNIX)
|
||||
target_include_directories(freertos_plus_tcp
|
||||
PUBLIC
|
||||
${CMAKE_CURRENT_SOURCE_DIR}/../test/build-combination/DefaultConf )
|
||||
endif()
|
||||
|
||||
target_link_libraries( freertos_plus_tcp
|
||||
PUBLIC
|
||||
freertos_config
|
||||
freertos_plus_tcp_port # for pack_struct_start.h
|
||||
PRIVATE
|
||||
freertos_kernel
|
||||
freertos_plus_tcp_network_if
|
||||
freertos_plus_tcp_utilities
|
||||
)
|
||||
|
||||
add_subdirectory(portable)
|
||||
+1477
File diff suppressed because it is too large.
Load diff
+354
@@ -0,0 +1,354 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_BitConfig.c
|
||||
* @brief Some functions that help when analysing a binary stream of information.
|
||||
* It offers an alternative to using packet structs with unaligned data members.
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
#include "semphr.h"
|
||||
|
||||
/* FreeRTOS+TCP includes. */
|
||||
#include "FreeRTOS_IP.h"
|
||||
#include "FreeRTOS_UDP_IP.h"
|
||||
#include "FreeRTOS_Sockets.h"
|
||||
#include "FreeRTOS_BitConfig.h"
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Initialise a bit-config struct.
|
||||
*
|
||||
* @param[in] pxConfig The structure containing a copy of the bits.
|
||||
* @param[in] pucData Not NULL if a bit-stream must be analysed, otherwise NULL.
|
||||
* @param[in] uxSize The length of the binary data stream.
|
||||
*
|
||||
* @return pdTRUE if the malloc was OK, otherwise pdFALSE.
|
||||
*/
|
||||
BaseType_t xBitConfig_init( BitConfig_t * pxConfig,
|
||||
const uint8_t * pucData,
|
||||
size_t uxSize )
|
||||
{
|
||||
BaseType_t xResult = pdFALSE;
|
||||
|
||||
( void ) memset( ( void * ) pxConfig, 0, sizeof( *pxConfig ) );
|
||||
pxConfig->ucContents = ( uint8_t * ) pvPortMalloc( uxSize );
|
||||
|
||||
if( pxConfig->ucContents != NULL )
|
||||
{
|
||||
pxConfig->uxSize = uxSize;
|
||||
|
||||
if( pucData != NULL )
|
||||
{
|
||||
( void ) memcpy( pxConfig->ucContents, pucData, uxSize );
|
||||
}
|
||||
else
|
||||
{
|
||||
( void ) memset( pxConfig->ucContents, 0, uxSize );
|
||||
}
|
||||
|
||||
xResult = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
pxConfig->xHasError = pdTRUE;
|
||||
}
|
||||
|
||||
return xResult;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Read from a bit-config struct.
|
||||
*
|
||||
* @param[in] pxConfig The structure containing a copy of the bits.
|
||||
* @param[in] pucData Not NULL if a bit-stream must be analysed, otherwise NULL.
|
||||
* @param[in] uxSize The length of the binary data stream.
|
||||
*
|
||||
* @return pdTRUE if the malloc was OK, otherwise pdFALSE.
|
||||
*/
|
||||
BaseType_t xBitConfig_read_uc( BitConfig_t * pxConfig,
|
||||
uint8_t * pucData,
|
||||
size_t uxSize )
|
||||
{
|
||||
BaseType_t xResult = pdFALSE;
|
||||
const size_t uxNeeded = uxSize;
|
||||
|
||||
if( pxConfig->xHasError == pdFALSE )
|
||||
{
|
||||
if( ( pxConfig->uxIndex + uxNeeded ) <= pxConfig->uxSize )
|
||||
{
|
||||
if( pucData != NULL )
|
||||
{
|
||||
( void ) memcpy( pucData, &( pxConfig->ucContents[ pxConfig->uxIndex ] ), uxNeeded );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Caller just wants to skip some bytes. */
|
||||
}
|
||||
|
||||
pxConfig->uxIndex += uxNeeded;
|
||||
xResult = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
pxConfig->xHasError = pdTRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return xResult;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Peek the last byte from a bit-config struct.
|
||||
*
|
||||
* @param[in] pxConfig The structure containing a copy of the bits.
|
||||
* @param[in] pucData The buffer to stored peeked data.
|
||||
* @param[in] uxSize The length of the binary data stream.
|
||||
*
|
||||
* @return pdTRUE if the malloc was OK, otherwise pdFALSE.
|
||||
*/
|
||||
BaseType_t pucBitConfig_peek_last_index_uc( BitConfig_t * pxConfig,
|
||||
uint8_t * pucData,
|
||||
size_t uxSize )
|
||||
{
|
||||
BaseType_t xResult = pdFALSE;
|
||||
const size_t uxNeeded = uxSize;
|
||||
|
||||
if( pxConfig->xHasError == pdFALSE )
|
||||
{
|
||||
if( ( pxConfig->uxIndex >= uxNeeded ) && ( pucData != NULL ) )
|
||||
{
|
||||
( void ) memcpy( pucData, &( pxConfig->ucContents[ pxConfig->uxIndex - uxNeeded ] ), uxNeeded );
|
||||
|
||||
xResult = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Not support to peek length larger than write. */
|
||||
pxConfig->xHasError = pdTRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return xResult;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Read a byte from the bit stream.
|
||||
*
|
||||
* @param[in] pxConfig The structure containing a copy of the bits.
|
||||
*
|
||||
* @return A byte value. When there was not enough data, xHasError will be set.
|
||||
*/
|
||||
uint8_t ucBitConfig_read_8( BitConfig_t * pxConfig )
|
||||
{
|
||||
uint8_t ucResult = 0xffU;
|
||||
const size_t uxNeeded = sizeof ucResult;
|
||||
uint8_t pucData[ sizeof ucResult ];
|
||||
|
||||
if( xBitConfig_read_uc( pxConfig, pucData, uxNeeded ) != pdFALSE )
|
||||
{
|
||||
ucResult = pucData[ 0 ];
|
||||
}
|
||||
|
||||
return ucResult;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Read 2 bytes from the bit stream.
|
||||
*
|
||||
* @param[in] pxConfig The structure containing a copy of the bits.
|
||||
*
|
||||
* @return A 16-bit value. When there was not enough data, xHasError will be set.
|
||||
*/
|
||||
uint16_t usBitConfig_read_16( BitConfig_t * pxConfig )
|
||||
{
|
||||
uint16_t usResult = 0xffffU;
|
||||
const size_t uxNeeded = sizeof usResult;
|
||||
uint8_t pucData[ sizeof usResult ];
|
||||
|
||||
if( xBitConfig_read_uc( pxConfig, pucData, uxNeeded ) != pdFALSE )
|
||||
{
|
||||
usResult = ( uint16_t ) ( ( ( ( uint16_t ) pucData[ 0 ] ) << 8 ) |
|
||||
( ( ( uint16_t ) pucData[ 1 ] ) ) );
|
||||
}
|
||||
|
||||
return usResult;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Read 4 bytes from the bit stream.
|
||||
*
|
||||
* @param[in] pxConfig The structure containing a copy of the bits.
|
||||
*
|
||||
* @return A 32-bit value. When there was not enough data, xHasError will be set.
|
||||
*/
|
||||
uint32_t ulBitConfig_read_32( BitConfig_t * pxConfig )
|
||||
{
|
||||
uint32_t ulResult = 0xffffffffU;
|
||||
const size_t uxNeeded = sizeof ulResult;
|
||||
uint8_t pucData[ sizeof ulResult ];
|
||||
|
||||
if( xBitConfig_read_uc( pxConfig, pucData, uxNeeded ) != pdFALSE )
|
||||
{
|
||||
ulResult = ( ( ( uint32_t ) pucData[ 0 ] ) << 24 ) |
|
||||
( ( ( uint32_t ) pucData[ 1 ] ) << 16 ) |
|
||||
( ( ( uint32_t ) pucData[ 2 ] ) << 8 ) |
|
||||
( ( ( uint32_t ) pucData[ 3 ] ) );
|
||||
}
|
||||
|
||||
return ulResult;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Read any number bytes from the bit stream.
|
||||
*
|
||||
* @param[in] pxConfig The structure containing a copy of the bit stream.
|
||||
* @param[in] pucData The binary data to be written.
|
||||
* @param[in] uxSize The number of bytes to be written.
|
||||
*
|
||||
* There is no return value. If the operation has failed,
|
||||
* the field xHasError will be set.
|
||||
*/
|
||||
void vBitConfig_write_uc( BitConfig_t * pxConfig,
|
||||
const uint8_t * pucData,
|
||||
size_t uxSize )
|
||||
{
|
||||
const size_t uxNeeded = uxSize;
|
||||
|
||||
if( pxConfig->xHasError == pdFALSE )
|
||||
{
|
||||
if( pxConfig->uxIndex <= ( pxConfig->uxSize - uxNeeded ) )
|
||||
{
|
||||
uint8_t * pucDestination = &( pxConfig->ucContents[ pxConfig->uxIndex ] );
|
||||
( void ) memcpy( pucDestination, pucData, uxNeeded );
|
||||
pxConfig->uxIndex += uxNeeded;
|
||||
}
|
||||
else
|
||||
{
|
||||
pxConfig->xHasError = pdTRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Write a byte to the bit stream.
|
||||
*
|
||||
* @param[in] pxConfig The structure containing a copy of the bits.
|
||||
* @param[in] ucValue The byte to be written.
|
||||
*
|
||||
* There is no return value. If the operation has failed,
|
||||
* the field xHasError will be set.
|
||||
*/
|
||||
void vBitConfig_write_8( BitConfig_t * pxConfig,
|
||||
uint8_t ucValue )
|
||||
{
|
||||
const size_t uxNeeded = sizeof ucValue;
|
||||
|
||||
vBitConfig_write_uc( pxConfig, &( ucValue ), uxNeeded );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Write a short word to the bit stream.
|
||||
*
|
||||
* @param[in] pxConfig The structure containing a copy of the bits.
|
||||
* @param[in] usValue The 16-bit value to be written.
|
||||
*
|
||||
* There is no return value. If the operation has failed,
|
||||
* the field xHasError will be set.
|
||||
*/
|
||||
void vBitConfig_write_16( BitConfig_t * pxConfig,
|
||||
uint16_t usValue )
|
||||
{
|
||||
const size_t uxNeeded = sizeof usValue;
|
||||
uint8_t pucData[ sizeof usValue ];
|
||||
|
||||
pucData[ 0 ] = ( uint8_t ) ( ( usValue >> 8 ) & 0xFFU );
|
||||
pucData[ 1 ] = ( uint8_t ) ( usValue & 0xFFU );
|
||||
vBitConfig_write_uc( pxConfig, pucData, uxNeeded );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Write a 32-bit word to the bit stream.
|
||||
*
|
||||
* @param[in] pxConfig The structure containing a copy of the bits.
|
||||
* @param[in] ulValue The 32-bit value to be written.
|
||||
*
|
||||
* There is no return value. If the operation has failed,
|
||||
* the field xHasError will be set.
|
||||
*/
|
||||
void vBitConfig_write_32( BitConfig_t * pxConfig,
|
||||
uint32_t ulValue )
|
||||
{
|
||||
const size_t uxNeeded = sizeof ulValue;
|
||||
uint8_t pucData[ sizeof ulValue ];
|
||||
|
||||
pucData[ 0 ] = ( uint8_t ) ( ( ulValue >> 24 ) & 0xFFU );
|
||||
pucData[ 1 ] = ( uint8_t ) ( ( ulValue >> 16 ) & 0xFFU );
|
||||
pucData[ 2 ] = ( uint8_t ) ( ( ulValue >> 8 ) & 0xFFU );
|
||||
pucData[ 3 ] = ( uint8_t ) ( ulValue & 0xFFU );
|
||||
|
||||
vBitConfig_write_uc( pxConfig, pucData, uxNeeded );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Deallocate ( release ) the buffer, and clear the bit stream structure.
|
||||
* Note that the struct must have be initialised before calling this function.
|
||||
*
|
||||
* @param[in] pxConfig The structure containing a copy of the bits.
|
||||
*
|
||||
*/
|
||||
void vBitConfig_release( BitConfig_t * pxConfig )
|
||||
{
|
||||
if( pxConfig != NULL )
|
||||
{
|
||||
if( pxConfig->ucContents != NULL )
|
||||
{
|
||||
vPortFree( pxConfig->ucContents );
|
||||
}
|
||||
|
||||
( void ) memset( pxConfig, 0, sizeof( BitConfig_t ) );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Nothing to free */
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
+1721
File diff suppressed because it is too large.
Load diff
+1616
File diff suppressed because it is too large.
Load diff
+1687
File diff suppressed because it is too large.
Load diff
+682
@@ -0,0 +1,682 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_DNS_Cache.c
|
||||
* @brief File that handles the DNS caching option
|
||||
*/
|
||||
|
||||
/* FreeRTOS+TCP includes. */
|
||||
#include "FreeRTOS_IP.h"
|
||||
#include "FreeRTOS_Sockets.h"
|
||||
#include "FreeRTOS_UDP_IP.h"
|
||||
#include "FreeRTOS_DHCP.h"
|
||||
#include "NetworkBufferManagement.h"
|
||||
#include "NetworkInterface.h"
|
||||
|
||||
#include "FreeRTOS_DNS_Cache.h"
|
||||
#include "FreeRTOS_DNS_Globals.h"
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#if ( ( ipconfigUSE_DNS != 0 ) && ( ipconfigUSE_DNS_CACHE == 1 ) )
|
||||
|
||||
/*!
|
||||
* @brief DNS cache structure instantiation
|
||||
*/
|
||||
static DNSCacheRow_t xDNSCache[ ipconfigDNS_CACHE_ENTRIES ];
|
||||
|
||||
/*!
|
||||
* @brief indicates the index of a free entry in the cache structure
|
||||
* \a DNSCacheRow_t
|
||||
*/
|
||||
static UBaseType_t uxFreeEntry = 0U;
|
||||
|
||||
/** returns the index of the hostname entry in the dns cache. */
|
||||
static BaseType_t prvFindEntryIndex( const char * pcName,
|
||||
const IPv46_Address_t * pxIP,
|
||||
UBaseType_t * uxResult );
|
||||
|
||||
/** get entry at \p index from the cache. */
|
||||
static BaseType_t prvGetCacheIPEntry( UBaseType_t uxIndex,
|
||||
IPv46_Address_t * pxIP,
|
||||
uint32_t ulCurrentTimeSeconds,
|
||||
struct freertos_addrinfo ** ppxAddressInfo );
|
||||
|
||||
/** update entry at \p index in the cache. */
|
||||
static void prvUpdateCacheEntry( UBaseType_t uxIndex,
|
||||
uint32_t ulTTL,
|
||||
const IPv46_Address_t * pxIP,
|
||||
uint32_t ulCurrentTimeSeconds );
|
||||
|
||||
/** insert entry in the cache. */
|
||||
static void prvInsertCacheEntry( const char * pcName,
|
||||
uint32_t ulTTL,
|
||||
const IPv46_Address_t * pxIP,
|
||||
uint32_t ulCurrentTimeSeconds );
|
||||
|
||||
/** Copy DNS cache entries at xIndex to a linked struct addrinfo. */
|
||||
static void prvReadDNSCache( BaseType_t uxIndex,
|
||||
struct freertos_addrinfo ** ppxAddressInfo );
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ipconfigUSE_IPv4 != 0 )
|
||||
|
||||
/**
|
||||
* @brief perform a dns lookup in the local cache
|
||||
* @param pcHostName the lookup name
|
||||
* @return ulIPAddress with the value from the cache else returns a zero if the
|
||||
* cache is not enabled or the lookup is not successful
|
||||
* @post the global structure \a xDNSCache might be modified
|
||||
*/
|
||||
uint32_t FreeRTOS_dnslookup( const char * pcHostName )
|
||||
{
|
||||
IPv46_Address_t xIPv46_Address;
|
||||
|
||||
/* Looking up an IPv4 address in the DNS cache. */
|
||||
( void ) memset( &xIPv46_Address, 0, sizeof( xIPv46_Address ) );
|
||||
( void ) FreeRTOS_ProcessDNSCache( pcHostName,
|
||||
&( xIPv46_Address ),
|
||||
0,
|
||||
pdTRUE,
|
||||
NULL );
|
||||
|
||||
return xIPv46_Address.xIPAddress.ulIP_IPv4;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
#endif /* if ( ipconfigUSE_IPv4 != 0 ) */
|
||||
|
||||
#if ( ipconfigUSE_IPv6 != 0 )
|
||||
|
||||
/**
|
||||
* @brief Perform a dns lookup in the local cache (IPv6)
|
||||
* @param pcHostName The lookup name
|
||||
* @param pxAddress_IPv6 The IPv6 address looked up from the cache if the return value is non zero.
|
||||
* @return ulReturn Non zero if name is found in cache else returns a zero if the
|
||||
* cache is not enabled or the lookup is not successful
|
||||
* @post the global structure \a xDNSCache might be modified
|
||||
*/
|
||||
uint32_t FreeRTOS_dnslookup6( const char * pcHostName,
|
||||
IPv6_Address_t * pxAddress_IPv6 )
|
||||
{
|
||||
IPv46_Address_t xIPv46_Address;
|
||||
BaseType_t xResult;
|
||||
uint32_t ulReturn = 0U;
|
||||
|
||||
/* Looking up an IPv6 address in the DNS cache. */
|
||||
( void ) memset( &xIPv46_Address, 0, sizeof( xIPv46_Address ) );
|
||||
/* Let FreeRTOS_ProcessDNSCache only return IPv6 addresses. */
|
||||
xIPv46_Address.xIs_IPv6 = pdTRUE;
|
||||
xResult = FreeRTOS_ProcessDNSCache( pcHostName, &xIPv46_Address, 0, pdTRUE, NULL );
|
||||
|
||||
if( xResult != pdFALSE )
|
||||
{
|
||||
( void ) memcpy( pxAddress_IPv6->ucBytes, xIPv46_Address.xIPAddress.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
|
||||
ulReturn = 1U;
|
||||
}
|
||||
|
||||
return ulReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
#endif /* if ( ipconfigUSE_IPv6 != 0 ) */
|
||||
|
||||
/**
|
||||
* @brief perform a dns update in the local cache
|
||||
* @param pcName the lookup name
|
||||
* @param pxIP the ip value to insert/replace (IPv4/v6)
|
||||
* @param ulTTL Time To live (in seconds)
|
||||
* @param xLookUp Ignored
|
||||
* @param ppxAddressInfo A pointer to a pointer where the find results
|
||||
* will be stored.
|
||||
* @return this is a dummy return, we are actually ignoring the return value
|
||||
* from this function
|
||||
* @post the global structure \a xDNSCache might be modified
|
||||
*/
|
||||
BaseType_t FreeRTOS_dns_update( const char * pcName,
|
||||
IPv46_Address_t * pxIP,
|
||||
uint32_t ulTTL,
|
||||
BaseType_t xLookUp,
|
||||
struct freertos_addrinfo ** ppxAddressInfo )
|
||||
{
|
||||
/* _HT_ we can as well remove the parameter 'xLookUp'. */
|
||||
( void ) xLookUp;
|
||||
( void ) FreeRTOS_ProcessDNSCache( pcName,
|
||||
pxIP,
|
||||
ulTTL,
|
||||
pdFALSE,
|
||||
ppxAddressInfo );
|
||||
return pdTRUE;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief perform a dns clear in the local cache
|
||||
* @post the global structure \a xDNSCache is modified
|
||||
*/
|
||||
void FreeRTOS_dnsclear( void )
|
||||
{
|
||||
( void ) memset( xDNSCache, 0x0, sizeof( xDNSCache ) );
|
||||
uxFreeEntry = 0U;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief process a DNS Cache request (get, update, or insert)
|
||||
*
|
||||
* @param[in] pcName the name of the host
|
||||
* @param[in,out] pxIP when doing a lookup, will be set, when doing an update,
|
||||
* will be read.
|
||||
* @param[in] ulTTL Time To Live (in seconds)
|
||||
* @param[in] xLookUp pdTRUE if a look-up is expected, pdFALSE, when the DNS cache must
|
||||
* be updated.
|
||||
* @param[in,out] ppxAddressInfo A pointer to a pointer where the find results
|
||||
* will be stored.
|
||||
* @return whether the operation was successful
|
||||
* @post the global structure \a xDNSCache might be modified
|
||||
*/
|
||||
BaseType_t FreeRTOS_ProcessDNSCache( const char * pcName,
|
||||
IPv46_Address_t * pxIP,
|
||||
uint32_t ulTTL,
|
||||
BaseType_t xLookUp,
|
||||
struct freertos_addrinfo ** ppxAddressInfo )
|
||||
{
|
||||
UBaseType_t uxIndex;
|
||||
BaseType_t xResult;
|
||||
/* Get the current time in clock-ticks. */
|
||||
TickType_t xCurrentTickCount = xTaskGetTickCount();
|
||||
/* In milliseconds. */
|
||||
uint32_t ulCurrentTimeSeconds;
|
||||
|
||||
configASSERT( ( pcName != NULL ) );
|
||||
|
||||
if( xLookUp != pdFALSE )
|
||||
{
|
||||
pxIP->xIPAddress.ulIP_IPv4 = 0U;
|
||||
}
|
||||
|
||||
ulCurrentTimeSeconds = ( uint32_t ) ( ( xCurrentTickCount / configTICK_RATE_HZ ) );
|
||||
xResult = prvFindEntryIndex( pcName, pxIP, &uxIndex );
|
||||
|
||||
if( xResult == pdTRUE )
|
||||
{ /* Element found */
|
||||
/* Is this function called for a lookup or to add/update an IP address? */
|
||||
if( xLookUp == pdTRUE )
|
||||
{
|
||||
/* This statement can only be reached when xResult is true; which
|
||||
* implies that the entry is present and a 'get' operation will result
|
||||
* in success. Therefore, it is safe to ignore the return value of the
|
||||
* below function. */
|
||||
( void ) prvGetCacheIPEntry( uxIndex,
|
||||
pxIP,
|
||||
ulCurrentTimeSeconds,
|
||||
ppxAddressInfo );
|
||||
}
|
||||
else
|
||||
{
|
||||
prvUpdateCacheEntry( uxIndex,
|
||||
ulTTL,
|
||||
pxIP,
|
||||
ulCurrentTimeSeconds );
|
||||
}
|
||||
}
|
||||
else /* Element not Found xResult = pdFALSE */
|
||||
{
|
||||
if( xLookUp == pdTRUE )
|
||||
{
|
||||
pxIP->xIPAddress.ulIP_IPv4 = 0U;
|
||||
}
|
||||
else
|
||||
{
|
||||
prvInsertCacheEntry( pcName,
|
||||
ulTTL,
|
||||
pxIP,
|
||||
ulCurrentTimeSeconds );
|
||||
}
|
||||
}
|
||||
|
||||
#if ( ipconfigHAS_DEBUG_PRINTF != 0 )
|
||||
if( ( xLookUp == pdFALSE ) || ( pxIP->xIPAddress.ulIP_IPv4 != 0U ) )
|
||||
{
|
||||
char pcAddress[ 40 ];
|
||||
IP_Address_t xAddress;
|
||||
BaseType_t xFamily = FREERTOS_AF_INET;
|
||||
|
||||
switch( pxIP->xIs_IPv6 )
|
||||
{
|
||||
#if ( ipconfigUSE_IPv6 != 0 )
|
||||
case pdTRUE:
|
||||
( void ) memcpy( xAddress.xIP_IPv6.ucBytes, pxIP->xIPAddress.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
|
||||
xFamily = FREERTOS_AF_INET6;
|
||||
break;
|
||||
#endif /* if ( ipconfigUSE_IPv6 != 0 ) */
|
||||
|
||||
#if ( ipconfigUSE_IPv4 != 0 )
|
||||
case pdFALSE:
|
||||
xAddress.ulIP_IPv4 = pxIP->xIPAddress.ulIP_IPv4;
|
||||
break;
|
||||
#endif /* if ( ipconfigUSE_IPv4 != 0 ) */
|
||||
|
||||
default:
|
||||
/* MISRA 16.4 Compliance */
|
||||
FreeRTOS_debug_printf( ( "FreeRTOS_ProcessDNSCache: Undefined IP Type \n" ) );
|
||||
break;
|
||||
}
|
||||
|
||||
( void ) FreeRTOS_inet_ntop( xFamily,
|
||||
( const void * ) xAddress.xIP_IPv6.ucBytes,
|
||||
pcAddress,
|
||||
( socklen_t ) sizeof( pcAddress ) );
|
||||
FreeRTOS_debug_printf( ( "FreeRTOS_ProcessDNSCache: %s: '%s' @ %s (TTL %u)\n",
|
||||
( xLookUp != 0 ) ? "look-up" : "add",
|
||||
pcName,
|
||||
pcAddress,
|
||||
( unsigned ) FreeRTOS_ntohl( ulTTL ) ) );
|
||||
}
|
||||
#endif /* ( ipconfigHAS_DEBUG_PRINTF != 0 ) */
|
||||
|
||||
return xResult;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief returns the index of the hostname entry in the dns cache.
|
||||
* @param[in] pcName find it in the cache
|
||||
* @param[in] pxIP ip address
|
||||
* @param [out] uxResult index number
|
||||
* @returns res pdTRUE if index in found else pdFALSE
|
||||
*/
|
||||
static BaseType_t prvFindEntryIndex( const char * pcName,
|
||||
const IPv46_Address_t * pxIP,
|
||||
UBaseType_t * uxResult )
|
||||
{
|
||||
BaseType_t xReturn = pdFALSE;
|
||||
UBaseType_t uxIndex;
|
||||
|
||||
/* For each entry in the DNS cache table. */
|
||||
for( uxIndex = 0; uxIndex < ipconfigDNS_CACHE_ENTRIES; uxIndex++ )
|
||||
{
|
||||
if( xDNSCache[ uxIndex ].pcName[ 0 ] == ( char ) 0 )
|
||||
{ /* empty slot */
|
||||
continue;
|
||||
}
|
||||
|
||||
if( strcmp( xDNSCache[ uxIndex ].pcName, pcName ) == 0 )
|
||||
{ /* hostname found */
|
||||
/* IPv6 is enabled, See if the cache entry has the correct type. */
|
||||
if( pxIP->xIs_IPv6 == xDNSCache[ uxIndex ].xAddresses[ 0 ].xIs_IPv6 )
|
||||
{
|
||||
xReturn = pdTRUE;
|
||||
*uxResult = uxIndex;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief get entry at \p index from the cache
|
||||
* @param[in] uxIndex index in the cache
|
||||
* @param[out] pxIP fill it with the result
|
||||
* @param[in] ulCurrentTimeSeconds current time
|
||||
* @param[out] ppxAddressInfo Target to store the DNS entries.
|
||||
* @returns \c pdTRUE if the value is valid \c pdFALSE otherwise
|
||||
* @post the global structure \a xDNSCache might be modified
|
||||
*
|
||||
*/
|
||||
|
||||
static BaseType_t prvGetCacheIPEntry( UBaseType_t uxIndex,
|
||||
IPv46_Address_t * pxIP,
|
||||
uint32_t ulCurrentTimeSeconds,
|
||||
struct freertos_addrinfo ** ppxAddressInfo )
|
||||
{
|
||||
BaseType_t isRead;
|
||||
uint32_t ulIPAddressIndex = 0;
|
||||
uint32_t ulAge = ulCurrentTimeSeconds - xDNSCache[ uxIndex ].ulTimeWhenAddedInSeconds;
|
||||
|
||||
/* Confirm that the record is still fresh.
|
||||
* The field ulTTL was stored as network-endian. */
|
||||
if( ulAge < FreeRTOS_ntohl( xDNSCache[ uxIndex ].ulTTL ) )
|
||||
{
|
||||
#if ( ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY > 1 )
|
||||
uint8_t ucIndex;
|
||||
|
||||
/* The ucCurrentIPAddress value increments without bound and will rollover, */
|
||||
/* modulo it by the number of IP addresses to keep it in range. */
|
||||
/* Also perform a final modulo by the max number of IP addresses */
|
||||
/* per DNS cache entry to prevent out-of-bounds access in the event */
|
||||
/* that ucNumIPAddresses has been corrupted. */
|
||||
|
||||
ucIndex = xDNSCache[ uxIndex ].ucCurrentIPAddress % xDNSCache[ uxIndex ].ucNumIPAddresses;
|
||||
ucIndex = ucIndex % ( uint8_t ) ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY;
|
||||
ulIPAddressIndex = ucIndex;
|
||||
|
||||
xDNSCache[ uxIndex ].ucCurrentIPAddress++;
|
||||
#endif /* if ( ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY > 1 ) */
|
||||
|
||||
( void ) memcpy( pxIP, &( xDNSCache[ uxIndex ].xAddresses[ ulIPAddressIndex ] ), sizeof( *pxIP ) );
|
||||
isRead = pdTRUE;
|
||||
|
||||
if( ppxAddressInfo != NULL )
|
||||
{
|
||||
/* Copy all entries from position 'uxIndex' to a linked struct addrinfo. */
|
||||
prvReadDNSCache( ( BaseType_t ) uxIndex, ppxAddressInfo );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Age out the old cached record. */
|
||||
xDNSCache[ uxIndex ].pcName[ 0 ] = ( char ) 0;
|
||||
isRead = pdFALSE;
|
||||
}
|
||||
|
||||
return isRead;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief update entry at \p index in the cache
|
||||
* @param[in] uxIndex index in the cache
|
||||
* @param[in] ulTTL time to live (in seconds)
|
||||
* @param[in] pxIP ip to update the cache with
|
||||
* @param[in] ulCurrentTimeSeconds current time
|
||||
* @post the global structure \a xDNSCache is modified
|
||||
*/
|
||||
static void prvUpdateCacheEntry( UBaseType_t uxIndex,
|
||||
uint32_t ulTTL,
|
||||
const IPv46_Address_t * pxIP,
|
||||
uint32_t ulCurrentTimeSeconds )
|
||||
{
|
||||
uint32_t ulIPAddressIndex = 0;
|
||||
|
||||
#if ( ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY > 1 )
|
||||
if( xDNSCache[ uxIndex ].ucNumIPAddresses <
|
||||
( uint8_t ) ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY )
|
||||
{
|
||||
/* If more answers exist than there are IP address storage
|
||||
* slots they will overwrite entry 0 */
|
||||
ulIPAddressIndex = xDNSCache[ uxIndex ].ucNumIPAddresses;
|
||||
xDNSCache[ uxIndex ].ucNumIPAddresses++;
|
||||
}
|
||||
#endif
|
||||
( void ) memcpy( &( xDNSCache[ uxIndex ].xAddresses[ ulIPAddressIndex ] ), pxIP, sizeof( *pxIP ) );
|
||||
xDNSCache[ uxIndex ].ulTTL = ulTTL;
|
||||
xDNSCache[ uxIndex ].ulTimeWhenAddedInSeconds = ulCurrentTimeSeconds;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief insert entry in the cache
|
||||
* @param[in] pcName cache entry key
|
||||
* @param[in] ulTTL time to live (in seconds)
|
||||
* @param[in] pxIP ip address
|
||||
* @param[in] ulCurrentTimeSeconds current time
|
||||
* @post the global structure \a xDNSCache is modified
|
||||
*/
|
||||
static void prvInsertCacheEntry( const char * pcName,
|
||||
uint32_t ulTTL,
|
||||
const IPv46_Address_t * pxIP,
|
||||
uint32_t ulCurrentTimeSeconds )
|
||||
{
|
||||
/* Add or update the item. */
|
||||
if( strlen( pcName ) < ( size_t ) ipconfigDNS_CACHE_NAME_LENGTH )
|
||||
{
|
||||
( void ) strncpy( xDNSCache[ uxFreeEntry ].pcName, pcName, ipconfigDNS_CACHE_NAME_LENGTH );
|
||||
( void ) memcpy( &( xDNSCache[ uxFreeEntry ].xAddresses[ 0 ] ), pxIP, sizeof( *pxIP ) );
|
||||
|
||||
xDNSCache[ uxFreeEntry ].ulTTL = ulTTL;
|
||||
xDNSCache[ uxFreeEntry ].ulTimeWhenAddedInSeconds = ulCurrentTimeSeconds;
|
||||
#if ( ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY > 1 )
|
||||
xDNSCache[ uxFreeEntry ].ucNumIPAddresses = 1;
|
||||
xDNSCache[ uxFreeEntry ].ucCurrentIPAddress = 0;
|
||||
|
||||
/* Initialize all remaining IP addresses in this entry to 0 */
|
||||
( void ) memset( &xDNSCache[ uxFreeEntry ].xAddresses[ 1 ],
|
||||
0,
|
||||
sizeof( xDNSCache[ uxFreeEntry ].xAddresses[ 1 ] ) *
|
||||
( ( uint32_t ) ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY - 1U ) );
|
||||
#endif
|
||||
uxFreeEntry++;
|
||||
|
||||
if( uxFreeEntry == ipconfigDNS_CACHE_ENTRIES )
|
||||
{
|
||||
uxFreeEntry = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Copy DNS cache entries at uxIndex to a linked struct addrinfo.
|
||||
* @param[in] uxIndex The index from where entries must be copied.
|
||||
* @param[out] ppxAddressInfo Target to store the DNS entries.
|
||||
*/
|
||||
static void prvReadDNSCache( BaseType_t uxIndex,
|
||||
struct freertos_addrinfo ** ppxAddressInfo )
|
||||
{
|
||||
size_t uxIPAddressIndex;
|
||||
size_t uxNumIPAddresses = 1U;
|
||||
const IPv46_Address_t * pxAddresses;
|
||||
struct freertos_addrinfo * pxNewAddress = NULL;
|
||||
struct freertos_addrinfo ** ppxLastAddress = ppxAddressInfo;
|
||||
|
||||
#if ( ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY > 1 )
|
||||
uxNumIPAddresses = ( size_t ) xDNSCache[ uxIndex ].ucNumIPAddresses;
|
||||
|
||||
if( uxNumIPAddresses > ( size_t ) ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY )
|
||||
{
|
||||
/* Make this a configASSERT()? */
|
||||
uxNumIPAddresses = ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY;
|
||||
}
|
||||
#endif /* ( ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY > 1 ) */
|
||||
|
||||
for( uxIPAddressIndex = 0; uxIPAddressIndex < uxNumIPAddresses; uxIPAddressIndex++ )
|
||||
{
|
||||
pxAddresses = &( xDNSCache[ uxIndex ].xAddresses[ uxIPAddressIndex ] );
|
||||
|
||||
switch( pxAddresses->xIs_IPv6 ) /* LCOV_EXCL_BR_LINE - xIs_IPv6 is always either pdFALSE or pdTRUE. */
|
||||
{
|
||||
#if ( ipconfigUSE_IPv4 != 0 )
|
||||
case pdFALSE:
|
||||
{
|
||||
const uint8_t * ucBytes = ( const uint8_t * ) &( pxAddresses->xIPAddress.ulIP_IPv4 );
|
||||
pxNewAddress = pxNew_AddrInfo( xDNSCache[ uxIndex ].pcName, FREERTOS_AF_INET4, ucBytes );
|
||||
}
|
||||
break;
|
||||
#endif /* ( ipconfigUSE_IPv4 != 0 ) */
|
||||
|
||||
#if ( ipconfigUSE_IPv6 != 0 )
|
||||
case pdTRUE:
|
||||
pxNewAddress = pxNew_AddrInfo( xDNSCache[ uxIndex ].pcName, FREERTOS_AF_INET6, pxAddresses->xIPAddress.xIP_IPv6.ucBytes );
|
||||
break;
|
||||
#endif /* ( ipconfigUSE_IPv6 != 0 ) */
|
||||
|
||||
default: /* LCOV_EXCL_LINE - xIs_IPv6 is always either pdFALSE or FREERTOS_AF_INET6. */
|
||||
/* MISRA 16.4 Compliance */
|
||||
FreeRTOS_debug_printf( ( "prvReadDNSCache: Undefined IP Type \n" ) );
|
||||
break; /* LCOV_EXCL_LINE - xIs_IPv6 is always either pdFALSE or FREERTOS_AF_INET6. */
|
||||
}
|
||||
|
||||
if( pxNewAddress == NULL )
|
||||
{
|
||||
/* Malloc must has failed. */
|
||||
break;
|
||||
}
|
||||
|
||||
/* Set either 'ppxAddressInfo' or 'pxNewAddress->ai_next'. */
|
||||
*( ppxLastAddress ) = pxNewAddress;
|
||||
|
||||
ppxLastAddress = &( pxNewAddress->ai_next );
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Lookup the given hostname in the DNS cache
|
||||
* @param[in] pcHostName THe host name to lookup
|
||||
* @param[in] xFamily IP type FREERTOS_AF_INET6 / FREERTOS_AF_INET4
|
||||
* @param[out] ppxAddressInfo Target to store the DNS entries.
|
||||
* @returns This function returns either a valid IPv4 address, or
|
||||
* in case of an IPv6 lookup, it will return a non-zero.
|
||||
*/
|
||||
uint32_t Prepare_CacheLookup( const char * pcHostName,
|
||||
BaseType_t xFamily,
|
||||
struct freertos_addrinfo ** ppxAddressInfo )
|
||||
{
|
||||
uint32_t ulIPAddress = 0U;
|
||||
IPv46_Address_t xIPv46_Address;
|
||||
|
||||
switch( xFamily )
|
||||
{
|
||||
#if ( ipconfigUSE_IPv4 != 0 )
|
||||
case FREERTOS_AF_INET:
|
||||
{
|
||||
BaseType_t xFound;
|
||||
|
||||
xIPv46_Address.xIs_IPv6 = pdFALSE;
|
||||
xFound = FreeRTOS_ProcessDNSCache( pcHostName, &( xIPv46_Address ), 0, pdTRUE, ppxAddressInfo );
|
||||
|
||||
if( xFound != 0 )
|
||||
{
|
||||
if( ( ppxAddressInfo != NULL ) && ( *( ppxAddressInfo ) != NULL ) )
|
||||
{
|
||||
const struct freertos_sockaddr * sockaddr = ( *( ppxAddressInfo ) )->ai_addr;
|
||||
|
||||
ulIPAddress = sockaddr->sin_address.ulIP_IPv4;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* prvGetHostByName will be called to start a DNS lookup. */
|
||||
}
|
||||
}
|
||||
break;
|
||||
#endif /* ( ipconfigUSE_IPv4 != 0 ) */
|
||||
|
||||
#if ( ipconfigUSE_IPv6 != 0 )
|
||||
case FREERTOS_AF_INET6:
|
||||
{
|
||||
BaseType_t xFound;
|
||||
|
||||
xIPv46_Address.xIs_IPv6 = pdTRUE;
|
||||
xFound = FreeRTOS_ProcessDNSCache( pcHostName, &( xIPv46_Address ), 0, pdTRUE, ppxAddressInfo );
|
||||
|
||||
if( xFound != 0 )
|
||||
{
|
||||
if( ( ppxAddressInfo != NULL ) && ( *( ppxAddressInfo ) != NULL ) )
|
||||
{
|
||||
/* This function returns either a valid IPv4 address, or
|
||||
* in case of an IPv6 lookup, it will return a non-zero */
|
||||
ulIPAddress = 1U;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* prvGetHostByName will be called to start a DNS lookup. */
|
||||
}
|
||||
}
|
||||
break;
|
||||
#endif /* ( ipconfigUSE_IPv6 != 0 ) */
|
||||
|
||||
default:
|
||||
/* MISRA 16.4 Compliance */
|
||||
FreeRTOS_debug_printf( ( "Prepare_CacheLookup: Undefined xFamily \n" ) );
|
||||
break;
|
||||
}
|
||||
|
||||
return ulIPAddress;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY > 1 )
|
||||
|
||||
/**
|
||||
* @brief For debugging only: prints the contents of the DNS cache table.
|
||||
*/
|
||||
void vShowDNSCacheTable( void )
|
||||
{
|
||||
UBaseType_t xEntry;
|
||||
UBaseType_t xSubEntry;
|
||||
|
||||
for( xEntry = 0; xEntry < ipconfigDNS_CACHE_ENTRIES; xEntry++ )
|
||||
{
|
||||
const DNSCacheRow_t * pxRow = &( xDNSCache[ xEntry ] );
|
||||
|
||||
if( pxRow->pcName[ 0 ] != ( char ) 0 )
|
||||
{
|
||||
FreeRTOS_printf( ( "Entry %2u: %s use %u/%u\n",
|
||||
( unsigned ) xEntry,
|
||||
pxRow->pcName,
|
||||
( unsigned ) pxRow->ucCurrentIPAddress,
|
||||
( unsigned ) pxRow->ucNumIPAddresses ) );
|
||||
|
||||
for( xSubEntry = 0; xSubEntry < pxRow->ucNumIPAddresses; xSubEntry++ )
|
||||
{
|
||||
char pcAddress[ 40 ] = "";
|
||||
|
||||
switch( pxRow->xAddresses[ 0 ].xIs_IPv6 )
|
||||
{
|
||||
/* The first entry determines the type of row:
|
||||
* either IPv4 or IPv6. */
|
||||
#if ( ipconfigUSE_IPv4 != 0 )
|
||||
case pdFALSE:
|
||||
( void ) FreeRTOS_inet_ntop( FREERTOS_AF_INET4,
|
||||
( const void * ) &( pxRow->xAddresses[ xSubEntry ].xIPAddress.ulIP_IPv4 ),
|
||||
pcAddress,
|
||||
sizeof( pcAddress ) );
|
||||
break;
|
||||
#endif /* ( ipconfigUSE_IPv4 != 0 ) */
|
||||
|
||||
#if ( ipconfigUSE_IPv6 != 0 )
|
||||
case pdTRUE:
|
||||
( void ) FreeRTOS_inet_ntop( FREERTOS_AF_INET6,
|
||||
( const void * ) pxRow->xAddresses[ xSubEntry ].xIPAddress.xIP_IPv6.ucBytes,
|
||||
pcAddress,
|
||||
sizeof( pcAddress ) );
|
||||
break;
|
||||
#endif /* ( ipconfigUSE_IPv6 != 0 ) */
|
||||
|
||||
default:
|
||||
/* MISRA 16.4 Compliance */
|
||||
FreeRTOS_debug_printf( ( "vShowDNSCacheTable: Undefined IP Type \n" ) );
|
||||
break;
|
||||
}
|
||||
|
||||
FreeRTOS_printf( ( " %2u: %s\n",
|
||||
( unsigned ) xSubEntry,
|
||||
pcAddress ) );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* if ( ipconfigDNS_CACHE_ADDRESSES_PER_ENTRY > 1 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#endif /* if ( ( ipconfigUSE_DNS != 0 ) && ( ipconfigUSE_DNS_CACHE == 1 ) ) */
|
||||
+284
@@ -0,0 +1,284 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_DNS_Callback.c
|
||||
* @brief File that handles the DNS Callback option
|
||||
*/
|
||||
|
||||
#include "FreeRTOS_DNS_Callback.h"
|
||||
|
||||
#include "FreeRTOS_IP.h"
|
||||
#include "FreeRTOS_IP_Private.h"
|
||||
#include "FreeRTOS_DNS_Globals.h"
|
||||
#include "FreeRTOS_IP_Timers.h"
|
||||
|
||||
#if ( ( ipconfigDNS_USE_CALLBACKS == 1 ) && ( ipconfigUSE_DNS != 0 ) )
|
||||
|
||||
/**
|
||||
* @brief list of callbacks to send
|
||||
*/
|
||||
static List_t xCallbackList;
|
||||
|
||||
/**
|
||||
* @brief A DNS reply was received, see if there is any matching entry and
|
||||
* call the handler.
|
||||
*
|
||||
* @param[in,out] pxSet a set of variables that are shared among the helper functions.
|
||||
* @param[in] pxAddress Pointer to address info ( IPv4/IPv6 ) obtained from the DNS server.
|
||||
*
|
||||
* @return Returns pdTRUE if uxIdentifier was recognized.
|
||||
*/
|
||||
BaseType_t xDNSDoCallback( ParseSet_t * pxSet,
|
||||
struct freertos_addrinfo * pxAddress )
|
||||
{
|
||||
BaseType_t xResult = pdFALSE;
|
||||
const ListItem_t * pxIterator;
|
||||
const ListItem_t * pxEnd = listGET_END_MARKER( &xCallbackList );
|
||||
TickType_t uxIdentifier = ( TickType_t ) pxSet->pxDNSMessageHeader->usIdentifier;
|
||||
|
||||
/* While iterating through the list, the scheduler is suspended.
|
||||
* Remember which function shall be called once the scheduler is
|
||||
* running again. */
|
||||
FOnDNSEvent pCallbackFunction = NULL;
|
||||
void * pvSearchID = NULL;
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
for( pxIterator = ( const ListItem_t * ) listGET_HEAD_ENTRY( &xCallbackList );
|
||||
pxIterator != ( const ListItem_t * ) pxEnd;
|
||||
pxIterator = ( const ListItem_t * ) listGET_NEXT( pxIterator ) )
|
||||
{
|
||||
BaseType_t xMatching;
|
||||
DNSCallback_t * pxCallback = ( ( DNSCallback_t * ) listGET_LIST_ITEM_OWNER( pxIterator ) );
|
||||
#if ( ipconfigUSE_MDNS == 1 )
|
||||
/* mDNS port 5353. Host byte order comparison. */
|
||||
if( pxSet->usPortNumber == ipMDNS_PORT )
|
||||
{
|
||||
/* In mDNS, the query ID field is ignored and the
|
||||
* hostname will be compared with outstanding requests. */
|
||||
|
||||
xMatching = ( strcasecmp( pxCallback->pcName, pxSet->pcName ) == 0 ) ? pdTRUE : pdFALSE;
|
||||
}
|
||||
else
|
||||
#endif /* if ( ipconfigUSE_MDNS == 1 ) */
|
||||
{
|
||||
xMatching = ( listGET_LIST_ITEM_VALUE( pxIterator ) == uxIdentifier ) ? pdTRUE : pdFALSE;
|
||||
}
|
||||
|
||||
if( xMatching == pdTRUE )
|
||||
{
|
||||
pvSearchID = pxCallback->pvSearchID;
|
||||
pCallbackFunction = pxCallback->pCallbackFunction;
|
||||
( void ) uxListRemove( &pxCallback->xListItem );
|
||||
vPortFree( pxCallback );
|
||||
|
||||
if( listLIST_IS_EMPTY( &xCallbackList ) != pdFALSE )
|
||||
{
|
||||
/* The list of outstanding requests is empty. No need for periodic polling. */
|
||||
vIPSetDNSTimerEnableState( pdFALSE );
|
||||
}
|
||||
|
||||
xResult = pdTRUE;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
|
||||
if( pCallbackFunction != NULL )
|
||||
{
|
||||
pCallbackFunction( pxSet->pcName, pvSearchID, pxAddress );
|
||||
}
|
||||
|
||||
return xResult;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief FreeRTOS_gethostbyname_a() was called along with callback parameters.
|
||||
* Store them in a list for later reference.
|
||||
*
|
||||
* @param[in] pcHostName The hostname whose IP address is being searched for.
|
||||
* @param[in] pvSearchID The search ID of the DNS callback function to set.
|
||||
* @param[in] pCallbackFunction The callback function pointer.
|
||||
* @param[in] uxTimeout Timeout of the callback function in ms.
|
||||
* @param[in] uxIdentifier Random number used as ID in the DNS message.
|
||||
* @param[in] xIsIPv6 pdTRUE if the address type should be IPv6.
|
||||
*/
|
||||
BaseType_t xDNSSetCallBack( const char * pcHostName,
|
||||
void * pvSearchID,
|
||||
FOnDNSEvent pCallbackFunction,
|
||||
TickType_t uxTimeout,
|
||||
TickType_t uxIdentifier,
|
||||
BaseType_t xIsIPv6 )
|
||||
{
|
||||
BaseType_t xReturn = pdPASS;
|
||||
size_t lLength = strlen( pcHostName );
|
||||
|
||||
/* MISRA Ref 4.12.1 [Use of dynamic memory]. */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#directive-412. */
|
||||
/* coverity[misra_c_2012_directive_4_12_violation] */
|
||||
DNSCallback_t * pxCallback = ( ( DNSCallback_t * ) pvPortMalloc( sizeof( *pxCallback ) + lLength ) );
|
||||
|
||||
/* Translate from ms to number of clock ticks. */
|
||||
uxTimeout = pdMS_TO_TICKS( uxTimeout );
|
||||
|
||||
if( pxCallback != NULL )
|
||||
{
|
||||
if( listLIST_IS_EMPTY( &xCallbackList ) != pdFALSE )
|
||||
{
|
||||
/* This is the first one, start the DNS timer to check for timeouts */
|
||||
vDNSTimerReload( FreeRTOS_min_uint32( 1000U, ( uint32_t ) uxTimeout ) );
|
||||
}
|
||||
|
||||
( void ) strncpy( pxCallback->pcName, pcHostName, lLength + 1U );
|
||||
pxCallback->pCallbackFunction = pCallbackFunction;
|
||||
pxCallback->pvSearchID = pvSearchID;
|
||||
pxCallback->uxRemainingTime = uxTimeout;
|
||||
pxCallback->xIsIPv6 = xIsIPv6;
|
||||
|
||||
vTaskSetTimeOutState( &( pxCallback->uxTimeoutState ) );
|
||||
listSET_LIST_ITEM_OWNER( &( pxCallback->xListItem ), ( void * ) pxCallback );
|
||||
listSET_LIST_ITEM_VALUE( &( pxCallback->xListItem ), uxIdentifier );
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
vListInsertEnd( &xCallbackList, &pxCallback->xListItem );
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
}
|
||||
else
|
||||
{
|
||||
xReturn = pdFAIL;
|
||||
FreeRTOS_debug_printf( ( " xDNSSetCallBack : Could not allocate memory: %u bytes",
|
||||
( unsigned ) ( sizeof( *pxCallback ) + lLength ) ) );
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Iterate through the list of call-back structures and remove
|
||||
* old entries which have reached a timeout.
|
||||
* As soon as the list has become empty, the DNS timer will be stopped.
|
||||
* In case pvSearchID is supplied, the user wants to cancel a DNS request.
|
||||
*
|
||||
* @param[in] pvSearchID The search ID of callback function whose associated
|
||||
* DNS request is being cancelled. If non-ID specific checking of
|
||||
* all requests is required, then this field should be kept as NULL.
|
||||
*/
|
||||
void vDNSCheckCallBack( void * pvSearchID )
|
||||
{
|
||||
const ListItem_t * pxIterator;
|
||||
const ListItem_t * pxEnd = listGET_END_MARKER( &xCallbackList );
|
||||
|
||||
/* When a DNS-search times out, the call-back function shall
|
||||
* be called. Store theses item in a temporary list.
|
||||
* Only when the scheduler is running, user functions
|
||||
* shall be called. */
|
||||
List_t xTempList;
|
||||
|
||||
vListInitialise( &xTempList );
|
||||
|
||||
vTaskSuspendAll();
|
||||
{
|
||||
for( pxIterator = ( const ListItem_t * ) listGET_HEAD_ENTRY( &xCallbackList );
|
||||
pxIterator != pxEnd; )
|
||||
{
|
||||
DNSCallback_t * pxCallback = ( ( DNSCallback_t * ) listGET_LIST_ITEM_OWNER( pxIterator ) );
|
||||
/* Move to the next item because we might remove this item */
|
||||
pxIterator = ( const ListItem_t * ) listGET_NEXT( pxIterator );
|
||||
|
||||
if( ( pvSearchID != NULL ) && ( pvSearchID == pxCallback->pvSearchID ) )
|
||||
{
|
||||
( void ) uxListRemove( &( pxCallback->xListItem ) );
|
||||
vPortFree( pxCallback );
|
||||
}
|
||||
else if( xTaskCheckForTimeOut( &pxCallback->uxTimeoutState, &( pxCallback->uxRemainingTime ) ) != pdFALSE )
|
||||
{
|
||||
/* A time-out occurred in the asynchronous search.
|
||||
* Remove it from xCallbackList. */
|
||||
( void ) uxListRemove( &( pxCallback->xListItem ) );
|
||||
|
||||
/* Insert it in a temporary list. The function will be called
|
||||
* once the scheduler is resumed. */
|
||||
vListInsertEnd( &( xTempList ), &pxCallback->xListItem );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* This call-back is still waiting for a reply or a time-out. */
|
||||
}
|
||||
}
|
||||
}
|
||||
( void ) xTaskResumeAll();
|
||||
|
||||
if( listLIST_IS_EMPTY( &xTempList ) == pdFALSE )
|
||||
{
|
||||
/* There is at least one item in xTempList which must be removed and deleted. */
|
||||
pxEnd = listGET_END_MARKER( &xTempList );
|
||||
|
||||
for( pxIterator = ( const ListItem_t * ) listGET_HEAD_ENTRY( &xTempList );
|
||||
pxIterator != pxEnd;
|
||||
)
|
||||
{
|
||||
DNSCallback_t * pxCallback = ( ( DNSCallback_t * ) listGET_LIST_ITEM_OWNER( pxIterator ) );
|
||||
/* Move to the next item because we might remove this item */
|
||||
pxIterator = ( const ListItem_t * ) listGET_NEXT( pxIterator );
|
||||
|
||||
/* A time-out occurred in the asynchronous search.
|
||||
* Call the application hook with the proper information. */
|
||||
if( pxCallback->xIsIPv6 != 0 )
|
||||
{
|
||||
pxCallback->pCallbackFunction( pxCallback->pcName, pxCallback->pvSearchID, NULL );
|
||||
}
|
||||
else
|
||||
{
|
||||
pxCallback->pCallbackFunction( pxCallback->pcName, pxCallback->pvSearchID, 0U );
|
||||
}
|
||||
|
||||
/* Remove it from 'xTempList' and free the memory. */
|
||||
( void ) uxListRemove( &( pxCallback->xListItem ) );
|
||||
vPortFree( pxCallback );
|
||||
}
|
||||
}
|
||||
|
||||
if( listLIST_IS_EMPTY( &xCallbackList ) != pdFALSE )
|
||||
{
|
||||
vIPSetDNSTimerEnableState( pdFALSE );
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief initialize the cache
|
||||
* @post will modify global list xCallbackList
|
||||
*/
|
||||
void vDNSCallbackInitialise()
|
||||
{
|
||||
vListInitialise( &xCallbackList );
|
||||
}
|
||||
#endif /* if ( ipconfigDNS_USE_CALLBACKS == 1 ) */
|
||||
+173
@@ -0,0 +1,173 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_DNS_Networking.c
|
||||
* @brief Implements the Domain Name System Networking
|
||||
* for the FreeRTOS+TCP network stack.
|
||||
*/
|
||||
|
||||
#include "FreeRTOS.h"
|
||||
|
||||
#include "FreeRTOS_DNS_Networking.h"
|
||||
|
||||
#if ( ipconfigUSE_DNS != 0 )
|
||||
|
||||
/**
|
||||
* @brief Bind the socket to a port number.
|
||||
* @param[in] xSocket the socket that must be bound.
|
||||
* @param[in] usPort the port number to bind to.
|
||||
* @return The created socket - or NULL if the socket could not be created or could not be bound.
|
||||
*/
|
||||
BaseType_t DNS_BindSocket( Socket_t xSocket,
|
||||
uint16_t usPort )
|
||||
{
|
||||
struct freertos_sockaddr xAddress;
|
||||
BaseType_t xReturn;
|
||||
|
||||
( void ) memset( &( xAddress ), 0, sizeof( xAddress ) );
|
||||
xAddress.sin_family = FREERTOS_AF_INET;
|
||||
xAddress.sin_port = usPort;
|
||||
|
||||
xReturn = FreeRTOS_bind( xSocket, &xAddress, ( socklen_t ) sizeof( xAddress ) );
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Create a socket and bind it to the standard DNS port number.
|
||||
*
|
||||
* @return The created socket - or NULL if the socket could not be created or could not be bound.
|
||||
*/
|
||||
Socket_t DNS_CreateSocket( TickType_t uxReadTimeOut_ticks )
|
||||
{
|
||||
Socket_t xSocket;
|
||||
TickType_t uxWriteTimeOut_ticks = ipconfigDNS_SEND_BLOCK_TIME_TICKS;
|
||||
|
||||
/* This must be the first time this function has been called. Create
|
||||
* the socket. */
|
||||
xSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );
|
||||
|
||||
if( xSocketValid( xSocket ) == pdFALSE )
|
||||
{
|
||||
/* There was an error, return NULL. */
|
||||
xSocket = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Ideally we should check for the return value. But since we are passing
|
||||
* correct parameters, and xSocket is != NULL, the return value is
|
||||
* going to be '0' i.e. success. Thus, return value is discarded */
|
||||
( void ) FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_SNDTIMEO, &( uxWriteTimeOut_ticks ), sizeof( TickType_t ) );
|
||||
( void ) FreeRTOS_setsockopt( xSocket, 0, FREERTOS_SO_RCVTIMEO, &( uxReadTimeOut_ticks ), sizeof( TickType_t ) );
|
||||
}
|
||||
|
||||
return xSocket;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief perform a DNS network request
|
||||
* @param xDNSSocket Created socket
|
||||
* @param xAddress address structure (ip, port etc)
|
||||
* @param pxDNSBuf buffer to send
|
||||
* @return xReturn: true if the message could be sent
|
||||
* false otherwise
|
||||
*
|
||||
*/
|
||||
BaseType_t DNS_SendRequest( Socket_t xDNSSocket,
|
||||
const struct freertos_sockaddr * xAddress,
|
||||
const struct xDNSBuffer * pxDNSBuf )
|
||||
{
|
||||
BaseType_t xReturn = pdFALSE;
|
||||
BaseType_t xSent;
|
||||
|
||||
iptraceSENDING_DNS_REQUEST();
|
||||
|
||||
/* Send the DNS message. */
|
||||
xSent = FreeRTOS_sendto( xDNSSocket,
|
||||
pxDNSBuf->pucPayloadBuffer,
|
||||
pxDNSBuf->uxPayloadLength,
|
||||
FREERTOS_ZERO_COPY,
|
||||
xAddress,
|
||||
( socklen_t ) sizeof( *xAddress ) );
|
||||
|
||||
if( xSent == ( BaseType_t ) pxDNSBuf->uxPayloadLength )
|
||||
{
|
||||
xReturn = pdPASS;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The message was not sent so the stack will not be
|
||||
* releasing the zero copy - it must be released here. */
|
||||
xReturn = pdFAIL;
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief perform a DNS network read
|
||||
* @param xDNSSocket socket
|
||||
* @param xAddress address to read from
|
||||
* @param pxReceiveBuffer buffer to fill with received data
|
||||
*/
|
||||
BaseType_t DNS_ReadReply( ConstSocket_t xDNSSocket,
|
||||
struct freertos_sockaddr * xAddress,
|
||||
struct xDNSBuffer * pxReceiveBuffer )
|
||||
{
|
||||
BaseType_t xReturn;
|
||||
uint32_t ulAddressLength = ( uint32_t ) sizeof( struct freertos_sockaddr );
|
||||
|
||||
/* Wait for the reply. */
|
||||
xReturn = FreeRTOS_recvfrom( xDNSSocket,
|
||||
&pxReceiveBuffer->pucPayloadBuffer,
|
||||
0,
|
||||
FREERTOS_ZERO_COPY,
|
||||
xAddress,
|
||||
&ulAddressLength );
|
||||
|
||||
if( xReturn <= 0 )
|
||||
{
|
||||
/* 'pdFREERTOS_ERRNO_EWOULDBLOCK' is returned in case of a timeout. */
|
||||
FreeRTOS_printf( ( "DNS_ReadReply returns %d\n", ( int ) xReturn ) );
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief perform a DNS network close
|
||||
* @param xDNSSocket the DNS socket to close
|
||||
*/
|
||||
void DNS_CloseSocket( Socket_t xDNSSocket )
|
||||
{
|
||||
( void ) FreeRTOS_closesocket( xDNSSocket );
|
||||
}
|
||||
#endif /* if ( ipconfigUSE_DNS != 0 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
+1336
File diff suppressed because it is too large.
Load diff
+268
@@ -0,0 +1,268 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_ICMP.c
|
||||
* @brief Implements the Internet Control Message Protocol for the FreeRTOS+TCP network stack.
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
#include "queue.h"
|
||||
#include "semphr.h"
|
||||
|
||||
/* FreeRTOS+TCP includes. */
|
||||
#include "FreeRTOS_IP.h"
|
||||
#include "FreeRTOS_IP_Private.h"
|
||||
#include "FreeRTOS_ICMP.h"
|
||||
#include "FreeRTOS_Sockets.h"
|
||||
#include "FreeRTOS_UDP_IP.h"
|
||||
#include "FreeRTOS_DHCP.h"
|
||||
#include "NetworkInterface.h"
|
||||
#include "NetworkBufferManagement.h"
|
||||
#include "FreeRTOS_DNS.h"
|
||||
|
||||
/*
|
||||
* Turns around an incoming ping request to convert it into a ping reply.
|
||||
*/
|
||||
#if ( ipconfigREPLY_TO_INCOMING_PINGS == 1 )
|
||||
static eFrameProcessingResult_t prvProcessICMPEchoRequest( ICMPPacket_t * const pxICMPPacket,
|
||||
const NetworkBufferDescriptor_t * const pxNetworkBuffer );
|
||||
#endif /* ipconfigREPLY_TO_INCOMING_PINGS */
|
||||
|
||||
/*
|
||||
* Processes incoming ping replies. The application callback function
|
||||
* vApplicationPingReplyHook() is called with the results.
|
||||
*/
|
||||
#if ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )
|
||||
static void prvProcessICMPEchoReply( const NetworkBufferDescriptor_t * const pxNetworkBuffer );
|
||||
#endif /* ipconfigSUPPORT_OUTGOING_PINGS */
|
||||
|
||||
#if ( ipconfigREPLY_TO_INCOMING_PINGS == 1 ) || ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )
|
||||
|
||||
/**
|
||||
* @brief Process an ICMP packet. Only echo requests and echo replies are recognised and handled.
|
||||
*
|
||||
* @param[in,out] pxNetworkBuffer The pointer to the network buffer descriptor
|
||||
* that contains the ICMP message.
|
||||
*
|
||||
* @return eReleaseBuffer when the message buffer should be released, or eReturnEthernetFrame
|
||||
* when the packet should be returned.
|
||||
*/
|
||||
eFrameProcessingResult_t ProcessICMPPacket( const NetworkBufferDescriptor_t * const pxNetworkBuffer )
|
||||
{
|
||||
eFrameProcessingResult_t eReturn = eReleaseBuffer;
|
||||
|
||||
iptraceICMP_PACKET_RECEIVED();
|
||||
|
||||
configASSERT( pxNetworkBuffer->xDataLength >= sizeof( ICMPPacket_t ) );
|
||||
|
||||
if( pxNetworkBuffer->xDataLength >= sizeof( ICMPPacket_t ) )
|
||||
{
|
||||
/* Map the buffer onto a ICMP-Packet struct to easily access the
|
||||
* fields of ICMP packet. */
|
||||
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
ICMPPacket_t * pxICMPPacket = ( ( ICMPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer );
|
||||
|
||||
switch( pxICMPPacket->xICMPHeader.ucTypeOfMessage )
|
||||
{
|
||||
case ipICMP_ECHO_REQUEST:
|
||||
#if ( ipconfigREPLY_TO_INCOMING_PINGS == 1 )
|
||||
{
|
||||
eReturn = prvProcessICMPEchoRequest( pxICMPPacket, pxNetworkBuffer );
|
||||
}
|
||||
#endif /* ( ipconfigREPLY_TO_INCOMING_PINGS == 1 ) */
|
||||
break;
|
||||
|
||||
case ipICMP_ECHO_REPLY:
|
||||
#if ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )
|
||||
{
|
||||
prvProcessICMPEchoReply( pxNetworkBuffer );
|
||||
}
|
||||
#endif /* ipconfigSUPPORT_OUTGOING_PINGS */
|
||||
break;
|
||||
|
||||
default:
|
||||
/* Only ICMP echo packets are handled. */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return eReturn;
|
||||
}
|
||||
|
||||
#endif /* ( ipconfigREPLY_TO_INCOMING_PINGS == 1 ) || ( ipconfigSUPPORT_OUTGOING_PINGS == 1 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ipconfigREPLY_TO_INCOMING_PINGS == 1 )
|
||||
|
||||
/**
|
||||
* @brief Process an ICMP echo request.
|
||||
*
|
||||
* @param[in,out] pxICMPPacket The IP packet that contains the ICMP message.
|
||||
* @param pxNetworkBuffer Pointer to the network buffer containing the ICMP packet.
|
||||
* @returns Function returns eReturnEthernetFrame.
|
||||
*/
|
||||
static eFrameProcessingResult_t prvProcessICMPEchoRequest( ICMPPacket_t * const pxICMPPacket,
|
||||
const NetworkBufferDescriptor_t * const pxNetworkBuffer )
|
||||
{
|
||||
ICMPHeader_t * pxICMPHeader;
|
||||
IPHeader_t * pxIPHeader;
|
||||
uint32_t ulIPAddress;
|
||||
|
||||
pxICMPHeader = &( pxICMPPacket->xICMPHeader );
|
||||
pxIPHeader = &( pxICMPPacket->xIPHeader );
|
||||
|
||||
/* HT:endian: changed back */
|
||||
iptraceSENDING_PING_REPLY( pxIPHeader->ulSourceIPAddress );
|
||||
|
||||
/* The checksum can be checked here - but a ping reply should be
|
||||
* returned even if the checksum is incorrect so the other end can
|
||||
* tell that the ping was received - even if the ping reply contains
|
||||
* invalid data. */
|
||||
pxICMPHeader->ucTypeOfMessage = ( uint8_t ) ipICMP_ECHO_REPLY;
|
||||
ulIPAddress = pxIPHeader->ulDestinationIPAddress;
|
||||
pxIPHeader->ulDestinationIPAddress = pxIPHeader->ulSourceIPAddress;
|
||||
pxIPHeader->ulSourceIPAddress = ulIPAddress;
|
||||
/* Update the TTL field. */
|
||||
pxIPHeader->ucTimeToLive = ipconfigICMP_TIME_TO_LIVE;
|
||||
|
||||
/* The stack doesn't support fragments, so the fragment offset field must always be zero.
|
||||
* The header was never memset to zero, so set both the fragment offset and fragmentation flags in one go.
|
||||
*/
|
||||
#if ( ipconfigFORCE_IP_DONT_FRAGMENT != 0 )
|
||||
pxIPHeader->usFragmentOffset = ipFRAGMENT_FLAGS_DONT_FRAGMENT;
|
||||
#else
|
||||
pxIPHeader->usFragmentOffset = 0U;
|
||||
#endif
|
||||
|
||||
#if ( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )
|
||||
{
|
||||
/* calculate the IP header checksum, in case the driver won't do that. */
|
||||
pxIPHeader->usHeaderChecksum = 0x00U;
|
||||
pxIPHeader->usHeaderChecksum = usGenerateChecksum( 0U, ( uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), uxIPHeaderSizePacket( pxNetworkBuffer ) );
|
||||
pxIPHeader->usHeaderChecksum = ( uint16_t ) ~FreeRTOS_htons( pxIPHeader->usHeaderChecksum );
|
||||
|
||||
/* calculate the ICMP checksum for an outgoing packet. */
|
||||
( void ) usGenerateProtocolChecksum( ( uint8_t * ) pxICMPPacket, pxNetworkBuffer->xDataLength, pdTRUE );
|
||||
}
|
||||
#else
|
||||
{
|
||||
/* Just to prevent compiler warnings about unused parameters. */
|
||||
( void ) pxNetworkBuffer;
|
||||
|
||||
/* Many EMAC peripherals will only calculate the ICMP checksum
|
||||
* correctly if the field is nulled beforehand. */
|
||||
pxICMPHeader->usChecksum = 0U;
|
||||
}
|
||||
#endif /* if ( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 ) */
|
||||
|
||||
return eReturnEthernetFrame;
|
||||
}
|
||||
|
||||
#endif /* ipconfigREPLY_TO_INCOMING_PINGS == 1 */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ipconfigSUPPORT_OUTGOING_PINGS == 1 )
|
||||
|
||||
/**
|
||||
* @brief Process an ICMP echo reply.
|
||||
*
|
||||
* @param[in] pxNetworkBuffer The network buffer descriptor containing the ICMP packet.
|
||||
*/
|
||||
static void prvProcessICMPEchoReply( const NetworkBufferDescriptor_t * const pxNetworkBuffer )
|
||||
{
|
||||
/* The packet contained an ICMPv4 frame. */
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
ICMPPacket_t * pxICMPPacket = ( ICMPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer;
|
||||
ePingReplyStatus_t eStatus = eSuccess;
|
||||
uint16_t usDataLength, usByteCount, usCount;
|
||||
size_t usByteAvail;
|
||||
uint8_t * pucByte;
|
||||
|
||||
/* Find the total length of the IP packet. */
|
||||
usDataLength = pxICMPPacket->xIPHeader.usLength;
|
||||
usByteCount = FreeRTOS_ntohs( usDataLength );
|
||||
usByteAvail = pxNetworkBuffer->xDataLength;
|
||||
|
||||
if( usByteAvail >= ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_ICMPv4_HEADER ) )
|
||||
{
|
||||
usByteAvail = usByteAvail - ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_ICMPv4_HEADER );
|
||||
|
||||
if( usByteCount >= ( ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_ICMPv4_HEADER ) )
|
||||
{
|
||||
usByteCount = ( uint16_t ) ( usByteCount - ( ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_ICMPv4_HEADER ) );
|
||||
|
||||
if( usByteCount <= usByteAvail )
|
||||
{
|
||||
/* Checksum has already been checked before in prvProcessIPPacket */
|
||||
|
||||
/* Find the first byte of the data within the ICMP packet. */
|
||||
pucByte = ( uint8_t * ) pxICMPPacket;
|
||||
/* Add an offset of 14 + 20 + 8. */
|
||||
pucByte = &( pucByte[ sizeof( ICMPPacket_t ) ] );
|
||||
|
||||
/* Check each byte. */
|
||||
for( usCount = 0; usCount < usByteCount; usCount++ )
|
||||
{
|
||||
if( *pucByte != ( uint8_t ) ipECHO_DATA_FILL_BYTE )
|
||||
{
|
||||
eStatus = eInvalidData;
|
||||
break;
|
||||
}
|
||||
|
||||
pucByte++;
|
||||
}
|
||||
|
||||
/* Call back into the application to pass it the result. */
|
||||
vApplicationPingReplyHook( eStatus, pxICMPPacket->xICMPHeader.usIdentifier );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* usByteCount too small, drop. */
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Buffer too small, drop. */
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* if ( ipconfigSUPPORT_OUTGOING_PINGS == 1 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
+2741
File diff suppressed because it is too large.
Load diff
+741
@@ -0,0 +1,741 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_IP_Timers.c
|
||||
* @brief Implements the Internet Control Message Protocol for the FreeRTOS+TCP network stack.
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
#include "queue.h"
|
||||
#include "semphr.h"
|
||||
|
||||
/* FreeRTOS+TCP includes. */
|
||||
#include "FreeRTOS_IP.h"
|
||||
#include "FreeRTOS_IP_Timers.h"
|
||||
#include "FreeRTOS_IP_Utils.h"
|
||||
#include "FreeRTOS_Sockets.h"
|
||||
#include "FreeRTOS_IP_Private.h"
|
||||
#include "FreeRTOS_UDP_IP.h"
|
||||
#include "FreeRTOS_DHCP.h"
|
||||
#include "FreeRTOS_ARP.h"
|
||||
#include "FreeRTOS_ND.h"
|
||||
#include "NetworkInterface.h"
|
||||
#include "NetworkBufferManagement.h"
|
||||
#include "FreeRTOS_Routing.h"
|
||||
#include "FreeRTOS_DNS.h"
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/** @brief 'xAllNetworksUp' becomes pdTRUE when all network interfaces are initialised
|
||||
* and becomes pdFALSE when any network interface goes down. */
|
||||
/* MISRA Ref 8.9.1 [File scoped variables] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-89 */
|
||||
/* coverity[misra_c_2012_rule_8_9_violation] */
|
||||
static BaseType_t xAllNetworksUp = pdFALSE;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Utility functions for the light weight IP timers.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Start an IP timer. The IP-task has its own implementation of a timer
|
||||
* called 'IPTimer_t', which is based on the FreeRTOS 'TimeOut_t'.
|
||||
*/
|
||||
static void prvIPTimerStart( IPTimer_t * pxTimer,
|
||||
TickType_t xTime );
|
||||
|
||||
/**
|
||||
* Check the IP timer to see whether an IP event should be processed or not.
|
||||
*/
|
||||
static BaseType_t prvIPTimerCheck( IPTimer_t * pxTimer );
|
||||
|
||||
/**
|
||||
* Sets the reload time of an IP timer and restarts it.
|
||||
*/
|
||||
static void prvIPTimerReload( IPTimer_t * pxTimer,
|
||||
TickType_t xTime );
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* A timer for each of the following processes, all of which need attention on a
|
||||
* regular basis
|
||||
*/
|
||||
|
||||
#if ipconfigIS_ENABLED( ipconfigUSE_IPv4 )
|
||||
|
||||
/** @brief Timer to limit the maximum time a packet should be stored while
|
||||
* awaiting an ARP resolution. */
|
||||
static IPTimer_t xARPResolutionTimer;
|
||||
|
||||
/** @brief ARP timer, to check its table entries. */
|
||||
static IPTimer_t xARPTimer;
|
||||
#endif
|
||||
#if ipconfigIS_ENABLED( ipconfigUSE_IPv6 )
|
||||
|
||||
/** @brief Timer to limit the maximum time a packet should be stored while
|
||||
* awaiting an ND resolution. */
|
||||
static IPTimer_t xNDResolutionTimer;
|
||||
|
||||
/** @brief ND timer, to check its table entries. */
|
||||
static IPTimer_t xNDTimer;
|
||||
#endif
|
||||
#if ( ipconfigUSE_TCP != 0 )
|
||||
/** @brief TCP timer, to check for timeouts, resends. */
|
||||
static IPTimer_t xTCPTimer;
|
||||
#endif
|
||||
#if ( ipconfigDNS_USE_CALLBACKS != 0 )
|
||||
/** @brief DNS timer, to check for timeouts when looking-up a domain. */
|
||||
static IPTimer_t xDNSTimer;
|
||||
#endif
|
||||
|
||||
/** @brief As long as not all networks are up, repeat initialisation by calling the
|
||||
* xNetworkInterfaceInitialise() function of the interfaces that are not ready. */
|
||||
|
||||
/* MISRA Ref 8.9.1 [File scoped variables] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-89 */
|
||||
/* coverity[misra_c_2012_rule_8_9_violation] */
|
||||
static IPTimer_t xNetworkTimer;
|
||||
struct xNetworkEndpoint;
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Calculate the maximum sleep time remaining. It will go through all
|
||||
* timers to see which timer will expire first. That will be the amount
|
||||
* of time to block in the next call to xQueueReceive().
|
||||
*
|
||||
* @return The maximum sleep time or ipconfigMAX_IP_TASK_SLEEP_TIME,
|
||||
* whichever is smaller.
|
||||
*/
|
||||
TickType_t xCalculateSleepTime( void )
|
||||
{
|
||||
TickType_t uxMaximumSleepTime;
|
||||
|
||||
/* Start with the maximum sleep time, then check this against the remaining
|
||||
* time in any other timers that are active. */
|
||||
uxMaximumSleepTime = ipconfigMAX_IP_TASK_SLEEP_TIME;
|
||||
|
||||
#if ipconfigIS_ENABLED( ipconfigUSE_IPv4 )
|
||||
if( xARPTimer.bActive != pdFALSE_UNSIGNED )
|
||||
{
|
||||
if( xARPTimer.ulRemainingTime < uxMaximumSleepTime )
|
||||
{
|
||||
uxMaximumSleepTime = xARPTimer.ulRemainingTime;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#if ipconfigIS_ENABLED( ipconfigUSE_IPv6 )
|
||||
if( xNDTimer.bActive != pdFALSE_UNSIGNED )
|
||||
{
|
||||
if( xNDTimer.ulRemainingTime < uxMaximumSleepTime )
|
||||
{
|
||||
uxMaximumSleepTime = xNDTimer.ulRemainingTime;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#if ( ipconfigUSE_DHCP == 1 ) || ( ipconfigUSE_RA == 1 )
|
||||
{
|
||||
const NetworkEndPoint_t * pxEndPoint = pxNetworkEndPoints;
|
||||
|
||||
while( pxEndPoint != NULL )
|
||||
{
|
||||
if( pxEndPoint->xDHCP_RATimer.bActive != pdFALSE_UNSIGNED )
|
||||
{
|
||||
if( pxEndPoint->xDHCP_RATimer.ulRemainingTime < uxMaximumSleepTime )
|
||||
{
|
||||
uxMaximumSleepTime = pxEndPoint->xDHCP_RATimer.ulRemainingTime;
|
||||
}
|
||||
}
|
||||
|
||||
pxEndPoint = pxEndPoint->pxNext;
|
||||
}
|
||||
}
|
||||
#endif /* ipconfigUSE_DHCP */
|
||||
|
||||
#if ( ipconfigUSE_TCP == 1 )
|
||||
{
|
||||
if( xTCPTimer.bActive != pdFALSE_UNSIGNED )
|
||||
{
|
||||
if( xTCPTimer.ulRemainingTime < uxMaximumSleepTime )
|
||||
{
|
||||
uxMaximumSleepTime = xTCPTimer.ulRemainingTime;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#if ( ipconfigDNS_USE_CALLBACKS != 0 )
|
||||
{
|
||||
if( xDNSTimer.bActive != pdFALSE_UNSIGNED )
|
||||
{
|
||||
if( xDNSTimer.ulRemainingTime < uxMaximumSleepTime )
|
||||
{
|
||||
uxMaximumSleepTime = xDNSTimer.ulRemainingTime;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
return uxMaximumSleepTime;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Check the network timers (ARP/ND/DHCP/DNS/TCP) and if they are
|
||||
* expired, send an event to the IP-Task.
|
||||
*/
|
||||
/* MISRA Ref 8.9.1 [File scoped variables] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-89 */
|
||||
/* coverity[misra_c_2012_rule_8_9_violation] */
|
||||
/* coverity[single_use] */
|
||||
void vCheckNetworkTimers( void )
|
||||
{
|
||||
NetworkInterface_t * pxInterface;
|
||||
|
||||
#if ipconfigIS_ENABLED( ipconfigUSE_IPv4 )
|
||||
/* Is it time for ARP processing? */
|
||||
if( prvIPTimerCheck( &xARPTimer ) != pdFALSE )
|
||||
{
|
||||
( void ) xSendEventToIPTask( eARPTimerEvent );
|
||||
}
|
||||
|
||||
/* Is the ARP resolution timer expired? */
|
||||
if( prvIPTimerCheck( &xARPResolutionTimer ) != pdFALSE )
|
||||
{
|
||||
if( pxARPWaitingNetworkBuffer != NULL )
|
||||
{
|
||||
/* Disable the ARP resolution timer. */
|
||||
vIPSetARPResolutionTimerEnableState( pdFALSE );
|
||||
|
||||
/* We have waited long enough for the ARP response. Now, free the network
|
||||
* buffer. */
|
||||
vReleaseNetworkBufferAndDescriptor( pxARPWaitingNetworkBuffer );
|
||||
|
||||
/* Clear the pointer. */
|
||||
pxARPWaitingNetworkBuffer = NULL;
|
||||
|
||||
iptraceDELAYED_ARP_TIMER_EXPIRED();
|
||||
}
|
||||
}
|
||||
#endif /* if ipconfigIS_ENABLED( ipconfigUSE_IPv4 ) */
|
||||
|
||||
#if ipconfigIS_ENABLED( ipconfigUSE_IPv6 )
|
||||
/* Is it time for ND processing? */
|
||||
if( prvIPTimerCheck( &xNDTimer ) != pdFALSE )
|
||||
{
|
||||
( void ) xSendEventToIPTask( eNDTimerEvent );
|
||||
}
|
||||
|
||||
/* Is the ND resolution timer expired? */
|
||||
if( prvIPTimerCheck( &xNDResolutionTimer ) != pdFALSE )
|
||||
{
|
||||
if( pxNDWaitingNetworkBuffer != NULL )
|
||||
{
|
||||
/* Disable the ND resolution timer. */
|
||||
vIPSetNDResolutionTimerEnableState( pdFALSE );
|
||||
|
||||
/* We have waited long enough for the ND response. Now, free the network
|
||||
* buffer. */
|
||||
vReleaseNetworkBufferAndDescriptor( pxNDWaitingNetworkBuffer );
|
||||
|
||||
/* Clear the pointer. */
|
||||
pxNDWaitingNetworkBuffer = NULL;
|
||||
|
||||
iptraceDELAYED_ND_TIMER_EXPIRED();
|
||||
}
|
||||
}
|
||||
#endif /* if ipconfigIS_ENABLED( ipconfigUSE_IPv6 ) */
|
||||
|
||||
#if ( ipconfigUSE_DHCP == 1 ) || ( ipconfigUSE_RA == 1 )
|
||||
{
|
||||
/* Is it time for DHCP processing? */
|
||||
NetworkEndPoint_t * pxEndPoint = pxNetworkEndPoints;
|
||||
|
||||
while( pxEndPoint != NULL )
|
||||
{
|
||||
if( prvIPTimerCheck( &( pxEndPoint->xDHCP_RATimer ) ) != pdFALSE )
|
||||
{
|
||||
#if ( ipconfigUSE_DHCP == 1 )
|
||||
if( END_POINT_USES_DHCP( pxEndPoint ) )
|
||||
{
|
||||
( void ) xSendDHCPEvent( pxEndPoint );
|
||||
}
|
||||
#endif /* ( ipconfigUSE_DHCP == 1 ) */
|
||||
|
||||
#if ( ( ipconfigUSE_RA != 0 ) && ( ipconfigUSE_IPv6 != 0 ) )
|
||||
if( END_POINT_USES_RA( pxEndPoint ) )
|
||||
{
|
||||
vRAProcess( pdFALSE, pxEndPoint );
|
||||
}
|
||||
#endif /* ( ipconfigUSE_RA != 0 ) */
|
||||
}
|
||||
|
||||
pxEndPoint = pxEndPoint->pxNext;
|
||||
}
|
||||
}
|
||||
#endif /* ( ipconfigUSE_DHCP == 1 ) || ( ipconfigUSE_RA != 0 ) */
|
||||
|
||||
#if ( ipconfigDNS_USE_CALLBACKS != 0 )
|
||||
{
|
||||
/* Is it time for DNS processing? */
|
||||
if( prvIPTimerCheck( &xDNSTimer ) != pdFALSE )
|
||||
{
|
||||
vDNSCheckCallBack( NULL );
|
||||
}
|
||||
}
|
||||
#endif /* ipconfigDNS_USE_CALLBACKS */
|
||||
|
||||
#if ( ipconfigUSE_TCP == 1 )
|
||||
{
|
||||
BaseType_t xWillSleep;
|
||||
TickType_t xNextTime;
|
||||
BaseType_t xCheckTCPSockets;
|
||||
|
||||
/* If the IP task has messages waiting to be processed then
|
||||
* it will not sleep in any case. */
|
||||
if( uxQueueMessagesWaiting( xNetworkEventQueue ) == 0U )
|
||||
{
|
||||
xWillSleep = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
xWillSleep = pdFALSE;
|
||||
}
|
||||
|
||||
/* Sockets need to be checked if the TCP timer has expired. */
|
||||
xCheckTCPSockets = prvIPTimerCheck( &xTCPTimer );
|
||||
|
||||
/* Sockets will also be checked if there are TCP messages but the
|
||||
* message queue is empty (indicated by xWillSleep being true). */
|
||||
if( xWillSleep != pdFALSE )
|
||||
{
|
||||
xCheckTCPSockets = pdTRUE;
|
||||
}
|
||||
|
||||
if( xCheckTCPSockets != pdFALSE )
|
||||
{
|
||||
/* Attend to the sockets, returning the period after which the
|
||||
* check must be repeated. */
|
||||
xNextTime = xTCPTimerCheck( xWillSleep );
|
||||
prvIPTimerStart( &xTCPTimer, xNextTime );
|
||||
}
|
||||
}
|
||||
|
||||
/* See if any socket was planned to be closed. */
|
||||
vSocketCloseNextTime( NULL );
|
||||
|
||||
/* See if any reusable socket needs to go back to 'eTCP_LISTEN' state. */
|
||||
vSocketListenNextTime( NULL );
|
||||
#endif /* ipconfigUSE_TCP == 1 */
|
||||
|
||||
/* Is it time to trigger the repeated NetworkDown events? */
|
||||
if( xAllNetworksUp == pdFALSE )
|
||||
{
|
||||
if( prvIPTimerCheck( &( xNetworkTimer ) ) != pdFALSE )
|
||||
{
|
||||
BaseType_t xUp = pdTRUE;
|
||||
|
||||
for( pxInterface = pxNetworkInterfaces; pxInterface != NULL; pxInterface = pxInterface->pxNext )
|
||||
{
|
||||
if( pxInterface->bits.bInterfaceUp == pdFALSE_UNSIGNED )
|
||||
{
|
||||
xUp = pdFALSE;
|
||||
FreeRTOS_NetworkDown( pxInterface );
|
||||
}
|
||||
}
|
||||
|
||||
vSetAllNetworksUp( xUp );
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Start an IP timer. The IP-task has its own implementation of a timer
|
||||
* called 'IPTimer_t', which is based on the FreeRTOS 'TimeOut_t'.
|
||||
*
|
||||
* @param[in] pxTimer Pointer to the IP timer. When zero, the timer is marked
|
||||
* as expired.
|
||||
* @param[in] xTime Time to be loaded into the IP timer.
|
||||
*/
|
||||
static void prvIPTimerStart( IPTimer_t * pxTimer,
|
||||
TickType_t xTime )
|
||||
{
|
||||
vTaskSetTimeOutState( &pxTimer->xTimeOut );
|
||||
pxTimer->ulRemainingTime = xTime;
|
||||
|
||||
if( xTime == ( TickType_t ) 0 )
|
||||
{
|
||||
pxTimer->bExpired = ipTRUE_BOOL;
|
||||
}
|
||||
else
|
||||
{
|
||||
pxTimer->bExpired = ipFALSE_BOOL;
|
||||
}
|
||||
|
||||
pxTimer->bActive = ipTRUE_BOOL;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ipconfigIS_ENABLED( ipconfigUSE_IPv4 )
|
||||
|
||||
/**
|
||||
* @brief Start an ARP Resolution timer.
|
||||
*
|
||||
* @param[in] xTime Time to be loaded into the ARP Resolution timer.
|
||||
*/
|
||||
void vIPTimerStartARPResolution( TickType_t xTime )
|
||||
{
|
||||
prvIPTimerStart( &( xARPResolutionTimer ), xTime );
|
||||
}
|
||||
#endif
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ipconfigIS_ENABLED( ipconfigUSE_IPv6 )
|
||||
|
||||
/**
|
||||
* @brief Start an ND Resolution timer.
|
||||
*
|
||||
* @param[in] xTime Time to be loaded into the ND Resolution timer.
|
||||
*/
|
||||
void vIPTimerStartNDResolution( TickType_t xTime )
|
||||
{
|
||||
prvIPTimerStart( &( xNDResolutionTimer ), xTime );
|
||||
}
|
||||
#endif
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Sets the reload time of an IP timer and restarts it.
|
||||
*
|
||||
* @param[in] pxTimer Pointer to the IP timer.
|
||||
* @param[in] xTime Time to be reloaded into the IP timer.
|
||||
*/
|
||||
static void prvIPTimerReload( IPTimer_t * pxTimer,
|
||||
TickType_t xTime )
|
||||
{
|
||||
pxTimer->ulReloadTime = xTime;
|
||||
prvIPTimerStart( pxTimer, xTime );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ipconfigUSE_TCP == 1 )
|
||||
|
||||
/**
|
||||
* @brief Sets the reload time of the TCP timer and restarts it.
|
||||
*
|
||||
* @param[in] xTime Time to be reloaded into the TCP timer.
|
||||
*/
|
||||
void vTCPTimerReload( TickType_t xTime )
|
||||
{
|
||||
prvIPTimerReload( &xTCPTimer, xTime );
|
||||
}
|
||||
#endif
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ipconfigIS_ENABLED( ipconfigUSE_IPv4 )
|
||||
|
||||
/**
|
||||
* @brief Sets the reload time of the ARP timer and restarts it.
|
||||
*
|
||||
* @param[in] xTime Time to be reloaded into the ARP timer.
|
||||
*/
|
||||
void vARPTimerReload( TickType_t xTime )
|
||||
{
|
||||
prvIPTimerReload( &xARPTimer, xTime );
|
||||
}
|
||||
#endif
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ipconfigIS_ENABLED( ipconfigUSE_IPv6 )
|
||||
|
||||
/**
|
||||
* @brief Sets the reload time of the ND timer and restarts it.
|
||||
*
|
||||
* @param[in] xTime Time to be reloaded into the ND timer.
|
||||
*/
|
||||
void vNDTimerReload( TickType_t xTime )
|
||||
{
|
||||
prvIPTimerReload( &xNDTimer, xTime );
|
||||
}
|
||||
#endif
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ipconfigDNS_USE_CALLBACKS != 0 )
|
||||
|
||||
/**
|
||||
* @brief Reload the DNS timer.
|
||||
*
|
||||
* @param[in] ulCheckTime The reload value.
|
||||
*/
|
||||
void vDNSTimerReload( uint32_t ulCheckTime )
|
||||
{
|
||||
prvIPTimerReload( &xDNSTimer, ulCheckTime );
|
||||
}
|
||||
#endif /* ipconfigDNS_USE_CALLBACKS != 0 */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ipconfigUSE_DHCP == 1 ) || ( ipconfigUSE_RA == 1 )
|
||||
|
||||
/**
|
||||
* @brief Set the reload time of the DHCP/DHCPv6/RA timer.
|
||||
*
|
||||
* @param[in] pxEndPoint The end-point that needs to acquire an IP-address.
|
||||
* @param[in] uxClockTicks The number of clock-ticks after which the timer should expire.
|
||||
*/
|
||||
|
||||
void vDHCP_RATimerReload( NetworkEndPoint_t * pxEndPoint,
|
||||
TickType_t uxClockTicks )
|
||||
{
|
||||
FreeRTOS_printf( ( "vDHCP_RATimerReload: %lu\n", ( unsigned long ) uxClockTicks ) );
|
||||
prvIPTimerReload( &( pxEndPoint->xDHCP_RATimer ), uxClockTicks );
|
||||
}
|
||||
#endif /* ( ipconfigUSE_DHCP == 1 ) || ( ipconfigUSE_RA == 1 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Reload the Network timer.
|
||||
*
|
||||
* @param[in] xTime Time to be reloaded into the Network timer.
|
||||
*/
|
||||
void vNetworkTimerReload( TickType_t xTime )
|
||||
{
|
||||
prvIPTimerReload( &xNetworkTimer, xTime );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Check the IP timer to see whether an IP event should be processed or not.
|
||||
*
|
||||
* @param[in] pxTimer Pointer to the IP timer.
|
||||
*
|
||||
* @return If the timer is expired then pdTRUE is returned. Else pdFALSE.
|
||||
*/
|
||||
static BaseType_t prvIPTimerCheck( IPTimer_t * pxTimer )
|
||||
{
|
||||
BaseType_t xReturn;
|
||||
|
||||
if( pxTimer->bActive == pdFALSE_UNSIGNED )
|
||||
{
|
||||
/* The timer is not enabled. */
|
||||
xReturn = pdFALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The timer might have set the bExpired flag already, if not, check the
|
||||
* value of xTimeOut against ulRemainingTime. */
|
||||
if( pxTimer->bExpired == ipFALSE_BOOL )
|
||||
{
|
||||
if( xTaskCheckForTimeOut( &( pxTimer->xTimeOut ), &( pxTimer->ulRemainingTime ) ) != pdFALSE )
|
||||
{
|
||||
pxTimer->bExpired = ipTRUE_BOOL;
|
||||
}
|
||||
}
|
||||
|
||||
if( pxTimer->bExpired != ipFALSE_BOOL )
|
||||
{
|
||||
prvIPTimerStart( pxTimer, pxTimer->ulReloadTime );
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
xReturn = pdFALSE;
|
||||
}
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ipconfigUSE_TCP == 1 )
|
||||
|
||||
/**
|
||||
* @brief Enable/disable the TCP timer.
|
||||
*
|
||||
* @param[in] xExpiredState pdTRUE - set as expired; pdFALSE - set as non-expired.
|
||||
*/
|
||||
void vIPSetTCPTimerExpiredState( BaseType_t xExpiredState )
|
||||
{
|
||||
xTCPTimer.bActive = ipTRUE_BOOL;
|
||||
|
||||
if( xExpiredState != pdFALSE )
|
||||
{
|
||||
xTCPTimer.bExpired = ipTRUE_BOOL;
|
||||
}
|
||||
else
|
||||
{
|
||||
xTCPTimer.bExpired = ipFALSE_BOOL;
|
||||
}
|
||||
}
|
||||
#endif /* if ( ipconfigUSE_TCP == 1 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ipconfigIS_ENABLED( ipconfigUSE_IPv4 )
|
||||
|
||||
/**
|
||||
* @brief Enable/disable the ARP timer.
|
||||
*
|
||||
* @param[in] xEnableState pdTRUE - enable timer; pdFALSE - disable timer.
|
||||
*/
|
||||
void vIPSetARPTimerEnableState( BaseType_t xEnableState )
|
||||
{
|
||||
if( xEnableState != pdFALSE )
|
||||
{
|
||||
xARPTimer.bActive = ipTRUE_BOOL;
|
||||
}
|
||||
else
|
||||
{
|
||||
xARPTimer.bActive = ipFALSE_BOOL;
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Enable or disable the ARP resolution timer.
|
||||
*
|
||||
* @param[in] xEnableState pdTRUE if the timer must be enabled, pdFALSE otherwise.
|
||||
*/
|
||||
void vIPSetARPResolutionTimerEnableState( BaseType_t xEnableState )
|
||||
{
|
||||
if( xEnableState != pdFALSE )
|
||||
{
|
||||
xARPResolutionTimer.bActive = ipTRUE_BOOL;
|
||||
}
|
||||
else
|
||||
{
|
||||
xARPResolutionTimer.bActive = ipFALSE_BOOL;
|
||||
}
|
||||
}
|
||||
#endif /* if ipconfigIS_ENABLED( ipconfigUSE_IPv4 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ipconfigIS_ENABLED( ipconfigUSE_IPv6 )
|
||||
|
||||
/**
|
||||
* @brief Enable/disable the ND timer.
|
||||
*
|
||||
* @param[in] xEnableState pdTRUE - enable timer; pdFALSE - disable timer.
|
||||
*/
|
||||
void vIPSetNDTimerEnableState( BaseType_t xEnableState )
|
||||
{
|
||||
if( xEnableState != pdFALSE )
|
||||
{
|
||||
xNDTimer.bActive = ipTRUE_BOOL;
|
||||
}
|
||||
else
|
||||
{
|
||||
xNDTimer.bActive = ipFALSE_BOOL;
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Enable or disable the ND resolution timer.
|
||||
*
|
||||
* @param[in] xEnableState pdTRUE if the timer must be enabled, pdFALSE otherwise.
|
||||
*/
|
||||
void vIPSetNDResolutionTimerEnableState( BaseType_t xEnableState )
|
||||
{
|
||||
if( xEnableState != pdFALSE )
|
||||
{
|
||||
xNDResolutionTimer.bActive = ipTRUE_BOOL;
|
||||
}
|
||||
else
|
||||
{
|
||||
xNDResolutionTimer.bActive = ipFALSE_BOOL;
|
||||
}
|
||||
}
|
||||
#endif /* if ipconfigIS_ENABLED( ipconfigUSE_IPv6 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ipconfigUSE_DHCP == 1 ) || ( ipconfigUSE_RA == 1 ) || ( ipconfigUSE_DHCPv6 == 1 )
|
||||
|
||||
/**
|
||||
* @brief Enable or disable the DHCP/DHCPv6/RA timer.
|
||||
*
|
||||
* @param[in] pxEndPoint The end-point that needs to acquire an IP-address.
|
||||
* @param[in] xEnableState pdTRUE if the timer must be enabled, pdFALSE otherwise.
|
||||
*/
|
||||
void vIPSetDHCP_RATimerEnableState( NetworkEndPoint_t * pxEndPoint,
|
||||
BaseType_t xEnableState )
|
||||
{
|
||||
FreeRTOS_printf( ( "vIPSetDHCP_RATimerEnableState: %s\n", ( xEnableState != 0 ) ? "On" : "Off" ) );
|
||||
|
||||
/* 'xDHCP_RATimer' is shared between DHCP (IPv4) and RA/SLAAC (IPv6). */
|
||||
if( xEnableState != 0 )
|
||||
{
|
||||
pxEndPoint->xDHCP_RATimer.bActive = ipTRUE_BOOL;
|
||||
}
|
||||
else
|
||||
{
|
||||
pxEndPoint->xDHCP_RATimer.bActive = ipFALSE_BOOL;
|
||||
}
|
||||
}
|
||||
#endif /* if ( ipconfigUSE_DHCP == 1 ) || ( ipconfigUSE_RA == 1 ) || ( ipconfigUSE_DHCPv6 == 1 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#if ( ipconfigDNS_USE_CALLBACKS == 1 )
|
||||
|
||||
/**
|
||||
* @brief Enable/disable the DNS timer.
|
||||
*
|
||||
* @param[in] xEnableState pdTRUE - enable timer; pdFALSE - disable timer.
|
||||
*/
|
||||
void vIPSetDNSTimerEnableState( BaseType_t xEnableState )
|
||||
{
|
||||
if( xEnableState != 0 )
|
||||
{
|
||||
xDNSTimer.bActive = ipTRUE_BOOL;
|
||||
}
|
||||
else
|
||||
{
|
||||
xDNSTimer.bActive = ipFALSE_BOOL;
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* ipconfigDNS_USE_CALLBACKS == 1 */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Mark whether all interfaces are up or at least one interface is down.
|
||||
* If all interfaces are up, the 'xNetworkTimer' will not be checked.
|
||||
*/
|
||||
void vSetAllNetworksUp( BaseType_t xIsAllNetworksUp )
|
||||
{
|
||||
xAllNetworksUp = xIsAllNetworksUp;
|
||||
}
|
||||
+1903
File diff suppressed because it is too large.
Load diff
+644
@@ -0,0 +1,644 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_IPv4.c
|
||||
* @brief Implements the basic functionality for the FreeRTOS+TCP network stack.
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
|
||||
/* FreeRTOS+TCP includes. */
|
||||
#include "FreeRTOS_IP.h"
|
||||
#include "FreeRTOS_IPv4.h"
|
||||
|
||||
/* IPv4 multi-cast addresses range from 224.0.0.0.0 to 240.0.0.0. */
|
||||
#define ipFIRST_MULTI_CAST_IPv4 0xE0000000U /**< Lower bound of the IPv4 multicast address. */
|
||||
#define ipLAST_MULTI_CAST_IPv4 0xF0000000U /**< Higher bound of the IPv4 multicast address. */
|
||||
|
||||
/* Just make sure the contents doesn't get compiled if IPv4 is not enabled. */
|
||||
/* *INDENT-OFF* */
|
||||
#if( ipconfigUSE_IPv4 != 0 )
|
||||
/* *INDENT-ON* */
|
||||
|
||||
#if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 )
|
||||
/* Check IPv4 packet length. */
|
||||
static BaseType_t xCheckIPv4SizeFields( const void * const pvEthernetBuffer,
|
||||
size_t uxBufferLength );
|
||||
#endif /* ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 ) */
|
||||
|
||||
|
||||
#if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 )
|
||||
|
||||
/**
|
||||
* @brief Check IPv4 packet length.
|
||||
*
|
||||
* @param[in] pvEthernetBuffer The Ethernet packet received.
|
||||
* @param[in] uxBufferLength The total number of bytes received.
|
||||
*
|
||||
* @return pdPASS when the length fields in the packet OK, pdFAIL when the packet
|
||||
* should be dropped.
|
||||
*/
|
||||
static BaseType_t xCheckIPv4SizeFields( const void * const pvEthernetBuffer,
|
||||
size_t uxBufferLength )
|
||||
{
|
||||
size_t uxLength;
|
||||
UBaseType_t uxIPHeaderLength;
|
||||
uint8_t ucProtocol;
|
||||
uint16_t usLength;
|
||||
uint16_t ucVersionHeaderLength;
|
||||
size_t uxMinimumLength;
|
||||
BaseType_t xResult = pdFAIL;
|
||||
|
||||
/* Map the buffer onto a IP-Packet struct to easily access the
|
||||
* fields of the IP packet. */
|
||||
const IPPacket_t * const pxIPPacket = ( ( const IPPacket_t * ) pvEthernetBuffer );
|
||||
|
||||
DEBUG_DECLARE_TRACE_VARIABLE( BaseType_t, xLocation, 0 );
|
||||
|
||||
do
|
||||
{
|
||||
/* Check for minimum packet size: Ethernet header and an IP-header, 34 bytes */
|
||||
if( uxBufferLength < sizeof( IPPacket_t ) )
|
||||
{
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 1 );
|
||||
break;
|
||||
}
|
||||
|
||||
ucVersionHeaderLength = pxIPPacket->xIPHeader.ucVersionHeaderLength;
|
||||
|
||||
/* Test if the length of the IP-header is between 20 and 60 bytes,
|
||||
* and if the IP-version is 4. */
|
||||
if( ( ucVersionHeaderLength < ipIPV4_VERSION_HEADER_LENGTH_MIN ) ||
|
||||
( ucVersionHeaderLength > ipIPV4_VERSION_HEADER_LENGTH_MAX ) )
|
||||
{
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 2 );
|
||||
break;
|
||||
}
|
||||
|
||||
ucVersionHeaderLength = ( uint16_t ) ( ( ucVersionHeaderLength & ( uint8_t ) 0x0FU ) << 2U );
|
||||
uxIPHeaderLength = ( UBaseType_t ) ucVersionHeaderLength;
|
||||
|
||||
/* Check if the complete IP-header is transferred. */
|
||||
if( uxBufferLength < ( ipSIZE_OF_ETH_HEADER + uxIPHeaderLength ) )
|
||||
{
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 3 );
|
||||
break;
|
||||
}
|
||||
|
||||
/* Check if the complete IP-header plus protocol data have been transferred: */
|
||||
usLength = pxIPPacket->xIPHeader.usLength;
|
||||
usLength = FreeRTOS_ntohs( usLength );
|
||||
|
||||
if( uxBufferLength < ( size_t ) ( ipSIZE_OF_ETH_HEADER + ( size_t ) usLength ) )
|
||||
{
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 4 );
|
||||
break;
|
||||
}
|
||||
|
||||
/* Identify the next protocol. */
|
||||
ucProtocol = pxIPPacket->xIPHeader.ucProtocol;
|
||||
|
||||
/* Switch on the Layer 3/4 protocol. */
|
||||
if( ucProtocol == ( uint8_t ) ipPROTOCOL_UDP )
|
||||
{
|
||||
/* Expect at least a complete UDP header. */
|
||||
uxMinimumLength = uxIPHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_UDP_HEADER;
|
||||
}
|
||||
else if( ucProtocol == ( uint8_t ) ipPROTOCOL_TCP )
|
||||
{
|
||||
uxMinimumLength = uxIPHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_TCP_HEADER;
|
||||
}
|
||||
else if( ( ucProtocol == ( uint8_t ) ipPROTOCOL_ICMP ) ||
|
||||
( ucProtocol == ( uint8_t ) ipPROTOCOL_IGMP ) )
|
||||
{
|
||||
uxMinimumLength = uxIPHeaderLength + ipSIZE_OF_ETH_HEADER + ipSIZE_OF_ICMPv4_HEADER;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Unhandled protocol, other than ICMP, IGMP, UDP, or TCP. */
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 5 );
|
||||
break;
|
||||
}
|
||||
|
||||
if( uxBufferLength < uxMinimumLength )
|
||||
{
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 6 );
|
||||
break;
|
||||
}
|
||||
|
||||
uxLength = ( size_t ) usLength;
|
||||
uxLength -= ( ( uint16_t ) uxIPHeaderLength ); /* normally, minus 20. */
|
||||
|
||||
if( ( uxLength < ( ( size_t ) sizeof( UDPHeader_t ) ) ) ||
|
||||
( uxLength > ( ( size_t ) ipconfigNETWORK_MTU - ( size_t ) uxIPHeaderLength ) ) )
|
||||
{
|
||||
/* For incoming packets, the length is out of bound: either
|
||||
* too short or too long. For outgoing packets, there is a
|
||||
* serious problem with the format/length. */
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 7 );
|
||||
break;
|
||||
}
|
||||
|
||||
xResult = pdPASS;
|
||||
} while( ipFALSE_BOOL );
|
||||
|
||||
if( xResult != pdPASS )
|
||||
{
|
||||
/* NOP if ipconfigHAS_PRINTF != 1 */
|
||||
FreeRTOS_printf( ( "xCheckIPv4SizeFields: location %ld\n", xLocation ) );
|
||||
}
|
||||
|
||||
return xResult;
|
||||
}
|
||||
|
||||
#endif /* ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Is the IP address an IPv4 multicast address.
|
||||
*
|
||||
* @param[in] ulIPAddress The IP address being checked.
|
||||
*
|
||||
* @return pdTRUE if the IP address is a multicast address or else, pdFALSE.
|
||||
*/
|
||||
BaseType_t xIsIPv4Multicast( uint32_t ulIPAddress )
|
||||
{
|
||||
BaseType_t xReturn;
|
||||
uint32_t ulIP = FreeRTOS_ntohl( ulIPAddress );
|
||||
|
||||
if( ( ulIP >= ipFIRST_MULTI_CAST_IPv4 ) && ( ulIP < ipLAST_MULTI_CAST_IPv4 ) )
|
||||
{
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
xReturn = pdFALSE;
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Checks if the IP address matches the global 255.255.255.255 broadcast address or
|
||||
* the broadcast address for any of our IPv4 endpoints.
|
||||
*
|
||||
* @param[in] ulIPAddress The IP address being checked.
|
||||
*
|
||||
* @param[out] ppxEndPoint Pointer to an end-point where we store the endpoint whose broadcast address we matched. Or NULL if no IPv4 endpoints were found.
|
||||
*
|
||||
* @return pdTRUE if the IP address is a broadcast address or else, pdFALSE.
|
||||
*/
|
||||
BaseType_t xIsIPv4Broadcast( uint32_t ulIPAddress,
|
||||
struct xNetworkEndPoint ** ppxEndPoint )
|
||||
{
|
||||
BaseType_t xIsBroadcast;
|
||||
NetworkEndPoint_t * pxEndPoint;
|
||||
|
||||
/* Assign a default answer based on the "global" broadcast. This way
|
||||
* we can still return the correct result even if there are no endpoints. */
|
||||
xIsBroadcast = ( ulIPAddress == FREERTOS_INADDR_BROADCAST ) ? pdTRUE : pdFALSE;
|
||||
|
||||
for( pxEndPoint = FreeRTOS_FirstEndPoint( NULL );
|
||||
pxEndPoint != NULL;
|
||||
pxEndPoint = FreeRTOS_NextEndPoint( NULL, pxEndPoint ) )
|
||||
{
|
||||
#if ( ipconfigUSE_IPv6 == ipconfigENABLE )
|
||||
/* Skip over any IPv6 endpoints. */
|
||||
if( pxEndPoint->bits.bIPv6 == ipTRUE_BOOL )
|
||||
{
|
||||
continue;
|
||||
}
|
||||
#endif /* ( ipconfigUSE_IPv6 == ipconfigENABLE ) */
|
||||
|
||||
/* If we already know if ulIPAddress is a broadcast,
|
||||
* simply return this first matching IPv4 endpoint. */
|
||||
if( xIsBroadcast == pdTRUE )
|
||||
{
|
||||
break;
|
||||
}
|
||||
else if( ulIPAddress == pxEndPoint->ipv4_settings.ulBroadcastAddress )
|
||||
{
|
||||
xIsBroadcast = pdTRUE;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* do nothing, coverity happy */
|
||||
}
|
||||
}
|
||||
|
||||
/* If the caller wants to know the corresponding endpoint, copy the result.
|
||||
* Note that this may be null if ulIPAddress is 255.255.255.255 AND there are
|
||||
* no IPv4 endpoints.
|
||||
* Also, when ulIPAddress is 255.255.255.255, we will
|
||||
* return the first IPv4 endpoint that we run across. */
|
||||
if( ( xIsBroadcast == pdTRUE ) && ( ppxEndPoint != NULL ) )
|
||||
{
|
||||
*ppxEndPoint = pxEndPoint;
|
||||
}
|
||||
|
||||
return xIsBroadcast;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Check if the packet is an illegal loopback packet.
|
||||
*
|
||||
* @param[in] pxIPHeader The IP-header being checked.
|
||||
*
|
||||
* @return Returns pdTRUE if the packet should be stopped, because either the source
|
||||
* or the target address is a loopback address.
|
||||
*/
|
||||
BaseType_t xBadIPv4Loopback( const IPHeader_t * const pxIPHeader )
|
||||
{
|
||||
BaseType_t xReturn = pdFALSE;
|
||||
BaseType_t x1 = ( xIsIPv4Loopback( pxIPHeader->ulDestinationIPAddress ) != 0 ) ? pdTRUE : pdFALSE;
|
||||
BaseType_t x2 = ( xIsIPv4Loopback( pxIPHeader->ulSourceIPAddress ) != 0 ) ? pdTRUE : pdFALSE;
|
||||
|
||||
if( x1 != x2 )
|
||||
{
|
||||
/* Either the source or the destination address is an IPv4 loopback address. */
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Is the IP address an IPv4 loopback address.
|
||||
*
|
||||
* @param[in] ulAddress The IP address being checked.
|
||||
*
|
||||
* @return pdTRUE if the IP address is a loopback address or else, pdFALSE.
|
||||
*/
|
||||
BaseType_t xIsIPv4Loopback( uint32_t ulAddress )
|
||||
{
|
||||
BaseType_t xReturn = pdFALSE;
|
||||
uint32_t ulIP = FreeRTOS_ntohl( ulAddress );
|
||||
|
||||
if( ( ulIP >= ipFIRST_LOOPBACK_IPv4 ) &&
|
||||
( ulIP < ipLAST_LOOPBACK_IPv4 ) )
|
||||
{
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Check whether this IPv4 packet is to be allowed or to be dropped.
|
||||
*
|
||||
* @param[in] pxIPPacket The IP packet under consideration.
|
||||
* @param[in] pxNetworkBuffer The whole network buffer.
|
||||
* @param[in] uxHeaderLength The length of the header.
|
||||
*
|
||||
* @return Whether the packet should be processed or dropped.
|
||||
*/
|
||||
enum eFrameProcessingResult prvAllowIPPacketIPv4( const struct xIP_PACKET * const pxIPPacket,
|
||||
const struct xNETWORK_BUFFER * const pxNetworkBuffer,
|
||||
UBaseType_t uxHeaderLength )
|
||||
{
|
||||
eFrameProcessingResult_t eReturn = eProcessBuffer;
|
||||
|
||||
#if ( ( ipconfigETHERNET_DRIVER_FILTERS_PACKETS == 0 ) || ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 ) )
|
||||
const IPHeader_t * pxIPHeader = &( pxIPPacket->xIPHeader );
|
||||
#else
|
||||
|
||||
/* or else, the parameter won't be used and the function will be optimised
|
||||
* away */
|
||||
( void ) pxIPPacket;
|
||||
#endif
|
||||
|
||||
#if ( ipconfigETHERNET_DRIVER_FILTERS_PACKETS == 0 )
|
||||
{
|
||||
/* In systems with a very small amount of RAM, it might be advantageous
|
||||
* to have incoming messages checked earlier, by the network card driver.
|
||||
* This method may decrease the usage of scarce network buffers. */
|
||||
uint32_t ulDestinationIPAddress = pxIPHeader->ulDestinationIPAddress;
|
||||
uint32_t ulSourceIPAddress = pxIPHeader->ulSourceIPAddress;
|
||||
/* Get a reference to the endpoint that the packet was assigned to during pxEasyFit() */
|
||||
const NetworkEndPoint_t * pxEndPoint = pxNetworkBuffer->pxEndPoint;
|
||||
|
||||
/* Ensure that the incoming packet is not fragmented because the stack
|
||||
* doesn't not support IP fragmentation. All but the last fragment coming in will have their
|
||||
* "more fragments" flag set and the last fragment will have a non-zero offset.
|
||||
* We need to drop the packet in either of those cases. */
|
||||
if( ( ( pxIPHeader->usFragmentOffset & ipFRAGMENT_OFFSET_BIT_MASK ) != 0U ) || ( ( pxIPHeader->usFragmentOffset & ipFRAGMENT_FLAGS_MORE_FRAGMENTS ) != 0U ) )
|
||||
{
|
||||
/* Can not handle, fragmented packet. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
|
||||
/* Test if the length of the IP-header is between 20 and 60 bytes,
|
||||
* and if the IP-version is 4. */
|
||||
else if( ( pxIPHeader->ucVersionHeaderLength < ipIPV4_VERSION_HEADER_LENGTH_MIN ) ||
|
||||
( pxIPHeader->ucVersionHeaderLength > ipIPV4_VERSION_HEADER_LENGTH_MAX ) )
|
||||
{
|
||||
/* Can not handle, unknown or invalid header version. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
else if( ( xIsIPv4Loopback( ulDestinationIPAddress ) == pdTRUE ) ||
|
||||
( xIsIPv4Loopback( ulSourceIPAddress ) == pdTRUE ) )
|
||||
{
|
||||
/* source OR destination is a loopback address. Make sure they BOTH are. */
|
||||
if( xBadIPv4Loopback( &( pxIPPacket->xIPHeader ) ) == pdTRUE )
|
||||
{
|
||||
/* The local loopback addresses must never appear outside a host. See RFC 1122
|
||||
* section 3.2.1.3. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
}
|
||||
else if( memcmp( xBroadcastMACAddress.ucBytes,
|
||||
pxIPPacket->xEthernetHeader.xSourceAddress.ucBytes,
|
||||
sizeof( MACAddress_t ) ) == 0 )
|
||||
{
|
||||
/* Ethernet source is a broadcast address. Drop the packet. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
else if( xIsIPv4Multicast( ulSourceIPAddress ) == pdTRUE )
|
||||
{
|
||||
/* Source is a multicast IP address. Drop the packet in conformity with RFC 1112 section 7.2. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
|
||||
/* Use ipv4_settings for filtering only after the endpoint is up,
|
||||
* so that DHCP packets that are exchanged for DHCP (example, DHCP unicast offers)
|
||||
* are not dropped/filtered. */
|
||||
else if( FreeRTOS_IsEndPointUp( pxEndPoint ) != pdFALSE )
|
||||
{
|
||||
if(
|
||||
/* Not destined for the assigned endpoint IPv4 address? */
|
||||
( ulDestinationIPAddress != pxEndPoint->ipv4_settings.ulIPAddress ) &&
|
||||
/* Also not an IPv4 broadcast address ? */
|
||||
( ulDestinationIPAddress != pxEndPoint->ipv4_settings.ulBroadcastAddress ) &&
|
||||
( ulDestinationIPAddress != FREERTOS_INADDR_BROADCAST ) &&
|
||||
/* And not an IPv4 multicast address ? */
|
||||
( xIsIPv4Multicast( ulDestinationIPAddress ) == pdFALSE ) )
|
||||
{
|
||||
/* Packet is not for this node, release it */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
/* Is the source address correct? */
|
||||
else if( ( ulSourceIPAddress == pxEndPoint->ipv4_settings.ulBroadcastAddress ) ||
|
||||
( ulSourceIPAddress == FREERTOS_INADDR_BROADCAST ) )
|
||||
{
|
||||
/* The source address cannot be broadcast address. Replying to this
|
||||
* packet may cause network storms. Drop the packet. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
else if( ( memcmp( xBroadcastMACAddress.ucBytes,
|
||||
pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes,
|
||||
sizeof( MACAddress_t ) ) == 0 ) &&
|
||||
( ulDestinationIPAddress != pxEndPoint->ipv4_settings.ulBroadcastAddress ) && ( ulDestinationIPAddress != FREERTOS_INADDR_BROADCAST ) )
|
||||
{
|
||||
/* Ethernet address is a broadcast address, but the IP address is not a
|
||||
* broadcast address. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Packet is not fragmented, destination is this device, source IP and MAC
|
||||
* addresses are correct. */
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Endpoint is down */
|
||||
|
||||
/* Check if the destination MAC address is a broadcast MAC address. */
|
||||
if( memcmp( xBroadcastMACAddress.ucBytes,
|
||||
pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes,
|
||||
sizeof( MACAddress_t ) ) == 0 )
|
||||
{
|
||||
if( ulDestinationIPAddress != FREERTOS_INADDR_BROADCAST )
|
||||
{
|
||||
/* Ethernet address is a broadcast address, but the IP address is not a
|
||||
* broadcast address. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Accept valid broadcast packet. */
|
||||
}
|
||||
}
|
||||
|
||||
/* RFC 2131: https://datatracker.ietf.org/doc/html/rfc2131#autoid-8
|
||||
* The TCP/IP software SHOULD accept and
|
||||
* forward to the IP layer any IP packets delivered to the client's
|
||||
* hardware address before the IP address is configured; DHCP servers
|
||||
* and BOOTP relay agents may not be able to deliver DHCP messages to
|
||||
* clients that cannot accept hardware unicast datagrams before the
|
||||
* TCP/IP software is configured. */
|
||||
else if( ( memcmp( pxEndPoint->xMACAddress.ucBytes,
|
||||
pxIPPacket->xEthernetHeader.xDestinationAddress.ucBytes,
|
||||
sizeof( MACAddress_t ) ) != 0 ) )
|
||||
{
|
||||
/* The endpoint is not up, and the destination MAC address of the
|
||||
* packet is not matching the endpoint's MAC address nor broadcast
|
||||
* MAC address. Drop the packet. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Endpoint is down, but the hardware address matches. Accept the
|
||||
* packet as per RFC 2131 */
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* ipconfigETHERNET_DRIVER_FILTERS_PACKETS */
|
||||
|
||||
#if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 )
|
||||
{
|
||||
/* Some drivers of NIC's with checksum-offloading will enable the above
|
||||
* define, so that the checksum won't be checked again here */
|
||||
if( eReturn == eProcessBuffer )
|
||||
{
|
||||
/* Is the IP header checksum correct?
|
||||
*
|
||||
* NOTE: When the checksum of IP header is calculated while not omitting
|
||||
* the checksum field, the resulting value of the checksum always is 0xffff
|
||||
* which is denoted by ipCORRECT_CRC. See this wiki for more information:
|
||||
* https://en.wikipedia.org/wiki/IPv4_header_checksum#Verifying_the_IPv4_header_checksum
|
||||
* and this RFC: https://tools.ietf.org/html/rfc1624#page-4
|
||||
*/
|
||||
if( usGenerateChecksum( 0U, ( const uint8_t * ) &( pxIPHeader->ucVersionHeaderLength ), ( size_t ) uxHeaderLength ) != ipCORRECT_CRC )
|
||||
{
|
||||
/* Check sum in IP-header not correct. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
/* Is the upper-layer checksum (TCP/UDP/ICMP) correct? */
|
||||
else if( usGenerateProtocolChecksum( ( uint8_t * ) ( pxNetworkBuffer->pucEthernetBuffer ), pxNetworkBuffer->xDataLength, pdFALSE ) != ipCORRECT_CRC )
|
||||
{
|
||||
/* Protocol checksum not accepted. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The checksum of the received packet is OK. */
|
||||
}
|
||||
}
|
||||
}
|
||||
#else /* if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 ) */
|
||||
{
|
||||
if( eReturn == eProcessBuffer )
|
||||
{
|
||||
if( xCheckIPv4SizeFields( pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength ) != pdPASS )
|
||||
{
|
||||
/* Some of the length checks were not successful. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
}
|
||||
|
||||
#if ( ipconfigUDP_PASS_ZERO_CHECKSUM_PACKETS == 0 )
|
||||
{
|
||||
/* Check if this is a UDP packet without a checksum. */
|
||||
if( eReturn == eProcessBuffer )
|
||||
{
|
||||
uint8_t ucProtocol;
|
||||
const ProtocolHeaders_t * pxProtocolHeaders;
|
||||
|
||||
/* ipconfigUDP_PASS_ZERO_CHECKSUM_PACKETS is defined as 0,
|
||||
* and so UDP packets carrying a protocol checksum of 0, will
|
||||
* be dropped. */
|
||||
ucProtocol = pxIPPacket->xIPHeader.ucProtocol;
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
pxProtocolHeaders = ( ( ProtocolHeaders_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ( size_t ) ipSIZE_OF_IPv4_HEADER ] ) );
|
||||
|
||||
/* Identify the next protocol. */
|
||||
if( ucProtocol == ( uint8_t ) ipPROTOCOL_UDP )
|
||||
{
|
||||
if( pxProtocolHeaders->xUDPHeader.usChecksum == ( uint16_t ) 0U )
|
||||
{
|
||||
#if ( ipconfigHAS_PRINTF != 0 )
|
||||
{
|
||||
static BaseType_t xCount = 0;
|
||||
|
||||
/* Exclude this from branch coverage as this is only used for debugging. */
|
||||
if( xCount < 5 ) /* LCOV_EXCL_BR_LINE */
|
||||
{
|
||||
FreeRTOS_printf( ( "prvAllowIPPacket: UDP packet from %lxip without CRC dropped\n",
|
||||
( unsigned long ) FreeRTOS_ntohl( pxIPPacket->xIPHeader.ulSourceIPAddress ) ) );
|
||||
xCount++;
|
||||
}
|
||||
}
|
||||
#endif /* ( ipconfigHAS_PRINTF != 0 ) */
|
||||
|
||||
/* Protocol checksum not accepted. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif /* ( ipconfigUDP_PASS_ZERO_CHECKSUM_PACKETS == 0 ) */
|
||||
|
||||
/* to avoid warning unused parameters */
|
||||
( void ) pxNetworkBuffer;
|
||||
( void ) uxHeaderLength;
|
||||
}
|
||||
#endif /* ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 */
|
||||
|
||||
return eReturn;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
|
||||
/** @brief Check if the IP-header is carrying options.
|
||||
* @param[in] pxNetworkBuffer the network buffer that contains the packet.
|
||||
*
|
||||
* @return Either 'eProcessBuffer' or 'eReleaseBuffer'
|
||||
*/
|
||||
enum eFrameProcessingResult prvCheckIP4HeaderOptions( struct xNETWORK_BUFFER * const pxNetworkBuffer )
|
||||
{
|
||||
eFrameProcessingResult_t eReturn = eProcessBuffer;
|
||||
|
||||
/* This function is only called for IPv4 packets, with an IP-header
|
||||
* which is larger than 20 bytes. The extra space is used for IP-options.
|
||||
* The options will either be removed, or the packet shall be dropped,
|
||||
* depending on a user define. */
|
||||
|
||||
#if ( ipconfigIP_PASS_PACKETS_WITH_IP_OPTIONS != 0 )
|
||||
{
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
IPHeader_t * pxIPHeader = ( ( IPHeader_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER ] ) );
|
||||
|
||||
/* All structs of headers expect a IP header size of 20 bytes
|
||||
* IP header options were included, we'll ignore them and cut them out. */
|
||||
size_t uxLength = ( size_t ) pxIPHeader->ucVersionHeaderLength;
|
||||
|
||||
/* Check if the IP headers are acceptable and if it has our destination.
|
||||
* The lowest four bits of 'ucVersionHeaderLength' indicate the IP-header
|
||||
* length in multiples of 4. */
|
||||
size_t uxHeaderLength = ( size_t ) ( ( uxLength & 0x0FU ) << 2 );
|
||||
|
||||
/* Number of bytes contained in IPv4 header options. */
|
||||
const size_t optlen = ( ( size_t ) uxHeaderLength ) - ipSIZE_OF_IPv4_HEADER;
|
||||
/* From: the previous start of UDP/ICMP/TCP data. */
|
||||
const uint8_t * pucSource = ( const uint8_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ sizeof( EthernetHeader_t ) + uxHeaderLength ] );
|
||||
/* To: the usual start of UDP/ICMP/TCP data at offset 20 (decimal ) from IP header. */
|
||||
uint8_t * pucTarget = ( uint8_t * ) &( pxNetworkBuffer->pucEthernetBuffer[ sizeof( EthernetHeader_t ) + ipSIZE_OF_IPv4_HEADER ] );
|
||||
/* How many: total length minus the options and the lower headers. */
|
||||
const size_t xMoveLen = pxNetworkBuffer->xDataLength - ( optlen + ipSIZE_OF_IPv4_HEADER + ipSIZE_OF_ETH_HEADER );
|
||||
|
||||
( void ) memmove( pucTarget, pucSource, xMoveLen );
|
||||
pxNetworkBuffer->xDataLength -= optlen;
|
||||
/* Update the total length of the IP packet after removing options. */
|
||||
pxIPHeader->usLength = FreeRTOS_htons( FreeRTOS_ntohs( pxIPHeader->usLength ) - optlen );
|
||||
|
||||
/* Rewrite the Version/IHL byte to indicate that this packet has no IP options. */
|
||||
pxIPHeader->ucVersionHeaderLength = ( uint8_t ) ( ( pxIPHeader->ucVersionHeaderLength & 0xF0U ) | /* High nibble is the version. */
|
||||
( ( ipSIZE_OF_IPv4_HEADER >> 2 ) & 0x0FU ) );
|
||||
}
|
||||
#else /* if ( ipconfigIP_PASS_PACKETS_WITH_IP_OPTIONS != 0 ) */
|
||||
{
|
||||
/* 'ipconfigIP_PASS_PACKETS_WITH_IP_OPTIONS' is not set, so packets carrying
|
||||
* IP-options will be dropped. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
#endif /* if ( ipconfigIP_PASS_PACKETS_WITH_IP_OPTIONS != 0 ) */
|
||||
|
||||
return eReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#endif /* ipconfigUSE_IPv4 != 0 ) */
|
||||
/* *INDENT-ON* */
|
||||
+277
@@ -0,0 +1,277 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_IPv4_Sockets.c
|
||||
* @brief Implements the Sockets API based on Berkeley sockets for the FreeRTOS+TCP network stack.
|
||||
* Sockets are used by the application processes to interact with the IP-task which in turn
|
||||
* interacts with the hardware.
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
#include "queue.h"
|
||||
#include "semphr.h"
|
||||
|
||||
/* FreeRTOS+TCP includes. */
|
||||
#include "FreeRTOS_UDP_IP.h"
|
||||
#include "FreeRTOS_IP.h"
|
||||
#include "FreeRTOS_IPv4_Sockets.h"
|
||||
|
||||
|
||||
/** @brief The number of octets that make up an IP address. */
|
||||
#define socketMAX_IP_ADDRESS_OCTETS ( 4U )
|
||||
|
||||
/* Just make sure the contents doesn't get compiled if IPv4 is not enabled. */
|
||||
/* *INDENT-OFF* */
|
||||
#if( ipconfigUSE_IPv4 != 0 )
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/**
|
||||
* @brief This function converts the character string pcSource into a network address
|
||||
* structure, then copies the network address structure to pvDestination.
|
||||
* pvDestination is written in network byte order.
|
||||
*
|
||||
* @param[in] pcSource The character string in holding the IP address.
|
||||
* @param[out] pvDestination The returned network address in 32-bit network-endian format.
|
||||
*
|
||||
* @return pdPASS if the translation was successful or else pdFAIL.
|
||||
*/
|
||||
BaseType_t FreeRTOS_inet_pton4( const char * pcSource,
|
||||
void * pvDestination )
|
||||
{
|
||||
const uint32_t ulDecimalBase = 10U;
|
||||
uint8_t ucOctet[ socketMAX_IP_ADDRESS_OCTETS ];
|
||||
uint32_t ulReturn = 0U, ulValue;
|
||||
UBaseType_t uxOctetNumber;
|
||||
BaseType_t xResult = pdPASS;
|
||||
const char * pcIPAddress = pcSource;
|
||||
const void * pvCopySource;
|
||||
|
||||
( void ) memset( pvDestination, 0, sizeof( ulReturn ) );
|
||||
|
||||
/* Translate "192.168.2.100" to a 32-bit number, network-endian. */
|
||||
for( uxOctetNumber = 0U; uxOctetNumber < socketMAX_IP_ADDRESS_OCTETS; uxOctetNumber++ )
|
||||
{
|
||||
ulValue = 0U;
|
||||
|
||||
if( pcIPAddress[ 0 ] == '0' )
|
||||
{
|
||||
/* Test for the sequence "0[0-9]", which would make it an octal representation. */
|
||||
if( ( pcIPAddress[ 1 ] >= '0' ) && ( pcIPAddress[ 1 ] <= '9' ) )
|
||||
{
|
||||
FreeRTOS_printf( ( "Octal representation of IP-addresses is not supported." ) );
|
||||
/* Don't support octal numbers. */
|
||||
xResult = pdFAIL;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
while( ( *pcIPAddress >= '0' ) && ( *pcIPAddress <= '9' ) )
|
||||
{
|
||||
BaseType_t xChar;
|
||||
|
||||
/* Move previous read characters into the next decimal
|
||||
* position. */
|
||||
ulValue *= ulDecimalBase;
|
||||
|
||||
/* Add the binary value of the ascii character. */
|
||||
xChar = ( BaseType_t ) pcIPAddress[ 0 ];
|
||||
xChar = xChar - ( BaseType_t ) '0';
|
||||
ulValue += ( uint32_t ) xChar;
|
||||
|
||||
/* Move to next character in the string. */
|
||||
pcIPAddress++;
|
||||
}
|
||||
|
||||
/* Check characters were read. */
|
||||
if( pcIPAddress == pcSource )
|
||||
{
|
||||
xResult = pdFAIL;
|
||||
}
|
||||
|
||||
/* Check the value fits in an 8-bit number. */
|
||||
if( ulValue > 0xffU )
|
||||
{
|
||||
xResult = pdFAIL;
|
||||
}
|
||||
else
|
||||
{
|
||||
ucOctet[ uxOctetNumber ] = ( uint8_t ) ulValue;
|
||||
|
||||
/* Check the next character is as expected. */
|
||||
if( uxOctetNumber < ( socketMAX_IP_ADDRESS_OCTETS - 1U ) )
|
||||
{
|
||||
if( *pcIPAddress != '.' )
|
||||
{
|
||||
xResult = pdFAIL;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Move past the dot. */
|
||||
pcIPAddress++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if( xResult == pdFAIL )
|
||||
{
|
||||
/* No point going on. */
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if( *pcIPAddress != ( char ) 0 )
|
||||
{
|
||||
/* Expected the end of the string. */
|
||||
xResult = pdFAIL;
|
||||
}
|
||||
|
||||
if( uxOctetNumber != socketMAX_IP_ADDRESS_OCTETS )
|
||||
{
|
||||
/* Didn't read enough octets. */
|
||||
xResult = pdFAIL;
|
||||
}
|
||||
|
||||
if( xResult == pdPASS )
|
||||
{
|
||||
/* lint: ucOctet has been set because xResult == pdPASS. */
|
||||
ulReturn = FreeRTOS_inet_addr_quick( ucOctet[ 0 ], ucOctet[ 1 ], ucOctet[ 2 ], ucOctet[ 3 ] );
|
||||
}
|
||||
else
|
||||
{
|
||||
ulReturn = 0U;
|
||||
}
|
||||
|
||||
if( xResult == pdPASS )
|
||||
{
|
||||
pvCopySource = ( const void * ) &ulReturn;
|
||||
( void ) memcpy( pvDestination, pvCopySource, sizeof( ulReturn ) );
|
||||
}
|
||||
|
||||
return xResult;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Convert the 32-bit representation of the IP-address to the dotted decimal format.
|
||||
*
|
||||
* @param[in] pvSource The pointer to the 32-bit representation of the IP-address.
|
||||
* @param[out] pcDestination The pointer to a character array where the string of the
|
||||
* dotted decimal IP format.
|
||||
* @param[in] uxSize Size of the character array. This value makes sure that the code
|
||||
* doesn't write beyond it's bounds.
|
||||
*
|
||||
* @return The pointer to the string holding the dotted decimal format of the IP-address. If
|
||||
* everything passes correctly, then the pointer being returned is the same as
|
||||
* pcDestination, else a NULL is returned.
|
||||
*/
|
||||
const char * FreeRTOS_inet_ntop4( const void * pvSource,
|
||||
char * pcDestination,
|
||||
socklen_t uxSize )
|
||||
{
|
||||
uint32_t ulIPAddress;
|
||||
void * pvCopyDest;
|
||||
const char * pcReturn;
|
||||
|
||||
if( uxSize < 16U )
|
||||
{
|
||||
/* There must be space for "255.255.255.255". */
|
||||
pcReturn = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
pvCopyDest = ( void * ) &ulIPAddress;
|
||||
( void ) memcpy( pvCopyDest, pvSource, sizeof( ulIPAddress ) );
|
||||
( void ) FreeRTOS_inet_ntoa( ulIPAddress, pcDestination );
|
||||
pcReturn = pcDestination;
|
||||
}
|
||||
|
||||
return pcReturn;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Called by prvSendUDPPacket(), this function will UDP packet
|
||||
* fields and IPv4 address for the packet to be send.
|
||||
* @param[in] pxNetworkBuffer The packet to be sent.
|
||||
* @param[in] pxDestinationAddress The IPv4 socket address.
|
||||
* @return Returns NULL, always.
|
||||
*/
|
||||
void * xSend_UDP_Update_IPv4( NetworkBufferDescriptor_t * pxNetworkBuffer,
|
||||
const struct freertos_sockaddr * pxDestinationAddress )
|
||||
{
|
||||
UDPPacket_t * pxUDPPacket;
|
||||
|
||||
if( ( pxNetworkBuffer != NULL ) && ( pxDestinationAddress != NULL ) )
|
||||
{
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
pxUDPPacket = ( ( UDPPacket_t * ) pxNetworkBuffer->pucEthernetBuffer );
|
||||
|
||||
pxNetworkBuffer->xIPAddress.ulIP_IPv4 = pxDestinationAddress->sin_address.ulIP_IPv4;
|
||||
/* Map the UDP packet onto the start of the frame. */
|
||||
pxUDPPacket->xEthernetHeader.usFrameType = ipIPv4_FRAME_TYPE;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Called by FreeRTOS_recvfrom(), this function will update socket
|
||||
* address with IPv4 address from the packet received.
|
||||
* @param[in] pxNetworkBuffer The packet received.
|
||||
* @param[in] pxSourceAddress The IPv4 socket address.
|
||||
* @return The Payload Offset.
|
||||
*/
|
||||
size_t xRecv_Update_IPv4( const NetworkBufferDescriptor_t * pxNetworkBuffer,
|
||||
struct freertos_sockaddr * pxSourceAddress )
|
||||
{
|
||||
size_t uxPayloadOffset = 0;
|
||||
|
||||
if( ( pxNetworkBuffer != NULL ) && ( pxSourceAddress != NULL ) )
|
||||
{
|
||||
pxSourceAddress->sin_family = ( uint8_t ) FREERTOS_AF_INET;
|
||||
pxSourceAddress->sin_address.ulIP_IPv4 = pxNetworkBuffer->xIPAddress.ulIP_IPv4;
|
||||
pxSourceAddress->sin_port = pxNetworkBuffer->usPort;
|
||||
}
|
||||
|
||||
uxPayloadOffset = ipUDP_PAYLOAD_OFFSET_IPv4;
|
||||
|
||||
return uxPayloadOffset;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#endif /* ipconfigUSE_IPv4 != 0 ) */
|
||||
/* *INDENT-ON* */
|
||||
+160
@@ -0,0 +1,160 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_IPv4_Utils.c
|
||||
* @brief Implements the basic functionality for the FreeRTOS+TCP network stack functions for IPv4.
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
|
||||
/* FreeRTOS+TCP includes. */
|
||||
#include "FreeRTOS_IP.h"
|
||||
|
||||
/* Just make sure the contents doesn't get compiled if IPv4 is not enabled. */
|
||||
/* *INDENT-OFF* */
|
||||
#if( ipconfigUSE_IPv4 != 0 )
|
||||
/* *INDENT-ON* */
|
||||
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Set multicast MAC address.
|
||||
*
|
||||
* @param[in] ulIPAddress IP address.
|
||||
* @param[out] pxMACAddress Pointer to MAC address.
|
||||
*/
|
||||
void vSetMultiCastIPv4MacAddress( uint32_t ulIPAddress,
|
||||
MACAddress_t * pxMACAddress )
|
||||
{
|
||||
uint32_t ulIP = FreeRTOS_ntohl( ulIPAddress );
|
||||
|
||||
pxMACAddress->ucBytes[ 0 ] = ( uint8_t ) ipMULTICAST_MAC_ADDRESS_IPv4_0;
|
||||
pxMACAddress->ucBytes[ 1 ] = ( uint8_t ) ipMULTICAST_MAC_ADDRESS_IPv4_1;
|
||||
pxMACAddress->ucBytes[ 2 ] = ( uint8_t ) ipMULTICAST_MAC_ADDRESS_IPv4_2;
|
||||
pxMACAddress->ucBytes[ 3 ] = ( uint8_t ) ( ( ulIP >> 16 ) & 0x7fU ); /* Use 7 bits. */
|
||||
pxMACAddress->ucBytes[ 4 ] = ( uint8_t ) ( ( ulIP >> 8 ) & 0xffU ); /* Use 8 bits. */
|
||||
pxMACAddress->ucBytes[ 5 ] = ( uint8_t ) ( ( ulIP ) & 0xffU ); /* Use 8 bits. */
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/** @brief Do the first IPv4 length checks at the IP-header level.
|
||||
* @param[in] pucEthernetBuffer The buffer containing the packet.
|
||||
* @param[in] uxBufferLength The number of bytes to be sent or received.
|
||||
* @param[in] pxSet A struct describing this packet.
|
||||
*
|
||||
* @return Non-zero in case of an error.
|
||||
*/
|
||||
BaseType_t prvChecksumIPv4Checks( uint8_t * pucEthernetBuffer,
|
||||
size_t uxBufferLength,
|
||||
struct xPacketSummary * pxSet )
|
||||
{
|
||||
BaseType_t xReturn = 0;
|
||||
uint8_t ucVersion;
|
||||
uint16_t usLength;
|
||||
|
||||
pxSet->xIsIPv6 = pdFALSE;
|
||||
|
||||
usLength = pxSet->pxIPPacket->xIPHeader.usLength;
|
||||
usLength = FreeRTOS_ntohs( usLength );
|
||||
|
||||
/* IPv4 : the lower nibble in 'ucVersionHeaderLength' indicates the length
|
||||
* of the IP-header, expressed in number of 4-byte words. Usually 5 words.
|
||||
*/
|
||||
ucVersion = pxSet->pxIPPacket->xIPHeader.ucVersionHeaderLength & ( uint8_t ) 0x0FU;
|
||||
pxSet->uxIPHeaderLength = ( size_t ) ucVersion;
|
||||
pxSet->uxIPHeaderLength *= 4U;
|
||||
|
||||
if( usLength < pxSet->uxIPHeaderLength )
|
||||
{
|
||||
pxSet->usChecksum = ipINVALID_LENGTH;
|
||||
xReturn = 3;
|
||||
}
|
||||
|
||||
/* Check for minimum packet size. */
|
||||
if( xReturn == 0 )
|
||||
{
|
||||
if( uxBufferLength < sizeof( IPPacket_t ) )
|
||||
{
|
||||
pxSet->usChecksum = ipINVALID_LENGTH;
|
||||
xReturn = 4;
|
||||
}
|
||||
}
|
||||
|
||||
if( xReturn == 0 )
|
||||
{
|
||||
/* Check for minimum packet size. */
|
||||
if( uxBufferLength < ( ipSIZE_OF_ETH_HEADER + pxSet->uxIPHeaderLength ) )
|
||||
{
|
||||
/* The packet does not contain the full IP-headers so drop it. */
|
||||
pxSet->usChecksum = ipINVALID_LENGTH;
|
||||
xReturn = 5;
|
||||
}
|
||||
}
|
||||
|
||||
if( xReturn == 0 )
|
||||
{
|
||||
size_t uxNeeded;
|
||||
/* xIPHeader.usLength is the total length, minus the Ethernet header. */
|
||||
pxSet->usPayloadLength = FreeRTOS_ntohs( pxSet->pxIPPacket->xIPHeader.usLength );
|
||||
|
||||
uxNeeded = pxSet->usPayloadLength;
|
||||
uxNeeded += ipSIZE_OF_ETH_HEADER;
|
||||
|
||||
if( uxBufferLength < uxNeeded )
|
||||
{
|
||||
/* The payload is longer than the packet appears to contain. */
|
||||
pxSet->usChecksum = ipINVALID_LENGTH;
|
||||
xReturn = 6;
|
||||
}
|
||||
}
|
||||
|
||||
if( xReturn == 0 )
|
||||
{
|
||||
/* Identify the next protocol. */
|
||||
pxSet->ucProtocol = pxSet->pxIPPacket->xIPHeader.ucProtocol;
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
pxSet->pxProtocolHeaders = ( ( ProtocolHeaders_t * ) &( pucEthernetBuffer[ pxSet->uxIPHeaderLength + ipSIZE_OF_ETH_HEADER ] ) );
|
||||
/* For IPv4, the number of bytes in IP-header + the protocol is indicated. */
|
||||
pxSet->usProtocolBytes = ( uint16_t ) ( pxSet->usPayloadLength - pxSet->uxIPHeaderLength );
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#endif /* ipconfigUSE_IPv4 != 0 ) */
|
||||
/* *INDENT-ON* */
|
||||
+709
@@ -0,0 +1,709 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_IPv6.c
|
||||
* @brief Implements the basic functionality for the FreeRTOS+TCP network stack.
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
|
||||
/* FreeRTOS+TCP includes. */
|
||||
#include "FreeRTOS_IP.h"
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#if( ipconfigUSE_IPv6 != 0 )
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/** @brief Get the scope field in IPv6 multicast address. */
|
||||
#define IPv6MC_GET_SCOPE_VALUE( pxIPv6Address ) ( ( ( pxIPv6Address )->ucBytes[ 1 ] ) & 0x0FU )
|
||||
|
||||
/** @brief Get the flags field in IPv6 multicast address. */
|
||||
#define IPv6MC_GET_FLAGS_VALUE( pxIPv6Address ) ( ( ( pxIPv6Address )->ucBytes[ 1 ] ) & 0xF0U )
|
||||
|
||||
/** @brief Get the group ID field in IPv6 multicast address. */
|
||||
#define IPv6MC_GET_GROUP_ID( pxIPv6Address, pxReturnGroupID ) ( xGetIPv6MulticastGroupID( pxIPv6Address, pxReturnGroupID ) )
|
||||
|
||||
/**
|
||||
* This variable is initialized by the system to contain the wildcard IPv6 address.
|
||||
*/
|
||||
const struct xIPv6_Address FreeRTOS_in6addr_any = { 0 };
|
||||
|
||||
/**
|
||||
* This variable is initialized by the system to contain the loopback IPv6 address.
|
||||
*/
|
||||
/* MISRA Ref 8.9.1 [File scoped variables] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-89 */
|
||||
/* coverity[misra_c_2012_rule_8_9_violation] */
|
||||
const struct xIPv6_Address FreeRTOS_in6addr_loopback = { { 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U, 1U } };
|
||||
|
||||
#if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 )
|
||||
/* Check IPv6 packet length. */
|
||||
static BaseType_t xCheckIPv6SizeFields( const void * const pvEthernetBuffer,
|
||||
size_t uxBufferLength );
|
||||
#endif /* ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 ) */
|
||||
|
||||
#if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 )
|
||||
/* Check if ucNextHeader is an extension header. */
|
||||
static BaseType_t xIsExtHeader( uint8_t ucNextHeader );
|
||||
#endif /* ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 ) */
|
||||
|
||||
#if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 )
|
||||
|
||||
/**
|
||||
* @brief Check IPv6 packet length.
|
||||
*
|
||||
* @param[in] pvEthernetBuffer The Ethernet packet received.
|
||||
* @param[in] uxBufferLength The total number of bytes received.
|
||||
*
|
||||
* @return pdPASS when the length fields in the packet OK, pdFAIL when the packet
|
||||
* should be dropped.
|
||||
*/
|
||||
static BaseType_t xCheckIPv6SizeFields( const void * const pvEthernetBuffer,
|
||||
size_t uxBufferLength )
|
||||
{
|
||||
BaseType_t xResult = pdFAIL;
|
||||
uint16_t usPayloadLength;
|
||||
uint8_t ucNextHeader;
|
||||
size_t uxMinimumLength;
|
||||
size_t uxExtHeaderLength = 0;
|
||||
const IPExtHeader_IPv6_t * pxExtHeader = NULL;
|
||||
const uint8_t * const pucEthernetBuffer = ( const uint8_t * ) pvEthernetBuffer;
|
||||
|
||||
/* Map the buffer onto a IPv6-Packet struct to easily access the
|
||||
* fields of the IPv6 packet. */
|
||||
const IPPacket_IPv6_t * const pxIPv6Packet = ( const IPPacket_IPv6_t * ) pucEthernetBuffer;
|
||||
|
||||
DEBUG_DECLARE_TRACE_VARIABLE( BaseType_t, xLocation, 0 );
|
||||
|
||||
do
|
||||
{
|
||||
/* Check for minimum packet size: Ethernet header and an IPv6-header, 54 bytes */
|
||||
if( uxBufferLength < sizeof( IPHeader_IPv6_t ) )
|
||||
{
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 1 );
|
||||
break;
|
||||
}
|
||||
|
||||
/* Check if the IPv6-header is transferred. */
|
||||
if( uxBufferLength < ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER ) )
|
||||
{
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 3 );
|
||||
break;
|
||||
}
|
||||
|
||||
/* Check if the complete IPv6-header plus protocol data have been transferred: */
|
||||
usPayloadLength = FreeRTOS_ntohs( pxIPv6Packet->xIPHeader.usPayloadLength );
|
||||
|
||||
if( uxBufferLength < ( size_t ) ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + ( size_t ) usPayloadLength ) )
|
||||
{
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 4 );
|
||||
break;
|
||||
}
|
||||
|
||||
/* Identify the next protocol. */
|
||||
ucNextHeader = pxIPv6Packet->xIPHeader.ucNextHeader;
|
||||
|
||||
while( xIsExtHeader( ucNextHeader ) )
|
||||
{
|
||||
pxExtHeader = ( const IPExtHeader_IPv6_t * ) ( &( pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + uxExtHeaderLength ] ) );
|
||||
/* The definition of length in extension header - Length of this header in 8-octet units, not including the first 8 octets. */
|
||||
uxExtHeaderLength += ( size_t ) ( ( 8 * pxExtHeader->ucHeaderExtLength ) + 8 );
|
||||
|
||||
ucNextHeader = pxExtHeader->ucNextHeader;
|
||||
|
||||
if( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + uxExtHeaderLength >= uxBufferLength )
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + uxExtHeaderLength >= uxBufferLength )
|
||||
{
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 7 );
|
||||
break;
|
||||
}
|
||||
|
||||
/* Switch on the Layer 3/4 protocol. */
|
||||
if( ucNextHeader == ( uint8_t ) ipPROTOCOL_UDP )
|
||||
{
|
||||
/* Expect at least a complete UDP header. */
|
||||
uxMinimumLength = ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + uxExtHeaderLength + ipSIZE_OF_UDP_HEADER;
|
||||
}
|
||||
else if( ucNextHeader == ( uint8_t ) ipPROTOCOL_TCP )
|
||||
{
|
||||
uxMinimumLength = ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + uxExtHeaderLength + ipSIZE_OF_TCP_HEADER;
|
||||
}
|
||||
else if( ucNextHeader == ( uint8_t ) ipPROTOCOL_ICMP_IPv6 )
|
||||
{
|
||||
uint8_t ucTypeOfMessage;
|
||||
|
||||
uxMinimumLength = ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + uxExtHeaderLength;
|
||||
|
||||
ucTypeOfMessage = pucEthernetBuffer[ uxMinimumLength ];
|
||||
|
||||
if( ( ucTypeOfMessage == ipICMP_PING_REQUEST_IPv6 ) ||
|
||||
( ucTypeOfMessage == ipICMP_PING_REPLY_IPv6 ) )
|
||||
{
|
||||
uxMinimumLength += sizeof( ICMPEcho_IPv6_t );
|
||||
}
|
||||
else if( ucTypeOfMessage == ipICMP_ROUTER_SOLICITATION_IPv6 )
|
||||
{
|
||||
uxMinimumLength += sizeof( ICMPRouterSolicitation_IPv6_t );
|
||||
}
|
||||
else if( ucTypeOfMessage == ipICMP_ROUTER_ADVERTISEMENT_IPv6 )
|
||||
{
|
||||
uxMinimumLength += sizeof( ICMPRouterAdvertisement_IPv6_t );
|
||||
}
|
||||
else
|
||||
{
|
||||
uxMinimumLength += ipSIZE_OF_ICMPv6_HEADER;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Unhandled protocol, other than ICMP, IGMP, UDP, or TCP. */
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 5 );
|
||||
break;
|
||||
}
|
||||
|
||||
if( uxBufferLength < uxMinimumLength )
|
||||
{
|
||||
DEBUG_SET_TRACE_VARIABLE( xLocation, 6 );
|
||||
break;
|
||||
}
|
||||
|
||||
xResult = pdPASS;
|
||||
} while( ipFALSE_BOOL );
|
||||
|
||||
if( xResult != pdPASS )
|
||||
{
|
||||
/* NOP if ipconfigHAS_PRINTF != 1 */
|
||||
FreeRTOS_printf( ( "xCheckIPv6SizeFields: location %ld\n", xLocation ) );
|
||||
}
|
||||
|
||||
return xResult;
|
||||
}
|
||||
|
||||
|
||||
#endif /* ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
|
||||
#if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 )
|
||||
|
||||
/**
|
||||
* @brief Check if ucNextHeader is an extension header.
|
||||
*
|
||||
* @param[in] ucNextHeader Next header, such as ipIPv6_EXT_HEADER_HOP_BY_HOP.
|
||||
*
|
||||
* @return pdTRUE if it's extension header, otherwise pdFALSE.
|
||||
*/
|
||||
static BaseType_t xIsExtHeader( uint8_t ucNextHeader )
|
||||
{
|
||||
BaseType_t xReturn = pdFALSE;
|
||||
|
||||
switch( ucNextHeader )
|
||||
{
|
||||
case ipIPv6_EXT_HEADER_HOP_BY_HOP:
|
||||
case ipIPv6_EXT_HEADER_ROUTING_HEADER:
|
||||
case ipIPv6_EXT_HEADER_FRAGMENT_HEADER:
|
||||
case ipIPv6_EXT_HEADER_SECURE_PAYLOAD:
|
||||
case ipIPv6_EXT_HEADER_AUTHEN_HEADER:
|
||||
case ipIPv6_EXT_HEADER_DESTINATION_OPTIONS:
|
||||
case ipIPv6_EXT_HEADER_MOBILITY_HEADER:
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
|
||||
|
||||
#endif /* ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 1 ) */
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Get the group ID and stored into IPv6_Address_t.
|
||||
*
|
||||
* @param[in] pxIPv6Address The multicast address to filter group ID.
|
||||
* @param[out] pxReturnGroupID The buffer to store group ID.
|
||||
*/
|
||||
static void xGetIPv6MulticastGroupID( const IPv6_Address_t * pxIPv6Address,
|
||||
IPv6_Address_t * pxReturnGroupID )
|
||||
{
|
||||
configASSERT( pxIPv6Address != NULL );
|
||||
configASSERT( pxReturnGroupID != NULL );
|
||||
|
||||
pxReturnGroupID->ucBytes[ 0 ] = 0U;
|
||||
pxReturnGroupID->ucBytes[ 1 ] = 0U;
|
||||
( void ) memcpy( &( pxReturnGroupID->ucBytes[ 2 ] ), &( pxIPv6Address->ucBytes[ 2 ] ), 14 );
|
||||
}
|
||||
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Check if the IP-address is an IPv6 loopback address.
|
||||
*
|
||||
* @param[in] pxAddress The IP-address being checked.
|
||||
*
|
||||
* @return pdTRUE if the IP-address is a loopback address or else, pdFALSE.
|
||||
*/
|
||||
BaseType_t xIsIPv6Loopback( const IPv6_Address_t * pxAddress )
|
||||
{
|
||||
BaseType_t xReturn = pdFALSE;
|
||||
|
||||
if( memcmp( pxAddress->ucBytes, FreeRTOS_in6addr_loopback.ucBytes, ipSIZE_OF_IPv6_ADDRESS ) == 0 )
|
||||
{
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
|
||||
#if ( ipconfigETHERNET_DRIVER_FILTERS_PACKETS == 0 )
|
||||
|
||||
/**
|
||||
* @brief Check if the packet is an illegal loopback packet.
|
||||
*
|
||||
* @param[in] pxIPv6Header The IP-header of the packet.
|
||||
*
|
||||
* @return Returns pdTRUE if the packet should be stopped, because either the source
|
||||
* or the target address is a loopback address.
|
||||
*/
|
||||
/* MISRA Ref 8.9.1 [File scoped variables] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-89 */
|
||||
/* coverity[misra_c_2012_rule_8_9_violation] */
|
||||
/* coverity[single_use] */
|
||||
BaseType_t xBadIPv6Loopback( const IPHeader_IPv6_t * const pxIPv6Header )
|
||||
{
|
||||
BaseType_t xReturn = pdFALSE;
|
||||
const NetworkEndPoint_t * pxEndPoint = FreeRTOS_FindEndPointOnIP_IPv6( &( pxIPv6Header->xSourceAddress ) );
|
||||
|
||||
/* Allow loopback packets from this node itself only. */
|
||||
if( pxEndPoint != NULL )
|
||||
{
|
||||
BaseType_t x1 = ( xIsIPv6Loopback( &( pxIPv6Header->xDestinationAddress ) ) != 0 ) ? pdTRUE : pdFALSE;
|
||||
BaseType_t x2 = ( xIsIPv6Loopback( &( pxIPv6Header->xSourceAddress ) ) != 0 ) ? pdTRUE : pdFALSE;
|
||||
|
||||
if( x1 != x2 )
|
||||
{
|
||||
/* Either source or the destination address is a loopback address. */
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
|
||||
#endif /* ipconfigETHERNET_DRIVER_FILTERS_PACKETS == 0 */
|
||||
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Check whether this IPv6 address is an allowed multicast address or not.
|
||||
*
|
||||
* @param[in] pxIPAddress The IP address to be checked.
|
||||
*
|
||||
* @return Returns pdTRUE if pxIPAddress is an allowed multicast address, pdFALSE if not.
|
||||
*/
|
||||
BaseType_t xIsIPv6AllowedMulticast( const IPv6_Address_t * pxIPAddress )
|
||||
{
|
||||
BaseType_t xReturn = pdFALSE;
|
||||
IPv6_Address_t xGroupIDAddress;
|
||||
|
||||
if( pxIPAddress->ucBytes[ 0 ] == 0xffU )
|
||||
{
|
||||
IPv6MC_GET_GROUP_ID( pxIPAddress, &xGroupIDAddress );
|
||||
|
||||
/* From RFC4291 - sec 2.7, packets from multicast address whose scope field is 0
|
||||
* should be silently dropped. */
|
||||
if( IPv6MC_GET_SCOPE_VALUE( pxIPAddress ) == 0U )
|
||||
{
|
||||
xReturn = pdFALSE;
|
||||
}
|
||||
|
||||
/* From RFC4291 - sec 2.7.1, packets from predefined multicast address should never be used.
|
||||
* - 0xFF00::
|
||||
* - 0xFF01::
|
||||
* - ..
|
||||
* - 0xFF0F:: */
|
||||
else if( ( IPv6MC_GET_FLAGS_VALUE( pxIPAddress ) == 0U ) &&
|
||||
( memcmp( xGroupIDAddress.ucBytes, FreeRTOS_in6addr_any.ucBytes, sizeof( IPv6_Address_t ) ) == 0 ) )
|
||||
{
|
||||
xReturn = pdFALSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Compares 2 IPv6 addresses and checks if the one
|
||||
* on the left can handle the one on right. Note that 'xCompareIPv6_Address' will also check if 'pxRight' is
|
||||
* the special unicast address: ff02::1:ffnn:nnnn, where nn:nnnn are
|
||||
* the last 3 bytes of the IPv6 address.
|
||||
*
|
||||
* @param[in] pxLeft First IP address.
|
||||
* @param[in] pxRight Second IP address.
|
||||
* @param[in] uxPrefixLength The IP address prefix length in bits.
|
||||
*
|
||||
* @return Returns 0 if it can handle it, else non zero .
|
||||
*/
|
||||
BaseType_t xCompareIPv6_Address( const IPv6_Address_t * pxLeft,
|
||||
const IPv6_Address_t * pxRight,
|
||||
size_t uxPrefixLength )
|
||||
{
|
||||
BaseType_t xResult;
|
||||
/* This variable is initialized by the system to contain the IPv6 multicast address for all nodes. */
|
||||
static const struct xIPv6_Address FreeRTOS_in6addr_allnodes = { { 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 } };
|
||||
|
||||
/* 0 2 4 6 8 10 12 14 */
|
||||
/* ff02:0000:0000:0000:0000:0001:ff66:4a81 */
|
||||
if( ( pxRight->ucBytes[ 0 ] == 0xffU ) &&
|
||||
( pxRight->ucBytes[ 1 ] == 0x02U ) &&
|
||||
( pxRight->ucBytes[ 12 ] == 0xffU ) )
|
||||
{
|
||||
/* This is an LLMNR address. */
|
||||
xResult = memcmp( &( pxLeft->ucBytes[ 13 ] ), &( pxRight->ucBytes[ 13 ] ), 3 );
|
||||
}
|
||||
else
|
||||
if( memcmp( pxRight->ucBytes, FreeRTOS_in6addr_allnodes.ucBytes, sizeof( IPv6_Address_t ) ) == 0 )
|
||||
{
|
||||
/* FF02::1 is all node address to reach out all nodes in the same link. */
|
||||
xResult = 0;
|
||||
}
|
||||
else
|
||||
if( ( pxRight->ucBytes[ 0 ] == 0xfeU ) &&
|
||||
( pxRight->ucBytes[ 1 ] == 0x80U ) &&
|
||||
( pxLeft->ucBytes[ 0 ] == 0xfeU ) &&
|
||||
( pxLeft->ucBytes[ 1 ] == 0x80U ) )
|
||||
{
|
||||
/* Both are local addresses. */
|
||||
xResult = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
if( uxPrefixLength == 0U )
|
||||
{
|
||||
xResult = 0;
|
||||
}
|
||||
else if( uxPrefixLength == ( 8U * ipSIZE_OF_IPv6_ADDRESS ) )
|
||||
{
|
||||
xResult = memcmp( pxLeft->ucBytes, pxRight->ucBytes, ipSIZE_OF_IPv6_ADDRESS );
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t uxLength = uxPrefixLength / 8U;
|
||||
|
||||
xResult = 0;
|
||||
|
||||
if( uxLength > 0U )
|
||||
{
|
||||
xResult = memcmp( pxLeft->ucBytes, pxRight->ucBytes, uxLength );
|
||||
}
|
||||
|
||||
if( ( xResult == 0 ) && ( ( uxPrefixLength % 8U ) != 0U ) )
|
||||
{
|
||||
/* One byte has both a network- and a host-address. */
|
||||
size_t uxBits = uxPrefixLength % 8U;
|
||||
size_t uxHostLen = 8U - uxBits;
|
||||
uint32_t uxHostMask = ( ( ( uint32_t ) 1U ) << uxHostLen ) - 1U;
|
||||
uint8_t ucNetMask = ( uint8_t ) ~( uxHostMask );
|
||||
|
||||
if( ( pxLeft->ucBytes[ uxLength ] & ucNetMask ) != ( pxRight->ucBytes[ uxLength ] & ucNetMask ) )
|
||||
{
|
||||
xResult = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return xResult;
|
||||
}
|
||||
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
|
||||
/**
|
||||
* @brief Check whether this IPv6 packet is to be allowed or to be dropped.
|
||||
*
|
||||
* @param[in] pxIPv6Header The IP packet under consideration.
|
||||
* @param[in] pxNetworkBuffer The whole network buffer.
|
||||
* @param[in] uxHeaderLength The length of the header.
|
||||
*
|
||||
* @return Whether the packet should be processed or dropped.
|
||||
*/
|
||||
eFrameProcessingResult_t prvAllowIPPacketIPv6( const IPHeader_IPv6_t * const pxIPv6Header,
|
||||
const NetworkBufferDescriptor_t * const pxNetworkBuffer,
|
||||
UBaseType_t uxHeaderLength )
|
||||
{
|
||||
eFrameProcessingResult_t eReturn;
|
||||
|
||||
#if ( ipconfigETHERNET_DRIVER_FILTERS_PACKETS == 0 )
|
||||
{
|
||||
/* In systems with a very small amount of RAM, it might be advantageous
|
||||
* to have incoming messages checked earlier, by the network card driver.
|
||||
* This method may decrease the usage of sparse network buffers. */
|
||||
const IPv6_Address_t * pxDestinationIPAddress = &( pxIPv6Header->xDestinationAddress );
|
||||
const IPv6_Address_t * pxSourceIPAddress = &( pxIPv6Header->xSourceAddress );
|
||||
BaseType_t xHasUnspecifiedAddress = pdFALSE;
|
||||
uint16_t ucVersionTrafficClass = pxIPv6Header->ucVersionTrafficClass;
|
||||
|
||||
/* Drop if packet has unspecified IPv6 address (defined in RFC4291 - sec 2.5.2)
|
||||
* either in source or destination address. */
|
||||
if( ( memcmp( pxDestinationIPAddress->ucBytes, FreeRTOS_in6addr_any.ucBytes, sizeof( IPv6_Address_t ) ) == 0 ) ||
|
||||
( memcmp( pxSourceIPAddress->ucBytes, FreeRTOS_in6addr_any.ucBytes, sizeof( IPv6_Address_t ) ) == 0 ) )
|
||||
{
|
||||
xHasUnspecifiedAddress = pdTRUE;
|
||||
}
|
||||
|
||||
/* Test if the IP-version is 6. */
|
||||
if( ( ( ucVersionTrafficClass & ( uint8_t ) 0xF0U ) >> 4 ) != 6U )
|
||||
{
|
||||
/* Can not handle, unknown or invalid header version. */
|
||||
eReturn = eReleaseBuffer;
|
||||
FreeRTOS_printf( ( "prvAllowIPPacketIPv6: drop packet, invalid header version: %u\n", ( ucVersionTrafficClass & ( uint8_t ) 0xF0U ) >> 4 ) );
|
||||
}
|
||||
/* Is the packet for this IP address? */
|
||||
else if( ( xHasUnspecifiedAddress == pdFALSE ) &&
|
||||
( pxNetworkBuffer->pxEndPoint != NULL ) &&
|
||||
( memcmp( pxDestinationIPAddress->ucBytes, pxNetworkBuffer->pxEndPoint->ipv6_settings.xIPAddress.ucBytes, sizeof( IPv6_Address_t ) ) == 0 ) )
|
||||
{
|
||||
eReturn = eProcessBuffer;
|
||||
}
|
||||
/* Is it the legal multicast address? */
|
||||
else if( ( ( xHasUnspecifiedAddress == pdFALSE ) &&
|
||||
( xBadIPv6Loopback( pxIPv6Header ) == pdFALSE ) ) &&
|
||||
( ( xIsIPv6AllowedMulticast( pxDestinationIPAddress ) != pdFALSE ) ||
|
||||
/* Or (during DHCP negotiation) we have no IP-address yet? */
|
||||
( FreeRTOS_IsNetworkUp() == 0 ) ) )
|
||||
{
|
||||
eReturn = eProcessBuffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Packet is not for this node, or the network is still not up,
|
||||
* release it */
|
||||
eReturn = eReleaseBuffer;
|
||||
FreeRTOS_printf( ( "prvAllowIPPacketIPv6: drop %pip (from %pip)\n", pxDestinationIPAddress->ucBytes, pxIPv6Header->xSourceAddress.ucBytes ) );
|
||||
}
|
||||
}
|
||||
#else /* if ( ipconfigETHERNET_DRIVER_FILTERS_PACKETS == 0 ) */
|
||||
{
|
||||
( void ) pxIPv6Header;
|
||||
/* The packet has been checked by the network interface. */
|
||||
eReturn = eProcessBuffer;
|
||||
}
|
||||
#endif /* ipconfigETHERNET_DRIVER_FILTERS_PACKETS */
|
||||
|
||||
#if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 )
|
||||
{
|
||||
/* Some drivers of NIC's with checksum-offloading will enable the above
|
||||
* define, so that the checksum won't be checked again here */
|
||||
if( eReturn == eProcessBuffer )
|
||||
{
|
||||
/* IPv6 does not have a separate checksum in the IP-header */
|
||||
/* Is the upper-layer checksum (TCP/UDP/ICMP) correct? */
|
||||
if( usGenerateProtocolChecksum( ( uint8_t * ) ( pxNetworkBuffer->pucEthernetBuffer ), pxNetworkBuffer->xDataLength, pdFALSE ) != ipCORRECT_CRC )
|
||||
{
|
||||
/* Protocol checksum not accepted. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
}
|
||||
}
|
||||
#else /* if ( ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 ) */
|
||||
{
|
||||
if( eReturn == eProcessBuffer )
|
||||
{
|
||||
if( xCheckIPv6SizeFields( pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength ) != pdPASS )
|
||||
{
|
||||
/* Some of the length checks were not successful. */
|
||||
eReturn = eReleaseBuffer;
|
||||
}
|
||||
}
|
||||
|
||||
/* to avoid warning unused parameters */
|
||||
( void ) pxNetworkBuffer;
|
||||
}
|
||||
#endif /* ipconfigDRIVER_INCLUDED_RX_IP_CHECKSUM == 0 */
|
||||
( void ) uxHeaderLength;
|
||||
|
||||
return eReturn;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Check extension header and next header and return their order.
|
||||
*
|
||||
* @param[in] ucProtocol Extension header ID.
|
||||
* @param[in] ucNextHeader Next header ID.
|
||||
*
|
||||
* @return Extension header order in the packet.
|
||||
*/
|
||||
BaseType_t xGetExtensionOrder( uint8_t ucProtocol,
|
||||
uint8_t ucNextHeader )
|
||||
{
|
||||
BaseType_t xReturn;
|
||||
|
||||
switch( ucProtocol )
|
||||
{
|
||||
case ipIPv6_EXT_HEADER_HOP_BY_HOP:
|
||||
xReturn = 1;
|
||||
break;
|
||||
|
||||
case ipIPv6_EXT_HEADER_DESTINATION_OPTIONS:
|
||||
xReturn = 7;
|
||||
|
||||
if( ucNextHeader == ipIPv6_EXT_HEADER_ROUTING_HEADER )
|
||||
{
|
||||
xReturn = 2;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case ipIPv6_EXT_HEADER_ROUTING_HEADER:
|
||||
xReturn = 3;
|
||||
break;
|
||||
|
||||
case ipIPv6_EXT_HEADER_FRAGMENT_HEADER:
|
||||
xReturn = 4;
|
||||
break;
|
||||
|
||||
case ipIPv6_EXT_HEADER_AUTHEN_HEADER:
|
||||
xReturn = 5;
|
||||
break;
|
||||
|
||||
case ipIPv6_EXT_HEADER_SECURE_PAYLOAD:
|
||||
xReturn = 6;
|
||||
break;
|
||||
|
||||
/* Destination options may follow here in case there are no routing options. */
|
||||
case ipIPv6_EXT_HEADER_MOBILITY_HEADER:
|
||||
xReturn = 8;
|
||||
break;
|
||||
|
||||
default:
|
||||
xReturn = -1;
|
||||
break;
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @brief Handle the IPv6 extension headers.
|
||||
*
|
||||
* @param[in,out] pxNetworkBuffer The received packet that contains IPv6 extension headers.
|
||||
* @param[in] xDoRemove Function removes the extension header if xDoRemove is set to pdTRUE.
|
||||
*
|
||||
* @return eProcessBuffer in case the options are removed successfully, otherwise
|
||||
* eReleaseBuffer.
|
||||
*/
|
||||
eFrameProcessingResult_t eHandleIPv6ExtensionHeaders( NetworkBufferDescriptor_t * const pxNetworkBuffer,
|
||||
BaseType_t xDoRemove )
|
||||
{
|
||||
eFrameProcessingResult_t eResult = eReleaseBuffer;
|
||||
const size_t uxMaxLength = pxNetworkBuffer->xDataLength;
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
IPPacket_IPv6_t * pxIPPacket_IPv6 = ( ( IPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer );
|
||||
size_t xMoveLen = 0U;
|
||||
size_t uxRemovedBytes = 0U;
|
||||
uint8_t ucNextHeader = 0U;
|
||||
size_t uxIndex = 0U;
|
||||
|
||||
uxRemovedBytes = usGetExtensionHeaderLength( pxNetworkBuffer->pucEthernetBuffer, pxNetworkBuffer->xDataLength, &ucNextHeader );
|
||||
uxIndex = ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + uxRemovedBytes;
|
||||
|
||||
if( uxIndex < uxMaxLength )
|
||||
{
|
||||
uint8_t * pucTo;
|
||||
const uint8_t * pucFrom;
|
||||
uint16_t usPayloadLength = FreeRTOS_ntohs( pxIPPacket_IPv6->xIPHeader.usPayloadLength );
|
||||
|
||||
if( uxRemovedBytes >= ( size_t ) usPayloadLength )
|
||||
{
|
||||
/* Can not remove more bytes than the payload length. */
|
||||
}
|
||||
else if( xDoRemove == pdTRUE )
|
||||
{
|
||||
pxIPPacket_IPv6->xIPHeader.ucNextHeader = ucNextHeader;
|
||||
pucTo = &( pxNetworkBuffer->pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER ] );
|
||||
pucFrom = &( pxNetworkBuffer->pucEthernetBuffer[ uxIndex ] );
|
||||
xMoveLen = uxMaxLength - uxIndex;
|
||||
( void ) memmove( pucTo, pucFrom, xMoveLen );
|
||||
pxNetworkBuffer->xDataLength -= uxRemovedBytes;
|
||||
|
||||
usPayloadLength = ( uint16_t ) ( usPayloadLength - uxRemovedBytes );
|
||||
pxIPPacket_IPv6->xIPHeader.usPayloadLength = FreeRTOS_htons( usPayloadLength );
|
||||
eResult = eProcessBuffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* xDoRemove is false, so the function is not supposed to
|
||||
* remove extension headers. */
|
||||
}
|
||||
}
|
||||
|
||||
FreeRTOS_printf( ( "Extension headers : %s Truncated %u bytes. Removed %u, Payload %u xDataLength now %u\n",
|
||||
( eResult == eProcessBuffer ) ? "good" : "bad",
|
||||
( unsigned ) xMoveLen,
|
||||
( unsigned ) uxRemovedBytes,
|
||||
FreeRTOS_ntohs( pxIPPacket_IPv6->xIPHeader.usPayloadLength ),
|
||||
( unsigned ) pxNetworkBuffer->xDataLength ) );
|
||||
return eResult;
|
||||
}
|
||||
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#endif /* ( ipconfigUSE_IPv6 != 0 ) */
|
||||
/* *INDENT-ON* */
|
||||
+660
@@ -0,0 +1,660 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_IPv6_Sockets.c
|
||||
* @brief Implements the Sockets API based on Berkeley sockets for the FreeRTOS+TCP network stack.
|
||||
* Sockets are used by the application processes to interact with the IP-task which in turn
|
||||
* interacts with the hardware.
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
|
||||
/* FreeRTOS+TCP includes. */
|
||||
#include "FreeRTOS_IP.h"
|
||||
#include "FreeRTOS_IPv6_Sockets.h"
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#if( ipconfigUSE_IPv6 != 0 )
|
||||
/* *INDENT-ON* */
|
||||
|
||||
#if ( ipconfigUSE_TCP == 1 )
|
||||
|
||||
/**
|
||||
* @brief Called by pxTCPSocketLookup(), this function will check if a socket
|
||||
* is connected to a remote IP-address. It will be called from a loop
|
||||
* iterating through all sockets.
|
||||
* @param[in] pxSocket The socket to be inspected.
|
||||
* @param[in] pxAddress The IPv4/IPv6 address.
|
||||
* @return The socket in case it is connected to the remote IP-address.
|
||||
*/
|
||||
FreeRTOS_Socket_t * pxTCPSocketLookup_IPv6( FreeRTOS_Socket_t * pxSocket,
|
||||
const IPv46_Address_t * pxAddress )
|
||||
{
|
||||
FreeRTOS_Socket_t * pxResult = NULL;
|
||||
|
||||
if( ( pxSocket != NULL ) && ( pxAddress != NULL ) )
|
||||
{
|
||||
if( pxSocket->bits.bIsIPv6 != pdFALSE_UNSIGNED )
|
||||
{
|
||||
if( pxAddress->xIs_IPv6 != pdFALSE )
|
||||
{
|
||||
if( memcmp( pxSocket->u.xTCP.xRemoteIP.xIP_IPv6.ucBytes, pxAddress->xIPAddress.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS ) == 0 )
|
||||
{
|
||||
/* For sockets not in listening mode, find a match with
|
||||
* uxLocalPort, ulRemoteIP AND uxRemotePort. */
|
||||
pxResult = pxSocket;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if( pxAddress->xIs_IPv6 == pdFALSE )
|
||||
{
|
||||
if( pxSocket->u.xTCP.xRemoteIP.ulIP_IPv4 == pxAddress->xIPAddress.ulIP_IPv4 )
|
||||
{
|
||||
/* For sockets not in listening mode, find a match with
|
||||
* uxLocalPort, ulRemoteIP AND uxRemotePort. */
|
||||
pxResult = pxSocket;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return pxResult;
|
||||
}
|
||||
|
||||
#endif /* if ( ( ipconfigUSE_TCP == 1 ) */
|
||||
|
||||
/**
|
||||
* @brief Called by prvSendUDPPacket(), this function will UDP packet
|
||||
* fields and IPv6 address for the packet to be send.
|
||||
* @param[in] pxNetworkBuffer The packet to be sent.
|
||||
* @param[in] pxDestinationAddress The IPv4 socket address.
|
||||
* @return Returns NULL, always.
|
||||
*/
|
||||
void * xSend_UDP_Update_IPv6( NetworkBufferDescriptor_t * pxNetworkBuffer,
|
||||
const struct freertos_sockaddr * pxDestinationAddress )
|
||||
{
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
UDPPacket_IPv6_t * pxUDPPacket_IPv6 = ( ( UDPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer );
|
||||
|
||||
pxNetworkBuffer->xIPAddress.ulIP_IPv4 = 0U;
|
||||
|
||||
configASSERT( pxDestinationAddress != NULL );
|
||||
( void ) memcpy( pxUDPPacket_IPv6->xIPHeader.xDestinationAddress.ucBytes, pxDestinationAddress->sin_address.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
|
||||
( void ) memcpy( pxNetworkBuffer->xIPAddress.xIP_IPv6.ucBytes, pxDestinationAddress->sin_address.xIP_IPv6.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
|
||||
pxUDPPacket_IPv6->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Called by FreeRTOS_recvfrom(), this function will update socket
|
||||
* address with IPv6 address from the packet received.
|
||||
* @param[in] pxNetworkBuffer The packet received.
|
||||
* @param[in] pxSourceAddress The IPv4 socket address.
|
||||
* @return The Payload Offset.
|
||||
*/
|
||||
size_t xRecv_Update_IPv6( const NetworkBufferDescriptor_t * pxNetworkBuffer,
|
||||
struct freertos_sockaddr * pxSourceAddress )
|
||||
{
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
const UDPPacket_IPv6_t * pxUDPPacketV6 = ( ( const UDPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer );
|
||||
size_t uxPayloadOffset = 0;
|
||||
|
||||
if( pxUDPPacketV6->xEthernetHeader.usFrameType == ipIPv6_FRAME_TYPE )
|
||||
{
|
||||
if( pxSourceAddress != NULL )
|
||||
{
|
||||
( void ) memcpy( ( void * ) pxSourceAddress->sin_address.xIP_IPv6.ucBytes,
|
||||
( const void * ) pxUDPPacketV6->xIPHeader.xSourceAddress.ucBytes,
|
||||
ipSIZE_OF_IPv6_ADDRESS );
|
||||
pxSourceAddress->sin_family = ( uint8_t ) FREERTOS_AF_INET6;
|
||||
pxSourceAddress->sin_port = pxNetworkBuffer->usPort;
|
||||
}
|
||||
|
||||
uxPayloadOffset = ipUDP_PAYLOAD_OFFSET_IPv6;
|
||||
}
|
||||
|
||||
return uxPayloadOffset;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @brief Converts a 4 bit (nibble) value to a readable hex character, e.g. 14 becomes 'e'.
|
||||
* @param usValue The value to be converted, must be between 0 and 15.
|
||||
* @return The character, between '0' and '9', or between 'a' and 'f'.
|
||||
*/
|
||||
char cHexToChar( uint16_t usValue )
|
||||
{
|
||||
char cReturn = '0';
|
||||
|
||||
if( usValue <= 9U )
|
||||
{
|
||||
cReturn = ( char ) ( cReturn + usValue );
|
||||
}
|
||||
else if( usValue <= 15U )
|
||||
{
|
||||
cReturn = 'a';
|
||||
cReturn = ( char ) ( cReturn + ( usValue - ( uint16_t ) 10 ) );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The value passed to 'usValue' has been and-ed with 0x0f,
|
||||
* so this else clause should never be reached. */
|
||||
configASSERT( 0 == 1 );
|
||||
}
|
||||
|
||||
return cReturn;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Convert a short numeric value to a hex string of at most 4 characters.
|
||||
* The resulting string is **not** null-terminated. The resulting string
|
||||
* will not have leading zero's, except when 'usValue' equals zero.
|
||||
* @param[in] pcBuffer The buffer to which the string is written.
|
||||
* @param[in] uxBufferSize The size of the buffer pointed to by 'pcBuffer'.
|
||||
* @param[in] usValue The 16-bit value to be converted.
|
||||
* @return The number of bytes written to 'pcBuffer'.
|
||||
*/
|
||||
socklen_t uxHexPrintShort( char * pcBuffer,
|
||||
size_t uxBufferSize,
|
||||
uint16_t usValue )
|
||||
{
|
||||
const size_t uxNibbleCount = 4U;
|
||||
size_t uxNibble;
|
||||
socklen_t uxIndex = 0U;
|
||||
uint16_t usShifter = usValue;
|
||||
BaseType_t xHadNonZero = pdFALSE;
|
||||
|
||||
for( uxNibble = 0; uxNibble < uxNibbleCount; uxNibble++ )
|
||||
{
|
||||
uint16_t usNibble = ( usShifter >> 12 ) & 0x0FU;
|
||||
|
||||
if( usNibble != 0U )
|
||||
{
|
||||
xHadNonZero = pdTRUE;
|
||||
}
|
||||
|
||||
if( ( xHadNonZero != pdFALSE ) || ( uxNibble == ( uxNibbleCount - 1U ) ) )
|
||||
{
|
||||
if( uxIndex >= ( uxBufferSize - 1U ) )
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
pcBuffer[ uxIndex ] = cHexToChar( usNibble );
|
||||
uxIndex++;
|
||||
}
|
||||
|
||||
usShifter = ( uint16_t ) ( usShifter << 4 );
|
||||
}
|
||||
|
||||
return uxIndex;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Scan the binary IPv6 address and find the longest train of consecutive zero's.
|
||||
* The result of this search will be stored in 'xZeroStart' and 'xZeroLength'.
|
||||
* @param pxSet the set of parameters as used by FreeRTOS_inet_ntop6().
|
||||
*/
|
||||
void prv_ntop6_search_zeros( struct sNTOP6_Set * pxSet )
|
||||
{
|
||||
BaseType_t xIndex = 0; /* The index in the IPv6 address: 0..7. */
|
||||
BaseType_t xCurStart = 0; /* The position of the first zero found so far. */
|
||||
BaseType_t xCurLength = 0; /* The number of zero's seen so far. */
|
||||
const BaseType_t xShortCount = 8; /* An IPv6 address consists of 8 shorts. */
|
||||
|
||||
/* Default: when xZeroStart is negative, it won't match with any xIndex. */
|
||||
pxSet->xZeroStart = -1;
|
||||
|
||||
/* Look for the longest train of zero's 0:0:0:... */
|
||||
for( ; xIndex < xShortCount; xIndex++ )
|
||||
{
|
||||
uint16_t usValue = pxSet->pusAddress[ xIndex ];
|
||||
|
||||
if( usValue == 0U )
|
||||
{
|
||||
if( xCurLength == 0 )
|
||||
{
|
||||
/* Remember the position of the first zero. */
|
||||
xCurStart = xIndex;
|
||||
}
|
||||
|
||||
/* Count consecutive zeros. */
|
||||
xCurLength++;
|
||||
}
|
||||
|
||||
if( ( usValue != 0U ) || ( xIndex == ( xShortCount - 1 ) ) )
|
||||
{
|
||||
/* Has a longer train of zero's been found? */
|
||||
if( ( xCurLength > 1 ) && ( pxSet->xZeroLength < xCurLength ) )
|
||||
{
|
||||
/* Remember the number of consecutive zeros. */
|
||||
pxSet->xZeroLength = xCurLength;
|
||||
/* Remember the index of the first zero found. */
|
||||
pxSet->xZeroStart = xCurStart;
|
||||
}
|
||||
|
||||
/* Reset the counter of consecutive zeros. */
|
||||
xCurLength = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief The location is now at the longest train of zero's. Two colons have to
|
||||
* be printed without a numeric value, e.g. "ff02::1".
|
||||
* @param pcDestination the output buffer where the colons will be printed.
|
||||
* @param uxSize the remaining length of the output buffer.
|
||||
* @param pxSet the set of parameters as used by FreeRTOS_inet_ntop6().
|
||||
* @return pdPASS in case the output buffer is big enough to contain the colons.
|
||||
* @note uxSize must be at least 2, enough to print "::". The string will get
|
||||
* null-terminated later on.
|
||||
*/
|
||||
static BaseType_t prv_ntop6_write_zeros( char * pcDestination,
|
||||
size_t uxSize,
|
||||
struct sNTOP6_Set * pxSet )
|
||||
{
|
||||
BaseType_t xReturn = pdPASS;
|
||||
const BaseType_t xShortCount = 8; /* An IPv6 address consists of 8 shorts. */
|
||||
|
||||
if( pxSet->uxTargetIndex <= ( uxSize - 1U ) )
|
||||
{
|
||||
pcDestination[ pxSet->uxTargetIndex ] = ':';
|
||||
pxSet->uxTargetIndex++;
|
||||
|
||||
if( ( pxSet->xIndex + pxSet->xZeroLength ) == xShortCount )
|
||||
{
|
||||
/* Reached the last index, write a second ":". */
|
||||
if( pxSet->uxTargetIndex <= ( uxSize - 1U ) )
|
||||
{
|
||||
pcDestination[ pxSet->uxTargetIndex ] = ':';
|
||||
pxSet->uxTargetIndex++;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Can not write the second colon. */
|
||||
xReturn = pdFAIL;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Otherwise the function prv_ntop6_write_short() will places the second colon. */
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Can not write the first colon. */
|
||||
xReturn = pdFAIL;
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Write a short value, as a hex number with at most 4 characters. E.g. the
|
||||
* value 15 will be printed as "f".
|
||||
* @param pcDestination the output buffer where the hex number is to be printed.
|
||||
* @param uxSize the remaining length of the output buffer.
|
||||
* @param pxSet the set of parameters as used by FreeRTOS_inet_ntop6().
|
||||
* @return pdPASS in case the output buffer is big enough to contain the string.
|
||||
* @note uxSize must be at least 4, enough to print "abcd". The string will get
|
||||
* null-terminated later on.
|
||||
*/
|
||||
static BaseType_t prv_ntop6_write_short( char * pcDestination,
|
||||
size_t uxSize,
|
||||
struct sNTOP6_Set * pxSet )
|
||||
{
|
||||
socklen_t uxLength;
|
||||
BaseType_t xReturn = pdPASS;
|
||||
const size_t uxBytesPerShortValue = 4U;
|
||||
|
||||
if( pxSet->xIndex > 0 )
|
||||
{
|
||||
if( pxSet->uxTargetIndex >= ( uxSize - 1U ) )
|
||||
{
|
||||
xReturn = pdFAIL;
|
||||
}
|
||||
else
|
||||
{
|
||||
pcDestination[ pxSet->uxTargetIndex ] = ':';
|
||||
pxSet->uxTargetIndex++;
|
||||
}
|
||||
}
|
||||
|
||||
if( xReturn == pdPASS )
|
||||
{
|
||||
/* If there is enough space to write a short. */
|
||||
if( pxSet->uxTargetIndex <= ( uxSize - uxBytesPerShortValue ) )
|
||||
{
|
||||
/* Write hex value of short. at most 4 + 1 bytes. */
|
||||
uxLength = uxHexPrintShort( &( pcDestination[ pxSet->uxTargetIndex ] ),
|
||||
uxBytesPerShortValue + 1U,
|
||||
FreeRTOS_ntohs( pxSet->pusAddress[ pxSet->xIndex ] ) );
|
||||
|
||||
/* uxLength will be non zero and positive always. */
|
||||
pxSet->uxTargetIndex += uxLength;
|
||||
}
|
||||
else
|
||||
{
|
||||
xReturn = pdFAIL;
|
||||
}
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief This function converts a binary IPv6 address to a human readable notation.
|
||||
*
|
||||
* @param[in] pvSource The binary address, 16 bytes long..
|
||||
* @param[out] pcDestination The human-readable ( hexadecimal ) notation of the
|
||||
* address.
|
||||
* @param[in] uxSize The size of pvDestination. A value of 40 is recommended.
|
||||
*
|
||||
* @return pdPASS if the translation was successful or else pdFAIL.
|
||||
*/
|
||||
const char * FreeRTOS_inet_ntop6( const void * pvSource,
|
||||
char * pcDestination,
|
||||
socklen_t uxSize )
|
||||
{
|
||||
const char * pcReturn; /* The return value, which is either 'pcDestination' or NULL. */
|
||||
struct sNTOP6_Set xSet; /* A set of values for easy exchange with the helper functions prv_ntop6_xxx(). */
|
||||
|
||||
( void ) memset( &( xSet ), 0, sizeof( xSet ) );
|
||||
|
||||
xSet.pusAddress = pvSource;
|
||||
|
||||
if( uxSize < 3U )
|
||||
{
|
||||
/* Can not even print :: */
|
||||
}
|
||||
else
|
||||
{
|
||||
prv_ntop6_search_zeros( &( xSet ) );
|
||||
|
||||
while( xSet.xIndex < 8 )
|
||||
{
|
||||
if( xSet.xIndex == xSet.xZeroStart )
|
||||
{
|
||||
if( prv_ntop6_write_zeros( pcDestination, uxSize, &( xSet ) ) == pdFAIL )
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
xSet.xIndex += xSet.xZeroLength;
|
||||
}
|
||||
else
|
||||
{
|
||||
if( prv_ntop6_write_short( pcDestination, uxSize, &( xSet ) ) == pdFAIL )
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
xSet.xIndex++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if( xSet.xIndex < 8 )
|
||||
{
|
||||
/* Didn't reach the last nibble: clear the string. */
|
||||
pcReturn = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
pcDestination[ xSet.uxTargetIndex ] = '\0';
|
||||
pcReturn = pcDestination;
|
||||
}
|
||||
|
||||
return pcReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Converting a readable IPv6 address to its binary form, add one nibble.
|
||||
*
|
||||
* @param[in] pxSet A set of variables describing the conversion.
|
||||
* @param[in] ucNew The hex value, between 0 and 15
|
||||
* @param[in] ch The character, such as '5', 'f', or ':'.
|
||||
*
|
||||
* @return pdTRUE when the nibble was added, otherwise pdFALSE.
|
||||
*/
|
||||
static BaseType_t prv_inet_pton6_add_nibble( struct sPTON6_Set * pxSet,
|
||||
uint8_t ucNew,
|
||||
char ch )
|
||||
{
|
||||
BaseType_t xReturn = pdPASS;
|
||||
|
||||
if( ucNew != ( uint8_t ) socketINVALID_HEX_CHAR )
|
||||
{
|
||||
/* Shift in 4 bits. */
|
||||
pxSet->ulValue <<= 4;
|
||||
pxSet->ulValue |= ( uint32_t ) ucNew;
|
||||
|
||||
/* Remember that ulValue is valid now. */
|
||||
pxSet->xHadDigit = pdTRUE;
|
||||
|
||||
/* Check if the number is not becoming larger than 16 bits. */
|
||||
if( pxSet->ulValue > 0xffffU )
|
||||
{
|
||||
/* The highest nibble has already been set,
|
||||
* an overflow would occur. Break out of the for-loop. */
|
||||
xReturn = pdFAIL;
|
||||
}
|
||||
}
|
||||
else if( ch == ':' )
|
||||
{
|
||||
if( pxSet->xHadDigit == pdFALSE )
|
||||
{
|
||||
/* A "::" sequence has been received. Check if it is not a third colon. */
|
||||
if( pxSet->xColon >= 0 )
|
||||
{
|
||||
xReturn = pdFAIL;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Two or more zero's are expected, starting at position 'xColon'. */
|
||||
pxSet->xColon = pxSet->xTargetIndex;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if( pxSet->xTargetIndex <= pxSet->xHighestIndex )
|
||||
{
|
||||
/* Store a short value at position 'xTargetIndex'. */
|
||||
pxSet->pucTarget[ pxSet->xTargetIndex ] = ( uint8_t ) ( ( pxSet->ulValue >> 8 ) & 0xffU );
|
||||
pxSet->pucTarget[ pxSet->xTargetIndex + 1 ] = ( uint8_t ) ( pxSet->ulValue & 0xffU );
|
||||
pxSet->xTargetIndex += 2;
|
||||
pxSet->xHadDigit = pdFALSE;
|
||||
pxSet->ulValue = 0U;
|
||||
}
|
||||
else
|
||||
{
|
||||
xReturn = pdFAIL;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* When an IPv4 address or rubbish is provided, this statement will be reached. */
|
||||
xReturn = pdFAIL;
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Convert an ASCII character to its corresponding hexadecimal value.
|
||||
* A :: block was found, now fill in the zero's.
|
||||
* @param[in] pxSet A set of variables describing the conversion.
|
||||
*/
|
||||
static void prv_inet_pton6_set_zeros( struct sPTON6_Set * pxSet )
|
||||
{
|
||||
/* The number of bytes that were written after the :: */
|
||||
const BaseType_t xCount = pxSet->xTargetIndex - pxSet->xColon;
|
||||
const BaseType_t xTopIndex = ( BaseType_t ) ipSIZE_OF_IPv6_ADDRESS;
|
||||
BaseType_t xIndex;
|
||||
BaseType_t xTarget = xTopIndex - 1;
|
||||
BaseType_t xSource = pxSet->xColon + ( xCount - 1 );
|
||||
|
||||
/* Inserting 'xCount' zero's. */
|
||||
for( xIndex = 0; xIndex < xCount; xIndex++ )
|
||||
{
|
||||
pxSet->pucTarget[ xTarget ] = pxSet->pucTarget[ xSource ];
|
||||
pxSet->pucTarget[ xSource ] = 0;
|
||||
xTarget--;
|
||||
xSource--;
|
||||
}
|
||||
|
||||
pxSet->xTargetIndex = ( BaseType_t ) ipSIZE_OF_IPv6_ADDRESS;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Convert an IPv6 address in hexadecimal notation to a binary format of 16 bytes.
|
||||
*
|
||||
* @param[in] pcSource The address in hexadecimal notation.
|
||||
* @param[out] pvDestination The address in binary format, 16 bytes long.
|
||||
*
|
||||
* @return The 32-bit representation of IP(v4) address.
|
||||
*/
|
||||
BaseType_t FreeRTOS_inet_pton6( const char * pcSource,
|
||||
void * pvDestination )
|
||||
{
|
||||
char ch;
|
||||
uint8_t ucNew;
|
||||
BaseType_t xResult;
|
||||
struct sPTON6_Set xSet;
|
||||
|
||||
const char * pcIterator = pcSource;
|
||||
|
||||
( void ) memset( &( xSet ), 0, sizeof( xSet ) );
|
||||
xSet.xColon = -1;
|
||||
xSet.pucTarget = pvDestination;
|
||||
|
||||
( void ) memset( xSet.pucTarget, 0, ipSIZE_OF_IPv6_ADDRESS );
|
||||
|
||||
xResult = 0;
|
||||
|
||||
/* Leading :: requires some special handling. */
|
||||
if( strcmp( pcIterator, "::" ) == 0 )
|
||||
{
|
||||
xResult = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
if( pcIterator[ 0 ] == ':' )
|
||||
{
|
||||
pcIterator++;
|
||||
}
|
||||
|
||||
/* The last bytes will be written at position 14 and 15. */
|
||||
xSet.xHighestIndex = ( BaseType_t ) ipSIZE_OF_IPv6_ADDRESS;
|
||||
xSet.xHighestIndex -= ( BaseType_t ) sizeof( uint16_t );
|
||||
|
||||
/* The value in ulValue is not yet valid. */
|
||||
xSet.xHadDigit = pdFALSE;
|
||||
xSet.ulValue = 0U;
|
||||
|
||||
for( ; ; )
|
||||
{
|
||||
ch = *( pcIterator );
|
||||
pcIterator++;
|
||||
|
||||
if( ch == ( char ) '\0' )
|
||||
{
|
||||
/* The string is parsed now.
|
||||
* Store the last short, if present. */
|
||||
if( ( xSet.xHadDigit != pdFALSE ) &&
|
||||
( xSet.xTargetIndex <= xSet.xHighestIndex ) )
|
||||
{
|
||||
/* Add the last value seen, network byte order ( MSB first ). */
|
||||
xSet.pucTarget[ xSet.xTargetIndex ] = ( uint8_t ) ( ( xSet.ulValue >> 8 ) & 0xffU );
|
||||
xSet.pucTarget[ xSet.xTargetIndex + 1 ] = ( uint8_t ) ( xSet.ulValue & 0xffU );
|
||||
xSet.xTargetIndex += 2;
|
||||
}
|
||||
|
||||
/* Break out of the for-ever loop. */
|
||||
break;
|
||||
}
|
||||
|
||||
/* Convert from a readable character to a hex value. */
|
||||
ucNew = ucASCIIToHex( ch );
|
||||
/* See if this is a digit or a colon. */
|
||||
xResult = prv_inet_pton6_add_nibble( &( xSet ), ucNew, ch );
|
||||
|
||||
if( xResult == pdFALSE )
|
||||
{
|
||||
/* The new character was not accepted. */
|
||||
break;
|
||||
}
|
||||
} /* for( ;; ) */
|
||||
|
||||
if( xSet.xColon >= 0 )
|
||||
{
|
||||
/* The address contains a block of zero. */
|
||||
prv_inet_pton6_set_zeros( &( xSet ) );
|
||||
}
|
||||
|
||||
if( xSet.xTargetIndex == ( BaseType_t ) ipSIZE_OF_IPv6_ADDRESS )
|
||||
{
|
||||
xResult = 1;
|
||||
}
|
||||
}
|
||||
|
||||
if( xResult != 1 )
|
||||
{
|
||||
xSet.pucTarget = ( uint8_t * ) pvDestination;
|
||||
( void ) memset( xSet.pucTarget, 0, ipSIZE_OF_IPv6_ADDRESS );
|
||||
}
|
||||
|
||||
return xResult;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
/* *INDENT-OFF* */
|
||||
#endif /* ipconfigUSE_IPv6 != 0 */
|
||||
/* *INDENT-ON* */
|
||||
+367
@@ -0,0 +1,367 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_IPv6_Utils.c
|
||||
* @brief Implements the basic functionality for the FreeRTOS+TCP network stack functions for IPv6.
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
|
||||
/* FreeRTOS+TCP includes. */
|
||||
#include "FreeRTOS_IP.h"
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#if( ipconfigUSE_IPv6 != 0 )
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/**
|
||||
* @brief Set multicast MAC address.
|
||||
*
|
||||
* @param[in] pxAddress IPv6 address.
|
||||
* @param[out] pxMACAddress Pointer to MAC address.
|
||||
*/
|
||||
void vSetMultiCastIPv6MacAddress( const IPv6_Address_t * pxAddress,
|
||||
MACAddress_t * pxMACAddress )
|
||||
{
|
||||
pxMACAddress->ucBytes[ 0 ] = ipMULTICAST_MAC_ADDRESS_IPv6_0;
|
||||
pxMACAddress->ucBytes[ 1 ] = ipMULTICAST_MAC_ADDRESS_IPv6_1;
|
||||
pxMACAddress->ucBytes[ 2 ] = pxAddress->ucBytes[ 12 ];
|
||||
pxMACAddress->ucBytes[ 3 ] = pxAddress->ucBytes[ 13 ];
|
||||
pxMACAddress->ucBytes[ 4 ] = pxAddress->ucBytes[ 14 ];
|
||||
pxMACAddress->ucBytes[ 5 ] = pxAddress->ucBytes[ 15 ];
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/** @brief Do the first IPv6 length checks at the IP-header level.
|
||||
* @param[in] pucEthernetBuffer The buffer containing the packet.
|
||||
* @param[in] uxBufferLength The number of bytes to be sent or received.
|
||||
* @param[in] pxSet A struct describing this packet.
|
||||
*
|
||||
* @return Non-zero in case of an error.
|
||||
*/
|
||||
BaseType_t prvChecksumIPv6Checks( uint8_t * pucEthernetBuffer,
|
||||
size_t uxBufferLength,
|
||||
struct xPacketSummary * pxSet )
|
||||
{
|
||||
BaseType_t xReturn = 0;
|
||||
size_t uxExtensionHeaderLength = 0;
|
||||
|
||||
pxSet->xIsIPv6 = pdTRUE;
|
||||
|
||||
pxSet->uxIPHeaderLength = ipSIZE_OF_IPv6_HEADER;
|
||||
|
||||
/* Check for minimum packet size: ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER (54 bytes) */
|
||||
if( uxBufferLength < sizeof( IPPacket_IPv6_t ) )
|
||||
{
|
||||
pxSet->usChecksum = ipINVALID_LENGTH;
|
||||
xReturn = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
uxExtensionHeaderLength = usGetExtensionHeaderLength( pucEthernetBuffer, uxBufferLength, &pxSet->ucProtocol );
|
||||
|
||||
if( ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + uxExtensionHeaderLength ) >= uxBufferLength )
|
||||
{
|
||||
/* Error detected when parsing extension header. */
|
||||
pxSet->usChecksum = ipINVALID_LENGTH;
|
||||
xReturn = 3;
|
||||
}
|
||||
else
|
||||
{
|
||||
size_t uxNeeded;
|
||||
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
pxSet->pxProtocolHeaders = ( ( ProtocolHeaders_t * ) &( pucEthernetBuffer[ ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + uxExtensionHeaderLength ] ) );
|
||||
pxSet->usPayloadLength = FreeRTOS_ntohs( pxSet->pxIPPacket_IPv6->usPayloadLength );
|
||||
|
||||
/* For IPv6, the number of bytes in the protocol is indicated. */
|
||||
if( pxSet->usPayloadLength < uxExtensionHeaderLength )
|
||||
{
|
||||
/* Invalid payload length - extension headers exceed payload. */
|
||||
pxSet->usChecksum = ipINVALID_LENGTH;
|
||||
xReturn = 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
pxSet->usProtocolBytes = ( uint16_t ) ( pxSet->usPayloadLength - uxExtensionHeaderLength );
|
||||
}
|
||||
|
||||
uxNeeded = ( size_t ) pxSet->usPayloadLength;
|
||||
uxNeeded += ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER;
|
||||
|
||||
if( uxBufferLength < uxNeeded )
|
||||
{
|
||||
/* The packet does not contain a complete IPv6 packet. */
|
||||
pxSet->usChecksum = ipINVALID_LENGTH;
|
||||
xReturn = 2;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Check the buffer lengths of an ICMPv6 packet.
|
||||
* @param[in] uxBufferLength The total length of the packet.
|
||||
* @param[in] pxSet A struct describing this packet.
|
||||
* @return Non-zero in case of an error.
|
||||
*/
|
||||
BaseType_t prvChecksumICMPv6Checks( size_t uxBufferLength,
|
||||
struct xPacketSummary * pxSet )
|
||||
{
|
||||
BaseType_t xReturn = 0;
|
||||
size_t xICMPLength;
|
||||
|
||||
switch( pxSet->pxProtocolHeaders->xICMPHeaderIPv6.ucTypeOfMessage )
|
||||
{
|
||||
case ipICMP_PING_REQUEST_IPv6:
|
||||
case ipICMP_PING_REPLY_IPv6:
|
||||
xICMPLength = sizeof( ICMPEcho_IPv6_t );
|
||||
break;
|
||||
|
||||
case ipICMP_ROUTER_SOLICITATION_IPv6:
|
||||
xICMPLength = sizeof( ICMPRouterSolicitation_IPv6_t );
|
||||
break;
|
||||
|
||||
default:
|
||||
xICMPLength = ipSIZE_OF_ICMPv6_HEADER;
|
||||
break;
|
||||
}
|
||||
|
||||
if( uxBufferLength < ( ipSIZE_OF_ETH_HEADER + pxSet->uxIPHeaderLength + xICMPLength ) )
|
||||
{
|
||||
pxSet->usChecksum = ipINVALID_LENGTH;
|
||||
xReturn = 10;
|
||||
}
|
||||
|
||||
if( xReturn == 0 )
|
||||
{
|
||||
pxSet->uxProtocolHeaderLength = xICMPLength;
|
||||
#if ( ipconfigHAS_DEBUG_PRINTF != 0 )
|
||||
{
|
||||
pxSet->pcType = "ICMP_IPv6";
|
||||
}
|
||||
#endif /* ipconfigHAS_DEBUG_PRINTF != 0 */
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Get total length of all extension headers in IPv6 packet.
|
||||
*
|
||||
* @param[in] pucEthernetBuffer The buffer containing the packet.
|
||||
* @param[in] uxBufferLength The number of bytes to be sent or received.
|
||||
* @param[out] pucProtocol The L4 protocol, such as TCP/UDP/ICMPv6.
|
||||
*
|
||||
* @return The total length of all extension headers, or whole buffer length when error detected.
|
||||
*/
|
||||
size_t usGetExtensionHeaderLength( const uint8_t * pucEthernetBuffer,
|
||||
size_t uxBufferLength,
|
||||
uint8_t * pucProtocol )
|
||||
{
|
||||
uint8_t ucCurrentHeader;
|
||||
const IPPacket_IPv6_t * pxIPPacket_IPv6;
|
||||
uint8_t ucNextHeader = 0U;
|
||||
size_t uxIndex = ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER;
|
||||
size_t uxHopSize = 0U;
|
||||
BaseType_t xCurrentOrder = 0;
|
||||
BaseType_t xNextOrder = 0;
|
||||
size_t uxReturn = uxBufferLength;
|
||||
|
||||
if( ( pucEthernetBuffer != NULL ) && ( pucProtocol != NULL ) )
|
||||
{
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
pxIPPacket_IPv6 = ( ( const IPPacket_IPv6_t * ) pucEthernetBuffer );
|
||||
ucCurrentHeader = pxIPPacket_IPv6->xIPHeader.ucNextHeader;
|
||||
|
||||
/* Check if packet has extension header. */
|
||||
if( xGetExtensionOrder( ucCurrentHeader, 0U ) > 0 )
|
||||
{
|
||||
while( ( uxIndex + 8U ) < uxBufferLength )
|
||||
{
|
||||
ucNextHeader = pucEthernetBuffer[ uxIndex ];
|
||||
|
||||
xCurrentOrder = xGetExtensionOrder( ucCurrentHeader, ucNextHeader );
|
||||
|
||||
/* To avoid compile warning if debug print is disabled. */
|
||||
( void ) xCurrentOrder;
|
||||
|
||||
/* Read the length expressed in number of octets. */
|
||||
uxHopSize = ( size_t ) pucEthernetBuffer[ uxIndex + 1U ];
|
||||
/* And multiply by 8 and add the minimum size of 8. */
|
||||
uxHopSize = ( uxHopSize * 8U ) + 8U;
|
||||
|
||||
if( ( uxIndex + uxHopSize ) >= uxBufferLength )
|
||||
{
|
||||
FreeRTOS_debug_printf( ( "The length %u + %u of extension header is larger than buffer size %u \n", ( unsigned ) uxIndex, ( unsigned ) uxHopSize, ( unsigned ) uxBufferLength ) );
|
||||
break;
|
||||
}
|
||||
|
||||
uxIndex = uxIndex + uxHopSize;
|
||||
|
||||
if( ( ucNextHeader == ipPROTOCOL_TCP ) ||
|
||||
( ucNextHeader == ipPROTOCOL_UDP ) ||
|
||||
( ucNextHeader == ipPROTOCOL_ICMP_IPv6 ) )
|
||||
{
|
||||
FreeRTOS_debug_printf( ( "Stop at header %u\n", ucNextHeader ) );
|
||||
|
||||
uxReturn = uxIndex - ( ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER );
|
||||
*pucProtocol = ucNextHeader;
|
||||
break;
|
||||
}
|
||||
|
||||
xNextOrder = xGetExtensionOrder( ucNextHeader, pucEthernetBuffer[ uxIndex ] );
|
||||
|
||||
FreeRTOS_debug_printf( ( "Going from header %2u (%d) to %2u (%d)\n",
|
||||
ucCurrentHeader,
|
||||
( int ) xCurrentOrder,
|
||||
ucNextHeader,
|
||||
( int ) xNextOrder ) );
|
||||
|
||||
/*
|
||||
* IPv6 nodes must accept and attempt to process extension headers in
|
||||
* any order and occurring any number of times in the same packet,
|
||||
* except for the Hop-by-Hop Options header which is restricted to
|
||||
* appear immediately after an IPv6 header only. Outlined
|
||||
* by RFC 2460 section 4.1 Extension Header Order.
|
||||
*/
|
||||
if( xNextOrder == 1 ) /* ipIPv6_EXT_HEADER_HOP_BY_HOP */
|
||||
{
|
||||
FreeRTOS_printf( ( "Wrong order. Hop-by-Hop Options header restricted to appear immediately after an IPv6 header\n" ) );
|
||||
break;
|
||||
}
|
||||
else if( xNextOrder < 0 )
|
||||
{
|
||||
FreeRTOS_printf( ( "Invalid extension header detected\n" ) );
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Do nothing, coverity happy. */
|
||||
}
|
||||
|
||||
ucCurrentHeader = ucNextHeader;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* No extension headers. */
|
||||
*pucProtocol = ucCurrentHeader;
|
||||
uxReturn = 0;
|
||||
}
|
||||
}
|
||||
|
||||
return uxReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Every IPv6 end-point has a solicited node multicast address and a corresponding
|
||||
* multicast MAC address. The IPv6 solicited node address also has an MLD reports associated
|
||||
* with it. This function manages both the MAC address and the MLD report associated with
|
||||
* the end-point's solicited-node address. On network UP, this function registers the MAC address
|
||||
* with the network driver's filter and creates and MLD report for the UPv6 multicast address.
|
||||
* On network DOWN, the function unregisters the MAC address and removes the MLD report.
|
||||
* This is a "convenience" function that keeps all these tasks under one roof for easier maintenance.
|
||||
*
|
||||
* @param[in] pxEndPoint The end-point for which a network up/down event is being handled.
|
||||
* @param[in] xNetworkGoingUp pdTRUE when the network goes UP, pdFALSE when the network goes DOWN.
|
||||
*/
|
||||
void vManageSolicitedNodeAddress( const struct xNetworkEndPoint * pxEndPoint,
|
||||
BaseType_t xNetworkGoingUp )
|
||||
{
|
||||
IPv6_Type_t xAddressType;
|
||||
MACAddress_t xMACAddress;
|
||||
|
||||
configASSERT( pxEndPoint != NULL );
|
||||
configASSERT( pxEndPoint->pxNetworkInterface != NULL );
|
||||
|
||||
/* do{}while(0) to allow for the use of break statements */
|
||||
do
|
||||
{
|
||||
/* During the very first network DOWN event, pxEndPoint->ipv6_settings does not yet hold the proper address and
|
||||
* therefore the calculated MAC address will be incorrect. Nothing bad will happen though, because the address
|
||||
* type check below will kick us out before the call to pfRemoveAllowedMAC(). Without the check below, the network
|
||||
* driver ends up being called once to register 33:33:FF:00:00:00 and that MAC never gets unregistered. */
|
||||
|
||||
/* Solicited-node multicast addresses only apply to normal unicast non-loopback addresses. */
|
||||
xAddressType = xIPv6_GetIPType( &( pxEndPoint->ipv6_settings.xIPAddress ) );
|
||||
|
||||
if( ( xAddressType != eIPv6_LinkLocal ) && ( xAddressType != eIPv6_SiteLocal ) && ( xAddressType != eIPv6_Global ) )
|
||||
{
|
||||
/* The address of this end-point is something other than a normal unicast address... Maybe it's the
|
||||
* loopback address or maybe this is an error scenario. In any case, there is no corresponding
|
||||
* solicited-node multicast address that we need to manage. Do nothing.*/
|
||||
break;
|
||||
}
|
||||
|
||||
/* Calculate the multicast MAC that corresponds to this endpoint's IPv6 address. */
|
||||
xMACAddress.ucBytes[ 0 ] = ipMULTICAST_MAC_ADDRESS_IPv6_0;
|
||||
xMACAddress.ucBytes[ 1 ] = ipMULTICAST_MAC_ADDRESS_IPv6_0;
|
||||
xMACAddress.ucBytes[ 2 ] = 0xFFU;
|
||||
xMACAddress.ucBytes[ 3 ] = pxEndPoint->ipv6_settings.xIPAddress.ucBytes[ 13 ];
|
||||
xMACAddress.ucBytes[ 4 ] = pxEndPoint->ipv6_settings.xIPAddress.ucBytes[ 14 ];
|
||||
xMACAddress.ucBytes[ 5 ] = pxEndPoint->ipv6_settings.xIPAddress.ucBytes[ 15 ];
|
||||
|
||||
/* Update the network driver filter */
|
||||
if( xNetworkGoingUp == pdTRUE )
|
||||
{
|
||||
if( pxEndPoint->pxNetworkInterface->pfAddAllowedMAC != NULL )
|
||||
{
|
||||
pxEndPoint->pxNetworkInterface->pfAddAllowedMAC( pxEndPoint->pxNetworkInterface, xMACAddress.ucBytes );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if( pxEndPoint->pxNetworkInterface->pfRemoveAllowedMAC != NULL )
|
||||
{
|
||||
pxEndPoint->pxNetworkInterface->pfRemoveAllowedMAC( pxEndPoint->pxNetworkInterface, xMACAddress.ucBytes );
|
||||
}
|
||||
}
|
||||
} while( ipFALSE_BOOL );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
#endif /* ( ipconfigUSE_IPv6 != 0 ) */
|
||||
/* *INDENT-ON* */
|
||||
+1483
File diff suppressed because it is too large.
Load diff
+723
@@ -0,0 +1,723 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_RA.c
|
||||
* @brief A client implementation of Router advertisement protocol.
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
|
||||
/* FreeRTOS+TCP includes. */
|
||||
#include "FreeRTOS_IP.h"
|
||||
#include "FreeRTOS_Sockets.h"
|
||||
#include "FreeRTOS_IP_Private.h"
|
||||
#include "FreeRTOS_IP_Timers.h"
|
||||
#include "FreeRTOS_UDP_IP.h"
|
||||
#include "FreeRTOS_Routing.h"
|
||||
#include "FreeRTOS_ND.h"
|
||||
#if ( ipconfigUSE_LLMNR == 1 )
|
||||
#include "FreeRTOS_DNS.h"
|
||||
#endif /* ipconfigUSE_LLMNR */
|
||||
#include "NetworkBufferManagement.h"
|
||||
|
||||
/* This define may exclude the entire source file. */
|
||||
#if ( ipconfigUSE_IPv6 != 0 ) && ( ipconfigUSE_RA != 0 )
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/** A block time of 0 simply means "don't block". */
|
||||
#define raDONT_BLOCK ( ( TickType_t ) 0 )
|
||||
|
||||
/** The default value for the IPv6-field 'ucVersionTrafficClass'. */
|
||||
#define raDEFAULT_VERSION_TRAFFIC_CLASS 0x60U
|
||||
|
||||
/** The default value for the IPv6-field 'ucHopLimit'. */
|
||||
#define raDEFAULT_HOP_LIMIT 255U
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Initialise the Router Advertisement process for a given end-point. */
|
||||
static void vRAProcessInit( NetworkEndPoint_t * pxEndPoint );
|
||||
|
||||
/* Find a link-local address that is bound to a given interface. */
|
||||
static BaseType_t xGetLinkLocalAddress( const NetworkInterface_t * pxInterface,
|
||||
IPv6_Address_t * pxAddress );
|
||||
|
||||
/* Read the reply received from the RA server. */
|
||||
static ICMPPrefixOption_IPv6_t * vReceiveRA_ReadReply( const NetworkBufferDescriptor_t * pxNetworkBuffer );
|
||||
|
||||
/* Handle the states that are limited by a timer. See if any of the timers has expired. */
|
||||
static TickType_t xRAProcess_HandleWaitStates( NetworkEndPoint_t * pxEndPoint,
|
||||
TickType_t uxReloadTime );
|
||||
|
||||
/* Handle the other states. */
|
||||
static TickType_t xRAProcess_HandleOtherStates( NetworkEndPoint_t * pxEndPoint,
|
||||
TickType_t uxReloadTime );
|
||||
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Find a link-local address that is bound to a given interface.
|
||||
*
|
||||
* @param[in] pxInterface The interface for which a link-local address is looked up.
|
||||
* @param[out] pxAddress The IP address will be copied to this parameter.
|
||||
*
|
||||
* @return pdPASS in case a link-local address was found, otherwise pdFAIL.
|
||||
*/
|
||||
static BaseType_t xGetLinkLocalAddress( const NetworkInterface_t * pxInterface,
|
||||
IPv6_Address_t * pxAddress )
|
||||
{
|
||||
BaseType_t xResult = pdFAIL;
|
||||
NetworkEndPoint_t * pxEndPoint;
|
||||
|
||||
for( pxEndPoint = FreeRTOS_FirstEndPoint( pxInterface );
|
||||
pxEndPoint != NULL;
|
||||
pxEndPoint = FreeRTOS_NextEndPoint( pxInterface, pxEndPoint ) )
|
||||
{
|
||||
/* Check if it has the link-local prefix FE80::/10 */
|
||||
if( ( pxEndPoint->ipv6_settings.xIPAddress.ucBytes[ 0 ] == 0xfeU ) &&
|
||||
( ( pxEndPoint->ipv6_settings.xIPAddress.ucBytes[ 1 ] & 0xc0U ) == 0x80U ) )
|
||||
{
|
||||
( void ) memcpy( pxAddress->ucBytes, pxEndPoint->ipv6_settings.xIPAddress.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
|
||||
xResult = pdPASS;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return xResult;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Send an ICMPv6 message of the type: Router Solicitation.
|
||||
*
|
||||
* @param[in] pxNetworkBuffer The network buffer which can be used for this.
|
||||
* @param[in] pxIPAddress The target address, normally ff02::2
|
||||
*
|
||||
*/
|
||||
void vNDSendRouterSolicitation( NetworkBufferDescriptor_t * pxNetworkBuffer,
|
||||
IPv6_Address_t * pxIPAddress )
|
||||
{
|
||||
ICMPPacket_IPv6_t * pxICMPPacket;
|
||||
ICMPRouterSolicitation_IPv6_t * xRASolicitationRequest;
|
||||
const NetworkEndPoint_t * pxEndPoint = pxNetworkBuffer->pxEndPoint;
|
||||
const size_t uxNeededSize = ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + sizeof( ICMPRouterSolicitation_IPv6_t );
|
||||
MACAddress_t xMultiCastMacAddress;
|
||||
NetworkBufferDescriptor_t * pxDescriptor = pxNetworkBuffer;
|
||||
IPv6_Address_t xSourceAddress;
|
||||
BaseType_t xHasLocal;
|
||||
NetworkBufferDescriptor_t * pxNewDescriptor = NULL;
|
||||
|
||||
configASSERT( pxEndPoint != NULL );
|
||||
configASSERT( pxEndPoint->bits.bIPv6 != ipFALSE_BOOL );
|
||||
|
||||
xHasLocal = xGetLinkLocalAddress( pxEndPoint->pxNetworkInterface, &( xSourceAddress ) );
|
||||
|
||||
if( xHasLocal == pdFAIL )
|
||||
{
|
||||
FreeRTOS_printf( ( "RA: can not find a Link-local address\n" ) );
|
||||
( void ) memset( xSourceAddress.ucBytes, 0, ipSIZE_OF_IPv6_ADDRESS );
|
||||
}
|
||||
else
|
||||
{
|
||||
FreeRTOS_printf( ( "RA: source %pip\n", ( void * ) xSourceAddress.ucBytes ) );
|
||||
}
|
||||
|
||||
if( pxDescriptor->xDataLength < uxNeededSize )
|
||||
{
|
||||
pxNewDescriptor = pxDuplicateNetworkBufferWithDescriptor( pxDescriptor, uxNeededSize );
|
||||
vReleaseNetworkBufferAndDescriptor( pxDescriptor );
|
||||
pxDescriptor = pxNewDescriptor;
|
||||
}
|
||||
|
||||
if( pxDescriptor != NULL )
|
||||
{
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
pxICMPPacket = ( ( ICMPPacket_IPv6_t * ) pxDescriptor->pucEthernetBuffer );
|
||||
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
xRASolicitationRequest = ( ( ICMPRouterSolicitation_IPv6_t * ) &( pxICMPPacket->xICMPHeaderIPv6 ) );
|
||||
|
||||
pxDescriptor->xDataLength = uxNeededSize;
|
||||
|
||||
( void ) eNDGetCacheEntry( pxIPAddress, &( xMultiCastMacAddress ), NULL );
|
||||
|
||||
/* Set Ethernet header. Will be swapped. */
|
||||
( void ) memcpy( pxICMPPacket->xEthernetHeader.xSourceAddress.ucBytes, xMultiCastMacAddress.ucBytes, ipMAC_ADDRESS_LENGTH_BYTES );
|
||||
( void ) memcpy( pxICMPPacket->xEthernetHeader.xDestinationAddress.ucBytes, pxEndPoint->xMACAddress.ucBytes, ipMAC_ADDRESS_LENGTH_BYTES );
|
||||
pxICMPPacket->xEthernetHeader.usFrameType = ipIPv6_FRAME_TYPE;
|
||||
|
||||
/* Set IP-header. */
|
||||
pxICMPPacket->xIPHeader.ucVersionTrafficClass = raDEFAULT_VERSION_TRAFFIC_CLASS;
|
||||
pxICMPPacket->xIPHeader.ucTrafficClassFlow = 0U;
|
||||
pxICMPPacket->xIPHeader.usFlowLabel = 0U;
|
||||
pxICMPPacket->xIPHeader.usPayloadLength = FreeRTOS_htons( sizeof( ICMPRouterSolicitation_IPv6_t ) );
|
||||
pxICMPPacket->xIPHeader.ucNextHeader = ipPROTOCOL_ICMP_IPv6;
|
||||
pxICMPPacket->xIPHeader.ucHopLimit = raDEFAULT_HOP_LIMIT;
|
||||
|
||||
/* Normally, the source address is set as 'ipv6_settings.xIPAddress'.
|
||||
* But is some routers will not accept a public IP-address, the original
|
||||
* default address will be used. It must be a link-local address. */
|
||||
( void ) memcpy( pxICMPPacket->xIPHeader.xSourceAddress.ucBytes, xSourceAddress.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
|
||||
|
||||
( void ) memcpy( pxICMPPacket->xIPHeader.xDestinationAddress.ucBytes, pxIPAddress->ucBytes, ipSIZE_OF_IPv6_ADDRESS );
|
||||
|
||||
/* Set ICMP header. */
|
||||
( void ) memset( xRASolicitationRequest, 0, sizeof( *xRASolicitationRequest ) );
|
||||
xRASolicitationRequest->ucTypeOfMessage = ipICMP_ROUTER_SOLICITATION_IPv6;
|
||||
|
||||
/* __XX__ revisit on why commented out
|
||||
* xRASolicitationRequest->ucOptionType = ndICMP_SOURCE_LINK_LAYER_ADDRESS;
|
||||
* xRASolicitationRequest->ucOptionLength = 1;
|
||||
* ( void ) memcpy( xRASolicitationRequest->ucOptionBytes, pxEndPoint->xMACAddress.ucBytes, ipMAC_ADDRESS_LENGTH_BYTES );
|
||||
*/
|
||||
|
||||
/* Checksums. */
|
||||
#if ( ipconfigDRIVER_INCLUDED_TX_IP_CHECKSUM == 0 )
|
||||
{
|
||||
/* calculate the ICMPv6 checksum for outgoing package */
|
||||
( void ) usGenerateProtocolChecksum( pxDescriptor->pucEthernetBuffer, pxDescriptor->xDataLength, pdTRUE );
|
||||
}
|
||||
#else
|
||||
{
|
||||
/* Many EMAC peripherals will only calculate the ICMP checksum
|
||||
* correctly if the field is nulled beforehand. */
|
||||
xRASolicitationRequest->usChecksum = 0U;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* This function will fill in the eth addresses and send the packet */
|
||||
vReturnEthernetFrame( pxDescriptor, pdTRUE );
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Receive a NA ( Neighbour Advertisement ) message to see if a chosen IP-address is already in use.
|
||||
*
|
||||
* @param[in] pxNetworkBuffer The buffer that contains the message.
|
||||
*/
|
||||
void vReceiveNA( const NetworkBufferDescriptor_t * pxNetworkBuffer )
|
||||
{
|
||||
const NetworkInterface_t * pxInterface = pxNetworkBuffer->pxInterface;
|
||||
NetworkEndPoint_t * pxPoint;
|
||||
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
const ICMPPacket_IPv6_t * pxICMPPacket = ( ( const ICMPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer );
|
||||
const ICMPHeader_IPv6_t * pxICMPHeader_IPv6 = ( ( const ICMPHeader_IPv6_t * ) &( pxICMPPacket->xICMPHeaderIPv6 ) );
|
||||
|
||||
for( pxPoint = FreeRTOS_FirstEndPoint( pxInterface );
|
||||
pxPoint != NULL;
|
||||
pxPoint = FreeRTOS_NextEndPoint( pxInterface, pxPoint ) )
|
||||
{
|
||||
if( ( pxPoint->bits.bWantRA != ipFALSE_BOOL ) && ( pxPoint->xRAData.eRAState == eRAStateIPWait ) )
|
||||
{
|
||||
if( memcmp( pxPoint->ipv6_settings.xIPAddress.ucBytes, pxICMPHeader_IPv6->xIPv6Address.ucBytes, ipSIZE_OF_IPv6_ADDRESS ) == 0 )
|
||||
{
|
||||
pxPoint->xRAData.bits.bIPAddressInUse = ipTRUE_BOOL;
|
||||
vDHCP_RATimerReload( pxPoint, 100U );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Read a received RA reply and return the prefix option from the packet.
|
||||
*
|
||||
* @param[in] pxNetworkBuffer The buffer that contains the message.
|
||||
*
|
||||
* @returns Returns the ICMP prefix option pointer, pointing to its location in the
|
||||
* input RA reply message buffer.
|
||||
*/
|
||||
static ICMPPrefixOption_IPv6_t * vReceiveRA_ReadReply( const NetworkBufferDescriptor_t * pxNetworkBuffer )
|
||||
{
|
||||
size_t uxIndex = 0U;
|
||||
const size_t uxICMPSize = sizeof( ICMPRouterAdvertisement_IPv6_t );
|
||||
const size_t uxNeededSize = ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + uxICMPSize;
|
||||
/* uxLast points to the first byte after the buffer. */
|
||||
const size_t uxLast = pxNetworkBuffer->xDataLength - uxNeededSize;
|
||||
uint8_t * pucBytes = &( pxNetworkBuffer->pucEthernetBuffer[ uxNeededSize ] );
|
||||
ICMPPrefixOption_IPv6_t * pxPrefixOption = NULL;
|
||||
BaseType_t xMalformed = pdFALSE;
|
||||
|
||||
while( ( uxIndex + 1U ) < uxLast )
|
||||
{
|
||||
uint8_t ucType = pucBytes[ uxIndex ];
|
||||
size_t uxPrefixLength = ( size_t ) pucBytes[ uxIndex + 1U ];
|
||||
size_t uxLength = uxPrefixLength * 8U;
|
||||
|
||||
if( uxPrefixLength == 0U )
|
||||
{
|
||||
/* According to RFC 4861, length of the option value 0 is invalid. Hence returning from here */
|
||||
FreeRTOS_printf( ( "RA: Invalid length of the option value as zero. " ) );
|
||||
break;
|
||||
}
|
||||
|
||||
if( uxLast < ( uxIndex + uxLength ) )
|
||||
{
|
||||
FreeRTOS_printf( ( "RA: Not enough bytes ( %u > %u )\n", ( unsigned ) ( uxIndex + uxLength ), ( unsigned ) uxLast ) );
|
||||
break;
|
||||
}
|
||||
|
||||
switch( ucType )
|
||||
{
|
||||
case ndICMP_SOURCE_LINK_LAYER_ADDRESS: /* 1 */
|
||||
FreeRTOS_printf( ( "RA: Source = %02x-%02x-%02x-%02x-%02x-%02x\n",
|
||||
pucBytes[ uxIndex + 2U ],
|
||||
pucBytes[ uxIndex + 3U ],
|
||||
pucBytes[ uxIndex + 4U ],
|
||||
pucBytes[ uxIndex + 5U ],
|
||||
pucBytes[ uxIndex + 6U ],
|
||||
pucBytes[ uxIndex + 7U ] ) );
|
||||
break;
|
||||
|
||||
case ndICMP_TARGET_LINK_LAYER_ADDRESS: /* 2 */
|
||||
break;
|
||||
|
||||
case ndICMP_PREFIX_INFORMATION: /* 3 */
|
||||
|
||||
if( uxLength < sizeof( ICMPPrefixOption_IPv6_t ) )
|
||||
{
|
||||
FreeRTOS_printf(
|
||||
( "RA: Prefix option too short ( %u < %u )\n",
|
||||
( unsigned ) uxLength,
|
||||
( unsigned ) sizeof( ICMPPrefixOption_IPv6_t ) ) );
|
||||
xMalformed = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
pxPrefixOption = ( ( ICMPPrefixOption_IPv6_t * ) &( pucBytes[ uxIndex ] ) );
|
||||
|
||||
FreeRTOS_printf( ( "RA: Prefix len %d Life %u, %u (%pip)\n",
|
||||
pxPrefixOption->ucPrefixLength,
|
||||
( unsigned ) FreeRTOS_ntohl( pxPrefixOption->ulValidLifeTime ),
|
||||
( unsigned ) FreeRTOS_ntohl( pxPrefixOption->ulPreferredLifeTime ),
|
||||
( void * ) pxPrefixOption->ucPrefix ) );
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
case ndICMP_REDIRECTED_HEADER: /* 4 */
|
||||
break;
|
||||
|
||||
case ndICMP_MTU_OPTION: /* 5 */
|
||||
{
|
||||
#if ipconfigHAS_PRINTF == 1
|
||||
uint32_t ulMTU;
|
||||
( void ) ulMTU;
|
||||
|
||||
/* ulChar2u32 returns host-endian numbers. */
|
||||
ulMTU = ulChar2u32( &( pucBytes[ uxIndex + 4U ] ) );
|
||||
FreeRTOS_printf( ( "RA: MTU = %u\n", ( unsigned int ) ulMTU ) );
|
||||
#endif /* ipconfigHAS_PRINTF == 1 */
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
FreeRTOS_printf( ( "RA: Type 0x%02x not implemented\n", ucType ) );
|
||||
break;
|
||||
}
|
||||
|
||||
if( xMalformed != pdFALSE )
|
||||
{
|
||||
FreeRTOS_printf( ( "RA: Malformed packet.\n" ) );
|
||||
break;
|
||||
}
|
||||
|
||||
uxIndex = uxIndex + uxLength;
|
||||
} /* while( ( uxIndex + 1 ) < uxLast ) */
|
||||
|
||||
return pxPrefixOption;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Receive and analyse a RA ( Router Advertisement ) message.
|
||||
* If the reply is satisfactory, the end-point will do SLAAC: choose an IP-address using the
|
||||
* prefix offered, and completed with random bits. It will start testing if another device
|
||||
* already exists that uses the same IP-address.
|
||||
*
|
||||
* @param[in] pxNetworkBuffer The buffer that contains the message.
|
||||
*/
|
||||
void vReceiveRA( const NetworkBufferDescriptor_t * pxNetworkBuffer )
|
||||
{
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
const ICMPPacket_IPv6_t * pxICMPPacket = ( ( const ICMPPacket_IPv6_t * ) pxNetworkBuffer->pucEthernetBuffer );
|
||||
const ICMPPrefixOption_IPv6_t * pxPrefixOption = NULL;
|
||||
const size_t uxICMPSize = sizeof( ICMPRouterAdvertisement_IPv6_t );
|
||||
const size_t uxNeededSize = ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + uxICMPSize;
|
||||
|
||||
/* A Router Advertisement was received, handle it here. */
|
||||
if( uxNeededSize > pxNetworkBuffer->xDataLength )
|
||||
{
|
||||
FreeRTOS_printf( ( "vReceiveRA: The buffer provided is too small\n" ) );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* MISRA Ref 11.3.1 [Misaligned access] */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-113 */
|
||||
/* coverity[misra_c_2012_rule_11_3_violation] */
|
||||
const ICMPRouterAdvertisement_IPv6_t * pxAdvertisement = ( ( const ICMPRouterAdvertisement_IPv6_t * ) &( pxICMPPacket->xICMPHeaderIPv6 ) );
|
||||
FreeRTOS_printf( ( "RA: Type %02x Srv %02x Checksum %04x Hops %d Flags %02x Life %d\n",
|
||||
pxAdvertisement->ucTypeOfMessage,
|
||||
pxAdvertisement->ucTypeOfService,
|
||||
FreeRTOS_ntohs( pxAdvertisement->usChecksum ),
|
||||
pxAdvertisement->ucHopLimit,
|
||||
pxAdvertisement->ucFlags,
|
||||
FreeRTOS_ntohs( pxAdvertisement->usLifetime ) ) );
|
||||
|
||||
if( pxAdvertisement->usLifetime != 0U )
|
||||
{
|
||||
pxPrefixOption = vReceiveRA_ReadReply( pxNetworkBuffer );
|
||||
|
||||
configASSERT( pxNetworkBuffer->pxInterface != NULL );
|
||||
|
||||
if( pxPrefixOption != NULL )
|
||||
{
|
||||
NetworkEndPoint_t * pxEndPoint;
|
||||
|
||||
for( pxEndPoint = FreeRTOS_FirstEndPoint( pxNetworkBuffer->pxInterface );
|
||||
pxEndPoint != NULL;
|
||||
pxEndPoint = FreeRTOS_NextEndPoint( pxNetworkBuffer->pxInterface, pxEndPoint ) )
|
||||
{
|
||||
if( ( pxEndPoint->bits.bWantRA != ipFALSE_BOOL ) && ( pxEndPoint->xRAData.eRAState == eRAStateWait ) )
|
||||
{
|
||||
if( ( pxPrefixOption->ucPrefixLength == 0U ) ||
|
||||
( pxPrefixOption->ucPrefixLength > ( 8U * ipSIZE_OF_IPv6_ADDRESS ) ) )
|
||||
{
|
||||
FreeRTOS_printf( ( "vReceiveRA: The prefix length "
|
||||
"is invalid\n" ) );
|
||||
break;
|
||||
}
|
||||
|
||||
pxEndPoint->ipv6_settings.uxPrefixLength = pxPrefixOption->ucPrefixLength;
|
||||
( void ) memcpy( pxEndPoint->ipv6_settings.xPrefix.ucBytes, pxPrefixOption->ucPrefix, ipSIZE_OF_IPv6_ADDRESS );
|
||||
( void ) memcpy( pxEndPoint->ipv6_settings.xGatewayAddress.ucBytes, pxICMPPacket->xIPHeader.xSourceAddress.ucBytes, ipSIZE_OF_IPv6_ADDRESS );
|
||||
|
||||
pxEndPoint->xRAData.bits.bRouterReplied = ipTRUE_BOOL;
|
||||
pxEndPoint->xRAData.uxRetryCount = 0U;
|
||||
pxEndPoint->xRAData.ulPreferredLifeTime = FreeRTOS_ntohl( pxPrefixOption->ulPreferredLifeTime );
|
||||
/* Force taking a new random IP-address. */
|
||||
pxEndPoint->xRAData.bits.bIPAddressInUse = ipTRUE_BOOL;
|
||||
pxEndPoint->xRAData.eRAState = eRAStateIPTest;
|
||||
vRAProcess( pdFALSE, pxEndPoint );
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* The life-time field contains zero. */
|
||||
}
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Handles the RA wait state and calculates the new timer reload value
|
||||
* based on the wait state. Also checks if any timer has expired. If its found that
|
||||
* there is no other device using the same IP-address vIPNetworkUpCalls() is called
|
||||
* to send the network up event.
|
||||
*
|
||||
* @param[in] pxEndPoint The end point for which RA assignment is required.
|
||||
* @param[out] uxReloadTime Timer reload value in ticks.
|
||||
*
|
||||
* @return New timer reload value.
|
||||
*/
|
||||
static TickType_t xRAProcess_HandleWaitStates( NetworkEndPoint_t * pxEndPoint,
|
||||
TickType_t uxReloadTime )
|
||||
{
|
||||
TickType_t uxNewReloadTime = uxReloadTime;
|
||||
|
||||
if( pxEndPoint->xRAData.eRAState == eRAStateWait )
|
||||
{
|
||||
/* A Router Solicitation has been sent, waited for a reply, but no came.
|
||||
* All replies will be handled in the function vReceiveRA(). */
|
||||
pxEndPoint->xRAData.uxRetryCount++;
|
||||
|
||||
if( pxEndPoint->xRAData.uxRetryCount < ( UBaseType_t ) ipconfigRA_SEARCH_COUNT )
|
||||
{
|
||||
pxEndPoint->xRAData.eRAState = eRAStateApply;
|
||||
}
|
||||
else
|
||||
{
|
||||
FreeRTOS_printf( ( "RA: Giving up waiting for a Router.\n" ) );
|
||||
( void ) memcpy( &( pxEndPoint->ipv6_settings ), &( pxEndPoint->ipv6_defaults ), sizeof( pxEndPoint->ipv6_settings ) );
|
||||
|
||||
pxEndPoint->xRAData.bits.bRouterReplied = ipFALSE_BOOL;
|
||||
pxEndPoint->xRAData.uxRetryCount = 0U;
|
||||
/* Force taking a new random IP-address. */
|
||||
pxEndPoint->xRAData.bits.bIPAddressInUse = ipTRUE_BOOL;
|
||||
pxEndPoint->xRAData.eRAState = eRAStateIPTest;
|
||||
}
|
||||
}
|
||||
else if( pxEndPoint->xRAData.eRAState == eRAStateIPWait )
|
||||
{
|
||||
/* A Neighbour Solicitation has been sent, waited for a reply.
|
||||
* Repeat this 'ipconfigRA_IP_TEST_COUNT' times to be sure. */
|
||||
if( pxEndPoint->xRAData.bits.bIPAddressInUse != ipFALSE_BOOL )
|
||||
{
|
||||
/* Another device has responded with the same IPv4 address. */
|
||||
pxEndPoint->xRAData.uxRetryCount = 0U;
|
||||
pxEndPoint->xRAData.eRAState = eRAStateIPTest;
|
||||
uxNewReloadTime = pdMS_TO_TICKS( ipconfigRA_IP_TEST_TIME_OUT_MSEC );
|
||||
}
|
||||
else if( pxEndPoint->xRAData.uxRetryCount < ( UBaseType_t ) ipconfigRA_IP_TEST_COUNT )
|
||||
{
|
||||
/* Try again. */
|
||||
pxEndPoint->xRAData.uxRetryCount++;
|
||||
pxEndPoint->xRAData.eRAState = eRAStateIPTest;
|
||||
uxNewReloadTime = pdMS_TO_TICKS( ipconfigRA_IP_TEST_TIME_OUT_MSEC );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Now it is assumed that there is no other device using the same IP-address. */
|
||||
if( pxEndPoint->xRAData.bits.bRouterReplied != ipFALSE_BOOL )
|
||||
{
|
||||
/* Obtained configuration from a router. */
|
||||
uxNewReloadTime = pdMS_TO_TICKS( ( 1000U * ( uint64_t ) pxEndPoint->xRAData.ulPreferredLifeTime ) );
|
||||
pxEndPoint->xRAData.eRAState = eRAStatePreLease;
|
||||
iptraceRA_SUCCEEDED( &( pxEndPoint->ipv6_settings.xIPAddress ) );
|
||||
FreeRTOS_printf( ( "RA: succeeded, using IP address %pip Reload after %u seconds\n",
|
||||
( void * ) pxEndPoint->ipv6_settings.xIPAddress.ucBytes,
|
||||
( unsigned ) pxEndPoint->xRAData.ulPreferredLifeTime ) );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Using the default network parameters. */
|
||||
pxEndPoint->xRAData.eRAState = eRAStateFailed;
|
||||
|
||||
iptraceRA_REQUESTS_FAILED_USING_DEFAULT_IP_ADDRESS( &( pxEndPoint->ipv6_settings.xIPAddress ) );
|
||||
|
||||
FreeRTOS_printf( ( "RA: failed, using default parameters and IP address %pip\n", ( void * ) pxEndPoint->ipv6_settings.xIPAddress.ucBytes ) );
|
||||
/* Disable the timer. */
|
||||
uxNewReloadTime = 0U;
|
||||
}
|
||||
|
||||
/* Now call vIPNetworkUpCalls() to send the network-up event and
|
||||
* start the Resolution timer. */
|
||||
vIPNetworkUpCalls( pxEndPoint );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Do nothing */
|
||||
}
|
||||
|
||||
return uxNewReloadTime;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Handles the RA states other than the wait states.
|
||||
*
|
||||
* @param[in] pxEndPoint The end point for which RA assignment is required.
|
||||
* @param[out] uxReloadTime Timer reload value in ticks.
|
||||
*
|
||||
* @return New timer reload value.
|
||||
*/
|
||||
static TickType_t xRAProcess_HandleOtherStates( NetworkEndPoint_t * pxEndPoint,
|
||||
TickType_t uxReloadTime )
|
||||
{
|
||||
TickType_t uxNewReloadTime = uxReloadTime;
|
||||
|
||||
switch( pxEndPoint->xRAData.eRAState )
|
||||
{
|
||||
case eRAStateApply:
|
||||
{
|
||||
IPv6_Address_t xIPAddress;
|
||||
size_t uxNeededSize;
|
||||
NetworkBufferDescriptor_t * pxNetworkBuffer;
|
||||
|
||||
/* Send a Router Solicitation to ff02::2 */
|
||||
( void ) memset( xIPAddress.ucBytes, 0, sizeof( xIPAddress.ucBytes ) );
|
||||
xIPAddress.ucBytes[ 0 ] = 0xffU;
|
||||
xIPAddress.ucBytes[ 1 ] = 0x02U;
|
||||
xIPAddress.ucBytes[ 15 ] = 0x02U;
|
||||
uxNeededSize = ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + sizeof( ICMPRouterSolicitation_IPv6_t );
|
||||
pxNetworkBuffer = pxGetNetworkBufferWithDescriptor( uxNeededSize, raDONT_BLOCK );
|
||||
|
||||
if( pxNetworkBuffer != NULL )
|
||||
{
|
||||
pxNetworkBuffer->pxEndPoint = pxEndPoint;
|
||||
vNDSendRouterSolicitation( pxNetworkBuffer, &( xIPAddress ) );
|
||||
}
|
||||
|
||||
FreeRTOS_printf( ( "vRAProcess: Router Solicitation, attempt %lu/%u\n",
|
||||
pxEndPoint->xRAData.uxRetryCount + 1U,
|
||||
ipconfigRA_SEARCH_COUNT ) );
|
||||
/* Wait a configurable time for a router advertisement. */
|
||||
uxNewReloadTime = pdMS_TO_TICKS( ipconfigRA_SEARCH_TIME_OUT_MSEC );
|
||||
pxEndPoint->xRAData.eRAState = eRAStateWait;
|
||||
}
|
||||
break;
|
||||
|
||||
case eRAStateIPTest: /* Assuming an IP address, test if another device is using it already. */
|
||||
{
|
||||
size_t uxNeededSize;
|
||||
NetworkBufferDescriptor_t * pxNetworkBuffer;
|
||||
|
||||
/* Get an IP-address, using the network prefix and a random host address. */
|
||||
if( pxEndPoint->xRAData.bits.bIPAddressInUse != ipFALSE_BOOL )
|
||||
{
|
||||
pxEndPoint->xRAData.bits.bIPAddressInUse = ipFALSE_BOOL;
|
||||
|
||||
( void ) FreeRTOS_CreateIPv6Address( &pxEndPoint->ipv6_settings.xIPAddress, &pxEndPoint->ipv6_settings.xPrefix, pxEndPoint->ipv6_settings.uxPrefixLength, pdTRUE );
|
||||
|
||||
FreeRTOS_printf( ( "RA: Creating a random IP-address\n" ) );
|
||||
}
|
||||
|
||||
FreeRTOS_printf( ( "RA: Neighbour solicitation for %pip\n", ( void * ) pxEndPoint->ipv6_settings.xIPAddress.ucBytes ) );
|
||||
|
||||
uxNeededSize = ipSIZE_OF_ETH_HEADER + ipSIZE_OF_IPv6_HEADER + sizeof( ICMPHeader_IPv6_t );
|
||||
pxNetworkBuffer = pxGetNetworkBufferWithDescriptor( uxNeededSize, raDONT_BLOCK );
|
||||
|
||||
if( pxNetworkBuffer != NULL )
|
||||
{
|
||||
pxNetworkBuffer->pxEndPoint = pxEndPoint;
|
||||
vNDSendNeighbourSolicitation( pxNetworkBuffer, &( pxEndPoint->ipv6_settings.xIPAddress ) );
|
||||
}
|
||||
|
||||
uxNewReloadTime = pdMS_TO_TICKS( 1000U );
|
||||
pxEndPoint->xRAData.eRAState = eRAStateIPWait;
|
||||
}
|
||||
break;
|
||||
|
||||
case eRAStatePreLease:
|
||||
pxEndPoint->xRAData.eRAState = eRAStateLease;
|
||||
break;
|
||||
|
||||
case eRAStateLease:
|
||||
|
||||
vRAProcessInit( pxEndPoint );
|
||||
uxNewReloadTime = pdMS_TO_TICKS( 1000U );
|
||||
|
||||
break;
|
||||
|
||||
case eRAStateFailed:
|
||||
break;
|
||||
|
||||
default:
|
||||
/* All states were handled. */
|
||||
break;
|
||||
}
|
||||
|
||||
return uxNewReloadTime;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Initialise the RA state machine.
|
||||
*
|
||||
* @param[in] pxEndPoint The end-point for which Router Advertisement is required.
|
||||
*/
|
||||
static void vRAProcessInit( NetworkEndPoint_t * pxEndPoint )
|
||||
{
|
||||
pxEndPoint->xRAData.uxRetryCount = 0U;
|
||||
pxEndPoint->xRAData.eRAState = eRAStateApply;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Do a single cycle of the RA state machine.
|
||||
*
|
||||
* @param[in] xDoReset pdTRUE if the state machine must be reset.
|
||||
* @param[in] pxEndPoint The end-point for which a RA assignment is required.
|
||||
*/
|
||||
void vRAProcess( BaseType_t xDoReset,
|
||||
NetworkEndPoint_t * pxEndPoint )
|
||||
{
|
||||
TickType_t uxReloadTime = pdMS_TO_TICKS( 5000U );
|
||||
|
||||
#if ( ipconfigHAS_PRINTF == 1 )
|
||||
eRAState_t eRAState;
|
||||
#endif
|
||||
|
||||
configASSERT( pxEndPoint != NULL );
|
||||
|
||||
#if ( ipconfigHAS_PRINTF == 1 )
|
||||
/* Remember the initial state, just for logging. */
|
||||
eRAState = pxEndPoint->xRAData.eRAState;
|
||||
#endif
|
||||
|
||||
if( xDoReset != pdFALSE )
|
||||
{
|
||||
vRAProcessInit( pxEndPoint );
|
||||
}
|
||||
|
||||
/* First handle the states that are limited by a timer. See if some
|
||||
* timer has expired. */
|
||||
uxReloadTime = xRAProcess_HandleWaitStates( pxEndPoint, uxReloadTime );
|
||||
|
||||
/* Now handle the other states. */
|
||||
uxReloadTime = xRAProcess_HandleOtherStates( pxEndPoint, uxReloadTime );
|
||||
|
||||
#if ( ipconfigHAS_PRINTF == 1 )
|
||||
{
|
||||
FreeRTOS_printf( ( "vRAProcess( %ld, %pip) bRouterReplied=%d bIPAddressInUse=%d state %d -> %d\n",
|
||||
xDoReset,
|
||||
( void * ) pxEndPoint->ipv6_defaults.xIPAddress.ucBytes,
|
||||
pxEndPoint->xRAData.bits.bRouterReplied,
|
||||
pxEndPoint->xRAData.bits.bIPAddressInUse,
|
||||
eRAState,
|
||||
pxEndPoint->xRAData.eRAState ) );
|
||||
}
|
||||
#endif /* ( ipconfigHAS_PRINTF == 1 ) */
|
||||
|
||||
if( uxReloadTime != 0U )
|
||||
{
|
||||
FreeRTOS_printf( ( "RA: Reload %u seconds\n", ( unsigned ) ( uxReloadTime / 1000U ) ) );
|
||||
vDHCP_RATimerReload( pxEndPoint, uxReloadTime );
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Disable the timer, this function vRAProcess() won't be called anymore for this end-point. */
|
||||
FreeRTOS_printf( ( "RA: Disabled timer.\n" ) );
|
||||
vIPSetDHCP_RATimerEnableState( pxEndPoint, pdFALSE );
|
||||
}
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
#endif /* ( ipconfigUSE_IPv6 != 0 ) && ( ipconfigUSE_RA != 0 ) */
|
||||
+1549
File diff suppressed because it is too large.
Load diff
+6360
File diff suppressed because it is too large.
Load diff
+425
@@ -0,0 +1,425 @@
|
||||
/*
|
||||
* FreeRTOS+TCP
|
||||
* Copyright (C) 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* SPDX-License-Identifier: MIT
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file FreeRTOS_Stream_Buffer.c
|
||||
* @brief Provides the API for managing/creating the stream buffers in the FreeRTOS+TCP network stack.
|
||||
*/
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
/* FreeRTOS includes. */
|
||||
#include "FreeRTOS.h"
|
||||
#include "task.h"
|
||||
|
||||
/* FreeRTOS+TCP includes. */
|
||||
#include "FreeRTOS_IP.h"
|
||||
|
||||
|
||||
/**
|
||||
* @brief Get the space between lower and upper value provided to the function.
|
||||
* @param[in] pxBuffer The circular stream buffer.
|
||||
* @param[in] uxLower The lower value.
|
||||
* @param[in] uxUpper The upper value.
|
||||
* @return The space between uxLower and uxUpper, which equals to the distance
|
||||
* minus 1.
|
||||
*/
|
||||
size_t uxStreamBufferSpace( const StreamBuffer_t * const pxBuffer,
|
||||
size_t uxLower,
|
||||
size_t uxUpper )
|
||||
{
|
||||
const size_t uxLength = pxBuffer->LENGTH;
|
||||
size_t uxCount = uxLength + uxUpper - uxLower - 1U;
|
||||
|
||||
if( uxCount >= uxLength )
|
||||
{
|
||||
uxCount -= uxLength;
|
||||
}
|
||||
|
||||
return uxCount;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Get the distance between lower and upper value provided to the function.
|
||||
* @param[in] pxBuffer The circular stream buffer.
|
||||
* @param[in] uxLower The lower value.
|
||||
* @param[in] uxUpper The upper value.
|
||||
* @return The distance between uxLower and uxUpper.
|
||||
*/
|
||||
size_t uxStreamBufferDistance( const StreamBuffer_t * const pxBuffer,
|
||||
size_t uxLower,
|
||||
size_t uxUpper )
|
||||
{
|
||||
const size_t uxLength = pxBuffer->LENGTH;
|
||||
size_t uxCount = uxLength + uxUpper - uxLower;
|
||||
|
||||
if( uxCount >= uxLength )
|
||||
{
|
||||
uxCount -= uxLength;
|
||||
}
|
||||
|
||||
return uxCount;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Get the number of items which can be added to the buffer at
|
||||
* the head before reaching the tail.
|
||||
* @param[in] pxBuffer The circular stream buffer.
|
||||
* @return The number of items which can still be added to uxHead
|
||||
* before hitting on uxTail
|
||||
*/
|
||||
size_t uxStreamBufferGetSpace( const StreamBuffer_t * const pxBuffer )
|
||||
{
|
||||
return uxStreamBufferSpace( pxBuffer, pxBuffer->uxHead, pxBuffer->uxTail );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Get the distance between the pointer in free space and the tail.
|
||||
* @param[in] pxBuffer The circular stream buffer.
|
||||
* @return Distance between uxFront and uxTail or the number of items
|
||||
* which can still be added to uxFront, before hitting on uxTail.
|
||||
*/
|
||||
size_t uxStreamBufferFrontSpace( const StreamBuffer_t * const pxBuffer )
|
||||
{
|
||||
return uxStreamBufferSpace( pxBuffer, pxBuffer->uxFront, pxBuffer->uxTail );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Get the number of items which can be read from the tail before
|
||||
* reaching the head.
|
||||
* @param[in] pxBuffer The circular stream buffer.
|
||||
* @return The number of items which can be read from the tail before
|
||||
* reaching the head.
|
||||
*/
|
||||
size_t uxStreamBufferGetSize( const StreamBuffer_t * const pxBuffer )
|
||||
{
|
||||
return uxStreamBufferDistance( pxBuffer, pxBuffer->uxTail, pxBuffer->uxHead );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Get the space between the mid pointer and the head in the stream
|
||||
* buffer.
|
||||
* @param[in] pxBuffer The circular stream buffer.
|
||||
* @return The space between the mid pointer and the head.
|
||||
*/
|
||||
size_t uxStreamBufferMidSpace( const StreamBuffer_t * const pxBuffer )
|
||||
{
|
||||
return uxStreamBufferDistance( pxBuffer, pxBuffer->uxMid, pxBuffer->uxHead );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Clear the stream buffer.
|
||||
* @param[in] pxBuffer The circular stream buffer.
|
||||
*/
|
||||
void vStreamBufferClear( StreamBuffer_t * const pxBuffer )
|
||||
{
|
||||
/* Make the circular buffer empty */
|
||||
pxBuffer->uxHead = 0U;
|
||||
pxBuffer->uxTail = 0U;
|
||||
pxBuffer->uxFront = 0U;
|
||||
pxBuffer->uxMid = 0U;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Move the mid pointer forward by given byte count
|
||||
* @param[in] pxBuffer The circular stream buffer.
|
||||
* @param[in] uxCount The byte count by which the mid pointer is to be moved.
|
||||
*/
|
||||
void vStreamBufferMoveMid( StreamBuffer_t * const pxBuffer,
|
||||
const size_t uxCount )
|
||||
{
|
||||
/* Increment uxMid, but no further than uxHead */
|
||||
const size_t uxLength = pxBuffer->LENGTH;
|
||||
const size_t uxSize = uxStreamBufferMidSpace( pxBuffer );
|
||||
size_t uxMid = pxBuffer->uxMid;
|
||||
size_t uxMoveCount = uxCount;
|
||||
|
||||
if( uxMoveCount > uxSize )
|
||||
{
|
||||
uxMoveCount = uxSize;
|
||||
}
|
||||
|
||||
uxMid += uxMoveCount;
|
||||
|
||||
if( uxMid >= uxLength )
|
||||
{
|
||||
uxMid -= uxLength;
|
||||
}
|
||||
|
||||
pxBuffer->uxMid = uxMid;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Check whether the value in left is less than or equal to the
|
||||
* value in right from the perspective of the circular stream
|
||||
* buffer.
|
||||
* @param[in] pxBuffer The circular stream buffer.
|
||||
* @param[in] uxLeft The left pointer in the stream buffer.
|
||||
* @param[in] uxRight The right value pointer in the stream buffer.
|
||||
* @return pdTRUE if uxLeft <= uxRight, else pdFALSE.
|
||||
*/
|
||||
BaseType_t xStreamBufferLessThenEqual( const StreamBuffer_t * const pxBuffer,
|
||||
size_t uxLeft,
|
||||
size_t uxRight )
|
||||
{
|
||||
BaseType_t xReturn = pdFALSE;
|
||||
const size_t uxTail = pxBuffer->uxTail;
|
||||
|
||||
if( ( uxLeft - uxTail ) <= ( uxRight - uxTail ) )
|
||||
{
|
||||
xReturn = pdTRUE;
|
||||
}
|
||||
|
||||
return xReturn;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Get the pointer to data and the amount of data which can be read in one go.
|
||||
*
|
||||
* @param[in] pxBuffer The circular stream buffer.
|
||||
* @param[out] ppucData Pointer to the data pointer which will point to the
|
||||
* data which can be read.
|
||||
*
|
||||
* @return The number of bytes which can be read in one go (which might be less than
|
||||
* actual number of available bytes since this is a circular buffer and tail
|
||||
* can loop back to the start of the buffer).
|
||||
*/
|
||||
size_t uxStreamBufferGetPtr( StreamBuffer_t * const pxBuffer,
|
||||
uint8_t ** const ppucData )
|
||||
{
|
||||
const size_t uxNextTail = pxBuffer->uxTail;
|
||||
const size_t uxSize = uxStreamBufferGetSize( pxBuffer );
|
||||
|
||||
/* MISRA Ref 18.4.1 [Usage of +, -, += and -= operators on expression of pointer type]. */
|
||||
/* More details at: https://github.com/FreeRTOS/FreeRTOS-Plus-TCP/blob/main/MISRA.md#rule-184. */
|
||||
/* coverity[misra_c_2012_rule_18_4_violation] */
|
||||
*ppucData = pxBuffer->ucArray + uxNextTail;
|
||||
|
||||
return FreeRTOS_min_size_t( uxSize, pxBuffer->LENGTH - uxNextTail );
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Adds data to a stream buffer.
|
||||
*
|
||||
* @param[in,out] pxBuffer The buffer to which the bytes will be added.
|
||||
* @param[in] uxOffset If uxOffset > 0, data will be written at an offset from uxHead
|
||||
* while uxHead will not be moved yet.
|
||||
* @param[in] pucData A pointer to the data to be added. If 'pucData' equals NULL,
|
||||
* the function is called to advance the 'Head' only.
|
||||
* @param[in] uxByteCount The number of bytes to add.
|
||||
*
|
||||
* @return The number of bytes added to the buffer.
|
||||
*/
|
||||
size_t uxStreamBufferAdd( StreamBuffer_t * const pxBuffer,
|
||||
size_t uxOffset,
|
||||
const uint8_t * const pucData,
|
||||
size_t uxByteCount )
|
||||
{
|
||||
size_t uxCount;
|
||||
size_t uxSpace = uxStreamBufferGetSpace( pxBuffer );
|
||||
|
||||
/* If uxOffset > 0, items can be placed in front of uxHead */
|
||||
if( uxSpace > uxOffset )
|
||||
{
|
||||
uxSpace -= uxOffset;
|
||||
}
|
||||
else
|
||||
{
|
||||
uxSpace = 0U;
|
||||
}
|
||||
|
||||
/* The number of bytes that can be written is the minimum of the number of
|
||||
* bytes requested and the number available. */
|
||||
uxCount = FreeRTOS_min_size_t( uxSpace, uxByteCount );
|
||||
|
||||
if( uxCount != 0U )
|
||||
{
|
||||
const size_t uxLength = pxBuffer->LENGTH;
|
||||
size_t uxNextHead = pxBuffer->uxHead;
|
||||
|
||||
if( uxOffset != 0U )
|
||||
{
|
||||
/* ( uxOffset > 0 ) means: write in front if the uxHead marker */
|
||||
uxNextHead += uxOffset;
|
||||
|
||||
if( uxNextHead >= uxLength )
|
||||
{
|
||||
uxNextHead -= uxLength;
|
||||
}
|
||||
}
|
||||
|
||||
if( pucData != NULL )
|
||||
{
|
||||
/* Calculate the number of bytes that can be added in the first
|
||||
* write - which may be less than the total number of bytes that need
|
||||
* to be added if the buffer will wrap back to the beginning. */
|
||||
const size_t uxFirst = FreeRTOS_min_size_t( uxLength - uxNextHead, uxCount );
|
||||
|
||||
/* Write as many bytes as can be written in the first write. */
|
||||
( void ) pvPortMemCpyStreamBuffer( &( pxBuffer->ucArray[ uxNextHead ] ), pucData, uxFirst );
|
||||
|
||||
/* If the number of bytes written was less than the number that
|
||||
* could be written in the first write... */
|
||||
if( uxCount > uxFirst )
|
||||
{
|
||||
/* ...then write the remaining bytes to the start of the
|
||||
* buffer. */
|
||||
( void ) pvPortMemCpyStreamBuffer( pxBuffer->ucArray, &( pucData[ uxFirst ] ), uxCount - uxFirst );
|
||||
}
|
||||
}
|
||||
|
||||
/* The below update to the stream buffer members must happen
|
||||
* atomically. */
|
||||
taskENTER_CRITICAL();
|
||||
{
|
||||
if( uxOffset == 0U )
|
||||
{
|
||||
/* ( uxOffset == 0 ) means: write at uxHead position */
|
||||
uxNextHead += uxCount;
|
||||
|
||||
if( uxNextHead >= uxLength )
|
||||
{
|
||||
uxNextHead -= uxLength;
|
||||
}
|
||||
|
||||
pxBuffer->uxHead = uxNextHead;
|
||||
}
|
||||
|
||||
if( xStreamBufferLessThenEqual( pxBuffer, pxBuffer->uxFront, uxNextHead ) != pdFALSE )
|
||||
{
|
||||
/* Advance the front pointer */
|
||||
pxBuffer->uxFront = uxNextHead;
|
||||
}
|
||||
}
|
||||
taskEXIT_CRITICAL();
|
||||
}
|
||||
|
||||
return uxCount;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/**
|
||||
* @brief Read bytes from stream buffer.
|
||||
*
|
||||
* @param[in] pxBuffer The buffer from which the bytes will be read.
|
||||
* @param[in] uxOffset can be used to read data located at a certain offset from 'lTail'.
|
||||
* @param[in,out] pucData If 'pucData' equals NULL, the function is called to advance 'lTail' only.
|
||||
* @param[in] uxMaxCount The number of bytes to read.
|
||||
* @param[in] xPeek if 'xPeek' is pdTRUE, or if 'uxOffset' is non-zero, the 'lTail' pointer will
|
||||
* not be advanced.
|
||||
*
|
||||
* @return The count of the bytes read.
|
||||
*/
|
||||
size_t uxStreamBufferGet( StreamBuffer_t * const pxBuffer,
|
||||
size_t uxOffset,
|
||||
uint8_t * const pucData,
|
||||
size_t uxMaxCount,
|
||||
BaseType_t xPeek )
|
||||
{
|
||||
size_t uxCount;
|
||||
|
||||
/* How much data is available? */
|
||||
size_t uxSize = uxStreamBufferGetSize( pxBuffer );
|
||||
|
||||
if( uxSize > uxOffset )
|
||||
{
|
||||
uxSize -= uxOffset;
|
||||
}
|
||||
else
|
||||
{
|
||||
uxSize = 0U;
|
||||
}
|
||||
|
||||
/* Use the minimum of the wanted bytes and the available bytes. */
|
||||
uxCount = FreeRTOS_min_size_t( uxSize, uxMaxCount );
|
||||
|
||||
if( uxCount != 0U )
|
||||
{
|
||||
const size_t uxLength = pxBuffer->LENGTH;
|
||||
size_t uxNextTail = pxBuffer->uxTail;
|
||||
|
||||
if( uxOffset != 0U )
|
||||
{
|
||||
uxNextTail += uxOffset;
|
||||
|
||||
if( uxNextTail >= uxLength )
|
||||
{
|
||||
uxNextTail -= uxLength;
|
||||
}
|
||||
}
|
||||
|
||||
if( pucData != NULL )
|
||||
{
|
||||
/* Calculate the number of bytes that can be read - which may be
|
||||
* less than the number wanted if the data wraps around to the start of
|
||||
* the buffer. */
|
||||
const size_t uxFirst = FreeRTOS_min_size_t( uxLength - uxNextTail, uxCount );
|
||||
|
||||
/* Obtain the number of bytes it is possible to obtain in the first
|
||||
* read. */
|
||||
( void ) pvPortMemCpyStreamBuffer( pucData, &( pxBuffer->ucArray[ uxNextTail ] ), uxFirst );
|
||||
|
||||
/* If the total number of wanted bytes is greater than the number
|
||||
* that could be read in the first read... */
|
||||
if( uxCount > uxFirst )
|
||||
{
|
||||
/* ...then read the remaining bytes from the start of the buffer. */
|
||||
( void ) pvPortMemCpyStreamBuffer( &( pucData[ uxFirst ] ), pxBuffer->ucArray, uxCount - uxFirst );
|
||||
}
|
||||
}
|
||||
|
||||
if( ( xPeek == pdFALSE ) && ( uxOffset == 0U ) )
|
||||
{
|
||||
/* Move the tail pointer to effectively remove the data read from
|
||||
* the buffer. */
|
||||
uxNextTail += uxCount;
|
||||
|
||||
if( uxNextTail >= uxLength )
|
||||
{
|
||||
uxNextTail -= uxLength;
|
||||
}
|
||||
|
||||
pxBuffer->uxTail = uxNextTail;
|
||||
}
|
||||
}
|
||||
|
||||
return uxCount;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
+1048
File diff suppressed because it is too large.
Load diff
Loaded 100 of 1978 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user