main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "jpeg_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"
 
/* ===========================================================================
 * Sizing + protocol constants (no magic numbers)
 * ===========================================================================
 */

typedef enum : uint32_t {
  k_iv_fb_w        = 160U,         
  k_iv_fb_h        = 120U,         
  k_iv_uart_baud   = 115200U,      
  k_iv_arena_bytes = 128U * 1024U, 
  k_iv_fnv_offset  = 2166136261U,  
  k_iv_fnv_prime   = 16777619U,    
  k_iv_hex_nibbles = 8U,           
  k_iv_nibble_bits = 4U,           
  k_iv_nibble_mask = 0x0FU,        
  k_iv_dec_ten     = 10U,          
} iv_consts_t;

typedef enum : uint32_t {
  k_iv_col_bg = 0x202028U, 
} iv_colors_t;

static uint16_t s_framebuffer[(size_t)k_iv_fb_h * (size_t)k_iv_fb_w];

static uint8_t s_img_arena[k_iv_arena_bytes];
 
static const uint8_t k_msg_boot[] = "ereader-jpeg-hil: boot\r\n";
static const uint8_t k_msg_fail[] = "ereader-jpeg-hil: FAIL init\r\n";
static const uint8_t k_msg_derr[] = "ereader-jpeg-hil: FAIL decode\r\n";
static const uint8_t k_msg_pre[]  = "ereader-jpeg-hil: img ";
static const uint8_t k_msg_x[]    = "x";
static const uint8_t k_msg_crc[]  = " crc=";
static const uint8_t k_msg_eol[]  = "\r\n";
 
/* ===========================================================================
 * Console helpers
 * ===========================================================================
 */

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

static void iv_panic_halt(void)
{
  iv_print(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  __asm__ volatile("bkpt #0");
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void iv_print_hex(uint32_t value)
{
  uint8_t buf[k_iv_hex_nibbles];
  for (uint32_t i = 0U; i < (uint32_t)k_iv_hex_nibbles; i++) {
    const uint32_t shift = ((uint32_t)k_iv_hex_nibbles - 1U - i) * (uint32_t)k_iv_nibble_bits;
    const uint32_t nib   = (value >> shift) & (uint32_t)k_iv_nibble_mask;
    buf[i] = (uint8_t)((nib < (uint32_t)k_iv_dec_ten) ? ('0' + nib) : ('A' + (nib - k_iv_dec_ten)));
  }
  iv_print(buf, (uint32_t)k_iv_hex_nibbles);
}

static void iv_print_uint(uint32_t value)
{
  uint8_t  buf[k_iv_dec_ten];
  uint32_t n = 0U;
  if (value == 0U) {
    buf[n] = '0';
    n++;
  }
  while ((value > 0U) && (n < (uint32_t)k_iv_dec_ten)) {
    buf[n] = (uint8_t)('0' + (value % (uint32_t)k_iv_dec_ten));
    n++;
    value /= (uint32_t)k_iv_dec_ten;
  }
  for (uint32_t i = 0U; i < n; i++) {
    iv_print(&buf[n - 1U - i], 1U);
  }
}
 
/* ===========================================================================
 * Render + hash
 * ===========================================================================
 */

static uint32_t iv_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_iv_fnv_offset;
  for (size_t i = 0U; i < n; i++) {
    hsh = (hsh ^ (uint32_t)p[i]) * (uint32_t)k_iv_fnv_prime;
  }
  return hsh;
}
 
/* ===========================================================================
 * Boot + main
 * ===========================================================================
 */

static void iv_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    iv_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    iv_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    iv_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_iv_uart_baud) != k_ra8_ok) {
    iv_panic_halt();
  }
}

void main(void)
{
  iv_setup_or_halt();
  ra8_isr_globals_enable();
  iv_print(k_msg_boot, (uint32_t)sizeof(k_msg_boot) - 1U);
 
  if (ra8_gfx_init(s_framebuffer,
                   (uint16_t)k_iv_fb_w,
                   (uint16_t)k_iv_fb_h,
                   k_ra8_gfx_format_rgb565) != k_ra8_ok) {
    iv_panic_halt();
  }
  (void)ra8_gfx_clear((uint32_t)k_iv_col_bg);
 
  ra8_img_arena_t arena = {.base   = s_img_arena,
                           .cap    = (size_t)k_iv_arena_bytes,
                           .offset = 0U,
                           .live   = 0U};
  int32_t         out_w = 0;
  int32_t         out_h = 0;
  const ra8_err_t err   = ra8_img_decode_blit(&arena,
                                              k_cover_jpg,
                                              (size_t)k_cover_jpg_len,
                                              0,
                                              0,
                                              (int32_t)k_iv_fb_w,
                                              (int32_t)k_iv_fb_h,
                                              &out_w,
                                              &out_h);
  if (err != k_ra8_ok) {
    iv_print(k_msg_derr, (uint32_t)sizeof(k_msg_derr) - 1U);
    iv_panic_halt();
  }
 
  iv_print(k_msg_pre, (uint32_t)sizeof(k_msg_pre) - 1U);
  iv_print_uint((uint32_t)out_w);
  iv_print(k_msg_x, (uint32_t)sizeof(k_msg_x) - 1U);
  iv_print_uint((uint32_t)out_h);
  iv_print(k_msg_crc, (uint32_t)sizeof(k_msg_crc) - 1U);
  iv_print_hex(iv_framebuffer_hash());
  iv_print(k_msg_eol, (uint32_t)sizeof(k_msg_eol) - 1U);
 
  while (1) {
    __asm__ volatile("wfi");
  }
}