c6_hosted_frame.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "c6_hosted.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_os.h"
#include "port_esp_hosted_host_spi.h"
#include "transport_drv.h"

typedef enum : uint16_t {
  k_c6_hosted_hdr_bytes = (uint16_t)sizeof(struct esp_payload_header),
  k_c6_hosted_max_payload = (uint16_t)MAX_PAYLOAD_SIZE,
  k_c6_hosted_byte_ones = 0xFFU,
  k_c6_hosted_filler_if_num = 0x0FU,
} c6_hosted_proto_t;

typedef enum : uint8_t {
  k_c6_hosted_fill_mixed = 0U, 
  k_c6_hosted_fill_zero  = 1U, 
  k_c6_hosted_fill_ones  = 2U, 
} c6_hosted_fill_t;

typedef enum : uint8_t {
  k_c6_hosted_verdict_pass     = 0U, 
  k_c6_hosted_verdict_idle     = 1U, 
  k_c6_hosted_verdict_transfer = 2U, 
  k_c6_hosted_verdict_zero     = 3U, 
  k_c6_hosted_verdict_ones     = 4U, 
  k_c6_hosted_verdict_offset   = 5U, 
  k_c6_hosted_verdict_length   = 6U, 
  k_c6_hosted_verdict_csum     = 7U, 
} c6_hosted_verdict_t;

alignas(k_c6_hosted_dma_align) static c6_hosted_frame_t s_c6_hosted_tx;

alignas(k_c6_hosted_dma_align) static c6_hosted_frame_t s_c6_hosted_rx;

static void c6_hosted_build_idle_frame(void)
{
  s_c6_hosted_tx.header.if_type      = (uint8_t)ESP_MAX_IF;
  s_c6_hosted_tx.header.if_num       = 0U;
  s_c6_hosted_tx.header.flags        = 0U;
  s_c6_hosted_tx.header.len          = 0U;
  s_c6_hosted_tx.header.offset       = (uint16_t)k_c6_hosted_hdr_bytes;
  s_c6_hosted_tx.header.checksum     = 0U;
  s_c6_hosted_tx.header.seq_num      = 0U;
  s_c6_hosted_tx.header.throttle_cmd = 0U;
  s_c6_hosted_tx.header.reserved2    = 0U;
  s_c6_hosted_tx.header.reserved3    = 0U;
  s_c6_hosted_tx.header.checksum =
    compute_checksum(s_c6_hosted_tx.bytes, (uint16_t)k_c6_hosted_hdr_bytes);
}

static c6_hosted_fill_t c6_hosted_rx_fill(void)
{
  bool all_zero = true;
  bool all_ones = true;
  for (uint32_t i = 0U; i < (uint32_t)k_c6_hosted_frame_bytes; i++) {
    if (s_c6_hosted_rx.bytes[i] != 0U) {
      all_zero = false;
    }
    if (s_c6_hosted_rx.bytes[i] != (uint8_t)k_c6_hosted_byte_ones) {
      all_ones = false;
    }
  }
  if (all_zero) {
    return k_c6_hosted_fill_zero;
  }
  if (all_ones) {
    return k_c6_hosted_fill_ones;
  }
  return k_c6_hosted_fill_mixed;
}

static uint16_t c6_hosted_rx_checksum(void)
{
  uint16_t span = (uint16_t)k_c6_hosted_hdr_bytes;
  if ((s_c6_hosted_rx.header.offset == (uint16_t)k_c6_hosted_hdr_bytes) &&
      (s_c6_hosted_rx.header.len <= (uint16_t)k_c6_hosted_max_payload)) {
    span = (uint16_t)(span + s_c6_hosted_rx.header.len);
  }
  const uint16_t saved           = s_c6_hosted_rx.header.checksum;
  s_c6_hosted_rx.header.checksum = 0U;
  const uint16_t calc            = compute_checksum(s_c6_hosted_rx.bytes, span);
  s_c6_hosted_rx.header.checksum = saved;
  return calc;
}

static c6_hosted_verdict_t c6_hosted_classify(int32_t rc, uint16_t calc)
{
  const c6_hosted_fill_t fill = c6_hosted_rx_fill();
 
  if (rc != (int32_t)RET_OK) {
    return k_c6_hosted_verdict_transfer;
  }
  if (fill == k_c6_hosted_fill_zero) {
    return k_c6_hosted_verdict_zero;
  }
  if (fill == k_c6_hosted_fill_ones) {
    return k_c6_hosted_verdict_ones;
  }
  if ((s_c6_hosted_rx.header.if_type == (uint8_t)ESP_MAX_IF) &&
      (s_c6_hosted_rx.header.if_num == (uint8_t)k_c6_hosted_filler_if_num) &&
      (s_c6_hosted_rx.header.len == 0U)) {
    return k_c6_hosted_verdict_idle;
  }
  if (s_c6_hosted_rx.header.offset != (uint16_t)k_c6_hosted_hdr_bytes) {
    return k_c6_hosted_verdict_offset;
  }
  if (s_c6_hosted_rx.header.len > (uint16_t)k_c6_hosted_max_payload) {
    return k_c6_hosted_verdict_length;
  }
  if (s_c6_hosted_rx.header.checksum != calc) {
    return k_c6_hosted_verdict_csum;
  }
  return k_c6_hosted_verdict_pass;
}

static const char* c6_hosted_verdict_text(c6_hosted_verdict_t verdict)
{
  switch (verdict) {
    case k_c6_hosted_verdict_pass:
      return "link up";
    case k_c6_hosted_verdict_idle:
      return "link up -- co-processor returned its idle filler frame";
    case k_c6_hosted_verdict_transfer:
      return "bus transfer did not return RET_OK";
    case k_c6_hosted_verdict_zero:
      return "receive buffer all-zero -- co-processor did not drive the bus";
    case k_c6_hosted_verdict_ones:
      return "receive buffer all-ones -- co-processor did not drive the bus";
    case k_c6_hosted_verdict_offset:
      return "header offset is not the payload-header size";
    case k_c6_hosted_verdict_length:
      return "advertised length exceeds MAX_PAYLOAD_SIZE";
    case k_c6_hosted_verdict_csum:
      return "checksum mismatch";
    default:
      return "unrecognised verdict";
  }
}

static void c6_hosted_print_rx_header(uint16_t calc)
{
  c6_hosted_puts("c6_hosted_init: rx if_type=");
  c6_hosted_put_u32((uint32_t)s_c6_hosted_rx.header.if_type);
  c6_hosted_puts(" if_num=");
  c6_hosted_put_u32((uint32_t)s_c6_hosted_rx.header.if_num);
  c6_hosted_puts(" flags=0x");
  c6_hosted_put_hex((uint32_t)s_c6_hosted_rx.header.flags, (uint8_t)k_c6_hosted_hex_byte);
  c6_hosted_puts(" len=");
  c6_hosted_put_u32((uint32_t)s_c6_hosted_rx.header.len);
  c6_hosted_puts(" offset=");
  c6_hosted_put_u32((uint32_t)s_c6_hosted_rx.header.offset);
  c6_hosted_puts(" seq_num=");
  c6_hosted_put_u32((uint32_t)s_c6_hosted_rx.header.seq_num);
  c6_hosted_puts(" csum=0x");
  c6_hosted_put_hex((uint32_t)s_c6_hosted_rx.header.checksum, (uint8_t)k_c6_hosted_hex_csum);
  c6_hosted_puts(" calc=0x");
  c6_hosted_put_hex((uint32_t)calc, (uint8_t)k_c6_hosted_hex_csum);
  c6_hosted_puts("\r\n");
}
 
void c6_hosted_run_transaction(void)
{
  struct hosted_transport_context_t ctx = {};
 
  c6_hosted_build_idle_frame();
  ctx.tx_buf      = s_c6_hosted_tx.bytes;
  ctx.tx_buf_size = (uint32_t)k_c6_hosted_frame_bytes;
  ctx.rx_buf      = s_c6_hosted_rx.bytes;
 
  const int32_t             rc      = (int32_t)g_h.funcs->_h_do_bus_transfer(&ctx);
  const uint16_t            calc    = c6_hosted_rx_checksum();
  const c6_hosted_verdict_t verdict = c6_hosted_classify(rc, calc);
 
  c6_hosted_puts("c6_hosted_init: transfer rc=");
  c6_hosted_put_i32(rc);
  c6_hosted_puts(" frame_bytes=");
  c6_hosted_put_u32((uint32_t)k_c6_hosted_frame_bytes);
  c6_hosted_puts("\r\n");
  c6_hosted_print_rx_header(calc);
  const bool ok = (verdict == k_c6_hosted_verdict_pass) || (verdict == k_c6_hosted_verdict_idle);
  c6_hosted_puts(ok ? "c6_hosted_init: PASS " : "c6_hosted_init: FAIL ");
  c6_hosted_puts(c6_hosted_verdict_text(verdict));
  c6_hosted_puts("\r\n");
}