196 lines
5.5 KiB
C
196 lines
5.5 KiB
C
/*
|
|
* Copyright (c) 2001-2003 Swedish Institute of Computer Science.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* 3. The name of the author may not be used to endorse or promote products
|
|
* derived from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
|
|
* SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
|
|
* OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
|
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
|
|
* OF SUCH DAMAGE.
|
|
*
|
|
* This file is part of the bluedroid stack.
|
|
*
|
|
* Author: Adam Dunkels <adam@sics.se>
|
|
*
|
|
*/
|
|
|
|
#include "osi_arch.h"
|
|
|
|
/** Create a new mutex
|
|
* @param mutex pointer to the mutex to create
|
|
* @return a new mutex */
|
|
int
|
|
osi_mutex_new(osi_mutex_t *pxMutex)
|
|
{
|
|
int xReturn = -1;
|
|
|
|
*pxMutex = xSemaphoreCreateMutex();
|
|
|
|
if (*pxMutex != NULL) {
|
|
xReturn = 0;
|
|
}
|
|
|
|
//LWIP_DEBUGF(THREAD_SAFE_DEBUG, ("osi_mutex_new: m=%p\n", *pxMutex));
|
|
|
|
return xReturn;
|
|
}
|
|
|
|
/** Lock a mutex
|
|
* @param mutex the mutex to lock */
|
|
void
|
|
osi_mutex_lock(osi_mutex_t *pxMutex)
|
|
{
|
|
while (xSemaphoreTake(*pxMutex, portMAX_DELAY) != pdPASS);
|
|
}
|
|
|
|
int
|
|
osi_mutex_trylock(osi_mutex_t *pxMutex)
|
|
{
|
|
if (xSemaphoreTake(*pxMutex, 0) == pdPASS) {
|
|
return 0;
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/** Unlock a mutex
|
|
* @param mutex the mutex to unlock */
|
|
void
|
|
osi_mutex_unlock(osi_mutex_t *pxMutex)
|
|
{
|
|
xSemaphoreGive(*pxMutex);
|
|
}
|
|
|
|
/** Delete a semaphore
|
|
* @param mutex the mutex to delete */
|
|
void
|
|
osi_mutex_free(osi_mutex_t *pxMutex)
|
|
{
|
|
//LWIP_DEBUGF(THREAD_SAFE_DEBUG, ("osi_mutex_free: m=%p\n", *pxMutex));
|
|
vQueueDelete(*pxMutex);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------------*/
|
|
// Creates and returns a new semaphore. The "init_count" argument specifies
|
|
// the initial state of the semaphore, "max_count" specifies the maximum value
|
|
// that can be reached.
|
|
int
|
|
osi_sem_new(osi_sem_t *sem, uint32_t max_count, uint32_t init_count)
|
|
{
|
|
int xReturn = -1;
|
|
if (sem) {
|
|
*sem = xSemaphoreCreateCounting(max_count, init_count);
|
|
if ((*sem) != NULL) {
|
|
xReturn = 0;
|
|
}
|
|
}
|
|
|
|
return xReturn;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------------*/
|
|
// Signals a semaphore
|
|
void
|
|
osi_sem_signal(osi_sem_t *sem)
|
|
{
|
|
xSemaphoreGive(*sem);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------------*/
|
|
/*
|
|
Blocks the thread while waiting for the semaphore to be
|
|
signaled. If the "timeout" argument is non-zero, the thread should
|
|
only be blocked for the specified time (measured in
|
|
milliseconds).
|
|
|
|
If the timeout argument is non-zero, the return value is the number of
|
|
milliseconds spent waiting for the semaphore to be signaled. If the
|
|
semaphore wasn't signaled within the specified time, the return value is
|
|
OSI_ARCH_TIMEOUT. If the thread didn't have to wait for the semaphore
|
|
(i.e., it was already signaled), the function may return zero.
|
|
|
|
Notice that lwIP implements a function with a similar name,
|
|
osi_sem_wait(), that uses the osi_arch_sem_wait() function.
|
|
*/
|
|
uint32_t
|
|
osi_sem_wait(osi_sem_t *sem, uint32_t timeout)
|
|
{
|
|
portTickType StartTime, EndTime, Elapsed;
|
|
unsigned long ulReturn;
|
|
|
|
StartTime = xTaskGetTickCount();
|
|
|
|
if (timeout != 0) {
|
|
if (xSemaphoreTake(*sem, timeout / portTICK_PERIOD_MS) == pdTRUE) {
|
|
EndTime = xTaskGetTickCount();
|
|
Elapsed = (EndTime - StartTime) * portTICK_PERIOD_MS;
|
|
|
|
if (Elapsed == 0) {
|
|
Elapsed = 1;
|
|
}
|
|
|
|
ulReturn = Elapsed;
|
|
} else {
|
|
ulReturn = OSI_ARCH_TIMEOUT;
|
|
}
|
|
} else { // must block without a timeout
|
|
while (xSemaphoreTake(*sem, portMAX_DELAY) != pdTRUE);
|
|
|
|
EndTime = xTaskGetTickCount();
|
|
Elapsed = (EndTime - StartTime) * portTICK_PERIOD_MS;
|
|
|
|
if (Elapsed == 0) {
|
|
Elapsed = 1;
|
|
}
|
|
|
|
ulReturn = Elapsed;
|
|
}
|
|
|
|
return ulReturn ; // return time blocked
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------------*/
|
|
// Deallocates a semaphore
|
|
void
|
|
osi_sem_free(osi_sem_t *sem)
|
|
{
|
|
vSemaphoreDelete(*sem);
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------------*/
|
|
// Initialize osi arch
|
|
void
|
|
osi_arch_init(void)
|
|
{
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------------*/
|
|
uint32_t
|
|
osi_now(void)
|
|
{
|
|
return xTaskGetTickCount();
|
|
}
|
|
|
|
|
|
void osi_delay_ms(uint32_t ms)
|
|
{
|
|
vTaskDelay(ms / portTICK_PERIOD_MS);
|
|
}
|
|
|
|
|