board_periph_spi.c

Go to the documentation of this file.

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

typedef enum : uint64_t {
  k_spi_base      = 0x4035C000UL,  
  k_spi_stride    = 0x100UL,       
  k_spi_count     = 2UL,           
  k_spi_span      = 0x100UL * 2UL, 
  k_spi_off_spdr  = 0x00UL,        
  k_spi_off_spcr  = 0x08UL,        
  k_spi_off_spcr2 = 0x0CUL,        
  k_spi_off_spsr  = 0x50UL,        
  k_spi_off_spsrc = 0x68UL,        
  k_spi_reg_words = 0x70UL / 4UL,  
} spi_map_t;

typedef enum : uint32_t {
  k_spi_spcr_spe = 0x00000001U, 
} spi_spcr_bit_t;

typedef enum : uint32_t {
  k_spi_spcr2_splp  = 0x00010000U, 
  k_spi_spcr2_splp2 = 0x00020000U, 
} spi_spcr2_bit_t;

typedef enum : uint32_t {
  k_spi_spsr_spdrf = 0x00800000U, 
  k_spi_spsr_sptef = 0x20000000U, 
  k_spi_spsr_cendf = 0x40000000U, 
  k_spi_spsr_sprf  = 0x80000000U, 
} spi_spsr_bit_t;

typedef enum : uint32_t {
  k_spi_byte_mask = 0xFFU, 
} spi_data_t;

typedef enum : uint32_t {
  k_spi_console_line_cap = 64U, 
} spi_console_dim_t;

typedef struct {
  uint32_t reg[k_spi_reg_words]; 
  uint32_t spsr;                 
  uint32_t rx;                   
  bool     enabled;              
  bool     loopback;             
  uint32_t frames;               
} spi_state_t;

static spi_state_t s_spi[k_spi_count];
 
/* =============================================================================
 * SPI_B controller model -- the single-frame echo the ra8_spi_b.c polling
 * driver clocks through SPDR / SPSR / SPSRC under internal loopback.
 * =============================================================================
 */

RA8_INTERNAL static uint32_t internal_spi_word(uint64_t off)
{
  return (uint32_t)(off / 4U);
}

RA8_INTERNAL static void internal_spi_spcr_write(spi_state_t* s, uint32_t value)
{
  s->enabled = ((value & (uint32_t)k_spi_spcr_spe) != 0U);
  if (s->enabled) {
    /* Running: the model drains TX instantly, so SPTEF is always ready for
     * the first frame; SPRF stays clear until a word is written. */
    s->spsr |= (uint32_t)k_spi_spsr_sptef;
    s->spsr &= ~(uint32_t)k_spi_spsr_sprf;
  } else {
    s->spsr = 0U;
  }
}

RA8_INTERNAL static void internal_spi_spcr2_write(spi_state_t* s, uint32_t value)
{
  s->loopback = ((value & ((uint32_t)k_spi_spcr2_splp | (uint32_t)k_spi_spcr2_splp2)) != 0U);
}

RA8_INTERNAL static void internal_spi_spdr_write(spi_state_t* s, uint32_t value)
{
  /* SPLP2 ties the outgoing line back to the receive shifter (rx = tx);
   * SPLP inverts it (rx = ~tx). Without loopback, if a `--sd` card is
   * attached it answers the exchange (the genuine ra8_sdmmc_spi path); an
   * `--eink` IT8951 controller answers the ra8_epaper path; else nothing
   * drives the line and the receive shifter clocks in an idle 0. */
  if ((s->reg[internal_spi_word((uint64_t)k_spi_off_spcr2)] & (uint32_t)k_spi_spcr2_splp) != 0U) {
    s->rx = (~value) & (uint32_t)k_spi_byte_mask;
  } else if (s->loopback) {
    s->rx = value;
  } else if (board_sd_attached()) {
    s->rx = (uint32_t)board_sd_exchange((uint8_t)(value & (uint32_t)k_spi_byte_mask));
  } else if (board_eink_attached()) {
    s->rx = (uint32_t)board_eink_exchange((uint8_t)(value & (uint32_t)k_spi_byte_mask));
  } else {
    s->rx = 0U;
  }
  /* TX drains immediately (SPTEF stays ready) and the echoed word lands in
   * the receive holding register, so SPRF asserts for the driver's RX poll. */
  s->spsr |= ((uint32_t)k_spi_spsr_sptef | (uint32_t)k_spi_spsr_sprf | (uint32_t)k_spi_spsr_spdrf);
  s->frames++;
}

RA8_INTERNAL static void internal_spi_spsrc_write(spi_state_t* s, uint32_t value)
{
  /* Every SPSRC clear bit sits at the same position as its SPSR flag, so a
   * written 1 clears that flag; SPTEF is re-asserted because the model's TX
   * buffer is always empty once the channel runs. */
  s->spsr &= ~value;
  if (s->enabled) {
    s->spsr |= (uint32_t)k_spi_spsr_sptef;
  }
}

RA8_INTERNAL static uint64_t internal_spi_reg_read(spi_state_t* s, uint64_t off)
{
  if (off == (uint64_t)k_spi_off_spsr) {
    return s->spsr;
  }
  if (off == (uint64_t)k_spi_off_spdr) {
    return s->rx; /* receive holding register: the echoed frame */
  }
  return s->reg[internal_spi_word(off)]; /* reflect every other register */
}

RA8_INTERNAL static void internal_spi_reg_write(spi_state_t* s, uint64_t off, uint32_t value)
{
  s->reg[internal_spi_word(off)] = value; /* shadow keeps "configure then verify" working */
  if (off == (uint64_t)k_spi_off_spcr) {
    internal_spi_spcr_write(s, value);
  } else if (off == (uint64_t)k_spi_off_spcr2) {
    internal_spi_spcr2_write(s, value);
  } else if (off == (uint64_t)k_spi_off_spdr) {
    internal_spi_spdr_write(s, value);
  } else if (off == (uint64_t)k_spi_off_spsrc) {
    internal_spi_spsrc_write(s, value);
  }
}

RA8_INTERNAL static uint64_t internal_spi_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint32_t ch  = (uint32_t)((addr - (uint64_t)k_spi_base) / (uint64_t)k_spi_stride);
  const uint64_t off = (addr - (uint64_t)k_spi_base) % (uint64_t)k_spi_stride;
  return internal_spi_reg_read(&s_spi[ch], off);
}

RA8_INTERNAL static void
internal_spi_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)uc;
  (void)size;
  const uint32_t ch  = (uint32_t)((addr - (uint64_t)k_spi_base) / (uint64_t)k_spi_stride);
  const uint64_t off = (addr - (uint64_t)k_spi_base) % (uint64_t)k_spi_stride;
  internal_spi_reg_write(&s_spi[ch], off, (uint32_t)value);
}

RA8_INTERNAL static void internal_spi_reset(void)
{
  for (uint32_t i = 0U; i < (uint32_t)k_spi_count; i++) {
    s_spi[i] = (spi_state_t){};
  }
  board_sd_reset();   /* clear any attached SD card's command framing   */
  board_eink_reset(); /* clear any attached IT8951 controller's framing */
}

RA8_INTERNAL static void internal_spi_report(void)
{
  for (uint32_t ch = 0U; ch < (uint32_t)k_spi_count; ch++) {
    if (s_spi[ch].frames > 0U) {
      (void)priv_emu_io_errf("  SPI%u          : %u frame(s) echoed (loopback=%s)\n",
                             ch,
                             s_spi[ch].frames,
                             s_spi[ch].loopback ? "yes" : "no");
      char ln[k_spi_console_line_cap];
      (void)snprintf(ln,
                     sizeof(ln),
                     "SPI%u: %u frames lb=%s",
                     ch,
                     s_spi[ch].frames,
                     s_spi[ch].loopback ? "on" : "off");
      board_console_push(k_board_console_ch_spi, ln);
    }
  }
  board_eink_report(); /* an attached IT8951 controller prints its own line */
}

static const board_periph_block_t s_k_spi_block = {
  .base   = (uint64_t)k_spi_base,
  .span   = (uint64_t)k_spi_span,
  .order  = (uint32_t)k_block_order_sci,
  .read   = internal_spi_read,
  .write  = internal_spi_write,
  .tick   = nullptr,
  .reset  = internal_spi_reset,
  .report = internal_spi_report,
  .name   = "SPI_B",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_board_periph_spi_register(void)
{
  board_periph_register_block(&s_k_spi_block);
}