c6_fwver_link.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "c6_fwver.h"
#include "esp_hosted_header.h"
#include "esp_hosted_interface.h"
#include "esp_hosted_os_abstraction.h"
#include "esp_hosted_transport.h"
#include "port_esp_hosted_host_config.h"
#include "port_esp_hosted_host_os.h"
#include "ra8_esp_hosted_port.h"
#include "transport_drv.h"

typedef enum : uint16_t {
  k_c6_fwver_hdr_bytes = (uint16_t)sizeof(struct esp_payload_header),
  k_c6_fwver_max_payload = (uint16_t)MAX_PAYLOAD_SIZE,
  k_c6_fwver_nibble_mask = 0x0FU,
  k_c6_fwver_ifnum_shift = 4U,
} c6_fwver_proto_t;

alignas(k_c6_fwver_dma_align) static c6_fwver_frame_t s_c6_fwver_tx;

alignas(k_c6_fwver_dma_align) static c6_fwver_frame_t s_c6_fwver_rx;

static void c6_fwver_tx_clear(void)
{
  for (uint16_t i = 0U; i < (uint16_t)k_c6_fwver_frame_bytes; i++) {
    s_c6_fwver_tx.bytes[i] = 0U;
  }
}

static void c6_fwver_tx_filler(void)
{
  c6_fwver_tx_clear();
  s_c6_fwver_tx.header.if_type = (uint8_t)((uint8_t)ESP_MAX_IF & (uint8_t)k_c6_fwver_nibble_mask);
}

static void c6_fwver_tx_frame(uint8_t if_type, uint8_t if_num, const uint8_t* payload, uint16_t len)
{
  c6_fwver_tx_clear();
  s_c6_fwver_tx.header.if_type = (uint8_t)(if_type & (uint8_t)k_c6_fwver_nibble_mask);
  s_c6_fwver_tx.header.if_num  = (uint8_t)(if_num & (uint8_t)k_c6_fwver_nibble_mask);
  s_c6_fwver_tx.header.len     = len;
  s_c6_fwver_tx.header.offset  = (uint16_t)k_c6_fwver_hdr_bytes;
  for (uint16_t i = 0U; i < len; i++) {
    s_c6_fwver_tx.bytes[(uint16_t)k_c6_fwver_hdr_bytes + i] = payload[i];
  }
  s_c6_fwver_tx.header.checksum =
    compute_checksum(s_c6_fwver_tx.bytes, (uint16_t)((uint16_t)k_c6_fwver_hdr_bytes + len));
}

static bool c6_fwver_wait_handshake(void)
{
  for (uint16_t waited = 0U; waited < (uint16_t)k_c6_fwver_hs_wait_ms;
       waited          = (uint16_t)(waited + (uint16_t)k_c6_fwver_hs_poll_ms)) {
    const int32_t level =
      (int32_t)g_h.funcs->_h_read_gpio(H_GPIO_HANDSHAKE_Port, (uint32_t)H_GPIO_HANDSHAKE_Pin);
    if (level == (int32_t)H_HS_VAL_ACTIVE) {
      return true;
    }
    (void)g_h.funcs->_h_msleep((unsigned int)k_c6_fwver_hs_poll_ms);
  }
  return false;
}

static uint16_t c6_fwver_rx_checksum(uint16_t span)
{
  const uint16_t saved          = s_c6_fwver_rx.header.checksum;
  s_c6_fwver_rx.header.checksum = 0U;
  const uint16_t calc           = compute_checksum(s_c6_fwver_rx.bytes, span);
  s_c6_fwver_rx.header.checksum = saved;
  return calc;
}

static void c6_fwver_print_reject(const char* why, uint16_t calc)
{
  c6_fwver_puts("c6_fwver: dropped ");
  c6_fwver_puts(why);
  c6_fwver_puts(" if_type=");
  c6_fwver_put_u32((uint32_t)s_c6_fwver_rx.header.if_type);
  c6_fwver_puts(" if_num=");
  c6_fwver_put_u32((uint32_t)s_c6_fwver_rx.header.if_num);
  c6_fwver_puts(" flags=0x");
  c6_fwver_put_hex((uint32_t)s_c6_fwver_rx.header.flags, (uint8_t)k_c6_fwver_hex_byte);
  c6_fwver_puts(" len=");
  c6_fwver_put_u32((uint32_t)s_c6_fwver_rx.header.len);
  c6_fwver_puts(" offset=");
  c6_fwver_put_u32((uint32_t)s_c6_fwver_rx.header.offset);
  c6_fwver_puts(" seq=");
  c6_fwver_put_u32((uint32_t)s_c6_fwver_rx.header.seq_num);
  c6_fwver_puts(" pkt_type=0x");
  c6_fwver_put_hex((uint32_t)s_c6_fwver_rx.header.reserved3, (uint8_t)k_c6_fwver_hex_byte);
  c6_fwver_puts(" csum=0x");
  c6_fwver_put_hex((uint32_t)s_c6_fwver_rx.header.checksum, (uint8_t)k_c6_fwver_hex_word);
  c6_fwver_puts(" calc=0x");
  c6_fwver_put_hex((uint32_t)calc, (uint8_t)k_c6_fwver_hex_word);
  c6_fwver_puts(" raw=");
  for (uint16_t i = 0U; i < (uint16_t)k_c6_fwver_hdr_bytes; i++) {
    c6_fwver_put_hex((uint32_t)s_c6_fwver_rx.bytes[i], (uint8_t)k_c6_fwver_hex_byte);
  }
  c6_fwver_puts("\r\n");
}

static bool c6_fwver_ifnum_defect(uint16_t calc, uint16_t stated)
{
  const uint16_t contribution =
    (uint16_t)((uint16_t)s_c6_fwver_rx.header.if_num << (uint16_t)k_c6_fwver_ifnum_shift);
  return (contribution != 0U) && ((uint16_t)(calc - stated) == contribution);
}

static bool c6_fwver_rx_dispatch(c6_fwver_sink_t sink, c6_fwver_pump_stats_t* stats)
{
  const uint16_t len    = s_c6_fwver_rx.header.len;
  const uint16_t offset = s_c6_fwver_rx.header.offset;
 
  if (len == 0U) {
    stats->idle++;
    return false;
  }
  if ((offset != (uint16_t)k_c6_fwver_hdr_bytes) || (len > (uint16_t)k_c6_fwver_max_payload)) {
    stats->malformed++;
    c6_fwver_print_reject("malformed", 0U);
    return false;
  }
  const uint16_t calc = c6_fwver_rx_checksum((uint16_t)(offset + len));
  if (calc != s_c6_fwver_rx.header.checksum) {
    stats->bad_checksum++;
    c6_fwver_print_reject("bad-checksum", calc);
    if (c6_fwver_ifnum_defect(calc, s_c6_fwver_rx.header.checksum)) {
      stats->ifnum_defect++;
      c6_fwver_puts("c6_fwver:   ^ explained: the co-processor checksummed this frame with "
                    "if_num=0 and then transmitted a non-zero if_num. A conformant host "
                    "drops it -- upstream's own process_spi_rx_buf() would too.\r\n");
    }
    return false;
  }
 
  stats->frames++;
  if (sink == nullptr) {
    return false;
  }
  return sink(s_c6_fwver_rx.header.if_type,
              s_c6_fwver_rx.header.if_num,
              &s_c6_fwver_rx.bytes[offset],
              len);
}

static ra8_err_t c6_fwver_pump_check(const uint8_t*               payload,
                                     uint16_t                     payload_len,
                                     uint16_t                     max_transfers,
                                     const c6_fwver_pump_stats_t* stats)
{
  if ((stats == nullptr) || ((payload_len != 0U) && (payload == nullptr))) {
    return k_ra8_err_null_ptr;
  }
  if (max_transfers == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (payload_len > (uint16_t)k_c6_fwver_tx_max) {
    return k_ra8_err_invalid_size;
  }
  if (!ra8_esp_hosted_port_is_ready()) {
    return k_ra8_err_not_initialized;
  }
  return k_ra8_ok;
}
 
ra8_err_t c6_fwver_link_pump(uint8_t                if_type,
                             uint8_t                if_num,
                             const uint8_t*         payload,
                             uint16_t               payload_len,
                             uint16_t               max_transfers,
                             c6_fwver_sink_t        sink,
                             c6_fwver_pump_stats_t* stats)
{
  const ra8_err_t bad = c6_fwver_pump_check(payload, payload_len, max_transfers, stats);
  if (bad != k_ra8_ok) {
    return bad;
  }
 
  *stats                                       = (c6_fwver_pump_stats_t){};
  bool                              tx_pending = (payload_len != 0U);
  struct hosted_transport_context_t ctx        = {};
 
  uint16_t consecutive_timeouts = 0U;
 
  for (uint16_t i = 0U; i < max_transfers; i++) {
    if (!c6_fwver_wait_handshake()) {
      stats->hs_timeouts++;
      consecutive_timeouts++;
      if (consecutive_timeouts >= (uint16_t)k_c6_fwver_hs_giveup) {
        break;
      }
      continue;
    }
    consecutive_timeouts = 0U;
    if (tx_pending) {
      c6_fwver_tx_frame(if_type, if_num, payload, payload_len);
      tx_pending = false;
    } else {
      c6_fwver_tx_filler();
    }
 
    ctx.tx_buf      = s_c6_fwver_tx.bytes;
    ctx.tx_buf_size = (uint32_t)k_c6_fwver_frame_bytes;
    ctx.rx_buf      = s_c6_fwver_rx.bytes;
    if ((int32_t)g_h.funcs->_h_do_bus_transfer(&ctx) != (int32_t)RET_OK) {
      stats->bus_error = true;
      return k_ra8_err_spi_error;
    }
    stats->transfers++;
 
    if (c6_fwver_rx_dispatch(sink, stats)) {
      stats->sink_stopped = true;
      return k_ra8_ok;
    }
    (void)g_h.funcs->_h_msleep((unsigned int)k_c6_fwver_gap_ms);
  }
 
  return (stats->transfers == 0U) ? k_ra8_err_hw_timeout : k_ra8_ok;
}