c6_xfer.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "c6_probe.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_err.h"
#include "ra8_port_utils.h"
#include "ra8_sci_spi.h"
#include "ra8_spi.h"
#include "ra8_time.h"

static uint8_t s_c6_tx[k_c6_proto_buf_size];

static uint8_t s_c6_rx[k_c6_proto_buf_size];

static void internal_fill_idle_tx(void)
{
  for (uint16_t i = 0U; i < (uint16_t)k_c6_proto_buf_size; i++) {
    s_c6_tx[i] = 0U;
    s_c6_rx[i] = 0U;
  }
  s_c6_tx[k_c6_hdr_off_iface] = (uint8_t)k_c6_if_max;
}

static void internal_cs(ra8_level_t level)
{
  (void)ra8_gpio_write((ra8_port_pin_t)k_ra8_board_pmod1_spi_cs, level);
  ra8_delay_ms((uint32_t)k_c6_probe_cs_hold_ms);
}

static bool internal_sample_ready(const c6_sideband_sample_t* s, uint8_t hs_idx)
{
  if (s == nullptr) {
    return false;
  }
  if (hs_idx < (uint8_t)k_c6_sb_count) {
    return s->level[hs_idx] != 0U;
  }
  for (uint8_t i = 0U; i < (uint8_t)k_c6_sb_count; i++) {
    if (s->level[i] != 0U) {
      return true;
    }
  }
  return false;
}

static bool internal_wait_ready(uint8_t hs_idx)
{
  for (uint8_t poll = 0U; poll < (uint8_t)k_c6_probe_hs_poll_max; poll++) {
    c6_sideband_sample_t s = {};
    c6_probe_sample_sideband(&s);
    if (internal_sample_ready(&s, hs_idx)) {
      return true;
    }
    ra8_delay_ms((uint32_t)k_c6_probe_hs_poll_ms);
  }
  return false;
}

static ra8_err_t
internal_transfer(c6_sideband_sample_t* pre, c6_sideband_sample_t* mid, c6_sideband_sample_t* post)
{
  if (pre == nullptr || mid == nullptr || post == nullptr) {
    return k_ra8_err_null_ptr;
  }
  const uint8_t channel = (uint8_t)k_ra8_board_pmod1_sci_channel;
  internal_fill_idle_tx();
 
  c6_probe_sample_sideband(pre);
  internal_cs(k_ra8_level_low);
  ra8_err_t err = ra8_sci_spi_xfer(channel, s_c6_tx, s_c6_rx, (uint32_t)k_c6_proto_hdr_size);
  c6_probe_sample_sideband(mid);
  if (err == k_ra8_ok) {
    err =
      ra8_sci_spi_xfer(channel,
                       &s_c6_tx[k_c6_proto_hdr_size],
                       &s_c6_rx[k_c6_proto_hdr_size],
                       (uint32_t)((uint16_t)k_c6_proto_buf_size - (uint16_t)k_c6_proto_hdr_size));
  }
  internal_cs(k_ra8_level_high);
  ra8_delay_ms((uint32_t)k_c6_probe_settle_ms);
  c6_probe_sample_sideband(post);
  return err;
}

static c6_frame_kind_t internal_report_frame(c6_probe_stats_t* st)
{
  if (st == nullptr) {
    return k_c6_frame_garbage;
  }
  c6_hdr_t hdr = {};
  c6_probe_decode_header(s_c6_rx, &hdr);
  c6_probe_print_header(&hdr);
  const c6_frame_kind_t kind = c6_probe_classify(&hdr);
  if (kind == k_c6_frame_idle) {
    st->idle_frames++;
    c6_probe_puts("    frame: idle filler from the C6\r\n");
  } else if (kind == k_c6_frame_data) {
    st->data_frames++;
    c6_probe_puts("    frame: data, checksum ok\r\n");
    c6_probe_dump_payload(s_c6_rx, hdr.len);
  } else if (kind == k_c6_frame_bad_csum) {
    st->bad_csum_frames++;
    c6_probe_puts("    frame: header sane, checksum mismatch\r\n");
    c6_probe_dump_payload(s_c6_rx, hdr.len);
  } else {
    c6_probe_puts("    frame: no esp-hosted structure\r\n");
  }
  return kind;
}

static c6_frame_kind_t internal_one_xfer(uint32_t index, uint8_t hs_idx, c6_probe_stats_t* st)
{
  if (st == nullptr) {
    return k_c6_frame_garbage;
  }
  c6_probe_puts("  xfer ");
  c6_probe_put_u32(index);
  c6_probe_puts("\r\n");
  if (!internal_wait_ready(hs_idx)) {
    c6_probe_puts("    skipped: no side-band pin asserted\r\n");
    return k_c6_frame_garbage;
  }
 
  c6_sideband_sample_t pre  = {};
  c6_sideband_sample_t mid  = {};
  c6_sideband_sample_t post = {};
  const ra8_err_t      err  = internal_transfer(&pre, &mid, &post);
  st->attempts++;
  c6_probe_print_sideband("    pre ", &pre);
  c6_probe_print_sideband("    mid ", &mid);
  c6_probe_print_sideband("    post", &post);
  c6_probe_vote(&pre, &mid, &post, st);
  if (err != k_ra8_ok) {
    c6_probe_puts("    spi transfer error\r\n");
    return k_c6_frame_garbage;
  }
 
  return internal_report_frame(st);
}
 
ra8_err_t c6_probe_spi_pins_init(void)
{
  ra8_err_t err = ra8_pfs_route_peripheral((ra8_port_pin_t)k_ra8_board_pmod1_spi_sck,
                                           k_ra8_psel_sci_async,
                                           "c6probe.sck");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_pfs_route_peripheral((ra8_port_pin_t)k_ra8_board_pmod1_spi_cipo,
                                 k_ra8_psel_sci_async,
                                 "c6probe.cipo");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_pfs_route_peripheral((ra8_port_pin_t)k_ra8_board_pmod1_spi_copi,
                                 k_ra8_psel_sci_async,
                                 "c6probe.copi");
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_gpio_output_init((ra8_port_pin_t)k_ra8_board_pmod1_spi_cs, k_ra8_level_high);
}
 
bool c6_probe_sweep_mode(ra8_spi_mode_t    mode,
                         uint32_t          pclka_hz,
                         c6_probe_stats_t* st,
                         uint8_t*          hs_idx)
{
  if (st == nullptr || hs_idx == nullptr) {
    return false;
  }
  const ra8_sci_spi_cfg_t cfg = {
    .baud_hz   = (uint32_t)k_c6_probe_sck_hz,
    .pclk_hz   = pclka_hz,
    .mode      = mode,
    .lsb_first = false,
  };
  c6_probe_puts("c6_probe: spi mode=");
  c6_probe_put_u32((uint32_t)mode);
  c6_probe_puts(" sck_hz=");
  c6_probe_put_u32((uint32_t)k_c6_probe_sck_hz);
  c6_probe_puts("\r\n");
  if (ra8_sci_spi_init((uint8_t)k_ra8_board_pmod1_sci_channel, &cfg) != k_ra8_ok) {
    c6_probe_puts("c6_probe: sci spi init failed\r\n");
    return false;
  }
 
  bool decoded = false;
  for (uint8_t i = 0U; i < (uint8_t)k_c6_probe_xfer_per_mode; i++) {
    const c6_frame_kind_t kind = internal_one_xfer((uint32_t)i + 1U, *hs_idx, st);
    if (kind == k_c6_frame_idle || kind == k_c6_frame_data) {
      decoded = true;
    }
    *hs_idx = c6_probe_best(st->hs_vote, (uint8_t)k_c6_sb_count, (uint32_t)k_c6_probe_min_votes);
    ra8_delay_ms((uint32_t)k_c6_probe_gap_ms);
  }
  (void)ra8_sci_spi_deinit((uint8_t)k_ra8_board_pmod1_sci_channel);
  return decoded;
}