diff --git a/arch/arm/aarch64/include/arch_reg.h b/arch/arm/aarch64/include/arch_reg.h index 8d5e44f85a92efa0e5c367401fbf0ffeb939eb49..735b68a443e4ff6af6285c511ef10a8561999f1a 100644 --- a/arch/arm/aarch64/include/arch_reg.h +++ b/arch/arm/aarch64/include/arch_reg.h @@ -74,6 +74,28 @@ #define MAIR_DEVICE_NGNRNE 0x0 #define MAIR_NORMAL_WB_NT 0xFF +/* + * SCTLR_EL3 values + */ +#define SCTLR_EL3_RES1 \ + (FWK_BIT(29) | FWK_BIT(28) | FWK_BIT(23) | FWK_BIT(18) | FWK_BIT(16) | \ + FWK_BIT(5) | FWK_BIT(4)) +#define SCTLR_EL3_RESET SCTLR_EL3_RES1 +#define SCTLR_EL3_NAA FWK_BIT(6) + +/* + * SCR_EL3 values + */ +#define SCR_EL3_RW FWK_BIT(10) + +/* + * SPSR_EL3 values + */ +#define SPSR_EL3_A FWK_BIT(8) +#define SPSR_EL3_I FWK_BIT(7) +#define SPSR_EL3_F FWK_BIT(6) +#define SPSR_EL3_M_EL2H 0b1001 /* EL2 is in handler mode */ + /* * SCTLR_EL2 values */ @@ -120,4 +142,23 @@ #define GICD_ISPENDR(N) (0x0200u + (4 * (N))) #define GICD_ICPENDR(N) (0x0280u + (4 * (N))) +/* + * GIC V2 registers + */ +#define GICC_BASE 0x20000u + +#define FIQ_EN_BIT FWK_BIT(3) +#define CTLR_ENABLE_G0_BIT FWK_BIT(0) + +#define FIQ_BYP_DIS_GRP0 FWK_BIT(5) +#define IRQ_BYP_DIS_GRP0 FWK_BIT(6) +#define FIQ_BYP_DIS_GRP1 FWK_BIT(7) +#define IRQ_BYP_DIS_GRP1 FWK_BIT(8) + +#define GICC_CTLR (0x0) +#define GICC_PMR (0x4) +#define GIC_PRI_MASK (0xff) +#define GICC_IAR (0xC) +#define GICC_EOIR (0x10) + #endif /* ARCH_REG_H */ diff --git a/arch/arm/aarch64/src/arch_crt0.S b/arch/arm/aarch64/src/arch_crt0.S index b791cd85764b7eba30a99a417964ca0c64c83fa9..e17ea72dbecfa45d79e9218eb9c254af77d72117 100644 --- a/arch/arm/aarch64/src/arch_crt0.S +++ b/arch/arm/aarch64/src/arch_crt0.S @@ -30,8 +30,32 @@ arch_exception_reset: b wfe_loop el3_init: - /* TODO */ - b wfe_loop + /* switch to el2 */ + msr SCTLR_EL2, xzr + msr HCR_EL2, xzr + + mrs x0, SCR_EL3 + orr x0, x0, #(SCR_EL3_RW) /* Next lower exception level is AArch64 */ + msr SCR_EL3, x0 + + mrs x0, SPSR_EL3 + orr x0, x0, #(SPSR_EL3_A) /* Mask SError */ + orr x0, x0, #(SPSR_EL3_I) /* Mask IRQ */ + orr x0, x0, #(SPSR_EL3_F) /* Mask FIQ */ + mov x1, #(SPSR_EL3_M_EL2H) /* EL2 is in handler mode */ + orr x0, x0, x1 + msr SPSR_EL3, x0 + + ldr x0, =SCTLR_EL3_RESET + orr x0, x0, #(SCTLR_EL3_NAA) + msr SCTLR_EL3, x0 + + isb + + adr x0, el2_init + msr ELR_EL3, x0 + + eret el2_init: /* Configure exception vectors */ @@ -39,13 +63,6 @@ el2_init: msr vbar_el2, x0 isb - /* Ensure PMSA is present */ - mrs x0, id_aa64mmfr0_el1 - and x1, x0, #ID_AA64MMFR0_EL1_MSA_MASK - cbz x1, wfe_loop - and x1, x0, #ID_AA64MMFR0_EL1_MSA_FRAC_MASK - cbz x1, wfe_loop - /* Initialize HCR */ ldr x0, =HCR_EL2_RESET msr hcr_el2, x0 @@ -57,6 +74,14 @@ el2_init: dsb sy isb + /* Ensure PMSA is present */ + mrs x0, id_aa64mmfr0_el1 + and x1, x0, #ID_AA64MMFR0_EL1_MSA_MASK + cbz x1, no_pmsa_support + and x1, x0, #ID_AA64MMFR0_EL1_MSA_FRAC_MASK + cbz x1, no_pmsa_support + + /* Initial MPU region config */ #if FMW_MEM_MODE == ARCH_MEM_MODE_SINGLE_REGION /* Region 0 */ @@ -90,7 +115,9 @@ el2_init: dsb sy isb - /* Enable PMSA, data cache and instruction cache */ +no_pmsa_support: + + /* Enable PMSA/MMU, data cache and instruction cache */ ldr x0, =SCTLR_EL2_RESET mov x1, #(SCTLR_EL2_M | SCTLR_EL2_C | SCTLR_EL2_I) orr x0, x0, x1 @@ -118,6 +145,10 @@ skip_bss: bl __libc_init_array #endif +#ifdef BUILD_HAS_NOTIFICATION + bl __fwk_notification_reset +#endif + bl arm_main wfe_loop: diff --git a/arch/arm/aarch64/src/arch_gic.c b/arch/arm/aarch64/src/arch_gic.c index 6c5970ccc718fc4f993ca12779fa9929e9d620ef..bab4a256542789c3713cca6326cdf07364b41f8b 100644 --- a/arch/arm/aarch64/src/arch_gic.c +++ b/arch/arm/aarch64/src/arch_gic.c @@ -53,6 +53,7 @@ struct isr_callback { static unsigned int current_iar = INTERRUPT_ID_INVALID; static struct isr_callback callback[INTERRUPT_ID_ISR_LIMIT] = { 0 }; +#ifndef GIC_V2 static uint64_t read_icc_iar0_el1(void) { return READ_SYSREG(icc_iar_el1); @@ -62,12 +63,20 @@ static void write_icc_eoir0_el1(uint64_t value) { return WRITE_SYSREG(icc_eoir0_el1, value); } +#endif void irq_global(void) { struct isr_callback *entry; +#ifdef GIC_V2 + current_iar = fwk_mmio_read_32(FMW_GICD_BASE + GICC_BASE + GICC_IAR); + fwk_mmio_write_32(FMW_GICD_BASE + GICC_BASE + GICC_EOIR, current_iar); + current_iar = current_iar & 0x00000FFFUL; +#else current_iar = read_icc_iar0_el1(); +#endif + if (current_iar >= INTERRUPT_ID_ISR_LIMIT) { return; } @@ -84,7 +93,9 @@ void irq_global(void) } } +#ifndef GIC_V2 write_icc_eoir0_el1(current_iar); +#endif current_iar = INTERRUPT_ID_INVALID; } @@ -293,5 +304,20 @@ bool arch_interrupt_is_interrupt_context(void) int arch_interrupt_init(void) { +#ifdef GIC_V2 + unsigned int val; + + /* + * Enable the Group 0 interrupts, FIQEn and disable Group 0/1 + * bypass. + */ + val = CTLR_ENABLE_G0_BIT | FIQ_EN_BIT | FIQ_BYP_DIS_GRP0; + val |= IRQ_BYP_DIS_GRP0 | FIQ_BYP_DIS_GRP1 | IRQ_BYP_DIS_GRP1; + + /* Program the idle priority in the PMR */ + fwk_mmio_write_32(FMW_GICD_BASE + GICC_BASE + GICC_PMR, GIC_PRI_MASK); + fwk_mmio_write_32(FMW_GICD_BASE + GICC_BASE + GICC_CTLR, val); +#endif + return FWK_SUCCESS; } diff --git a/arch/arm/aarch64/src/arch_main.c b/arch/arm/aarch64/src/arch_main.c index 22ff1ac1b8abbe01a62b62ffadd68d2c62fe2a87..b75b2db53ce323c98b9d3a6a4bc9c6cc6e3ab32a 100644 --- a/arch/arm/aarch64/src/arch_main.c +++ b/arch/arm/aarch64/src/arch_main.c @@ -12,6 +12,15 @@ #include +/* + * Error handler for failures that occur during early initialization. + */ +void panic(void) +{ + while (true) + asm volatile("wfi"); +} + int arm_main(void) { return fwk_arch_init(); diff --git a/arch/arm/armv8-a/include/arch_gic.h b/arch/arm/armv8-a/include/arch_gic.h index 2f77d9317bfd63713494492a525adff85b44b626..10b9b4d9b39599cc18e8f4556d80a277bf5906a2 100644 --- a/arch/arm/armv8-a/include/arch_gic.h +++ b/arch/arm/armv8-a/include/arch_gic.h @@ -129,6 +129,6 @@ #define RCAR_GICV_BASE U(0xF1060000) void gic_init(void); -void irq_global(uint32_t iid); +void irq_global(void); #endif /* ARMV8A_GIC_H */ diff --git a/arch/arm/armv8-a/src/arch_exceptions.S b/arch/arm/armv8-a/src/arch_exceptions.S index 4d7fa27d0079dc66fa69cbf1f09d12d537c582e6..c155e8d3c7534f63ce4cbec71f4f59091fd2ffe3 100644 --- a/arch/arm/armv8-a/src/arch_exceptions.S +++ b/arch/arm/armv8-a/src/arch_exceptions.S @@ -1,14 +1,19 @@ /* * Renesas SCP/MCP Software - * Copyright (c) 2020-2021, Renesas Electronics Corporation. All rights reserved. + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ .globl _vector_table - .globl _freertos_vector_table .extern _entrypoint +.macro ventry label +.align 7 +b \label +.endm + + .section .vectors, "ax" .balign 2048 _vector_table: @@ -19,109 +24,96 @@ _vector_table: * ----------------------------------------------------- */ .org VBAR - b _entrypoint + ventry _entrypoint .org (VBAR + 0x80) - b . + ventry err_exception .org (VBAR + 0x100) - b . + ventry fiq_handler .org (VBAR + 0x180) - b . + ventry err_exception /* ----------------------------------------------------- * Current EL with SPx: 0x200 - 0x400 (at EL3) * ----------------------------------------------------- */ .org (VBAR + 0x200) - b . + ventry err_exception .org (VBAR + 0x280) - b . + ventry err_exception .org (VBAR + 0x300) - b . + ventry fiq_handler .org (VBAR + 0x380) - b . + ventry err_exception /* ----------------------------------------------------- * Lower EL using AArch64 : 0x400 - 0x600 (at EL3) * ----------------------------------------------------- */ .org (VBAR + 0x400) - b . + ventry err_exception .org (VBAR + 0x480) - b . + ventry err_exception .org (VBAR + 0x500) - b . + ventry err_exception .org (VBAR + 0x580) - b . + ventry err_exception /* ----------------------------------------------------- * Lower EL using AArch32 : 0x600 - 0x800 (at EL3) * ----------------------------------------------------- */ .org (VBAR + 0x600) - b . + ventry err_exception .org (VBAR + 0x680) - b . + ventry err_exception .org (VBAR + 0x700) - b . + ventry err_exception .org (VBAR + 0x780) - b . + ventry err_exception -/****************************************************************************** - * Vector table to use when FreeRTOS is running. - *****************************************************************************/ -.set FREERTOS_VBAR, (VBAR+0x0800) - /* ----------------------------------------------------- - * Current EL with SP0 : 0x0 - 0x200 (at EL3) - * ----------------------------------------------------- - */ -.org(FREERTOS_VBAR) -_freertos_vector_table: - b FreeRTOS_SWI_Handler -.org (FREERTOS_VBAR + 0x80) - b FreeRTOS_IRQ_Handler -.org (FREERTOS_VBAR + 0x100) - b FreeRTOS_IRQ_Handler -.org (FREERTOS_VBAR + 0x180) - b . +err_exception: + wfe + b err_exception - /* ----------------------------------------------------- - * Current EL with SPx: 0x200 - 0x400 (at EL3) - * ----------------------------------------------------- - */ -.org (FREERTOS_VBAR + 0x200) - b FreeRTOS_SWI_Handler -.org (FREERTOS_VBAR + 0x280) - b FreeRTOS_IRQ_Handler -.org (FREERTOS_VBAR + 0x300) - b FreeRTOS_IRQ_Handler -.org (FREERTOS_VBAR + 0x380) - b . +fiq_handler: + /* Save registers onto stack */ + str x30, [sp, #-16]! + stp x28, x29, [sp, #-16]! + stp x26, x27, [sp, #-16]! + stp x24, x25, [sp, #-16]! + stp x22, x23, [sp, #-16]! + stp x20, x21, [sp, #-16]! + stp x18, x19, [sp, #-16]! + stp x16, x17, [sp, #-16]! + stp x14, x15, [sp, #-16]! + stp x12, x13, [sp, #-16]! + stp x10, x11, [sp, #-16]! + stp x8, x9, [sp, #-16]! + stp x6, x7, [sp, #-16]! + stp x4, x5, [sp, #-16]! + stp x2, x3, [sp, #-16]! + stp x0, x1, [sp, #-16]! - /* ----------------------------------------------------- - * Lower EL using AArch64 : 0x400 - 0x600 (at EL3) - * ----------------------------------------------------- - */ -.org (FREERTOS_VBAR + 0x400) - b . -.org (FREERTOS_VBAR + 0x480) - b . -.org (FREERTOS_VBAR + 0x500) - b . -.org (FREERTOS_VBAR + 0x580) - b . +.extern irq_global + bl irq_global - /* ----------------------------------------------------- - * Lower EL using AArch32 : 0x600 - 0x800 (at EL3) - * ----------------------------------------------------- - */ -.org (FREERTOS_VBAR + 0x600) - b . -.org (FREERTOS_VBAR + 0x680) - b . -.org (FREERTOS_VBAR + 0x700) - b . -.org (FREERTOS_VBAR + 0x780) - b . + /* Restore registers from stack */ + ldp x0, x1, [sp], #16 + ldp x2, x3, [sp], #16 + ldp x4, x5, [sp], #16 + ldp x6, x7, [sp], #16 + ldp x8, x9, [sp], #16 + ldp x10, x11, [sp], #16 + ldp x12, x13, [sp], #16 + ldp x14, x15, [sp], #16 + ldp x16, x17, [sp], #16 + ldp x18, x19, [sp], #16 + ldp x20, x21, [sp], #16 + ldp x22, x23, [sp], #16 + ldp x24, x25, [sp], #16 + ldp x26, x27, [sp], #16 + ldp x28, x29, [sp], #16 + ldr x30, [sp], #16 - .end + eret diff --git a/arch/arm/armv8-a/src/arch_gic.c b/arch/arm/armv8-a/src/arch_gic.c index d33c09f6e6c31730e142eb6805b130e8bea2baf8..5fd4585e997d3870177742e209c3b1d68ef788bc 100644 --- a/arch/arm/armv8-a/src/arch_gic.c +++ b/arch/arm/armv8-a/src/arch_gic.c @@ -141,13 +141,17 @@ static int add_entry(struct r_tree *rt, uint32_t iid, void *entry, int len) return _add(&rt->root, iid, entry, len, 0); } -void irq_global(uint32_t iid) +void irq_global(void) { struct callback *entry; + uint32_t ulInterruptID; - c_interrupt = iid; + c_interrupt = fwk_mmio_read_32(RCAR_GICC_BASE + GICC_IAR); + fwk_mmio_write_32(RCAR_GICC_BASE + GICC_EOIR, c_interrupt); - entry = (struct callback *)lookup_entry(radix, iid); + ulInterruptID = c_interrupt & 0x00000FFFUL; + + entry = (struct callback *)lookup_entry(radix, ulInterruptID); if (entry != NULL) { if (entry->func) { /* Available callback Function */ diff --git a/arch/arm/common/src/arch.ld.S b/arch/arm/common/src/arch.ld.S index edfb2d125043689754b166374c50b573e1d0fbf8..3c362ae2c86645405390c36d6e5801f1777c9f7d 100644 --- a/arch/arm/common/src/arch.ld.S +++ b/arch/arm/common/src/arch.ld.S @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2015-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2015-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -50,6 +50,9 @@ MEMORY { mem0 (x) : ORIGIN = FMW_MEM0_BASE, LENGTH = FMW_MEM0_SIZE mem1 (rw) : ORIGIN = FMW_MEM1_BASE, LENGTH = FMW_MEM1_SIZE #endif +#ifdef FWM_SYSTEM_RAM + sram (rxw): ORIGIN = FWM_SYSTEM_RAM_BASE, LENGTH = FWM_SYSTEM_RAM_SIZE +#endif } #if FMW_MEM_MODE == ARCH_MEM_MODE_SINGLE_REGION @@ -126,6 +129,16 @@ SECTIONS { __fini_array_end = .; } > r +#ifdef FWM_SYSTEM_RAM + __sram_copy_start__ = .; + .system_ram : { + __system_ram_start__ = .; + *(.system_ram*) + *iic_dvfs.o(.rodata) + __system_ram_end__ = .; + } > sram AT> r +#endif + .rodata : { *(.rodata .rodata.*) } > r diff --git a/framework/include/fwk_macros.h b/framework/include/fwk_macros.h index 316f92b1cad4ed8ece6a971a5b8cbe8b8519cae7..65092b415ab52bf57939ddb1c5f5757efe96932f 100644 --- a/framework/include/fwk_macros.h +++ b/framework/include/fwk_macros.h @@ -1,6 +1,6 @@ /* * Arm SCP/MCP Software - * Copyright (c) 2015-2024, Arm Limited and Contributors. All rights reserved. + * Copyright (c) 2015-2025, Arm Limited and Contributors. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause * @@ -470,6 +470,18 @@ #endif +/*! + * \brief Import an assembly or linker symbol as a C expression + * + * \param[in] type type of the C variable to create + * \param[in] sym name of the symbol to import + * \param[in] name name of the C variable to create + * + */ +#define IMPORT_SYM(type, sym, name) \ + extern char sym[]; \ + static const __attribute__((unused)) type name = (type)sym; + /*! * \} */ diff --git a/product/rcar/include/fmw_gic.h b/product/rcar/include/fmw_gic.h new file mode 100644 index 0000000000000000000000000000000000000000..18012b652eabba9abfb59b1d8a3c08aea7616fed --- /dev/null +++ b/product/rcar/include/fmw_gic.h @@ -0,0 +1,17 @@ +/* + * Renesas SCP/MCP Software + * Copyright (c) 2025, Renesas Electronics Corporation. All rights + * reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#ifndef FMW_GIC_H +#define FMW_GIC_H + +#define GIC_V2 + +#define FMW_GICD_BASE (0xF1010000) +#define FMW_GICR_BASE (0xF1000000) + +#endif /* FMW_GIC_H */ diff --git a/product/rcar/include/rcar_mmap_scp.h b/product/rcar/include/rcar_mmap_scp.h index 30019d3e87b6e3c7e6786d9ef219089b41440696..509934b6efcddc4e4369631d1d03e482b7c845bd 100644 --- a/product/rcar/include/rcar_mmap_scp.h +++ b/product/rcar/include/rcar_mmap_scp.h @@ -1,6 +1,6 @@ /* * Renesas SCP/MCP Software - * Copyright (c) 2020-2021, Renesas Electronics Corporation. All rights + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights * reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -11,5 +11,6 @@ #define SCP_ROM_BASE 0x00000000 #define SCP_RAM_BASE 0x44200000 +#define SCP_SRAM_BASE 0xE6302000 #endif /* RCAR_MMAP_SCP_H */ diff --git a/product/rcar/include/system_mmap_scp.h b/product/rcar/include/system_mmap_scp.h index 942a2c88836066ee1ca9eae99b39e4f82ed93e38..badfb7cf540facb39d1d38088936daf2070b1a5d 100644 --- a/product/rcar/include/system_mmap_scp.h +++ b/product/rcar/include/system_mmap_scp.h @@ -1,6 +1,6 @@ /* * Renesas SCP/MCP Software - * Copyright (c) 2020-2021, Renesas Electronics Corporation. All rights + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights * reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -13,5 +13,6 @@ #define SCP_ROM_SIZE (64 * 1024) /* for SCP romfw */ #define SCP_RAM_SIZE (384 * 1024) /* for SCP ramfw */ +#define SCP_SRAM_SIZE (4 * 1024) /* for SCP sramfw */ #endif /* SYSTEM_MMAP_SCP_H */ diff --git a/product/rcar/module/rcar_arch_timer/src/mod_rcar_arch_timer.c b/product/rcar/module/rcar_arch_timer/src/mod_rcar_arch_timer.c index c532803b720e3bbbf42a7ac7626ebcc17e1a4177..5a4024daca15aad0fdede8685eba79ef1ab97d44 100644 --- a/product/rcar/module/rcar_arch_timer/src/mod_rcar_arch_timer.c +++ b/product/rcar/module/rcar_arch_timer/src/mod_rcar_arch_timer.c @@ -45,7 +45,7 @@ static uint64_t mod_arch_timer_get_counter(void) { uint64_t counter; - counter = read_cntpct_el0(); + counter = READ_SYSREG(cntpct_el0); return counter; } @@ -58,9 +58,9 @@ static int enable(fwk_id_t dev_id) { uint32_t cntp_ctl; - cntp_ctl = read_cntp_ctl_el0() & ~CNTBASE_P_CTL_IMASK; + cntp_ctl = READ_SYSREG(cntp_ctl_el0) & ~CNTBASE_P_CTL_IMASK; cntp_ctl |= CNTBASE_P_CTL_ENABLE; - write_cntp_ctl_el0(cntp_ctl); + WRITE_SYSREG(cntp_ctl_el0, cntp_ctl); return FWK_SUCCESS; } @@ -69,9 +69,10 @@ static int disable(fwk_id_t dev_id) { uint32_t cntp_ctl; - cntp_ctl = read_cntp_ctl_el0() | CNTBASE_P_CTL_IMASK; + cntp_ctl = READ_SYSREG(cntp_ctl_el0); + cntp_ctl |= CNTBASE_P_CTL_IMASK; cntp_ctl &= ~CNTBASE_P_CTL_ENABLE; - write_cntp_ctl_el0(cntp_ctl); + WRITE_SYSREG(cntp_ctl_el0, cntp_ctl); return FWK_SUCCESS; } @@ -94,21 +95,21 @@ static int set_timer(fwk_id_t dev_id, uint64_t timestamp) timestamp = FWK_MAX(counter + GTIMER_MIN_TIMESTAMP, timestamp); - write_cntp_cval_el0(timestamp); + WRITE_SYSREG(cntp_cval_el0, timestamp); return FWK_SUCCESS; } static int get_timer(fwk_id_t dev_id, uint64_t *timestamp) { - *timestamp = read_cntp_cval_el0(); + *timestamp = READ_SYSREG(cntp_cval_el0); return FWK_SUCCESS; } static int get_frequency(fwk_id_t dev_id, uint32_t *frequency) { - *frequency = read_cntfrq_el0(); + *frequency = READ_SYSREG(cntfrq_el0); return FWK_SUCCESS; } @@ -167,7 +168,7 @@ static int arch_timer_process_bind_request(fwk_id_t requester_id, static void arch_timer_control_init(void) { /* Disable & Imask */ - write_cntp_ctl_el0(CNTBASE_P_CTL_IMASK); + WRITE_SYSREG(cntp_ctl_el0, CNTBASE_P_CTL_IMASK); } static int arch_timer_start(fwk_id_t id) @@ -228,7 +229,7 @@ static fwk_timestamp_t mod_arch_timer_timestamp(const void *ctx) { fwk_timestamp_t timestamp; - uint32_t frequency = read_cntfrq_el0(); + uint32_t frequency = READ_SYSREG(cntfrq_el0); uint64_t counter = mod_arch_timer_get_counter(); timestamp = (FWK_S(1) / frequency) * counter; diff --git a/product/rcar/module/rcar_clock/include/mod_rcar_clock.h b/product/rcar/module/rcar_clock/include/mod_rcar_clock.h index b4cdc11fdbe5c30eaf6bf7eecb1bb3df4f033ddd..be313e7985bb6eb5a7b043ab698b3cad6e42e662 100644 --- a/product/rcar/module/rcar_clock/include/mod_rcar_clock.h +++ b/product/rcar/module/rcar_clock/include/mod_rcar_clock.h @@ -1,6 +1,6 @@ /* * Renesas SCP/MCP Software - * Copyright (c) 2020-2022, Renesas Electronics Corporation. All rights + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights * reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -12,11 +12,11 @@ #define MOD_RCAR_CLOCK_H #include -#include #include #include +#include #include @@ -371,8 +371,8 @@ struct op_points { #define CPG_PLLECR 0x00D0 /* Implementation for customized clocks (Z-clk, Z2-clk, PLL0-clk) for CPUFreq */ -#define CPG_PLLECR_PLL0ST BIT(8) -#define CPG_PLLECR_PLL2ST BIT(10) +#define CPG_PLLECR_PLL0ST FWK_BIT(8) +#define CPG_PLLECR_PLL2ST FWK_BIT(10) /* Define for PLL0 clk driver */ #define CPG_PLLCR_STC_MASK 0x7f000000 diff --git a/product/rcar/module/rcar_mstp_clock/src/mod_rcar_mstp_clock.c b/product/rcar/module/rcar_mstp_clock/src/mod_rcar_mstp_clock.c index 33c719e64e9448a327444854d0c4c685d4073669..22d99e96942765128c2643b8c3bd8b2b29029185 100644 --- a/product/rcar/module/rcar_mstp_clock/src/mod_rcar_mstp_clock.c +++ b/product/rcar/module/rcar_mstp_clock/src/mod_rcar_mstp_clock.c @@ -1,13 +1,12 @@ /* * Renesas SCP/MCP Software - * Copyright (c) 2020-2024, Renesas Electronics Corporation. All rights + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights * reserved. * * SPDX-License-Identifier: BSD-3-Clause */ #include -#include #include #include @@ -16,6 +15,7 @@ #include #include +#include #include #include #include @@ -41,9 +41,9 @@ static int mstp_clock_set_state( value = fwk_mmio_read_32(CPG_BASE + smstpcr[ctx->config->control_reg]); if (MOD_CLOCK_STATE_RUNNING == target_state) - value &= ~(BIT(ctx->config->bit)); + value &= ~(FWK_BIT(ctx->config->bit)); else - value |= BIT(ctx->config->bit); + value |= FWK_BIT(ctx->config->bit); fwk_mmio_write_32((CPG_BASE + smstpcr[ctx->config->control_reg]), value); @@ -51,7 +51,7 @@ static int mstp_clock_set_state( for (i = 1000; i > 0; --i) { if (!(fwk_mmio_read_32( CPG_BASE + mstpsr[ctx->config->control_reg]) & - BIT(ctx->config->bit))) + FWK_BIT(ctx->config->bit))) break; } @@ -78,7 +78,7 @@ static void mstp_clock_hw_initial_set_state( { /* Maintain clock supply at startup. */ if (module_ctx.mstp_init->smstpcr_init[ctx->config->control_reg] & - BIT(ctx->config->bit)) + FWK_BIT(ctx->config->bit)) ctx->current_state = MOD_CLOCK_STATE_STOPPED; else ctx->current_state = MOD_CLOCK_STATE_RUNNING; diff --git a/product/rcar/module/rcar_pd_core/src/mod_rcar_pd_core.c b/product/rcar/module/rcar_pd_core/src/mod_rcar_pd_core.c index a741d03c110fa35fa3dd12ee9ad17f09fbd39055..d6841e43501a7adbf555c244d2d44946a239a8f3 100644 --- a/product/rcar/module/rcar_pd_core/src/mod_rcar_pd_core.c +++ b/product/rcar/module/rcar_pd_core/src/mod_rcar_pd_core.c @@ -1,11 +1,12 @@ /* * Renesas SCP/MCP Software - * Copyright (c) 2020-2024, Renesas Electronics Corporation. All rights + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights * reserved. * * SPDX-License-Identifier: BSD-3-Clause */ +#include #include #include @@ -23,8 +24,6 @@ #include #include -#include - #include static struct rcar_pd_sysc_ctx rcar_pd_sysc_ctx; diff --git a/product/rcar/module/rcar_reg_sensor/include/mod_rcar_reg_sensor.h b/product/rcar/module/rcar_reg_sensor/include/mod_rcar_reg_sensor.h index 75593681a0b5ef0a61b2262ae973714d75584d97..a29c96fae31a9c9967d4ae5f3d6451e6e552c657 100644 --- a/product/rcar/module/rcar_reg_sensor/include/mod_rcar_reg_sensor.h +++ b/product/rcar/module/rcar_reg_sensor/include/mod_rcar_reg_sensor.h @@ -1,6 +1,6 @@ /* * Renesas SCP/MCP Software - * Copyright (c) 2020-2021, Renesas Electronics Corporation. All rights + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights * reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -9,10 +9,10 @@ #ifndef MOD_RCAR_REG_SENSOR_H #define MOD_RCAR_REG_SENSOR_H -#include - #include +#include + #include /*! @@ -73,8 +73,8 @@ enum mod_rcar_reg_sensor_api_type { #define NEXT_REG_OFFSET (4) /* THCTR bits */ -#define THCTR_PONM BIT(6) -#define THCTR_THSST BIT(0) +#define THCTR_PONM FWK_BIT(6) +#define THCTR_THSST FWK_BIT(0) #define CTEMP_MASK (0xFFF) #define MCELSIUS(temp) ((temp)*1000) diff --git a/product/rcar/module/rcar_reset/src/mod_rcar_reset.c b/product/rcar/module/rcar_reset/src/mod_rcar_reset.c index a495f88666bc1bd06a6f9b8721826a756a089494..07a4c045587884b05290cb5393d4312b13e7d5e1 100644 --- a/product/rcar/module/rcar_reset/src/mod_rcar_reset.c +++ b/product/rcar/module/rcar_reset/src/mod_rcar_reset.c @@ -1,13 +1,11 @@ /* * Renesas SCP/MCP Software - * Copyright (c) 2020-2024, Renesas Electronics Corporation. All rights + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights * reserved. * * SPDX-License-Identifier: BSD-3-Clause */ -#include - #include #include @@ -42,14 +40,15 @@ static int rcar_auto_domain(fwk_id_t dev_id, uint32_t state) ctx = module_ctx.dev_ctx_table + fwk_id_get_element_idx(dev_id); fwk_mmio_write_32( - (CPG_BASE + srcr[ctx->config->control_reg]), BIT(ctx->config->bit)); + (CPG_BASE + srcr[ctx->config->control_reg]), FWK_BIT(ctx->config->bit)); /* Wait for at least one cycle of the RCLK clock (@ ca. 32 kHz) */ udelay(SCSR_DELAY_US); /* Release module from reset state */ fwk_mmio_write_32( - (CPG_BASE + SRSTCLR(ctx->config->control_reg)), BIT(ctx->config->bit)); + (CPG_BASE + SRSTCLR(ctx->config->control_reg)), + FWK_BIT(ctx->config->bit)); return FWK_SUCCESS; } @@ -61,7 +60,7 @@ static int rcar_assert_domain(fwk_id_t dev_id) ctx = module_ctx.dev_ctx_table + fwk_id_get_element_idx(dev_id); fwk_mmio_write_32( - (CPG_BASE + srcr[ctx->config->control_reg]), BIT(ctx->config->bit)); + (CPG_BASE + srcr[ctx->config->control_reg]), FWK_BIT(ctx->config->bit)); return FWK_SUCCESS; } @@ -73,7 +72,8 @@ static int rcar_deassert_domain(fwk_id_t dev_id) ctx = module_ctx.dev_ctx_table + fwk_id_get_element_idx(dev_id); fwk_mmio_write_32( - (CPG_BASE + SRSTCLR(ctx->config->control_reg)), BIT(ctx->config->bit)); + (CPG_BASE + SRSTCLR(ctx->config->control_reg)), + FWK_BIT(ctx->config->bit)); return FWK_SUCCESS; } diff --git a/product/rcar/module/rcar_sd_clock/include/mod_rcar_sd_clock.h b/product/rcar/module/rcar_sd_clock/include/mod_rcar_sd_clock.h index 6d09eabdf42c3f0640fb060c38fccb8faaa0fab7..6481137231f4f38c019d6b954bc5bdd2df1cde0d 100644 --- a/product/rcar/module/rcar_sd_clock/include/mod_rcar_sd_clock.h +++ b/product/rcar/module/rcar_sd_clock/include/mod_rcar_sd_clock.h @@ -1,6 +1,6 @@ /* * Renesas SCP/MCP Software - * Copyright (c) 2020-2021, Renesas Electronics Corporation. All rights + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights * reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -150,8 +150,8 @@ struct rcar_gen3_cpg_pll_config { #define CPG_FRQCRB_ZTRD2FC_12 0x5 #define CPG_PLL_CONFIG_INDEX(md) \ - ((((md)&BIT(14)) >> 11) | (((md)&BIT(13)) >> 11) | \ - (((md)&BIT(19)) >> 18) | (((md)&BIT(17)) >> 17)) + ((((md)&FWK_BIT(14)) >> 11) | (((md)&FWK_BIT(13)) >> 11) | \ + (((md)&FWK_BIT(19)) >> 18) | (((md)&FWK_BIT(17)) >> 17)) static const struct rcar_gen3_cpg_pll_config cpg_pll_configs[16] = { /* EXTAL div PLL1 mult/div PLL3 mult/div OSC prediv */ diff --git a/product/rcar/module/rcar_sd_clock/src/mod_rcar_sd_clock.c b/product/rcar/module/rcar_sd_clock/src/mod_rcar_sd_clock.c index 3177c8627dfa6db469ddf9fbc51dbb5ae2d02979..da80f4da4219d2e89456a9dba6e17879ca033d99 100644 --- a/product/rcar/module/rcar_sd_clock/src/mod_rcar_sd_clock.c +++ b/product/rcar/module/rcar_sd_clock/src/mod_rcar_sd_clock.c @@ -1,6 +1,6 @@ /* * Renesas SCP/MCP Software - * Copyright (c) 2020-2024, Renesas Electronics Corporation. All rights + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights * reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -167,9 +167,9 @@ static int sd_clock_set_state( value = fwk_mmio_read_32(ctx->config->control_reg); if (MOD_CLOCK_STATE_RUNNING == target_state) - value &= ~(BIT(ctx->config->stop_clk_bit)); + value &= ~(FWK_BIT(ctx->config->stop_clk_bit)); else - value |= BIT(ctx->config->stop_clk_bit); + value |= FWK_BIT(ctx->config->stop_clk_bit); fwk_mmio_write_32(ctx->config->control_reg, value); @@ -232,7 +232,7 @@ static int sd_clock_hw_initial_set_state( ctx->current_state = MOD_CLOCK_STATE_RUNNING; if (ctx->config->stop_clk) { if (fwk_mmio_read_32(ctx->config->control_reg) & - BIT(ctx->config->stop_clk_bit)) + FWK_BIT(ctx->config->stop_clk_bit)) ctx->current_state = MOD_CLOCK_STATE_STOPPED; } /* Holds clock frequency at startup. */ diff --git a/product/rcar/module/rcar_system/CMakeLists.txt b/product/rcar/module/rcar_system/CMakeLists.txt index b7946a421de5d4dc1b60c0034832d11bac29af84..3599d3647c0fbec246c6bc2b9a7a69a14542a7d3 100644 --- a/product/rcar/module/rcar_system/CMakeLists.txt +++ b/product/rcar/module/rcar_system/CMakeLists.txt @@ -1,6 +1,6 @@ # # Arm SCP/MCP Software -# Copyright (c) 2021-2022, Arm Limited and Contributors. All rights reserved. +# Copyright (c) 2021-2025, Arm Limited and Contributors. All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # @@ -13,7 +13,6 @@ target_include_directories(${SCP_MODULE_TARGET} target_sources( ${SCP_MODULE_TARGET} PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src/rcar_pwc.c" - "${CMAKE_CURRENT_SOURCE_DIR}/src/FreeRTOS_tick_config.c" "${CMAKE_CURRENT_SOURCE_DIR}/src/rcar_iic_dvfs.c" "${CMAKE_CURRENT_SOURCE_DIR}/src/mod_rcar_system.c" "${CMAKE_CURRENT_SOURCE_DIR}/src/rcar_common.c" diff --git a/product/rcar/module/rcar_system/src/FreeRTOS_tick_config.c b/product/rcar/module/rcar_system/src/FreeRTOS_tick_config.c deleted file mode 100644 index 380bb62fe699ab3d7fe21ef0ee5e2d8299a2f1be..0000000000000000000000000000000000000000 --- a/product/rcar/module/rcar_system/src/FreeRTOS_tick_config.c +++ /dev/null @@ -1,160 +0,0 @@ -/* - * Renesas SCP/MCP Software - * Copyright (c) 2020-2024, Renesas Electronics Corporation. All rights - * reserved. - * - * SPDX-License-Identifier: BSD-3-Clause - */ - -#include "FreeRTOS.h" -#include "arch_gic.h" -#include "rcar_irq.h" -#include "rcar_mmap.h" -#include "task.h" - -#include - -uint32_t c_interrupt; - -/* ARM Generic Timer */ -#define CORE0_TIMER_IRQCNTL ((volatile uint32_t *)(0x40000040)) -static uint32_t timer_cntfrq = 0; -static uint32_t timer_tick = 0; - -static void init_generic_timer(void) -{ - uint32_t reg; - uint32_t reg_cntfid; - uint32_t modemr; - uint32_t modemr_pll; - - const uint32_t pll_table[] = { - EXTAL_MD14_MD13_TYPE_0, /* MD14/MD13 : 0b00 */ - EXTAL_MD14_MD13_TYPE_1, /* MD14/MD13 : 0b01 */ - EXTAL_MD14_MD13_TYPE_2, /* MD14/MD13 : 0b10 */ - EXTAL_MD14_MD13_TYPE_3 /* MD14/MD13 : 0b11 */ - }; - - modemr = fwk_mmio_read_32(RCAR_MODEMR); - modemr_pll = (modemr & MODEMR_BOOT_PLL_MASK); - - /* Set frequency data in CNTFID0 */ - reg_cntfid = pll_table[modemr_pll >> MODEMR_BOOT_PLL_SHIFT]; - reg = fwk_mmio_read_32(RCAR_PRR) & (RCAR_PRODUCT_MASK | RCAR_CUT_MASK); - switch (modemr_pll) { - case MD14_MD13_TYPE_0: -#ifdef SALVATORE_XS - reg_cntfid = EXTAL_SALVATOR_XS; -#endif - break; - case MD14_MD13_TYPE_3: - if (RCAR_PRODUCT_H3_CUT10 == reg) { - reg_cntfid = reg_cntfid >> 1U; - } - break; - default: - /* none */ - break; - } - /* Update memory mapped and register based freqency */ - __asm__ volatile("msr cntfrq_el0, %0" ::"r"(reg_cntfid)); -} - -void disable_cntv(void) -{ - uint32_t cntv_ctl; - cntv_ctl = 0; - __asm__ volatile("msr cntv_ctl_el0, %0" ::"r"(cntv_ctl)); -} -/*-----------------------------------------------------------*/ - -void enable_cntv(void) -{ - uint32_t cntv_ctl; - cntv_ctl = 1; - __asm__ volatile("msr cntv_ctl_el0, %0" ::"r"(cntv_ctl)); -} -/*-----------------------------------------------------------*/ - -void write_cntv_tval(uint32_t val) -{ - __asm__ volatile("msr cntv_tval_el0, %0" ::"r"(val)); - return; -} -/*-----------------------------------------------------------*/ - -uint32_t read_cntfrq(void) -{ - uint32_t val; - __asm__ volatile("mrs %0, cntfrq_el0" : "=r"(val)); - return val; -} -/*-----------------------------------------------------------*/ - -uint32_t read_cntv_tval(void) -{ - uint32_t val; - __asm__ volatile("mrs %0, cntvct_el0" : "=r"(val)); - return val; -} -/*-----------------------------------------------------------*/ - -void init_timer(void) -{ - timer_cntfrq = timer_tick = read_cntfrq(); - /* clear cntv interrupt and set next 1 sec timer. */ - write_cntv_tval(timer_cntfrq); - return; -} -/*-----------------------------------------------------------*/ - -void timer_set_tick_rate_hz(uint32_t rate) -{ - timer_tick = timer_cntfrq / rate; - write_cntv_tval(timer_tick); -} -/*-----------------------------------------------------------*/ - -void vConfigureTickInterrupt(void) -{ - /* disable timer */ - disable_cntv(); - - /* init timer device. */ - init_generic_timer(); - init_timer(); - - /* set tick rate. */ - timer_set_tick_rate_hz(configTICK_RATE_HZ); - - /* start & enable interrupts in the timer. */ - enable_cntv(); -} -/*-----------------------------------------------------------*/ - -void vClearTickInterrupt(void) -{ - /* clear cntv interrupt and set next timer. */ - write_cntv_tval(timer_tick); - return; -} -/*-----------------------------------------------------------*/ - -void vApplicationIRQHandler(void) -{ - uint32_t ulInterruptID; - - c_interrupt = fwk_mmio_read_32(RCAR_GICC_BASE + GICC_IAR); - fwk_mmio_write_32(RCAR_GICC_BASE + GICC_EOIR, c_interrupt); - ulInterruptID = c_interrupt & 0x00000FFFUL; - - /* call handler function */ - if (ulInterruptID == VIRTUAL_TIMER_IRQ) { - /* Generic Timer */ - FreeRTOS_Tick_Handler(); - } else { - /* Peripherals */ - irq_global(ulInterruptID); - } - c_interrupt = 0; -} diff --git a/product/rcar/module/rcar_system/src/mod_rcar_system.c b/product/rcar/module/rcar_system/src/mod_rcar_system.c index 708631016b3fea233cf793de23fc8998e672ef72..b299c2ef9dbece8170e6b77c2977b5de02473097 100644 --- a/product/rcar/module/rcar_system/src/mod_rcar_system.c +++ b/product/rcar/module/rcar_system/src/mod_rcar_system.c @@ -6,6 +6,7 @@ * SPDX-License-Identifier: BSD-3-Clause */ +#include #include #include #include @@ -32,9 +33,7 @@ #include #include -#include #include -#include /* Device context */ struct rcar_system_dev_ctx { @@ -118,59 +117,6 @@ void rcar_system_code_copy_to_system_ram(void) (SYSTEM_RAM_END - SYSTEM_RAM_START)); } -int _platform_init(void *params) -{ - rcar_system_code_copy_to_system_ram(); - return FWK_SUCCESS; -} - -void vApplicationIdleHook(void) -{ - uint32_t req; - struct rcar_system_dev_ctx *ctx; - fwk_id_t element_id = FWK_ID_ELEMENT_INIT(FWK_MODULE_IDX_CLOCK, 0); - uint32_t i; - unsigned int flags; - - if (is_available_shutdown_req(P_STATUS)) { - flags = fwk_interrupt_global_disable(); - req = P_STATUS; - P_STATUS = R_CLEAR; - switch (req) { - case R_SUSPEND: - _boot_flag = R_WARMBOOT; - while (!(fwk_mmio_read_32(RCAR_CA57PSTR) & 0x0f)) - continue; - - _save_system(); - - rcar_system_code_copy_to_system_ram(); - - for (i = 0; i < module_ctx.dev_count; i++) { - element_id.element.element_idx = i; - ctx = module_ctx.dev_ctx_table + - fwk_id_get_element_idx(element_id); - if (ctx->api->resume) - ctx->api->resume(); - } - - messaging_stack_ready(); - gic_init(); - vConfigureTickInterrupt(); - fwk_interrupt_global_enable(flags); - break; - case R_RESET: - rcar_system_reset(); - break; - case R_OFF: - rcar_system_off(); - break; - default: - break; - } - } -} - /* * Functions fulfilling the framework's module interface */ @@ -204,6 +150,8 @@ static int rcar_system_init( unsigned int element_count, const void *data) { + rcar_system_code_copy_to_system_ram(); + module_ctx.dev_count = element_count; if (element_count == 0) diff --git a/product/rcar/module/rcar_system/src/rcar_call_sram.S b/product/rcar/module/rcar_system/src/rcar_call_sram.S index 43e8cdb5972f68703bc30fdaf56484cd39dd433f..b7ced541d02e63d107d67b6235b0e6515a8864cd 100644 --- a/product/rcar/module/rcar_system/src/rcar_call_sram.S +++ b/product/rcar/module/rcar_system/src/rcar_call_sram.S @@ -1,14 +1,64 @@ /* * Renesas SCP/MCP Software - * Copyright (c) 2020-2021, Renesas Electronics Corporation. All rights reserved. + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ -#include - .global rcar_pwrc_switch_stack +/* + * Create a variable in assembly to ensure that its value is not initialized in + * case of suspend/resume. +*/ +.globl _shutdown_request + + .align 4 +_shutdown_request: + .long 0 + +/* + * This macro is used to create a function label and place the + * code into a separate text section based on the function name + * to enable elimination of unused code during linking. It also adds + * basic debug information to enable call stack printing most of the + * time. The optional _align parameter can be used to force a + * non-standard alignment (indicated in powers of 2). The default is + * _align=2 because both Aarch32 and Aarch64 instructions must be + * word aligned. Do *not* try to use a raw .align directive. Since func + * switches to a new section, this would not have the desired effect. + */ +.macro func _name, _align=2 +/* + * Add Call Frame Information entry in the .debug_frame section for + * debugger consumption. This enables callstack printing in debuggers. + * This does not use any space in the final loaded binary, only in the + * ELF file. + * Note that a function manipulating the CFA pointer location (i.e. the + * x29 frame pointer on AArch64) should declare it using the + * appropriate .cfi* directives, or be prepared to have a degraded + * debugging experience. + */ +.cfi_sections .debug_frame +.section .text.asm.\_name, "ax" +.type \_name, %function +/* + * .cfi_startproc and .cfi_endproc are needed to output entries in + * .debug_frame + */ +.cfi_startproc +.align \_align +\_name: +.endm + +/* + * This macro is used to mark the end of a function. + */ +.macro endfunc _name +.cfi_endproc +.size \_name, . - \_name +.endm + /* * x0 : jump address, * x1 : stack address, diff --git a/product/rcar/module/rcar_system/src/rcar_pwc.c b/product/rcar/module/rcar_system/src/rcar_pwc.c index 5880aafcbcaba29c1e3b48a280de76e0ba361bbc..51501e7c9edba22b895dd127ddf1522429fde94d 100644 --- a/product/rcar/module/rcar_system/src/rcar_pwc.c +++ b/product/rcar/module/rcar_system/src/rcar_pwc.c @@ -182,7 +182,7 @@ void FWK_SECTION(".system_ram") FWK_NOINLINE rcar_pwrc_go_suspend_to_ram(void) } } - wfi(); + asm volatile("wfi"); while (1) continue; @@ -195,9 +195,9 @@ void rcar_pwrc_set_suspend_to_ram(void) uint32_t sctlr; /* disable MMU */ - sctlr = (uint32_t)read_sctlr_el3(); + sctlr = (uint32_t)READ_SYSREG(sctlr_el3); sctlr &= (uint32_t)~SCTLR_EL3_M_BIT; - write_sctlr_el3((uint64_t)sctlr); + WRITE_SYSREG(sctlr_el3, (uint64_t)sctlr); rcar_pwrc_switch_stack(jump, stack, NULL); } diff --git a/product/rcar/scp_ramfw/CMakeLists.txt b/product/rcar/scp_ramfw/CMakeLists.txt index c4393139f1eee93494e5009c7bb28d4513f62e12..86227b2c4e5c97befe63ab5c18bbc02da858a868 100644 --- a/product/rcar/scp_ramfw/CMakeLists.txt +++ b/product/rcar/scp_ramfw/CMakeLists.txt @@ -1,6 +1,6 @@ # # Arm SCP/MCP Software -# Copyright (c) 2021-2024, Arm Limited and Contributors. All rights reserved. +# Copyright (c) 2021-2025, Arm Limited and Contributors. All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # @@ -14,17 +14,11 @@ add_executable(rcar-bl2) target_include_directories( rcar-bl2 PUBLIC - "${CMAKE_CURRENT_SOURCE_DIR}/../src/CMSIS-FreeRTOS/Source/include" - "${CMAKE_CURRENT_SOURCE_DIR}/../src/CMSIS-FreeRTOS/Source/portable/GCC/ARM_CA53_64_Rcar" "${CMAKE_CURRENT_SOURCE_DIR}/../include" "${CMAKE_CURRENT_SOURCE_DIR}") # cmake-lint: disable=E1122 -set(freertos_source "${CMAKE_CURRENT_SOURCE_DIR}/../src/CMSIS-FreeRTOS/Source") -set(freertos2_source - "${CMAKE_CURRENT_SOURCE_DIR}/../src/CMSIS-FreeRTOS/CMSIS/RTOS2/FreeRTOS/Source") - target_sources( rcar-bl2 PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/config_rcar_scif.c" @@ -54,15 +48,8 @@ target_sources( "${CMAKE_CURRENT_SOURCE_DIR}/config_rcar_system_power.c" "${CMAKE_CURRENT_SOURCE_DIR}/config_rcar_system.c" "${CMAKE_CURRENT_SOURCE_DIR}/config_sds.c" - "${CMAKE_CURRENT_SOURCE_DIR}/../src/rcar_core.c" - "${freertos_source}/timers.c" - "${freertos_source}/list.c" - "${freertos_source}/queue.c" - "${freertos_source}/tasks.c" - "${freertos_source}/portable/MemMang/heap_1.c" - "${freertos_source}/portable/GCC/ARM_CA53_64_Rcar/portASM.S" - "${freertos_source}/portable/GCC/ARM_CA53_64_Rcar/port.c" - "${freertos2_source}/cmsis_os2_tiny4scp.c") + "${CMAKE_CURRENT_SOURCE_DIR}/rcar_libc.c" + "${CMAKE_CURRENT_SOURCE_DIR}/../src/rcar_core.c") if(SCP_ENABLE_RESOURCE_PERMISSIONS) target_sources(rcar-bl2 diff --git a/product/rcar/scp_ramfw/Firmware.cmake b/product/rcar/scp_ramfw/Firmware.cmake index 9f97e4455b2056ff251621304de9a552108fc62f..91b62b8b76d8c898e4c6469e5f090e0e1fc0e5a1 100644 --- a/product/rcar/scp_ramfw/Firmware.cmake +++ b/product/rcar/scp_ramfw/Firmware.cmake @@ -1,6 +1,6 @@ # # Arm SCP/MCP Software -# Copyright (c) 2021-2023, Arm Limited and Contributors. All rights reserved. +# Copyright (c) 2021-2025, Arm Limited and Contributors. All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # @@ -17,6 +17,8 @@ set(SCP_TOOLCHAIN_INIT "GNU") set(SCP_GENERATE_FLAT_BINARY_INIT TRUE) +set(SCP_ENABLE_MULTITHREADING_INIT FALSE) + set(SCP_ENABLE_NOTIFICATIONS_INIT TRUE) set(SCP_ENABLE_SCMI_RESET_INIT TRUE) @@ -25,7 +27,9 @@ set(SCP_ENABLE_IPO_INIT FALSE) set(SCP_ENABLE_OUTBAND_MSG_SUPPORT_INIT TRUE) -set(SCP_ARCHITECTURE "armv8-a") +set(SCP_HAVE_NEWLIB FALSE) + +set(SCP_ARCHITECTURE "aarch64") list(PREPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_LIST_DIR}/../module/rcar_arch_timer") list(PREPEND SCP_MODULE_PATHS "${CMAKE_CURRENT_LIST_DIR}/../module/rcar_reset") diff --git a/product/rcar/scp_ramfw/FreeRTOSConfig.h b/product/rcar/scp_ramfw/FreeRTOSConfig.h deleted file mode 100644 index 2b0707392b8b68c841133f28638cf78d16b41178..0000000000000000000000000000000000000000 --- a/product/rcar/scp_ramfw/FreeRTOSConfig.h +++ /dev/null @@ -1,50 +0,0 @@ -/* - * Renesas SCP/MCP Software - * Copyright (c) 2020-2021, Renesas Electronics Corporation. All rights - * reserved. - * - * SPDX-License-Identifier: BSD-3-Clause - */ - -#ifndef FREERTOS_CONFIG_H -#define FREERTOS_CONFIG_H - -#define configUSE_IDLE_HOOK 1 -#define configUSE_TICK_HOOK 0 -#define configMINIMAL_STACK_SIZE ((unsigned short)200) -#define configTOTAL_HEAP_SIZE ((size_t)(20 * 1024)) - -/* Software timer definitions. */ -#define configUSE_TIMERS 1 -#define configTIMER_TASK_PRIORITY (configMAX_PRIORITIES - 1) -#define configTIMER_QUEUE_LENGTH 5 -#define configTIMER_TASK_STACK_DEPTH (configMINIMAL_STACK_SIZE * 2) - -/* Set the following definitions to 1 to include the API function, or zero -to exclude the API function. */ -#define INCLUDE_vTaskDelay 1 - -#define INCLUDE_xSemaphoreGetMutexHolder 1 - -void vConfigureTickInterrupt(void); -#define configSETUP_TICK_INTERRUPT() vConfigureTickInterrupt() -void vClearTickInterrupt(void); -#define configCLEAR_TICK_INTERRUPT() vClearTickInterrupt() - -/* Defines needed by FreeRTOS to implement CMSIS RTOS2 API. Do not change! */ -#define configTICK_RATE_HZ ((TickType_t)1000 /* 1ms */) -#define configSUPPORT_STATIC_ALLOCATION 1 -#define configSUPPORT_DYNAMIC_ALLOCATION 1 -#define configUSE_PREEMPTION 0 -#define configUSE_TIMERS 1 -#define configUSE_MUTEXES 1 -#define configUSE_RECURSIVE_MUTEXES 1 -#define configUSE_COUNTING_SEMAPHORES 1 -#define configUSE_TASK_NOTIFICATIONS 1 -#define configUSE_TRACE_FACILITY 1 -#define configUSE_16_BIT_TICKS 0 -#define configUSE_PORT_OPTIMISED_TASK_SELECTION 0 -#define configMAX_PRIORITIES 56 -#define configUSE_TASK_NOTIFICATIONS 1 -#define configUSE_OS2_THREAD_FLAGS 1 -#endif /* FREERTOS_CONFIG_H */ diff --git a/product/rcar/scp_ramfw/Toolchain-GNU.cmake b/product/rcar/scp_ramfw/Toolchain-GNU.cmake index a0e339af84fdfbc61e51daebee8ec350a479360f..2b09a7ad835f86df5d6a4cd719b79873afc7dc39 100644 --- a/product/rcar/scp_ramfw/Toolchain-GNU.cmake +++ b/product/rcar/scp_ramfw/Toolchain-GNU.cmake @@ -1,6 +1,6 @@ # # Arm SCP/MCP Software -# Copyright (c) 2021, Arm Limited and Contributors. All rights reserved. +# Copyright (c) 2021-2025, Arm Limited and Contributors. All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # @@ -13,5 +13,7 @@ set(SCP_AARCH64_PROCESSOR_TARGET "cortex-a57.cortex-a53") set(CMAKE_TOOLCHAIN_PREFIX "aarch64-none-elf-") +string(APPEND CMAKE_EXE_LINKER_FLAGS_INIT "-nostdlib ") + include( "${CMAKE_CURRENT_LIST_DIR}/../../../cmake/Toolchain/GNU-Baremetal.cmake") diff --git a/product/rcar/scp_ramfw/config_shutdown.h b/product/rcar/scp_ramfw/config_shutdown.h new file mode 100644 index 0000000000000000000000000000000000000000..a40090dd7115b8d37611813a9b32291ad95fe8d3 --- /dev/null +++ b/product/rcar/scp_ramfw/config_shutdown.h @@ -0,0 +1,26 @@ +/* + * Renesas SCP/MCP Software + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights + * reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#ifndef CONFIG_SHUTDOWN_H +#define CONFIG_SHUTDOWN_H + +#include + +#define R_WARMBOOT (0xAA55AA55) +#define R_SUSPEND (0x55AA55AA) +#define R_RESET (0x5555AAAA) +#define R_OFF (0xAAAA5555) +#define R_CLEAR (0) + +#ifdef __ASSEMBLER__ +.extern _boot_flag.extern _shutdown_request +#else +extern volatile uint32_t _boot_flag; +extern volatile uint32_t _shutdown_request; +#endif /* __ASSEMBLER__ */ + +#endif /* CONFIG_SHUTDOWN_H */ diff --git a/product/rcar/scp_ramfw/fmw_memory.h b/product/rcar/scp_ramfw/fmw_memory.h index e1336d1040b85132887ed0fcd4b8e20d026cea5f..345b55b674db8e3cf5ebf568193789e43e5d4bea 100644 --- a/product/rcar/scp_ramfw/fmw_memory.h +++ b/product/rcar/scp_ramfw/fmw_memory.h @@ -1,6 +1,6 @@ /* * Renesas SCP/MCP Software - * Copyright (c) 2020-2021, Renesas Electronics Corporation. All rights + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights * reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -12,6 +12,13 @@ #include #define FMW_MEM_MODE ARCH_MEM_MODE_SINGLE_REGION +#define FWM_SYSTEM_RAM + +/* + * SRAM memory + */ +#define FWM_SYSTEM_RAM_SIZE SCP_SRAM_SIZE +#define FWM_SYSTEM_RAM_BASE SCP_SRAM_BASE /* * RAM memory diff --git a/product/rcar/scp_ramfw/rcar_libc.c b/product/rcar/scp_ramfw/rcar_libc.c new file mode 100644 index 0000000000000000000000000000000000000000..824f894c9cf15b4fdcc291bc238fd6a2a62e2699 --- /dev/null +++ b/product/rcar/scp_ramfw/rcar_libc.c @@ -0,0 +1,332 @@ +/* + * Renesas SCP/MCP Software + * Copyright (c) 2020-2025, Renesas Electronics Corporation. All rights + * reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include + +#include +#include +#include +#include + +extern void panic(void); + +int __errno; + +void *memset(void *s, int c, size_t count) +{ + char *xs = s; + while (count--) + *xs++ = c; + return s; +} + +void *memcpy(void *dst, const void *src, size_t n) +{ + /* copy per 1 byte */ + const char *p = src; + char *q = dst; + + while (n--) { + *q++ = *p++; + } + + return dst; +} + +char *strncpy(char *dest, const char *src, size_t n) +{ + size_t i; + + for (i = 0; i < n && src[i] != 0; i++) + dest[i] = src[i]; + for (; i < n; i++) + dest[i] = 0; + + return dest; +} + +char *strchr(const char *str, int c) +{ + do { + if (*str == (char)c) + return (char *)str; + str++; + } while (*str); + + return NULL; +} + +size_t strlen(const char *str) +{ + char *tmp = (char *)str; + size_t counter = 0; + while (*tmp++) + ++counter; + return counter; +} + +static void uint_to_str(unsigned int i, char *buf, int base) +{ + char const digit_10[] = "0123456789"; + char const digit_16[] = "0123456789abcdef"; + unsigned int shifter = i; + char const *digit; + + if (base == 10) + digit = digit_10; + else + digit = digit_16; + + do { + ++buf; + shifter = shifter / base; + } while (shifter); + + *buf = '\0'; + + do { + *--buf = digit[i % base]; + i = i / base; + } while (i); +} + +static void int_to_str(int i, char *buf, int base) +{ + int sign = i; + + if (i < 0) { + i = -i; + buf++; + } + + uint_to_str((unsigned int)i, buf, base); + + if (sign < 0) + *--buf = '-'; +} + +static int isdigit(char c) +{ + return (c >= '0' && c <= '9'); +} + +static int handle_num(char type, char *buf, va_list *args) +{ + int int_num; + unsigned int uint_num; + + switch (type) { + case 'u': + uint_num = va_arg(*args, unsigned int); + uint_to_str(uint_num, buf, 10); + break; + case 'd': + int_num = va_arg(*args, int); + int_to_str(int_num, buf, 10); + break; + case 'x': + uint_num = va_arg(*args, unsigned int); + uint_to_str(uint_num, buf, 16); + break; + default: + return 1; + break; + } + + return 0; +} + +int vsnprintf(char *str, size_t n, const char *format, va_list args) +{ + char *pos; + char *s; + char *tmp = str; + size_t length = 0; + int num_length, min_length; + char num_buf[12]; + int not_implemented; + + for (pos = (char *)format; *pos != '\0'; pos++) { + while ((*pos != '%') && (*pos != '\0') && (length < n)) { + *tmp++ = *pos++; + length++; + } + + if (length == n) + break; + + if (*pos == '\0') { + *tmp = '\0'; + break; + } + + pos++; + + not_implemented = 0; + + switch (*pos) { + case 's': + s = va_arg(args, char *); + strncpy(tmp, s, n - length); + break; + case '0': + if (isdigit(*(pos + 1)) && (*(pos + 1) > '0')) { + pos++; + } else { + not_implemented = 1; + break; + } + case '1' ... '9': + min_length = (unsigned int)(*pos - '0'); + + if (handle_num(*(pos + 1), num_buf, &args)) { + if (*(pos - 1) == '0') + pos--; + + not_implemented = 1; + break; + } + + num_length = strlen(num_buf); + + if (num_length < min_length) { + while (num_length >= 0) + num_buf[min_length--] = num_buf[num_length--]; + + if (*(pos - 1) == '0') { + if (num_buf[0] == '-') { + min_length++; + while (min_length > 0) + num_buf[min_length--] = '0'; + } else { + while (min_length >= 0) + num_buf[min_length--] = '0'; + } + } else { + while (min_length >= 0) + num_buf[min_length--] = ' '; + } + } + strncpy(tmp, num_buf, n - length); + pos++; + break; + default: + if (handle_num(*pos, num_buf, &args)) + not_implemented = 1; + else + strncpy(tmp, num_buf, n - length); + break; + } + + if (not_implemented) { + va_arg(args, unsigned int); + *tmp++ = '%'; + length++; + pos--; + } else { + while ((*tmp != '\0') && (length < n)) { + tmp++; + length++; + } + } + } + + if (tmp == str) { + *tmp = '\0'; + } else if (length == n) { + tmp--; + if (*tmp != '\0') + *tmp = '\0'; + else + length--; + } else if (*(tmp - 1) != '\0') { + *tmp = '\0'; + } else { + length--; + } + + return length; +} + +int snprintf(char *str, size_t size, const char *format, ...) +{ + int counter; + va_list args; + va_start(args, format); + counter = vsnprintf(str, size, format, args); + va_end(args); + return counter; +} + +void __assert_fail( + const char *assertion, + const char *file, + unsigned int line, + const char *function) +{ + while (1) + continue; +} + +extern char __stackheap_start__; +extern char __stackheap_end__; + +/*! + * \brief Architecture memory manager context. + */ +static struct arch_mm_ctx { + uintptr_t heap_break; + uintptr_t heap_end; +} arch_mm_ctx = { + .heap_break = (uintptr_t)(&__stackheap_start__), + .heap_end = (uintptr_t)(&__stackheap_end__), +}; + +void *sbrk(intptr_t increment) +{ + if (increment == 0) { + return (void *)arch_mm_ctx.heap_break; + } else { + uintptr_t heap_old = FWK_ALIGN_NEXT(arch_mm_ctx.heap_break, 16); + uintptr_t heap_new = heap_old + increment; + + if (heap_new > arch_mm_ctx.heap_end) { + return (void *)-1; + } else { + arch_mm_ctx.heap_break = heap_new; + + return (void *)heap_old; + } + } +} + +void *malloc(size_t size) +{ + void *mem = sbrk((intptr_t)size); + + if (mem == ((void *)-1)) + mem = NULL; + + return mem; +} + +void *calloc(size_t nmemb, size_t size) +{ + void *mem = malloc(nmemb * size); + + if (mem) + memset(mem, 0, nmemb * size); + + return mem; +} + +void free(void *ptr) +{ + panic(); +} diff --git a/product/rcar/src/CMSIS-FreeRTOS/CMSIS/RTOS2/FreeRTOS/Source/cmsis_os2_tiny4scp.c b/product/rcar/src/CMSIS-FreeRTOS/CMSIS/RTOS2/FreeRTOS/Source/cmsis_os2_tiny4scp.c deleted file mode 100644 index 0b481c64f5a40ae1f1af70a0f28d90b0083135ef..0000000000000000000000000000000000000000 --- a/product/rcar/src/CMSIS-FreeRTOS/CMSIS/RTOS2/FreeRTOS/Source/cmsis_os2_tiny4scp.c +++ /dev/null @@ -1,538 +0,0 @@ -/* -------------------------------------------------------------------------- - * Copyright (c) 2013-2019 Arm Limited. All rights reserved. - * Copyright (c) 2020-2021, Renesas Electronics Corporation. All rights - *reserved. - * - * SPDX-License-Identifier: Apache-2.0 - * - * Licensed under the Apache License, Version 2.0 (the License); you may - * not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an AS IS BASIS, WITHOUT - * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - * Name: cmsis_os2_tyny4scp.c - * Purpose: CMSIS RTOS2 wrapper for FreeRTOS - * - *---------------------------------------------------------------------------*/ - -#include "FreeRTOS.h" // ARM.FreeRTOS::RTOS:Core -#include "cmsis_os2.h" // ::CMSIS:RTOS2 -#include "task.h" // ARM.FreeRTOS::RTOS:Core - -#include - -#define __ARM_ARCH_8A__ (1) - -#define IS_IRQ() is_irq() - -/* Kernel version and identification string definition - (major.minor.rev: mmnnnrrrr dec) */ -#define KERNEL_VERSION \ - (((uint32_t)tskKERNEL_VERSION_MAJOR * 10000000UL) | \ - ((uint32_t)tskKERNEL_VERSION_MINOR * 10000UL) | \ - ((uint32_t)tskKERNEL_VERSION_BUILD * 1UL)) - -#define KERNEL_ID ("FreeRTOS " tskKERNEL_VERSION_NUMBER) - -#define portYIELD_FROM_ISR(n) -#define __STATIC_INLINE static inline -/* Limits */ -#define MAX_BITS_TASK_NOTIFY 31U -#define MAX_BITS_EVENT_GROUPS 24U - -#define THREAD_FLAGS_INVALID_BITS (~((1UL << MAX_BITS_TASK_NOTIFY) - 1U)) -#define EVENT_FLAGS_INVALID_BITS (~((1UL << MAX_BITS_EVENT_GROUPS) - 1U)) - -static inline uint32_t is_irq(void) -{ - uint32_t val; - __asm__ volatile("mrs %0, spsel" : "=r"(val)); - return val & 0x01; -} - -/* - Setup SVC to reset value. -*/ -__STATIC_INLINE void SVC_Setup(void) -{ -#if ((__ARM_ARCH_7A__ == 0U) && (__ARM_ARCH_8A__ == 0U)) - /* Service Call interrupt might be configured before kernel start */ - /* and when its priority is lower or equal to BASEPRI, svc intruction */ - /* causes a Hard Fault. */ - NVIC_SetPriority(SVCall_IRQn, 0U); -#endif -} - -/* Kernel initialization state */ -static osKernelState_t KernelState = osKernelInactive; - -osStatus_t osKernelInitialize(void) -{ - osStatus_t stat; - - if (IS_IRQ()) { - stat = osErrorISR; - } else { - if (KernelState == osKernelInactive) { -#if defined(RTE_Compiler_EventRecorder) - EvrFreeRTOSSetup(0U); -#endif -#if defined(RTE_RTOS_FreeRTOS_HEAP_5) && (HEAP_5_REGION_SETUP == 1) - vPortDefineHeapRegions(configHEAP_5_REGIONS); -#endif - KernelState = osKernelReady; - stat = osOK; - } else { - stat = osError; - } - } - - return (stat); -} - -osStatus_t osKernelGetInfo(osVersion_t *version, char *id_buf, uint32_t id_size) -{ - if (version != NULL) { - /* Version encoding is major.minor.rev: mmnnnrrrr dec */ - version->api = KERNEL_VERSION; - version->kernel = KERNEL_VERSION; - } - - if ((id_buf != NULL) && (id_size != 0U)) { - if (id_size > sizeof(KERNEL_ID)) { - id_size = sizeof(KERNEL_ID); - } - memcpy(id_buf, KERNEL_ID, id_size); - } - - return (osOK); -} - -osKernelState_t osKernelGetState(void) -{ - osKernelState_t state; - - switch (xTaskGetSchedulerState()) { - case taskSCHEDULER_RUNNING: - state = osKernelRunning; - break; - - case taskSCHEDULER_SUSPENDED: - state = osKernelLocked; - break; - - case taskSCHEDULER_NOT_STARTED: - default: - if (KernelState == osKernelReady) { - state = osKernelReady; - } else { - state = osKernelInactive; - } - break; - } - - return (state); -} - -osStatus_t osKernelStart(void) -{ - osStatus_t stat; - - if (IS_IRQ()) { - stat = osErrorISR; - } else { - if (KernelState == osKernelReady) { - /* Ensure SVC priority is at the reset value */ - SVC_Setup(); - /* Change state to enable IRQ masking check */ - KernelState = osKernelRunning; - /* Start the kernel scheduler */ - vTaskStartScheduler(); - stat = osOK; - } else { - stat = osError; - } - } - - return (stat); -} - -int32_t osKernelLock(void) -{ - int32_t lock; - - if (IS_IRQ()) { - lock = (int32_t)osErrorISR; - } else { - switch (xTaskGetSchedulerState()) { - case taskSCHEDULER_SUSPENDED: - lock = 1; - break; - - case taskSCHEDULER_RUNNING: - vTaskSuspendAll(); - lock = 0; - break; - - case taskSCHEDULER_NOT_STARTED: - default: - lock = (int32_t)osError; - break; - } - } - - return (lock); -} - -int32_t osKernelUnlock(void) -{ - int32_t lock; - - if (IS_IRQ()) { - lock = (int32_t)osErrorISR; - } else { - switch (xTaskGetSchedulerState()) { - case taskSCHEDULER_SUSPENDED: - lock = 1; - - if (xTaskResumeAll() != pdTRUE) { - if (xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED) { - lock = (int32_t)osError; - } - } - break; - - case taskSCHEDULER_RUNNING: - lock = 0; - break; - - case taskSCHEDULER_NOT_STARTED: - default: - lock = (int32_t)osError; - break; - } - } - - return (lock); -} - -int32_t osKernelRestoreLock(int32_t lock) -{ - if (IS_IRQ()) { - lock = (int32_t)osErrorISR; - } else { - switch (xTaskGetSchedulerState()) { - case taskSCHEDULER_SUSPENDED: - case taskSCHEDULER_RUNNING: - if (lock == 1) { - vTaskSuspendAll(); - } else { - if (lock != 0) { - lock = (int32_t)osError; - } else { - if (xTaskResumeAll() != pdTRUE) { - if (xTaskGetSchedulerState() != taskSCHEDULER_RUNNING) { - lock = (int32_t)osError; - } - } - } - } - break; - - case taskSCHEDULER_NOT_STARTED: - default: - lock = (int32_t)osError; - break; - } - } - - return (lock); -} - -uint32_t osKernelGetTickCount(void) -{ - TickType_t ticks; - - if (IS_IRQ()) { - ticks = xTaskGetTickCountFromISR(); - } else { - ticks = xTaskGetTickCount(); - } - - return (ticks); -} - -uint32_t osKernelGetTickFreq(void) -{ - return (configTICK_RATE_HZ); -} - -/*---------------------------------------------------------------------------*/ - -osThreadId_t osThreadNew( - osThreadFunc_t func, - void *argument, - const osThreadAttr_t *attr) -{ - const char *name; - uint32_t stack; - TaskHandle_t hTask; - UBaseType_t prio; - int32_t mem; - - hTask = NULL; - - if (!IS_IRQ() && (func != NULL)) { - stack = configMINIMAL_STACK_SIZE; - prio = (UBaseType_t)osPriorityNormal; - - name = NULL; - mem = -1; - - if (attr != NULL) { - if (attr->name != NULL) { - name = attr->name; - } - if (attr->priority != osPriorityNone) { - prio = (UBaseType_t)attr->priority; - } - - if ((prio < osPriorityIdle) || (prio > osPriorityISR) || - ((attr->attr_bits & osThreadJoinable) == osThreadJoinable)) { - return (NULL); - } - - if (attr->stack_size > 0U) { - /* In FreeRTOS stack is not in bytes, */ - /* but in sizeof(StackType_t) which is 4 on ARM ports. */ - /* Stack size should be therefore 4 byte aligned in order to */ - /* avoid division caused side effects */ - stack = attr->stack_size / sizeof(StackType_t); - } - - if ((attr->cb_mem != NULL) && - (attr->cb_size >= sizeof(StaticTask_t)) && - (attr->stack_mem != NULL) && (attr->stack_size > 0U)) { - mem = 1; - } else { - if ((attr->cb_mem == NULL) && (attr->cb_size == 0U) && - (attr->stack_mem == NULL)) { - mem = 0; - } - } - } else { - mem = 0; - } - - if (mem == 1) { - hTask = xTaskCreateStatic( - (TaskFunction_t)func, - name, - stack, - argument, - prio, - (StackType_t *)attr->stack_mem, - (StaticTask_t *)attr->cb_mem); - } else { - if (mem == 0) { - if (xTaskCreate( - (TaskFunction_t)func, - name, - (uint16_t)stack, - argument, - prio, - &hTask) != pdPASS) { - hTask = NULL; - } - } - } - } - - return ((osThreadId_t)hTask); -} - -uint32_t osThreadFlagsSet(osThreadId_t thread_id, uint32_t flags) -{ - TaskHandle_t hTask = (TaskHandle_t)thread_id; - uint32_t rflags; - BaseType_t yield; - - if ((hTask == NULL) || ((flags & THREAD_FLAGS_INVALID_BITS) != 0U)) { - rflags = (uint32_t)osErrorParameter; - } else { - rflags = (uint32_t)osError; - - if (IS_IRQ()) { - yield = pdFALSE; - - (void)xTaskNotifyFromISR(hTask, flags, eSetBits, &yield); - (void)xTaskNotifyAndQueryFromISR( - hTask, 0, eNoAction, &rflags, NULL); - - portYIELD_FROM_ISR(yield); - } else { - (void)xTaskNotify(hTask, flags, eSetBits); - (void)xTaskNotifyAndQuery(hTask, 0, eNoAction, &rflags); - } - } - /* Return flags after setting */ - return (rflags); -} - -uint32_t osThreadFlagsClear(uint32_t flags) -{ - TaskHandle_t hTask; - uint32_t rflags, cflags; - - if (IS_IRQ()) { - rflags = (uint32_t)osErrorISR; - } else if ((flags & THREAD_FLAGS_INVALID_BITS) != 0U) { - rflags = (uint32_t)osErrorParameter; - } else { - hTask = xTaskGetCurrentTaskHandle(); - - if (xTaskNotifyAndQuery(hTask, 0, eNoAction, &cflags) == pdPASS) { - rflags = cflags; - cflags &= ~flags; - - if (xTaskNotify(hTask, cflags, eSetValueWithOverwrite) != pdPASS) { - rflags = (uint32_t)osError; - } - } else { - rflags = (uint32_t)osError; - } - } - - /* Return flags before clearing */ - return (rflags); -} - -uint32_t osThreadFlagsWait(uint32_t flags, uint32_t options, uint32_t timeout) -{ - uint32_t rflags, nval; - uint32_t clear; - TickType_t t0, td, tout; - BaseType_t rval; - - if (IS_IRQ()) { - rflags = (uint32_t)osErrorISR; - } else if ((flags & THREAD_FLAGS_INVALID_BITS) != 0U) { - rflags = (uint32_t)osErrorParameter; - } else { - if ((options & osFlagsNoClear) == osFlagsNoClear) { - clear = 0U; - } else { - clear = flags; - } - - rflags = 0U; - tout = timeout; - - t0 = xTaskGetTickCount(); - do { - rval = xTaskNotifyWait(0, clear, &nval, tout); - - if (rval == pdPASS) { - rflags &= flags; - rflags |= nval; - - if ((options & osFlagsWaitAll) == osFlagsWaitAll) { - if ((flags & rflags) == flags) { - break; - } else { - if (timeout == 0U) { - rflags = (uint32_t)osErrorResource; - break; - } - } - } else { - if ((flags & rflags) != 0) { - break; - } else { - if (timeout == 0U) { - rflags = (uint32_t)osErrorResource; - break; - } - } - } - - /* Update timeout */ - td = xTaskGetTickCount() - t0; - - if (td > tout) { - tout = 0; - } else { - tout -= td; - } - } else { - if (timeout == 0) { - rflags = (uint32_t)osErrorResource; - } else { - rflags = (uint32_t)osErrorTimeout; - } - } - } while (rval != pdFAIL); - } - - /* Return flags before clearing */ - return (rflags); -} - -/*---------------------------------------------------------------------------*/ - -/* External Idle and Timer task static memory allocation functions */ - -/* External Idle and Timer task static memory allocation functions */ -extern void vApplicationGetIdleTaskMemory( - StaticTask_t **ppxIdleTaskTCBBuffer, - StackType_t **ppxIdleTaskStackBuffer, - uint32_t *pulIdleTaskStackSize); -extern void vApplicationGetTimerTaskMemory( - StaticTask_t **ppxTimerTaskTCBBuffer, - StackType_t **ppxTimerTaskStackBuffer, - uint32_t *pulTimerTaskStackSize); - -/* Idle task control block and stack */ -static StaticTask_t Idle_TCB; -static StackType_t Idle_Stack[configMINIMAL_STACK_SIZE]; - -/* Timer task control block and stack */ -static StaticTask_t Timer_TCB; -static StackType_t Timer_Stack[configTIMER_TASK_STACK_DEPTH]; - -/* - vApplicationGetIdleTaskMemory gets called when - configSUPPORT_STATIC_ALLOCATION - equals to 1 and is required for static memory allocation support. -*/ -void vApplicationGetIdleTaskMemory( - StaticTask_t **ppxIdleTaskTCBBuffer, - StackType_t **ppxIdleTaskStackBuffer, - uint32_t *pulIdleTaskStackSize) -{ - *ppxIdleTaskTCBBuffer = &Idle_TCB; - *ppxIdleTaskStackBuffer = &Idle_Stack[0]; - *pulIdleTaskStackSize = (uint32_t)configMINIMAL_STACK_SIZE; -} - -/* - vApplicationGetTimerTaskMemory gets called when - configSUPPORT_STATIC_ALLOCATION - equals to 1 and is required for static memory allocation support. -*/ -void vApplicationGetTimerTaskMemory( - StaticTask_t **ppxTimerTaskTCBBuffer, - StackType_t **ppxTimerTaskStackBuffer, - uint32_t *pulTimerTaskStackSize) -{ - *ppxTimerTaskTCBBuffer = &Timer_TCB; - *ppxTimerTaskStackBuffer = &Timer_Stack[0]; - *pulTimerTaskStackSize = (uint32_t)configTIMER_TASK_STACK_DEPTH; -} diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/include/FreeRTOS.h b/product/rcar/src/CMSIS-FreeRTOS/Source/include/FreeRTOS.h deleted file mode 100644 index c8d2497e7593b580bf14ef7c0c96be27c9843d03..0000000000000000000000000000000000000000 --- a/product/rcar/src/CMSIS-FreeRTOS/Source/include/FreeRTOS.h +++ /dev/null @@ -1,1317 +0,0 @@ -/* - * FreeRTOS Kernel V10.3.1 - * 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://www.FreeRTOS.org - * http://aws.amazon.com/freertos - * - * 1 tab == 4 spaces! - */ - -#ifndef INC_FREERTOS_H -#define INC_FREERTOS_H - -/* - * Include the generic headers required for the FreeRTOS port being used. - */ -#include - -/* - * If stdint.h cannot be located then: - * + If using GCC ensure the -nostdint options is *not* being used. - * + Ensure the project's include path includes the directory in which your - * compiler stores stdint.h. - * + Set any compiler options necessary for it to support C99, as technically - * stdint.h is only mandatory with C99 (FreeRTOS does not require C99 in any - * other way). - * + The FreeRTOS download includes a simple stdint.h definition that can be - * used in cases where none is provided by the compiler. The files only - * contains the typedefs required to build FreeRTOS. Read the instructions - * in FreeRTOS/source/stdint.readme for more information. - */ -#include /* READ COMMENT ABOVE. */ - -#ifdef __cplusplus -extern "C" { -#endif - -/* Application specific configuration options. */ -#include "FreeRTOSConfig.h" - -/* Basic FreeRTOS definitions. */ -#include "projdefs.h" - -/* Definitions specific to the port being used. */ -#include "portable.h" - -/* Must be defaulted before configUSE_NEWLIB_REENTRANT is used below. */ -#ifndef configUSE_NEWLIB_REENTRANT -# define configUSE_NEWLIB_REENTRANT 0 -#endif - -/* Required if struct _reent is used. */ -#if (configUSE_NEWLIB_REENTRANT == 1) -# include -#endif -/* - * Check all the required application specific macros have been defined. - * These macros are application specific and (as downloaded) are defined - * within FreeRTOSConfig.h. - */ - -#ifndef configMINIMAL_STACK_SIZE -#error Missing definition: configMINIMAL_STACK_SIZE must be defined in FreeRTOSConfig.h. configMINIMAL_STACK_SIZE defines the size (in words) of the stack allocated to the idle task. Refer to the demo project provided for your port for a suitable value. -#endif - -#ifndef configMAX_PRIORITIES -#error Missing definition: configMAX_PRIORITIES must be defined in FreeRTOSConfig.h. See the Configuration section of the FreeRTOS API documentation for details. -#endif - -#if configMAX_PRIORITIES < 1 -# error configMAX_PRIORITIES must be defined to be greater than or equal to 1. -#endif - -#ifndef configUSE_PREEMPTION -#error Missing definition: configUSE_PREEMPTION must be defined in FreeRTOSConfig.h as either 1 or 0. See the Configuration section of the FreeRTOS API documentation for details. -#endif - -#ifndef configUSE_IDLE_HOOK -#error Missing definition: configUSE_IDLE_HOOK must be defined in FreeRTOSConfig.h as either 1 or 0. See the Configuration section of the FreeRTOS API documentation for details. -#endif - -#ifndef configUSE_TICK_HOOK -#error Missing definition: configUSE_TICK_HOOK must be defined in FreeRTOSConfig.h as either 1 or 0. See the Configuration section of the FreeRTOS API documentation for details. -#endif - -#ifndef configUSE_16_BIT_TICKS -#error Missing definition: configUSE_16_BIT_TICKS must be defined in FreeRTOSConfig.h as either 1 or 0. See the Configuration section of the FreeRTOS API documentation for details. -#endif - -#ifndef configUSE_CO_ROUTINES -# define configUSE_CO_ROUTINES 0 -#endif - -#ifndef INCLUDE_vTaskPrioritySet -# define INCLUDE_vTaskPrioritySet 0 -#endif - -#ifndef INCLUDE_uxTaskPriorityGet -# define INCLUDE_uxTaskPriorityGet 0 -#endif - -#ifndef INCLUDE_vTaskDelete -# define INCLUDE_vTaskDelete 0 -#endif - -#ifndef INCLUDE_vTaskSuspend -# define INCLUDE_vTaskSuspend 0 -#endif - -#ifndef INCLUDE_vTaskDelayUntil -# define INCLUDE_vTaskDelayUntil 0 -#endif - -#ifndef INCLUDE_vTaskDelay -# define INCLUDE_vTaskDelay 0 -#endif - -#ifndef INCLUDE_xTaskGetIdleTaskHandle -# define INCLUDE_xTaskGetIdleTaskHandle 0 -#endif - -#ifndef INCLUDE_xTaskAbortDelay -# define INCLUDE_xTaskAbortDelay 0 -#endif - -#ifndef INCLUDE_xQueueGetMutexHolder -# define INCLUDE_xQueueGetMutexHolder 0 -#endif - -#ifndef INCLUDE_xSemaphoreGetMutexHolder -# define INCLUDE_xSemaphoreGetMutexHolder INCLUDE_xQueueGetMutexHolder -#endif - -#ifndef INCLUDE_xTaskGetHandle -# define INCLUDE_xTaskGetHandle 0 -#endif - -#ifndef INCLUDE_uxTaskGetStackHighWaterMark -# define INCLUDE_uxTaskGetStackHighWaterMark 0 -#endif - -#ifndef INCLUDE_uxTaskGetStackHighWaterMark2 -# define INCLUDE_uxTaskGetStackHighWaterMark2 0 -#endif - -#ifndef INCLUDE_eTaskGetState -# define INCLUDE_eTaskGetState 0 -#endif - -#ifndef INCLUDE_xTaskResumeFromISR -# define INCLUDE_xTaskResumeFromISR 1 -#endif - -#ifndef INCLUDE_xTimerPendFunctionCall -# define INCLUDE_xTimerPendFunctionCall 0 -#endif - -#ifndef INCLUDE_xTaskGetSchedulerState -# define INCLUDE_xTaskGetSchedulerState 0 -#endif - -#ifndef INCLUDE_xTaskGetCurrentTaskHandle -# define INCLUDE_xTaskGetCurrentTaskHandle 0 -#endif - -#if configUSE_CO_ROUTINES != 0 -# ifndef configMAX_CO_ROUTINE_PRIORITIES -# error configMAX_CO_ROUTINE_PRIORITIES must be greater than or equal to 1. -# endif -#endif - -#ifndef configUSE_DAEMON_TASK_STARTUP_HOOK -# define configUSE_DAEMON_TASK_STARTUP_HOOK 0 -#endif - -#ifndef configUSE_APPLICATION_TASK_TAG -# define configUSE_APPLICATION_TASK_TAG 0 -#endif - -#ifndef configNUM_THREAD_LOCAL_STORAGE_POINTERS -# define configNUM_THREAD_LOCAL_STORAGE_POINTERS 0 -#endif - -#ifndef configUSE_RECURSIVE_MUTEXES -# define configUSE_RECURSIVE_MUTEXES 0 -#endif - -#ifndef configUSE_MUTEXES -# define configUSE_MUTEXES 0 -#endif - -#ifndef configUSE_TIMERS -# define configUSE_TIMERS 0 -#endif - -#ifndef configUSE_COUNTING_SEMAPHORES -# define configUSE_COUNTING_SEMAPHORES 0 -#endif - -#ifndef configUSE_ALTERNATIVE_API -# define configUSE_ALTERNATIVE_API 0 -#endif - -#ifndef portCRITICAL_NESTING_IN_TCB -# define portCRITICAL_NESTING_IN_TCB 0 -#endif - -#ifndef configMAX_TASK_NAME_LEN -# define configMAX_TASK_NAME_LEN 16 -#endif - -#ifndef configIDLE_SHOULD_YIELD -# define configIDLE_SHOULD_YIELD 1 -#endif - -#if configMAX_TASK_NAME_LEN < 1 -#error configMAX_TASK_NAME_LEN must be set to a minimum of 1 in FreeRTOSConfig.h -#endif - -#ifndef configASSERT -# define configASSERT(x) -# define configASSERT_DEFINED 0 -#else -# define configASSERT_DEFINED 1 -#endif - -/* configPRECONDITION should be defined as configASSERT. -The CBMC proofs need a way to track assumptions and assertions. -A configPRECONDITION statement should express an implicit invariant or -assumption made. A configASSERT statement should express an invariant that must -hold explicit before calling the code. */ -#ifndef configPRECONDITION -# define configPRECONDITION(X) configASSERT(X) -# define configPRECONDITION_DEFINED 0 -#else -# define configPRECONDITION_DEFINED 1 -#endif - -#ifndef portMEMORY_BARRIER -# define portMEMORY_BARRIER() -#endif - -#ifndef portSOFTWARE_BARRIER -# define portSOFTWARE_BARRIER() -#endif - -/* The timers module relies on xTaskGetSchedulerState(). */ -#if configUSE_TIMERS == 1 - -# ifndef configTIMER_TASK_PRIORITY -#error If configUSE_TIMERS is set to 1 then configTIMER_TASK_PRIORITY must also be defined. -# endif /* configTIMER_TASK_PRIORITY */ - -# ifndef configTIMER_QUEUE_LENGTH -#error If configUSE_TIMERS is set to 1 then configTIMER_QUEUE_LENGTH must also be defined. -# endif /* configTIMER_QUEUE_LENGTH */ - -# ifndef configTIMER_TASK_STACK_DEPTH -#error If configUSE_TIMERS is set to 1 then configTIMER_TASK_STACK_DEPTH must also be defined. -# endif /* configTIMER_TASK_STACK_DEPTH */ - -#endif /* configUSE_TIMERS */ - -#ifndef portSET_INTERRUPT_MASK_FROM_ISR -# define portSET_INTERRUPT_MASK_FROM_ISR() 0 -#endif - -#ifndef portCLEAR_INTERRUPT_MASK_FROM_ISR -# define portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedStatusValue) \ - (void)uxSavedStatusValue -#endif - -#ifndef portCLEAN_UP_TCB -# define portCLEAN_UP_TCB(pxTCB) (void)pxTCB -#endif - -#ifndef portPRE_TASK_DELETE_HOOK -# define portPRE_TASK_DELETE_HOOK(pvTaskToDelete, pxYieldPending) -#endif - -#ifndef portSETUP_TCB -# define portSETUP_TCB(pxTCB) (void)pxTCB -#endif - -#ifndef configQUEUE_REGISTRY_SIZE -# define configQUEUE_REGISTRY_SIZE 0U -#endif - -#if (configQUEUE_REGISTRY_SIZE < 1) -# define vQueueAddToRegistry(xQueue, pcName) -# define vQueueUnregisterQueue(xQueue) -# define pcQueueGetName(xQueue) -#endif - -#ifndef portPOINTER_SIZE_TYPE -# define portPOINTER_SIZE_TYPE uint32_t -#endif - -/* Remove any unused trace macros. */ -#ifndef traceSTART -/* Used to perform any necessary initialisation - for example, open a file -into which trace is to be written. */ -# define traceSTART() -#endif - -#ifndef traceEND -/* Use to close a trace, for example close a file into which trace has been -written. */ -# define traceEND() -#endif - -#ifndef traceTASK_SWITCHED_IN -/* Called after a task has been selected to run. pxCurrentTCB holds a pointer -to the task control block of the selected task. */ -# define traceTASK_SWITCHED_IN() -#endif - -#ifndef traceINCREASE_TICK_COUNT -/* Called before stepping the tick count after waking from tickless idle -sleep. */ -# define traceINCREASE_TICK_COUNT(x) -#endif - -#ifndef traceLOW_POWER_IDLE_BEGIN -/* Called immediately before entering tickless idle. */ -# define traceLOW_POWER_IDLE_BEGIN() -#endif - -#ifndef traceLOW_POWER_IDLE_END -/* Called when returning to the Idle task after a tickless idle. */ -# define traceLOW_POWER_IDLE_END() -#endif - -#ifndef traceTASK_SWITCHED_OUT -/* Called before a task has been selected to run. pxCurrentTCB holds a pointer -to the task control block of the task being switched out. */ -# define traceTASK_SWITCHED_OUT() -#endif - -#ifndef traceTASK_PRIORITY_INHERIT -/* Called when a task attempts to take a mutex that is already held by a -lower priority task. pxTCBOfMutexHolder is a pointer to the TCB of the task -that holds the mutex. uxInheritedPriority is the priority the mutex holder -will inherit (the priority of the task that is attempting to obtain the -muted. */ -# define traceTASK_PRIORITY_INHERIT(pxTCBOfMutexHolder, uxInheritedPriority) -#endif - -#ifndef traceTASK_PRIORITY_DISINHERIT -/* Called when a task releases a mutex, the holding of which had resulted in -the task inheriting the priority of a higher priority task. -pxTCBOfMutexHolder is a pointer to the TCB of the task that is releasing the -mutex. uxOriginalPriority is the task's configured (base) priority. */ -# define traceTASK_PRIORITY_DISINHERIT( \ - pxTCBOfMutexHolder, uxOriginalPriority) -#endif - -#ifndef traceBLOCKING_ON_QUEUE_RECEIVE -/* Task is about to block because it cannot read from a -queue/mutex/semaphore. pxQueue is a pointer to the queue/mutex/semaphore -upon which the read was attempted. pxCurrentTCB points to the TCB of the -task that attempted the read. */ -# define traceBLOCKING_ON_QUEUE_RECEIVE(pxQueue) -#endif - -#ifndef traceBLOCKING_ON_QUEUE_PEEK -/* Task is about to block because it cannot read from a -queue/mutex/semaphore. pxQueue is a pointer to the queue/mutex/semaphore -upon which the read was attempted. pxCurrentTCB points to the TCB of the -task that attempted the read. */ -# define traceBLOCKING_ON_QUEUE_PEEK(pxQueue) -#endif - -#ifndef traceBLOCKING_ON_QUEUE_SEND -/* Task is about to block because it cannot write to a -queue/mutex/semaphore. pxQueue is a pointer to the queue/mutex/semaphore -upon which the write was attempted. pxCurrentTCB points to the TCB of the -task that attempted the write. */ -# define traceBLOCKING_ON_QUEUE_SEND(pxQueue) -#endif - -#ifndef configCHECK_FOR_STACK_OVERFLOW -# define configCHECK_FOR_STACK_OVERFLOW 0 -#endif - -#ifndef configRECORD_STACK_HIGH_ADDRESS -# define configRECORD_STACK_HIGH_ADDRESS 0 -#endif - -#ifndef configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H -# define configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H 0 -#endif - -/* The following event macros are embedded in the kernel API calls. */ - -#ifndef traceMOVED_TASK_TO_READY_STATE -# define traceMOVED_TASK_TO_READY_STATE(pxTCB) -#endif - -#ifndef tracePOST_MOVED_TASK_TO_READY_STATE -# define tracePOST_MOVED_TASK_TO_READY_STATE(pxTCB) -#endif - -#ifndef traceQUEUE_CREATE -# define traceQUEUE_CREATE(pxNewQueue) -#endif - -#ifndef traceQUEUE_CREATE_FAILED -# define traceQUEUE_CREATE_FAILED(ucQueueType) -#endif - -#ifndef traceCREATE_MUTEX -# define traceCREATE_MUTEX(pxNewQueue) -#endif - -#ifndef traceCREATE_MUTEX_FAILED -# define traceCREATE_MUTEX_FAILED() -#endif - -#ifndef traceGIVE_MUTEX_RECURSIVE -# define traceGIVE_MUTEX_RECURSIVE(pxMutex) -#endif - -#ifndef traceGIVE_MUTEX_RECURSIVE_FAILED -# define traceGIVE_MUTEX_RECURSIVE_FAILED(pxMutex) -#endif - -#ifndef traceTAKE_MUTEX_RECURSIVE -# define traceTAKE_MUTEX_RECURSIVE(pxMutex) -#endif - -#ifndef traceTAKE_MUTEX_RECURSIVE_FAILED -# define traceTAKE_MUTEX_RECURSIVE_FAILED(pxMutex) -#endif - -#ifndef traceCREATE_COUNTING_SEMAPHORE -# define traceCREATE_COUNTING_SEMAPHORE() -#endif - -#ifndef traceCREATE_COUNTING_SEMAPHORE_FAILED -# define traceCREATE_COUNTING_SEMAPHORE_FAILED() -#endif - -#ifndef traceQUEUE_SEND -# define traceQUEUE_SEND(pxQueue) -#endif - -#ifndef traceQUEUE_SEND_FAILED -# define traceQUEUE_SEND_FAILED(pxQueue) -#endif - -#ifndef traceQUEUE_RECEIVE -# define traceQUEUE_RECEIVE(pxQueue) -#endif - -#ifndef traceQUEUE_PEEK -# define traceQUEUE_PEEK(pxQueue) -#endif - -#ifndef traceQUEUE_PEEK_FAILED -# define traceQUEUE_PEEK_FAILED(pxQueue) -#endif - -#ifndef traceQUEUE_PEEK_FROM_ISR -# define traceQUEUE_PEEK_FROM_ISR(pxQueue) -#endif - -#ifndef traceQUEUE_RECEIVE_FAILED -# define traceQUEUE_RECEIVE_FAILED(pxQueue) -#endif - -#ifndef traceQUEUE_SEND_FROM_ISR -# define traceQUEUE_SEND_FROM_ISR(pxQueue) -#endif - -#ifndef traceQUEUE_SEND_FROM_ISR_FAILED -# define traceQUEUE_SEND_FROM_ISR_FAILED(pxQueue) -#endif - -#ifndef traceQUEUE_RECEIVE_FROM_ISR -# define traceQUEUE_RECEIVE_FROM_ISR(pxQueue) -#endif - -#ifndef traceQUEUE_RECEIVE_FROM_ISR_FAILED -# define traceQUEUE_RECEIVE_FROM_ISR_FAILED(pxQueue) -#endif - -#ifndef traceQUEUE_PEEK_FROM_ISR_FAILED -# define traceQUEUE_PEEK_FROM_ISR_FAILED(pxQueue) -#endif - -#ifndef traceQUEUE_DELETE -# define traceQUEUE_DELETE(pxQueue) -#endif - -#ifndef traceTASK_CREATE -# define traceTASK_CREATE(pxNewTCB) -#endif - -#ifndef traceTASK_CREATE_FAILED -# define traceTASK_CREATE_FAILED() -#endif - -#ifndef traceTASK_DELETE -# define traceTASK_DELETE(pxTaskToDelete) -#endif - -#ifndef traceTASK_DELAY_UNTIL -# define traceTASK_DELAY_UNTIL(x) -#endif - -#ifndef traceTASK_DELAY -# define traceTASK_DELAY() -#endif - -#ifndef traceTASK_PRIORITY_SET -# define traceTASK_PRIORITY_SET(pxTask, uxNewPriority) -#endif - -#ifndef traceTASK_SUSPEND -# define traceTASK_SUSPEND(pxTaskToSuspend) -#endif - -#ifndef traceTASK_RESUME -# define traceTASK_RESUME(pxTaskToResume) -#endif - -#ifndef traceTASK_RESUME_FROM_ISR -# define traceTASK_RESUME_FROM_ISR(pxTaskToResume) -#endif - -#ifndef traceTASK_INCREMENT_TICK -# define traceTASK_INCREMENT_TICK(xTickCount) -#endif - -#ifndef traceTIMER_CREATE -# define traceTIMER_CREATE(pxNewTimer) -#endif - -#ifndef traceTIMER_CREATE_FAILED -# define traceTIMER_CREATE_FAILED() -#endif - -#ifndef traceTIMER_COMMAND_SEND -# define traceTIMER_COMMAND_SEND( \ - xTimer, xMessageID, xMessageValueValue, xReturn) -#endif - -#ifndef traceTIMER_EXPIRED -# define traceTIMER_EXPIRED(pxTimer) -#endif - -#ifndef traceTIMER_COMMAND_RECEIVED -# define traceTIMER_COMMAND_RECEIVED(pxTimer, xMessageID, xMessageValue) -#endif - -#ifndef traceMALLOC -# define traceMALLOC(pvAddress, uiSize) -#endif - -#ifndef traceFREE -# define traceFREE(pvAddress, uiSize) -#endif - -#ifndef traceEVENT_GROUP_CREATE -# define traceEVENT_GROUP_CREATE(xEventGroup) -#endif - -#ifndef traceEVENT_GROUP_CREATE_FAILED -# define traceEVENT_GROUP_CREATE_FAILED() -#endif - -#ifndef traceEVENT_GROUP_SYNC_BLOCK -# define traceEVENT_GROUP_SYNC_BLOCK( \ - xEventGroup, uxBitsToSet, uxBitsToWaitFor) -#endif - -#ifndef traceEVENT_GROUP_SYNC_END -# define traceEVENT_GROUP_SYNC_END( \ - xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred) \ - (void)xTimeoutOccurred -#endif - -#ifndef traceEVENT_GROUP_WAIT_BITS_BLOCK -# define traceEVENT_GROUP_WAIT_BITS_BLOCK(xEventGroup, uxBitsToWaitFor) -#endif - -#ifndef traceEVENT_GROUP_WAIT_BITS_END -# define traceEVENT_GROUP_WAIT_BITS_END( \ - xEventGroup, uxBitsToWaitFor, xTimeoutOccurred) \ - (void)xTimeoutOccurred -#endif - -#ifndef traceEVENT_GROUP_CLEAR_BITS -# define traceEVENT_GROUP_CLEAR_BITS(xEventGroup, uxBitsToClear) -#endif - -#ifndef traceEVENT_GROUP_CLEAR_BITS_FROM_ISR -# define traceEVENT_GROUP_CLEAR_BITS_FROM_ISR(xEventGroup, uxBitsToClear) -#endif - -#ifndef traceEVENT_GROUP_SET_BITS -# define traceEVENT_GROUP_SET_BITS(xEventGroup, uxBitsToSet) -#endif - -#ifndef traceEVENT_GROUP_SET_BITS_FROM_ISR -# define traceEVENT_GROUP_SET_BITS_FROM_ISR(xEventGroup, uxBitsToSet) -#endif - -#ifndef traceEVENT_GROUP_DELETE -# define traceEVENT_GROUP_DELETE(xEventGroup) -#endif - -#ifndef tracePEND_FUNC_CALL -# define tracePEND_FUNC_CALL( \ - xFunctionToPend, pvParameter1, ulParameter2, ret) -#endif - -#ifndef tracePEND_FUNC_CALL_FROM_ISR -# define tracePEND_FUNC_CALL_FROM_ISR( \ - xFunctionToPend, pvParameter1, ulParameter2, ret) -#endif - -#ifndef traceQUEUE_REGISTRY_ADD -# define traceQUEUE_REGISTRY_ADD(xQueue, pcQueueName) -#endif - -#ifndef traceTASK_NOTIFY_TAKE_BLOCK -# define traceTASK_NOTIFY_TAKE_BLOCK() -#endif - -#ifndef traceTASK_NOTIFY_TAKE -# define traceTASK_NOTIFY_TAKE() -#endif - -#ifndef traceTASK_NOTIFY_WAIT_BLOCK -# define traceTASK_NOTIFY_WAIT_BLOCK() -#endif - -#ifndef traceTASK_NOTIFY_WAIT -# define traceTASK_NOTIFY_WAIT() -#endif - -#ifndef traceTASK_NOTIFY -# define traceTASK_NOTIFY() -#endif - -#ifndef traceTASK_NOTIFY_FROM_ISR -# define traceTASK_NOTIFY_FROM_ISR() -#endif - -#ifndef traceTASK_NOTIFY_GIVE_FROM_ISR -# define traceTASK_NOTIFY_GIVE_FROM_ISR() -#endif - -#ifndef traceSTREAM_BUFFER_CREATE_FAILED -# define traceSTREAM_BUFFER_CREATE_FAILED(xIsMessageBuffer) -#endif - -#ifndef traceSTREAM_BUFFER_CREATE_STATIC_FAILED -# define traceSTREAM_BUFFER_CREATE_STATIC_FAILED(xReturn, xIsMessageBuffer) -#endif - -#ifndef traceSTREAM_BUFFER_CREATE -# define traceSTREAM_BUFFER_CREATE(pxStreamBuffer, xIsMessageBuffer) -#endif - -#ifndef traceSTREAM_BUFFER_DELETE -# define traceSTREAM_BUFFER_DELETE(xStreamBuffer) -#endif - -#ifndef traceSTREAM_BUFFER_RESET -# define traceSTREAM_BUFFER_RESET(xStreamBuffer) -#endif - -#ifndef traceBLOCKING_ON_STREAM_BUFFER_SEND -# define traceBLOCKING_ON_STREAM_BUFFER_SEND(xStreamBuffer) -#endif - -#ifndef traceSTREAM_BUFFER_SEND -# define traceSTREAM_BUFFER_SEND(xStreamBuffer, xBytesSent) -#endif - -#ifndef traceSTREAM_BUFFER_SEND_FAILED -# define traceSTREAM_BUFFER_SEND_FAILED(xStreamBuffer) -#endif - -#ifndef traceSTREAM_BUFFER_SEND_FROM_ISR -# define traceSTREAM_BUFFER_SEND_FROM_ISR(xStreamBuffer, xBytesSent) -#endif - -#ifndef traceBLOCKING_ON_STREAM_BUFFER_RECEIVE -# define traceBLOCKING_ON_STREAM_BUFFER_RECEIVE(xStreamBuffer) -#endif - -#ifndef traceSTREAM_BUFFER_RECEIVE -# define traceSTREAM_BUFFER_RECEIVE(xStreamBuffer, xReceivedLength) -#endif - -#ifndef traceSTREAM_BUFFER_RECEIVE_FAILED -# define traceSTREAM_BUFFER_RECEIVE_FAILED(xStreamBuffer) -#endif - -#ifndef traceSTREAM_BUFFER_RECEIVE_FROM_ISR -# define traceSTREAM_BUFFER_RECEIVE_FROM_ISR(xStreamBuffer, xReceivedLength) -#endif - -#ifndef configGENERATE_RUN_TIME_STATS -# define configGENERATE_RUN_TIME_STATS 0 -#endif - -#if (configGENERATE_RUN_TIME_STATS == 1) - -# ifndef portCONFIGURE_TIMER_FOR_RUN_TIME_STATS -#error If configGENERATE_RUN_TIME_STATS is defined then portCONFIGURE_TIMER_FOR_RUN_TIME_STATS must also be defined. portCONFIGURE_TIMER_FOR_RUN_TIME_STATS should call a port layer function to setup a peripheral timer/counter that can then be used as the run time counter time base. -# endif /* portCONFIGURE_TIMER_FOR_RUN_TIME_STATS */ - -# ifndef portGET_RUN_TIME_COUNTER_VALUE -# ifndef portALT_GET_RUN_TIME_COUNTER_VALUE -#error If configGENERATE_RUN_TIME_STATS is defined then either portGET_RUN_TIME_COUNTER_VALUE or portALT_GET_RUN_TIME_COUNTER_VALUE must also be defined. See the examples provided and the FreeRTOS web site for more information. -# endif /* portALT_GET_RUN_TIME_COUNTER_VALUE */ -# endif /* portGET_RUN_TIME_COUNTER_VALUE */ - -#endif /* configGENERATE_RUN_TIME_STATS */ - -#ifndef portCONFIGURE_TIMER_FOR_RUN_TIME_STATS -# define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() -#endif - -#ifndef configUSE_MALLOC_FAILED_HOOK -# define configUSE_MALLOC_FAILED_HOOK 0 -#endif - -#ifndef portPRIVILEGE_BIT -# define portPRIVILEGE_BIT ((UBaseType_t)0x00) -#endif - -#ifndef portYIELD_WITHIN_API -# define portYIELD_WITHIN_API portYIELD -#endif - -#ifndef portSUPPRESS_TICKS_AND_SLEEP -# define portSUPPRESS_TICKS_AND_SLEEP(xExpectedIdleTime) -#endif - -#ifndef configEXPECTED_IDLE_TIME_BEFORE_SLEEP -# define configEXPECTED_IDLE_TIME_BEFORE_SLEEP 2 -#endif - -#if configEXPECTED_IDLE_TIME_BEFORE_SLEEP < 2 -# error configEXPECTED_IDLE_TIME_BEFORE_SLEEP must not be less than 2 -#endif - -#ifndef configUSE_TICKLESS_IDLE -# define configUSE_TICKLESS_IDLE 0 -#endif - -#ifndef configPRE_SUPPRESS_TICKS_AND_SLEEP_PROCESSING -# define configPRE_SUPPRESS_TICKS_AND_SLEEP_PROCESSING(x) -#endif - -#ifndef configPRE_SLEEP_PROCESSING -# define configPRE_SLEEP_PROCESSING(x) -#endif - -#ifndef configPOST_SLEEP_PROCESSING -# define configPOST_SLEEP_PROCESSING(x) -#endif - -#ifndef configUSE_QUEUE_SETS -# define configUSE_QUEUE_SETS 0 -#endif - -#ifndef portTASK_USES_FLOATING_POINT -# define portTASK_USES_FLOATING_POINT() -#endif - -#ifndef portALLOCATE_SECURE_CONTEXT -# define portALLOCATE_SECURE_CONTEXT(ulSecureStackSize) -#endif - -#ifndef portDONT_DISCARD -# define portDONT_DISCARD -#endif - -#ifndef configUSE_TIME_SLICING -# define configUSE_TIME_SLICING 1 -#endif - -#ifndef configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS -# define configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS 0 -#endif - -#ifndef configUSE_STATS_FORMATTING_FUNCTIONS -# define configUSE_STATS_FORMATTING_FUNCTIONS 0 -#endif - -#ifndef portASSERT_IF_INTERRUPT_PRIORITY_INVALID -# define portASSERT_IF_INTERRUPT_PRIORITY_INVALID() -#endif - -#ifndef configUSE_TRACE_FACILITY -# define configUSE_TRACE_FACILITY 0 -#endif - -#ifndef mtCOVERAGE_TEST_MARKER -# define mtCOVERAGE_TEST_MARKER() -#endif - -#ifndef mtCOVERAGE_TEST_DELAY -# define mtCOVERAGE_TEST_DELAY() -#endif - -#ifndef portASSERT_IF_IN_ISR -# define portASSERT_IF_IN_ISR() -#endif - -#ifndef configUSE_PORT_OPTIMISED_TASK_SELECTION -# define configUSE_PORT_OPTIMISED_TASK_SELECTION 0 -#endif - -#ifndef configAPPLICATION_ALLOCATED_HEAP -# define configAPPLICATION_ALLOCATED_HEAP 0 -#endif - -#ifndef configUSE_TASK_NOTIFICATIONS -# define configUSE_TASK_NOTIFICATIONS 1 -#endif - -#ifndef configUSE_POSIX_ERRNO -# define configUSE_POSIX_ERRNO 0 -#endif - -#ifndef portTICK_TYPE_IS_ATOMIC -# define portTICK_TYPE_IS_ATOMIC 0 -#endif - -#ifndef configSUPPORT_STATIC_ALLOCATION -/* Defaults to 0 for backward compatibility. */ -# define configSUPPORT_STATIC_ALLOCATION 0 -#endif - -#ifndef configSUPPORT_DYNAMIC_ALLOCATION -/* Defaults to 1 for backward compatibility. */ -# define configSUPPORT_DYNAMIC_ALLOCATION 1 -#endif - -#ifndef configSTACK_DEPTH_TYPE -/* Defaults to uint16_t for backward compatibility, but can be overridden -in FreeRTOSConfig.h if uint16_t is too restrictive. */ -# define configSTACK_DEPTH_TYPE uint16_t -#endif - -#ifndef configMESSAGE_BUFFER_LENGTH_TYPE -/* Defaults to size_t for backward compatibility, but can be overridden -in FreeRTOSConfig.h if lengths will always be less than the number of bytes -in a size_t. */ -# define configMESSAGE_BUFFER_LENGTH_TYPE size_t -#endif - -/* Sanity check the configuration. */ -#if (configUSE_TICKLESS_IDLE != 0) -# if (INCLUDE_vTaskSuspend != 1) -# error INCLUDE_vTaskSuspend must be set to 1 if configUSE_TICKLESS_IDLE is not set to 0 -# endif /* INCLUDE_vTaskSuspend */ -#endif /* configUSE_TICKLESS_IDLE */ - -#if ( \ - (configSUPPORT_STATIC_ALLOCATION == 0) && \ - (configSUPPORT_DYNAMIC_ALLOCATION == 0)) -# error configSUPPORT_STATIC_ALLOCATION and configSUPPORT_DYNAMIC_ALLOCATION cannot both be 0, but can both be 1. -#endif - -#if ((configUSE_RECURSIVE_MUTEXES == 1) && (configUSE_MUTEXES != 1)) -# error configUSE_MUTEXES must be set to 1 to use recursive mutexes -#endif - -#ifndef configINITIAL_TICK_COUNT -# define configINITIAL_TICK_COUNT 0 -#endif - -#if (portTICK_TYPE_IS_ATOMIC == 0) -/* Either variables of tick type cannot be read atomically, or -portTICK_TYPE_IS_ATOMIC was not set - map the critical sections used when -the tick count is returned to the standard critical section macros. */ -# define portTICK_TYPE_ENTER_CRITICAL() portENTER_CRITICAL() -# define portTICK_TYPE_EXIT_CRITICAL() portEXIT_CRITICAL() -# define portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR() \ - portSET_INTERRUPT_MASK_FROM_ISR() -# define portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR(x) \ - portCLEAR_INTERRUPT_MASK_FROM_ISR((x)) -#else -/* The tick type can be read atomically, so critical sections used when the -tick count is returned can be defined away. */ -# define portTICK_TYPE_ENTER_CRITICAL() -# define portTICK_TYPE_EXIT_CRITICAL() -# define portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR() 0 -# define portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR(x) (void)x -#endif - -/* Definitions to allow backward compatibility with FreeRTOS versions prior to -V8 if desired. */ -#ifndef configENABLE_BACKWARD_COMPATIBILITY -# define configENABLE_BACKWARD_COMPATIBILITY 1 -#endif - -#ifndef configPRINTF -/* configPRINTF() was not defined, so define it away to nothing. To use -configPRINTF() then define it as follows (where MyPrintFunction() is -provided by the application writer): - -void MyPrintFunction(const char *pcFormat, ... ); -#define configPRINTF( X ) MyPrintFunction X - -Then call like a standard printf() function, but placing brackets around -all parameters so they are passed as a single parameter. For example: -configPRINTF( ("Value = %d", MyVariable) ); */ -# define configPRINTF(X) -#endif - -#ifndef configMAX -/* The application writer has not provided their own MAX macro, so define -the following generic implementation. */ -# define configMAX(a, b) (((a) > (b)) ? (a) : (b)) -#endif - -#ifndef configMIN -/* The application writer has not provided their own MAX macro, so define -the following generic implementation. */ -# define configMIN(a, b) (((a) < (b)) ? (a) : (b)) -#endif - -#if configENABLE_BACKWARD_COMPATIBILITY == 1 -# define eTaskStateGet eTaskGetState -# define portTickType TickType_t -# define xTaskHandle TaskHandle_t -# define xQueueHandle QueueHandle_t -# define xSemaphoreHandle SemaphoreHandle_t -# define xQueueSetHandle QueueSetHandle_t -# define xQueueSetMemberHandle QueueSetMemberHandle_t -# define xTimeOutType TimeOut_t -# define xMemoryRegion MemoryRegion_t -# define xTaskParameters TaskParameters_t -# define xTaskStatusType TaskStatus_t -# define xTimerHandle TimerHandle_t -# define xCoRoutineHandle CoRoutineHandle_t -# define pdTASK_HOOK_CODE TaskHookFunction_t -# define portTICK_RATE_MS portTICK_PERIOD_MS -# define pcTaskGetTaskName pcTaskGetName -# define pcTimerGetTimerName pcTimerGetName -# define pcQueueGetQueueName pcQueueGetName -# define vTaskGetTaskInfo vTaskGetInfo -# define xTaskGetIdleRunTimeCounter ulTaskGetIdleRunTimeCounter - -/* Backward compatibility within the scheduler code only - these definitions -are not really required but are included for completeness. */ -# define tmrTIMER_CALLBACK TimerCallbackFunction_t -# define pdTASK_CODE TaskFunction_t -# define xListItem ListItem_t -# define xList List_t - -/* For libraries that break the list data hiding, and access list structure -members directly (which is not supposed to be done). */ -# define pxContainer pvContainer -#endif /* configENABLE_BACKWARD_COMPATIBILITY */ - -#if (configUSE_ALTERNATIVE_API != 0) -# error The alternative API was deprecated some time ago, and was removed in FreeRTOS V9.0 0 -#endif - -/* Set configUSE_TASK_FPU_SUPPORT to 0 to omit floating point support even -if floating point hardware is otherwise supported by the FreeRTOS port in use. -This constant is not supported by all FreeRTOS ports that include floating -point support. */ -#ifndef configUSE_TASK_FPU_SUPPORT -# define configUSE_TASK_FPU_SUPPORT 1 -#endif - -/* Set configENABLE_MPU to 1 to enable MPU support and 0 to disable it. This is -currently used in ARMv8M ports. */ -#ifndef configENABLE_MPU -# define configENABLE_MPU 0 -#endif - -/* Set configENABLE_FPU to 1 to enable FPU support and 0 to disable it. This is -currently used in ARMv8M ports. */ -#ifndef configENABLE_FPU -# define configENABLE_FPU 1 -#endif - -/* Set configENABLE_TRUSTZONE to 1 enable TrustZone support and 0 to disable it. -This is currently used in ARMv8M ports. */ -#ifndef configENABLE_TRUSTZONE -# define configENABLE_TRUSTZONE 1 -#endif - -/* Set configRUN_FREERTOS_SECURE_ONLY to 1 to run the FreeRTOS ARMv8M port on -the Secure Side only. */ -#ifndef configRUN_FREERTOS_SECURE_ONLY -# define configRUN_FREERTOS_SECURE_ONLY 0 -#endif - -/* Sometimes the FreeRTOSConfig.h settings only allow a task to be created using - * dynamically allocated RAM, in which case when any task is deleted it is known - * that both the task's stack and TCB need to be freed. Sometimes the - * FreeRTOSConfig.h settings only allow a task to be created using statically - * allocated RAM, in which case when any task is deleted it is known that - * neither the task's stack or TCB should be freed. Sometimes the - * FreeRTOSConfig.h settings allow a task to be created using either statically - * or dynamically allocated RAM, in which case a member of the TCB is used to - * record whether the stack and/or TCB were allocated statically or dynamically, - * so when a task is deleted the RAM that was allocated dynamically is freed - * again and no attempt is made to free the RAM that was allocated statically. - * tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE is only true if it is possible for - * a task to be created using either statically or dynamically allocated RAM. - * Note that if portUSING_MPU_WRAPPERS is 1 then a protected task can be created - * with a statically allocated stack and a dynamically allocated TCB. - * - * The following table lists various combinations of portUSING_MPU_WRAPPERS, - * configSUPPORT_DYNAMIC_ALLOCATION and configSUPPORT_STATIC_ALLOCATION and - * when it is possible to have both static and dynamic allocation: - * +-----+---------+--------+-----------------------------+-----------------------------------+------------------+-----------+ - * | MPU | Dynamic | Static | Available Functions | Possible - * Allocations | Both Dynamic and | Need Free | | | | | | | - * Static Possible | | - * +-----+---------+--------+-----------------------------+-----------------------------------+------------------+-----------+ - * | 0 | 0 | 1 | xTaskCreateStatic | TCB - Static, Stack - * - Static | No | No | - * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------| - * | 0 | 1 | 0 | xTaskCreate | TCB - Dynamic, Stack - * - Dynamic | No | Yes | - * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------| - * | 0 | 1 | 1 | xTaskCreate, | 1. TCB - Dynamic, - * Stack - Dynamic | Yes | Yes | | | | | - * xTaskCreateStatic | 2. TCB - Static, Stack - Static | | | - * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------| - * | 1 | 0 | 1 | xTaskCreateStatic, | TCB - Static, Stack - * - Static | No | No | | | | | - * xTaskCreateRestrictedStatic | | | | - * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------| - * | 1 | 1 | 0 | xTaskCreate, | 1. TCB - Dynamic, - * Stack - Dynamic | Yes | Yes | | | | | - * xTaskCreateRestricted | 2. TCB - Dynamic, Stack - Static | | | - * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------| - * | 1 | 1 | 1 | xTaskCreate, | 1. TCB - Dynamic, - * Stack - Dynamic | Yes | Yes | | | | | - * xTaskCreateStatic, | 2. TCB - Dynamic, Stack - Static | | | | | - * | | xTaskCreateRestricted, | 3. TCB - Static, Stack - Static | - * | | | | | | xTaskCreateRestrictedStatic | | | | - * +-----+---------+--------+-----------------------------+-----------------------------------+------------------+-----------+ - */ -#define tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE \ - (((portUSING_MPU_WRAPPERS == 0) && \ - (configSUPPORT_DYNAMIC_ALLOCATION == 1) && \ - (configSUPPORT_STATIC_ALLOCATION == 1)) || \ - ((portUSING_MPU_WRAPPERS == 1) && \ - (configSUPPORT_DYNAMIC_ALLOCATION == 1))) - -/* - * In line with software engineering best practice, FreeRTOS implements a strict - * data hiding policy, so the real structures used by FreeRTOS to maintain the - * state of tasks, queues, semaphores, etc. are not accessible to the - * application code. However, if the application writer wants to statically - * allocate such an object then the size of the object needs to be know. Dummy - * structures that are guaranteed to have the same size and alignment - * requirements of the real objects are used for this purpose. The dummy list - * and list item structures below are used for inclusion in such a dummy - * structure. - */ -struct xSTATIC_LIST_ITEM { -#if (configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 1) - TickType_t xDummy1; -#endif - TickType_t xDummy2; - void *pvDummy3[4]; -#if (configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 1) - TickType_t xDummy4; -#endif -}; -typedef struct xSTATIC_LIST_ITEM StaticListItem_t; - -/* See the comments above the struct xSTATIC_LIST_ITEM definition. */ -struct xSTATIC_MINI_LIST_ITEM { -#if (configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 1) - TickType_t xDummy1; -#endif - TickType_t xDummy2; - void *pvDummy3[2]; -}; -typedef struct xSTATIC_MINI_LIST_ITEM StaticMiniListItem_t; - -/* See the comments above the struct xSTATIC_LIST_ITEM definition. */ -typedef struct xSTATIC_LIST { -#if (configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 1) - TickType_t xDummy1; -#endif - UBaseType_t uxDummy2; - void *pvDummy3; - StaticMiniListItem_t xDummy4; -#if (configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 1) - TickType_t xDummy5; -#endif -} StaticList_t; - -/* - * In line with software engineering best practice, especially when supplying a - * library that is likely to change in future versions, FreeRTOS implements a - * strict data hiding policy. This means the Task structure used internally by - * FreeRTOS is not accessible to application code. However, if the application - * writer wants to statically allocate the memory required to create a task then - * the size of the task object needs to be know. The StaticTask_t structure - * below is provided for this purpose. Its sizes and alignment requirements are - * guaranteed to match those of the genuine structure, no matter which - * architecture is being used, and no matter how the values in FreeRTOSConfig.h - * are set. Its contents are somewhat obfuscated in the hope users will - * recognise that it would be unwise to make direct use of the structure - * members. - */ -typedef struct xSTATIC_TCB { - void *pxDummy1; -#if (portUSING_MPU_WRAPPERS == 1) - xMPU_SETTINGS xDummy2; -#endif - StaticListItem_t xDummy3[2]; - UBaseType_t uxDummy5; - void *pxDummy6; - uint8_t ucDummy7[configMAX_TASK_NAME_LEN]; -#if ((portSTACK_GROWTH > 0) || (configRECORD_STACK_HIGH_ADDRESS == 1)) - void *pxDummy8; -#endif -#if (portCRITICAL_NESTING_IN_TCB == 1) - UBaseType_t uxDummy9; -#endif -#if (configUSE_TRACE_FACILITY == 1) - UBaseType_t uxDummy10[2]; -#endif -#if (configUSE_MUTEXES == 1) - UBaseType_t uxDummy12[2]; -#endif -#if (configUSE_APPLICATION_TASK_TAG == 1) - void *pxDummy14; -#endif -#if (configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0) - void *pvDummy15[configNUM_THREAD_LOCAL_STORAGE_POINTERS]; -#endif -#if (configGENERATE_RUN_TIME_STATS == 1) - uint32_t ulDummy16; -#endif -#if (configUSE_NEWLIB_REENTRANT == 1) - struct _reent xDummy17; -#endif -#if (configUSE_TASK_NOTIFICATIONS == 1) - uint32_t ulDummy18; - uint8_t ucDummy19; -#endif -#if (tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0) - uint8_t uxDummy20; -#endif - -#if (INCLUDE_xTaskAbortDelay == 1) - uint8_t ucDummy21; -#endif -#if (configUSE_POSIX_ERRNO == 1) - int iDummy22; -#endif -} StaticTask_t; - -/* - * In line with software engineering best practice, especially when supplying a - * library that is likely to change in future versions, FreeRTOS implements a - * strict data hiding policy. This means the Queue structure used internally by - * FreeRTOS is not accessible to application code. However, if the application - * writer wants to statically allocate the memory required to create a queue - * then the size of the queue object needs to be know. The StaticQueue_t - * structure below is provided for this purpose. Its sizes and alignment - * requirements are guaranteed to match those of the genuine structure, no - * matter which architecture is being used, and no matter how the values in - * FreeRTOSConfig.h are set. Its contents are somewhat obfuscated in the hope - * users will recognise that it would be unwise to make direct use of the - * structure members. - */ -typedef struct xSTATIC_QUEUE { - void *pvDummy1[3]; - - union { - void *pvDummy2; - UBaseType_t uxDummy2; - } u; - - StaticList_t xDummy3[2]; - UBaseType_t uxDummy4[3]; - uint8_t ucDummy5[2]; - -#if ( \ - (configSUPPORT_STATIC_ALLOCATION == 1) && \ - (configSUPPORT_DYNAMIC_ALLOCATION == 1)) - uint8_t ucDummy6; -#endif - -#if (configUSE_QUEUE_SETS == 1) - void *pvDummy7; -#endif - -#if (configUSE_TRACE_FACILITY == 1) - UBaseType_t uxDummy8; - uint8_t ucDummy9; -#endif - -} StaticQueue_t; -typedef StaticQueue_t StaticSemaphore_t; - -/* - * In line with software engineering best practice, especially when supplying a - * library that is likely to change in future versions, FreeRTOS implements a - * strict data hiding policy. This means the event group structure used - * internally by FreeRTOS is not accessible to application code. However, if - * the application writer wants to statically allocate the memory required to - * create an event group then the size of the event group object needs to be - * know. The StaticEventGroup_t structure below is provided for this purpose. - * Its sizes and alignment requirements are guaranteed to match those of the - * genuine structure, no matter which architecture is being used, and no matter - * how the values in FreeRTOSConfig.h are set. Its contents are somewhat - * obfuscated in the hope users will recognise that it would be unwise to make - * direct use of the structure members. - */ -typedef struct xSTATIC_EVENT_GROUP { - TickType_t xDummy1; - StaticList_t xDummy2; - -#if (configUSE_TRACE_FACILITY == 1) - UBaseType_t uxDummy3; -#endif - -#if ( \ - (configSUPPORT_STATIC_ALLOCATION == 1) && \ - (configSUPPORT_DYNAMIC_ALLOCATION == 1)) - uint8_t ucDummy4; -#endif - -} StaticEventGroup_t; - -/* - * In line with software engineering best practice, especially when supplying a - * library that is likely to change in future versions, FreeRTOS implements a - * strict data hiding policy. This means the software timer structure used - * internally by FreeRTOS is not accessible to application code. However, if - * the application writer wants to statically allocate the memory required to - * create a software timer then the size of the queue object needs to be know. - * The StaticTimer_t structure below is provided for this purpose. Its sizes - * and alignment requirements are guaranteed to match those of the genuine - * structure, no matter which architecture is being used, and no matter how the - * values in FreeRTOSConfig.h are set. Its contents are somewhat obfuscated in - * the hope users will recognise that it would be unwise to make direct use of - * the structure members. - */ -typedef struct xSTATIC_TIMER { - void *pvDummy1; - StaticListItem_t xDummy2; - TickType_t xDummy3; - void *pvDummy5; - TaskFunction_t pvDummy6; -#if (configUSE_TRACE_FACILITY == 1) - UBaseType_t uxDummy7; -#endif - uint8_t ucDummy8; - -} StaticTimer_t; - -/* - * In line with software engineering best practice, especially when supplying a - * library that is likely to change in future versions, FreeRTOS implements a - * strict data hiding policy. This means the stream buffer structure used - * internally by FreeRTOS is not accessible to application code. However, if - * the application writer wants to statically allocate the memory required to - * create a stream buffer then the size of the stream buffer object needs to be - * know. The StaticStreamBuffer_t structure below is provided for this purpose. - * Its size and alignment requirements are guaranteed to match those of the - * genuine structure, no matter which architecture is being used, and no matter - * how the values in FreeRTOSConfig.h are set. Its contents are somewhat - * obfuscated in the hope users will recognise that it would be unwise to make - * direct use of the structure members. - */ -typedef struct xSTATIC_STREAM_BUFFER { - size_t uxDummy1[4]; - void *pvDummy2[3]; - uint8_t ucDummy3; -#if (configUSE_TRACE_FACILITY == 1) - UBaseType_t uxDummy4; -#endif -} StaticStreamBuffer_t; - -/* Message buffers are built on stream buffers. */ -typedef StaticStreamBuffer_t StaticMessageBuffer_t; - -#ifdef __cplusplus -} -#endif - -#endif /* INC_FREERTOS_H */ diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/include/deprecated_definitions.h b/product/rcar/src/CMSIS-FreeRTOS/Source/include/deprecated_definitions.h deleted file mode 100644 index 82bc047aeef3b8272bfc2b3ab74b9cddf753d9d3..0000000000000000000000000000000000000000 --- a/product/rcar/src/CMSIS-FreeRTOS/Source/include/deprecated_definitions.h +++ /dev/null @@ -1,277 +0,0 @@ -/* - * FreeRTOS Kernel V10.3.1 - * 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://www.FreeRTOS.org - * http://aws.amazon.com/freertos - * - * 1 tab == 4 spaces! - */ - -#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 "..\portable\BCC\16BitDOS\PC\prtmacro.h" -# include "frconfig.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 "..\portable\BCC\16BitDOS\flsh186\prtmacro.h" -# include "frconfig.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 */ diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/include/list.h b/product/rcar/src/CMSIS-FreeRTOS/Source/include/list.h deleted file mode 100644 index 5f80895f87dda39f540d2df18e08536b9052ddb5..0000000000000000000000000000000000000000 --- a/product/rcar/src/CMSIS-FreeRTOS/Source/include/list.h +++ /dev/null @@ -1,465 +0,0 @@ -/* - * FreeRTOS Kernel V10.3.1 - * 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://www.FreeRTOS.org - * http://aws.amazon.com/freertos - * - * 1 tab == 4 spaces! - */ - -/* - * 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 - * descending 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 to 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 INC_FREERTOS_H -# error FreeRTOS.h must be included before list.h -#endif - -#ifndef LIST_H -# define LIST_H - -/* - * 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 */ - -# ifdef __cplusplus -extern "C" { -# endif - -/* 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 -/* 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 - descending - 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; /* For some reason lint wants this as two - separate definitions. */ - -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; - -/* - * 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. */ - 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 descending 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 - */ -# define listGET_OWNER_OF_NEXT_ENTRY(pxTCB, pxList) \ - { \ - 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)->pxIndex->pxNext; \ - } \ - (pxTCB) = (pxConstList)->pxIndex->pvOwner; \ - } - -/* - * 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 (descending 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; - -# ifdef __cplusplus -} -# endif - -#endif diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/include/mpu_wrappers.h b/product/rcar/src/CMSIS-FreeRTOS/Source/include/mpu_wrappers.h deleted file mode 100644 index e59c57ad3740c7b05597cdac2f690bc4de7e7558..0000000000000000000000000000000000000000 --- a/product/rcar/src/CMSIS-FreeRTOS/Source/include/mpu_wrappers.h +++ /dev/null @@ -1,195 +0,0 @@ -/* - * FreeRTOS Kernel V10.3.1 - * 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://www.FreeRTOS.org - * http://aws.amazon.com/freertos - * - * 1 tab == 4 spaces! - */ - -#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. */ -#ifdef portUSING_MPU_WRAPPERS - -/* 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 tasks.h API functions to the MPU equivalents. */ -# define xTaskCreate MPU_xTaskCreate -# define xTaskCreateStatic MPU_xTaskCreateStatic -# define xTaskCreateRestricted MPU_xTaskCreateRestricted -# define vTaskAllocateMPURegions MPU_vTaskAllocateMPURegions -# define vTaskDelete MPU_vTaskDelete -# define vTaskDelay MPU_vTaskDelay -# define vTaskDelayUntil MPU_vTaskDelayUntil -# define xTaskAbortDelay MPU_xTaskAbortDelay -# define uxTaskPriorityGet MPU_uxTaskPriorityGet -# define eTaskGetState MPU_eTaskGetState -# define vTaskGetInfo MPU_vTaskGetInfo -# define vTaskPrioritySet MPU_vTaskPrioritySet -# define vTaskSuspend MPU_vTaskSuspend -# define vTaskResume MPU_vTaskResume -# define vTaskSuspendAll MPU_vTaskSuspendAll -# define xTaskResumeAll MPU_xTaskResumeAll -# define xTaskGetTickCount MPU_xTaskGetTickCount -# define uxTaskGetNumberOfTasks MPU_uxTaskGetNumberOfTasks -# define pcTaskGetName MPU_pcTaskGetName -# define xTaskGetHandle MPU_xTaskGetHandle -# 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 xTaskCallApplicationTaskHook MPU_xTaskCallApplicationTaskHook -# define xTaskGetIdleTaskHandle MPU_xTaskGetIdleTaskHandle -# define uxTaskGetSystemState MPU_uxTaskGetSystemState -# define vTaskList MPU_vTaskList -# define vTaskGetRunTimeStats MPU_vTaskGetRunTimeStats -# define ulTaskGetIdleRunTimeCounter MPU_ulTaskGetIdleRunTimeCounter -# define xTaskGenericNotify MPU_xTaskGenericNotify -# define xTaskNotifyWait MPU_xTaskNotifyWait -# define ulTaskNotifyTake MPU_ulTaskNotifyTake -# define xTaskNotifyStateClear MPU_xTaskNotifyStateClear -# define ulTaskNotifyValueClear MPU_ulTaskNotifyValueClear -# define xTaskCatchUpTicks MPU_xTaskCatchUpTicks - -# define xTaskGetCurrentTaskHandle MPU_xTaskGetCurrentTaskHandle -# define vTaskSetTimeOutState MPU_vTaskSetTimeOutState -# define xTaskCheckForTimeOut MPU_xTaskCheckForTimeOut -# define xTaskGetSchedulerState MPU_xTaskGetSchedulerState - -/* 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 vQueueDelete MPU_vQueueDelete -# define xQueueCreateMutex MPU_xQueueCreateMutex -# define xQueueCreateMutexStatic MPU_xQueueCreateMutexStatic -# define xQueueCreateCountingSemaphore MPU_xQueueCreateCountingSemaphore -# define xQueueCreateCountingSemaphoreStatic \ - MPU_xQueueCreateCountingSemaphoreStatic -# define xQueueGetMutexHolder MPU_xQueueGetMutexHolder -# define xQueueTakeMutexRecursive MPU_xQueueTakeMutexRecursive -# define xQueueGiveMutexRecursive MPU_xQueueGiveMutexRecursive -# define xQueueGenericCreate MPU_xQueueGenericCreate -# define xQueueGenericCreateStatic MPU_xQueueGenericCreateStatic -# define xQueueCreateSet MPU_xQueueCreateSet -# define xQueueAddToSet MPU_xQueueAddToSet -# define xQueueRemoveFromSet MPU_xQueueRemoveFromSet -# define xQueueSelectFromSet MPU_xQueueSelectFromSet -# define xQueueGenericReset MPU_xQueueGenericReset - -# if (configQUEUE_REGISTRY_SIZE > 0) -# define vQueueAddToRegistry MPU_vQueueAddToRegistry -# define vQueueUnregisterQueue MPU_vQueueUnregisterQueue -# define pcQueueGetName MPU_pcQueueGetName -# endif - -/* Map standard timer.h API functions to the MPU equivalents. */ -# define xTimerCreate MPU_xTimerCreate -# define xTimerCreateStatic MPU_xTimerCreateStatic -# define pvTimerGetTimerID MPU_pvTimerGetTimerID -# define vTimerSetTimerID MPU_vTimerSetTimerID -# define xTimerIsTimerActive MPU_xTimerIsTimerActive -# define xTimerGetTimerDaemonTaskHandle \ - MPU_xTimerGetTimerDaemonTaskHandle -# define xTimerPendFunctionCall MPU_xTimerPendFunctionCall -# define pcTimerGetName MPU_pcTimerGetName -# define vTimerSetReloadMode MPU_vTimerSetReloadMode -# define uxTimerGetReloadMode MPU_uxTimerGetReloadMode -# define xTimerGetPeriod MPU_xTimerGetPeriod -# define xTimerGetExpiryTime MPU_xTimerGetExpiryTime -# define xTimerGenericCommand MPU_xTimerGenericCommand - -/* Map standard event_group.h API functions to the MPU equivalents. */ -# define xEventGroupCreate MPU_xEventGroupCreate -# define xEventGroupCreateStatic MPU_xEventGroupCreateStatic -# define xEventGroupWaitBits MPU_xEventGroupWaitBits -# define xEventGroupClearBits MPU_xEventGroupClearBits -# define xEventGroupSetBits MPU_xEventGroupSetBits -# define xEventGroupSync MPU_xEventGroupSync -# define vEventGroupDelete MPU_vEventGroupDelete - -/* Map standard message/stream_buffer.h API functions to the MPU -equivalents. */ -# define xStreamBufferSend MPU_xStreamBufferSend -# define xStreamBufferReceive MPU_xStreamBufferReceive -# define xStreamBufferNextMessageLengthBytes \ - MPU_xStreamBufferNextMessageLengthBytes -# define vStreamBufferDelete MPU_vStreamBufferDelete -# define xStreamBufferIsFull MPU_xStreamBufferIsFull -# define xStreamBufferIsEmpty MPU_xStreamBufferIsEmpty -# define xStreamBufferReset MPU_xStreamBufferReset -# define xStreamBufferSpacesAvailable MPU_xStreamBufferSpacesAvailable -# define xStreamBufferBytesAvailable MPU_xStreamBufferBytesAvailable -# define xStreamBufferSetTriggerLevel MPU_xStreamBufferSetTriggerLevel -# define xStreamBufferGenericCreate MPU_xStreamBufferGenericCreate -# define xStreamBufferGenericCreateStatic \ - MPU_xStreamBufferGenericCreateStatic - -/* Remove the privileged function macro, but keep the PRIVILEGED_DATA -macro so applications can place data in privileged access sections -(useful when using statically allocated objects). */ -# define PRIVILEGED_FUNCTION -# define PRIVILEGED_DATA __attribute__((section("privileged_data"))) -# define FREERTOS_SYSTEM_CALL - -# else /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */ - -/* Ensure API functions go in the privileged execution section. */ -# define PRIVILEGED_FUNCTION \ - __attribute__((section("privileged_functions"))) -# define PRIVILEGED_DATA __attribute__((section("privileged_data"))) -# define FREERTOS_SYSTEM_CALL \ - __attribute__((section("freertos_system_calls"))) - -# endif /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */ - -#else /* portUSING_MPU_WRAPPERS */ - -# define PRIVILEGED_FUNCTION -# define PRIVILEGED_DATA -# define FREERTOS_SYSTEM_CALL -# define portUSING_MPU_WRAPPERS 0 - -#endif /* portUSING_MPU_WRAPPERS */ - -#endif /* MPU_WRAPPERS_H */ diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/include/portable.h b/product/rcar/src/CMSIS-FreeRTOS/Source/include/portable.h deleted file mode 100644 index 3661a89227c8b9bdf73f2218de901c811a803bc7..0000000000000000000000000000000000000000 --- a/product/rcar/src/CMSIS-FreeRTOS/Source/include/portable.h +++ /dev/null @@ -1,236 +0,0 @@ -/* - * FreeRTOS Kernel V10.3.1 - * 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://www.FreeRTOS.org - * http://aws.amazon.com/freertos - * - * 1 tab == 4 spaces! - */ - -/*----------------------------------------------------------- - * 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) -#endif - -#if portBYTE_ALIGNMENT == 16 -# define portBYTE_ALIGNMENT_MASK (0x000f) -#endif - -#if portBYTE_ALIGNMENT == 8 -# define portBYTE_ALIGNMENT_MASK (0x0007) -#endif - -#if portBYTE_ALIGNMENT == 4 -# define portBYTE_ALIGNMENT_MASK (0x0003) -#endif - -#if portBYTE_ALIGNMENT == 2 -# define portBYTE_ALIGNMENT_MASK (0x0001) -#endif - -#if portBYTE_ALIGNMENT == 1 -# define portBYTE_ALIGNMENT_MASK (0x0000) -#endif - -#ifndef portBYTE_ALIGNMENT_MASK -# error "Invalid portBYTE_ALIGNMENT definition" -#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 - -#ifdef __cplusplus -extern "C" { -#endif - -#include "mpu_wrappers.h" - -/* - * 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) PRIVILEGED_FUNCTION; -# else -StackType_t *pxPortInitialiseStack( - StackType_t *pxTopOfStack, - TaskFunction_t pxCode, - void *pvParameters, - BaseType_t xRunPrivileged) PRIVILEGED_FUNCTION; -# endif -#else -# 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 - -/* 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 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; - -/* - * 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, - uint32_t ulStackDepth) PRIVILEGED_FUNCTION; -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* PORTABLE_H */ diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/include/projdefs.h b/product/rcar/src/CMSIS-FreeRTOS/Source/include/projdefs.h deleted file mode 100644 index 09f99345954adcca042899ac75af1bad3f8d6e70..0000000000000000000000000000000000000000 --- a/product/rcar/src/CMSIS-FreeRTOS/Source/include/projdefs.h +++ /dev/null @@ -1,126 +0,0 @@ -/* - * FreeRTOS Kernel V10.3.1 - * 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://www.FreeRTOS.org - * http://aws.amazon.com/freertos - * - * 1 tab == 4 spaces! - */ - -#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 *); - -/* 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)( \ - ((TickType_t)(xTimeInMs) * (TickType_t)configTICK_RATE_HZ) / \ - (TickType_t)1000)) -#endif - -#define pdFALSE ((BaseType_t)0) -#define pdTRUE ((BaseType_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 (configUSE_16_BIT_TICKS == 1) -# define pdINTEGRITY_CHECK_VALUE 0x5a5a -#else -# define pdINTEGRITY_CHECK_VALUE 0x5a5a5a5aUL -#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_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 */ diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/include/queue.h b/product/rcar/src/CMSIS-FreeRTOS/Source/include/queue.h deleted file mode 100644 index 50f464df21c039f0afec0104eb876e085e5a2581..0000000000000000000000000000000000000000 --- a/product/rcar/src/CMSIS-FreeRTOS/Source/include/queue.h +++ /dev/null @@ -1,1783 +0,0 @@ -/* - * FreeRTOS Kernel V10.3.1 - * 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://www.FreeRTOS.org - * http://aws.amazon.com/freertos - * - * 1 tab == 4 spaces! - */ - -#ifndef QUEUE_H -#define QUEUE_H - -#ifndef INC_FREERTOS_H -# error "include FreeRTOS.h" must appear in source files before "include queue.h" -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -#include "task.h" - -/** - * Type by which queues are referenced. For example, a call to xQueueCreate() - * returns an QueueHandle_t variable that can then be used as a parameter to - * xQueueSend(), xQueueReceive(), etc. - */ -struct QueueDefinition; /* Using old naming convention so as not to break kernel - aware debuggers. */ -typedef struct QueueDefinition *QueueHandle_t; - -/** - * Type by which queue sets are referenced. For example, a call to - * xQueueCreateSet() returns an xQueueSet variable that can then be used as a - * parameter to xQueueSelectFromSet(), xQueueAddToSet(), etc. - */ -typedef struct QueueDefinition *QueueSetHandle_t; - -/** - * Queue sets can contain both queues and semaphores, so the - * QueueSetMemberHandle_t is defined as a type to be used where a parameter or - * return value can be either an QueueHandle_t or an SemaphoreHandle_t. - */ -typedef struct QueueDefinition *QueueSetMemberHandle_t; - -/* For internal use only. */ -#define queueSEND_TO_BACK ((BaseType_t)0) -#define queueSEND_TO_FRONT ((BaseType_t)1) -#define queueOVERWRITE ((BaseType_t)2) - -/* For internal use only. These definitions *must* match those in queue.c. */ -#define queueQUEUE_TYPE_BASE ((uint8_t)0U) -#define queueQUEUE_TYPE_SET ((uint8_t)0U) -#define queueQUEUE_TYPE_MUTEX ((uint8_t)1U) -#define queueQUEUE_TYPE_COUNTING_SEMAPHORE ((uint8_t)2U) -#define queueQUEUE_TYPE_BINARY_SEMAPHORE ((uint8_t)3U) -#define queueQUEUE_TYPE_RECURSIVE_MUTEX ((uint8_t)4U) - -/** - * queue. h - * 
- QueueHandle_t xQueueCreate(
-                              UBaseType_t uxQueueLength,
-                              UBaseType_t uxItemSize
-                          );
- *
- * - * Creates a new queue instance, and returns a handle by which the new queue - * can be referenced. - * - * Internally, within the FreeRTOS implementation, queues use two blocks of - * memory. The first block is used to hold the queue's data structures. The - * second block is used to hold items placed into the queue. If a queue is - * created using xQueueCreate() then both blocks of memory are automatically - * dynamically allocated inside the xQueueCreate() function. (see - * http://www.freertos.org/a00111.html). If a queue is created using - * xQueueCreateStatic() then the application writer must provide the memory that - * will get used by the queue. xQueueCreateStatic() therefore allows a queue to - * be created without using any dynamic memory allocation. - * - * http://www.FreeRTOS.org/Embedded-RTOS-Queues.html - * - * @param uxQueueLength The maximum number of items that the queue can contain. - * - * @param uxItemSize The number of bytes each item in the queue will require. - * Items are queued by copy, not by reference, so this is the number of bytes - * that will be copied for each posted item. Each item on the queue must be - * the same size. - * - * @return If the queue is successfully create then a handle to the newly - * created queue is returned. If the queue cannot be created then 0 is - * returned. - * - * Example usage: - 
- struct AMessage
- {
-    char ucMessageID;
-    char ucData[ 20 ];
- };
-
- void vATask( void *pvParameters )
- {
- QueueHandle_t xQueue1, xQueue2;
-
-    // Create a queue capable of containing 10 uint32_t values.
-    xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
-    if( xQueue1 == 0 )
-    {
-        // Queue was not created and must not be used.
-    }
-
-    // Create a queue capable of containing 10 pointers to AMessage structures.
-    // These should be passed by pointer as they contain a lot of data.
-    xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
-    if( xQueue2 == 0 )
-    {
-        // Queue was not created and must not be used.
-    }
-
-    // ... Rest of task code.
- }
-
- * \defgroup xQueueCreate xQueueCreate - * \ingroup QueueManagement - */ -#if (configSUPPORT_DYNAMIC_ALLOCATION == 1) -# define xQueueCreate(uxQueueLength, uxItemSize) \ - xQueueGenericCreate( \ - (uxQueueLength), (uxItemSize), (queueQUEUE_TYPE_BASE)) -#endif - -/** - * queue. h - * 
- QueueHandle_t xQueueCreateStatic(
-                              UBaseType_t uxQueueLength,
-                              UBaseType_t uxItemSize,
-                              uint8_t *pucQueueStorageBuffer,
-                              StaticQueue_t *pxQueueBuffer
-                          );
- *
- * - * Creates a new queue instance, and returns a handle by which the new queue - * can be referenced. - * - * Internally, within the FreeRTOS implementation, queues use two blocks of - * memory. The first block is used to hold the queue's data structures. The - * second block is used to hold items placed into the queue. If a queue is - * created using xQueueCreate() then both blocks of memory are automatically - * dynamically allocated inside the xQueueCreate() function. (see - * http://www.freertos.org/a00111.html). If a queue is created using - * xQueueCreateStatic() then the application writer must provide the memory that - * will get used by the queue. xQueueCreateStatic() therefore allows a queue to - * be created without using any dynamic memory allocation. - * - * http://www.FreeRTOS.org/Embedded-RTOS-Queues.html - * - * @param uxQueueLength The maximum number of items that the queue can contain. - * - * @param uxItemSize The number of bytes each item in the queue will require. - * Items are queued by copy, not by reference, so this is the number of bytes - * that will be copied for each posted item. Each item on the queue must be - * the same size. - * - * @param pucQueueStorageBuffer If uxItemSize is not zero then - * pucQueueStorageBuffer must point to a uint8_t array that is at least large - * enough to hold the maximum number of items that can be in the queue at any - * one time - which is ( uxQueueLength * uxItemsSize ) bytes. If uxItemSize is - * zero then pucQueueStorageBuffer can be NULL. - * - * @param pxQueueBuffer Must point to a variable of type StaticQueue_t, which - * will be used to hold the queue's data structure. - * - * @return If the queue is created then a handle to the created queue is - * returned. If pxQueueBuffer is NULL then NULL is returned. - * - * Example usage: - 
- struct AMessage
- {
-    char ucMessageID;
-    char ucData[ 20 ];
- };
-
- #define QUEUE_LENGTH 10
- #define ITEM_SIZE sizeof( uint32_t )
-
- // xQueueBuffer will hold the queue structure.
- StaticQueue_t xQueueBuffer;
-
- // ucQueueStorage will hold the items posted to the queue.  Must be at least
- // [(queue length) * ( queue item size)] bytes long.
- uint8_t ucQueueStorage[ QUEUE_LENGTH * ITEM_SIZE ];
-
- void vATask( void *pvParameters )
- {
- QueueHandle_t xQueue1;
-
-    // Create a queue capable of containing 10 uint32_t values.
-    xQueue1 = xQueueCreate( QUEUE_LENGTH, // The number of items the queue can
- hold. ITEM_SIZE	  // The size of each item in the queue
-                            &( ucQueueStorage[ 0 ] ), // The buffer that will
- hold the items in the queue. &xQueueBuffer ); // The buffer that will hold the
- queue structure.
-
-    // The queue is guaranteed to be created successfully as no dynamic memory
-    // allocation is used.  Therefore xQueue1 is now a handle to a valid queue.
-
-    // ... Rest of task code.
- }
-
- * \defgroup xQueueCreateStatic xQueueCreateStatic - * \ingroup QueueManagement - */ -#if (configSUPPORT_STATIC_ALLOCATION == 1) -# define xQueueCreateStatic( \ - uxQueueLength, uxItemSize, pucQueueStorage, pxQueueBuffer) \ - xQueueGenericCreateStatic( \ - (uxQueueLength), \ - (uxItemSize), \ - (pucQueueStorage), \ - (pxQueueBuffer), \ - (queueQUEUE_TYPE_BASE)) -#endif /* configSUPPORT_STATIC_ALLOCATION */ - -/** - * queue. h - * 
- BaseType_t xQueueSendToToFront(
-                                   QueueHandle_t	xQueue,
-                                   const void		*pvItemToQueue,
-                                   TickType_t		xTicksToWait
-                               );
- *
- * - * Post an item to the front of a queue. The item is queued by copy, not by - * reference. This function must not be called from an interrupt service - * routine. See xQueueSendFromISR () for an alternative which may be used - * in an ISR. - * - * @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 xTicksToWait The maximum amount of time the task should block - * waiting for space to become available on the queue, should it already - * be full. The call will return immediately if this is set to 0 and the - * queue is full. The time is defined in tick periods so the constant - * portTICK_PERIOD_MS should be used to convert to real time if this is - required. - * - * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL. - * - * Example usage: - 
- struct AMessage
- {
-    char ucMessageID;
-    char ucData[ 20 ];
- } xMessage;
-
- uint32_t ulVar = 10UL;
-
- void vATask( void *pvParameters )
- {
- QueueHandle_t xQueue1, xQueue2;
- struct AMessage *pxMessage;
-
-    // Create a queue capable of containing 10 uint32_t values.
-    xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
-
-    // Create a queue capable of containing 10 pointers to AMessage structures.
-    // These should be passed by pointer as they contain a lot of data.
-    xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
-
-    // ...
-
-    if( xQueue1 != 0 )
-    {
-        // Send an uint32_t.  Wait for 10 ticks for space to become
-        // available if necessary.
-        if( xQueueSendToFront( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 )
- != pdPASS )
-        {
-            // Failed to post the message, even after 10 ticks.
-        }
-    }
-
-    if( xQueue2 != 0 )
-    {
-        // Send a pointer to a struct AMessage object.  Don't block if the
-        // queue is already full.
-        pxMessage = & xMessage;
-        xQueueSendToFront( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
-    }
-
-    // ... Rest of task code.
- }
-
- * \defgroup xQueueSend xQueueSend - * \ingroup QueueManagement - */ -#define xQueueSendToFront(xQueue, pvItemToQueue, xTicksToWait) \ - xQueueGenericSend( \ - (xQueue), (pvItemToQueue), (xTicksToWait), queueSEND_TO_FRONT) - -/** - * queue. h - * 
- BaseType_t xQueueSendToBack(
-                                   QueueHandle_t	xQueue,
-                                   const void		*pvItemToQueue,
-                                   TickType_t		xTicksToWait
-                               );
- *
- * - * This is a macro that calls xQueueGenericSend(). - * - * Post an item to the back of a queue. The item is queued by copy, not by - * reference. This function must not be called from an interrupt service - * routine. See xQueueSendFromISR () for an alternative which may be used - * in an ISR. - * - * @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 xTicksToWait The maximum amount of time the task should block - * waiting for space to become available on the queue, should it already - * be full. The call will return immediately if this is set to 0 and the queue - * is full. The time is defined in tick periods so the constant - * portTICK_PERIOD_MS should be used to convert to real time if this is - required. - * - * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL. - * - * Example usage: - 
- struct AMessage
- {
-    char ucMessageID;
-    char ucData[ 20 ];
- } xMessage;
-
- uint32_t ulVar = 10UL;
-
- void vATask( void *pvParameters )
- {
- QueueHandle_t xQueue1, xQueue2;
- struct AMessage *pxMessage;
-
-    // Create a queue capable of containing 10 uint32_t values.
-    xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
-
-    // Create a queue capable of containing 10 pointers to AMessage structures.
-    // These should be passed by pointer as they contain a lot of data.
-    xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
-
-    // ...
-
-    if( xQueue1 != 0 )
-    {
-        // Send an uint32_t.  Wait for 10 ticks for space to become
-        // available if necessary.
-        if( xQueueSendToBack( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) !=
- pdPASS )
-        {
-            // Failed to post the message, even after 10 ticks.
-        }
-    }
-
-    if( xQueue2 != 0 )
-    {
-        // Send a pointer to a struct AMessage object.  Don't block if the
-        // queue is already full.
-        pxMessage = & xMessage;
-        xQueueSendToBack( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
-    }
-
-    // ... Rest of task code.
- }
-
- * \defgroup xQueueSend xQueueSend - * \ingroup QueueManagement - */ -#define xQueueSendToBack(xQueue, pvItemToQueue, xTicksToWait) \ - xQueueGenericSend( \ - (xQueue), (pvItemToQueue), (xTicksToWait), queueSEND_TO_BACK) - -/** - * queue. h - * 
- BaseType_t xQueueSend(
-                              QueueHandle_t xQueue,
-                              const void * pvItemToQueue,
-                              TickType_t xTicksToWait
-                         );
- *
- * - * This is a macro that calls xQueueGenericSend(). It is included for - * backward compatibility with versions of FreeRTOS.org that did not - * include the xQueueSendToFront() and xQueueSendToBack() macros. It is - * equivalent to xQueueSendToBack(). - * - * Post an item on a queue. The item is queued by copy, not by reference. - * This function must not be called from an interrupt service routine. - * See xQueueSendFromISR () for an alternative which may be used in an ISR. - * - * @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 xTicksToWait The maximum amount of time the task should block - * waiting for space to become available on the queue, should it already - * be full. The call will return immediately if this is set to 0 and the - * queue is full. The time is defined in tick periods so the constant - * portTICK_PERIOD_MS should be used to convert to real time if this is - required. - * - * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL. - * - * Example usage: - 
- struct AMessage
- {
-    char ucMessageID;
-    char ucData[ 20 ];
- } xMessage;
-
- uint32_t ulVar = 10UL;
-
- void vATask( void *pvParameters )
- {
- QueueHandle_t xQueue1, xQueue2;
- struct AMessage *pxMessage;
-
-    // Create a queue capable of containing 10 uint32_t values.
-    xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
-
-    // Create a queue capable of containing 10 pointers to AMessage structures.
-    // These should be passed by pointer as they contain a lot of data.
-    xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
-
-    // ...
-
-    if( xQueue1 != 0 )
-    {
-        // Send an uint32_t.  Wait for 10 ticks for space to become
-        // available if necessary.
-        if( xQueueSend( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10 ) !=
- pdPASS )
-        {
-            // Failed to post the message, even after 10 ticks.
-        }
-    }
-
-    if( xQueue2 != 0 )
-    {
-        // Send a pointer to a struct AMessage object.  Don't block if the
-        // queue is already full.
-        pxMessage = & xMessage;
-        xQueueSend( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0 );
-    }
-
-    // ... Rest of task code.
- }
-
- * \defgroup xQueueSend xQueueSend - * \ingroup QueueManagement - */ -#define xQueueSend(xQueue, pvItemToQueue, xTicksToWait) \ - xQueueGenericSend( \ - (xQueue), (pvItemToQueue), (xTicksToWait), queueSEND_TO_BACK) - -/** - * queue. h - * 
- BaseType_t xQueueOverwrite(
-                              QueueHandle_t xQueue,
-                              const void * pvItemToQueue
-                         );
- *
- * - * Only for use with queues that have a length of one - so the queue is either - * empty or full. - * - * Post an item on a queue. If the queue is already full then overwrite the - * value held in the queue. The item is queued by copy, not by reference. - * - * This function must not be called from an interrupt service routine. - * See xQueueOverwriteFromISR () for an alternative which may be used in an ISR. - * - * @param xQueue The handle of the queue to which the data is being sent. - * - * @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. - * - * @return xQueueOverwrite() is a macro that calls xQueueGenericSend(), and - * therefore has the same return values as xQueueSendToFront(). However, pdPASS - * is the only value that can be returned because xQueueOverwrite() will write - * to the queue even when the queue is already full. - * - * Example usage: - 
-
- void vFunction( void *pvParameters )
- {
- QueueHandle_t xQueue;
- uint32_t ulVarToSend, ulValReceived;
-
-    // Create a queue to hold one uint32_t value.  It is strongly
-    // recommended *not* to use xQueueOverwrite() on queues that can
-    // contain more than one value, and doing so will trigger an assertion
-    // if configASSERT() is defined.
-    xQueue = xQueueCreate( 1, sizeof( uint32_t ) );
-
-    // Write the value 10 to the queue using xQueueOverwrite().
-    ulVarToSend = 10;
-    xQueueOverwrite( xQueue, &ulVarToSend );
-
-    // Peeking the queue should now return 10, but leave the value 10 in
-    // the queue.  A block time of zero is used as it is known that the
-    // queue holds a value.
-    ulValReceived = 0;
-    xQueuePeek( xQueue, &ulValReceived, 0 );
-
-    if( ulValReceived != 10 )
-    {
-        // Error unless the item was removed by a different task.
-    }
-
-    // The queue is still full.  Use xQueueOverwrite() to overwrite the
-    // value held in the queue with 100.
-    ulVarToSend = 100;
-    xQueueOverwrite( xQueue, &ulVarToSend );
-
-    // This time read from the queue, leaving the queue empty once more.
-    // A block time of 0 is used again.
-    xQueueReceive( xQueue, &ulValReceived, 0 );
-
-    // The value read should be the last value written, even though the
-    // queue was already full when the value was written.
-    if( ulValReceived != 100 )
-    {
-        // Error!
-    }
-
-    // ...
-}
-
- * \defgroup xQueueOverwrite xQueueOverwrite - * \ingroup QueueManagement - */ -#define xQueueOverwrite(xQueue, pvItemToQueue) \ - xQueueGenericSend((xQueue), (pvItemToQueue), 0, queueOVERWRITE) - -/** - * queue. h - * 
- BaseType_t xQueueGenericSend(
-                                    QueueHandle_t xQueue,
-                                    const void * pvItemToQueue,
-                                    TickType_t xTicksToWait
-                                    BaseType_t xCopyPosition
-                                );
- *
- * - * It is preferred that the macros xQueueSend(), xQueueSendToFront() and - * xQueueSendToBack() are used in place of calling this function directly. - * - * Post an item on a queue. The item is queued by copy, not by reference. - * This function must not be called from an interrupt service routine. - * See xQueueSendFromISR () for an alternative which may be used in an ISR. - * - * @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 xTicksToWait The maximum amount of time the task should block - * waiting for space to become available on the queue, should it already - * be full. The call will return immediately if this is set to 0 and the - * queue is full. The time is defined in tick periods so the constant - * portTICK_PERIOD_MS should be used to convert to real time if this is - required. - * - * @param xCopyPosition Can take the value queueSEND_TO_BACK to place the - * item at the back of the queue, or queueSEND_TO_FRONT to place the item - * at the front of the queue (for high priority messages). - * - * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL. - * - * Example usage: - 
- struct AMessage
- {
-    char ucMessageID;
-    char ucData[ 20 ];
- } xMessage;
-
- uint32_t ulVar = 10UL;
-
- void vATask( void *pvParameters )
- {
- QueueHandle_t xQueue1, xQueue2;
- struct AMessage *pxMessage;
-
-    // Create a queue capable of containing 10 uint32_t values.
-    xQueue1 = xQueueCreate( 10, sizeof( uint32_t ) );
-
-    // Create a queue capable of containing 10 pointers to AMessage structures.
-    // These should be passed by pointer as they contain a lot of data.
-    xQueue2 = xQueueCreate( 10, sizeof( struct AMessage * ) );
-
-    // ...
-
-    if( xQueue1 != 0 )
-    {
-        // Send an uint32_t.  Wait for 10 ticks for space to become
-        // available if necessary.
-        if( xQueueGenericSend( xQueue1, ( void * ) &ulVar, ( TickType_t ) 10,
- queueSEND_TO_BACK ) != pdPASS )
-        {
-            // Failed to post the message, even after 10 ticks.
-        }
-    }
-
-    if( xQueue2 != 0 )
-    {
-        // Send a pointer to a struct AMessage object.  Don't block if the
-        // queue is already full.
-        pxMessage = & xMessage;
-        xQueueGenericSend( xQueue2, ( void * ) &pxMessage, ( TickType_t ) 0,
- queueSEND_TO_BACK );
-    }
-
-    // ... Rest of task code.
- }
-
- * \defgroup xQueueSend xQueueSend - * \ingroup QueueManagement - */ -BaseType_t xQueueGenericSend( - QueueHandle_t xQueue, - const void *const pvItemToQueue, - TickType_t xTicksToWait, - const BaseType_t xCopyPosition) PRIVILEGED_FUNCTION; - -/** - * queue. h - * 
- BaseType_t xQueuePeek(
-                             QueueHandle_t xQueue,
-                             void * const pvBuffer,
-                             TickType_t xTicksToWait
-                         );
- * - * Receive an item from a queue without removing the item from the queue. - * The item is received by copy so a buffer of adequate size must be - * provided. The number of bytes copied into the buffer was defined when - * the queue was created. - * - * Successfully received items remain on the queue so will be returned again - * by the next call, or a call to xQueueReceive(). - * - * This macro must not be used in an interrupt service routine. See - * xQueuePeekFromISR() for an alternative that can be called from an interrupt - * service routine. - * - * @param xQueue The handle to the queue from which the item is to be - * received. - * - * @param pvBuffer Pointer to the buffer into which the received item will - * be copied. - * - * @param xTicksToWait The maximum amount of time the task should block - * waiting for an item to receive should the queue be empty at the time - * of the call. The time is defined in tick periods so the constant - * portTICK_PERIOD_MS should be used to convert to real time if this is - required. - * xQueuePeek() will return immediately if xTicksToWait is 0 and the queue - * is empty. - * - * @return pdTRUE if an item was successfully received from the queue, - * otherwise pdFALSE. - * - * Example usage: - 
- struct AMessage
- {
-    char ucMessageID;
-    char ucData[ 20 ];
- } xMessage;
-
- QueueHandle_t xQueue;
-
- // Task to create a queue and post a value.
- void vATask( void *pvParameters )
- {
- struct AMessage *pxMessage;
-
-    // Create a queue capable of containing 10 pointers to AMessage structures.
-    // These should be passed by pointer as they contain a lot of data.
-    xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
-    if( xQueue == 0 )
-    {
-        // Failed to create the queue.
-    }
-
-    // ...
-
-    // Send a pointer to a struct AMessage object.  Don't block if the
-    // queue is already full.
-    pxMessage = & xMessage;
-    xQueueSend( xQueue, ( void * ) &pxMessage, ( TickType_t ) 0 );
-
-    // ... Rest of task code.
- }
-
- // Task to peek the data from the queue.
- void vADifferentTask( void *pvParameters )
- {
- struct AMessage *pxRxedMessage;
-
-    if( xQueue != 0 )
-    {
-        // Peek a message on the created queue.  Block for 10 ticks if a
-        // message is not immediately available.
-        if( xQueuePeek( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
-        {
-            // pcRxedMessage now points to the struct AMessage variable posted
-            // by vATask, but the item still remains on the queue.
-        }
-    }
-
-    // ... Rest of task code.
- }
-
- * \defgroup xQueuePeek xQueuePeek - * \ingroup QueueManagement - */ -BaseType_t xQueuePeek( - QueueHandle_t xQueue, - void *const pvBuffer, - TickType_t xTicksToWait) PRIVILEGED_FUNCTION; - -/** - * queue. h - * 
- BaseType_t xQueuePeekFromISR(
-                                    QueueHandle_t xQueue,
-                                    void *pvBuffer,
-                                );
- * - * A version of xQueuePeek() that can be called from an interrupt service - * routine (ISR). - * - * Receive an item from a queue without removing the item from the queue. - * The item is received by copy so a buffer of adequate size must be - * provided. The number of bytes copied into the buffer was defined when - * the queue was created. - * - * Successfully received items remain on the queue so will be returned again - * by the next call, or a call to xQueueReceive(). - * - * @param xQueue The handle to the queue from which the item is to be - * received. - * - * @param pvBuffer Pointer to the buffer into which the received item will - * be copied. - * - * @return pdTRUE if an item was successfully received from the queue, - * otherwise pdFALSE. - * - * \defgroup xQueuePeekFromISR xQueuePeekFromISR - * \ingroup QueueManagement - */ -BaseType_t xQueuePeekFromISR(QueueHandle_t xQueue, void *const pvBuffer) - PRIVILEGED_FUNCTION; - -/** - * queue. h - * 
- BaseType_t xQueueReceive(
-                                 QueueHandle_t xQueue,
-                                 void *pvBuffer,
-                                 TickType_t xTicksToWait
-                            );
- * - * Receive an item from a queue. The item is received by copy so a buffer of - * adequate size must be provided. The number of bytes copied into the buffer - * was defined when the queue was created. - * - * Successfully received items are removed from the queue. - * - * This function must not be used in an interrupt service routine. See - * xQueueReceiveFromISR for an alternative that can. - * - * @param xQueue The handle to the queue from which the item is to be - * received. - * - * @param pvBuffer Pointer to the buffer into which the received item will - * be copied. - * - * @param xTicksToWait The maximum amount of time the task should block - * waiting for an item to receive should the queue be empty at the time - * of the call. xQueueReceive() will return immediately if xTicksToWait - * is zero and the queue is empty. The time is defined in tick periods so the - * constant portTICK_PERIOD_MS should be used to convert to real time if this is - * required. - * - * @return pdTRUE if an item was successfully received from the queue, - * otherwise pdFALSE. - * - * Example usage: - 
- struct AMessage
- {
-    char ucMessageID;
-    char ucData[ 20 ];
- } xMessage;
-
- QueueHandle_t xQueue;
-
- // Task to create a queue and post a value.
- void vATask( void *pvParameters )
- {
- struct AMessage *pxMessage;
-
-    // Create a queue capable of containing 10 pointers to AMessage structures.
-    // These should be passed by pointer as they contain a lot of data.
-    xQueue = xQueueCreate( 10, sizeof( struct AMessage * ) );
-    if( xQueue == 0 )
-    {
-        // Failed to create the queue.
-    }
-
-    // ...
-
-    // Send a pointer to a struct AMessage object.  Don't block if the
-    // queue is already full.
-    pxMessage = & xMessage;
-    xQueueSend( xQueue, ( void * ) &pxMessage, ( TickType_t ) 0 );
-
-    // ... Rest of task code.
- }
-
- // Task to receive from the queue.
- void vADifferentTask( void *pvParameters )
- {
- struct AMessage *pxRxedMessage;
-
-    if( xQueue != 0 )
-    {
-        // Receive a message on the created queue.  Block for 10 ticks if a
-        // message is not immediately available.
-        if( xQueueReceive( xQueue, &( pxRxedMessage ), ( TickType_t ) 10 ) )
-        {
-            // pcRxedMessage now points to the struct AMessage variable posted
-            // by vATask.
-        }
-    }
-
-    // ... Rest of task code.
- }
-
- * \defgroup xQueueReceive xQueueReceive - * \ingroup QueueManagement - */ -BaseType_t xQueueReceive( - QueueHandle_t xQueue, - void *const pvBuffer, - TickType_t xTicksToWait) PRIVILEGED_FUNCTION; - -/** - * queue. h - * 
UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue );
- * - * Return the number of messages stored in a queue. - * - * @param xQueue A handle to the queue being queried. - * - * @return The number of messages available in the queue. - * - * \defgroup uxQueueMessagesWaiting uxQueueMessagesWaiting - * \ingroup QueueManagement - */ -UBaseType_t uxQueueMessagesWaiting(const QueueHandle_t xQueue) - PRIVILEGED_FUNCTION; - -/** - * queue. h - * 
UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue );
- * - * Return the number of free spaces available in a queue. This is equal to the - * number of items that can be sent to the queue before the queue becomes full - * if no items are removed. - * - * @param xQueue A handle to the queue being queried. - * - * @return The number of spaces available in the queue. - * - * \defgroup uxQueueMessagesWaiting uxQueueMessagesWaiting - * \ingroup QueueManagement - */ -UBaseType_t uxQueueSpacesAvailable(const QueueHandle_t xQueue) - PRIVILEGED_FUNCTION; - -/** - * queue. h - * 
void vQueueDelete( QueueHandle_t xQueue );
- * - * Delete a queue - freeing all the memory allocated for storing of items - * placed on the queue. - * - * @param xQueue A handle to the queue to be deleted. - * - * \defgroup vQueueDelete vQueueDelete - * \ingroup QueueManagement - */ -void vQueueDelete(QueueHandle_t xQueue) PRIVILEGED_FUNCTION; - -/** - * queue. h - * 
- BaseType_t xQueueSendToFrontFromISR(
-                                         QueueHandle_t xQueue,
-                                         const void *pvItemToQueue,
-                                         BaseType_t *pxHigherPriorityTaskWoken
-                                      );
-
- * - * This is a macro that calls xQueueGenericSendFromISR(). - * - * Post an item to the front of a queue. It is safe to use this macro from - * within an interrupt service routine. - * - * Items are queued by copy not reference so it is preferable to only - * queue small items, especially when called from an ISR. In most cases - * it would be preferable to store a pointer to the item being queued. - * - * @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 pxHigherPriorityTaskWoken xQueueSendToFrontFromISR() will set - * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task - * to unblock, and the unblocked task has a priority higher than the currently - * running task. If xQueueSendToFromFromISR() sets this value to pdTRUE then - * a context switch should be requested before the interrupt is exited. - * - * @return pdTRUE if the data was successfully sent to the queue, otherwise - * errQUEUE_FULL. - * - * Example usage for buffered IO (where the ISR can obtain more than one value - * per call): - 
- void vBufferISR( void )
- {
- char cIn;
- BaseType_t xHigherPrioritTaskWoken;
-
-    // We have not woken a task at the start of the ISR.
-    xHigherPriorityTaskWoken = pdFALSE;
-
-    // Loop until the buffer is empty.
-    do
-    {
-        // Obtain a byte from the buffer.
-        cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
-
-        // Post the byte.
-        xQueueSendToFrontFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );
-
-    } while( portINPUT_BYTE( BUFFER_COUNT ) );
-
-    // Now the buffer is empty we can switch context if necessary.
-    if( xHigherPriorityTaskWoken )
-    {
-        taskYIELD ();
-    }
- }
-
- * - * \defgroup xQueueSendFromISR xQueueSendFromISR - * \ingroup QueueManagement - */ -#define xQueueSendToFrontFromISR( \ - xQueue, pvItemToQueue, pxHigherPriorityTaskWoken) \ - xQueueGenericSendFromISR( \ - (xQueue), \ - (pvItemToQueue), \ - (pxHigherPriorityTaskWoken), \ - queueSEND_TO_FRONT) - -/** - * queue. h - * 
- BaseType_t xQueueSendToBackFromISR(
-                                         QueueHandle_t xQueue,
-                                         const void *pvItemToQueue,
-                                         BaseType_t *pxHigherPriorityTaskWoken
-                                      );
-
- * - * This is a macro that calls xQueueGenericSendFromISR(). - * - * Post an item to the back of a queue. It is safe to use this macro from - * within an interrupt service routine. - * - * Items are queued by copy not reference so it is preferable to only - * queue small items, especially when called from an ISR. In most cases - * it would be preferable to store a pointer to the item being queued. - * - * @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 pxHigherPriorityTaskWoken xQueueSendToBackFromISR() will set - * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task - * to unblock, and the unblocked task has a priority higher than the currently - * running task. If xQueueSendToBackFromISR() sets this value to pdTRUE then - * a context switch should be requested before the interrupt is exited. - * - * @return pdTRUE if the data was successfully sent to the queue, otherwise - * errQUEUE_FULL. - * - * Example usage for buffered IO (where the ISR can obtain more than one value - * per call): - 
- void vBufferISR( void )
- {
- char cIn;
- BaseType_t xHigherPriorityTaskWoken;
-
-    // We have not woken a task at the start of the ISR.
-    xHigherPriorityTaskWoken = pdFALSE;
-
-    // Loop until the buffer is empty.
-    do
-    {
-        // Obtain a byte from the buffer.
-        cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
-
-        // Post the byte.
-        xQueueSendToBackFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );
-
-    } while( portINPUT_BYTE( BUFFER_COUNT ) );
-
-    // Now the buffer is empty we can switch context if necessary.
-    if( xHigherPriorityTaskWoken )
-    {
-        taskYIELD ();
-    }
- }
-
- * - * \defgroup xQueueSendFromISR xQueueSendFromISR - * \ingroup QueueManagement - */ -#define xQueueSendToBackFromISR( \ - xQueue, pvItemToQueue, pxHigherPriorityTaskWoken) \ - xQueueGenericSendFromISR( \ - (xQueue), \ - (pvItemToQueue), \ - (pxHigherPriorityTaskWoken), \ - queueSEND_TO_BACK) - -/** - * queue. h - * 
- BaseType_t xQueueOverwriteFromISR(
-                              QueueHandle_t xQueue,
-                              const void * pvItemToQueue,
-                              BaseType_t *pxHigherPriorityTaskWoken
-                         );
- *
- * - * A version of xQueueOverwrite() that can be used in an interrupt service - * routine (ISR). - * - * Only for use with queues that can hold a single item - so the queue is either - * empty or full. - * - * Post an item on a queue. If the queue is already full then overwrite the - * value held in the queue. The item is queued by copy, not by reference. - * - * @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 pxHigherPriorityTaskWoken xQueueOverwriteFromISR() will set - * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task - * to unblock, and the unblocked task has a priority higher than the currently - * running task. If xQueueOverwriteFromISR() sets this value to pdTRUE then - * a context switch should be requested before the interrupt is exited. - * - * @return xQueueOverwriteFromISR() is a macro that calls - * xQueueGenericSendFromISR(), and therefore has the same return values as - * xQueueSendToFrontFromISR(). However, pdPASS is the only value that can be - * returned because xQueueOverwriteFromISR() will write to the queue even when - * the queue is already full. - * - * Example usage: - 
-
- QueueHandle_t xQueue;
-
- void vFunction( void *pvParameters )
- {
-    // Create a queue to hold one uint32_t value.  It is strongly
-    // recommended *not* to use xQueueOverwriteFromISR() on queues that can
-    // contain more than one value, and doing so will trigger an assertion
-    // if configASSERT() is defined.
-    xQueue = xQueueCreate( 1, sizeof( uint32_t ) );
-}
-
-void vAnInterruptHandler( void )
-{
-// xHigherPriorityTaskWoken must be set to pdFALSE before it is used.
-BaseType_t xHigherPriorityTaskWoken = pdFALSE;
-uint32_t ulVarToSend, ulValReceived;
-
-    // Write the value 10 to the queue using xQueueOverwriteFromISR().
-    ulVarToSend = 10;
-    xQueueOverwriteFromISR( xQueue, &ulVarToSend, &xHigherPriorityTaskWoken );
-
-    // The queue is full, but calling xQueueOverwriteFromISR() again will still
-    // pass because the value held in the queue will be overwritten with the
-    // new value.
-    ulVarToSend = 100;
-    xQueueOverwriteFromISR( xQueue, &ulVarToSend, &xHigherPriorityTaskWoken );
-
-    // Reading from the queue will now return 100.
-
-    // ...
-
-    if( xHigherPrioritytaskWoken == pdTRUE )
-    {
-        // Writing to the queue caused a task to unblock and the unblocked task
-        // has a priority higher than or equal to the priority of the currently
-        // executing task (the task this interrupt interrupted).  Perform a
-context
-        // switch so this interrupt returns directly to the unblocked task.
-        portYIELD_FROM_ISR(); // or portEND_SWITCHING_ISR() depending on the
-port.
-    }
-}
-
- * \defgroup xQueueOverwriteFromISR xQueueOverwriteFromISR - * \ingroup QueueManagement - */ -#define xQueueOverwriteFromISR( \ - xQueue, pvItemToQueue, pxHigherPriorityTaskWoken) \ - xQueueGenericSendFromISR( \ - (xQueue), \ - (pvItemToQueue), \ - (pxHigherPriorityTaskWoken), \ - queueOVERWRITE) - -/** - * queue. h - * 
- BaseType_t xQueueSendFromISR(
-                                     QueueHandle_t xQueue,
-                                     const void *pvItemToQueue,
-                                     BaseType_t *pxHigherPriorityTaskWoken
-                                );
-
- * - * This is a macro that calls xQueueGenericSendFromISR(). It is included - * for backward compatibility with versions of FreeRTOS.org that did not - * include the xQueueSendToBackFromISR() and xQueueSendToFrontFromISR() - * macros. - * - * Post an item to the back of a queue. It is safe to use this function from - * within an interrupt service routine. - * - * Items are queued by copy not reference so it is preferable to only - * queue small items, especially when called from an ISR. In most cases - * it would be preferable to store a pointer to the item being queued. - * - * @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 pxHigherPriorityTaskWoken xQueueSendFromISR() will set - * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task - * to unblock, and the unblocked task has a priority higher than the currently - * running task. If xQueueSendFromISR() sets this value to pdTRUE then - * a context switch should be requested before the interrupt is exited. - * - * @return pdTRUE if the data was successfully sent to the queue, otherwise - * errQUEUE_FULL. - * - * Example usage for buffered IO (where the ISR can obtain more than one value - * per call): - 
- void vBufferISR( void )
- {
- char cIn;
- BaseType_t xHigherPriorityTaskWoken;
-
-    // We have not woken a task at the start of the ISR.
-    xHigherPriorityTaskWoken = pdFALSE;
-
-    // Loop until the buffer is empty.
-    do
-    {
-        // Obtain a byte from the buffer.
-        cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
-
-        // Post the byte.
-        xQueueSendFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );
-
-    } while( portINPUT_BYTE( BUFFER_COUNT ) );
-
-    // Now the buffer is empty we can switch context if necessary.
-    if( xHigherPriorityTaskWoken )
-    {
-        // Actual macro used here is port specific.
-        portYIELD_FROM_ISR ();
-    }
- }
-
- * - * \defgroup xQueueSendFromISR xQueueSendFromISR - * \ingroup QueueManagement - */ -#define xQueueSendFromISR(xQueue, pvItemToQueue, pxHigherPriorityTaskWoken) \ - xQueueGenericSendFromISR( \ - (xQueue), \ - (pvItemToQueue), \ - (pxHigherPriorityTaskWoken), \ - queueSEND_TO_BACK) - -/** - * queue. h - * 
- BaseType_t xQueueGenericSendFromISR(
-                                           QueueHandle_t		xQueue,
-                                           const	void	*pvItemToQueue,
-                                           BaseType_t
- *pxHigherPriorityTaskWoken, BaseType_t	xCopyPosition
-                                       );
-
- * - * It is preferred that the macros xQueueSendFromISR(), - * xQueueSendToFrontFromISR() and xQueueSendToBackFromISR() be used in place - * of calling this function directly. xQueueGiveFromISR() is an - * equivalent for use by semaphores that don't actually copy any data. - * - * Post an item on a queue. It is safe to use this function from within an - * interrupt service routine. - * - * Items are queued by copy not reference so it is preferable to only - * queue small items, especially when called from an ISR. In most cases - * it would be preferable to store a pointer to the item being queued. - * - * @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 pxHigherPriorityTaskWoken xQueueGenericSendFromISR() will set - * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task - * to unblock, and the unblocked task has a priority higher than the currently - * running task. If xQueueGenericSendFromISR() sets this value to pdTRUE then - * a context switch should be requested before the interrupt is exited. - * - * @param xCopyPosition Can take the value queueSEND_TO_BACK to place the - * item at the back of the queue, or queueSEND_TO_FRONT to place the item - * at the front of the queue (for high priority messages). - * - * @return pdTRUE if the data was successfully sent to the queue, otherwise - * errQUEUE_FULL. - * - * Example usage for buffered IO (where the ISR can obtain more than one value - * per call): - 
- void vBufferISR( void )
- {
- char cIn;
- BaseType_t xHigherPriorityTaskWokenByPost;
-
-    // We have not woken a task at the start of the ISR.
-    xHigherPriorityTaskWokenByPost = pdFALSE;
-
-    // Loop until the buffer is empty.
-    do
-    {
-        // Obtain a byte from the buffer.
-        cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );
-
-        // Post each byte.
-        xQueueGenericSendFromISR( xRxQueue, &cIn,
- &xHigherPriorityTaskWokenByPost, queueSEND_TO_BACK );
-
-    } while( portINPUT_BYTE( BUFFER_COUNT ) );
-
-    // Now the buffer is empty we can switch context if necessary.  Note that
- the
-    // name of the yield function required is port specific.
-    if( xHigherPriorityTaskWokenByPost )
-    {
-        portYIELD_FROM_ISR();
-    }
- }
-
- * - * \defgroup xQueueSendFromISR xQueueSendFromISR - * \ingroup QueueManagement - */ -BaseType_t xQueueGenericSendFromISR( - QueueHandle_t xQueue, - const void *const pvItemToQueue, - BaseType_t *const pxHigherPriorityTaskWoken, - const BaseType_t xCopyPosition) PRIVILEGED_FUNCTION; -BaseType_t xQueueGiveFromISR( - QueueHandle_t xQueue, - BaseType_t *const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION; - -/** - * queue. h - * 
- BaseType_t xQueueReceiveFromISR(
-                                       QueueHandle_t	xQueue,
-                                       void	*pvBuffer,
-                                       BaseType_t *pxTaskWoken
-                                   );
- *
- * - * Receive an item from a queue. It is safe to use this function from within an - * interrupt service routine. - * - * @param xQueue The handle to the queue from which the item is to be - * received. - * - * @param pvBuffer Pointer to the buffer into which the received item will - * be copied. - * - * @param pxTaskWoken A task may be blocked waiting for space to become - * available on the queue. If xQueueReceiveFromISR causes such a task to - * unblock *pxTaskWoken will get set to pdTRUE, otherwise *pxTaskWoken will - * remain unchanged. - * - * @return pdTRUE if an item was successfully received from the queue, - * otherwise pdFALSE. - * - * Example usage: - 
-
- QueueHandle_t xQueue;
-
- // Function to create a queue and post some values.
- void vAFunction( void *pvParameters )
- {
- char cValueToPost;
- const TickType_t xTicksToWait = ( TickType_t )0xff;
-
-    // Create a queue capable of containing 10 characters.
-    xQueue = xQueueCreate( 10, sizeof( char ) );
-    if( xQueue == 0 )
-    {
-        // Failed to create the queue.
-    }
-
-    // ...
-
-    // Post some characters that will be used within an ISR.  If the queue
-    // is full then this task will block for xTicksToWait ticks.
-    cValueToPost = 'a';
-    xQueueSend( xQueue, ( void * ) &cValueToPost, xTicksToWait );
-    cValueToPost = 'b';
-    xQueueSend( xQueue, ( void * ) &cValueToPost, xTicksToWait );
-
-    // ... keep posting characters ... this task may block when the queue
-    // becomes full.
-
-    cValueToPost = 'c';
-    xQueueSend( xQueue, ( void * ) &cValueToPost, xTicksToWait );
- }
-
- // ISR that outputs all the characters received on the queue.
- void vISR_Routine( void )
- {
- BaseType_t xTaskWokenByReceive = pdFALSE;
- char cRxedChar;
-
-    while( xQueueReceiveFromISR( xQueue, ( void * ) &cRxedChar,
- &xTaskWokenByReceive) )
-    {
-        // A character was received.  Output the character now.
-        vOutputCharacter( cRxedChar );
-
-        // If removing the character from the queue woke the task that was
-        // posting onto the queue cTaskWokenByReceive will have been set to
-        // pdTRUE.  No matter how many times this loop iterates only one
-        // task will be woken.
-    }
-
-    if( cTaskWokenByPost != ( char ) pdFALSE;
-    {
-        taskYIELD ();
-    }
- }
-
- * \defgroup xQueueReceiveFromISR xQueueReceiveFromISR - * \ingroup QueueManagement - */ -BaseType_t xQueueReceiveFromISR( - QueueHandle_t xQueue, - void *const pvBuffer, - BaseType_t *const pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION; - -/* - * Utilities to query queues that are safe to use from an ISR. These utilities - * should be used only from witin an ISR, or within a critical section. - */ -BaseType_t xQueueIsQueueEmptyFromISR(const QueueHandle_t xQueue) - PRIVILEGED_FUNCTION; -BaseType_t xQueueIsQueueFullFromISR(const QueueHandle_t xQueue) - PRIVILEGED_FUNCTION; -UBaseType_t uxQueueMessagesWaitingFromISR(const QueueHandle_t xQueue) - PRIVILEGED_FUNCTION; - -/* - * The functions defined above are for passing data to and from tasks. The - * functions below are the equivalents for passing data to and from - * co-routines. - * - * These functions are called from the co-routine macro implementation and - * should not be called directly from application code. Instead use the macro - * wrappers defined within croutine.h. - */ -BaseType_t xQueueCRSendFromISR( - QueueHandle_t xQueue, - const void *pvItemToQueue, - BaseType_t xCoRoutinePreviouslyWoken); -BaseType_t xQueueCRReceiveFromISR( - QueueHandle_t xQueue, - void *pvBuffer, - BaseType_t *pxTaskWoken); -BaseType_t xQueueCRSend( - QueueHandle_t xQueue, - const void *pvItemToQueue, - TickType_t xTicksToWait); -BaseType_t xQueueCRReceive( - QueueHandle_t xQueue, - void *pvBuffer, - TickType_t xTicksToWait); - -/* - * For internal use only. Use xSemaphoreCreateMutex(), - * xSemaphoreCreateCounting() or xSemaphoreGetMutexHolder() instead of calling - * these functions directly. - */ -QueueHandle_t xQueueCreateMutex(const uint8_t ucQueueType) PRIVILEGED_FUNCTION; -QueueHandle_t xQueueCreateMutexStatic( - const uint8_t ucQueueType, - StaticQueue_t *pxStaticQueue) PRIVILEGED_FUNCTION; -QueueHandle_t xQueueCreateCountingSemaphore( - const UBaseType_t uxMaxCount, - const UBaseType_t uxInitialCount) PRIVILEGED_FUNCTION; -QueueHandle_t xQueueCreateCountingSemaphoreStatic( - const UBaseType_t uxMaxCount, - const UBaseType_t uxInitialCount, - StaticQueue_t *pxStaticQueue) PRIVILEGED_FUNCTION; -BaseType_t xQueueSemaphoreTake(QueueHandle_t xQueue, TickType_t xTicksToWait) - PRIVILEGED_FUNCTION; -TaskHandle_t xQueueGetMutexHolder(QueueHandle_t xSemaphore) PRIVILEGED_FUNCTION; -TaskHandle_t xQueueGetMutexHolderFromISR(QueueHandle_t xSemaphore) - PRIVILEGED_FUNCTION; - -/* - * For internal use only. Use xSemaphoreTakeMutexRecursive() or - * xSemaphoreGiveMutexRecursive() instead of calling these functions directly. - */ -BaseType_t xQueueTakeMutexRecursive( - QueueHandle_t xMutex, - TickType_t xTicksToWait) PRIVILEGED_FUNCTION; -BaseType_t xQueueGiveMutexRecursive(QueueHandle_t xMutex) PRIVILEGED_FUNCTION; - -/* - * Reset a queue back to its original empty state. The return value is now - * obsolete and is always set to pdPASS. - */ -#define xQueueReset(xQueue) xQueueGenericReset(xQueue, pdFALSE) - -/* - * The registry is provided as a means for kernel aware debuggers to - * locate queues, semaphores and mutexes. Call vQueueAddToRegistry() add - * a queue, semaphore or mutex handle to the registry if you want the handle - * to be available to a kernel aware debugger. If you are not using a kernel - * aware debugger then this function can be ignored. - * - * configQUEUE_REGISTRY_SIZE defines the maximum number of handles the - * registry can hold. configQUEUE_REGISTRY_SIZE must be greater than 0 - * within FreeRTOSConfig.h for the registry to be available. Its value - * does not effect the number of queues, semaphores and mutexes that can be - * created - just the number that the registry can hold. - * - * @param xQueue The handle of the queue being added to the registry. This - * is the handle returned by a call to xQueueCreate(). Semaphore and mutex - * handles can also be passed in here. - * - * @param pcName The name to be associated with the handle. This is the - * name that the kernel aware debugger will display. The queue registry only - * stores a pointer to the string - so the string must be persistent (global or - * preferably in ROM/Flash), not on the stack. - */ -#if (configQUEUE_REGISTRY_SIZE > 0) -void vQueueAddToRegistry(QueueHandle_t xQueue, const char *pcQueueName) - PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for - strings and single characters only. */ -#endif - -/* - * The registry is provided as a means for kernel aware debuggers to - * locate queues, semaphores and mutexes. Call vQueueAddToRegistry() add - * a queue, semaphore or mutex handle to the registry if you want the handle - * to be available to a kernel aware debugger, and vQueueUnregisterQueue() to - * remove the queue, semaphore or mutex from the register. If you are not using - * a kernel aware debugger then this function can be ignored. - * - * @param xQueue The handle of the queue being removed from the registry. - */ -#if (configQUEUE_REGISTRY_SIZE > 0) -void vQueueUnregisterQueue(QueueHandle_t xQueue) PRIVILEGED_FUNCTION; -#endif - -/* - * The queue registry is provided as a means for kernel aware debuggers to - * locate queues, semaphores and mutexes. Call pcQueueGetName() to look - * up and return the name of a queue in the queue registry from the queue's - * handle. - * - * @param xQueue The handle of the queue the name of which will be returned. - * @return If the queue is in the registry then a pointer to the name of the - * queue is returned. If the queue is not in the registry then NULL is - * returned. - */ -#if (configQUEUE_REGISTRY_SIZE > 0) -const char *pcQueueGetName(QueueHandle_t xQueue) - PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for - strings and single characters only. */ -#endif - -/* - * Generic version of the function used to creaet a queue using dynamic memory - * allocation. This is called by other functions and macros that create other - * RTOS objects that use the queue structure as their base. - */ -#if (configSUPPORT_DYNAMIC_ALLOCATION == 1) -QueueHandle_t xQueueGenericCreate( - const UBaseType_t uxQueueLength, - const UBaseType_t uxItemSize, - const uint8_t ucQueueType) PRIVILEGED_FUNCTION; -#endif - -/* - * Generic version of the function used to creaet a queue using dynamic memory - * allocation. This is called by other functions and macros that create other - * RTOS objects that use the queue structure as their base. - */ -#if (configSUPPORT_STATIC_ALLOCATION == 1) -QueueHandle_t xQueueGenericCreateStatic( - const UBaseType_t uxQueueLength, - const UBaseType_t uxItemSize, - uint8_t *pucQueueStorage, - StaticQueue_t *pxStaticQueue, - const uint8_t ucQueueType) PRIVILEGED_FUNCTION; -#endif - -/* - * Queue sets provide a mechanism to allow a task to block (pend) on a read - * operation from multiple queues or semaphores simultaneously. - * - * See FreeRTOS/Source/Demo/Common/Minimal/QueueSet.c for an example using this - * function. - * - * A queue set must be explicitly created using a call to xQueueCreateSet() - * before it can be used. Once created, standard FreeRTOS queues and semaphores - * can be added to the set using calls to xQueueAddToSet(). - * xQueueSelectFromSet() is then used to determine which, if any, of the queues - * or semaphores contained in the set is in a state where a queue read or - * semaphore take operation would be successful. - * - * Note 1: See the documentation on http://wwwFreeRTOS.org/RTOS-queue-sets.html - * for reasons why queue sets are very rarely needed in practice as there are - * simpler methods of blocking on multiple objects. - * - * Note 2: Blocking on a queue set that contains a mutex will not cause the - * mutex holder to inherit the priority of the blocked task. - * - * Note 3: An additional 4 bytes of RAM is required for each space in a every - * queue added to a queue set. Therefore counting semaphores that have a high - * maximum count value should not be added to a queue set. - * - * Note 4: A receive (in the case of a queue) or take (in the case of a - * semaphore) operation must not be performed on a member of a queue set unless - * a call to xQueueSelectFromSet() has first returned a handle to that set - * member. - * - * @param uxEventQueueLength Queue sets store events that occur on - * the queues and semaphores contained in the set. uxEventQueueLength specifies - * the maximum number of events that can be queued at once. To be absolutely - * certain that events are not lost uxEventQueueLength should be set to the - * total sum of the length of the queues added to the set, where binary - * semaphores and mutexes have a length of 1, and counting semaphores have a - * length set by their maximum count value. Examples: - * + If a queue set is to hold a queue of length 5, another queue of length 12, - * and a binary semaphore, then uxEventQueueLength should be set to - * (5 + 12 + 1), or 18. - * + If a queue set is to hold three binary semaphores then uxEventQueueLength - * should be set to (1 + 1 + 1 ), or 3. - * + If a queue set is to hold a counting semaphore that has a maximum count of - * 5, and a counting semaphore that has a maximum count of 3, then - * uxEventQueueLength should be set to (5 + 3), or 8. - * - * @return If the queue set is created successfully then a handle to the created - * queue set is returned. Otherwise NULL is returned. - */ -QueueSetHandle_t xQueueCreateSet(const UBaseType_t uxEventQueueLength) - PRIVILEGED_FUNCTION; - -/* - * Adds a queue or semaphore to a queue set that was previously created by a - * call to xQueueCreateSet(). - * - * See FreeRTOS/Source/Demo/Common/Minimal/QueueSet.c for an example using this - * function. - * - * Note 1: A receive (in the case of a queue) or take (in the case of a - * semaphore) operation must not be performed on a member of a queue set unless - * a call to xQueueSelectFromSet() has first returned a handle to that set - * member. - * - * @param xQueueOrSemaphore The handle of the queue or semaphore being added to - * the queue set (cast to an QueueSetMemberHandle_t type). - * - * @param xQueueSet The handle of the queue set to which the queue or semaphore - * is being added. - * - * @return If the queue or semaphore was successfully added to the queue set - * then pdPASS is returned. If the queue could not be successfully added to the - * queue set because it is already a member of a different queue set then pdFAIL - * is returned. - */ -BaseType_t xQueueAddToSet( - QueueSetMemberHandle_t xQueueOrSemaphore, - QueueSetHandle_t xQueueSet) PRIVILEGED_FUNCTION; - -/* - * Removes a queue or semaphore from a queue set. A queue or semaphore can only - * be removed from a set if the queue or semaphore is empty. - * - * See FreeRTOS/Source/Demo/Common/Minimal/QueueSet.c for an example using this - * function. - * - * @param xQueueOrSemaphore The handle of the queue or semaphore being removed - * from the queue set (cast to an QueueSetMemberHandle_t type). - * - * @param xQueueSet The handle of the queue set in which the queue or semaphore - * is included. - * - * @return If the queue or semaphore was successfully removed from the queue set - * then pdPASS is returned. If the queue was not in the queue set, or the - * queue (or semaphore) was not empty, then pdFAIL is returned. - */ -BaseType_t xQueueRemoveFromSet( - QueueSetMemberHandle_t xQueueOrSemaphore, - QueueSetHandle_t xQueueSet) PRIVILEGED_FUNCTION; - -/* - * xQueueSelectFromSet() selects from the members of a queue set a queue or - * semaphore that either contains data (in the case of a queue) or is available - * to take (in the case of a semaphore). xQueueSelectFromSet() effectively - * allows a task to block (pend) on a read operation on all the queues and - * semaphores in a queue set simultaneously. - * - * See FreeRTOS/Source/Demo/Common/Minimal/QueueSet.c for an example using this - * function. - * - * Note 1: See the documentation on http://wwwFreeRTOS.org/RTOS-queue-sets.html - * for reasons why queue sets are very rarely needed in practice as there are - * simpler methods of blocking on multiple objects. - * - * Note 2: Blocking on a queue set that contains a mutex will not cause the - * mutex holder to inherit the priority of the blocked task. - * - * Note 3: A receive (in the case of a queue) or take (in the case of a - * semaphore) operation must not be performed on a member of a queue set unless - * a call to xQueueSelectFromSet() has first returned a handle to that set - * member. - * - * @param xQueueSet The queue set on which the task will (potentially) block. - * - * @param xTicksToWait The maximum time, in ticks, that the calling task will - * remain in the Blocked state (with other tasks executing) to wait for a member - * of the queue set to be ready for a successful queue read or semaphore take - * operation. - * - * @return xQueueSelectFromSet() will return the handle of a queue (cast to - * a QueueSetMemberHandle_t type) contained in the queue set that contains data, - * or the handle of a semaphore (cast to a QueueSetMemberHandle_t type) - * contained in the queue set that is available, or NULL if no such queue or - * semaphore exists before before the specified block time expires. - */ -QueueSetMemberHandle_t xQueueSelectFromSet( - QueueSetHandle_t xQueueSet, - const TickType_t xTicksToWait) PRIVILEGED_FUNCTION; - -/* - * A version of xQueueSelectFromSet() that can be used from an ISR. - */ -QueueSetMemberHandle_t xQueueSelectFromSetFromISR(QueueSetHandle_t xQueueSet) - PRIVILEGED_FUNCTION; - -/* Not public API functions. */ -void vQueueWaitForMessageRestricted( - QueueHandle_t xQueue, - TickType_t xTicksToWait, - const BaseType_t xWaitIndefinitely) PRIVILEGED_FUNCTION; -BaseType_t xQueueGenericReset(QueueHandle_t xQueue, BaseType_t xNewQueue) - PRIVILEGED_FUNCTION; -void vQueueSetQueueNumber(QueueHandle_t xQueue, UBaseType_t uxQueueNumber) - PRIVILEGED_FUNCTION; -UBaseType_t uxQueueGetQueueNumber(QueueHandle_t xQueue) PRIVILEGED_FUNCTION; -uint8_t ucQueueGetQueueType(QueueHandle_t xQueue) PRIVILEGED_FUNCTION; - -#ifdef __cplusplus -} -#endif - -#endif /* QUEUE_H */ diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/include/stack_macros.h b/product/rcar/src/CMSIS-FreeRTOS/Source/include/stack_macros.h deleted file mode 100644 index 30334846462eb6aea0300b0be61a25d89ff1f8dc..0000000000000000000000000000000000000000 --- a/product/rcar/src/CMSIS-FreeRTOS/Source/include/stack_macros.h +++ /dev/null @@ -1,133 +0,0 @@ -/* - * FreeRTOS Kernel V10.3.1 - * 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://www.FreeRTOS.org - * http://aws.amazon.com/freertos - * - * 1 tab == 4 spaces! - */ - -#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. - */ - -/*-----------------------------------------------------------*/ - -#if ((configCHECK_FOR_STACK_OVERFLOW == 1) && (portSTACK_GROWTH < 0)) - -/* Only the current stack state is to be checked. */ -# define taskCHECK_FOR_STACK_OVERFLOW() \ - { \ - /* Is the currently saved stack pointer within the stack limit? */ \ - if (pxCurrentTCB->pxTopOfStack <= pxCurrentTCB->pxStack) { \ - vApplicationStackOverflowHook( \ - (TaskHandle_t)pxCurrentTCB, pxCurrentTCB->pcTaskName); \ - } \ - } - -#endif /* configCHECK_FOR_STACK_OVERFLOW == 1 */ -/*-----------------------------------------------------------*/ - -#if ((configCHECK_FOR_STACK_OVERFLOW == 1) && (portSTACK_GROWTH > 0)) - -/* Only the current stack state is to be checked. */ -# define taskCHECK_FOR_STACK_OVERFLOW() \ - { \ - /* Is the currently saved stack pointer within the stack limit? */ \ - if (pxCurrentTCB->pxTopOfStack >= pxCurrentTCB->pxEndOfStack) { \ - vApplicationStackOverflowHook( \ - (TaskHandle_t)pxCurrentTCB, pxCurrentTCB->pcTaskName); \ - } \ - } - -#endif /* configCHECK_FOR_STACK_OVERFLOW == 1 */ -/*-----------------------------------------------------------*/ - -#if ((configCHECK_FOR_STACK_OVERFLOW > 1) && (portSTACK_GROWTH < 0)) - -# define taskCHECK_FOR_STACK_OVERFLOW() \ - { \ - const uint32_t *const pulStack = \ - (uint32_t *)pxCurrentTCB->pxStack; \ - const uint32_t ulCheckValue = (uint32_t)0xa5a5a5a5; \ -\ - if ((pulStack[0] != ulCheckValue) || \ - (pulStack[1] != ulCheckValue) || \ - (pulStack[2] != ulCheckValue) || \ - (pulStack[3] != ulCheckValue)) { \ - vApplicationStackOverflowHook( \ - (TaskHandle_t)pxCurrentTCB, pxCurrentTCB->pcTaskName); \ - } \ - } - -#endif /* #if( configCHECK_FOR_STACK_OVERFLOW > 1 ) */ -/*-----------------------------------------------------------*/ - -#if ((configCHECK_FOR_STACK_OVERFLOW > 1) && (portSTACK_GROWTH > 0)) - -# define taskCHECK_FOR_STACK_OVERFLOW() \ - { \ - 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); \ -\ - /* Has the extremity of the task stack ever been written over? */ \ - if (memcmp( \ - (void *)pcEndOfStack, \ - (void *)ucExpectedStackBytes, \ - sizeof(ucExpectedStackBytes)) != 0) { \ - vApplicationStackOverflowHook( \ - (TaskHandle_t)pxCurrentTCB, pxCurrentTCB->pcTaskName); \ - } \ - } - -#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 */ diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/include/task.h b/product/rcar/src/CMSIS-FreeRTOS/Source/include/task.h deleted file mode 100644 index 96d912b74d2745bad455ddecea3c643346c1795e..0000000000000000000000000000000000000000 --- a/product/rcar/src/CMSIS-FreeRTOS/Source/include/task.h +++ /dev/null @@ -1,2729 +0,0 @@ -/* - * FreeRTOS Kernel V10.3.1 - * 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://www.FreeRTOS.org - * http://aws.amazon.com/freertos - * - * 1 tab == 4 spaces! - */ - -#ifndef INC_TASK_H -#define INC_TASK_H - -#ifndef INC_FREERTOS_H -# error \ - "include FreeRTOS.h must appear in source files before include task.h" -#endif - -#include "list.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/*----------------------------------------------------------- - * MACROS AND DEFINITIONS - *----------------------------------------------------------*/ - -#define tskKERNEL_VERSION_NUMBER "V10.3.1" -#define tskKERNEL_VERSION_MAJOR 10 -#define tskKERNEL_VERSION_MINOR 3 -#define tskKERNEL_VERSION_BUILD 1 - -/* MPU region parameters passed in ulParameters - * of MemoryRegion_t struct. */ -#define tskMPU_REGION_READ_ONLY (1UL << 0UL) -#define tskMPU_REGION_READ_WRITE (1UL << 1UL) -#define tskMPU_REGION_EXECUTE_NEVER (1UL << 2UL) -#define tskMPU_REGION_NORMAL_MEMORY (1UL << 3UL) -#define tskMPU_REGION_DEVICE_MEMORY (1UL << 4UL) - -/** - * task. h - * - * Type by which tasks are referenced. For example, a call to xTaskCreate - * returns (via a pointer parameter) an TaskHandle_t variable that can then - * be used as a parameter to vTaskDelete to delete the task. - * - * \defgroup TaskHandle_t TaskHandle_t - * \ingroup Tasks - */ -struct tskTaskControlBlock; /* The old naming convention is used to prevent - breaking kernel aware debuggers. */ -typedef struct tskTaskControlBlock *TaskHandle_t; - -/* - * Defines the prototype to which the application task hook function must - * conform. - */ -typedef BaseType_t (*TaskHookFunction_t)(void *); - -/* Task states returned by eTaskGetState. */ -typedef enum { - eRunning = - 0, /* A task is querying the state of itself, so must be running. */ - eReady, /* The task being queried is in a read or pending ready list. */ - eBlocked, /* The task being queried is in the Blocked state. */ - eSuspended, /* The task being queried is in the Suspended state, or is in - the Blocked state with an infinite time out. */ - eDeleted, /* The task being queried has been deleted, but its TCB has not - yet been freed. */ - eInvalid /* Used as an 'invalid state' value. */ -} eTaskState; - -/* Actions that can be performed when vTaskNotify() is called. */ -typedef enum { - eNoAction = 0, /* Notify the task without updating its notify value. */ - eSetBits, /* Set bits in the task's notification value. */ - eIncrement, /* Increment the task's notification value. */ - eSetValueWithOverwrite, /* Set the task's notification value to a specific - value even if the previous value has not yet been - read by the task. */ - eSetValueWithoutOverwrite /* Set the task's notification value if the - previous value has been read by the task. */ -} eNotifyAction; - -/* - * Used internally only. - */ -typedef struct xTIME_OUT { - BaseType_t xOverflowCount; - TickType_t xTimeOnEntering; -} TimeOut_t; - -/* - * Defines the memory ranges allocated to the task when an MPU is used. - */ -typedef struct xMEMORY_REGION { - void *pvBaseAddress; - uint32_t ulLengthInBytes; - uint32_t ulParameters; -} MemoryRegion_t; - -/* - * Parameters required to create an MPU protected task. - */ -typedef struct xTASK_PARAMETERS { - TaskFunction_t pvTaskCode; - const char *const pcName; /*lint !e971 Unqualified char types are allowed - for strings and single characters only. */ - configSTACK_DEPTH_TYPE usStackDepth; - void *pvParameters; - UBaseType_t uxPriority; - StackType_t *puxStackBuffer; - MemoryRegion_t xRegions[portNUM_CONFIGURABLE_REGIONS]; -#if ((portUSING_MPU_WRAPPERS == 1) && (configSUPPORT_STATIC_ALLOCATION == 1)) - StaticTask_t *const pxTaskBuffer; -#endif -} TaskParameters_t; - -/* Used with the uxTaskGetSystemState() function to return the state of each -task in the system. */ -typedef struct xTASK_STATUS { - TaskHandle_t xHandle; /* The handle of the task to which the rest of the - information in the structure relates. */ - const char *pcTaskName; /* A pointer to the task's name. This value will be invalid if the task was deleted since the structure was populated! */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */ - UBaseType_t xTaskNumber; /* A number unique to the task. */ - eTaskState eCurrentState; /* The state in which the task existed when the - structure was populated. */ - UBaseType_t - uxCurrentPriority; /* The priority at which the task was running (may be - inherited) when the structure was populated. */ - UBaseType_t - uxBasePriority; /* The priority to which the task will return if the - task's current priority has been inherited to avoid - unbounded priority inversion when obtaining a mutex. - Only valid if configUSE_MUTEXES is defined as 1 in - FreeRTOSConfig.h. */ - uint32_t - ulRunTimeCounter; /* The total run time allocated to the task so far, as - defined by the run time stats clock. See - http://www.freertos.org/rtos-run-time-stats.html. - Only valid when configGENERATE_RUN_TIME_STATS is - defined as 1 in FreeRTOSConfig.h. */ - StackType_t *pxStackBase; /* Points to the lowest address of the task's - stack area. */ - configSTACK_DEPTH_TYPE - usStackHighWaterMark; /* The minimum amount of stack space that has - remained for the task since the task was - created. The closer this value is to zero the - closer the task has come to overflowing its - stack. */ -} TaskStatus_t; - -/* Possible return values for eTaskConfirmSleepModeStatus(). */ -typedef enum { - eAbortSleep = 0, /* A task has been made ready or a context switch pended - since portSUPPORESS_TICKS_AND_SLEEP() was called - abort - entering a sleep mode. */ - eStandardSleep, /* Enter a sleep mode that will not last any longer than the - expected idle time. */ - eNoTasksWaitingTimeout /* No tasks are waiting for a timeout so it is safe - to enter a sleep mode that can only be exited by - an external interrupt. */ -} eSleepModeStatus; - -/** - * Defines the priority used by the idle task. This must not be modified. - * - * \ingroup TaskUtils - */ -#define tskIDLE_PRIORITY ((UBaseType_t)0U) - -/** - * task. h - * - * Macro for forcing a context switch. - * - * \defgroup taskYIELD taskYIELD - * \ingroup SchedulerControl - */ -#define taskYIELD() portYIELD() - -/** - * task. h - * - * Macro to mark the start of a critical code region. Preemptive context - * switches cannot occur when in a critical region. - * - * NOTE: This may alter the stack (depending on the portable implementation) - * so must be used with care! - * - * \defgroup taskENTER_CRITICAL taskENTER_CRITICAL - * \ingroup SchedulerControl - */ -#define taskENTER_CRITICAL() portENTER_CRITICAL() -#define taskENTER_CRITICAL_FROM_ISR() portSET_INTERRUPT_MASK_FROM_ISR() - -/** - * task. h - * - * Macro to mark the end of a critical code region. Preemptive context - * switches cannot occur when in a critical region. - * - * NOTE: This may alter the stack (depending on the portable implementation) - * so must be used with care! - * - * \defgroup taskEXIT_CRITICAL taskEXIT_CRITICAL - * \ingroup SchedulerControl - */ -#define taskEXIT_CRITICAL() portEXIT_CRITICAL() -#define taskEXIT_CRITICAL_FROM_ISR(x) portCLEAR_INTERRUPT_MASK_FROM_ISR(x) -/** - * task. h - * - * Macro to disable all maskable interrupts. - * - * \defgroup taskDISABLE_INTERRUPTS taskDISABLE_INTERRUPTS - * \ingroup SchedulerControl - */ -#define taskDISABLE_INTERRUPTS() portDISABLE_INTERRUPTS() - -/** - * task. h - * - * Macro to enable microcontroller interrupts. - * - * \defgroup taskENABLE_INTERRUPTS taskENABLE_INTERRUPTS - * \ingroup SchedulerControl - */ -#define taskENABLE_INTERRUPTS() portENABLE_INTERRUPTS() - -/* Definitions returned by xTaskGetSchedulerState(). taskSCHEDULER_SUSPENDED is -0 to generate more optimal code when configASSERT() is defined as the constant -is used in assert() statements. */ -#define taskSCHEDULER_SUSPENDED ((BaseType_t)0) -#define taskSCHEDULER_NOT_STARTED ((BaseType_t)1) -#define taskSCHEDULER_RUNNING ((BaseType_t)2) - -/*----------------------------------------------------------- - * TASK CREATION API - *----------------------------------------------------------*/ - -/** - * task. h - *
- BaseType_t xTaskCreate(
-                              TaskFunction_t pvTaskCode,
-                              const char * const pcName,
-                              configSTACK_DEPTH_TYPE usStackDepth,
-                              void *pvParameters,
-                              UBaseType_t uxPriority,
-                              TaskHandle_t *pvCreatedTask
-                          );
- * - * Create a new task and add it to the list of tasks that are ready to run. - * - * Internally, within the FreeRTOS implementation, tasks use two blocks of - * memory. The first block is used to hold the task's data structures. The - * second block is used by the task as its stack. If a task is created using - * xTaskCreate() then both blocks of memory are automatically dynamically - * allocated inside the xTaskCreate() function. (see - * http://www.freertos.org/a00111.html). If a task is created using - * xTaskCreateStatic() then the application writer must provide the required - * memory. xTaskCreateStatic() therefore allows a task to be created without - * using any dynamic memory allocation. - * - * See xTaskCreateStatic() for a version that does not use any dynamic memory - * allocation. - * - * xTaskCreate() can only be used to create a task that has unrestricted - * access to the entire microcontroller memory map. Systems that include MPU - * support can alternatively create an MPU constrained task using - * xTaskCreateRestricted(). - * - * @param pvTaskCode Pointer to the task entry function. Tasks - * must be implemented to never return (i.e. continuous loop). - * - * @param pcName A descriptive name for the task. This is mainly used to - * facilitate debugging. Max length defined by configMAX_TASK_NAME_LEN - - default - * is 16. - * - * @param usStackDepth The size of the task stack specified as the number of - * variables the stack can hold - not the number of bytes. For example, if - * the stack is 16 bits wide and usStackDepth is defined as 100, 200 bytes - * will be allocated for stack storage. - * - * @param pvParameters Pointer that will be used as the parameter for the task - * being created. - * - * @param uxPriority The priority at which the task should run. Systems that - * include MPU support can optionally create tasks in a privileged (system) - * mode by setting bit portPRIVILEGE_BIT of the priority parameter. For - * example, to create a privileged task at priority 2 the uxPriority parameter - * should be set to ( 2 | portPRIVILEGE_BIT ). - * - * @param pvCreatedTask Used to pass back a handle by which the created task - * can be referenced. - * - * @return pdPASS if the task was successfully created and added to a ready - * list, otherwise an error code defined in the file projdefs.h - * - * Example usage: - 
- // Task to be created.
- void vTaskCode( void * pvParameters )
- {
-     for( ;; )
-     {
-         // Task code goes here.
-     }
- }
-
- // Function that creates a task.
- void vOtherFunction( void )
- {
- static uint8_t ucParameterToPass;
- TaskHandle_t xHandle = NULL;
-
-     // Create the task, storing the handle.  Note that the passed parameter
- ucParameterToPass
-     // must exist for the lifetime of the task, so in this case is declared
- static.  If it was just an
-     // an automatic stack variable it might no longer exist, or at least have
- been corrupted, by the time
-     // the new task attempts to access it.
-     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass,
- tskIDLE_PRIORITY, &xHandle ); configASSERT( xHandle );
-
-     // Use the handle to delete the task.
-     if( xHandle != NULL )
-     {
-        vTaskDelete( xHandle );
-     }
- }
-
- * \defgroup xTaskCreate xTaskCreate - * \ingroup Tasks - */ -#if (configSUPPORT_DYNAMIC_ALLOCATION == 1) -BaseType_t xTaskCreate( - TaskFunction_t pxTaskCode, - const char *const pcName, /*lint !e971 Unqualified char types are allowed - for strings and single characters only. */ - const configSTACK_DEPTH_TYPE usStackDepth, - void *const pvParameters, - UBaseType_t uxPriority, - TaskHandle_t *const pxCreatedTask) PRIVILEGED_FUNCTION; -#endif - -/** - * task. h - *
- TaskHandle_t xTaskCreateStatic( TaskFunction_t pvTaskCode,
-                                 const char * const pcName,
-                                 uint32_t ulStackDepth,
-                                 void *pvParameters,
-                                 UBaseType_t uxPriority,
-                                 StackType_t *pxStackBuffer,
-                                 StaticTask_t *pxTaskBuffer );
- * - * Create a new task and add it to the list of tasks that are ready to run. - * - * Internally, within the FreeRTOS implementation, tasks use two blocks of - * memory. The first block is used to hold the task's data structures. The - * second block is used by the task as its stack. If a task is created using - * xTaskCreate() then both blocks of memory are automatically dynamically - * allocated inside the xTaskCreate() function. (see - * http://www.freertos.org/a00111.html). If a task is created using - * xTaskCreateStatic() then the application writer must provide the required - * memory. xTaskCreateStatic() therefore allows a task to be created without - * using any dynamic memory allocation. - * - * @param pvTaskCode Pointer to the task entry function. Tasks - * must be implemented to never return (i.e. continuous loop). - * - * @param pcName A descriptive name for the task. This is mainly used to - * facilitate debugging. The maximum length of the string is defined by - * configMAX_TASK_NAME_LEN in FreeRTOSConfig.h. - * - * @param ulStackDepth The size of the task stack specified as the number of - * variables the stack can hold - not the number of bytes. For example, if - * the stack is 32-bits wide and ulStackDepth is defined as 100 then 400 bytes - * will be allocated for stack storage. - * - * @param pvParameters Pointer that will be used as the parameter for the task - * being created. - * - * @param uxPriority The priority at which the task will run. - * - * @param pxStackBuffer Must point to a StackType_t array that has at least - * ulStackDepth indexes - the array will then be used as the task's stack, - * removing the need for the stack to be allocated dynamically. - * - * @param pxTaskBuffer Must point to a variable of type StaticTask_t, which will - * then be used to hold the task's data structures, removing the need for the - * memory to be allocated dynamically. - * - * @return If neither pxStackBuffer or pxTaskBuffer are NULL, then the task will - * be created and a handle to the created task is returned. If either - * pxStackBuffer or pxTaskBuffer are NULL then the task will not be created and - * NULL is returned. - * - * Example usage: - 
-
-    // Dimensions the buffer that the task being created will use as its stack.
-    // NOTE:  This is the number of words the stack will hold, not the number of
-    // bytes.  For example, if each stack item is 32-bits, and this is set to
- 100,
-    // then 400 bytes (100 * 32-bits) will be allocated.
-    #define STACK_SIZE 200
-
-    // Structure that will hold the TCB of the task being created.
-    StaticTask_t xTaskBuffer;
-
-    // Buffer that the task being created will use as its stack.  Note this is
-    // an array of StackType_t variables.  The size of StackType_t is dependent
- on
-    // the RTOS port.
-    StackType_t xStack[ STACK_SIZE ];
-
-    // Function that implements the task being created.
-    void vTaskCode( void * pvParameters )
-    {
-        // The parameter value is expected to be 1 as 1 is passed in the
-        // pvParameters value in the call to xTaskCreateStatic().
-        configASSERT( ( uint32_t ) pvParameters == 1UL );
-
-        for( ;; )
-        {
-            // Task code goes here.
-        }
-    }
-
-    // Function that creates a task.
-    void vOtherFunction( void )
-    {
-        TaskHandle_t xHandle = NULL;
-
-        // Create the task without using any dynamic memory allocation.
-        xHandle = xTaskCreateStatic(
-                      vTaskCode,       // Function that implements the task.
-                      "NAME",          // Text name for the task.
-                      STACK_SIZE,      // Stack size in words, not bytes.
-                      ( void * ) 1,    // Parameter passed into the task.
-                      tskIDLE_PRIORITY,// Priority at which the task is created.
-                      xStack,          // Array to use as the task's stack.
-                      &xTaskBuffer );  // Variable to hold the task's data
- structure.
-
-        // puxStackBuffer and pxTaskBuffer were not NULL, so the task will have
-        // been created, and xHandle will be the task's handle.  Use the handle
-        // to suspend the task.
-        vTaskSuspend( xHandle );
-    }
-
- * \defgroup xTaskCreateStatic xTaskCreateStatic - * \ingroup Tasks - */ -#if (configSUPPORT_STATIC_ALLOCATION == 1) -TaskHandle_t xTaskCreateStatic( - TaskFunction_t pxTaskCode, - const char *const pcName, /*lint !e971 Unqualified char types are allowed - for strings and single characters only. */ - const uint32_t ulStackDepth, - void *const pvParameters, - UBaseType_t uxPriority, - StackType_t *const puxStackBuffer, - StaticTask_t *const pxTaskBuffer) PRIVILEGED_FUNCTION; -#endif /* configSUPPORT_STATIC_ALLOCATION */ - -/** - * task. h - *
- BaseType_t xTaskCreateRestricted( TaskParameters_t *pxTaskDefinition,
-TaskHandle_t *pxCreatedTask );
- * - * Only available when configSUPPORT_DYNAMIC_ALLOCATION is set to 1. - * - * xTaskCreateRestricted() should only be used in systems that include an MPU - * implementation. - * - * Create a new task and add it to the list of tasks that are ready to run. - * The function parameters define the memory regions and associated access - * permissions allocated to the task. - * - * See xTaskCreateRestrictedStatic() for a version that does not use any - * dynamic memory allocation. - * - * @param pxTaskDefinition Pointer to a structure that contains a member - * for each of the normal xTaskCreate() parameters (see the xTaskCreate() API - * documentation) plus an optional stack buffer and the memory region - * definitions. - * - * @param pxCreatedTask Used to pass back a handle by which the created task - * can be referenced. - * - * @return pdPASS if the task was successfully created and added to a ready - * list, otherwise an error code defined in the file projdefs.h - * - * Example usage: - 
-// Create an TaskParameters_t structure that defines the task to be created.
-static const TaskParameters_t xCheckTaskParameters =
-{
-    vATask,		// pvTaskCode - the function that implements the task.
-    "ATask",	// pcName - just a text name for the task to assist debugging.
-    100,		// usStackDepth	- the stack size DEFINED IN WORDS.
-    NULL,		// pvParameters - passed into the task function as the function
-parameters. ( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the
-portPRIVILEGE_BIT if the task should run in a privileged state. cStackBuffer,//
-puxStackBuffer - the buffer to be used as the task stack.
-
-    // xRegions - Allocate up to three separate memory regions for access by
-    // the task, with appropriate access permissions.  Different processors have
-    // different memory alignment requirements - refer to the FreeRTOS
-documentation
-    // for full information.
-    {
-        // Base address					Length	Parameters
-        { cReadWriteArray,				32,		portMPU_REGION_READ_WRITE },
-        { cReadOnlyArray,				32,		portMPU_REGION_READ_ONLY },
-        { cPrivilegedOnlyAccessArray,	128,
-portMPU_REGION_PRIVILEGED_READ_WRITE }
-    }
-};
-
-int main( void )
-{
-TaskHandle_t xHandle;
-
-    // Create a task from the const structure defined above.  The task handle
-    // is requested (the second parameter is not NULL) but in this case just for
-    // demonstration purposes as its not actually used.
-    xTaskCreateRestricted( &xRegTest1Parameters, &xHandle );
-
-    // Start the scheduler.
-    vTaskStartScheduler();
-
-    // Will only get here if there was insufficient memory to create the idle
-    // and/or timer task.
-    for( ;; );
-}
-
- * \defgroup xTaskCreateRestricted xTaskCreateRestricted - * \ingroup Tasks - */ -#if (portUSING_MPU_WRAPPERS == 1) -BaseType_t xTaskCreateRestricted( - const TaskParameters_t *const pxTaskDefinition, - TaskHandle_t *pxCreatedTask) PRIVILEGED_FUNCTION; -#endif - -/** - * task. h - *
- BaseType_t xTaskCreateRestrictedStatic( TaskParameters_t *pxTaskDefinition,
-TaskHandle_t *pxCreatedTask );
- * - * Only available when configSUPPORT_STATIC_ALLOCATION is set to 1. - * - * xTaskCreateRestrictedStatic() should only be used in systems that include an - * MPU implementation. - * - * Internally, within the FreeRTOS implementation, tasks use two blocks of - * memory. The first block is used to hold the task's data structures. The - * second block is used by the task as its stack. If a task is created using - * xTaskCreateRestricted() then the stack is provided by the application writer, - * and the memory used to hold the task's data structure is automatically - * dynamically allocated inside the xTaskCreateRestricted() function. If a task - * is created using xTaskCreateRestrictedStatic() then the application writer - * must provide the memory used to hold the task's data structures too. - * xTaskCreateRestrictedStatic() therefore allows a memory protected task to be - * created without using any dynamic memory allocation. - * - * @param pxTaskDefinition Pointer to a structure that contains a member - * for each of the normal xTaskCreate() parameters (see the xTaskCreate() API - * documentation) plus an optional stack buffer and the memory region - * definitions. If configSUPPORT_STATIC_ALLOCATION is set to 1 the structure - * contains an additional member, which is used to point to a variable of type - * StaticTask_t - which is then used to hold the task's data structure. - * - * @param pxCreatedTask Used to pass back a handle by which the created task - * can be referenced. - * - * @return pdPASS if the task was successfully created and added to a ready - * list, otherwise an error code defined in the file projdefs.h - * - * Example usage: - 
-// Create an TaskParameters_t structure that defines the task to be created.
-// The StaticTask_t variable is only included in the structure when
-// configSUPPORT_STATIC_ALLOCATION is set to 1.  The PRIVILEGED_DATA macro can
-// be used to force the variable into the RTOS kernel's privileged data area.
-static PRIVILEGED_DATA StaticTask_t xTaskBuffer;
-static const TaskParameters_t xCheckTaskParameters =
-{
-    vATask,		// pvTaskCode - the function that implements the task.
-    "ATask",	// pcName - just a text name for the task to assist debugging.
-    100,		// usStackDepth	- the stack size DEFINED IN WORDS.
-    NULL,		// pvParameters - passed into the task function as the function
-parameters. ( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the
-portPRIVILEGE_BIT if the task should run in a privileged state. cStackBuffer,//
-puxStackBuffer - the buffer to be used as the task stack.
-
-    // xRegions - Allocate up to three separate memory regions for access by
-    // the task, with appropriate access permissions.  Different processors have
-    // different memory alignment requirements - refer to the FreeRTOS
-documentation
-    // for full information.
-    {
-        // Base address					Length	Parameters
-        { cReadWriteArray,				32,		portMPU_REGION_READ_WRITE },
-        { cReadOnlyArray,				32,		portMPU_REGION_READ_ONLY },
-        { cPrivilegedOnlyAccessArray,	128,
-portMPU_REGION_PRIVILEGED_READ_WRITE }
-    }
-
-    &xTaskBuffer; // Holds the task's data structure.
-};
-
-int main( void )
-{
-TaskHandle_t xHandle;
-
-    // Create a task from the const structure defined above.  The task handle
-    // is requested (the second parameter is not NULL) but in this case just for
-    // demonstration purposes as its not actually used.
-    xTaskCreateRestricted( &xRegTest1Parameters, &xHandle );
-
-    // Start the scheduler.
-    vTaskStartScheduler();
-
-    // Will only get here if there was insufficient memory to create the idle
-    // and/or timer task.
-    for( ;; );
-}
-
- * \defgroup xTaskCreateRestrictedStatic xTaskCreateRestrictedStatic - * \ingroup Tasks - */ -#if ((portUSING_MPU_WRAPPERS == 1) && (configSUPPORT_STATIC_ALLOCATION == 1)) -BaseType_t xTaskCreateRestrictedStatic( - const TaskParameters_t *const pxTaskDefinition, - TaskHandle_t *pxCreatedTask) PRIVILEGED_FUNCTION; -#endif - -/** - * task. h - *
- void vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const
-pxRegions );
- * - * Memory regions are assigned to a restricted task when the task is created by - * a call to xTaskCreateRestricted(). These regions can be redefined using - * vTaskAllocateMPURegions(). - * - * @param xTask The handle of the task being updated. - * - * @param xRegions A pointer to an MemoryRegion_t structure that contains the - * new memory region definitions. - * - * Example usage: - 
-// Define an array of MemoryRegion_t structures that configures an MPU region
-// allowing read/write access for 1024 bytes starting at the beginning of the
-// ucOneKByte array.  The other two of the maximum 3 definable regions are
-// unused so set to zero.
-static const MemoryRegion_t xAltRegions[ portNUM_CONFIGURABLE_REGIONS ] =
-{
-    // Base address		Length		Parameters
-    { ucOneKByte,		1024,		portMPU_REGION_READ_WRITE },
-    { 0,				0,			0 },
-    { 0,				0,			0 }
-};
-
-void vATask( void *pvParameters )
-{
-    // This task was created such that it has access to certain regions of
-    // memory as defined by the MPU configuration.  At some point it is
-    // desired that these MPU regions are replaced with that defined in the
-    // xAltRegions const struct above.  Use a call to vTaskAllocateMPURegions()
-    // for this purpose.  NULL is used as the task handle to indicate that this
-    // function should modify the MPU regions of the calling task.
-    vTaskAllocateMPURegions( NULL, xAltRegions );
-
-    // Now the task can continue its function, but from this point on can only
-    // access its stack and the ucOneKByte array (unless any other statically
-    // defined or shared regions have been declared elsewhere).
-}
-
- * \defgroup xTaskCreateRestricted xTaskCreateRestricted - * \ingroup Tasks - */ -void vTaskAllocateMPURegions( - TaskHandle_t xTask, - const MemoryRegion_t *const pxRegions) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
void vTaskDelete( TaskHandle_t xTask );
- * - * INCLUDE_vTaskDelete must be defined as 1 for this function to be available. - * See the configuration section for more information. - * - * Remove a task from the RTOS real time kernel's management. The task being - * deleted will be removed from all ready, blocked, suspended and event lists. - * - * NOTE: The idle task is responsible for freeing the kernel allocated - * memory from tasks that have been deleted. It is therefore important that - * the idle task is not starved of microcontroller processing time if your - * application makes any calls to vTaskDelete (). Memory allocated by the - * task code is not automatically freed, and should be freed before the task - * is deleted. - * - * See the demo application file death.c for sample code that utilises - * vTaskDelete (). - * - * @param xTask The handle of the task to be deleted. Passing NULL will - * cause the calling task to be deleted. - * - * Example usage: - 
- void vOtherFunction( void )
- {
- TaskHandle_t xHandle;
-
-     // Create the task, storing the handle.
-     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY,
- &xHandle );
-
-     // Use the handle to delete the task.
-     vTaskDelete( xHandle );
- }
-
- * \defgroup vTaskDelete vTaskDelete - * \ingroup Tasks - */ -void vTaskDelete(TaskHandle_t xTaskToDelete) PRIVILEGED_FUNCTION; - -/*----------------------------------------------------------- - * TASK CONTROL API - *----------------------------------------------------------*/ - -/** - * task. h - * 
void vTaskDelay( const TickType_t xTicksToDelay );
- * - * Delay a task for a given number of ticks. The actual time that the - * task remains blocked depends on the tick rate. The constant - * portTICK_PERIOD_MS can be used to calculate real time from the tick - * rate - with the resolution of one tick period. - * - * INCLUDE_vTaskDelay must be defined as 1 for this function to be available. - * See the configuration section for more information. - * - * - * vTaskDelay() specifies a time at which the task wishes to unblock relative to - * the time at which vTaskDelay() is called. For example, specifying a block - * period of 100 ticks will cause the task to unblock 100 ticks after - * vTaskDelay() is called. vTaskDelay() does not therefore provide a good - method - * of controlling the frequency of a periodic task as the path taken through the - * code, as well as other task and interrupt activity, will effect the frequency - * at which vTaskDelay() gets called and therefore the time at which the task - * next executes. See vTaskDelayUntil() for an alternative API function - designed - * to facilitate fixed frequency execution. It does this by specifying an - * absolute time (rather than a relative time) at which the calling task should - * unblock. - * - * @param xTicksToDelay The amount of time, in tick periods, that - * the calling task should block. - * - * Example usage: - - void vTaskFunction( void * pvParameters ) - { - // Block for 500ms. - const TickType_t xDelay = 500 / portTICK_PERIOD_MS; - - for( ;; ) - { - // Simply toggle the LED every 500ms, blocking between each toggle. - vToggleLED(); - vTaskDelay( xDelay ); - } - } - - * \defgroup vTaskDelay vTaskDelay - * \ingroup TaskCtrl - */ -void vTaskDelay(const TickType_t xTicksToDelay) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
void vTaskDelayUntil( TickType_t *pxPreviousWakeTime, const TickType_t
- xTimeIncrement );
- * - * INCLUDE_vTaskDelayUntil must be defined as 1 for this function to be - available. - * See the configuration section for more information. - * - * Delay a task until a specified time. This function can be used by periodic - * tasks to ensure a constant execution frequency. - * - * This function differs from vTaskDelay () in one important aspect: vTaskDelay - () will - * cause a task to block for the specified number of ticks from the time - vTaskDelay () is - * called. It is therefore difficult to use vTaskDelay () by itself to generate - a fixed - * execution frequency as the time between a task starting to execute and that - task - * calling vTaskDelay () may not be fixed [the task may take a different path - though the - * code between calls, or may get interrupted or preempted a different number of - times - * each time it executes]. - * - * Whereas vTaskDelay () specifies a wake time relative to the time at which the - function - * is called, vTaskDelayUntil () specifies the absolute (exact) time at which it - wishes to - * unblock. - * - * The constant portTICK_PERIOD_MS can be used to calculate real time from the - tick - * rate - with the resolution of one tick period. - * - * @param pxPreviousWakeTime Pointer to a variable that holds the time at which - the - * task was last unblocked. The variable must be initialised with the current - time - * prior to its first use (see the example below). Following this the variable - is - * automatically updated within vTaskDelayUntil (). - * - * @param xTimeIncrement The cycle time period. The task will be unblocked at - * time *pxPreviousWakeTime + xTimeIncrement. Calling vTaskDelayUntil with the - * same xTimeIncrement parameter value will cause the task to execute with - * a fixed interface period. - * - * Example usage: - 
- // Perform an action every 10 ticks.
- void vTaskFunction( void * pvParameters )
- {
- TickType_t xLastWakeTime;
- const TickType_t xFrequency = 10;
-
-     // Initialise the xLastWakeTime variable with the current time.
-     xLastWakeTime = xTaskGetTickCount ();
-     for( ;; )
-     {
-         // Wait for the next cycle.
-         vTaskDelayUntil( &xLastWakeTime, xFrequency );
-
-         // Perform action here.
-     }
- }
-
- * \defgroup vTaskDelayUntil vTaskDelayUntil - * \ingroup TaskCtrl - */ -void vTaskDelayUntil( - TickType_t *const pxPreviousWakeTime, - const TickType_t xTimeIncrement) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
BaseType_t xTaskAbortDelay( TaskHandle_t xTask );
- * - * INCLUDE_xTaskAbortDelay must be defined as 1 in FreeRTOSConfig.h for this - * function to be available. - * - * A task will enter the Blocked state when it is waiting for an event. The - * event it is waiting for can be a temporal event (waiting for a time), such - * as when vTaskDelay() is called, or an event on an object, such as when - * xQueueReceive() or ulTaskNotifyTake() is called. If the handle of a task - * that is in the Blocked state is used in a call to xTaskAbortDelay() then the - * task will leave the Blocked state, and return from whichever function call - * placed the task into the Blocked state. - * - * There is no 'FromISR' version of this function as an interrupt would need to - * know which object a task was blocked on in order to know which actions to - * take. For example, if the task was blocked on a queue the interrupt handler - * would then need to know if the queue was locked. - * - * @param xTask The handle of the task to remove from the Blocked state. - * - * @return If the task referenced by xTask was not in the Blocked state then - * pdFAIL is returned. Otherwise pdPASS is returned. - * - * \defgroup xTaskAbortDelay xTaskAbortDelay - * \ingroup TaskCtrl - */ -BaseType_t xTaskAbortDelay(TaskHandle_t xTask) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask );
- * - * INCLUDE_uxTaskPriorityGet must be defined as 1 for this function to be - available. - * See the configuration section for more information. - * - * Obtain the priority of any task. - * - * @param xTask Handle of the task to be queried. Passing a NULL - * handle results in the priority of the calling task being returned. - * - * @return The priority of xTask. - * - * Example usage: - 
- void vAFunction( void )
- {
- TaskHandle_t xHandle;
-
-     // Create a task, storing the handle.
-     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY,
- &xHandle );
-
-     // ...
-
-     // Use the handle to obtain the priority of the created task.
-     // It was created with tskIDLE_PRIORITY, but may have changed
-     // it itself.
-     if( uxTaskPriorityGet( xHandle ) != tskIDLE_PRIORITY )
-     {
-         // The task has changed it's priority.
-     }
-
-     // ...
-
-     // Is our priority higher than the created task?
-     if( uxTaskPriorityGet( xHandle ) < uxTaskPriorityGet( NULL ) )
-     {
-         // Our priority (obtained using NULL handle) is higher.
-     }
- }
-
- * \defgroup uxTaskPriorityGet uxTaskPriorityGet - * \ingroup TaskCtrl - */ -UBaseType_t uxTaskPriorityGet(const TaskHandle_t xTask) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask );
- * - * A version of uxTaskPriorityGet() that can be used from an ISR. - */ -UBaseType_t uxTaskPriorityGetFromISR(const TaskHandle_t xTask) - PRIVILEGED_FUNCTION; - -/** - * task. h - * 
eTaskState eTaskGetState( TaskHandle_t xTask );
- * - * INCLUDE_eTaskGetState must be defined as 1 for this function to be available. - * See the configuration section for more information. - * - * Obtain the state of any task. States are encoded by the eTaskState - * enumerated type. - * - * @param xTask Handle of the task to be queried. - * - * @return The state of xTask at the time the function was called. Note the - * state of the task might change between the function being called, and the - * functions return value being tested by the calling task. - */ -eTaskState eTaskGetState(TaskHandle_t xTask) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
void vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus,
- BaseType_t xGetFreeStackSpace, eTaskState eState );
- * - * configUSE_TRACE_FACILITY must be defined as 1 for this function to be - * available. See the configuration section for more information. - * - * Populates a TaskStatus_t structure with information about a task. - * - * @param xTask Handle of the task being queried. If xTask is NULL then - * information will be returned about the calling task. - * - * @param pxTaskStatus A pointer to the TaskStatus_t structure that will be - * filled with information about the task referenced by the handle passed using - * the xTask parameter. - * - * @xGetFreeStackSpace The TaskStatus_t structure contains a member to report - * the stack high water mark of the task being queried. Calculating the stack - * high water mark takes a relatively long time, and can make the system - * temporarily unresponsive - so the xGetFreeStackSpace parameter is provided to - * allow the high water mark checking to be skipped. The high watermark value - * will only be written to the TaskStatus_t structure if xGetFreeStackSpace is - * not set to pdFALSE; - * - * @param eState The TaskStatus_t structure contains a member to report the - * state of the task being queried. Obtaining the task state is not as fast as - * a simple assignment - so the eState parameter is provided to allow the state - * information to be omitted from the TaskStatus_t structure. To obtain state - * information then set eState to eInvalid - otherwise the value passed in - * eState will be reported as the task state in the TaskStatus_t structure. - * - * Example usage: - 
- void vAFunction( void )
- {
- TaskHandle_t xHandle;
- TaskStatus_t xTaskDetails;
-
-    // Obtain the handle of a task from its name.
-    xHandle = xTaskGetHandle( "Task_Name" );
-
-    // Check the handle is not NULL.
-    configASSERT( xHandle );
-
-    // Use the handle to obtain further information about the task.
-    vTaskGetInfo( xHandle,
-                  &xTaskDetails,
-                  pdTRUE, // Include the high water mark in xTaskDetails.
-                  eInvalid ); // Include the task state in xTaskDetails.
- }
-
- * \defgroup vTaskGetInfo vTaskGetInfo - * \ingroup TaskCtrl - */ -void vTaskGetInfo( - TaskHandle_t xTask, - TaskStatus_t *pxTaskStatus, - BaseType_t xGetFreeStackSpace, - eTaskState eState) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority
- );
- * - * INCLUDE_vTaskPrioritySet must be defined as 1 for this function to be - available. - * See the configuration section for more information. - * - * Set the priority of any task. - * - * A context switch will occur before the function returns if the priority - * being set is higher than the currently executing task. - * - * @param xTask Handle to the task for which the priority is being set. - * Passing a NULL handle results in the priority of the calling task being set. - * - * @param uxNewPriority The priority to which the task will be set. - * - * Example usage: - 
- void vAFunction( void )
- {
- TaskHandle_t xHandle;
-
-     // Create a task, storing the handle.
-     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY,
- &xHandle );
-
-     // ...
-
-     // Use the handle to raise the priority of the created task.
-     vTaskPrioritySet( xHandle, tskIDLE_PRIORITY + 1 );
-
-     // ...
-
-     // Use a NULL handle to raise our priority to the same value.
-     vTaskPrioritySet( NULL, tskIDLE_PRIORITY + 1 );
- }
-
- * \defgroup vTaskPrioritySet vTaskPrioritySet - * \ingroup TaskCtrl - */ -void vTaskPrioritySet(TaskHandle_t xTask, UBaseType_t uxNewPriority) - PRIVILEGED_FUNCTION; - -/** - * task. h - * 
void vTaskSuspend( TaskHandle_t xTaskToSuspend );
- * - * INCLUDE_vTaskSuspend must be defined as 1 for this function to be available. - * See the configuration section for more information. - * - * Suspend any task. When suspended a task will never get any microcontroller - * processing time, no matter what its priority. - * - * Calls to vTaskSuspend are not accumulative - - * i.e. calling vTaskSuspend () twice on the same task still only requires one - * call to vTaskResume () to ready the suspended task. - * - * @param xTaskToSuspend Handle to the task being suspended. Passing a NULL - * handle will cause the calling task to be suspended. - * - * Example usage: - 
- void vAFunction( void )
- {
- TaskHandle_t xHandle;
-
-     // Create a task, storing the handle.
-     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY,
- &xHandle );
-
-     // ...
-
-     // Use the handle to suspend the created task.
-     vTaskSuspend( xHandle );
-
-     // ...
-
-     // The created task will not run during this period, unless
-     // another task calls vTaskResume( xHandle ).
-
-     //...
-
-
-     // Suspend ourselves.
-     vTaskSuspend( NULL );
-
-     // We cannot get here unless another task calls vTaskResume
-     // with our handle as the parameter.
- }
-
- * \defgroup vTaskSuspend vTaskSuspend - * \ingroup TaskCtrl - */ -void vTaskSuspend(TaskHandle_t xTaskToSuspend) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
void vTaskResume( TaskHandle_t xTaskToResume );
- * - * INCLUDE_vTaskSuspend must be defined as 1 for this function to be available. - * See the configuration section for more information. - * - * Resumes a suspended task. - * - * A task that has been suspended by one or more calls to vTaskSuspend () - * will be made available for running again by a single call to - * vTaskResume (). - * - * @param xTaskToResume Handle to the task being readied. - * - * Example usage: - 
- void vAFunction( void )
- {
- TaskHandle_t xHandle;
-
-     // Create a task, storing the handle.
-     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY,
- &xHandle );
-
-     // ...
-
-     // Use the handle to suspend the created task.
-     vTaskSuspend( xHandle );
-
-     // ...
-
-     // The created task will not run during this period, unless
-     // another task calls vTaskResume( xHandle ).
-
-     //...
-
-
-     // Resume the suspended task ourselves.
-     vTaskResume( xHandle );
-
-     // The created task will once again get microcontroller processing
-     // time in accordance with its priority within the system.
- }
-
- * \defgroup vTaskResume vTaskResume - * \ingroup TaskCtrl - */ -void vTaskResume(TaskHandle_t xTaskToResume) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
void xTaskResumeFromISR( TaskHandle_t xTaskToResume );
- * - * INCLUDE_xTaskResumeFromISR must be defined as 1 for this function to be - * available. See the configuration section for more information. - * - * An implementation of vTaskResume() that can be called from within an ISR. - * - * A task that has been suspended by one or more calls to vTaskSuspend () - * will be made available for running again by a single call to - * xTaskResumeFromISR (). - * - * xTaskResumeFromISR() should not be used to synchronise a task with an - * interrupt if there is a chance that the interrupt could arrive prior to the - * task being suspended - as this can lead to interrupts being missed. Use of a - * semaphore as a synchronisation mechanism would avoid this eventuality. - * - * @param xTaskToResume Handle to the task being readied. - * - * @return pdTRUE if resuming the task should result in a context switch, - * otherwise pdFALSE. This is used by the ISR to determine if a context switch - * may be required following the ISR. - * - * \defgroup vTaskResumeFromISR vTaskResumeFromISR - * \ingroup TaskCtrl - */ -BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume) PRIVILEGED_FUNCTION; - -/*----------------------------------------------------------- - * SCHEDULER CONTROL - *----------------------------------------------------------*/ - -/** - * task. h - * 
void vTaskStartScheduler( void );
- * - * Starts the real time kernel tick processing. After calling the kernel - * has control over which tasks are executed and when. - * - * See the demo application file main.c for an example of creating - * tasks and starting the kernel. - * - * Example usage: - 
- void vAFunction( void )
- {
-     // Create at least one task before starting the kernel.
-     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
-
-     // Start the real time kernel with preemption.
-     vTaskStartScheduler ();
-
-     // Will not get here unless a task calls vTaskEndScheduler ()
- }
-
- * - * \defgroup vTaskStartScheduler vTaskStartScheduler - * \ingroup SchedulerControl - */ -void vTaskStartScheduler(void) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
void vTaskEndScheduler( void );
- * - * NOTE: At the time of writing only the x86 real mode port, which runs on a PC - * in place of DOS, implements this function. - * - * Stops the real time kernel tick. All created tasks will be automatically - * deleted and multitasking (either preemptive or cooperative) will - * stop. Execution then resumes from the point where vTaskStartScheduler () - * was called, as if vTaskStartScheduler () had just returned. - * - * See the demo application file main. c in the demo/PC directory for an - * example that uses vTaskEndScheduler (). - * - * vTaskEndScheduler () requires an exit function to be defined within the - * portable layer (see vPortEndScheduler () in port. c for the PC port). This - * performs hardware specific operations such as stopping the kernel tick. - * - * vTaskEndScheduler () will cause all of the resources allocated by the - * kernel to be freed - but will not free resources allocated by application - * tasks. - * - * Example usage: - 
- void vTaskCode( void * pvParameters )
- {
-     for( ;; )
-     {
-         // Task code goes here.
-
-         // At some point we want to end the real time kernel processing
-         // so call ...
-         vTaskEndScheduler ();
-     }
- }
-
- void vAFunction( void )
- {
-     // Create at least one task before starting the kernel.
-     xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
-
-     // Start the real time kernel with preemption.
-     vTaskStartScheduler ();
-
-     // Will only get here when the vTaskCode () task has called
-     // vTaskEndScheduler ().  When we get here we are back to single task
-     // execution.
- }
-
- * - * \defgroup vTaskEndScheduler vTaskEndScheduler - * \ingroup SchedulerControl - */ -void vTaskEndScheduler(void) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
void vTaskSuspendAll( void );
- * - * Suspends the scheduler without disabling interrupts. Context switches will - * not occur while the scheduler is suspended. - * - * After calling vTaskSuspendAll () the calling task will continue to execute - * without risk of being swapped out until a call to xTaskResumeAll () has been - * made. - * - * API functions that have the potential to cause a context switch (for example, - * vTaskDelayUntil(), xQueueSend(), etc.) must not be called while the scheduler - * is suspended. - * - * Example usage: - 
- void vTask1( void * pvParameters )
- {
-     for( ;; )
-     {
-         // Task code goes here.
-
-         // ...
-
-         // At some point the task wants to perform a long operation during
-         // which it does not want to get swapped out.  It cannot use
-         // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the
-         // operation may cause interrupts to be missed - including the
-         // ticks.
-
-         // Prevent the real time kernel swapping out the task.
-         vTaskSuspendAll ();
-
-         // Perform the operation here.  There is no need to use critical
-         // sections as we have all the microcontroller processing time.
-         // During this time interrupts will still operate and the kernel
-         // tick count will be maintained.
-
-         // ...
-
-         // The operation is complete.  Restart the kernel.
-         xTaskResumeAll ();
-     }
- }
-
- * \defgroup vTaskSuspendAll vTaskSuspendAll - * \ingroup SchedulerControl - */ -void vTaskSuspendAll(void) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
BaseType_t xTaskResumeAll( void );
- * - * Resumes scheduler activity after it was suspended by a call to - * vTaskSuspendAll(). - * - * xTaskResumeAll() only resumes the scheduler. It does not unsuspend tasks - * that were previously suspended by a call to vTaskSuspend(). - * - * @return If resuming the scheduler caused a context switch then pdTRUE is - * returned, otherwise pdFALSE is returned. - * - * Example usage: - 
- void vTask1( void * pvParameters )
- {
-     for( ;; )
-     {
-         // Task code goes here.
-
-         // ...
-
-         // At some point the task wants to perform a long operation during
-         // which it does not want to get swapped out.  It cannot use
-         // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the
-         // operation may cause interrupts to be missed - including the
-         // ticks.
-
-         // Prevent the real time kernel swapping out the task.
-         vTaskSuspendAll ();
-
-         // Perform the operation here.  There is no need to use critical
-         // sections as we have all the microcontroller processing time.
-         // During this time interrupts will still operate and the real
-         // time kernel tick count will be maintained.
-
-         // ...
-
-         // The operation is complete.  Restart the kernel.  We want to force
-         // a context switch - but there is no point if resuming the scheduler
-         // caused a context switch already.
-         if( !xTaskResumeAll () )
-         {
-              taskYIELD ();
-         }
-     }
- }
-
- * \defgroup xTaskResumeAll xTaskResumeAll - * \ingroup SchedulerControl - */ -BaseType_t xTaskResumeAll(void) PRIVILEGED_FUNCTION; - -/*----------------------------------------------------------- - * TASK UTILITIES - *----------------------------------------------------------*/ - -/** - * task. h - * 
TickType_t xTaskGetTickCount( void );
- * - * @return The count of ticks since vTaskStartScheduler was called. - * - * \defgroup xTaskGetTickCount xTaskGetTickCount - * \ingroup TaskUtils - */ -TickType_t xTaskGetTickCount(void) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
TickType_t xTaskGetTickCountFromISR( void );
- * - * @return The count of ticks since vTaskStartScheduler was called. - * - * This is a version of xTaskGetTickCount() that is safe to be called from an - * ISR - provided that TickType_t is the natural word size of the - * microcontroller being used or interrupt nesting is either not supported or - * not being used. - * - * \defgroup xTaskGetTickCountFromISR xTaskGetTickCountFromISR - * \ingroup TaskUtils - */ -TickType_t xTaskGetTickCountFromISR(void) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
uint16_t uxTaskGetNumberOfTasks( void );
- * - * @return The number of tasks that the real time kernel is currently managing. - * This includes all ready, blocked and suspended tasks. A task that - * has been deleted but not yet freed by the idle task will also be - * included in the count. - * - * \defgroup uxTaskGetNumberOfTasks uxTaskGetNumberOfTasks - * \ingroup TaskUtils - */ -UBaseType_t uxTaskGetNumberOfTasks(void) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
char *pcTaskGetName( TaskHandle_t xTaskToQuery );
- * - * @return The text (human readable) name of the task referenced by the handle - * xTaskToQuery. A task can query its own name by either passing in its own - * handle, or by setting xTaskToQuery to NULL. - * - * \defgroup pcTaskGetName pcTaskGetName - * \ingroup TaskUtils - */ -char *pcTaskGetName(TaskHandle_t xTaskToQuery) - PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for - strings and single characters only. */ - -/** - * task. h - * 
TaskHandle_t xTaskGetHandle( const char *pcNameToQuery );
- * - * NOTE: This function takes a relatively long time to complete and should be - * used sparingly. - * - * @return The handle of the task that has the human readable name - * pcNameToQuery. NULL is returned if no matching name is found. - * INCLUDE_xTaskGetHandle must be set to 1 in FreeRTOSConfig.h for - * pcTaskGetHandle() to be available. - * - * \defgroup pcTaskGetHandle pcTaskGetHandle - * \ingroup TaskUtils - */ -TaskHandle_t xTaskGetHandle(const char *pcNameToQuery) - PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for - strings and single characters only. */ - -/** - * task.h - * 
UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask );
- * - * INCLUDE_uxTaskGetStackHighWaterMark must be set to 1 in FreeRTOSConfig.h for - * this function to be available. - * - * Returns the high water mark of the stack associated with xTask. That is, - * the minimum free stack space there has been (in words, so on a 32 bit machine - * a value of 1 means 4 bytes) since the task started. The smaller the returned - * number the closer the task has come to overflowing its stack. - * - * uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the - * same except for their return type. Using configSTACK_DEPTH_TYPE allows the - * user to determine the return type. It gets around the problem of the value - * overflowing on 8-bit types without breaking backward compatibility for - * applications that expect an 8-bit return type. - * - * @param xTask Handle of the task associated with the stack to be checked. - * Set xTask to NULL to check the stack of the calling task. - * - * @return The smallest amount of free stack space there has been (in words, so - * actual spaces on the stack rather than bytes) since the task referenced by - * xTask was created. - */ -UBaseType_t uxTaskGetStackHighWaterMark(TaskHandle_t xTask) PRIVILEGED_FUNCTION; - -/** - * task.h - * 
configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask
- * );
- * - * INCLUDE_uxTaskGetStackHighWaterMark2 must be set to 1 in FreeRTOSConfig.h for - * this function to be available. - * - * Returns the high water mark of the stack associated with xTask. That is, - * the minimum free stack space there has been (in words, so on a 32 bit machine - * a value of 1 means 4 bytes) since the task started. The smaller the returned - * number the closer the task has come to overflowing its stack. - * - * uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the - * same except for their return type. Using configSTACK_DEPTH_TYPE allows the - * user to determine the return type. It gets around the problem of the value - * overflowing on 8-bit types without breaking backward compatibility for - * applications that expect an 8-bit return type. - * - * @param xTask Handle of the task associated with the stack to be checked. - * Set xTask to NULL to check the stack of the calling task. - * - * @return The smallest amount of free stack space there has been (in words, so - * actual spaces on the stack rather than bytes) since the task referenced by - * xTask was created. - */ -configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2(TaskHandle_t xTask) - PRIVILEGED_FUNCTION; - -/* When using trace macros it is sometimes necessary to include task.h before -FreeRTOS.h. When this is done TaskHookFunction_t will not yet have been -defined, so the following two prototypes will cause a compilation error. This -can be fixed by simply guarding against the inclusion of these two prototypes -unless they are explicitly required by the configUSE_APPLICATION_TASK_TAG -configuration constant. */ -#ifdef configUSE_APPLICATION_TASK_TAG -# if configUSE_APPLICATION_TASK_TAG == 1 -/** - * task.h - * 
void vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t
- * pxHookFunction );
- * - * Sets pxHookFunction to be the task hook function used by the task xTask. - * Passing xTask as NULL has the effect of setting the calling tasks hook - * function. - */ -void vTaskSetApplicationTaskTag( - TaskHandle_t xTask, - TaskHookFunction_t pxHookFunction) PRIVILEGED_FUNCTION; - -/** - * task.h - * 
void xTaskGetApplicationTaskTag( TaskHandle_t xTask );
- * - * Returns the pxHookFunction value assigned to the task xTask. Do not - * call from an interrupt service routine - call - * xTaskGetApplicationTaskTagFromISR() instead. - */ -TaskHookFunction_t xTaskGetApplicationTaskTag(TaskHandle_t xTask) - PRIVILEGED_FUNCTION; - -/** - * task.h - * 
void xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask );
- * - * Returns the pxHookFunction value assigned to the task xTask. Can - * be called from an interrupt service routine. - */ -TaskHookFunction_t xTaskGetApplicationTaskTagFromISR(TaskHandle_t xTask) - PRIVILEGED_FUNCTION; -# endif /* configUSE_APPLICATION_TASK_TAG ==1 */ -#endif /* ifdef configUSE_APPLICATION_TASK_TAG */ - -#if (configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0) - -/* Each task contains an array of pointers that is dimensioned by the -configNUM_THREAD_LOCAL_STORAGE_POINTERS setting in FreeRTOSConfig.h. The -kernel does not use the pointers itself, so the application writer can use -the pointers for any purpose they wish. The following two functions are -used to set and query a pointer respectively. */ -void vTaskSetThreadLocalStoragePointer( - TaskHandle_t xTaskToSet, - BaseType_t xIndex, - void *pvValue) PRIVILEGED_FUNCTION; -void *pvTaskGetThreadLocalStoragePointer( - TaskHandle_t xTaskToQuery, - BaseType_t xIndex) PRIVILEGED_FUNCTION; - -#endif - -/** - * task.h - * 
BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask, void
- * *pvParameter );
- * - * Calls the hook function associated with xTask. Passing xTask as NULL has - * the effect of calling the Running tasks (the calling task) hook function. - * - * pvParameter is passed to the hook function for the task to interpret as it - * wants. The return value is the value returned by the task hook function - * registered by the user. - */ -BaseType_t xTaskCallApplicationTaskHook(TaskHandle_t xTask, void *pvParameter) - PRIVILEGED_FUNCTION; - -/** - * xTaskGetIdleTaskHandle() is only available if - * INCLUDE_xTaskGetIdleTaskHandle is set to 1 in FreeRTOSConfig.h. - * - * Simply returns the handle of the idle task. It is not valid to call - * xTaskGetIdleTaskHandle() before the scheduler has been started. - */ -TaskHandle_t xTaskGetIdleTaskHandle(void) PRIVILEGED_FUNCTION; - -/** - * configUSE_TRACE_FACILITY must be defined as 1 in FreeRTOSConfig.h for - * uxTaskGetSystemState() to be available. - * - * uxTaskGetSystemState() populates an TaskStatus_t structure for each task in - * the system. TaskStatus_t structures contain, among other things, members - * for the task handle, task name, task priority, task state, and total amount - * of run time consumed by the task. See the TaskStatus_t structure - * definition in this file for the full member list. - * - * NOTE: This function is intended for debugging use only as its use results in - * the scheduler remaining suspended for an extended period. - * - * @param pxTaskStatusArray A pointer to an array of TaskStatus_t structures. - * The array must contain at least one TaskStatus_t structure for each task - * that is under the control of the RTOS. The number of tasks under the control - * of the RTOS can be determined using the uxTaskGetNumberOfTasks() API - function. - * - * @param uxArraySize The size of the array pointed to by the pxTaskStatusArray - * parameter. The size is specified as the number of indexes in the array, or - * the number of TaskStatus_t structures contained in the array, not by the - * number of bytes in the array. - * - * @param pulTotalRunTime If configGENERATE_RUN_TIME_STATS is set to 1 in - * FreeRTOSConfig.h then *pulTotalRunTime is set by uxTaskGetSystemState() to - the - * total run time (as defined by the run time stats clock, see - * http://www.freertos.org/rtos-run-time-stats.html) since the target booted. - * pulTotalRunTime can be set to NULL to omit the total run time information. - * - * @return The number of TaskStatus_t structures that were populated by - * uxTaskGetSystemState(). This should equal the number returned by the - * uxTaskGetNumberOfTasks() API function, but will be zero if the value passed - * in the uxArraySize parameter was too small. - * - * Example usage: - 
-    // This example demonstrates how a human readable table of run time stats
-    // information is generated from raw data provided by
- uxTaskGetSystemState().
-    // The human readable table is written to pcWriteBuffer
-    void vTaskGetRunTimeStats( char *pcWriteBuffer )
-    {
-    TaskStatus_t *pxTaskStatusArray;
-    volatile UBaseType_t uxArraySize, x;
-    uint32_t ulTotalRunTime, ulStatsAsPercentage;
-
-        // Make sure the write buffer does not contain a string.
-        *pcWriteBuffer = 0x00;
-
-        // Take a snapshot of the number of tasks in case it changes while this
-        // function is executing.
-        uxArraySize = uxTaskGetNumberOfTasks();
-
-        // Allocate a TaskStatus_t structure for each task.  An array could be
-        // allocated statically at compile time.
-        pxTaskStatusArray = pvPortMalloc( uxArraySize * sizeof( TaskStatus_t )
- );
-
-        if( pxTaskStatusArray != NULL )
-        {
-            // Generate raw status information about each task.
-            uxArraySize = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize,
- &ulTotalRunTime );
-
-            // For percentage calculations.
-            ulTotalRunTime /= 100UL;
-
-            // Avoid divide by zero errors.
-            if( ulTotalRunTime > 0 )
-            {
-                // For each populated position in the pxTaskStatusArray array,
-                // format the raw data as human readable ASCII data
-                for( x = 0; x < uxArraySize; x++ )
-                {
-                    // What percentage of the total run time has the task used?
-                    // This will always be rounded down to the nearest integer.
-                    // ulTotalRunTimeDiv100 has already been divided by 100.
-                    ulStatsAsPercentage = pxTaskStatusArray[ x
- ].ulRunTimeCounter / ulTotalRunTime;
-
-                    if( ulStatsAsPercentage > 0UL )
-                    {
-                        sprintf( pcWriteBuffer, "%s\t\t%lu\t\t%lu%%\r\n",
- pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter,
- ulStatsAsPercentage );
-                    }
-                    else
-                    {
-                        // If the percentage is zero here then the task has
-                        // consumed less than 1% of the total run time.
-                        sprintf( pcWriteBuffer, "%s\t\t%lu\t\t<1%%\r\n",
- pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter );
-                    }
-
-                    pcWriteBuffer += strlen( ( char * ) pcWriteBuffer );
-                }
-            }
-
-            // The array is no longer needed, free the memory it consumes.
-            vPortFree( pxTaskStatusArray );
-        }
-    }
-
- */ -UBaseType_t uxTaskGetSystemState( - TaskStatus_t *const pxTaskStatusArray, - const UBaseType_t uxArraySize, - uint32_t *const pulTotalRunTime) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
void vTaskList( char *pcWriteBuffer );
- * - * configUSE_TRACE_FACILITY and configUSE_STATS_FORMATTING_FUNCTIONS must - * both be defined as 1 for this function to be available. See the - * configuration section of the FreeRTOS.org website for more information. - * - * NOTE 1: This function will disable interrupts for its duration. It is - * not intended for normal application runtime use but as a debug aid. - * - * Lists all the current tasks, along with their current state and stack - * usage high water mark. - * - * Tasks are reported as blocked ('B'), ready ('R'), deleted ('D') or - * suspended ('S'). - * - * PLEASE NOTE: - * - * This function is provided for convenience only, and is used by many of the - * demo applications. Do not consider it to be part of the scheduler. - * - * vTaskList() calls uxTaskGetSystemState(), then formats part of the - * uxTaskGetSystemState() output into a human readable table that displays task - * names, states and stack usage. - * - * vTaskList() has a dependency on the sprintf() C library function that might - * bloat the code size, use a lot of stack, and provide different results on - * different platforms. An alternative, tiny, third party, and limited - * functionality implementation of sprintf() is provided in many of the - * FreeRTOS/Demo sub-directories in a file called printf-stdarg.c (note - * printf-stdarg.c does not provide a full snprintf() implementation!). - * - * It is recommended that production systems call uxTaskGetSystemState() - * directly to get access to raw stats data, rather than indirectly through a - * call to vTaskList(). - * - * @param pcWriteBuffer A buffer into which the above mentioned details - * will be written, in ASCII form. This buffer is assumed to be large - * enough to contain the generated report. Approximately 40 bytes per - * task should be sufficient. - * - * \defgroup vTaskList vTaskList - * \ingroup TaskUtils - */ -void vTaskList(char *pcWriteBuffer) - PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for - strings and single characters only. */ - -/** - * task. h - * 
void vTaskGetRunTimeStats( char *pcWriteBuffer );
- * - * configGENERATE_RUN_TIME_STATS and configUSE_STATS_FORMATTING_FUNCTIONS - * must both be defined as 1 for this function to be available. The application - * must also then provide definitions for - * portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and portGET_RUN_TIME_COUNTER_VALUE() - * to configure a peripheral timer/counter and return the timers current count - * value respectively. The counter should be at least 10 times the frequency of - * the tick count. - * - * NOTE 1: This function will disable interrupts for its duration. It is - * not intended for normal application runtime use but as a debug aid. - * - * Setting configGENERATE_RUN_TIME_STATS to 1 will result in a total - * accumulated execution time being stored for each task. The resolution - * of the accumulated time value depends on the frequency of the timer - * configured by the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() macro. - * Calling vTaskGetRunTimeStats() writes the total execution time of each - * task into a buffer, both as an absolute count value and as a percentage - * of the total system execution time. - * - * NOTE 2: - * - * This function is provided for convenience only, and is used by many of the - * demo applications. Do not consider it to be part of the scheduler. - * - * vTaskGetRunTimeStats() calls uxTaskGetSystemState(), then formats part of the - * uxTaskGetSystemState() output into a human readable table that displays the - * amount of time each task has spent in the Running state in both absolute and - * percentage terms. - * - * vTaskGetRunTimeStats() has a dependency on the sprintf() C library function - * that might bloat the code size, use a lot of stack, and provide different - * results on different platforms. An alternative, tiny, third party, and - * limited functionality implementation of sprintf() is provided in many of the - * FreeRTOS/Demo sub-directories in a file called printf-stdarg.c (note - * printf-stdarg.c does not provide a full snprintf() implementation!). - * - * It is recommended that production systems call uxTaskGetSystemState() - * directly to get access to raw stats data, rather than indirectly through a - * call to vTaskGetRunTimeStats(). - * - * @param pcWriteBuffer A buffer into which the execution times will be - * written, in ASCII form. This buffer is assumed to be large enough to - * contain the generated report. Approximately 40 bytes per task should - * be sufficient. - * - * \defgroup vTaskGetRunTimeStats vTaskGetRunTimeStats - * \ingroup TaskUtils - */ -void vTaskGetRunTimeStats(char *pcWriteBuffer) - PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for - strings and single characters only. */ - -/** - * task. h - * 
uint32_t ulTaskGetIdleRunTimeCounter( void );
- * - * configGENERATE_RUN_TIME_STATS and configUSE_STATS_FORMATTING_FUNCTIONS - * must both be defined as 1 for this function to be available. The application - * must also then provide definitions for - * portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and portGET_RUN_TIME_COUNTER_VALUE() - * to configure a peripheral timer/counter and return the timers current count - * value respectively. The counter should be at least 10 times the frequency of - * the tick count. - * - * Setting configGENERATE_RUN_TIME_STATS to 1 will result in a total - * accumulated execution time being stored for each task. The resolution - * of the accumulated time value depends on the frequency of the timer - * configured by the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() macro. - * While uxTaskGetSystemState() and vTaskGetRunTimeStats() writes the total - * execution time of each task into a buffer, ulTaskGetIdleRunTimeCounter() - * returns the total execution time of just the idle task. - * - * @return The total run time of the idle task. This is the amount of time the - * idle task has actually been executing. The unit of time is dependent on the - * frequency configured using the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and - * portGET_RUN_TIME_COUNTER_VALUE() macros. - * - * \defgroup ulTaskGetIdleRunTimeCounter ulTaskGetIdleRunTimeCounter - * \ingroup TaskUtils - */ -uint32_t ulTaskGetIdleRunTimeCounter(void) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue,
- * eNotifyAction eAction );
- * - * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this - * function to be available. - * - * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private - * "notification value", which is a 32-bit unsigned integer (uint32_t). - * - * Events can be sent to a task using an intermediary object. Examples of such - * objects are queues, semaphores, mutexes and event groups. Task notifications - * are a method of sending an event directly to a task without the need for such - * an intermediary object. - * - * A notification sent to a task can optionally perform an action, such as - * update, overwrite or increment the task's notification value. In that way - * task notifications can be used to send data to a task, or be used as light - * weight and fast binary or counting semaphores. - * - * A notification sent to a task will remain pending until it is cleared by the - * task calling xTaskNotifyWait() or ulTaskNotifyTake(). If the task was - * already in the Blocked state to wait for a notification when the notification - * arrives then the task will automatically be removed from the Blocked state - * (unblocked) and the notification cleared. - * - * A task can use xTaskNotifyWait() to [optionally] block to wait for a - * notification to be pending, or ulTaskNotifyTake() to [optionally] block - * to wait for its notification value to have a non-zero value. The task does - * not consume any CPU time while it is in the Blocked state. - * - * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details. - * - * @param xTaskToNotify The handle of the task being notified. The handle to a - * task can be returned from the xTaskCreate() API function used to create the - * task, and the handle of the currently running task can be obtained by calling - * xTaskGetCurrentTaskHandle(). - * - * @param ulValue Data that can be sent with the notification. How the data is - * used depends on the value of the eAction parameter. - * - * @param eAction Specifies how the notification updates the task's notification - * value, if at all. Valid values for eAction are as follows: - * - * eSetBits - - * The task's notification value is bitwise ORed with ulValue. xTaskNofify() - * always returns pdPASS in this case. - * - * eIncrement - - * The task's notification value is incremented. ulValue is not used and - * xTaskNotify() always returns pdPASS in this case. - * - * eSetValueWithOverwrite - - * The task's notification value is set to the value of ulValue, even if the - * task being notified had not yet processed the previous notification (the - * task already had a notification pending). xTaskNotify() always returns - * pdPASS in this case. - * - * eSetValueWithoutOverwrite - - * If the task being notified did not already have a notification pending then - * the task's notification value is set to ulValue and xTaskNotify() will - * return pdPASS. If the task being notified already had a notification - * pending then no action is performed and pdFAIL is returned. - * - * eNoAction - - * The task receives a notification without its notification value being - * updated. ulValue is not used and xTaskNotify() always returns pdPASS in - * this case. - * - * pulPreviousNotificationValue - - * Can be used to pass out the subject task's notification value before any - * bits are modified by the notify function. - * - * @return Dependent on the value of eAction. See the description of the - * eAction parameter. - * - * \defgroup xTaskNotify xTaskNotify - * \ingroup TaskNotifications - */ -BaseType_t xTaskGenericNotify( - TaskHandle_t xTaskToNotify, - uint32_t ulValue, - eNotifyAction eAction, - uint32_t *pulPreviousNotificationValue) PRIVILEGED_FUNCTION; -#define xTaskNotify(xTaskToNotify, ulValue, eAction) \ - xTaskGenericNotify((xTaskToNotify), (ulValue), (eAction), NULL) -#define xTaskNotifyAndQuery( \ - xTaskToNotify, ulValue, eAction, pulPreviousNotifyValue) \ - xTaskGenericNotify( \ - (xTaskToNotify), (ulValue), (eAction), (pulPreviousNotifyValue)) - -/** - * task. h - * 
BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t
- * ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken
- * );
- * - * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this - * function to be available. - * - * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private - * "notification value", which is a 32-bit unsigned integer (uint32_t). - * - * A version of xTaskNotify() that can be used from an interrupt service routine - * (ISR). - * - * Events can be sent to a task using an intermediary object. Examples of such - * objects are queues, semaphores, mutexes and event groups. Task notifications - * are a method of sending an event directly to a task without the need for such - * an intermediary object. - * - * A notification sent to a task can optionally perform an action, such as - * update, overwrite or increment the task's notification value. In that way - * task notifications can be used to send data to a task, or be used as light - * weight and fast binary or counting semaphores. - * - * A notification sent to a task will remain pending until it is cleared by the - * task calling xTaskNotifyWait() or ulTaskNotifyTake(). If the task was - * already in the Blocked state to wait for a notification when the notification - * arrives then the task will automatically be removed from the Blocked state - * (unblocked) and the notification cleared. - * - * A task can use xTaskNotifyWait() to [optionally] block to wait for a - * notification to be pending, or ulTaskNotifyTake() to [optionally] block - * to wait for its notification value to have a non-zero value. The task does - * not consume any CPU time while it is in the Blocked state. - * - * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details. - * - * @param xTaskToNotify The handle of the task being notified. The handle to a - * task can be returned from the xTaskCreate() API function used to create the - * task, and the handle of the currently running task can be obtained by calling - * xTaskGetCurrentTaskHandle(). - * - * @param ulValue Data that can be sent with the notification. How the data is - * used depends on the value of the eAction parameter. - * - * @param eAction Specifies how the notification updates the task's notification - * value, if at all. Valid values for eAction are as follows: - * - * eSetBits - - * The task's notification value is bitwise ORed with ulValue. xTaskNofify() - * always returns pdPASS in this case. - * - * eIncrement - - * The task's notification value is incremented. ulValue is not used and - * xTaskNotify() always returns pdPASS in this case. - * - * eSetValueWithOverwrite - - * The task's notification value is set to the value of ulValue, even if the - * task being notified had not yet processed the previous notification (the - * task already had a notification pending). xTaskNotify() always returns - * pdPASS in this case. - * - * eSetValueWithoutOverwrite - - * If the task being notified did not already have a notification pending then - * the task's notification value is set to ulValue and xTaskNotify() will - * return pdPASS. If the task being notified already had a notification - * pending then no action is performed and pdFAIL is returned. - * - * eNoAction - - * The task receives a notification without its notification value being - * updated. ulValue is not used and xTaskNotify() always returns pdPASS in - * this case. - * - * @param pxHigherPriorityTaskWoken xTaskNotifyFromISR() will set - * *pxHigherPriorityTaskWoken to pdTRUE if sending the notification caused the - * task to which the notification was sent to leave the Blocked state, and the - * unblocked task has a priority higher than the currently running task. If - * xTaskNotifyFromISR() sets this value to pdTRUE then a context switch should - * be requested before the interrupt is exited. How a context switch is - * requested from an ISR is dependent on the port - see the documentation page - * for the port in use. - * - * @return Dependent on the value of eAction. See the description of the - * eAction parameter. - * - * \defgroup xTaskNotify xTaskNotify - * \ingroup TaskNotifications - */ -BaseType_t xTaskGenericNotifyFromISR( - TaskHandle_t xTaskToNotify, - uint32_t ulValue, - eNotifyAction eAction, - uint32_t *pulPreviousNotificationValue, - BaseType_t *pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION; -#define xTaskNotifyFromISR( \ - xTaskToNotify, ulValue, eAction, pxHigherPriorityTaskWoken) \ - xTaskGenericNotifyFromISR( \ - (xTaskToNotify), \ - (ulValue), \ - (eAction), \ - NULL, \ - (pxHigherPriorityTaskWoken)) -#define xTaskNotifyAndQueryFromISR( \ - xTaskToNotify, \ - ulValue, \ - eAction, \ - pulPreviousNotificationValue, \ - pxHigherPriorityTaskWoken) \ - xTaskGenericNotifyFromISR( \ - (xTaskToNotify), \ - (ulValue), \ - (eAction), \ - (pulPreviousNotificationValue), \ - (pxHigherPriorityTaskWoken)) - -/** - * task. h - * 
BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t
- * ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait
- * );
- * - * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this - * function to be available. - * - * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private - * "notification value", which is a 32-bit unsigned integer (uint32_t). - * - * Events can be sent to a task using an intermediary object. Examples of such - * objects are queues, semaphores, mutexes and event groups. Task notifications - * are a method of sending an event directly to a task without the need for such - * an intermediary object. - * - * A notification sent to a task can optionally perform an action, such as - * update, overwrite or increment the task's notification value. In that way - * task notifications can be used to send data to a task, or be used as light - * weight and fast binary or counting semaphores. - * - * A notification sent to a task will remain pending until it is cleared by the - * task calling xTaskNotifyWait() or ulTaskNotifyTake(). If the task was - * already in the Blocked state to wait for a notification when the notification - * arrives then the task will automatically be removed from the Blocked state - * (unblocked) and the notification cleared. - * - * A task can use xTaskNotifyWait() to [optionally] block to wait for a - * notification to be pending, or ulTaskNotifyTake() to [optionally] block - * to wait for its notification value to have a non-zero value. The task does - * not consume any CPU time while it is in the Blocked state. - * - * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details. - * - * @param ulBitsToClearOnEntry Bits that are set in ulBitsToClearOnEntry value - * will be cleared in the calling task's notification value before the task - * checks to see if any notifications are pending, and optionally blocks if no - * notifications are pending. Setting ulBitsToClearOnEntry to ULONG_MAX (if - * limits.h is included) or 0xffffffffUL (if limits.h is not included) will have - * the effect of resetting the task's notification value to 0. Setting - * ulBitsToClearOnEntry to 0 will leave the task's notification value unchanged. - * - * @param ulBitsToClearOnExit If a notification is pending or received before - * the calling task exits the xTaskNotifyWait() function then the task's - * notification value (see the xTaskNotify() API function) is passed out using - * the pulNotificationValue parameter. Then any bits that are set in - * ulBitsToClearOnExit will be cleared in the task's notification value (note - * *pulNotificationValue is set before any bits are cleared). Setting - * ulBitsToClearOnExit to ULONG_MAX (if limits.h is included) or 0xffffffffUL - * (if limits.h is not included) will have the effect of resetting the task's - * notification value to 0 before the function exits. Setting - * ulBitsToClearOnExit to 0 will leave the task's notification value unchanged - * when the function exits (in which case the value passed out in - * pulNotificationValue will match the task's notification value). - * - * @param pulNotificationValue Used to pass the task's notification value out - * of the function. Note the value passed out will not be effected by the - * clearing of any bits caused by ulBitsToClearOnExit being non-zero. - * - * @param xTicksToWait The maximum amount of time that the task should wait in - * the Blocked state for a notification to be received, should a notification - * not already be pending when xTaskNotifyWait() was called. The task - * will not consume any processing time while it is in the Blocked state. This - * is specified in kernel ticks, the macro pdMS_TO_TICSK( value_in_ms ) can be - * used to convert a time specified in milliseconds to a time specified in - * ticks. - * - * @return If a notification was received (including notifications that were - * already pending when xTaskNotifyWait was called) then pdPASS is - * returned. Otherwise pdFAIL is returned. - * - * \defgroup xTaskNotifyWait xTaskNotifyWait - * \ingroup TaskNotifications - */ -BaseType_t xTaskNotifyWait( - uint32_t ulBitsToClearOnEntry, - uint32_t ulBitsToClearOnExit, - uint32_t *pulNotificationValue, - TickType_t xTicksToWait) PRIVILEGED_FUNCTION; - -/** - * task. h - * 
BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );
- * - * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this macro - * to be available. - * - * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private - * "notification value", which is a 32-bit unsigned integer (uint32_t). - * - * Events can be sent to a task using an intermediary object. Examples of such - * objects are queues, semaphores, mutexes and event groups. Task notifications - * are a method of sending an event directly to a task without the need for such - * an intermediary object. - * - * A notification sent to a task can optionally perform an action, such as - * update, overwrite or increment the task's notification value. In that way - * task notifications can be used to send data to a task, or be used as light - * weight and fast binary or counting semaphores. - * - * xTaskNotifyGive() is a helper macro intended for use when task notifications - * are used as light weight and faster binary or counting semaphore equivalents. - * Actual FreeRTOS semaphores are given using the xSemaphoreGive() API function, - * the equivalent action that instead uses a task notification is - * xTaskNotifyGive(). - * - * When task notifications are being used as a binary or counting semaphore - * equivalent then the task being notified should wait for the notification - * using the ulTaskNotificationTake() API function rather than the - * xTaskNotifyWait() API function. - * - * See http://www.FreeRTOS.org/RTOS-task-notifications.html for more details. - * - * @param xTaskToNotify The handle of the task being notified. The handle to a - * task can be returned from the xTaskCreate() API function used to create the - * task, and the handle of the currently running task can be obtained by calling - * xTaskGetCurrentTaskHandle(). - * - * @return xTaskNotifyGive() is a macro that calls xTaskNotify() with the - * eAction parameter set to eIncrement - so pdPASS is always returned. - * - * \defgroup xTaskNotifyGive xTaskNotifyGive - * \ingroup TaskNotifications - */ -#define xTaskNotifyGive(xTaskToNotify) \ - xTaskGenericNotify((xTaskToNotify), (0), eIncrement, NULL) - -/** - * task. h - * 
void vTaskNotifyGiveFromISR( TaskHandle_t xTaskHandle, BaseType_t
- * *pxHigherPriorityTaskWoken );
- *
- * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this macro
- * to be available.
- *
- * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
- * "notification value", which is a 32-bit unsigned integer (uint32_t).
- *
- * A version of xTaskNotifyGive() that can be called from an interrupt service
- * routine (ISR).
- *
- * Events can be sent to a task using an intermediary object.  Examples of such
- * objects are queues, semaphores, mutexes and event groups.  Task notifications
- * are a method of sending an event directly to a task without the need for such
- * an intermediary object.
- *
- * A notification sent to a task can optionally perform an action, such as
- * update, overwrite or increment the task's notification value.  In that way
- * task notifications can be used to send data to a task, or be used as light
- * weight and fast binary or counting semaphores.
- *
- * vTaskNotifyGiveFromISR() is intended for use when task notifications are
- * used as light weight and faster binary or counting semaphore equivalents.
- * Actual FreeRTOS semaphores are given from an ISR using the
- * xSemaphoreGiveFromISR() API function, the equivalent action that instead uses
- * a task notification is vTaskNotifyGiveFromISR().
- *
- * When task notifications are being used as a binary or counting semaphore
- * equivalent then the task being notified should wait for the notification
- * using the ulTaskNotificationTake() API function rather than the
- * xTaskNotifyWait() API function.
- *
- * See http://www.FreeRTOS.org/RTOS-task-notifications.html for more details.
- *
- * @param xTaskToNotify The handle of the task being notified.  The handle to a
- * task can be returned from the xTaskCreate() API function used to create the
- * task, and the handle of the currently running task can be obtained by calling
- * xTaskGetCurrentTaskHandle().
- *
- * @param pxHigherPriorityTaskWoken  vTaskNotifyGiveFromISR() will set
- * *pxHigherPriorityTaskWoken to pdTRUE if sending the notification caused the
- * task to which the notification was sent to leave the Blocked state, and the
- * unblocked task has a priority higher than the currently running task.  If
- * vTaskNotifyGiveFromISR() sets this value to pdTRUE then a context switch
- * should be requested before the interrupt is exited.  How a context switch is
- * requested from an ISR is dependent on the port - see the documentation page
- * for the port in use.
- *
- * \defgroup xTaskNotifyWait xTaskNotifyWait
- * \ingroup TaskNotifications
- */
-void vTaskNotifyGiveFromISR(
-    TaskHandle_t xTaskToNotify,
-    BaseType_t *pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION;
-
-/**
- * task. h
- * 
uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t
- * xTicksToWait );

- *
- * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
- * function to be available.
- *
- * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
- * "notification value", which is a 32-bit unsigned integer (uint32_t).
- *
- * Events can be sent to a task using an intermediary object.  Examples of such
- * objects are queues, semaphores, mutexes and event groups.  Task notifications
- * are a method of sending an event directly to a task without the need for such
- * an intermediary object.
- *
- * A notification sent to a task can optionally perform an action, such as
- * update, overwrite or increment the task's notification value.  In that way
- * task notifications can be used to send data to a task, or be used as light
- * weight and fast binary or counting semaphores.
- *
- * ulTaskNotifyTake() is intended for use when a task notification is used as a
- * faster and lighter weight binary or counting semaphore alternative.  Actual
- * FreeRTOS semaphores are taken using the xSemaphoreTake() API function, the
- * equivalent action that instead uses a task notification is
- * ulTaskNotifyTake().
- *
- * When a task is using its notification value as a binary or counting semaphore
- * other tasks should send notifications to it using the xTaskNotifyGive()
- * macro, or xTaskNotify() function with the eAction parameter set to
- * eIncrement.
- *
- * ulTaskNotifyTake() can either clear the task's notification value to
- * zero on exit, in which case the notification value acts like a binary
- * semaphore, or decrement the task's notification value on exit, in which case
- * the notification value acts like a counting semaphore.
- *
- * A task can use ulTaskNotifyTake() to [optionally] block to wait for a
- * the task's notification value to be non-zero.  The task does not consume any
- * CPU time while it is in the Blocked state.
- *
- * Where as xTaskNotifyWait() will return when a notification is pending,
- * ulTaskNotifyTake() will return when the task's notification value is
- * not zero.
- *
- * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
- *
- * @param xClearCountOnExit if xClearCountOnExit is pdFALSE then the task's
- * notification value is decremented when the function exits.  In this way the
- * notification value acts like a counting semaphore.  If xClearCountOnExit is
- * not pdFALSE then the task's notification value is cleared to zero when the
- * function exits.  In this way the notification value acts like a binary
- * semaphore.
- *
- * @param xTicksToWait The maximum amount of time that the task should wait in
- * the Blocked state for the task's notification value to be greater than zero,
- * should the count not already be greater than zero when
- * ulTaskNotifyTake() was called.  The task will not consume any processing
- * time while it is in the Blocked state.  This is specified in kernel ticks,
- * the macro pdMS_TO_TICSK( value_in_ms ) can be used to convert a time
- * specified in milliseconds to a time specified in ticks.
- *
- * @return The task's notification count before it is either cleared to zero or
- * decremented (see the xClearCountOnExit parameter).
- *
- * \defgroup ulTaskNotifyTake ulTaskNotifyTake
- * \ingroup TaskNotifications
- */
-uint32_t ulTaskNotifyTake(BaseType_t xClearCountOnExit, TickType_t xTicksToWait)
-    PRIVILEGED_FUNCTION;
-
-/**
- * task. h
- * 
BaseType_t xTaskNotifyStateClear( TaskHandle_t xTask );

- *
- * If the notification state of the task referenced by the handle xTask is
- * eNotified, then set the task's notification state to eNotWaitingNotification.
- * The task's notification value is not altered.  Set xTask to NULL to clear the
- * notification state of the calling task.
- *
- * @return pdTRUE if the task's notification state was set to
- * eNotWaitingNotification, otherwise pdFALSE.
- * \defgroup xTaskNotifyStateClear xTaskNotifyStateClear
- * \ingroup TaskNotifications
- */
-BaseType_t xTaskNotifyStateClear(TaskHandle_t xTask);
-
-/**
- * task. h
- * 
uint32_t ulTaskNotifyValueClear( TaskHandle_t xTask, uint32_t
- * ulBitsToClear );

- *
- * Clears the bits specified by the ulBitsToClear bit mask in the notification
- * value of the task referenced by xTask.
- *
- * Set ulBitsToClear to 0xffffffff (UINT_MAX on 32-bit architectures) to clear
- * the notification value to 0.  Set ulBitsToClear to 0 to query the task's
- * notification value without clearing any bits.
- *
- * @return The value of the target task's notification value before the bits
- * specified by ulBitsToClear were cleared.
- * \defgroup ulTaskNotifyValueClear ulTaskNotifyValueClear
- * \ingroup TaskNotifications
- */
-uint32_t ulTaskNotifyValueClear(TaskHandle_t xTask, uint32_t ulBitsToClear)
-    PRIVILEGED_FUNCTION;
-
-/**
- * task.h
- * 
void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut )

- *
- * Capture the current time for future use with xTaskCheckForTimeOut().
- *
- * @param pxTimeOut Pointer to a timeout object into which the current time
- * is to be captured.  The captured time includes the tick count and the number
- * of times the tick count has overflowed since the system first booted.
- * \defgroup vTaskSetTimeOutState vTaskSetTimeOutState
- * \ingroup TaskCtrl
- */
-void vTaskSetTimeOutState(TimeOut_t *const pxTimeOut) PRIVILEGED_FUNCTION;
-
-/**
- * task.h
- * 
BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t
- * const pxTicksToWait );

- *
- * Determines if pxTicksToWait ticks has passed since a time was captured
- * using a call to vTaskSetTimeOutState().  The captured time includes the tick
- * count and the number of times the tick count has overflowed.
- *
- * @param pxTimeOut The time status as captured previously using
- * vTaskSetTimeOutState. If the timeout has not yet occurred, it is updated
- * to reflect the current time status.
- * @param pxTicksToWait The number of ticks to check for timeout i.e. if
- * pxTicksToWait ticks have passed since pxTimeOut was last updated (either by
- * vTaskSetTimeOutState() or xTaskCheckForTimeOut()), the timeout has occurred.
- * If the timeout has not occurred, pxTIcksToWait is updated to reflect the
- * number of remaining ticks.
- *
- * @return If timeout has occurred, pdTRUE is returned. Otherwise pdFALSE is
- * returned and pxTicksToWait is updated to reflect the number of remaining
- * ticks.
- *
- * @see https://www.freertos.org/xTaskCheckForTimeOut.html
- *
- * Example Usage:
- * 
-    // Driver library function used to receive uxWantedBytes from an Rx buffer
-    // that is filled by a UART interrupt. If there are not enough bytes in the
-    // Rx buffer then the task enters the Blocked state until it is notified
- that
-    // more data has been placed into the buffer. If there is still not enough
-    // data then the task re-enters the Blocked state, and
- xTaskCheckForTimeOut()
-    // is used to re-calculate the Block time to ensure the total amount of time
-    // spent in the Blocked state does not exceed MAX_TIME_TO_WAIT. This
-    // continues until either the buffer contains at least uxWantedBytes bytes,
-    // or the total amount of time spent in the Blocked state reaches
-    // MAX_TIME_TO_WAIT – at which point the task reads however many bytes are
-    // available up to a maximum of uxWantedBytes.
-
-    size_t xUART_Receive( uint8_t *pucBuffer, size_t uxWantedBytes )
-    {
-    size_t uxReceived = 0;
-    TickType_t xTicksToWait = MAX_TIME_TO_WAIT;
-    TimeOut_t xTimeOut;
-
-        // Initialize xTimeOut.  This records the time at which this function
-        // was entered.
-        vTaskSetTimeOutState( &xTimeOut );
-
-        // Loop until the buffer contains the wanted number of bytes, or a
-        // timeout occurs.
-        while( UART_bytes_in_rx_buffer( pxUARTInstance ) < uxWantedBytes )
-        {
-            // The buffer didn't contain enough data so this task is going to
-            // enter the Blocked state. Adjusting xTicksToWait to account for
-            // any time that has been spent in the Blocked state within this
-            // function so far to ensure the total amount of time spent in the
-            // Blocked state does not exceed MAX_TIME_TO_WAIT.
-            if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) != pdFALSE )
-            {
-                //Timed out before the wanted number of bytes were available,
-                // exit the loop.
-                break;
-            }
-
-            // Wait for a maximum of xTicksToWait ticks to be notified that the
-            // receive interrupt has placed more data into the buffer.
-            ulTaskNotifyTake( pdTRUE, xTicksToWait );
-        }
-
-        // Attempt to read uxWantedBytes from the receive buffer into pucBuffer.
-        // The actual number of bytes read (which might be less than
-        // uxWantedBytes) is returned.
-        uxReceived = UART_read_from_receive_buffer( pxUARTInstance,
-                                                    pucBuffer,
-                                                    uxWantedBytes );
-
-        return uxReceived;
-    }
- 

- * \defgroup xTaskCheckForTimeOut xTaskCheckForTimeOut
- * \ingroup TaskCtrl
- */
-BaseType_t xTaskCheckForTimeOut(
-    TimeOut_t *const pxTimeOut,
-    TickType_t *const pxTicksToWait) PRIVILEGED_FUNCTION;
-
-/*-----------------------------------------------------------
- * SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES
- *----------------------------------------------------------*/
-
-/*
- * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS ONLY
- * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS
- * AN INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
- *
- * Called from the real time kernel tick (either preemptive or cooperative),
- * this increments the tick count and checks if any tasks that are blocked
- * for a finite period required removing from a blocked list and placing on
- * a ready list.  If a non-zero value is returned then a context switch is
- * required because either:
- *   + A task was removed from a blocked list because its timeout had expired,
- *     or
- *   + Time slicing is in use and there is a task of equal priority to the
- *     currently running task.
- */
-BaseType_t xTaskIncrementTick(void) PRIVILEGED_FUNCTION;
-
-/*
- * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN
- * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
- *
- * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.
- *
- * Removes the calling task from the ready list and places it both
- * on the list of tasks waiting for a particular event, and the
- * list of delayed tasks.  The task will be removed from both lists
- * and replaced on the ready list should either the event occur (and
- * there be no higher priority tasks waiting on the same event) or
- * the delay period expires.
- *
- * The 'unordered' version replaces the event list item value with the
- * xItemValue value, and inserts the list item at the end of the list.
- *
- * The 'ordered' version uses the existing event list item value (which is the
- * owning tasks priority) to insert the list item into the event list is task
- * priority order.
- *
- * @param pxEventList The list containing tasks that are blocked waiting
- * for the event to occur.
- *
- * @param xItemValue The item value to use for the event list item when the
- * event list is not ordered by task priority.
- *
- * @param xTicksToWait The maximum amount of time that the task should wait
- * for the event to occur.  This is specified in kernel ticks,the constant
- * portTICK_PERIOD_MS can be used to convert kernel ticks into a real time
- * period.
- */
-void vTaskPlaceOnEventList(
-    List_t *const pxEventList,
-    const TickType_t xTicksToWait) PRIVILEGED_FUNCTION;
-void vTaskPlaceOnUnorderedEventList(
-    List_t *pxEventList,
-    const TickType_t xItemValue,
-    const TickType_t xTicksToWait) PRIVILEGED_FUNCTION;
-
-/*
- * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN
- * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
- *
- * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.
- *
- * This function performs nearly the same function as vTaskPlaceOnEventList().
- * The difference being that this function does not permit tasks to block
- * indefinitely, whereas vTaskPlaceOnEventList() does.
- *
- */
-void vTaskPlaceOnEventListRestricted(
-    List_t *const pxEventList,
-    TickType_t xTicksToWait,
-    const BaseType_t xWaitIndefinitely) PRIVILEGED_FUNCTION;
-
-/*
- * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN
- * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
- *
- * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.
- *
- * Removes a task from both the specified event list and the list of blocked
- * tasks, and places it on a ready queue.
- *
- * xTaskRemoveFromEventList()/vTaskRemoveFromUnorderedEventList() will be called
- * if either an event occurs to unblock a task, or the block timeout period
- * expires.
- *
- * xTaskRemoveFromEventList() is used when the event list is in task priority
- * order.  It removes the list item from the head of the event list as that will
- * have the highest priority owning task of all the tasks on the event list.
- * vTaskRemoveFromUnorderedEventList() is used when the event list is not
- * ordered and the event list items hold something other than the owning tasks
- * priority.  In this case the event list item value is updated to the value
- * passed in the xItemValue parameter.
- *
- * @return pdTRUE if the task being removed has a higher priority than the task
- * making the call, otherwise pdFALSE.
- */
-BaseType_t xTaskRemoveFromEventList(const List_t *const pxEventList)
-    PRIVILEGED_FUNCTION;
-void vTaskRemoveFromUnorderedEventList(
-    ListItem_t *pxEventListItem,
-    const TickType_t xItemValue) PRIVILEGED_FUNCTION;
-
-/*
- * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS ONLY
- * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS
- * AN INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
- *
- * Sets the pointer to the current TCB to the TCB of the highest priority task
- * that is ready to run.
- */
-portDONT_DISCARD void vTaskSwitchContext(void) PRIVILEGED_FUNCTION;
-
-/*
- * THESE FUNCTIONS MUST NOT BE USED FROM APPLICATION CODE.  THEY ARE USED BY
- * THE EVENT BITS MODULE.
- */
-TickType_t uxTaskResetEventItemValue(void) PRIVILEGED_FUNCTION;
-
-/*
- * Return the handle of the calling task.
- */
-TaskHandle_t xTaskGetCurrentTaskHandle(void) PRIVILEGED_FUNCTION;
-
-/*
- * Shortcut used by the queue implementation to prevent unnecessary call to
- * taskYIELD();
- */
-void vTaskMissedYield(void) PRIVILEGED_FUNCTION;
-
-/*
- * Returns the scheduler state as taskSCHEDULER_RUNNING,
- * taskSCHEDULER_NOT_STARTED or taskSCHEDULER_SUSPENDED.
- */
-BaseType_t xTaskGetSchedulerState(void) PRIVILEGED_FUNCTION;
-
-/*
- * Raises the priority of the mutex holder to that of the calling task should
- * the mutex holder have a priority less than the calling task.
- */
-BaseType_t xTaskPriorityInherit(TaskHandle_t const pxMutexHolder)
-    PRIVILEGED_FUNCTION;
-
-/*
- * Set the priority of a task back to its proper priority in the case that it
- * inherited a higher priority while it was holding a semaphore.
- */
-BaseType_t xTaskPriorityDisinherit(TaskHandle_t const pxMutexHolder)
-    PRIVILEGED_FUNCTION;
-
-/*
- * If a higher priority task attempting to obtain a mutex caused a lower
- * priority task to inherit the higher priority task's priority - but the higher
- * priority task then timed out without obtaining the mutex, then the lower
- * priority task will disinherit the priority again - but only down as far as
- * the highest priority task that is still waiting for the mutex (if there were
- * more than one task waiting for the mutex).
- */
-void vTaskPriorityDisinheritAfterTimeout(
-    TaskHandle_t const pxMutexHolder,
-    UBaseType_t uxHighestPriorityWaitingTask) PRIVILEGED_FUNCTION;
-
-/*
- * Get the uxTCBNumber assigned to the task referenced by the xTask parameter.
- */
-UBaseType_t uxTaskGetTaskNumber(TaskHandle_t xTask) PRIVILEGED_FUNCTION;
-
-/*
- * Set the uxTaskNumber of the task referenced by the xTask parameter to
- * uxHandle.
- */
-void vTaskSetTaskNumber(TaskHandle_t xTask, const UBaseType_t uxHandle)
-    PRIVILEGED_FUNCTION;
-
-/*
- * Only available when configUSE_TICKLESS_IDLE is set to 1.
- * If tickless mode is being used, or a low power mode is implemented, then
- * the tick interrupt will not execute during idle periods.  When this is the
- * case, the tick count value maintained by the scheduler needs to be kept up
- * to date with the actual execution time by being skipped forward by a time
- * equal to the idle period.
- */
-void vTaskStepTick(const TickType_t xTicksToJump) PRIVILEGED_FUNCTION;
-
-/* Correct the tick count value after the application code has held
-interrupts disabled for an extended period.  xTicksToCatchUp is the number
-of tick interrupts that have been missed due to interrupts being disabled.
-Its value is not computed automatically, so must be computed by the
-application writer.
-
-This function is similar to vTaskStepTick(), however, unlike
-vTaskStepTick(), xTaskCatchUpTicks() may move the tick count forward past a
-time at which a task should be removed from the blocked state.  That means
-tasks may have to be removed from the blocked state as the tick count is
-moved. */
-BaseType_t xTaskCatchUpTicks(TickType_t xTicksToCatchUp) PRIVILEGED_FUNCTION;
-
-/*
- * Only available when configUSE_TICKLESS_IDLE is set to 1.
- * Provided for use within portSUPPRESS_TICKS_AND_SLEEP() to allow the port
- * specific sleep function to determine if it is ok to proceed with the sleep,
- * and if it is ok to proceed, if it is ok to sleep indefinitely.
- *
- * This function is necessary because portSUPPRESS_TICKS_AND_SLEEP() is only
- * called with the scheduler suspended, not from within a critical section.  It
- * is therefore possible for an interrupt to request a context switch between
- * portSUPPRESS_TICKS_AND_SLEEP() and the low power mode actually being
- * entered.  eTaskConfirmSleepModeStatus() should be called from a short
- * critical section between the timer being stopped and the sleep mode being
- * entered to ensure it is ok to proceed into the sleep mode.
- */
-eSleepModeStatus eTaskConfirmSleepModeStatus(void) PRIVILEGED_FUNCTION;
-
-/*
- * For internal use only.  Increment the mutex held count when a mutex is
- * taken and return the handle of the task that has taken the mutex.
- */
-TaskHandle_t pvTaskIncrementMutexHeldCount(void) PRIVILEGED_FUNCTION;
-
-/*
- * For internal use only.  Same as vTaskSetTimeOutState(), but without a critial
- * section.
- */
-void vTaskInternalSetTimeOutState(TimeOut_t *const pxTimeOut)
-    PRIVILEGED_FUNCTION;
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* INC_TASK_H */
diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/include/timers.h b/product/rcar/src/CMSIS-FreeRTOS/Source/include/timers.h
deleted file mode 100644
index 028657cdd1e0b020f95f541a94bc7fac60367a18..0000000000000000000000000000000000000000
--- a/product/rcar/src/CMSIS-FreeRTOS/Source/include/timers.h
+++ /dev/null
@@ -1,1401 +0,0 @@
-/*
- * FreeRTOS Kernel V10.3.1
- * 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://www.FreeRTOS.org
- * http://aws.amazon.com/freertos
- *
- * 1 tab == 4 spaces!
- */
-
-#ifndef TIMERS_H
-#define TIMERS_H
-
-#ifndef INC_FREERTOS_H
-#    error \
-        "include FreeRTOS.h must appear in source files before include timers.h"
-#endif
-
-/*lint -save -e537 This headers are only multiply included if the application
-code happens to also be including task.h. */
-#include "task.h"
-/*lint -restore */
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*-----------------------------------------------------------
- * MACROS AND DEFINITIONS
- *----------------------------------------------------------*/
-
-/* IDs for commands that can be sent/received on the timer queue.  These are to
-be used solely through the macros that make up the public software timer API,
-as defined below.  The commands that are sent from interrupts must use the
-highest numbers as tmrFIRST_FROM_ISR_COMMAND is used to determine if the task
-or interrupt version of the queue send function should be used. */
-#define tmrCOMMAND_EXECUTE_CALLBACK_FROM_ISR ((BaseType_t)-2)
-#define tmrCOMMAND_EXECUTE_CALLBACK ((BaseType_t)-1)
-#define tmrCOMMAND_START_DONT_TRACE ((BaseType_t)0)
-#define tmrCOMMAND_START ((BaseType_t)1)
-#define tmrCOMMAND_RESET ((BaseType_t)2)
-#define tmrCOMMAND_STOP ((BaseType_t)3)
-#define tmrCOMMAND_CHANGE_PERIOD ((BaseType_t)4)
-#define tmrCOMMAND_DELETE ((BaseType_t)5)
-
-#define tmrFIRST_FROM_ISR_COMMAND ((BaseType_t)6)
-#define tmrCOMMAND_START_FROM_ISR ((BaseType_t)6)
-#define tmrCOMMAND_RESET_FROM_ISR ((BaseType_t)7)
-#define tmrCOMMAND_STOP_FROM_ISR ((BaseType_t)8)
-#define tmrCOMMAND_CHANGE_PERIOD_FROM_ISR ((BaseType_t)9)
-
-/**
- * Type by which software timers are referenced.  For example, a call to
- * xTimerCreate() returns an TimerHandle_t variable that can then be used to
- * reference the subject timer in calls to other software timer API functions
- * (for example, xTimerStart(), xTimerReset(), etc.).
- */
-struct tmrTimerControl; /* The old naming convention is used to prevent breaking
-                           kernel aware debuggers. */
-typedef struct tmrTimerControl *TimerHandle_t;
-
-/*
- * Defines the prototype to which timer callback functions must conform.
- */
-typedef void (*TimerCallbackFunction_t)(TimerHandle_t xTimer);
-
-/*
- * Defines the prototype to which functions used with the
- * xTimerPendFunctionCallFromISR() function must conform.
- */
-typedef void (*PendedFunction_t)(void *, uint32_t);
-
-/**
- * TimerHandle_t xTimerCreate( 	const char * const pcTimerName,
- * 								TickType_t xTimerPeriodInTicks,
- * 								UBaseType_t uxAutoReload,
- * 								void * pvTimerID,
- * 								TimerCallbackFunction_t pxCallbackFunction );
- *
- * Creates a new software timer instance, and returns a handle by which the
- * created software timer can be referenced.
- *
- * Internally, within the FreeRTOS implementation, software timers use a block
- * of memory, in which the timer data structure is stored.  If a software timer
- * is created using xTimerCreate() then the required memory is automatically
- * dynamically allocated inside the xTimerCreate() function.  (see
- * http://www.freertos.org/a00111.html).  If a software timer is created using
- * xTimerCreateStatic() then the application writer must provide the memory that
- * will get used by the software timer.  xTimerCreateStatic() therefore allows a
- * software timer to be created without using any dynamic memory allocation.
- *
- * Timers are created in the dormant state.  The xTimerStart(), xTimerReset(),
- * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and
- * xTimerChangePeriodFromISR() API functions can all be used to transition a
- * timer into the active state.
- *
- * @param pcTimerName A text name that is assigned to the timer.  This is done
- * purely to assist debugging.  The kernel itself only ever references a timer
- * by its handle, and never by its name.
- *
- * @param xTimerPeriodInTicks The timer period.  The time is defined in tick
- * periods so the constant portTICK_PERIOD_MS can be used to convert a time that
- * has been specified in milliseconds.  For example, if the timer must expire
- * after 100 ticks, then xTimerPeriodInTicks should be set to 100.
- * Alternatively, if the timer must expire after 500ms, then xPeriod can be set
- * to ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than or
- * equal to 1000.
- *
- * @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will
- * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter.
- * If uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and
- * enter the dormant state after it expires.
- *
- * @param pvTimerID An identifier that is assigned to the timer being created.
- * Typically this would be used in the timer callback function to identify which
- * timer expired when the same callback function is assigned to more than one
- * timer.
- *
- * @param pxCallbackFunction The function to call when the timer expires.
- * Callback functions must have the prototype defined by
- * TimerCallbackFunction_t, which is	"void vCallbackFunction( TimerHandle_t
- * xTimer );".
- *
- * @return If the timer is successfully created then a handle to the newly
- * created timer is returned.  If the timer cannot be created (because either
- * there is insufficient FreeRTOS heap remaining to allocate the timer
- * structures, or the timer period was set to 0) then NULL is returned.
- *
- * Example usage:
- * @verbatim
- * #define NUM_TIMERS 5
- *
- * // An array to hold handles to the created timers.
- * TimerHandle_t xTimers[ NUM_TIMERS ];
- *
- * // An array to hold a count of the number of times each timer expires.
- * int32_t lExpireCounters[ NUM_TIMERS ] = { 0 };
- *
- * // Define a callback function that will be used by multiple timer instances.
- * // The callback function does nothing but count the number of times the
- * // associated timer expires, and stop the timer once the timer has expired
- * // 10 times.
- * void vTimerCallback( TimerHandle_t pxTimer )
- * {
- * int32_t lArrayIndex;
- * const int32_t xMaxExpiryCountBeforeStopping = 10;
- *
- * 	   // Optionally do something if the pxTimer parameter is NULL.
- * 	   configASSERT( pxTimer );
- *
- *     // Which timer expired?
- *     lArrayIndex = ( int32_t ) pvTimerGetTimerID( pxTimer );
- *
- *     // Increment the number of times that pxTimer has expired.
- *     lExpireCounters[ lArrayIndex ] += 1;
- *
- *     // If the timer has expired 10 times then stop it from running.
- *     if( lExpireCounters[ lArrayIndex ] == xMaxExpiryCountBeforeStopping )
- *     {
- *         // Do not use a block time if calling a timer API function from a
- *         // timer callback function, as doing so could cause a deadlock!
- *         xTimerStop( pxTimer, 0 );
- *     }
- * }
- *
- * void main( void )
- * {
- * int32_t x;
- *
- *     // Create then start some timers.  Starting the timers before the
- * scheduler
- *     // has been started means the timers will start running immediately that
- *     // the scheduler starts.
- *     for( x = 0; x < NUM_TIMERS; x++ )
- *     {
- *         xTimers[ x ] = xTimerCreate(    "Timer",       // Just a text name,
- * not used by the kernel. ( 100 * x ),   // The timer period in ticks. pdTRUE,
- * // The timers will auto-reload themselves when they expire. ( void * ) x,  //
- * Assign each timer a unique id equal to its array index. vTimerCallback //
- * Each timer calls the same callback when it expires.
- *                                     );
- *
- *         if( xTimers[ x ] == NULL )
- *         {
- *             // The timer was not created.
- *         }
- *         else
- *         {
- *             // Start the timer.  No block time is specified, and even if one
- * was
- *             // it would be ignored because the scheduler has not yet been
- *             // started.
- *             if( xTimerStart( xTimers[ x ], 0 ) != pdPASS )
- *             {
- *                 // The timer could not be set into the Active state.
- *             }
- *         }
- *     }
- *
- *     // ...
- *     // Create tasks here.
- *     // ...
- *
- *     // Starting the scheduler will start the timers running as they have
- * already
- *     // been set into the active state.
- *     vTaskStartScheduler();
- *
- *     // Should not reach here.
- *     for( ;; );
- * }
- * @endverbatim
- */
-#if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
-TimerHandle_t xTimerCreate(
-    const char
-        *const pcTimerName, /*lint !e971 Unqualified char types are allowed for
-                               strings and single characters only. */
-    const TickType_t xTimerPeriodInTicks,
-    const UBaseType_t uxAutoReload,
-    void *const pvTimerID,
-    TimerCallbackFunction_t pxCallbackFunction) PRIVILEGED_FUNCTION;
-#endif
-
-/**
- * TimerHandle_t xTimerCreateStatic(const char * const pcTimerName,
- * 									TickType_t xTimerPeriodInTicks,
- * 									UBaseType_t uxAutoReload,
- * 									void * pvTimerID,
- * 									TimerCallbackFunction_t pxCallbackFunction,
- *									StaticTimer_t *pxTimerBuffer );
- *
- * Creates a new software timer instance, and returns a handle by which the
- * created software timer can be referenced.
- *
- * Internally, within the FreeRTOS implementation, software timers use a block
- * of memory, in which the timer data structure is stored.  If a software timer
- * is created using xTimerCreate() then the required memory is automatically
- * dynamically allocated inside the xTimerCreate() function.  (see
- * http://www.freertos.org/a00111.html).  If a software timer is created using
- * xTimerCreateStatic() then the application writer must provide the memory that
- * will get used by the software timer.  xTimerCreateStatic() therefore allows a
- * software timer to be created without using any dynamic memory allocation.
- *
- * Timers are created in the dormant state.  The xTimerStart(), xTimerReset(),
- * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and
- * xTimerChangePeriodFromISR() API functions can all be used to transition a
- * timer into the active state.
- *
- * @param pcTimerName A text name that is assigned to the timer.  This is done
- * purely to assist debugging.  The kernel itself only ever references a timer
- * by its handle, and never by its name.
- *
- * @param xTimerPeriodInTicks The timer period.  The time is defined in tick
- * periods so the constant portTICK_PERIOD_MS can be used to convert a time that
- * has been specified in milliseconds.  For example, if the timer must expire
- * after 100 ticks, then xTimerPeriodInTicks should be set to 100.
- * Alternatively, if the timer must expire after 500ms, then xPeriod can be set
- * to ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than or
- * equal to 1000.
- *
- * @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will
- * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter.
- * If uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and
- * enter the dormant state after it expires.
- *
- * @param pvTimerID An identifier that is assigned to the timer being created.
- * Typically this would be used in the timer callback function to identify which
- * timer expired when the same callback function is assigned to more than one
- * timer.
- *
- * @param pxCallbackFunction The function to call when the timer expires.
- * Callback functions must have the prototype defined by
- *TimerCallbackFunction_t, which is "void vCallbackFunction( TimerHandle_t
- *xTimer );".
- *
- * @param pxTimerBuffer Must point to a variable of type StaticTimer_t, which
- * will be then be used to hold the software timer's data structures, removing
- * the need for the memory to be allocated dynamically.
- *
- * @return If the timer is created then a handle to the created timer is
- * returned.  If pxTimerBuffer was NULL then NULL is returned.
- *
- * Example usage:
- * @verbatim
- *
- * // The buffer used to hold the software timer's data structure.
- * static StaticTimer_t xTimerBuffer;
- *
- * // A variable that will be incremented by the software timer's callback
- * // function.
- * UBaseType_t uxVariableToIncrement = 0;
- *
- * // A software timer callback function that increments a variable passed to
- * // it when the software timer was created.  After the 5th increment the
- * // callback function stops the software timer.
- * static void prvTimerCallback( TimerHandle_t xExpiredTimer )
- * {
- * UBaseType_t *puxVariableToIncrement;
- * BaseType_t xReturned;
- *
- *     // Obtain the address of the variable to increment from the timer ID.
- *     puxVariableToIncrement = ( UBaseType_t * ) pvTimerGetTimerID(
- *xExpiredTimer );
- *
- *     // Increment the variable to show the timer callback has executed.
- *     ( *puxVariableToIncrement )++;
- *
- *     // If this callback has executed the required number of times, stop the
- *     // timer.
- *     if( *puxVariableToIncrement == 5 )
- *     {
- *         // This is called from a timer callback so must not block.
- *         xTimerStop( xExpiredTimer, staticDONT_BLOCK );
- *     }
- * }
- *
- *
- * void main( void )
- * {
- *     // Create the software time.  xTimerCreateStatic() has an extra parameter
- *     // than the normal xTimerCreate() API function.  The parameter is a
- *pointer
- *     // to the StaticTimer_t structure that will hold the software timer
- *     // structure.  If the parameter is passed as NULL then the structure will
- *be
- *     // allocated dynamically, just as if xTimerCreate() had been called.
- *     xTimer = xTimerCreateStatic( "T1",             // Text name for the task.
- *Helps debugging only.  Not used by FreeRTOS. xTimerPeriod,     // The period
- *of the timer in ticks. pdTRUE,           // This is an auto-reload timer. (
- *void * ) &uxVariableToIncrement,    // A variable incremented by the software
- *timer's callback function prvTimerCallback, // The function to execute when
- *the timer expires. &xTimerBuffer );  // The buffer that will hold the software
- *timer structure.
- *
- *     // The scheduler has not started yet so a block time is not used.
- *     xReturned = xTimerStart( xTimer, 0 );
- *
- *     // ...
- *     // Create tasks here.
- *     // ...
- *
- *     // Starting the scheduler will start the timers running as they have
- *already
- *     // been set into the active state.
- *     vTaskStartScheduler();
- *
- *     // Should not reach here.
- *     for( ;; );
- * }
- * @endverbatim
- */
-#if (configSUPPORT_STATIC_ALLOCATION == 1)
-TimerHandle_t xTimerCreateStatic(
-    const char
-        *const pcTimerName, /*lint !e971 Unqualified char types are allowed for
-                               strings and single characters only. */
-    const TickType_t xTimerPeriodInTicks,
-    const UBaseType_t uxAutoReload,
-    void *const pvTimerID,
-    TimerCallbackFunction_t pxCallbackFunction,
-    StaticTimer_t *pxTimerBuffer) PRIVILEGED_FUNCTION;
-#endif /* configSUPPORT_STATIC_ALLOCATION */
-
-/**
- * void *pvTimerGetTimerID( TimerHandle_t xTimer );
- *
- * Returns the ID assigned to the timer.
- *
- * IDs are assigned to timers using the pvTimerID parameter of the call to
- * xTimerCreated() that was used to create the timer, and by calling the
- * vTimerSetTimerID() API function.
- *
- * If the same callback function is assigned to multiple timers then the timer
- * ID can be used as time specific (timer local) storage.
- *
- * @param xTimer The timer being queried.
- *
- * @return The ID assigned to the timer being queried.
- *
- * Example usage:
- *
- * See the xTimerCreate() API function example usage scenario.
- */
-void *pvTimerGetTimerID(const TimerHandle_t xTimer) PRIVILEGED_FUNCTION;
-
-/**
- * void vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID );
- *
- * Sets the ID assigned to the timer.
- *
- * IDs are assigned to timers using the pvTimerID parameter of the call to
- * xTimerCreated() that was used to create the timer.
- *
- * If the same callback function is assigned to multiple timers then the timer
- * ID can be used as time specific (timer local) storage.
- *
- * @param xTimer The timer being updated.
- *
- * @param pvNewID The ID to assign to the timer.
- *
- * Example usage:
- *
- * See the xTimerCreate() API function example usage scenario.
- */
-void vTimerSetTimerID(TimerHandle_t xTimer, void *pvNewID) PRIVILEGED_FUNCTION;
-
-/**
- * BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer );
- *
- * Queries a timer to see if it is active or dormant.
- *
- * A timer will be dormant if:
- *     1) It has been created but not started, or
- *     2) It is an expired one-shot timer that has not been restarted.
- *
- * Timers are created in the dormant state.  The xTimerStart(), xTimerReset(),
- * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and
- * xTimerChangePeriodFromISR() API functions can all be used to transition a
- * timer into the active state.
- *
- * @param xTimer The timer being queried.
- *
- * @return pdFALSE will be returned if the timer is dormant.  A value other than
- * pdFALSE will be returned if the timer is active.
- *
- * Example usage:
- * @verbatim
- * // This function assumes xTimer has already been created.
- * void vAFunction( TimerHandle_t xTimer )
- * {
- *     if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and
- * equivalently "if( xTimerIsTimerActive( xTimer ) )"
- *     {
- *         // xTimer is active, do something.
- *     }
- *     else
- *     {
- *         // xTimer is not active, do something else.
- *     }
- * }
- * @endverbatim
- */
-BaseType_t xTimerIsTimerActive(TimerHandle_t xTimer) PRIVILEGED_FUNCTION;
-
-/**
- * TaskHandle_t xTimerGetTimerDaemonTaskHandle( void );
- *
- * Simply returns the handle of the timer service/daemon task.  It it not valid
- * to call xTimerGetTimerDaemonTaskHandle() before the scheduler has been
- * started.
- */
-TaskHandle_t xTimerGetTimerDaemonTaskHandle(void) PRIVILEGED_FUNCTION;
-
-/**
- * BaseType_t xTimerStart( TimerHandle_t xTimer, TickType_t xTicksToWait );
- *
- * Timer functionality is provided by a timer service/daemon task.  Many of the
- * public FreeRTOS timer API functions send commands to the timer service task
- * through a queue called the timer command queue.  The timer command queue is
- * private to the kernel itself and is not directly accessible to application
- * code.  The length of the timer command queue is set by the
- * configTIMER_QUEUE_LENGTH configuration constant.
- *
- * xTimerStart() starts a timer that was previously created using the
- * xTimerCreate() API function.  If the timer had already been started and was
- * already in the active state, then xTimerStart() has equivalent functionality
- * to the xTimerReset() API function.
- *
- * Starting a timer ensures the timer is in the active state.  If the timer
- * is not stopped, deleted, or reset in the mean time, the callback function
- * associated with the timer will get called 'n' ticks after xTimerStart() was
- * called, where 'n' is the timers defined period.
- *
- * It is valid to call xTimerStart() before the scheduler has been started, but
- * when this is done the timer will not actually start until the scheduler is
- * started, and the timers expiry time will be relative to when the scheduler is
- * started, not relative to when xTimerStart() was called.
- *
- * The configUSE_TIMERS configuration constant must be set to 1 for
- * xTimerStart() to be available.
- *
- * @param xTimer The handle of the timer being started/restarted.
- *
- * @param xTicksToWait Specifies the time, in ticks, that the calling task
- * should be held in the Blocked state to wait for the start command to be
- * successfully sent to the timer command queue, should the queue already be
- * full when xTimerStart() was called.  xTicksToWait is ignored if xTimerStart()
- * is called before the scheduler is started.
- *
- * @return pdFAIL will be returned if the start command could not be sent to
- * the timer command queue even after xTicksToWait ticks had passed.  pdPASS
- * will be returned if the command was successfully sent to the timer command
- * queue. When the command is actually processed will depend on the priority of
- * the timer service/daemon task relative to other tasks in the system, although
- * the timers expiry time is relative to when xTimerStart() is actually called.
- * The timer service/daemon task priority is set by the
- * configTIMER_TASK_PRIORITY configuration constant.
- *
- * Example usage:
- *
- * See the xTimerCreate() API function example usage scenario.
- *
- */
-#define xTimerStart(xTimer, xTicksToWait) \
-    xTimerGenericCommand( \
-        (xTimer), \
-        tmrCOMMAND_START, \
-        (xTaskGetTickCount()), \
-        NULL, \
-        (xTicksToWait))
-
-/**
- * BaseType_t xTimerStop( TimerHandle_t xTimer, TickType_t xTicksToWait );
- *
- * Timer functionality is provided by a timer service/daemon task.  Many of the
- * public FreeRTOS timer API functions send commands to the timer service task
- * through a queue called the timer command queue.  The timer command queue is
- * private to the kernel itself and is not directly accessible to application
- * code.  The length of the timer command queue is set by the
- * configTIMER_QUEUE_LENGTH configuration constant.
- *
- * xTimerStop() stops a timer that was previously started using either of the
- * The xTimerStart(), xTimerReset(), xTimerStartFromISR(), xTimerResetFromISR(),
- * xTimerChangePeriod() or xTimerChangePeriodFromISR() API functions.
- *
- * Stopping a timer ensures the timer is not in the active state.
- *
- * The configUSE_TIMERS configuration constant must be set to 1 for xTimerStop()
- * to be available.
- *
- * @param xTimer The handle of the timer being stopped.
- *
- * @param xTicksToWait Specifies the time, in ticks, that the calling task
- * should be held in the Blocked state to wait for the stop command to be
- * successfully sent to the timer command queue, should the queue already be
- * full when xTimerStop() was called.  xTicksToWait is ignored if xTimerStop()
- * is called before the scheduler is started.
- *
- * @return pdFAIL will be returned if the stop command could not be sent to
- * the timer command queue even after xTicksToWait ticks had passed.  pdPASS
- * will be returned if the command was successfully sent to the timer command
- * queue. When the command is actually processed will depend on the priority of
- * the timer service/daemon task relative to other tasks in the system.  The
- * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY
- * configuration constant.
- *
- * Example usage:
- *
- * See the xTimerCreate() API function example usage scenario.
- *
- */
-#define xTimerStop(xTimer, xTicksToWait) \
-    xTimerGenericCommand((xTimer), tmrCOMMAND_STOP, 0U, NULL, (xTicksToWait))
-
-/**
- * BaseType_t xTimerChangePeriod( 	TimerHandle_t xTimer,
- *										TickType_t xNewPeriod,
- *										TickType_t xTicksToWait );
- *
- * Timer functionality is provided by a timer service/daemon task.  Many of the
- * public FreeRTOS timer API functions send commands to the timer service task
- * through a queue called the timer command queue.  The timer command queue is
- * private to the kernel itself and is not directly accessible to application
- * code.  The length of the timer command queue is set by the
- * configTIMER_QUEUE_LENGTH configuration constant.
- *
- * xTimerChangePeriod() changes the period of a timer that was previously
- * created using the xTimerCreate() API function.
- *
- * xTimerChangePeriod() can be called to change the period of an active or
- * dormant state timer.
- *
- * The configUSE_TIMERS configuration constant must be set to 1 for
- * xTimerChangePeriod() to be available.
- *
- * @param xTimer The handle of the timer that is having its period changed.
- *
- * @param xNewPeriod The new period for xTimer. Timer periods are specified in
- * tick periods, so the constant portTICK_PERIOD_MS can be used to convert a
- *time that has been specified in milliseconds.  For example, if the timer must
- * expire after 100 ticks, then xNewPeriod should be set to 100.  Alternatively,
- * if the timer must expire after 500ms, then xNewPeriod can be set to
- * ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than
- * or equal to 1000.
- *
- * @param xTicksToWait Specifies the time, in ticks, that the calling task
- *should be held in the Blocked state to wait for the change period command to
- *be successfully sent to the timer command queue, should the queue already be
- * full when xTimerChangePeriod() was called.  xTicksToWait is ignored if
- * xTimerChangePeriod() is called before the scheduler is started.
- *
- * @return pdFAIL will be returned if the change period command could not be
- * sent to the timer command queue even after xTicksToWait ticks had passed.
- * pdPASS will be returned if the command was successfully sent to the timer
- * command queue.  When the command is actually processed will depend on the
- * priority of the timer service/daemon task relative to other tasks in the
- * system.  The timer service/daemon task priority is set by the
- * configTIMER_TASK_PRIORITY configuration constant.
- *
- * Example usage:
- * @verbatim
- * // This function assumes xTimer has already been created.  If the timer
- * // referenced by xTimer is already active when it is called, then the timer
- * // is deleted.  If the timer referenced by xTimer is not active when it is
- * // called, then the period of the timer is set to 500ms and the timer is
- * // started.
- * void vAFunction( TimerHandle_t xTimer )
- * {
- *     if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and
- *equivalently "if( xTimerIsTimerActive( xTimer ) )"
- *     {
- *         // xTimer is already active - delete it.
- *         xTimerDelete( xTimer );
- *     }
- *     else
- *     {
- *         // xTimer is not active, change its period to 500ms.  This will also
- *         // cause the timer to start.  Block for a maximum of 100 ticks if the
- *         // change period command cannot immediately be sent to the timer
- *         // command queue.
- *         if( xTimerChangePeriod( xTimer, 500 / portTICK_PERIOD_MS, 100 ) ==
- *pdPASS )
- *         {
- *             // The command was successfully sent.
- *         }
- *         else
- *         {
- *             // The command could not be sent, even after waiting for 100
- *ticks
- *             // to pass.  Take appropriate action here.
- *         }
- *     }
- * }
- * @endverbatim
- */
-#define xTimerChangePeriod(xTimer, xNewPeriod, xTicksToWait) \
-    xTimerGenericCommand( \
-        (xTimer), \
-        tmrCOMMAND_CHANGE_PERIOD, \
-        (xNewPeriod), \
-        NULL, \
-        (xTicksToWait))
-
-/**
- * BaseType_t xTimerDelete( TimerHandle_t xTimer, TickType_t xTicksToWait );
- *
- * Timer functionality is provided by a timer service/daemon task.  Many of the
- * public FreeRTOS timer API functions send commands to the timer service task
- * through a queue called the timer command queue.  The timer command queue is
- * private to the kernel itself and is not directly accessible to application
- * code.  The length of the timer command queue is set by the
- * configTIMER_QUEUE_LENGTH configuration constant.
- *
- * xTimerDelete() deletes a timer that was previously created using the
- * xTimerCreate() API function.
- *
- * The configUSE_TIMERS configuration constant must be set to 1 for
- * xTimerDelete() to be available.
- *
- * @param xTimer The handle of the timer being deleted.
- *
- * @param xTicksToWait Specifies the time, in ticks, that the calling task
- * should be held in the Blocked state to wait for the delete command to be
- * successfully sent to the timer command queue, should the queue already be
- * full when xTimerDelete() was called.  xTicksToWait is ignored if
- * xTimerDelete() is called before the scheduler is started.
- *
- * @return pdFAIL will be returned if the delete command could not be sent to
- * the timer command queue even after xTicksToWait ticks had passed.  pdPASS
- * will be returned if the command was successfully sent to the timer command
- * queue. When the command is actually processed will depend on the priority of
- * the timer service/daemon task relative to other tasks in the system.  The
- * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY
- * configuration constant.
- *
- * Example usage:
- *
- * See the xTimerChangePeriod() API function example usage scenario.
- */
-#define xTimerDelete(xTimer, xTicksToWait) \
-    xTimerGenericCommand((xTimer), tmrCOMMAND_DELETE, 0U, NULL, (xTicksToWait))
-
-/**
- * BaseType_t xTimerReset( TimerHandle_t xTimer, TickType_t xTicksToWait );
- *
- * Timer functionality is provided by a timer service/daemon task.  Many of the
- * public FreeRTOS timer API functions send commands to the timer service task
- * through a queue called the timer command queue.  The timer command queue is
- * private to the kernel itself and is not directly accessible to application
- * code.  The length of the timer command queue is set by the
- * configTIMER_QUEUE_LENGTH configuration constant.
- *
- * xTimerReset() re-starts a timer that was previously created using the
- * xTimerCreate() API function.  If the timer had already been started and was
- * already in the active state, then xTimerReset() will cause the timer to
- * re-evaluate its expiry time so that it is relative to when xTimerReset() was
- * called.  If the timer was in the dormant state then xTimerReset() has
- * equivalent functionality to the xTimerStart() API function.
- *
- * Resetting a timer ensures the timer is in the active state.  If the timer
- * is not stopped, deleted, or reset in the mean time, the callback function
- * associated with the timer will get called 'n' ticks after xTimerReset() was
- * called, where 'n' is the timers defined period.
- *
- * It is valid to call xTimerReset() before the scheduler has been started, but
- * when this is done the timer will not actually start until the scheduler is
- * started, and the timers expiry time will be relative to when the scheduler is
- * started, not relative to when xTimerReset() was called.
- *
- * The configUSE_TIMERS configuration constant must be set to 1 for
- * xTimerReset() to be available.
- *
- * @param xTimer The handle of the timer being reset/started/restarted.
- *
- * @param xTicksToWait Specifies the time, in ticks, that the calling task
- * should be held in the Blocked state to wait for the reset command to be
- * successfully sent to the timer command queue, should the queue already be
- * full when xTimerReset() was called.  xTicksToWait is ignored if xTimerReset()
- * is called before the scheduler is started.
- *
- * @return pdFAIL will be returned if the reset command could not be sent to
- * the timer command queue even after xTicksToWait ticks had passed.  pdPASS
- * will be returned if the command was successfully sent to the timer command
- * queue. When the command is actually processed will depend on the priority of
- * the timer service/daemon task relative to other tasks in the system, although
- * the timers expiry time is relative to when xTimerStart() is actually called.
- * The timer service/daemon task priority is set by the
- * configTIMER_TASK_PRIORITY configuration constant.
- *
- * Example usage:
- * @verbatim
- * // When a key is pressed, an LCD back-light is switched on.  If 5 seconds
- * pass
- * // without a key being pressed, then the LCD back-light is switched off.  In
- * // this case, the timer is a one-shot timer.
- *
- * TimerHandle_t xBacklightTimer = NULL;
- *
- * // The callback function assigned to the one-shot timer.  In this case the
- * // parameter is not used.
- * void vBacklightTimerCallback( TimerHandle_t pxTimer )
- * {
- *     // The timer expired, therefore 5 seconds must have passed since a key
- *     // was pressed.  Switch off the LCD back-light.
- *     vSetBacklightState( BACKLIGHT_OFF );
- * }
- *
- * // The key press event handler.
- * void vKeyPressEventHandler( char cKey )
- * {
- *     // Ensure the LCD back-light is on, then reset the timer that is
- *     // responsible for turning the back-light off after 5 seconds of
- *     // key inactivity.  Wait 10 ticks for the command to be successfully sent
- *     // if it cannot be sent immediately.
- *     vSetBacklightState( BACKLIGHT_ON );
- *     if( xTimerReset( xBacklightTimer, 100 ) != pdPASS )
- *     {
- *         // The reset command was not executed successfully.  Take appropriate
- *         // action here.
- *     }
- *
- *     // Perform the rest of the key processing here.
- * }
- *
- * void main( void )
- * {
- * int32_t x;
- *
- *     // Create then start the one-shot timer that is responsible for turning
- *     // the back-light off if no keys are pressed within a 5 second period.
- *     xBacklightTimer = xTimerCreate( "BacklightTimer",           // Just a
- * text name, not used by the kernel. ( 5000 / portTICK_PERIOD_MS), // The timer
- * period in ticks. pdFALSE,                    // The timer is a one-shot
- * timer. 0,                          // The id is not used by the callback so
- * can take any value. vBacklightTimerCallback     // The callback function that
- * switches the LCD back-light off.
- *                                   );
- *
- *     if( xBacklightTimer == NULL )
- *     {
- *         // The timer was not created.
- *     }
- *     else
- *     {
- *         // Start the timer.  No block time is specified, and even if one was
- *         // it would be ignored because the scheduler has not yet been
- *         // started.
- *         if( xTimerStart( xBacklightTimer, 0 ) != pdPASS )
- *         {
- *             // The timer could not be set into the Active state.
- *         }
- *     }
- *
- *     // ...
- *     // Create tasks here.
- *     // ...
- *
- *     // Starting the scheduler will start the timer running as it has already
- *     // been set into the active state.
- *     vTaskStartScheduler();
- *
- *     // Should not reach here.
- *     for( ;; );
- * }
- * @endverbatim
- */
-#define xTimerReset(xTimer, xTicksToWait) \
-    xTimerGenericCommand( \
-        (xTimer), \
-        tmrCOMMAND_RESET, \
-        (xTaskGetTickCount()), \
-        NULL, \
-        (xTicksToWait))
-
-/**
- * BaseType_t xTimerStartFromISR( 	TimerHandle_t xTimer,
- *									BaseType_t *pxHigherPriorityTaskWoken );
- *
- * A version of xTimerStart() that can be called from an interrupt service
- * routine.
- *
- * @param xTimer The handle of the timer being started/restarted.
- *
- * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
- * of its time in the Blocked state, waiting for messages to arrive on the timer
- * command queue.  Calling xTimerStartFromISR() writes a message to the timer
- * command queue, so has the potential to transition the timer service/daemon
- * task out of the Blocked state.  If calling xTimerStartFromISR() causes the
- * timer service/daemon task to leave the Blocked state, and the timer service/
- * daemon task has a priority equal to or greater than the currently executing
- * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will
- * get set to pdTRUE internally within the xTimerStartFromISR() function.  If
- * xTimerStartFromISR() sets this value to pdTRUE then a context switch should
- * be performed before the interrupt exits.
- *
- * @return pdFAIL will be returned if the start command could not be sent to
- * the timer command queue.  pdPASS will be returned if the command was
- * successfully sent to the timer command queue.  When the command is actually
- * processed will depend on the priority of the timer service/daemon task
- * relative to other tasks in the system, although the timers expiry time is
- * relative to when xTimerStartFromISR() is actually called.  The timer
- * service/daemon task priority is set by the configTIMER_TASK_PRIORITY
- * configuration constant.
- *
- * Example usage:
- * @verbatim
- * // This scenario assumes xBacklightTimer has already been created.  When a
- * // key is pressed, an LCD back-light is switched on.  If 5 seconds pass
- * // without a key being pressed, then the LCD back-light is switched off.  In
- * // this case, the timer is a one-shot timer, and unlike the example given for
- * // the xTimerReset() function, the key press event handler is an interrupt
- * // service routine.
- *
- * // The callback function assigned to the one-shot timer.  In this case the
- * // parameter is not used.
- * void vBacklightTimerCallback( TimerHandle_t pxTimer )
- * {
- *     // The timer expired, therefore 5 seconds must have passed since a key
- *     // was pressed.  Switch off the LCD back-light.
- *     vSetBacklightState( BACKLIGHT_OFF );
- * }
- *
- * // The key press interrupt service routine.
- * void vKeyPressEventInterruptHandler( void )
- * {
- * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
- *
- *     // Ensure the LCD back-light is on, then restart the timer that is
- *     // responsible for turning the back-light off after 5 seconds of
- *     // key inactivity.  This is an interrupt service routine so can only
- *     // call FreeRTOS API functions that end in "FromISR".
- *     vSetBacklightState( BACKLIGHT_ON );
- *
- *     // xTimerStartFromISR() or xTimerResetFromISR() could be called here
- *     // as both cause the timer to re-calculate its expiry time.
- *     // xHigherPriorityTaskWoken was initialised to pdFALSE when it was
- *     // declared (in this function).
- *     if( xTimerStartFromISR( xBacklightTimer, &xHigherPriorityTaskWoken ) !=
- *pdPASS )
- *     {
- *         // The start command was not executed successfully.  Take appropriate
- *         // action here.
- *     }
- *
- *     // Perform the rest of the key processing here.
- *
- *     // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
- *     // should be performed.  The syntax required to perform a context switch
- *     // from inside an ISR varies from port to port, and from compiler to
- *     // compiler.  Inspect the demos for the port you are using to find the
- *     // actual syntax required.
- *     if( xHigherPriorityTaskWoken != pdFALSE )
- *     {
- *         // Call the interrupt safe yield function here (actual function
- *         // depends on the FreeRTOS port being used).
- *     }
- * }
- * @endverbatim
- */
-#define xTimerStartFromISR(xTimer, pxHigherPriorityTaskWoken) \
-    xTimerGenericCommand( \
-        (xTimer), \
-        tmrCOMMAND_START_FROM_ISR, \
-        (xTaskGetTickCountFromISR()), \
-        (pxHigherPriorityTaskWoken), \
-        0U)
-
-/**
- * BaseType_t xTimerStopFromISR( 	TimerHandle_t xTimer,
- *									BaseType_t *pxHigherPriorityTaskWoken );
- *
- * A version of xTimerStop() that can be called from an interrupt service
- * routine.
- *
- * @param xTimer The handle of the timer being stopped.
- *
- * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
- * of its time in the Blocked state, waiting for messages to arrive on the timer
- * command queue.  Calling xTimerStopFromISR() writes a message to the timer
- * command queue, so has the potential to transition the timer service/daemon
- * task out of the Blocked state.  If calling xTimerStopFromISR() causes the
- * timer service/daemon task to leave the Blocked state, and the timer service/
- * daemon task has a priority equal to or greater than the currently executing
- * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will
- * get set to pdTRUE internally within the xTimerStopFromISR() function.  If
- * xTimerStopFromISR() sets this value to pdTRUE then a context switch should
- * be performed before the interrupt exits.
- *
- * @return pdFAIL will be returned if the stop command could not be sent to
- * the timer command queue.  pdPASS will be returned if the command was
- * successfully sent to the timer command queue.  When the command is actually
- * processed will depend on the priority of the timer service/daemon task
- * relative to other tasks in the system.  The timer service/daemon task
- * priority is set by the configTIMER_TASK_PRIORITY configuration constant.
- *
- * Example usage:
- * @verbatim
- * // This scenario assumes xTimer has already been created and started.  When
- * // an interrupt occurs, the timer should be simply stopped.
- *
- * // The interrupt service routine that stops the timer.
- * void vAnExampleInterruptServiceRoutine( void )
- * {
- * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
- *
- *     // The interrupt has occurred - simply stop the timer.
- *     // xHigherPriorityTaskWoken was set to pdFALSE where it was defined
- *     // (within this function).  As this is an interrupt service routine, only
- *     // FreeRTOS API functions that end in "FromISR" can be used.
- *     if( xTimerStopFromISR( xTimer, &xHigherPriorityTaskWoken ) != pdPASS )
- *     {
- *         // The stop command was not executed successfully.  Take appropriate
- *         // action here.
- *     }
- *
- *     // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
- *     // should be performed.  The syntax required to perform a context switch
- *     // from inside an ISR varies from port to port, and from compiler to
- *     // compiler.  Inspect the demos for the port you are using to find the
- *     // actual syntax required.
- *     if( xHigherPriorityTaskWoken != pdFALSE )
- *     {
- *         // Call the interrupt safe yield function here (actual function
- *         // depends on the FreeRTOS port being used).
- *     }
- * }
- * @endverbatim
- */
-#define xTimerStopFromISR(xTimer, pxHigherPriorityTaskWoken) \
-    xTimerGenericCommand( \
-        (xTimer), \
-        tmrCOMMAND_STOP_FROM_ISR, \
-        0, \
-        (pxHigherPriorityTaskWoken), \
-        0U)
-
-/**
- * BaseType_t xTimerChangePeriodFromISR( TimerHandle_t xTimer,
- *										 TickType_t xNewPeriod,
- *										 BaseType_t *pxHigherPriorityTaskWoken
- *);
- *
- * A version of xTimerChangePeriod() that can be called from an interrupt
- * service routine.
- *
- * @param xTimer The handle of the timer that is having its period changed.
- *
- * @param xNewPeriod The new period for xTimer. Timer periods are specified in
- * tick periods, so the constant portTICK_PERIOD_MS can be used to convert a
- *time that has been specified in milliseconds.  For example, if the timer must
- * expire after 100 ticks, then xNewPeriod should be set to 100.  Alternatively,
- * if the timer must expire after 500ms, then xNewPeriod can be set to
- * ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than
- * or equal to 1000.
- *
- * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
- * of its time in the Blocked state, waiting for messages to arrive on the timer
- * command queue.  Calling xTimerChangePeriodFromISR() writes a message to the
- * timer command queue, so has the potential to transition the timer service/
- * daemon task out of the Blocked state.  If calling xTimerChangePeriodFromISR()
- * causes the timer service/daemon task to leave the Blocked state, and the
- * timer service/daemon task has a priority equal to or greater than the
- * currently executing task (the task that was interrupted), then
- * *pxHigherPriorityTaskWoken will get set to pdTRUE internally within the
- * xTimerChangePeriodFromISR() function.  If xTimerChangePeriodFromISR() sets
- * this value to pdTRUE then a context switch should be performed before the
- * interrupt exits.
- *
- * @return pdFAIL will be returned if the command to change the timers period
- * could not be sent to the timer command queue.  pdPASS will be returned if the
- * command was successfully sent to the timer command queue.  When the command
- * is actually processed will depend on the priority of the timer service/daemon
- * task relative to other tasks in the system.  The timer service/daemon task
- * priority is set by the configTIMER_TASK_PRIORITY configuration constant.
- *
- * Example usage:
- * @verbatim
- * // This scenario assumes xTimer has already been created and started.  When
- * // an interrupt occurs, the period of xTimer should be changed to 500ms.
- *
- * // The interrupt service routine that changes the period of xTimer.
- * void vAnExampleInterruptServiceRoutine( void )
- * {
- * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
- *
- *     // The interrupt has occurred - change the period of xTimer to 500ms.
- *     // xHigherPriorityTaskWoken was set to pdFALSE where it was defined
- *     // (within this function).  As this is an interrupt service routine, only
- *     // FreeRTOS API functions that end in "FromISR" can be used.
- *     if( xTimerChangePeriodFromISR( xTimer, &xHigherPriorityTaskWoken ) !=
- *pdPASS )
- *     {
- *         // The command to change the timers period was not executed
- *         // successfully.  Take appropriate action here.
- *     }
- *
- *     // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
- *     // should be performed.  The syntax required to perform a context switch
- *     // from inside an ISR varies from port to port, and from compiler to
- *     // compiler.  Inspect the demos for the port you are using to find the
- *     // actual syntax required.
- *     if( xHigherPriorityTaskWoken != pdFALSE )
- *     {
- *         // Call the interrupt safe yield function here (actual function
- *         // depends on the FreeRTOS port being used).
- *     }
- * }
- * @endverbatim
- */
-#define xTimerChangePeriodFromISR( \
-    xTimer, xNewPeriod, pxHigherPriorityTaskWoken) \
-    xTimerGenericCommand( \
-        (xTimer), \
-        tmrCOMMAND_CHANGE_PERIOD_FROM_ISR, \
-        (xNewPeriod), \
-        (pxHigherPriorityTaskWoken), \
-        0U)
-
-/**
- * BaseType_t xTimerResetFromISR( 	TimerHandle_t xTimer,
- *									BaseType_t *pxHigherPriorityTaskWoken );
- *
- * A version of xTimerReset() that can be called from an interrupt service
- * routine.
- *
- * @param xTimer The handle of the timer that is to be started, reset, or
- * restarted.
- *
- * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most
- * of its time in the Blocked state, waiting for messages to arrive on the timer
- * command queue.  Calling xTimerResetFromISR() writes a message to the timer
- * command queue, so has the potential to transition the timer service/daemon
- * task out of the Blocked state.  If calling xTimerResetFromISR() causes the
- * timer service/daemon task to leave the Blocked state, and the timer service/
- * daemon task has a priority equal to or greater than the currently executing
- * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will
- * get set to pdTRUE internally within the xTimerResetFromISR() function.  If
- * xTimerResetFromISR() sets this value to pdTRUE then a context switch should
- * be performed before the interrupt exits.
- *
- * @return pdFAIL will be returned if the reset command could not be sent to
- * the timer command queue.  pdPASS will be returned if the command was
- * successfully sent to the timer command queue.  When the command is actually
- * processed will depend on the priority of the timer service/daemon task
- * relative to other tasks in the system, although the timers expiry time is
- * relative to when xTimerResetFromISR() is actually called.  The timer
- *service/daemon task priority is set by the configTIMER_TASK_PRIORITY
- *configuration constant.
- *
- * Example usage:
- * @verbatim
- * // This scenario assumes xBacklightTimer has already been created.  When a
- * // key is pressed, an LCD back-light is switched on.  If 5 seconds pass
- * // without a key being pressed, then the LCD back-light is switched off.  In
- * // this case, the timer is a one-shot timer, and unlike the example given for
- * // the xTimerReset() function, the key press event handler is an interrupt
- * // service routine.
- *
- * // The callback function assigned to the one-shot timer.  In this case the
- * // parameter is not used.
- * void vBacklightTimerCallback( TimerHandle_t pxTimer )
- * {
- *     // The timer expired, therefore 5 seconds must have passed since a key
- *     // was pressed.  Switch off the LCD back-light.
- *     vSetBacklightState( BACKLIGHT_OFF );
- * }
- *
- * // The key press interrupt service routine.
- * void vKeyPressEventInterruptHandler( void )
- * {
- * BaseType_t xHigherPriorityTaskWoken = pdFALSE;
- *
- *     // Ensure the LCD back-light is on, then reset the timer that is
- *     // responsible for turning the back-light off after 5 seconds of
- *     // key inactivity.  This is an interrupt service routine so can only
- *     // call FreeRTOS API functions that end in "FromISR".
- *     vSetBacklightState( BACKLIGHT_ON );
- *
- *     // xTimerStartFromISR() or xTimerResetFromISR() could be called here
- *     // as both cause the timer to re-calculate its expiry time.
- *     // xHigherPriorityTaskWoken was initialised to pdFALSE when it was
- *     // declared (in this function).
- *     if( xTimerResetFromISR( xBacklightTimer, &xHigherPriorityTaskWoken ) !=
- *pdPASS )
- *     {
- *         // The reset command was not executed successfully.  Take appropriate
- *         // action here.
- *     }
- *
- *     // Perform the rest of the key processing here.
- *
- *     // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
- *     // should be performed.  The syntax required to perform a context switch
- *     // from inside an ISR varies from port to port, and from compiler to
- *     // compiler.  Inspect the demos for the port you are using to find the
- *     // actual syntax required.
- *     if( xHigherPriorityTaskWoken != pdFALSE )
- *     {
- *         // Call the interrupt safe yield function here (actual function
- *         // depends on the FreeRTOS port being used).
- *     }
- * }
- * @endverbatim
- */
-#define xTimerResetFromISR(xTimer, pxHigherPriorityTaskWoken) \
-    xTimerGenericCommand( \
-        (xTimer), \
-        tmrCOMMAND_RESET_FROM_ISR, \
-        (xTaskGetTickCountFromISR()), \
-        (pxHigherPriorityTaskWoken), \
-        0U)
-
-/**
- * BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend,
- *                                          void *pvParameter1,
- *                                          uint32_t ulParameter2,
- *                                          BaseType_t
- **pxHigherPriorityTaskWoken );
- *
- *
- * Used from application interrupt service routines to defer the execution of a
- * function to the RTOS daemon task (the timer service task, hence this function
- * is implemented in timers.c and is prefixed with 'Timer').
- *
- * Ideally an interrupt service routine (ISR) is kept as short as possible, but
- * sometimes an ISR either has a lot of processing to do, or needs to perform
- * processing that is not deterministic.  In these cases
- * xTimerPendFunctionCallFromISR() can be used to defer processing of a function
- * to the RTOS daemon task.
- *
- * A mechanism is provided that allows the interrupt to return directly to the
- * task that will subsequently execute the pended callback function.  This
- * allows the callback function to execute contiguously in time with the
- * interrupt - just as if the callback had executed in the interrupt itself.
- *
- * @param xFunctionToPend The function to execute from the timer service/
- * daemon task.  The function must conform to the PendedFunction_t
- * prototype.
- *
- * @param pvParameter1 The value of the callback function's first parameter.
- * The parameter has a void * type to allow it to be used to pass any type.
- * For example, unsigned longs can be cast to a void *, or the void * can be
- * used to point to a structure.
- *
- * @param ulParameter2 The value of the callback function's second parameter.
- *
- * @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 (which is set using
- * configTIMER_TASK_PRIORITY in FreeRTOSConfig.h) is higher than the priority of
- * the currently running task (the task the interrupt interrupted) then
- * *pxHigherPriorityTaskWoken will be set to pdTRUE within
- * xTimerPendFunctionCallFromISR(), 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 pdPASS is returned if the message was successfully sent to the
- * timer daemon task, otherwise pdFALSE is returned.
- *
- * Example usage:
- * @verbatim
- *
- *	// The callback function that will execute in the context of the daemon
- *task.
- *  // Note callback functions must all use this same prototype.
- *  void vProcessInterface( void *pvParameter1, uint32_t ulParameter2 )
- *	{
- *		BaseType_t xInterfaceToService;
- *
- *		// The interface that requires servicing is passed in the second
- *      // parameter.  The first parameter is not used in this case.
- *		xInterfaceToService = ( BaseType_t ) ulParameter2;
- *
- *		// ...Perform the processing here...
- *	}
- *
- *	// An ISR that receives data packets from multiple interfaces
- *  void vAnISR( void )
- *	{
- *		BaseType_t xInterfaceToService, xHigherPriorityTaskWoken;
- *
- *		// Query the hardware to determine which interface needs processing.
- *		xInterfaceToService = prvCheckInterfaces();
- *
- *      // The actual processing is to be deferred to a task.  Request the
- *      // vProcessInterface() callback function is executed, passing in the
- *		// number of the interface that needs processing.  The interface to
- *		// service is passed in the second parameter.  The first parameter is
- *		// not used in this case.
- *		xHigherPriorityTaskWoken = pdFALSE;
- *		xTimerPendFunctionCallFromISR( vProcessInterface, NULL, ( uint32_t )
- *xInterfaceToService, &xHigherPriorityTaskWoken );
- *
- *		// 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 );
- *
- *	}
- * @endverbatim
- */
-BaseType_t xTimerPendFunctionCallFromISR(
-    PendedFunction_t xFunctionToPend,
-    void *pvParameter1,
-    uint32_t ulParameter2,
-    BaseType_t *pxHigherPriorityTaskWoken) PRIVILEGED_FUNCTION;
-
-/**
- * BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend,
- *                                    void *pvParameter1,
- *                                    uint32_t ulParameter2,
- *                                    TickType_t xTicksToWait );
- *
- *
- * Used to defer the execution of a function to the RTOS daemon task (the timer
- * service task, hence this function is implemented in timers.c and is prefixed
- * with 'Timer').
- *
- * @param xFunctionToPend The function to execute from the timer service/
- * daemon task.  The function must conform to the PendedFunction_t
- * prototype.
- *
- * @param pvParameter1 The value of the callback function's first parameter.
- * The parameter has a void * type to allow it to be used to pass any type.
- * For example, unsigned longs can be cast to a void *, or the void * can be
- * used to point to a structure.
- *
- * @param ulParameter2 The value of the callback function's second parameter.
- *
- * @param xTicksToWait Calling this function will result in a message being
- * sent to the timer daemon task on a queue.  xTicksToWait is the amount of
- * time the calling task should remain in the Blocked state (so not using any
- * processing time) for space to become available on the timer queue if the
- * queue is found to be full.
- *
- * @return pdPASS is returned if the message was successfully sent to the
- * timer daemon task, otherwise pdFALSE is returned.
- *
- */
-BaseType_t xTimerPendFunctionCall(
-    PendedFunction_t xFunctionToPend,
-    void *pvParameter1,
-    uint32_t ulParameter2,
-    TickType_t xTicksToWait) PRIVILEGED_FUNCTION;
-
-/**
- * const char * const pcTimerGetName( TimerHandle_t xTimer );
- *
- * Returns the name that was assigned to a timer when the timer was created.
- *
- * @param xTimer The handle of the timer being queried.
- *
- * @return The name assigned to the timer specified by the xTimer parameter.
- */
-const char *pcTimerGetName(TimerHandle_t xTimer)
-    PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for
-                            strings and single characters only. */
-
-/**
- * void vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t
- * uxAutoReload );
- *
- * Updates a timer to be either an auto-reload timer, in which case the timer
- * automatically resets itself each time it expires, or a one-shot timer, in
- * which case the timer will only expire once unless it is manually restarted.
- *
- * @param xTimer The handle of the timer being updated.
- *
- * @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will
- * expire repeatedly with a frequency set by the timer's period (see the
- * xTimerPeriodInTicks parameter of the xTimerCreate() API function).  If
- * uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and
- * enter the dormant state after it expires.
- */
-void vTimerSetReloadMode(TimerHandle_t xTimer, const UBaseType_t uxAutoReload)
-    PRIVILEGED_FUNCTION;
-
-/**
- * UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer );
- *
- * Queries a timer to determine if it is an auto-reload timer, in which case the
- * timer automatically resets itself each time it expires, or a one-shot timer,
- * in which case the timer will only expire once unless it is manually
- * restarted.
- *
- * @param xTimer The handle of the timer being queried.
- *
- * @return If the timer is an auto-reload timer then pdTRUE is returned,
- * otherwise pdFALSE is returned.
- */
-UBaseType_t uxTimerGetReloadMode(TimerHandle_t xTimer) PRIVILEGED_FUNCTION;
-
-/**
- * TickType_t xTimerGetPeriod( TimerHandle_t xTimer );
- *
- * Returns the period of a timer.
- *
- * @param xTimer The handle of the timer being queried.
- *
- * @return The period of the timer in ticks.
- */
-TickType_t xTimerGetPeriod(TimerHandle_t xTimer) PRIVILEGED_FUNCTION;
-
-/**
- * TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer );
- *
- * Returns the time in ticks at which the timer will expire.  If this is less
- * than the current tick count then the expiry time has overflowed from the
- * current time.
- *
- * @param xTimer The handle of the timer being queried.
- *
- * @return If the timer is running then the time in ticks at which the timer
- * will next expire is returned.  If the timer is not running then the return
- * value is undefined.
- */
-TickType_t xTimerGetExpiryTime(TimerHandle_t xTimer) PRIVILEGED_FUNCTION;
-
-/*
- * Functions beyond this part are not part of the public API and are intended
- * for use by the kernel only.
- */
-BaseType_t xTimerCreateTimerTask(void) PRIVILEGED_FUNCTION;
-BaseType_t xTimerGenericCommand(
-    TimerHandle_t xTimer,
-    const BaseType_t xCommandID,
-    const TickType_t xOptionalValue,
-    BaseType_t *const pxHigherPriorityTaskWoken,
-    const TickType_t xTicksToWait) PRIVILEGED_FUNCTION;
-
-#if (configUSE_TRACE_FACILITY == 1)
-void vTimerSetTimerNumber(TimerHandle_t xTimer, UBaseType_t uxTimerNumber)
-    PRIVILEGED_FUNCTION;
-UBaseType_t uxTimerGetTimerNumber(TimerHandle_t xTimer) PRIVILEGED_FUNCTION;
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* TIMERS_H */
diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/list.c b/product/rcar/src/CMSIS-FreeRTOS/Source/list.c
deleted file mode 100644
index 61d4fcad1448d32f26cc52e6592c16dc00b62afd..0000000000000000000000000000000000000000
--- a/product/rcar/src/CMSIS-FreeRTOS/Source/list.c
+++ /dev/null
@@ -1,205 +0,0 @@
-/*
- * FreeRTOS Kernel V10.3.1
- * 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://www.FreeRTOS.org
- * http://aws.amazon.com/freertos
- *
- * 1 tab == 4 spaces!
- */
-
-#include "FreeRTOS.h"
-#include "list.h"
-
-#include 
-
-/*-----------------------------------------------------------
- * PUBLIC LIST API documented in list.h
- *----------------------------------------------------------*/
-
-void vListInitialise(List_t *const 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); /*lint !e826 !e740 !e9087 The mini list structure is
-                              used as the list end to save RAM.  This is checked
-                              and valid. */
-
-    /* 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); /*lint !e826 !e740 !e9087 The mini list structure is
-                              used as the list end to save RAM.  This is checked
-                              and valid. */
-    pxList->xListEnd.pxPrevious = (ListItem_t *)&(
-        pxList->xListEnd); /*lint !e826 !e740 !e9087 The mini list structure is
-                              used as the list end to save RAM.  This is checked
-                              and valid. */
-
-    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);
-}
-/*-----------------------------------------------------------*/
-
-void vListInitialiseItem(ListItem_t *const 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);
-}
-/*-----------------------------------------------------------*/
-
-void vListInsertEnd(List_t *const pxList, ListItem_t *const pxNewListItem)
-{
-    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;
-
-    /* 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)++;
-}
-/*-----------------------------------------------------------*/
-
-void vListInsert(List_t *const pxList, ListItem_t *const pxNewListItem)
-{
-    ListItem_t *pxIterator;
-    const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
-
-    /* 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/FAQHelp.html 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?).
-        **********************************************************************/
-
-        for (
-            pxIterator = (ListItem_t *)&(pxList->xListEnd); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator =
-                                                                                                                     pxIterator
-                                                                                                                         ->pxNext) /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */ /*lint !e440 The iterator moves to a different value, not xValueOfInsertion. */
-        {
-            /* There is nothing to do here, just iterating to the wanted
-            insertion position. */
-        }
-    }
-
-    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 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;
-
-    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)--;
-
-    return pxList->uxNumberOfItems;
-}
-/*-----------------------------------------------------------*/
diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/portable/GCC/ARM_CA53_64_Rcar/port.c b/product/rcar/src/CMSIS-FreeRTOS/Source/portable/GCC/ARM_CA53_64_Rcar/port.c
deleted file mode 100644
index 663b758e9d47095f36adb36b4c7b31f20861bbd3..0000000000000000000000000000000000000000
--- a/product/rcar/src/CMSIS-FreeRTOS/Source/portable/GCC/ARM_CA53_64_Rcar/port.c
+++ /dev/null
@@ -1,299 +0,0 @@
-/*
- * FreeRTOS Kernel V10.2.0
- * Copyright (C) 2019 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://www.FreeRTOS.org
- * http://aws.amazon.com/freertos
- *
- * 1 tab == 4 spaces!
- */
-
-/* Standard includes. */
-#include 
-
-/* Scheduler includes. */
-#include "FreeRTOS.h"
-#include "task.h"
-
-#ifndef configSETUP_TICK_INTERRUPT
-#    error configSETUP_TICK_INTERRUPT() must be defined.  See http://www.freertos.org/Using-FreeRTOS-on-Cortex-A-Embedded-Processors.html
-#endif /* configSETUP_TICK_INTERRUPT */
-
-/* Some vendor specific files default configCLEAR_TICK_INTERRUPT() in
-portmacro.h. */
-#ifndef configCLEAR_TICK_INTERRUPT
-#    define configCLEAR_TICK_INTERRUPT()
-#endif
-
-/* A critical section is exited when the critical section nesting count reaches
-this value. */
-#define portNO_CRITICAL_NESTING ((size_t)0)
-
-/* Tasks are not created with a floating point context, but can be given a
-floating point context after they have been created.  A variable is stored as
-part of the tasks context that holds portNO_FLOATING_POINT_CONTEXT if the task
-does not have an FPU context, or any other value if the task does have an FPU
-context. */
-#define portNO_FLOATING_POINT_CONTEXT ((StackType_t)0)
-
-/* Constants required to setup the initial task context. */
-#define portSP_ELx ((StackType_t)0x01)
-#define portSP_EL0 ((StackType_t)0x00)
-
-#define portEL1 ((StackType_t)0x04)
-#define portEL3 ((StackType_t)0x0C)
-#if 0
-#    define portINITIAL_PSTATE (portEL1 | portSP_EL0)
-#else
-#    define portINITIAL_PSTATE (portEL3 | portSP_EL0)
-#endif
-
-/* Masks all bits in the APSR other than the mode bits. */
-#define portAPSR_MODE_BITS_MASK (0x0C)
-
-/* Used in the ASM code. */
-__attribute__((used)) const uint64_t ulCORE0_INT_SRC = 0x40000060;
-
-/*-----------------------------------------------------------*/
-
-/*
- * Starts the first task executing.  This function is necessarily written in
- * assembly code so is implemented in portASM.s.
- */
-extern void vPortRestoreTaskContext(void);
-
-/*-----------------------------------------------------------*/
-
-/* A variable is used to keep track of the critical section nesting.  This
-variable has to be stored as part of the task context and must be initialised to
-a non zero value to ensure interrupts don't inadvertently become unmasked before
-the scheduler starts.  As it is stored as part of the task context it will
-automatically be set to 0 when the first task is started. */
-volatile uint64_t ullCriticalNesting = 9999ULL;
-
-/* Saved as part of the task context.  If ullPortTaskHasFPUContext is non-zero
-then floating point context must be saved and restored for the task. */
-uint64_t ullPortTaskHasFPUContext = pdFALSE;
-
-/* Set to 1 to pend a context switch from an ISR. */
-uint64_t ullPortYieldRequired = pdFALSE;
-
-/* Counts the interrupt nesting depth.  A context switch is only performed if
-if the nesting depth is 0. */
-uint64_t ullPortInterruptNesting = 0;
-
-/*-----------------------------------------------------------*/
-/*
- * See header file for description.
- */
-StackType_t *pxPortInitialiseStack(
-    StackType_t *pxTopOfStack,
-    TaskFunction_t pxCode,
-    void *pvParameters)
-{
-    /* Setup the initial stack of the task.  The stack is set exactly as
-    expected by the portRESTORE_CONTEXT() macro. */
-
-    /* First all the general purpose registers. */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x0101010101010101ULL; /* R1 */
-    pxTopOfStack--;
-    *pxTopOfStack = (StackType_t)pvParameters; /* R0 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x0303030303030303ULL; /* R3 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x0202020202020202ULL; /* R2 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x0505050505050505ULL; /* R5 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x0404040404040404ULL; /* R4 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x0707070707070707ULL; /* R7 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x0606060606060606ULL; /* R6 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x0909090909090909ULL; /* R9 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x0808080808080808ULL; /* R8 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x1111111111111111ULL; /* R11 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x1010101010101010ULL; /* R10 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x1313131313131313ULL; /* R13 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x1212121212121212ULL; /* R12 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x1515151515151515ULL; /* R15 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x1414141414141414ULL; /* R14 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x1717171717171717ULL; /* R17 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x1616161616161616ULL; /* R16 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x1919191919191919ULL; /* R19 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x1818181818181818ULL; /* R18 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x2121212121212121ULL; /* R21 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x2020202020202020ULL; /* R20 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x2323232323232323ULL; /* R23 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x2222222222222222ULL; /* R22 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x2525252525252525ULL; /* R25 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x2424242424242424ULL; /* R24 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x2727272727272727ULL; /* R27 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x2626262626262626ULL; /* R26 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x2929292929292929ULL; /* R29 */
-    pxTopOfStack--;
-    *pxTopOfStack = 0x2828282828282828ULL; /* R28 */
-    pxTopOfStack--;
-    *pxTopOfStack = (StackType_t)0x00; /* XZR */
-    /* - has no effect, used so there are an even number of registers. */
-    pxTopOfStack--;
-    *pxTopOfStack = (StackType_t)0x00; /* R30 */
-    /* - procedure call link register. */
-    pxTopOfStack--;
-
-    *pxTopOfStack = portINITIAL_PSTATE;
-    pxTopOfStack--;
-
-    *pxTopOfStack = (StackType_t)pxCode; /* Exception return address. */
-    pxTopOfStack--;
-
-    /* The task will start with a critical nesting count of 0 as interrupts are
-    enabled. */
-    *pxTopOfStack = portNO_CRITICAL_NESTING;
-    pxTopOfStack--;
-
-    /* The task will start without a floating point context.  A task that uses
-    the floating point hardware must call vPortTaskUsesFPU() before executing
-    any floating point instructions. */
-    *pxTopOfStack = portNO_FLOATING_POINT_CONTEXT;
-
-    return pxTopOfStack;
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xPortStartScheduler(void)
-{
-    uint32_t ulAPSR;
-
-    /* At the time of writing, the BSP only supports EL3. */
-    __asm volatile("MRS %0, CurrentEL" : "=r"(ulAPSR));
-    ulAPSR &= portAPSR_MODE_BITS_MASK;
-
-    configASSERT(ulAPSR == portEL3);
-    if (ulAPSR == portEL3) {
-        {
-            /* Interrupts are turned off in the CPU itself to ensure a tick does
-            not execute while the scheduler is being started.  Interrupts are
-            automatically turned back on in the CPU when the first task starts
-            executing. */
-            portDISABLE_INTERRUPTS();
-
-            /* Start the timer that generates the tick ISR. */
-            configSETUP_TICK_INTERRUPT();
-
-            /* Start the first task executing. */
-            vPortRestoreTaskContext();
-        }
-    }
-
-    return 0;
-}
-/*-----------------------------------------------------------*/
-
-void vPortEndScheduler(void)
-{
-    /* Not implemented in ports where there is nothing to return to.
-    Artificially force an assert. */
-    configASSERT(ullCriticalNesting == 1000ULL);
-}
-/*-----------------------------------------------------------*/
-
-void vPortEnterCritical(void)
-{
-    portDISABLE_INTERRUPTS();
-
-    /* Now interrupts are disabled ullCriticalNesting can be accessed
-    directly.  Increment ullCriticalNesting to keep a count of how many times
-    portENTER_CRITICAL() has been called. */
-    ullCriticalNesting++;
-
-    /* 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 (ullCriticalNesting == 1ULL) {
-        configASSERT(ullPortInterruptNesting == 0);
-    }
-}
-/*-----------------------------------------------------------*/
-
-void vPortExitCritical(void)
-{
-    if (ullCriticalNesting > portNO_CRITICAL_NESTING) {
-        /* Decrement the nesting count as the critical section is being
-        exited. */
-        ullCriticalNesting--;
-
-        /* If the nesting level has reached zero then all interrupt
-        priorities must be re-enabled. */
-        if (ullCriticalNesting == portNO_CRITICAL_NESTING) {
-            /* Critical nesting has reached zero so interrupts
-            should be enabled. */
-            portENABLE_INTERRUPTS();
-        }
-    }
-}
-/*-----------------------------------------------------------*/
-
-void FreeRTOS_Tick_Handler(void)
-{
-/* Interrupts should not be enabled before this point. */
-#if (configASSERT_DEFINED == 1)
-    {
-        uint32_t ulMaskBits;
-
-        __asm volatile("mrs %0, daif" : "=r"(ulMaskBits)::"memory");
-        configASSERT((ulMaskBits & portDAIF_I) != 0);
-    }
-#endif /* configASSERT_DEFINED */
-
-    /* Ok to enable interrupts after the interrupt source has been cleared. */
-    configCLEAR_TICK_INTERRUPT();
-    portENABLE_INTERRUPTS();
-
-    /* Increment the RTOS tick. */
-    if (xTaskIncrementTick() != pdFALSE) {
-        ullPortYieldRequired = pdTRUE;
-    }
-}
diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/portable/GCC/ARM_CA53_64_Rcar/portASM.S b/product/rcar/src/CMSIS-FreeRTOS/Source/portable/GCC/ARM_CA53_64_Rcar/portASM.S
deleted file mode 100644
index 602e8c28826040e21e29ff14d736f0c0c1e5bcd7..0000000000000000000000000000000000000000
--- a/product/rcar/src/CMSIS-FreeRTOS/Source/portable/GCC/ARM_CA53_64_Rcar/portASM.S
+++ /dev/null
@@ -1,352 +0,0 @@
-/*
- * FreeRTOS Kernel V10.2.0
- * Copyright (C) 2019 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://www.FreeRTOS.org
- * http://aws.amazon.com/freertos
- *
- * 1 tab == 4 spaces!
- */
-
-    .text
-
-    /* Variables and functions. */
-    .extern ullMaxAPIPriorityMask
-    .extern pxCurrentTCB
-    .extern _freertos_vector_table
-
-    .globl FreeRTOS_SWI_Handler
-    .globl FreeRTOS_IRQ_Handler
-    .globl vPortRestoreTaskContext
-
-; /**********************************************************************/
-
-.macro portSAVE_CONTEXT
-
-    /* Switch to use the EL0 stack pointer. */
-    MSR     SPSEL, #0
-
-    /* Save the entire context. */
-    STP     X0, X1, [SP, #-0x10]!
-    STP     X2, X3, [SP, #-0x10]!
-    STP     X4, X5, [SP, #-0x10]!
-    STP     X6, X7, [SP, #-0x10]!
-    STP     X8, X9, [SP, #-0x10]!
-    STP     X10, X11, [SP, #-0x10]!
-    STP     X12, X13, [SP, #-0x10]!
-    STP     X14, X15, [SP, #-0x10]!
-    STP     X16, X17, [SP, #-0x10]!
-    STP     X18, X19, [SP, #-0x10]!
-    STP     X20, X21, [SP, #-0x10]!
-    STP     X22, X23, [SP, #-0x10]!
-    STP     X24, X25, [SP, #-0x10]!
-    STP     X26, X27, [SP, #-0x10]!
-    STP     X28, X29, [SP, #-0x10]!
-    STP     X30, XZR, [SP, #-0x10]!
-
-    /* Save the SPSR. */
-    MRS     X3, SPSR_EL3
-    MRS     X2, ELR_EL3
-
-    STP     X2, X3, [SP, #-0x10]!
-
-    /* Save the critical section nesting depth. */
-    LDR     X0, ullCriticalNestingConst
-    LDR     X3, [X0]
-
-    /* Save the FPU context indicator. */
-    LDR     X0, ullPortTaskHasFPUContextConst
-    LDR     X2, [X0]
-
-    /* Save the FPU context, if any (32 128-bit registers). */
-    CMP     X2, #0
-    B.EQ    1f
-    STP     Q0, Q1, [SP,#-0x20]!
-    STP     Q2, Q3, [SP,#-0x20]!
-    STP     Q4, Q5, [SP,#-0x20]!
-    STP     Q6, Q7, [SP,#-0x20]!
-    STP     Q8, Q9, [SP,#-0x20]!
-    STP     Q10, Q11, [SP,#-0x20]!
-    STP     Q12, Q13, [SP,#-0x20]!
-    STP     Q14, Q15, [SP,#-0x20]!
-    STP     Q16, Q17, [SP,#-0x20]!
-    STP     Q18, Q19, [SP,#-0x20]!
-    STP     Q20, Q21, [SP,#-0x20]!
-    STP     Q22, Q23, [SP,#-0x20]!
-    STP     Q24, Q25, [SP,#-0x20]!
-    STP     Q26, Q27, [SP,#-0x20]!
-    STP     Q28, Q29, [SP,#-0x20]!
-    STP     Q30, Q31, [SP,#-0x20]!
-
-1:
-    /* Store the critical nesting count and FPU context indicator. */
-    STP     X2, X3, [SP, #-0x10]!
-
-    LDR     X0, pxCurrentTCBConst
-    LDR     X1, [X0]
-    MOV     X0, SP   /* Move SP into X0 for saving. */
-    STR     X0, [X1]
-
-    /* Switch to use the ELx stack pointer. */
-    MSR     SPSEL, #1
-
-    .endm
-
-
-.macro portRESTORE_CONTEXT
-
-    /* Switch to use the EL0 stack pointer. */
-    MSR     SPSEL, #0
-
-    /* Set the SP to point to the stack of the task being restored. */
-    LDR     X0, pxCurrentTCBConst
-    LDR     X1, [X0]
-    LDR     X0, [X1]
-    MOV     SP, X0
-
-    LDP     X2, X3, [SP], #0x10  /* Critical nesting and FPU context. */
-
-    /* Set the PMR register to be correct for the current critical nesting
-    depth. */
-    /* X0 holds the address of ullCriticalNesting. */
-    LDR     X0, ullCriticalNestingConst
-    /* Restore the task's critical nesting count. */
-    STR     X3, [X0]
-
-    /* Restore the FPU context indicator. */
-    LDR     X0, ullPortTaskHasFPUContextConst
-    STR     X2, [X0]
-
-    /* Restore the FPU context, if any. */
-    CMP     X2, #0
-    B.EQ    1f
-    LDP     Q30, Q31, [SP], #0x20
-    LDP     Q28, Q29, [SP], #0x20
-    LDP     Q26, Q27, [SP], #0x20
-    LDP     Q24, Q25, [SP], #0x20
-    LDP     Q22, Q23, [SP], #0x20
-    LDP     Q20, Q21, [SP], #0x20
-    LDP     Q18, Q19, [SP], #0x20
-    LDP     Q16, Q17, [SP], #0x20
-    LDP     Q14, Q15, [SP], #0x20
-    LDP     Q12, Q13, [SP], #0x20
-    LDP     Q10, Q11, [SP], #0x20
-    LDP     Q8, Q9, [SP], #0x20
-    LDP     Q6, Q7, [SP], #0x20
-    LDP     Q4, Q5, [SP], #0x20
-    LDP     Q2, Q3, [SP], #0x20
-    LDP     Q0, Q1, [SP], #0x20
-1:
-    LDP     X2, X3, [SP], #0x10  /* SPSR and ELR. */
-
-    /* Restore the SPSR. */
-    MSR     SPSR_EL3, X3
-    /* Restore the ELR. */
-    MSR     ELR_EL3, X2
-
-    LDP     X30, XZR, [SP], #0x10
-    LDP     X28, X29, [SP], #0x10
-    LDP     X26, X27, [SP], #0x10
-    LDP     X24, X25, [SP], #0x10
-    LDP     X22, X23, [SP], #0x10
-    LDP     X20, X21, [SP], #0x10
-    LDP     X18, X19, [SP], #0x10
-    LDP     X16, X17, [SP], #0x10
-    LDP     X14, X15, [SP], #0x10
-    LDP     X12, X13, [SP], #0x10
-    LDP     X10, X11, [SP], #0x10
-    LDP     X8, X9, [SP], #0x10
-    LDP     X6, X7, [SP], #0x10
-    LDP     X4, X5, [SP], #0x10
-    LDP     X2, X3, [SP], #0x10
-    LDP     X0, X1, [SP], #0x10
-
-    /* Switch to use the ELx stack pointer.  _RB_ Might not be required. */
-    MSR     SPSEL, #1
-
-    ERET
-
-    .endm
-
-/******************************************************************************
- * FreeRTOS_SWI_Handler handler is used to perform a context switch.
- *****************************************************************************/
-.align 8
-.type FreeRTOS_SWI_Handler, %function
-FreeRTOS_SWI_Handler:
-    /* Save the context of the current task and select a new task to run. */
-    portSAVE_CONTEXT
-    MRS     X0, ESR_EL3
-
-    LSR     X1, X0, #26
-
-    CMP     X1, #0x15   /* 0x15 = SVC instruction. */
-
-    B.NE    FreeRTOS_Abort
-    BL      vTaskSwitchContext
-
-    portRESTORE_CONTEXT
-
-FreeRTOS_Abort:
-    /* Full ESR is in X0, exception class code is in X1. */
-    B       .
-
-/******************************************************************************
- * vPortRestoreTaskContext is used to start the scheduler.
- *****************************************************************************/
-.align 8
-.type vPortRestoreTaskContext, %function
-vPortRestoreTaskContext:
-.set freertos_vector_base,  _freertos_vector_table
-
-    /* Install the FreeRTOS interrupt handlers. */
-    LDR     X1, =freertos_vector_base
-    MSR     VBAR_EL3, X1
-    DSB     SY
-    ISB     SY
-
-    /* Start the first task. */
-    portRESTORE_CONTEXT
-
-/******************************************************************************
- * FreeRTOS_IRQ_Handler handles IRQ entry and exit.
- *****************************************************************************/
-.align 8
-.type FreeRTOS_IRQ_Handler, %function
-FreeRTOS_IRQ_Handler:
-    /* Save volatile registers. */
-    STP     X0, X1, [SP, #-0x10]!
-    STP     X2, X3, [SP, #-0x10]!
-    STP     X4, X5, [SP, #-0x10]!
-    STP     X6, X7, [SP, #-0x10]!
-    STP     X8, X9, [SP, #-0x10]!
-    STP     X10, X11, [SP, #-0x10]!
-    STP     X12, X13, [SP, #-0x10]!
-    STP     X14, X15, [SP, #-0x10]!
-    STP     X16, X17, [SP, #-0x10]!
-    STP     X18, X19, [SP, #-0x10]!
-    STP     X29, X30, [SP, #-0x10]!
-
-    /* Save the SPSR and ELR. */
-    MRS     X3, SPSR_EL3
-    MRS     X2, ELR_EL3
-    STP     X2, X3, [SP, #-0x10]!
-
-    /* Increment the interrupt nesting counter. */
-    LDR     X5, ullPortInterruptNestingConst
-    LDR     X1, [X5]    /* Old nesting count in X1. */
-    ADD     X6, X1, #1
-    STR     X6, [X5]    /* Address of nesting count variable in X5. */
-
-    /* Maintain the interrupt nesting information across the function call. */
-    STP     X1, X5, [SP, #-0x10]!
-
-#if 0
-    /* Read Cor0 interrupt Source */
-    ldr     x2, ulCORE0_INT_SRCConst
-    ldr     x3, [x2]
-    ldr     w0, [x3] /* set parametor for handler */
-#endif
-
-    /* Call the C handler. */
-    BL vApplicationIRQHandler
-
-    /* Disable interrupts. */
-    MSR     DAIFSET, #1 /* IRQ -> FIQ */
-    DSB     SY
-    ISB     SY
-
-    /* Restore the critical nesting count. */
-    LDP     X1, X5, [SP], #0x10
-    STR     X1, [X5]
-
-    /* Has interrupt nesting unwound? */
-    CMP     X1, #0
-    B.NE    Exit_IRQ_No_Context_Switch
-
-    /* Is a context switch required? */
-    LDR     X0, ullPortYieldRequiredConst
-    LDR     X1, [X0]
-    CMP     X1, #0
-    B.EQ    Exit_IRQ_No_Context_Switch
-
-    /* Reset ullPortYieldRequired to 0. */
-    MOV     X2, #0
-    STR     X2, [X0]
-
-    /* Restore volatile registers. */
-    LDP     X4, X5, [SP], #0x10  /* SPSR and ELR. */
-    MSR     SPSR_EL3, X5
-    MSR     ELR_EL3, X4
-    DSB     SY
-    ISB     SY
-
-    LDP     X29, X30, [SP], #0x10
-    LDP     X18, X19, [SP], #0x10
-    LDP     X16, X17, [SP], #0x10
-    LDP     X14, X15, [SP], #0x10
-    LDP     X12, X13, [SP], #0x10
-    LDP     X10, X11, [SP], #0x10
-    LDP     X8, X9, [SP], #0x10
-    LDP     X6, X7, [SP], #0x10
-    LDP     X4, X5, [SP], #0x10
-    LDP     X2, X3, [SP], #0x10
-    LDP     X0, X1, [SP], #0x10
-
-    /* Save the context of the current task and select a new task to run. */
-    portSAVE_CONTEXT
-    BL vTaskSwitchContext
-    portRESTORE_CONTEXT
-
-Exit_IRQ_No_Context_Switch:
-    /* Restore volatile registers. */
-    LDP     X4, X5, [SP], #0x10  /* SPSR and ELR. */
-    MSR     SPSR_EL3, X5
-    MSR     ELR_EL3, X4
-    DSB     SY
-    ISB     SY
-
-    LDP     X29, X30, [SP], #0x10
-    LDP     X18, X19, [SP], #0x10
-    LDP     X16, X17, [SP], #0x10
-    LDP     X14, X15, [SP], #0x10
-    LDP     X12, X13, [SP], #0x10
-    LDP     X10, X11, [SP], #0x10
-    LDP     X8, X9, [SP], #0x10
-    LDP     X6, X7, [SP], #0x10
-    LDP     X4, X5, [SP], #0x10
-    LDP     X2, X3, [SP], #0x10
-    LDP     X0, X1, [SP], #0x10
-
-    ERET
-
-
-.align 8
-pxCurrentTCBConst: .dword pxCurrentTCB
-ullCriticalNestingConst: .dword ullCriticalNesting
-ullPortTaskHasFPUContextConst: .dword ullPortTaskHasFPUContext
-
-vApplicationIRQHandlerConst: .word vApplicationIRQHandler
-    .word 0
-ullPortInterruptNestingConst: .dword ullPortInterruptNesting
-ullPortYieldRequiredConst: .dword ullPortYieldRequired
-
-ulCORE0_INT_SRCConst: .dword ulCORE0_INT_SRC
-.end
diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/portable/GCC/ARM_CA53_64_Rcar/portmacro.h b/product/rcar/src/CMSIS-FreeRTOS/Source/portable/GCC/ARM_CA53_64_Rcar/portmacro.h
deleted file mode 100644
index 120ccb3f3baac3d29907bcfd3ce156243437dd89..0000000000000000000000000000000000000000
--- a/product/rcar/src/CMSIS-FreeRTOS/Source/portable/GCC/ARM_CA53_64_Rcar/portmacro.h
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * FreeRTOS Kernel V10.2.0
- * Copyright (C) 2019 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://www.FreeRTOS.org
- * http://aws.amazon.com/freertos
- *
- * 1 tab == 4 spaces!
- */
-
-#ifndef PORTMACRO_H
-#define PORTMACRO_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/*-----------------------------------------------------------
- * 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 size_t
-#define portBASE_TYPE long
-
-typedef portSTACK_TYPE StackType_t;
-typedef portBASE_TYPE BaseType_t;
-typedef uint64_t UBaseType_t;
-
-typedef uint64_t TickType_t;
-#define portMAX_DELAY ((TickType_t)0xffffffffffffffff)
-
-/*-----------------------------------------------------------*/
-
-/* Task utilities. */
-
-#define portYIELD() __asm volatile("SVC 0" ::: "memory")
-
-/*-----------------------------------------------------------
- * Critical section control
- *----------------------------------------------------------*/
-
-extern void vPortEnterCritical(void);
-extern void vPortExitCritical(void);
-
-#define portDISABLE_INTERRUPTS() \
-    __asm volatile("MSR DAIFSET, #1" ::: "memory"); \
-    __asm volatile("DSB SY"); \
-    __asm volatile("ISB SY");
-
-#define portENABLE_INTERRUPTS() \
-    __asm volatile("MSR DAIFCLR, #1" ::: "memory"); \
-    __asm volatile("DSB SY"); \
-    __asm volatile("ISB SY");
-
-/* These macros do not globally disable/enable interrupts.  They do mask off
-interrupts that have a priority below configMAX_API_CALL_INTERRUPT_PRIORITY. */
-#define portENTER_CRITICAL() vPortEnterCritical();
-#define portEXIT_CRITICAL() vPortExitCritical();
-
-/*-----------------------------------------------------------*/
-
-/* Task function macros as described on the FreeRTOS.org WEB site.  These are
-not required for this port but included in case common demo code that uses these
-macros is used. */
-#define portTASK_FUNCTION_PROTO(vFunction, pvParameters) \
-    void vFunction(void *pvParameters)
-#define portTASK_FUNCTION(vFunction, pvParameters) \
-    void vFunction(void *pvParameters)
-
-/* Prototype of the FreeRTOS tick handler.  This must be installed as the
-handler for whichever peripheral is used to generate the RTOS tick. */
-void FreeRTOS_Tick_Handler(void);
-
-/*-----------------------------------------------------------*/
-
-/* Hardware specifics. */
-#define portSTACK_GROWTH (-1)
-#define portTICK_PERIOD_MS ((TickType_t)1000 / configTICK_RATE_HZ)
-#define portBYTE_ALIGNMENT 16
-#define portPOINTER_SIZE_TYPE uint64_t
-
-#ifdef __cplusplus
-} /* extern C */
-#endif
-
-#endif /* PORTMACRO_H */
diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/portable/MemMang/heap_1.c b/product/rcar/src/CMSIS-FreeRTOS/Source/portable/MemMang/heap_1.c
deleted file mode 100644
index ae03b9f947096b808f53970508d97d0b6500bcd3..0000000000000000000000000000000000000000
--- a/product/rcar/src/CMSIS-FreeRTOS/Source/portable/MemMang/heap_1.c
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * FreeRTOS Kernel V10.3.1
- * 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://www.FreeRTOS.org
- * http://aws.amazon.com/freertos
- *
- * 1 tab == 4 spaces!
- */
-
-/*
- * 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 http://www.FreeRTOS.org for more information.
- */
-#include 
-
-/* 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)
-
-/* 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)0;
-
-/*-----------------------------------------------------------*/
-
-void *pvPortMalloc(size_t xWantedSize)
-{
-    void *pvReturn = NULL;
-    static uint8_t *pucAlignedHeap = NULL;
-
-/* Ensure that blocks are always aligned to the required number of bytes. */
-#if (portBYTE_ALIGNMENT != 1)
-    {
-        if (xWantedSize & portBYTE_ALIGNMENT_MASK) {
-            /* Byte alignment required. */
-            xWantedSize +=
-                (portBYTE_ALIGNMENT - (xWantedSize & portBYTE_ALIGNMENT_MASK));
-        }
-    }
-#endif
-
-    vTaskSuspendAll();
-    {
-        if (pucAlignedHeap == NULL) {
-            /* Ensure the heap starts on a correctly aligned boundary. */
-            pucAlignedHeap =
-                (uint8_t
-                     *)(((portPOINTER_SIZE_TYPE)&ucHeap[portBYTE_ALIGNMENT]) & (~((portPOINTER_SIZE_TYPE)portBYTE_ALIGNMENT_MASK)));
-        }
-
-        /* Check there is enough room left for the allocation. */
-        if (((xNextFreeByte + xWantedSize) < configADJUSTED_HEAP_SIZE) &&
-            ((xNextFreeByte + xWantedSize) >
-             xNextFreeByte)) /* Check for overflow. */
-        {
-            /* 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) {
-            extern void vApplicationMallocFailedHook(void);
-            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
-    http://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);
-}
diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/queue.c b/product/rcar/src/CMSIS-FreeRTOS/Source/queue.c
deleted file mode 100644
index 398e7e20a11d2eee473973408635818fb9c6c0a0..0000000000000000000000000000000000000000
--- a/product/rcar/src/CMSIS-FreeRTOS/Source/queue.c
+++ /dev/null
@@ -1,2826 +0,0 @@
-/*
- * FreeRTOS Kernel V10.3.1
- * 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://www.FreeRTOS.org
- * http://aws.amazon.com/freertos
- *
- * 1 tab == 4 spaces!
- */
-
-#include 
-#include 
-
-/* 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 "queue.h"
-#include "task.h"
-
-#if (configUSE_CO_ROUTINES == 1)
-#    include "croutine.h"
-#endif
-
-/* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified
-because 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 /*lint !e961 !e750 !e9021. */
-
-/* Constants used with the cRxLock and cTxLock structure members. */
-#define queueUNLOCKED ((int8_t)-1)
-#define queueLOCKED_UNMODIFIED ((int8_t)0)
-
-/* When the Queue_t structure is used to represent a base queue its pcHead and
-pcTail members are used as pointers into the queue storage area.  When the
-Queue_t structure is used to represent a mutex pcHead and pcTail pointers are
-not necessary, and the pcHead pointer is set to NULL to indicate that the
-structure instead holds a pointer to the mutex holder (if any).  Map alternative
-names to the pcHead and structure member to ensure the readability of the code
-is maintained.  The QueuePointers_t and SemaphoreData_t types are used to form
-a union as their usage is mutually exclusive dependent on what the queue is
-being used for. */
-#define uxQueueType pcHead
-#define queueQUEUE_IS_MUTEX NULL
-
-typedef struct QueuePointers {
-    int8_t *pcTail; /*< Points to the byte at the end of the queue storage area.
-                       Once more byte is allocated than necessary to store the
-                       queue items, this is used as a marker. */
-    int8_t *pcReadFrom; /*< Points to the last place that a queued item was read
-                           from when the structure is used as a queue. */
-} QueuePointers_t;
-
-typedef struct SemaphoreData {
-    TaskHandle_t
-        xMutexHolder; /*< The handle of the task that holds the mutex. */
-    UBaseType_t
-        uxRecursiveCallCount; /*< Maintains a count of the number of times a
-                                 recursive mutex has been recursively 'taken'
-                                 when the structure is used as a mutex. */
-} SemaphoreData_t;
-
-/* Semaphores do not actually store or copy data, so have an item size of
-zero. */
-#define queueSEMAPHORE_QUEUE_ITEM_LENGTH ((UBaseType_t)0)
-#define queueMUTEX_GIVE_BLOCK_TIME ((TickType_t)0U)
-
-#if (configUSE_PREEMPTION == 0)
-/* If the cooperative scheduler is being used then a yield should not be
-performed just because a higher priority task has been woken. */
-#    define queueYIELD_IF_USING_PREEMPTION()
-#else
-#    define queueYIELD_IF_USING_PREEMPTION() portYIELD_WITHIN_API()
-#endif
-
-/*
- * Definition of the queue used by the scheduler.
- * Items are queued by copy, not reference.  See the following link for the
- * rationale: https://www.freertos.org/Embedded-RTOS-Queues.html
- */
-typedef struct QueueDefinition /* The old naming convention is used to prevent
-                                  breaking kernel aware debuggers. */
-{
-    int8_t *pcHead; /*< Points to the beginning of the queue storage area. */
-    int8_t *pcWriteTo; /*< Points to the free next place in the storage area. */
-
-    union {
-        QueuePointers_t xQueue; /*< Data required exclusively when this
-                                   structure is used as a queue. */
-        SemaphoreData_t xSemaphore; /*< Data required exclusively when this
-                                       structure is used as a semaphore. */
-    } u;
-
-    List_t
-        xTasksWaitingToSend; /*< List of tasks that are blocked waiting to post
-                                onto this queue.  Stored in priority order. */
-    List_t xTasksWaitingToReceive; /*< List of tasks that are blocked waiting to
-                                      read from this queue.  Stored in priority
-                                      order. */
-
-    volatile UBaseType_t
-        uxMessagesWaiting; /*< The number of items currently in the queue. */
-    UBaseType_t uxLength; /*< The length of the queue defined as the number of
-                             items it will hold, not the number of bytes. */
-    UBaseType_t
-        uxItemSize; /*< The size of each items that the queue will hold. */
-
-    volatile int8_t
-        cRxLock; /*< Stores the number of items received from the queue (removed
-                    from the queue) while the queue was locked.  Set to
-                    queueUNLOCKED when the queue is not locked. */
-    volatile int8_t
-        cTxLock; /*< Stores the number of items transmitted to the queue (added
-                    to the queue) while the queue was locked.  Set to
-                    queueUNLOCKED when the queue is not locked. */
-
-#if ( \
-    (configSUPPORT_STATIC_ALLOCATION == 1) && \
-    (configSUPPORT_DYNAMIC_ALLOCATION == 1))
-    uint8_t ucStaticallyAllocated; /*< Set to pdTRUE if the memory used by the
-                                      queue was statically allocated to ensure
-                                      no attempt is made to free the memory. */
-#endif
-
-#if (configUSE_QUEUE_SETS == 1)
-    struct QueueDefinition *pxQueueSetContainer;
-#endif
-
-#if (configUSE_TRACE_FACILITY == 1)
-    UBaseType_t uxQueueNumber;
-    uint8_t ucQueueType;
-#endif
-
-} xQUEUE;
-
-/* The old xQUEUE name is maintained above then typedefed to the new Queue_t
-name below to enable the use of older kernel aware debuggers. */
-typedef xQUEUE Queue_t;
-
-/*-----------------------------------------------------------*/
-
-/*
- * The queue registry is just a means for kernel aware debuggers to locate
- * queue structures.  It has no other purpose so is an optional component.
- */
-#if (configQUEUE_REGISTRY_SIZE > 0)
-
-/* The type stored within the queue registry array.  This allows a name
-to be assigned to each queue making kernel aware debugging a little
-more user friendly. */
-typedef struct QUEUE_REGISTRY_ITEM {
-    const char *pcQueueName; /*lint !e971 Unqualified char types are allowed for
-                                strings and single characters only. */
-    QueueHandle_t xHandle;
-} xQueueRegistryItem;
-
-/* The old xQueueRegistryItem name is maintained above then typedefed to the
-new xQueueRegistryItem name below to enable the use of older kernel aware
-debuggers. */
-typedef xQueueRegistryItem QueueRegistryItem_t;
-
-/* The queue registry is simply an array of QueueRegistryItem_t structures.
-The pcQueueName member of a structure being NULL is indicative of the
-array position being vacant. */
-PRIVILEGED_DATA QueueRegistryItem_t xQueueRegistry[configQUEUE_REGISTRY_SIZE];
-
-#endif /* configQUEUE_REGISTRY_SIZE */
-
-/*
- * Unlocks a queue locked by a call to prvLockQueue.  Locking a queue does not
- * prevent an ISR from adding or removing items to the queue, but does prevent
- * an ISR from removing tasks from the queue event lists.  If an ISR finds a
- * queue is locked it will instead increment the appropriate queue lock count
- * to indicate that a task may require unblocking.  When the queue in unlocked
- * these lock counts are inspected, and the appropriate action taken.
- */
-static void prvUnlockQueue(Queue_t *const pxQueue) PRIVILEGED_FUNCTION;
-
-/*
- * Uses a critical section to determine if there is any data in a queue.
- *
- * @return pdTRUE if the queue contains no items, otherwise pdFALSE.
- */
-static BaseType_t prvIsQueueEmpty(const Queue_t *pxQueue) PRIVILEGED_FUNCTION;
-
-/*
- * Uses a critical section to determine if there is any space in a queue.
- *
- * @return pdTRUE if there is no space, otherwise pdFALSE;
- */
-static BaseType_t prvIsQueueFull(const Queue_t *pxQueue) PRIVILEGED_FUNCTION;
-
-/*
- * Copies an item into the queue, either at the front of the queue or the
- * back of the queue.
- */
-static BaseType_t prvCopyDataToQueue(
-    Queue_t *const pxQueue,
-    const void *pvItemToQueue,
-    const BaseType_t xPosition) PRIVILEGED_FUNCTION;
-
-/*
- * Copies an item out of a queue.
- */
-static void prvCopyDataFromQueue(Queue_t *const pxQueue, void *const pvBuffer)
-    PRIVILEGED_FUNCTION;
-
-#if (configUSE_QUEUE_SETS == 1)
-/*
- * Checks to see if a queue is a member of a queue set, and if so, notifies
- * the queue set that the queue contains data.
- */
-static BaseType_t prvNotifyQueueSetContainer(const Queue_t *const pxQueue)
-    PRIVILEGED_FUNCTION;
-#endif
-
-/*
- * Called after a Queue_t structure has been allocated either statically or
- * dynamically to fill in the structure's members.
- */
-static void prvInitialiseNewQueue(
-    const UBaseType_t uxQueueLength,
-    const UBaseType_t uxItemSize,
-    uint8_t *pucQueueStorage,
-    const uint8_t ucQueueType,
-    Queue_t *pxNewQueue) PRIVILEGED_FUNCTION;
-
-/*
- * Mutexes are a special type of queue.  When a mutex is created, first the
- * queue is created, then prvInitialiseMutex() is called to configure the queue
- * as a mutex.
- */
-#if (configUSE_MUTEXES == 1)
-static void prvInitialiseMutex(Queue_t *pxNewQueue) PRIVILEGED_FUNCTION;
-#endif
-
-#if (configUSE_MUTEXES == 1)
-/*
- * If a task waiting for a mutex causes the mutex holder to inherit a
- * priority, but the waiting task times out, then the holder should
- * disinherit the priority - but only down to the highest priority of any
- * other tasks that are waiting for the same mutex.  This function returns
- * that priority.
- */
-static UBaseType_t prvGetDisinheritPriorityAfterTimeout(
-    const Queue_t *const pxQueue) PRIVILEGED_FUNCTION;
-#endif
-/*-----------------------------------------------------------*/
-
-/*
- * Macro to mark a queue as locked.  Locking a queue prevents an ISR from
- * accessing the queue event lists.
- */
-#define prvLockQueue(pxQueue) \
-    taskENTER_CRITICAL(); \
-    { \
-        if ((pxQueue)->cRxLock == queueUNLOCKED) { \
-            (pxQueue)->cRxLock = queueLOCKED_UNMODIFIED; \
-        } \
-        if ((pxQueue)->cTxLock == queueUNLOCKED) { \
-            (pxQueue)->cTxLock = queueLOCKED_UNMODIFIED; \
-        } \
-    } \
-    taskEXIT_CRITICAL()
-/*-----------------------------------------------------------*/
-
-BaseType_t xQueueGenericReset(QueueHandle_t xQueue, BaseType_t xNewQueue)
-{
-    Queue_t *const pxQueue = xQueue;
-
-    configASSERT(pxQueue);
-
-    taskENTER_CRITICAL();
-    {
-        pxQueue->u.xQueue.pcTail = pxQueue->pcHead +
-            (pxQueue->uxLength *
-             pxQueue->uxItemSize); /*lint !e9016 Pointer arithmetic allowed on
-                                      char types, especially when it assists
-                                      conveying intent. */
-        pxQueue->uxMessagesWaiting = (UBaseType_t)0U;
-        pxQueue->pcWriteTo = pxQueue->pcHead;
-        pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead +
-            ((pxQueue->uxLength - 1U) *
-             pxQueue->uxItemSize); /*lint !e9016 Pointer arithmetic allowed on
-                                      char types, especially when it assists
-                                      conveying intent. */
-        pxQueue->cRxLock = queueUNLOCKED;
-        pxQueue->cTxLock = queueUNLOCKED;
-
-        if (xNewQueue == pdFALSE) {
-            /* If there are tasks blocked waiting to read from the queue, then
-            the tasks will remain blocked as after this function exits the queue
-            will still be empty.  If there are tasks blocked waiting to write to
-            the queue, then one should be unblocked as after this function exits
-            it will be possible to write to it. */
-            if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToSend)) == pdFALSE) {
-                if (xTaskRemoveFromEventList(&(pxQueue->xTasksWaitingToSend)) !=
-                    pdFALSE) {
-                    queueYIELD_IF_USING_PREEMPTION();
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            /* Ensure the event queues start in the correct state. */
-            vListInitialise(&(pxQueue->xTasksWaitingToSend));
-            vListInitialise(&(pxQueue->xTasksWaitingToReceive));
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    /* A value is returned for calling semantic consistency with previous
-    versions. */
-    return pdPASS;
-}
-/*-----------------------------------------------------------*/
-
-#if (configSUPPORT_STATIC_ALLOCATION == 1)
-
-QueueHandle_t xQueueGenericCreateStatic(
-    const UBaseType_t uxQueueLength,
-    const UBaseType_t uxItemSize,
-    uint8_t *pucQueueStorage,
-    StaticQueue_t *pxStaticQueue,
-    const uint8_t ucQueueType)
-{
-    Queue_t *pxNewQueue;
-
-    configASSERT(uxQueueLength > (UBaseType_t)0);
-
-    /* The StaticQueue_t structure and the queue storage area must be
-    supplied. */
-    configASSERT(pxStaticQueue != NULL);
-
-    /* A queue storage area should be provided if the item size is not 0, and
-    should not be provided if the item size is 0. */
-    configASSERT(!((pucQueueStorage != NULL) && (uxItemSize == 0)));
-    configASSERT(!((pucQueueStorage == NULL) && (uxItemSize != 0)));
-
-#    if (configASSERT_DEFINED == 1)
-    {
-        /* Sanity check that the size of the structure used to declare a
-        variable of type StaticQueue_t or StaticSemaphore_t equals the size of
-        the real queue and semaphore structures. */
-        volatile size_t xSize = sizeof(StaticQueue_t);
-        configASSERT(xSize == sizeof(Queue_t));
-        (void)xSize; /* Keeps lint quiet when configASSERT() is not defined. */
-    }
-#    endif /* configASSERT_DEFINED */
-
-    /* The address of a statically allocated queue was passed in, use it.
-    The address of a statically allocated storage area was also passed in
-    but is already set. */
-    pxNewQueue = (Queue_t *)
-        pxStaticQueue; /*lint !e740 !e9087 Unusual cast is ok as the structures
-                          are designed to have the same alignment, and the size
-                          is checked by an assert. */
-
-    if (pxNewQueue != NULL) {
-#    if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
-        {
-            /* Queues can be allocated wither statically or dynamically, so
-            note this queue was allocated statically in case the queue is
-            later deleted. */
-            pxNewQueue->ucStaticallyAllocated = pdTRUE;
-        }
-#    endif /* configSUPPORT_DYNAMIC_ALLOCATION */
-
-        prvInitialiseNewQueue(
-            uxQueueLength,
-            uxItemSize,
-            pucQueueStorage,
-            ucQueueType,
-            pxNewQueue);
-    } else {
-        traceQUEUE_CREATE_FAILED(ucQueueType);
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    return pxNewQueue;
-}
-
-#endif /* configSUPPORT_STATIC_ALLOCATION */
-/*-----------------------------------------------------------*/
-
-#if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
-
-QueueHandle_t xQueueGenericCreate(
-    const UBaseType_t uxQueueLength,
-    const UBaseType_t uxItemSize,
-    const uint8_t ucQueueType)
-{
-    Queue_t *pxNewQueue;
-    size_t xQueueSizeInBytes;
-    uint8_t *pucQueueStorage;
-
-    configASSERT(uxQueueLength > (UBaseType_t)0);
-
-    /* Allocate enough space to hold the maximum number of items that
-    can be in the queue at any time.  It is valid for uxItemSize to be
-    zero in the case the queue is used as a semaphore. */
-    xQueueSizeInBytes = (size_t)(
-        uxQueueLength * uxItemSize); /*lint !e961 MISRA exception as the casts
-                                        are only redundant for some ports. */
-
-    /* Allocate the queue and storage area.  Justification for MISRA
-    deviation as follows:  pvPortMalloc() always ensures returned memory
-    blocks are aligned per the requirements of the MCU stack.  In this case
-    pvPortMalloc() must return a pointer that is guaranteed to meet the
-    alignment requirements of the Queue_t structure - which in this case
-    is an int8_t *.  Therefore, whenever the stack alignment requirements
-    are greater than or equal to the pointer to char requirements the cast
-    is safe.  In other cases alignment requirements are not strict (one or
-    two bytes). */
-    pxNewQueue = (Queue_t *)pvPortMalloc(
-        sizeof(Queue_t) +
-        xQueueSizeInBytes); /*lint !e9087 !e9079 see comment above. */
-
-    if (pxNewQueue != NULL) {
-        /* Jump past the queue structure to find the location of the queue
-        storage area. */
-        pucQueueStorage = (uint8_t *)pxNewQueue;
-        pucQueueStorage += sizeof(
-            Queue_t); /*lint !e9016 Pointer arithmetic allowed on char types,
-                         especially when it assists conveying intent. */
-
-#    if (configSUPPORT_STATIC_ALLOCATION == 1)
-        {
-            /* Queues can be created either statically or dynamically, so
-            note this task was created dynamically in case it is later
-            deleted. */
-            pxNewQueue->ucStaticallyAllocated = pdFALSE;
-        }
-#    endif /* configSUPPORT_STATIC_ALLOCATION */
-
-        prvInitialiseNewQueue(
-            uxQueueLength,
-            uxItemSize,
-            pucQueueStorage,
-            ucQueueType,
-            pxNewQueue);
-    } else {
-        traceQUEUE_CREATE_FAILED(ucQueueType);
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    return pxNewQueue;
-}
-
-#endif /* configSUPPORT_STATIC_ALLOCATION */
-/*-----------------------------------------------------------*/
-
-static void prvInitialiseNewQueue(
-    const UBaseType_t uxQueueLength,
-    const UBaseType_t uxItemSize,
-    uint8_t *pucQueueStorage,
-    const uint8_t ucQueueType,
-    Queue_t *pxNewQueue)
-{
-    /* Remove compiler warnings about unused parameters should
-    configUSE_TRACE_FACILITY not be set to 1. */
-    (void)ucQueueType;
-
-    if (uxItemSize == (UBaseType_t)0) {
-        /* No RAM was allocated for the queue storage area, but PC head cannot
-        be set to NULL because NULL is used as a key to say the queue is used as
-        a mutex.  Therefore just set pcHead to point to the queue as a benign
-        value that is known to be within the memory map. */
-        pxNewQueue->pcHead = (int8_t *)pxNewQueue;
-    } else {
-        /* Set the head to the start of the queue storage area. */
-        pxNewQueue->pcHead = (int8_t *)pucQueueStorage;
-    }
-
-    /* Initialise the queue members as described where the queue type is
-    defined. */
-    pxNewQueue->uxLength = uxQueueLength;
-    pxNewQueue->uxItemSize = uxItemSize;
-    (void)xQueueGenericReset(pxNewQueue, pdTRUE);
-
-#if (configUSE_TRACE_FACILITY == 1)
-    {
-        pxNewQueue->ucQueueType = ucQueueType;
-    }
-#endif /* configUSE_TRACE_FACILITY */
-
-#if (configUSE_QUEUE_SETS == 1)
-    {
-        pxNewQueue->pxQueueSetContainer = NULL;
-    }
-#endif /* configUSE_QUEUE_SETS */
-
-    traceQUEUE_CREATE(pxNewQueue);
-}
-/*-----------------------------------------------------------*/
-
-#if (configUSE_MUTEXES == 1)
-
-static void prvInitialiseMutex(Queue_t *pxNewQueue)
-{
-    if (pxNewQueue != NULL) {
-        /* The queue create function will set all the queue structure members
-        correctly for a generic queue, but this function is creating a
-        mutex.  Overwrite those members that need to be set differently -
-        in particular the information required for priority inheritance. */
-        pxNewQueue->u.xSemaphore.xMutexHolder = NULL;
-        pxNewQueue->uxQueueType = queueQUEUE_IS_MUTEX;
-
-        /* In case this is a recursive mutex. */
-        pxNewQueue->u.xSemaphore.uxRecursiveCallCount = 0;
-
-        traceCREATE_MUTEX(pxNewQueue);
-
-        /* Start with the semaphore in the expected state. */
-        (void)xQueueGenericSend(
-            pxNewQueue, NULL, (TickType_t)0U, queueSEND_TO_BACK);
-    } else {
-        traceCREATE_MUTEX_FAILED();
-    }
-}
-
-#endif /* configUSE_MUTEXES */
-/*-----------------------------------------------------------*/
-
-#if ((configUSE_MUTEXES == 1) && (configSUPPORT_DYNAMIC_ALLOCATION == 1))
-
-QueueHandle_t xQueueCreateMutex(const uint8_t ucQueueType)
-{
-    QueueHandle_t xNewQueue;
-    const UBaseType_t uxMutexLength = (UBaseType_t)1,
-                      uxMutexSize = (UBaseType_t)0;
-
-    xNewQueue = xQueueGenericCreate(uxMutexLength, uxMutexSize, ucQueueType);
-    prvInitialiseMutex((Queue_t *)xNewQueue);
-
-    return xNewQueue;
-}
-
-#endif /* configUSE_MUTEXES */
-/*-----------------------------------------------------------*/
-
-#if ((configUSE_MUTEXES == 1) && (configSUPPORT_STATIC_ALLOCATION == 1))
-
-QueueHandle_t xQueueCreateMutexStatic(
-    const uint8_t ucQueueType,
-    StaticQueue_t *pxStaticQueue)
-{
-    QueueHandle_t xNewQueue;
-    const UBaseType_t uxMutexLength = (UBaseType_t)1,
-                      uxMutexSize = (UBaseType_t)0;
-
-    /* Prevent compiler warnings about unused parameters if
-    configUSE_TRACE_FACILITY does not equal 1. */
-    (void)ucQueueType;
-
-    xNewQueue = xQueueGenericCreateStatic(
-        uxMutexLength, uxMutexSize, NULL, pxStaticQueue, ucQueueType);
-    prvInitialiseMutex((Queue_t *)xNewQueue);
-
-    return xNewQueue;
-}
-
-#endif /* configUSE_MUTEXES */
-/*-----------------------------------------------------------*/
-
-#if ((configUSE_MUTEXES == 1) && (INCLUDE_xSemaphoreGetMutexHolder == 1))
-
-TaskHandle_t xQueueGetMutexHolder(QueueHandle_t xSemaphore)
-{
-    TaskHandle_t pxReturn;
-    Queue_t *const pxSemaphore = (Queue_t *)xSemaphore;
-
-    /* This function is called by xSemaphoreGetMutexHolder(), and should not
-    be called directly.  Note:  This is a good way of determining if the
-    calling task is the mutex holder, but not a good way of determining the
-    identity of the mutex holder, as the holder may change between the
-    following critical section exiting and the function returning. */
-    taskENTER_CRITICAL();
-    {
-        if (pxSemaphore->uxQueueType == queueQUEUE_IS_MUTEX) {
-            pxReturn = pxSemaphore->u.xSemaphore.xMutexHolder;
-        } else {
-            pxReturn = NULL;
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    return pxReturn;
-} /*lint !e818 xSemaphore cannot be a pointer to const because it is a typedef.
-   */
-
-#endif
-/*-----------------------------------------------------------*/
-
-#if ((configUSE_MUTEXES == 1) && (INCLUDE_xSemaphoreGetMutexHolder == 1))
-
-TaskHandle_t xQueueGetMutexHolderFromISR(QueueHandle_t xSemaphore)
-{
-    TaskHandle_t pxReturn;
-
-    configASSERT(xSemaphore);
-
-    /* Mutexes cannot be used in interrupt service routines, so the mutex
-    holder should not change in an ISR, and therefore a critical section is
-    not required here. */
-    if (((Queue_t *)xSemaphore)->uxQueueType == queueQUEUE_IS_MUTEX) {
-        pxReturn = ((Queue_t *)xSemaphore)->u.xSemaphore.xMutexHolder;
-    } else {
-        pxReturn = NULL;
-    }
-
-    return pxReturn;
-} /*lint !e818 xSemaphore cannot be a pointer to const because it is a typedef.
-   */
-
-#endif
-/*-----------------------------------------------------------*/
-
-#if (configUSE_RECURSIVE_MUTEXES == 1)
-
-BaseType_t xQueueGiveMutexRecursive(QueueHandle_t xMutex)
-{
-    BaseType_t xReturn;
-    Queue_t *const pxMutex = (Queue_t *)xMutex;
-
-    configASSERT(pxMutex);
-
-    /* If this is the task that holds the mutex then xMutexHolder will not
-    change outside of this task.  If this task does not hold the mutex then
-    pxMutexHolder can never coincidentally equal the tasks handle, and as
-    this is the only condition we are interested in it does not matter if
-    pxMutexHolder is accessed simultaneously by another task.  Therefore no
-    mutual exclusion is required to test the pxMutexHolder variable. */
-    if (pxMutex->u.xSemaphore.xMutexHolder == xTaskGetCurrentTaskHandle()) {
-        traceGIVE_MUTEX_RECURSIVE(pxMutex);
-
-        /* uxRecursiveCallCount cannot be zero if xMutexHolder is equal to
-        the task handle, therefore no underflow check is required.  Also,
-        uxRecursiveCallCount is only modified by the mutex holder, and as
-        there can only be one, no mutual exclusion is required to modify the
-        uxRecursiveCallCount member. */
-        (pxMutex->u.xSemaphore.uxRecursiveCallCount)--;
-
-        /* Has the recursive call count unwound to 0? */
-        if (pxMutex->u.xSemaphore.uxRecursiveCallCount == (UBaseType_t)0) {
-            /* Return the mutex.  This will automatically unblock any other
-            task that might be waiting to access the mutex. */
-            (void)xQueueGenericSend(
-                pxMutex, NULL, queueMUTEX_GIVE_BLOCK_TIME, queueSEND_TO_BACK);
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-
-        xReturn = pdPASS;
-    } else {
-        /* The mutex cannot be given because the calling task is not the
-        holder. */
-        xReturn = pdFAIL;
-
-        traceGIVE_MUTEX_RECURSIVE_FAILED(pxMutex);
-    }
-
-    return xReturn;
-}
-
-#endif /* configUSE_RECURSIVE_MUTEXES */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_RECURSIVE_MUTEXES == 1)
-
-BaseType_t xQueueTakeMutexRecursive(
-    QueueHandle_t xMutex,
-    TickType_t xTicksToWait)
-{
-    BaseType_t xReturn;
-    Queue_t *const pxMutex = (Queue_t *)xMutex;
-
-    configASSERT(pxMutex);
-
-    /* Comments regarding mutual exclusion as per those within
-    xQueueGiveMutexRecursive(). */
-
-    traceTAKE_MUTEX_RECURSIVE(pxMutex);
-
-    if (pxMutex->u.xSemaphore.xMutexHolder == xTaskGetCurrentTaskHandle()) {
-        (pxMutex->u.xSemaphore.uxRecursiveCallCount)++;
-        xReturn = pdPASS;
-    } else {
-        xReturn = xQueueSemaphoreTake(pxMutex, xTicksToWait);
-
-        /* pdPASS will only be returned if the mutex was successfully
-        obtained.  The calling task may have entered the Blocked state
-        before reaching here. */
-        if (xReturn != pdFAIL) {
-            (pxMutex->u.xSemaphore.uxRecursiveCallCount)++;
-        } else {
-            traceTAKE_MUTEX_RECURSIVE_FAILED(pxMutex);
-        }
-    }
-
-    return xReturn;
-}
-
-#endif /* configUSE_RECURSIVE_MUTEXES */
-/*-----------------------------------------------------------*/
-
-#if ( \
-    (configUSE_COUNTING_SEMAPHORES == 1) && \
-    (configSUPPORT_STATIC_ALLOCATION == 1))
-
-QueueHandle_t xQueueCreateCountingSemaphoreStatic(
-    const UBaseType_t uxMaxCount,
-    const UBaseType_t uxInitialCount,
-    StaticQueue_t *pxStaticQueue)
-{
-    QueueHandle_t xHandle;
-
-    configASSERT(uxMaxCount != 0);
-    configASSERT(uxInitialCount <= uxMaxCount);
-
-    xHandle = xQueueGenericCreateStatic(
-        uxMaxCount,
-        queueSEMAPHORE_QUEUE_ITEM_LENGTH,
-        NULL,
-        pxStaticQueue,
-        queueQUEUE_TYPE_COUNTING_SEMAPHORE);
-
-    if (xHandle != NULL) {
-        ((Queue_t *)xHandle)->uxMessagesWaiting = uxInitialCount;
-
-        traceCREATE_COUNTING_SEMAPHORE();
-    } else {
-        traceCREATE_COUNTING_SEMAPHORE_FAILED();
-    }
-
-    return xHandle;
-}
-
-#endif /* ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( \
-          configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
-/*-----------------------------------------------------------*/
-
-#if ( \
-    (configUSE_COUNTING_SEMAPHORES == 1) && \
-    (configSUPPORT_DYNAMIC_ALLOCATION == 1))
-
-QueueHandle_t xQueueCreateCountingSemaphore(
-    const UBaseType_t uxMaxCount,
-    const UBaseType_t uxInitialCount)
-{
-    QueueHandle_t xHandle;
-
-    configASSERT(uxMaxCount != 0);
-    configASSERT(uxInitialCount <= uxMaxCount);
-
-    xHandle = xQueueGenericCreate(
-        uxMaxCount,
-        queueSEMAPHORE_QUEUE_ITEM_LENGTH,
-        queueQUEUE_TYPE_COUNTING_SEMAPHORE);
-
-    if (xHandle != NULL) {
-        ((Queue_t *)xHandle)->uxMessagesWaiting = uxInitialCount;
-
-        traceCREATE_COUNTING_SEMAPHORE();
-    } else {
-        traceCREATE_COUNTING_SEMAPHORE_FAILED();
-    }
-
-    return xHandle;
-}
-
-#endif /* ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( \
-          configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
-/*-----------------------------------------------------------*/
-
-BaseType_t xQueueGenericSend(
-    QueueHandle_t xQueue,
-    const void *const pvItemToQueue,
-    TickType_t xTicksToWait,
-    const BaseType_t xCopyPosition)
-{
-    BaseType_t xEntryTimeSet = pdFALSE, xYieldRequired;
-    TimeOut_t xTimeOut;
-    Queue_t *const pxQueue = xQueue;
-
-    configASSERT(pxQueue);
-    configASSERT(
-        !((pvItemToQueue == NULL) && (pxQueue->uxItemSize != (UBaseType_t)0U)));
-    configASSERT(
-        !((xCopyPosition == queueOVERWRITE) && (pxQueue->uxLength != 1)));
-#if ((INCLUDE_xTaskGetSchedulerState == 1) || (configUSE_TIMERS == 1))
-    {
-        configASSERT(
-            !((xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED) &&
-              (xTicksToWait != 0)));
-    }
-#endif
-
-    /*lint -save -e904 This function relaxes the coding standard somewhat to
-    allow return statements within the function itself.  This is done in the
-    interest of execution time efficiency. */
-    for (;;) {
-        taskENTER_CRITICAL();
-        {
-            /* Is there room on the queue now?  The running task must be the
-            highest priority task wanting to access the queue.  If the head item
-            in the queue is to be overwritten then it does not matter if the
-            queue is full. */
-            if ((pxQueue->uxMessagesWaiting < pxQueue->uxLength) ||
-                (xCopyPosition == queueOVERWRITE)) {
-                traceQUEUE_SEND(pxQueue);
-
-#if (configUSE_QUEUE_SETS == 1)
-                {
-                    const UBaseType_t uxPreviousMessagesWaiting =
-                        pxQueue->uxMessagesWaiting;
-
-                    xYieldRequired = prvCopyDataToQueue(
-                        pxQueue, pvItemToQueue, xCopyPosition);
-
-                    if (pxQueue->pxQueueSetContainer != NULL) {
-                        if ((xCopyPosition == queueOVERWRITE) &&
-                            (uxPreviousMessagesWaiting != (UBaseType_t)0)) {
-                            /* Do not notify the queue set as an existing item
-                            was overwritten in the queue so the number of items
-                            in the queue has not changed. */
-                            mtCOVERAGE_TEST_MARKER();
-                        } else if (
-                            prvNotifyQueueSetContainer(pxQueue) != pdFALSE) {
-                            /* The queue is a member of a queue set, and posting
-                            to the queue set caused a higher priority task to
-                            unblock. A context switch is required. */
-                            queueYIELD_IF_USING_PREEMPTION();
-                        } else {
-                            mtCOVERAGE_TEST_MARKER();
-                        }
-                    } else {
-                        /* If there was a task waiting for data to arrive on the
-                        queue then unblock it now. */
-                        if (listLIST_IS_EMPTY(&(
-                                pxQueue->xTasksWaitingToReceive)) == pdFALSE) {
-                            if (xTaskRemoveFromEventList(
-                                    &(pxQueue->xTasksWaitingToReceive)) !=
-                                pdFALSE) {
-                                /* The unblocked task has a priority higher than
-                                our own so yield immediately.  Yes it is ok to
-                                do this from within the critical section - the
-                                kernel takes care of that. */
-                                queueYIELD_IF_USING_PREEMPTION();
-                            } else {
-                                mtCOVERAGE_TEST_MARKER();
-                            }
-                        } else if (xYieldRequired != pdFALSE) {
-                            /* This path is a special case that will only get
-                            executed if the task was holding multiple mutexes
-                            and the mutexes were given back in an order that is
-                            different to that in which they were taken. */
-                            queueYIELD_IF_USING_PREEMPTION();
-                        } else {
-                            mtCOVERAGE_TEST_MARKER();
-                        }
-                    }
-                }
-#else /* configUSE_QUEUE_SETS */
-                {
-                    xYieldRequired = prvCopyDataToQueue(
-                        pxQueue, pvItemToQueue, xCopyPosition);
-
-                    /* If there was a task waiting for data to arrive on the
-                    queue then unblock it now. */
-                    if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive)) ==
-                        pdFALSE) {
-                        if (xTaskRemoveFromEventList(&(
-                                pxQueue->xTasksWaitingToReceive)) != pdFALSE) {
-                            /* The unblocked task has a priority higher than
-                            our own so yield immediately.  Yes it is ok to do
-                            this from within the critical section - the kernel
-                            takes care of that. */
-                            queueYIELD_IF_USING_PREEMPTION();
-                        } else {
-                            mtCOVERAGE_TEST_MARKER();
-                        }
-                    } else if (xYieldRequired != pdFALSE) {
-                        /* This path is a special case that will only get
-                        executed if the task was holding multiple mutexes and
-                        the mutexes were given back in an order that is
-                        different to that in which they were taken. */
-                        queueYIELD_IF_USING_PREEMPTION();
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                }
-#endif /* configUSE_QUEUE_SETS */
-
-                taskEXIT_CRITICAL();
-                return pdPASS;
-            } else {
-                if (xTicksToWait == (TickType_t)0) {
-                    /* The queue was full and no block time is specified (or
-                    the block time has expired) so leave now. */
-                    taskEXIT_CRITICAL();
-
-                    /* Return to the original privilege level before exiting
-                    the function. */
-                    traceQUEUE_SEND_FAILED(pxQueue);
-                    return errQUEUE_FULL;
-                } else if (xEntryTimeSet == pdFALSE) {
-                    /* The queue was full and a block time was specified so
-                    configure the timeout structure. */
-                    vTaskInternalSetTimeOutState(&xTimeOut);
-                    xEntryTimeSet = pdTRUE;
-                } else {
-                    /* Entry time was already set. */
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            }
-        }
-        taskEXIT_CRITICAL();
-
-        /* Interrupts and other tasks can send to and receive from the queue
-        now the critical section has been exited. */
-
-        vTaskSuspendAll();
-        prvLockQueue(pxQueue);
-
-        /* Update the timeout state to see if it has expired yet. */
-        if (xTaskCheckForTimeOut(&xTimeOut, &xTicksToWait) == pdFALSE) {
-            if (prvIsQueueFull(pxQueue) != pdFALSE) {
-                traceBLOCKING_ON_QUEUE_SEND(pxQueue);
-                vTaskPlaceOnEventList(
-                    &(pxQueue->xTasksWaitingToSend), xTicksToWait);
-
-                /* Unlocking the queue means queue events can effect the
-                event list.  It is possible that interrupts occurring now
-                remove this task from the event list again - but as the
-                scheduler is suspended the task will go onto the pending
-                ready last instead of the actual ready list. */
-                prvUnlockQueue(pxQueue);
-
-                /* Resuming the scheduler will move tasks from the pending
-                ready list into the ready list - so it is feasible that this
-                task is already in a ready list before it yields - in which
-                case the yield will not cause a context switch unless there
-                is also a higher priority task in the pending ready list. */
-                if (xTaskResumeAll() == pdFALSE) {
-                    portYIELD_WITHIN_API();
-                }
-            } else {
-                /* Try again. */
-                prvUnlockQueue(pxQueue);
-                (void)xTaskResumeAll();
-            }
-        } else {
-            /* The timeout has expired. */
-            prvUnlockQueue(pxQueue);
-            (void)xTaskResumeAll();
-
-            traceQUEUE_SEND_FAILED(pxQueue);
-            return errQUEUE_FULL;
-        }
-    } /*lint -restore */
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xQueueGenericSendFromISR(
-    QueueHandle_t xQueue,
-    const void *const pvItemToQueue,
-    BaseType_t *const pxHigherPriorityTaskWoken,
-    const BaseType_t xCopyPosition)
-{
-    BaseType_t xReturn;
-    UBaseType_t uxSavedInterruptStatus;
-    Queue_t *const pxQueue = xQueue;
-
-    configASSERT(pxQueue);
-    configASSERT(
-        !((pvItemToQueue == NULL) && (pxQueue->uxItemSize != (UBaseType_t)0U)));
-    configASSERT(
-        !((xCopyPosition == queueOVERWRITE) && (pxQueue->uxLength != 1)));
-
-    /* RTOS ports that support interrupt nesting have the concept of a maximum
-    system call (or maximum API call) interrupt priority.  Interrupts that are
-    above the maximum system call priority are kept permanently enabled, even
-    when the RTOS kernel is in a critical section, but cannot make any calls to
-    FreeRTOS API functions.  If configASSERT() is defined in FreeRTOSConfig.h
-    then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
-    failure if a FreeRTOS API function is called from an interrupt that has been
-    assigned a priority above the configured maximum system call priority.
-    Only FreeRTOS functions that end in FromISR can be called from interrupts
-    that have been assigned a priority at or (logically) below the maximum
-    system call	interrupt priority.  FreeRTOS maintains a separate interrupt
-    safe API to ensure interrupt entry is as fast and as simple as possible.
-    More information (albeit Cortex-M specific) is provided on the following
-    link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
-
-    /* Similar to xQueueGenericSend, except without blocking if there is no room
-    in the queue.  Also don't directly wake a task that was blocked on a queue
-    read, instead return a flag to say whether a context switch is required or
-    not (i.e. has a task with a higher priority than us been woken by this
-    post). */
-    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
-    {
-        if ((pxQueue->uxMessagesWaiting < pxQueue->uxLength) ||
-            (xCopyPosition == queueOVERWRITE)) {
-            const int8_t cTxLock = pxQueue->cTxLock;
-            const UBaseType_t uxPreviousMessagesWaiting =
-                pxQueue->uxMessagesWaiting;
-
-            traceQUEUE_SEND_FROM_ISR(pxQueue);
-
-            /* Semaphores use xQueueGiveFromISR(), so pxQueue will not be a
-            semaphore or mutex.  That means prvCopyDataToQueue() cannot result
-            in a task disinheriting a priority and prvCopyDataToQueue() can be
-            called here even though the disinherit function does not check if
-            the scheduler is suspended before accessing the ready lists. */
-            (void)prvCopyDataToQueue(pxQueue, pvItemToQueue, xCopyPosition);
-
-            /* The event list is not altered if the queue is locked.  This will
-            be done when the queue is unlocked later. */
-            if (cTxLock == queueUNLOCKED) {
-#if (configUSE_QUEUE_SETS == 1)
-                {
-                    if (pxQueue->pxQueueSetContainer != NULL) {
-                        if ((xCopyPosition == queueOVERWRITE) &&
-                            (uxPreviousMessagesWaiting != (UBaseType_t)0)) {
-                            /* Do not notify the queue set as an existing item
-                            was overwritten in the queue so the number of items
-                            in the queue has not changed. */
-                            mtCOVERAGE_TEST_MARKER();
-                        } else if (
-                            prvNotifyQueueSetContainer(pxQueue) != pdFALSE) {
-                            /* The queue is a member of a queue set, and posting
-                            to the queue set caused a higher priority task to
-                            unblock.  A context switch is required. */
-                            if (pxHigherPriorityTaskWoken != NULL) {
-                                *pxHigherPriorityTaskWoken = pdTRUE;
-                            } else {
-                                mtCOVERAGE_TEST_MARKER();
-                            }
-                        } else {
-                            mtCOVERAGE_TEST_MARKER();
-                        }
-                    } else {
-                        if (listLIST_IS_EMPTY(&(
-                                pxQueue->xTasksWaitingToReceive)) == pdFALSE) {
-                            if (xTaskRemoveFromEventList(
-                                    &(pxQueue->xTasksWaitingToReceive)) !=
-                                pdFALSE) {
-                                /* The task waiting has a higher priority so
-                                record that a context switch is required. */
-                                if (pxHigherPriorityTaskWoken != NULL) {
-                                    *pxHigherPriorityTaskWoken = pdTRUE;
-                                } else {
-                                    mtCOVERAGE_TEST_MARKER();
-                                }
-                            } else {
-                                mtCOVERAGE_TEST_MARKER();
-                            }
-                        } else {
-                            mtCOVERAGE_TEST_MARKER();
-                        }
-                    }
-                }
-#else /* configUSE_QUEUE_SETS */
-                {
-                    if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive)) ==
-                        pdFALSE) {
-                        if (xTaskRemoveFromEventList(&(
-                                pxQueue->xTasksWaitingToReceive)) != pdFALSE) {
-                            /* The task waiting has a higher priority so record
-                            that a context	switch is required. */
-                            if (pxHigherPriorityTaskWoken != NULL) {
-                                *pxHigherPriorityTaskWoken = pdTRUE;
-                            } else {
-                                mtCOVERAGE_TEST_MARKER();
-                            }
-                        } else {
-                            mtCOVERAGE_TEST_MARKER();
-                        }
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-
-                    /* Not used in this path. */
-                    (void)uxPreviousMessagesWaiting;
-                }
-#endif /* configUSE_QUEUE_SETS */
-            } else {
-                /* Increment the lock count so the task that unlocks the queue
-                knows that data was posted while it was locked. */
-                pxQueue->cTxLock = (int8_t)(cTxLock + 1);
-            }
-
-            xReturn = pdPASS;
-        } else {
-            traceQUEUE_SEND_FROM_ISR_FAILED(pxQueue);
-            xReturn = errQUEUE_FULL;
-        }
-    }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus);
-
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xQueueGiveFromISR(
-    QueueHandle_t xQueue,
-    BaseType_t *const pxHigherPriorityTaskWoken)
-{
-    BaseType_t xReturn;
-    UBaseType_t uxSavedInterruptStatus;
-    Queue_t *const pxQueue = xQueue;
-
-    /* Similar to xQueueGenericSendFromISR() but used with semaphores where the
-    item size is 0.  Don't directly wake a task that was blocked on a queue
-    read, instead return a flag to say whether a context switch is required or
-    not (i.e. has a task with a higher priority than us been woken by this
-    post). */
-
-    configASSERT(pxQueue);
-
-    /* xQueueGenericSendFromISR() should be used instead of xQueueGiveFromISR()
-    if the item size is not 0. */
-    configASSERT(pxQueue->uxItemSize == 0);
-
-    /* Normally a mutex would not be given from an interrupt, especially if
-    there is a mutex holder, as priority inheritance makes no sense for an
-    interrupts, only tasks. */
-    configASSERT(
-        !((pxQueue->uxQueueType == queueQUEUE_IS_MUTEX) &&
-          (pxQueue->u.xSemaphore.xMutexHolder != NULL)));
-
-    /* RTOS ports that support interrupt nesting have the concept of a maximum
-    system call (or maximum API call) interrupt priority.  Interrupts that are
-    above the maximum system call priority are kept permanently enabled, even
-    when the RTOS kernel is in a critical section, but cannot make any calls to
-    FreeRTOS API functions.  If configASSERT() is defined in FreeRTOSConfig.h
-    then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
-    failure if a FreeRTOS API function is called from an interrupt that has been
-    assigned a priority above the configured maximum system call priority.
-    Only FreeRTOS functions that end in FromISR can be called from interrupts
-    that have been assigned a priority at or (logically) below the maximum
-    system call	interrupt priority.  FreeRTOS maintains a separate interrupt
-    safe API to ensure interrupt entry is as fast and as simple as possible.
-    More information (albeit Cortex-M specific) is provided on the following
-    link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
-
-    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
-    {
-        const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;
-
-        /* When the queue is used to implement a semaphore no data is ever
-        moved through the queue but it is still valid to see if the queue 'has
-        space'. */
-        if (uxMessagesWaiting < pxQueue->uxLength) {
-            const int8_t cTxLock = pxQueue->cTxLock;
-
-            traceQUEUE_SEND_FROM_ISR(pxQueue);
-
-            /* A task can only have an inherited priority if it is a mutex
-            holder - and if there is a mutex holder then the mutex cannot be
-            given from an ISR.  As this is the ISR version of the function it
-            can be assumed there is no mutex holder and no need to determine if
-            priority disinheritance is needed.  Simply increase the count of
-            messages (semaphores) available. */
-            pxQueue->uxMessagesWaiting = uxMessagesWaiting + (UBaseType_t)1;
-
-            /* The event list is not altered if the queue is locked.  This will
-            be done when the queue is unlocked later. */
-            if (cTxLock == queueUNLOCKED) {
-#if (configUSE_QUEUE_SETS == 1)
-                {
-                    if (pxQueue->pxQueueSetContainer != NULL) {
-                        if (prvNotifyQueueSetContainer(pxQueue) != pdFALSE) {
-                            /* The semaphore is a member of a queue set, and
-                            posting	to the queue set caused a higher priority
-                            task to	unblock.  A context switch is required. */
-                            if (pxHigherPriorityTaskWoken != NULL) {
-                                *pxHigherPriorityTaskWoken = pdTRUE;
-                            } else {
-                                mtCOVERAGE_TEST_MARKER();
-                            }
-                        } else {
-                            mtCOVERAGE_TEST_MARKER();
-                        }
-                    } else {
-                        if (listLIST_IS_EMPTY(&(
-                                pxQueue->xTasksWaitingToReceive)) == pdFALSE) {
-                            if (xTaskRemoveFromEventList(
-                                    &(pxQueue->xTasksWaitingToReceive)) !=
-                                pdFALSE) {
-                                /* The task waiting has a higher priority so
-                                record that a context switch is required. */
-                                if (pxHigherPriorityTaskWoken != NULL) {
-                                    *pxHigherPriorityTaskWoken = pdTRUE;
-                                } else {
-                                    mtCOVERAGE_TEST_MARKER();
-                                }
-                            } else {
-                                mtCOVERAGE_TEST_MARKER();
-                            }
-                        } else {
-                            mtCOVERAGE_TEST_MARKER();
-                        }
-                    }
-                }
-#else /* configUSE_QUEUE_SETS */
-                {
-                    if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive)) ==
-                        pdFALSE) {
-                        if (xTaskRemoveFromEventList(&(
-                                pxQueue->xTasksWaitingToReceive)) != pdFALSE) {
-                            /* The task waiting has a higher priority so record
-                            that a context	switch is required. */
-                            if (pxHigherPriorityTaskWoken != NULL) {
-                                *pxHigherPriorityTaskWoken = pdTRUE;
-                            } else {
-                                mtCOVERAGE_TEST_MARKER();
-                            }
-                        } else {
-                            mtCOVERAGE_TEST_MARKER();
-                        }
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                }
-#endif /* configUSE_QUEUE_SETS */
-            } else {
-                /* Increment the lock count so the task that unlocks the queue
-                knows that data was posted while it was locked. */
-                pxQueue->cTxLock = (int8_t)(cTxLock + 1);
-            }
-
-            xReturn = pdPASS;
-        } else {
-            traceQUEUE_SEND_FROM_ISR_FAILED(pxQueue);
-            xReturn = errQUEUE_FULL;
-        }
-    }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus);
-
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xQueueReceive(
-    QueueHandle_t xQueue,
-    void *const pvBuffer,
-    TickType_t xTicksToWait)
-{
-    BaseType_t xEntryTimeSet = pdFALSE;
-    TimeOut_t xTimeOut;
-    Queue_t *const pxQueue = xQueue;
-
-    /* Check the pointer is not NULL. */
-    configASSERT((pxQueue));
-
-    /* The buffer into which data is received can only be NULL if the data size
-    is zero (so no data is copied into the buffer. */
-    configASSERT(
-        !(((pvBuffer) == NULL) && ((pxQueue)->uxItemSize != (UBaseType_t)0U)));
-
-/* Cannot block if the scheduler is suspended. */
-#if ((INCLUDE_xTaskGetSchedulerState == 1) || (configUSE_TIMERS == 1))
-    {
-        configASSERT(
-            !((xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED) &&
-              (xTicksToWait != 0)));
-    }
-#endif
-
-    /*lint -save -e904  This function relaxes the coding standard somewhat to
-    allow return statements within the function itself.  This is done in the
-    interest of execution time efficiency. */
-    for (;;) {
-        taskENTER_CRITICAL();
-        {
-            const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;
-
-            /* Is there data in the queue now?  To be running the calling task
-            must be the highest priority task wanting to access the queue. */
-            if (uxMessagesWaiting > (UBaseType_t)0) {
-                /* Data available, remove one item. */
-                prvCopyDataFromQueue(pxQueue, pvBuffer);
-                traceQUEUE_RECEIVE(pxQueue);
-                pxQueue->uxMessagesWaiting = uxMessagesWaiting - (UBaseType_t)1;
-
-                /* There is now space in the queue, were any tasks waiting to
-                post to the queue?  If so, unblock the highest priority waiting
-                task. */
-                if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToSend)) ==
-                    pdFALSE) {
-                    if (xTaskRemoveFromEventList(
-                            &(pxQueue->xTasksWaitingToSend)) != pdFALSE) {
-                        queueYIELD_IF_USING_PREEMPTION();
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-
-                taskEXIT_CRITICAL();
-                return pdPASS;
-            } else {
-                if (xTicksToWait == (TickType_t)0) {
-                    /* The queue was empty and no block time is specified (or
-                    the block time has expired) so leave now. */
-                    taskEXIT_CRITICAL();
-                    traceQUEUE_RECEIVE_FAILED(pxQueue);
-                    return errQUEUE_EMPTY;
-                } else if (xEntryTimeSet == pdFALSE) {
-                    /* The queue was empty and a block time was specified so
-                    configure the timeout structure. */
-                    vTaskInternalSetTimeOutState(&xTimeOut);
-                    xEntryTimeSet = pdTRUE;
-                } else {
-                    /* Entry time was already set. */
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            }
-        }
-        taskEXIT_CRITICAL();
-
-        /* Interrupts and other tasks can send to and receive from the queue
-        now the critical section has been exited. */
-
-        vTaskSuspendAll();
-        prvLockQueue(pxQueue);
-
-        /* Update the timeout state to see if it has expired yet. */
-        if (xTaskCheckForTimeOut(&xTimeOut, &xTicksToWait) == pdFALSE) {
-            /* The timeout has not expired.  If the queue is still empty place
-            the task on the list of tasks waiting to receive from the queue. */
-            if (prvIsQueueEmpty(pxQueue) != pdFALSE) {
-                traceBLOCKING_ON_QUEUE_RECEIVE(pxQueue);
-                vTaskPlaceOnEventList(
-                    &(pxQueue->xTasksWaitingToReceive), xTicksToWait);
-                prvUnlockQueue(pxQueue);
-                if (xTaskResumeAll() == pdFALSE) {
-                    portYIELD_WITHIN_API();
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                /* The queue contains data again.  Loop back to try and read the
-                data. */
-                prvUnlockQueue(pxQueue);
-                (void)xTaskResumeAll();
-            }
-        } else {
-            /* Timed out.  If there is no data in the queue exit, otherwise loop
-            back and attempt to read the data. */
-            prvUnlockQueue(pxQueue);
-            (void)xTaskResumeAll();
-
-            if (prvIsQueueEmpty(pxQueue) != pdFALSE) {
-                traceQUEUE_RECEIVE_FAILED(pxQueue);
-                return errQUEUE_EMPTY;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-    } /*lint -restore */
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xQueueSemaphoreTake(QueueHandle_t xQueue, TickType_t xTicksToWait)
-{
-    BaseType_t xEntryTimeSet = pdFALSE;
-    TimeOut_t xTimeOut;
-    Queue_t *const pxQueue = xQueue;
-
-#if (configUSE_MUTEXES == 1)
-    BaseType_t xInheritanceOccurred = pdFALSE;
-#endif
-
-    /* Check the queue pointer is not NULL. */
-    configASSERT((pxQueue));
-
-    /* Check this really is a semaphore, in which case the item size will be
-    0. */
-    configASSERT(pxQueue->uxItemSize == 0);
-
-/* Cannot block if the scheduler is suspended. */
-#if ((INCLUDE_xTaskGetSchedulerState == 1) || (configUSE_TIMERS == 1))
-    {
-        configASSERT(
-            !((xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED) &&
-              (xTicksToWait != 0)));
-    }
-#endif
-
-    /*lint -save -e904 This function relaxes the coding standard somewhat to
-    allow return statements within the function itself.  This is done in the
-    interest of execution time efficiency. */
-    for (;;) {
-        taskENTER_CRITICAL();
-        {
-            /* Semaphores are queues with an item size of 0, and where the
-            number of messages in the queue is the semaphore's count value. */
-            const UBaseType_t uxSemaphoreCount = pxQueue->uxMessagesWaiting;
-
-            /* Is there data in the queue now?  To be running the calling task
-            must be the highest priority task wanting to access the queue. */
-            if (uxSemaphoreCount > (UBaseType_t)0) {
-                traceQUEUE_RECEIVE(pxQueue);
-
-                /* Semaphores are queues with a data size of zero and where the
-                messages waiting is the semaphore's count.  Reduce the count. */
-                pxQueue->uxMessagesWaiting = uxSemaphoreCount - (UBaseType_t)1;
-
-#if (configUSE_MUTEXES == 1)
-                {
-                    if (pxQueue->uxQueueType == queueQUEUE_IS_MUTEX) {
-                        /* Record the information required to implement
-                        priority inheritance should it become necessary. */
-                        pxQueue->u.xSemaphore.xMutexHolder =
-                            pvTaskIncrementMutexHeldCount();
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                }
-#endif /* configUSE_MUTEXES */
-
-                /* Check to see if other tasks are blocked waiting to give the
-                semaphore, and if so, unblock the highest priority such task. */
-                if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToSend)) ==
-                    pdFALSE) {
-                    if (xTaskRemoveFromEventList(
-                            &(pxQueue->xTasksWaitingToSend)) != pdFALSE) {
-                        queueYIELD_IF_USING_PREEMPTION();
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-
-                taskEXIT_CRITICAL();
-                return pdPASS;
-            } else {
-                if (xTicksToWait == (TickType_t)0) {
-/* For inheritance to have occurred there must have been an
-initial timeout, and an adjusted timeout cannot become 0, as
-if it were 0 the function would have exited. */
-#if (configUSE_MUTEXES == 1)
-                    {
-                        configASSERT(xInheritanceOccurred == pdFALSE);
-                    }
-#endif /* configUSE_MUTEXES */
-
-                    /* The semaphore count was 0 and no block time is specified
-                    (or the block time has expired) so exit now. */
-                    taskEXIT_CRITICAL();
-                    traceQUEUE_RECEIVE_FAILED(pxQueue);
-                    return errQUEUE_EMPTY;
-                } else if (xEntryTimeSet == pdFALSE) {
-                    /* The semaphore count was 0 and a block time was specified
-                    so configure the timeout structure ready to block. */
-                    vTaskInternalSetTimeOutState(&xTimeOut);
-                    xEntryTimeSet = pdTRUE;
-                } else {
-                    /* Entry time was already set. */
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            }
-        }
-        taskEXIT_CRITICAL();
-
-        /* Interrupts and other tasks can give to and take from the semaphore
-        now the critical section has been exited. */
-
-        vTaskSuspendAll();
-        prvLockQueue(pxQueue);
-
-        /* Update the timeout state to see if it has expired yet. */
-        if (xTaskCheckForTimeOut(&xTimeOut, &xTicksToWait) == pdFALSE) {
-            /* A block time is specified and not expired.  If the semaphore
-            count is 0 then enter the Blocked state to wait for a semaphore to
-            become available.  As semaphores are implemented with queues the
-            queue being empty is equivalent to the semaphore count being 0. */
-            if (prvIsQueueEmpty(pxQueue) != pdFALSE) {
-                traceBLOCKING_ON_QUEUE_RECEIVE(pxQueue);
-
-#if (configUSE_MUTEXES == 1)
-                {
-                    if (pxQueue->uxQueueType == queueQUEUE_IS_MUTEX) {
-                        taskENTER_CRITICAL();
-                        {
-                            xInheritanceOccurred = xTaskPriorityInherit(
-                                pxQueue->u.xSemaphore.xMutexHolder);
-                        }
-                        taskEXIT_CRITICAL();
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                }
-#endif
-
-                vTaskPlaceOnEventList(
-                    &(pxQueue->xTasksWaitingToReceive), xTicksToWait);
-                prvUnlockQueue(pxQueue);
-                if (xTaskResumeAll() == pdFALSE) {
-                    portYIELD_WITHIN_API();
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                /* There was no timeout and the semaphore count was not 0, so
-                attempt to take the semaphore again. */
-                prvUnlockQueue(pxQueue);
-                (void)xTaskResumeAll();
-            }
-        } else {
-            /* Timed out. */
-            prvUnlockQueue(pxQueue);
-            (void)xTaskResumeAll();
-
-            /* If the semaphore count is 0 exit now as the timeout has
-            expired.  Otherwise return to attempt to take the semaphore that is
-            known to be available.  As semaphores are implemented by queues the
-            queue being empty is equivalent to the semaphore count being 0. */
-            if (prvIsQueueEmpty(pxQueue) != pdFALSE) {
-#if (configUSE_MUTEXES == 1)
-                {
-                    /* xInheritanceOccurred could only have be set if
-                    pxQueue->uxQueueType == queueQUEUE_IS_MUTEX so no need to
-                    test the mutex type again to check it is actually a mutex.
-                  */
-                    if (xInheritanceOccurred != pdFALSE) {
-                        taskENTER_CRITICAL();
-                        {
-                            UBaseType_t uxHighestWaitingPriority;
-
-                            /* This task blocking on the mutex caused another
-                            task to inherit this task's priority.  Now this task
-                            has timed out the priority should be disinherited
-                            again, but only as low as the next highest priority
-                            task that is waiting for the same mutex. */
-                            uxHighestWaitingPriority =
-                                prvGetDisinheritPriorityAfterTimeout(pxQueue);
-                            vTaskPriorityDisinheritAfterTimeout(
-                                pxQueue->u.xSemaphore.xMutexHolder,
-                                uxHighestWaitingPriority);
-                        }
-                        taskEXIT_CRITICAL();
-                    }
-                }
-#endif /* configUSE_MUTEXES */
-
-                traceQUEUE_RECEIVE_FAILED(pxQueue);
-                return errQUEUE_EMPTY;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-    } /*lint -restore */
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xQueuePeek(
-    QueueHandle_t xQueue,
-    void *const pvBuffer,
-    TickType_t xTicksToWait)
-{
-    BaseType_t xEntryTimeSet = pdFALSE;
-    TimeOut_t xTimeOut;
-    int8_t *pcOriginalReadPosition;
-    Queue_t *const pxQueue = xQueue;
-
-    /* Check the pointer is not NULL. */
-    configASSERT((pxQueue));
-
-    /* The buffer into which data is received can only be NULL if the data size
-    is zero (so no data is copied into the buffer. */
-    configASSERT(
-        !(((pvBuffer) == NULL) && ((pxQueue)->uxItemSize != (UBaseType_t)0U)));
-
-/* Cannot block if the scheduler is suspended. */
-#if ((INCLUDE_xTaskGetSchedulerState == 1) || (configUSE_TIMERS == 1))
-    {
-        configASSERT(
-            !((xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED) &&
-              (xTicksToWait != 0)));
-    }
-#endif
-
-    /*lint -save -e904  This function relaxes the coding standard somewhat to
-    allow return statements within the function itself.  This is done in the
-    interest of execution time efficiency. */
-    for (;;) {
-        taskENTER_CRITICAL();
-        {
-            const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;
-
-            /* Is there data in the queue now?  To be running the calling task
-            must be the highest priority task wanting to access the queue. */
-            if (uxMessagesWaiting > (UBaseType_t)0) {
-                /* Remember the read position so it can be reset after the data
-                is read from the queue as this function is only peeking the
-                data, not removing it. */
-                pcOriginalReadPosition = pxQueue->u.xQueue.pcReadFrom;
-
-                prvCopyDataFromQueue(pxQueue, pvBuffer);
-                traceQUEUE_PEEK(pxQueue);
-
-                /* The data is not being removed, so reset the read pointer. */
-                pxQueue->u.xQueue.pcReadFrom = pcOriginalReadPosition;
-
-                /* The data is being left in the queue, so see if there are
-                any other tasks waiting for the data. */
-                if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive)) ==
-                    pdFALSE) {
-                    if (xTaskRemoveFromEventList(
-                            &(pxQueue->xTasksWaitingToReceive)) != pdFALSE) {
-                        /* The task waiting has a higher priority than this
-                         * task. */
-                        queueYIELD_IF_USING_PREEMPTION();
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-
-                taskEXIT_CRITICAL();
-                return pdPASS;
-            } else {
-                if (xTicksToWait == (TickType_t)0) {
-                    /* The queue was empty and no block time is specified (or
-                    the block time has expired) so leave now. */
-                    taskEXIT_CRITICAL();
-                    traceQUEUE_PEEK_FAILED(pxQueue);
-                    return errQUEUE_EMPTY;
-                } else if (xEntryTimeSet == pdFALSE) {
-                    /* The queue was empty and a block time was specified so
-                    configure the timeout structure ready to enter the blocked
-                    state. */
-                    vTaskInternalSetTimeOutState(&xTimeOut);
-                    xEntryTimeSet = pdTRUE;
-                } else {
-                    /* Entry time was already set. */
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            }
-        }
-        taskEXIT_CRITICAL();
-
-        /* Interrupts and other tasks can send to and receive from the queue
-        now the critical section has been exited. */
-
-        vTaskSuspendAll();
-        prvLockQueue(pxQueue);
-
-        /* Update the timeout state to see if it has expired yet. */
-        if (xTaskCheckForTimeOut(&xTimeOut, &xTicksToWait) == pdFALSE) {
-            /* Timeout has not expired yet, check to see if there is data in the
-            queue now, and if not enter the Blocked state to wait for data. */
-            if (prvIsQueueEmpty(pxQueue) != pdFALSE) {
-                traceBLOCKING_ON_QUEUE_PEEK(pxQueue);
-                vTaskPlaceOnEventList(
-                    &(pxQueue->xTasksWaitingToReceive), xTicksToWait);
-                prvUnlockQueue(pxQueue);
-                if (xTaskResumeAll() == pdFALSE) {
-                    portYIELD_WITHIN_API();
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                /* There is data in the queue now, so don't enter the blocked
-                state, instead return to try and obtain the data. */
-                prvUnlockQueue(pxQueue);
-                (void)xTaskResumeAll();
-            }
-        } else {
-            /* The timeout has expired.  If there is still no data in the queue
-            exit, otherwise go back and try to read the data again. */
-            prvUnlockQueue(pxQueue);
-            (void)xTaskResumeAll();
-
-            if (prvIsQueueEmpty(pxQueue) != pdFALSE) {
-                traceQUEUE_PEEK_FAILED(pxQueue);
-                return errQUEUE_EMPTY;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-    } /*lint -restore */
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xQueueReceiveFromISR(
-    QueueHandle_t xQueue,
-    void *const pvBuffer,
-    BaseType_t *const pxHigherPriorityTaskWoken)
-{
-    BaseType_t xReturn;
-    UBaseType_t uxSavedInterruptStatus;
-    Queue_t *const pxQueue = xQueue;
-
-    configASSERT(pxQueue);
-    configASSERT(
-        !((pvBuffer == NULL) && (pxQueue->uxItemSize != (UBaseType_t)0U)));
-
-    /* RTOS ports that support interrupt nesting have the concept of a maximum
-    system call (or maximum API call) interrupt priority.  Interrupts that are
-    above the maximum system call priority are kept permanently enabled, even
-    when the RTOS kernel is in a critical section, but cannot make any calls to
-    FreeRTOS API functions.  If configASSERT() is defined in FreeRTOSConfig.h
-    then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
-    failure if a FreeRTOS API function is called from an interrupt that has been
-    assigned a priority above the configured maximum system call priority.
-    Only FreeRTOS functions that end in FromISR can be called from interrupts
-    that have been assigned a priority at or (logically) below the maximum
-    system call	interrupt priority.  FreeRTOS maintains a separate interrupt
-    safe API to ensure interrupt entry is as fast and as simple as possible.
-    More information (albeit Cortex-M specific) is provided on the following
-    link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
-
-    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
-    {
-        const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;
-
-        /* Cannot block in an ISR, so check there is data available. */
-        if (uxMessagesWaiting > (UBaseType_t)0) {
-            const int8_t cRxLock = pxQueue->cRxLock;
-
-            traceQUEUE_RECEIVE_FROM_ISR(pxQueue);
-
-            prvCopyDataFromQueue(pxQueue, pvBuffer);
-            pxQueue->uxMessagesWaiting = uxMessagesWaiting - (UBaseType_t)1;
-
-            /* If the queue is locked the event list will not be modified.
-            Instead update the lock count so the task that unlocks the queue
-            will know that an ISR has removed data while the queue was
-            locked. */
-            if (cRxLock == queueUNLOCKED) {
-                if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToSend)) ==
-                    pdFALSE) {
-                    if (xTaskRemoveFromEventList(
-                            &(pxQueue->xTasksWaitingToSend)) != pdFALSE) {
-                        /* The task waiting has a higher priority than us so
-                        force a context switch. */
-                        if (pxHigherPriorityTaskWoken != NULL) {
-                            *pxHigherPriorityTaskWoken = pdTRUE;
-                        } else {
-                            mtCOVERAGE_TEST_MARKER();
-                        }
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                /* Increment the lock count so the task that unlocks the queue
-                knows that data was removed while it was locked. */
-                pxQueue->cRxLock = (int8_t)(cRxLock + 1);
-            }
-
-            xReturn = pdPASS;
-        } else {
-            xReturn = pdFAIL;
-            traceQUEUE_RECEIVE_FROM_ISR_FAILED(pxQueue);
-        }
-    }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus);
-
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xQueuePeekFromISR(QueueHandle_t xQueue, void *const pvBuffer)
-{
-    BaseType_t xReturn;
-    UBaseType_t uxSavedInterruptStatus;
-    int8_t *pcOriginalReadPosition;
-    Queue_t *const pxQueue = xQueue;
-
-    configASSERT(pxQueue);
-    configASSERT(
-        !((pvBuffer == NULL) && (pxQueue->uxItemSize != (UBaseType_t)0U)));
-    configASSERT(pxQueue->uxItemSize != 0); /* Can't peek a semaphore. */
-
-    /* RTOS ports that support interrupt nesting have the concept of a maximum
-    system call (or maximum API call) interrupt priority.  Interrupts that are
-    above the maximum system call priority are kept permanently enabled, even
-    when the RTOS kernel is in a critical section, but cannot make any calls to
-    FreeRTOS API functions.  If configASSERT() is defined in FreeRTOSConfig.h
-    then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
-    failure if a FreeRTOS API function is called from an interrupt that has been
-    assigned a priority above the configured maximum system call priority.
-    Only FreeRTOS functions that end in FromISR can be called from interrupts
-    that have been assigned a priority at or (logically) below the maximum
-    system call	interrupt priority.  FreeRTOS maintains a separate interrupt
-    safe API to ensure interrupt entry is as fast and as simple as possible.
-    More information (albeit Cortex-M specific) is provided on the following
-    link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
-
-    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
-    {
-        /* Cannot block in an ISR, so check there is data available. */
-        if (pxQueue->uxMessagesWaiting > (UBaseType_t)0) {
-            traceQUEUE_PEEK_FROM_ISR(pxQueue);
-
-            /* Remember the read position so it can be reset as nothing is
-            actually being removed from the queue. */
-            pcOriginalReadPosition = pxQueue->u.xQueue.pcReadFrom;
-            prvCopyDataFromQueue(pxQueue, pvBuffer);
-            pxQueue->u.xQueue.pcReadFrom = pcOriginalReadPosition;
-
-            xReturn = pdPASS;
-        } else {
-            xReturn = pdFAIL;
-            traceQUEUE_PEEK_FROM_ISR_FAILED(pxQueue);
-        }
-    }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus);
-
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-UBaseType_t uxQueueMessagesWaiting(const QueueHandle_t xQueue)
-{
-    UBaseType_t uxReturn;
-
-    configASSERT(xQueue);
-
-    taskENTER_CRITICAL();
-    {
-        uxReturn = ((Queue_t *)xQueue)->uxMessagesWaiting;
-    }
-    taskEXIT_CRITICAL();
-
-    return uxReturn;
-} /*lint !e818 Pointer cannot be declared const as xQueue is a typedef not
-     pointer. */
-/*-----------------------------------------------------------*/
-
-UBaseType_t uxQueueSpacesAvailable(const QueueHandle_t xQueue)
-{
-    UBaseType_t uxReturn;
-    Queue_t *const pxQueue = xQueue;
-
-    configASSERT(pxQueue);
-
-    taskENTER_CRITICAL();
-    {
-        uxReturn = pxQueue->uxLength - pxQueue->uxMessagesWaiting;
-    }
-    taskEXIT_CRITICAL();
-
-    return uxReturn;
-} /*lint !e818 Pointer cannot be declared const as xQueue is a typedef not
-     pointer. */
-/*-----------------------------------------------------------*/
-
-UBaseType_t uxQueueMessagesWaitingFromISR(const QueueHandle_t xQueue)
-{
-    UBaseType_t uxReturn;
-    Queue_t *const pxQueue = xQueue;
-
-    configASSERT(pxQueue);
-    uxReturn = pxQueue->uxMessagesWaiting;
-
-    return uxReturn;
-} /*lint !e818 Pointer cannot be declared const as xQueue is a typedef not
-     pointer. */
-/*-----------------------------------------------------------*/
-
-void vQueueDelete(QueueHandle_t xQueue)
-{
-    Queue_t *const pxQueue = xQueue;
-
-    configASSERT(pxQueue);
-    traceQUEUE_DELETE(pxQueue);
-
-#if (configQUEUE_REGISTRY_SIZE > 0)
-    {
-        vQueueUnregisterQueue(pxQueue);
-    }
-#endif
-
-#if ( \
-    (configSUPPORT_DYNAMIC_ALLOCATION == 1) && \
-    (configSUPPORT_STATIC_ALLOCATION == 0))
-    {
-        /* The queue can only have been allocated dynamically - free it
-        again. */
-        vPortFree(pxQueue);
-    }
-#elif ( \
-    (configSUPPORT_DYNAMIC_ALLOCATION == 1) && \
-    (configSUPPORT_STATIC_ALLOCATION == 1))
-    {
-        /* The queue could have been allocated statically or dynamically, so
-        check before attempting to free the memory. */
-        if (pxQueue->ucStaticallyAllocated == (uint8_t)pdFALSE) {
-            vPortFree(pxQueue);
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-#else
-    {
-        /* The queue must have been statically allocated, so is not going to be
-        deleted.  Avoid compiler warnings about the unused parameter. */
-        (void)pxQueue;
-    }
-#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
-}
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TRACE_FACILITY == 1)
-
-UBaseType_t uxQueueGetQueueNumber(QueueHandle_t xQueue)
-{
-    return ((Queue_t *)xQueue)->uxQueueNumber;
-}
-
-#endif /* configUSE_TRACE_FACILITY */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TRACE_FACILITY == 1)
-
-void vQueueSetQueueNumber(QueueHandle_t xQueue, UBaseType_t uxQueueNumber)
-{
-    ((Queue_t *)xQueue)->uxQueueNumber = uxQueueNumber;
-}
-
-#endif /* configUSE_TRACE_FACILITY */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TRACE_FACILITY == 1)
-
-uint8_t ucQueueGetQueueType(QueueHandle_t xQueue)
-{
-    return ((Queue_t *)xQueue)->ucQueueType;
-}
-
-#endif /* configUSE_TRACE_FACILITY */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_MUTEXES == 1)
-
-static UBaseType_t prvGetDisinheritPriorityAfterTimeout(
-    const Queue_t *const pxQueue)
-{
-    UBaseType_t uxHighestPriorityOfWaitingTasks;
-
-    /* If a task waiting for a mutex causes the mutex holder to inherit a
-    priority, but the waiting task times out, then the holder should
-    disinherit the priority - but only down to the highest priority of any
-    other tasks that are waiting for the same mutex.  For this purpose,
-    return the priority of the highest priority task that is waiting for the
-    mutex. */
-    if (listCURRENT_LIST_LENGTH(&(pxQueue->xTasksWaitingToReceive)) > 0U) {
-        uxHighestPriorityOfWaitingTasks = (UBaseType_t)configMAX_PRIORITIES -
-            (UBaseType_t)listGET_ITEM_VALUE_OF_HEAD_ENTRY(&(
-                pxQueue->xTasksWaitingToReceive));
-    } else {
-        uxHighestPriorityOfWaitingTasks = tskIDLE_PRIORITY;
-    }
-
-    return uxHighestPriorityOfWaitingTasks;
-}
-
-#endif /* configUSE_MUTEXES */
-/*-----------------------------------------------------------*/
-
-static BaseType_t prvCopyDataToQueue(
-    Queue_t *const pxQueue,
-    const void *pvItemToQueue,
-    const BaseType_t xPosition)
-{
-    BaseType_t xReturn = pdFALSE;
-    UBaseType_t uxMessagesWaiting;
-
-    /* This function is called from a critical section. */
-
-    uxMessagesWaiting = pxQueue->uxMessagesWaiting;
-
-    if (pxQueue->uxItemSize == (UBaseType_t)0) {
-#if (configUSE_MUTEXES == 1)
-        {
-            if (pxQueue->uxQueueType == queueQUEUE_IS_MUTEX) {
-                /* The mutex is no longer being held. */
-                xReturn =
-                    xTaskPriorityDisinherit(pxQueue->u.xSemaphore.xMutexHolder);
-                pxQueue->u.xSemaphore.xMutexHolder = NULL;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-#endif /* configUSE_MUTEXES */
-    } else if (xPosition == queueSEND_TO_BACK) {
-        (void)memcpy(
-            (void *)pxQueue->pcWriteTo,
-            pvItemToQueue,
-            (size_t)pxQueue
-                ->uxItemSize); /*lint !e961 !e418 !e9087 MISRA exception as the
-                                  casts are only redundant for some ports, plus
-                                  previous logic ensures a null pointer can only
-                                  be passed to memcpy() if the copy size is 0.
-                                  Cast to void required by function signature
-                                  and safe as no alignment requirement and copy
-                                  length specified in bytes. */
-        pxQueue->pcWriteTo +=
-            pxQueue->uxItemSize; /*lint !e9016 Pointer arithmetic on char types
-                                    ok, especially in this use case where it is
-                                    the clearest way of conveying intent. */
-        if (pxQueue->pcWriteTo >=
-            pxQueue->u.xQueue
-                .pcTail) /*lint !e946 MISRA exception justified as comparison of
-                            pointers is the cleanest solution. */
-        {
-            pxQueue->pcWriteTo = pxQueue->pcHead;
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    } else {
-        (void)memcpy(
-            (void *)pxQueue->u.xQueue.pcReadFrom,
-            pvItemToQueue,
-            (size_t)pxQueue
-                ->uxItemSize); /*lint !e961 !e9087 !e418 MISRA exception as the
-                                  casts are only redundant for some ports.  Cast
-                                  to void required by function signature and
-                                  safe as no alignment requirement and copy
-                                  length specified in bytes.  Assert checks null
-                                  pointer only used when length is 0. */
-        pxQueue->u.xQueue.pcReadFrom -= pxQueue->uxItemSize;
-        if (pxQueue->u.xQueue.pcReadFrom <
-            pxQueue
-                ->pcHead) /*lint !e946 MISRA exception justified as comparison
-                             of pointers is the cleanest solution. */
-        {
-            pxQueue->u.xQueue.pcReadFrom =
-                (pxQueue->u.xQueue.pcTail - pxQueue->uxItemSize);
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-
-        if (xPosition == queueOVERWRITE) {
-            if (uxMessagesWaiting > (UBaseType_t)0) {
-                /* An item is not being added but overwritten, so subtract
-                one from the recorded number of items in the queue so when
-                one is added again below the number of recorded items remains
-                correct. */
-                --uxMessagesWaiting;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-
-    pxQueue->uxMessagesWaiting = uxMessagesWaiting + (UBaseType_t)1;
-
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-static void prvCopyDataFromQueue(Queue_t *const pxQueue, void *const pvBuffer)
-{
-    if (pxQueue->uxItemSize != (UBaseType_t)0) {
-        pxQueue->u.xQueue.pcReadFrom +=
-            pxQueue->uxItemSize; /*lint !e9016 Pointer arithmetic on char types
-                                    ok, especially in this use case where it is
-                                    the clearest way of conveying intent. */
-        if (pxQueue->u.xQueue.pcReadFrom >=
-            pxQueue->u.xQueue
-                .pcTail) /*lint !e946 MISRA exception justified as use of the
-                            relational operator is the cleanest solutions. */
-        {
-            pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead;
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-        (void)memcpy(
-            (void *)pvBuffer,
-            (void *)pxQueue->u.xQueue.pcReadFrom,
-            (size_t)pxQueue
-                ->uxItemSize); /*lint !e961 !e418 !e9087 MISRA exception as the
-                                  casts are only redundant for some ports.  Also
-                                  previous logic ensures a null pointer can only
-                                  be passed to memcpy() when the count is 0.
-                                  Cast to void required by function signature
-                                  and safe as no alignment requirement and copy
-                                  length specified in bytes. */
-    }
-}
-/*-----------------------------------------------------------*/
-
-static void prvUnlockQueue(Queue_t *const pxQueue)
-{
-    /* THIS FUNCTION MUST BE CALLED WITH THE SCHEDULER SUSPENDED. */
-
-    /* The lock counts contains the number of extra data items placed or
-    removed from the queue while the queue was locked.  When a queue is
-    locked items can be added or removed, but the event lists cannot be
-    updated. */
-    taskENTER_CRITICAL();
-    {
-        int8_t cTxLock = pxQueue->cTxLock;
-
-        /* See if data was added to the queue while it was locked. */
-        while (cTxLock > queueLOCKED_UNMODIFIED) {
-/* Data was posted while the queue was locked.  Are any tasks
-blocked waiting for data to become available? */
-#if (configUSE_QUEUE_SETS == 1)
-            {
-                if (pxQueue->pxQueueSetContainer != NULL) {
-                    if (prvNotifyQueueSetContainer(pxQueue) != pdFALSE) {
-                        /* The queue is a member of a queue set, and posting to
-                        the queue set caused a higher priority task to unblock.
-                        A context switch is required. */
-                        vTaskMissedYield();
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                } else {
-                    /* Tasks that are removed from the event list will get
-                    added to the pending ready list as the scheduler is still
-                    suspended. */
-                    if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive)) ==
-                        pdFALSE) {
-                        if (xTaskRemoveFromEventList(&(
-                                pxQueue->xTasksWaitingToReceive)) != pdFALSE) {
-                            /* The task waiting has a higher priority so record
-                            that a context	switch is required. */
-                            vTaskMissedYield();
-                        } else {
-                            mtCOVERAGE_TEST_MARKER();
-                        }
-                    } else {
-                        break;
-                    }
-                }
-            }
-#else /* configUSE_QUEUE_SETS */
-            {
-                /* Tasks that are removed from the event list will get added to
-                the pending ready list as the scheduler is still suspended. */
-                if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive)) ==
-                    pdFALSE) {
-                    if (xTaskRemoveFromEventList(
-                            &(pxQueue->xTasksWaitingToReceive)) != pdFALSE) {
-                        /* The task waiting has a higher priority so record that
-                        a context switch is required. */
-                        vTaskMissedYield();
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                } else {
-                    break;
-                }
-            }
-#endif /* configUSE_QUEUE_SETS */
-
-            --cTxLock;
-        }
-
-        pxQueue->cTxLock = queueUNLOCKED;
-    }
-    taskEXIT_CRITICAL();
-
-    /* Do the same for the Rx lock. */
-    taskENTER_CRITICAL();
-    {
-        int8_t cRxLock = pxQueue->cRxLock;
-
-        while (cRxLock > queueLOCKED_UNMODIFIED) {
-            if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToSend)) == pdFALSE) {
-                if (xTaskRemoveFromEventList(&(pxQueue->xTasksWaitingToSend)) !=
-                    pdFALSE) {
-                    vTaskMissedYield();
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-
-                --cRxLock;
-            } else {
-                break;
-            }
-        }
-
-        pxQueue->cRxLock = queueUNLOCKED;
-    }
-    taskEXIT_CRITICAL();
-}
-/*-----------------------------------------------------------*/
-
-static BaseType_t prvIsQueueEmpty(const Queue_t *pxQueue)
-{
-    BaseType_t xReturn;
-
-    taskENTER_CRITICAL();
-    {
-        if (pxQueue->uxMessagesWaiting == (UBaseType_t)0) {
-            xReturn = pdTRUE;
-        } else {
-            xReturn = pdFALSE;
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xQueueIsQueueEmptyFromISR(const QueueHandle_t xQueue)
-{
-    BaseType_t xReturn;
-    Queue_t *const pxQueue = xQueue;
-
-    configASSERT(pxQueue);
-    if (pxQueue->uxMessagesWaiting == (UBaseType_t)0) {
-        xReturn = pdTRUE;
-    } else {
-        xReturn = pdFALSE;
-    }
-
-    return xReturn;
-} /*lint !e818 xQueue could not be pointer to const because it is a typedef. */
-/*-----------------------------------------------------------*/
-
-static BaseType_t prvIsQueueFull(const Queue_t *pxQueue)
-{
-    BaseType_t xReturn;
-
-    taskENTER_CRITICAL();
-    {
-        if (pxQueue->uxMessagesWaiting == pxQueue->uxLength) {
-            xReturn = pdTRUE;
-        } else {
-            xReturn = pdFALSE;
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xQueueIsQueueFullFromISR(const QueueHandle_t xQueue)
-{
-    BaseType_t xReturn;
-    Queue_t *const pxQueue = xQueue;
-
-    configASSERT(pxQueue);
-    if (pxQueue->uxMessagesWaiting == pxQueue->uxLength) {
-        xReturn = pdTRUE;
-    } else {
-        xReturn = pdFALSE;
-    }
-
-    return xReturn;
-} /*lint !e818 xQueue could not be pointer to const because it is a typedef. */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_CO_ROUTINES == 1)
-
-BaseType_t xQueueCRSend(
-    QueueHandle_t xQueue,
-    const void *pvItemToQueue,
-    TickType_t xTicksToWait)
-{
-    BaseType_t xReturn;
-    Queue_t *const pxQueue = xQueue;
-
-    /* If the queue is already full we may have to block.  A critical section
-    is required to prevent an interrupt removing something from the queue
-    between the check to see if the queue is full and blocking on the queue. */
-    portDISABLE_INTERRUPTS();
-    {
-        if (prvIsQueueFull(pxQueue) != pdFALSE) {
-            /* The queue is full - do we want to block or just leave without
-            posting? */
-            if (xTicksToWait > (TickType_t)0) {
-                /* As this is called from a coroutine we cannot block directly,
-                but return indicating that we need to block. */
-                vCoRoutineAddToDelayedList(
-                    xTicksToWait, &(pxQueue->xTasksWaitingToSend));
-                portENABLE_INTERRUPTS();
-                return errQUEUE_BLOCKED;
-            } else {
-                portENABLE_INTERRUPTS();
-                return errQUEUE_FULL;
-            }
-        }
-    }
-    portENABLE_INTERRUPTS();
-
-    portDISABLE_INTERRUPTS();
-    {
-        if (pxQueue->uxMessagesWaiting < pxQueue->uxLength) {
-            /* There is room in the queue, copy the data into the queue. */
-            prvCopyDataToQueue(pxQueue, pvItemToQueue, queueSEND_TO_BACK);
-            xReturn = pdPASS;
-
-            /* Were any co-routines waiting for data to become available? */
-            if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive)) ==
-                pdFALSE) {
-                /* In this instance the co-routine could be placed directly
-                into the ready list as we are within a critical section.
-                Instead the same pending ready list mechanism is used as if
-                the event were caused from within an interrupt. */
-                if (xCoRoutineRemoveFromEventList(
-                        &(pxQueue->xTasksWaitingToReceive)) != pdFALSE) {
-                    /* The co-routine waiting has a higher priority so record
-                    that a yield might be appropriate. */
-                    xReturn = errQUEUE_YIELD;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            xReturn = errQUEUE_FULL;
-        }
-    }
-    portENABLE_INTERRUPTS();
-
-    return xReturn;
-}
-
-#endif /* configUSE_CO_ROUTINES */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_CO_ROUTINES == 1)
-
-BaseType_t xQueueCRReceive(
-    QueueHandle_t xQueue,
-    void *pvBuffer,
-    TickType_t xTicksToWait)
-{
-    BaseType_t xReturn;
-    Queue_t *const pxQueue = xQueue;
-
-    /* If the queue is already empty we may have to block.  A critical section
-    is required to prevent an interrupt adding something to the queue
-    between the check to see if the queue is empty and blocking on the queue. */
-    portDISABLE_INTERRUPTS();
-    {
-        if (pxQueue->uxMessagesWaiting == (UBaseType_t)0) {
-            /* There are no messages in the queue, do we want to block or just
-            leave with nothing? */
-            if (xTicksToWait > (TickType_t)0) {
-                /* As this is a co-routine we cannot block directly, but return
-                indicating that we need to block. */
-                vCoRoutineAddToDelayedList(
-                    xTicksToWait, &(pxQueue->xTasksWaitingToReceive));
-                portENABLE_INTERRUPTS();
-                return errQUEUE_BLOCKED;
-            } else {
-                portENABLE_INTERRUPTS();
-                return errQUEUE_FULL;
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-    portENABLE_INTERRUPTS();
-
-    portDISABLE_INTERRUPTS();
-    {
-        if (pxQueue->uxMessagesWaiting > (UBaseType_t)0) {
-            /* Data is available from the queue. */
-            pxQueue->u.xQueue.pcReadFrom += pxQueue->uxItemSize;
-            if (pxQueue->u.xQueue.pcReadFrom >= pxQueue->u.xQueue.pcTail) {
-                pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-            --(pxQueue->uxMessagesWaiting);
-            (void)memcpy(
-                (void *)pvBuffer,
-                (void *)pxQueue->u.xQueue.pcReadFrom,
-                (unsigned)pxQueue->uxItemSize);
-
-            xReturn = pdPASS;
-
-            /* Were any co-routines waiting for space to become available? */
-            if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToSend)) == pdFALSE) {
-                /* In this instance the co-routine could be placed directly
-                into the ready list as we are within a critical section.
-                Instead the same pending ready list mechanism is used as if
-                the event were caused from within an interrupt. */
-                if (xCoRoutineRemoveFromEventList(
-                        &(pxQueue->xTasksWaitingToSend)) != pdFALSE) {
-                    xReturn = errQUEUE_YIELD;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            xReturn = pdFAIL;
-        }
-    }
-    portENABLE_INTERRUPTS();
-
-    return xReturn;
-}
-
-#endif /* configUSE_CO_ROUTINES */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_CO_ROUTINES == 1)
-
-BaseType_t xQueueCRSendFromISR(
-    QueueHandle_t xQueue,
-    const void *pvItemToQueue,
-    BaseType_t xCoRoutinePreviouslyWoken)
-{
-    Queue_t *const pxQueue = xQueue;
-
-    /* Cannot block within an ISR so if there is no space on the queue then
-    exit without doing anything. */
-    if (pxQueue->uxMessagesWaiting < pxQueue->uxLength) {
-        prvCopyDataToQueue(pxQueue, pvItemToQueue, queueSEND_TO_BACK);
-
-        /* We only want to wake one co-routine per ISR, so check that a
-        co-routine has not already been woken. */
-        if (xCoRoutinePreviouslyWoken == pdFALSE) {
-            if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToReceive)) ==
-                pdFALSE) {
-                if (xCoRoutineRemoveFromEventList(
-                        &(pxQueue->xTasksWaitingToReceive)) != pdFALSE) {
-                    return pdTRUE;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    return xCoRoutinePreviouslyWoken;
-}
-
-#endif /* configUSE_CO_ROUTINES */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_CO_ROUTINES == 1)
-
-BaseType_t xQueueCRReceiveFromISR(
-    QueueHandle_t xQueue,
-    void *pvBuffer,
-    BaseType_t *pxCoRoutineWoken)
-{
-    BaseType_t xReturn;
-    Queue_t *const pxQueue = xQueue;
-
-    /* We cannot block from an ISR, so check there is data available. If
-    not then just leave without doing anything. */
-    if (pxQueue->uxMessagesWaiting > (UBaseType_t)0) {
-        /* Copy the data from the queue. */
-        pxQueue->u.xQueue.pcReadFrom += pxQueue->uxItemSize;
-        if (pxQueue->u.xQueue.pcReadFrom >= pxQueue->u.xQueue.pcTail) {
-            pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead;
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-        --(pxQueue->uxMessagesWaiting);
-        (void)memcpy(
-            (void *)pvBuffer,
-            (void *)pxQueue->u.xQueue.pcReadFrom,
-            (unsigned)pxQueue->uxItemSize);
-
-        if ((*pxCoRoutineWoken) == pdFALSE) {
-            if (listLIST_IS_EMPTY(&(pxQueue->xTasksWaitingToSend)) == pdFALSE) {
-                if (xCoRoutineRemoveFromEventList(
-                        &(pxQueue->xTasksWaitingToSend)) != pdFALSE) {
-                    *pxCoRoutineWoken = pdTRUE;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-
-        xReturn = pdPASS;
-    } else {
-        xReturn = pdFAIL;
-    }
-
-    return xReturn;
-}
-
-#endif /* configUSE_CO_ROUTINES */
-/*-----------------------------------------------------------*/
-
-#if (configQUEUE_REGISTRY_SIZE > 0)
-
-void vQueueAddToRegistry(
-    QueueHandle_t xQueue,
-    const char *pcQueueName) /*lint !e971 Unqualified char types are allowed for
-                                strings and single characters only. */
-{
-    UBaseType_t ux;
-
-    /* See if there is an empty space in the registry.  A NULL name denotes
-    a free slot. */
-    for (ux = (UBaseType_t)0U; ux < (UBaseType_t)configQUEUE_REGISTRY_SIZE;
-         ux++) {
-        if (xQueueRegistry[ux].pcQueueName == NULL) {
-            /* Store the information on this queue. */
-            xQueueRegistry[ux].pcQueueName = pcQueueName;
-            xQueueRegistry[ux].xHandle = xQueue;
-
-            traceQUEUE_REGISTRY_ADD(xQueue, pcQueueName);
-            break;
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-}
-
-#endif /* configQUEUE_REGISTRY_SIZE */
-/*-----------------------------------------------------------*/
-
-#if (configQUEUE_REGISTRY_SIZE > 0)
-
-const char *pcQueueGetName(
-    QueueHandle_t xQueue) /*lint !e971 Unqualified char types are allowed for
-                             strings and single characters only. */
-{
-    UBaseType_t ux;
-    const char *pcReturn = NULL; /*lint !e971 Unqualified char types are allowed
-                                    for strings and single characters only. */
-
-    /* Note there is nothing here to protect against another task adding or
-    removing entries from the registry while it is being searched. */
-    for (ux = (UBaseType_t)0U; ux < (UBaseType_t)configQUEUE_REGISTRY_SIZE;
-         ux++) {
-        if (xQueueRegistry[ux].xHandle == xQueue) {
-            pcReturn = xQueueRegistry[ux].pcQueueName;
-            break;
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-
-    return pcReturn;
-} /*lint !e818 xQueue cannot be a pointer to const because it is a typedef. */
-
-#endif /* configQUEUE_REGISTRY_SIZE */
-/*-----------------------------------------------------------*/
-
-#if (configQUEUE_REGISTRY_SIZE > 0)
-
-void vQueueUnregisterQueue(QueueHandle_t xQueue)
-{
-    UBaseType_t ux;
-
-    /* See if the handle of the queue being unregistered in actually in the
-    registry. */
-    for (ux = (UBaseType_t)0U; ux < (UBaseType_t)configQUEUE_REGISTRY_SIZE;
-         ux++) {
-        if (xQueueRegistry[ux].xHandle == xQueue) {
-            /* Set the name to NULL to show that this slot if free again. */
-            xQueueRegistry[ux].pcQueueName = NULL;
-
-            /* Set the handle to NULL to ensure the same queue handle cannot
-            appear in the registry twice if it is added, removed, then
-            added again. */
-            xQueueRegistry[ux].xHandle = (QueueHandle_t)0;
-            break;
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-
-} /*lint !e818 xQueue could not be pointer to const because it is a typedef. */
-
-#endif /* configQUEUE_REGISTRY_SIZE */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TIMERS == 1)
-
-void vQueueWaitForMessageRestricted(
-    QueueHandle_t xQueue,
-    TickType_t xTicksToWait,
-    const BaseType_t xWaitIndefinitely)
-{
-    Queue_t *const pxQueue = xQueue;
-
-    /* This function should not be called by application code hence the
-    'Restricted' in its name.  It is not part of the public API.  It is
-    designed for use by kernel code, and has special calling requirements.
-    It can result in vListInsert() being called on a list that can only
-    possibly ever have one item in it, so the list will be fast, but even
-    so it should be called with the scheduler locked and not from a critical
-    section. */
-
-    /* Only do anything if there are no messages in the queue.  This function
-    will not actually cause the task to block, just place it on a blocked
-    list.  It will not block until the scheduler is unlocked - at which
-    time a yield will be performed.  If an item is added to the queue while
-    the queue is locked, and the calling task blocks on the queue, then the
-    calling task will be immediately unblocked when the queue is unlocked. */
-    prvLockQueue(pxQueue);
-    if (pxQueue->uxMessagesWaiting == (UBaseType_t)0U) {
-        /* There is nothing in the queue, block for the specified period. */
-        vTaskPlaceOnEventListRestricted(
-            &(pxQueue->xTasksWaitingToReceive),
-            xTicksToWait,
-            xWaitIndefinitely);
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-    prvUnlockQueue(pxQueue);
-}
-
-#endif /* configUSE_TIMERS */
-/*-----------------------------------------------------------*/
-
-#if ((configUSE_QUEUE_SETS == 1) && (configSUPPORT_DYNAMIC_ALLOCATION == 1))
-
-QueueSetHandle_t xQueueCreateSet(const UBaseType_t uxEventQueueLength)
-{
-    QueueSetHandle_t pxQueue;
-
-    pxQueue = xQueueGenericCreate(
-        uxEventQueueLength,
-        (UBaseType_t)sizeof(Queue_t *),
-        queueQUEUE_TYPE_SET);
-
-    return pxQueue;
-}
-
-#endif /* configUSE_QUEUE_SETS */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_QUEUE_SETS == 1)
-
-BaseType_t xQueueAddToSet(
-    QueueSetMemberHandle_t xQueueOrSemaphore,
-    QueueSetHandle_t xQueueSet)
-{
-    BaseType_t xReturn;
-
-    taskENTER_CRITICAL();
-    {
-        if (((Queue_t *)xQueueOrSemaphore)->pxQueueSetContainer != NULL) {
-            /* Cannot add a queue/semaphore to more than one queue set. */
-            xReturn = pdFAIL;
-        } else if (
-            ((Queue_t *)xQueueOrSemaphore)->uxMessagesWaiting !=
-            (UBaseType_t)0) {
-            /* Cannot add a queue/semaphore to a queue set if there are already
-            items in the queue/semaphore. */
-            xReturn = pdFAIL;
-        } else {
-            ((Queue_t *)xQueueOrSemaphore)->pxQueueSetContainer = xQueueSet;
-            xReturn = pdPASS;
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    return xReturn;
-}
-
-#endif /* configUSE_QUEUE_SETS */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_QUEUE_SETS == 1)
-
-BaseType_t xQueueRemoveFromSet(
-    QueueSetMemberHandle_t xQueueOrSemaphore,
-    QueueSetHandle_t xQueueSet)
-{
-    BaseType_t xReturn;
-    Queue_t *const pxQueueOrSemaphore = (Queue_t *)xQueueOrSemaphore;
-
-    if (pxQueueOrSemaphore->pxQueueSetContainer != xQueueSet) {
-        /* The queue was not a member of the set. */
-        xReturn = pdFAIL;
-    } else if (pxQueueOrSemaphore->uxMessagesWaiting != (UBaseType_t)0) {
-        /* It is dangerous to remove a queue from a set when the queue is
-        not empty because the queue set will still hold pending events for
-        the queue. */
-        xReturn = pdFAIL;
-    } else {
-        taskENTER_CRITICAL();
-        {
-            /* The queue is no longer contained in the set. */
-            pxQueueOrSemaphore->pxQueueSetContainer = NULL;
-        }
-        taskEXIT_CRITICAL();
-        xReturn = pdPASS;
-    }
-
-    return xReturn;
-} /*lint !e818 xQueueSet could not be declared as pointing to const as it is a
-     typedef. */
-
-#endif /* configUSE_QUEUE_SETS */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_QUEUE_SETS == 1)
-
-QueueSetMemberHandle_t xQueueSelectFromSet(
-    QueueSetHandle_t xQueueSet,
-    TickType_t const xTicksToWait)
-{
-    QueueSetMemberHandle_t xReturn = NULL;
-
-    (void)xQueueReceive(
-        (QueueHandle_t)xQueueSet,
-        &xReturn,
-        xTicksToWait); /*lint !e961 Casting from one typedef to another is not
-                          redundant. */
-    return xReturn;
-}
-
-#endif /* configUSE_QUEUE_SETS */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_QUEUE_SETS == 1)
-
-QueueSetMemberHandle_t xQueueSelectFromSetFromISR(QueueSetHandle_t xQueueSet)
-{
-    QueueSetMemberHandle_t xReturn = NULL;
-
-    (void)xQueueReceiveFromISR(
-        (QueueHandle_t)xQueueSet,
-        &xReturn,
-        NULL); /*lint !e961 Casting from one typedef to another is not
-                  redundant. */
-    return xReturn;
-}
-
-#endif /* configUSE_QUEUE_SETS */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_QUEUE_SETS == 1)
-
-static BaseType_t prvNotifyQueueSetContainer(const Queue_t *const pxQueue)
-{
-    Queue_t *pxQueueSetContainer = pxQueue->pxQueueSetContainer;
-    BaseType_t xReturn = pdFALSE;
-
-    /* This function must be called form a critical section. */
-
-    configASSERT(pxQueueSetContainer);
-    configASSERT(
-        pxQueueSetContainer->uxMessagesWaiting < pxQueueSetContainer->uxLength);
-
-    if (pxQueueSetContainer->uxMessagesWaiting <
-        pxQueueSetContainer->uxLength) {
-        const int8_t cTxLock = pxQueueSetContainer->cTxLock;
-
-        traceQUEUE_SEND(pxQueueSetContainer);
-
-        /* The data copied is the handle of the queue that contains data. */
-        xReturn = prvCopyDataToQueue(
-            pxQueueSetContainer, &pxQueue, queueSEND_TO_BACK);
-
-        if (cTxLock == queueUNLOCKED) {
-            if (listLIST_IS_EMPTY(&(
-                    pxQueueSetContainer->xTasksWaitingToReceive)) == pdFALSE) {
-                if (xTaskRemoveFromEventList(
-                        &(pxQueueSetContainer->xTasksWaitingToReceive)) !=
-                    pdFALSE) {
-                    /* The task waiting has a higher priority. */
-                    xReturn = pdTRUE;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            pxQueueSetContainer->cTxLock = (int8_t)(cTxLock + 1);
-        }
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    return xReturn;
-}
-
-#endif /* configUSE_QUEUE_SETS */
diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/tasks.c b/product/rcar/src/CMSIS-FreeRTOS/Source/tasks.c
deleted file mode 100644
index ea5650322dd2f1976963a2b6790d5a07c9af6fb6..0000000000000000000000000000000000000000
--- a/product/rcar/src/CMSIS-FreeRTOS/Source/tasks.c
+++ /dev/null
@@ -1,5356 +0,0 @@
-/*
- * FreeRTOS Kernel V10.3.1
- * 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://www.FreeRTOS.org
- * http://aws.amazon.com/freertos
- *
- * 1 tab == 4 spaces!
- */
-
-/* Standard includes. */
-#include 
-#include 
-
-/* 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 "stack_macros.h"
-#include "task.h"
-#include "timers.h"
-
-/* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified
-because 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 /*lint !e961 !e750 !e9021. */
-
-/* Set configUSE_STATS_FORMATTING_FUNCTIONS to 2 to include the stats formatting
-functions but without including stdio.h here. */
-#if (configUSE_STATS_FORMATTING_FUNCTIONS == 1)
-/* At the bottom of this file are two optional functions that can be used
-to generate human readable text from the raw data generated by the
-uxTaskGetSystemState() function.  Note the formatting functions are provided
-for convenience only, and are NOT considered part of the kernel. */
-#    include 
-#endif /* configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) */
-
-#if (configUSE_PREEMPTION == 0)
-/* If the cooperative scheduler is being used then a yield should not be
-performed just because a higher priority task has been woken. */
-#    define taskYIELD_IF_USING_PREEMPTION()
-#else
-#    define taskYIELD_IF_USING_PREEMPTION() portYIELD_WITHIN_API()
-#endif
-
-/* Values that can be assigned to the ucNotifyState member of the TCB. */
-#define taskNOT_WAITING_NOTIFICATION ((uint8_t)0)
-#define taskWAITING_NOTIFICATION ((uint8_t)1)
-#define taskNOTIFICATION_RECEIVED ((uint8_t)2)
-
-/*
- * The value used to fill the stack of a task when the task is created.  This
- * is used purely for checking the high water mark for tasks.
- */
-#define tskSTACK_FILL_BYTE (0xa5U)
-
-/* Bits used to recored how a task's stack and TCB were allocated. */
-#define tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB ((uint8_t)0)
-#define tskSTATICALLY_ALLOCATED_STACK_ONLY ((uint8_t)1)
-#define tskSTATICALLY_ALLOCATED_STACK_AND_TCB ((uint8_t)2)
-
-/* If any of the following are set then task stacks are filled with a known
-value so the high water mark can be determined.  If none of the following are
-set then don't fill the stack so there is no unnecessary dependency on memset.
-*/
-#if ( \
-    (configCHECK_FOR_STACK_OVERFLOW > 1) || (configUSE_TRACE_FACILITY == 1) || \
-    (INCLUDE_uxTaskGetStackHighWaterMark == 1) || \
-    (INCLUDE_uxTaskGetStackHighWaterMark2 == 1))
-#    define tskSET_NEW_STACKS_TO_KNOWN_VALUE 1
-#else
-#    define tskSET_NEW_STACKS_TO_KNOWN_VALUE 0
-#endif
-
-/*
- * Macros used by vListTask to indicate which state a task is in.
- */
-#define tskRUNNING_CHAR ('X')
-#define tskBLOCKED_CHAR ('B')
-#define tskREADY_CHAR ('R')
-#define tskDELETED_CHAR ('D')
-#define tskSUSPENDED_CHAR ('S')
-
-/*
- * Some kernel aware debuggers require the data the debugger needs access to be
- * global, rather than file scope.
- */
-#ifdef portREMOVE_STATIC_QUALIFIER
-#    define static
-#endif
-
-/* The name allocated to the Idle task.  This can be overridden by defining
-configIDLE_TASK_NAME in FreeRTOSConfig.h. */
-#ifndef configIDLE_TASK_NAME
-#    define configIDLE_TASK_NAME "IDLE"
-#endif
-
-#if (configUSE_PORT_OPTIMISED_TASK_SELECTION == 0)
-
-/* If configUSE_PORT_OPTIMISED_TASK_SELECTION is 0 then task selection is
-performed in a generic way that is not optimised to any particular
-microcontroller architecture. */
-
-/* uxTopReadyPriority holds the priority of the highest priority ready
-state task. */
-#    define taskRECORD_READY_PRIORITY(uxPriority) \
-        { \
-            if ((uxPriority) > uxTopReadyPriority) { \
-                uxTopReadyPriority = (uxPriority); \
-            } \
-        } /* taskRECORD_READY_PRIORITY */
-
-/*-----------------------------------------------------------*/
-
-#    define taskSELECT_HIGHEST_PRIORITY_TASK() \
-        { \
-            UBaseType_t uxTopPriority = uxTopReadyPriority; \
-\
-            /* Find the highest priority queue that contains ready tasks. */ \
-            while (listLIST_IS_EMPTY(&(pxReadyTasksLists[uxTopPriority]))) { \
-                configASSERT(uxTopPriority); \
-                --uxTopPriority; \
-            } \
-\
-            /* listGET_OWNER_OF_NEXT_ENTRY indexes through the list, so the \
-            tasks of \
-            the	same priority get an equal share of the processor time. */ \
-            listGET_OWNER_OF_NEXT_ENTRY( \
-                pxCurrentTCB, &(pxReadyTasksLists[uxTopPriority])); \
-            uxTopReadyPriority = uxTopPriority; \
-        } /* taskSELECT_HIGHEST_PRIORITY_TASK */
-
-/*-----------------------------------------------------------*/
-
-/* Define away taskRESET_READY_PRIORITY() and portRESET_READY_PRIORITY() as
-they are only required when a port optimised method of task selection is
-being used. */
-#    define taskRESET_READY_PRIORITY(uxPriority)
-#    define portRESET_READY_PRIORITY(uxPriority, uxTopReadyPriority)
-
-#else /* configUSE_PORT_OPTIMISED_TASK_SELECTION */
-
-/* If configUSE_PORT_OPTIMISED_TASK_SELECTION is 1 then task selection is
-performed in a way that is tailored to the particular microcontroller
-architecture being used. */
-
-/* A port optimised version is provided.  Call the port defined macros. */
-#    define taskRECORD_READY_PRIORITY(uxPriority) \
-        portRECORD_READY_PRIORITY(uxPriority, uxTopReadyPriority)
-
-/*-----------------------------------------------------------*/
-
-#    define taskSELECT_HIGHEST_PRIORITY_TASK() \
-        { \
-            UBaseType_t uxTopPriority; \
-\
-            /* Find the highest priority list that contains ready tasks. */ \
-            portGET_HIGHEST_PRIORITY(uxTopPriority, uxTopReadyPriority); \
-            configASSERT( \
-                listCURRENT_LIST_LENGTH(&(pxReadyTasksLists[uxTopPriority])) > \
-                0); \
-            listGET_OWNER_OF_NEXT_ENTRY( \
-                pxCurrentTCB, &(pxReadyTasksLists[uxTopPriority])); \
-        } /* taskSELECT_HIGHEST_PRIORITY_TASK() */
-
-/*-----------------------------------------------------------*/
-
-/* A port optimised version is provided, call it only if the TCB being reset
-is being referenced from a ready list.  If it is referenced from a delayed
-or suspended list then it won't be in a ready list. */
-#    define taskRESET_READY_PRIORITY(uxPriority) \
-        { \
-            if (listCURRENT_LIST_LENGTH(&(pxReadyTasksLists[(uxPriority)])) == \
-                (UBaseType_t)0) { \
-                portRESET_READY_PRIORITY((uxPriority), (uxTopReadyPriority)); \
-            } \
-        }
-
-#endif /* configUSE_PORT_OPTIMISED_TASK_SELECTION */
-
-/*-----------------------------------------------------------*/
-
-/* pxDelayedTaskList and pxOverflowDelayedTaskList are switched when the tick
-count overflows. */
-#define taskSWITCH_DELAYED_LISTS() \
-    { \
-        List_t *pxTemp; \
-\
-        /* The delayed tasks list should be empty when the lists are switched. \
-         */ \
-        configASSERT((listLIST_IS_EMPTY(pxDelayedTaskList))); \
-\
-        pxTemp = pxDelayedTaskList; \
-        pxDelayedTaskList = pxOverflowDelayedTaskList; \
-        pxOverflowDelayedTaskList = pxTemp; \
-        xNumOfOverflows++; \
-        prvResetNextTaskUnblockTime(); \
-    }
-
-/*-----------------------------------------------------------*/
-
-/*
- * Place the task represented by pxTCB into the appropriate ready list for
- * the task.  It is inserted at the end of the list.
- */
-#define prvAddTaskToReadyList(pxTCB) \
-    traceMOVED_TASK_TO_READY_STATE(pxTCB); \
-    taskRECORD_READY_PRIORITY((pxTCB)->uxPriority); \
-    vListInsertEnd( \
-        &(pxReadyTasksLists[(pxTCB)->uxPriority]), \
-        &((pxTCB)->xStateListItem)); \
-    tracePOST_MOVED_TASK_TO_READY_STATE(pxTCB)
-/*-----------------------------------------------------------*/
-
-/*
- * Several functions take an TaskHandle_t parameter that can optionally be NULL,
- * where NULL is used to indicate that the handle of the currently executing
- * task should be used in place of the parameter.  This macro simply checks to
- * see if the parameter is NULL and returns a pointer to the appropriate TCB.
- */
-#define prvGetTCBFromHandle(pxHandle) \
-    (((pxHandle) == NULL) ? pxCurrentTCB : (pxHandle))
-
-/* The item value of the event list item is normally used to hold the priority
-of the task to which it belongs (coded to allow it to be held in reverse
-priority order).  However, it is occasionally borrowed for other purposes.  It
-is important its value is not updated due to a task priority change while it is
-being used for another purpose.  The following bit definition is used to inform
-the scheduler that the value should not be changed - in which case it is the
-responsibility of whichever module is using the value to ensure it gets set back
-to its original value when it is released. */
-#if (configUSE_16_BIT_TICKS == 1)
-#    define taskEVENT_LIST_ITEM_VALUE_IN_USE 0x8000U
-#else
-#    define taskEVENT_LIST_ITEM_VALUE_IN_USE 0x80000000UL
-#endif
-
-/*
- * Task control block.  A task control block (TCB) is allocated for each task,
- * and stores task state information, including a pointer to the task's context
- * (the task's run time environment, including register values)
- */
-typedef struct tskTaskControlBlock /* The old naming convention is used to
-                                      prevent breaking kernel aware debuggers.
-                                    */
-{
-    volatile StackType_t
-        *pxTopOfStack; /*< Points to the location of the last item placed on the
-                          tasks stack.  THIS MUST BE THE FIRST MEMBER OF THE TCB
-                          STRUCT. */
-
-#if (portUSING_MPU_WRAPPERS == 1)
-    xMPU_SETTINGS xMPUSettings; /*< The MPU settings are defined as part of the
-                                   port layer.  THIS MUST BE THE SECOND MEMBER
-                                   OF THE TCB STRUCT. */
-#endif
-
-    ListItem_t xStateListItem; /*< The list that the state list item of a task
-                                  is reference from denotes the state of that
-                                  task (Ready, Blocked, Suspended ). */
-    ListItem_t
-        xEventListItem; /*< Used to reference a task from an event list. */
-    UBaseType_t
-        uxPriority; /*< The priority of the task.  0 is the lowest priority. */
-    StackType_t *pxStack; /*< Points to the start of the stack. */
-    char				pcTaskName[ configMAX_TASK_NAME_LEN ];/*< Descriptive name given to the task when created.  Facilitates debugging only. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
-
-#if ((portSTACK_GROWTH > 0) || (configRECORD_STACK_HIGH_ADDRESS == 1))
-    StackType_t
-        *pxEndOfStack; /*< Points to the highest valid address for the stack. */
-#endif
-
-#if (portCRITICAL_NESTING_IN_TCB == 1)
-    UBaseType_t uxCriticalNesting; /*< Holds the critical section nesting depth
-                                      for ports that do not maintain their own
-                                      count in the port layer. */
-#endif
-
-#if (configUSE_TRACE_FACILITY == 1)
-    UBaseType_t
-        uxTCBNumber; /*< Stores a number that increments each time a TCB is
-                        created.  It allows debuggers to determine when a task
-                        has been deleted and then recreated. */
-    UBaseType_t uxTaskNumber; /*< Stores a number specifically for use by third
-                                 party trace code. */
-#endif
-
-#if (configUSE_MUTEXES == 1)
-    UBaseType_t
-        uxBasePriority; /*< The priority last assigned to the task - used by the
-                           priority inheritance mechanism. */
-    UBaseType_t uxMutexesHeld;
-#endif
-
-#if (configUSE_APPLICATION_TASK_TAG == 1)
-    TaskHookFunction_t pxTaskTag;
-#endif
-
-#if (configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0)
-    void *pvThreadLocalStoragePointers[configNUM_THREAD_LOCAL_STORAGE_POINTERS];
-#endif
-
-#if (configGENERATE_RUN_TIME_STATS == 1)
-    uint32_t ulRunTimeCounter; /*< Stores the amount of time the task has spent
-                                  in the Running state. */
-#endif
-
-#if (configUSE_NEWLIB_REENTRANT == 1)
-    /* Allocate a Newlib reent structure that is specific to this task.
-    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. */
-    struct _reent xNewLib_reent;
-#endif
-
-#if (configUSE_TASK_NOTIFICATIONS == 1)
-    volatile uint32_t ulNotifiedValue;
-    volatile uint8_t ucNotifyState;
-#endif
-
-/* See the comments in FreeRTOS.h with the definition of
-tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE. */
-#if (tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0) /*lint !e731 !e9029 Macro \
-                                                        has been consolidated \
-                                                        for readability \
-                                                        reasons. */
-    uint8_t ucStaticallyAllocated; /*< Set to pdTRUE if the task is a statically
-                                      allocated to ensure no attempt is made to
-                                      free the memory. */
-#endif
-
-#if (INCLUDE_xTaskAbortDelay == 1)
-    uint8_t ucDelayAborted;
-#endif
-
-#if (configUSE_POSIX_ERRNO == 1)
-    int iTaskErrno;
-#endif
-
-} tskTCB;
-
-/* The old tskTCB name is maintained above then typedefed to the new TCB_t name
-below to enable the use of older kernel aware debuggers. */
-typedef tskTCB TCB_t;
-
-/*lint -save -e956 A manual analysis and inspection has been used to determine
-which static variables must be declared volatile. */
-PRIVILEGED_DATA TCB_t *volatile pxCurrentTCB = NULL;
-
-/* Lists for ready and blocked tasks. --------------------
-xDelayedTaskList1 and xDelayedTaskList2 could be move to function scople but
-doing so breaks some kernel aware debuggers and debuggers that rely on removing
-the static qualifier. */
-PRIVILEGED_DATA static List_t
-    pxReadyTasksLists[configMAX_PRIORITIES]; /*< Prioritised ready tasks. */
-PRIVILEGED_DATA static List_t xDelayedTaskList1; /*< Delayed tasks. */
-PRIVILEGED_DATA static List_t
-    xDelayedTaskList2; /*< Delayed tasks (two lists are used - one for delays
-                          that have overflowed the current tick count. */
-PRIVILEGED_DATA static List_t
-    *volatile pxDelayedTaskList; /*< Points to the delayed task list currently
-                                    being used. */
-PRIVILEGED_DATA static List_t
-    *volatile pxOverflowDelayedTaskList; /*< Points to the delayed task list
-                                            currently being used to hold tasks
-                                            that have overflowed the current
-                                            tick count. */
-PRIVILEGED_DATA static List_t
-    xPendingReadyList; /*< Tasks that have been readied while the scheduler was
-                          suspended.  They will be moved to the ready list when
-                          the scheduler is resumed. */
-
-#if (INCLUDE_vTaskDelete == 1)
-
-PRIVILEGED_DATA static List_t
-    xTasksWaitingTermination; /*< Tasks that have been deleted - but their
-                                 memory not yet freed. */
-PRIVILEGED_DATA static volatile UBaseType_t uxDeletedTasksWaitingCleanUp =
-    (UBaseType_t)0U;
-
-#endif
-
-#if (INCLUDE_vTaskSuspend == 1)
-
-PRIVILEGED_DATA static List_t
-    xSuspendedTaskList; /*< Tasks that are currently suspended. */
-
-#endif
-
-/* Global POSIX errno. Its value is changed upon context switching to match
-the errno of the currently running task. */
-#if (configUSE_POSIX_ERRNO == 1)
-int FreeRTOS_errno = 0;
-#endif
-
-/* Other file private variables. --------------------------------*/
-PRIVILEGED_DATA static volatile UBaseType_t uxCurrentNumberOfTasks =
-    (UBaseType_t)0U;
-PRIVILEGED_DATA static volatile TickType_t xTickCount =
-    (TickType_t)configINITIAL_TICK_COUNT;
-PRIVILEGED_DATA static volatile UBaseType_t uxTopReadyPriority =
-    tskIDLE_PRIORITY;
-PRIVILEGED_DATA static volatile BaseType_t xSchedulerRunning = pdFALSE;
-PRIVILEGED_DATA static volatile TickType_t xPendedTicks = (TickType_t)0U;
-PRIVILEGED_DATA static volatile BaseType_t xYieldPending = pdFALSE;
-PRIVILEGED_DATA static volatile BaseType_t xNumOfOverflows = (BaseType_t)0;
-PRIVILEGED_DATA static UBaseType_t uxTaskNumber = (UBaseType_t)0U;
-PRIVILEGED_DATA static volatile TickType_t xNextTaskUnblockTime =
-    (TickType_t)0U; /* Initialised to portMAX_DELAY before the scheduler starts.
-                     */
-PRIVILEGED_DATA static TaskHandle_t xIdleTaskHandle =
-    NULL; /*< Holds the handle of the idle task.  The idle task is created
-             automatically when the scheduler is started. */
-
-/* Context switches are held pending while the scheduler is suspended.  Also,
-interrupts must not manipulate the xStateListItem of a TCB, or any of the
-lists the xStateListItem can be referenced from, if the scheduler is suspended.
-If an interrupt needs to unblock a task while the scheduler is suspended then it
-moves the task's event list item into the xPendingReadyList, ready for the
-kernel to move the task from the pending ready list into the real ready list
-when the scheduler is unsuspended.  The pending ready list itself can only be
-accessed from a critical section. */
-PRIVILEGED_DATA static volatile UBaseType_t uxSchedulerSuspended =
-    (UBaseType_t)pdFALSE;
-
-#if (configGENERATE_RUN_TIME_STATS == 1)
-
-/* Do not move these variables to function scope as doing so prevents the
-code working with debuggers that need to remove the static qualifier. */
-PRIVILEGED_DATA static uint32_t ulTaskSwitchedInTime =
-    0UL; /*< Holds the value of a timer/counter the last time a task was
-            switched in. */
-PRIVILEGED_DATA static uint32_t ulTotalRunTime =
-    0UL; /*< Holds the total amount of execution time as defined by the run time
-            counter clock. */
-
-#endif
-
-/*lint -restore */
-
-/*-----------------------------------------------------------*/
-
-/* Callback function prototypes. --------------------------*/
-#if (configCHECK_FOR_STACK_OVERFLOW > 0)
-
-extern void vApplicationStackOverflowHook(TaskHandle_t xTask, char *pcTaskName);
-
-#endif
-
-#if (configUSE_TICK_HOOK > 0)
-
-extern void vApplicationTickHook(
-    void); /*lint !e526 Symbol not defined as it is an application callback. */
-
-#endif
-
-#if (configSUPPORT_STATIC_ALLOCATION == 1)
-
-extern void vApplicationGetIdleTaskMemory(
-    StaticTask_t **ppxIdleTaskTCBBuffer,
-    StackType_t **ppxIdleTaskStackBuffer,
-    uint32_t *pulIdleTaskStackSize); /*lint !e526 Symbol not defined as it is an
-                                        application callback. */
-
-#endif
-
-/* File private functions. --------------------------------*/
-
-/**
- * Utility task that simply returns pdTRUE if the task referenced by xTask is
- * currently in the Suspended state, or pdFALSE if the task referenced by xTask
- * is in any other state.
- */
-#if (INCLUDE_vTaskSuspend == 1)
-
-static BaseType_t prvTaskIsTaskSuspended(const TaskHandle_t xTask)
-    PRIVILEGED_FUNCTION;
-
-#endif /* INCLUDE_vTaskSuspend */
-
-/*
- * Utility to ready all the lists used by the scheduler.  This is called
- * automatically upon the creation of the first task.
- */
-static void prvInitialiseTaskLists(void) PRIVILEGED_FUNCTION;
-
-/*
- * The idle task, which as all tasks is implemented as a never ending loop.
- * The idle task is automatically created and added to the ready lists upon
- * creation of the first user task.
- *
- * The portTASK_FUNCTION_PROTO() macro is used to allow port/compiler specific
- * language extensions.  The equivalent prototype for this function is:
- *
- * void prvIdleTask( void *pvParameters );
- *
- */
-static portTASK_FUNCTION_PROTO(prvIdleTask, pvParameters);
-
-/*
- * Utility to free all memory allocated by the scheduler to hold a TCB,
- * including the stack pointed to by the TCB.
- *
- * This does not free memory allocated by the task itself (i.e. memory
- * allocated by calls to pvPortMalloc from within the tasks application code).
- */
-#if (INCLUDE_vTaskDelete == 1)
-
-static void prvDeleteTCB(TCB_t *pxTCB) PRIVILEGED_FUNCTION;
-
-#endif
-
-/*
- * Used only by the idle task.  This checks to see if anything has been placed
- * in the list of tasks waiting to be deleted.  If so the task is cleaned up
- * and its TCB deleted.
- */
-static void prvCheckTasksWaitingTermination(void) PRIVILEGED_FUNCTION;
-
-/*
- * The currently executing task is entering the Blocked state.  Add the task to
- * either the current or the overflow delayed task list.
- */
-static void prvAddCurrentTaskToDelayedList(
-    TickType_t xTicksToWait,
-    const BaseType_t xCanBlockIndefinitely) PRIVILEGED_FUNCTION;
-
-/*
- * Fills an TaskStatus_t structure with information on each task that is
- * referenced from the pxList list (which may be a ready list, a delayed list,
- * a suspended list, etc.).
- *
- * THIS FUNCTION IS INTENDED FOR DEBUGGING ONLY, AND SHOULD NOT BE CALLED FROM
- * NORMAL APPLICATION CODE.
- */
-#if (configUSE_TRACE_FACILITY == 1)
-
-static UBaseType_t prvListTasksWithinSingleList(
-    TaskStatus_t *pxTaskStatusArray,
-    List_t *pxList,
-    eTaskState eState) PRIVILEGED_FUNCTION;
-
-#endif
-
-/*
- * Searches pxList for a task with name pcNameToQuery - returning a handle to
- * the task if it is found, or NULL if the task is not found.
- */
-#if (INCLUDE_xTaskGetHandle == 1)
-
-static TCB_t *prvSearchForNameWithinSingleList(
-    List_t *pxList,
-    const char pcNameToQuery[]) PRIVILEGED_FUNCTION;
-
-#endif
-
-/*
- * When a task is created, the stack of the task is filled with a known value.
- * This function determines the 'high water mark' of the task stack by
- * determining how much of the stack remains at the original preset value.
- */
-#if ( \
-    (configUSE_TRACE_FACILITY == 1) || \
-    (INCLUDE_uxTaskGetStackHighWaterMark == 1) || \
-    (INCLUDE_uxTaskGetStackHighWaterMark2 == 1))
-
-static configSTACK_DEPTH_TYPE prvTaskCheckFreeStackSpace(
-    const uint8_t *pucStackByte) PRIVILEGED_FUNCTION;
-
-#endif
-
-/*
- * Return the amount of time, in ticks, that will pass before the kernel will
- * next move a task from the Blocked state to the Running state.
- *
- * This conditional compilation should use inequality to 0, not equality to 1.
- * This is to ensure portSUPPRESS_TICKS_AND_SLEEP() can be called when user
- * defined low power mode implementations require configUSE_TICKLESS_IDLE to be
- * set to a value other than 1.
- */
-#if (configUSE_TICKLESS_IDLE != 0)
-
-static TickType_t prvGetExpectedIdleTime(void) PRIVILEGED_FUNCTION;
-
-#endif
-
-/*
- * Set xNextTaskUnblockTime to the time at which the next Blocked state task
- * will exit the Blocked state.
- */
-static void prvResetNextTaskUnblockTime(void);
-
-#if ( \
-    (configUSE_TRACE_FACILITY == 1) && \
-    (configUSE_STATS_FORMATTING_FUNCTIONS > 0))
-
-/*
- * Helper function used to pad task names with spaces when printing out
- * human readable tables of task information.
- */
-static char *prvWriteNameToBuffer(char *pcBuffer, const char *pcTaskName)
-    PRIVILEGED_FUNCTION;
-
-#endif
-
-/*
- * Called after a Task_t structure has been allocated either statically or
- * dynamically to fill in the structure's members.
- */
-static void prvInitialiseNewTask(
-    TaskFunction_t pxTaskCode,
-    const char *const pcName, /*lint !e971 Unqualified char types are allowed
-                                 for strings and single characters only. */
-    const uint32_t ulStackDepth,
-    void *const pvParameters,
-    UBaseType_t uxPriority,
-    TaskHandle_t *const pxCreatedTask,
-    TCB_t *pxNewTCB,
-    const MemoryRegion_t *const xRegions) PRIVILEGED_FUNCTION;
-
-/*
- * Called after a new task has been created and initialised to place the task
- * under the control of the scheduler.
- */
-static void prvAddNewTaskToReadyList(TCB_t *pxNewTCB) PRIVILEGED_FUNCTION;
-
-/*
- * freertos_tasks_c_additions_init() should only be called if the user definable
- * macro FREERTOS_TASKS_C_ADDITIONS_INIT() is defined, as that is the only macro
- * called by the function.
- */
-#ifdef FREERTOS_TASKS_C_ADDITIONS_INIT
-
-static void freertos_tasks_c_additions_init(void) PRIVILEGED_FUNCTION;
-
-#endif
-
-/*-----------------------------------------------------------*/
-
-#if (configSUPPORT_STATIC_ALLOCATION == 1)
-
-TaskHandle_t xTaskCreateStatic(
-    TaskFunction_t pxTaskCode,
-    const char *const pcName, /*lint !e971 Unqualified char types are allowed
-                                 for strings and single characters only. */
-    const uint32_t ulStackDepth,
-    void *const pvParameters,
-    UBaseType_t uxPriority,
-    StackType_t *const puxStackBuffer,
-    StaticTask_t *const pxTaskBuffer)
-{
-    TCB_t *pxNewTCB;
-    TaskHandle_t xReturn;
-
-    configASSERT(puxStackBuffer != NULL);
-    configASSERT(pxTaskBuffer != NULL);
-
-#    if (configASSERT_DEFINED == 1)
-    {
-        /* Sanity check that the size of the structure used to declare a
-        variable of type StaticTask_t equals the size of the real task
-        structure. */
-        volatile size_t xSize = sizeof(StaticTask_t);
-        configASSERT(xSize == sizeof(TCB_t));
-        (void)xSize; /* Prevent lint warning when configASSERT() is not used. */
-    }
-#    endif /* configASSERT_DEFINED */
-
-    if ((pxTaskBuffer != NULL) && (puxStackBuffer != NULL)) {
-        /* The memory used for the task's TCB and stack are passed into this
-        function - use them. */
-        pxNewTCB = (TCB_t *)
-            pxTaskBuffer; /*lint !e740 !e9087 Unusual cast is ok as the
-                             structures are designed to have the same alignment,
-                             and the size is checked by an assert. */
-        pxNewTCB->pxStack = (StackType_t *)puxStackBuffer;
-
-#    if (tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0) /*lint !e731 !e9029 \
-                                                            Macro has been \
-                                                            consolidated for \
-                                                            readability \
-                                                            reasons. */
-        {
-            /* Tasks can be created statically or dynamically, so note this
-            task was created statically in case the task is later deleted. */
-            pxNewTCB->ucStaticallyAllocated =
-                tskSTATICALLY_ALLOCATED_STACK_AND_TCB;
-        }
-#    endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */
-
-        prvInitialiseNewTask(
-            pxTaskCode,
-            pcName,
-            ulStackDepth,
-            pvParameters,
-            uxPriority,
-            &xReturn,
-            pxNewTCB,
-            NULL);
-        prvAddNewTaskToReadyList(pxNewTCB);
-    } else {
-        xReturn = NULL;
-    }
-
-    return xReturn;
-}
-
-#endif /* SUPPORT_STATIC_ALLOCATION */
-/*-----------------------------------------------------------*/
-
-#if ((portUSING_MPU_WRAPPERS == 1) && (configSUPPORT_STATIC_ALLOCATION == 1))
-
-BaseType_t xTaskCreateRestrictedStatic(
-    const TaskParameters_t *const pxTaskDefinition,
-    TaskHandle_t *pxCreatedTask)
-{
-    TCB_t *pxNewTCB;
-    BaseType_t xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
-
-    configASSERT(pxTaskDefinition->puxStackBuffer != NULL);
-    configASSERT(pxTaskDefinition->pxTaskBuffer != NULL);
-
-    if ((pxTaskDefinition->puxStackBuffer != NULL) &&
-        (pxTaskDefinition->pxTaskBuffer != NULL)) {
-        /* Allocate space for the TCB.  Where the memory comes from depends
-        on the implementation of the port malloc function and whether or
-        not static allocation is being used. */
-        pxNewTCB = (TCB_t *)pxTaskDefinition->pxTaskBuffer;
-
-        /* Store the stack location in the TCB. */
-        pxNewTCB->pxStack = pxTaskDefinition->puxStackBuffer;
-
-#    if (tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0)
-        {
-            /* Tasks can be created statically or dynamically, so note this
-            task was created statically in case the task is later deleted. */
-            pxNewTCB->ucStaticallyAllocated =
-                tskSTATICALLY_ALLOCATED_STACK_AND_TCB;
-        }
-#    endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */
-
-        prvInitialiseNewTask(
-            pxTaskDefinition->pvTaskCode,
-            pxTaskDefinition->pcName,
-            (uint32_t)pxTaskDefinition->usStackDepth,
-            pxTaskDefinition->pvParameters,
-            pxTaskDefinition->uxPriority,
-            pxCreatedTask,
-            pxNewTCB,
-            pxTaskDefinition->xRegions);
-
-        prvAddNewTaskToReadyList(pxNewTCB);
-        xReturn = pdPASS;
-    }
-
-    return xReturn;
-}
-
-#endif /* ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION \
-          == 1 ) */
-/*-----------------------------------------------------------*/
-
-#if ((portUSING_MPU_WRAPPERS == 1) && (configSUPPORT_DYNAMIC_ALLOCATION == 1))
-
-BaseType_t xTaskCreateRestricted(
-    const TaskParameters_t *const pxTaskDefinition,
-    TaskHandle_t *pxCreatedTask)
-{
-    TCB_t *pxNewTCB;
-    BaseType_t xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
-
-    configASSERT(pxTaskDefinition->puxStackBuffer);
-
-    if (pxTaskDefinition->puxStackBuffer != NULL) {
-        /* Allocate space for the TCB.  Where the memory comes from depends
-        on the implementation of the port malloc function and whether or
-        not static allocation is being used. */
-        pxNewTCB = (TCB_t *)pvPortMalloc(sizeof(TCB_t));
-
-        if (pxNewTCB != NULL) {
-            /* Store the stack location in the TCB. */
-            pxNewTCB->pxStack = pxTaskDefinition->puxStackBuffer;
-
-#    if (tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0)
-            {
-                /* Tasks can be created statically or dynamically, so note
-                this task had a statically allocated stack in case it is
-                later deleted.  The TCB was allocated dynamically. */
-                pxNewTCB->ucStaticallyAllocated =
-                    tskSTATICALLY_ALLOCATED_STACK_ONLY;
-            }
-#    endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */
-
-            prvInitialiseNewTask(
-                pxTaskDefinition->pvTaskCode,
-                pxTaskDefinition->pcName,
-                (uint32_t)pxTaskDefinition->usStackDepth,
-                pxTaskDefinition->pvParameters,
-                pxTaskDefinition->uxPriority,
-                pxCreatedTask,
-                pxNewTCB,
-                pxTaskDefinition->xRegions);
-
-            prvAddNewTaskToReadyList(pxNewTCB);
-            xReturn = pdPASS;
-        }
-    }
-
-    return xReturn;
-}
-
-#endif /* portUSING_MPU_WRAPPERS */
-/*-----------------------------------------------------------*/
-
-#if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
-
-BaseType_t xTaskCreate(
-    TaskFunction_t pxTaskCode,
-    const char *const pcName, /*lint !e971 Unqualified char types are allowed
-                                 for strings and single characters only. */
-    const configSTACK_DEPTH_TYPE usStackDepth,
-    void *const pvParameters,
-    UBaseType_t uxPriority,
-    TaskHandle_t *const pxCreatedTask)
-{
-    TCB_t *pxNewTCB;
-    BaseType_t xReturn;
-
-/* If the stack grows down then allocate the stack then the TCB so the stack
-does not grow into the TCB.  Likewise if the stack grows up then allocate
-the TCB then the stack. */
-#    if (portSTACK_GROWTH > 0)
-    {
-        /* Allocate space for the TCB.  Where the memory comes from depends on
-        the implementation of the port malloc function and whether or not static
-        allocation is being used. */
-        pxNewTCB = (TCB_t *)pvPortMalloc(sizeof(TCB_t));
-
-        if (pxNewTCB != NULL) {
-            /* Allocate space for the stack used by the task being created.
-            The base of the stack memory stored in the TCB so the task can
-            be deleted later if required. */
-            pxNewTCB->pxStack = (StackType_t *)pvPortMalloc((
-                ((size_t)usStackDepth) *
-                sizeof(StackType_t))); /*lint !e961 MISRA exception as the casts
-                                          are only redundant for some ports. */
-
-            if (pxNewTCB->pxStack == NULL) {
-                /* Could not allocate the stack.  Delete the allocated TCB. */
-                vPortFree(pxNewTCB);
-                pxNewTCB = NULL;
-            }
-        }
-    }
-#    else /* portSTACK_GROWTH */
-    {
-        StackType_t *pxStack;
-
-        /* Allocate space for the stack used by the task being created. */
-        pxStack = pvPortMalloc(
-            (((size_t)usStackDepth) *
-             sizeof(StackType_t))); /*lint !e9079 All values returned by
-                                       pvPortMalloc() have at least the
-                                       alignment required by the MCU's stack and
-                                       this allocation is the stack. */
-
-        if (pxStack != NULL) {
-            /* Allocate space for the TCB. */
-            pxNewTCB = (TCB_t *)pvPortMalloc(sizeof(
-                TCB_t)); /*lint !e9087 !e9079 All values returned by
-                            pvPortMalloc() have at least the alignment required
-                            by the MCU's stack, and the first member of TCB_t is
-                            always a pointer to the task's stack. */
-
-            if (pxNewTCB != NULL) {
-                /* Store the stack location in the TCB. */
-                pxNewTCB->pxStack = pxStack;
-            } else {
-                /* The stack cannot be used as the TCB was not created.  Free
-                it again. */
-                vPortFree(pxStack);
-            }
-        } else {
-            pxNewTCB = NULL;
-        }
-    }
-#    endif /* portSTACK_GROWTH */
-
-    if (pxNewTCB != NULL) {
-#    if (tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0) /*lint !e9029 !e731 \
-                                                            Macro has been \
-                                                            consolidated for \
-                                                            readability \
-                                                            reasons. */
-        {
-            /* Tasks can be created statically or dynamically, so note this
-            task was created dynamically in case it is later deleted. */
-            pxNewTCB->ucStaticallyAllocated =
-                tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB;
-        }
-#    endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */
-
-        prvInitialiseNewTask(
-            pxTaskCode,
-            pcName,
-            (uint32_t)usStackDepth,
-            pvParameters,
-            uxPriority,
-            pxCreatedTask,
-            pxNewTCB,
-            NULL);
-        prvAddNewTaskToReadyList(pxNewTCB);
-        xReturn = pdPASS;
-    } else {
-        xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
-    }
-
-    return xReturn;
-}
-
-#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
-/*-----------------------------------------------------------*/
-
-static void prvInitialiseNewTask(
-    TaskFunction_t pxTaskCode,
-    const char *const pcName, /*lint !e971 Unqualified char types are allowed
-                                 for strings and single characters only. */
-    const uint32_t ulStackDepth,
-    void *const pvParameters,
-    UBaseType_t uxPriority,
-    TaskHandle_t *const pxCreatedTask,
-    TCB_t *pxNewTCB,
-    const MemoryRegion_t *const xRegions)
-{
-    StackType_t *pxTopOfStack;
-    UBaseType_t x;
-
-#if (portUSING_MPU_WRAPPERS == 1)
-    /* Should the task be created in privileged mode? */
-    BaseType_t xRunPrivileged;
-    if ((uxPriority & portPRIVILEGE_BIT) != 0U) {
-        xRunPrivileged = pdTRUE;
-    } else {
-        xRunPrivileged = pdFALSE;
-    }
-    uxPriority &= ~portPRIVILEGE_BIT;
-#endif /* portUSING_MPU_WRAPPERS == 1 */
-
-/* Avoid dependency on memset() if it is not required. */
-#if (tskSET_NEW_STACKS_TO_KNOWN_VALUE == 1)
-    {
-        /* Fill the stack with a known value to assist debugging. */
-        (void)memset(
-            pxNewTCB->pxStack,
-            (int)tskSTACK_FILL_BYTE,
-            (size_t)ulStackDepth * sizeof(StackType_t));
-    }
-#endif /* tskSET_NEW_STACKS_TO_KNOWN_VALUE */
-
-/* Calculate the top of stack address.  This depends on whether the stack
-grows from high memory to low (as per the 80x86) or vice versa.
-portSTACK_GROWTH is used to make the result positive or negative as required
-by the port. */
-#if (portSTACK_GROWTH < 0)
-    {
-        pxTopOfStack = &(pxNewTCB->pxStack[ulStackDepth - (uint32_t)1]);
-        pxTopOfStack =
-            (StackType_t
-                 *)(((portPOINTER_SIZE_TYPE)pxTopOfStack) & (~((portPOINTER_SIZE_TYPE)portBYTE_ALIGNMENT_MASK))); /*lint !e923 !e9033 !e9078 MISRA exception.  Avoiding casts between pointers and integers is not practical.  Size differences accounted for using portPOINTER_SIZE_TYPE type.  Checked by assert(). */
-
-        /* Check the alignment of the calculated top of stack is correct. */
-        configASSERT(
-            (((portPOINTER_SIZE_TYPE)pxTopOfStack &
-              (portPOINTER_SIZE_TYPE)portBYTE_ALIGNMENT_MASK) == 0UL));
-
-#    if (configRECORD_STACK_HIGH_ADDRESS == 1)
-        {
-            /* Also record the stack's high address, which may assist
-            debugging. */
-            pxNewTCB->pxEndOfStack = pxTopOfStack;
-        }
-#    endif /* configRECORD_STACK_HIGH_ADDRESS */
-    }
-#else /* portSTACK_GROWTH */
-    {
-        pxTopOfStack = pxNewTCB->pxStack;
-
-        /* Check the alignment of the stack buffer is correct. */
-        configASSERT(
-            (((portPOINTER_SIZE_TYPE)pxNewTCB->pxStack &
-              (portPOINTER_SIZE_TYPE)portBYTE_ALIGNMENT_MASK) == 0UL));
-
-        /* The other extreme of the stack space is required if stack checking is
-        performed. */
-        pxNewTCB->pxEndOfStack =
-            pxNewTCB->pxStack + (ulStackDepth - (uint32_t)1);
-    }
-#endif /* portSTACK_GROWTH */
-
-    /* Store the task name in the TCB. */
-    if (pcName != NULL) {
-        for (x = (UBaseType_t)0; x < (UBaseType_t)configMAX_TASK_NAME_LEN;
-             x++) {
-            pxNewTCB->pcTaskName[x] = pcName[x];
-
-            /* Don't copy all configMAX_TASK_NAME_LEN if the string is shorter
-            than configMAX_TASK_NAME_LEN characters just in case the memory
-            after the string is not accessible (extremely unlikely). */
-            if (pcName[x] == (char)0x00) {
-                break;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-
-        /* Ensure the name string is terminated in the case that the string
-        length was greater or equal to configMAX_TASK_NAME_LEN. */
-        pxNewTCB->pcTaskName[configMAX_TASK_NAME_LEN - 1] = '\0';
-    } else {
-        /* The task has not been given a name, so just ensure there is a NULL
-        terminator when it is read out. */
-        pxNewTCB->pcTaskName[0] = 0x00;
-    }
-
-    /* This is used as an array index so must ensure it's not too large.  First
-    remove the privilege bit if one is present. */
-    if (uxPriority >= (UBaseType_t)configMAX_PRIORITIES) {
-        uxPriority = (UBaseType_t)configMAX_PRIORITIES - (UBaseType_t)1U;
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    pxNewTCB->uxPriority = uxPriority;
-#if (configUSE_MUTEXES == 1)
-    {
-        pxNewTCB->uxBasePriority = uxPriority;
-        pxNewTCB->uxMutexesHeld = 0;
-    }
-#endif /* configUSE_MUTEXES */
-
-    vListInitialiseItem(&(pxNewTCB->xStateListItem));
-    vListInitialiseItem(&(pxNewTCB->xEventListItem));
-
-    /* Set the pxNewTCB as a link back from the ListItem_t.  This is so we can
-    get back to	the containing TCB from a generic item in a list. */
-    listSET_LIST_ITEM_OWNER(&(pxNewTCB->xStateListItem), pxNewTCB);
-
-    /* Event lists are always in priority order. */
-    listSET_LIST_ITEM_VALUE(
-        &(pxNewTCB->xEventListItem),
-        (TickType_t)configMAX_PRIORITIES -
-            (TickType_t)uxPriority); /*lint !e961 MISRA exception as the casts
-                                        are only redundant for some ports. */
-    listSET_LIST_ITEM_OWNER(&(pxNewTCB->xEventListItem), pxNewTCB);
-
-#if (portCRITICAL_NESTING_IN_TCB == 1)
-    {
-        pxNewTCB->uxCriticalNesting = (UBaseType_t)0U;
-    }
-#endif /* portCRITICAL_NESTING_IN_TCB */
-
-#if (configUSE_APPLICATION_TASK_TAG == 1)
-    {
-        pxNewTCB->pxTaskTag = NULL;
-    }
-#endif /* configUSE_APPLICATION_TASK_TAG */
-
-#if (configGENERATE_RUN_TIME_STATS == 1)
-    {
-        pxNewTCB->ulRunTimeCounter = 0UL;
-    }
-#endif /* configGENERATE_RUN_TIME_STATS */
-
-#if (portUSING_MPU_WRAPPERS == 1)
-    {
-        vPortStoreTaskMPUSettings(
-            &(pxNewTCB->xMPUSettings),
-            xRegions,
-            pxNewTCB->pxStack,
-            ulStackDepth);
-    }
-#else
-    {
-        /* Avoid compiler warning about unreferenced parameter. */
-        (void)xRegions;
-    }
-#endif
-
-#if (configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0)
-    {
-        for (x = 0; x < (UBaseType_t)configNUM_THREAD_LOCAL_STORAGE_POINTERS;
-             x++) {
-            pxNewTCB->pvThreadLocalStoragePointers[x] = NULL;
-        }
-    }
-#endif
-
-#if (configUSE_TASK_NOTIFICATIONS == 1)
-    {
-        pxNewTCB->ulNotifiedValue = 0;
-        pxNewTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
-    }
-#endif
-
-#if (configUSE_NEWLIB_REENTRANT == 1)
-    {
-        /* Initialise this task's Newlib reent structure.
-        See the third party link
-        http://www.nadler.com/embedded/newlibAndFreeRTOS.html for additional
-        information. */
-        _REENT_INIT_PTR((&(pxNewTCB->xNewLib_reent)));
-    }
-#endif
-
-#if (INCLUDE_xTaskAbortDelay == 1)
-    {
-        pxNewTCB->ucDelayAborted = pdFALSE;
-    }
-#endif
-
-/* Initialize the TCB stack to look as if the task was already running,
-but had been interrupted by the scheduler.  The return address is set
-to the start of the task function. Once the stack has been initialised
-the top of stack variable is updated. */
-#if (portUSING_MPU_WRAPPERS == 1)
-    {
-/* If the port has capability to detect stack overflow,
-pass the stack end address to the stack initialization
-function as well. */
-#    if (portHAS_STACK_OVERFLOW_CHECKING == 1)
-        {
-#        if (portSTACK_GROWTH < 0)
-            {
-                pxNewTCB->pxTopOfStack = pxPortInitialiseStack(
-                    pxTopOfStack,
-                    pxNewTCB->pxStack,
-                    pxTaskCode,
-                    pvParameters,
-                    xRunPrivileged);
-            }
-#        else /* portSTACK_GROWTH */
-            {
-                pxNewTCB->pxTopOfStack = pxPortInitialiseStack(
-                    pxTopOfStack,
-                    pxNewTCB->pxEndOfStack,
-                    pxTaskCode,
-                    pvParameters,
-                    xRunPrivileged);
-            }
-#        endif /* portSTACK_GROWTH */
-        }
-#    else /* portHAS_STACK_OVERFLOW_CHECKING */
-        {
-            pxNewTCB->pxTopOfStack = pxPortInitialiseStack(
-                pxTopOfStack, pxTaskCode, pvParameters, xRunPrivileged);
-        }
-#    endif /* portHAS_STACK_OVERFLOW_CHECKING */
-    }
-#else /* portUSING_MPU_WRAPPERS */
-    {
-/* If the port has capability to detect stack overflow,
-pass the stack end address to the stack initialization
-function as well. */
-#    if (portHAS_STACK_OVERFLOW_CHECKING == 1)
-        {
-#        if (portSTACK_GROWTH < 0)
-            {
-                pxNewTCB->pxTopOfStack = pxPortInitialiseStack(
-                    pxTopOfStack, pxNewTCB->pxStack, pxTaskCode, pvParameters);
-            }
-#        else /* portSTACK_GROWTH */
-            {
-                pxNewTCB->pxTopOfStack = pxPortInitialiseStack(
-                    pxTopOfStack,
-                    pxNewTCB->pxEndOfStack,
-                    pxTaskCode,
-                    pvParameters);
-            }
-#        endif /* portSTACK_GROWTH */
-        }
-#    else /* portHAS_STACK_OVERFLOW_CHECKING */
-        {
-            pxNewTCB->pxTopOfStack =
-                pxPortInitialiseStack(pxTopOfStack, pxTaskCode, pvParameters);
-        }
-#    endif /* portHAS_STACK_OVERFLOW_CHECKING */
-    }
-#endif /* portUSING_MPU_WRAPPERS */
-
-    if (pxCreatedTask != NULL) {
-        /* Pass the handle out in an anonymous way.  The handle can be used to
-        change the created task's priority, delete the created task, etc.*/
-        *pxCreatedTask = (TaskHandle_t)pxNewTCB;
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-}
-/*-----------------------------------------------------------*/
-
-static void prvAddNewTaskToReadyList(TCB_t *pxNewTCB)
-{
-    /* Ensure interrupts don't access the task lists while the lists are being
-    updated. */
-    taskENTER_CRITICAL();
-    {
-        uxCurrentNumberOfTasks++;
-        if (pxCurrentTCB == NULL) {
-            /* There are no other tasks, or all the other tasks are in
-            the suspended state - make this the current task. */
-            pxCurrentTCB = pxNewTCB;
-
-            if (uxCurrentNumberOfTasks == (UBaseType_t)1) {
-                /* This is the first task to be created so do the preliminary
-                initialisation required.  We will not recover if this call
-                fails, but we will report the failure. */
-                prvInitialiseTaskLists();
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            /* If the scheduler is not already running, make this task the
-            current task if it is the highest priority task to be created
-            so far. */
-            if (xSchedulerRunning == pdFALSE) {
-                if (pxCurrentTCB->uxPriority <= pxNewTCB->uxPriority) {
-                    pxCurrentTCB = pxNewTCB;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-
-        uxTaskNumber++;
-
-#if (configUSE_TRACE_FACILITY == 1)
-        {
-            /* Add a counter into the TCB for tracing only. */
-            pxNewTCB->uxTCBNumber = uxTaskNumber;
-        }
-#endif /* configUSE_TRACE_FACILITY */
-        traceTASK_CREATE(pxNewTCB);
-
-        prvAddTaskToReadyList(pxNewTCB);
-
-        portSETUP_TCB(pxNewTCB);
-    }
-    taskEXIT_CRITICAL();
-
-    if (xSchedulerRunning != pdFALSE) {
-        /* If the created task is of a higher priority than the current task
-        then it should run now. */
-        if (pxCurrentTCB->uxPriority < pxNewTCB->uxPriority) {
-            taskYIELD_IF_USING_PREEMPTION();
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-}
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_vTaskDelete == 1)
-
-void vTaskDelete(TaskHandle_t xTaskToDelete)
-{
-    TCB_t *pxTCB;
-
-    taskENTER_CRITICAL();
-    {
-        /* If null is passed in here then it is the calling task that is
-        being deleted. */
-        pxTCB = prvGetTCBFromHandle(xTaskToDelete);
-
-        /* Remove task from the ready/delayed list. */
-        if (uxListRemove(&(pxTCB->xStateListItem)) == (UBaseType_t)0) {
-            taskRESET_READY_PRIORITY(pxTCB->uxPriority);
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-
-        /* Is the task waiting on an event also? */
-        if (listLIST_ITEM_CONTAINER(&(pxTCB->xEventListItem)) != NULL) {
-            (void)uxListRemove(&(pxTCB->xEventListItem));
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-
-        /* Increment the uxTaskNumber also so kernel aware debuggers can
-        detect that the task lists need re-generating.  This is done before
-        portPRE_TASK_DELETE_HOOK() as in the Windows port that macro will
-        not return. */
-        uxTaskNumber++;
-
-        if (pxTCB == pxCurrentTCB) {
-            /* A task is deleting itself.  This cannot complete within the
-            task itself, as a context switch to another task is required.
-            Place the task in the termination list.  The idle task will
-            check the termination list and free up any memory allocated by
-            the scheduler for the TCB and stack of the deleted task. */
-            vListInsertEnd(&xTasksWaitingTermination, &(pxTCB->xStateListItem));
-
-            /* Increment the ucTasksDeleted variable so the idle task knows
-            there is a task that has been deleted and that it should therefore
-            check the xTasksWaitingTermination list. */
-            ++uxDeletedTasksWaitingCleanUp;
-
-            /* Call the delete hook before portPRE_TASK_DELETE_HOOK() as
-            portPRE_TASK_DELETE_HOOK() does not return in the Win32 port. */
-            traceTASK_DELETE(pxTCB);
-
-            /* The pre-delete hook is primarily for the Windows simulator,
-            in which Windows specific clean up operations are performed,
-            after which it is not possible to yield away from this task -
-            hence xYieldPending is used to latch that a context switch is
-            required. */
-            portPRE_TASK_DELETE_HOOK(pxTCB, &xYieldPending);
-        } else {
-            --uxCurrentNumberOfTasks;
-            traceTASK_DELETE(pxTCB);
-            prvDeleteTCB(pxTCB);
-
-            /* Reset the next expected unblock time in case it referred to
-            the task that has just been deleted. */
-            prvResetNextTaskUnblockTime();
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    /* Force a reschedule if it is the currently running task that has just
-    been deleted. */
-    if (xSchedulerRunning != pdFALSE) {
-        if (pxTCB == pxCurrentTCB) {
-            configASSERT(uxSchedulerSuspended == 0);
-            portYIELD_WITHIN_API();
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-}
-
-#endif /* INCLUDE_vTaskDelete */
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_vTaskDelayUntil == 1)
-
-void vTaskDelayUntil(
-    TickType_t *const pxPreviousWakeTime,
-    const TickType_t xTimeIncrement)
-{
-    TickType_t xTimeToWake;
-    BaseType_t xAlreadyYielded, xShouldDelay = pdFALSE;
-
-    configASSERT(pxPreviousWakeTime);
-    configASSERT((xTimeIncrement > 0U));
-    configASSERT(uxSchedulerSuspended == 0);
-
-    vTaskSuspendAll();
-    {
-        /* Minor optimisation.  The tick count cannot change in this
-        block. */
-        const TickType_t xConstTickCount = xTickCount;
-
-        /* Generate the tick time at which the task wants to wake. */
-        xTimeToWake = *pxPreviousWakeTime + xTimeIncrement;
-
-        if (xConstTickCount < *pxPreviousWakeTime) {
-            /* The tick count has overflowed since this function was
-            lasted called.  In this case the only time we should ever
-            actually delay is if the wake time has also	overflowed,
-            and the wake time is greater than the tick time.  When this
-            is the case it is as if neither time had overflowed. */
-            if ((xTimeToWake < *pxPreviousWakeTime) &&
-                (xTimeToWake > xConstTickCount)) {
-                xShouldDelay = pdTRUE;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            /* The tick time has not overflowed.  In this case we will
-            delay if either the wake time has overflowed, and/or the
-            tick time is less than the wake time. */
-            if ((xTimeToWake < *pxPreviousWakeTime) ||
-                (xTimeToWake > xConstTickCount)) {
-                xShouldDelay = pdTRUE;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-
-        /* Update the wake time ready for the next call. */
-        *pxPreviousWakeTime = xTimeToWake;
-
-        if (xShouldDelay != pdFALSE) {
-            traceTASK_DELAY_UNTIL(xTimeToWake);
-
-            /* prvAddCurrentTaskToDelayedList() needs the block time, not
-            the time to wake, so subtract the current tick count. */
-            prvAddCurrentTaskToDelayedList(
-                xTimeToWake - xConstTickCount, pdFALSE);
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-    xAlreadyYielded = xTaskResumeAll();
-
-    /* Force a reschedule if xTaskResumeAll has not already done so, we may
-    have put ourselves to sleep. */
-    if (xAlreadyYielded == pdFALSE) {
-        portYIELD_WITHIN_API();
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-}
-
-#endif /* INCLUDE_vTaskDelayUntil */
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_vTaskDelay == 1)
-
-void vTaskDelay(const TickType_t xTicksToDelay)
-{
-    BaseType_t xAlreadyYielded = pdFALSE;
-
-    /* A delay time of zero just forces a reschedule. */
-    if (xTicksToDelay > (TickType_t)0U) {
-        configASSERT(uxSchedulerSuspended == 0);
-        vTaskSuspendAll();
-        {
-            traceTASK_DELAY();
-
-            /* A task that is removed from the event list while the
-            scheduler is suspended will not get placed in the ready
-            list or removed from the blocked list until the scheduler
-            is resumed.
-
-            This task cannot be in an event list as it is the currently
-            executing task. */
-            prvAddCurrentTaskToDelayedList(xTicksToDelay, pdFALSE);
-        }
-        xAlreadyYielded = xTaskResumeAll();
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    /* Force a reschedule if xTaskResumeAll has not already done so, we may
-    have put ourselves to sleep. */
-    if (xAlreadyYielded == pdFALSE) {
-        portYIELD_WITHIN_API();
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-}
-
-#endif /* INCLUDE_vTaskDelay */
-/*-----------------------------------------------------------*/
-
-#if ( \
-    (INCLUDE_eTaskGetState == 1) || (configUSE_TRACE_FACILITY == 1) || \
-    (INCLUDE_xTaskAbortDelay == 1))
-
-eTaskState eTaskGetState(TaskHandle_t xTask)
-{
-    eTaskState eReturn;
-    List_t const *pxStateList, *pxDelayedList, *pxOverflowedDelayedList;
-    const TCB_t *const pxTCB = xTask;
-
-    configASSERT(pxTCB);
-
-    if (pxTCB == pxCurrentTCB) {
-        /* The task calling this function is querying its own state. */
-        eReturn = eRunning;
-    } else {
-        taskENTER_CRITICAL();
-        {
-            pxStateList = listLIST_ITEM_CONTAINER(&(pxTCB->xStateListItem));
-            pxDelayedList = pxDelayedTaskList;
-            pxOverflowedDelayedList = pxOverflowDelayedTaskList;
-        }
-        taskEXIT_CRITICAL();
-
-        if ((pxStateList == pxDelayedList) ||
-            (pxStateList == pxOverflowedDelayedList)) {
-            /* The task being queried is referenced from one of the Blocked
-            lists. */
-            eReturn = eBlocked;
-        }
-#    if (INCLUDE_vTaskSuspend == 1)
-        else if (pxStateList == &xSuspendedTaskList) {
-            /* The task being queried is referenced from the suspended
-            list.  Is it genuinely suspended or is it blocked
-            indefinitely? */
-            if (listLIST_ITEM_CONTAINER(&(pxTCB->xEventListItem)) == NULL) {
-#        if (configUSE_TASK_NOTIFICATIONS == 1)
-                {
-                    /* The task does not appear on the event list item of
-                    and of the RTOS objects, but could still be in the
-                    blocked state if it is waiting on its notification
-                    rather than waiting on an object. */
-                    if (pxTCB->ucNotifyState == taskWAITING_NOTIFICATION) {
-                        eReturn = eBlocked;
-                    } else {
-                        eReturn = eSuspended;
-                    }
-                }
-#        else
-                {
-                    eReturn = eSuspended;
-                }
-#        endif
-            } else {
-                eReturn = eBlocked;
-            }
-        }
-#    endif
-
-#    if (INCLUDE_vTaskDelete == 1)
-        else if (
-            (pxStateList == &xTasksWaitingTermination) ||
-            (pxStateList == NULL)) {
-            /* The task being queried is referenced from the deleted
-            tasks list, or it is not referenced from any lists at
-            all. */
-            eReturn = eDeleted;
-        }
-#    endif
-
-        else /*lint !e525 Negative indentation is intended to make use of
-                pre-processor clearer. */
-        {
-            /* If the task is not in any other state, it must be in the
-            Ready (including pending ready) state. */
-            eReturn = eReady;
-        }
-    }
-
-    return eReturn;
-} /*lint !e818 xTask cannot be a pointer to const because it is a typedef. */
-
-#endif /* INCLUDE_eTaskGetState */
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_uxTaskPriorityGet == 1)
-
-UBaseType_t uxTaskPriorityGet(const TaskHandle_t xTask)
-{
-    TCB_t const *pxTCB;
-    UBaseType_t uxReturn;
-
-    taskENTER_CRITICAL();
-    {
-        /* If null is passed in here then it is the priority of the task
-        that called uxTaskPriorityGet() that is being queried. */
-        pxTCB = prvGetTCBFromHandle(xTask);
-        uxReturn = pxTCB->uxPriority;
-    }
-    taskEXIT_CRITICAL();
-
-    return uxReturn;
-}
-
-#endif /* INCLUDE_uxTaskPriorityGet */
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_uxTaskPriorityGet == 1)
-
-UBaseType_t uxTaskPriorityGetFromISR(const TaskHandle_t xTask)
-{
-    TCB_t const *pxTCB;
-    UBaseType_t uxReturn, uxSavedInterruptState;
-
-    /* RTOS ports that support interrupt nesting have the concept of a
-    maximum	system call (or maximum API call) interrupt priority.
-    Interrupts that are	above the maximum system call priority are keep
-    permanently enabled, even when the RTOS kernel is in a critical section,
-    but cannot make any calls to FreeRTOS API functions.  If configASSERT()
-    is defined in FreeRTOSConfig.h then
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
-    failure if a FreeRTOS API function is called from an interrupt that has
-    been assigned a priority above the configured maximum system call
-    priority.  Only FreeRTOS functions that end in FromISR can be called
-    from interrupts	that have been assigned a priority at or (logically)
-    below the maximum system call interrupt priority.  FreeRTOS maintains a
-    separate interrupt safe API to ensure interrupt entry is as fast and as
-    simple as possible.  More information (albeit Cortex-M specific) is
-    provided on the following link:
-    https://www.freertos.org/RTOS-Cortex-M3-M4.html */
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
-
-    uxSavedInterruptState = portSET_INTERRUPT_MASK_FROM_ISR();
-    {
-        /* If null is passed in here then it is the priority of the calling
-        task that is being queried. */
-        pxTCB = prvGetTCBFromHandle(xTask);
-        uxReturn = pxTCB->uxPriority;
-    }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptState);
-
-    return uxReturn;
-}
-
-#endif /* INCLUDE_uxTaskPriorityGet */
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_vTaskPrioritySet == 1)
-
-void vTaskPrioritySet(TaskHandle_t xTask, UBaseType_t uxNewPriority)
-{
-    TCB_t *pxTCB;
-    UBaseType_t uxCurrentBasePriority, uxPriorityUsedOnEntry;
-    BaseType_t xYieldRequired = pdFALSE;
-
-    configASSERT((uxNewPriority < configMAX_PRIORITIES));
-
-    /* Ensure the new priority is valid. */
-    if (uxNewPriority >= (UBaseType_t)configMAX_PRIORITIES) {
-        uxNewPriority = (UBaseType_t)configMAX_PRIORITIES - (UBaseType_t)1U;
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    taskENTER_CRITICAL();
-    {
-        /* If null is passed in here then it is the priority of the calling
-        task that is being changed. */
-        pxTCB = prvGetTCBFromHandle(xTask);
-
-        traceTASK_PRIORITY_SET(pxTCB, uxNewPriority);
-
-#    if (configUSE_MUTEXES == 1)
-        {
-            uxCurrentBasePriority = pxTCB->uxBasePriority;
-        }
-#    else
-        {
-            uxCurrentBasePriority = pxTCB->uxPriority;
-        }
-#    endif
-
-        if (uxCurrentBasePriority != uxNewPriority) {
-            /* The priority change may have readied a task of higher
-            priority than the calling task. */
-            if (uxNewPriority > uxCurrentBasePriority) {
-                if (pxTCB != pxCurrentTCB) {
-                    /* The priority of a task other than the currently
-                    running task is being raised.  Is the priority being
-                    raised above that of the running task? */
-                    if (uxNewPriority >= pxCurrentTCB->uxPriority) {
-                        xYieldRequired = pdTRUE;
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                } else {
-                    /* The priority of the running task is being raised,
-                    but the running task must already be the highest
-                    priority task able to run so no yield is required. */
-                }
-            } else if (pxTCB == pxCurrentTCB) {
-                /* Setting the priority of the running task down means
-                there may now be another task of higher priority that
-                is ready to execute. */
-                xYieldRequired = pdTRUE;
-            } else {
-                /* Setting the priority of any other task down does not
-                require a yield as the running task must be above the
-                new priority of the task being modified. */
-            }
-
-            /* Remember the ready list the task might be referenced from
-            before its uxPriority member is changed so the
-            taskRESET_READY_PRIORITY() macro can function correctly. */
-            uxPriorityUsedOnEntry = pxTCB->uxPriority;
-
-#    if (configUSE_MUTEXES == 1)
-            {
-                /* Only change the priority being used if the task is not
-                currently using an inherited priority. */
-                if (pxTCB->uxBasePriority == pxTCB->uxPriority) {
-                    pxTCB->uxPriority = uxNewPriority;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-
-                /* The base priority gets set whatever. */
-                pxTCB->uxBasePriority = uxNewPriority;
-            }
-#    else
-            {
-                pxTCB->uxPriority = uxNewPriority;
-            }
-#    endif
-
-            /* Only reset the event list item value if the value is not
-            being used for anything else. */
-            if ((listGET_LIST_ITEM_VALUE(&(pxTCB->xEventListItem)) &
-                 taskEVENT_LIST_ITEM_VALUE_IN_USE) == 0UL) {
-                listSET_LIST_ITEM_VALUE(
-                    &(pxTCB->xEventListItem),
-                    ((TickType_t)configMAX_PRIORITIES -
-                     (TickType_t)
-                         uxNewPriority)); /*lint !e961 MISRA exception as the
-                                             casts are only redundant for some
-                                             ports. */
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-
-            /* If the task is in the blocked or suspended list we need do
-            nothing more than change its priority variable. However, if
-            the task is in a ready list it needs to be removed and placed
-            in the list appropriate to its new priority. */
-            if (listIS_CONTAINED_WITHIN(
-                    &(pxReadyTasksLists[uxPriorityUsedOnEntry]),
-                    &(pxTCB->xStateListItem)) != pdFALSE) {
-                /* The task is currently in its ready list - remove before
-                adding it to it's new ready list.  As we are in a critical
-                section we can do this even if the scheduler is suspended. */
-                if (uxListRemove(&(pxTCB->xStateListItem)) == (UBaseType_t)0) {
-                    /* It is known that the task is in its ready list so
-                    there is no need to check again and the port level
-                    reset macro can be called directly. */
-                    portRESET_READY_PRIORITY(
-                        uxPriorityUsedOnEntry, uxTopReadyPriority);
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-                prvAddTaskToReadyList(pxTCB);
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-
-            if (xYieldRequired != pdFALSE) {
-                taskYIELD_IF_USING_PREEMPTION();
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-
-            /* Remove compiler warning about unused variables when the port
-            optimised task selection is not being used. */
-            (void)uxPriorityUsedOnEntry;
-        }
-    }
-    taskEXIT_CRITICAL();
-}
-
-#endif /* INCLUDE_vTaskPrioritySet */
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_vTaskSuspend == 1)
-
-void vTaskSuspend(TaskHandle_t xTaskToSuspend)
-{
-    TCB_t *pxTCB;
-
-    taskENTER_CRITICAL();
-    {
-        /* If null is passed in here then it is the running task that is
-        being suspended. */
-        pxTCB = prvGetTCBFromHandle(xTaskToSuspend);
-
-        traceTASK_SUSPEND(pxTCB);
-
-        /* Remove task from the ready/delayed list and place in the
-        suspended list. */
-        if (uxListRemove(&(pxTCB->xStateListItem)) == (UBaseType_t)0) {
-            taskRESET_READY_PRIORITY(pxTCB->uxPriority);
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-
-        /* Is the task waiting on an event also? */
-        if (listLIST_ITEM_CONTAINER(&(pxTCB->xEventListItem)) != NULL) {
-            (void)uxListRemove(&(pxTCB->xEventListItem));
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-
-        vListInsertEnd(&xSuspendedTaskList, &(pxTCB->xStateListItem));
-
-#    if (configUSE_TASK_NOTIFICATIONS == 1)
-        {
-            if (pxTCB->ucNotifyState == taskWAITING_NOTIFICATION) {
-                /* The task was blocked to wait for a notification, but is
-                now suspended, so no notification was received. */
-                pxTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
-            }
-        }
-#    endif
-    }
-    taskEXIT_CRITICAL();
-
-    if (xSchedulerRunning != pdFALSE) {
-        /* Reset the next expected unblock time in case it referred to the
-        task that is now in the Suspended state. */
-        taskENTER_CRITICAL();
-        {
-            prvResetNextTaskUnblockTime();
-        }
-        taskEXIT_CRITICAL();
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    if (pxTCB == pxCurrentTCB) {
-        if (xSchedulerRunning != pdFALSE) {
-            /* The current task has just been suspended. */
-            configASSERT(uxSchedulerSuspended == 0);
-            portYIELD_WITHIN_API();
-        } else {
-            /* The scheduler is not running, but the task that was pointed
-            to by pxCurrentTCB has just been suspended and pxCurrentTCB
-            must be adjusted to point to a different task. */
-            if (listCURRENT_LIST_LENGTH(&xSuspendedTaskList) ==
-                uxCurrentNumberOfTasks) /*lint !e931 Right has no side effect,
-                                           just volatile. */
-            {
-                /* No other tasks are ready, so set pxCurrentTCB back to
-                NULL so when the next task is created pxCurrentTCB will
-                be set to point to it no matter what its relative priority
-                is. */
-                pxCurrentTCB = NULL;
-            } else {
-                vTaskSwitchContext();
-            }
-        }
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-}
-
-#endif /* INCLUDE_vTaskSuspend */
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_vTaskSuspend == 1)
-
-static BaseType_t prvTaskIsTaskSuspended(const TaskHandle_t xTask)
-{
-    BaseType_t xReturn = pdFALSE;
-    const TCB_t *const pxTCB = xTask;
-
-    /* Accesses xPendingReadyList so must be called from a critical
-    section. */
-
-    /* It does not make sense to check if the calling task is suspended. */
-    configASSERT(xTask);
-
-    /* Is the task being resumed actually in the suspended list? */
-    if (listIS_CONTAINED_WITHIN(
-            &xSuspendedTaskList, &(pxTCB->xStateListItem)) != pdFALSE) {
-        /* Has the task already been resumed from within an ISR? */
-        if (listIS_CONTAINED_WITHIN(
-                &xPendingReadyList, &(pxTCB->xEventListItem)) == pdFALSE) {
-            /* Is it in the suspended list because it is in the	Suspended
-            state, or because is is blocked with no timeout? */
-            if (listIS_CONTAINED_WITHIN(NULL, &(pxTCB->xEventListItem)) !=
-                pdFALSE) /*lint !e961.  The cast is only redundant when NULL is
-                            used. */
-            {
-                xReturn = pdTRUE;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    return xReturn;
-} /*lint !e818 xTask cannot be a pointer to const because it is a typedef. */
-
-#endif /* INCLUDE_vTaskSuspend */
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_vTaskSuspend == 1)
-
-void vTaskResume(TaskHandle_t xTaskToResume)
-{
-    TCB_t *const pxTCB = xTaskToResume;
-
-    /* It does not make sense to resume the calling task. */
-    configASSERT(xTaskToResume);
-
-    /* The parameter cannot be NULL as it is impossible to resume the
-    currently executing task. */
-    if ((pxTCB != pxCurrentTCB) && (pxTCB != NULL)) {
-        taskENTER_CRITICAL();
-        {
-            if (prvTaskIsTaskSuspended(pxTCB) != pdFALSE) {
-                traceTASK_RESUME(pxTCB);
-
-                /* The ready list can be accessed even if the scheduler is
-                suspended because this is inside a critical section. */
-                (void)uxListRemove(&(pxTCB->xStateListItem));
-                prvAddTaskToReadyList(pxTCB);
-
-                /* A higher priority task may have just been resumed. */
-                if (pxTCB->uxPriority >= pxCurrentTCB->uxPriority) {
-                    /* This yield may not cause the task just resumed to run,
-                    but will leave the lists in the correct state for the
-                    next yield. */
-                    taskYIELD_IF_USING_PREEMPTION();
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-        taskEXIT_CRITICAL();
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-}
-
-#endif /* INCLUDE_vTaskSuspend */
-
-/*-----------------------------------------------------------*/
-
-#if ((INCLUDE_xTaskResumeFromISR == 1) && (INCLUDE_vTaskSuspend == 1))
-
-BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume)
-{
-    BaseType_t xYieldRequired = pdFALSE;
-    TCB_t *const pxTCB = xTaskToResume;
-    UBaseType_t uxSavedInterruptStatus;
-
-    configASSERT(xTaskToResume);
-
-    /* RTOS ports that support interrupt nesting have the concept of a
-    maximum	system call (or maximum API call) interrupt priority.
-    Interrupts that are	above the maximum system call priority are keep
-    permanently enabled, even when the RTOS kernel is in a critical section,
-    but cannot make any calls to FreeRTOS API functions.  If configASSERT()
-    is defined in FreeRTOSConfig.h then
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
-    failure if a FreeRTOS API function is called from an interrupt that has
-    been assigned a priority above the configured maximum system call
-    priority.  Only FreeRTOS functions that end in FromISR can be called
-    from interrupts	that have been assigned a priority at or (logically)
-    below the maximum system call interrupt priority.  FreeRTOS maintains a
-    separate interrupt safe API to ensure interrupt entry is as fast and as
-    simple as possible.  More information (albeit Cortex-M specific) is
-    provided on the following link:
-    https://www.freertos.org/RTOS-Cortex-M3-M4.html */
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
-
-    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
-    {
-        if (prvTaskIsTaskSuspended(pxTCB) != pdFALSE) {
-            traceTASK_RESUME_FROM_ISR(pxTCB);
-
-            /* Check the ready lists can be accessed. */
-            if (uxSchedulerSuspended == (UBaseType_t)pdFALSE) {
-                /* Ready lists can be accessed so move the task from the
-                suspended list to the ready list directly. */
-                if (pxTCB->uxPriority >= pxCurrentTCB->uxPriority) {
-                    xYieldRequired = pdTRUE;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-
-                (void)uxListRemove(&(pxTCB->xStateListItem));
-                prvAddTaskToReadyList(pxTCB);
-            } else {
-                /* The delayed or ready lists cannot be accessed so the task
-                is held in the pending ready list until the scheduler is
-                unsuspended. */
-                vListInsertEnd(&(xPendingReadyList), &(pxTCB->xEventListItem));
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus);
-
-    return xYieldRequired;
-}
-
-#endif /* ( ( INCLUDE_xTaskResumeFromISR == 1 ) && ( INCLUDE_vTaskSuspend == 1 \
-          ) ) */
-/*-----------------------------------------------------------*/
-
-void vTaskStartScheduler(void)
-{
-    BaseType_t xReturn;
-
-/* Add the idle task at the lowest priority. */
-#if (configSUPPORT_STATIC_ALLOCATION == 1)
-    {
-        StaticTask_t *pxIdleTaskTCBBuffer = NULL;
-        StackType_t *pxIdleTaskStackBuffer = NULL;
-        uint32_t ulIdleTaskStackSize;
-
-        /* The Idle task is created using user provided RAM - obtain the
-        address of the RAM then create the idle task. */
-        vApplicationGetIdleTaskMemory(
-            &pxIdleTaskTCBBuffer, &pxIdleTaskStackBuffer, &ulIdleTaskStackSize);
-        xIdleTaskHandle = xTaskCreateStatic(
-            prvIdleTask,
-            configIDLE_TASK_NAME,
-            ulIdleTaskStackSize,
-            (void *)NULL, /*lint !e961.  The cast is not redundant for all
-                             compilers. */
-            portPRIVILEGE_BIT, /* In effect ( tskIDLE_PRIORITY |
-                                  portPRIVILEGE_BIT ), but tskIDLE_PRIORITY is
-                                  zero. */
-            pxIdleTaskStackBuffer,
-            pxIdleTaskTCBBuffer); /*lint !e961 MISRA exception, justified as it
-                                     is not a redundant explicit cast to all
-                                     supported compilers. */
-
-        if (xIdleTaskHandle != NULL) {
-            xReturn = pdPASS;
-        } else {
-            xReturn = pdFAIL;
-        }
-    }
-#else
-    {
-        /* The Idle task is being created using dynamically allocated RAM. */
-        xReturn = xTaskCreate(
-            prvIdleTask,
-            configIDLE_TASK_NAME,
-            configMINIMAL_STACK_SIZE,
-            (void *)NULL,
-            portPRIVILEGE_BIT, /* In effect ( tskIDLE_PRIORITY |
-                                  portPRIVILEGE_BIT ), but tskIDLE_PRIORITY is
-                                  zero. */
-            &xIdleTaskHandle); /*lint !e961 MISRA exception, justified as it is
-                                  not a redundant explicit cast to all supported
-                                  compilers. */
-    }
-#endif /* configSUPPORT_STATIC_ALLOCATION */
-
-#if (configUSE_TIMERS == 1)
-    {
-        if (xReturn == pdPASS) {
-            xReturn = xTimerCreateTimerTask();
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-#endif /* configUSE_TIMERS */
-
-    if (xReturn == pdPASS) {
-/* freertos_tasks_c_additions_init() should only be called if the user
-definable macro FREERTOS_TASKS_C_ADDITIONS_INIT() is defined, as that is
-the only macro called by the function. */
-#ifdef FREERTOS_TASKS_C_ADDITIONS_INIT
-        {
-            freertos_tasks_c_additions_init();
-        }
-#endif
-
-        /* Interrupts are turned off here, to ensure a tick does not occur
-        before or during the call to xPortStartScheduler().  The stacks of
-        the created tasks contain a status word with interrupts switched on
-        so interrupts will automatically get re-enabled when the first task
-        starts to run. */
-        portDISABLE_INTERRUPTS();
-
-#if (configUSE_NEWLIB_REENTRANT == 1)
-        {
-            /* Switch Newlib's _impure_ptr variable to point to the _reent
-            structure specific to the task that will run first.
-            See the third party link
-            http://www.nadler.com/embedded/newlibAndFreeRTOS.html
-            for additional information. */
-            _impure_ptr = &(pxCurrentTCB->xNewLib_reent);
-        }
-#endif /* configUSE_NEWLIB_REENTRANT */
-
-        xNextTaskUnblockTime = portMAX_DELAY;
-        xSchedulerRunning = pdTRUE;
-        xTickCount = (TickType_t)configINITIAL_TICK_COUNT;
-
-        /* If configGENERATE_RUN_TIME_STATS is defined then the following
-        macro must be defined to configure the timer/counter used to generate
-        the run time counter time base.   NOTE:  If
-        configGENERATE_RUN_TIME_STATS is set to 0 and the following line fails
-        to build then ensure you do not have
-        portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() defined in your
-        FreeRTOSConfig.h file. */
-        portCONFIGURE_TIMER_FOR_RUN_TIME_STATS();
-
-        traceTASK_SWITCHED_IN();
-
-        /* Setting up the timer tick is hardware specific and thus in the
-        portable interface. */
-        if (xPortStartScheduler() != pdFALSE) {
-            /* Should not reach here as if the scheduler is running the
-            function will not return. */
-        } else {
-            /* Should only reach here if a task calls xTaskEndScheduler(). */
-        }
-    } else {
-        /* This line will only be reached if the kernel could not be started,
-        because there was not enough FreeRTOS heap to create the idle task
-        or the timer task. */
-        configASSERT(xReturn != errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY);
-    }
-
-    /* Prevent compiler warnings if INCLUDE_xTaskGetIdleTaskHandle is set to 0,
-    meaning xIdleTaskHandle is not used anywhere else. */
-    (void)xIdleTaskHandle;
-}
-/*-----------------------------------------------------------*/
-
-void vTaskEndScheduler(void)
-{
-    /* Stop the scheduler interrupts and call the portable scheduler end
-    routine so the original ISRs can be restored if necessary.  The port
-    layer must ensure interrupts enable	bit is left in the correct state. */
-    portDISABLE_INTERRUPTS();
-    xSchedulerRunning = pdFALSE;
-    vPortEndScheduler();
-}
-/*----------------------------------------------------------*/
-
-void vTaskSuspendAll(void)
-{
-    /* A critical section is not required as the variable is of type
-    BaseType_t.  Please read Richard Barry's reply in the following link to a
-    post in the FreeRTOS support forum before reporting this as a bug! -
-    http://goo.gl/wu4acr */
-
-    /* portSOFRWARE_BARRIER() is only implemented for emulated/simulated ports
-    that do not otherwise exhibit real time behaviour. */
-    portSOFTWARE_BARRIER();
-
-    /* The scheduler is suspended if uxSchedulerSuspended is non-zero.  An
-    increment is used to allow calls to vTaskSuspendAll() to nest. */
-    ++uxSchedulerSuspended;
-
-    /* Enforces ordering for ports and optimised compilers that may otherwise
-    place the above increment elsewhere. */
-    portMEMORY_BARRIER();
-}
-/*----------------------------------------------------------*/
-
-#if (configUSE_TICKLESS_IDLE != 0)
-
-static TickType_t prvGetExpectedIdleTime(void)
-{
-    TickType_t xReturn;
-    UBaseType_t uxHigherPriorityReadyTasks = pdFALSE;
-
-/* uxHigherPriorityReadyTasks takes care of the case where
-configUSE_PREEMPTION is 0, so there may be tasks above the idle priority
-task that are in the Ready state, even though the idle task is
-running. */
-#    if (configUSE_PORT_OPTIMISED_TASK_SELECTION == 0)
-    {
-        if (uxTopReadyPriority > tskIDLE_PRIORITY) {
-            uxHigherPriorityReadyTasks = pdTRUE;
-        }
-    }
-#    else
-    {
-        const UBaseType_t uxLeastSignificantBit = (UBaseType_t)0x01;
-
-        /* When port optimised task selection is used the uxTopReadyPriority
-        variable is used as a bit map.  If bits other than the least
-        significant bit are set then there are tasks that have a priority
-        above the idle priority that are in the Ready state.  This takes
-        care of the case where the co-operative scheduler is in use. */
-        if (uxTopReadyPriority > uxLeastSignificantBit) {
-            uxHigherPriorityReadyTasks = pdTRUE;
-        }
-    }
-#    endif
-
-    if (pxCurrentTCB->uxPriority > tskIDLE_PRIORITY) {
-        xReturn = 0;
-    } else if (
-        listCURRENT_LIST_LENGTH(&(pxReadyTasksLists[tskIDLE_PRIORITY])) > 1) {
-        /* There are other idle priority tasks in the ready state.  If
-        time slicing is used then the very next tick interrupt must be
-        processed. */
-        xReturn = 0;
-    } else if (uxHigherPriorityReadyTasks != pdFALSE) {
-        /* There are tasks in the Ready state that have a priority above the
-        idle priority.  This path can only be reached if
-        configUSE_PREEMPTION is 0. */
-        xReturn = 0;
-    } else {
-        xReturn = xNextTaskUnblockTime - xTickCount;
-    }
-
-    return xReturn;
-}
-
-#endif /* configUSE_TICKLESS_IDLE */
-/*----------------------------------------------------------*/
-
-BaseType_t xTaskResumeAll(void)
-{
-    TCB_t *pxTCB = NULL;
-    BaseType_t xAlreadyYielded = pdFALSE;
-
-    /* If uxSchedulerSuspended is zero then this function does not match a
-    previous call to vTaskSuspendAll(). */
-    configASSERT(uxSchedulerSuspended);
-
-    /* It is possible that an ISR caused a task to be removed from an event
-    list while the scheduler was suspended.  If this was the case then the
-    removed task will have been added to the xPendingReadyList.  Once the
-    scheduler has been resumed it is safe to move all the pending ready
-    tasks from this list into their appropriate ready list. */
-    taskENTER_CRITICAL();
-    {
-        --uxSchedulerSuspended;
-
-        if (uxSchedulerSuspended == (UBaseType_t)pdFALSE) {
-            if (uxCurrentNumberOfTasks > (UBaseType_t)0U) {
-                /* Move any readied tasks from the pending list into the
-                appropriate ready list. */
-                while (listLIST_IS_EMPTY(&xPendingReadyList) == pdFALSE) {
-                    pxTCB = listGET_OWNER_OF_HEAD_ENTRY(
-                        (&xPendingReadyList)); /*lint !e9079 void * is used as
-                                                  this macro is used with timers
-                                                  and co-routines too. Alignment
-                                                  is known to be fine as the
-                                                  type of the pointer stored and
-                                                  retrieved is the same. */
-                    (void)uxListRemove(&(pxTCB->xEventListItem));
-                    (void)uxListRemove(&(pxTCB->xStateListItem));
-                    prvAddTaskToReadyList(pxTCB);
-
-                    /* If the moved task has a priority higher than the current
-                    task then a yield must be performed. */
-                    if (pxTCB->uxPriority >= pxCurrentTCB->uxPriority) {
-                        xYieldPending = pdTRUE;
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                }
-
-                if (pxTCB != NULL) {
-                    /* A task was unblocked while the scheduler was suspended,
-                    which may have prevented the next unblock time from being
-                    re-calculated, in which case re-calculate it now.  Mainly
-                    important for low power tickless implementations, where
-                    this can prevent an unnecessary exit from low power
-                    state. */
-                    prvResetNextTaskUnblockTime();
-                }
-
-                /* If any ticks occurred while the scheduler was suspended then
-                they should be processed now.  This ensures the tick count does
-                not	slip, and that any delayed tasks are resumed at the correct
-                time. */
-                {
-                    TickType_t xPendedCounts =
-                        xPendedTicks; /* Non-volatile copy. */
-
-                    if (xPendedCounts > (TickType_t)0U) {
-                        do {
-                            if (xTaskIncrementTick() != pdFALSE) {
-                                xYieldPending = pdTRUE;
-                            } else {
-                                mtCOVERAGE_TEST_MARKER();
-                            }
-                            --xPendedCounts;
-                        } while (xPendedCounts > (TickType_t)0U);
-
-                        xPendedTicks = 0;
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                }
-
-                if (xYieldPending != pdFALSE) {
-#if (configUSE_PREEMPTION != 0)
-                    {
-                        xAlreadyYielded = pdTRUE;
-                    }
-#endif
-                    taskYIELD_IF_USING_PREEMPTION();
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    return xAlreadyYielded;
-}
-/*-----------------------------------------------------------*/
-
-TickType_t xTaskGetTickCount(void)
-{
-    TickType_t xTicks;
-
-    /* Critical section required if running on a 16 bit processor. */
-    portTICK_TYPE_ENTER_CRITICAL();
-    {
-        xTicks = xTickCount;
-    }
-    portTICK_TYPE_EXIT_CRITICAL();
-
-    return xTicks;
-}
-/*-----------------------------------------------------------*/
-
-TickType_t xTaskGetTickCountFromISR(void)
-{
-    TickType_t xReturn;
-    UBaseType_t uxSavedInterruptStatus;
-
-    /* RTOS ports that support interrupt nesting have the concept of a maximum
-    system call (or maximum API call) interrupt priority.  Interrupts that are
-    above the maximum system call priority are kept permanently enabled, even
-    when the RTOS kernel is in a critical section, but cannot make any calls to
-    FreeRTOS API functions.  If configASSERT() is defined in FreeRTOSConfig.h
-    then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
-    failure if a FreeRTOS API function is called from an interrupt that has been
-    assigned a priority above the configured maximum system call priority.
-    Only FreeRTOS functions that end in FromISR can be called from interrupts
-    that have been assigned a priority at or (logically) below the maximum
-    system call	interrupt priority.  FreeRTOS maintains a separate interrupt
-    safe API to ensure interrupt entry is as fast and as simple as possible.
-    More information (albeit Cortex-M specific) is provided on the following
-    link: https://www.freertos.org/RTOS-Cortex-M3-M4.html */
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
-
-    uxSavedInterruptStatus = portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR();
-    {
-        xReturn = xTickCount;
-    }
-    portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus);
-
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-UBaseType_t uxTaskGetNumberOfTasks(void)
-{
-    /* A critical section is not required because the variables are of type
-    BaseType_t. */
-    return uxCurrentNumberOfTasks;
-}
-/*-----------------------------------------------------------*/
-
-char *pcTaskGetName(
-    TaskHandle_t xTaskToQuery) /*lint !e971 Unqualified char types are allowed
-                                  for strings and single characters only. */
-{
-    TCB_t *pxTCB;
-
-    /* If null is passed in here then the name of the calling task is being
-    queried. */
-    pxTCB = prvGetTCBFromHandle(xTaskToQuery);
-    configASSERT(pxTCB);
-    return &(pxTCB->pcTaskName[0]);
-}
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_xTaskGetHandle == 1)
-
-static TCB_t *prvSearchForNameWithinSingleList(
-    List_t *pxList,
-    const char pcNameToQuery[])
-{
-    TCB_t *pxNextTCB, *pxFirstTCB, *pxReturn = NULL;
-    UBaseType_t x;
-    char cNextChar;
-    BaseType_t xBreakLoop;
-
-    /* This function is called with the scheduler suspended. */
-
-    if (listCURRENT_LIST_LENGTH(pxList) > (UBaseType_t)0) {
-        listGET_OWNER_OF_NEXT_ENTRY(
-            pxFirstTCB,
-            pxList); /*lint !e9079 void * is used as this macro is used with
-                        timers and co-routines too.  Alignment is known to be
-                        fine as the type of the pointer stored and retrieved is
-                        the same. */
-
-        do {
-            listGET_OWNER_OF_NEXT_ENTRY(
-                pxNextTCB,
-                pxList); /*lint !e9079 void * is used as this macro is used with
-                            timers and co-routines too.  Alignment is known to
-                            be fine as the type of the pointer stored and
-                            retrieved is the same. */
-
-            /* Check each character in the name looking for a match or
-            mismatch. */
-            xBreakLoop = pdFALSE;
-            for (x = (UBaseType_t)0; x < (UBaseType_t)configMAX_TASK_NAME_LEN;
-                 x++) {
-                cNextChar = pxNextTCB->pcTaskName[x];
-
-                if (cNextChar != pcNameToQuery[x]) {
-                    /* Characters didn't match. */
-                    xBreakLoop = pdTRUE;
-                } else if (cNextChar == (char)0x00) {
-                    /* Both strings terminated, a match must have been
-                    found. */
-                    pxReturn = pxNextTCB;
-                    xBreakLoop = pdTRUE;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-
-                if (xBreakLoop != pdFALSE) {
-                    break;
-                }
-            }
-
-            if (pxReturn != NULL) {
-                /* The handle has been found. */
-                break;
-            }
-
-        } while (pxNextTCB != pxFirstTCB);
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    return pxReturn;
-}
-
-#endif /* INCLUDE_xTaskGetHandle */
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_xTaskGetHandle == 1)
-
-TaskHandle_t xTaskGetHandle(
-    const char *pcNameToQuery) /*lint !e971 Unqualified char types are allowed
-                                  for strings and single characters only. */
-{
-    UBaseType_t uxQueue = configMAX_PRIORITIES;
-    TCB_t *pxTCB;
-
-    /* Task names will be truncated to configMAX_TASK_NAME_LEN - 1 bytes. */
-    configASSERT(strlen(pcNameToQuery) < configMAX_TASK_NAME_LEN);
-
-    vTaskSuspendAll();
-    {
-        /* Search the ready lists. */
-        do {
-            uxQueue--;
-            pxTCB = prvSearchForNameWithinSingleList(
-                (List_t *)&(pxReadyTasksLists[uxQueue]), pcNameToQuery);
-
-            if (pxTCB != NULL) {
-                /* Found the handle. */
-                break;
-            }
-
-        } while (
-            uxQueue >
-            (UBaseType_t)
-                tskIDLE_PRIORITY); /*lint !e961 MISRA exception as the casts are
-                                      only redundant for some ports. */
-
-        /* Search the delayed lists. */
-        if (pxTCB == NULL) {
-            pxTCB = prvSearchForNameWithinSingleList(
-                (List_t *)pxDelayedTaskList, pcNameToQuery);
-        }
-
-        if (pxTCB == NULL) {
-            pxTCB = prvSearchForNameWithinSingleList(
-                (List_t *)pxOverflowDelayedTaskList, pcNameToQuery);
-        }
-
-#    if (INCLUDE_vTaskSuspend == 1)
-        {
-            if (pxTCB == NULL) {
-                /* Search the suspended list. */
-                pxTCB = prvSearchForNameWithinSingleList(
-                    &xSuspendedTaskList, pcNameToQuery);
-            }
-        }
-#    endif
-
-#    if (INCLUDE_vTaskDelete == 1)
-        {
-            if (pxTCB == NULL) {
-                /* Search the deleted list. */
-                pxTCB = prvSearchForNameWithinSingleList(
-                    &xTasksWaitingTermination, pcNameToQuery);
-            }
-        }
-#    endif
-    }
-    (void)xTaskResumeAll();
-
-    return pxTCB;
-}
-
-#endif /* INCLUDE_xTaskGetHandle */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TRACE_FACILITY == 1)
-
-UBaseType_t uxTaskGetSystemState(
-    TaskStatus_t *const pxTaskStatusArray,
-    const UBaseType_t uxArraySize,
-    uint32_t *const pulTotalRunTime)
-{
-    UBaseType_t uxTask = 0, uxQueue = configMAX_PRIORITIES;
-
-    vTaskSuspendAll();
-    {
-        /* Is there a space in the array for each task in the system? */
-        if (uxArraySize >= uxCurrentNumberOfTasks) {
-            /* Fill in an TaskStatus_t structure with information on each
-            task in the Ready state. */
-            do {
-                uxQueue--;
-                uxTask += prvListTasksWithinSingleList(
-                    &(pxTaskStatusArray[uxTask]),
-                    &(pxReadyTasksLists[uxQueue]),
-                    eReady);
-
-            } while (
-                uxQueue >
-                (UBaseType_t)
-                    tskIDLE_PRIORITY); /*lint !e961 MISRA exception as the casts
-                                          are only redundant for some ports. */
-
-            /* Fill in an TaskStatus_t structure with information on each
-            task in the Blocked state. */
-            uxTask += prvListTasksWithinSingleList(
-                &(pxTaskStatusArray[uxTask]),
-                (List_t *)pxDelayedTaskList,
-                eBlocked);
-            uxTask += prvListTasksWithinSingleList(
-                &(pxTaskStatusArray[uxTask]),
-                (List_t *)pxOverflowDelayedTaskList,
-                eBlocked);
-
-#    if (INCLUDE_vTaskDelete == 1)
-            {
-                /* Fill in an TaskStatus_t structure with information on
-                each task that has been deleted but not yet cleaned up. */
-                uxTask += prvListTasksWithinSingleList(
-                    &(pxTaskStatusArray[uxTask]),
-                    &xTasksWaitingTermination,
-                    eDeleted);
-            }
-#    endif
-
-#    if (INCLUDE_vTaskSuspend == 1)
-            {
-                /* Fill in an TaskStatus_t structure with information on
-                each task in the Suspended state. */
-                uxTask += prvListTasksWithinSingleList(
-                    &(pxTaskStatusArray[uxTask]),
-                    &xSuspendedTaskList,
-                    eSuspended);
-            }
-#    endif
-
-#    if (configGENERATE_RUN_TIME_STATS == 1)
-            {
-                if (pulTotalRunTime != NULL) {
-#        ifdef portALT_GET_RUN_TIME_COUNTER_VALUE
-                    portALT_GET_RUN_TIME_COUNTER_VALUE((*pulTotalRunTime));
-#        else
-                    *pulTotalRunTime = portGET_RUN_TIME_COUNTER_VALUE();
-#        endif
-                }
-            }
-#    else
-            {
-                if (pulTotalRunTime != NULL) {
-                    *pulTotalRunTime = 0;
-                }
-            }
-#    endif
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-    (void)xTaskResumeAll();
-
-    return uxTask;
-}
-
-#endif /* configUSE_TRACE_FACILITY */
-/*----------------------------------------------------------*/
-
-#if (INCLUDE_xTaskGetIdleTaskHandle == 1)
-
-TaskHandle_t xTaskGetIdleTaskHandle(void)
-{
-    /* If xTaskGetIdleTaskHandle() is called before the scheduler has been
-    started, then xIdleTaskHandle will be NULL. */
-    configASSERT((xIdleTaskHandle != NULL));
-    return xIdleTaskHandle;
-}
-
-#endif /* INCLUDE_xTaskGetIdleTaskHandle */
-/*----------------------------------------------------------*/
-
-/* This conditional compilation should use inequality to 0, not equality to 1.
-This is to ensure vTaskStepTick() is available when user defined low power mode
-implementations require configUSE_TICKLESS_IDLE to be set to a value other than
-1. */
-#if (configUSE_TICKLESS_IDLE != 0)
-
-void vTaskStepTick(const TickType_t xTicksToJump)
-{
-    /* Correct the tick count value after a period during which the tick
-    was suppressed.  Note this does *not* call the tick hook function for
-    each stepped tick. */
-    configASSERT((xTickCount + xTicksToJump) <= xNextTaskUnblockTime);
-    xTickCount += xTicksToJump;
-    traceINCREASE_TICK_COUNT(xTicksToJump);
-}
-
-#endif /* configUSE_TICKLESS_IDLE */
-/*----------------------------------------------------------*/
-
-BaseType_t xTaskCatchUpTicks(TickType_t xTicksToCatchUp)
-{
-    BaseType_t xYieldRequired = pdFALSE;
-
-    /* Must not be called with the scheduler suspended as the implementation
-    relies on xPendedTicks being wound down to 0 in xTaskResumeAll(). */
-    configASSERT(uxSchedulerSuspended == 0);
-
-    /* Use xPendedTicks to mimic xTicksToCatchUp number of ticks occurring when
-    the scheduler is suspended so the ticks are executed in xTaskResumeAll(). */
-    vTaskSuspendAll();
-    xPendedTicks += xTicksToCatchUp;
-    xYieldRequired = xTaskResumeAll();
-
-    return xYieldRequired;
-}
-/*----------------------------------------------------------*/
-
-#if (INCLUDE_xTaskAbortDelay == 1)
-
-BaseType_t xTaskAbortDelay(TaskHandle_t xTask)
-{
-    TCB_t *pxTCB = xTask;
-    BaseType_t xReturn;
-
-    configASSERT(pxTCB);
-
-    vTaskSuspendAll();
-    {
-        /* A task can only be prematurely removed from the Blocked state if
-        it is actually in the Blocked state. */
-        if (eTaskGetState(xTask) == eBlocked) {
-            xReturn = pdPASS;
-
-            /* Remove the reference to the task from the blocked list.  An
-            interrupt won't touch the xStateListItem because the
-            scheduler is suspended. */
-            (void)uxListRemove(&(pxTCB->xStateListItem));
-
-            /* Is the task waiting on an event also?  If so remove it from
-            the event list too.  Interrupts can touch the event list item,
-            even though the scheduler is suspended, so a critical section
-            is used. */
-            taskENTER_CRITICAL();
-            {
-                if (listLIST_ITEM_CONTAINER(&(pxTCB->xEventListItem)) != NULL) {
-                    (void)uxListRemove(&(pxTCB->xEventListItem));
-
-                    /* This lets the task know it was forcibly removed from the
-                    blocked state so it should not re-evaluate its block time
-                    and then block again. */
-                    pxTCB->ucDelayAborted = pdTRUE;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            }
-            taskEXIT_CRITICAL();
-
-            /* Place the unblocked task into the appropriate ready list. */
-            prvAddTaskToReadyList(pxTCB);
-
-/* A task being unblocked cannot cause an immediate context
-switch if preemption is turned off. */
-#    if (configUSE_PREEMPTION == 1)
-            {
-                /* Preemption is on, but a context switch should only be
-                performed if the unblocked task has a priority that is
-                equal to or higher than the currently executing task. */
-                if (pxTCB->uxPriority > pxCurrentTCB->uxPriority) {
-                    /* Pend the yield to be performed when the scheduler
-                    is unsuspended. */
-                    xYieldPending = pdTRUE;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            }
-#    endif /* configUSE_PREEMPTION */
-        } else {
-            xReturn = pdFAIL;
-        }
-    }
-    (void)xTaskResumeAll();
-
-    return xReturn;
-}
-
-#endif /* INCLUDE_xTaskAbortDelay */
-/*----------------------------------------------------------*/
-
-BaseType_t xTaskIncrementTick(void)
-{
-    TCB_t *pxTCB;
-    TickType_t xItemValue;
-    BaseType_t xSwitchRequired = pdFALSE;
-
-    /* Called by the portable layer each time a tick interrupt occurs.
-    Increments the tick then checks to see if the new tick value will cause any
-    tasks to be unblocked. */
-    traceTASK_INCREMENT_TICK(xTickCount);
-    if (uxSchedulerSuspended == (UBaseType_t)pdFALSE) {
-        /* Minor optimisation.  The tick count cannot change in this
-        block. */
-        const TickType_t xConstTickCount = xTickCount + (TickType_t)1;
-
-        /* Increment the RTOS tick, switching the delayed and overflowed
-        delayed lists if it wraps to 0. */
-        xTickCount = xConstTickCount;
-
-        if (xConstTickCount ==
-            (TickType_t)0U) /*lint !e774 'if' does not always evaluate to false
-                               as it is looking for an overflow. */
-        {
-            taskSWITCH_DELAYED_LISTS();
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-
-        /* See if this tick has made a timeout expire.  Tasks are stored in
-        the	queue in the order of their wake time - meaning once one task
-        has been found whose block time has not expired there is no need to
-        look any further down the list. */
-        if (xConstTickCount >= xNextTaskUnblockTime) {
-            for (;;) {
-                if (listLIST_IS_EMPTY(pxDelayedTaskList) != pdFALSE) {
-                    /* The delayed list is empty.  Set xNextTaskUnblockTime
-                    to the maximum possible value so it is extremely
-                    unlikely that the
-                    if( xTickCount >= xNextTaskUnblockTime ) test will pass
-                    next time through. */
-                    xNextTaskUnblockTime =
-                        portMAX_DELAY; /*lint !e961 MISRA exception as the casts
-                                          are only redundant for some ports. */
-                    break;
-                } else {
-                    /* The delayed list is not empty, get the value of the
-                    item at the head of the delayed list.  This is the time
-                    at which the task at the head of the delayed list must
-                    be removed from the Blocked state. */
-                    pxTCB = listGET_OWNER_OF_HEAD_ENTRY(
-                        pxDelayedTaskList); /*lint !e9079 void * is used as this
-                                               macro is used with timers and
-                                               co-routines too.  Alignment is
-                                               known to be fine as the type of
-                                               the pointer stored and retrieved
-                                               is the same. */
-                    xItemValue =
-                        listGET_LIST_ITEM_VALUE(&(pxTCB->xStateListItem));
-
-                    if (xConstTickCount < xItemValue) {
-                        /* It is not time to unblock this item yet, but the
-                        item value is the time at which the task at the head
-                        of the blocked list must be removed from the Blocked
-                        state -	so record the item value in
-                        xNextTaskUnblockTime. */
-                        xNextTaskUnblockTime = xItemValue;
-                        break; /*lint !e9011 Code structure here is deedmed
-                                  easier to understand with multiple breaks. */
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-
-                    /* It is time to remove the item from the Blocked state. */
-                    (void)uxListRemove(&(pxTCB->xStateListItem));
-
-                    /* Is the task waiting on an event also?  If so remove
-                    it from the event list. */
-                    if (listLIST_ITEM_CONTAINER(&(pxTCB->xEventListItem)) !=
-                        NULL) {
-                        (void)uxListRemove(&(pxTCB->xEventListItem));
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-
-                    /* Place the unblocked task into the appropriate ready
-                    list. */
-                    prvAddTaskToReadyList(pxTCB);
-
-/* A task being unblocked cannot cause an immediate
-context switch if preemption is turned off. */
-#if (configUSE_PREEMPTION == 1)
-                    {
-                        /* Preemption is on, but a context switch should
-                        only be performed if the unblocked task has a
-                        priority that is equal to or higher than the
-                        currently executing task. */
-                        if (pxTCB->uxPriority >= pxCurrentTCB->uxPriority) {
-                            xSwitchRequired = pdTRUE;
-                        } else {
-                            mtCOVERAGE_TEST_MARKER();
-                        }
-                    }
-#endif /* configUSE_PREEMPTION */
-                }
-            }
-        }
-
-/* Tasks of equal priority to the currently running task will share
-processing time (time slice) if preemption is on, and the application
-writer has not explicitly turned time slicing off. */
-#if ((configUSE_PREEMPTION == 1) && (configUSE_TIME_SLICING == 1))
-        {
-            if (listCURRENT_LIST_LENGTH(
-                    &(pxReadyTasksLists[pxCurrentTCB->uxPriority])) >
-                (UBaseType_t)1) {
-                xSwitchRequired = pdTRUE;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-#endif /* ( ( configUSE_PREEMPTION == 1 ) && ( configUSE_TIME_SLICING == 1 ) ) \
-        */
-
-#if (configUSE_TICK_HOOK == 1)
-        {
-            /* Guard against the tick hook being called when the pended tick
-            count is being unwound (when the scheduler is being unlocked). */
-            if (xPendedTicks == (TickType_t)0) {
-                vApplicationTickHook();
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-#endif /* configUSE_TICK_HOOK */
-
-#if (configUSE_PREEMPTION == 1)
-        {
-            if (xYieldPending != pdFALSE) {
-                xSwitchRequired = pdTRUE;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-#endif /* configUSE_PREEMPTION */
-    } else {
-        ++xPendedTicks;
-
-/* The tick hook gets called at regular intervals, even if the
-scheduler is locked. */
-#if (configUSE_TICK_HOOK == 1)
-        {
-            vApplicationTickHook();
-        }
-#endif
-    }
-
-    return xSwitchRequired;
-}
-/*-----------------------------------------------------------*/
-
-#if (configUSE_APPLICATION_TASK_TAG == 1)
-
-void vTaskSetApplicationTaskTag(
-    TaskHandle_t xTask,
-    TaskHookFunction_t pxHookFunction)
-{
-    TCB_t *xTCB;
-
-    /* If xTask is NULL then it is the task hook of the calling task that is
-    getting set. */
-    if (xTask == NULL) {
-        xTCB = (TCB_t *)pxCurrentTCB;
-    } else {
-        xTCB = xTask;
-    }
-
-    /* Save the hook function in the TCB.  A critical section is required as
-    the value can be accessed from an interrupt. */
-    taskENTER_CRITICAL();
-    {
-        xTCB->pxTaskTag = pxHookFunction;
-    }
-    taskEXIT_CRITICAL();
-}
-
-#endif /* configUSE_APPLICATION_TASK_TAG */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_APPLICATION_TASK_TAG == 1)
-
-TaskHookFunction_t xTaskGetApplicationTaskTag(TaskHandle_t xTask)
-{
-    TCB_t *pxTCB;
-    TaskHookFunction_t xReturn;
-
-    /* If xTask is NULL then set the calling task's hook. */
-    pxTCB = prvGetTCBFromHandle(xTask);
-
-    /* Save the hook function in the TCB.  A critical section is required as
-    the value can be accessed from an interrupt. */
-    taskENTER_CRITICAL();
-    {
-        xReturn = pxTCB->pxTaskTag;
-    }
-    taskEXIT_CRITICAL();
-
-    return xReturn;
-}
-
-#endif /* configUSE_APPLICATION_TASK_TAG */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_APPLICATION_TASK_TAG == 1)
-
-TaskHookFunction_t xTaskGetApplicationTaskTagFromISR(TaskHandle_t xTask)
-{
-    TCB_t *pxTCB;
-    TaskHookFunction_t xReturn;
-    UBaseType_t uxSavedInterruptStatus;
-
-    /* If xTask is NULL then set the calling task's hook. */
-    pxTCB = prvGetTCBFromHandle(xTask);
-
-    /* Save the hook function in the TCB.  A critical section is required as
-    the value can be accessed from an interrupt. */
-    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
-    {
-        xReturn = pxTCB->pxTaskTag;
-    }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus);
-
-    return xReturn;
-}
-
-#endif /* configUSE_APPLICATION_TASK_TAG */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_APPLICATION_TASK_TAG == 1)
-
-BaseType_t xTaskCallApplicationTaskHook(TaskHandle_t xTask, void *pvParameter)
-{
-    TCB_t *xTCB;
-    BaseType_t xReturn;
-
-    /* If xTask is NULL then we are calling our own task hook. */
-    if (xTask == NULL) {
-        xTCB = pxCurrentTCB;
-    } else {
-        xTCB = xTask;
-    }
-
-    if (xTCB->pxTaskTag != NULL) {
-        xReturn = xTCB->pxTaskTag(pvParameter);
-    } else {
-        xReturn = pdFAIL;
-    }
-
-    return xReturn;
-}
-
-#endif /* configUSE_APPLICATION_TASK_TAG */
-/*-----------------------------------------------------------*/
-
-void vTaskSwitchContext(void)
-{
-    if (uxSchedulerSuspended != (UBaseType_t)pdFALSE) {
-        /* The scheduler is currently suspended - do not allow a context
-        switch. */
-        xYieldPending = pdTRUE;
-    } else {
-        xYieldPending = pdFALSE;
-        traceTASK_SWITCHED_OUT();
-
-#if (configGENERATE_RUN_TIME_STATS == 1)
-        {
-#    ifdef portALT_GET_RUN_TIME_COUNTER_VALUE
-            portALT_GET_RUN_TIME_COUNTER_VALUE(ulTotalRunTime);
-#    else
-            ulTotalRunTime = portGET_RUN_TIME_COUNTER_VALUE();
-#    endif
-
-            /* Add the amount of time the task has been running to the
-            accumulated time so far.  The time the task started running was
-            stored in ulTaskSwitchedInTime.  Note that there is no overflow
-            protection here so count values are only valid until the timer
-            overflows.  The guard against negative values is to protect
-            against suspect run time stat counter implementations - which
-            are provided by the application, not the kernel. */
-            if (ulTotalRunTime > ulTaskSwitchedInTime) {
-                pxCurrentTCB->ulRunTimeCounter +=
-                    (ulTotalRunTime - ulTaskSwitchedInTime);
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-            ulTaskSwitchedInTime = ulTotalRunTime;
-        }
-#endif /* configGENERATE_RUN_TIME_STATS */
-
-        /* Check for stack overflow, if configured. */
-        taskCHECK_FOR_STACK_OVERFLOW();
-
-/* Before the currently running task is switched out, save its errno. */
-#if (configUSE_POSIX_ERRNO == 1)
-        {
-            pxCurrentTCB->iTaskErrno = FreeRTOS_errno;
-        }
-#endif
-
-        /* Select a new task to run using either the generic C or port
-        optimised asm code. */
-        taskSELECT_HIGHEST_PRIORITY_TASK(); /*lint !e9079 void * is used as this
-                                               macro is used with timers and
-                                               co-routines too.  Alignment is
-                                               known to be fine as the type of
-                                               the pointer stored and retrieved
-                                               is the same. */
-        traceTASK_SWITCHED_IN();
-
-/* After the new task is switched in, update the global errno. */
-#if (configUSE_POSIX_ERRNO == 1)
-        {
-            FreeRTOS_errno = pxCurrentTCB->iTaskErrno;
-        }
-#endif
-
-#if (configUSE_NEWLIB_REENTRANT == 1)
-        {
-            /* Switch Newlib's _impure_ptr variable to point to the _reent
-            structure specific to this task.
-            See the third party link
-            http://www.nadler.com/embedded/newlibAndFreeRTOS.html
-            for additional information. */
-            _impure_ptr = &(pxCurrentTCB->xNewLib_reent);
-        }
-#endif /* configUSE_NEWLIB_REENTRANT */
-    }
-}
-/*-----------------------------------------------------------*/
-
-void vTaskPlaceOnEventList(
-    List_t *const pxEventList,
-    const TickType_t xTicksToWait)
-{
-    configASSERT(pxEventList);
-
-    /* THIS FUNCTION MUST BE CALLED WITH EITHER INTERRUPTS DISABLED OR THE
-    SCHEDULER SUSPENDED AND THE QUEUE BEING ACCESSED LOCKED. */
-
-    /* Place the event list item of the TCB in the appropriate event list.
-    This is placed in the list in priority order so the highest priority task
-    is the first to be woken by the event.  The queue that contains the event
-    list is locked, preventing simultaneous access from interrupts. */
-    vListInsert(pxEventList, &(pxCurrentTCB->xEventListItem));
-
-    prvAddCurrentTaskToDelayedList(xTicksToWait, pdTRUE);
-}
-/*-----------------------------------------------------------*/
-
-void vTaskPlaceOnUnorderedEventList(
-    List_t *pxEventList,
-    const TickType_t xItemValue,
-    const TickType_t xTicksToWait)
-{
-    configASSERT(pxEventList);
-
-    /* THIS FUNCTION MUST BE CALLED WITH THE SCHEDULER SUSPENDED.  It is used by
-    the event groups implementation. */
-    configASSERT(uxSchedulerSuspended != 0);
-
-    /* Store the item value in the event list item.  It is safe to access the
-    event list item here as interrupts won't access the event list item of a
-    task that is not in the Blocked state. */
-    listSET_LIST_ITEM_VALUE(
-        &(pxCurrentTCB->xEventListItem),
-        xItemValue | taskEVENT_LIST_ITEM_VALUE_IN_USE);
-
-    /* Place the event list item of the TCB at the end of the appropriate event
-    list.  It is safe to access the event list here because it is part of an
-    event group implementation - and interrupts don't access event groups
-    directly (instead they access them indirectly by pending function calls to
-    the task level). */
-    vListInsertEnd(pxEventList, &(pxCurrentTCB->xEventListItem));
-
-    prvAddCurrentTaskToDelayedList(xTicksToWait, pdTRUE);
-}
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TIMERS == 1)
-
-void vTaskPlaceOnEventListRestricted(
-    List_t *const pxEventList,
-    TickType_t xTicksToWait,
-    const BaseType_t xWaitIndefinitely)
-{
-    configASSERT(pxEventList);
-
-    /* This function should not be called by application code hence the
-    'Restricted' in its name.  It is not part of the public API.  It is
-    designed for use by kernel code, and has special calling requirements -
-    it should be called with the scheduler suspended. */
-
-    /* Place the event list item of the TCB in the appropriate event list.
-    In this case it is assume that this is the only task that is going to
-    be waiting on this event list, so the faster vListInsertEnd() function
-    can be used in place of vListInsert. */
-    vListInsertEnd(pxEventList, &(pxCurrentTCB->xEventListItem));
-
-    /* If the task should block indefinitely then set the block time to a
-    value that will be recognised as an indefinite delay inside the
-    prvAddCurrentTaskToDelayedList() function. */
-    if (xWaitIndefinitely != pdFALSE) {
-        xTicksToWait = portMAX_DELAY;
-    }
-
-    traceTASK_DELAY_UNTIL((xTickCount + xTicksToWait));
-    prvAddCurrentTaskToDelayedList(xTicksToWait, xWaitIndefinitely);
-}
-
-#endif /* configUSE_TIMERS */
-/*-----------------------------------------------------------*/
-
-BaseType_t xTaskRemoveFromEventList(const List_t *const pxEventList)
-{
-    TCB_t *pxUnblockedTCB;
-    BaseType_t xReturn;
-
-    /* THIS FUNCTION MUST BE CALLED FROM A CRITICAL SECTION.  It can also be
-    called from a critical section within an ISR. */
-
-    /* The event list is sorted in priority order, so the first in the list can
-    be removed as it is known to be the highest priority.  Remove the TCB from
-    the delayed list, and add it to the ready list.
-
-    If an event is for a queue that is locked then this function will never
-    get called - the lock count on the queue will get modified instead.  This
-    means exclusive access to the event list is guaranteed here.
-
-    This function assumes that a check has already been made to ensure that
-    pxEventList is not empty. */
-    pxUnblockedTCB = listGET_OWNER_OF_HEAD_ENTRY(
-        pxEventList); /*lint !e9079 void * is used as this macro is used with
-                         timers and co-routines too.  Alignment is known to be
-                         fine as the type of the pointer stored and retrieved is
-                         the same. */
-    configASSERT(pxUnblockedTCB);
-    (void)uxListRemove(&(pxUnblockedTCB->xEventListItem));
-
-    if (uxSchedulerSuspended == (UBaseType_t)pdFALSE) {
-        (void)uxListRemove(&(pxUnblockedTCB->xStateListItem));
-        prvAddTaskToReadyList(pxUnblockedTCB);
-
-#if (configUSE_TICKLESS_IDLE != 0)
-        {
-            /* If a task is blocked on a kernel object then xNextTaskUnblockTime
-            might be set to the blocked task's time out time.  If the task is
-            unblocked for a reason other than a timeout xNextTaskUnblockTime is
-            normally left unchanged, because it is automatically reset to a new
-            value when the tick count equals xNextTaskUnblockTime.  However if
-            tickless idling is used it might be more important to enter sleep
-            mode at the earliest possible time - so reset xNextTaskUnblockTime
-            here to ensure it is updated at the earliest possible time. */
-            prvResetNextTaskUnblockTime();
-        }
-#endif
-    } else {
-        /* The delayed and ready lists cannot be accessed, so hold this task
-        pending until the scheduler is resumed. */
-        vListInsertEnd(&(xPendingReadyList), &(pxUnblockedTCB->xEventListItem));
-    }
-
-    if (pxUnblockedTCB->uxPriority > pxCurrentTCB->uxPriority) {
-        /* Return true if the task removed from the event list has a higher
-        priority than the calling task.  This allows the calling task to know if
-        it should force a context switch now. */
-        xReturn = pdTRUE;
-
-        /* Mark that a yield is pending in case the user is not using the
-        "xHigherPriorityTaskWoken" parameter to an ISR safe FreeRTOS function.
-      */
-        xYieldPending = pdTRUE;
-    } else {
-        xReturn = pdFALSE;
-    }
-
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-void vTaskRemoveFromUnorderedEventList(
-    ListItem_t *pxEventListItem,
-    const TickType_t xItemValue)
-{
-    TCB_t *pxUnblockedTCB;
-
-    /* THIS FUNCTION MUST BE CALLED WITH THE SCHEDULER SUSPENDED.  It is used by
-    the event flags implementation. */
-    configASSERT(uxSchedulerSuspended != pdFALSE);
-
-    /* Store the new item value in the event list. */
-    listSET_LIST_ITEM_VALUE(
-        pxEventListItem, xItemValue | taskEVENT_LIST_ITEM_VALUE_IN_USE);
-
-    /* Remove the event list form the event flag.  Interrupts do not access
-    event flags. */
-    pxUnblockedTCB = listGET_LIST_ITEM_OWNER(
-        pxEventListItem); /*lint !e9079 void * is used as this macro is used
-                             with timers and co-routines too.  Alignment is
-                             known to be fine as the type of the pointer stored
-                             and retrieved is the same. */
-    configASSERT(pxUnblockedTCB);
-    (void)uxListRemove(pxEventListItem);
-
-#if (configUSE_TICKLESS_IDLE != 0)
-    {
-        /* If a task is blocked on a kernel object then xNextTaskUnblockTime
-        might be set to the blocked task's time out time.  If the task is
-        unblocked for a reason other than a timeout xNextTaskUnblockTime is
-        normally left unchanged, because it is automatically reset to a new
-        value when the tick count equals xNextTaskUnblockTime.  However if
-        tickless idling is used it might be more important to enter sleep mode
-        at the earliest possible time - so reset xNextTaskUnblockTime here to
-        ensure it is updated at the earliest possible time. */
-        prvResetNextTaskUnblockTime();
-    }
-#endif
-
-    /* Remove the task from the delayed list and add it to the ready list.  The
-    scheduler is suspended so interrupts will not be accessing the ready
-    lists. */
-    (void)uxListRemove(&(pxUnblockedTCB->xStateListItem));
-    prvAddTaskToReadyList(pxUnblockedTCB);
-
-    if (pxUnblockedTCB->uxPriority > pxCurrentTCB->uxPriority) {
-        /* The unblocked task has a priority above that of the calling task, so
-        a context switch is required.  This function is called with the
-        scheduler suspended so xYieldPending is set so the context switch
-        occurs immediately that the scheduler is resumed (unsuspended). */
-        xYieldPending = pdTRUE;
-    }
-}
-/*-----------------------------------------------------------*/
-
-void vTaskSetTimeOutState(TimeOut_t *const pxTimeOut)
-{
-    configASSERT(pxTimeOut);
-    taskENTER_CRITICAL();
-    {
-        pxTimeOut->xOverflowCount = xNumOfOverflows;
-        pxTimeOut->xTimeOnEntering = xTickCount;
-    }
-    taskEXIT_CRITICAL();
-}
-/*-----------------------------------------------------------*/
-
-void vTaskInternalSetTimeOutState(TimeOut_t *const pxTimeOut)
-{
-    /* For internal use only as it does not use a critical section. */
-    pxTimeOut->xOverflowCount = xNumOfOverflows;
-    pxTimeOut->xTimeOnEntering = xTickCount;
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xTaskCheckForTimeOut(
-    TimeOut_t *const pxTimeOut,
-    TickType_t *const pxTicksToWait)
-{
-    BaseType_t xReturn;
-
-    configASSERT(pxTimeOut);
-    configASSERT(pxTicksToWait);
-
-    taskENTER_CRITICAL();
-    {
-        /* Minor optimisation.  The tick count cannot change in this block. */
-        const TickType_t xConstTickCount = xTickCount;
-        const TickType_t xElapsedTime =
-            xConstTickCount - pxTimeOut->xTimeOnEntering;
-
-#if (INCLUDE_xTaskAbortDelay == 1)
-        if (pxCurrentTCB->ucDelayAborted != (uint8_t)pdFALSE) {
-            /* The delay was aborted, which is not the same as a time out,
-            but has the same result. */
-            pxCurrentTCB->ucDelayAborted = pdFALSE;
-            xReturn = pdTRUE;
-        } else
-#endif
-
-#if (INCLUDE_vTaskSuspend == 1)
-            if (*pxTicksToWait == portMAX_DELAY) {
-            /* If INCLUDE_vTaskSuspend is set to 1 and the block time
-            specified is the maximum block time then the task should block
-            indefinitely, and therefore never time out. */
-            xReturn = pdFALSE;
-        } else
-#endif
-
-            if ((xNumOfOverflows != pxTimeOut->xOverflowCount) &&
-                (xConstTickCount >=
-                 pxTimeOut
-                     ->xTimeOnEntering)) /*lint !e525 Indentation preferred as
-                                            is to make code within pre-processor
-                                            directives clearer. */
-        {
-            /* The tick count is greater than the time at which
-            vTaskSetTimeout() was called, but has also overflowed since
-            vTaskSetTimeOut() was called.  It must have wrapped all the way
-            around and gone past again. This passed since vTaskSetTimeout()
-            was called. */
-            xReturn = pdTRUE;
-        } else if (xElapsedTime < *pxTicksToWait) /*lint !e961 Explicit casting
-                                                     is only redundant with some
-                                                     compilers, whereas others
-                                                     require it to prevent
-                                                     integer conversion errors.
-                                                   */
-        {
-            /* Not a genuine timeout. Adjust parameters for time remaining. */
-            *pxTicksToWait -= xElapsedTime;
-            vTaskInternalSetTimeOutState(pxTimeOut);
-            xReturn = pdFALSE;
-        } else {
-            *pxTicksToWait = 0;
-            xReturn = pdTRUE;
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-void vTaskMissedYield(void)
-{
-    xYieldPending = pdTRUE;
-}
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TRACE_FACILITY == 1)
-
-UBaseType_t uxTaskGetTaskNumber(TaskHandle_t xTask)
-{
-    UBaseType_t uxReturn;
-    TCB_t const *pxTCB;
-
-    if (xTask != NULL) {
-        pxTCB = xTask;
-        uxReturn = pxTCB->uxTaskNumber;
-    } else {
-        uxReturn = 0U;
-    }
-
-    return uxReturn;
-}
-
-#endif /* configUSE_TRACE_FACILITY */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TRACE_FACILITY == 1)
-
-void vTaskSetTaskNumber(TaskHandle_t xTask, const UBaseType_t uxHandle)
-{
-    TCB_t *pxTCB;
-
-    if (xTask != NULL) {
-        pxTCB = xTask;
-        pxTCB->uxTaskNumber = uxHandle;
-    }
-}
-
-#endif /* configUSE_TRACE_FACILITY */
-
-/*
- * -----------------------------------------------------------
- * The Idle task.
- * ----------------------------------------------------------
- *
- * The portTASK_FUNCTION() macro is used to allow port/compiler specific
- * language extensions.  The equivalent prototype for this function is:
- *
- * void prvIdleTask( void *pvParameters );
- *
- */
-static portTASK_FUNCTION(prvIdleTask, pvParameters)
-{
-    /* Stop warnings. */
-    (void)pvParameters;
-
-    /** THIS IS THE RTOS IDLE TASK - WHICH IS CREATED AUTOMATICALLY WHEN THE
-    SCHEDULER IS STARTED. **/
-
-    /* In case a task that has a secure context deletes itself, in which case
-    the idle task is responsible for deleting the task's secure context, if
-    any. */
-    portALLOCATE_SECURE_CONTEXT(configMINIMAL_SECURE_STACK_SIZE);
-
-    for (;;) {
-        /* See if any tasks have deleted themselves - if so then the idle task
-        is responsible for freeing the deleted task's TCB and stack. */
-        prvCheckTasksWaitingTermination();
-
-#if (configUSE_PREEMPTION == 0)
-        {
-            /* If we are not using preemption we keep forcing a task switch to
-            see if any other task has become available.  If we are using
-            preemption we don't need to do this as any task becoming available
-            will automatically get the processor anyway. */
-            taskYIELD();
-        }
-#endif /* configUSE_PREEMPTION */
-
-#if ((configUSE_PREEMPTION == 1) && (configIDLE_SHOULD_YIELD == 1))
-        {
-            /* When using preemption tasks of equal priority will be
-            timesliced.  If a task that is sharing the idle priority is ready
-            to run then the idle task should yield before the end of the
-            timeslice.
-
-            A critical region is not required here as we are just reading from
-            the list, and an occasional incorrect value will not matter.  If
-            the ready list at the idle priority contains more than one task
-            then a task other than the idle task is ready to execute. */
-            if (listCURRENT_LIST_LENGTH(
-                    &(pxReadyTasksLists[tskIDLE_PRIORITY])) > (UBaseType_t)1) {
-                taskYIELD();
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-#endif /* ( ( configUSE_PREEMPTION == 1 ) && ( configIDLE_SHOULD_YIELD == 1 ) \
-          ) */
-
-#if (configUSE_IDLE_HOOK == 1)
-        {
-            extern void vApplicationIdleHook(void);
-
-            /* Call the user defined function from within the idle task.  This
-            allows the application designer to add background functionality
-            without the overhead of a separate task.
-            NOTE: vApplicationIdleHook() MUST NOT, UNDER ANY CIRCUMSTANCES,
-            CALL A FUNCTION THAT MIGHT BLOCK. */
-            vApplicationIdleHook();
-        }
-#endif /* configUSE_IDLE_HOOK */
-
-/* This conditional compilation should use inequality to 0, not equality
-to 1.  This is to ensure portSUPPRESS_TICKS_AND_SLEEP() is called when
-user defined low power mode	implementations require
-configUSE_TICKLESS_IDLE to be set to a value other than 1. */
-#if (configUSE_TICKLESS_IDLE != 0)
-        {
-            TickType_t xExpectedIdleTime;
-
-            /* It is not desirable to suspend then resume the scheduler on
-            each iteration of the idle task.  Therefore, a preliminary
-            test of the expected idle time is performed without the
-            scheduler suspended.  The result here is not necessarily
-            valid. */
-            xExpectedIdleTime = prvGetExpectedIdleTime();
-
-            if (xExpectedIdleTime >= configEXPECTED_IDLE_TIME_BEFORE_SLEEP) {
-                vTaskSuspendAll();
-                {
-                    /* Now the scheduler is suspended, the expected idle
-                    time can be sampled again, and this time its value can
-                    be used. */
-                    configASSERT(xNextTaskUnblockTime >= xTickCount);
-                    xExpectedIdleTime = prvGetExpectedIdleTime();
-
-                    /* Define the following macro to set xExpectedIdleTime to 0
-                    if the application does not want
-                    portSUPPRESS_TICKS_AND_SLEEP() to be called. */
-                    configPRE_SUPPRESS_TICKS_AND_SLEEP_PROCESSING(
-                        xExpectedIdleTime);
-
-                    if (xExpectedIdleTime >=
-                        configEXPECTED_IDLE_TIME_BEFORE_SLEEP) {
-                        traceLOW_POWER_IDLE_BEGIN();
-                        portSUPPRESS_TICKS_AND_SLEEP(xExpectedIdleTime);
-                        traceLOW_POWER_IDLE_END();
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                }
-                (void)xTaskResumeAll();
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-#endif /* configUSE_TICKLESS_IDLE */
-    }
-}
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TICKLESS_IDLE != 0)
-
-eSleepModeStatus eTaskConfirmSleepModeStatus(void)
-{
-    /* The idle task exists in addition to the application tasks. */
-    const UBaseType_t uxNonApplicationTasks = 1;
-    eSleepModeStatus eReturn = eStandardSleep;
-
-    /* This function must be called from a critical section. */
-
-    if (listCURRENT_LIST_LENGTH(&xPendingReadyList) != 0) {
-        /* A task was made ready while the scheduler was suspended. */
-        eReturn = eAbortSleep;
-    } else if (xYieldPending != pdFALSE) {
-        /* A yield was pended while the scheduler was suspended. */
-        eReturn = eAbortSleep;
-    } else {
-        /* If all the tasks are in the suspended list (which might mean they
-        have an infinite block time rather than actually being suspended)
-        then it is safe to turn all clocks off and just wait for external
-        interrupts. */
-        if (listCURRENT_LIST_LENGTH(&xSuspendedTaskList) ==
-            (uxCurrentNumberOfTasks - uxNonApplicationTasks)) {
-            eReturn = eNoTasksWaitingTimeout;
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-
-    return eReturn;
-}
-
-#endif /* configUSE_TICKLESS_IDLE */
-/*-----------------------------------------------------------*/
-
-#if (configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0)
-
-void vTaskSetThreadLocalStoragePointer(
-    TaskHandle_t xTaskToSet,
-    BaseType_t xIndex,
-    void *pvValue)
-{
-    TCB_t *pxTCB;
-
-    if (xIndex < configNUM_THREAD_LOCAL_STORAGE_POINTERS) {
-        pxTCB = prvGetTCBFromHandle(xTaskToSet);
-        configASSERT(pxTCB != NULL);
-        pxTCB->pvThreadLocalStoragePointers[xIndex] = pvValue;
-    }
-}
-
-#endif /* configNUM_THREAD_LOCAL_STORAGE_POINTERS */
-/*-----------------------------------------------------------*/
-
-#if (configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0)
-
-void *pvTaskGetThreadLocalStoragePointer(
-    TaskHandle_t xTaskToQuery,
-    BaseType_t xIndex)
-{
-    void *pvReturn = NULL;
-    TCB_t *pxTCB;
-
-    if (xIndex < configNUM_THREAD_LOCAL_STORAGE_POINTERS) {
-        pxTCB = prvGetTCBFromHandle(xTaskToQuery);
-        pvReturn = pxTCB->pvThreadLocalStoragePointers[xIndex];
-    } else {
-        pvReturn = NULL;
-    }
-
-    return pvReturn;
-}
-
-#endif /* configNUM_THREAD_LOCAL_STORAGE_POINTERS */
-/*-----------------------------------------------------------*/
-
-#if (portUSING_MPU_WRAPPERS == 1)
-
-void vTaskAllocateMPURegions(
-    TaskHandle_t xTaskToModify,
-    const MemoryRegion_t *const xRegions)
-{
-    TCB_t *pxTCB;
-
-    /* If null is passed in here then we are modifying the MPU settings of
-    the calling task. */
-    pxTCB = prvGetTCBFromHandle(xTaskToModify);
-
-    vPortStoreTaskMPUSettings(&(pxTCB->xMPUSettings), xRegions, NULL, 0);
-}
-
-#endif /* portUSING_MPU_WRAPPERS */
-/*-----------------------------------------------------------*/
-
-static void prvInitialiseTaskLists(void)
-{
-    UBaseType_t uxPriority;
-
-    for (uxPriority = (UBaseType_t)0U;
-         uxPriority < (UBaseType_t)configMAX_PRIORITIES;
-         uxPriority++) {
-        vListInitialise(&(pxReadyTasksLists[uxPriority]));
-    }
-
-    vListInitialise(&xDelayedTaskList1);
-    vListInitialise(&xDelayedTaskList2);
-    vListInitialise(&xPendingReadyList);
-
-#if (INCLUDE_vTaskDelete == 1)
-    {
-        vListInitialise(&xTasksWaitingTermination);
-    }
-#endif /* INCLUDE_vTaskDelete */
-
-#if (INCLUDE_vTaskSuspend == 1)
-    {
-        vListInitialise(&xSuspendedTaskList);
-    }
-#endif /* INCLUDE_vTaskSuspend */
-
-    /* Start with pxDelayedTaskList using list1 and the
-    pxOverflowDelayedTaskList using list2. */
-    pxDelayedTaskList = &xDelayedTaskList1;
-    pxOverflowDelayedTaskList = &xDelayedTaskList2;
-}
-/*-----------------------------------------------------------*/
-
-static void prvCheckTasksWaitingTermination(void)
-{
-    /** THIS FUNCTION IS CALLED FROM THE RTOS IDLE TASK **/
-
-#if (INCLUDE_vTaskDelete == 1)
-    {
-        TCB_t *pxTCB;
-
-        /* uxDeletedTasksWaitingCleanUp is used to prevent taskENTER_CRITICAL()
-        being called too often in the idle task. */
-        while (uxDeletedTasksWaitingCleanUp > (UBaseType_t)0U) {
-            taskENTER_CRITICAL();
-            {
-                pxTCB = listGET_OWNER_OF_HEAD_ENTRY(
-                    (&xTasksWaitingTermination)); /*lint !e9079 void * is used
-                                                     as this macro is used with
-                                                     timers and co-routines too.
-                                                     Alignment is known to be
-                                                     fine as the type of the
-                                                     pointer stored and
-                                                     retrieved is the same. */
-                (void)uxListRemove(&(pxTCB->xStateListItem));
-                --uxCurrentNumberOfTasks;
-                --uxDeletedTasksWaitingCleanUp;
-            }
-            taskEXIT_CRITICAL();
-
-            prvDeleteTCB(pxTCB);
-        }
-    }
-#endif /* INCLUDE_vTaskDelete */
-}
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TRACE_FACILITY == 1)
-
-void vTaskGetInfo(
-    TaskHandle_t xTask,
-    TaskStatus_t *pxTaskStatus,
-    BaseType_t xGetFreeStackSpace,
-    eTaskState eState)
-{
-    TCB_t *pxTCB;
-
-    /* xTask is NULL then get the state of the calling task. */
-    pxTCB = prvGetTCBFromHandle(xTask);
-
-    pxTaskStatus->xHandle = (TaskHandle_t)pxTCB;
-    pxTaskStatus->pcTaskName = (const char *)&(pxTCB->pcTaskName[0]);
-    pxTaskStatus->uxCurrentPriority = pxTCB->uxPriority;
-    pxTaskStatus->pxStackBase = pxTCB->pxStack;
-    pxTaskStatus->xTaskNumber = pxTCB->uxTCBNumber;
-
-#    if (configUSE_MUTEXES == 1)
-    {
-        pxTaskStatus->uxBasePriority = pxTCB->uxBasePriority;
-    }
-#    else
-    {
-        pxTaskStatus->uxBasePriority = 0;
-    }
-#    endif
-
-#    if (configGENERATE_RUN_TIME_STATS == 1)
-    {
-        pxTaskStatus->ulRunTimeCounter = pxTCB->ulRunTimeCounter;
-    }
-#    else
-    {
-        pxTaskStatus->ulRunTimeCounter = 0;
-    }
-#    endif
-
-    /* Obtaining the task state is a little fiddly, so is only done if the
-    value of eState passed into this function is eInvalid - otherwise the
-    state is just set to whatever is passed in. */
-    if (eState != eInvalid) {
-        if (pxTCB == pxCurrentTCB) {
-            pxTaskStatus->eCurrentState = eRunning;
-        } else {
-            pxTaskStatus->eCurrentState = eState;
-
-#    if (INCLUDE_vTaskSuspend == 1)
-            {
-                /* If the task is in the suspended list then there is a
-                chance it is actually just blocked indefinitely - so really
-                it should be reported as being in the Blocked state. */
-                if (eState == eSuspended) {
-                    vTaskSuspendAll();
-                    {
-                        if (listLIST_ITEM_CONTAINER(&(pxTCB->xEventListItem)) !=
-                            NULL) {
-                            pxTaskStatus->eCurrentState = eBlocked;
-                        }
-                    }
-                    (void)xTaskResumeAll();
-                }
-            }
-#    endif /* INCLUDE_vTaskSuspend */
-        }
-    } else {
-        pxTaskStatus->eCurrentState = eTaskGetState(pxTCB);
-    }
-
-    /* Obtaining the stack space takes some time, so the xGetFreeStackSpace
-    parameter is provided to allow it to be skipped. */
-    if (xGetFreeStackSpace != pdFALSE) {
-#    if (portSTACK_GROWTH > 0)
-        {
-            pxTaskStatus->usStackHighWaterMark =
-                prvTaskCheckFreeStackSpace((uint8_t *)pxTCB->pxEndOfStack);
-        }
-#    else
-        {
-            pxTaskStatus->usStackHighWaterMark =
-                prvTaskCheckFreeStackSpace((uint8_t *)pxTCB->pxStack);
-        }
-#    endif
-    } else {
-        pxTaskStatus->usStackHighWaterMark = 0;
-    }
-}
-
-#endif /* configUSE_TRACE_FACILITY */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TRACE_FACILITY == 1)
-
-static UBaseType_t prvListTasksWithinSingleList(
-    TaskStatus_t *pxTaskStatusArray,
-    List_t *pxList,
-    eTaskState eState)
-{
-    configLIST_VOLATILE TCB_t *pxNextTCB, *pxFirstTCB;
-    UBaseType_t uxTask = 0;
-
-    if (listCURRENT_LIST_LENGTH(pxList) > (UBaseType_t)0) {
-        listGET_OWNER_OF_NEXT_ENTRY(
-            pxFirstTCB,
-            pxList); /*lint !e9079 void * is used as this macro is used with
-                        timers and co-routines too.  Alignment is known to be
-                        fine as the type of the pointer stored and retrieved is
-                        the same. */
-
-        /* Populate an TaskStatus_t structure within the
-        pxTaskStatusArray array for each task that is referenced from
-        pxList.  See the definition of TaskStatus_t in task.h for the
-        meaning of each TaskStatus_t structure member. */
-        do {
-            listGET_OWNER_OF_NEXT_ENTRY(
-                pxNextTCB,
-                pxList); /*lint !e9079 void * is used as this macro is used with
-                            timers and co-routines too.  Alignment is known to
-                            be fine as the type of the pointer stored and
-                            retrieved is the same. */
-            vTaskGetInfo(
-                (TaskHandle_t)pxNextTCB,
-                &(pxTaskStatusArray[uxTask]),
-                pdTRUE,
-                eState);
-            uxTask++;
-        } while (pxNextTCB != pxFirstTCB);
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    return uxTask;
-}
-
-#endif /* configUSE_TRACE_FACILITY */
-/*-----------------------------------------------------------*/
-
-#if ( \
-    (configUSE_TRACE_FACILITY == 1) || \
-    (INCLUDE_uxTaskGetStackHighWaterMark == 1) || \
-    (INCLUDE_uxTaskGetStackHighWaterMark2 == 1))
-
-static configSTACK_DEPTH_TYPE prvTaskCheckFreeStackSpace(
-    const uint8_t *pucStackByte)
-{
-    uint32_t ulCount = 0U;
-
-    while (*pucStackByte == (uint8_t)tskSTACK_FILL_BYTE) {
-        pucStackByte -= portSTACK_GROWTH;
-        ulCount++;
-    }
-
-    ulCount /=
-        (uint32_t)sizeof(StackType_t); /*lint !e961 Casting is not redundant on
-                                          smaller architectures. */
-
-    return (configSTACK_DEPTH_TYPE)ulCount;
-}
-
-#endif /* ( ( configUSE_TRACE_FACILITY == 1 ) || ( \
-          INCLUDE_uxTaskGetStackHighWaterMark == 1 ) || ( \
-          INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) ) */
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_uxTaskGetStackHighWaterMark2 == 1)
-
-/* uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the
-same except for their return type.  Using configSTACK_DEPTH_TYPE allows the
-user to determine the return type.  It gets around the problem of the value
-overflowing on 8-bit types without breaking backward compatibility for
-applications that expect an 8-bit return type. */
-configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2(TaskHandle_t xTask)
-{
-    TCB_t *pxTCB;
-    uint8_t *pucEndOfStack;
-    configSTACK_DEPTH_TYPE uxReturn;
-
-    /* uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are
-    the same except for their return type.  Using configSTACK_DEPTH_TYPE
-    allows the user to determine the return type.  It gets around the
-    problem of the value overflowing on 8-bit types without breaking
-    backward compatibility for applications that expect an 8-bit return
-    type. */
-
-    pxTCB = prvGetTCBFromHandle(xTask);
-
-#    if portSTACK_GROWTH < 0
-    {
-        pucEndOfStack = (uint8_t *)pxTCB->pxStack;
-    }
-#    else
-    {
-        pucEndOfStack = (uint8_t *)pxTCB->pxEndOfStack;
-    }
-#    endif
-
-    uxReturn = prvTaskCheckFreeStackSpace(pucEndOfStack);
-
-    return uxReturn;
-}
-
-#endif /* INCLUDE_uxTaskGetStackHighWaterMark2 */
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_uxTaskGetStackHighWaterMark == 1)
-
-UBaseType_t uxTaskGetStackHighWaterMark(TaskHandle_t xTask)
-{
-    TCB_t *pxTCB;
-    uint8_t *pucEndOfStack;
-    UBaseType_t uxReturn;
-
-    pxTCB = prvGetTCBFromHandle(xTask);
-
-#    if portSTACK_GROWTH < 0
-    {
-        pucEndOfStack = (uint8_t *)pxTCB->pxStack;
-    }
-#    else
-    {
-        pucEndOfStack = (uint8_t *)pxTCB->pxEndOfStack;
-    }
-#    endif
-
-    uxReturn = (UBaseType_t)prvTaskCheckFreeStackSpace(pucEndOfStack);
-
-    return uxReturn;
-}
-
-#endif /* INCLUDE_uxTaskGetStackHighWaterMark */
-/*-----------------------------------------------------------*/
-
-#if (INCLUDE_vTaskDelete == 1)
-
-static void prvDeleteTCB(TCB_t *pxTCB)
-{
-    /* This call is required specifically for the TriCore port.  It must be
-    above the vPortFree() calls.  The call is also used by ports/demos that
-    want to allocate and clean RAM statically. */
-    portCLEAN_UP_TCB(pxTCB);
-
-/* Free up the memory allocated by the scheduler for the task.  It is up
-to the task to free any memory allocated at the application level.
-See the third party link http://www.nadler.com/embedded/newlibAndFreeRTOS.html
-for additional information. */
-#    if (configUSE_NEWLIB_REENTRANT == 1)
-    {
-        _reclaim_reent(&(pxTCB->xNewLib_reent));
-    }
-#    endif /* configUSE_NEWLIB_REENTRANT */
-
-#    if ( \
-        (configSUPPORT_DYNAMIC_ALLOCATION == 1) && \
-        (configSUPPORT_STATIC_ALLOCATION == 0) && \
-        (portUSING_MPU_WRAPPERS == 0))
-    {
-        /* The task can only have been allocated dynamically - free both
-        the stack and TCB. */
-        vPortFree(pxTCB->pxStack);
-        vPortFree(pxTCB);
-    }
-#    elif ( \
-        tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != \
-        0) /*lint !e731 !e9029 Macro has been consolidated for readability \
-              reasons. */
-    {
-        /* The task could have been allocated statically or dynamically, so
-        check what was statically allocated before trying to free the
-        memory. */
-        if (pxTCB->ucStaticallyAllocated ==
-            tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB) {
-            /* Both the stack and TCB were allocated dynamically, so both
-            must be freed. */
-            vPortFree(pxTCB->pxStack);
-            vPortFree(pxTCB);
-        } else if (
-            pxTCB->ucStaticallyAllocated ==
-            tskSTATICALLY_ALLOCATED_STACK_ONLY) {
-            /* Only the stack was statically allocated, so the TCB is the
-            only memory that must be freed. */
-            vPortFree(pxTCB);
-        } else {
-            /* Neither the stack nor the TCB were allocated dynamically, so
-            nothing needs to be freed. */
-            configASSERT(
-                pxTCB->ucStaticallyAllocated ==
-                tskSTATICALLY_ALLOCATED_STACK_AND_TCB);
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-#    endif /* configSUPPORT_DYNAMIC_ALLOCATION */
-}
-
-#endif /* INCLUDE_vTaskDelete */
-/*-----------------------------------------------------------*/
-
-static void prvResetNextTaskUnblockTime(void)
-{
-    TCB_t *pxTCB;
-
-    if (listLIST_IS_EMPTY(pxDelayedTaskList) != pdFALSE) {
-        /* The new current delayed list is empty.  Set xNextTaskUnblockTime to
-        the maximum possible value so it is	extremely unlikely that the
-        if( xTickCount >= xNextTaskUnblockTime ) test will pass until
-        there is an item in the delayed list. */
-        xNextTaskUnblockTime = portMAX_DELAY;
-    } else {
-        /* The new current delayed list is not empty, get the value of
-        the item at the head of the delayed list.  This is the time at
-        which the task at the head of the delayed list should be removed
-        from the Blocked state. */
-        (pxTCB) = listGET_OWNER_OF_HEAD_ENTRY(
-            pxDelayedTaskList); /*lint !e9079 void * is used as this macro is
-                                   used with timers and co-routines too.
-                                   Alignment is known to be fine as the type of
-                                   the pointer stored and retrieved is the same.
-                                 */
-        xNextTaskUnblockTime =
-            listGET_LIST_ITEM_VALUE(&((pxTCB)->xStateListItem));
-    }
-}
-/*-----------------------------------------------------------*/
-
-#if ((INCLUDE_xTaskGetCurrentTaskHandle == 1) || (configUSE_MUTEXES == 1))
-
-TaskHandle_t xTaskGetCurrentTaskHandle(void)
-{
-    TaskHandle_t xReturn;
-
-    /* A critical section is not required as this is not called from
-    an interrupt and the current TCB will always be the same for any
-    individual execution thread. */
-    xReturn = pxCurrentTCB;
-
-    return xReturn;
-}
-
-#endif /* ( ( INCLUDE_xTaskGetCurrentTaskHandle == 1 ) || ( configUSE_MUTEXES \
-          == 1 ) ) */
-/*-----------------------------------------------------------*/
-
-#if ((INCLUDE_xTaskGetSchedulerState == 1) || (configUSE_TIMERS == 1))
-
-BaseType_t xTaskGetSchedulerState(void)
-{
-    BaseType_t xReturn;
-
-    if (xSchedulerRunning == pdFALSE) {
-        xReturn = taskSCHEDULER_NOT_STARTED;
-    } else {
-        if (uxSchedulerSuspended == (UBaseType_t)pdFALSE) {
-            xReturn = taskSCHEDULER_RUNNING;
-        } else {
-            xReturn = taskSCHEDULER_SUSPENDED;
-        }
-    }
-
-    return xReturn;
-}
-
-#endif /* ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 \
-          ) ) */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_MUTEXES == 1)
-
-BaseType_t xTaskPriorityInherit(TaskHandle_t const pxMutexHolder)
-{
-    TCB_t *const pxMutexHolderTCB = pxMutexHolder;
-    BaseType_t xReturn = pdFALSE;
-
-    /* If the mutex was given back by an interrupt while the queue was
-    locked then the mutex holder might now be NULL.  _RB_ Is this still
-    needed as interrupts can no longer use mutexes? */
-    if (pxMutexHolder != NULL) {
-        /* If the holder of the mutex has a priority below the priority of
-        the task attempting to obtain the mutex then it will temporarily
-        inherit the priority of the task attempting to obtain the mutex. */
-        if (pxMutexHolderTCB->uxPriority < pxCurrentTCB->uxPriority) {
-            /* Adjust the mutex holder state to account for its new
-            priority.  Only reset the event list item value if the value is
-            not being used for anything else. */
-            if ((listGET_LIST_ITEM_VALUE(&(pxMutexHolderTCB->xEventListItem)) &
-                 taskEVENT_LIST_ITEM_VALUE_IN_USE) == 0UL) {
-                listSET_LIST_ITEM_VALUE(
-                    &(pxMutexHolderTCB->xEventListItem),
-                    (TickType_t)configMAX_PRIORITIES -
-                        (TickType_t)pxCurrentTCB
-                            ->uxPriority); /*lint !e961 MISRA exception as the
-                                              casts are only redundant for some
-                                              ports. */
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-
-            /* If the task being modified is in the ready state it will need
-            to be moved into a new list. */
-            if (listIS_CONTAINED_WITHIN(
-                    &(pxReadyTasksLists[pxMutexHolderTCB->uxPriority]),
-                    &(pxMutexHolderTCB->xStateListItem)) != pdFALSE) {
-                if (uxListRemove(&(pxMutexHolderTCB->xStateListItem)) ==
-                    (UBaseType_t)0) {
-                    /* It is known that the task is in its ready list so
-                    there is no need to check again and the port level
-                    reset macro can be called directly. */
-                    portRESET_READY_PRIORITY(
-                        pxMutexHolderTCB->uxPriority, uxTopReadyPriority);
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-
-                /* Inherit the priority before being moved into the new list. */
-                pxMutexHolderTCB->uxPriority = pxCurrentTCB->uxPriority;
-                prvAddTaskToReadyList(pxMutexHolderTCB);
-            } else {
-                /* Just inherit the priority. */
-                pxMutexHolderTCB->uxPriority = pxCurrentTCB->uxPriority;
-            }
-
-            traceTASK_PRIORITY_INHERIT(
-                pxMutexHolderTCB, pxCurrentTCB->uxPriority);
-
-            /* Inheritance occurred. */
-            xReturn = pdTRUE;
-        } else {
-            if (pxMutexHolderTCB->uxBasePriority < pxCurrentTCB->uxPriority) {
-                /* The base priority of the mutex holder is lower than the
-                priority of the task attempting to take the mutex, but the
-                current priority of the mutex holder is not lower than the
-                priority of the task attempting to take the mutex.
-                Therefore the mutex holder must have already inherited a
-                priority, but inheritance would have occurred if that had
-                not been the case. */
-                xReturn = pdTRUE;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    return xReturn;
-}
-
-#endif /* configUSE_MUTEXES */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_MUTEXES == 1)
-
-BaseType_t xTaskPriorityDisinherit(TaskHandle_t const pxMutexHolder)
-{
-    TCB_t *const pxTCB = pxMutexHolder;
-    BaseType_t xReturn = pdFALSE;
-
-    if (pxMutexHolder != NULL) {
-        /* A task can only have an inherited priority if it holds the mutex.
-        If the mutex is held by a task then it cannot be given from an
-        interrupt, and if a mutex is given by the holding task then it must
-        be the running state task. */
-        configASSERT(pxTCB == pxCurrentTCB);
-        configASSERT(pxTCB->uxMutexesHeld);
-        (pxTCB->uxMutexesHeld)--;
-
-        /* Has the holder of the mutex inherited the priority of another
-        task? */
-        if (pxTCB->uxPriority != pxTCB->uxBasePriority) {
-            /* Only disinherit if no other mutexes are held. */
-            if (pxTCB->uxMutexesHeld == (UBaseType_t)0) {
-                /* A task can only have an inherited priority if it holds
-                the mutex.  If the mutex is held by a task then it cannot be
-                given from an interrupt, and if a mutex is given by the
-                holding task then it must be the running state task.  Remove
-                the holding task from the ready/delayed list. */
-                if (uxListRemove(&(pxTCB->xStateListItem)) == (UBaseType_t)0) {
-                    taskRESET_READY_PRIORITY(pxTCB->uxPriority);
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-
-                /* Disinherit the priority before adding the task into the
-                new	ready list. */
-                traceTASK_PRIORITY_DISINHERIT(pxTCB, pxTCB->uxBasePriority);
-                pxTCB->uxPriority = pxTCB->uxBasePriority;
-
-                /* Reset the event list item value.  It cannot be in use for
-                any other purpose if this task is running, and it must be
-                running to give back the mutex. */
-                listSET_LIST_ITEM_VALUE(
-                    &(pxTCB->xEventListItem),
-                    (TickType_t)configMAX_PRIORITIES -
-                        (TickType_t)
-                            pxTCB->uxPriority); /*lint !e961 MISRA exception as
-                                                   the casts are only redundant
-                                                   for some ports. */
-                prvAddTaskToReadyList(pxTCB);
-
-                /* Return true to indicate that a context switch is required.
-                This is only actually required in the corner case whereby
-                multiple mutexes were held and the mutexes were given back
-                in an order different to that in which they were taken.
-                If a context switch did not occur when the first mutex was
-                returned, even if a task was waiting on it, then a context
-                switch should occur when the last mutex is returned whether
-                a task is waiting on it or not. */
-                xReturn = pdTRUE;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    return xReturn;
-}
-
-#endif /* configUSE_MUTEXES */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_MUTEXES == 1)
-
-void vTaskPriorityDisinheritAfterTimeout(
-    TaskHandle_t const pxMutexHolder,
-    UBaseType_t uxHighestPriorityWaitingTask)
-{
-    TCB_t *const pxTCB = pxMutexHolder;
-    UBaseType_t uxPriorityUsedOnEntry, uxPriorityToUse;
-    const UBaseType_t uxOnlyOneMutexHeld = (UBaseType_t)1;
-
-    if (pxMutexHolder != NULL) {
-        /* If pxMutexHolder is not NULL then the holder must hold at least
-        one mutex. */
-        configASSERT(pxTCB->uxMutexesHeld);
-
-        /* Determine the priority to which the priority of the task that
-        holds the mutex should be set.  This will be the greater of the
-        holding task's base priority and the priority of the highest
-        priority task that is waiting to obtain the mutex. */
-        if (pxTCB->uxBasePriority < uxHighestPriorityWaitingTask) {
-            uxPriorityToUse = uxHighestPriorityWaitingTask;
-        } else {
-            uxPriorityToUse = pxTCB->uxBasePriority;
-        }
-
-        /* Does the priority need to change? */
-        if (pxTCB->uxPriority != uxPriorityToUse) {
-            /* Only disinherit if no other mutexes are held.  This is a
-            simplification in the priority inheritance implementation.  If
-            the task that holds the mutex is also holding other mutexes then
-            the other mutexes may have caused the priority inheritance. */
-            if (pxTCB->uxMutexesHeld == uxOnlyOneMutexHeld) {
-                /* If a task has timed out because it already holds the
-                mutex it was trying to obtain then it cannot of inherited
-                its own priority. */
-                configASSERT(pxTCB != pxCurrentTCB);
-
-                /* Disinherit the priority, remembering the previous
-                priority to facilitate determining the subject task's
-                state. */
-                traceTASK_PRIORITY_DISINHERIT(pxTCB, pxTCB->uxBasePriority);
-                uxPriorityUsedOnEntry = pxTCB->uxPriority;
-                pxTCB->uxPriority = uxPriorityToUse;
-
-                /* Only reset the event list item value if the value is not
-                being used for anything else. */
-                if ((listGET_LIST_ITEM_VALUE(&(pxTCB->xEventListItem)) &
-                     taskEVENT_LIST_ITEM_VALUE_IN_USE) == 0UL) {
-                    listSET_LIST_ITEM_VALUE(
-                        &(pxTCB->xEventListItem),
-                        (TickType_t)configMAX_PRIORITIES -
-                            (TickType_t)
-                                uxPriorityToUse); /*lint !e961 MISRA exception
-                                                     as the casts are only
-                                                     redundant for some ports.
-                                                   */
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-
-                /* If the running task is not the task that holds the mutex
-                then the task that holds the mutex could be in either the
-                Ready, Blocked or Suspended states.  Only remove the task
-                from its current state list if it is in the Ready state as
-                the task's priority is going to change and there is one
-                Ready list per priority. */
-                if (listIS_CONTAINED_WITHIN(
-                        &(pxReadyTasksLists[uxPriorityUsedOnEntry]),
-                        &(pxTCB->xStateListItem)) != pdFALSE) {
-                    if (uxListRemove(&(pxTCB->xStateListItem)) ==
-                        (UBaseType_t)0) {
-                        /* It is known that the task is in its ready list so
-                        there is no need to check again and the port level
-                        reset macro can be called directly. */
-                        portRESET_READY_PRIORITY(
-                            pxTCB->uxPriority, uxTopReadyPriority);
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-
-                    prvAddTaskToReadyList(pxTCB);
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-}
-
-#endif /* configUSE_MUTEXES */
-/*-----------------------------------------------------------*/
-
-#if (portCRITICAL_NESTING_IN_TCB == 1)
-
-void vTaskEnterCritical(void)
-{
-    portDISABLE_INTERRUPTS();
-
-    if (xSchedulerRunning != pdFALSE) {
-        (pxCurrentTCB->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 (pxCurrentTCB->uxCriticalNesting == 1) {
-            portASSERT_IF_IN_ISR();
-        }
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-}
-
-#endif /* portCRITICAL_NESTING_IN_TCB */
-/*-----------------------------------------------------------*/
-
-#if (portCRITICAL_NESTING_IN_TCB == 1)
-
-void vTaskExitCritical(void)
-{
-    if (xSchedulerRunning != pdFALSE) {
-        if (pxCurrentTCB->uxCriticalNesting > 0U) {
-            (pxCurrentTCB->uxCriticalNesting)--;
-
-            if (pxCurrentTCB->uxCriticalNesting == 0U) {
-                portENABLE_INTERRUPTS();
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-}
-
-#endif /* portCRITICAL_NESTING_IN_TCB */
-/*-----------------------------------------------------------*/
-
-#if ( \
-    (configUSE_TRACE_FACILITY == 1) && \
-    (configUSE_STATS_FORMATTING_FUNCTIONS > 0))
-
-static char *prvWriteNameToBuffer(char *pcBuffer, const char *pcTaskName)
-{
-    size_t x;
-
-    /* Start by copying the entire string. */
-    strcpy(pcBuffer, pcTaskName);
-
-    /* Pad the end of the string with spaces to ensure columns line up when
-    printed out. */
-    for (x = strlen(pcBuffer); x < (size_t)(configMAX_TASK_NAME_LEN - 1); x++) {
-        pcBuffer[x] = ' ';
-    }
-
-    /* Terminate. */
-    pcBuffer[x] = (char)0x00;
-
-    /* Return the new end of string. */
-    return &(pcBuffer[x]);
-}
-
-#endif /* ( configUSE_TRACE_FACILITY == 1 ) && ( \
-          configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) */
-/*-----------------------------------------------------------*/
-
-#if ( \
-    (configUSE_TRACE_FACILITY == 1) && \
-    (configUSE_STATS_FORMATTING_FUNCTIONS > 0) && \
-    (configSUPPORT_DYNAMIC_ALLOCATION == 1))
-
-void vTaskList(char *pcWriteBuffer)
-{
-    TaskStatus_t *pxTaskStatusArray;
-    UBaseType_t uxArraySize, x;
-    char cStatus;
-
-    /*
-     * PLEASE NOTE:
-     *
-     * This function is provided for convenience only, and is used by many
-     * of the demo applications.  Do not consider it to be part of the
-     * scheduler.
-     *
-     * vTaskList() calls uxTaskGetSystemState(), then formats part of the
-     * uxTaskGetSystemState() output into a human readable table that
-     * displays task names, states and stack usage.
-     *
-     * vTaskList() has a dependency on the sprintf() C library function that
-     * might bloat the code size, use a lot of stack, and provide different
-     * results on different platforms.  An alternative, tiny, third party,
-     * and limited functionality implementation of sprintf() is provided in
-     * many of the FreeRTOS/Demo sub-directories in a file called
-     * printf-stdarg.c (note printf-stdarg.c does not provide a full
-     * snprintf() implementation!).
-     *
-     * It is recommended that production systems call uxTaskGetSystemState()
-     * directly to get access to raw stats data, rather than indirectly
-     * through a call to vTaskList().
-     */
-
-    /* Make sure the write buffer does not contain a string. */
-    *pcWriteBuffer = (char)0x00;
-
-    /* Take a snapshot of the number of tasks in case it changes while this
-    function is executing. */
-    uxArraySize = uxCurrentNumberOfTasks;
-
-    /* Allocate an array index for each task.  NOTE!  if
-    configSUPPORT_DYNAMIC_ALLOCATION is set to 0 then pvPortMalloc() will
-    equate to NULL. */
-    pxTaskStatusArray = pvPortMalloc(
-        uxCurrentNumberOfTasks *
-        sizeof(
-            TaskStatus_t)); /*lint !e9079 All values returned by pvPortMalloc()
-                               have at least the alignment required by the MCU's
-                               stack and this allocation allocates a struct that
-                               has the alignment requirements of a pointer. */
-
-    if (pxTaskStatusArray != NULL) {
-        /* Generate the (binary) data. */
-        uxArraySize =
-            uxTaskGetSystemState(pxTaskStatusArray, uxArraySize, NULL);
-
-        /* Create a human readable table from the binary data. */
-        for (x = 0; x < uxArraySize; x++) {
-            switch (pxTaskStatusArray[x].eCurrentState) {
-            case eRunning:
-                cStatus = tskRUNNING_CHAR;
-                break;
-
-            case eReady:
-                cStatus = tskREADY_CHAR;
-                break;
-
-            case eBlocked:
-                cStatus = tskBLOCKED_CHAR;
-                break;
-
-            case eSuspended:
-                cStatus = tskSUSPENDED_CHAR;
-                break;
-
-            case eDeleted:
-                cStatus = tskDELETED_CHAR;
-                break;
-
-            case eInvalid: /* Fall through. */
-            default: /* Should not get here, but it is included
-                     to prevent static checking errors. */
-                cStatus = (char)0x00;
-                break;
-            }
-
-            /* Write the task name to the string, padding with spaces so it
-            can be printed in tabular form more easily. */
-            pcWriteBuffer = prvWriteNameToBuffer(
-                pcWriteBuffer, pxTaskStatusArray[x].pcTaskName);
-
-            /* Write the rest of the string. */
-            sprintf(
-                pcWriteBuffer,
-                "\t%c\t%u\t%u\t%u\r\n",
-                cStatus,
-                (unsigned int)pxTaskStatusArray[x].uxCurrentPriority,
-                (unsigned int)pxTaskStatusArray[x].usStackHighWaterMark,
-                (unsigned int)pxTaskStatusArray[x]
-                    .xTaskNumber); /*lint !e586 sprintf() allowed as this is
-                                      compiled with many compilers and this is a
-                                      utility function only - not part of the
-                                      core kernel implementation. */
-            pcWriteBuffer += strlen(
-                pcWriteBuffer); /*lint !e9016 Pointer arithmetic ok on char
-                                   pointers especially as in this case where it
-                                   best denotes the intent of the code. */
-        }
-
-        /* Free the array again.  NOTE!  If configSUPPORT_DYNAMIC_ALLOCATION
-        is 0 then vPortFree() will be #defined to nothing. */
-        vPortFree(pxTaskStatusArray);
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-}
-
-#endif /* ( ( configUSE_TRACE_FACILITY == 1 ) && ( \
-          configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( \
-          configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */
-/*----------------------------------------------------------*/
-
-#if ( \
-    (configGENERATE_RUN_TIME_STATS == 1) && \
-    (configUSE_STATS_FORMATTING_FUNCTIONS > 0) && \
-    (configSUPPORT_DYNAMIC_ALLOCATION == 1))
-
-void vTaskGetRunTimeStats(char *pcWriteBuffer)
-{
-    TaskStatus_t *pxTaskStatusArray;
-    UBaseType_t uxArraySize, x;
-    uint32_t ulTotalTime, ulStatsAsPercentage;
-
-#    if (configUSE_TRACE_FACILITY != 1)
-    {
-#error configUSE_TRACE_FACILITY must also be set to 1 in FreeRTOSConfig.h to use vTaskGetRunTimeStats().
-    }
-#    endif
-
-    /*
-     * PLEASE NOTE:
-     *
-     * This function is provided for convenience only, and is used by many
-     * of the demo applications.  Do not consider it to be part of the
-     * scheduler.
-     *
-     * vTaskGetRunTimeStats() calls uxTaskGetSystemState(), then formats part
-     * of the uxTaskGetSystemState() output into a human readable table that
-     * displays the amount of time each task has spent in the Running state
-     * in both absolute and percentage terms.
-     *
-     * vTaskGetRunTimeStats() has a dependency on the sprintf() C library
-     * function that might bloat the code size, use a lot of stack, and
-     * provide different results on different platforms.  An alternative,
-     * tiny, third party, and limited functionality implementation of
-     * sprintf() is provided in many of the FreeRTOS/Demo sub-directories in
-     * a file called printf-stdarg.c (note printf-stdarg.c does not provide
-     * a full snprintf() implementation!).
-     *
-     * It is recommended that production systems call uxTaskGetSystemState()
-     * directly to get access to raw stats data, rather than indirectly
-     * through a call to vTaskGetRunTimeStats().
-     */
-
-    /* Make sure the write buffer does not contain a string. */
-    *pcWriteBuffer = (char)0x00;
-
-    /* Take a snapshot of the number of tasks in case it changes while this
-    function is executing. */
-    uxArraySize = uxCurrentNumberOfTasks;
-
-    /* Allocate an array index for each task.  NOTE!  If
-    configSUPPORT_DYNAMIC_ALLOCATION is set to 0 then pvPortMalloc() will
-    equate to NULL. */
-    pxTaskStatusArray = pvPortMalloc(
-        uxCurrentNumberOfTasks *
-        sizeof(
-            TaskStatus_t)); /*lint !e9079 All values returned by pvPortMalloc()
-                               have at least the alignment required by the MCU's
-                               stack and this allocation allocates a struct that
-                               has the alignment requirements of a pointer. */
-
-    if (pxTaskStatusArray != NULL) {
-        /* Generate the (binary) data. */
-        uxArraySize =
-            uxTaskGetSystemState(pxTaskStatusArray, uxArraySize, &ulTotalTime);
-
-        /* For percentage calculations. */
-        ulTotalTime /= 100UL;
-
-        /* Avoid divide by zero errors. */
-        if (ulTotalTime > 0UL) {
-            /* Create a human readable table from the binary data. */
-            for (x = 0; x < uxArraySize; x++) {
-                /* What percentage of the total run time has the task used?
-                This will always be rounded down to the nearest integer.
-                ulTotalRunTimeDiv100 has already been divided by 100. */
-                ulStatsAsPercentage =
-                    pxTaskStatusArray[x].ulRunTimeCounter / ulTotalTime;
-
-                /* Write the task name to the string, padding with
-                spaces so it can be printed in tabular form more
-                easily. */
-                pcWriteBuffer = prvWriteNameToBuffer(
-                    pcWriteBuffer, pxTaskStatusArray[x].pcTaskName);
-
-                if (ulStatsAsPercentage > 0UL) {
-#    ifdef portLU_PRINTF_SPECIFIER_REQUIRED
-                    {
-                        sprintf(
-                            pcWriteBuffer,
-                            "\t%lu\t\t%lu%%\r\n",
-                            pxTaskStatusArray[x].ulRunTimeCounter,
-                            ulStatsAsPercentage);
-                    }
-#    else
-                    {
-                        /* sizeof( int ) == sizeof( long ) so a smaller
-                        printf() library can be used. */
-                        sprintf(
-                            pcWriteBuffer,
-                            "\t%u\t\t%u%%\r\n",
-                            (unsigned int)pxTaskStatusArray[x].ulRunTimeCounter,
-                            (unsigned int)
-                                ulStatsAsPercentage); /*lint !e586 sprintf()
-                                                         allowed as this is
-                                                         compiled with many
-                                                         compilers and this is a
-                                                         utility function only -
-                                                         not part of the core
-                                                         kernel implementation.
-                                                       */
-                    }
-#    endif
-                } else {
-/* If the percentage is zero here then the task has
-consumed less than 1% of the total run time. */
-#    ifdef portLU_PRINTF_SPECIFIER_REQUIRED
-                    {
-                        sprintf(
-                            pcWriteBuffer,
-                            "\t%lu\t\t<1%%\r\n",
-                            pxTaskStatusArray[x].ulRunTimeCounter);
-                    }
-#    else
-                    {
-                        /* sizeof( int ) == sizeof( long ) so a smaller
-                        printf() library can be used. */
-                        sprintf(
-                            pcWriteBuffer,
-                            "\t%u\t\t<1%%\r\n",
-                            (unsigned int)pxTaskStatusArray[x]
-                                .ulRunTimeCounter); /*lint !e586 sprintf()
-                                                       allowed as this is
-                                                       compiled with many
-                                                       compilers and this is a
-                                                       utility function only -
-                                                       not part of the core
-                                                       kernel implementation. */
-                    }
-#    endif
-                }
-
-                pcWriteBuffer +=
-                    strlen(pcWriteBuffer); /*lint !e9016 Pointer arithmetic ok
-                                              on char pointers especially as in
-                                              this case where it best denotes
-                                              the intent of the code. */
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-
-        /* Free the array again.  NOTE!  If configSUPPORT_DYNAMIC_ALLOCATION
-        is 0 then vPortFree() will be #defined to nothing. */
-        vPortFree(pxTaskStatusArray);
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-}
-
-#endif /* ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( \
-          configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( \
-          configSUPPORT_STATIC_ALLOCATION == 1 ) ) */
-/*-----------------------------------------------------------*/
-
-TickType_t uxTaskResetEventItemValue(void)
-{
-    TickType_t uxReturn;
-
-    uxReturn = listGET_LIST_ITEM_VALUE(&(pxCurrentTCB->xEventListItem));
-
-    /* Reset the event list item to its normal value - so it can be used with
-    queues and semaphores. */
-    listSET_LIST_ITEM_VALUE(
-        &(pxCurrentTCB->xEventListItem),
-        ((TickType_t)configMAX_PRIORITIES -
-         (TickType_t)pxCurrentTCB
-             ->uxPriority)); /*lint !e961 MISRA exception as the casts are only
-                                redundant for some ports. */
-
-    return uxReturn;
-}
-/*-----------------------------------------------------------*/
-
-#if (configUSE_MUTEXES == 1)
-
-TaskHandle_t pvTaskIncrementMutexHeldCount(void)
-{
-    /* If xSemaphoreCreateMutex() is called before any tasks have been created
-    then pxCurrentTCB will be NULL. */
-    if (pxCurrentTCB != NULL) {
-        (pxCurrentTCB->uxMutexesHeld)++;
-    }
-
-    return pxCurrentTCB;
-}
-
-#endif /* configUSE_MUTEXES */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TASK_NOTIFICATIONS == 1)
-
-uint32_t ulTaskNotifyTake(BaseType_t xClearCountOnExit, TickType_t xTicksToWait)
-{
-    uint32_t ulReturn;
-
-    taskENTER_CRITICAL();
-    {
-        /* Only block if the notification count is not already non-zero. */
-        if (pxCurrentTCB->ulNotifiedValue == 0UL) {
-            /* Mark this task as waiting for a notification. */
-            pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;
-
-            if (xTicksToWait > (TickType_t)0) {
-                prvAddCurrentTaskToDelayedList(xTicksToWait, pdTRUE);
-                traceTASK_NOTIFY_TAKE_BLOCK();
-
-                /* All ports are written to allow a yield in a critical
-                section (some will yield immediately, others wait until the
-                critical section exits) - but it is not something that
-                application code should ever do. */
-                portYIELD_WITHIN_API();
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    taskENTER_CRITICAL();
-    {
-        traceTASK_NOTIFY_TAKE();
-        ulReturn = pxCurrentTCB->ulNotifiedValue;
-
-        if (ulReturn != 0UL) {
-            if (xClearCountOnExit != pdFALSE) {
-                pxCurrentTCB->ulNotifiedValue = 0UL;
-            } else {
-                pxCurrentTCB->ulNotifiedValue = ulReturn - (uint32_t)1;
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-
-        pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
-    }
-    taskEXIT_CRITICAL();
-
-    return ulReturn;
-}
-
-#endif /* configUSE_TASK_NOTIFICATIONS */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TASK_NOTIFICATIONS == 1)
-
-BaseType_t xTaskNotifyWait(
-    uint32_t ulBitsToClearOnEntry,
-    uint32_t ulBitsToClearOnExit,
-    uint32_t *pulNotificationValue,
-    TickType_t xTicksToWait)
-{
-    BaseType_t xReturn;
-
-    taskENTER_CRITICAL();
-    {
-        /* Only block if a notification is not already pending. */
-        if (pxCurrentTCB->ucNotifyState != taskNOTIFICATION_RECEIVED) {
-            /* Clear bits in the task's notification value as bits may get
-            set	by the notifying task or interrupt.  This can be used to
-            clear the value to zero. */
-            pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnEntry;
-
-            /* Mark this task as waiting for a notification. */
-            pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;
-
-            if (xTicksToWait > (TickType_t)0) {
-                prvAddCurrentTaskToDelayedList(xTicksToWait, pdTRUE);
-                traceTASK_NOTIFY_WAIT_BLOCK();
-
-                /* All ports are written to allow a yield in a critical
-                section (some will yield immediately, others wait until the
-                critical section exits) - but it is not something that
-                application code should ever do. */
-                portYIELD_WITHIN_API();
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    taskENTER_CRITICAL();
-    {
-        traceTASK_NOTIFY_WAIT();
-
-        if (pulNotificationValue != NULL) {
-            /* Output the current notification value, which may or may not
-            have changed. */
-            *pulNotificationValue = pxCurrentTCB->ulNotifiedValue;
-        }
-
-        /* If ucNotifyValue is set then either the task never entered the
-        blocked state (because a notification was already pending) or the
-        task unblocked because of a notification.  Otherwise the task
-        unblocked because of a timeout. */
-        if (pxCurrentTCB->ucNotifyState != taskNOTIFICATION_RECEIVED) {
-            /* A notification was not received. */
-            xReturn = pdFALSE;
-        } else {
-            /* A notification was already pending or a notification was
-            received while the task was waiting. */
-            pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnExit;
-            xReturn = pdTRUE;
-        }
-
-        pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
-    }
-    taskEXIT_CRITICAL();
-
-    return xReturn;
-}
-
-#endif /* configUSE_TASK_NOTIFICATIONS */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TASK_NOTIFICATIONS == 1)
-
-BaseType_t xTaskGenericNotify(
-    TaskHandle_t xTaskToNotify,
-    uint32_t ulValue,
-    eNotifyAction eAction,
-    uint32_t *pulPreviousNotificationValue)
-{
-    TCB_t *pxTCB;
-    BaseType_t xReturn = pdPASS;
-    uint8_t ucOriginalNotifyState;
-
-    configASSERT(xTaskToNotify);
-    pxTCB = xTaskToNotify;
-
-    taskENTER_CRITICAL();
-    {
-        if (pulPreviousNotificationValue != NULL) {
-            *pulPreviousNotificationValue = pxTCB->ulNotifiedValue;
-        }
-
-        ucOriginalNotifyState = pxTCB->ucNotifyState;
-
-        pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;
-
-        switch (eAction) {
-        case eSetBits:
-            pxTCB->ulNotifiedValue |= ulValue;
-            break;
-
-        case eIncrement:
-            (pxTCB->ulNotifiedValue)++;
-            break;
-
-        case eSetValueWithOverwrite:
-            pxTCB->ulNotifiedValue = ulValue;
-            break;
-
-        case eSetValueWithoutOverwrite:
-            if (ucOriginalNotifyState != taskNOTIFICATION_RECEIVED) {
-                pxTCB->ulNotifiedValue = ulValue;
-            } else {
-                /* The value could not be written to the task. */
-                xReturn = pdFAIL;
-            }
-            break;
-
-        case eNoAction:
-            /* The task is being notified without its notify value being
-            updated. */
-            break;
-
-        default:
-            /* Should not get here if all enums are handled.
-            Artificially force an assert by testing a value the
-            compiler can't assume is const. */
-            configASSERT(pxTCB->ulNotifiedValue == ~0UL);
-
-            break;
-        }
-
-        traceTASK_NOTIFY();
-
-        /* If the task is in the blocked state specifically to wait for a
-        notification then unblock it now. */
-        if (ucOriginalNotifyState == taskWAITING_NOTIFICATION) {
-            (void)uxListRemove(&(pxTCB->xStateListItem));
-            prvAddTaskToReadyList(pxTCB);
-
-            /* The task should not have been on an event list. */
-            configASSERT(
-                listLIST_ITEM_CONTAINER(&(pxTCB->xEventListItem)) == NULL);
-
-#    if (configUSE_TICKLESS_IDLE != 0)
-            {
-                /* If a task is blocked waiting for a notification then
-                xNextTaskUnblockTime might be set to the blocked task's time
-                out time.  If the task is unblocked for a reason other than
-                a timeout xNextTaskUnblockTime is normally left unchanged,
-                because it will automatically get reset to a new value when
-                the tick count equals xNextTaskUnblockTime.  However if
-                tickless idling is used it might be more important to enter
-                sleep mode at the earliest possible time - so reset
-                xNextTaskUnblockTime here to ensure it is updated at the
-                earliest possible time. */
-                prvResetNextTaskUnblockTime();
-            }
-#    endif
-
-            if (pxTCB->uxPriority > pxCurrentTCB->uxPriority) {
-                /* The notified task has a priority above the currently
-                executing task so a yield is required. */
-                taskYIELD_IF_USING_PREEMPTION();
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    return xReturn;
-}
-
-#endif /* configUSE_TASK_NOTIFICATIONS */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TASK_NOTIFICATIONS == 1)
-
-BaseType_t xTaskGenericNotifyFromISR(
-    TaskHandle_t xTaskToNotify,
-    uint32_t ulValue,
-    eNotifyAction eAction,
-    uint32_t *pulPreviousNotificationValue,
-    BaseType_t *pxHigherPriorityTaskWoken)
-{
-    TCB_t *pxTCB;
-    uint8_t ucOriginalNotifyState;
-    BaseType_t xReturn = pdPASS;
-    UBaseType_t uxSavedInterruptStatus;
-
-    configASSERT(xTaskToNotify);
-
-    /* RTOS ports that support interrupt nesting have the concept of a
-    maximum	system call (or maximum API call) interrupt priority.
-    Interrupts that are	above the maximum system call priority are keep
-    permanently enabled, even when the RTOS kernel is in a critical section,
-    but cannot make any calls to FreeRTOS API functions.  If configASSERT()
-    is defined in FreeRTOSConfig.h then
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
-    failure if a FreeRTOS API function is called from an interrupt that has
-    been assigned a priority above the configured maximum system call
-    priority.  Only FreeRTOS functions that end in FromISR can be called
-    from interrupts	that have been assigned a priority at or (logically)
-    below the maximum system call interrupt priority.  FreeRTOS maintains a
-    separate interrupt safe API to ensure interrupt entry is as fast and as
-    simple as possible.  More information (albeit Cortex-M specific) is
-    provided on the following link:
-    http://www.freertos.org/RTOS-Cortex-M3-M4.html */
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
-
-    pxTCB = xTaskToNotify;
-
-    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
-    {
-        if (pulPreviousNotificationValue != NULL) {
-            *pulPreviousNotificationValue = pxTCB->ulNotifiedValue;
-        }
-
-        ucOriginalNotifyState = pxTCB->ucNotifyState;
-        pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;
-
-        switch (eAction) {
-        case eSetBits:
-            pxTCB->ulNotifiedValue |= ulValue;
-            break;
-
-        case eIncrement:
-            (pxTCB->ulNotifiedValue)++;
-            break;
-
-        case eSetValueWithOverwrite:
-            pxTCB->ulNotifiedValue = ulValue;
-            break;
-
-        case eSetValueWithoutOverwrite:
-            if (ucOriginalNotifyState != taskNOTIFICATION_RECEIVED) {
-                pxTCB->ulNotifiedValue = ulValue;
-            } else {
-                /* The value could not be written to the task. */
-                xReturn = pdFAIL;
-            }
-            break;
-
-        case eNoAction:
-            /* The task is being notified without its notify value being
-            updated. */
-            break;
-
-        default:
-            /* Should not get here if all enums are handled.
-            Artificially force an assert by testing a value the
-            compiler can't assume is const. */
-            configASSERT(pxTCB->ulNotifiedValue == ~0UL);
-            break;
-        }
-
-        traceTASK_NOTIFY_FROM_ISR();
-
-        /* If the task is in the blocked state specifically to wait for a
-        notification then unblock it now. */
-        if (ucOriginalNotifyState == taskWAITING_NOTIFICATION) {
-            /* The task should not have been on an event list. */
-            configASSERT(
-                listLIST_ITEM_CONTAINER(&(pxTCB->xEventListItem)) == NULL);
-
-            if (uxSchedulerSuspended == (UBaseType_t)pdFALSE) {
-                (void)uxListRemove(&(pxTCB->xStateListItem));
-                prvAddTaskToReadyList(pxTCB);
-            } else {
-                /* The delayed and ready lists cannot be accessed, so hold
-                this task pending until the scheduler is resumed. */
-                vListInsertEnd(&(xPendingReadyList), &(pxTCB->xEventListItem));
-            }
-
-            if (pxTCB->uxPriority > pxCurrentTCB->uxPriority) {
-                /* The notified task has a priority above the currently
-                executing task so a yield is required. */
-                if (pxHigherPriorityTaskWoken != NULL) {
-                    *pxHigherPriorityTaskWoken = pdTRUE;
-                }
-
-                /* Mark that a yield is pending in case the user is not
-                using the "xHigherPriorityTaskWoken" parameter to an ISR
-                safe FreeRTOS function. */
-                xYieldPending = pdTRUE;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-    }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus);
-
-    return xReturn;
-}
-
-#endif /* configUSE_TASK_NOTIFICATIONS */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TASK_NOTIFICATIONS == 1)
-
-void vTaskNotifyGiveFromISR(
-    TaskHandle_t xTaskToNotify,
-    BaseType_t *pxHigherPriorityTaskWoken)
-{
-    TCB_t *pxTCB;
-    uint8_t ucOriginalNotifyState;
-    UBaseType_t uxSavedInterruptStatus;
-
-    configASSERT(xTaskToNotify);
-
-    /* RTOS ports that support interrupt nesting have the concept of a
-    maximum	system call (or maximum API call) interrupt priority.
-    Interrupts that are	above the maximum system call priority are keep
-    permanently enabled, even when the RTOS kernel is in a critical section,
-    but cannot make any calls to FreeRTOS API functions.  If configASSERT()
-    is defined in FreeRTOSConfig.h then
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
-    failure if a FreeRTOS API function is called from an interrupt that has
-    been assigned a priority above the configured maximum system call
-    priority.  Only FreeRTOS functions that end in FromISR can be called
-    from interrupts	that have been assigned a priority at or (logically)
-    below the maximum system call interrupt priority.  FreeRTOS maintains a
-    separate interrupt safe API to ensure interrupt entry is as fast and as
-    simple as possible.  More information (albeit Cortex-M specific) is
-    provided on the following link:
-    http://www.freertos.org/RTOS-Cortex-M3-M4.html */
-    portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
-
-    pxTCB = xTaskToNotify;
-
-    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
-    {
-        ucOriginalNotifyState = pxTCB->ucNotifyState;
-        pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;
-
-        /* 'Giving' is equivalent to incrementing a count in a counting
-        semaphore. */
-        (pxTCB->ulNotifiedValue)++;
-
-        traceTASK_NOTIFY_GIVE_FROM_ISR();
-
-        /* If the task is in the blocked state specifically to wait for a
-        notification then unblock it now. */
-        if (ucOriginalNotifyState == taskWAITING_NOTIFICATION) {
-            /* The task should not have been on an event list. */
-            configASSERT(
-                listLIST_ITEM_CONTAINER(&(pxTCB->xEventListItem)) == NULL);
-
-            if (uxSchedulerSuspended == (UBaseType_t)pdFALSE) {
-                (void)uxListRemove(&(pxTCB->xStateListItem));
-                prvAddTaskToReadyList(pxTCB);
-            } else {
-                /* The delayed and ready lists cannot be accessed, so hold
-                this task pending until the scheduler is resumed. */
-                vListInsertEnd(&(xPendingReadyList), &(pxTCB->xEventListItem));
-            }
-
-            if (pxTCB->uxPriority > pxCurrentTCB->uxPriority) {
-                /* The notified task has a priority above the currently
-                executing task so a yield is required. */
-                if (pxHigherPriorityTaskWoken != NULL) {
-                    *pxHigherPriorityTaskWoken = pdTRUE;
-                }
-
-                /* Mark that a yield is pending in case the user is not
-                using the "xHigherPriorityTaskWoken" parameter in an ISR
-                safe FreeRTOS function. */
-                xYieldPending = pdTRUE;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-    }
-    portCLEAR_INTERRUPT_MASK_FROM_ISR(uxSavedInterruptStatus);
-}
-
-#endif /* configUSE_TASK_NOTIFICATIONS */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TASK_NOTIFICATIONS == 1)
-
-BaseType_t xTaskNotifyStateClear(TaskHandle_t xTask)
-{
-    TCB_t *pxTCB;
-    BaseType_t xReturn;
-
-    /* If null is passed in here then it is the calling task that is having
-    its notification state cleared. */
-    pxTCB = prvGetTCBFromHandle(xTask);
-
-    taskENTER_CRITICAL();
-    {
-        if (pxTCB->ucNotifyState == taskNOTIFICATION_RECEIVED) {
-            pxTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
-            xReturn = pdPASS;
-        } else {
-            xReturn = pdFAIL;
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    return xReturn;
-}
-
-#endif /* configUSE_TASK_NOTIFICATIONS */
-/*-----------------------------------------------------------*/
-
-#if (configUSE_TASK_NOTIFICATIONS == 1)
-
-uint32_t ulTaskNotifyValueClear(TaskHandle_t xTask, uint32_t ulBitsToClear)
-{
-    TCB_t *pxTCB;
-    uint32_t ulReturn;
-
-    /* If null is passed in here then it is the calling task that is having
-    its notification state cleared. */
-    pxTCB = prvGetTCBFromHandle(xTask);
-
-    taskENTER_CRITICAL();
-    {
-        /* Return the notification as it was before the bits were cleared,
-        then clear the bit mask. */
-        ulReturn = pxCurrentTCB->ulNotifiedValue;
-        pxTCB->ulNotifiedValue &= ~ulBitsToClear;
-    }
-    taskEXIT_CRITICAL();
-
-    return ulReturn;
-}
-
-#endif /* configUSE_TASK_NOTIFICATIONS */
-/*-----------------------------------------------------------*/
-
-#if ( \
-    (configGENERATE_RUN_TIME_STATS == 1) && \
-    (INCLUDE_xTaskGetIdleTaskHandle == 1))
-
-uint32_t ulTaskGetIdleRunTimeCounter(void)
-{
-    return xIdleTaskHandle->ulRunTimeCounter;
-}
-
-#endif
-/*-----------------------------------------------------------*/
-
-static void prvAddCurrentTaskToDelayedList(
-    TickType_t xTicksToWait,
-    const BaseType_t xCanBlockIndefinitely)
-{
-    TickType_t xTimeToWake;
-    const TickType_t xConstTickCount = xTickCount;
-
-#if (INCLUDE_xTaskAbortDelay == 1)
-    {
-        /* About to enter a delayed list, so ensure the ucDelayAborted flag is
-        reset to pdFALSE so it can be detected as having been set to pdTRUE
-        when the task leaves the Blocked state. */
-        pxCurrentTCB->ucDelayAborted = pdFALSE;
-    }
-#endif
-
-    /* Remove the task from the ready list before adding it to the blocked list
-    as the same list item is used for both lists. */
-    if (uxListRemove(&(pxCurrentTCB->xStateListItem)) == (UBaseType_t)0) {
-        /* The current task must be in a ready list, so there is no need to
-        check, and the port reset macro can be called directly. */
-        portRESET_READY_PRIORITY(
-            pxCurrentTCB->uxPriority,
-            uxTopReadyPriority); /*lint !e931 pxCurrentTCB cannot change as it
-                                    is the calling task.
-                                    pxCurrentTCB->uxPriority and
-                                    uxTopReadyPriority cannot change as called
-                                    with scheduler suspended or in a critical
-                                    section. */
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-#if (INCLUDE_vTaskSuspend == 1)
-    {
-        if ((xTicksToWait == portMAX_DELAY) &&
-            (xCanBlockIndefinitely != pdFALSE)) {
-            /* Add the task to the suspended task list instead of a delayed task
-            list to ensure it is not woken by a timing event.  It will block
-            indefinitely. */
-            vListInsertEnd(
-                &xSuspendedTaskList, &(pxCurrentTCB->xStateListItem));
-        } else {
-            /* Calculate the time at which the task should be woken if the event
-            does not occur.  This may overflow but this doesn't matter, the
-            kernel will manage it correctly. */
-            xTimeToWake = xConstTickCount + xTicksToWait;
-
-            /* The list item will be inserted in wake time order. */
-            listSET_LIST_ITEM_VALUE(
-                &(pxCurrentTCB->xStateListItem), xTimeToWake);
-
-            if (xTimeToWake < xConstTickCount) {
-                /* Wake time has overflowed.  Place this item in the overflow
-                list. */
-                vListInsert(
-                    pxOverflowDelayedTaskList, &(pxCurrentTCB->xStateListItem));
-            } else {
-                /* The wake time has not overflowed, so the current block list
-                is used. */
-                vListInsert(pxDelayedTaskList, &(pxCurrentTCB->xStateListItem));
-
-                /* If the task entering the blocked state was placed at the
-                head of the list of blocked tasks then xNextTaskUnblockTime
-                needs to be updated too. */
-                if (xTimeToWake < xNextTaskUnblockTime) {
-                    xNextTaskUnblockTime = xTimeToWake;
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            }
-        }
-    }
-#else /* INCLUDE_vTaskSuspend */
-    {
-        /* Calculate the time at which the task should be woken if the event
-        does not occur.  This may overflow but this doesn't matter, the kernel
-        will manage it correctly. */
-        xTimeToWake = xConstTickCount + xTicksToWait;
-
-        /* The list item will be inserted in wake time order. */
-        listSET_LIST_ITEM_VALUE(&(pxCurrentTCB->xStateListItem), xTimeToWake);
-
-        if (xTimeToWake < xConstTickCount) {
-            /* Wake time has overflowed.  Place this item in the overflow list.
-             */
-            vListInsert(
-                pxOverflowDelayedTaskList, &(pxCurrentTCB->xStateListItem));
-        } else {
-            /* The wake time has not overflowed, so the current block list is
-             * used. */
-            vListInsert(pxDelayedTaskList, &(pxCurrentTCB->xStateListItem));
-
-            /* If the task entering the blocked state was placed at the head of
-            the list of blocked tasks then xNextTaskUnblockTime needs to be
-            updated too. */
-            if (xTimeToWake < xNextTaskUnblockTime) {
-                xNextTaskUnblockTime = xTimeToWake;
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-
-        /* Avoid compiler warning when INCLUDE_vTaskSuspend is not 1. */
-        (void)xCanBlockIndefinitely;
-    }
-#endif /* INCLUDE_vTaskSuspend */
-}
-
-/* Code below here allows additional code to be inserted into this source file,
-especially where access to file scope functions and data is needed (for example
-when performing module tests). */
-
-#ifdef FREERTOS_MODULE_TEST
-#    include "tasks_test_access_functions.h"
-#endif
-
-#if (configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H == 1)
-
-#    include "freertos_tasks_c_additions.h"
-
-#    ifdef FREERTOS_TASKS_C_ADDITIONS_INIT
-static void freertos_tasks_c_additions_init(void)
-{
-    FREERTOS_TASKS_C_ADDITIONS_INIT();
-}
-#    endif
-
-#endif
diff --git a/product/rcar/src/CMSIS-FreeRTOS/Source/timers.c b/product/rcar/src/CMSIS-FreeRTOS/Source/timers.c
deleted file mode 100644
index 253022929f3ccb548dbbc8da4f33c090c0924fa9..0000000000000000000000000000000000000000
--- a/product/rcar/src/CMSIS-FreeRTOS/Source/timers.c
+++ /dev/null
@@ -1,1200 +0,0 @@
-/*
- * FreeRTOS Kernel V10.3.1
- * 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://www.FreeRTOS.org
- * http://aws.amazon.com/freertos
- *
- * 1 tab == 4 spaces!
- */
-
-/* Standard includes. */
-#include 
-
-/* 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 "queue.h"
-#include "task.h"
-#include "timers.h"
-
-#if (INCLUDE_xTimerPendFunctionCall == 1) && (configUSE_TIMERS == 0)
-#error configUSE_TIMERS must be set to 1 to make the xTimerPendFunctionCall() function available.
-#endif
-
-/* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified
-because 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 /*lint !e9021 !e961 !e750. */
-
-/* This entire source file will be skipped if the application is not configured
-to include software timer functionality.  This #if is closed at the very bottom
-of this file.  If you want to include software timer functionality then ensure
-configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */
-#if (configUSE_TIMERS == 1)
-
-/* Misc definitions. */
-#    define tmrNO_DELAY (TickType_t)0U
-
-/* The name assigned to the timer service task.  This can be overridden by
-defining trmTIMER_SERVICE_TASK_NAME in FreeRTOSConfig.h. */
-#    ifndef configTIMER_SERVICE_TASK_NAME
-#        define configTIMER_SERVICE_TASK_NAME "Tmr Svc"
-#    endif
-
-/* Bit definitions used in the ucStatus member of a timer structure. */
-#    define tmrSTATUS_IS_ACTIVE ((uint8_t)0x01)
-#    define tmrSTATUS_IS_STATICALLY_ALLOCATED ((uint8_t)0x02)
-#    define tmrSTATUS_IS_AUTORELOAD ((uint8_t)0x04)
-
-/* The definition of the timers themselves. */
-typedef struct tmrTimerControl /* The old naming convention is used to prevent
-                                  breaking kernel aware debuggers. */
-{
-    const char				*pcTimerName;		/*<< Text name.  This is not used by the kernel, it is included simply to make debugging easier. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
-    ListItem_t xTimerListItem; /*<< Standard linked list item as used by all
-                                  kernel features for event management. */
-    TickType_t
-        xTimerPeriodInTicks; /*<< How quickly and often the timer expires. */
-    void *pvTimerID; /*<< An ID to identify the timer.  This allows the timer to
-                        be identified when the same callback is used for
-                        multiple timers. */
-    TimerCallbackFunction_t
-        pxCallbackFunction; /*<< The function that will be called when the timer
-                               expires. */
-#    if (configUSE_TRACE_FACILITY == 1)
-    UBaseType_t uxTimerNumber; /*<< An ID assigned by trace tools such as
-                                  FreeRTOS+Trace */
-#    endif
-    uint8_t ucStatus; /*<< Holds bits to say if the timer was statically
-                         allocated or not, and if it is active or not. */
-} xTIMER;
-
-/* The old xTIMER name is maintained above then typedefed to the new Timer_t
-name below to enable the use of older kernel aware debuggers. */
-typedef xTIMER Timer_t;
-
-/* The definition of messages that can be sent and received on the timer queue.
-Two types of message can be queued - messages that manipulate a software timer,
-and messages that request the execution of a non-timer related callback.  The
-two message types are defined in two separate structures, xTimerParametersType
-and xCallbackParametersType respectively. */
-typedef struct tmrTimerParameters {
-    TickType_t
-        xMessageValue; /*<< An optional value used by a subset of commands, for
-                          example, when changing the period of a timer. */
-    Timer_t *pxTimer; /*<< The timer to which the command will be applied. */
-} TimerParameter_t;
-
-typedef struct tmrCallbackParameters {
-    PendedFunction_t
-        pxCallbackFunction; /* << The callback function to execute. */
-    void *pvParameter1; /* << The value that will be used as the callback
-                           functions first parameter. */
-    uint32_t ulParameter2; /* << The value that will be used as the callback
-                              functions second parameter. */
-} CallbackParameters_t;
-
-/* The structure that contains the two message types, along with an identifier
-that is used to determine which message type is valid. */
-typedef struct tmrTimerQueueMessage {
-    BaseType_t
-        xMessageID; /*<< The command being sent to the timer service task. */
-    union {
-        TimerParameter_t xTimerParameters;
-
-/* Don't include xCallbackParameters if it is not going to be used as
-it makes the structure (and therefore the timer queue) larger. */
-#    if (INCLUDE_xTimerPendFunctionCall == 1)
-        CallbackParameters_t xCallbackParameters;
-#    endif /* INCLUDE_xTimerPendFunctionCall */
-    } u;
-} DaemonTaskMessage_t;
-
-/*lint -save -e956 A manual analysis and inspection has been used to determine
-which static variables must be declared volatile. */
-
-/* The list in which active timers are stored.  Timers are referenced in expire
-time order, with the nearest expiry time at the front of the list.  Only the
-timer service task is allowed to access these lists.
-xActiveTimerList1 and xActiveTimerList2 could be at function scope but that
-breaks some kernel aware debuggers, and debuggers that reply on removing the
-static qualifier. */
-PRIVILEGED_DATA static List_t xActiveTimerList1;
-PRIVILEGED_DATA static List_t xActiveTimerList2;
-PRIVILEGED_DATA static List_t *pxCurrentTimerList;
-PRIVILEGED_DATA static List_t *pxOverflowTimerList;
-
-/* A queue that is used to send commands to the timer service task. */
-PRIVILEGED_DATA static QueueHandle_t xTimerQueue = NULL;
-PRIVILEGED_DATA static TaskHandle_t xTimerTaskHandle = NULL;
-
-/*lint -restore */
-
-/*-----------------------------------------------------------*/
-
-#    if (configSUPPORT_STATIC_ALLOCATION == 1)
-
-/* If static allocation is supported then the application must provide the
-following callback function - which enables the application to optionally
-provide the memory that will be used by the timer task as the task's stack
-and TCB. */
-extern void vApplicationGetTimerTaskMemory(
-    StaticTask_t **ppxTimerTaskTCBBuffer,
-    StackType_t **ppxTimerTaskStackBuffer,
-    uint32_t *pulTimerTaskStackSize);
-
-#    endif
-
-/*
- * Initialise the infrastructure used by the timer service task if it has not
- * been initialised already.
- */
-static void prvCheckForValidListAndQueue(void) PRIVILEGED_FUNCTION;
-
-/*
- * The timer service task (daemon).  Timer functionality is controlled by this
- * task.  Other tasks communicate with the timer service task using the
- * xTimerQueue queue.
- */
-static portTASK_FUNCTION_PROTO(prvTimerTask, pvParameters) PRIVILEGED_FUNCTION;
-
-/*
- * Called by the timer service task to interpret and process a command it
- * received on the timer queue.
- */
-static void prvProcessReceivedCommands(void) PRIVILEGED_FUNCTION;
-
-/*
- * Insert the timer into either xActiveTimerList1, or xActiveTimerList2,
- * depending on if the expire time causes a timer counter overflow.
- */
-static BaseType_t prvInsertTimerInActiveList(
-    Timer_t *const pxTimer,
-    const TickType_t xNextExpiryTime,
-    const TickType_t xTimeNow,
-    const TickType_t xCommandTime) PRIVILEGED_FUNCTION;
-
-/*
- * An active timer has reached its expire time.  Reload the timer if it is an
- * auto-reload timer, then call its callback.
- */
-static void prvProcessExpiredTimer(
-    const TickType_t xNextExpireTime,
-    const TickType_t xTimeNow) PRIVILEGED_FUNCTION;
-
-/*
- * The tick count has overflowed.  Switch the timer lists after ensuring the
- * current timer list does not still reference some timers.
- */
-static void prvSwitchTimerLists(void) PRIVILEGED_FUNCTION;
-
-/*
- * Obtain the current tick count, setting *pxTimerListsWereSwitched to pdTRUE
- * if a tick count overflow occurred since prvSampleTimeNow() was last called.
- */
-static TickType_t prvSampleTimeNow(BaseType_t *const pxTimerListsWereSwitched)
-    PRIVILEGED_FUNCTION;
-
-/*
- * If the timer list contains any active timers then return the expire time of
- * the timer that will expire first and set *pxListWasEmpty to false.  If the
- * timer list does not contain any timers then return 0 and set *pxListWasEmpty
- * to pdTRUE.
- */
-static TickType_t prvGetNextExpireTime(BaseType_t *const pxListWasEmpty)
-    PRIVILEGED_FUNCTION;
-
-/*
- * If a timer has expired, process it.  Otherwise, block the timer service task
- * until either a timer does expire or a command is received.
- */
-static void prvProcessTimerOrBlockTask(
-    const TickType_t xNextExpireTime,
-    BaseType_t xListWasEmpty) PRIVILEGED_FUNCTION;
-
-/*
- * Called after a Timer_t structure has been allocated either statically or
- * dynamically to fill in the structure's members.
- */
-static void prvInitialiseNewTimer(
-    const char
-        *const pcTimerName, /*lint !e971 Unqualified char types are allowed for
-                               strings and single characters only. */
-    const TickType_t xTimerPeriodInTicks,
-    const UBaseType_t uxAutoReload,
-    void *const pvTimerID,
-    TimerCallbackFunction_t pxCallbackFunction,
-    Timer_t *pxNewTimer) PRIVILEGED_FUNCTION;
-/*-----------------------------------------------------------*/
-
-BaseType_t xTimerCreateTimerTask(void)
-{
-    BaseType_t xReturn = pdFAIL;
-
-    /* This function is called when the scheduler is started if
-    configUSE_TIMERS is set to 1.  Check that the infrastructure used by the
-    timer service task has been created/initialised.  If timers have already
-    been created then the initialisation will already have been performed. */
-    prvCheckForValidListAndQueue();
-
-    if (xTimerQueue != NULL) {
-#    if (configSUPPORT_STATIC_ALLOCATION == 1)
-        {
-            StaticTask_t *pxTimerTaskTCBBuffer = NULL;
-            StackType_t *pxTimerTaskStackBuffer = NULL;
-            uint32_t ulTimerTaskStackSize;
-
-            vApplicationGetTimerTaskMemory(
-                &pxTimerTaskTCBBuffer,
-                &pxTimerTaskStackBuffer,
-                &ulTimerTaskStackSize);
-            xTimerTaskHandle = xTaskCreateStatic(
-                prvTimerTask,
-                configTIMER_SERVICE_TASK_NAME,
-                ulTimerTaskStackSize,
-                NULL,
-                ((UBaseType_t)configTIMER_TASK_PRIORITY) | portPRIVILEGE_BIT,
-                pxTimerTaskStackBuffer,
-                pxTimerTaskTCBBuffer);
-
-            if (xTimerTaskHandle != NULL) {
-                xReturn = pdPASS;
-            }
-        }
-#    else
-        {
-            xReturn = xTaskCreate(
-                prvTimerTask,
-                configTIMER_SERVICE_TASK_NAME,
-                configTIMER_TASK_STACK_DEPTH,
-                NULL,
-                ((UBaseType_t)configTIMER_TASK_PRIORITY) | portPRIVILEGE_BIT,
-                &xTimerTaskHandle);
-        }
-#    endif /* configSUPPORT_STATIC_ALLOCATION */
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    configASSERT(xReturn);
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-#    if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
-
-TimerHandle_t xTimerCreate(
-    const char
-        *const pcTimerName, /*lint !e971 Unqualified char types are allowed for
-                               strings and single characters only. */
-    const TickType_t xTimerPeriodInTicks,
-    const UBaseType_t uxAutoReload,
-    void *const pvTimerID,
-    TimerCallbackFunction_t pxCallbackFunction)
-{
-    Timer_t *pxNewTimer;
-
-    pxNewTimer = (Timer_t *)pvPortMalloc(
-        sizeof(Timer_t)); /*lint !e9087 !e9079 All values returned by
-                             pvPortMalloc() have at least the alignment required
-                             by the MCU's stack, and the first member of Timer_t
-                             is always a pointer to the timer's mame. */
-
-    if (pxNewTimer != NULL) {
-        /* Status is thus far zero as the timer is not created statically
-        and has not been started.  The auto-reload bit may get set in
-        prvInitialiseNewTimer. */
-        pxNewTimer->ucStatus = 0x00;
-        prvInitialiseNewTimer(
-            pcTimerName,
-            xTimerPeriodInTicks,
-            uxAutoReload,
-            pvTimerID,
-            pxCallbackFunction,
-            pxNewTimer);
-    }
-
-    return pxNewTimer;
-}
-
-#    endif /* configSUPPORT_DYNAMIC_ALLOCATION */
-/*-----------------------------------------------------------*/
-
-#    if (configSUPPORT_STATIC_ALLOCATION == 1)
-
-TimerHandle_t xTimerCreateStatic(
-    const char
-        *const pcTimerName, /*lint !e971 Unqualified char types are allowed for
-                               strings and single characters only. */
-    const TickType_t xTimerPeriodInTicks,
-    const UBaseType_t uxAutoReload,
-    void *const pvTimerID,
-    TimerCallbackFunction_t pxCallbackFunction,
-    StaticTimer_t *pxTimerBuffer)
-{
-    Timer_t *pxNewTimer;
-
-#        if (configASSERT_DEFINED == 1)
-    {
-        /* Sanity check that the size of the structure used to declare a
-        variable of type StaticTimer_t equals the size of the real timer
-        structure. */
-        volatile size_t xSize = sizeof(StaticTimer_t);
-        configASSERT(xSize == sizeof(Timer_t));
-        (void)xSize; /* Keeps lint quiet when configASSERT() is not defined. */
-    }
-#        endif /* configASSERT_DEFINED */
-
-    /* A pointer to a StaticTimer_t structure MUST be provided, use it. */
-    configASSERT(pxTimerBuffer);
-    pxNewTimer =
-        (Timer_t *)pxTimerBuffer; /*lint !e740 !e9087 StaticTimer_t is a pointer
-                                     to a Timer_t, so guaranteed to be aligned
-                                     and sized correctly (checked by an
-                                     assert()), so this is safe. */
-
-    if (pxNewTimer != NULL) {
-        /* Timers can be created statically or dynamically so note this
-        timer was created statically in case it is later deleted.  The
-        auto-reload bit may get set in prvInitialiseNewTimer(). */
-        pxNewTimer->ucStatus = tmrSTATUS_IS_STATICALLY_ALLOCATED;
-
-        prvInitialiseNewTimer(
-            pcTimerName,
-            xTimerPeriodInTicks,
-            uxAutoReload,
-            pvTimerID,
-            pxCallbackFunction,
-            pxNewTimer);
-    }
-
-    return pxNewTimer;
-}
-
-#    endif /* configSUPPORT_STATIC_ALLOCATION */
-/*-----------------------------------------------------------*/
-
-static void prvInitialiseNewTimer(
-    const char
-        *const pcTimerName, /*lint !e971 Unqualified char types are allowed for
-                               strings and single characters only. */
-    const TickType_t xTimerPeriodInTicks,
-    const UBaseType_t uxAutoReload,
-    void *const pvTimerID,
-    TimerCallbackFunction_t pxCallbackFunction,
-    Timer_t *pxNewTimer)
-{
-    /* 0 is not a valid value for xTimerPeriodInTicks. */
-    configASSERT((xTimerPeriodInTicks > 0));
-
-    if (pxNewTimer != NULL) {
-        /* Ensure the infrastructure used by the timer service task has been
-        created/initialised. */
-        prvCheckForValidListAndQueue();
-
-        /* Initialise the timer structure members using the function
-        parameters. */
-        pxNewTimer->pcTimerName = pcTimerName;
-        pxNewTimer->xTimerPeriodInTicks = xTimerPeriodInTicks;
-        pxNewTimer->pvTimerID = pvTimerID;
-        pxNewTimer->pxCallbackFunction = pxCallbackFunction;
-        vListInitialiseItem(&(pxNewTimer->xTimerListItem));
-        if (uxAutoReload != pdFALSE) {
-            pxNewTimer->ucStatus |= tmrSTATUS_IS_AUTORELOAD;
-        }
-        traceTIMER_CREATE(pxNewTimer);
-    }
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xTimerGenericCommand(
-    TimerHandle_t xTimer,
-    const BaseType_t xCommandID,
-    const TickType_t xOptionalValue,
-    BaseType_t *const pxHigherPriorityTaskWoken,
-    const TickType_t xTicksToWait)
-{
-    BaseType_t xReturn = pdFAIL;
-    DaemonTaskMessage_t xMessage;
-
-    configASSERT(xTimer);
-
-    /* Send a message to the timer service task to perform a particular action
-    on a particular timer definition. */
-    if (xTimerQueue != NULL) {
-        /* Send a command to the timer service task to start the xTimer timer.
-         */
-        xMessage.xMessageID = xCommandID;
-        xMessage.u.xTimerParameters.xMessageValue = xOptionalValue;
-        xMessage.u.xTimerParameters.pxTimer = xTimer;
-
-        if (xCommandID < tmrFIRST_FROM_ISR_COMMAND) {
-            if (xTaskGetSchedulerState() == taskSCHEDULER_RUNNING) {
-                xReturn =
-                    xQueueSendToBack(xTimerQueue, &xMessage, xTicksToWait);
-            } else {
-                xReturn = xQueueSendToBack(xTimerQueue, &xMessage, tmrNO_DELAY);
-            }
-        } else {
-            xReturn = xQueueSendToBackFromISR(
-                xTimerQueue, &xMessage, pxHigherPriorityTaskWoken);
-        }
-
-        traceTIMER_COMMAND_SEND(xTimer, xCommandID, xOptionalValue, xReturn);
-    } else {
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-TaskHandle_t xTimerGetTimerDaemonTaskHandle(void)
-{
-    /* If xTimerGetTimerDaemonTaskHandle() is called before the scheduler has
-    been started, then xTimerTaskHandle will be NULL. */
-    configASSERT((xTimerTaskHandle != NULL));
-    return xTimerTaskHandle;
-}
-/*-----------------------------------------------------------*/
-
-TickType_t xTimerGetPeriod(TimerHandle_t xTimer)
-{
-    Timer_t *pxTimer = xTimer;
-
-    configASSERT(xTimer);
-    return pxTimer->xTimerPeriodInTicks;
-}
-/*-----------------------------------------------------------*/
-
-void vTimerSetReloadMode(TimerHandle_t xTimer, const UBaseType_t uxAutoReload)
-{
-    Timer_t *pxTimer = xTimer;
-
-    configASSERT(xTimer);
-    taskENTER_CRITICAL();
-    {
-        if (uxAutoReload != pdFALSE) {
-            pxTimer->ucStatus |= tmrSTATUS_IS_AUTORELOAD;
-        } else {
-            pxTimer->ucStatus &= ~tmrSTATUS_IS_AUTORELOAD;
-        }
-    }
-    taskEXIT_CRITICAL();
-}
-/*-----------------------------------------------------------*/
-
-UBaseType_t uxTimerGetReloadMode(TimerHandle_t xTimer)
-{
-    Timer_t *pxTimer = xTimer;
-    UBaseType_t uxReturn;
-
-    configASSERT(xTimer);
-    taskENTER_CRITICAL();
-    {
-        if ((pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD) == 0) {
-            /* Not an auto-reload timer. */
-            uxReturn = (UBaseType_t)pdFALSE;
-        } else {
-            /* Is an auto-reload timer. */
-            uxReturn = (UBaseType_t)pdTRUE;
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    return uxReturn;
-}
-/*-----------------------------------------------------------*/
-
-TickType_t xTimerGetExpiryTime(TimerHandle_t xTimer)
-{
-    Timer_t *pxTimer = xTimer;
-    TickType_t xReturn;
-
-    configASSERT(xTimer);
-    xReturn = listGET_LIST_ITEM_VALUE(&(pxTimer->xTimerListItem));
-    return xReturn;
-}
-/*-----------------------------------------------------------*/
-
-const char *pcTimerGetName(
-    TimerHandle_t xTimer) /*lint !e971 Unqualified char types are allowed for
-                             strings and single characters only. */
-{
-    Timer_t *pxTimer = xTimer;
-
-    configASSERT(xTimer);
-    return pxTimer->pcTimerName;
-}
-/*-----------------------------------------------------------*/
-
-static void prvProcessExpiredTimer(
-    const TickType_t xNextExpireTime,
-    const TickType_t xTimeNow)
-{
-    BaseType_t xResult;
-    Timer_t *const pxTimer = (Timer_t *)listGET_OWNER_OF_HEAD_ENTRY(
-        pxCurrentTimerList); /*lint !e9087 !e9079 void * is used as this macro
-                                is used with tasks and co-routines too.
-                                Alignment is known to be fine as the type of the
-                                pointer stored and retrieved is the same. */
-
-    /* Remove the timer from the list of active timers.  A check has already
-    been performed to ensure the list is not empty. */
-    (void)uxListRemove(&(pxTimer->xTimerListItem));
-    traceTIMER_EXPIRED(pxTimer);
-
-    /* If the timer is an auto-reload timer then calculate the next
-    expiry time and re-insert the timer in the list of active timers. */
-    if ((pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD) != 0) {
-        /* The timer is inserted into a list using a time relative to anything
-        other than the current time.  It will therefore be inserted into the
-        correct list relative to the time this task thinks it is now. */
-        if (prvInsertTimerInActiveList(
-                pxTimer,
-                (xNextExpireTime + pxTimer->xTimerPeriodInTicks),
-                xTimeNow,
-                xNextExpireTime) != pdFALSE) {
-            /* The timer expired before it was added to the active timer
-            list.  Reload it now.  */
-            xResult = xTimerGenericCommand(
-                pxTimer,
-                tmrCOMMAND_START_DONT_TRACE,
-                xNextExpireTime,
-                NULL,
-                tmrNO_DELAY);
-            configASSERT(xResult);
-            (void)xResult;
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    } else {
-        pxTimer->ucStatus &= ~tmrSTATUS_IS_ACTIVE;
-        mtCOVERAGE_TEST_MARKER();
-    }
-
-    /* Call the timer callback. */
-    pxTimer->pxCallbackFunction((TimerHandle_t)pxTimer);
-}
-/*-----------------------------------------------------------*/
-
-static portTASK_FUNCTION(prvTimerTask, pvParameters)
-{
-    TickType_t xNextExpireTime;
-    BaseType_t xListWasEmpty;
-
-    /* Just to avoid compiler warnings. */
-    (void)pvParameters;
-
-#    if (configUSE_DAEMON_TASK_STARTUP_HOOK == 1)
-    {
-        extern void vApplicationDaemonTaskStartupHook(void);
-
-        /* Allow the application writer to execute some code in the context of
-        this task at the point the task starts executing.  This is useful if the
-        application includes initialisation code that would benefit from
-        executing after the scheduler has been started. */
-        vApplicationDaemonTaskStartupHook();
-    }
-#    endif /* configUSE_DAEMON_TASK_STARTUP_HOOK */
-
-    for (;;) {
-        /* Query the timers list to see if it contains any timers, and if so,
-        obtain the time at which the next timer will expire. */
-        xNextExpireTime = prvGetNextExpireTime(&xListWasEmpty);
-
-        /* If a timer has expired, process it.  Otherwise, block this task
-        until either a timer does expire, or a command is received. */
-        prvProcessTimerOrBlockTask(xNextExpireTime, xListWasEmpty);
-
-        /* Empty the command queue. */
-        prvProcessReceivedCommands();
-    }
-}
-/*-----------------------------------------------------------*/
-
-static void prvProcessTimerOrBlockTask(
-    const TickType_t xNextExpireTime,
-    BaseType_t xListWasEmpty)
-{
-    TickType_t xTimeNow;
-    BaseType_t xTimerListsWereSwitched;
-
-    vTaskSuspendAll();
-    {
-        /* Obtain the time now to make an assessment as to whether the timer
-        has expired or not.  If obtaining the time causes the lists to switch
-        then don't process this timer as any timers that remained in the list
-        when the lists were switched will have been processed within the
-        prvSampleTimeNow() function. */
-        xTimeNow = prvSampleTimeNow(&xTimerListsWereSwitched);
-        if (xTimerListsWereSwitched == pdFALSE) {
-            /* The tick count has not overflowed, has the timer expired? */
-            if ((xListWasEmpty == pdFALSE) && (xNextExpireTime <= xTimeNow)) {
-                (void)xTaskResumeAll();
-                prvProcessExpiredTimer(xNextExpireTime, xTimeNow);
-            } else {
-                /* The tick count has not overflowed, and the next expire
-                time has not been reached yet.  This task should therefore
-                block to wait for the next expire time or a command to be
-                received - whichever comes first.  The following line cannot
-                be reached unless xNextExpireTime > xTimeNow, except in the
-                case when the current timer list is empty. */
-                if (xListWasEmpty != pdFALSE) {
-                    /* The current timer list is empty - is the overflow list
-                    also empty? */
-                    xListWasEmpty = listLIST_IS_EMPTY(pxOverflowTimerList);
-                }
-
-                vQueueWaitForMessageRestricted(
-                    xTimerQueue, (xNextExpireTime - xTimeNow), xListWasEmpty);
-
-                if (xTaskResumeAll() == pdFALSE) {
-                    /* Yield to wait for either a command to arrive, or the
-                    block time to expire.  If a command arrived between the
-                    critical section being exited and this yield then the yield
-                    will not cause the task to block. */
-                    portYIELD_WITHIN_API();
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            }
-        } else {
-            (void)xTaskResumeAll();
-        }
-    }
-}
-/*-----------------------------------------------------------*/
-
-static TickType_t prvGetNextExpireTime(BaseType_t *const pxListWasEmpty)
-{
-    TickType_t xNextExpireTime;
-
-    /* Timers are listed in expiry time order, with the head of the list
-    referencing the task that will expire first.  Obtain the time at which
-    the timer with the nearest expiry time will expire.  If there are no
-    active timers then just set the next expire time to 0.  That will cause
-    this task to unblock when the tick count overflows, at which point the
-    timer lists will be switched and the next expiry time can be
-    re-assessed.  */
-    *pxListWasEmpty = listLIST_IS_EMPTY(pxCurrentTimerList);
-    if (*pxListWasEmpty == pdFALSE) {
-        xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY(pxCurrentTimerList);
-    } else {
-        /* Ensure the task unblocks when the tick count rolls over. */
-        xNextExpireTime = (TickType_t)0U;
-    }
-
-    return xNextExpireTime;
-}
-/*-----------------------------------------------------------*/
-
-static TickType_t prvSampleTimeNow(BaseType_t *const pxTimerListsWereSwitched)
-{
-    TickType_t xTimeNow;
-    PRIVILEGED_DATA static TickType_t xLastTime =
-        (TickType_t)0U; /*lint !e956 Variable is only accessible to one task. */
-
-    xTimeNow = xTaskGetTickCount();
-
-    if (xTimeNow < xLastTime) {
-        prvSwitchTimerLists();
-        *pxTimerListsWereSwitched = pdTRUE;
-    } else {
-        *pxTimerListsWereSwitched = pdFALSE;
-    }
-
-    xLastTime = xTimeNow;
-
-    return xTimeNow;
-}
-/*-----------------------------------------------------------*/
-
-static BaseType_t prvInsertTimerInActiveList(
-    Timer_t *const pxTimer,
-    const TickType_t xNextExpiryTime,
-    const TickType_t xTimeNow,
-    const TickType_t xCommandTime)
-{
-    BaseType_t xProcessTimerNow = pdFALSE;
-
-    listSET_LIST_ITEM_VALUE(&(pxTimer->xTimerListItem), xNextExpiryTime);
-    listSET_LIST_ITEM_OWNER(&(pxTimer->xTimerListItem), pxTimer);
-
-    if (xNextExpiryTime <= xTimeNow) {
-        /* Has the expiry time elapsed between the command to start/reset a
-        timer was issued, and the time the command was processed? */
-        if (((TickType_t)(xTimeNow - xCommandTime)) >=
-            pxTimer
-                ->xTimerPeriodInTicks) /*lint !e961 MISRA exception as the casts
-                                          are only redundant for some ports. */
-        {
-            /* The time between a command being issued and the command being
-            processed actually exceeds the timers period.  */
-            xProcessTimerNow = pdTRUE;
-        } else {
-            vListInsert(pxOverflowTimerList, &(pxTimer->xTimerListItem));
-        }
-    } else {
-        if ((xTimeNow < xCommandTime) && (xNextExpiryTime >= xCommandTime)) {
-            /* If, since the command was issued, the tick count has overflowed
-            but the expiry time has not, then the timer must have already passed
-            its expiry time and should be processed immediately. */
-            xProcessTimerNow = pdTRUE;
-        } else {
-            vListInsert(pxCurrentTimerList, &(pxTimer->xTimerListItem));
-        }
-    }
-
-    return xProcessTimerNow;
-}
-/*-----------------------------------------------------------*/
-
-static void prvProcessReceivedCommands(void)
-{
-    DaemonTaskMessage_t xMessage;
-    Timer_t *pxTimer;
-    BaseType_t xTimerListsWereSwitched, xResult;
-    TickType_t xTimeNow;
-
-    while (xQueueReceive(xTimerQueue, &xMessage, tmrNO_DELAY) !=
-           pdFAIL) /*lint !e603 xMessage does not have to be initialised as it
-                      is passed out, not in, and it is not used unless
-                      xQueueReceive() returns pdTRUE. */
-    {
-#    if (INCLUDE_xTimerPendFunctionCall == 1)
-        {
-            /* Negative commands are pended function calls rather than timer
-            commands. */
-            if (xMessage.xMessageID < (BaseType_t)0) {
-                const CallbackParameters_t *const pxCallback =
-                    &(xMessage.u.xCallbackParameters);
-
-                /* The timer uses the xCallbackParameters member to request a
-                callback be executed.  Check the callback is not NULL. */
-                configASSERT(pxCallback);
-
-                /* Call the function. */
-                pxCallback->pxCallbackFunction(
-                    pxCallback->pvParameter1, pxCallback->ulParameter2);
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-        }
-#    endif /* INCLUDE_xTimerPendFunctionCall */
-
-        /* Commands that are positive are timer commands rather than pended
-        function calls. */
-        if (xMessage.xMessageID >= (BaseType_t)0) {
-            /* The messages uses the xTimerParameters member to work on a
-            software timer. */
-            pxTimer = xMessage.u.xTimerParameters.pxTimer;
-
-            if (listIS_CONTAINED_WITHIN(NULL, &(pxTimer->xTimerListItem)) ==
-                pdFALSE) /*lint !e961. The cast is only redundant when NULL is
-                            passed into the macro. */
-            {
-                /* The timer is in a list, remove it. */
-                (void)uxListRemove(&(pxTimer->xTimerListItem));
-            } else {
-                mtCOVERAGE_TEST_MARKER();
-            }
-
-            traceTIMER_COMMAND_RECEIVED(
-                pxTimer,
-                xMessage.xMessageID,
-                xMessage.u.xTimerParameters.xMessageValue);
-
-            /* In this case the xTimerListsWereSwitched parameter is not used,
-            but it must be present in the function call.  prvSampleTimeNow()
-            must be called after the message is received from xTimerQueue so
-            there is no possibility of a higher priority task adding a message
-            to the message queue with a time that is ahead of the timer daemon
-            task (because it
-            pre-empted the timer daemon task after the xTimeNow value was set).
-          */
-            xTimeNow = prvSampleTimeNow(&xTimerListsWereSwitched);
-
-            switch (xMessage.xMessageID) {
-            case tmrCOMMAND_START:
-            case tmrCOMMAND_START_FROM_ISR:
-            case tmrCOMMAND_RESET:
-            case tmrCOMMAND_RESET_FROM_ISR:
-            case tmrCOMMAND_START_DONT_TRACE:
-                /* Start or restart a timer. */
-                pxTimer->ucStatus |= tmrSTATUS_IS_ACTIVE;
-                if (prvInsertTimerInActiveList(
-                        pxTimer,
-                        xMessage.u.xTimerParameters.xMessageValue +
-                            pxTimer->xTimerPeriodInTicks,
-                        xTimeNow,
-                        xMessage.u.xTimerParameters.xMessageValue) != pdFALSE) {
-                    /* The timer expired before it was added to the active
-                    timer list.  Process it now. */
-                    pxTimer->pxCallbackFunction((TimerHandle_t)pxTimer);
-                    traceTIMER_EXPIRED(pxTimer);
-
-                    if ((pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD) != 0) {
-                        xResult = xTimerGenericCommand(
-                            pxTimer,
-                            tmrCOMMAND_START_DONT_TRACE,
-                            xMessage.u.xTimerParameters.xMessageValue +
-                                pxTimer->xTimerPeriodInTicks,
-                            NULL,
-                            tmrNO_DELAY);
-                        configASSERT(xResult);
-                        (void)xResult;
-                    } else {
-                        mtCOVERAGE_TEST_MARKER();
-                    }
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-                break;
-
-            case tmrCOMMAND_STOP:
-            case tmrCOMMAND_STOP_FROM_ISR:
-                /* The timer has already been removed from the active list. */
-                pxTimer->ucStatus &= ~tmrSTATUS_IS_ACTIVE;
-                break;
-
-            case tmrCOMMAND_CHANGE_PERIOD:
-            case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR:
-                pxTimer->ucStatus |= tmrSTATUS_IS_ACTIVE;
-                pxTimer->xTimerPeriodInTicks =
-                    xMessage.u.xTimerParameters.xMessageValue;
-                configASSERT((pxTimer->xTimerPeriodInTicks > 0));
-
-                /* The new period does not really have a reference, and can
-                be longer or shorter than the old one.  The command time is
-                therefore set to the current time, and as the period cannot
-                be zero the next expiry time can only be in the future,
-                meaning (unlike for the xTimerStart() case above) there is
-                no fail case that needs to be handled here. */
-                (void)prvInsertTimerInActiveList(
-                    pxTimer,
-                    (xTimeNow + pxTimer->xTimerPeriodInTicks),
-                    xTimeNow,
-                    xTimeNow);
-                break;
-
-            case tmrCOMMAND_DELETE:
-#    if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
-            {
-                /* The timer has already been removed from the active list,
-                just free up the memory if the memory was dynamically
-                allocated. */
-                if ((pxTimer->ucStatus & tmrSTATUS_IS_STATICALLY_ALLOCATED) ==
-                    (uint8_t)0) {
-                    vPortFree(pxTimer);
-                } else {
-                    pxTimer->ucStatus &= ~tmrSTATUS_IS_ACTIVE;
-                }
-            }
-#    else
-            {
-                /* If dynamic allocation is not enabled, the memory
-                could not have been dynamically allocated. So there is
-                no need to free the memory - just mark the timer as
-                "not active". */
-                pxTimer->ucStatus &= ~tmrSTATUS_IS_ACTIVE;
-            }
-#    endif /* configSUPPORT_DYNAMIC_ALLOCATION */
-            break;
-
-            default:
-                /* Don't expect to get here. */
-                break;
-            }
-        }
-    }
-}
-/*-----------------------------------------------------------*/
-
-static void prvSwitchTimerLists(void)
-{
-    TickType_t xNextExpireTime, xReloadTime;
-    List_t *pxTemp;
-    Timer_t *pxTimer;
-    BaseType_t xResult;
-
-    /* The tick count has overflowed.  The timer lists must be switched.
-    If there are any timers still referenced from the current timer list
-    then they must have expired and should be processed before the lists
-    are switched. */
-    while (listLIST_IS_EMPTY(pxCurrentTimerList) == pdFALSE) {
-        xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY(pxCurrentTimerList);
-
-        /* Remove the timer from the list. */
-        pxTimer = (Timer_t *)listGET_OWNER_OF_HEAD_ENTRY(
-            pxCurrentTimerList); /*lint !e9087 !e9079 void * is used as this
-                                    macro is used with tasks and co-routines
-                                    too.  Alignment is known to be fine as the
-                                    type of the pointer stored and retrieved is
-                                    the same. */
-        (void)uxListRemove(&(pxTimer->xTimerListItem));
-        traceTIMER_EXPIRED(pxTimer);
-
-        /* Execute its callback, then send a command to restart the timer if
-        it is an auto-reload timer.  It cannot be restarted here as the lists
-        have not yet been switched. */
-        pxTimer->pxCallbackFunction((TimerHandle_t)pxTimer);
-
-        if ((pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD) != 0) {
-            /* Calculate the reload value, and if the reload value results in
-            the timer going into the same timer list then it has already expired
-            and the timer should be re-inserted into the current list so it is
-            processed again within this loop.  Otherwise a command should be
-            sent to restart the timer to ensure it is only inserted into a list
-            after the lists have been swapped. */
-            xReloadTime = (xNextExpireTime + pxTimer->xTimerPeriodInTicks);
-            if (xReloadTime > xNextExpireTime) {
-                listSET_LIST_ITEM_VALUE(
-                    &(pxTimer->xTimerListItem), xReloadTime);
-                listSET_LIST_ITEM_OWNER(&(pxTimer->xTimerListItem), pxTimer);
-                vListInsert(pxCurrentTimerList, &(pxTimer->xTimerListItem));
-            } else {
-                xResult = xTimerGenericCommand(
-                    pxTimer,
-                    tmrCOMMAND_START_DONT_TRACE,
-                    xNextExpireTime,
-                    NULL,
-                    tmrNO_DELAY);
-                configASSERT(xResult);
-                (void)xResult;
-            }
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-
-    pxTemp = pxCurrentTimerList;
-    pxCurrentTimerList = pxOverflowTimerList;
-    pxOverflowTimerList = pxTemp;
-}
-/*-----------------------------------------------------------*/
-
-static void prvCheckForValidListAndQueue(void)
-{
-    /* Check that the list from which active timers are referenced, and the
-    queue used to communicate with the timer service, have been
-    initialised. */
-    taskENTER_CRITICAL();
-    {
-        if (xTimerQueue == NULL) {
-            vListInitialise(&xActiveTimerList1);
-            vListInitialise(&xActiveTimerList2);
-            pxCurrentTimerList = &xActiveTimerList1;
-            pxOverflowTimerList = &xActiveTimerList2;
-
-#    if (configSUPPORT_STATIC_ALLOCATION == 1)
-            {
-                /* The timer queue is allocated statically in case
-                configSUPPORT_DYNAMIC_ALLOCATION is 0. */
-                static StaticQueue_t
-                    xStaticTimerQueue; /*lint !e956 Ok to declare in this manner
-                                          to prevent additional conditional
-                                          compilation guards in other locations.
-                                        */
-                static uint8_t ucStaticTimerQueueStorage
-                    [(size_t)configTIMER_QUEUE_LENGTH *
-                     sizeof(DaemonTaskMessage_t)]; /*lint !e956 Ok to declare in
-                                                      this manner to prevent
-                                                      additional conditional
-                                                      compilation guards in
-                                                      other locations. */
-
-                xTimerQueue = xQueueCreateStatic(
-                    (UBaseType_t)configTIMER_QUEUE_LENGTH,
-                    (UBaseType_t)sizeof(DaemonTaskMessage_t),
-                    &(ucStaticTimerQueueStorage[0]),
-                    &xStaticTimerQueue);
-            }
-#    else
-            {
-                xTimerQueue = xQueueCreate(
-                    (UBaseType_t)configTIMER_QUEUE_LENGTH,
-                    sizeof(DaemonTaskMessage_t));
-            }
-#    endif
-
-#    if (configQUEUE_REGISTRY_SIZE > 0)
-            {
-                if (xTimerQueue != NULL) {
-                    vQueueAddToRegistry(xTimerQueue, "TmrQ");
-                } else {
-                    mtCOVERAGE_TEST_MARKER();
-                }
-            }
-#    endif /* configQUEUE_REGISTRY_SIZE */
-        } else {
-            mtCOVERAGE_TEST_MARKER();
-        }
-    }
-    taskEXIT_CRITICAL();
-}
-/*-----------------------------------------------------------*/
-
-BaseType_t xTimerIsTimerActive(TimerHandle_t xTimer)
-{
-    BaseType_t xReturn;
-    Timer_t *pxTimer = xTimer;
-
-    configASSERT(xTimer);
-
-    /* Is the timer in the list of active timers? */
-    taskENTER_CRITICAL();
-    {
-        if ((pxTimer->ucStatus & tmrSTATUS_IS_ACTIVE) == 0) {
-            xReturn = pdFALSE;
-        } else {
-            xReturn = pdTRUE;
-        }
-    }
-    taskEXIT_CRITICAL();
-
-    return xReturn;
-} /*lint !e818 Can't be pointer to const due to the typedef. */
-/*-----------------------------------------------------------*/
-
-void *pvTimerGetTimerID(const TimerHandle_t xTimer)
-{
-    Timer_t *const pxTimer = xTimer;
-    void *pvReturn;
-
-    configASSERT(xTimer);
-
-    taskENTER_CRITICAL();
-    {
-        pvReturn = pxTimer->pvTimerID;
-    }
-    taskEXIT_CRITICAL();
-
-    return pvReturn;
-}
-/*-----------------------------------------------------------*/
-
-void vTimerSetTimerID(TimerHandle_t xTimer, void *pvNewID)
-{
-    Timer_t *const pxTimer = xTimer;
-
-    configASSERT(xTimer);
-
-    taskENTER_CRITICAL();
-    {
-        pxTimer->pvTimerID = pvNewID;
-    }
-    taskEXIT_CRITICAL();
-}
-/*-----------------------------------------------------------*/
-
-#    if (INCLUDE_xTimerPendFunctionCall == 1)
-
-BaseType_t xTimerPendFunctionCallFromISR(
-    PendedFunction_t xFunctionToPend,
-    void *pvParameter1,
-    uint32_t ulParameter2,
-    BaseType_t *pxHigherPriorityTaskWoken)
-{
-    DaemonTaskMessage_t xMessage;
-    BaseType_t xReturn;
-
-    /* Complete the message with the function parameters and post it to the
-    daemon task. */
-    xMessage.xMessageID = tmrCOMMAND_EXECUTE_CALLBACK_FROM_ISR;
-    xMessage.u.xCallbackParameters.pxCallbackFunction = xFunctionToPend;
-    xMessage.u.xCallbackParameters.pvParameter1 = pvParameter1;
-    xMessage.u.xCallbackParameters.ulParameter2 = ulParameter2;
-
-    xReturn =
-        xQueueSendFromISR(xTimerQueue, &xMessage, pxHigherPriorityTaskWoken);
-
-    tracePEND_FUNC_CALL_FROM_ISR(
-        xFunctionToPend, pvParameter1, ulParameter2, xReturn);
-
-    return xReturn;
-}
-
-#    endif /* INCLUDE_xTimerPendFunctionCall */
-/*-----------------------------------------------------------*/
-
-#    if (INCLUDE_xTimerPendFunctionCall == 1)
-
-BaseType_t xTimerPendFunctionCall(
-    PendedFunction_t xFunctionToPend,
-    void *pvParameter1,
-    uint32_t ulParameter2,
-    TickType_t xTicksToWait)
-{
-    DaemonTaskMessage_t xMessage;
-    BaseType_t xReturn;
-
-    /* This function can only be called after a timer has been created or
-    after the scheduler has been started because, until then, the timer
-    queue does not exist. */
-    configASSERT(xTimerQueue);
-
-    /* Complete the message with the function parameters and post it to the
-    daemon task. */
-    xMessage.xMessageID = tmrCOMMAND_EXECUTE_CALLBACK;
-    xMessage.u.xCallbackParameters.pxCallbackFunction = xFunctionToPend;
-    xMessage.u.xCallbackParameters.pvParameter1 = pvParameter1;
-    xMessage.u.xCallbackParameters.ulParameter2 = ulParameter2;
-
-    xReturn = xQueueSendToBack(xTimerQueue, &xMessage, xTicksToWait);
-
-    tracePEND_FUNC_CALL(xFunctionToPend, pvParameter1, ulParameter2, xReturn);
-
-    return xReturn;
-}
-
-#    endif /* INCLUDE_xTimerPendFunctionCall */
-/*-----------------------------------------------------------*/
-
-#    if (configUSE_TRACE_FACILITY == 1)
-
-UBaseType_t uxTimerGetTimerNumber(TimerHandle_t xTimer)
-{
-    return ((Timer_t *)xTimer)->uxTimerNumber;
-}
-
-#    endif /* configUSE_TRACE_FACILITY */
-/*-----------------------------------------------------------*/
-
-#    if (configUSE_TRACE_FACILITY == 1)
-
-void vTimerSetTimerNumber(TimerHandle_t xTimer, UBaseType_t uxTimerNumber)
-{
-    ((Timer_t *)xTimer)->uxTimerNumber = uxTimerNumber;
-}
-
-#    endif /* configUSE_TRACE_FACILITY */
-/*-----------------------------------------------------------*/
-
-/* This entire source file will be skipped if the application is not configured
-to include software timer functionality.  If you want to include software timer
-functionality then ensure configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */
-#endif /* configUSE_TIMERS == 1 */