board_periph_doc.c

Go to the documentation of this file.

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

typedef enum : uint32_t {
  k_u32_all  = 0xFFFFFFFFU, 
  k_u16_full = 0x0000FFFFU, 
} doc_lit_t;

typedef enum : uint64_t {
  k_doc_base       = 0x40311000UL, 
  k_doc_span       = 0x20UL,       
  k_doc_off_docr   = 0x00UL,       
  k_doc_off_dosr   = 0x04UL,       
  k_doc_off_doscr  = 0x08UL,       
  k_doc_off_dodir  = 0x0CUL,       
  k_doc_off_dodsr0 = 0x10UL,       
  k_doc_off_dodsr1 = 0x14UL,       
} doc_map_t;

typedef enum : uint32_t {
  k_doc_oms_mask    = 0x03U, 
  k_doc_dobw_mask   = 0x08U, 
  k_doc_dcsel_mask  = 0x70U, 
  k_doc_dcsel_shift = 4U,    
  k_doc_dopcf       = 0x01U, 
} doc_field_t;

typedef enum : uint32_t {
  k_doc_mode_compare  = 0U, 
  k_doc_mode_add      = 1U, 
  k_doc_mode_subtract = 2U, 
} doc_mode_t;

typedef enum : uint32_t {
  k_doc_block_order = 141U, 
} doc_order_t;

typedef struct {
  uint8_t  docr;   
  uint8_t  dopcf;  
  uint32_t dodsr0; 
  uint32_t dodsr1; 
  uint32_t ops;    
} doc_state_t;
 
static doc_state_t s_doc;

RA8_INTERNAL static uint32_t internal_doc_width_mask(void)
{
  return ((s_doc.docr & (uint8_t)k_doc_dobw_mask) != 0U) ? (uint32_t)k_u32_all
                                                         : (uint32_t)k_u16_full;
}

RA8_INTERNAL static void internal_doc_apply(uint32_t dodir)
{
  const uint32_t mode = (uint32_t)(s_doc.docr & (uint8_t)k_doc_oms_mask);
  const uint32_t mask = internal_doc_width_mask();
  const uint32_t in   = dodir & mask;
  const uint32_t cur  = s_doc.dodsr0 & mask;
  if (mode == (uint32_t)k_doc_mode_add) {
    const uint32_t sum = cur + in;
    s_doc.dopcf        = ((sum & ~mask) != 0U) ? (uint8_t)k_doc_dopcf : s_doc.dopcf;
    s_doc.dodsr0       = sum & mask;
  } else if (mode == (uint32_t)k_doc_mode_subtract) {
    s_doc.dopcf  = (in > cur) ? (uint8_t)k_doc_dopcf : s_doc.dopcf; /* borrow */
    s_doc.dodsr0 = (cur - in) & mask;
  } else {
    /* Compare: DCSEL selects the relation that latches DOPCF. DCSEL=1 matches
     * on equality; everything else (including 0) latches on mismatch. */
    const uint32_t dcsel =
      (uint32_t)((s_doc.docr & (uint8_t)k_doc_dcsel_mask) >> (uint32_t)k_doc_dcsel_shift);
    const bool equal = (in == cur);
    const bool hit   = (dcsel == 1U) ? equal : !equal;
    if (hit) {
      s_doc.dopcf = (uint8_t)k_doc_dopcf;
    }
  }
  s_doc.ops++;
}

RA8_INTERNAL static void internal_doc_reset(void)
{
  s_doc.docr   = 0U;
  s_doc.dopcf  = 0U;
  s_doc.dodsr0 = 0U;
  s_doc.dodsr1 = 0U;
  s_doc.ops    = 0U;
}

RA8_INTERNAL static uint64_t internal_doc_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_doc_base;
  if (off == (uint64_t)k_doc_off_docr) {
    return s_doc.docr;
  }
  if (off == (uint64_t)k_doc_off_dosr) {
    return s_doc.dopcf;
  }
  if (off == (uint64_t)k_doc_off_dodsr0) {
    return s_doc.dodsr0;
  }
  if (off == (uint64_t)k_doc_off_dodsr1) {
    return s_doc.dodsr1;
  }
  return 0U;
}

RA8_INTERNAL static void
internal_doc_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_doc_base;
  if (off == (uint64_t)k_doc_off_docr) {
    s_doc.docr = (uint8_t)value;
  } else if (off == (uint64_t)k_doc_off_doscr) {
    if (((uint8_t)value & (uint8_t)k_doc_dopcf) != 0U) {
      s_doc.dopcf = 0U; /* DOPCFCL clears the flag. */
    }
  } else if (off == (uint64_t)k_doc_off_dodir) {
    internal_doc_apply((uint32_t)value);
  } else if (off == (uint64_t)k_doc_off_dodsr0) {
    s_doc.dodsr0 = (uint32_t)value; /* Seed operand A. */
  } else if (off == (uint64_t)k_doc_off_dodsr1) {
    s_doc.dodsr1 = (uint32_t)value;
  }
}

RA8_INTERNAL static void internal_doc_report(void)
{
  if (s_doc.ops == 0U) {
    return; /* Untouched: stay quiet. */
  }
  (void)priv_emu_io_errf("  DOC           : OMS=%u DODSR0=0x%08X DOPCF=%u ops=%u\n",
                         (unsigned)(s_doc.docr & (uint8_t)k_doc_oms_mask),
                         s_doc.dodsr0,
                         (unsigned)s_doc.dopcf,
                         s_doc.ops);
}

static const board_periph_block_t s_k_doc_block = {
  .base   = (uint32_t)k_doc_base,
  .span   = (uint32_t)k_doc_span,
  .order  = (uint32_t)k_doc_block_order,
  .read   = internal_doc_read,
  .write  = internal_doc_write,
  .tick   = nullptr,
  .reset  = internal_doc_reset,
  .report = internal_doc_report,
  .name   = "DOC",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_doc_block_register(void)
{
  board_periph_register_block(&s_k_doc_block);
}