main.c

Go to the documentation of this file.

 
#include <stddef.h>
#include <stdint.h>
 
#include "book.h"
#include "mdl_rabook_vfs.h"
#include "mdl_storage_vfs.h"
#include "media_download_image_internal.h"
#include "miniz.h"
#include "ra8_attributes.h"
#include "ra8_board_ek_ra8d2.h"
#include "ra8_boot_entry.h"
#include "ra8_c6link.h"
#include "ra8_c6link_mdl_transfer.h"
#include "ra8_c6link_wifi.h"
#include "ra8_err.h"
#include "ra8_esp_hosted_c6link.h"
#include "ra8_esp_hosted_port.h"
#include "ra8_fs.h"
#include "ra8_io_vfs.h"
#include "ra8_isr.h"
#include "ra8_mstp.h"
#include "ra8_net_provision.h"
#include "ra8_rsip.h"
#include "ra8_sdmmc_spi.h"
#include "ra8_secure.h"
#include "ra8_time.h"
#include "tx_api.h"
#ifndef RA8_MEDIA_DOWNLOAD_SOURCE_IMAGE
#define RA8_MEDIA_DOWNLOAD_SOURCE_IMAGE (0)
#endif
 
static_assert((RA8_MEDIA_DOWNLOAD_SOURCE_IMAGE == 0) || (RA8_MEDIA_DOWNLOAD_SOURCE_IMAGE == 1),
              "RA8_MEDIA_DOWNLOAD_SOURCE_IMAGE must be 0 or 1");

typedef enum : uint32_t {
  k_media_uart_baud          = 115200U,  
  k_media_c6_sck_hz          = 5000000U, 
  k_media_c6_edge_poll_ms    = 2U,       
  k_media_c6_boot_wait_ms    = 200U,     
  k_media_assoc_tries        = 200U,     
  k_media_assoc_gap_ms       = 50U,      
  k_media_diagnostic_bytes   = 256U,     
  k_media_heartbeat_ms       = 5000U,    
  k_media_worker_stack_bytes = 8192U,    
  k_media_worker_priority    = 8U,       
  k_media_c6_arena_bytes     = 4096U,    
  k_media_transfer_chunk     = 1024U,    
  k_media_transfer_chunks    = 32768U,   
  k_media_rbkc_chunk_bytes   = 65536U,   
  k_media_compressed_bytes   = 66560U,   
  k_media_table_entries      = 2049U,    
  k_media_scratch_bytes      = 65536U,   
} media_limit_t;

static const char s_destination[] = "sd:/BOOKS/C6BOOK.RBK";
static const char s_stage_leaf[] = "C6STAGE.TMP";
static const bool s_source_is_image = RA8_MEDIA_DOWNLOAD_SOURCE_IMAGE != 0;

static uint32_t s_cpuclk_hz;
static uint32_t s_pclka_hz;
static ra8_err_t s_port_err = k_ra8_err_not_initialized;
static TX_THREAD s_worker;
static CHAR s_worker_name[] = "media_download";
static UCHAR s_worker_stack[k_media_worker_stack_bytes];
static ra8_c6link_t s_link;
static uint8_t s_c6_arena[k_media_c6_arena_bytes];
static volatile uint8_t s_connected;
static volatile uint8_t s_disconnected;
static const ra8_net_provision_uart_t s_provision_uart = {
  .write   = ra8_board_uart_console_write,
  .read    = ra8_board_uart_console_read,
  .wait_ms = ra8_delay_ms,
};

static ra8_fs_backend_t s_fs_backend;
static ra8_fs_mount_t* s_mount;
static mdl_storage_vfs_t s_storage;
static mdl_rabook_vfs_t s_rabook;
static ra8_rsip_sha256_ctx_t s_sha;

[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint64_t s_table[k_media_table_entries];
[[gnu::section(".sdram_data"),
  gnu::aligned(8)]] static uint8_t s_compressed[k_media_compressed_bytes];
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint8_t s_chunk[k_media_rbkc_chunk_bytes];
[[gnu::section(".sdram_data"), gnu::aligned(8)]] static uint8_t s_scratch[k_media_scratch_bytes];

RA8_INTERNAL static void internal_puts(const char* text)
{
  size_t length = 0U;
  while ((length < (size_t)k_media_diagnostic_bytes) && (text[length] != '\0')) {
    length++;
  }
  (void)ra8_board_uart_console_write((const uint8_t*)text, length);
}

RA8_INTERNAL static bool internal_fail(const char* stage, ra8_err_t err)
{
  internal_puts("media_download: FAIL ");
  internal_puts(stage);
  internal_puts(" err=");
  internal_puts(ra8_err_to_str(err));
  internal_puts("\r\n");
  return false;
}

[[noreturn]] RA8_INTERNAL static void internal_halt(void)
{
  while (true) {
    __asm volatile("wfi");
  }
}

RA8_INTERNAL static void internal_setup_or_halt(void)
{
  ra8_board_clock_rates_t clock_rates = {};
  if (ra8_board_clocks_init(&clock_rates) != k_ra8_ok) {
    internal_halt();
  }
  s_cpuclk_hz = clock_rates.cpuclk0_hz;
  s_pclka_hz  = clock_rates.pclka_hz;
  if ((ra8_mstp_init() != k_ra8_ok) || (ra8_time_init(s_cpuclk_hz) != k_ra8_ok) ||
      (ra8_board_uart_console_init((uint32_t)k_media_uart_baud) != k_ra8_ok)) {
    internal_halt();
  }
}

RA8_INTERNAL static void internal_on_event(void* context, const ra8_c6link_event_t* event)
{
  (void)context;
  if (event == nullptr) {
    return;
  }
  if (event->kind == k_ra8_c6link_event_sta_connected) {
    s_connected = 1U;
  } else if (event->kind == k_ra8_c6link_event_sta_disconnected) {
    s_disconnected = 1U;
  }
}

RA8_INTERNAL static bool internal_wait_connected(void)
{
  for (uint32_t attempt = 0U; attempt < (uint32_t)k_media_assoc_tries; ++attempt) {
    ra8_c6link_stats_t stats = {};
    (void)ra8_c6link_poll(&s_link, (uint16_t)k_ra8_c6link_announce_transfers, &stats);
    if (s_connected != 0U) {
      return true;
    }
    if (s_disconnected != 0U) {
      return false;
    }
    tx_thread_sleep((ULONG)k_media_assoc_gap_ms);
  }
  return false;
}

RA8_INTERNAL static ra8_err_t internal_open_and_join(const ra8_net_credentials_t* credentials)
{
  if ((credentials == nullptr) || (credentials->ssid[0] == '\0')) {
    return k_ra8_err_invalid_arg;
  }
  ra8_c6link_cfg_t link_config = {};
  ra8_err_t        err         = ra8_esp_hosted_c6link_bind(&link_config.transport);
  if (err != k_ra8_ok) {
    return err;
  }
  link_config.arena       = s_c6_arena;
  link_config.arena_bytes = sizeof(s_c6_arena);
  link_config.event_cb    = internal_on_event;
  err                     = ra8_c6link_open(&s_link, &link_config);
  if (err != k_ra8_ok) {
    return err;
  }
  ra8_c6link_fw_version_t version = {};
  err = ra8_c6link_await_ready(&s_link, (uint16_t)k_ra8_c6link_announce_transfers, &version);
  if (err == k_ra8_ok) {
    err = ra8_c6link_wifi_start(&s_link);
  }
  ra8_c6link_sta_cfg_t station = {};
  if (err == k_ra8_ok) {
    err = ra8_c6link_sta_cfg_set(&station, credentials->ssid, credentials->psk);
  }
  if (err == k_ra8_ok) {
    err = ra8_c6link_wifi_join(&s_link, &station);
  }
  ra8_secure_memzero(&station, sizeof(station));
  if ((err == k_ra8_ok) && !internal_wait_connected()) {
    err = k_ra8_err_timeout;
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_mount_sd(void)
{
  const ra8_sdmmc_spi_sci_pins_t pins = {
    .sck  = (ra8_port_pin_t)k_ra8_board_pmod2_spi_sck,
    .cipo = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cipo,
    .copi = (ra8_port_pin_t)k_ra8_board_pmod2_spi_copi,
    .cs   = (ra8_port_pin_t)k_ra8_board_pmod2_spi_cs,
  };
  ra8_sdmmc_spi_transport_t transport = {};
  ra8_err_t err = ra8_sdmmc_spi_transport_sci((uint8_t)k_ra8_board_pmod2_sci_channel,
                                              s_pclka_hz,
                                              &pins,
                                              &transport);
  if (err == k_ra8_ok) {
    err = ra8_sdmmc_spi_init(&transport);
  }
  if (err == k_ra8_ok) {
    err = ra8_sdmmc_spi_bind_fs_backend(&s_fs_backend);
  }
  if (err == k_ra8_ok) {
    err = ra8_fs_mount(&s_fs_backend, &s_mount);
  }
  if (err == k_ra8_ok) {
    err = ra8_io_vfs_init();
  }
  if (err == k_ra8_ok) {
    err = ra8_io_vfs_mount("sd", s_mount);
  }
  ra8_io_vfs_stat_t book_dir = {};
  if (err == k_ra8_ok) {
    err = ra8_io_vfs_stat("sd:/BOOKS", &book_dir);
  }
  if ((err == k_ra8_ok) && !book_dir.exists) {
    err = ra8_io_vfs_mkdir("sd:/BOOKS");
  } else if ((err == k_ra8_ok) && !book_dir.is_directory) {
    err = k_ra8_err_invalid_arg;
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_inflate(const void* source,
                                               size_t      source_bytes,
                                               void*       destination,
                                               size_t      destination_capacity,
                                               size_t*     output_bytes)
{
  if ((source == nullptr) || (destination == nullptr) || (output_bytes == nullptr)) {
    return k_ra8_err_null_ptr;
  }
  const size_t inflated = tinfl_decompress_mem_to_mem(
    destination,
    destination_capacity,
    source,
    source_bytes,
    (uint32_t)(TINFL_FLAG_PARSE_ZLIB_HEADER | TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF));
  if (inflated == TINFL_DECOMPRESS_MEM_TO_MEM_FAILED) {
    return k_ra8_err_validation_failed;
  }
  *output_bytes = inflated;
  return k_ra8_ok;
}

RA8_INTERNAL static ra8_err_t internal_sha_init(void* context)
{
  return ra8_rsip_sha256_init((ra8_rsip_sha256_ctx_t*)context);
}

RA8_INTERNAL static ra8_err_t
internal_sha_update(void* context, const uint8_t* data, uint16_t length)
{
  return ra8_rsip_sha256_update((ra8_rsip_sha256_ctx_t*)context, data, length);
}

RA8_INTERNAL static ra8_err_t internal_sha_final(void*   context,
                                                 uint8_t output[k_ra8_mdl_sha256_bytes])
{
  return ra8_rsip_sha256_final((ra8_rsip_sha256_ctx_t*)context, output);
}

RA8_INTERNAL static ra8_err_t internal_bind_transfer(ra8_mdl_transfer_config_t* output)
{
  const mdl_rabook_vfs_config_t reader_config = {
    .inflate_cb     = internal_inflate,
    .table          = s_table,
    .compressed     = s_compressed,
    .chunk          = s_chunk,
    .scratch        = s_scratch,
    .table_cap      = (uint32_t)k_media_table_entries,
    .compressed_cap = sizeof(s_compressed),
    .chunk_cap      = sizeof(s_chunk),
    .scratch_cap    = sizeof(s_scratch),
  };
  ra8_err_t               err               = mdl_rabook_vfs_init(&s_rabook, &reader_config);
  ra8_mdl_storage_iface_t storage_interface = {};
  if (err == k_ra8_ok) {
    const mdl_storage_vfs_config_t storage_config = {
      .stage_leaf   = s_stage_leaf,
      .validate     = mdl_rabook_vfs_validate,
      .validate_ctx = &s_rabook,
    };
    err = mdl_storage_vfs_init(&s_storage, &storage_config, &storage_interface);
  }
  if (err == k_ra8_ok) {
    *output = (ra8_mdl_transfer_config_t){
      .storage     = storage_interface,
      .sha256      = {.init   = internal_sha_init,
                      .update = internal_sha_update,
                      .final  = internal_sha_final,
                      .ctx    = &s_sha},
      .format      = k_mdl_format_rabook,
      .chunk_bytes = (uint16_t)k_media_transfer_chunk,
      .max_chunks  = (uint32_t)k_media_transfer_chunks,
    };
  }
  return err;
}

RA8_INTERNAL static ra8_err_t internal_consume(void)
{
  ra8_err_t     err       = mdl_rabook_vfs_open(&s_rabook, s_destination);
  book_header_t header    = {};
  uint64_t      flat_size = 0U;
  if (err == k_ra8_ok) {
    err = mdl_rabook_vfs_info(&s_rabook, &header, &flat_size);
  }
  uint32_t first_bytes = 0U;
  if (err == k_ra8_ok) {
    first_bytes = s_rabook.reader.chunk_bytes;
    if (flat_size < first_bytes) {
      first_bytes = (uint32_t)flat_size;
    }
    if ((first_bytes == 0U) || (first_bytes > sizeof(s_chunk)) ||
        ((uint64_t)header.total_size != flat_size)) {
      err = k_ra8_err_invalid_size;
    }
  }
  if (err == k_ra8_ok) {
    err = mdl_rabook_vfs_read_chunk(&s_rabook, 0U, s_chunk, first_bytes);
  }
  const ra8_err_t close_err = mdl_rabook_vfs_close(&s_rabook);
  return ((err == k_ra8_ok) ? close_err : err);
}

RA8_INTERNAL static ra8_err_t
internal_transfer_and_consume(const ra8_net_credentials_t* configuration)
{
  ra8_mdl_transfer_config_t transfer = {};
  ra8_err_t                 err      = internal_bind_transfer(&transfer);
  if (err == k_ra8_ok) {
    if (s_source_is_image) {
      err = priv_media_download_image_run(&s_link, configuration->url, s_destination, &transfer);
    } else {
      ra8_mdl_transfer_result_t result = {};
      err = ra8_c6link_mdl_transfer(&s_link, configuration->url, s_destination, &transfer, &result);
    }
  }
  if (err == k_ra8_ok) {
    err = internal_consume();
  }
  return err;
}

RA8_INTERNAL static bool internal_run(ra8_net_credentials_t* configuration)
{
  if (s_port_err != k_ra8_ok) {
    return internal_fail("c6 port", s_port_err);
  }
  if ((configuration == nullptr) || (configuration->url[0] == '\0')) {
    return internal_fail("runtime configuration", k_ra8_err_invalid_arg);
  }
  ra8_err_t err = internal_mount_sd();
  if (err != k_ra8_ok) {
    return internal_fail("sd mount", err);
  }
  const ra8_rsip_config_t rsip_config = {.run_bist = true};
  err                                 = ra8_rsip_init(&rsip_config);
  if (err != k_ra8_ok) {
    return internal_fail("rsip", err);
  }
  ra8_delay_ms((uint32_t)k_media_c6_boot_wait_ms);
  err = internal_open_and_join(configuration);
  if (err != k_ra8_ok) {
    return internal_fail("c6 join", err);
  }
  ra8_secure_memzero(configuration->ssid, sizeof(configuration->ssid));
  ra8_secure_memzero(configuration->psk, sizeof(configuration->psk));
  configuration->ssid_len = 0U;
  configuration->psk_len  = 0U;
  err                     = internal_transfer_and_consume(configuration);
  (void)ra8_c6link_close(&s_link);
  if (err != k_ra8_ok) {
    return internal_fail("transfer/consume", err);
  }
  internal_puts("media_download: PASS C6->RABOOK->SD publish and read\r\n");
  return true;
}

[[noreturn]] RA8_INTERNAL static void internal_heartbeat(bool passed)
{
  while (true) {
    internal_puts(passed ? "media_download: alive PASS\r\n" : "media_download: alive FAIL\r\n");
    tx_thread_sleep((ULONG)k_media_heartbeat_ms);
  }
}

RA8_INTERNAL static void internal_worker(ULONG input)
{
  (void)input;
  ra8_net_credentials_t configuration = {};
  const ra8_err_t provisioned = ra8_net_provision_receive(&s_provision_uart,
                                                          (uint32_t)k_ra8_net_provision_timeout_ms,
                                                          &configuration);
  bool            passed      = false;
  if (provisioned == k_ra8_ok) {
    passed = internal_run(&configuration);
  } else {
    (void)internal_fail("runtime provisioning", provisioned);
  }
  ra8_net_provision_clear(&configuration);
  internal_heartbeat(passed);
}

void tx_application_define(void* first_unused_memory)
{
  (void)first_unused_memory;
  const ra8_esp_hosted_port_cfg_t port_config = {
    .pclk_hz      = s_pclka_hz,
    .sck_hz       = (uint32_t)k_media_c6_sck_hz,
    .edge_poll_ms = (uint16_t)k_media_c6_edge_poll_ms,
    .sci_channel  = (uint8_t)k_ra8_board_pmod1_sci_channel,
  };
  s_port_err = ra8_esp_hosted_port_init(&port_config);
  if (tx_thread_create(&s_worker,
                       s_worker_name,
                       internal_worker,
                       0U,
                       s_worker_stack,
                       sizeof(s_worker_stack),
                       (UINT)k_media_worker_priority,
                       (UINT)k_media_worker_priority,
                       TX_NO_TIME_SLICE,
                       TX_AUTO_START) != TX_SUCCESS) {
    internal_puts("media_download: FAIL worker create\r\n");
  }
}

void main(void)
{
  internal_setup_or_halt();
  ra8_isr_globals_enable();
  internal_puts("media_download: boot; C6 Pmod1 + SD Pmod2\r\n");
  tx_kernel_enter();
  internal_halt();
}