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_err.h"
#include "ra8_fs.h"
#include "ra8_isr.h"
#include "ra8_time.h"
 
/*
 * The host unit-test build (RA8_OFF_TARGET) does not link the ThreadX /
 * LevelX vendor trees, so their headers are unreachable when clang-tidy
 * walks this file. Pull them in only on the cross-compile target.
 */
#ifndef RA8_OFF_TARGET
#include "lx_api.h"
#include "lx_fs_backend.h"
#include "lx_nor_driver_ra8_xspi.h"
#include "tx_api.h"
#endif

typedef enum : uint32_t {
  k_demo_baud         = 115200U, 
  k_demo_thread_stack = 8192U,   
  k_demo_file_chunk   = 64U,     
} demo_config_t;
 
#ifndef RA8_OFF_TARGET
static const char s_readme_text[] = "ra8_fs FAT on OSPI flash via LevelX.\r\n";

static const char s_readme_path[] = "/readme.txt";

static const char s_scratch_path[] = "/scratch.txt";
 
/* Statically-allocated control blocks (NASA P10 Rule 3 -- no dynamic memory). */
static LX_NOR_FLASH s_nor_flash;
 
static TX_THREAD s_demo_thread;
static UCHAR     s_demo_stack[k_demo_thread_stack];

static TX_MUTEX s_fs_mutex;
 
/* Mutable name -- the ThreadX/LevelX APIs take non-const CHAR*. */
static char s_lx_flash_name[] = "ra8_xspi_nor";
#endif /* !RA8_OFF_TARGET */

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

static void demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
 
  if (ra8_cgc_init() != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_time_init(cpuclk0_hz) != k_ra8_ok) {
    demo_panic_halt();
  }
  if (ra8_board_uart_console_init((uint32_t)k_demo_baud) != k_ra8_ok) {
    demo_panic_halt();
  }
}

static void demo_print(const char* s)
{
  if (s == (const char*)0) {
    return;
  }
  size_t len = strlen(s);
  (void)ra8_board_uart_console_write((const uint8_t*)s, len);
}
 
#ifndef RA8_OFF_TARGET
static void demo_fs_lock_acquire(void* ctx)
{
  (void)tx_mutex_get((TX_MUTEX*)ctx, TX_WAIT_FOREVER);
}

static void demo_fs_lock_release(void* ctx)
{
  (void)tx_mutex_put((TX_MUTEX*)ctx);
}

static bool demo_lx_open(void)
{
  if (lx_nor_flash_format(&s_nor_flash,
                          s_lx_flash_name,
                          lx_nor_driver_ra8_xspi_initialize,
                          LX_NULL) != LX_SUCCESS) {
    demo_print("[fs] lx_nor_flash_format failed\r\n");
    return false;
  }
  if (lx_nor_flash_open(&s_nor_flash, s_lx_flash_name, lx_nor_driver_ra8_xspi_initialize) !=
      LX_SUCCESS) {
    demo_print("[fs] lx_nor_flash_open failed\r\n");
    return false;
  }
  return true;
}

static bool demo_fs_format_mount(ra8_fs_backend_t* out_backend, ra8_fs_mount_t** out_mount)
{
  if (lx_fs_backend_bind(&s_nor_flash, out_backend) != k_ra8_ok) {
    demo_print("[fs] lx_fs_backend_bind failed\r\n");
    return false;
  }
  ra8_fs_format_opts_t opts = {};
  opts.type                 = k_ra8_fs_type_fat12;
  opts.label                = "RA8FS";
  if (ra8_fs_format(out_backend, &opts) != k_ra8_ok) {
    demo_print("[fs] ra8_fs_format failed\r\n");
    return false;
  }
  if (ra8_fs_mount(out_backend, out_mount) != k_ra8_ok) {
    demo_print("[fs] ra8_fs_mount failed\r\n");
    return false;
  }
  return true;
}

static bool demo_read_verify(ra8_fs_mount_t* mount, const char* path, const char* expected)
{
  ra8_fs_file_t* file = nullptr;
  if (ra8_fs_open(mount, path, k_ra8_fs_mode_read, &file) != k_ra8_ok) {
    demo_print("[fs] ra8_fs_open(read) failed\r\n");
    return false;
  }
  uint8_t  buf[k_demo_file_chunk];
  uint32_t off = 0U;
  bool     ok  = true;
  uint32_t got = 0U;
  do {
    got = 0U;
    if (ra8_fs_read(file, buf, (uint32_t)k_demo_file_chunk, &got) != k_ra8_ok) {
      ok = false;
      break;
    }
    if (got > 0U) {
      if (memcmp(buf, &expected[off], (size_t)got) != 0) {
        ok = false;
      }
      off += got;
    }
  } while (got > 0U);
  (void)ra8_fs_close(file);
  ok = ok && (off == (uint32_t)strlen(expected));
  return ok;
}

static void demo_list_entry(const char* name, uint8_t attr, uint64_t size, void* ctx)
{
  (void)attr;
  (void)size;
  (void)ctx;
  demo_print("  ");
  demo_print(name);
  demo_print("\r\n");
}

static void demo_file_ops(ra8_fs_mount_t* mount)
{
  const uint8_t* payload = (const uint8_t*)s_readme_text;
  uint32_t       len     = (uint32_t)strlen(s_readme_text);
  if (ra8_fs_write_file(mount, s_readme_path, payload, len) != k_ra8_ok) {
    demo_print("[fs] ra8_fs_write_file failed\r\n");
    return;
  }
  if (ra8_fs_write_file(mount, s_scratch_path, payload, len) != k_ra8_ok) {
    demo_print("[fs] ra8_fs_write_file failed\r\n");
    return;
  }
  demo_print("[fs] root listing:\r\n");
  if (ra8_fs_listdir(mount, "/", demo_list_entry, nullptr) != k_ra8_ok) {
    demo_print("[fs] ra8_fs_listdir failed\r\n");
    return;
  }
  if (!demo_read_verify(mount, s_readme_path, s_readme_text)) {
    demo_print("[fs] readback mismatch\r\n");
    return;
  }
  demo_print("[fs] readback verified\r\n");
  if (ra8_fs_unlink(mount, s_scratch_path) != k_ra8_ok) {
    demo_print("[fs] ra8_fs_unlink failed\r\n");
    return;
  }
  ra8_fs_stat_t st = {};
  if (ra8_fs_stat(mount, s_scratch_path, &st) != k_ra8_err_not_found) {
    demo_print("[fs] delete did not remove the file\r\n");
    return;
  }
  demo_print("[fs] ospi FAT roundtrip ok\r\n");
}

static void demo_thread_entry(ULONG thread_input)
{
  (void)thread_input;
 
  demo_print("[fs] formatting + opening LevelX on OSPI flash\r\n");
  if (!demo_lx_open()) {
    return;
  }
  demo_print("[fs] formatting + mounting FAT volume\r\n");
  ra8_fs_backend_t backend = {};
  ra8_fs_mount_t*  mount   = nullptr;
  if (!demo_fs_format_mount(&backend, &mount)) {
    (void)lx_nor_flash_close(&s_nor_flash);
    return;
  }
  demo_file_ops(mount);
  (void)ra8_fs_unmount(mount);
  (void)lx_nor_flash_close(&s_nor_flash);
  demo_print("[fs] done\r\n");
}

void tx_application_define(void* first_unused_memory)
{
  static CHAR s_mutex_name[]  = "ra8_fs";
  static CHAR s_thread_name[] = "fs_demo";
 
  (void)first_unused_memory;
 
  lx_nor_flash_initialize();
 
  (void)tx_mutex_create(&s_fs_mutex, s_mutex_name, TX_NO_INHERIT);
  const ra8_fs_lock_t lock = {
    .acquire = demo_fs_lock_acquire,
    .release = demo_fs_lock_release,
    .ctx     = &s_fs_mutex,
  };
  if (ra8_fs_set_lock(&lock) != k_ra8_ok) {
    demo_print("[fs] ra8_fs_set_lock failed\r\n");
  }
 
  (void)tx_thread_create(&s_demo_thread,
                         s_thread_name,
                         demo_thread_entry,
                         0U,
                         s_demo_stack,
                         (ULONG)sizeof(s_demo_stack),
                         8U, /* priority          */
                         8U, /* preempt threshold */
                         TX_NO_TIME_SLICE,
                         TX_AUTO_START);
}
#endif /* !RA8_OFF_TARGET */

void main(void)
{
  demo_setup_or_halt();
  ra8_isr_globals_enable();
  demo_print("[fs] booting ThreadX + ra8_fs on OSPI flash...\r\n");
 
#ifndef RA8_OFF_TARGET
  tx_kernel_enter();
#endif
 
  demo_panic_halt();
}