board_periph_poeg.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_poeg_base      = 0x40212000UL,  
  k_poeg_stride    = 0x100UL,       
  k_poeg_count     = 4UL,           
  k_poeg_span      = 0x100UL * 4UL, 
  k_poeg_off_poegg = 0x00UL,        
} poeg_geom_t;

typedef enum : uint32_t {
  k_poegg_pidf = 0x00000001UL, 
  k_poegg_iocf = 0x00000002UL, 
  k_poegg_ostp = 0x00000004UL, 
  k_poegg_ssf  = 0x00000008UL, 
  k_poegg_st   = 0x00010000UL, 
  k_poegg_trig = k_poegg_pidf | k_poegg_iocf | k_poegg_ostp | k_poegg_ssf,
} poegg_field_t;

typedef enum : uint32_t {
  k_poeg_block_order = 22U, 
} poeg_order_t;

typedef struct {
  uint32_t poegg[k_poeg_count]; 
  uint32_t asserts;             
  uint32_t clears;              
} poeg_state_t;
 
static poeg_state_t s_poeg;

RA8_INTERNAL static uint32_t internal_poeg_with_st(uint32_t writable)
{
  if ((writable & (uint32_t)k_poegg_trig) != 0U) {
    return writable | (uint32_t)k_poegg_st;
  }
  return writable & ~(uint32_t)k_poegg_st;
}

RA8_INTERNAL static void internal_poeg_reset(void)
{
  s_poeg = (poeg_state_t){};
}

RA8_INTERNAL static uint64_t internal_poeg_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint64_t off   = addr - (uint64_t)k_poeg_base;
  const uint64_t group = off / (uint64_t)k_poeg_stride;
  const uint64_t reg   = off % (uint64_t)k_poeg_stride;
  if (group >= (uint64_t)k_poeg_count) {
    return 0U;
  }
  if (reg == (uint64_t)k_poeg_off_poegg) {
    return s_poeg.poegg[group];
  }
  return 0U;
}

RA8_INTERNAL static void
internal_poeg_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)uc;
  (void)size;
  const uint64_t off   = addr - (uint64_t)k_poeg_base;
  const uint64_t group = off / (uint64_t)k_poeg_stride;
  const uint64_t reg   = off % (uint64_t)k_poeg_stride;
  if (group >= (uint64_t)k_poeg_count) {
    return;
  }
  if (reg != (uint64_t)k_poeg_off_poegg) {
    return;
  }
  /* ST is read-only: strip any incoming ST, then re-derive it from the
   * request flags so a software-stop assert / clear moves ST as hardware would. */
  const uint32_t writable = (uint32_t)value & ~(uint32_t)k_poegg_st;
  const uint32_t prev     = s_poeg.poegg[group];
  const uint32_t next     = internal_poeg_with_st(writable);
  s_poeg.poegg[group]     = next;
  if (((prev & (uint32_t)k_poegg_st) == 0U) && ((next & (uint32_t)k_poegg_st) != 0U)) {
    s_poeg.asserts++;
  }
  if (((prev & (uint32_t)k_poegg_st) != 0U) && ((next & (uint32_t)k_poegg_st) == 0U)) {
    s_poeg.clears++;
  }
}

RA8_INTERNAL static void internal_poeg_report(void)
{
  if ((s_poeg.asserts == 0U) && (s_poeg.clears == 0U)) {
    return; /* Untouched: stay quiet. */
  }
  (void)priv_emu_io_errf("  POEG          : shutoffs=%u re-enables=%u\n",
                         s_poeg.asserts,
                         s_poeg.clears);
}

static const board_periph_block_t s_k_poeg_block = {
  .base   = (uint64_t)k_poeg_base,
  .span   = (uint64_t)k_poeg_span,
  .order  = (uint32_t)k_poeg_block_order,
  .read   = internal_poeg_read,
  .write  = internal_poeg_write,
  .tick   = nullptr,
  .reset  = internal_poeg_reset,
  .report = internal_poeg_report,
  .name   = "POEG",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_poeg_block_register(void)
{
  board_periph_register_block(&s_k_poeg_block);
}