esp-idf/components/bt/bluedroid/osi/osi_arch.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_RATE_MS) == pdTRUE) {
      EndTime = xTaskGetTickCount();
      Elapsed = (EndTime - StartTime) * portTICK_RATE_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_RATE_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_RATE_MS);
}