ra8_usb_pmsc_scsi.c

Go to the documentation of this file.

 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ra8_err.h"
#include "ra8_usb.h"
#include "ra8_usb_pmsc.h"
#include "ra8_usb_pmsc_internal.h"
 
/* =============================================================================
 * Internal constants
 * =============================================================================
 */

typedef enum : uint8_t {
  k_ra8_pmsc_cdb_off_lba_msb = 2U, 
  k_ra8_pmsc_cdb_off_lba_b1  = 3U, 
  k_ra8_pmsc_cdb_off_lba_b2  = 4U, 
  k_ra8_pmsc_cdb_off_lba_lsb = 5U, 
  k_ra8_pmsc_cdb_off_cnt_msb = 7U, 
  k_ra8_pmsc_cdb_off_cnt_lsb = 8U, 
} ra8_usb_pmsc_cdb_offset_t;

typedef enum : uint8_t {
  k_ra8_pmsc_inq_off_dev_type    = 0U,  
  k_ra8_pmsc_inq_off_removable   = 1U,  
  k_ra8_pmsc_inq_off_version     = 2U,  
  k_ra8_pmsc_inq_off_resp_format = 3U,  
  k_ra8_pmsc_inq_off_addl_length = 4U,  
  k_ra8_pmsc_inq_off_vendor      = 8U,  
  k_ra8_pmsc_inq_off_product     = 16U, 
  k_ra8_pmsc_inq_off_revision    = 32U, 
} ra8_usb_pmsc_inquiry_offset_t;

typedef enum : uint8_t {
  k_ra8_pmsc_inq_byte_dev_type    = 0x00U, 
  k_ra8_pmsc_inq_byte_removable   = 0x80U, 
  k_ra8_pmsc_inq_byte_version     = 0x04U, 
  k_ra8_pmsc_inq_byte_resp_format = 0x02U, 
  k_ra8_pmsc_inq_byte_addl_length = 0x1FU, 
} ra8_usb_pmsc_inquiry_byte_t;

typedef enum : uint8_t {
  k_ra8_pmsc_cap_off_last_lba = 0U, 
  k_ra8_pmsc_cap_off_blk_size = 4U, 
} ra8_usb_pmsc_capacity_offset_t;

typedef enum : uint8_t {
  k_ra8_pmsc_sense_resp_code         = 0x70U, 
  k_ra8_pmsc_sense_addl_length_byte  = 7U,    
  k_ra8_pmsc_sense_addl_length_value = 0x0AU, 
  k_ra8_pmsc_mode_data_length_value  = 0x03U, 
} ra8_usb_pmsc_sense_t;

typedef enum : uint8_t {
  k_ra8_pmsc_ascii_space = 0x20U, 
} ra8_usb_pmsc_ascii_t;
 
/* =============================================================================
 * Internal helpers
 * =============================================================================
 */

RA8_INTERNAL
static void internal_pack_u32_be(uint32_t value, uint8_t* dst)
{
  dst[0] = (uint8_t)((value >> k_ra8_pmsc_shift_byte3) & k_ra8_pmsc_byte_mask);
  dst[1] = (uint8_t)((value >> k_ra8_pmsc_shift_byte2) & k_ra8_pmsc_byte_mask);
  dst[2] = (uint8_t)((value >> k_ra8_pmsc_shift_byte1) & k_ra8_pmsc_byte_mask);
  dst[3] = (uint8_t)((value >> k_ra8_pmsc_shift_byte0) & k_ra8_pmsc_byte_mask);
}

RA8_INTERNAL
static void internal_pad_space(uint8_t* dst, uint32_t len)
{
  for (uint32_t i = 0U; i < len; ++i) {
    dst[i] = k_ra8_pmsc_ascii_space;
  }
}
 
/* =============================================================================
 * SCSI handler internals
 * =============================================================================
 */

RA8_INTERNAL
static void internal_decode_rw10(const uint8_t* cdb, uint32_t* out_lba, uint32_t* out_block_count)
{
  *out_lba         = ((uint32_t)cdb[k_ra8_pmsc_cdb_off_lba_msb] << k_ra8_pmsc_shift_byte3) |
                     ((uint32_t)cdb[k_ra8_pmsc_cdb_off_lba_b1] << k_ra8_pmsc_shift_byte2) |
                     ((uint32_t)cdb[k_ra8_pmsc_cdb_off_lba_b2] << k_ra8_pmsc_shift_byte1) |
                     ((uint32_t)cdb[k_ra8_pmsc_cdb_off_lba_lsb] << k_ra8_pmsc_shift_byte0);
  *out_block_count = ((uint32_t)cdb[k_ra8_pmsc_cdb_off_cnt_msb] << k_ra8_pmsc_shift_byte1) |
                     ((uint32_t)cdb[k_ra8_pmsc_cdb_off_cnt_lsb] << k_ra8_pmsc_shift_byte0);
}
 
ra8_err_t priv_handle_inquiry(uint8_t* data_buf, uint32_t capacity, uint32_t* out_len)
{
  if (capacity < k_ra8_pmsc_inquiry_resp_len) {
    return k_ra8_err_invalid_size;
  }
  priv_zero_bytes(data_buf, (uint32_t)k_ra8_pmsc_inquiry_resp_len);
 
  data_buf[k_ra8_pmsc_inq_off_dev_type]    = k_ra8_pmsc_inq_byte_dev_type;
  data_buf[k_ra8_pmsc_inq_off_removable]   = k_ra8_pmsc_inq_byte_removable;
  data_buf[k_ra8_pmsc_inq_off_version]     = k_ra8_pmsc_inq_byte_version;
  data_buf[k_ra8_pmsc_inq_off_resp_format] = k_ra8_pmsc_inq_byte_resp_format;
  data_buf[k_ra8_pmsc_inq_off_addl_length] = k_ra8_pmsc_inq_byte_addl_length;
 
  /* Pad the three string fields with SPACE first so a backend that
   * writes fewer bytes still produces a spec-conforming response. */
  internal_pad_space(&data_buf[k_ra8_pmsc_inq_off_vendor], (uint32_t)k_ra8_pmsc_inq_vendor_len);
  internal_pad_space(&data_buf[k_ra8_pmsc_inq_off_product], (uint32_t)k_ra8_pmsc_inq_product_len);
  internal_pad_space(&data_buf[k_ra8_pmsc_inq_off_revision], (uint32_t)k_ra8_pmsc_inq_revision_len);
 
  const ra8_err_t err =
    g_usb_pmsc_state.storage.get_inquiry(g_usb_pmsc_state.storage.ctx,
                                         &data_buf[k_ra8_pmsc_inq_off_vendor],
                                         &data_buf[k_ra8_pmsc_inq_off_product],
                                         &data_buf[k_ra8_pmsc_inq_off_revision]);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_len = (uint32_t)k_ra8_pmsc_inquiry_resp_len;
  return k_ra8_ok;
}
 
ra8_err_t priv_handle_read_capacity(uint8_t* data_buf, uint32_t capacity, uint32_t* out_len)
{
  if (capacity < k_ra8_pmsc_read_capacity_resp_len) {
    return k_ra8_err_invalid_size;
  }
  uint32_t        block_count = 0U;
  uint32_t        block_size  = 0U;
  const ra8_err_t err =
    g_usb_pmsc_state.storage.get_capacity(g_usb_pmsc_state.storage.ctx, &block_count, &block_size);
  if (err != k_ra8_ok) {
    return err;
  }
  /* Block count of zero is meaningless; degrade gracefully. */
  const uint32_t last_lba = (block_count == 0U) ? 0U : (block_count - 1U);
  priv_zero_bytes(data_buf, (uint32_t)k_ra8_pmsc_read_capacity_resp_len);
  internal_pack_u32_be(last_lba, &data_buf[k_ra8_pmsc_cap_off_last_lba]);
  internal_pack_u32_be(block_size, &data_buf[k_ra8_pmsc_cap_off_blk_size]);
  *out_len = (uint32_t)k_ra8_pmsc_read_capacity_resp_len;
  return k_ra8_ok;
}
 
ra8_err_t priv_handle_request_sense(uint8_t* data_buf, uint32_t capacity, uint32_t* out_len)
{
  if (capacity < k_ra8_pmsc_request_sense_resp_len) {
    return k_ra8_err_invalid_size;
  }
  priv_zero_bytes(data_buf, (uint32_t)k_ra8_pmsc_request_sense_resp_len);
  /* Byte 0 = response code (0x70 current error, valid bit clear). */
  data_buf[0] = k_ra8_pmsc_sense_resp_code;
  /* Byte 7 = additional sense length (n - 7 = 10). */
  data_buf[k_ra8_pmsc_sense_addl_length_byte] = k_ra8_pmsc_sense_addl_length_value;
  *out_len                                    = (uint32_t)k_ra8_pmsc_request_sense_resp_len;
  return k_ra8_ok;
}
 
ra8_err_t priv_handle_mode_sense(uint8_t* data_buf, uint32_t capacity, uint32_t* out_len)
{
  if (capacity < k_ra8_pmsc_mode_sense_resp_len) {
    return k_ra8_err_invalid_size;
  }
  priv_zero_bytes(data_buf, (uint32_t)k_ra8_pmsc_mode_sense_resp_len);
  /* Mode data length (3, header-only response). */
  data_buf[0] = k_ra8_pmsc_mode_data_length_value;
  *out_len    = (uint32_t)k_ra8_pmsc_mode_sense_resp_len;
  return k_ra8_ok;
}
 
ra8_err_t priv_handle_read10(uint8_t* data_buf, uint32_t capacity, uint32_t* out_len)
{
  uint32_t lba         = 0U;
  uint32_t block_count = 0U;
  internal_decode_rw10(g_usb_pmsc_state.cbw_cdb, &lba, &block_count);
  if (block_count == 0U) {
    *out_len = 0U;
    return k_ra8_ok;
  }
  uint32_t        device_block_count = 0U;
  uint32_t        block_size         = 0U;
  const ra8_err_t cap_err = g_usb_pmsc_state.storage.get_capacity(g_usb_pmsc_state.storage.ctx,
                                                                  &device_block_count,
                                                                  &block_size);
  if (cap_err != k_ra8_ok) {
    return cap_err;
  }
  if (block_size == 0U) {
    block_size = (uint32_t)k_ra8_pmsc_block_size_default;
  }
  const uint32_t bytes = block_count * block_size;
  if (bytes > capacity) {
    return k_ra8_err_invalid_size;
  }
  const ra8_err_t err =
    g_usb_pmsc_state.storage.read_block(g_usb_pmsc_state.storage.ctx, lba, block_count, data_buf);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_len = bytes;
  return k_ra8_ok;
}
 
ra8_err_t priv_handle_write10(const uint8_t* data_buf, uint32_t* out_len)
{
  uint32_t lba         = 0U;
  uint32_t block_count = 0U;
  internal_decode_rw10(g_usb_pmsc_state.cbw_cdb, &lba, &block_count);
  if (block_count == 0U) {
    *out_len = 0U;
    return k_ra8_ok;
  }
  uint32_t        device_block_count = 0U;
  uint32_t        block_size         = 0U;
  const ra8_err_t cap_err = g_usb_pmsc_state.storage.get_capacity(g_usb_pmsc_state.storage.ctx,
                                                                  &device_block_count,
                                                                  &block_size);
  if (cap_err != k_ra8_ok) {
    return cap_err;
  }
  if (block_size == 0U) {
    block_size = (uint32_t)k_ra8_pmsc_block_size_default;
  }
  const ra8_err_t err =
    g_usb_pmsc_state.storage.write_block(g_usb_pmsc_state.storage.ctx, lba, block_count, data_buf);
  if (err != k_ra8_ok) {
    return err;
  }
  *out_len = block_count * block_size;
  return k_ra8_ok;
}