board_periph_cac.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 : uint64_t {
  k_cac_base        = 0x40202400UL, 
  k_cac_span        = 0x10UL,       
  k_cac_off_cacr0   = 0x00UL,       
  k_cac_off_caicr   = 0x03UL,       
  k_cac_off_castr   = 0x04UL,       
  k_cac_off_caulvr  = 0x06UL,       
  k_cac_off_callvr  = 0x08UL,       
  k_cac_off_cacntbr = 0x0AUL,       
} cac_geom_t;

typedef enum : uint8_t {
  k_cac_cacr0_cfme    = 0x01U, 
  k_cac_castr_ferrf   = 0x01U, 
  k_cac_castr_mendf   = 0x02U, 
  k_cac_castr_ovff    = 0x04U, 
  k_cac_caicr_ferrfcl = 0x10U, 
  k_cac_caicr_mendfcl = 0x20U, 
  k_cac_caicr_ovffcl  = 0x40U, 
} cac_field_t;

typedef enum : uint32_t {
  k_cac_block_order = 165U, 
} cac_order_t;

typedef struct {
  uint8_t  cacr0;   
  uint8_t  castr;   
  uint16_t caulvr;  
  uint16_t callvr;  
  uint16_t cacntbr; 
  uint32_t meas;    
} cac_state_t;
 
static cac_state_t s_cac;

RA8_INTERNAL static void internal_cac_measure(void)
{
  /* Report the midpoint of the firmware's programmed window: in-band by
   * construction, so FERRF stays clear and the measurement reads healthy. */
  s_cac.cacntbr = (uint16_t)(((uint32_t)s_cac.callvr + (uint32_t)s_cac.caulvr) / 2U);
  s_cac.castr   = (uint8_t)k_cac_castr_mendf; /* MENDF set; FERRF / OVFF clear. */
  s_cac.meas++;
}

RA8_INTERNAL static void internal_cac_reset(void)
{
  s_cac = (cac_state_t){};
}

RA8_INTERNAL static uint64_t internal_cac_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_cac_base;
  if (off == (uint64_t)k_cac_off_cacr0) {
    return s_cac.cacr0;
  }
  if (off == (uint64_t)k_cac_off_castr) {
    return s_cac.castr;
  }
  if (off == (uint64_t)k_cac_off_caulvr) {
    return s_cac.caulvr;
  }
  if (off == (uint64_t)k_cac_off_callvr) {
    return s_cac.callvr;
  }
  if (off == (uint64_t)k_cac_off_cacntbr) {
    return s_cac.cacntbr;
  }
  return 0U;
}

RA8_INTERNAL static void
internal_cac_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_cac_base;
  if (off == (uint64_t)k_cac_off_cacr0) {
    s_cac.cacr0 = (uint8_t)value;
    if (((uint8_t)value & (uint8_t)k_cac_cacr0_cfme) != 0U) {
      internal_cac_measure(); /* CFME=1 starts a measurement; it completes at once. */
    }
  } else if (off == (uint64_t)k_cac_off_caicr) {
    /* CAICR clear bits are write-1-to-clear of the matching CASTR flags. */
    if (((uint8_t)value & (uint8_t)k_cac_caicr_ferrfcl) != 0U) {
      s_cac.castr &= (uint8_t)~(uint8_t)k_cac_castr_ferrf;
    }
    if (((uint8_t)value & (uint8_t)k_cac_caicr_mendfcl) != 0U) {
      s_cac.castr &= (uint8_t)~(uint8_t)k_cac_castr_mendf;
    }
    if (((uint8_t)value & (uint8_t)k_cac_caicr_ovffcl) != 0U) {
      s_cac.castr &= (uint8_t)~(uint8_t)k_cac_castr_ovff;
    }
  } else if (off == (uint64_t)k_cac_off_caulvr) {
    s_cac.caulvr = (uint16_t)value;
  } else if (off == (uint64_t)k_cac_off_callvr) {
    s_cac.callvr = (uint16_t)value;
  }
}

RA8_INTERNAL static void internal_cac_report(void)
{
  if (s_cac.meas == 0U) {
    return; /* Untouched: stay quiet. */
  }
  (void)priv_emu_io_errf("  CAC           : measurements=%u count=%u window=[%u,%u]\n",
                         s_cac.meas,
                         (unsigned)s_cac.cacntbr,
                         (unsigned)s_cac.callvr,
                         (unsigned)s_cac.caulvr);
}

static const board_periph_block_t s_k_cac_block = {
  .base   = (uint64_t)k_cac_base,
  .span   = (uint64_t)k_cac_span,
  .order  = (uint32_t)k_cac_block_order,
  .read   = internal_cac_read,
  .write  = internal_cac_write,
  .tick   = nullptr,
  .reset  = internal_cac_reset,
  .report = internal_cac_report,
  .name   = "CAC",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_cac_block_register(void)
{
  board_periph_register_block(&s_k_cac_block);
}