ra8_display_pal_lcd.c

Go to the documentation of this file.

 
#include "ra8_display_pal_lcd.h"
 
#include <stddef.h>
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_cache.h"
#include "ra8_check.h"
#include "ra8_display_pal.h"
#include "ra8_display_pal_internal.h"
#include "ra8_err.h"
#include "ra8_glcdc.h"
#include "ra8_log.h"
#include "ra8_time.h"
 
/* =============================================================================
 * Module-static storage
 * =============================================================================
 */

static const char* const s_tag = "ra8_display_pal_lcd";

typedef enum : uint32_t {
  k_rgb565_mask = 0xFFFFU, 
} disp_lcd_mask_t;

typedef enum : uint32_t {
  k_lcd_bringup_settle_ms = 200U, 
  k_lcd_bg_color_black    = 0U,   
  k_lcd_fb_align_bytes    = 64U,  
  k_lcd_rgb565_bpp        = 2U,   
} ra8_display_pal_lcd_const_t;

typedef struct {
  display_caps_t caps;    
  display_fb_t   fb;      
  bool           started; 
} lcd_ctx_t;

static lcd_ctx_t s_lcd_ctx;

RA8_INTERNAL
static inline void internal_lcd_dsb(void)
{
#ifndef RA8_OFF_TARGET
  __asm__ volatile("dsb 0xF" ::: "memory");
#endif
}
 
/* =============================================================================
 * Internal helpers (kept short for NASA P10 Rule 4)
 * =============================================================================
 */

RA8_INTERNAL
static ra8_err_t internal_lcd_validate_cfg(const display_cfg_t* cfg)
{
  RA8_CHECK_NULL_PTR(cfg->framebuffer, s_tag, "cfg->framebuffer");
  if (cfg->width_px == 0U || cfg->height_px == 0U) {
    return k_ra8_err_invalid_arg;
  }
  if (cfg->pixfmt != k_display_pixfmt_rgb565) {
    return k_ra8_err_not_supported;
  }
  /* The GLCDC backend needs the panel's RGB timing; the board BSP supplies it
   * (e.g. &s_ra8_panel_ek_ra8d2_timing). Host / e-ink backends leave it null. */
  if (cfg->panel_timing == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  const uint32_t need_bytes =
    (uint32_t)cfg->width_px * (uint32_t)cfg->height_px * (uint32_t)k_lcd_rgb565_bpp;
  if (cfg->framebuffer_bytes < need_bytes) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_lcd_bringup_panel(const display_cfg_t* cfg)
{
  ra8_err_t err = ra8_board_lcd_panel_power_on();
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_board_glcdc_init(k_ra8_board_glcdc_fmt_rgb888);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_delay_ms((uint32_t)k_lcd_bringup_settle_ms);
 
  const ra8_glcdc_config_t glcdc_cfg = {
    .framebuffer_addr = (uint32_t)(uintptr_t)cfg->framebuffer,
    .width_px         = cfg->width_px,
    .height_px        = cfg->height_px,
    .format           = k_ra8_glcdc_fmt_rgb565,
    .timing           = *(const ra8_glcdc_timing_t*)cfg->panel_timing,
  };
  err = ra8_glcdc_init(&glcdc_cfg);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_glcdc_set_background_color((uint32_t)k_lcd_bg_color_black);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_glcdc_start(true);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_glcdc_layer1_show((uintptr_t)cfg->framebuffer);
}

RA8_INTERNAL
static void internal_lcd_snapshot(const display_cfg_t* cfg)
{
  const uint32_t stride                  = (uint32_t)cfg->width_px * (uint32_t)k_lcd_rgb565_bpp;
  s_lcd_ctx.caps.width_px                = cfg->width_px;
  s_lcd_ctx.caps.height_px               = cfg->height_px;
  s_lcd_ctx.caps.pixfmt                  = k_display_pixfmt_rgb565;
  s_lcd_ctx.caps.stride_bytes            = stride;
  s_lcd_ctx.caps.refresh_latency_us_typ  = 0U;
  s_lcd_ctx.caps.supports_partial_update = true;
  s_lcd_ctx.caps.continuous_refresh      = true;
 
  s_lcd_ctx.fb.pixels       = cfg->framebuffer;
  s_lcd_ctx.fb.width_px     = cfg->width_px;
  s_lcd_ctx.fb.height_px    = cfg->height_px;
  s_lcd_ctx.fb.stride_bytes = stride;
  s_lcd_ctx.fb.pixfmt       = k_display_pixfmt_rgb565;
  s_lcd_ctx.started         = true;
}

RA8_INTERNAL
static ra8_err_t internal_lcd_check_rect(const display_caps_t* caps, display_rect_t r)
{
  if (r.x > caps->width_px) {
    return k_ra8_err_invalid_arg;
  }
  if (r.y > caps->height_px) {
    return k_ra8_err_invalid_arg;
  }
  if ((uint32_t)r.x + (uint32_t)r.w > (uint32_t)caps->width_px) {
    return k_ra8_err_invalid_arg;
  }
  if ((uint32_t)r.y + (uint32_t)r.h > (uint32_t)caps->height_px) {
    return k_ra8_err_invalid_arg;
  }
  return k_ra8_ok;
}
 
/* =============================================================================
 * Vtable callbacks
 * =============================================================================
 */

RA8_INTERNAL
static ra8_err_t internal_lcd_init(const display_cfg_t* cfg, void** out_ctx)
{
  RA8_CHECK_NULL_PTR(cfg, s_tag, "cfg");
  RA8_CHECK_NULL_PTR(out_ctx, s_tag, "out_ctx");
 
  const ra8_err_t v = internal_lcd_validate_cfg(cfg);
  if (v != k_ra8_ok) {
    return v;
  }
  if (s_lcd_ctx.started) {
    ra8_log_error(s_tag, "internal_lcd_init: already started");
    return k_ra8_err_busy;
  }
  const ra8_err_t err = internal_lcd_bringup_panel(cfg);
  if (err != k_ra8_ok) {
    return err;
  }
  internal_lcd_snapshot(cfg);
  *out_ctx = &s_lcd_ctx;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_lcd_get_caps(const void* ctx, display_caps_t* out)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx");
  RA8_CHECK_NULL_PTR(out, s_tag, "out");
  const lcd_ctx_t* c = (const lcd_ctx_t*)ctx;
  *out               = c->caps;
  return k_ra8_ok;
}

RA8_INTERNAL
/* cppcheck-suppress constParameterCallback -- display_pal_ops_t fixes this callback's context type as void*. */
static ra8_err_t internal_lcd_get_framebuffer(void* ctx, display_fb_t* out)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx");
  RA8_CHECK_NULL_PTR(out, s_tag, "out");
  const lcd_ctx_t* c = (const lcd_ctx_t*)ctx;
  *out               = c->fb;
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_lcd_flush(void* ctx, display_rect_t rect, display_refresh_hint_t hint)
{
  (void)hint; /* LCD scans continuously; hint is purely informational. */
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx");
  const lcd_ctx_t* c = (const lcd_ctx_t*)ctx;
  const ra8_err_t  v = internal_lcd_check_rect(&c->caps, rect);
  if (v != k_ra8_ok) {
    return v;
  }
#ifdef RA8_BOOT_ENABLE_CACHE_MPU
  /* D-cache is enabled for this build: the CPU paints the cacheable SDRAM
   * framebuffer through the write-back L1 D-cache, but the GLCDC scans SDRAM
   * directly over AXI and never sees the cache. Clean (write back) the painted
   * rows so the next scan latches the new pixels instead of stale SDRAM. The
   * clean covers the flushed rect's contiguous row-span [y, y+h) -- a superset
   * of the rect, exact for the full-width flushes the reader issues, and safe
   * for a partial-width rect (whole rows, never a strided w*h slice).
   * ra8_cache_dcache_clean_by_addr rounds to whole cache lines internally. */
  {
    const uint8_t* row_base = (const uint8_t*)c->fb.pixels + (uint32_t)rect.y * c->fb.stride_bytes;
    const uint32_t row_span = (uint32_t)rect.h * c->fb.stride_bytes;
    (void)ra8_cache_dcache_clean_by_addr(row_base, row_span);
  }
#endif
  /* Memory barrier so any pixel writes the caller did with NEON / DMA
   * are visible to the GLCDC's AXI controller before the next scan. */
  internal_lcd_dsb();
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_lcd_clear(void* ctx, uint32_t color)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx");
  lcd_ctx_t*     c            = (lcd_ctx_t*)ctx;
  uint16_t*      pixels       = (uint16_t*)c->fb.pixels;
  const uint32_t pixels_total = (uint32_t)c->fb.width_px * (uint32_t)c->fb.height_px;
  const uint16_t rgb565       = (uint16_t)(color & k_rgb565_mask);
  for (uint32_t i = 0U; i < pixels_total; ++i) {
    pixels[i] = rgb565;
  }
#ifdef RA8_BOOT_ENABLE_CACHE_MPU
  /* Write the cleared pixels back from the write-back D-cache to SDRAM so the
   * GLCDC scan sees them (see internal_lcd_flush for the coherency rationale). The whole
   * framebuffer was just touched, so clean the whole contiguous span. */
  (void)ra8_cache_dcache_clean_by_addr(c->fb.pixels,
                                       (uint32_t)c->fb.stride_bytes * (uint32_t)c->fb.height_px);
#endif
  internal_lcd_dsb();
  return k_ra8_ok;
}

RA8_INTERNAL
static ra8_err_t internal_lcd_deinit(void* ctx)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx");
  lcd_ctx_t*      c   = (lcd_ctx_t*)ctx;
  const ra8_err_t err = ra8_glcdc_deinit();
  c->started          = false;
  c->fb.pixels        = nullptr;
  return err;
}
 
/* =============================================================================
 * Public iface instance
 * =============================================================================
 */
 
const display_backend_iface_t k_display_backend_lcd_ra8_glcdc = {
  .init            = internal_lcd_init,
  .get_caps        = internal_lcd_get_caps,
  .get_framebuffer = internal_lcd_get_framebuffer,
  .flush           = internal_lcd_flush,
  .clear           = internal_lcd_clear,
  .deinit          = internal_lcd_deinit,
};