ra8_esp_hosted_c6link.c

Go to the documentation of this file.

 
#include "ra8_esp_hosted_c6link.h"
 
#include <stdint.h>
#include <string.h>
 
#include "esp_hosted_os_abstraction.h"
#include "port_esp_hosted_host_config.h"
#include "port_esp_hosted_host_os.h"
#include "port_esp_hosted_host_spi.h"
#include "ra8_attributes.h"
#include "ra8_c6link.h"
#include "ra8_c6link_transport.h"
#include "ra8_err.h"
#include "ra8_esp_hosted_port.h"
#include "transport_drv.h"

alignas(k_ra8_c6link_dma_align) static uint8_t s_ra8_esp_hosted_c6link_tx[k_ra8_c6link_frame_bytes];

RA8_INTERNAL static ra8_err_t
internal_ra8_esp_hosted_c6link_transfer(void* ctx, const uint8_t* tx, uint8_t* rx, uint16_t len)
{
  (void)ctx;
  if (!ra8_esp_hosted_port_is_ready()) {
    return k_ra8_err_not_initialized;
  }
  if (len > (uint16_t)k_ra8_c6link_frame_bytes) {
    return k_ra8_err_invalid_size;
  }
 
  /* The vendored transport context's transmit pointer is not const, and
     casting the caller's const one to fit would be a pointer-to-integer
     conversion with no recorded MISRA deviation behind it. Staging the frame
     instead costs a memcpy of about a microsecond against a transaction that
     takes milliseconds, and it buys something real: the buffer the bus sees is
     always DMA-aligned regardless of what the caller allocated. */
  (void)memcpy(s_ra8_esp_hosted_c6link_tx, tx, (size_t)len);
 
  struct hosted_transport_context_t xfer = {};
  xfer.tx_buf                            = s_ra8_esp_hosted_c6link_tx;
  xfer.tx_buf_size                       = (uint32_t)len;
  xfer.rx_buf                            = rx;
 
  const int32_t moved = (int32_t)g_h.funcs->_h_do_bus_transfer(&xfer);
  return (moved == (int32_t)RET_OK) ? k_ra8_ok : k_ra8_err_spi_error;
}

RA8_INTERNAL static bool internal_ra8_esp_hosted_c6link_handshake(void* ctx)
{
  (void)ctx;
  if (!ra8_esp_hosted_port_is_ready()) {
    return false;
  }
  const int32_t level =
    (int32_t)g_h.funcs->_h_read_gpio(H_GPIO_HANDSHAKE_Port, (uint32_t)H_GPIO_HANDSHAKE_Pin);
  return level == (int32_t)H_HS_VAL_ACTIVE;
}

RA8_INTERNAL static void internal_ra8_esp_hosted_c6link_delay(void* ctx, uint16_t ms)
{
  (void)ctx;
  if (!ra8_esp_hosted_port_is_ready()) {
    return;
  }
  (void)g_h.funcs->_h_msleep((unsigned int)ms);
}
 
ra8_err_t ra8_esp_hosted_c6link_bind(ra8_c6link_transport_t* out)
{
  if (out == nullptr) {
    return k_ra8_err_null_ptr;
  }
  *out = (ra8_c6link_transport_t){};
  if (!ra8_esp_hosted_port_is_ready()) {
    return k_ra8_err_not_initialized;
  }
 
  out->transfer         = internal_ra8_esp_hosted_c6link_transfer;
  out->handshake_active = internal_ra8_esp_hosted_c6link_handshake;
  out->delay_ms         = internal_ra8_esp_hosted_c6link_delay;
  out->ctx              = nullptr;
  return k_ra8_ok;
}