main.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_board_ek_ra8d2_console_stream.h"
#include "ra8_boot_entry.h"
#include "ra8_cgc.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_flash.h"
#include "ra8_io.h"
#include "ra8_log.h"
#include "ra8_time.h"

typedef enum : uint32_t {
  k_demo_uart_baud   = 115200U,                           
  k_demo_mram_base   = (uint32_t)k_ra8_flash_extra_start, 
  k_demo_disk_blocks = 24U,                               
  k_demo_test_lba    = 0U,                                
  k_demo_block_count = 1U,                                
  k_demo_payload     = 512U,                              
  k_demo_seed_mul    = 5U,                                
  k_demo_seed_add    = 3U,                                
  k_demo_mrcfreq_mhz = 200U,                              
  k_demo_mrefreq_mhz = 100U,                              
} demo_const_t;

static ra8_io_blockdev_t            s_bd;
static ra8_io_blockdev_mram_state_t s_mstate;
static ra8_io_stream_t s_uart;

static const char* const s_tag = "ra8_io_mram_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;
  if ((ra8_cgc_init() != k_ra8_ok) ||
      (ra8_cgc_get_clock_hz(k_ra8_clock_id_cpuclk0, &cpuclk0_hz) != k_ra8_ok) ||
      (ra8_time_init(cpuclk0_hz) != k_ra8_ok) ||
      (ra8_board_uart_console_init((uint32_t)k_demo_uart_baud) != k_ra8_ok) ||
      (ra8_board_console_stream(&s_uart) != k_ra8_ok)) {
    while (true) {
    }
  }
}

RA8_INTERNAL static ra8_err_t internal_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_disk_blocks,
                                                false),
                      s_tag,
                      "mram blockdev init");
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_demo_roundtrip(void)
{
  uint8_t data[(size_t)k_demo_payload];
  for (uint32_t i = 0; i < (uint32_t)k_demo_payload; ++i) {
    data[i] = (uint8_t)((i * (uint32_t)k_demo_seed_mul) + (uint32_t)k_demo_seed_add);
  }
  RA8_RETURN_ON_ERROR(
    ra8_io_blockdev_erase(&s_bd, (uint32_t)k_demo_test_lba, (uint32_t)k_demo_block_count),
    s_tag,
    "erase");
  RA8_RETURN_ON_ERROR(
    ra8_io_blockdev_write(&s_bd, (uint32_t)k_demo_test_lba, (uint32_t)k_demo_block_count, data),
    s_tag,
    "write");
  uint8_t got[(size_t)k_demo_payload] = {};
  RA8_RETURN_ON_ERROR(
    ra8_io_blockdev_read(&s_bd, (uint32_t)k_demo_test_lba, (uint32_t)k_demo_block_count, got),
    s_tag,
    "read");
  if (memcmp(got, data, sizeof(data)) != 0) {
    return k_ra8_err_checksum_mismatch;
  }
  return k_ra8_ok;
}

void main(void)
{
  ra8_log_init();
  internal_demo_setup_or_halt();
  (void)ra8_io_log_attach(&s_uart); /* route ra8_log into the console stream too */
  internal_demo_print("ra8_io_mram_demo: boot\r\n");
 
  ra8_err_t e = internal_demo_open();
  if (e == k_ra8_ok) {
    e = internal_demo_roundtrip();
  }
  if (e == k_ra8_ok) {
    internal_demo_print(
      "ra8_io_mram_demo: 512-byte block erase/program/read on extra MRAM PASS\r\n");
  } else {
    internal_demo_print("ra8_io_mram_demo: FAIL\r\n");
  }
  (void)ra8_board_uart_console_flush();
  while (true) {
  }
}