board_periph_ceu.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 : uint64_t {
  k_ceu_base      = 0x40348000UL,  
  k_ceu_span      = 0x100UL,       
  k_ceu_words     = 0x100UL / 4UL, 
  k_ceu_off_capsr = 0x00UL,        
  k_ceu_off_cmcyr = 0x0CUL,        
  k_ceu_off_capwr = 0x14UL,        
  k_ceu_off_cdwdr = 0x38UL,        
  k_ceu_off_cdayr = 0x3CUL,        
  k_ceu_off_cetcr = 0x74UL,        
  k_ceu_off_cstsr = 0x7CUL,        
  k_ceu_off_cdssr = 0x84UL,        
} ceu_map_t;

typedef enum : uint32_t {
  k_ceu_capsr_ce     = 0x00000001U, 
  k_ceu_capsr_cpkil  = 0x00010000U, 
  k_ceu_cetcr_cpe    = 0x00000001U, 
  k_ceu_cmcyr_hcyl   = 0x00003FFFU, 
  k_ceu_field_14bit  = 0x00003FFFU, 
  k_ceu_capwr_hwdth  = 0x00001FFFU, 
  k_ceu_field_12bit  = 0x00000FFFU, 
  k_ceu_pattern_mask = 0x000000FFU, 
} ceu_field_t;

typedef enum : uint32_t {
  k_ceu_shift_vert = 16U,   
  k_ceu_max_line   = 8192U, 
  k_ceu_max_lines  = 4096U, 
} ceu_bound_t;

typedef enum : uint32_t {
  k_ceu_console_line_cap = 56U, 
} ceu_console_t;

typedef struct {
  uint32_t reg[k_ceu_words]; 
  uint32_t frames;           
  uint32_t last_bytes;       
  uint32_t last_w;           
  uint32_t last_h;           
} ceu_state_t;
 
static ceu_state_t s_ceu;
static uint8_t     s_ceu_line[k_ceu_max_line]; 

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

RA8_INTERNAL static uint32_t internal_ceu_line_bytes(void)
{
  const uint32_t stride =
    s_ceu.reg[internal_ceu_word(k_ceu_off_cdwdr)] & (uint32_t)k_ceu_capwr_hwdth;
  if (stride != 0U) {
    return stride;
  }
  return s_ceu.reg[internal_ceu_word(k_ceu_off_cmcyr)] & (uint32_t)k_ceu_cmcyr_hcyl;
}

RA8_INTERNAL static uint32_t internal_ceu_line_count(void)
{
  const uint32_t vwdth =
    (s_ceu.reg[internal_ceu_word(k_ceu_off_capwr)] >> (uint32_t)k_ceu_shift_vert) &
    (uint32_t)k_ceu_field_12bit;
  if (vwdth != 0U) {
    return vwdth;
  }
  return (s_ceu.reg[internal_ceu_word(k_ceu_off_cmcyr)] >> (uint32_t)k_ceu_shift_vert) &
         (uint32_t)k_ceu_field_14bit;
}

RA8_INTERNAL static bool internal_ceu_do_capture(uc_engine* uc)
{
  uint32_t line_bytes = internal_ceu_line_bytes();
  uint32_t lines      = internal_ceu_line_count();
  if ((line_bytes == 0U) || (lines == 0U)) {
    return false; /* No geometry programmed -> no capture. */
  }
  if (line_bytes > (uint32_t)k_ceu_max_line) {
    line_bytes = (uint32_t)k_ceu_max_line;
  }
  if (lines > (uint32_t)k_ceu_max_lines) {
    lines = (uint32_t)k_ceu_max_lines;
  }
  const uint32_t dst = s_ceu.reg[internal_ceu_word(k_ceu_off_cdayr)];
  if (dst == 0U) {
    return false; /* No destination buffer -> no capture. */
  }
  for (uint32_t y = 0U; y < lines; y++) {
    for (uint32_t x = 0U; x < line_bytes; x++) {
      s_ceu_line[x] = (uint8_t)((x + y) & (uint32_t)k_ceu_pattern_mask);
    }
    (void)emu_mem_write(uc,
                        (uint64_t)dst + ((uint64_t)y * (uint64_t)line_bytes),
                        s_ceu_line,
                        (size_t)line_bytes);
  }
  const uint32_t total = line_bytes * lines;
  s_ceu.reg[internal_ceu_word(k_ceu_off_cetcr)] |= (uint32_t)k_ceu_cetcr_cpe;
  s_ceu.reg[internal_ceu_word(k_ceu_off_cdssr)] = total;
  s_ceu.reg[internal_ceu_word(k_ceu_off_capsr)] &= ~(uint32_t)k_ceu_capsr_ce;
  s_ceu.frames++;
  s_ceu.last_bytes = total;
  s_ceu.last_w     = line_bytes;
  s_ceu.last_h     = lines;
 
  char ln[k_ceu_console_line_cap];
  (void)snprintf(ln,
                 sizeof(ln),
                 "CEU frame %ux%u -> %u bytes",
                 (unsigned)line_bytes,
                 (unsigned)lines,
                 (unsigned)total);
  board_console_push(k_board_console_ch_dma, ln);
  if (board_periph_trace()) {
    (void)priv_emu_io_errf("  [trace] CEU capture %ux%u -> 0x%08X\n", line_bytes, lines, dst);
  }
  return true;
}

RA8_INTERNAL static uint64_t internal_ceu_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_ceu_base;
  if (off >= (uint64_t)k_ceu_span) {
    return 0U;
  }
  if (off == (uint64_t)k_ceu_off_cstsr) {
    return 0U; /* Capture is instantaneous: CPTON always reads idle. */
  }
  if (off == (uint64_t)k_ceu_off_capsr) {
    /* CPKIL self-clears (reset is instantaneous in the model). */
    return (uint64_t)(s_ceu.reg[internal_ceu_word(off)] & ~(uint32_t)k_ceu_capsr_cpkil);
  }
  return (uint64_t)s_ceu.reg[internal_ceu_word(off)];
}

RA8_INTERNAL static void
internal_ceu_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)size;
  const uint64_t off = addr - (uint64_t)k_ceu_base;
  if (off >= (uint64_t)k_ceu_span) {
    return;
  }
  s_ceu.reg[internal_ceu_word(off)] = (uint32_t)value;
  if (off != (uint64_t)k_ceu_off_capsr) {
    return;
  }
  if (((uint32_t)value & (uint32_t)k_ceu_capsr_cpkil) != 0U) {
    /* Software reset: drop pending events and CE; CPKIL self-clears. */
    s_ceu.reg[internal_ceu_word(k_ceu_off_cetcr)] = 0U;
    s_ceu.reg[internal_ceu_word(k_ceu_off_capsr)] =
      (uint32_t)value & ~((uint32_t)k_ceu_capsr_cpkil | (uint32_t)k_ceu_capsr_ce);
    return;
  }
  if (((uint32_t)value & (uint32_t)k_ceu_capsr_ce) != 0U) {
    (void)internal_ceu_do_capture(uc); /* Arm -> synthesise a frame + latch CETCR.CPE. */
  }
}

RA8_INTERNAL static void internal_ceu_reset(void)
{
  s_ceu = (ceu_state_t){};
}

RA8_INTERNAL static void internal_ceu_report(void)
{
  if (s_ceu.frames == 0U) {
    return;
  }
  (void)priv_emu_io_errf("  CEU           : frames=%u last=%ux%u (%u bytes) synth test-pattern\n",
                         s_ceu.frames,
                         s_ceu.last_w,
                         s_ceu.last_h,
                         s_ceu.last_bytes);
}

static const board_periph_block_t s_k_ceu_block = {
  .base   = (uint64_t)k_ceu_base,
  .span   = (uint64_t)k_ceu_span,
  .order  = (uint32_t)k_block_order_i2c, /* Synchronous on CAPSR.CE; no tick. */
  .read   = internal_ceu_read,
  .write  = internal_ceu_write,
  .tick   = nullptr,
  .reset  = internal_ceu_reset,
  .report = internal_ceu_report,
  .name   = "CEU",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_board_periph_ceu_register(void)
{
  board_periph_register_block(&s_k_ceu_block);
}