main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_gfx.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_time.h"
#include "reflow_svg.h"
#include "svg_fixture.h"

typedef enum : uint32_t {
  k_es_uart_baud   = 115200U,     
  k_es_fb_w        = 160U,        
  k_es_fb_h        = 120U,        
  k_es_col_bg      = 0x202028U,   
  k_es_fnv_offset  = 0x811C9DC5U, 
  k_es_fnv_prime   = 0x01000193U, 
  k_es_hex_nibbles = 8U,          
  k_es_nibble_bits = 4U,          
  k_es_nibble_mask = 0x0FU,       
  k_es_dec_ten     = 10U,         
} es_consts_t;

static uint16_t s_framebuffer[(size_t)k_es_fb_h * (size_t)k_es_fb_w];
 
static const uint8_t k_msg_boot[] = "ereader-svg-hil: boot\r\n";
static const uint8_t k_msg_fail[] = "ereader-svg-hil: FAIL init\r\n";
static const uint8_t k_msg_size[] = "ereader-svg-hil: FAIL size\r\n";
static const uint8_t k_msg_rerr[] = "ereader-svg-hil: FAIL render\r\n";
static const uint8_t k_msg_pre[]  = "ereader-svg-hil: svg ";
static const uint8_t k_msg_x[]    = "x";
static const uint8_t k_msg_crc[]  = " crc=";
static const uint8_t k_msg_ok[]   = " PASS\r\n";

static void es_print(const uint8_t* msg, uint32_t len)
{
  (void)ra8_board_uart_console_write(msg, (size_t)len);
}

static void es_panic_halt(const uint8_t* msg, uint32_t len)
{
  es_print(msg, len);
  __asm__ volatile("bkpt #0");
  while (1) {
    __asm__ volatile("wfi");
  }
}

static uint32_t es_framebuffer_hash(void)
{
  const uint8_t* p   = (const uint8_t*)s_framebuffer;
  const size_t   n   = sizeof(s_framebuffer);
  uint32_t       hsh = (uint32_t)k_es_fnv_offset;
  for (size_t i = 0U; i < n; i++) {
    hsh = (hsh ^ (uint32_t)p[i]) * (uint32_t)k_es_fnv_prime;
  }
  return hsh;
}

static void es_print_hex(uint32_t value)
{
  uint8_t buf[k_es_hex_nibbles];
  for (uint32_t i = 0U; i < (uint32_t)k_es_hex_nibbles; i++) {
    const uint32_t shift = ((uint32_t)k_es_hex_nibbles - 1U - i) * (uint32_t)k_es_nibble_bits;
    const uint32_t nib   = (value >> shift) & (uint32_t)k_es_nibble_mask;
    buf[i] = (uint8_t)((nib < (uint32_t)k_es_dec_ten) ? ('0' + nib) : ('A' + (nib - k_es_dec_ten)));
  }
  es_print(buf, (uint32_t)k_es_hex_nibbles);
}

static void es_print_uint(uint32_t value)
{
  uint8_t  buf[k_es_dec_ten];
  uint32_t n = 0U;
  if (value == 0U) {
    buf[n] = '0';
    n++;
  }
  while ((value > 0U) && (n < (uint32_t)k_es_dec_ten)) {
    buf[n] = (uint8_t)('0' + (value % (uint32_t)k_es_dec_ten));
    n++;
    value /= (uint32_t)k_es_dec_ten;
  }
  for (uint32_t i = 0U; i < n; i++) {
    es_print(&buf[n - 1U - i], 1U);
  }
}

static void es_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    es_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    es_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    es_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_board_uart_console_init((uint32_t)k_es_uart_baud) != k_ra8_ok) {
    es_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
}

static void es_render_svg_or_halt(int32_t* out_w, int32_t* out_h)
{
  const size_t svg_len = sizeof(k_svg_fixture) - 1U;
  if (ra8_svg_size((const uint8_t*)k_svg_fixture, svg_len, out_w, out_h) != k_ra8_ok) {
    es_panic_halt(k_msg_size, (uint32_t)sizeof(k_msg_size) - 1U);
  }
  if (ra8_svg_render((const uint8_t*)k_svg_fixture,
                     svg_len,
                     0,
                     0,
                     (int32_t)k_es_fb_w,
                     (int32_t)k_es_fb_h) != k_ra8_ok) {
    es_panic_halt(k_msg_rerr, (uint32_t)sizeof(k_msg_rerr) - 1U);
  }
}

void main(void)
{
  es_setup_or_halt();
  ra8_isr_globals_enable();
  es_print(k_msg_boot, (uint32_t)sizeof(k_msg_boot) - 1U);
 
  if (ra8_gfx_init(s_framebuffer,
                   (uint16_t)k_es_fb_w,
                   (uint16_t)k_es_fb_h,
                   k_ra8_gfx_format_rgb565) != k_ra8_ok) {
    es_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  (void)ra8_gfx_clear((uint32_t)k_es_col_bg);
 
  int32_t svg_w = 0;
  int32_t svg_h = 0;
  es_render_svg_or_halt(&svg_w, &svg_h);
 
  es_print(k_msg_pre, (uint32_t)sizeof(k_msg_pre) - 1U);
  es_print_uint((uint32_t)svg_w);
  es_print(k_msg_x, (uint32_t)sizeof(k_msg_x) - 1U);
  es_print_uint((uint32_t)svg_h);
  es_print(k_msg_crc, (uint32_t)sizeof(k_msg_crc) - 1U);
  es_print_hex(es_framebuffer_hash());
  es_print(k_msg_ok, (uint32_t)sizeof(k_msg_ok) - 1U);
 
  while (1) {
    __asm__ volatile("wfi");
  }
}