usb_msc_sdcard_steps.c

Go to the documentation of this file.

 
#include "usb_msc_sdcard_steps.h"
 
#include <stdint.h>
#include <string.h>
 
#include "ra8_board_ek_ra8d2.h"
#include "ra8_err.h"
#include "ra8_sdmmc_spi.h"
#include "ra8_usb.h"
 
#ifndef RA8_OFF_TARGET
#include "tx_api.h"
#include "ux_api.h"
#include "ux_dcd_ra8_usb.h"
#include "ux_device_class_storage.h"
#include "ux_device_stack.h"
 
/* -------------------------------------------------------------------------- */
/* USBX pool storage + SCSI INQUIRY strings */
/* -------------------------------------------------------------------------- */

static UCHAR s_usbx_pool[k_sdmsc_usbx_pool_bytes];
 
/* SCSI INQUIRY strings -- 8 / 16 / 4 byte fields per SBC-3. */
static UCHAR s_msc_vendor_id[]   = "RA8D2   ";
static UCHAR s_msc_product_id[]  = "SDCARD LIVE RW  ";
static UCHAR s_msc_product_rev[] = "0001";
 
/* -------------------------------------------------------------------------- */
/* J-Link probes (device worker + media-callback owned) */
/* -------------------------------------------------------------------------- */

static volatile uint32_t s_dbg_dev_step;
static volatile uint32_t s_dbg_dev_err;
static volatile uint32_t s_dbg_read_calls;
static volatile uint32_t s_dbg_write_calls;
static volatile uint32_t s_dbg_read_blocks;
static volatile uint32_t s_dbg_write_blocks;
static volatile uint32_t s_dbg_media_err;
 
/* -------------------------------------------------------------------------- */
/* USB descriptors (single-interface MSC; SCSI transparent; BBB) */
/* -------------------------------------------------------------------------- */
 
/* MSC config: bulk-only transport, SCSI command set, EP1 IN + EP2 OUT,
 * 64-byte MPS. PID 0x0019 marks the live-SD read/write MSC identity. */
static UCHAR s_device_framework_fs[] = {
  /* Device descriptor (USB 2.0 sec 9.6.1) -- 18 bytes. */
  0x12U,
  0x01U,
  0x00U,
  0x02U,
  0x00U,
  0x00U,
  0x00U,
  0x40U,
  0x09U,
  0x12U,
  0x19U, /* PID = 0x0019 (pid.codes test). */
  0x00U,
  0x00U,
  0x01U,
  0x01U,
  0x02U,
  0x03U,
  0x01U,
  /* Configuration descriptor (32 bytes total). */
  0x09U,
  0x02U,
  0x20U,
  0x00U,
  0x01U,
  0x01U,
  0x00U,
  0x80U,
  0x32U,
  /* Interface descriptor -- MSC, SCSI, BBB. */
  0x09U,
  0x04U,
  0x00U,
  0x00U,
  0x02U,
  0x08U,
  0x06U,
  0x50U,
  0x00U,
  /* Bulk-IN endpoint (EP1 IN, 64-byte MPS). */
  0x07U,
  0x05U,
  0x81U,
  0x02U,
  0x40U,
  0x00U,
  0x00U,
  /* Bulk-OUT endpoint (EP2 OUT, 64-byte MPS). */
  0x07U,
  0x05U,
  0x02U,
  0x02U,
  0x40U,
  0x00U,
  0x00U,
};

static UCHAR s_string_framework[] = {
  /* idx 1: "Brighton Sikarskie". */
  0x09U,
  0x04U,
  0x01U,
  0x12U,
  'B',
  'r',
  'i',
  'g',
  'h',
  't',
  'o',
  'n',
  ' ',
  'S',
  'i',
  'k',
  'a',
  'r',
  's',
  'k',
  'i',
  'e',
  /* idx 2: "RA8D2 SDCARD RW". */
  0x09U,
  0x04U,
  0x02U,
  0x0FU,
  'R',
  'A',
  '8',
  'D',
  '2',
  ' ',
  'S',
  'D',
  'C',
  'A',
  'R',
  'D',
  ' ',
  'R',
  'W',
  /* idx 3: serial. */
  0x09U,
  0x04U,
  0x03U,
  0x08U,
  '0',
  '0',
  '0',
  '0',
  '0',
  '0',
  '1',
  '9',
};

static UCHAR s_language_id_framework[] = {k_usb_langid_en_us_lo, k_usb_langid_en_us_hi};
 
/* -------------------------------------------------------------------------- */
/* Storage class media callbacks (single writable live-SD LUN) */
/* -------------------------------------------------------------------------- */

static UINT sdmsc_msc_read(VOID*  storage,
                           ULONG  lun,
                           UCHAR* data_pointer,
                           ULONG  number_blocks,
                           ULONG  lba,
                           ULONG* media_status)
{
  (void)storage;
  (void)lun;
  s_dbg_read_calls++;
  if ((lba + number_blocks) > (ULONG)s_usb_msc_sdcard_blocks) {
    *media_status = UX_DEVICE_CLASS_STORAGE_SENSE_STATUS(k_scsi_sense_illegal_request,
                                                         k_scsi_asc_lba_out_of_range,
                                                         k_scsi_ascq_none);
    return UX_ERROR;
  }
  const ra8_err_t err =
    ra8_sdmmc_spi_read_blocks((uint32_t)lba, data_pointer, (uint32_t)number_blocks);
  if (err != k_ra8_ok) {
    s_dbg_media_err = (uint32_t)err;
    *media_status   = UX_DEVICE_CLASS_STORAGE_SENSE_STATUS(k_scsi_sense_medium_error,
                                                           k_scsi_asc_unrecovered_read,
                                                           k_scsi_ascq_none);
    return UX_ERROR;
  }
  s_dbg_read_blocks += (uint32_t)number_blocks;
  *media_status = 0UL;
  (void)ra8_board_led_toggle(k_ra8_board_led1);
  return UX_SUCCESS;
}

static UINT sdmsc_msc_write(VOID*  storage,
                            ULONG  lun,
                            UCHAR* data_pointer,
                            ULONG  number_blocks,
                            ULONG  lba,
                            ULONG* media_status)
{
  (void)storage;
  (void)lun;
  s_dbg_write_calls++;
  if ((lba + number_blocks) > (ULONG)s_usb_msc_sdcard_blocks) {
    *media_status = UX_DEVICE_CLASS_STORAGE_SENSE_STATUS(k_scsi_sense_illegal_request,
                                                         k_scsi_asc_lba_out_of_range,
                                                         k_scsi_ascq_none);
    return UX_ERROR;
  }
  const ra8_err_t err =
    ra8_sdmmc_spi_write_blocks((uint32_t)lba, data_pointer, (uint32_t)number_blocks);
  if (err != k_ra8_ok) {
    s_dbg_media_err = (uint32_t)err;
    *media_status   = UX_DEVICE_CLASS_STORAGE_SENSE_STATUS(k_scsi_sense_medium_error,
                                                           k_scsi_asc_write_fault,
                                                           k_scsi_ascq_none);
    return UX_ERROR;
  }
  s_dbg_write_blocks += (uint32_t)number_blocks;
  *media_status = 0UL;
  (void)ra8_board_led_toggle(k_ra8_board_led2);
  return UX_SUCCESS;
}

static UINT sdmsc_msc_status(VOID* storage, ULONG lun, ULONG media_id, ULONG* media_status)
{
  (void)storage;
  (void)lun;
  (void)media_id;
  *media_status = 0UL;
  return UX_SUCCESS;
}
 
/* -------------------------------------------------------------------------- */
/* Device side: USBX MSC with one writable live-SD LUN */
/* -------------------------------------------------------------------------- */

static UINT sdmsc_usbx_stack_up(void)
{
  if (_ux_system_initialize(s_usbx_pool, k_sdmsc_usbx_pool_bytes, UX_NULL, 0) != UX_SUCCESS) {
    return UX_ERROR;
  }
  return _ux_device_stack_initialize((UCHAR*)UX_NULL,
                                     0,
                                     s_device_framework_fs,
                                     sizeof(s_device_framework_fs),
                                     s_string_framework,
                                     sizeof(s_string_framework),
                                     s_language_id_framework,
                                     sizeof(s_language_id_framework),
                                     UX_NULL);
}

static UINT sdmsc_class_register(void)
{
  UX_SLAVE_CLASS_STORAGE_PARAMETER msc_params;
  (void)memset(&msc_params, 0, sizeof(msc_params));
  msc_params.ux_slave_class_storage_parameter_number_lun  = 1UL;
  msc_params.ux_slave_class_storage_parameter_vendor_id   = s_msc_vendor_id;
  msc_params.ux_slave_class_storage_parameter_product_id  = s_msc_product_id;
  msc_params.ux_slave_class_storage_parameter_product_rev = s_msc_product_rev;
 
  msc_params.ux_slave_class_storage_parameter_lun[0].ux_slave_class_storage_media_last_lba =
    (ULONG)s_usb_msc_sdcard_blocks - 1UL;
  msc_params.ux_slave_class_storage_parameter_lun[0].ux_slave_class_storage_media_block_length =
    (ULONG)k_sdmsc_block_size;
  msc_params.ux_slave_class_storage_parameter_lun[0].ux_slave_class_storage_media_type =
    UX_SLAVE_CLASS_STORAGE_MEDIA_FAT_DISK;
  msc_params.ux_slave_class_storage_parameter_lun[0].ux_slave_class_storage_media_removable_flag =
    UX_SLAVE_CLASS_STORAGE_MEDIA_IS_REMOVABLE;
  msc_params.ux_slave_class_storage_parameter_lun[0].ux_slave_class_storage_media_read_only_flag =
    UX_FALSE;
  msc_params.ux_slave_class_storage_parameter_lun[0].ux_slave_class_storage_media_read =
    sdmsc_msc_read;
  msc_params.ux_slave_class_storage_parameter_lun[0].ux_slave_class_storage_media_write =
    sdmsc_msc_write;
  msc_params.ux_slave_class_storage_parameter_lun[0].ux_slave_class_storage_media_status =
    sdmsc_msc_status;
 
  static UCHAR s_class_name[] = "ux_slave_class_storage";
 
  return _ux_device_stack_class_register(s_class_name,
                                         _ux_device_class_storage_entry,
                                         1,
                                         0,
                                         &msc_params);
}

[[nodiscard]] static ra8_err_t sdmsc_print_ready(void)
{
  ra8_err_t err = sdmsc_print("usb_msc_sdcard: USB MSC SDCARD READY (RW, ");
  if (err != k_ra8_ok) {
    return err;
  }
  err = sdmsc_print_dec(s_usb_msc_sdcard_blocks);
  if (err != k_ra8_ok) {
    return err;
  }
  return sdmsc_print(" blocks)\r\n");
}
 
VOID sdmsc_device_worker(ULONG arg)
{
  (void)arg;
 
  if (s_usb_msc_sdcard_blocks == 0U) {
    (void)sdmsc_print_fail("no card -- not attaching USB", k_ra8_err_invalid_state);
    return;
  }
  UINT ux = sdmsc_usbx_stack_up();
  if (ux != UX_SUCCESS) {
    s_dbg_dev_err = (uint32_t)ux;
    (void)sdmsc_print_fail("usbx stack", (ra8_err_t)ux);
    return;
  }
  s_dbg_dev_step = (uint32_t)k_sdmsc_dev_step_stack;
  ux             = sdmsc_class_register();
  if (ux != UX_SUCCESS) {
    s_dbg_dev_err = (uint32_t)ux;
    (void)sdmsc_print_fail("msc class", (ra8_err_t)ux);
    return;
  }
  s_dbg_dev_step = (uint32_t)k_sdmsc_dev_step_class;
  ra8_err_t err  = ux_dcd_ra8_usb_initialize(k_ra8_usb_speed_fs);
  if (err != k_ra8_ok) {
    s_dbg_dev_err = (uint32_t)err;
    (void)sdmsc_print_fail("dcd init", err);
    return;
  }
  s_dbg_dev_step = (uint32_t)k_sdmsc_dev_step_dcd;
  err            = ra8_usb_device_attach(k_ra8_usb_speed_fs, true);
  if (err != k_ra8_ok) {
    s_dbg_dev_err = (uint32_t)err;
    (void)sdmsc_print_fail("device attach", err);
    return;
  }
  s_dbg_dev_step = (uint32_t)k_sdmsc_dev_step_attach;
  (void)sdmsc_print_ready();
 
  while (1) {
    s_dbg_dev_step = (uint32_t)k_sdmsc_dev_step_parked;
    tx_thread_sleep(k_sdmsc_idle_ticks);
  }
}
 
#endif /* !RA8_OFF_TARGET */