/* | |
* Copyright (c) 2015-2019 Cadence Design Systems, Inc. | |
* | |
* 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. | |
*/ | |
#include "FreeRTOS.h" | |
#if XT_USE_THREAD_SAFE_CLIB | |
#if XSHAL_CLIB == XTHAL_CLIB_XCLIB | |
#include <errno.h> | |
#include <sys/reent.h> | |
#include "semphr.h" | |
typedef SemaphoreHandle_t _Rmtx; | |
//----------------------------------------------------------------------------- | |
// Override this and set to nonzero to enable locking. | |
//----------------------------------------------------------------------------- | |
int32_t _xclib_use_mt = 1; | |
//----------------------------------------------------------------------------- | |
// Init lock. | |
//----------------------------------------------------------------------------- | |
void | |
_Mtxinit(_Rmtx * mtx) | |
{ | |
*mtx = xSemaphoreCreateRecursiveMutex(); | |
} | |
//----------------------------------------------------------------------------- | |
// Destroy lock. | |
//----------------------------------------------------------------------------- | |
void | |
_Mtxdst(_Rmtx * mtx) | |
{ | |
if ((mtx != NULL) && (*mtx != NULL)) { | |
vSemaphoreDelete(*mtx); | |
} | |
} | |
//----------------------------------------------------------------------------- | |
// Lock. | |
//----------------------------------------------------------------------------- | |
void | |
_Mtxlock(_Rmtx * mtx) | |
{ | |
if ((mtx != NULL) && (*mtx != NULL)) { | |
xSemaphoreTakeRecursive(*mtx, portMAX_DELAY); | |
} | |
} | |
//----------------------------------------------------------------------------- | |
// Unlock. | |
//----------------------------------------------------------------------------- | |
void | |
_Mtxunlock(_Rmtx * mtx) | |
{ | |
if ((mtx != NULL) && (*mtx != NULL)) { | |
xSemaphoreGiveRecursive(*mtx); | |
} | |
} | |
//----------------------------------------------------------------------------- | |
// Called by malloc() to allocate blocks of memory from the heap. | |
//----------------------------------------------------------------------------- | |
void * | |
_sbrk_r (struct _reent * reent, int32_t incr) | |
{ | |
extern char _end; | |
extern char _heap_sentry; | |
static char * _heap_sentry_ptr = &_heap_sentry; | |
static char * heap_ptr; | |
char * base; | |
if (!heap_ptr) | |
heap_ptr = (char *) &_end; | |
base = heap_ptr; | |
if (heap_ptr + incr >= _heap_sentry_ptr) { | |
reent->_errno = ENOMEM; | |
return (char *) -1; | |
} | |
heap_ptr += incr; | |
return base; | |
} | |
//----------------------------------------------------------------------------- | |
// Global initialization for C library. | |
//----------------------------------------------------------------------------- | |
void | |
vPortClibInit(void) | |
{ | |
} | |
//----------------------------------------------------------------------------- | |
// Per-thread cleanup stub provided for linking, does nothing. | |
//----------------------------------------------------------------------------- | |
void | |
_reclaim_reent(void * ptr) | |
{ | |
} | |
#endif /* XSHAL_CLIB == XTHAL_CLIB_XCLIB */ | |
#if XSHAL_CLIB == XTHAL_CLIB_NEWLIB | |
#include <errno.h> | |
#include <malloc.h> | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <string.h> | |
#include "semphr.h" | |
static SemaphoreHandle_t xClibMutex; | |
static uint32_t ulClibInitDone = 0; | |
//----------------------------------------------------------------------------- | |
// Get C library lock. | |
//----------------------------------------------------------------------------- | |
void | |
__malloc_lock(struct _reent * ptr) | |
{ | |
if (!ulClibInitDone) | |
return; | |
xSemaphoreTakeRecursive(xClibMutex, portMAX_DELAY); | |
} | |
//----------------------------------------------------------------------------- | |
// Release C library lock. | |
//----------------------------------------------------------------------------- | |
void | |
__malloc_unlock(struct _reent * ptr) | |
{ | |
if (!ulClibInitDone) | |
return; | |
xSemaphoreGiveRecursive(xClibMutex); | |
} | |
//----------------------------------------------------------------------------- | |
// Lock for environment. Since we have only one global lock we can just call | |
// the malloc() lock function. | |
//----------------------------------------------------------------------------- | |
void | |
__env_lock(struct _reent * ptr) | |
{ | |
__malloc_lock(ptr); | |
} | |
//----------------------------------------------------------------------------- | |
// Unlock environment. | |
//----------------------------------------------------------------------------- | |
void | |
__env_unlock(struct _reent * ptr) | |
{ | |
__malloc_unlock(ptr); | |
} | |
//----------------------------------------------------------------------------- | |
// Called by malloc() to allocate blocks of memory from the heap. | |
//----------------------------------------------------------------------------- | |
void * | |
_sbrk_r (struct _reent * reent, int32_t incr) | |
{ | |
extern char _end; | |
extern char _heap_sentry; | |
static char * _heap_sentry_ptr = &_heap_sentry; | |
static char * heap_ptr; | |
char * base; | |
if (!heap_ptr) | |
heap_ptr = (char *) &_end; | |
base = heap_ptr; | |
if (heap_ptr + incr >= _heap_sentry_ptr) { | |
reent->_errno = ENOMEM; | |
return (char *) -1; | |
} | |
heap_ptr += incr; | |
return base; | |
} | |
//----------------------------------------------------------------------------- | |
// Global initialization for C library. | |
//----------------------------------------------------------------------------- | |
void | |
vPortClibInit(void) | |
{ | |
configASSERT(!ulClibInitDone); | |
xClibMutex = xSemaphoreCreateRecursiveMutex(); | |
ulClibInitDone = 1; | |
} | |
#endif /* XSHAL_CLIB == XTHAL_CLIB_NEWLIB */ | |
#endif /* XT_USE_THREAD_SAFE_CLIB */ |