ra8_esp_hosted_rtos_sync.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_esp_hosted_port.h"
#include "ra8_esp_hosted_rtos_internal.h"
#include "ra8_log.h"
 
#ifdef RA8_OFF_TARGET
#include "ra8_esp_hosted_tx_shim_sync_internal.h"
#else
#include "tx_api.h"
#endif
 
#include "port_esp_hosted_host_os.h"

static const char* s_tag = "ESPH_SYNC";

typedef enum : uint32_t {
  k_ra8_esp_hosted_sem_initial = 1U, 
} ra8_esp_hosted_sync_const_t;

typedef struct {
  TX_MUTEX     mutexes[k_ra8_esp_hosted_max_mutexes];     
  bool         mutex_used[k_ra8_esp_hosted_max_mutexes];  
  TX_SEMAPHORE sems[k_ra8_esp_hosted_max_semaphores];     
  bool         sem_used[k_ra8_esp_hosted_max_semaphores]; 
  bool         ready;                                     
} ra8_esp_hosted_sync_state_t;

static ra8_esp_hosted_sync_state_t s_sync;
 
/* ----------------------------------------------------------------------- */
/* Mutex vtable slots */
/* ----------------------------------------------------------------------- */

RA8_INTERNAL static void* internal_h_create_mutex(void)
{
  if (!s_sync.ready) {
    return nullptr;
  }
  const uint32_t idx =
    priv_ra8_esp_hosted_rtos_slot_take(s_sync.mutex_used, k_ra8_esp_hosted_max_mutexes);
  if (idx == (uint32_t)k_ra8_esp_hosted_max_mutexes) {
    ra8_log_error(s_tag, "mutex table exhausted");
    return nullptr;
  }
  if (tx_mutex_create(&s_sync.mutexes[idx], nullptr, TX_INHERIT) != TX_SUCCESS) {
    s_sync.mutex_used[idx] = false;
    return nullptr;
  }
  return &s_sync.mutexes[idx];
}

RA8_INTERNAL static int internal_h_lock_mutex(void* mutex_handle, int timeout_ms)
{
  const uint32_t idx = priv_ra8_esp_hosted_rtos_slot_index(mutex_handle,
                                                           s_sync.mutexes,
                                                           sizeof(s_sync.mutexes[0]),
                                                           k_ra8_esp_hosted_max_mutexes,
                                                           s_sync.mutex_used);
  if (idx == (uint32_t)k_ra8_esp_hosted_max_mutexes) {
    return RET_INVALID;
  }
  const UINT rc =
    tx_mutex_get(&s_sync.mutexes[idx], (ULONG)priv_ra8_esp_hosted_rtos_ms_to_ticks(timeout_ms));
  return (rc == TX_SUCCESS) ? RET_OK : RET_FAIL_TIMEOUT;
}

RA8_INTERNAL static int internal_h_unlock_mutex(void* mutex_handle)
{
  const uint32_t idx = priv_ra8_esp_hosted_rtos_slot_index(mutex_handle,
                                                           s_sync.mutexes,
                                                           sizeof(s_sync.mutexes[0]),
                                                           k_ra8_esp_hosted_max_mutexes,
                                                           s_sync.mutex_used);
  if (idx == (uint32_t)k_ra8_esp_hosted_max_mutexes) {
    return RET_INVALID;
  }
  return (tx_mutex_put(&s_sync.mutexes[idx]) == TX_SUCCESS) ? RET_OK : RET_FAIL;
}

RA8_INTERNAL static int internal_h_destroy_mutex(void* mutex_handle)
{
  const uint32_t idx = priv_ra8_esp_hosted_rtos_slot_index(mutex_handle,
                                                           s_sync.mutexes,
                                                           sizeof(s_sync.mutexes[0]),
                                                           k_ra8_esp_hosted_max_mutexes,
                                                           s_sync.mutex_used);
  if (idx == (uint32_t)k_ra8_esp_hosted_max_mutexes) {
    return RET_INVALID;
  }
  const int rc = (tx_mutex_delete(&s_sync.mutexes[idx]) == TX_SUCCESS) ? RET_OK : RET_FAIL;
  s_sync.mutex_used[idx] = false;
  return rc;
}
 
/* ----------------------------------------------------------------------- */
/* Semaphore vtable slots */
/* ----------------------------------------------------------------------- */

RA8_INTERNAL static void* internal_h_create_semaphore(int max_count)
{
  if (!s_sync.ready || (max_count <= 0)) {
    return nullptr;
  }
  const uint32_t idx =
    priv_ra8_esp_hosted_rtos_slot_take(s_sync.sem_used, k_ra8_esp_hosted_max_semaphores);
  if (idx == (uint32_t)k_ra8_esp_hosted_max_semaphores) {
    ra8_log_error(s_tag, "semaphore table exhausted");
    return nullptr;
  }
  if (tx_semaphore_create(&s_sync.sems[idx], nullptr, (ULONG)k_ra8_esp_hosted_sem_initial) !=
      TX_SUCCESS) {
    s_sync.sem_used[idx] = false;
    return nullptr;
  }
  return &s_sync.sems[idx];
}

RA8_INTERNAL static int internal_h_get_semaphore(void* semaphore_handle, int timeout_ms)
{
  const uint32_t idx = priv_ra8_esp_hosted_rtos_slot_index(semaphore_handle,
                                                           s_sync.sems,
                                                           sizeof(s_sync.sems[0]),
                                                           k_ra8_esp_hosted_max_semaphores,
                                                           s_sync.sem_used);
  if (idx == (uint32_t)k_ra8_esp_hosted_max_semaphores) {
    return RET_INVALID;
  }
  const UINT rc =
    tx_semaphore_get(&s_sync.sems[idx], (ULONG)priv_ra8_esp_hosted_rtos_ms_to_ticks(timeout_ms));
  return (rc == TX_SUCCESS) ? RET_OK : RET_FAIL_TIMEOUT;
}

RA8_INTERNAL static int internal_h_post_semaphore(void* semaphore_handle)
{
  const uint32_t idx = priv_ra8_esp_hosted_rtos_slot_index(semaphore_handle,
                                                           s_sync.sems,
                                                           sizeof(s_sync.sems[0]),
                                                           k_ra8_esp_hosted_max_semaphores,
                                                           s_sync.sem_used);
  if (idx == (uint32_t)k_ra8_esp_hosted_max_semaphores) {
    return RET_INVALID;
  }
  return (tx_semaphore_put(&s_sync.sems[idx]) == TX_SUCCESS) ? RET_OK : RET_FAIL;
}

RA8_INTERNAL RA8_ISR_SAFE static int internal_h_post_semaphore_from_isr(void* semaphore_handle)
{
  const uint32_t idx = priv_ra8_esp_hosted_rtos_slot_index(semaphore_handle,
                                                           s_sync.sems,
                                                           sizeof(s_sync.sems[0]),
                                                           k_ra8_esp_hosted_max_semaphores,
                                                           s_sync.sem_used);
  if (idx == (uint32_t)k_ra8_esp_hosted_max_semaphores) {
    return RET_INVALID;
  }
  return (tx_semaphore_put(&s_sync.sems[idx]) == TX_SUCCESS) ? RET_OK : RET_FAIL;
}

RA8_INTERNAL static int internal_h_destroy_semaphore(void* semaphore_handle)
{
  const uint32_t idx = priv_ra8_esp_hosted_rtos_slot_index(semaphore_handle,
                                                           s_sync.sems,
                                                           sizeof(s_sync.sems[0]),
                                                           k_ra8_esp_hosted_max_semaphores,
                                                           s_sync.sem_used);
  if (idx == (uint32_t)k_ra8_esp_hosted_max_semaphores) {
    return RET_INVALID;
  }
  const int rc         = (tx_semaphore_delete(&s_sync.sems[idx]) == TX_SUCCESS) ? RET_OK : RET_FAIL;
  s_sync.sem_used[idx] = false;
  return rc;
}
 
ra8_err_t priv_ra8_esp_hosted_rtos_sync_init(void)
{
  if (s_sync.ready) {
    ra8_log_error(s_tag, "sync tables already initialised");
    return k_ra8_err_invalid_state;
  }
  (void)memset(&s_sync, 0, sizeof(s_sync));
  s_sync.ready = true;
  return k_ra8_ok;
}
 
ra8_err_t priv_ra8_esp_hosted_rtos_sync_deinit(void)
{
  if (!s_sync.ready) {
    ra8_log_error(s_tag, "sync tables not initialised");
    return k_ra8_err_not_initialized;
  }
  ra8_err_t worst = k_ra8_ok;
  for (uint32_t i = 0U; i < (uint32_t)k_ra8_esp_hosted_max_semaphores; ++i) {
    if (s_sync.sem_used[i] && (internal_h_destroy_semaphore(&s_sync.sems[i]) != RET_OK)) {
      worst = k_ra8_err_rtos_error;
    }
  }
  for (uint32_t i = 0U; i < (uint32_t)k_ra8_esp_hosted_max_mutexes; ++i) {
    if (s_sync.mutex_used[i] && (internal_h_destroy_mutex(&s_sync.mutexes[i]) != RET_OK)) {
      worst = k_ra8_err_rtos_error;
    }
  }
  (void)memset(&s_sync, 0, sizeof(s_sync));
  return worst;
}
 
ra8_err_t priv_ra8_esp_hosted_rtos_bind_sync(hosted_osi_funcs_t* out)
{
  RA8_CHECK_NULL_PTR(out, s_tag, "vtable is NULL");
  out->_h_create_mutex            = internal_h_create_mutex;
  out->_h_lock_mutex              = internal_h_lock_mutex;
  out->_h_unlock_mutex            = internal_h_unlock_mutex;
  out->_h_destroy_mutex           = internal_h_destroy_mutex;
  out->_h_create_semaphore        = internal_h_create_semaphore;
  out->_h_get_semaphore           = internal_h_get_semaphore;
  out->_h_post_semaphore          = internal_h_post_semaphore;
  out->_h_post_semaphore_from_isr = internal_h_post_semaphore_from_isr;
  out->_h_destroy_semaphore       = internal_h_destroy_semaphore;
  return k_ra8_ok;
}