usb_host_msc_browse_host.c

Go to the documentation of this file.

 
#include <stdint.h>
#include <string.h>
 
#include "usb_host_msc_browse_steps.h"
 
#ifndef RA8_OFF_TARGET
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_err.h"
#include "ra8_fs.h"
#include "ra8_io_blockdev.h"
#include "ra8_io_blockdev_usbmsc.h"
#include "ra8_time.h"
#include "ra8_usb_hmsc.h"
 
/* -------------------------------------------------------------------------- */
/* Tunables */
/* -------------------------------------------------------------------------- */

typedef enum : uint8_t {
  k_selftest_hex_chars_u16   = 4U,  
  k_selftest_hex_chars_u32   = 8U,  
  k_selftest_dec_chars_u32   = 10U, 
  k_selftest_nibble_bits     = 4U,  
  k_selftest_hex_digit_split = 10U, 
} selftest_hex_t;

typedef enum : uint32_t {
  k_selftest_nibble_mask = 0xFU, 
  k_selftest_dec_radix   = 10U,  
} selftest_mask_t;

typedef enum : uint32_t {
  k_selftest_burst_blocks  = 8U,          
  k_selftest_burst_bytes   = 4096U,       
  k_selftest_target_lun    = 0U,          
  k_selftest_wp_probe_lba  = 50U,         
  k_selftest_no_mismatch   = 0xFFFFFFFFU, 
  k_selftest_ms_per_sec    = 1000U,       
  k_selftest_bytes_per_kib = 1024U,       
} selftest_verify_t;

typedef enum : uint32_t {
  k_selftest_phase_boot      = 0U, 
  k_selftest_phase_host_init = 1U, 
  k_selftest_phase_enum      = 2U, 
  k_selftest_phase_mount     = 3U, 
  k_selftest_phase_verify    = 4U, 
  k_selftest_phase_wp        = 5U, 
  k_selftest_phase_pass      = 6U, 
} selftest_phase_t;
 
/* -------------------------------------------------------------------------- */
/* J-Link probes */
/* -------------------------------------------------------------------------- */

static volatile uint32_t s_dbg_phase;
static volatile uint32_t s_dbg_verified_bytes;
static volatile uint32_t s_dbg_mismatch_off = (uint32_t)k_selftest_no_mismatch;
static volatile uint32_t s_dbg_verify_ms;
static volatile uint32_t s_dbg_pass_count;
 
/* -------------------------------------------------------------------------- */
/* Console helpers (SCI8 -> J-Link OB CDC) */
/* -------------------------------------------------------------------------- */

static uint8_t selftest_nibble_to_hex(uint32_t nibble)
{
  if (nibble < k_selftest_hex_digit_split) {
    return (uint8_t)((uint8_t)'0' + (uint8_t)nibble);
  }
  return (uint8_t)((uint8_t)'A' + (uint8_t)nibble - (uint8_t)k_selftest_hex_digit_split);
}

static uint32_t selftest_str_len(const char* text)
{
  uint32_t len = 0U;
  while (len < (uint32_t)k_selftest_print_cap) {
    if (text[len] == '\0') {
      break;
    }
    len++;
  }
  return len;
}

[[nodiscard]] static ra8_err_t selftest_sci_write(const uint8_t* data, uint32_t len)
{
  return ra8_board_uart_console_write(data, (size_t)len);
}

[[nodiscard]] static ra8_err_t selftest_print(const char* text)
{
  return selftest_sci_write((const uint8_t*)text, selftest_str_len(text));
}

[[nodiscard]] static ra8_err_t selftest_print_dec(uint32_t value)
{
  uint8_t  scratch[k_selftest_dec_chars_u32] = {};
  uint8_t  out[k_selftest_dec_chars_u32]     = {};
  uint8_t  count                             = 0U;
  uint32_t v                                 = value;
  if (v == 0U) {
    out[0] = (uint8_t)'0';
    return selftest_sci_write(out, 1U);
  }
  while (v != 0U) {
    if (count >= (uint8_t)k_selftest_dec_chars_u32) {
      break;
    }
    scratch[count] = (uint8_t)((uint8_t)'0' + (uint8_t)(v % k_selftest_dec_radix));
    v              = v / k_selftest_dec_radix;
    count++;
  }
  for (uint8_t i = 0U; i < count; i++) {
    out[i] = scratch[count - 1U - i];
  }
  return selftest_sci_write(out, (uint32_t)count);
}

[[nodiscard]] static ra8_err_t selftest_print_hex(uint32_t value, uint8_t digits)
{
  uint8_t out[k_selftest_hex_chars_u32] = {};
  uint8_t width                         = digits;
  if (width > (uint8_t)k_selftest_hex_chars_u32) {
    width = (uint8_t)k_selftest_hex_chars_u32;
  }
  for (uint8_t i = 0U; i < width; i++) {
    const uint8_t shift = (uint8_t)((width - 1U - i) * k_selftest_nibble_bits);
    out[i]              = selftest_nibble_to_hex((value >> shift) & k_selftest_nibble_mask);
  }
  return selftest_sci_write(out, (uint32_t)width);
}

[[nodiscard]] static ra8_err_t selftest_print_fail(const char* what, ra8_err_t err)
{
  ra8_err_t e = selftest_print("ra8d2 selftest: FAIL ");
  if (e != k_ra8_ok) {
    return e;
  }
  e = selftest_print(what);
  if (e != k_ra8_ok) {
    return e;
  }
  e = selftest_print(" err=0x");
  if (e != k_ra8_ok) {
    return e;
  }
  e = selftest_print_hex((uint32_t)err, (uint8_t)k_selftest_hex_chars_u32);
  if (e != k_ra8_ok) {
    return e;
  }
  return selftest_print("\r\n");
}
 
/* -------------------------------------------------------------------------- */
/* Host side: ra8_fs mount over the ra8_io USB-MSC block device */
/* -------------------------------------------------------------------------- */

static ra8_io_blockdev_t s_selftest_usb_dev;

static ra8_io_blockdev_usbmsc_state_t s_selftest_usb_state;

static const char* selftest_fs_type_name(ra8_fs_type_t type)
{
  switch (type) {
    case k_ra8_fs_type_fat12:
      return "fat12";
    case k_ra8_fs_type_fat16:
      return "fat16";
    case k_ra8_fs_type_fat32:
      return "fat32";
    case k_ra8_fs_type_exfat:
      return "exfat";
    case k_ra8_fs_type_unknown:
    default:
      return "unknown";
  }
}

[[nodiscard]] static ra8_err_t selftest_mount_volume(ra8_fs_mount_t** out_mount)
{
  ra8_err_t err = ra8_io_blockdev_usbmsc_init(&s_selftest_usb_dev,
                                              &s_selftest_usb_state,
                                              (uint8_t)k_selftest_target_lun);
  if (err != k_ra8_ok) {
    (void)selftest_print_fail("blockdev", err);
    return err;
  }
  ra8_fs_backend_t backend = {};
  err                      = ra8_io_blockdev_as_fs_backend(&s_selftest_usb_dev, &backend);
  if (err != k_ra8_ok) {
    (void)selftest_print_fail("backend", err);
    return err;
  }
  err = ra8_fs_mount(&backend, out_mount);
  if (err != k_ra8_ok) {
    (void)selftest_print_fail("mount", err);
    return err;
  }
  err = selftest_print("ra8d2 selftest: mounted fs=");
  if (err != k_ra8_ok) {
    return err;
  }
  err = selftest_print(selftest_fs_type_name((*out_mount)->type));
  if (err != k_ra8_ok) {
    return err;
  }
  return selftest_print("\r\n");
}

[[nodiscard]] static ra8_err_t selftest_verify_mram_raw(void)
{
  static uint8_t s_burst[k_selftest_burst_bytes] = {};
 
  s_dbg_verified_bytes = 0U;
  s_dbg_mismatch_off   = (uint32_t)k_selftest_no_mismatch;
  const uint32_t t0    = ra8_time_ms();
  for (uint32_t blk = 0U; blk < (uint32_t)k_fat_mram_clusters;
       blk += (uint32_t)k_selftest_burst_blocks) {
    const uint32_t lba = (uint32_t)k_fat_data_lba + blk;
    ra8_err_t      err = ra8_usb_hmsc_read10((uint8_t)k_selftest_target_lun,
                                             lba,
                                             (uint16_t)k_selftest_burst_blocks,
                                             s_burst);
    if (err != k_ra8_ok) {
      (void)selftest_print_fail("READ(10) burst", err);
      return err;
    }
    const uint32_t offset = blk * (uint32_t)k_selftest_block_size;
    const uint8_t* mram   = (const uint8_t*)(uintptr_t)((uint32_t)k_mram_base_addr + offset);
    if (memcmp(s_burst, mram, (size_t)k_selftest_burst_bytes) != 0) {
      s_dbg_mismatch_off = offset;
      (void)selftest_print_fail("content mismatch at 0x", (ra8_err_t)offset);
      return k_ra8_err_invalid_state;
    }
    s_dbg_verified_bytes = offset + (uint32_t)k_selftest_burst_bytes;
  }
  s_dbg_verify_ms = ra8_time_ms() - t0;
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t selftest_print_verify_verdict(void)
{
  ra8_err_t err = selftest_print("ra8d2 selftest: verified ");
  if (err != k_ra8_ok) {
    return err;
  }
  err = selftest_print_dec(s_dbg_verified_bytes);
  if (err != k_ra8_ok) {
    return err;
  }
  err = selftest_print(" bytes vs MRAM in ");
  if (err != k_ra8_ok) {
    return err;
  }
  err = selftest_print_dec(s_dbg_verify_ms);
  if (err != k_ra8_ok) {
    return err;
  }
  err = selftest_print(" ms (");
  if (err != k_ra8_ok) {
    return err;
  }
  uint32_t ms = s_dbg_verify_ms;
  if (ms == 0U) {
    ms = 1U;
  }
  const uint32_t kib_per_s =
    (uint32_t)(((uint64_t)s_dbg_verified_bytes * (uint64_t)k_selftest_ms_per_sec) /
               ((uint64_t)ms * (uint64_t)k_selftest_bytes_per_kib));
  err = selftest_print_dec(kib_per_s);
  if (err != k_ra8_ok) {
    return err;
  }
  return selftest_print(" KiB/s)\r\n");
}

[[nodiscard]] static ra8_err_t selftest_write_protect_probe(void)
{
  static uint8_t s_wp_buf[k_selftest_block_size] = {};
 
  ra8_err_t err = selftest_print("ra8d2 selftest: WRITE(10) into RO LUN must be rejected...\r\n");
  if (err != k_ra8_ok) {
    return err;
  }
  const ra8_err_t wr = ra8_usb_hmsc_write10((uint8_t)k_selftest_target_lun,
                                            (uint32_t)k_selftest_wp_probe_lba,
                                            1U,
                                            s_wp_buf);
  if (wr == k_ra8_ok) {
    (void)selftest_print_fail("write unexpectedly accepted", k_ra8_err_invalid_state);
    return k_ra8_err_invalid_state;
  }
  err = selftest_print("ra8d2 selftest: write rejected (code 0x");
  if (err != k_ra8_ok) {
    return err;
  }
  err = selftest_print_hex((uint32_t)wr, (uint8_t)k_selftest_hex_chars_u32);
  if (err != k_ra8_ok) {
    return err;
  }
  return selftest_print("), MRAM protected\r\n");
}

[[nodiscard]] static ra8_err_t selftest_host_enumerate(ra8_usb_hmsc_device_t* out_device)
{
  s_dbg_phase   = (uint32_t)k_selftest_phase_host_init;
  ra8_err_t err = selftest_print("ra8d2 selftest: host up on USB-HS, probing the loop...\r\n");
  if (err != k_ra8_ok) {
    return err;
  }
  err = ra8_usb_hmsc_init(k_ra8_usb_speed_hs);
  if (err != k_ra8_ok) {
    (void)selftest_print_fail("host init", err);
    return err;
  }
  s_dbg_phase = (uint32_t)k_selftest_phase_enum;
  err         = ra8_usb_hmsc_enumerate(out_device);
  if (err != k_ra8_ok) {
    (void)selftest_print_fail("enumerate", err);
    (void)ra8_usb_hmsc_close();
    return err;
  }
  err = selftest_print("ra8d2 selftest: enumerated vid=0x");
  if (err != k_ra8_ok) {
    return err;
  }
  err = selftest_print_hex((uint32_t)out_device->vendor_id, (uint8_t)k_selftest_hex_chars_u16);
  if (err != k_ra8_ok) {
    return err;
  }
  err = selftest_print(" pid=0x");
  if (err != k_ra8_ok) {
    return err;
  }
  err = selftest_print_hex((uint32_t)out_device->product_id, (uint8_t)k_selftest_hex_chars_u16);
  if (err != k_ra8_ok) {
    return err;
  }
  return selftest_print(" over the loop cable\r\n");
}

[[nodiscard]] static ra8_err_t selftest_browse_root(void)
{
  static uint8_t s_dir[k_selftest_block_size] = {};
 
  ra8_err_t err =
    ra8_usb_hmsc_read10((uint8_t)k_selftest_target_lun, (uint32_t)k_fat_root_lba, 1U, s_dir);
  if (err != k_ra8_ok) {
    (void)selftest_print_fail("READ(10) root dir", err);
    return err;
  }
  const uint8_t* entry = &s_dir[k_dir_entry_bytes]; /* entry 0 = volume label */
  char           name[(uint32_t)k_dir_name_bytes + 1U];
  for (uint32_t i = 0U; i < (uint32_t)k_dir_name_bytes; i++) {
    name[i] = (char)entry[i];
  }
  name[(uint32_t)k_dir_name_bytes] = '\0';
  uint32_t size                    = 0U;
  for (uint32_t i = 0U; i < 4U; i++) {
    size |= (uint32_t)entry[(uint32_t)k_dir_off_size + i] << (i * (uint32_t)k_byte_shift);
  }
  err = selftest_print("ra8d2 host: browsed root, file=");
  if (err == k_ra8_ok) {
    err = selftest_print(name);
  }
  if (err == k_ra8_ok) {
    err = selftest_print(" size=");
  }
  if (err == k_ra8_ok) {
    err = selftest_print_dec(size);
  }
  if (err == k_ra8_ok) {
    err = selftest_print(" bytes\r\n");
  }
  return err;
}

[[nodiscard]] ra8_err_t selftest_host_pass(void)
{
  ra8_usb_hmsc_device_t device = {};
  ra8_err_t             err    = selftest_host_enumerate(&device);
  if (err != k_ra8_ok) {
    return err;
  }
 
  /* Mount proves the host can PARSE the FAT16 volume over the loop;
   * then unmount and do the heavy integrity check with raw multi-block
   * READ(10) (ra8_fs's per-cluster metadata re-reads are far too slow
   * for a 1 MiB sweep). */
  s_dbg_phase           = (uint32_t)k_selftest_phase_mount;
  ra8_fs_mount_t* mount = nullptr;
  err                   = selftest_mount_volume(&mount);
  if (err != k_ra8_ok) {
    (void)ra8_usb_hmsc_close();
    return err;
  }
  (void)ra8_fs_unmount(mount);
 
  /* Browse the FAT directory of the fake peripheral (the host-side
   * directory walk this app adds on top of the raw integrity check). */
  err = selftest_browse_root();
  if (err != k_ra8_ok) {
    (void)ra8_usb_hmsc_close();
    return err;
  }
 
  s_dbg_phase = (uint32_t)k_selftest_phase_verify;
  err         = selftest_verify_mram_raw();
  if (err == k_ra8_ok) {
    err = selftest_print_verify_verdict();
  }
  if (err == k_ra8_ok) {
    s_dbg_phase = (uint32_t)k_selftest_phase_wp;
    err         = selftest_write_protect_probe();
  }
  if (err != k_ra8_ok) {
    (void)ra8_usb_hmsc_close();
    return err;
  }
 
  s_dbg_phase = (uint32_t)k_selftest_phase_pass;
  s_dbg_pass_count++;
  err = selftest_print("ra8d2 host: USB HOST MSC BROWSE PASS\r\n");
  if (err != k_ra8_ok) {
    return err;
  }
  (void)ra8_board_led_on(k_ra8_board_led2);
  return k_ra8_ok;
}
 
#endif /* !RA8_OFF_TARGET */