board_periph_rtc.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_bcd_base    = 10U,   
  k_bcd_shift   = 4U,    
  k_nibble_mask = 0x0FU, 
  k_year_mod    = 100U,  
  k_year_base   = 2000U, 
} rtc_lit_t;

typedef enum : uint32_t {
  k_rtc_block_order = 60U, 
} rtc_order_t;

typedef enum : uint64_t {
  k_rtc_base = 0x40202000UL, 
  k_rtc_span = 0x80UL,       
} rtc_geom_t;

typedef enum : uint64_t {
  k_rtc_off_r64cnt  = 0x00UL, 
  k_rtc_off_rseccnt = 0x02UL, 
  k_rtc_off_rmincnt = 0x04UL, 
  k_rtc_off_rhrcnt  = 0x06UL, 
  k_rtc_off_rwkcnt  = 0x08UL, 
  k_rtc_off_rdaycnt = 0x0AUL, 
  k_rtc_off_rmoncnt = 0x0CUL, 
  k_rtc_off_ryrcnt  = 0x0EUL, 
  k_rtc_off_rsecar  = 0x10UL, 
  k_rtc_off_rminar  = 0x12UL, 
  k_rtc_off_rhrar   = 0x14UL, 
  k_rtc_off_rwkar   = 0x16UL, 
  k_rtc_off_rdayar  = 0x18UL, 
  k_rtc_off_rmonar  = 0x1AUL, 
  k_rtc_off_ryrar   = 0x1CUL, 
  k_rtc_off_ryraren = 0x1EUL, 
  k_rtc_off_rcr1    = 0x22UL, 
  k_rtc_off_rcr2    = 0x24UL, 
  k_rtc_off_rcr4    = 0x28UL, 
} rtc_off_t;

typedef enum : uint8_t {
  k_rtc_rcr1_aie   = 0x01U, 
  k_rtc_rcr1_pie   = 0x04U, 
  k_rtc_rcr2_start = 0x01U, 
  k_rtc_alarm_enb  = 0x80U, 
  k_rtc_alarm_val  = 0x7FU, 
} rtc_bit_t;

typedef enum : uint32_t {
  k_rtc_secs_per_min  = 60U, 
  k_rtc_mins_per_hour = 60U, 
  k_rtc_hours_per_day = 24U, 
  k_rtc_days_per_mon  = 28U, 
  k_rtc_mons_per_year = 12U, 
  k_rtc_ticks_per_sec = 8U,  
} rtc_calendar_t;

typedef enum : uint8_t {
  k_rtc_r64_mask = 0x3FU, 
} rtc_r64_t;

typedef enum : uint16_t {
  k_rtc_event_alarm    = 0x0BBU, 
  k_rtc_event_periodic = 0x0BCU, 
} rtc_event_t;

typedef struct {
  uint8_t  reg[k_rtc_span]; 
  uint8_t  sec;             
  uint8_t  min;             
  uint8_t  hour;            
  uint8_t  day;             
  uint8_t  mon;             
  uint16_t year;            
  uint8_t  r64;             
  uint32_t tick_frac;       
  uint32_t alarms;          
  uint32_t periodics;       
} rtc_state_t;
 
static rtc_state_t s_rtc;
 
/* =============================================================================
 * BCD helpers + the binary <-> BCD calendar reflection.
 * =============================================================================
 */

RA8_INTERNAL static uint8_t internal_rtc_bin_to_bcd(uint8_t bin)
{
  return (uint8_t)(((uint8_t)(bin / (uint8_t)k_bcd_base) << (uint8_t)k_bcd_shift) |
                   (uint8_t)(bin % (uint8_t)k_bcd_base));
}

RA8_INTERNAL static uint8_t internal_rtc_bcd_to_bin(uint8_t bcd)
{
  return (uint8_t)(((uint8_t)((bcd >> (uint8_t)k_bcd_shift) & (uint8_t)k_nibble_mask) *
                    (uint8_t)k_bcd_base) +
                   (uint8_t)(bcd & (uint8_t)k_nibble_mask));
}

RA8_INTERNAL static void internal_rtc_publish_calendar(void)
{
  s_rtc.reg[(uint64_t)k_rtc_off_r64cnt]  = (uint8_t)(s_rtc.r64 & (uint8_t)k_rtc_r64_mask);
  s_rtc.reg[(uint64_t)k_rtc_off_rseccnt] = internal_rtc_bin_to_bcd(s_rtc.sec);
  s_rtc.reg[(uint64_t)k_rtc_off_rmincnt] = internal_rtc_bin_to_bcd(s_rtc.min);
  s_rtc.reg[(uint64_t)k_rtc_off_rhrcnt]  = internal_rtc_bin_to_bcd(s_rtc.hour);
  s_rtc.reg[(uint64_t)k_rtc_off_rdaycnt] = internal_rtc_bin_to_bcd(s_rtc.day);
  s_rtc.reg[(uint64_t)k_rtc_off_rmoncnt] = internal_rtc_bin_to_bcd(s_rtc.mon);
  s_rtc.reg[(uint64_t)k_rtc_off_ryrcnt] =
    internal_rtc_bin_to_bcd((uint8_t)(s_rtc.year % (uint32_t)k_year_mod));
}

RA8_INTERNAL static void internal_rtc_latch_calendar(void)
{
  s_rtc.sec  = internal_rtc_bcd_to_bin(s_rtc.reg[(uint64_t)k_rtc_off_rseccnt]);
  s_rtc.min  = internal_rtc_bcd_to_bin(s_rtc.reg[(uint64_t)k_rtc_off_rmincnt]);
  s_rtc.hour = internal_rtc_bcd_to_bin(s_rtc.reg[(uint64_t)k_rtc_off_rhrcnt]);
  s_rtc.day  = internal_rtc_bcd_to_bin(s_rtc.reg[(uint64_t)k_rtc_off_rdaycnt]);
  s_rtc.mon  = internal_rtc_bcd_to_bin(s_rtc.reg[(uint64_t)k_rtc_off_rmoncnt]);
  s_rtc.year = (uint16_t)internal_rtc_bcd_to_bin(s_rtc.reg[(uint64_t)k_rtc_off_ryrcnt]);
}
 
/* =============================================================================
 * MMIO read / write.
 * =============================================================================
 */

RA8_INTERNAL static uint64_t internal_rtc_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  const uint64_t off = addr - (uint64_t)k_rtc_base;
  uint64_t       v   = 0U;
  for (unsigned i = 0U; i < size; i++) {
    const uint64_t b = off + (uint64_t)i;
    if (b < (uint64_t)k_rtc_span) {
      v |= (uint64_t)s_rtc.reg[b] << (8U * i);
    }
  }
  return v;
}

RA8_INTERNAL static bool internal_rtc_is_calendar_off(uint64_t off)
{
  return (off == (uint64_t)k_rtc_off_rseccnt) || (off == (uint64_t)k_rtc_off_rmincnt) ||
         (off == (uint64_t)k_rtc_off_rhrcnt) || (off == (uint64_t)k_rtc_off_rdaycnt) ||
         (off == (uint64_t)k_rtc_off_rmoncnt) || (off == (uint64_t)k_rtc_off_ryrcnt);
}

RA8_INTERNAL static void
internal_rtc_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)uc;
  const uint64_t off         = addr - (uint64_t)k_rtc_base;
  bool           touched_cal = false;
  for (unsigned i = 0U; i < size; i++) {
    const uint64_t b = off + (uint64_t)i;
    if (b >= (uint64_t)k_rtc_span) {
      continue;
    }
    s_rtc.reg[b] = (uint8_t)(value >> (8U * i));
    if (internal_rtc_is_calendar_off(b)) {
      touched_cal = true;
    }
  }
  /* A calendar-count write (ra8_rtc_set, performed with START cleared) reseeds
   * the running time mirror so the clock continues from the new value. */
  if (touched_cal) {
    internal_rtc_latch_calendar();
  }
}
 
/* =============================================================================
 * Per-tick time advance + alarm / periodic event raising.
 * =============================================================================
 */

RA8_INTERNAL static void internal_rtc_advance_one_second(void)
{
  s_rtc.sec++;
  if (s_rtc.sec < (uint8_t)k_rtc_secs_per_min) {
    return;
  }
  s_rtc.sec = 0U;
  s_rtc.min++;
  if (s_rtc.min < (uint8_t)k_rtc_mins_per_hour) {
    return;
  }
  s_rtc.min = 0U;
  s_rtc.hour++;
  if (s_rtc.hour < (uint8_t)k_rtc_hours_per_day) {
    return;
  }
  s_rtc.hour = 0U;
  s_rtc.day++;
  if (s_rtc.day <= (uint8_t)k_rtc_days_per_mon) {
    return;
  }
  s_rtc.day = 1U;
  s_rtc.mon++;
  if (s_rtc.mon <= (uint8_t)k_rtc_mons_per_year) {
    return;
  }
  s_rtc.mon = 1U;
  s_rtc.year++;
}

RA8_INTERNAL static bool internal_rtc_alarm_matches(void)
{
  const uint8_t sar = s_rtc.reg[(uint64_t)k_rtc_off_rsecar];
  const uint8_t mar = s_rtc.reg[(uint64_t)k_rtc_off_rminar];
  const uint8_t har = s_rtc.reg[(uint64_t)k_rtc_off_rhrar];
  /* Alarm is meaningful only if at least one field has its ENB bit set. */
  if (((sar | mar | har) & (uint8_t)k_rtc_alarm_enb) == 0U) {
    return false;
  }
  const bool sec_ok =
    ((sar & (uint8_t)k_rtc_alarm_enb) == 0U) ||
    (internal_rtc_bcd_to_bin((uint8_t)(sar & (uint8_t)k_rtc_alarm_val)) == s_rtc.sec);
  const bool min_ok =
    ((mar & (uint8_t)k_rtc_alarm_enb) == 0U) ||
    (internal_rtc_bcd_to_bin((uint8_t)(mar & (uint8_t)k_rtc_alarm_val)) == s_rtc.min);
  const bool hr_ok =
    ((har & (uint8_t)k_rtc_alarm_enb) == 0U) ||
    (internal_rtc_bcd_to_bin((uint8_t)(har & (uint8_t)k_rtc_alarm_val)) == s_rtc.hour);
  return sec_ok && min_ok && hr_ok;
}

RA8_INTERNAL static void internal_rtc_raise_events(uc_engine* uc)
{
  const uint8_t rcr1 = s_rtc.reg[(uint64_t)k_rtc_off_rcr1];
  if (internal_rtc_alarm_matches()) {
    s_rtc.alarms++;
    if ((rcr1 & (uint8_t)k_rtc_rcr1_aie) != 0U) {
      board_periph_icu_raise_event(uc, (uint16_t)k_rtc_event_alarm);
    }
    if (board_periph_trace()) {
      (void)priv_emu_io_errf("  RTC           : alarm match %02u:%02u:%02u\n",
                             s_rtc.hour,
                             s_rtc.min,
                             s_rtc.sec);
    }
  }
  if ((rcr1 & (uint8_t)k_rtc_rcr1_pie) != 0U) {
    s_rtc.periodics++;
    board_periph_icu_raise_event(uc, (uint16_t)k_rtc_event_periodic);
  }
}

RA8_INTERNAL static void internal_rtc_tick(uc_engine* uc)
{
  if ((s_rtc.reg[(uint64_t)k_rtc_off_rcr2] & (uint8_t)k_rtc_rcr2_start) == 0U) {
    return; /* stopped: time holds */
  }
  s_rtc.r64 = (uint8_t)(s_rtc.r64 + 1U);
  s_rtc.tick_frac++;
  if (s_rtc.tick_frac < (uint32_t)k_rtc_ticks_per_sec) {
    internal_rtc_publish_calendar();
    return;
  }
  s_rtc.tick_frac = 0U;
  internal_rtc_advance_one_second();
  internal_rtc_publish_calendar();
  internal_rtc_raise_events(uc);
}
 
/* =============================================================================
 * Reset / report.
 * =============================================================================
 */

RA8_INTERNAL static void internal_rtc_reset(void)
{
  s_rtc = (rtc_state_t){};
}

RA8_INTERNAL static void internal_rtc_report(void)
{
  if ((s_rtc.alarms == 0U) && (s_rtc.periodics == 0U)) {
    return;
  }
  (void)priv_emu_io_errf("  RTC           : %04u-%02u-%02u %02u:%02u:%02u alarms=%u periodics=%u\n",
                         (unsigned)((uint32_t)k_year_base + s_rtc.year),
                         s_rtc.mon,
                         s_rtc.day,
                         s_rtc.hour,
                         s_rtc.min,
                         s_rtc.sec,
                         s_rtc.alarms,
                         s_rtc.periodics);
}

static const board_periph_block_t s_k_rtc_block = {
  .base   = (uint64_t)k_rtc_base,
  .span   = (uint64_t)k_rtc_span,
  .order  = (uint32_t)k_rtc_block_order,
  .read   = internal_rtc_read,
  .write  = internal_rtc_write,
  .tick   = internal_rtc_tick,
  .reset  = internal_rtc_reset,
  .report = internal_rtc_report,
  .name   = "RTC",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_board_periph_rtc_register(void)
{
  board_periph_register_block(&s_k_rtc_block);
}