board_periph_rtt.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <stdio.h>
#include <string.h>
 
#include "board_console.h"
#include "board_periph_block.h"
#include "emu_host_io_internal.h"

typedef enum : uint64_t {
  k_rtt_scan_base = 0x22000000UL, 
  k_rtt_scan_span = 0x00400000UL, 
  k_rtt_scan_step = 0x00010000UL, 
} rtt_scan_window_t;

typedef enum : uint32_t {
  k_rtt_off_max_up  = 16U, 
  k_rtt_off_up0     = 24U, 
  k_rtt_up_off_buf  = 4U,  
  k_rtt_up_off_size = 8U,  
  k_rtt_up_off_wr   = 12U, 
  k_rtt_up_off_rd   = 16U, 
} rtt_cb_layout_t;

typedef enum : uint32_t {
  k_rtt_id_len          = 10U,      
  k_rtt_scan_first_tick = 64U,      
  k_rtt_scan_max_gap    = 1024U,    
  k_rtt_max_up_sane     = 16U,      
  k_rtt_size_sane       = 1048576U, 
  k_rtt_drain_max       = 4096U,    
  k_rtt_line_max        = 240U,     
} rtt_tune_t;

static const char s_k_rtt_id[k_rtt_id_len] = {'S', 'E', 'G', 'G', 'E', 'R', ' ', 'R', 'T', 'T'};

typedef struct {
  uint64_t cb_addr;                   
  uint32_t ticks;                     
  uint32_t next_scan;                 
  uint32_t scan_gap;                  
  uint32_t drained;                   
  uint32_t lines;                     
  uint32_t line_len;                  
  char     line[k_rtt_line_max + 1U]; 
} rtt_state_t;
 
static rtt_state_t s_rtt;

static uint8_t s_rtt_stage[(uint32_t)k_rtt_scan_step + (uint32_t)k_rtt_id_len];

static uint8_t s_rtt_seg[k_rtt_drain_max];

RA8_INTERNAL static uint32_t internal_rtt_rd32(uc_engine* uc, uint64_t addr)
{
  uint32_t v = 0U;
  if (emu_mem_read(uc, addr, &v, sizeof(v)) != UC_ERR_OK) {
    return 0U;
  }
  return v;
}

RA8_INTERNAL static bool internal_rtt_cb_valid(uc_engine* uc, uint64_t cb_addr)
{
  const uint32_t max_up = internal_rtt_rd32(uc, cb_addr + (uint64_t)k_rtt_off_max_up);
  if ((max_up == 0U) || (max_up > (uint32_t)k_rtt_max_up_sane)) {
    return false;
  }
  const uint64_t up0  = cb_addr + (uint64_t)k_rtt_off_up0;
  const uint32_t buf  = internal_rtt_rd32(uc, up0 + (uint64_t)k_rtt_up_off_buf);
  const uint32_t size = internal_rtt_rd32(uc, up0 + (uint64_t)k_rtt_up_off_size);
  const uint32_t wr   = internal_rtt_rd32(uc, up0 + (uint64_t)k_rtt_up_off_wr);
  const uint32_t rd   = internal_rtt_rd32(uc, up0 + (uint64_t)k_rtt_up_off_rd);
  if ((buf == 0U) || (size == 0U) || (size > (uint32_t)k_rtt_size_sane)) {
    return false;
  }
  return (wr < size) && (rd < size);
}

RA8_INTERNAL static uint64_t
internal_rtt_match_stage(uc_engine* uc, uint64_t stage_addr, uint64_t len)
{
  const uint8_t* p    = s_rtt_stage;
  uint64_t       left = len;
  while (left >= (uint64_t)k_rtt_id_len) {
    const uint8_t* hit =
      memchr(p, (int)s_k_rtt_id[0], (size_t)(left - ((uint64_t)k_rtt_id_len - 1U)));
    if (hit == nullptr) {
      return 0U;
    }
    if (memcmp(hit, s_k_rtt_id, (size_t)k_rtt_id_len) == 0) {
      const uint64_t cb = stage_addr + (uint64_t)(hit - s_rtt_stage);
      if (internal_rtt_cb_valid(uc, cb)) {
        return cb;
      }
    }
    left -= (uint64_t)(hit - p) + 1U;
    p = hit + 1U;
  }
  return 0U;
}

RA8_INTERNAL static void internal_rtt_scan(uc_engine* uc)
{
  for (uint64_t off = 0U; off < (uint64_t)k_rtt_scan_span; off += (uint64_t)k_rtt_scan_step) {
    /* Stage one step plus the ID-length overlap into the NEXT step (clamped at
     * the window end) so a block straddling the boundary is still found. */
    uint64_t want = (uint64_t)k_rtt_scan_step + (uint64_t)k_rtt_id_len;
    if ((off + want) > (uint64_t)k_rtt_scan_span) {
      want = (uint64_t)k_rtt_scan_span - off;
    }
    if (emu_mem_read(uc, (uint64_t)k_rtt_scan_base + off, s_rtt_stage, (size_t)want) != UC_ERR_OK) {
      return; /* SRAM window unreadable: give up this scan pass */
    }
    if (want < (uint64_t)k_rtt_id_len) {
      return; /* tail shorter than the ID: nothing left to match */
    }
    const uint64_t cb = internal_rtt_match_stage(uc, (uint64_t)k_rtt_scan_base + off, want);
    if (cb != 0U) {
      s_rtt.cb_addr = cb;
      return;
    }
  }
}

RA8_INTERNAL static void internal_rtt_line_feed(uint8_t byte)
{
  const char c = (char)byte;
  if (c == '\r') {
    return;
  }
  if ((c == '\n') || (s_rtt.line_len >= (uint32_t)k_rtt_line_max)) {
    s_rtt.line[s_rtt.line_len] = '\0';
    (void)priv_emu_io_outf("[rtt] %s\n", s_rtt.line);
    board_console_push(k_board_console_ch_rtt, s_rtt.line);
    s_rtt.lines++;
    s_rtt.line_len = 0U;
    if (c == '\n') {
      return;
    }
  }
  s_rtt.line[s_rtt.line_len] = c;
  s_rtt.line_len++;
}

RA8_INTERNAL static void internal_rtt_drain(uc_engine* uc)
{
  uint8_t id_now[k_rtt_id_len];
  if ((emu_mem_read(uc, s_rtt.cb_addr, id_now, sizeof(id_now)) != UC_ERR_OK) ||
      (memcmp(id_now, s_k_rtt_id, sizeof(id_now)) != 0)) {
    s_rtt.cb_addr = 0U; /* block gone (reboot / clobber): re-discover by scan */
    return;
  }
  const uint64_t up0  = s_rtt.cb_addr + (uint64_t)k_rtt_off_up0;
  const uint32_t buf  = internal_rtt_rd32(uc, up0 + (uint64_t)k_rtt_up_off_buf);
  const uint32_t size = internal_rtt_rd32(uc, up0 + (uint64_t)k_rtt_up_off_size);
  const uint32_t wr   = internal_rtt_rd32(uc, up0 + (uint64_t)k_rtt_up_off_wr);
  uint32_t       rd   = internal_rtt_rd32(uc, up0 + (uint64_t)k_rtt_up_off_rd);
  if ((buf == 0U) || (size == 0U) || (size > (uint32_t)k_rtt_size_sane) || (wr >= size) ||
      (rd >= size) || (wr == rd)) {
    return; /* invalid mid-update descriptor, or simply nothing pending */
  }
  const uint32_t avail = (wr > rd) ? (wr - rd) : ((size - rd) + wr);
  const uint32_t n     = (avail > (uint32_t)k_rtt_drain_max) ? (uint32_t)k_rtt_drain_max : avail;
  uint32_t       got   = 0U;
  /* At most two contiguous segments: rd..min(rd+n, size), then a wrap to 0. */
  const uint32_t first = ((size - rd) < n) ? (size - rd) : n;
  if (emu_mem_read(uc, (uint64_t)buf + (uint64_t)rd, s_rtt_seg, (size_t)first) == UC_ERR_OK) {
    got = first;
    if ((n > first) &&
        (emu_mem_read(uc, (uint64_t)buf, &s_rtt_seg[first], (size_t)(n - first)) == UC_ERR_OK)) {
      got = n;
    }
  }
  if (got == 0U) {
    return; /* ring storage unreadable: leave the offsets untouched */
  }
  for (uint32_t i = 0U; i < got; i++) {
    internal_rtt_line_feed(s_rtt_seg[i]);
  }
  rd = (rd + got) % size;
  /* Store the advanced read offset back so the firmware sees the drain. */
  (void)emu_mem_write(uc, up0 + (uint64_t)k_rtt_up_off_rd, &rd, sizeof(rd));
  s_rtt.drained += got;
}

RA8_INTERNAL static void internal_rtt_tick(uc_engine* uc)
{
  s_rtt.ticks++;
  if (s_rtt.cb_addr == 0U) {
    if (s_rtt.ticks < s_rtt.next_scan) {
      return;
    }
    internal_rtt_scan(uc);
    if (s_rtt.cb_addr == 0U) {
      /* Exponential backoff, capped: a non-RTT app pays a bounded scan cost. */
      if (s_rtt.scan_gap < (uint32_t)k_rtt_scan_max_gap) {
        s_rtt.scan_gap *= 2U;
      }
      s_rtt.next_scan = s_rtt.ticks + s_rtt.scan_gap;
      return;
    }
  }
  internal_rtt_drain(uc);
}

RA8_INTERNAL static void internal_rtt_reset(void)
{
  s_rtt           = (rtt_state_t){};
  s_rtt.next_scan = (uint32_t)k_rtt_scan_first_tick;
  s_rtt.scan_gap  = (uint32_t)k_rtt_scan_first_tick;
}

RA8_INTERNAL static void internal_rtt_report(void)
{
  if (s_rtt.cb_addr == 0U) {
    return; /* no RTT user in this firmware: stay quiet */
  }
  (void)priv_emu_io_errf(
    "  SEGGER RTT    : control block @0x%08llX, drained %u byte(s), %u line(s)\n",
    (unsigned long long)s_rtt.cb_addr,
    s_rtt.drained,
    s_rtt.lines);
}

RA8_INTERNAL static uint64_t internal_rtt_mmio_read(uc_engine* uc, uint64_t addr, unsigned size)
{
  (void)uc;
  (void)addr;
  (void)size;
  return 0U;
}

RA8_INTERNAL static void
internal_rtt_mmio_write(uc_engine* uc, uint64_t addr, unsigned size, uint64_t value)
{
  (void)uc;
  (void)addr;
  (void)size;
  (void)value;
}

typedef enum : uint32_t {
  k_rtt_block_order = 32U, 
} rtt_order_t;

static const board_periph_block_t s_k_rtt_block = {
  .base   = 0U,
  .span   = 0U, /* RAM-resident protocol: dispatch never routes here. */
  .order  = (uint32_t)k_rtt_block_order,
  .read   = internal_rtt_mmio_read,
  .write  = internal_rtt_mmio_write,
  .tick   = internal_rtt_tick,
  .reset  = internal_rtt_reset,
  .report = internal_rtt_report,
  .name   = "SEGGER RTT",
};

[[gnu::constructor]] RA8_INTERNAL static void internal_rtt_block_register(void)
{
  board_periph_register_block(&s_k_rtt_block);
}