main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "imgfmt_fixtures.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_image.h"

typedef enum : uint32_t {
  k_ef_uart_baud   = 115200U,      
  k_ef_fb_w        = 160U,         
  k_ef_fb_h        = 120U,         
  k_ef_arena_bytes = 128U * 1024U, 
  k_ef_col_bg      = 0x202028U,    
  k_ef_fnv_offset  = 0x811C9DC5U,  
  k_ef_fnv_prime   = 0x01000193U,  
  k_ef_hex_nibbles = 8U,           
  k_ef_nibble_bits = 4U,           
  k_ef_nibble_mask = 0x0FU,        
  k_ef_dec_ten     = 10U,          
} ef_consts_t;

static uint16_t s_framebuffer[(size_t)k_ef_fb_h * (size_t)k_ef_fb_w];
static uint8_t s_img_arena[k_ef_arena_bytes];
 
static const uint8_t k_msg_boot[] = "ereader-imgfmt-hil: boot\r\n";
static const uint8_t k_msg_fail[] = "ereader-imgfmt-hil: FAIL init\r\n";
static const uint8_t k_msg_dbmp[] = "ereader-imgfmt-hil: FAIL bmp\r\n";
static const uint8_t k_msg_dgif[] = "ereader-imgfmt-hil: FAIL gif\r\n";
static const uint8_t k_msg_pre[]  = "ereader-imgfmt-hil: bmp=";
static const uint8_t k_msg_gif[]  = " gif=";
static const uint8_t k_msg_ok[]   = " PASS\r\n";

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

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

static uint32_t ef_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_ef_fnv_offset;
  for (size_t i = 0U; i < n; i++) {
    hsh = (hsh ^ (uint32_t)p[i]) * (uint32_t)k_ef_fnv_prime;
  }
  return hsh;
}

static void ef_print_hex(uint32_t value)
{
  uint8_t buf[k_ef_hex_nibbles];
  for (uint32_t i = 0U; i < (uint32_t)k_ef_hex_nibbles; i++) {
    const uint32_t shift = ((uint32_t)k_ef_hex_nibbles - 1U - i) * (uint32_t)k_ef_nibble_bits;
    const uint32_t nib   = (value >> shift) & (uint32_t)k_ef_nibble_mask;
    buf[i] = (uint8_t)((nib < (uint32_t)k_ef_dec_ten) ? ('0' + nib) : ('A' + (nib - k_ef_dec_ten)));
  }
  ef_print(buf, (uint32_t)k_ef_hex_nibbles);
}

static void ef_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    ef_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) {
    ef_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    ef_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_board_uart_console_init((uint32_t)k_ef_uart_baud) != k_ra8_ok) {
    ef_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
}

static uint32_t
ef_decode_and_hash(const uint8_t* bytes, size_t len, const uint8_t* fail_msg, uint32_t fail_len)
{
  (void)ra8_gfx_clear((uint32_t)k_ef_col_bg);
  ra8_img_arena_t arena = {.base   = s_img_arena,
                           .cap    = (size_t)k_ef_arena_bytes,
                           .offset = 0U,
                           .live   = 0U};
  int32_t         out_w = 0;
  int32_t         out_h = 0;
  if (ra8_img_decode_blit(&arena,
                          bytes,
                          len,
                          0,
                          0,
                          (int32_t)k_ef_fb_w,
                          (int32_t)k_ef_fb_h,
                          &out_w,
                          &out_h) != k_ra8_ok) {
    ef_panic_halt(fail_msg, fail_len);
  }
  return ef_framebuffer_hash();
}

void main(void)
{
  ef_setup_or_halt();
  ra8_isr_globals_enable();
  ef_print(k_msg_boot, (uint32_t)sizeof(k_msg_boot) - 1U);
 
  if (ra8_gfx_init(s_framebuffer,
                   (uint16_t)k_ef_fb_w,
                   (uint16_t)k_ef_fb_h,
                   k_ra8_gfx_format_rgb565) != k_ra8_ok) {
    ef_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
 
  const uint32_t bmp_crc =
    ef_decode_and_hash(k_bmp, (size_t)k_bmp_len, k_msg_dbmp, (uint32_t)sizeof(k_msg_dbmp) - 1U);
  const uint32_t gif_crc =
    ef_decode_and_hash(k_gif, (size_t)k_gif_len, k_msg_dgif, (uint32_t)sizeof(k_msg_dgif) - 1U);
 
  ef_print(k_msg_pre, (uint32_t)sizeof(k_msg_pre) - 1U);
  ef_print_hex(bmp_crc);
  ef_print(k_msg_gif, (uint32_t)sizeof(k_msg_gif) - 1U);
  ef_print_hex(gif_crc);
  ef_print(k_msg_ok, (uint32_t)sizeof(k_msg_ok) - 1U);
 
  while (1) {
    __asm__ volatile("wfi");
  }
}