/* Copyright (C) 2016-2017 Espressif Shanghai PTE LTD Copyright (C) 2015 Real Time Engineers Ltd. All rights reserved FreeRTOS is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License (version 2) as published by the Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception. *************************************************************************** >>! NOTE: The modification to the GPL is included to allow you to !<< >>! distribute a combined work that includes FreeRTOS without being !<< >>! obliged to provide the source code for proprietary components !<< >>! outside of the FreeRTOS kernel. !<< *************************************************************************** FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Full license text is available on the following link: http://www.freertos.org/a00114.html */ /* Warning: funky preprocessor hackery ahead. Including these headers will generate two functions, which names are defined by the preprocessor macros PORTMUX_AQUIRE_MUX_FN_NAME and PORTMUX_RELEASE_MUX_FN_NAME. In order to do the compare and exchange function, they will use whatever PORTMUX_COMPARE_SET_FN_NAME resolves to. In some scenarios, this header is included *twice* in portmux_impl.h: one time for the 'normal' mux code which uses a compare&exchange routine, another time to generate code for a second set of these routines that use a second mux (in internal ram) to fake a compare&exchange on a variable in external memory. */ static inline bool __attribute__((always_inline)) #ifdef CONFIG_FREERTOS_PORTMUX_DEBUG PORTMUX_AQUIRE_MUX_FN_NAME(portMUX_TYPE *mux, int timeout_cycles, const char *fnName, int line) { #else PORTMUX_AQUIRE_MUX_FN_NAME(portMUX_TYPE *mux, int timeout_cycles) { #endif #if !CONFIG_FREERTOS_UNICORE uint32_t res; portBASE_TYPE coreID, otherCoreID; uint32_t ccount_start; bool set_timeout = timeout_cycles > portMUX_NO_TIMEOUT; #ifdef CONFIG_FREERTOS_PORTMUX_DEBUG if (!set_timeout) { timeout_cycles = 1000000 * (esp_clk_cpu_freq() / 1000000); // Always set a timeout in debug mode set_timeout = true; } #endif if (set_timeout) { // Timeout RSR(CCOUNT, ccount_start); } #ifdef CONFIG_FREERTOS_PORTMUX_DEBUG uint32_t owner = mux->owner; if (owner != portMUX_FREE_VAL && owner != CORE_ID_REGVAL_PRO && owner != CORE_ID_REGVAL_APP) { ets_printf("ERROR: vPortCPUAcquireMutex: mux %p is uninitialized (0x%X)! Called from %s line %d.\n", mux, owner, fnName, line); mux->owner=portMUX_FREE_VAL; } #endif /* Spin until we own the core */ RSR(PRID, coreID); /* Note: coreID is the full 32 bit core ID (CORE_ID_REGVAL_PRO/CORE_ID_REGVAL_APP), not the 0/1 value returned by xPortGetCoreID() */ otherCoreID = CORE_ID_REGVAL_XOR_SWAP ^ coreID; do { /* mux->owner should be one of portMUX_FREE_VAL, CORE_ID_REGVAL_PRO, CORE_ID_REGVAL_APP: - If portMUX_FREE_VAL, we want to atomically set to 'coreID'. - If "our" coreID, we can drop through immediately. - If "otherCoreID", we spin here. */ res = coreID; PORTMUX_COMPARE_SET_FN_NAME(&mux->owner, portMUX_FREE_VAL, &res); if (res != otherCoreID) { break; // mux->owner is "our" coreID } if (set_timeout) { uint32_t ccount_now; RSR(CCOUNT, ccount_now); if (ccount_now - ccount_start > (unsigned)timeout_cycles) { #ifdef CONFIG_FREERTOS_PORTMUX_DEBUG ets_printf("Timeout on mux! last non-recursive lock %s line %d, curr %s line %d\n", mux->lastLockedFn, mux->lastLockedLine, fnName, line); ets_printf("Owner 0x%x count %d\n", mux->owner, mux->count); #endif return false; } } } while (1); assert(res == coreID || res == portMUX_FREE_VAL); /* any other value implies memory corruption or uninitialized mux */ assert((res == portMUX_FREE_VAL) == (mux->count == 0)); /* we're first to lock iff count is zero */ assert(mux->count < 0xFF); /* Bad count value implies memory corruption */ /* now we own it, we can increment the refcount */ mux->count++; #ifdef CONFIG_FREERTOS_PORTMUX_DEBUG if (res==portMUX_FREE_VAL) { //initial lock mux->lastLockedFn=fnName; mux->lastLockedLine=line; } else { ets_printf("Recursive lock: count=%d last non-recursive lock %s line %d, curr %s line %d\n", mux->count-1, mux->lastLockedFn, mux->lastLockedLine, fnName, line); } #endif /* CONFIG_FREERTOS_PORTMUX_DEBUG */ #endif /* CONFIG_FREERTOS_UNICORE */ return true; } #ifdef CONFIG_FREERTOS_PORTMUX_DEBUG static inline void PORTMUX_RELEASE_MUX_FN_NAME(portMUX_TYPE *mux, const char *fnName, int line) { #else static inline void PORTMUX_RELEASE_MUX_FN_NAME(portMUX_TYPE *mux) { #endif #if !CONFIG_FREERTOS_UNICORE portBASE_TYPE coreID; #ifdef CONFIG_FREERTOS_PORTMUX_DEBUG const char *lastLockedFn=mux->lastLockedFn; int lastLockedLine=mux->lastLockedLine; mux->lastLockedFn=fnName; mux->lastLockedLine=line; uint32_t owner = mux->owner; if (owner != portMUX_FREE_VAL && owner != CORE_ID_REGVAL_PRO && owner != CORE_ID_REGVAL_APP) { ets_printf("ERROR: vPortCPUReleaseMutex: mux %p is invalid (0x%x)!\n", mux, mux->owner); } #endif #if CONFIG_FREERTOS_PORTMUX_DEBUG || !defined(NDEBUG) RSR(PRID, coreID); #endif #ifdef CONFIG_FREERTOS_PORTMUX_DEBUG if (coreID != mux->owner) { ets_printf("ERROR: vPortCPUReleaseMutex: mux %p was already unlocked!\n", mux); ets_printf("Last non-recursive unlock %s line %d, curr unlock %s line %d\n", lastLockedFn, lastLockedLine, fnName, line); } #endif assert(coreID == mux->owner); // This is a mutex we didn't lock, or it's corrupt mux->count--; if(mux->count == 0) { mux->owner = portMUX_FREE_VAL; } else { assert(mux->count < 0x100); // Indicates memory corruption #ifdef CONFIG_FREERTOS_PORTMUX_DEBUG_RECURSIVE ets_printf("Recursive unlock: count=%d last locked %s line %d, curr %s line %d\n", mux->count, lastLockedFn, lastLockedLine, fnName, line); #endif } #endif //!CONFIG_FREERTOS_UNICORE }