ra8_esp_hosted_osi.c

Go to the documentation of this file.

 
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>
 
#include "esp_hosted_os_abstraction.h"
#include "esp_hosted_transport_config.h"
#include "esp_log.h"
#include "port_esp_hosted_host_config.h"
#include "port_esp_hosted_host_log.h"
#include "port_esp_hosted_host_os.h"
#include "port_esp_hosted_host_spi.h"
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_esp_hosted_gpio_internal.h"
#include "ra8_esp_hosted_log_internal.h"
#include "ra8_esp_hosted_osi_internal.h"
#include "ra8_esp_hosted_pins.h"
#include "ra8_esp_hosted_port.h"
#include "ra8_esp_hosted_rtos_internal.h"
#include "ra8_esp_hosted_spi_internal.h"
 
DEFINE_LOG_TAG(osi);

typedef enum : uint8_t {
  k_ra8_esp_hosted_osi_queue_depth = (uint8_t)H_TRANSPORT_QUEUE_SIZE,
  k_ra8_esp_hosted_osi_spi_mode = 3U,
  k_ra8_esp_hosted_osi_wakeup_reboot = 1U,
} ra8_esp_hosted_osi_const_t;

static const char* const s_tag = "C6OSI";

static const char* const s_event_base_wifi = "WIFI_EVENT";

static ra8_esp_hosted_event_cb_t s_ra8_esp_hosted_event_cb;

static void* s_ra8_esp_hosted_event_ctx;

hosted_osi_funcs_t g_hosted_osi_funcs;

struct hosted_config_t g_h = HOSTED_CONFIG_INIT_DEFAULT();

ra8_err_t ra8_esp_hosted_port_set_event_cb(ra8_esp_hosted_event_cb_t cb, void* ctx)
{
  if ((cb == nullptr) && (ctx != nullptr)) {
    return k_ra8_err_invalid_arg;
  }
  s_ra8_esp_hosted_event_cb  = cb;
  s_ra8_esp_hosted_event_ctx = ctx;
  return k_ra8_ok;
}

RA8_PRIV
int priv_ra8_esp_hosted_osi_dispatch_event(const char* base,
                                           int32_t     event_id,
                                           const void* data,
                                           size_t      data_len)
{
  if (s_ra8_esp_hosted_event_cb == nullptr) {
    return RET_FAIL;
  }
  if ((data == nullptr) && (data_len != 0U)) {
    return RET_INVALID;
  }
  s_ra8_esp_hosted_event_cb(s_ra8_esp_hosted_event_ctx,
                            (base == nullptr) ? "" : base,
                            event_id,
                            data,
                            data_len);
  return RET_OK;
}

RA8_INTERNAL
static int internal_event_post(esp_event_base_t event_base,
                               int32_t          event_id,
                               void*            event_data,
                               size_t           event_data_size,
                               uint32_t         ticks_to_wait)
{
  (void)ticks_to_wait;
  return priv_ra8_esp_hosted_osi_dispatch_event(event_base, event_id, event_data, event_data_size);
}

RA8_INTERNAL
static int internal_event_wifi_post(int32_t  event_id,
                                    void*    event_data,
                                    size_t   event_data_size,
                                    uint32_t ticks_to_wait)
{
  (void)ticks_to_wait;
  return priv_ra8_esp_hosted_osi_dispatch_event(s_event_base_wifi,
                                                event_id,
                                                event_data,
                                                event_data_size);
}

RA8_INTERNAL
[[gnu::format(printf, 3, 4)]] static void
internal_printf(int level, const char* tag, const char* format, ...)
{
  va_list ap;
  va_start(ap, format);
  priv_ra8_esp_hosted_log_vwrite(level, tag, format, ap);
  va_end(ap);
}

RA8_INTERNAL
static void internal_init_hook(void)
{
  if (!ra8_esp_hosted_port_is_ready()) {
    ESP_LOGE(s_esp_hosted_tag, "core started before ra8_esp_hosted_port_init");
    return;
  }
  ra8_esp_hosted_mem_dump("hosted_init_hook");
}

RA8_INTERNAL
static int internal_restart_host(void)
{
  ESP_LOGE(s_esp_hosted_tag, "core asked for a host restart; declined by policy");
  return RET_FAIL;
}

RA8_INTERNAL
static int internal_config_host_power_save(uint32_t power_save_type,
                                           void*    gpio_port,
                                           uint32_t gpio_num,
                                           int      level)
{
  (void)gpio_port;
  ESP_LOGW(s_esp_hosted_tag,
           "host power save %u not enabled (pin %u level %d)",
           (unsigned int)power_save_type,
           (unsigned int)gpio_num,
           level);
  return RET_FAIL;
}

RA8_INTERNAL
static int internal_start_host_power_save(uint32_t power_save_type)
{
  ESP_LOGW(s_esp_hosted_tag, "host power save %u not enabled", (unsigned int)power_save_type);
  return RET_FAIL;
}

typedef union ra8_esp_hosted_osi_view {
  hosted_osi_funcs_t table; 
  void (*rows[sizeof(hosted_osi_funcs_t) / sizeof(void (*)(void))])(void);
} ra8_esp_hosted_osi_view_t;
 
static_assert(sizeof(hosted_osi_funcs_t) % sizeof(void (*)(void)) == 0U,
              "the esp-hosted vtable must be a whole number of function pointers");

RA8_PRIV
bool priv_ra8_esp_hosted_osi_is_complete(const hosted_osi_funcs_t* table)
{
  if (table == nullptr) {
    return false;
  }
 
  ra8_esp_hosted_osi_view_t view = {.table = *table};
  const uint32_t            rows = (uint32_t)(sizeof(view.rows) / sizeof(view.rows[0]));
 
  for (uint32_t i = 0U; i < rows; i++) {
    if (view.rows[i] == nullptr) {
      return false;
    }
  }
  return true;
}

RA8_PRIV
ra8_err_t priv_ra8_esp_hosted_osi_bind_all(hosted_osi_funcs_t* out)
{
  RA8_CHECK_NULL_PTR(out, s_tag, "vtable");
 
  *out = (hosted_osi_funcs_t){};
 
  ra8_err_t err = priv_ra8_esp_hosted_rtos_bind(out);
  if (err == k_ra8_ok) {
    err = priv_ra8_esp_hosted_rtos_bind_pool(out);
  }
  if (err == k_ra8_ok) {
    err = priv_ra8_esp_hosted_rtos_bind_sync(out);
  }
  if (err == k_ra8_ok) {
    err = priv_ra8_esp_hosted_gpio_bind(out);
  }
  if (err == k_ra8_ok) {
    err = priv_ra8_esp_hosted_spi_bind(out);
  }
  if (err != k_ra8_ok) {
    return err;
  }
  priv_ra8_esp_hosted_osi_bind_absent(out);
 
  out->_h_event_post                      = internal_event_post;
  out->_h_event_wifi_post                 = internal_event_wifi_post;
  out->_h_printf                          = internal_printf;
  out->_h_hosted_init_hook                = internal_init_hook;
  out->_h_restart_host                    = internal_restart_host;
  out->_h_config_host_power_save_hal_impl = internal_config_host_power_save;
  out->_h_start_host_power_save_hal_impl  = internal_start_host_power_save;
 
  if (!priv_ra8_esp_hosted_osi_is_complete(out)) {
    return k_ra8_err_invalid_state;
  }
  return k_ra8_ok;
}
 
/* Every field below comes from the port headers, so the configuration the
   vendored core reads and the pins the port actually drives cannot
   disagree. Written as a plain comment rather than a Doxygen block: the
   contract lives on the declaration in the vendored
   `esp_hosted_transport_config.h`, and a Doxygen block here would attach
   itself to the struct return type rather than to the function. */
struct esp_hosted_spi_config esp_hosted_get_default_spi_config(void)
{
  struct esp_hosted_spi_config cfg = {};
 
  cfg.pin_mosi.port       = RA8_ESP_HOSTED_GPIO_PORT(k_ra8_esp_hosted_pin_copi);
  cfg.pin_mosi.pin        = RA8_ESP_HOSTED_GPIO_PIN(k_ra8_esp_hosted_pin_copi);
  cfg.pin_miso.port       = RA8_ESP_HOSTED_GPIO_PORT(k_ra8_esp_hosted_pin_cipo);
  cfg.pin_miso.pin        = RA8_ESP_HOSTED_GPIO_PIN(k_ra8_esp_hosted_pin_cipo);
  cfg.pin_sclk.port       = RA8_ESP_HOSTED_GPIO_PORT(k_ra8_esp_hosted_pin_sck);
  cfg.pin_sclk.pin        = RA8_ESP_HOSTED_GPIO_PIN(k_ra8_esp_hosted_pin_sck);
  cfg.pin_cs.port         = RA8_ESP_HOSTED_GPIO_PORT(k_ra8_esp_hosted_pin_chip_select);
  cfg.pin_cs.pin          = RA8_ESP_HOSTED_GPIO_PIN(k_ra8_esp_hosted_pin_chip_select);
  cfg.pin_handshake.port  = H_GPIO_HANDSHAKE_Port;
  cfg.pin_handshake.pin   = H_GPIO_HANDSHAKE_Pin;
  cfg.pin_data_ready.port = H_GPIO_DATA_READY_Port;
  cfg.pin_data_ready.pin  = H_GPIO_DATA_READY_Pin;
  cfg.pin_reset.port      = H_GPIO_PORT_RESET;
  cfg.pin_reset.pin       = H_GPIO_PIN_RESET;
 
  cfg.tx_queue_size = (uint16_t)k_ra8_esp_hosted_osi_queue_depth;
  cfg.rx_queue_size = (uint16_t)k_ra8_esp_hosted_osi_queue_depth;
  cfg.mode          = (uint8_t)k_ra8_esp_hosted_osi_spi_mode;
  cfg.clk_mhz       = (uint32_t)H_SPI_FD_CLK_MHZ;
 
  return cfg;
}