main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_err.h"
#include "ra8_i2c_bus_ops.h"
#include "ra8_i3c.h"
#include "ra8_io_i2c_bus.h"
#include "ra8_io_i2c_bus_i3c_compat.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_port_utils.h"
#include "ra8_smbus.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_sd_uart_baud = 115200U, 
  k_sd_bus_hz    = 100000U, 
  k_sd_iic_chan   = (uint32_t)k_ra8_board_mikrobus_iic_b_channel,
  k_sd_lsm_addr   = 0x6BU, 
  k_sd_reg_whoami = 0x0FU, 
  k_sd_whoami_val = 0x6CU, 
  k_sd_hex_shift  = 4U,    
  k_sd_hex_mask   = 0x0FU, 
  k_sd_dec_ten    = 10U,   
} sd_consts_t;

static const ra8_port_pin_t k_sd_pin_scl = (ra8_port_pin_t)k_ra8_board_mikrobus_i2c_scl;
static const ra8_port_pin_t k_sd_pin_sda = (ra8_port_pin_t)k_ra8_board_mikrobus_i2c_sda;

static ra8_io_i2c_bus_t s_sd_bus;
 
static const uint8_t k_msg_boot[] = "smbus-demo: boot\r\n";
static const uint8_t k_msg_fail[] = "smbus-demo: FAIL init\r\n";
static const uint8_t k_msg_open[] = "smbus: FAIL open\r\n";
static const uint8_t k_msg_nak[]  = "smbus: NAK (no LSM6DSO)\r\n";
static const uint8_t k_msg_bad[]  = "smbus: mismatch\r\n";
static const uint8_t k_msg_pre[]  = "smbus: whoami=";
static const uint8_t k_msg_mid[]  = " sendrecv=";
static const uint8_t k_msg_ok[]   = " PASS\r\n";

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

static void sd_panic_halt(const uint8_t* msg, uint32_t len)
{
  sd_print(msg, len);
  __asm__ volatile("bkpt #0");
  while (1) {
    __asm__ volatile("wfi");
  }
}

static void sd_print_hex8(uint8_t value)
{
  uint8_t        buf[2];
  const uint32_t hi = ((uint32_t)value >> (uint32_t)k_sd_hex_shift) & (uint32_t)k_sd_hex_mask;
  const uint32_t lo = (uint32_t)value & (uint32_t)k_sd_hex_mask;
  buf[0] = (uint8_t)((hi < (uint32_t)k_sd_dec_ten) ? ('0' + hi) : ('A' + (hi - k_sd_dec_ten)));
  buf[1] = (uint8_t)((lo < (uint32_t)k_sd_dec_ten) ? ('0' + lo) : ('A' + (lo - k_sd_dec_ten)));
  sd_print(buf, 2U);
}

[[nodiscard]] static ra8_err_t sd_pins_init(void)
{
  if (ra8_pfs_route_peripheral(k_sd_pin_scl, k_ra8_psel_iic, "smbus.scl1") != k_ra8_ok) {
    return k_ra8_err_hw_init_failed;
  }
  return ra8_pfs_route_peripheral(k_sd_pin_sda, k_ra8_psel_iic, "smbus.sda1");
}

static void sd_setup_or_halt(uint32_t* out_pclka_hz)
{
  uint32_t cpuclk0_hz = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) || (ra8_mstp_init() != k_ra8_ok)) {
    sd_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if ((ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) ||
      (ra8_cgc_get_clock_hz(k_ra8_clock_id_pclka, out_pclka_hz) != k_ra8_ok)) {
    sd_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    sd_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (sd_pins_init() != k_ra8_ok) {
    sd_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
  if (ra8_board_uart_console_init((uint32_t)k_sd_uart_baud) != k_ra8_ok) {
    sd_panic_halt(k_msg_fail, (uint32_t)sizeof(k_msg_fail) - 1U);
  }
}

static void sd_read_whoami_or_halt(uint8_t* out_a, uint8_t* out_b)
{
  uint8_t a = 0U;
  if (ra8_smbus_read_byte_data((uint8_t)k_sd_lsm_addr, (uint8_t)k_sd_reg_whoami, &a) != k_ra8_ok) {
    sd_panic_halt(k_msg_nak, (uint32_t)sizeof(k_msg_nak) - 1U);
  }
  uint8_t b = 0U;
  if (ra8_smbus_send_byte((uint8_t)k_sd_lsm_addr, (uint8_t)k_sd_reg_whoami) != k_ra8_ok) {
    sd_panic_halt(k_msg_nak, (uint32_t)sizeof(k_msg_nak) - 1U);
  }
  if (ra8_smbus_receive_byte((uint8_t)k_sd_lsm_addr, &b) != k_ra8_ok) {
    sd_panic_halt(k_msg_nak, (uint32_t)sizeof(k_msg_nak) - 1U);
  }
  if ((a != (uint8_t)k_sd_whoami_val) || (b != (uint8_t)k_sd_whoami_val)) {
    sd_panic_halt(k_msg_bad, (uint32_t)sizeof(k_msg_bad) - 1U);
  }
  *out_a = a;
  *out_b = b;
}

void main(void)
{
  uint32_t pclka_hz = 0U;
  sd_setup_or_halt(&pclka_hz);
  ra8_isr_globals_enable();
  sd_print(k_msg_boot, (uint32_t)sizeof(k_msg_boot) - 1U);
 
  /* App-owned bus bring-up: IIC_B in I2C-compat mode, bound through the
   * ra8_io facade into the SMBus layer's injected seam. A future board
   * revision that moves the bus onto a RIIC channel only swaps the bind. */
  const ra8_i3c_cfg_t iic_cfg = {.mode     = k_ra8_i3c_mode_i2c,
                                 .bus_hz   = (uint32_t)k_sd_bus_hz,
                                 .pclka_hz = pclka_hz};
  ra8_i2c_bus_ops_t   bus_ops = {};
  if (ra8_i3c_init((uint8_t)k_sd_iic_chan, &iic_cfg) != k_ra8_ok) {
    sd_panic_halt(k_msg_open, (uint32_t)sizeof(k_msg_open) - 1U);
  }
  if (ra8_io_i2c_bus_bind_i3c_compat(&s_sd_bus, (uint8_t)k_sd_iic_chan) != k_ra8_ok) {
    sd_panic_halt(k_msg_open, (uint32_t)sizeof(k_msg_open) - 1U);
  }
  if (ra8_io_i2c_bus_as_ops(&s_sd_bus, &bus_ops) != k_ra8_ok) {
    sd_panic_halt(k_msg_open, (uint32_t)sizeof(k_msg_open) - 1U);
  }
 
  const ra8_smbus_cfg_t cfg = {.bus = bus_ops, .pec_enabled = false};
  if (ra8_smbus_init(&cfg) != k_ra8_ok) {
    sd_panic_halt(k_msg_open, (uint32_t)sizeof(k_msg_open) - 1U);
  }
 
  uint8_t a = 0U;
  uint8_t b = 0U;
  sd_read_whoami_or_halt(&a, &b);
 
  sd_print(k_msg_pre, (uint32_t)sizeof(k_msg_pre) - 1U);
  sd_print_hex8(a);
  sd_print(k_msg_mid, (uint32_t)sizeof(k_msg_mid) - 1U);
  sd_print_hex8(b);
  sd_print(k_msg_ok, (uint32_t)sizeof(k_msg_ok) - 1U);
 
  while (1) {
    __asm__ volatile("wfi");
  }
}