board_periph_wdt.c

Go to the documentation of this file.

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

typedef enum : uint64_t {
  k_wdt_base       = 0x40202600UL, 
  k_wdt_span       = 0x10UL,       
  k_wdt_off_wdtrr  = 0x00UL,       
  k_wdt_off_wdtcr  = 0x02UL,       
  k_wdt_off_wdtsr  = 0x04UL,       
  k_wdt_off_wdtrcr = 0x06UL,       
} wdt_geom_t;

typedef enum : uint32_t {
  k_wdt_refresh_a   = 0x00U,   
  k_wdt_refresh_b   = 0xFFU,   
  k_wdt_rcr_rstirqs = 0x80U,   
  k_wdt_sr_cntval   = 0x3FFFU, 
  k_wdt_sr_undff    = 0x4000U, 
  /* Emulation timeout in run-loop chunks. The demo refreshes about every 50
   * chunks; this is comfortably longer (so a refreshing app never trips) yet
   * well within the run budget once refreshing stops. */
  k_wdt_timeout_ticks = 400U, 
} wdt_field_t;

typedef enum : uint32_t {
  k_wdt_block_order = 180U, 
} wdt_order_t;

typedef struct {
  uint16_t wdtcr;     
  uint8_t  wdtrcr;    
  uint8_t  last_rr;   
  bool     armed;     
  bool     fired;     
  uint32_t counter;   
  uint16_t undff;     
  uint32_t refreshes; 
} wdt_state_t;
 
static wdt_state_t s_wdt;

RA8_INTERNAL static void internal_wdt_tick(uc_engine* uc)
{
  (void)uc;
  if (!s_wdt.armed || s_wdt.fired) {
    return;
  }
  if (s_wdt.counter > 0U) {
    s_wdt.counter--;
    return;
  }
  /* Underflow. Latch UNDFF; if configured for reset, request a warm reboot with
   * the watchdog-reset cause and disarm so it fires exactly once. */
  s_wdt.undff = (uint16_t)k_wdt_sr_undff;
  if ((s_wdt.wdtrcr & (uint8_t)k_wdt_rcr_rstirqs) != 0U) {
    s_wdt.fired = true;
    s_wdt.armed = false;
    board_periph_reset_request_reboot(true, false);
  }
}

RA8_INTERNAL static void internal_wdt_reset(void)
{
  s_wdt = (wdt_state_t){};
}

RA8_INTERNAL static uint64_t internal_wdt_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_wdt_base;
  if (off == (uint64_t)k_wdt_off_wdtcr) {
    return s_wdt.wdtcr;
  }
  if (off == (uint64_t)k_wdt_off_wdtsr) {
    const uint16_t cnt = (uint16_t)(s_wdt.counter & (uint32_t)k_wdt_sr_cntval);
    return (uint64_t)(cnt | s_wdt.undff);
  }
  if (off == (uint64_t)k_wdt_off_wdtrcr) {
    return s_wdt.wdtrcr;
  }
  return 0U;
}

RA8_INTERNAL static void
internal_wdt_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)uc;
  (void)size;
  const uint64_t off = addr - (uint64_t)k_wdt_base;
  if (off == (uint64_t)k_wdt_off_wdtrr) {
    const uint8_t b = (uint8_t)value;
    /* The 0x00 then 0xFF sequence refreshes: arm (first time) and reload. */
    if ((s_wdt.last_rr == (uint8_t)k_wdt_refresh_a) && (b == (uint8_t)k_wdt_refresh_b)) {
      s_wdt.armed   = true;
      s_wdt.counter = (uint32_t)k_wdt_timeout_ticks;
      s_wdt.undff   = 0U;
      s_wdt.refreshes++;
    }
    s_wdt.last_rr = b;
  } else if (off == (uint64_t)k_wdt_off_wdtcr) {
    s_wdt.wdtcr = (uint16_t)value;
  } else if (off == (uint64_t)k_wdt_off_wdtrcr) {
    s_wdt.wdtrcr = (uint8_t)value;
  }
}

RA8_INTERNAL static void internal_wdt_report(void)
{
  if ((s_wdt.refreshes == 0U) && !s_wdt.fired) {
    return; /* Untouched: stay quiet. */
  }
  (void)priv_emu_io_errf("  WDT0          : refreshes=%u armed=%u reset_fired=%u\n",
                         s_wdt.refreshes,
                         (unsigned)s_wdt.armed,
                         (unsigned)s_wdt.fired);
}

static const board_periph_block_t s_k_wdt_block = {
  .base   = (uint64_t)k_wdt_base,
  .span   = (uint64_t)k_wdt_span,
  .order  = (uint32_t)k_wdt_block_order,
  .read   = internal_wdt_read,
  .write  = internal_wdt_write,
  .tick   = internal_wdt_tick,
  .reset  = internal_wdt_reset,
  .report = internal_wdt_report,
  .name   = "WDT0",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_wdt_block_register(void)
{
  board_periph_register_block(&s_k_wdt_block);
}