main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_fs.h"
#include "ra8_io.h"
#include "ra8_isr.h"
#include "ra8_log.h"
#include "ra8_sdcard.h"
#include "ra8_sdhi.h"
#include "ra8_time.h"
 
/* =============================================================================
 * Tunables
 * =============================================================================
 */

typedef enum : uint32_t {
  k_sdhi_demo_uart_baud       = 115200U,      
  k_sdhi_demo_instance        = 0U,           
  k_sdhi_demo_payload_bytes   = 512U,         
  k_sdhi_demo_prng_seed       = 0xA5F00DadUL, 
  k_sdhi_demo_prng_mul        = 1664525UL,    
  k_sdhi_demo_prng_add        = 1013904223UL, 
  k_sdhi_demo_prng_byte_shift = 16U,          
  k_sdhi_demo_byte_mask       = 0xFFU,        
} sdhi_demo_config_t;
 
/* =============================================================================
 * Static message strings (ASCII-only per project policy)
 * =============================================================================
 */
 
static const uint8_t k_msg_boot[]      = "ra8_io_sdhi_demo: boot\r\n";
static const uint8_t k_msg_card_ok[]   = "ra8_io_sdhi_demo: card ready\r\n";
static const uint8_t k_msg_init_fail[] = "ra8_io_sdhi_demo: FAIL init\r\n";
static const uint8_t k_msg_pass[]      = "ra8_io_sdhi_demo: sd:/LOGS/A.TXT 512 bytes PASS\r\n";
static const uint8_t k_msg_fail[]      = "ra8_io_sdhi_demo: FAIL\r\n";

static const char k_mount_name[] = "sd";
static const char k_dir_path[]   = "sd:/LOGS";
static const char k_file_path[]  = "sd:/LOGS/A.TXT";

static const char* const s_tag = "ra8_io_sdhi_demo";
 
/* =============================================================================
 * UART output helpers
 * =============================================================================
 */

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

#define SDHI_DEMO_PUTS(lit) sdhi_demo_print((lit), (uint32_t)sizeof(lit) - 1U)

static void sdhi_demo_panic_halt(void)
{
  while (true) {
    __asm__ volatile("wfi");
  }
}
 
/* =============================================================================
 * Hardware bring-up
 * =============================================================================
 */

static void sdhi_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  if (ra8_cgc_init() != k_ra8_ok) {
    sdhi_demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    sdhi_demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    sdhi_demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_sdhi_demo_uart_baud) != k_ra8_ok) {
    sdhi_demo_panic_halt();
  }
  if (ra8_board_sdhi_pins_init() != k_ra8_ok) {
    sdhi_demo_panic_halt();
  }
}

static void sdhi_demo_init_card_or_halt(void)
{
  const ra8_sdcard_cfg_t cfg = {.instance = (uint8_t)k_sdhi_demo_instance};
  if (ra8_sdcard_init(&cfg) != k_ra8_ok) {
    SDHI_DEMO_PUTS(k_msg_init_fail);
    sdhi_demo_panic_halt();
  }
  SDHI_DEMO_PUTS(k_msg_card_ok);
}
 
/* =============================================================================
 * Payload + ra8_io round-trip
 * =============================================================================
 */

static uint8_t s_payload[k_sdhi_demo_payload_bytes];
static uint8_t s_readback[k_sdhi_demo_payload_bytes];

static ra8_io_blockdev_t s_bd;
static ra8_fs_backend_t  s_be;

static void sdhi_demo_fill_payload(void)
{
  uint32_t state = (uint32_t)k_sdhi_demo_prng_seed;
  for (uint32_t i = 0U; i < (uint32_t)k_sdhi_demo_payload_bytes; i++) {
    state        = (state * (uint32_t)k_sdhi_demo_prng_mul) + (uint32_t)k_sdhi_demo_prng_add;
    s_payload[i] = (uint8_t)((state >> k_sdhi_demo_prng_byte_shift) & k_sdhi_demo_byte_mask);
  }
}

[[nodiscard]] static ra8_err_t sdhi_demo_mount_via_io(void)
{
  RA8_RETURN_ON_ERROR(ra8_io_vfs_init(), s_tag, "vfs init");
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_sdhi_init(&s_bd), s_tag, "sdhi bind");
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_as_fs_backend(&s_bd, &s_be), s_tag, "fs bridge");
  ra8_fs_format_opts_t opts = {};
  opts.type                 = k_ra8_fs_type_fat16;
  opts.label                = "RAIOSD";
  RA8_RETURN_ON_ERROR(ra8_fs_format(&s_be, &opts), s_tag, "format");
  ra8_fs_mount_t* mnt = nullptr;
  RA8_RETURN_ON_ERROR(ra8_fs_mount(&s_be, &mnt), s_tag, "mount");
  RA8_RETURN_ON_ERROR(ra8_io_vfs_mount(k_mount_name, mnt), s_tag, "vfs mount");
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t sdhi_demo_write_payload(const char* path)
{
  ra8_fs_file_t* wf = nullptr;
  RA8_RETURN_ON_ERROR(ra8_io_vfs_open(path, k_ra8_fs_mode_write, &wf), s_tag, "open w");
  ra8_err_t err = ra8_fs_write(wf, s_payload, (uint32_t)k_sdhi_demo_payload_bytes);
  if (err != k_ra8_ok) {
    (void)ra8_fs_close(wf);
    return err;
  }
  return ra8_fs_close(wf);
}

[[nodiscard]] static ra8_err_t sdhi_demo_read_and_verify(const char* path)
{
  ra8_fs_file_t* rf = nullptr;
  RA8_RETURN_ON_ERROR(ra8_io_vfs_open(path, k_ra8_fs_mode_read, &rf), s_tag, "open r");
  memset(s_readback, 0, sizeof(s_readback));
  uint32_t  got = 0U;
  ra8_err_t err = ra8_fs_read(rf, s_readback, (uint32_t)k_sdhi_demo_payload_bytes, &got);
  (void)ra8_fs_close(rf);
  if (err != k_ra8_ok) {
    return err;
  }
  if (got != (uint32_t)k_sdhi_demo_payload_bytes) {
    return k_ra8_err_invalid_size;
  }
  if (memcmp(s_payload, s_readback, (size_t)k_sdhi_demo_payload_bytes) != 0) {
    return k_ra8_err_checksum_mismatch;
  }
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t sdhi_demo_roundtrip(void)
{
  RA8_RETURN_ON_ERROR(sdhi_demo_mount_via_io(), s_tag, "mount via io");
  RA8_RETURN_ON_ERROR(ra8_io_vfs_mkdir(k_dir_path), s_tag, "mkdir");
  RA8_RETURN_ON_ERROR(sdhi_demo_write_payload(k_file_path), s_tag, "write payload");
  RA8_RETURN_ON_ERROR(sdhi_demo_read_and_verify(k_file_path), s_tag, "read verify");
  return k_ra8_ok;
}
 
/* =============================================================================
 * Main
 * =============================================================================
 */

void main(void)
{
  sdhi_demo_setup_or_halt();
  ra8_isr_globals_enable();
  ra8_log_init();
  SDHI_DEMO_PUTS(k_msg_boot);
 
  sdhi_demo_init_card_or_halt();
  sdhi_demo_fill_payload();
 
  const ra8_err_t r = sdhi_demo_roundtrip();
  if (r != k_ra8_ok) {
    SDHI_DEMO_PUTS(k_msg_fail);
    sdhi_demo_panic_halt();
  }
  SDHI_DEMO_PUTS(k_msg_pass);
  (void)ra8_board_uart_console_flush();
 
  while (true) {
    __asm__ volatile("wfi");
  }
}