main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_elc_regs.h"
#include "ra8_err.h"
#include "ra8_isr.h"
#include "ra8_lpm.h"
#include "ra8_lpm_regs.h"
#include "ra8_time.h"
#include "ra8_ulpt.h"

typedef enum : uint32_t {
  k_lus_baud = 115200U, 
  /* ULPTLCLK = LOCO / 1 = 32.768 kHz; 0x4000 (16384) ticks ~= 0.5 s. A
   * sub-second period keeps the bench wake banner prompt without
   * spinning the console. */
  k_lus_period_ticks = 0x4000U, 
  /* Bounded spin (NASA P10 Rule 2) waiting for ULPTCR.TCSTF to confirm
   * the count actually started before we drop into standby. */
  k_lus_tcstf_poll_limit = 0x100000U, 
} lus_const_t;

typedef enum : uint8_t {
  k_lus_channel = 0U, 
} lus_chan_t;

static const uint8_t s_lus_boot_msg[] = "lpm_ulpt: boot\r\n";

static const uint8_t s_lus_wake_msg[] = "lpm_ulpt: wake\r\n";

volatile uint32_t g_lpm_ulpt_wake_count = 0U;

RA8_INTERNAL static void internal_lus_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

RA8_INTERNAL static void internal_lus_ulpt_isr(void* ctx)
{
  (void)ctx;
  g_lpm_ulpt_wake_count++;
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_lus_wait_count_started(uint8_t channel)
{
  const uint8_t tcstf_mask = (uint8_t)(1U << (uint8_t)k_ra8_ulpt_bit_tcstf);
  for (uint32_t i = 0U; i < (uint32_t)k_lus_tcstf_poll_limit; ++i) {
    uint8_t   status = 0U;
    ra8_err_t err    = ra8_ulpt_get_status(channel, &status);
    if (err != k_ra8_ok) {
      return err;
    }
    if ((status & tcstf_mask) != 0U) {
      return k_ra8_ok;
    }
  }
  return k_ra8_err_hw_timeout;
}

RA8_INTERNAL static void internal_lus_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    internal_lus_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    internal_lus_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    internal_lus_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_lus_baud) != k_ra8_ok) {
    internal_lus_panic_halt();
  }
  if (ra8_ulpt_init() != k_ra8_ok) {
    internal_lus_panic_halt();
  }
  const ra8_lpm_config_t lpm_cfg = {
    .io_port_keep     = false,
    .opa_bus_keep     = true,
    .sscr_fast_return = false,
    .dcdc_softstart   = k_ra8_lpm_dcssmode_128us,
    .sscr_low_power   = k_ra8_lpm_ss2lp_default,
  };
  if (ra8_lpm_init(&lpm_cfg) != k_ra8_ok) {
    internal_lus_panic_halt();
  }
  /* Keep LOCO running (LCSTP = 0) so ULPTLCLK survives Software Standby:
   * HUM Table 11.3 footnote *2 (p 433) -- with IWDT unused and
   * LOCOCR.LCSTP = 0, LOCO is not stopped in Software Standby. */
  if (ra8_lpm_set_clock_stop(k_ra8_lpm_clock_loco, false) != k_ra8_ok) {
    internal_lus_panic_halt();
  }
}

[[nodiscard]] RA8_INTERNAL static ra8_err_t internal_lus_arm_wake(void)
{
  ra8_err_t err = ra8_isr_init();
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_isr_register(k_ra8_elc_event_ulpt0_ulpti,
                         internal_lus_ulpt_isr,
                         nullptr,
                         (uint8_t)k_ra8_isr_prio_default,
                         nullptr);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_lpm_arm_wupen1_bits((uint32_t)k_ra8_lpm_wupen1_ulpt0u);
}
 
void main(void)
{
  internal_lus_setup_or_halt();
 
  if (internal_lus_arm_wake() != k_ra8_ok) {
    internal_lus_panic_halt();
  }
  ra8_isr_globals_enable();
 
  (void)ra8_board_uart_console_write(s_lus_boot_msg, (size_t)(sizeof(s_lus_boot_msg) - 1U));
 
  while (1) {
    /* Re-arm the ULPT countdown, then drop into Software Standby until
     * the underflow cancels it. ra8_ulpt_stop clears ULPTCR.TUNF so the
     * next cycle starts clean. */
    if (ra8_ulpt_start((uint8_t)k_lus_channel, (uint32_t)k_lus_period_ticks) != k_ra8_ok) {
      break;
    }
    if (internal_lus_wait_count_started((uint8_t)k_lus_channel) != k_ra8_ok) {
      break;
    }
    if (ra8_lpm_enter_sleep(k_ra8_sleep_mode_software_std) != k_ra8_ok) {
      break;
    }
    if (ra8_ulpt_stop((uint8_t)k_lus_channel) != k_ra8_ok) {
      break;
    }
    if (ra8_board_uart_console_write(s_lus_wake_msg, (size_t)(sizeof(s_lus_wake_msg) - 1U)) !=
        k_ra8_ok) {
      break;
    }
  }
  internal_lus_panic_halt();
}