board_periph_ssie.c

Go to the documentation of this file.

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

typedef enum : uint32_t {
  k_ssie_console_line_cap = 48U, 
} ssie_console_t;

typedef enum : uint64_t {
  k_ssie_base   = 0x4025D000UL,  
  k_ssie_stride = 0x100UL,       
  k_ssie_count  = 2UL,           
  k_ssie_span   = 0x100UL * 2UL, 
  k_ssie_regs   = 0x40UL,        
} ssie_map_t;

typedef enum : uint64_t {
  k_ssie_off_ssicr   = 0x00UL, 
  k_ssie_off_ssisr   = 0x04UL, 
  k_ssie_off_ssifcr  = 0x10UL, 
  k_ssie_off_ssifsr  = 0x14UL, 
  k_ssie_off_ssiftdr = 0x18UL, 
  k_ssie_off_ssifrdr = 0x1CUL, 
} ssie_off_t;

typedef enum : uint32_t {
  k_ssie_ren_ten = 0x00000003U, 
  k_ssie_iirq    = 0x02000000U, 
  k_ssie_tde     = 0x00010000U, 
} ssie_field_t;

typedef enum : uint32_t {
  k_ssie_block_order = 130U, 
} ssie_order_t;

typedef struct {
  uint32_t reg[k_ssie_regs]; 
  uint32_t tx_samples;       
} ssie_state_t;
 
static ssie_state_t s_ssie[k_ssie_count];

RA8_INTERNAL static void internal_ssie_reset(void)
{
  for (uint32_t ch = 0U; ch < (uint32_t)k_ssie_count; ch++) {
    for (uint32_t i = 0U; i < (uint32_t)k_ssie_regs; i++) {
      s_ssie[ch].reg[i] = 0U;
    }
    s_ssie[ch].tx_samples = 0U;
  }
}

RA8_INTERNAL static uint64_t internal_ssie_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint32_t ch  = (uint32_t)((addr - (uint64_t)k_ssie_base) / (uint64_t)k_ssie_stride);
  const uint64_t off = (addr - (uint64_t)k_ssie_base) % (uint64_t)k_ssie_stride;
  if (ch >= (uint32_t)k_ssie_count) {
    return 0U;
  }
  const ssie_state_t* s = &s_ssie[ch];
  if (off == (uint64_t)k_ssie_off_ssisr) {
    /* IIRQ asserts while the channel is idle (REN and TEN both clear), so the
     * driver's "must be idle before enabling" gate in ra8_ssie_start passes. */
    const bool running = (s->reg[k_ssie_off_ssicr / 4U] & (uint32_t)k_ssie_ren_ten) != 0U;
    return running ? 0U : (uint64_t)k_ssie_iirq;
  }
  if (off == (uint64_t)k_ssie_off_ssifsr) {
    return (uint64_t)k_ssie_tde; /* TX FIFO always has room; RX empty. */
  }
  if (off == (uint64_t)k_ssie_off_ssifrdr) {
    return 0U; /* No RX audio source in the model. */
  }
  if ((off % 4UL) != 0UL) {
    return 0U;
  }
  const uint32_t idx = (uint32_t)(off / 4UL);
  return (idx < (uint32_t)k_ssie_regs) ? (uint64_t)s->reg[idx] : 0U;
}

RA8_INTERNAL static void
internal_ssie_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_ssie_base) / (uint64_t)k_ssie_stride);
  const uint64_t off = (addr - (uint64_t)k_ssie_base) % (uint64_t)k_ssie_stride;
  if (ch >= (uint32_t)k_ssie_count) {
    return;
  }
  ssie_state_t* s = &s_ssie[ch];
  if (off == (uint64_t)k_ssie_off_ssiftdr) {
    s->tx_samples++; /* Transmit FIFO drains immediately in the model. */
    return;
  }
  if ((off % 4UL) != 0UL) {
    return;
  }
  const uint32_t idx = (uint32_t)(off / 4UL);
  if (idx < (uint32_t)k_ssie_regs) {
    s->reg[idx] = (uint32_t)value;
  }
}

RA8_INTERNAL static void internal_ssie_report(void)
{
  for (uint32_t ch = 0U; ch < (uint32_t)k_ssie_count; ch++) {
    const uint32_t ssicr = s_ssie[ch].reg[k_ssie_off_ssicr / 4U];
    if ((ssicr == 0U) && (s_ssie[ch].tx_samples == 0U)) {
      continue; /* Untouched channel: stay quiet. */
    }
    /* Console I2S tab: per-channel TX-sample tally at end-of-run. I2S streams a
     * sample per SSIFTDR write (far too fast to log live), so the bounded
     * transfer summary is the whole-run tally -- the same shape spi_report uses. */
    char ln[k_ssie_console_line_cap];
    (void)snprintf(ln,
                   sizeof(ln),
                   "I2S ch%u tx_samples=%u",
                   (unsigned)ch,
                   (unsigned)s_ssie[ch].tx_samples);
    board_console_push(k_board_console_ch_i2s, ln);
    (void)priv_emu_io_errf("  SSIE%u         : TEN=%u REN=%u tx_samples=%u\n",
                           ch,
                           (unsigned)((ssicr >> 1) & 1U),
                           (unsigned)(ssicr & 1U),
                           s_ssie[ch].tx_samples);
  }
}

static const board_periph_block_t s_k_ssie_block = {
  .base   = (uint32_t)k_ssie_base,
  .span   = (uint32_t)k_ssie_span,
  .order  = (uint32_t)k_ssie_block_order,
  .read   = internal_ssie_read,
  .write  = internal_ssie_write,
  .tick   = nullptr,
  .reset  = internal_ssie_reset,
  .report = internal_ssie_report,
  .name   = "SSIE",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_ssie_block_register(void)
{
  board_periph_register_block(&s_k_ssie_block);
}