board_periph_canfd.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
#include "board_console.h"
#include "board_periph_block.h"
#include "emu_host_io_internal.h"

typedef enum : uint64_t {
  k_canfd0_base       = 0x40380000UL,   
  k_canfd1_base       = 0x40382000UL,   
  k_canfd_span        = 0x1920UL,       
  k_canfd_count       = 2UL,            
  k_canfd_words       = 0x1920UL / 4UL, 
  k_canfd_off_cnctr   = 0x004UL,        
  k_canfd_off_cnsts   = 0x008UL,        
  k_canfd_off_gctr    = 0x018UL,        
  k_canfd_off_gsts    = 0x01CUL,        
  k_canfd_off_rfsts0  = 0x044UL,        
  k_canfd_off_rfpctr0 = 0x04CUL,        
  k_canfd_off_tmc0    = 0x070UL,        
  k_canfd_off_tmsts0  = 0x074UL,        
  k_canfd_off_rf0     = 0x520UL,        
  k_canfd_off_tm0     = 0x604UL,        
  k_canfd_frame_words = 0x4CUL / 4UL,   
  k_canfd_off_afl     = 0x120UL,        
  k_canfd_afl_stride  = 0x10UL,         
  k_canfd_afl_count   = 16UL,           
} canfd_map_t;

typedef enum : uint32_t {
  k_gsts_grststs  = 1UL << 0U, 
  k_gsts_ghltsts  = 1UL << 1U, 
  k_gsts_graminit = 1UL << 3U, 
} canfd_gsts_t;

typedef enum : uint32_t {
  k_cnsts_crstst = 1UL << 0U, 
  k_cnsts_chltst = 1UL << 1U, 
} canfd_cnsts_t;

typedef enum : uint32_t {
  k_canfd_id_std = 0x000007FFUL, 
  k_canfd_id_ext = 0x1FFFFFFFUL, 
} canfd_id_mask_t;

typedef enum : uint32_t {
  k_canfd_ptr_word      = 1UL,   
  k_canfd_ptr_dlc_shift = 28UL,  
  k_canfd_ptr_dlc_mask  = 0xFUL, 
} canfd_ptr_t;

typedef enum : uint32_t {
  k_mode_mask      = 0x3UL, 
  k_mode_operation = 0x0UL, 
  k_mode_reset     = 0x1UL, 
  k_mode_halt      = 0x2UL, 
} canfd_mode_t;

typedef enum : uint32_t {
  k_rfsts_empty = 1UL << 0U, 
  k_rfsts_if    = 1UL << 3U, 
} canfd_rfsts_t;

typedef enum : uint8_t {
  k_tmc_txreq  = 1U << 0U, 
  k_tmsts_done = 0x04U,    
} canfd_tmc_t;

typedef enum : uint16_t {
  k_event_can0_rxf = 0x33DU, 
} canfd_elc_event_t;

typedef struct {
  uint32_t reg[k_canfd_words]; 
  uint32_t loopbacks;          
} canfd_inst_t;
 
static canfd_inst_t s_canfd[k_canfd_count];

RA8_INTERNAL static uint32_t internal_canfd_instance(uint64_t addr)
{
  if ((addr >= (uint64_t)k_canfd0_base) &&
      (addr < (uint64_t)k_canfd0_base + (uint64_t)k_canfd_span)) {
    return 0U;
  }
  if ((addr >= (uint64_t)k_canfd1_base) &&
      (addr < (uint64_t)k_canfd1_base + (uint64_t)k_canfd_span)) {
    return 1U;
  }
  return (uint32_t)k_canfd_count;
}

RA8_INTERNAL static uint64_t internal_canfd_offset(uint32_t inst, uint64_t addr)
{
  const uint64_t base = (inst == 0U) ? (uint64_t)k_canfd0_base : (uint64_t)k_canfd1_base;
  return addr - base;
}

RA8_INTERNAL static uint32_t internal_canfd_word(uint64_t off)
{
  return (uint32_t)(off >> 2U);
}

RA8_INTERNAL static void internal_canfd_apply_global_mode(canfd_inst_t* c, uint32_t gctr)
{
  uint32_t gsts = c->reg[internal_canfd_word((uint64_t)k_canfd_off_gsts)];
  gsts &= ~(uint32_t)(k_gsts_grststs | k_gsts_ghltsts | k_gsts_graminit);
  const uint32_t mode = gctr & (uint32_t)k_mode_mask;
  if (mode == (uint32_t)k_mode_reset) {
    gsts |= (uint32_t)k_gsts_grststs;
  } else if (mode == (uint32_t)k_mode_halt) {
    gsts |= (uint32_t)k_gsts_ghltsts;
  }
  c->reg[internal_canfd_word((uint64_t)k_canfd_off_gsts)] = gsts;
}

RA8_INTERNAL static void internal_canfd_apply_channel_mode(canfd_inst_t* c, uint32_t ctr)
{
  uint32_t sts = c->reg[internal_canfd_word((uint64_t)k_canfd_off_cnsts)];
  sts &= ~(uint32_t)(k_cnsts_crstst | k_cnsts_chltst);
  const uint32_t mode = ctr & (uint32_t)k_mode_mask;
  if (mode == (uint32_t)k_mode_reset) {
    sts |= (uint32_t)k_cnsts_crstst;
  } else if (mode == (uint32_t)k_mode_halt) {
    sts |= (uint32_t)k_cnsts_chltst;
  }
  c->reg[internal_canfd_word((uint64_t)k_canfd_off_cnsts)] = sts;
}

RA8_INTERNAL static bool internal_canfd_frame_accepted(const canfd_inst_t* c, uint32_t tx_id)
{
  bool any_active = false;
  for (uint32_t slot = 0U; slot < (uint32_t)k_canfd_afl_count; slot++) {
    const uint64_t ent =
      (uint64_t)k_canfd_off_afl + ((uint64_t)slot * (uint64_t)k_canfd_afl_stride);
    const uint32_t mask = c->reg[internal_canfd_word(ent + 4UL)] & (uint32_t)k_canfd_id_ext;
    if (mask == 0U) {
      continue; /* unprogrammed slot */
    }
    any_active               = true;
    const uint32_t accept_id = c->reg[internal_canfd_word(ent)] & (uint32_t)k_canfd_id_ext;
    if ((tx_id & mask) == (accept_id & mask)) {
      return true;
    }
  }
  return !any_active;
}

RA8_INTERNAL static void
internal_canfd_console_frame(uint32_t inst, uint32_t tx_id, uint32_t dlc, const char* outcome)
{
  enum : uint8_t {
    k_canfd_console_line_cap = 64U, 
  };
  char ln[k_canfd_console_line_cap];
  (void)snprintf(ln, sizeof(ln), "CANFD%u TX id=0x%X dlc=%u %s", inst, tx_id, dlc, outcome);
  board_console_push(k_board_console_ch_can, ln);
}

RA8_INTERNAL static void internal_canfd_loopback_deliver(uc_engine* uc, uint32_t inst)
{
  canfd_inst_t*  c     = &s_canfd[inst];
  const uint32_t tm    = internal_canfd_word((uint64_t)k_canfd_off_tm0);
  const uint32_t rf    = internal_canfd_word((uint64_t)k_canfd_off_rf0);
  const uint32_t tx_id = c->reg[tm] & (uint32_t)k_canfd_id_ext;
  const uint32_t ptr   = c->reg[tm + (uint32_t)k_canfd_ptr_word];
  const uint32_t dlc   = (ptr >> (uint32_t)k_canfd_ptr_dlc_shift) & (uint32_t)k_canfd_ptr_dlc_mask;
  /* The frame is transmitted regardless of the filter; mark TX complete.
   * CFDTMSTS[0] is a byte at a word-aligned offset, so its low byte carries
   * TMTRF = 10b ("transmission complete"). */
  c->reg[internal_canfd_word((uint64_t)k_canfd_off_tmsts0)] = (uint32_t)k_tmsts_done;
  if (!internal_canfd_frame_accepted(c, tx_id)) {
    if (board_periph_trace()) {
      (void)priv_emu_io_errf("  [trace] CANFD%u loopback: TX id=0x%X filtered (no AFL match)\n",
                             inst,
                             tx_id);
    }
    internal_canfd_console_frame(inst, tx_id, dlc, "filtered");
    return; /* filtered out: transmitted but not received */
  }
  for (uint32_t w = 0U; w < (uint32_t)k_canfd_frame_words; w++) {
    c->reg[rf + w] = c->reg[tm + w];
  }
  /* RX FIFO 0 now holds one frame: clear empty, raise the RX flag. */
  uint32_t rfsts = c->reg[internal_canfd_word((uint64_t)k_canfd_off_rfsts0)];
  rfsts &= ~(uint32_t)k_rfsts_empty;
  rfsts |= (uint32_t)k_rfsts_if;
  c->reg[internal_canfd_word((uint64_t)k_canfd_off_rfsts0)] = rfsts;
  c->loopbacks++;
  if (inst == 0U) {
    board_periph_icu_raise_event(uc, (uint16_t)k_event_can0_rxf);
  }
  if (board_periph_trace()) {
    (void)priv_emu_io_errf("  [trace] CANFD%u loopback: TX MB0 -> RX FIFO0 (id=0x%X)\n",
                           inst,
                           c->reg[rf] & (uint32_t)k_canfd_id_ext);
  }
  internal_canfd_console_frame(inst, tx_id, dlc, "-> RXF0");
}

RA8_INTERNAL static uint64_t internal_canfd_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint32_t inst = internal_canfd_instance(addr);
  if (inst >= (uint32_t)k_canfd_count) {
    return 0U;
  }
  const uint64_t off = internal_canfd_offset(inst, addr);
  if (off >= (uint64_t)k_canfd_span) {
    return 0U;
  }
  return s_canfd[inst].reg[internal_canfd_word(off)];
}

RA8_INTERNAL static void
internal_canfd_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)size;
  const uint32_t inst = internal_canfd_instance(addr);
  if (inst >= (uint32_t)k_canfd_count) {
    return;
  }
  const uint64_t off = internal_canfd_offset(inst, addr);
  if (off >= (uint64_t)k_canfd_span) {
    return;
  }
  canfd_inst_t* c = &s_canfd[inst];
  /* CFDTMC[0] is a byte register; a TMTR request triggers the loopback. */
  if (off == (uint64_t)k_canfd_off_tmc0) {
    c->reg[internal_canfd_word(off)] = (uint32_t)value;
    if (((uint8_t)value & (uint8_t)k_tmc_txreq) != 0U) {
      internal_canfd_loopback_deliver(uc, inst);
    }
    return;
  }
  /* Popping RX FIFO 0 (CFDRFPCTR write) returns it to the empty state. */
  if (off == (uint64_t)k_canfd_off_rfpctr0) {
    c->reg[internal_canfd_word(off)] = (uint32_t)value;
    uint32_t rfsts                   = c->reg[internal_canfd_word((uint64_t)k_canfd_off_rfsts0)];
    rfsts |= (uint32_t)k_rfsts_empty;
    rfsts &= ~(uint32_t)k_rfsts_if;
    c->reg[internal_canfd_word((uint64_t)k_canfd_off_rfsts0)] = rfsts;
    return;
  }
  c->reg[internal_canfd_word(off)] = (uint32_t)value;
  if (off == (uint64_t)k_canfd_off_gctr) {
    internal_canfd_apply_global_mode(c, (uint32_t)value);
  } else if (off == (uint64_t)k_canfd_off_cnctr) {
    internal_canfd_apply_channel_mode(c, (uint32_t)value);
  }
}

RA8_INTERNAL static void internal_canfd_reset(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_canfd_count; i++) {
    (void)memset(&s_canfd[i], 0, sizeof(s_canfd[i]));
    /* RX FIFO 0 powers up empty; GRAMINIT powers up already-clear (0). */
    s_canfd[i].reg[internal_canfd_word((uint64_t)k_canfd_off_rfsts0)] = (uint32_t)k_rfsts_empty;
  }
}

RA8_INTERNAL static void internal_canfd_report(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_canfd_count; i++) {
    if (s_canfd[i].loopbacks == 0U) {
      continue;
    }
    const uint32_t rf = internal_canfd_word((uint64_t)k_canfd_off_rf0);
    (void)priv_emu_io_errf("  CANFD%u        : loopback frames=%u last_rx_id=0x%03X\n",
                           i,
                           s_canfd[i].loopbacks,
                           s_canfd[i].reg[rf] & (uint32_t)k_canfd_id_std);
  }
}

static const board_periph_block_t s_k_canfd0_block = {
  .base   = (uint64_t)k_canfd0_base,
  .span   = (uint64_t)k_canfd_span,
  .order  = (uint32_t)k_block_order_i2c, /* After the timers/UART; no tick. */
  .read   = internal_canfd_read,
  .write  = internal_canfd_write,
  .tick   = nullptr,
  .reset  = internal_canfd_reset,
  .report = internal_canfd_report,
  .name   = "CANFD0",
};

static const board_periph_block_t s_k_canfd1_block = {
  .base   = (uint64_t)k_canfd1_base,
  .span   = (uint64_t)k_canfd_span,
  .order  = (uint32_t)k_block_order_i2c,
  .read   = internal_canfd_read,
  .write  = internal_canfd_write,
  .tick   = nullptr,
  .reset  = nullptr,
  .report = nullptr,
  .name   = "CANFD1",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_board_periph_canfd_register(void)
{
  board_periph_register_block(&s_k_canfd0_block);
  board_periph_register_block(&s_k_canfd1_block);
}