ra8_io_blockdev_usbmsc.c

Go to the documentation of this file.

 
#include "ra8_io_blockdev_usbmsc.h"
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_check.h"
#include "ra8_err.h"
#include "ra8_io_blockdev.h"
#include "ra8_io_blockdev_backend.h"
#include "ra8_usb_hmsc.h"

static const char* const s_tag = "ra8_io_blockdev_usbmsc";

typedef enum : uint32_t {
  k_ra8_io_usbmsc_erase_unit_blocks = 1, 
} ra8_io_usbmsc_const_t;

RA8_INTERNAL
static ra8_err_t internal_usbmsc_read(void* ctx, uint32_t lba, uint32_t count, uint8_t* buf)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  const ra8_io_blockdev_usbmsc_state_t* st = (const ra8_io_blockdev_usbmsc_state_t*)ctx;
  if (count > (uint32_t)k_ra8_io_usbmsc_max_transfer_blocks) {
    return k_ra8_err_out_of_range;
  }
  return ra8_usb_hmsc_read10(st->lun, lba, (uint16_t)count, buf);
}

RA8_INTERNAL
static ra8_err_t internal_usbmsc_write(void* ctx, uint32_t lba, uint32_t count, const uint8_t* buf)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(buf, s_tag, "buf must not be nullptr");
  const ra8_io_blockdev_usbmsc_state_t* st = (const ra8_io_blockdev_usbmsc_state_t*)ctx;
  if (count > (uint32_t)k_ra8_io_usbmsc_max_transfer_blocks) {
    return k_ra8_err_out_of_range;
  }
  return ra8_usb_hmsc_write10(st->lun, lba, (uint16_t)count, buf);
}

RA8_INTERNAL
static ra8_err_t internal_usbmsc_get_caps(const void* ctx, ra8_io_blockdev_caps_t* out)
{
  RA8_CHECK_NULL_PTR(ctx, s_tag, "ctx must not be nullptr");
  RA8_CHECK_NULL_PTR(out, s_tag, "out must not be nullptr");
  const ra8_io_blockdev_usbmsc_state_t* st         = (const ra8_io_blockdev_usbmsc_state_t*)ctx;
  uint32_t                              blocks     = 0;
  uint32_t                              block_size = 0;
  const ra8_err_t cap = ra8_usb_hmsc_read_capacity(st->lun, &blocks, &block_size);
  if (cap != k_ra8_ok) {
    return cap;
  }
  /* GCOVR_EXCL_START -- host-unreachable: everything below runs only after a
   * completed READ CAPACITY(10), which needs a Bulk-Only Transport round trip.
   * The plain-RAM ra8_fake_mmap backing has no USB SIE model, so the CBW push
   * inside ra8_usb_hmsc always times out and this tail is bench territory --
   * the same boundary ra8_usb_hmsc.c marks on its own command tails. */
  if (block_size != (uint32_t)k_ra8_io_block_size_bytes) {
    return k_ra8_err_not_supported;
  }
  out->block_count             = blocks;
  out->erase_unit_blocks       = (uint32_t)k_ra8_io_usbmsc_erase_unit_blocks;
  out->program_size_bytes      = (uint32_t)k_ra8_io_block_size_bytes;
  out->logical_block_bytes     = (uint16_t)k_ra8_io_block_size_bytes;
  out->erase_value             = (uint8_t)k_ra8_io_erase_value_zero;
  out->must_erase_before_write = false;
  out->read_only               = false;
  return k_ra8_ok;
  /* GCOVR_EXCL_STOP */
}

static const ra8_io_blockdev_iface_t s_usbmsc_iface = {
  .read     = internal_usbmsc_read,
  .write    = internal_usbmsc_write,
  .erase    = nullptr,
  .get_caps = internal_usbmsc_get_caps,
  .sync     = nullptr,
};
 
ra8_err_t ra8_io_blockdev_usbmsc_init(ra8_io_blockdev_t*              bd,
                                      ra8_io_blockdev_usbmsc_state_t* state,
                                      uint8_t                         lun)
{
  RA8_CHECK_NULL_PTR(bd, s_tag, "bd must not be nullptr");
  RA8_CHECK_NULL_PTR(state, s_tag, "state must not be nullptr");
  if (lun > (uint8_t)k_ra8_hmsc_max_lun) {
    return k_ra8_err_out_of_range;
  }
  state->lun = lun;
  bd->iface  = &s_usbmsc_iface;
  bd->ctx    = state;
  return k_ra8_ok;
}