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_elc.h"
#include "ra8_err.h"
#include "ra8_gpio_constants.h"
#include "ra8_isr.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_sci.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_uart_irq_baud     = 115200U, 
  k_uart_irq_loop_ms  = 100U,    
  k_uart_irq_sci_chan = 8U,      
  k_uart_irq_isr_prio = 4U,      
} uart_irq_config_t;

typedef enum : uint16_t {
  k_uart_irq_event_rxi = 0x122U, 
  k_uart_irq_event_txi = 0x123U, 
  k_uart_irq_event_tei = 0x124U, 
} uart_irq_event_t;

static const ra8_port_pin_t k_uart_irq_pin_txd = (ra8_port_pin_t)k_ra8_board_uart_console_pin_txd;
static const ra8_port_pin_t k_uart_irq_pin_rxd = (ra8_port_pin_t)k_ra8_board_uart_console_pin_rxd;

static const uint8_t k_uart_irq_banner[] = "uart_irq_echo ready\r\n";

volatile uint32_t g_uart_irq_echoes = 0U;

static uint8_t s_uart_irq_rx_byte;

static void uart_irq_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}
 
/* ---- Interrupt service routines (registered via ra8_isr_register) ---------- */

static void uart_irq_rxi_isr(void* ctx)
{
  (void)ctx;
  ra8_sci_dispatch_rxi((uint8_t)k_uart_irq_sci_chan);
}

static void uart_irq_txi_isr(void* ctx)
{
  (void)ctx;
  ra8_sci_dispatch_txi((uint8_t)k_uart_irq_sci_chan);
}

static void uart_irq_tei_isr(void* ctx)
{
  (void)ctx;
  ra8_sci_dispatch_eri((uint8_t)k_uart_irq_sci_chan);
}

static void uart_irq_rx_cb(void* ctx, uint8_t byte)
{
  (void)ctx;
  g_uart_irq_echoes += 1U;
  (void)ra8_board_led_toggle(k_ra8_board_led1);
  s_uart_irq_rx_byte = byte;
  (void)ra8_sci_write((uint8_t)k_uart_irq_sci_chan, &s_uart_irq_rx_byte, 1U);
  (void)ra8_sci_read((uint8_t)k_uart_irq_sci_chan, &s_uart_irq_rx_byte, 1U);
}
 
/* ---- Bring-up ------------------------------------------------------------- */

[[nodiscard]] static ra8_err_t uart_irq_pins_init(void)
{
  ra8_err_t err =
    ra8_pfs_route_peripheral(k_uart_irq_pin_txd, k_ra8_psel_sci_async, "uart_irq.txd8");
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_pfs_route_peripheral(k_uart_irq_pin_rxd, k_ra8_psel_sci_async, "uart_irq.rxd8");
}

[[nodiscard]] static ra8_err_t uart_irq_register_isrs(void)
{
  ra8_err_t err = ra8_isr_register((ra8_elc_event_t)k_uart_irq_event_rxi,
                                   uart_irq_rxi_isr,
                                   nullptr,
                                   (uint8_t)k_uart_irq_isr_prio,
                                   nullptr);
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_isr_register((ra8_elc_event_t)k_uart_irq_event_txi,
                         uart_irq_txi_isr,
                         nullptr,
                         (uint8_t)k_uart_irq_isr_prio,
                         nullptr);
  if (err != k_ra8_ok) {
    return err;
  }
  return ra8_isr_register((ra8_elc_event_t)k_uart_irq_event_tei,
                          uart_irq_tei_isr,
                          nullptr,
                          (uint8_t)k_uart_irq_isr_prio,
                          nullptr);
}

static void uart_irq_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  uint32_t pclka_hz   = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    uart_irq_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    uart_irq_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, &pclka_hz) != k_ra8_ok) {
    uart_irq_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    uart_irq_panic_halt();
  }
  if (uart_irq_pins_init() != k_ra8_ok) {
    uart_irq_panic_halt();
  }
 
  const ra8_sci_cfg_t sci_cfg = {
    .baud      = k_uart_irq_baud,
    .data_bits = k_ra8_sci_data_8,
    .parity    = k_ra8_sci_parity_none,
    .stop_bits = k_ra8_sci_stop_1,
    .pclk_hz   = pclka_hz,
  };
  if (ra8_sci_init((uint8_t)k_uart_irq_sci_chan, &sci_cfg) != k_ra8_ok) {
    uart_irq_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    uart_irq_panic_halt();
  }
  if (ra8_isr_init() != k_ra8_ok) {
    uart_irq_panic_halt();
  }
  if (uart_irq_register_isrs() != k_ra8_ok) {
    uart_irq_panic_halt();
  }
}

void main(void)
{
  uart_irq_setup_or_halt();
 
  ra8_isr_globals_enable();
 
  /* Polled path: announce readiness (also exercises ra8_sci_write_polling). */
  (void)ra8_sci_write_polling((uint8_t)k_uart_irq_sci_chan,
                              k_uart_irq_banner,
                              (uint32_t)(sizeof(k_uart_irq_banner) - 1U));
 
  /* Attach the echo callback and arm the first interrupt-driven receive. */
  (void)ra8_sci_attach_rx_handler((uint8_t)k_uart_irq_sci_chan, uart_irq_rx_cb, nullptr);
  (void)ra8_sci_read((uint8_t)k_uart_irq_sci_chan, &s_uart_irq_rx_byte, 1U);
 
  while (1) {
    /* All echo work happens in the SCI ISRs; the loop only idles. */
    ra8_delay_ms((uint32_t)k_uart_irq_loop_ms);
  }
 
  uart_irq_panic_halt();
}