ra8_board_ek_ra8d2.c

Go to the documentation of this file.

 
#include "ra8_board_ek_ra8d2.h"
 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_elc_regs.h"
#include "ra8_err.h"
#include "ra8_gpio_constants.h"
#include "ra8_icu.h"
#include "ra8_icu_regs.h"
#include "ra8_isr.h"
#include "ra8_pfs_regs.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_time.h"
 
/* =============================================================================
 * Board identity strings (UM cover page, R20UT5523EG0101 Rev 1.01)
 * =============================================================================
 */
 
const char* const k_ra8_board_name    = "EK-RA8D2 v1";
const char* const k_ra8_board_doc_rev = "R20UT5523EG0101 Rev 1.01";
const char* const k_ra8_board_mcu     = "R7KA8D2KFLCAC";
 
ra8_err_t ra8_board_get_info(ra8_board_info_t* out)
{
  if (out == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  out->name    = k_ra8_board_name;
  out->doc_rev = k_ra8_board_doc_rev;
  out->mcu     = k_ra8_board_mcu;
  return k_ra8_ok;
}
 
/* =============================================================================
 * 1. User LEDs (UM Table 24, page 31)
 * =============================================================================
 */

static const ra8_port_pin_t s_led_pins[k_ra8_board_led_count] = {
  [k_ra8_board_led1] = (ra8_port_pin_t)RA8_PIN(k_ra8_port_6, k_ra8_pin_0),  
  [k_ra8_board_led2] = (ra8_port_pin_t)RA8_PIN(k_ra8_port_3, k_ra8_pin_3),  
  [k_ra8_board_led3] = (ra8_port_pin_t)RA8_PIN(k_ra8_port_10, k_ra8_pin_7), 
};
 
ra8_err_t ra8_board_led_pin(ra8_board_led_id_t led, ra8_port_pin_t* out_pin)
{
  if (out_pin == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  if ((uint8_t)led >= (uint8_t)k_ra8_board_led_count) {
    return k_ra8_err_invalid_arg;
  }
  *out_pin = s_led_pins[led];
  return k_ra8_ok;
}
 
ra8_err_t ra8_board_led_init(ra8_board_led_id_t led)
{
  ra8_port_pin_t pin = k_ra8_pin_none;
  ra8_err_t      err = ra8_board_led_pin(led, &pin);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_gpio_output_init(pin, k_ra8_level_low);
}
 
ra8_err_t ra8_board_led_on(ra8_board_led_id_t led)
{
  ra8_port_pin_t pin = k_ra8_pin_none;
  ra8_err_t      err = ra8_board_led_pin(led, &pin);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_gpio_write(pin, k_ra8_level_high);
}
 
ra8_err_t ra8_board_led_off(ra8_board_led_id_t led)
{
  ra8_port_pin_t pin = k_ra8_pin_none;
  ra8_err_t      err = ra8_board_led_pin(led, &pin);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_gpio_write(pin, k_ra8_level_low);
}
 
ra8_err_t ra8_board_led_toggle(ra8_board_led_id_t led)
{
  ra8_port_pin_t pin = k_ra8_pin_none;
  ra8_err_t      err = ra8_board_led_pin(led, &pin);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_gpio_toggle(pin);
}
 
/* =============================================================================
 * 2. User switches (UM Table 25, page 32)
 * =============================================================================
 */

static const ra8_port_pin_t s_sw_pins[k_ra8_board_sw_count] = {
  [k_ra8_board_sw1] = (ra8_port_pin_t)RA8_PIN(k_ra8_port_0, k_ra8_pin_9), 
  [k_ra8_board_sw2] = (ra8_port_pin_t)RA8_PIN(k_ra8_port_0, k_ra8_pin_8), 
};

static const uint8_t s_sw_irq_nums[k_ra8_board_sw_count] = {
  [k_ra8_board_sw1] = (uint8_t)k_ra8_board_sw1_irq, 
  [k_ra8_board_sw2] = (uint8_t)k_ra8_board_sw2_irq, 
};
 
ra8_err_t ra8_board_sw_pin(ra8_board_sw_id_t sw, ra8_port_pin_t* out_pin)
{
  if (out_pin == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  if ((uint8_t)sw >= (uint8_t)k_ra8_board_sw_count) {
    return k_ra8_err_invalid_arg;
  }
  *out_pin = s_sw_pins[sw];
  return k_ra8_ok;
}
 
ra8_err_t ra8_board_sw_init(ra8_board_sw_id_t sw)
{
  ra8_port_pin_t pin = k_ra8_pin_none;
  ra8_err_t      err = ra8_board_sw_pin(sw, &pin);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_gpio_input_init(pin, k_ra8_pull_up);
}
 
ra8_err_t ra8_board_sw_read(ra8_board_sw_id_t sw, ra8_board_sw_state_t* out_pressed)
{
  if (out_pressed == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  ra8_port_pin_t pin = k_ra8_pin_none;
  ra8_err_t      err = ra8_board_sw_pin(sw, &pin);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_level_t lvl = k_ra8_level_high;
  err             = ra8_gpio_read(pin, &lvl);
  if (err != k_ra8_ok) {
    /* ra8_gpio_read returns k_ra8_ok for valid port-0 SW pins off-target. */
    return err; /* GCOVR_EXCL_LINE -- static board pin table cannot fail validation */
  }
  /* Buttons are active-low: low level == pressed. */
  *out_pressed = (lvl == k_ra8_level_low) ? k_ra8_board_sw_pressed : k_ra8_board_sw_released;
  return k_ra8_ok;
}
 
ra8_err_t ra8_board_sw_attach_irq(ra8_board_sw_id_t sw, ra8_board_sw_irq_cb_t cb, void* ctx)
{
  if (cb == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  if ((uint8_t)sw >= (uint8_t)k_ra8_board_sw_count) {
    return k_ra8_err_invalid_arg;
  }
  /* Step 1: configure the ICU IRQ pin for falling-edge detection so a
   * button press (active-low; UM Table 25 p 32) latches IRQCR[12] /
   * IRQCR[13]. The digital filter samples at PCLKB to debounce
   * contact bounce; HUM Ch 14.2.12 (p 535) describes IRQCRi fields. */
  const ra8_icu_irq_cfg_t cfg = {
    .sense      = k_ra8_icu_irqmd_falling,
    .filter_div = k_ra8_icu_fclksel_pclkb,
    .filter_en  = true,
  };
  ra8_err_t err = ra8_icu_configure_irq_pin(s_sw_irq_nums[sw], &cfg);
  if (err != k_ra8_ok) {
    /* ra8_icu_configure_irq_pin succeeds for IRQ12/13 (well within 32-channel limit). */
    return err; /* GCOVR_EXCL_LINE -- static board pin table cannot fail validation */
  }
 
  /* Step 2: route the ELC event for IRQ12-DS / IRQ13-DS through an
   * IELSR slot and enable the matching NVIC line. SW1 -> IRQ13-DS
   * (event 0x00E), SW2 -> IRQ12-DS (event 0x00D). */
  const ra8_elc_event_t evt =
    (sw == k_ra8_board_sw1) ? k_ra8_elc_event_icu_irq13 : k_ra8_elc_event_icu_irq12;
  return ra8_isr_register(evt, (ra8_isr_handler_t)cb, ctx, k_ra8_isr_prio_default, nullptr);
}
 
/* =============================================================================
 * 3. Parallel-RGB GLCDC pin tables (UM Table 33 p 42)
 * =============================================================================
 */

const ra8_board_glcdc_pin_t g_ra8_board_glcdc_rgb888_pins[] = {
  {.signal = "BLEN",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_14)}, 
  {.signal = "SDA1",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_11)}, 
  {.signal = "INT",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_1, k_ra8_pin_11)}, 
  {.signal = "SCL1",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_12)}, 
  {.signal = "RST",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_6, k_ra8_pin_6)}, 
  {.signal = "TCON0",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_8, k_ra8_pin_6)}, 
  {.signal = "CLK",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_15)}, 
  {.signal = "TCON2",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_8, k_ra8_pin_7)}, 
  {.signal = "TCON1",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_8, k_ra8_pin_5)}, 
  {.signal = "EXTCLK",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_7, k_ra8_pin_10)}, 
  {.signal = "TCON3",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_13)}, 
  {.signal = "B1",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_15)}, 
  {.signal = "B0",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_14)}, 
  {.signal = "B3",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_2)}, 
  {.signal = "B2",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_3)}, 
  {.signal = "B5",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_11)}, 
  {.signal = "B4",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_10)}, 
  {.signal = "B7",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_13)}, 
  {.signal = "B6",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_12)}, 
  {.signal = "G1",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_2, k_ra8_pin_7)}, 
  {.signal = "G0",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_4)}, 
  {.signal = "G3",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_6)}, 
  {.signal = "G2",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_7)}, 
  {.signal = "G5",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_1)}, 
  {.signal = "G4",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_5)}, 
  {.signal = "G7",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_3)}, 
  {.signal = "G6",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_4)}, 
  {.signal = "R1",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_0)}, 
  {.signal = "R0",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_2)}, 
  {.signal = "R3",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_7, k_ra8_pin_11)}, 
  {.signal = "R2",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_7, k_ra8_pin_7)}, 
  {.signal = "R5",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_7, k_ra8_pin_13)}, 
  {.signal = "R4",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_7, k_ra8_pin_12)}, 
  {.signal = "R7",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_7, k_ra8_pin_15)}, 
  {.signal = "R6",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_7, k_ra8_pin_14)}, 
};

const ra8_board_glcdc_pin_t g_ra8_board_glcdc_rgb666_pins[] = {
  {.signal = "BLEN", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_14)},
  {.signal = "SDA1", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_11)},
  {.signal = "INT", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_1, k_ra8_pin_11)},
  {.signal = "SCL1", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_12)},
  {.signal = "RST", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_6, k_ra8_pin_6)},
  {.signal = "TCON0", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_8, k_ra8_pin_6)},
  {.signal = "CLK", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_15)},
  {.signal = "TCON2", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_8, k_ra8_pin_7)},
  {.signal = "TCON1", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_8, k_ra8_pin_5)},
  {.signal = "EXTCLK", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_7, k_ra8_pin_10)},
  {.signal = "TCON3", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_13)},
  {.signal = "B3",
   .pin    = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_15)}, 
  {.signal = "B2", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_14)},
  {.signal = "B5", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_2)},
  {.signal = "B4", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_3)},
  {.signal = "B7", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_11)},
  {.signal = "B6", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_10)},
  {.signal = "G3", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_13)},
  {.signal = "G2", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_12)},
  {.signal = "G5", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_2, k_ra8_pin_7)},
  {.signal = "G4", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_4)},
  {.signal = "G7", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_6)},
  {.signal = "G6", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_7)},
  {.signal = "R3", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_1)},
  {.signal = "R2", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_5)},
  {.signal = "R5", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_3)},
  {.signal = "R4", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_4)},
  {.signal = "R7", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_0)},
  {.signal = "R6", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_2)},
};

const ra8_board_glcdc_pin_t g_ra8_board_glcdc_rgb565_pins[] = {
  {.signal = "BLEN", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_14)},
  {.signal = "SDA1", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_11)},
  {.signal = "INT", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_1, k_ra8_pin_11)},
  {.signal = "SCL1", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_12)},
  {.signal = "RST", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_6, k_ra8_pin_6)},
  {.signal = "TCON0", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_8, k_ra8_pin_6)},
  {.signal = "CLK", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_15)},
  {.signal = "TCON2", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_8, k_ra8_pin_7)},
  {.signal = "TCON1", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_8, k_ra8_pin_5)},
  {.signal = "EXTCLK", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_7, k_ra8_pin_10)},
  {.signal = "TCON3", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_5, k_ra8_pin_13)},
  {.signal = "B4", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_15)},
  {.signal = "B3", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_14)},
  {.signal = "B6", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_2)},
  {.signal = "B5", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_3)},
  {.signal = "G2", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_11)},
  {.signal = "B7", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_10)},
  {.signal = "G4", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_13)},
  {.signal = "G3", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_12)},
  {.signal = "G6", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_2, k_ra8_pin_7)},
  {.signal = "G5", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_9, k_ra8_pin_4)},
  {.signal = "R3", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_6)},
  {.signal = "G7", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_7)},
  {.signal = "R5", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_1)},
  {.signal = "R4", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_5)},
  {.signal = "R7", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_3)},
  {.signal = "R6", .pin = (ra8_port_pin_t)RA8_PIN(k_ra8_port_11, k_ra8_pin_4)},
};
 
const uint32_t g_ra8_board_glcdc_rgb888_pin_count =
  sizeof(g_ra8_board_glcdc_rgb888_pins) / sizeof(g_ra8_board_glcdc_rgb888_pins[0]);
const uint32_t g_ra8_board_glcdc_rgb666_pin_count =
  sizeof(g_ra8_board_glcdc_rgb666_pins) / sizeof(g_ra8_board_glcdc_rgb666_pins[0]);
const uint32_t g_ra8_board_glcdc_rgb565_pin_count =
  sizeof(g_ra8_board_glcdc_rgb565_pins) / sizeof(g_ra8_board_glcdc_rgb565_pins[0]);

RA8_INTERNAL static bool internal_glcdc_signal_starts_with(const char* s, const char* prefix)
{
  for (uint32_t i = 0U; i < 4U; i++) { /* longest prefix here is "TCON" = 4. */
    if (prefix[i] == '\0') {
      return true;
    }
    if (s[i] != prefix[i]) {
      return false;
    }
  }
  return true;
}

RA8_INTERNAL static bool internal_glcdc_signal_is_color_data(const char* signal)
{
  /* Match R0..R9 / G0..G9 / B0..B9; digit in [1] excludes BLEN. */
  const char c0 = signal[0];
  if (c0 != 'R') {
    if (c0 != 'G') {
      if (c0 != 'B') {
        return false;
      }
    }
  }
  const char c1 = signal[1];
  if (c1 < '0') {
    /* No EK-RA8D2 GLCDC pin table entry starts with R/G/B followed by ASCII < '0'. */
    return false; /* GCOVR_EXCL_LINE -- static board pin table cannot fail validation */
  }
  if (c1 > '9') {
    return false;
  }
  return true;
}

RA8_INTERNAL static bool internal_glcdc_signal_is_output(const char* signal)
{
  if (internal_glcdc_signal_starts_with(signal, "TCON")) {
    return true;
  }
  if (internal_glcdc_signal_starts_with(signal, "CLK")) {
    return true;
  }
  return internal_glcdc_signal_is_color_data(signal);
}

RA8_INTERNAL static void internal_glcdc_force_pin_output(ra8_port_pin_t pin)
{
  enum : uint32_t {
    k_pfs_psel_shift = 24U,      
    k_pfs_pmr_bit    = 1U << 16, 
    k_pfs_pdr_bit    = 1U << 2,  
  };
  const ra8_port_t         port = RA8_PIN_PORT(pin);
  const ra8_pin_t          bit  = RA8_PIN_PIN(pin);
  volatile uint32_t* const pfs  = ra8_pfs_pmn(port, bit);
  if (pfs == nullptr) {
    /* ra8_pfs_pmn is non-null for every hardcoded board pin in the GLCDC table. */
    return; /* GCOVR_EXCL_LINE -- static board pin table cannot fail validation */
  }
  ra8_pfs_pwpr_unlock();
  *pfs = ((uint32_t)k_ra8_psel_glcdc << k_pfs_psel_shift) | k_pfs_pmr_bit | k_pfs_pdr_bit;
  ra8_pfs_pwpr_lock();
}
 
ra8_err_t ra8_board_glcdc_init(ra8_board_glcdc_fmt_t fmt)
{
  const ra8_board_glcdc_pin_t* table = nullptr;
  uint32_t                     count = 0U;
 
  switch (fmt) {
    case k_ra8_board_glcdc_fmt_rgb888:
      table = g_ra8_board_glcdc_rgb888_pins;
      count = g_ra8_board_glcdc_rgb888_pin_count;
      break;
    case k_ra8_board_glcdc_fmt_rgb666:
      table = g_ra8_board_glcdc_rgb666_pins;
      count = g_ra8_board_glcdc_rgb666_pin_count;
      break;
    case k_ra8_board_glcdc_fmt_rgb565:
      table = g_ra8_board_glcdc_rgb565_pins;
      count = g_ra8_board_glcdc_rgb565_pin_count;
      break;
    default:
      return k_ra8_err_invalid_arg;
  }
 
  for (uint32_t i = 0U; i < count; ++i) {
    if (!internal_glcdc_signal_is_output(table[i].signal)) {
      continue; /* GPIO/I2C/clock-input -- not a GLCDC peripheral pin. */
    }
    const ra8_err_t err =
      ra8_pfs_route_peripheral(table[i].pin, k_ra8_psel_glcdc, "ra8_board.glcdc");
    if (err != k_ra8_ok) {
      return err;
    }
    /* Override PFS with PSEL + PMR + PDR=1 so the chip drives the
     * pin as an output instead of leaving it as an input under
     * peripheral control. */
    internal_glcdc_force_pin_output(table[i].pin);
  }
  return k_ra8_ok;
}

ra8_err_t ra8_board_lcd_panel_power_on(void)
{
  enum : uint32_t {
    k_reset_pulse_ms = 50U, 
  };
  ra8_err_t err = ra8_gpio_output_init(k_ra8_pin_lcd_reset_l, k_ra8_level_low);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_delay_ms(k_reset_pulse_ms);
  err = ra8_gpio_write(k_ra8_pin_lcd_reset_l, k_ra8_level_high);
  if (err != k_ra8_ok) {
    /* ra8_gpio_write returns k_ra8_ok for valid port/pin pairs off-target. */
    return err; /* GCOVR_EXCL_LINE -- static board pin table cannot fail validation */
  }
  ra8_delay_ms(k_reset_pulse_ms);
  return ra8_gpio_output_init(k_ra8_pin_lcd_blen, k_ra8_level_high);
}
 
ra8_err_t ra8_board_backlight_set(bool on)
{
  /* BLEN (P514) is already a GPIO output after ra8_board_lcd_panel_power_on;
   * drive it high to light the panel backlight, low to blank it. Active-high,
   * so `on` maps directly to the output level. */
  return ra8_gpio_write(k_ra8_pin_lcd_blen, on ? k_ra8_level_high : k_ra8_level_low);
}
 
/* =============================================================================
 * 3b. Octo-SPI flash pin routing (UM Table 29 p 35, IS25LX512M-JHLE)
 * =============================================================================
 */

static const ra8_port_pin_t s_xspi_octa_pins[] = {
  (ra8_port_pin_t)k_ra8_board_xspi_cs,  
  (ra8_port_pin_t)k_ra8_board_xspi_clk, 
  (ra8_port_pin_t)k_ra8_board_xspi_dqs, 
  (ra8_port_pin_t)k_ra8_board_xspi_dq0, 
  (ra8_port_pin_t)k_ra8_board_xspi_dq1, 
  (ra8_port_pin_t)k_ra8_board_xspi_dq2, 
  (ra8_port_pin_t)k_ra8_board_xspi_dq3, 
  (ra8_port_pin_t)k_ra8_board_xspi_dq4, 
  (ra8_port_pin_t)k_ra8_board_xspi_dq5, 
  (ra8_port_pin_t)k_ra8_board_xspi_dq6, 
  (ra8_port_pin_t)k_ra8_board_xspi_dq7, 
};

typedef enum : uint32_t {
  k_ra8_board_xspi_reset_low_ms  = 1U,  
  k_ra8_board_xspi_reset_high_ms = 15U, 
} ra8_board_xspi_reset_timing_t;
 
ra8_err_t ra8_board_xspi_pins_init(void)
{
  /* Step 1: drive RESET_L low while the pin is still GPIO. PSEL=0x00
   * + PDR=output is the IS25LX512M strap that holds the chip in
   * reset (datasheet Ch 9.2). EK-RA8D2 UM Table 29 maps RESET_L to
   * P106. */
  const ra8_port_pin_t reset_pin = (ra8_port_pin_t)k_ra8_board_xspi_reset;
  ra8_err_t            err       = ra8_gpio_output_init(reset_pin, k_ra8_level_low);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_delay_ms((uint32_t)k_ra8_board_xspi_reset_low_ms);
 
  /* Step 2: drive RESET_L high to release the chip. */
  err = ra8_gpio_write(reset_pin, k_ra8_level_high);
  if (err != k_ra8_ok) {
    /* ra8_gpio_write returns k_ra8_ok for valid port/pin pairs off-target. */
    return err; /* GCOVR_EXCL_LINE -- static board pin table cannot fail validation */
  }
  ra8_delay_ms((uint32_t)k_ra8_board_xspi_reset_high_ms);
 
  /* Step 3: route the 12 OCTA bus pins to PSEL=0x1C. PSEL 0x1C is
   * shared between the QSPI and Octo-SPI controllers per HUM Ch 20.6
   * "Multiplexed Pin Function Selector" p 871; the named constant
   * is ``k_ra8_psel_qspi`` for legacy reasons. */
  const uint32_t count = (uint32_t)(sizeof(s_xspi_octa_pins) / sizeof(s_xspi_octa_pins[0]));
  for (uint32_t i = 0U; i < count; ++i) {
    err = ra8_pfs_route_peripheral(s_xspi_octa_pins[i], k_ra8_psel_qspi, "ra8_board.xspi");
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_ok;
}
 
/* =============================================================================
 * 6d. Native SDHI bus pin routing (SDHI0, port 4 pins 0..7)
 * =============================================================================
 */

static const ra8_port_pin_t s_sdhi_bus_pins[] = {
  (ra8_port_pin_t)k_ra8_board_sdhi_cmd,  
  (ra8_port_pin_t)k_ra8_board_sdhi_clk,  
  (ra8_port_pin_t)k_ra8_board_sdhi_dat0, 
  (ra8_port_pin_t)k_ra8_board_sdhi_dat1, 
  (ra8_port_pin_t)k_ra8_board_sdhi_dat2, 
  (ra8_port_pin_t)k_ra8_board_sdhi_dat3, 
  (ra8_port_pin_t)k_ra8_board_sdhi_wp,   
  (ra8_port_pin_t)k_ra8_board_sdhi_cd,   
};
 
ra8_err_t ra8_board_sdhi_pins_init(void)
{
  /* Route the eight SDHI0 bus pins to PSEL=0x15. PSEL 0x15 is the SDHI
   * SD / MMC function per chip HUM Ch 20.6 "Multiplexed Pin Function
   * Selector"; the named constant is ``k_ra8_psel_sdhi``. */
  const uint32_t count = (uint32_t)(sizeof(s_sdhi_bus_pins) / sizeof(s_sdhi_bus_pins[0]));
  for (uint32_t i = 0U; i < count; ++i) {
    const ra8_err_t err =
      ra8_pfs_route_peripheral(s_sdhi_bus_pins[i], k_ra8_psel_sdhi, "ra8_board.sdhi");
    if (err != k_ra8_ok) {
      return err;
    }
  }
  return k_ra8_ok;
}
 
/* =============================================================================
 * 5. Arduino header (UM Table 20, page 28)
 * =============================================================================
 */
 
ra8_err_t ra8_board_arduino_pin_init(ra8_board_arduino_pin_t pin, ra8_board_arduino_mode_t mode)
{
  switch (mode) {
    case k_ra8_board_arduino_mode_input:
      return ra8_gpio_input_init((ra8_port_pin_t)pin, k_ra8_pull_none);
    case k_ra8_board_arduino_mode_input_pullup:
      return ra8_gpio_input_init((ra8_port_pin_t)pin, k_ra8_pull_up);
    case k_ra8_board_arduino_mode_output:
      return ra8_gpio_output_init((ra8_port_pin_t)pin, k_ra8_level_low);
    default:
      return k_ra8_err_invalid_arg;
  }
}
 
ra8_err_t ra8_board_arduino_gpio_write(ra8_board_arduino_pin_t pin, ra8_level_t level)
{
  return ra8_gpio_write((ra8_port_pin_t)pin, level);
}
 
ra8_err_t ra8_board_arduino_gpio_read(ra8_board_arduino_pin_t pin, ra8_level_t* out_level)
{
  if (out_level == nullptr) {
    return k_ra8_err_invalid_arg;
  }
  return ra8_gpio_read((ra8_port_pin_t)pin, out_level);
}