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_err.h"
#include "ra8_gpio_constants.h"
#include "ra8_i3c.h"
#include "ra8_isr.h"
#include "ra8_mpc.h"
#include "ra8_mstp.h"
#include "ra8_port_utils.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_i3c_demo_baud        = 115200U, 
  k_i3c_demo_period_ms   = 1000U,   
  k_i3c_demo_bus_hz      = 100000U, 
  k_i3c_demo_iic_channel = 0U,      
} i3c_demo_const_t;

typedef enum : uint8_t {
  k_i3c_demo_probe_addr = 0x43U, 
} i3c_demo_byte_t;

static const ra8_port_pin_t k_i3c_demo_pin_scl = (ra8_port_pin_t)k_ra8_board_i3c0_pin_scl;
static const ra8_port_pin_t k_i3c_demo_pin_sda = (ra8_port_pin_t)k_ra8_board_i3c0_pin_sda;
 
/* Controller bring-up banners. Reaching this loop at all proves
 * ra8_i3c_init configured + powered the I3C controller on real silicon
 * (init failure panic-halts before the loop), so every banner leads with
 * "i3c: ctrl init ok". The scan outcome is reported but not gated: on a
 * bare EVM the ch0/J27 bus floats (no device, no pull-ups) so the
 * transaction cannot complete -- attach a device to J27 to see ack=1. */
static const uint8_t k_i3c_demo_msg_ack[]  = "i3c: ctrl init ok | scan 0x43 ack=1\r\n";
static const uint8_t k_i3c_demo_msg_nack[] = "i3c: ctrl init ok | scan 0x43 ack=0\r\n";
static const uint8_t k_i3c_demo_msg_err[]  = "i3c: ctrl init ok | bus idle on J27 (bare EVM)\r\n";

static void i3c_demo_panic_halt(void)
{
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void i3c_demo_clocks_or_halt(uint32_t* out_pclka_hz)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    i3c_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    i3c_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, out_pclka_hz) != k_ra8_ok) {
    i3c_demo_panic_halt();
  }
  if (ra8_mstp_init() != k_ra8_ok) {
    i3c_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    i3c_demo_panic_halt();
  }
}

static void i3c_demo_pfs_or_halt(void)
{
  if (ra8_pfs_route_peripheral(k_i3c_demo_pin_scl, k_ra8_psel_iic, "i3c_loopback.scl0") !=
      k_ra8_ok) {
    i3c_demo_panic_halt();
  }
  if (ra8_pfs_route_peripheral(k_i3c_demo_pin_sda, k_ra8_psel_iic, "i3c_loopback.sda0") !=
      k_ra8_ok) {
    i3c_demo_panic_halt();
  }
 
  /* IIC_B requires N-channel open-drain on SCL/SDA so the on-board
   * pullups can win bus arbitration; ra8_pfs_route_peripheral routes
   * the IIC mux but leaves NCODR clear (push-pull). Mirrors the
   * same NCODR write in
   * ra8_board_ek_ra8d2.c::internal_io_expander_route_pins.
   * HUM Ch 20.2.1 "PmnPFS Register" p 855 + HUM Ch 40 "IIC_B" p 2436 */
  if (ra8_mpc_set_open_drain(k_ra8_port_4, k_ra8_pin_0, true) != k_ra8_ok) {
    i3c_demo_panic_halt();
  }
  if (ra8_mpc_set_open_drain(k_ra8_port_4, k_ra8_pin_1, true) != k_ra8_ok) {
    i3c_demo_panic_halt();
  }
}

static void i3c_demo_setup_or_halt(void)
{
  uint32_t pclka_hz = 0U;
  i3c_demo_clocks_or_halt(&pclka_hz);
  i3c_demo_pfs_or_halt();
 
  if (ra8_board_uart_console_init((uint32_t)k_i3c_demo_baud) != k_ra8_ok) {
    i3c_demo_panic_halt();
  }
  const ra8_i3c_cfg_t iic_cfg = {
    .mode     = k_ra8_i3c_mode_i2c,
    .bus_hz   = k_i3c_demo_bus_hz,
    .pclka_hz = pclka_hz,
  };
  if (ra8_i3c_init((uint8_t)k_i3c_demo_iic_channel, &iic_cfg) != k_ra8_ok) {
    i3c_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led1) != k_ra8_ok) {
    i3c_demo_panic_halt();
  }
  if (ra8_board_led_init(k_ra8_board_led2) != k_ra8_ok) {
    i3c_demo_panic_halt();
  }
}

void main(void)
{
  i3c_demo_setup_or_halt();
  ra8_isr_globals_enable();
 
  while (1) {
    bool            acked = false;
    const ra8_err_t err =
      ra8_i3c_scan((uint8_t)k_i3c_demo_iic_channel, (uint8_t)k_i3c_demo_probe_addr, &acked);
    const uint8_t* msg     = k_i3c_demo_msg_err;
    uint32_t       msg_len = (uint32_t)(sizeof(k_i3c_demo_msg_err) - 1U);
    if (err == k_ra8_ok) {
      if (acked) {
        msg     = k_i3c_demo_msg_ack;
        msg_len = (uint32_t)(sizeof(k_i3c_demo_msg_ack) - 1U);
      } else {
        msg     = k_i3c_demo_msg_nack;
        msg_len = (uint32_t)(sizeof(k_i3c_demo_msg_nack) - 1U);
      }
    }
    if (ra8_board_uart_console_write(msg, (size_t)msg_len) != k_ra8_ok) {
      break;
    }
    if (ra8_board_led_toggle(k_ra8_board_led1) != k_ra8_ok) {
      break;
    }
    ra8_delay_ms(k_i3c_demo_period_ms);
  }
 
  i3c_demo_panic_halt();
}