From b63b22dfc11eff7564164f290e3fd8ea1456419e Mon Sep 17 00:00:00 2001 From: ReservedField Date: Fri, 21 Oct 2016 01:40:59 +0200 Subject: [PATCH] Rescope Thread_Error_t to TD_* --- include/Thread.h | 54 +++++++++++++++--------------- src/atomizer/Atomizer.c | 2 +- src/thread/Thread.c | 74 ++++++++++++++++++++--------------------- 3 files changed, 65 insertions(+), 65 deletions(-) diff --git a/include/Thread.h b/include/Thread.h index 7091030..68fc42d 100644 --- a/include/Thread.h +++ b/include/Thread.h @@ -66,23 +66,23 @@ typedef uint32_t Thread_Mutex_t; */ typedef enum { /**< No error. */ - SUCCESS = 0, + TD_SUCCESS = 0, /**< Couldn't allocate memory. */ - NO_MEMORY = -1, + TD_NO_MEMORY = -1, /**< A try operation failed. */ - TRY_FAIL = -2, + TD_TRY_FAIL = -2, /**< An invalid value was passed. */ - INVALID_VALUE = -3, + TD_INVALID_VALUE = -3, /**< An invalid thread handle was passed. */ - INVALID_THREAD = -100, + TD_INVALID_THREAD = -100, /**< Attempted to join an already joined thread. */ - ALREADY_JOINED = -101, + TD_ALREADY_JOINED = -101, /**< An invalid semaphore handle was passed. */ - INVALID_SEMA = -200, + TD_INVALID_SEMA = -200, /**< An invalid mutex handle was passed. */ - INVALID_MUTEX = -300, + TD_INVALID_MUTEX = -300, /**< Bad mutex unlock: already unlocked, or locked by a different thread. */ - MUTEX_BAD_UNLOCK = -301 + TD_MUTEX_BAD_UNLOCK = -301 } Thread_Error_t; /** @@ -114,8 +114,8 @@ void Thread_Init(); * @param args Arguments parameter to be passed to entry. * @param stackSize Stack size, in bytes. * - * @return SUCCESS or NO_MEMORY. In case of error, the value of - * thread is undefined. + * @return TD_SUCCESS or TD_NO_MEMORY. In case of error + * the value of thread is undefined. */ Thread_Error_t Thread_Create(Thread_t *thread, Thread_EntryPtr_t entry, void *args, uint16_t stackSize); @@ -129,13 +129,13 @@ void Thread_Yield(); * Waits for another thread to complete. * Each thread can only have one other thread waiting on it. * Attempting to join a thread that already has another thread - * waiting on it will fail with ALREADY_JOINED. + * waiting on it will fail with TD_ALREADY_JOINED. * * @param thread Handle of the thread to wait for. * @param ret Pointer to receive the return value of the * joined thread. * - * @return SUCCESS, INVALID_THREAD or ALREADY_JOINED. + * @return TD_SUCCESS, TD_INVALID_THREAD or TD_ALREADY_JOINED. */ Thread_Error_t Thread_Join(Thread_t thread, void **ret); @@ -168,7 +168,7 @@ void Thread_CriticalExit(); * @param sema Pointer to receive semaphore handle. * @param count Initial count (must not be negative). * - * @return SUCCESS, INVALID_VALUE (negative count) or NO_MEMORY. + * @return TD_SUCCESS, TD_INVALID_VALUE (negative count) or TD_NO_MEMORY. * In case of error the value of sema is undefined. */ Thread_Error_t Thread_SemaphoreCreate(Thread_Semaphore_t *sema, int32_t count); @@ -178,7 +178,7 @@ Thread_Error_t Thread_SemaphoreCreate(Thread_Semaphore_t *sema, int32_t count); * * @param sema Semaphore handle. * - * @return SUCCESS or INVALID_SEMA. + * @return TD_SUCCESS or TD_INVALID_SEMA. */ Thread_Error_t Thread_SemaphoreDestroy(Thread_Semaphore_t sema); @@ -188,7 +188,7 @@ Thread_Error_t Thread_SemaphoreDestroy(Thread_Semaphore_t sema); * * @param sema Semaphore handle. * - * @return SUCCESS or INVALID_SEMA. + * @return TD_SUCCESS or TD_INVALID_SEMA. */ Thread_Error_t Thread_SemaphoreDown(Thread_Semaphore_t sema); @@ -198,7 +198,7 @@ Thread_Error_t Thread_SemaphoreDown(Thread_Semaphore_t sema); * * @param sema Semaphore handle. * - * @return SUCCESS, INVALID_SEMA or TRY_FAIL. + * @return TD_SUCCESS, TD_INVALID_SEMA or TD_TRY_FAIL. */ Thread_Error_t Thread_SemaphoreTryDown(Thread_Semaphore_t sema); @@ -207,7 +207,7 @@ Thread_Error_t Thread_SemaphoreTryDown(Thread_Semaphore_t sema); * * @param sema Semaphore handle. * - * @return SUCCESS or INVALID_SEMA. + * @return TD_SUCCESS or TD_INVALID_SEMA. */ Thread_Error_t Thread_SemaphoreUp(Thread_Semaphore_t sema); @@ -217,8 +217,8 @@ Thread_Error_t Thread_SemaphoreUp(Thread_Semaphore_t sema); * @param sema Semaphore handle. * @param count Pointer to receive the count. * - * @return SUCCESS or INVALID_SEMA. In case of error the - * value of count is undefined. + * @return TD_SUCCESS or TD_INVALID_SEMA. In case of + * error the value of count is undefined. */ Thread_Error_t Thread_SemaphoreGetCount(Thread_Semaphore_t sema, int32_t *count); @@ -228,8 +228,8 @@ Thread_Error_t Thread_SemaphoreGetCount(Thread_Semaphore_t sema, int32_t *count) * * @param mutex Pointer to receive mutex handle. * - * @return SUCCESS or NO_MEMORY. In case of error the - * value of mutex is undefined. + * @return TD_SUCCESS or TD_NO_MEMORY. In case of + * error the value of mutex is undefined. */ Thread_Error_t Thread_MutexCreate(Thread_Mutex_t *mutex); @@ -238,7 +238,7 @@ Thread_Error_t Thread_MutexCreate(Thread_Mutex_t *mutex); * * @param mutex Mutex handle. * - * @return SUCCESS or INVALID_MUTEX. + * @return TD_SUCCESS or TD_INVALID_MUTEX. */ Thread_Error_t Thread_MutexDestroy(Thread_Mutex_t mutex); @@ -248,7 +248,7 @@ Thread_Error_t Thread_MutexDestroy(Thread_Mutex_t mutex); * * @param mutex Mutex handle. * - * @return SUCCESS or INVALID_MUTEX. + * @return TD_SUCCESS or TD_INVALID_MUTEX. */ Thread_Error_t Thread_MutexLock(Thread_Mutex_t mutex); @@ -258,7 +258,7 @@ Thread_Error_t Thread_MutexLock(Thread_Mutex_t mutex); * * @param mutex Mutex handle. * - * @return SUCCESS, INVALID_MUTEX or TRY_FAIL. + * @return TD_SUCCESS, TD_INVALID_MUTEX or TD_TRY_FAIL. */ Thread_Error_t Thread_MutexTryLock(Thread_Mutex_t mutex); @@ -268,7 +268,7 @@ Thread_Error_t Thread_MutexTryLock(Thread_Mutex_t mutex); * * @param mutex Mutex handle. * - * @return SUCCESS or MUTEX_BAD_UNLOCK. + * @return TD_SUCCESS or TD_MUTEX_BAD_UNLOCK. */ Thread_Error_t Thread_MutexUnlock(Thread_Mutex_t mutex); @@ -279,7 +279,7 @@ Thread_Error_t Thread_MutexUnlock(Thread_Mutex_t mutex); * @param isLocked Pointer to receive state. Will be set to true * if the mutex is locked, false if unlocked. * - * @return SUCCESS or INVALID_MUTEX. In case of error the value + * @return TD_SUCCESS or TD_INVALID_MUTEX. In case of error the value * of isLocked is undefined. */ Thread_Error_t Thread_MutexGetState(Thread_Mutex_t mutex, uint8_t *isLocked); diff --git a/src/atomizer/Atomizer.c b/src/atomizer/Atomizer.c index c98f689..0ddb5c6 100755 --- a/src/atomizer/Atomizer.c +++ b/src/atomizer/Atomizer.c @@ -724,7 +724,7 @@ void Atomizer_Init() { PWM_SET_CMR(PWM0, ATOMIZER_PWMCH_BOOST, 0); // Create our Big Atomizer Lock - if(Thread_MutexCreate(&Atomizer_mutex) != SUCCESS) { + if(Thread_MutexCreate(&Atomizer_mutex) != TD_SUCCESS) { // No user code has run yet, the heap is messed up asm volatile ("udf"); } diff --git a/src/thread/Thread.c b/src/thread/Thread.c index 2668e83..07e4fc1 100644 --- a/src/thread/Thread.c +++ b/src/thread/Thread.c @@ -622,7 +622,7 @@ Thread_Error_t Thread_Create(Thread_t *thread, Thread_EntryPtr_t entry, void *ar // allocation to stack guard size (which is 8-byte aligned). block = memalign(THREAD_STACKGUARD_SIZE, stackSize + sizeof(Thread_TCB_t)); if(block == NULL) { - return NO_MEMORY; + return TD_NO_MEMORY; } // Setup TCB @@ -654,7 +654,7 @@ Thread_Error_t Thread_Create(Thread_t *thread, Thread_EntryPtr_t entry, void *ar THREAD_PEND_SCHED(); } - return SUCCESS; + return TD_SUCCESS; } void Thread_Yield() { @@ -676,12 +676,12 @@ Thread_Error_t Thread_Join(Thread_t thread, void **ret) { if(!THREAD_CHECK_TCB(thread)) { Thread_CriticalExit(); - return INVALID_THREAD; + return TD_INVALID_THREAD; } tcb = (Thread_TCB_t *) thread; if(tcb->join.tcb != NULL) { - return ALREADY_JOINED; + return TD_ALREADY_JOINED; } // Setup ourselves as the joined thread @@ -696,7 +696,7 @@ Thread_Error_t Thread_Join(Thread_t thread, void **ret) { // CriticalExit pended the scheduler, wait for suspend/wakeup THREAD_WAIT_READY(); - return SUCCESS; + return TD_SUCCESS; } void Thread_DelayMs(uint32_t delay) { @@ -786,14 +786,14 @@ static void Thread_SemaphoreInit(Thread_SemaphoreInternal_t *sema, int32_t count * @param sema Semaphore. * @param doFree True to free the memory pointed by sema. * - * @return SUCCESS or INVALID_SEMA. + * @return TD_SUCCESS or TD_INVALID_SEMA. */ static Thread_Error_t Thread_SemaphoreDelete(Thread_SemaphoreInternal_t *sema, uint8_t doFree) { Thread_CriticalEnter(); if(!THREAD_CHECK_SEMA(sema)) { Thread_CriticalExit(); - return INVALID_SEMA; + return TD_INVALID_SEMA; } // Delete semaphore @@ -804,27 +804,27 @@ static Thread_Error_t Thread_SemaphoreDelete(Thread_SemaphoreInternal_t *sema, u Thread_CriticalExit(); - return SUCCESS; + return TD_SUCCESS; } Thread_Error_t Thread_SemaphoreCreate(Thread_Semaphore_t *sema, int32_t count) { Thread_SemaphoreInternal_t *sm; if(count < 0) { - return INVALID_VALUE; + return TD_INVALID_VALUE; } // Allocate semaphore sm = malloc(sizeof(Thread_SemaphoreInternal_t)); if(sm == NULL) { - return NO_MEMORY; + return TD_NO_MEMORY; } // Initialize semaphore Thread_SemaphoreInit(sm, count); *sema = (Thread_Semaphore_t) sm; - return SUCCESS; + return TD_SUCCESS; } Thread_Error_t Thread_SemaphoreDestroy(Thread_Semaphore_t sema) { @@ -841,7 +841,7 @@ Thread_Error_t Thread_SemaphoreDown(Thread_Semaphore_t sema) { if(!THREAD_CHECK_SEMA(sema)) { Thread_CriticalExit(); - return INVALID_SEMA; + return TD_INVALID_SEMA; } // Decrement semaphore @@ -876,7 +876,7 @@ Thread_Error_t Thread_SemaphoreDown(Thread_Semaphore_t sema) { THREAD_WAIT_READY(); } - return SUCCESS; + return TD_SUCCESS; } Thread_Error_t Thread_SemaphoreTryDown(Thread_Semaphore_t sema) { @@ -887,7 +887,7 @@ Thread_Error_t Thread_SemaphoreTryDown(Thread_Semaphore_t sema) { if(!THREAD_CHECK_SEMA(sema)) { Thread_CriticalExit(); - return INVALID_SEMA; + return TD_INVALID_SEMA; } // Try to down by compare-and-swap @@ -897,13 +897,13 @@ Thread_Error_t Thread_SemaphoreTryDown(Thread_Semaphore_t sema) { if(oldVal <= 0) { // Can't be downed without waiting Thread_CriticalExit(); - return TRY_FAIL; + return TD_TRY_FAIL; } } while(AtomicOps_CmpSwap((volatile uint32_t *) &sm->count, oldVal, oldVal - 1) != oldVal); Thread_CriticalExit(); - return SUCCESS; + return TD_SUCCESS; } Thread_Error_t Thread_SemaphoreUp(Thread_Semaphore_t sema) { @@ -916,7 +916,7 @@ Thread_Error_t Thread_SemaphoreUp(Thread_Semaphore_t sema) { if(!THREAD_CHECK_SEMA(sema)) { Thread_CriticalExit(); - return INVALID_SEMA; + return TD_INVALID_SEMA; } // Increment semaphore @@ -938,7 +938,7 @@ Thread_Error_t Thread_SemaphoreUp(Thread_Semaphore_t sema) { Thread_CriticalExit(); - return SUCCESS; + return TD_SUCCESS; } Thread_Error_t Thread_SemaphoreGetCount(Thread_Semaphore_t sema, int32_t *count) { @@ -949,7 +949,7 @@ Thread_Error_t Thread_SemaphoreGetCount(Thread_Semaphore_t sema, int32_t *count) if(!THREAD_CHECK_SEMA(sema)) { Thread_CriticalExit(); - return INVALID_SEMA; + return TD_INVALID_SEMA; } // We internally use negative values to count @@ -960,7 +960,7 @@ Thread_Error_t Thread_SemaphoreGetCount(Thread_Semaphore_t sema, int32_t *count) Thread_CriticalExit(); - return SUCCESS; + return TD_SUCCESS; } Thread_Error_t Thread_MutexCreate(Thread_Mutex_t *mutex) { @@ -969,7 +969,7 @@ Thread_Error_t Thread_MutexCreate(Thread_Mutex_t *mutex) { // Allocate mutex and binary semaphore mtx = malloc(sizeof(Thread_MutexInternal_t)); if(mtx == NULL) { - return NO_MEMORY; + return TD_NO_MEMORY; } // Initialize mutex/semaphore to 1 (unlocked) @@ -977,7 +977,7 @@ Thread_Error_t Thread_MutexCreate(Thread_Mutex_t *mutex) { mtx->owner = NULL; *mutex = (Thread_Mutex_t) mtx; - return SUCCESS; + return TD_SUCCESS; } Thread_Error_t Thread_MutexDestroy(Thread_Mutex_t mutex) { @@ -985,14 +985,14 @@ Thread_Error_t Thread_MutexDestroy(Thread_Mutex_t mutex) { // Destroy semaphore, without freeing memory mtx = (Thread_MutexInternal_t *) mutex; - if(Thread_SemaphoreDelete(&mtx->sema, 0) == INVALID_SEMA) { - return INVALID_MUTEX; + if(Thread_SemaphoreDelete(&mtx->sema, 0) == TD_INVALID_SEMA) { + return TD_INVALID_MUTEX; } // Destroy mutex free(mtx); - return SUCCESS; + return TD_SUCCESS; } Thread_Error_t Thread_MutexLock(Thread_Mutex_t mutex) { @@ -1000,12 +1000,12 @@ Thread_Error_t Thread_MutexLock(Thread_Mutex_t mutex) { // Down semaphore (blocking) and take ownership mtx = (Thread_MutexInternal_t *) mutex; - if(Thread_SemaphoreDown((Thread_Semaphore_t) &mtx->sema) == INVALID_SEMA) { - return INVALID_MUTEX; + if(Thread_SemaphoreDown((Thread_Semaphore_t) &mtx->sema) == TD_INVALID_SEMA) { + return TD_INVALID_MUTEX; } mtx->owner = Thread_curTcb; - return SUCCESS; + return TD_SUCCESS; } Thread_Error_t Thread_MutexTryLock(Thread_Mutex_t mutex) { @@ -1016,15 +1016,15 @@ Thread_Error_t Thread_MutexTryLock(Thread_Mutex_t mutex) { mtx = (Thread_MutexInternal_t *) mutex; ret = Thread_SemaphoreTryDown((Thread_Semaphore_t) &mtx->sema); switch(ret) { - case SUCCESS: + case TD_SUCCESS: // Lock succeeded, take ownership mtx->owner = Thread_curTcb; break; - case INVALID_SEMA: - ret = INVALID_MUTEX; + case TD_INVALID_SEMA: + ret = TD_INVALID_MUTEX; break; default: - ret = TRY_FAIL; + ret = TD_TRY_FAIL; break; } @@ -1042,14 +1042,14 @@ Thread_Error_t Thread_MutexUnlock(Thread_Mutex_t mutex) { // already unlocked or we preempted // a Thread_Mutex(Try)Lock, which can // only happen if we don't own the mutex - return MUTEX_BAD_UNLOCK; + return TD_MUTEX_BAD_UNLOCK; } // Release ownership and up semaphore mtx->owner = NULL; Thread_SemaphoreUp((Thread_Semaphore_t) &mtx->sema); - return SUCCESS; + return TD_SUCCESS; } Thread_Error_t Thread_MutexGetState(Thread_Mutex_t mutex, uint8_t *isLocked) { @@ -1057,10 +1057,10 @@ Thread_Error_t Thread_MutexGetState(Thread_Mutex_t mutex, uint8_t *isLocked) { int32_t count; mtx = (Thread_MutexInternal_t *) mutex; - if(Thread_SemaphoreGetCount((Thread_Semaphore_t) &mtx->sema, &count) == INVALID_SEMA) { - return INVALID_MUTEX; + if(Thread_SemaphoreGetCount((Thread_Semaphore_t) &mtx->sema, &count) == TD_INVALID_SEMA) { + return TD_INVALID_MUTEX; } *isLocked = (count == 0); - return SUCCESS; + return TD_SUCCESS; }