emu_console.c

Go to the documentation of this file.

 
#include "emu_console.h"
 
#include <stdio.h>
 
#include "board_console.h"
#include "emu_host_io_internal.h"
#include "emu_memory_access.h"

static char s_itm_line[k_itm_line_max + 1U];

static uint32_t s_itm_len;
 
static char     s_uart_line[k_uart_line_max]; 
static uint32_t s_uart_line_len;              

RA8_INTERNAL static void internal_on_itm_stim_write(uc_engine*  uc,
                                                    uc_mem_type type,
                                                    uint64_t    addr,
                                                    int         size,
                                                    int64_t     value,
                                                    void*       user)
{
  (void)uc;
  (void)type;
  (void)addr;
  (void)size;
  (void)user;
  const char c = (char)(uint8_t)value;
  if (c == '\r') {
    return;
  }
  if ((c == '\n') || (s_itm_len >= (uint32_t)k_itm_line_max)) {
    s_itm_line[s_itm_len] = '\0';
    /* Emit one ra8_log line as `[itm] <line>` -- the CoreSight ITM/SWO-trace
     * analog of the `[uart] SCI8:` console echo (see the ITM model block
     * above). */
    (void)priv_emu_io_outf("[itm] %s\n", s_itm_line);
    /* Also route it to the board_console ITM channel so the tabbed board-view
     * console shows ITM/SWO trace in its own tab (a different endpoint than the
     * UART line). The injected output sink echo above is unchanged -- this is
     * purely additive. */
    board_console_push(k_board_console_ch_itm, s_itm_line);
    s_itm_len = 0U;
    if (c == '\n') {
      return;
    }
  }
  s_itm_line[s_itm_len] = c;
  s_itm_len++;
}

RA8_INTERNAL static void internal_itm_seed_ready(uc_engine* uc)
{
  const uint32_t demcr = (uint32_t)k_scb_demcr_trcena;
  const uint32_t tcr   = (uint32_t)k_itm_tcr_itmena;
  const uint32_t tenr  = (uint32_t)k_itm_tenr_port0;
  const uint32_t stim  = (uint32_t)k_itm_stim_ready;
  (void)emu_mem_write(uc, (uint64_t)k_scb_demcr_addr, &demcr, sizeof(demcr));
  (void)emu_mem_write(uc, (uint64_t)k_itm_tcr_addr, &tcr, sizeof(tcr));
  (void)emu_mem_write(uc, (uint64_t)k_itm_tenr_addr, &tenr, sizeof(tenr));
  (void)emu_mem_write(uc, (uint64_t)k_itm_stim0_addr, &stim, sizeof(stim));
}

void emu_console_install(uc_engine* uc)
{
  internal_itm_seed_ready(uc);
  static uc_hook s_h_itm;
  (void)uc_hook_add(uc,
                    &s_h_itm,
                    UC_HOOK_MEM_WRITE,
                    (void*)internal_on_itm_stim_write,
                    nullptr,
                    (uint64_t)k_itm_stim0_addr,
                    (uint64_t)k_itm_stim0_addr + 3U);
}
 
void console_flush_line(uint8_t channel)
{
  if (s_uart_line_len == 0U) {
    return;
  }
  s_uart_line[s_uart_line_len] = '\0';
  (void)priv_emu_io_outf("[uart] SCI%u: %s\n", channel, s_uart_line);
  s_uart_line_len = 0U;
}
 
void console_tx_sink(uint8_t channel, uint8_t byte)
{
  if (byte == (uint8_t)'\n') {
    console_flush_line(channel);
    return;
  }
  if ((byte != (uint8_t)'\r') && (s_uart_line_len < (uint32_t)(k_uart_line_max - 1U))) {
    s_uart_line[s_uart_line_len++] = (char)byte;
  }
  if (s_uart_line_len == (uint32_t)(k_uart_line_max - 1U)) {
    console_flush_line(channel); /* avoid an unbounded line on a stream with no LF */
  }
}
 
uint32_t decode_escapes(const char* in, uint8_t* out, uint32_t cap)
{
  uint32_t n = 0U;
  for (uint32_t i = 0U; (in[i] != '\0') && (n < cap); i++) {
    char c = in[i];
    if ((c == '\\') && (in[i + 1U] != '\0')) {
      i++;
      switch (in[i]) {
        case 'n':
          c = '\n';
          break;
        case 'r':
          c = '\r';
          break;
        case 't':
          c = '\t';
          break;
        case '0':
          c = '\0';
          break;
        default:
          c = in[i]; /* \\ -> \, and any other escape is taken literally */
          break;
      }
    }
    out[n++] = (uint8_t)c;
  }
  return n;
}

void emu_console_reset(void)
{
  s_itm_len = 0U;
}