board_periph_bkup.c

Go to the documentation of this file.

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

typedef enum : uint64_t {
  k_bkup_base        = 0x4001EC40UL, 
  k_bkup_span        = 0x180UL,      
  k_bkup_off_vbtber  = 0x000UL,      
  k_bkup_off_vbtbkr0 = 0x0C0UL,      
  k_bkup_reg_count   = 128UL,        
} bkup_geom_t;

typedef enum : uint8_t {
  k_bkup_vbtber_mask_vbae = 0x08U, 
  k_bkup_vbtber_reset     = 0x08U, 
} bkup_vbtber_mask_t;

typedef enum : uint32_t {
  k_bkup_block_order = 175U, 
} bkup_order_t;

static uint8_t s_bkup_vbtbkr[k_bkup_reg_count];

typedef struct {
  uint8_t  vbtber;       
  uint32_t writes;       
  uint32_t dropped_prc1; 
  uint32_t dropped_vbae; 
} bkup_ctrl_t;
 
static bkup_ctrl_t s_bkup;

RA8_INTERNAL static void internal_bkup_reset(void)
{
  s_bkup = (bkup_ctrl_t){};
  /* HUM Ch 12.2.6 p 504 "Value after reset": VBAE = 1, so the access-enable
   * bit is already armed out of reset (confirmed by a J-Link read of a live
   * board). Modelling it as 0 would make a forgotten VBAE arm look fatal in
   * the emulator when on silicon it is harmless. */
  s_bkup.vbtber = (uint8_t)k_bkup_vbtber_reset;
  /* s_bkup_vbtbkr is intentionally NOT cleared: it is the reset-retained
   * domain that the survival demo depends on across a --reboot. */
}

RA8_INTERNAL static uint64_t internal_bkup_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  const uint64_t off = addr - (uint64_t)k_bkup_base;
  if (off == (uint64_t)k_bkup_off_vbtber) {
    return s_bkup.vbtber;
  }
  if (off >= (uint64_t)k_bkup_off_vbtbkr0) {
    const uint64_t idx = off - (uint64_t)k_bkup_off_vbtbkr0;
    uint64_t       v   = 0U;
    for (unsigned i = 0U; (i < size) && ((idx + (uint64_t)i) < (uint64_t)k_bkup_reg_count); ++i) {
      v |= (uint64_t)s_bkup_vbtbkr[idx + (uint64_t)i] << (8U * i);
    }
    return v;
  }
  return 0U;
}

RA8_INTERNAL static void
internal_bkup_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)uc;
  const uint64_t off = addr - (uint64_t)k_bkup_base;
  /* HUM Ch 13.1 Table 13.1 p 521 lists VBTBER and VBTBKRn (with the rest of
   * the VBATT file) under PRC1. Every write below is discarded while that
   * group is locked, with no fault and no flag -- the #131 silicon behaviour.
   * Nested-if (not &&) keeps each decision single-condition. */
  if (!priv_board_prcr_group_unlocked((uint16_t)k_board_prcr_grp1_lpm)) {
    if (off >= (uint64_t)k_bkup_off_vbtbkr0) {
      s_bkup.dropped_prc1++;
    }
    return;
  }
  if (off == (uint64_t)k_bkup_off_vbtber) {
    s_bkup.vbtber = (uint8_t)value;
    return;
  }
  if (off >= (uint64_t)k_bkup_off_vbtbkr0) {
    /* HUM Ch 12.2.6 "VBTBER : VBATT Backup Enable Register" p 504: "You must
     * write 1 to VBAE before accessing VBTBKR." Drop the write while VBAE = 0
     * so a cleared-VBAE bug surfaces here (rw=BAD) exactly as on silicon. */
    if ((s_bkup.vbtber & (uint8_t)k_bkup_vbtber_mask_vbae) == 0U) {
      s_bkup.dropped_vbae++;
      return;
    }
    const uint64_t idx = off - (uint64_t)k_bkup_off_vbtbkr0;
    for (unsigned i = 0U; (i < size) && ((idx + (uint64_t)i) < (uint64_t)k_bkup_reg_count); ++i) {
      s_bkup_vbtbkr[idx + (uint64_t)i] = (uint8_t)(value >> (8U * i));
    }
    s_bkup.writes++;
  }
}

RA8_INTERNAL static void internal_bkup_report(void)
{
  if (s_bkup.dropped_prc1 != 0U) {
    /* Loud: firmware wrote VBTBKRn without unlocking PRCR.PRC1 (#131). */
    (void)priv_emu_io_errf(
      "  VBATT-BKUP    : VBTBKRn writes=%u dropped=%u (PRCR.PRC1 locked: unlock 0xA502)\n",
      s_bkup.writes,
      s_bkup.dropped_prc1);
    return;
  }
  if (s_bkup.dropped_vbae != 0U) {
    /* Loud: firmware touched VBTBKRn after clearing VBTBER.VBAE. */
    (void)priv_emu_io_errf(
      "  VBATT-BKUP    : VBTBKRn writes=%u dropped=%u (VBAE=0: enable VBTBER.VBAE)\n",
      s_bkup.writes,
      s_bkup.dropped_vbae);
    return;
  }
  if (s_bkup.writes == 0U) {
    return; /* Untouched: stay quiet. */
  }
  (void)priv_emu_io_errf("  VBATT-BKUP    : VBTBKRn writes=%u (domain retained)\n", s_bkup.writes);
}

static const board_periph_block_t s_k_bkup_block = {
  .base   = (uint64_t)k_bkup_base,
  .span   = (uint64_t)k_bkup_span,
  .order  = (uint32_t)k_bkup_block_order,
  .read   = internal_bkup_read,
  .write  = internal_bkup_write,
  .tick   = nullptr,
  .reset  = internal_bkup_reset,
  .report = internal_bkup_report,
  .name   = "VBATT-BKUP",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_bkup_block_register(void)
{
  board_periph_register_block(&s_k_bkup_block);
}