main.c

Go to the documentation of this file.

 
#include <capstone/capstone.h>
#include <ctype.h>
#include <stdalign.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <time.h>
#include <unicorn/unicorn.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_eink.h"
#include "board_periph_modem.h"
#include "board_periph_sd.h"
#include "board_usb.h"
#include "board_usb_host.h"
#include "board_view.h"
#include "emu_args.h"
#include "emu_console.h"
#include "emu_cpu1.h"
#include "emu_elf.h"
#include "emu_elf_source_internal.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.h"
#include "emu_seams.h"
#include "emu_trace.h"
#include "emu_tz.h"
#include "emu_usbh_seam.h"
#include "emu_view.h"

alignas(max_align_t) static uint8_t
  s_main_presentation_scratch[k_emu_presentation_max_scratch_bytes];

RA8_INTERNAL static bool internal_main_open_memory(emu_memmap_workspace_t* memory)
{
  const emu_memmap_result_t result = emu_memmap_open(memory);
  if (result.status == k_emu_memmap_ok) {
    return true;
  }
  (void)priv_emu_io_errf("ra8_emulator: memory backing failed (%u): logical=%llu os=%d\n",
                         (unsigned int)result.status,
                         (unsigned long long)result.logical_backing_bytes,
                         result.os_error);
  return false;
}

RA8_INTERNAL static const char*
internal_main_apply_panel(const emu_args_t* args, uint16_t* view_w, uint16_t* view_h)
{
  static board_panel_t s_panel    = {};
  bool                 have_panel = false;
  if (args->panel_path != nullptr) {
    have_panel = load_panel(args->panel_path, &s_panel);
    if (have_panel && !args->size_set) {
      *view_w = s_panel.width;
      *view_h = s_panel.height;
    }
  }
  return (have_panel && (s_panel.name[0] != '\0')) ? s_panel.name : "ra8_emulator";
}

RA8_INTERNAL static bool internal_main_open_presentation(const emu_args_t*             args,
                                                         uint16_t                      view_w,
                                                         uint16_t                      view_h,
                                                         emu_presentation_workspace_t* workspace)
{
  const emu_presentation_spec_t spec = {
    .panel_width  = view_w,
    .panel_height = view_h,
    .rotate_deg   = args->rotate_deg,
    .active       = args->want_view || (args->ppm_path != nullptr) || args->want_click ||
                    (args->record_dir != nullptr),
  };
  const emu_presentation_result_t result =
    emu_presentation_open(&spec,
                          s_main_presentation_scratch,
                          sizeof(s_main_presentation_scratch),
                          workspace);
  if (result.status != k_emu_presentation_ok) {
    (void)priv_emu_io_errf("ra8_emulator: presentation workspace failed (%u): "
                           "surface=%zu scratch-required=%zu scratch-supplied=%zu os=%d\n",
                           (unsigned int)result.status,
                           result.required_surface_bytes,
                           result.required_scratch_bytes,
                           result.supplied_scratch_bytes,
                           result.os_error);
    return false;
  }
  return true;
}

RA8_INTERNAL static int internal_main_open_engine(uc_engine**             uc_out,
                                                  emu_memmap_workspace_t* memory)
{
  uc_engine* uc = nullptr;
  if (uc_open(UC_ARCH_ARM, (uc_mode)(UC_MODE_THUMB | UC_MODE_MCLASS), &uc) != UC_ERR_OK) {
    (void)priv_emu_io_errf("uc_open failed\n");
    return 1;
  }
  (void)uc_ctl_set_cpu_model(uc, UC_CPU_ARM_CORTEX_M33); /* closest to the M85. */
  if (emu_memmap_attach(memory, uc).status != k_emu_memmap_ok) {
    (void)uc_close(uc);
    return 1;
  }
  /* Seed hardwired MPU_TYPE.DREGION (=8) so ra8_mpu_configure validates; the
   * PPB is plain RAM here, so it would otherwise read 0 and panic
   * mpu_partition_simple. */
  wr32(uc, (uint64_t)k_mpu_type, (uint32_t)k_mpu_type_seed);
  *uc_out = uc;
  return 0;
}

RA8_INTERNAL static void internal_main_arm_touch_seq(const char* touch_seq_str)
{
  if (touch_seq_str == nullptr) {
    return;
  }
  enum : uint32_t {
    k_touch_seq_parse_max = 32U, 
  };
  board_periph_touch_seq_reset();
  const char* p      = touch_seq_str;
  uint32_t    pushed = 0U;
  for (uint32_t n = 0U; (n < (uint32_t)k_touch_seq_parse_max) && (*p != '\0'); n++) {
    char*      end = nullptr;
    const long x   = strtol(p, &end, (int)k_strtol_base10);
    if ((end == p) || (*end != ':')) {
      break;
    }
    p            = end + 1;
    const long y = strtol(p, &end, (int)k_strtol_base10);
    if (end == p) {
      break;
    }
    p = end;
    if ((x >= 0L) && (y >= 0L) && board_periph_touch_seq_push((uint16_t)x, (uint16_t)y)) {
      pushed++;
    }
    if (*p == ',') {
      p++;
    }
  }
  (void)priv_emu_io_errf("ra8_emulator: --touch-seq armed %u raw point(s)\n", (unsigned)pushed);
}

RA8_INTERNAL static void internal_main_apply_button_battery(const emu_args_t* args)
{
  if (args->button_press != 0) {
    const uint8_t pin = (args->button_press == 2) ? (uint8_t)k_emu_sw2_pin : (uint8_t)k_emu_sw1_pin;
    board_periph_gpio_set_input((uint8_t)k_emu_sw_port, pin, false);
    (void)priv_emu_io_errf("ra8_emulator: --button %d held (SW pin P00%u low/pressed)\n",
                           args->button_press,
                           (unsigned)pin);
  }
  if (args->battery_opt) {
    uint8_t cur_soc = 0U;
    board_periph_battery_get(&cur_soc, nullptr);
    const uint8_t soc = (args->battery_soc >= 0) ? (uint8_t)args->battery_soc : cur_soc;
    board_periph_battery_set(soc, args->battery_charging);
    (void)priv_emu_io_errf("ra8_emulator: battery %u%% %s (MAX17048 @ I2C 0x36)\n",
                           (unsigned)soc,
                           args->battery_charging ? "charging" : "discharging");
  }
}

RA8_INTERNAL static void internal_main_feed_inputs(const emu_args_t* args)
{
  if (args->input_str != nullptr) {
    uint8_t        rx[k_uart_line_max];
    const uint32_t n = decode_escapes(args->input_str, rx, (uint32_t)sizeof(rx));
    board_periph_sci_feed_rx(board_periph_sci_console_channel(), rx, n);
    (void)priv_emu_io_errf("ra8_emulator: queued %u byte(s) to SCI%u RX from --input\n",
                           n,
                           board_periph_sci_console_channel());
  }
  if (args->keys_str != nullptr) {
    uint8_t        kb[k_uart_line_max];
    const uint32_t n = decode_escapes(args->keys_str, kb, (uint32_t)sizeof(kb));
    for (uint32_t k = 0U; k < n; k++) {
      board_input_push_key((char)kb[k]);
    }
    (void)priv_emu_io_errf("ra8_emulator: queued %u keystroke(s) via --keys (window-key path)\n",
                           n);
  }
  if (args->usb_in_str != nullptr) {
    uint8_t        ub[k_uart_line_max];
    const uint32_t n = decode_escapes(args->usb_in_str, ub, (uint32_t)sizeof(ub));
    board_usb_feed_bulk_in(ub, n);
    (void)priv_emu_io_errf("ra8_emulator: queued %u byte(s) to the USB CDC bulk OUT pipe\n", n);
  }
}

RA8_INTERNAL static void internal_main_bringup_peripherals(const emu_args_t* args)
{
  board_periph_init(args->want_trace);
  internal_main_arm_touch_seq(args->touch_seq_str);
  board_periph_set_device(args->emu_device); /* gates the RA8P1-only NPU block. */
  /* --usbhs-loop: activate the on-chip USBHS host model and hand the USBFS
   * device to its bridge so the built-in virtual host stands down
   * (chip-internal loop). */
  board_periph_set_usbhs_loop(args->usbhs_loop);
  board_usb_set_external_host(args->usbhs_loop);
  board_net_init(args->want_trace);
  board_periph_sci_set_tx_sink(console_tx_sink);
  internal_main_apply_button_battery(args);
  internal_main_feed_inputs(args);
}

RA8_INTERNAL static int
internal_main_load_primary(uc_engine* uc, const char* elf_path, emu_elf_source_t* elf_out)
{
  const emu_elf_io_result_t opened = priv_emu_elf_source_open(elf_path, elf_out);
  if (opened.status != k_emu_elf_io_ok) {
    (void)priv_emu_io_errf("cannot read %s\n", elf_path);
    return 1;
  }
  (void)priv_emu_io_errf("ra8_emulator: loading %s (%llu bytes)\n",
                         elf_path,
                         (unsigned long long)elf_out->length);
  (void)priv_emu_io_errf("  device        : %s\n",
                         (board_periph_device() == k_board_device_ra8p1)
                           ? "RA8P1 (R7KA8P1KFLCAC) -- +Ethos-U55 NPU"
                           : "RA8D2 (R7KA8D2KFLCAC)");
  (void)priv_emu_io_errf("  primary core  : %s%s\n",
                         (emu_primary_core() == k_core_m33)
                           ? "Cortex-M33 (Armv8-M)"
                           : "Cortex-M85 (Armv8.1-M, MVE seams armed)",
                         emu_low_power() ? "  [low-power: 1/4 chunk budget]" : "");
  if (load_elf(uc, elf_out) != 0) {
    (void)priv_emu_elf_source_close(elf_out);
    return 1;
  }
  return 0;
}

RA8_INTERNAL static int internal_main_load_ns(uc_engine*        uc,
                                              const char*       ns_elf_path,
                                              emu_elf_source_t* elf,
                                              emu_elf_source_t* ns_out)
{
  if (ns_elf_path != nullptr) {
    const emu_elf_io_result_t opened = priv_emu_elf_source_open(ns_elf_path, ns_out);
    if (opened.status != k_emu_elf_io_ok) {
      (void)priv_emu_io_errf("cannot read --ns %s\n", ns_elf_path);
      (void)priv_emu_elf_source_close(elf);
      return 1;
    }
    (void)priv_emu_io_errf("ra8_emulator: loading NS image %s (%llu bytes)\n",
                           ns_elf_path,
                           (unsigned long long)ns_out->length);
    if (load_elf(uc, ns_out) != 0) {
      (void)priv_emu_elf_source_close(ns_out);
      (void)priv_emu_elf_source_close(elf);
      return 1;
    }
    /* Track the NS image's vector base (0x32100000 RAM-resident, 0x90000000 XIP
     * from OSPI) so the BLXNS world switch reads MSP/reset from the right
     * place. */
    const uint32_t ns_vbase = elf_vector_base(ns_out);
    if (ns_vbase != 0U) {
      emu_tz_set_ns_vector_base(ns_vbase);
    }
    (void)priv_emu_io_errf("ra8_emulator: NS vector base @ 0x%08X\n", emu_tz_ns_vector_base());
  }
  return 0;
}

RA8_INTERNAL static void internal_main_resolve_symbols(const emu_elf_source_t* elf,
                                                       const emu_elf_source_t* ns_elf,
                                                       const emu_args_t*       args,
                                                       uint32_t*               dump_sym_addrs,
                                                       uint32_t*               stop_sym_addr)
{
  for (uint32_t d = 0U; d < args->dump_sym_n; d++) {
    dump_sym_addrs[d] = elf_sym_addr(elf, args->dump_sym_names[d], nullptr);
    if ((dump_sym_addrs[d] == 0U) && (ns_elf->fd >= 0)) {
      dump_sym_addrs[d] = elf_sym_addr(ns_elf, args->dump_sym_names[d], nullptr);
    }
    if (dump_sym_addrs[d] == 0U) {
      (void)priv_emu_io_errf("ra8_emulator: --dump-sym %s not found in symbol table\n",
                             args->dump_sym_names[d]);
    }
  }
  *stop_sym_addr = 0U;
  if (args->stop_sym_name != nullptr) {
    *stop_sym_addr = elf_sym_addr(elf, args->stop_sym_name, nullptr);
    if ((*stop_sym_addr == 0U) && (ns_elf->fd >= 0)) {
      *stop_sym_addr = elf_sym_addr(ns_elf, args->stop_sym_name, nullptr);
    }
    if (*stop_sym_addr == 0U) {
      (void)priv_emu_io_errf("ra8_emulator: --stop-sym %s not found in symbol table\n",
                             args->stop_sym_name);
    }
  }
}

RA8_INTERNAL static uint32_t internal_main_reset_vector(uc_engine* uc)
{
  uint32_t sp = 0U;
  uint32_t pc = 0U;
  /* MRAM[0] */
  (void)emu_mem_read(uc, emu_memmap_mram_base() + 0U, &sp, 4);
  /* MRAM[4] (Thumb: bit0=1) */
  (void)emu_mem_read(uc, emu_memmap_mram_base() + 4U, &pc, 4);
  pc |= 1U;                               /* M-profile is always Thumb (EPSR.T must be 1). */
  uint32_t xpsr = (uint32_t)k_xpsr_t_bit; /* xPSR.T                                        */
  (void)uc_reg_write(uc, UC_ARM_REG_SP, &sp);
  (void)uc_reg_write(uc, UC_ARM_REG_PC, &pc);
  (void)uc_reg_write(uc, UC_ARM_REG_XPSR, &xpsr);
  (void)priv_emu_io_errf("ra8_emulator: reset SP=0x%08X PC=0x%08X -- running "
                         "(<= %u x %u insns, %u s wall)\n",
                         sp,
                         pc,
                         (unsigned)k_run_max_chunks,
                         (unsigned)k_run_chunk_insns,
                         (unsigned)k_run_wall_s);
  return pc;
}

RA8_INTERNAL static void internal_main_install_core_seams(uc_engine*              uc,
                                                          const emu_elf_source_t* elf)
{
  emu_insn_seams_install(uc);
  emu_exc_install_core(uc);
  /* Seed the ITM ready bits + echo stimulus-port writes so ra8_log prints
   * [itm]. */
  emu_console_install(uc);
  /* TrustZone S->NS boot seams (SAU_TYPE seed + hand-emulated BLXNS), armed
   * only when the firmware links the secure boot. */
  emu_tz_install(uc, elf);
  emu_exc_install_scb_nvic(uc);
  emu_mpu_install(uc);
}

RA8_INTERNAL static void internal_main_install_run_seams(uc_engine*              uc,
                                                         const emu_elf_source_t* elf,
                                                         const emu_args_t*       args,
                                                         emu_memmap_workspace_t* memory)
{
  bool usbh_seamed = false;
  if (!args->usbhs_loop) {
    usbh_seamed = usbh_seam_install(uc, elf);
  }
  /* Register-level USBHS host model: only an UNSEAMED, non-loop firmware
   * engages it, so the C-level seam / loop-only register block do not both
   * answer. */
  board_usb_host_set_allowed(!usbh_seamed && !args->usbhs_loop);
  sym_trace_install(uc, elf, args->trace_sym_names, args->trace_sym_n);
  /* M85-only long-shift (LSLL/LSRL/ASRL) + MVE (Helium) seams: off under
   * --primary-core m33 (pure Armv8-M), inert but honest. CSEL rides the
   * invalid- instruction hook and stays armed (also inert for an M33 image). */
  if (emu_primary_core() == k_core_m85) {
    long_shift_seam_install(uc, elf);
  }
  div0_seam_install(elf);        /* UDIV/SDIV sites, patched only under DIV_0_TRP. */
  fast_sd_seam_install(uc, elf); /* --fast-sd whole-block serve; else inert.       */
  prof_load(elf);                /* RA8_EMU_PROFILE FUNC symbols + code hook.      */
  emu_prof_install(uc);
  emu_cpu1_init(elf, memory); /* dual-core cpu1 engine; no-op for single-core. */
}

RA8_INTERNAL static emu_run_cfg_t
internal_main_build_run_cfg(const emu_args_t*             args,
                            uc_engine*                    uc,
                            emu_elf_source_t*             elf,
                            uint32_t                      pc,
                            uint32_t                      vtor_base,
                            uint16_t                      view_w,
                            uint16_t                      view_h,
                            const char*                   win_title,
                            const uint32_t*               dump_sym_addrs,
                            uint32_t                      stop_sym_addr,
                            emu_presentation_workspace_t* presentation,
                            emu_memmap_workspace_t*       memory)
{
  return (emu_run_cfg_t){
    .uc              = uc,
    .elf             = elf,
    .initial_pc      = pc,
    .vtor_base       = vtor_base,
    .want_trace      = args->want_trace,
    .want_view       = args->want_view,
    .want_click      = args->want_click,
    .click_x         = args->click_x,
    .click_y         = args->click_y,
    .ppm_path        = args->ppm_path,
    .record_dir      = args->record_dir,
    .record_secs     = args->record_secs,
    .rotate_deg      = args->rotate_deg,
    .reboot_count    = args->reboot_count,
    .save_sd_path    = args->save_sd_path,
    .stop_sym_addr   = stop_sym_addr,
    .stop_sym_thresh = args->stop_sym_thresh,
    .dump_sym_names  = args->dump_sym_names,
    .dump_sym_addrs  = dump_sym_addrs,
    .dump_sym_n      = args->dump_sym_n,
    .view_w          = view_w,
    .view_h          = view_h,
    .win_title       = win_title,
    .presentation    = presentation,
    .memory          = memory,
  };
}

RA8_INTERNAL static int internal_main_run_loaded(const emu_args_t*             args,
                                                 emu_memmap_workspace_t*       memory,
                                                 emu_presentation_workspace_t* presentation,
                                                 uc_engine*                    uc,
                                                 emu_elf_source_t*             elf,
                                                 emu_elf_source_t*             ns_elf,
                                                 uint16_t                      view_w,
                                                 uint16_t                      view_h,
                                                 const char*                   win_title)
{
  uint32_t dump_sym_addrs[k_dump_sym_max] = {};
  uint32_t stop_sym_addr                  = 0U;
  internal_main_resolve_symbols(elf, ns_elf, args, dump_sym_addrs, &stop_sym_addr);
  if (ns_elf->fd >= 0) {
    (void)priv_emu_elf_source_close(ns_elf);
  }
  emu_tz_patch_cmse(uc, elf);
 
  const uint32_t pc        = internal_main_reset_vector(uc);
  const uint32_t vtor_base = (uint32_t)emu_memmap_mram_base();
  internal_main_install_core_seams(uc, elf);
  internal_main_install_run_seams(uc, elf, args, memory);
 
  const emu_run_cfg_t run_cfg = internal_main_build_run_cfg(args,
                                                            uc,
                                                            elf,
                                                            pc,
                                                            vtor_base,
                                                            view_w,
                                                            view_h,
                                                            win_title,
                                                            dump_sym_addrs,
                                                            stop_sym_addr,
                                                            presentation,
                                                            memory);
  return emu_run_and_report(&run_cfg);
}

RA8_INTERNAL static int internal_main_load_images(uc_engine*                    uc,
                                                  const emu_args_t*             args,
                                                  emu_memmap_workspace_t*       memory,
                                                  emu_presentation_workspace_t* presentation,
                                                  emu_elf_source_t*             elf,
                                                  emu_elf_source_t*             ns_elf)
{
  if (internal_main_load_primary(uc, args->elf_path, elf) != 0) {
    (void)emu_memmap_detach(memory, uc);
    (void)uc_close(uc);
    (void)emu_memmap_close(memory);
    (void)emu_presentation_close(presentation);
    return 1;
  }
  if (internal_main_load_ns(uc, args->ns_elf_path, elf, ns_elf) != 0) {
    (void)priv_emu_elf_source_close(elf);
    (void)emu_memmap_detach(memory, uc);
    (void)uc_close(uc);
    (void)emu_memmap_close(memory);
    (void)emu_presentation_close(presentation);
    return 1;
  }
  return 0;
}
 
int main(int argc, char** argv)
{
  priv_emu_io_configure(STDOUT_FILENO, STDERR_FILENO, nullptr);
  emu_args_t args = {};
  if (!emu_args_parse(argc, argv, &args)) {
    return 2;
  }
  uint16_t                     view_w       = args.view_w;
  uint16_t                     view_h       = args.view_h;
  const char* const            win_title    = internal_main_apply_panel(&args, &view_w, &view_h);
  emu_presentation_workspace_t presentation = {.fd = -1};
  if (!internal_main_open_presentation(&args, view_w, view_h, &presentation)) {
    return 2;
  }
  emu_memmap_workspace_t memory = {};
  if (!internal_main_open_memory(&memory)) {
    (void)emu_presentation_close(&presentation);
    return 2;
  }
 
  uc_engine* uc = nullptr;
  if (internal_main_open_engine(&uc, &memory) != 0) {
    (void)emu_memmap_close(&memory);
    (void)emu_presentation_close(&presentation);
    return 1;
  }
  internal_main_bringup_peripherals(&args);
 
  emu_elf_source_t elf    = {.fd = -1};
  emu_elf_source_t ns_elf = {.fd = -1};
  if (internal_main_load_images(uc, &args, &memory, &presentation, &elf, &ns_elf) != 0) {
    return 1;
  }
 
  return internal_main_run_loaded(&args,
                                  &memory,
                                  &presentation,
                                  uc,
                                  &elf,
                                  &ns_elf,
                                  view_w,
                                  view_h,
                                  win_title);
}