usb_selftest_mlun_steps.c

Go to the documentation of this file.

 
#include "usb_selftest_mlun_steps.h"
 
#include <stdint.h>
#include <string.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_err.h"
#include "ra8_usb_hmsc.h"
 
#ifndef RA8_OFF_TARGET
 
#include "tx_api.h"
#include "ux_api.h"
#include "ux_device_class_storage.h"
 
/* -------------------------------------------------------------------------- */
/* J-Link probes (host-ladder side) */
/* -------------------------------------------------------------------------- */

static volatile uint32_t s_dbg_phase;
static volatile uint32_t s_dbg_luns_ok;
static volatile uint32_t s_dbg_max_lun;
static volatile uint32_t s_dbg_mismatch = (uint32_t)k_mlun_no_mismatch;
static volatile uint32_t s_dbg_pass_count;
 
/* -------------------------------------------------------------------------- */
/* Shared per-(LUN,LBA) pattern */
/* -------------------------------------------------------------------------- */
 
void mlun_pattern_fill(uint32_t lun, uint32_t lba, UCHAR* out)
{
  for (uint32_t i = 0U; i < (uint32_t)k_mlun_block_size; i++) {
    const uint32_t v = (lun * (uint32_t)k_mlun_pat_lun_mul) + (lba * (uint32_t)k_mlun_pat_lba_mul) +
                       i + (uint32_t)k_mlun_pat_bias;
    out[i]           = (UCHAR)(v & (uint32_t)k_mlun_byte_mask);
  }
}
 
/* -------------------------------------------------------------------------- */
/* Console helpers (SCI8 -> J-Link OB CDC) */
/* -------------------------------------------------------------------------- */

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

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

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

[[nodiscard]] static ra8_err_t mlun_print(const char* text)
{
  return mlun_sci_write((const uint8_t*)text, mlun_str_len(text));
}

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

[[nodiscard]] static ra8_err_t mlun_print_hex(uint32_t value, uint8_t digits)
{
  uint8_t out[k_mlun_hex_chars_u32] = {};
  uint8_t width                     = digits;
  if (width > (uint8_t)k_mlun_hex_chars_u32) {
    width = (uint8_t)k_mlun_hex_chars_u32;
  }
  for (uint8_t i = 0U; i < width; i++) {
    const uint8_t shift = (uint8_t)((width - 1U - i) * k_mlun_nibble_bits);
    out[i]              = mlun_nibble_to_hex((value >> shift) & k_mlun_nibble_mask);
  }
  return mlun_sci_write(out, (uint32_t)width);
}

[[nodiscard]] static ra8_err_t mlun_print_fail(const char* what, ra8_err_t err)
{
  ra8_err_t e = mlun_print("ra8d2 mlun: FAIL ");
  if (e != k_ra8_ok) {
    return e;
  }
  e = mlun_print(what);
  if (e != k_ra8_ok) {
    return e;
  }
  e = mlun_print(" err=0x");
  if (e != k_ra8_ok) {
    return e;
  }
  e = mlun_print_hex((uint32_t)err, (uint8_t)k_mlun_hex_chars_u32);
  if (e != k_ra8_ok) {
    return e;
  }
  return mlun_print("\r\n");
}
 
/* -------------------------------------------------------------------------- */
/* Host side: ra8_usb_hmsc enumerate + per-LUN read/verify */
/* -------------------------------------------------------------------------- */

[[nodiscard]] static ra8_err_t mlun_verify_one(uint32_t lun)
{
  static uint8_t s_burst[k_mlun_burst_bytes] = {};
  static uint8_t s_expect[k_mlun_block_size] = {};
 
  uint32_t  block_count = 0U;
  uint32_t  block_size  = 0U;
  ra8_err_t err         = ra8_usb_hmsc_read_capacity((uint8_t)lun, &block_count, &block_size);
  if (err != k_ra8_ok) {
    (void)mlun_print_fail("read_capacity", err);
    return err;
  }
  if (block_count != (uint32_t)k_mlun_sectors) {
    (void)mlun_print_fail("capacity mismatch", k_ra8_err_invalid_size);
    return k_ra8_err_invalid_size;
  }
  for (uint32_t blk = 0U; blk < (uint32_t)k_mlun_sectors; blk += (uint32_t)k_mlun_burst_blocks) {
    err = ra8_usb_hmsc_read10((uint8_t)lun, blk, (uint16_t)k_mlun_burst_blocks, s_burst);
    if (err != k_ra8_ok) {
      (void)mlun_print_fail("READ(10)", err);
      return err;
    }
    for (uint32_t s = 0U; s < (uint32_t)k_mlun_burst_blocks; s++) {
      mlun_pattern_fill(lun, blk + s, s_expect);
      const uint32_t boff = s * (uint32_t)k_mlun_block_size;
      if (memcmp(&s_burst[boff], s_expect, (size_t)k_mlun_block_size) != 0) {
        s_dbg_mismatch = (lun << (uint32_t)k_mlun_mismatch_lun_shift) | (blk + s);
        (void)mlun_print_fail("LUN data mismatch", k_ra8_err_invalid_state);
        return k_ra8_err_invalid_state;
      }
    }
  }
  return k_ra8_ok;
}

[[nodiscard]] static ra8_err_t mlun_print_lun_ok(uint32_t lun)
{
  ra8_err_t err = mlun_print("ra8d2 mlun: LUN ");
  if (err != k_ra8_ok) {
    return err;
  }
  err = mlun_print_dec(lun);
  if (err != k_ra8_ok) {
    return err;
  }
  return mlun_print(" OK (256 sectors, pattern verified)\r\n");
}

[[nodiscard]] static ra8_err_t mlun_host_enumerate(ra8_usb_hmsc_device_t* device)
{
  s_dbg_phase   = (uint32_t)k_mlun_phase_enum;
  ra8_err_t err = ra8_usb_hmsc_enumerate(device);
  if (err != k_ra8_ok) {
    (void)mlun_print_fail("enumerate", err);
    (void)ra8_usb_hmsc_close();
    return err;
  }
  s_dbg_max_lun = (uint32_t)device->max_lun;
  err           = mlun_print("ra8d2 mlun: enumerated pid=0x");
  if (err != k_ra8_ok) {
    return err;
  }
  err = mlun_print_hex((uint32_t)device->product_id, (uint8_t)k_mlun_hex_chars_u16);
  if (err != k_ra8_ok) {
    return err;
  }
  err = mlun_print(", GET_MAX_LUN=");
  if (err != k_ra8_ok) {
    return err;
  }
  err = mlun_print_dec(s_dbg_max_lun);
  if (err != k_ra8_ok) {
    return err;
  }
  return mlun_print("\r\n");
}

[[nodiscard]] static ra8_err_t mlun_host_pass(void)
{
  s_dbg_phase   = (uint32_t)k_mlun_phase_init;
  ra8_err_t err = mlun_print("ra8d2 mlun: 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)mlun_print_fail("host init", err);
    return err;
  }
 
  ra8_usb_hmsc_device_t device = {};
  err                          = mlun_host_enumerate(&device);
  if (err != k_ra8_ok) {
    return err;
  }
 
  s_dbg_phase   = (uint32_t)k_mlun_phase_verify;
  s_dbg_luns_ok = 0U;
  for (uint32_t lun = 0U; lun < (uint32_t)k_mlun_count; lun++) {
    err = mlun_verify_one(lun);
    if (err != k_ra8_ok) {
      (void)ra8_usb_hmsc_close();
      return err;
    }
    s_dbg_luns_ok++;
    err = mlun_print_lun_ok(lun);
    if (err != k_ra8_ok) {
      return err;
    }
  }
 
  s_dbg_phase = (uint32_t)k_mlun_phase_pass;
  s_dbg_pass_count++;
  err = mlun_print("ra8d2 mlun: USB SELFTEST MULTI-LUN PASS\r\n");
  if (err != k_ra8_ok) {
    return err;
  }
  (void)ra8_board_led_on(k_ra8_board_led2);
  return k_ra8_ok;
}
 
VOID mlun_host_worker(ULONG arg)
{
  (void)arg;
 
  tx_thread_sleep(k_mlun_boot_wait_ticks);
  for (;;) {
    const ra8_err_t err = mlun_host_pass();
    if (err == k_ra8_ok) {
      break;
    }
    tx_thread_sleep(k_mlun_retry_ticks);
  }
  while (1) {
    tx_thread_sleep(k_mlun_idle_ticks);
  }
}
 
#endif /* !RA8_OFF_TARGET */