main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "epub.h"
#include "epub_cover_fixture.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_ec_uart_baud   = 115200U,      
  k_ec_fb_w        = 160U,         
  k_ec_fb_h        = 120U,         
  k_ec_arena_bytes = 128U * 1024U, 
  k_ec_cover_cap   = 64U * 1024U,  
  k_ec_col_bg      = 0x202028U,    
  k_ec_fnv_offset  = 0x811C9DC5U,  
  k_ec_fnv_prime   = 0x01000193U,  
  k_ec_hex_nibbles = 8U,           
  k_ec_nibble_bits = 4U,           
  k_ec_nibble_mask = 0x0FU,        
  k_ec_dec_ten     = 10U,          
} ec_consts_t;

static epub_book_t s_book;
static uint8_t s_cover[k_ec_cover_cap];
static uint16_t s_framebuffer[(size_t)k_ec_fb_h * (size_t)k_ec_fb_w];
static uint8_t s_img_arena[k_ec_arena_bytes];
 
static const uint8_t k_msg_boot[] = "ereader-cover-hil: boot\r\n";
static const uint8_t k_msg_fail[] = "ereader-cover-hil: FAIL init\r\n";
static const uint8_t k_msg_open[] = "ereader-cover-hil: FAIL open\r\n";
static const uint8_t k_msg_cov[]  = "ereader-cover-hil: FAIL cover\r\n";
static const uint8_t k_msg_derr[] = "ereader-cover-hil: FAIL decode\r\n";
static const uint8_t k_msg_pre[]  = "ereader-cover-hil: cover ";
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 ec_print(const uint8_t* msg, uint32_t len)
{
  (void)ra8_board_uart_console_write(msg, (size_t)len);
}

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

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

static void ec_print_hex(uint32_t value)
{
  uint8_t buf[k_ec_hex_nibbles];
  for (uint32_t i = 0U; i < (uint32_t)k_ec_hex_nibbles; i++) {
    const uint32_t shift = ((uint32_t)k_ec_hex_nibbles - 1U - i) * (uint32_t)k_ec_nibble_bits;
    const uint32_t nib   = (value >> shift) & (uint32_t)k_ec_nibble_mask;
    buf[i] = (uint8_t)((nib < (uint32_t)k_ec_dec_ten) ? ('0' + nib) : ('A' + (nib - k_ec_dec_ten)));
  }
  ec_print(buf, (uint32_t)k_ec_hex_nibbles);
}

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

static void ec_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    ec_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) {
    ec_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    ec_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_board_uart_console_init((uint32_t)k_ec_uart_baud) != k_ra8_ok) {
    ec_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
}

static size_t ec_render_cover_or_halt(int32_t* out_w, int32_t* out_h)
{
  const epub_mem_media_t media = {.data = k_epub_cover_fixture,
                                  .size = (size_t)k_epub_cover_fixture_len};
  if (epub_open(&media, "book.epub", &s_book) != k_ra8_ok) {
    ec_panic_halt(k_msg_open, (uint32_t)sizeof(k_msg_open) - 1U);
  }
  size_t cover_len = 0U;
  if ((epub_get_cover_image(&s_book, s_cover, (size_t)k_ec_cover_cap, &cover_len) != k_ra8_ok) ||
      (cover_len == 0U)) {
    ec_panic_halt(k_msg_cov, (uint32_t)sizeof(k_msg_cov) - 1U);
  }
 
  ra8_img_arena_t arena = {.base   = s_img_arena,
                           .cap    = (size_t)k_ec_arena_bytes,
                           .offset = 0U,
                           .live   = 0U};
  if (ra8_img_decode_blit(&arena,
                          s_cover,
                          cover_len,
                          0,
                          0,
                          (int32_t)k_ec_fb_w,
                          (int32_t)k_ec_fb_h,
                          out_w,
                          out_h) != k_ra8_ok) {
    ec_panic_halt(k_msg_derr, (uint32_t)sizeof(k_msg_derr) - 1U);
  }
  return cover_len;
}

void main(void)
{
  ec_setup_or_halt();
  ra8_isr_globals_enable();
  ec_print(k_msg_boot, (uint32_t)sizeof(k_msg_boot) - 1U);
 
  if (ra8_gfx_init(s_framebuffer,
                   (uint16_t)k_ec_fb_w,
                   (uint16_t)k_ec_fb_h,
                   k_ra8_gfx_format_rgb565) != k_ra8_ok) {
    ec_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  (void)ra8_gfx_clear((uint32_t)k_ec_col_bg);
 
  int32_t out_w = 0;
  int32_t out_h = 0;
  (void)ec_render_cover_or_halt(&out_w, &out_h);
 
  ec_print(k_msg_pre, (uint32_t)sizeof(k_msg_pre) - 1U);
  ec_print_uint((uint32_t)out_w);
  ec_print(k_msg_x, (uint32_t)sizeof(k_msg_x) - 1U);
  ec_print_uint((uint32_t)out_h);
  ec_print(k_msg_crc, (uint32_t)sizeof(k_msg_crc) - 1U);
  ec_print_hex(ec_framebuffer_hash());
  ec_print(k_msg_ok, (uint32_t)sizeof(k_msg_ok) - 1U);
 
  while (1) {
    __asm__ volatile("wfi");
  }
}