main.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_display_pal.h"
#include "ra8_display_pal_lcd.h"
#include "ra8_err.h"
#include "ra8_glcdc.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_panel.h"
#include "ra8_panel_timing.h"
#include "ra8_time.h"

typedef enum : uint16_t {
  k_gh_fb_w        = 512U, 
  k_gh_fb_h        = 512U, 
  k_gh_x_thickness = 4U,   
} glcdc_hil_geom_t;

typedef enum : uint16_t {
  k_gh_color_bg     = 0x001FU, 
  k_gh_color_x      = 0xFFE0U, 
  k_gh_color_border = 0xFFFFU, 
} glcdc_hil_color_t;

typedef enum : uint32_t {
  k_gh_uart_baud   = 115200U,     
  k_gh_fnv_offset  = 2166136261U, 
  k_gh_fnv_prime   = 16777619U,   
  k_gh_hex_nibbles = 8U,          
  k_gh_nibble_bits = 4U,          
  k_gh_nibble_mask = 0x0FU,       
  k_gh_dec_ten     = 10U,         
} glcdc_hil_console_t;

[[gnu::aligned(k_ra8_board_fb_align_bytes)]] static uint16_t
  s_framebuffer[(uint32_t)k_gh_fb_w * (uint32_t)k_gh_fb_h];

static const display_cfg_t k_gh_display_cfg = {
  .iface             = &k_display_backend_lcd_ra8_glcdc,
  .framebuffer       = s_framebuffer,
  .framebuffer_bytes = sizeof(s_framebuffer),
  .width_px          = (uint16_t)k_gh_fb_w,
  .height_px         = (uint16_t)k_gh_fb_h,
  .pixfmt            = k_display_pixfmt_rgb565,
  .panel_timing      = &s_ra8_panel_ek_ra8d2_timing,
};

volatile uint32_t g_glcdc_hil_ok = 0U;
volatile uint32_t g_glcdc_hil_crc = 0U;
volatile uint32_t g_glcdc_hil_status = 0U;
volatile uint32_t g_glcdc_hil_heartbeat = 0U;
 
static const uint8_t k_gh_msg_boot[]       = "glcdc-hil: boot\r\n";
static const uint8_t k_gh_msg_fail_init[]  = "glcdc-hil: FAIL init\r\n";
static const uint8_t k_gh_msg_fail_glcdc[] = "glcdc-hil: FAIL glcdc\r\n";
static const uint8_t k_gh_msg_pre[]        = "glcdc-hil: layer1=ok dim=";
static const uint8_t k_gh_msg_x[]          = "x";
static const uint8_t k_gh_msg_crc[]        = " crc=";
static const uint8_t k_gh_msg_pass[]       = " PASS\r\n";
 
/* ===========================================================================
 * Console
 * ===========================================================================
 */

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

static void gh_panic_halt(void)
{
  gh_print(k_gh_msg_fail_init, (uint32_t)sizeof(k_gh_msg_fail_init) - 1U);
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void gh_print_hex(uint32_t value)
{
  uint8_t buf[k_gh_hex_nibbles];
  for (uint32_t i = 0U; i < (uint32_t)k_gh_hex_nibbles; i++) {
    const uint32_t shift = ((uint32_t)k_gh_hex_nibbles - 1U - i) * (uint32_t)k_gh_nibble_bits;
    const uint32_t nib   = (value >> shift) & (uint32_t)k_gh_nibble_mask;
    buf[i] = (uint8_t)((nib < (uint32_t)k_gh_dec_ten) ? ('0' + nib) : ('A' + (nib - k_gh_dec_ten)));
  }
  gh_print(buf, (uint32_t)k_gh_hex_nibbles);
}

static void gh_print_uint(uint32_t value)
{
  uint8_t  buf[k_gh_dec_ten];
  uint32_t n = 0U;
  if (value == 0U) {
    buf[n] = '0';
    n++;
  }
  while ((value > 0U) && (n < (uint32_t)k_gh_dec_ten)) {
    buf[n] = (uint8_t)('0' + (value % (uint32_t)k_gh_dec_ten));
    n++;
    value /= (uint32_t)k_gh_dec_ten;
  }
  for (uint32_t i = 0U; i < n; i++) {
    gh_print(&buf[n - 1U - i], 1U);
  }
}
 
/* ===========================================================================
 * Deterministic framebuffer pattern
 * ===========================================================================
 */

static void gh_fb_fill(uint16_t color)
{
  for (uint32_t i = 0U; i < (uint32_t)k_gh_fb_w * (uint32_t)k_gh_fb_h; i++) {
    s_framebuffer[i] = color;
  }
}

static void gh_draw_x(uint16_t color)
{
  for (uint16_t x = 0U; x < (uint16_t)k_gh_fb_w; x++) {
    const int32_t y_down = ((int32_t)x * (int32_t)k_gh_fb_h) / (int32_t)k_gh_fb_w;
    const int32_t y_up   = ((int32_t)k_gh_fb_h - 1) - y_down;
    for (int32_t dy = -(int32_t)k_gh_x_thickness; dy <= (int32_t)k_gh_x_thickness; dy++) {
      const int32_t yy_down = y_down + dy;
      const int32_t yy_up   = y_up + dy;
      if ((yy_down >= 0) && (yy_down < (int32_t)k_gh_fb_h)) {
        s_framebuffer[((uint32_t)yy_down * (uint32_t)k_gh_fb_w) + (uint32_t)x] = color;
      }
      if ((yy_up >= 0) && (yy_up < (int32_t)k_gh_fb_h)) {
        s_framebuffer[((uint32_t)yy_up * (uint32_t)k_gh_fb_w) + (uint32_t)x] = color;
      }
    }
  }
}

static void gh_draw_border(uint16_t color)
{
  const uint32_t last_row = ((uint32_t)k_gh_fb_h - 1U) * (uint32_t)k_gh_fb_w;
  for (uint32_t x = 0U; x < (uint32_t)k_gh_fb_w; x++) {
    s_framebuffer[x]            = color;
    s_framebuffer[last_row + x] = color;
  }
  for (uint32_t y = 0U; y < (uint32_t)k_gh_fb_h; y++) {
    const uint32_t row                            = y * (uint32_t)k_gh_fb_w;
    s_framebuffer[row]                            = color;
    s_framebuffer[row + (uint32_t)k_gh_fb_w - 1U] = color;
  }
}

static void gh_render_pattern(void)
{
  gh_fb_fill((uint16_t)k_gh_color_bg);
  gh_draw_x((uint16_t)k_gh_color_x);
  gh_draw_border((uint16_t)k_gh_color_border);
#ifndef RA8_OFF_TARGET
  __asm__ volatile("dsb" ::: "memory");
#endif
}

static uint32_t gh_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_gh_fnv_offset;
  for (size_t i = 0U; i < n; i++) {
    hsh = (hsh ^ (uint32_t)p[i]) * (uint32_t)k_gh_fnv_prime;
  }
  return hsh;
}
 
/* ===========================================================================
 * GLCDC bring-up + programmed-layer proof
 * ===========================================================================
 */

static bool gh_glcdc_programmed(void)
{
  display_handle_t* d = nullptr;
  if (display_init(&k_gh_display_cfg, &d) != k_ra8_ok) {
    return false;
  }
  if (d == nullptr) {
    return false;
  }
  display_fb_t fb = {};
  if (display_get_framebuffer(d, &fb) != k_ra8_ok) {
    return false;
  }
  if (fb.pixels != (void*)s_framebuffer) {
    return false;
  }
  uint32_t status_mask = 0U;
  if (ra8_glcdc_get_status(&status_mask) != k_ra8_ok) {
    return false;
  }
  g_glcdc_hil_status = status_mask;
  return true;
}

static void gh_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    gh_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    gh_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    gh_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_gh_uart_baud) != k_ra8_ok) {
    gh_panic_halt();
  }
}
 
/* ===========================================================================
 * Boot + main
 * ===========================================================================
 */

void main(void)
{
  gh_setup_or_halt();
  ra8_isr_globals_enable();
  gh_print(k_gh_msg_boot, (uint32_t)sizeof(k_gh_msg_boot) - 1U);
 
  gh_render_pattern();
 
  if (!gh_glcdc_programmed()) {
    gh_print(k_gh_msg_fail_glcdc, (uint32_t)sizeof(k_gh_msg_fail_glcdc) - 1U);
    while (1) {
      __asm__ volatile("wfi");
    }
  }
  g_glcdc_hil_ok  = 1U;
  g_glcdc_hil_crc = gh_framebuffer_hash();
 
  gh_print(k_gh_msg_pre, (uint32_t)sizeof(k_gh_msg_pre) - 1U);
  gh_print_uint((uint32_t)k_gh_fb_w);
  gh_print(k_gh_msg_x, (uint32_t)sizeof(k_gh_msg_x) - 1U);
  gh_print_uint((uint32_t)k_gh_fb_h);
  gh_print(k_gh_msg_crc, (uint32_t)sizeof(k_gh_msg_crc) - 1U);
  gh_print_hex((uint32_t)g_glcdc_hil_crc);
  gh_print(k_gh_msg_pass, (uint32_t)sizeof(k_gh_msg_pass) - 1U);
 
  while (1) {
    g_glcdc_hil_heartbeat++;
    __asm__ volatile("wfi");
  }
}