c6_sideband.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_time.h"

static const ra8_port_pin_t k_c6_sideband_pin[k_c6_sb_count] = {
  (ra8_port_pin_t)k_ra8_board_pmod1_irq,
  (ra8_port_pin_t)k_ra8_board_pmod1_reset,
  (ra8_port_pin_t)k_ra8_board_pmod1_gpio_a,
  (ra8_port_pin_t)k_ra8_board_pmod1_gpio_b,
};

static const char* const k_c6_sideband_label[k_c6_sb_count + 1U] = {
  "P006",
  "P402",
  "P412",
  "P413",
  "unresolved",
};

static const ra8_port_pin_t k_c6_wire_pin[k_c6_wire_count] = {
  (ra8_port_pin_t)k_ra8_board_pmod1_uart_cts,
  (ra8_port_pin_t)k_ra8_board_pmod1_spi_copi,
  (ra8_port_pin_t)k_ra8_board_pmod1_spi_cipo,
  (ra8_port_pin_t)k_ra8_board_pmod1_spi_sck,
  (ra8_port_pin_t)k_ra8_board_pmod1_spi_cs,
};

static const char* const k_c6_wire_label[k_c6_wire_count + 1U] = {
  "P800(J26-1 in UART mux)",
  "P801(J26-2)",
  "P802(J26-3)",
  "P803(J26-4 in SPI mux)",
  "P804(J26-1 in SPI mux)",
  "none",
};
 
ra8_err_t c6_probe_sideband_init(void)
{
  for (uint8_t i = 0U; i < (uint8_t)k_c6_sb_count; i++) {
    const ra8_err_t err = ra8_gpio_input_init(k_c6_sideband_pin[i], k_ra8_pull_none);
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_ok;
}
 
void c6_probe_sample_sideband(c6_sideband_sample_t* out)
{
  if (out == nullptr) {
    return;
  }
  for (uint8_t i = 0U; i < (uint8_t)k_c6_sb_count; i++) {
    ra8_level_t level = k_ra8_level_low;
    if (ra8_gpio_read(k_c6_sideband_pin[i], &level) != k_ra8_ok) {
      level = k_ra8_level_low;
    }
    out->level[i] = (level == k_ra8_level_high) ? 1U : 0U;
  }
}
 
const char* c6_probe_sideband_name(uint8_t idx)
{
  const uint8_t safe = (idx < (uint8_t)k_c6_sb_count) ? idx : (uint8_t)k_c6_sb_count;
  return k_c6_sideband_label[safe];
}
 
void c6_probe_print_sideband(const char* label, const c6_sideband_sample_t* s)
{
  if (s == nullptr) {
    return;
  }
  c6_probe_puts(label);
  for (uint8_t i = 0U; i < (uint8_t)k_c6_sb_count; i++) {
    c6_probe_puts(" ");
    c6_probe_puts(c6_probe_sideband_name(i));
    c6_probe_puts("=");
    c6_probe_put_u32((uint32_t)s->level[i]);
  }
  c6_probe_puts("\r\n");
}
 
void c6_probe_vote(const c6_sideband_sample_t* pre,
                   const c6_sideband_sample_t* mid,
                   const c6_sideband_sample_t* post,
                   c6_probe_stats_t*           st)
{
  if (pre == nullptr || mid == nullptr || post == nullptr || st == nullptr) {
    return;
  }
  for (uint8_t i = 0U; i < (uint8_t)k_c6_sb_count; i++) {
    if (pre->level[i] != 0U && mid->level[i] == 0U) {
      st->hs_vote[i]++;
    }
    if (pre->level[i] != 0U && post->level[i] == 0U) {
      st->dr_vote[i]++;
    }
    if (pre->level[i] != 0U || mid->level[i] != 0U || post->level[i] != 0U) {
      st->ever_high[i] = 1U;
    }
    if (pre->level[i] == 0U || mid->level[i] == 0U || post->level[i] == 0U) {
      st->ever_low[i] = 1U;
    }
  }
}
 
uint8_t c6_probe_best(const uint32_t* votes, uint8_t ignore, uint32_t min_votes)
{
  if (votes == nullptr || min_votes == 0U) {
    return (uint8_t)k_c6_sb_count;
  }
  uint8_t  best       = (uint8_t)k_c6_sb_count;
  uint32_t best_score = 0U;
  uint8_t  tied       = 0U;
  for (uint8_t i = 0U; i < (uint8_t)k_c6_sb_count; i++) {
    if (i == ignore || votes[i] < min_votes) {
      continue;
    }
    if (votes[i] > best_score) {
      best_score = votes[i];
      best       = i;
      tied       = 0U;
      continue;
    }
    if (votes[i] == best_score) {
      tied++;
    }
  }
  return (tied == 0U) ? best : (uint8_t)k_c6_sb_count;
}

static ra8_err_t internal_pull_read(ra8_port_pin_t pin, uint8_t* out_low)
{
  if (out_low == nullptr) {
    return k_ra8_err_null_ptr;
  }
  ra8_err_t err = ra8_gpio_release(pin);
  if (err == k_ra8_ok) {
    err = ra8_gpio_input_init(pin, k_ra8_pull_up);
  }
  uint8_t low = 0U;
  if (err == k_ra8_ok) {
    ra8_delay_ms((uint32_t)k_c6_probe_pull_settle_ms);
    for (uint8_t s = 0U; s < (uint8_t)k_c6_probe_pull_samples; s++) {
      ra8_level_t level = k_ra8_level_high;
      /* A failed read must abort the contest, not shorten it. Silently
       * returning a partial count would report "not sunk" for a pin that was
       * never fully measured -- the same read-silence-as-absence mistake this
       * whole mechanism exists to correct. */
      err = ra8_gpio_read(pin, &level);
      if (err != k_ra8_ok) {
        break;
      }
      if (level == k_ra8_level_low) {
        low++;
      }
      ra8_delay_ms((uint32_t)k_c6_probe_pull_settle_ms);
    }
  }
 
  const ra8_err_t released = ra8_gpio_release(pin);
  const ra8_err_t restored = ra8_gpio_input_init(pin, k_ra8_pull_none);
  if (err == k_ra8_ok) {
    err = (released != k_ra8_ok) ? released : restored;
  }
  *out_low = low;
  return err;
}
 
ra8_err_t c6_probe_pull_contest(c6_probe_stats_t* st)
{
  if (st == nullptr) {
    return k_ra8_err_null_ptr;
  }
  for (uint8_t i = 0U; i < (uint8_t)k_c6_sb_count; i++) {
    uint8_t         low = 0U;
    const ra8_err_t err = internal_pull_read(k_c6_sideband_pin[i], &low);
    if (err != k_ra8_ok) {
      return err;
    }
    st->pull_low[i] = low;
    c6_probe_puts("c6_probe: pull-up ");
    c6_probe_puts(c6_probe_sideband_name(i));
    c6_probe_puts(" low=");
    c6_probe_put_u32((uint32_t)low);
    c6_probe_puts("/");
    c6_probe_put_u32((uint32_t)k_c6_probe_pull_samples);
    c6_probe_puts((low >= (uint8_t)k_c6_probe_pull_samples) ? " SUNK: driven low off-chip\r\n"
                                                            : " follows the pull-up\r\n");
  }
  st->pull_samples = (uint8_t)k_c6_probe_pull_samples;
  return k_ra8_ok;
}
 
uint8_t c6_probe_sunk_pin(const c6_probe_stats_t* st, uint8_t ignore)
{
  if (st == nullptr || st->pull_samples == 0U) {
    return (uint8_t)k_c6_sb_count;
  }
  uint8_t found = (uint8_t)k_c6_sb_count;
  uint8_t sunk  = 0U;
  for (uint8_t i = 0U; i < (uint8_t)k_c6_sb_count; i++) {
    if (i == ignore || st->pull_low[i] < st->pull_samples) {
      continue;
    }
    if (sunk == 0U) {
      found = i;
    }
    sunk++;
  }
  return (sunk == 1U) ? found : (uint8_t)k_c6_sb_count;
}
 
void c6_probe_resolve_map(const c6_probe_stats_t* st, uint8_t* hs_idx, uint8_t* dr_idx)
{
  if (st == nullptr || hs_idx == nullptr || dr_idx == nullptr) {
    return;
  }
  const uint8_t hs =
    c6_probe_best(st->hs_vote, (uint8_t)k_c6_sb_count, (uint32_t)k_c6_probe_min_votes);
  uint8_t dr = c6_probe_sunk_pin(st, hs);
  if (dr == (uint8_t)k_c6_sb_count) {
    dr = c6_probe_best(st->dr_vote, hs, (uint32_t)k_c6_probe_min_votes);
  }
  *hs_idx = hs;
  *dr_idx = dr;
}

static ra8_err_t internal_kick_net(ra8_port_pin_t pin, ra8_level_t level, uint8_t* out_level)
{
  if (out_level == nullptr) {
    return k_ra8_err_null_ptr;
  }
  ra8_err_t err = ra8_gpio_output_init(pin, level);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_delay_ms((uint32_t)k_c6_probe_cs_hold_ms);
  err = ra8_gpio_release(pin);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_gpio_input_init(pin, k_ra8_pull_none);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_delay_ms((uint32_t)k_c6_probe_cs_hold_ms);
  ra8_level_t sampled = k_ra8_level_low;
  err                 = ra8_gpio_read(pin, &sampled);
  if (err != k_ra8_ok) {
    (void)ra8_gpio_release(pin);
    return err;
  }
  *out_level = (sampled == k_ra8_level_high) ? 1U : 0U;
  return ra8_gpio_release(pin);
}
 
c6_wire_kind_t c6_probe_wire_kind(uint8_t after_high, uint8_t after_low)
{
  if (after_high != 0U && after_low == 0U) {
    return k_c6_wire_floating;
  }
  if (after_high == 0U && after_low == 0U) {
    return k_c6_wire_low_side;
  }
  if (after_high != 0U && after_low != 0U) {
    return k_c6_wire_high_side;
  }
  return k_c6_wire_odd;
}
 
void c6_probe_wire_test(void)
{
  static const char* const k_kind_name[] = {
    "floating(no termination)",
    "low-side(pull-down or driven low)",
    "high-side(pull-up or driven high)",
    "inconsistent",
  };
  for (uint8_t i = 0U; i < (uint8_t)k_c6_wire_count; i++) {
    uint8_t         after_high = 0U;
    uint8_t         after_low  = 0U;
    const ra8_err_t e_high     = internal_kick_net(k_c6_wire_pin[i], k_ra8_level_high, &after_high);
    const ra8_err_t e_low      = internal_kick_net(k_c6_wire_pin[i], k_ra8_level_low, &after_low);
    c6_probe_puts("c6_probe: wire ");
    c6_probe_puts(k_c6_wire_label[i]);
    if (e_high != k_ra8_ok || e_low != k_ra8_ok) {
      c6_probe_puts(" test failed\r\n");
      continue;
    }
    c6_probe_puts(" hi->");
    c6_probe_put_u32((uint32_t)after_high);
    c6_probe_puts(" lo->");
    c6_probe_put_u32((uint32_t)after_low);
    c6_probe_puts(" ");
    const c6_wire_kind_t kind = c6_probe_wire_kind(after_high, after_low);
    c6_probe_puts(k_kind_name[(uint8_t)kind]);
    c6_probe_puts("\r\n");
  }
}

static bool internal_cs_try(uint8_t idx, c6_probe_stats_t* st)
{
  const ra8_port_pin_t pin = k_c6_wire_pin[idx];
  if (ra8_gpio_output_init(pin, k_ra8_level_high) != k_ra8_ok) {
    return false;
  }
  ra8_delay_ms((uint32_t)k_c6_probe_settle_ms);
  c6_sideband_sample_t idle = {};
  c6_probe_sample_sideband(&idle);
 
  (void)ra8_gpio_write(pin, k_ra8_level_low);
  ra8_delay_ms((uint32_t)k_c6_probe_cs_hold_ms);
  c6_sideband_sample_t asserted = {};
  c6_probe_sample_sideband(&asserted);
 
  (void)ra8_gpio_write(pin, k_ra8_level_high);
  ra8_delay_ms((uint32_t)k_c6_probe_settle_ms);
  (void)ra8_gpio_release(pin);
 
  bool answered = false;
  for (uint8_t i = 0U; i < (uint8_t)k_c6_sb_count; i++) {
    if (idle.level[i] != 0U && asserted.level[i] == 0U) {
      st->hs_vote[i]++;
      answered = true;
    }
  }
  c6_probe_puts("c6_probe: cs-hunt ");
  c6_probe_puts(k_c6_wire_label[idx]);
  c6_probe_print_sideband(answered ? " ANSWERED, asserted" : " no response, asserted", &asserted);
  return answered;
}
 
uint8_t c6_probe_cs_hunt(c6_probe_stats_t* st)
{
  if (st == nullptr) {
    return (uint8_t)k_c6_wire_count;
  }
  uint8_t found = (uint8_t)k_c6_wire_count;
  for (uint8_t i = 0U; i < (uint8_t)k_c6_wire_count; i++) {
    if (internal_cs_try(i, st) && found == (uint8_t)k_c6_wire_count) {
      found = i;
    }
  }
  c6_probe_puts("c6_probe: cs-hunt result ");
  c6_probe_puts(k_c6_wire_label[found]);
  c6_probe_puts("\r\n");
  return found;
}