main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "c6_probe.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_spi.h"
#include "ra8_time.h"

static c6_probe_stats_t s_c6_stats;

static uint32_t s_c6_pclka_hz;

static const ra8_spi_mode_t k_c6_mode_order[k_c6_probe_mode_count] = {
  k_ra8_spi_mode_3,
  k_ra8_spi_mode_0,
  k_ra8_spi_mode_1,
  k_ra8_spi_mode_2,
};

static void c6_probe_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void c6_probe_clocks_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    c6_probe_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    c6_probe_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &s_c6_pclka_hz) != k_ra8_ok) {
    c6_probe_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    c6_probe_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    c6_probe_panic_halt();
  }
}

static void c6_probe_setup_or_halt(void)
{
  c6_probe_clocks_or_halt();
  if (ra8_board_uart_console_init((uint32_t)k_c6_probe_uart_baud) != k_ra8_ok) {
    c6_probe_panic_halt();
  }
  if (c6_probe_sideband_init() != k_ra8_ok) {
    c6_probe_puts("c6_probe: side-band pin init failed\r\n");
    c6_probe_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    c6_probe_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    c6_probe_panic_halt();
  }
}

static void c6_probe_print_map(const c6_probe_stats_t* st, uint8_t hs_idx, uint8_t dr_idx)
{
  if (st == nullptr) {
    return;
  }
  for (uint8_t i = 0U; i < (uint8_t)k_c6_sb_count; i++) {
    c6_probe_puts("c6_probe: evidence ");
    c6_probe_puts(c6_probe_sideband_name(i));
    c6_probe_puts(" hs_vote=");
    c6_probe_put_u32(st->hs_vote[i]);
    c6_probe_puts(" dr_vote=");
    c6_probe_put_u32(st->dr_vote[i]);
    c6_probe_puts(" pull_low=");
    c6_probe_put_u32((uint32_t)st->pull_low[i]);
    c6_probe_puts("/");
    c6_probe_put_u32((uint32_t)st->pull_samples);
    c6_probe_puts(" high=");
    c6_probe_put_u32((uint32_t)st->ever_high[i]);
    c6_probe_puts(" low=");
    c6_probe_put_u32((uint32_t)st->ever_low[i]);
    c6_probe_puts("\r\n");
  }
  c6_probe_puts("c6_probe: map HANDSHAKE=");
  c6_probe_puts(c6_probe_sideband_name(hs_idx));
  c6_probe_puts(" DATA_READY=");
  c6_probe_puts(c6_probe_sideband_name(dr_idx));
  c6_probe_puts("\r\n");
}

static void c6_probe_print_verdict(const c6_probe_stats_t* st, ra8_spi_mode_t mode, bool link_live)
{
  if (st == nullptr) {
    return;
  }
  c6_probe_puts(link_live ? "c6_probe: PASS esp-hosted link up mode="
                          : "c6_probe: FAIL no esp-hosted frame 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(" xfers=");
  c6_probe_put_u32(st->attempts);
  c6_probe_puts(" data=");
  c6_probe_put_u32(st->data_frames);
  c6_probe_puts(" idle=");
  c6_probe_put_u32(st->idle_frames);
  c6_probe_puts(" badcsum=");
  c6_probe_put_u32(st->bad_csum_frames);
  c6_probe_puts("\r\n");
}

static void c6_probe_run(void)
{
  uint8_t hs_idx =
    c6_probe_best(s_c6_stats.hs_vote, (uint8_t)k_c6_sb_count, (uint32_t)k_c6_probe_min_votes);
  bool           link_live = false;
  ra8_spi_mode_t used      = k_c6_mode_order[0];
 
  for (uint8_t m = 0U; m < (uint8_t)k_c6_probe_mode_count && !link_live; m++) {
    used      = k_c6_mode_order[m];
    link_live = c6_probe_sweep_mode(used, s_c6_pclka_hz, &s_c6_stats, &hs_idx);
  }
 
  /* Here, and not before the sweep: a freshly-booted C6 has its INIT event
   * queued and holds DATA_READY high until a transaction drains it, so an
   * early contest would find nothing sunk. By now the queue is empty (or the
   * link is dead and the contest is the only evidence there is) and the
   * chip-select has been released, which is DATA_READY's true idle state. */
  if (c6_probe_pull_contest(&s_c6_stats) != k_ra8_ok) {
    c6_probe_puts("c6_probe: pull-up contest failed; map falls back to votes\r\n");
  }
 
  uint8_t dr_idx = (uint8_t)k_c6_sb_count;
  c6_probe_resolve_map(&s_c6_stats, &hs_idx, &dr_idx);
  c6_probe_print_map(&s_c6_stats, hs_idx, dr_idx);
  c6_probe_print_verdict(&s_c6_stats, used, link_live);
  if (!link_live) {
    (void)ra8_board_led_on(k_ra8_board_led2);
  }
}

void main(void)
{
  c6_probe_setup_or_halt();
  ra8_isr_globals_enable();
 
  c6_probe_puts("\r\nc6_probe: EK-RA8D2 <-> ESP32-C6 esp-hosted SPI probe\r\n");
  c6_probe_puts("c6_probe: pmod1 sci2 simple-spi controller, cs on P804\r\n");
  ra8_delay_ms((uint32_t)k_c6_probe_boot_wait_ms);
 
  c6_sideband_sample_t idle = {};
  c6_probe_sample_sideband(&idle);
  c6_probe_print_sideband("c6_probe: idle sideband", &idle);
 
  c6_probe_wire_test();
  (void)c6_probe_cs_hunt(&s_c6_stats);
 
  if (c6_probe_spi_pins_init() != k_ra8_ok) {
    c6_probe_puts("c6_probe: spi pin routing failed\r\n");
    c6_probe_panic_halt();
  }
  c6_probe_run();
 
  while (1) {
    (void)ra8_board_led_toggle(k_ra8_board_led1);
    ra8_delay_ms((uint32_t)k_c6_probe_idle_ms);
  }
 
  c6_probe_panic_halt();
}