main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_flash.h"
#include "ra8_ftl.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"

typedef enum : uintptr_t {
  k_demo_mram_base = k_ra8_flash_extra_start, 
} demo_addr_t;

typedef enum : uint32_t {
  k_demo_uart_chan    = 8U,      
  k_demo_uart_baud    = 115200U, 
  k_demo_total_blocks = 24U,     
  k_demo_ftl_phys     = 23U,     
  k_demo_ftl_logical  = 8U,      
  k_demo_meta_lba     = 23U,     
  k_demo_one_block    = 1U,      
  k_demo_test_lbn     = 2U,      
  k_demo_writes       = 12U,     
  k_demo_block        = 512U,    
  k_demo_pin_shift    = 8U,      
  k_demo_mrcfreq_mhz  = 200U,    
  k_demo_mrefreq_mhz  = 100U,    
  k_demo_seed_mul     = 17U,     
  k_demo_lbn_mul      = 5U,      
  k_demo_tag_base     = 1U,      
} demo_const_t;

static const ra8_port_pin_t k_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 k_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 ra8_io_blockdev_t            s_bd;
static ra8_io_blockdev_mram_state_t s_mstate;
static ra8_ftl_t         s_ftl;
static ra8_io_blockdev_t s_present;
static uint16_t         s_map[(size_t)k_demo_ftl_logical];
static ra8_ftl_pblock_t s_pblocks[(size_t)k_demo_ftl_phys];
static uint8_t          s_scratch[(size_t)k_demo_block];
static uint8_t s_ckbuf[(size_t)k_demo_block];
static ra8_io_stream_t            s_uart;
static ra8_io_stream_uart_state_t s_ust;

static const char* const s_tag = "ra8_ftl_demo";

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

static void demo_report_map(uint32_t lbn, uint16_t phys)
{
  demo_print("ra8_ftl_demo: logical ");
  (void)ra8_io_stream_put_u32(&s_uart, lbn);
  demo_print(" now at physical ");
  (void)ra8_io_stream_put_u32(&s_uart, (uint32_t)phys);
  demo_print("\r\n");
}

static void 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(k_demo_txd, k_ra8_psel_sci_async, "demo.txd") != k_ra8_ok) ||
      (ra8_pfs_route_peripheral(k_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) {
    }
  }
}

static ra8_err_t demo_open(void)
{
  const ra8_flash_cfg_t fcfg = {.mrcfreq_mhz        = (uint16_t)k_demo_mrcfreq_mhz,
                                .mrefreq_mhz        = (uint8_t)k_demo_mrefreq_mhz,
                                .prefetch_en        = true,
                                .ecc_encoder_enable = true,
                                .ecc_decoder_enable = true};
  RA8_RETURN_ON_ERROR(ra8_flash_init(&fcfg), s_tag, "flash init");
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_mram_init(&s_bd,
                                                &s_mstate,
                                                (uintptr_t)k_demo_mram_base,
                                                (uint32_t)k_demo_total_blocks,
                                                false),
                      s_tag,
                      "mram blockdev init");
  return k_ra8_ok;
}

static ra8_err_t demo_write_verify(uint32_t lbn, uint32_t tag, uint16_t* out_phys)
{
  RA8_CHECK_NULL_PTR(out_phys, s_tag, "out_phys must not be nullptr");
  uint8_t blk[(size_t)k_demo_block];
  for (uint32_t i = 0; i < (uint32_t)k_demo_block; ++i) {
    blk[i] = (uint8_t)((i * (uint32_t)k_demo_seed_mul) + (lbn * (uint32_t)k_demo_lbn_mul) + tag);
  }
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_write(&s_present, lbn, (uint32_t)k_demo_one_block, blk),
                      s_tag,
                      "write");
  uint8_t got[(size_t)k_demo_block];
  RA8_RETURN_ON_ERROR(ra8_io_blockdev_read(&s_present, lbn, (uint32_t)k_demo_one_block, got),
                      s_tag,
                      "read");
  if (memcmp(got, blk, sizeof(blk)) != 0) {
    return k_ra8_err_checksum_mismatch;
  }
  return ra8_ftl_phys_of(&s_ftl, lbn, out_phys);
}

static ra8_err_t demo_wear_phase(uint32_t* migrations, uint16_t* last_phys)
{
  RA8_CHECK_NULL_PTR(migrations, s_tag, "migrations must not be nullptr");
  RA8_CHECK_NULL_PTR(last_phys, s_tag, "last_phys must not be nullptr");
  RA8_RETURN_ON_ERROR(ra8_ftl_init(&s_ftl,
                                   &s_bd,
                                   s_map,
                                   (uint32_t)k_demo_ftl_logical,
                                   s_pblocks,
                                   (uint32_t)k_demo_ftl_phys,
                                   s_scratch),
                      s_tag,
                      "ftl init");
  RA8_RETURN_ON_ERROR(ra8_ftl_as_blockdev(&s_ftl, &s_present), s_tag, "ftl as blockdev");
  uint32_t moves = 0U;
  uint16_t prev  = (uint16_t)k_ra8_ftl_unmapped;
  for (uint32_t k = 0; k < (uint32_t)k_demo_writes; ++k) {
    uint16_t        cur = 0U;
    const ra8_err_t e =
      demo_write_verify((uint32_t)k_demo_test_lbn, (uint32_t)k_demo_tag_base + k, &cur);
    if (e != k_ra8_ok) {
      return e;
    }
    demo_report_map((uint32_t)k_demo_test_lbn, cur);
    if ((prev != (uint16_t)k_ra8_ftl_unmapped) && (cur != prev)) {
      moves += 1U;
    }
    prev = cur;
  }
  *migrations = moves;
  *last_phys  = prev;
  return k_ra8_ok;
}

static ra8_err_t demo_checkpoint(void)
{
  uint32_t need = 0U;
  RA8_RETURN_ON_ERROR(ra8_ftl_checkpoint_size(&s_ftl, &need), s_tag, "checkpoint size");
  if (need > (uint32_t)k_demo_block) {
    return k_ra8_err_invalid_size;
  }
  RA8_RETURN_ON_ERROR(ra8_ftl_checkpoint_save(&s_ftl, s_ckbuf, (uint32_t)k_demo_block),
                      s_tag,
                      "checkpoint save");
  RA8_RETURN_ON_ERROR(
    ra8_io_blockdev_erase(&s_bd, (uint32_t)k_demo_meta_lba, (uint32_t)k_demo_one_block),
    s_tag,
    "meta erase");
  RA8_RETURN_ON_ERROR(
    ra8_io_blockdev_write(&s_bd, (uint32_t)k_demo_meta_lba, (uint32_t)k_demo_one_block, s_ckbuf),
    s_tag,
    "meta write");
  return k_ra8_ok;
}

static ra8_err_t demo_reopen_naive(void)
{
  (void)memset(&s_ftl, 0, sizeof(s_ftl));
  (void)memset(s_map, 0, sizeof(s_map));
  (void)memset(s_pblocks, 0, sizeof(s_pblocks));
  (void)memset(&s_present, 0, sizeof(s_present));
  RA8_RETURN_ON_ERROR(ra8_ftl_init(&s_ftl,
                                   &s_bd,
                                   s_map,
                                   (uint32_t)k_demo_ftl_logical,
                                   s_pblocks,
                                   (uint32_t)k_demo_ftl_phys,
                                   s_scratch),
                      s_tag,
                      "ftl reinit");
  RA8_RETURN_ON_ERROR(ra8_ftl_as_blockdev(&s_ftl, &s_present), s_tag, "ftl rebind");
  uint8_t got[(size_t)k_demo_block];
  RA8_RETURN_ON_ERROR(
    ra8_io_blockdev_read(&s_present, (uint32_t)k_demo_test_lbn, (uint32_t)k_demo_one_block, got),
    s_tag,
    "naive read");
  for (uint32_t i = 0; i < (uint32_t)k_demo_block; ++i) {
    if (got[i] != (uint8_t)k_ra8_io_erase_value_ones) {
      return k_ra8_err_invalid_state;
    }
  }
  return k_ra8_ok;
}

static ra8_err_t demo_restore(uint32_t want_tag, uint16_t want_phys)
{
  RA8_RETURN_ON_ERROR(
    ra8_io_blockdev_read(&s_bd, (uint32_t)k_demo_meta_lba, (uint32_t)k_demo_one_block, s_ckbuf),
    s_tag,
    "meta read");
  RA8_RETURN_ON_ERROR(ra8_ftl_checkpoint_load(&s_ftl, s_ckbuf, (uint32_t)k_demo_block),
                      s_tag,
                      "checkpoint load");
  uint8_t want[(size_t)k_demo_block] = {};
  for (uint32_t i = 0; i < (uint32_t)k_demo_block; ++i) {
    want[i] = (uint8_t)((i * (uint32_t)k_demo_seed_mul) +
                        ((uint32_t)k_demo_test_lbn * (uint32_t)k_demo_lbn_mul) + want_tag);
  }
  uint8_t got[(size_t)k_demo_block];
  RA8_RETURN_ON_ERROR(
    ra8_io_blockdev_read(&s_present, (uint32_t)k_demo_test_lbn, (uint32_t)k_demo_one_block, got),
    s_tag,
    "restored read");
  if (memcmp(got, want, sizeof(want)) != 0) {
    return k_ra8_err_checksum_mismatch;
  }
  uint16_t phys = 0U;
  RA8_RETURN_ON_ERROR(ra8_ftl_phys_of(&s_ftl, (uint32_t)k_demo_test_lbn, &phys),
                      s_tag,
                      "restored map");
  if (phys != want_phys) {
    return k_ra8_err_invalid_state;
  }
  return k_ra8_ok;
}

static void demo_report_wear(void)
{
  uint32_t hi = 0U;
  uint32_t lo = 0U;
  if (ra8_ftl_wear_stats(&s_ftl, &hi, &lo) != k_ra8_ok) {
    demo_print("ra8_ftl_demo: wear stats unavailable\r\n");
    return;
  }
  demo_print("ra8_ftl_demo: wear erase-count max ");
  (void)ra8_io_stream_put_u32(&s_uart, hi);
  demo_print(" min ");
  (void)ra8_io_stream_put_u32(&s_uart, lo);
  demo_print("\r\n");
}

static ra8_err_t demo_run(void)
{
  uint32_t migrations = 0U;
  uint16_t last_phys  = 0U;
  RA8_RETURN_ON_ERROR(demo_wear_phase(&migrations, &last_phys), s_tag, "wear phase");
  demo_report_wear();
  if (migrations == 0U) {
    return k_ra8_err_invalid_state; /* no relocation observed -- wear-levelling failed */
  }
  RA8_RETURN_ON_ERROR(demo_checkpoint(), s_tag, "checkpoint");
  RA8_RETURN_ON_ERROR(demo_reopen_naive(), s_tag, "reopen naive");
  demo_print("ra8_ftl_demo: naive re-open lost the mapping (reads erase value)\r\n");
  RA8_RETURN_ON_ERROR(
    demo_restore((uint32_t)k_demo_tag_base + (uint32_t)k_demo_writes - (uint32_t)k_demo_one_block,
                 last_phys),
    s_tag,
    "restore");
  return k_ra8_ok;
}

void main(void)
{
  ra8_log_init();
  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); /* route ra8_log into the UART stream too */
  demo_print("ra8_ftl_demo: boot\r\n");
 
  ra8_err_t e = demo_open();
  if (e == k_ra8_ok) {
    e = demo_run();
  }
  if (e == k_ra8_ok) {
    demo_print("ra8_ftl_demo: wear-level + power-cycle-survive on extra MRAM PASS\r\n");
  } else {
    demo_print("ra8_ftl_demo: FAIL\r\n");
  }
  (void)ra8_sci_flush((uint8_t)k_demo_uart_chan);
  while (true) {
  }
}