167 lines
3.3 KiB
C
167 lines
3.3 KiB
C
/*
|
|
* pico_osal.h
|
|
*
|
|
* Created on: December 2014
|
|
* Author: Maxime Vincent
|
|
* Description: OS Abstraction Layer between PicoTCP and No Operating System
|
|
*
|
|
*/
|
|
|
|
/* PicoTCP includes */
|
|
#include "pico_defines.h"
|
|
#include "pico_config.h"
|
|
#include "pico_stack.h"
|
|
#include "pico_osal.h"
|
|
|
|
#define osal_dbg(...)
|
|
//#define osal_dbg(...) printf(__VA_ARGS__)
|
|
|
|
/*****************************************************************************
|
|
* Public functions
|
|
****************************************************************************/
|
|
|
|
/* ============= */
|
|
/* == MUTEXES == */
|
|
/* ============= */
|
|
|
|
struct osal_mutex {
|
|
volatile int want_to_take; /* for ISR safety, basically a mutex for the mutex */
|
|
volatile int mutex;
|
|
int idx; /* only to keep track of the amount/idx, no real function .. */
|
|
};
|
|
|
|
static uint8_t mtx_number = 0;
|
|
|
|
void * pico_mutex_init(void)
|
|
{
|
|
struct osal_mutex * mutex;
|
|
mutex = pico_zalloc(sizeof(struct osal_mutex));
|
|
osal_dbg("mi: %p for %p\n", mutex, __builtin_return_address(0));
|
|
if (!mutex)
|
|
return NULL;
|
|
mutex->mutex = 1;
|
|
mutex->idx = mtx_number++;
|
|
return mutex;
|
|
}
|
|
|
|
void pico_mutex_deinit(void * mutex)
|
|
{
|
|
struct osal_mutex * mtx = mutex;
|
|
pico_free(mutex);
|
|
}
|
|
|
|
int pico_mutex_lock_timeout(void * mutex, int timeout)
|
|
{
|
|
int retval = 0;
|
|
if(mutex != NULL)
|
|
{
|
|
struct osal_mutex * mtx = mutex;
|
|
pico_time timestamp = PICO_TIME_MS();
|
|
while (mtx->mutex == 0)
|
|
{
|
|
pico_stack_tick();
|
|
#ifdef _POSIX_VERSION
|
|
usleep(500);
|
|
#endif
|
|
|
|
/* break on timeout unless infinite timeout */
|
|
if ((timeout != -1) && (PICO_TIME_MS() > (timestamp + timeout)))
|
|
break;
|
|
}
|
|
if (mtx->mutex == 1)
|
|
{
|
|
mtx->mutex = 0; /* take the mutex */
|
|
}
|
|
else
|
|
{
|
|
retval = -1; /* timeout */
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
void pico_mutex_lock(void * mutex)
|
|
{
|
|
pico_mutex_lock_timeout(mutex, -1);
|
|
}
|
|
|
|
void pico_mutex_unlock(void * mutex)
|
|
{
|
|
if(mutex != NULL)
|
|
{
|
|
struct osal_mutex * mtx = mutex;
|
|
mtx->mutex = 1;
|
|
}
|
|
}
|
|
|
|
void pico_mutex_unlock_ISR(void * mutex)
|
|
{
|
|
if(mutex != NULL)
|
|
{
|
|
struct osal_mutex * mtx = mutex;
|
|
// tricky stuff needed or not?
|
|
mtx->mutex = 1;
|
|
}
|
|
}
|
|
|
|
/* ============= */
|
|
/* == SIGNALS == */
|
|
/* ============= */
|
|
|
|
void * pico_signal_init(void)
|
|
{
|
|
void * signal = pico_mutex_init();
|
|
pico_mutex_lock(signal);
|
|
return signal;
|
|
}
|
|
|
|
void pico_signal_deinit(void * signal)
|
|
{
|
|
pico_mutex_deinit(signal);
|
|
}
|
|
|
|
void pico_signal_wait(void * signal)
|
|
{
|
|
pico_signal_wait_timeout(signal, -1);
|
|
}
|
|
|
|
int pico_signal_wait_timeout(void * signal, int timeout)
|
|
{
|
|
return pico_mutex_lock_timeout(signal, timeout);
|
|
}
|
|
|
|
void pico_signal_send(void * signal)
|
|
{
|
|
pico_mutex_unlock(signal);
|
|
}
|
|
|
|
void pico_signal_send_ISR(void * signal)
|
|
{
|
|
pico_mutex_unlock_ISR(signal);
|
|
}
|
|
|
|
|
|
/* ============= */
|
|
/* == THREADS == */
|
|
/* ============= */
|
|
|
|
pico_thread_t pico_thread_create(pico_thread_fn thread, void *arg, int stack_size, int prio)
|
|
{
|
|
(void)thread;
|
|
(void)arg;
|
|
(void)stack_size;
|
|
(void)prio;
|
|
return NULL;
|
|
}
|
|
|
|
void pico_thread_destroy(pico_thread_t t)
|
|
{
|
|
return;
|
|
}
|
|
|
|
void pico_msleep(int ms)
|
|
{
|
|
pico_time now = PICO_TIME_MS();
|
|
while ((pico_time)(now + ms) < PICO_TIME_MS());
|
|
}
|