main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.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_log.h"
#include "ra8_port_constants.h"
#include "ra8_port_utils.h"
#include "ra8_sci.h"
#include "ra8_time.h"
#include "ra8_vfs_compress.h"

typedef enum : uint32_t {
  k_demo_uart_chan   = 8U,      
  k_demo_uart_baud   = 115200U, 
  k_demo_disk_blocks = 512U,    
  k_demo_payload     = 4096U,   
  k_demo_blob_cap    = 8192U,   
  k_demo_pin_shift   = 8U,      
  k_demo_seed_mul    = 31U,     
  k_demo_pattern_mod = 7U,      
} demo_const_t;

static const ra8_port_pin_t s_demo_txd =
  (ra8_port_pin_t)(((uint16_t)k_ra8_port_13 << (uint16_t)k_demo_pin_shift) | (uint16_t)k_ra8_pin_2);
static const ra8_port_pin_t s_demo_rxd =
  (ra8_port_pin_t)(((uint16_t)k_ra8_port_13 << (uint16_t)k_demo_pin_shift) | (uint16_t)k_ra8_pin_3);

static uint8_t s_disk[(size_t)k_demo_disk_blocks * (size_t)k_ra8_io_block_size_bytes];

static ra8_io_blockdev_t           s_bd_ram;
static ra8_io_blockdev_ram_state_t s_bstate_ram;
static ra8_io_blockdev_t           s_bd_dr;
static ra8_io_blockdev_ram_state_t s_bstate_dr;
static ra8_fs_backend_t s_be_ram;
static ra8_fs_backend_t s_be_dr;

static ra8_io_stream_t            s_uart;
static ra8_io_stream_uart_state_t s_ust;

static uint8_t s_payload[(size_t)k_demo_payload];
static uint8_t s_blob[(size_t)k_demo_blob_cap];
static uint8_t s_restored[(size_t)k_demo_payload];
static uint8_t s_scratch[(size_t)k_ra8_compress_scratch_bytes];

static const char* const s_tag = "compress_demo";

RA8_INTERNAL static void internal_demo_print(const char* msg)
{
  (void)ra8_io_stream_puts(&s_uart, msg);
}

RA8_INTERNAL static void internal_demo_setup_or_halt(void)
{
  uint32_t cpuclk0_hz = 0U;
  uint32_t pclka_hz   = 0U;
  if ((ra8_cgc_init() != k_ra8_ok) ||
      (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, &pclka_hz) != k_ra8_ok) ||
      (ra8_time_init(cpuclk0_hz) != k_ra8_ok) ||
      (ra8_pfs_route_peripheral(s_demo_txd, k_ra8_psel_sci_async, "demo.txd") != k_ra8_ok) ||
      (ra8_pfs_route_peripheral(s_demo_rxd, k_ra8_psel_sci_async, "demo.rxd") != k_ra8_ok)) {
    while (true) {
    }
  }
  const ra8_sci_cfg_t sci_cfg = {.baud      = (uint32_t)k_demo_uart_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_demo_uart_chan, &sci_cfg) != k_ra8_ok) {
    while (true) {
    }
  }
}

RA8_INTERNAL static ra8_err_t
internal_demo_mount(ra8_io_blockdev_t* bd, ra8_fs_backend_t* be, const char* name)
{
  RA8_CHECK_NULL_PTR(bd, s_tag, "bd");
  RA8_CHECK_NULL_PTR(be, s_tag, "be");
  RA8_CHECK_NULL_PTR(name, s_tag, "name");
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_as_fs_backend(bd, be), s_tag, "fs bridge");
  ra8_fs_format_opts_t opts = {};
  opts.type                 = k_ra8_fs_type_fat12;
  opts.label                = "RAIO";
  RA8_RETURN_ON_ERROR(ra8_fs_format(be, &opts), s_tag, "format");
  ra8_fs_mount_t* mnt = nullptr;
  RA8_RETURN_ON_ERROR(ra8_fs_mount(be, &mnt), s_tag, "mount");
  RA8_RETURN_ON_ERROR(ra8_io_vfs_mount(name, mnt), s_tag, "vfs mount");
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_demo_roundtrip(const char* prefix, uint32_t* out_blob_len)
{
  RA8_CHECK_NULL_PTR(prefix, s_tag, "prefix");
  RA8_CHECK_NULL_PTR(out_blob_len, s_tag, "out_blob_len");
 
  char         path[(size_t)k_ra8_io_vfs_name_max + sizeof("STORY.RBK") + 1U] = {};
  const size_t prefix_limit = sizeof(path) - sizeof("STORY.RBK");
  const size_t prefix_len   = strnlen(prefix, prefix_limit);
  if (prefix_len >= prefix_limit) {
    return k_ra8_err_invalid_size;
  }
  (void)memcpy(path, prefix, prefix_len);
  (void)memcpy(&path[prefix_len], "STORY.RBK", sizeof("STORY.RBK"));
 
  uint32_t blob_len = 0;
  RA8_RETURN_ON_ERROR(ra8_vfs_compress_write(path,
                                             s_payload,
                                             (uint32_t)k_demo_payload,
                                             s_scratch,
                                             (uint32_t)k_ra8_compress_scratch_bytes,
                                             s_blob,
                                             (uint32_t)k_demo_blob_cap,
                                             &blob_len),
                      s_tag,
                      "write compressed");
 
  uint32_t out_len = 0;
  RA8_RETURN_ON_ERROR(ra8_vfs_compress_read(path,
                                            s_blob,
                                            (uint32_t)k_demo_blob_cap,
                                            s_restored,
                                            (uint32_t)k_demo_payload,
                                            &out_len),
                      s_tag,
                      "read compressed");
  if (out_len != (uint32_t)k_demo_payload) {
    return k_ra8_err_invalid_size;
  }
  if (memcmp(s_restored, s_payload, sizeof(s_payload)) != 0) {
    return k_ra8_err_checksum_mismatch;
  }
  *out_blob_len = blob_len;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_demo_run(uint32_t* out_blob_len)
{
  RA8_CHECK_NULL_PTR(out_blob_len, s_tag, "out_blob_len");
 
  for (uint32_t i = 0; i < (uint32_t)k_demo_payload; ++i) {
    s_payload[i] = (uint8_t)((i * (uint32_t)k_demo_seed_mul) % (uint32_t)k_demo_pattern_mod);
  }
 
  /* Backend 1: RAM disk over an in-SRAM buffer, mounted as "ram". */
  RA8_RETURN_ON_ERROR(
    ra8_io_blockdev_ram_init(&s_bd_ram, &s_bstate_ram, s_disk, (uint32_t)k_demo_disk_blocks, false),
    s_tag,
    "ram blockdev init");
  RA8_RETURN_ON_ERROR(internal_demo_mount(&s_bd_ram, &s_be_ram, "ram"), s_tag, "ram mount");
  uint32_t ram_blob_len = 0;
  RA8_RETURN_ON_ERROR(internal_demo_roundtrip("ram:/", &ram_blob_len), s_tag, "ram round-trip");
 
  /* Backend 2: external SDRAM as a volatile ramdisk, mounted as "dr". */
  RA8_RETURN_ON_ERROR(
    ra8_io_blockdev_sdram_init(&s_bd_dr, &s_bstate_dr, (uint32_t)k_demo_disk_blocks),
    s_tag,
    "sdram blockdev init");
  RA8_RETURN_ON_ERROR(internal_demo_mount(&s_bd_dr, &s_be_dr, "dr"), s_tag, "dr mount");
  uint32_t dr_blob_len = 0;
  RA8_RETURN_ON_ERROR(internal_demo_roundtrip("dr:/", &dr_blob_len), s_tag, "dr round-trip");
 
  *out_blob_len = ram_blob_len;
  return k_ra8_ok;
}

void main(void)
{
  ra8_log_init();
  internal_demo_setup_or_halt();
  (void)ra8_io_stream_uart_init(&s_uart, &s_ust, (uint8_t)k_demo_uart_chan);
  (void)ra8_io_log_attach(&s_uart);
  internal_demo_print("compress_demo: boot\r\n");
 
  uint32_t        blob_len = 0;
  const ra8_err_t e        = internal_demo_run(&blob_len);
  if (e == k_ra8_ok) {
    internal_demo_print("compress_demo: ram+dr 4096 -> ");
    (void)ra8_io_stream_put_u32(&s_uart, blob_len);
    internal_demo_print(" bytes -> 4096 round-trip PASS\r\n");
  } else {
    internal_demo_print("compress_demo: FAIL\r\n");
  }
  (void)ra8_sci_flush((uint8_t)k_demo_uart_chan);
  while (true) {
  }
}