emu_run.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <time.h>
#include <unistd.h>
 
#include "board_console.h"
#include "board_input.h"
#include "board_net.h"
#include "board_overlay.h"
#include "board_periph.h"
#include "board_periph_sd.h"
#include "board_usb.h"
#include "board_view.h"
#include "emu_console.h"
#include "emu_cpu1.h"
#include "emu_elf.h"
#include "emu_engine.h"
#include "emu_exc.h"
#include "emu_host_io_internal.h"
#include "emu_memmap.h"
#include "emu_mmio.h"
#include "emu_mpu.h"
#include "emu_prof.h"
#include "emu_run_internal.h"
#include "emu_seams.h"
#include "emu_usbh_seam.h"
#include "emu_view.h"

typedef enum : uint8_t {
  k_loop_next     = 0, 
  k_loop_continue = 1, 
  k_loop_break    = 2, 
} loop_action_t;

RA8_INTERNAL static void internal_run_setup_geometry(const emu_run_cfg_t* cfg, run_loop_t* st)
{
  st->presentation = cfg->presentation;
  st->panel_w      = cfg->presentation->panel_width;
  st->panel_h      = cfg->presentation->panel_height;
  st->disp_w       = cfg->presentation->display_width;
  st->disp_h       = cfg->presentation->display_height;
  st->comp_w       = cfg->presentation->composite_width;
  st->comp_h       = cfg->presentation->composite_height;
}

RA8_INTERNAL static void internal_run_open_view(const emu_run_cfg_t* cfg, run_loop_t* st)
{
  if (cfg->want_view) {
    st->view = board_view_open(&st->view_storage, st->comp_w, st->comp_h, cfg->win_title);
    if (st->view == nullptr) {
      (void)priv_emu_io_errf("ra8_emulator: could not open window; continuing headless\n");
    }
  }
}

RA8_INTERNAL static void internal_run_classify_click(const emu_run_cfg_t* cfg, run_loop_t* st)
{
  if (!cfg->want_click) {
    return;
  }
  (void)priv_emu_io_errf("ra8_emulator: --click armed at (%d,%d)\n", cfg->click_x, cfg->click_y);
  uint32_t click_tab_idx = 0U;
  if (board_overlay_hit_console_tab((uint16_t)cfg->click_x,
                                    (uint16_t)cfg->click_y,
                                    st->disp_w,
                                    (uint32_t)k_board_console_ch_count,
                                    &click_tab_idx)) {
    emu_view_select_console_tab(click_tab_idx);
    st->click_was_tab = true;
  }
  st->click_btn =
    (!st->click_was_tab)
      ? board_overlay_hit_button((uint16_t)cfg->click_x, (uint16_t)cfg->click_y, st->disp_w)
      : k_board_overlay_btn_none;
}

RA8_INTERNAL static void internal_run_loop_setup(const emu_run_cfg_t* cfg, run_loop_t* st)
{
  *st              = (run_loop_t){};
  st->cfg          = cfg;
  st->click_btn    = k_board_overlay_btn_none;
  st->held_btn     = k_board_overlay_btn_none;
  st->reboot_count = cfg->reboot_count;
  st->run_pc       = cfg->initial_pc;
  st->err          = UC_ERR_OK;
  internal_run_setup_geometry(cfg, st);
  internal_run_open_view(cfg, st);
  st->guards = run_read_guards(cfg, st->view);
  internal_run_classify_click(cfg, st);
  st->t0 = clock();
}

RA8_INTERNAL static loop_action_t internal_run_loop_prologue(run_loop_t* st)
{
  const emu_run_cfg_t* cfg = st->cfg;
  /* RA8_EMU_PROFILE: charge the wall time of the previous chunk to the
   * function its execution started in (so a cheap WFI-halt chunk and an
   * expensive compute chunk are weighted by real time, not by chunk count). */
  if (emu_prof_mode() == k_prof_wall) {
    const double now = board_now_s();
    if (st->prof_prev_t > 0.0) {
      prof_add(st->prof_prev_pc, now - st->prof_prev_t);
    }
    st->prof_prev_pc = st->run_pc;
    st->prof_prev_t  = now;
  }
  emu_view_publish(st->run_pc, st->chunks); /* PC + chunk counter for the board view. */
 
  /* --reboot N: after each boot's settle window force a power-on warm reboot;
   * the reset-retained models (VBATT backup) survive, proving reset-survival.
   */
  if ((st->reboot_count > 0) && ((st->chunks - st->last_boot_chunk) >= (uint32_t)k_reboot_settle)) {
    st->reboot_count--;
    board_periph_reset_set_cause(true, false, false, false); /* power-on reboot */
    st->run_pc = warm_reboot(cfg->uc, cfg->elf, cfg->want_trace);
    if (st->run_pc == 0U) {
      return k_loop_break; /* reboot failed to reload the image -- end the run
                            */
    }
    st->last_boot_chunk = st->chunks;
    return k_loop_continue;
  }
  /* A peripheral (the watchdog) may have requested a reset on its tick: latch
   * the watchdog cause and warm-reboot so the next boot reads reset_by=wdt. */
  bool wdt_rst  = false;
  bool iwdt_rst = false;
  if (board_periph_reset_take_request(&wdt_rst, &iwdt_rst)) {
    board_periph_reset_set_cause(false, false, wdt_rst, iwdt_rst);
    st->run_pc = warm_reboot(cfg->uc, cfg->elf, cfg->want_trace);
    if (st->run_pc == 0U) {
      return k_loop_break; /* reboot failed to reload the image -- end the run
                            */
    }
    st->last_boot_chunk = st->chunks;
    return k_loop_continue;
  }
  return k_loop_next;
}

RA8_INTERNAL static void internal_run_loop_tick_inputs(run_loop_t* st)
{
  const emu_run_cfg_t* cfg = st->cfg;
  emu_exc_arm_systick(); /* one SysTick period per outer chunk. */
  /* DWT cycle counter: keep a masked-context ra8_delay_ms (spins on CYCCNT with
   * PRIMASK set) making progress. Inert unless the firmware enabled it. */
  dwt_cyccnt_advance(cfg->uc);
  board_periph_tick(cfg->uc); /* advance timers; pend any wrap IRQ like SysTick. */
  board_net_tick();
 
  /* Drain buffered keystrokes into the console UART RX (the SCI channel --input
   * targets), from the live window (keyDown) and the headless --keys injector.
   */
  char key_byte = 0;
  while (board_input_pop_key(&key_byte)) {
    const uint8_t kb = (uint8_t)key_byte;
    board_periph_sci_feed_rx(board_periph_sci_console_channel(), &kb, 1U);
  }
 
  /* Headless --click: keep one contact armed in the GT911 model until the
   * firmware's real ra8_touch_read drains it; re-arming each chunk is needed
   * because ra8_touch_open clears the GT911 status byte during bring-up. */
  if (cfg->want_click && (st->click_btn != k_board_overlay_btn_none)) {
    if (!st->button_fired) {
      if ((st->click_btn == k_board_overlay_btn_battery) ||
          (st->click_btn == k_board_overlay_btn_batt_chg) ||
          (st->click_btn == k_board_overlay_btn_lowpower)) {
        apply_battery_click(st->click_btn, (uint16_t)cfg->click_x, st->disp_w); /* SOC/CHG/LP. */
      } else {
        set_switch(st->click_btn, true); /* headless --click SW1/SW2: press + hold. */
      }
      st->button_fired = true;
    }
  } else if (cfg->want_click && !st->click_was_tab && (board_periph_touch_reported() == 0U)) {
    uint16_t cnx = (uint16_t)cfg->click_x;
    uint16_t cny = (uint16_t)cfg->click_y;
    unrotate_click((uint16_t)cfg->click_x,
                   (uint16_t)cfg->click_y,
                   st->panel_w,
                   st->panel_h,
                   cfg->rotate_deg,
                   &cnx,
                   &cny);
    board_periph_touch_inject(cnx, cny);
  }
}

RA8_INTERNAL static loop_action_t internal_run_loop_run_chunk(run_loop_t* st)
{
  const emu_run_cfg_t* cfg = st->cfg;
  if (priv_run_inner(cfg->uc, cfg->vtor_base, &st->run_pc, &st->err)) {
    return k_loop_break;
  }
  if (emu_prof_stop_hit()) {
    st->prof_stopped = true; /* RA8_EMU_STOP_PC reached -- end the profiled run. */
    return k_loop_break;
  }
  /* AIRCR.SYSRESETREQ: latch a software-reset cause and warm reboot the
   * firmware from its reset vector, then keep running. */
  if (emu_exc_reboot_requested()) {
    board_periph_reset_set_cause(false, true, false, false); /* software reset */
    st->run_pc = warm_reboot(cfg->uc, cfg->elf, cfg->want_trace);
    emu_exc_clear_reboot_request();
    if (st->run_pc == 0U) {
      return k_loop_break; /* reboot failed to reload the image -- end the run
                            */
    }
    return k_loop_continue;
  }
  return k_loop_next;
}

RA8_INTERNAL static void internal_run_loop_record(run_loop_t* st)
{
  const emu_run_cfg_t* cfg = st->cfg;
  /* Dual-core: step cpu1 interleaved with cpu0; a cpu1 fault just stops cpu1.
   */
  emu_cpu1_step();
  /* --record: dump the composite every k_record_every chunks as a numbered PPM.
   */
  if ((cfg->record_dir != nullptr) && (st->presentation->fd >= 0) &&
      ((st->chunks % (uint32_t)k_record_every) == 0U)) {
    const bool built = build_composite(cfg->uc, st->presentation, cfg->win_title);
    enum : uint16_t {
      k_rec_path_cap = 1024U, 
    };
    char fpath[k_rec_path_cap];
    (void)snprintf(fpath,
                   sizeof(fpath),
                   "%s/frame_%06u.ppm",
                   cfg->record_dir,
                   (unsigned)st->rec_frames);
    if (built && (write_ppm(fpath, st->presentation) == 0)) {
      st->rec_frames++;
    }
  }
}

RA8_INTERNAL static void internal_run_view_maybe_present(run_loop_t* st)
{
  const emu_run_cfg_t* cfg    = st->cfg;
  struct timespec      ts_now = {};
  (void)clock_gettime(CLOCK_MONOTONIC, &ts_now);
  const uint64_t now_us = ((uint64_t)ts_now.tv_sec * (uint64_t)k_us_per_s) +
                          ((uint64_t)ts_now.tv_nsec / (uint64_t)k_ns_per_us);
  if ((now_us - st->last_present_us) >= (uint64_t)k_view_frame_us) {
    if (build_composite(cfg->uc, st->presentation, cfg->win_title)) {
      board_view_present(st->view, st->presentation);
      st->last_present_us = now_us;
    }
  } else {
    (void)usleep((useconds_t)k_view_yield_us);
  }
}

RA8_INTERNAL static loop_action_t internal_run_loop_view(run_loop_t* st)
{
  uint16_t cx = 0U;
  uint16_t cy = 0U;
  if (board_view_poll_click(st->view, &cx, &cy)) {
    const board_overlay_btn_t hit =
      route_click(cx, cy, st->panel_w, st->panel_h, st->disp_w, st->cfg->rotate_deg);
    st->slider_grab = (hit == k_board_overlay_btn_battery);
    st->held_btn    = ((hit == k_board_overlay_btn_sw1) || (hit == k_board_overlay_btn_sw2))
                        ? hit
                        : k_board_overlay_btn_none;
  }
  if (board_view_poll_release(st->view)) { /* mouse-up: release a held button + grab. */
    if (st->held_btn != k_board_overlay_btn_none) {
      set_switch(st->held_btn, false);
      st->held_btn = k_board_overlay_btn_none;
    }
    st->slider_grab = false;
  }
  uint16_t dx = 0U;
  uint16_t dy = 0U;
  if (board_view_poll_drag(st->view, &dx, &dy) && st->slider_grab) {
    apply_battery_click(k_board_overlay_btn_battery, dx, st->disp_w);
  }
  emu_view_wheel(board_view_poll_scroll(st->view)); /* wheel pages the scrollback. */
  if ((st->chunks % (uint32_t)k_view_present_every) == 0U) {
    internal_run_view_maybe_present(st);
  }
  if (board_view_pump(st->view)) {
    st->closed = true;
    return k_loop_break;
  }
  return k_loop_next;
}

RA8_INTERNAL static loop_action_t internal_run_loop_click_tail(run_loop_t* st)
{
  const bool click_acted = (st->click_btn != k_board_overlay_btn_none)
                             ? st->button_fired
                             : (board_periph_touch_reported() > 0U);
  if (click_acted) {
    st->settle_left =
      (st->settle_left == 0U) ? st->guards.click_settle_chunks : (st->settle_left - 1U);
    if (st->settle_left == 1U) {
      return k_loop_break;
    }
  }
  if (st->guards.wall_guard_on &&
      (((double)(clock() - st->t0) / (double)CLOCKS_PER_SEC) >= st->guards.wall_s)) {
    st->timed_out = true;
    return k_loop_break;
  }
  return k_loop_next;
}

RA8_INTERNAL static bool internal_run_stop_prof_idle(run_loop_t* st)
{
  if (!((emu_prof_mode() == k_prof_insn) && (st->cfg->record_dir == nullptr) &&
        (st->chunks >= st->guards.prof_idle_arm))) {
    return false;
  }
  const uint64_t d     = emu_prof_total_insns() - st->prof_idle_prev_i;
  st->prof_idle_prev_i = emu_prof_total_insns();
  if (d < (uint64_t)st->guards.prof_idle_insns) {
    st->prof_idle_run++;
    if (st->prof_idle_run >= st->guards.prof_idle_need) {
      st->prof_stopped = true;
      return true;
    }
  } else {
    st->prof_idle_run = 0U;
  }
  return false;
}

RA8_INTERNAL static bool internal_run_stop_idle(run_loop_t* st)
{
  if (!((st->guards.idle_stop_chunks > 0U) && (st->cfg->record_dir == nullptr))) {
    return false;
  }
  const uint64_t idle_sig = (uint64_t)emu_mmio_reads() + (uint64_t)emu_mmio_writes() +
                            (uint64_t)emu_exc_pendsv_takes() + (uint64_t)emu_exc_svc_takes() +
                            (uint64_t)board_periph_irq_total();
  if (idle_sig == st->idle_sig_prev) {
    st->idle_run++;
    if (st->idle_run >= st->guards.idle_stop_chunks) {
      st->idle_stopped = true;
      return true;
    }
  } else {
    st->idle_sig_prev = idle_sig;
    st->idle_run      = 0U;
  }
  return false;
}

RA8_INTERNAL static bool internal_run_stop_usb(run_loop_t* st)
{
  const bool recording = (st->cfg->record_dir != nullptr);
  if ((st->guards.usb_stop_settle > 0U) && !recording && board_usb_configured()) {
    st->usb_stop_run++;
    if (st->usb_stop_run >= st->guards.usb_stop_settle) {
      st->usb_stopped = true;
      return true;
    }
  }
  if ((st->guards.usbh_stop_settle > 0U) && !recording && emu_usbh_done()) {
    st->usbh_stop_run++;
    if (st->usbh_stop_run >= st->guards.usbh_stop_settle) {
      st->usb_stopped = true;
      return true;
    }
  }
  return false;
}

RA8_INTERNAL static bool internal_run_stop_banner(run_loop_t* st)
{
  const char* const stop_on = st->guards.stop_on;
  if (stop_on == nullptr) {
    return false;
  }
  const char* const last_uart = board_periph_uart_last_line();
  const char* const last_itm  = board_console_line(k_board_console_ch_itm, 0U);
  const char* const last_rtt  = board_console_line(k_board_console_ch_rtt, 0U);
  const bool        hit = ((last_uart != nullptr) && (strstr(last_uart, stop_on) != nullptr)) ||
                          ((last_itm != nullptr) && (strstr(last_itm, stop_on) != nullptr)) ||
                          ((last_rtt != nullptr) && (strstr(last_rtt, stop_on) != nullptr));
  if (hit) {
    st->usb_stopped = true;
    return true;
  }
  return false;
}

RA8_INTERNAL static bool internal_run_stop_sym(run_loop_t* st)
{
  const emu_run_cfg_t* cfg = st->cfg;
  if (cfg->stop_sym_addr == 0U) {
    return false;
  }
  uint32_t sv = 0U;
  if ((emu_mem_read(cfg->uc, (uint64_t)cfg->stop_sym_addr, &sv, sizeof(sv)) == UC_ERR_OK) &&
      (sv >= cfg->stop_sym_thresh)) {
    st->stop_sym_hit = true;
    return true;
  }
  return false;
}

RA8_INTERNAL static bool internal_run_stop_wall(run_loop_t* st)
{
  if (st->guards.wall_guard_on &&
      (((double)(clock() - st->t0) / (double)CLOCKS_PER_SEC) >= st->guards.wall_s)) {
    st->timed_out = true;
    return true;
  }
  return false;
}

RA8_INTERNAL static loop_action_t internal_run_loop_headless(run_loop_t* st)
{
  if (internal_run_stop_prof_idle(st) || internal_run_stop_idle(st) || internal_run_stop_usb(st) ||
      internal_run_stop_banner(st) || internal_run_stop_sym(st) || internal_run_stop_wall(st)) {
    return k_loop_break;
  }
  return k_loop_next;
}

RA8_INTERNAL static loop_action_t internal_run_loop_present_and_stops(run_loop_t* st)
{
  if (st->view != nullptr) {
    return internal_run_loop_view(st);
  }
  if (st->cfg->want_click) {
    return internal_run_loop_click_tail(st);
  }
  return internal_run_loop_headless(st);
}

RA8_INTERNAL static void internal_run_loop(run_loop_t* st)
{
  for (; st->chunks < st->guards.max_chunks; st->chunks++) {
    const loop_action_t pro = internal_run_loop_prologue(st);
    if (pro == k_loop_break) {
      break;
    }
    if (pro == k_loop_continue) {
      continue;
    }
    internal_run_loop_tick_inputs(st);
    const loop_action_t chunk = internal_run_loop_run_chunk(st);
    if (chunk == k_loop_break) {
      break;
    }
    if (chunk == k_loop_continue) {
      continue;
    }
    internal_run_loop_record(st);
    if (internal_run_loop_present_and_stops(st) == k_loop_break) {
      break;
    }
  }
}
 
int emu_run_and_report(const emu_run_cfg_t* cfg)
{
  run_loop_t st = {};
  internal_run_loop_setup(cfg, &st);
  internal_run_loop(&st);
  priv_run_report(&st);
  priv_run_write_outputs(&st);
  priv_run_hold_view(&st);
  return priv_run_cleanup(&st);
}