ux_device_class_storage_inquiry.c

Go to the documentation of this file.

 
#define UX_SOURCE_CODE
 
#include <stdint.h>
 
#include "ra8_attributes.h"
#include "ux_api.h"
#include "ux_device_class_storage.h"
#include "ux_device_stack.h"

typedef enum : uint8_t {
  k_inq_cdb_off_evpd    = 1U,    
  k_inq_cdb_evpd_bit    = 0x01U, 
  k_inq_off_page_code   = 1U,    
  k_inq_off_version     = 2U,    
  k_inq_off_data_format = 3U,    
  k_inq_off_addl_len    = 4U,    
  k_inq_version_spc2    = 0x04U, 
  k_inq_format_spc      = 0x02U, 
  k_inq_format_cdrom    = 0x32U, 
  k_inq_addl_len_std    = 0x1FU, 
  k_inq_vpd0_count_off  = 3U,    
  k_inq_vpd0_first_off  = 4U,    
  k_inq_vpd0_second_off = 5U,    
  k_inq_vpd0_pages      = 2U,    
  k_inq_vpd0_len        = 6U,    
  k_inq_vpd_hdr_len     = 4U,    
  k_inq_serial_len      = 20U,   
  k_inq_vendor_id_len   = 8U,    
  k_inq_product_id_len  = 16U,   
  k_inq_product_rev_len = 4U,    
  k_inq_serial_resp_len = 24U,   
  k_inq_dir_in_bit      = 0x80U, 
  k_inq_sense_illegal   = 0x05U, 
  k_inq_sense_asc_field = 0x26U, 
  k_inq_sense_ascq      = 0x01U, 
} ra8_ux_inquiry_const_t;

RA8_INTERNAL static void
internal_inquiry_fill_standard(UX_SLAVE_CLASS_STORAGE* storage, ULONG lun, UCHAR* buf)
{
  buf[UX_SLAVE_CLASS_STORAGE_INQUIRY_RESPONSE_PERIPHERAL_TYPE] =
    (UCHAR)storage->ux_slave_class_storage_lun[lun].ux_slave_class_storage_media_type;
  buf[UX_SLAVE_CLASS_STORAGE_INQUIRY_RESPONSE_REMOVABLE_MEDIA] =
    (UCHAR)storage->ux_slave_class_storage_lun[lun].ux_slave_class_storage_media_removable_flag;
  if (storage->ux_slave_class_storage_lun[lun].ux_slave_class_storage_media_type ==
      UX_SLAVE_CLASS_STORAGE_MEDIA_CDROM) {
    buf[k_inq_off_data_format] = (UCHAR)k_inq_format_cdrom;
    buf[k_inq_off_addl_len]    = UX_SLAVE_CLASS_STORAGE_INQUIRY_RESPONSE_LENGTH_CD_ROM;
  } else {
    buf[k_inq_off_version]     = (UCHAR)k_inq_version_spc2;
    buf[k_inq_off_data_format] = (UCHAR)k_inq_format_spc;
    buf[k_inq_off_addl_len]    = (UCHAR)k_inq_addl_len_std;
  }
  _ux_utility_memory_copy(buf + UX_SLAVE_CLASS_STORAGE_INQUIRY_RESPONSE_VENDOR_INFORMATION,
                          storage->ux_slave_class_storage_vendor_id,
                          (ULONG)k_inq_vendor_id_len); /* Use case of memcpy is verified. */
  _ux_utility_memory_copy(buf + UX_SLAVE_CLASS_STORAGE_INQUIRY_RESPONSE_PRODUCT_ID,
                          storage->ux_slave_class_storage_product_id,
                          (ULONG)k_inq_product_id_len); /* Use case of memcpy is verified. */
  _ux_utility_memory_copy(buf + UX_SLAVE_CLASS_STORAGE_INQUIRY_RESPONSE_PRODUCT_REVISION,
                          storage->ux_slave_class_storage_product_rev,
                          (ULONG)k_inq_product_rev_len); /* Use case of memcpy is verified. */
}

RA8_INTERNAL static ULONG internal_inquiry_fill_vpd_pages(UCHAR* buf)
{
  buf[k_inq_off_page_code]   = UX_SLAVE_CLASS_STORAGE_INQUIRY_PAGE_CODE_STANDARD;
  buf[k_inq_vpd0_count_off]  = (UCHAR)k_inq_vpd0_pages;
  buf[k_inq_vpd0_first_off]  = UX_SLAVE_CLASS_STORAGE_INQUIRY_PAGE_CODE_STANDARD;
  buf[k_inq_vpd0_second_off] = UX_SLAVE_CLASS_STORAGE_INQUIRY_PAGE_CODE_SERIAL;
  return (ULONG)k_inq_vpd0_len;
}

RA8_INTERNAL static ULONG internal_inquiry_fill_serial(UX_SLAVE_CLASS_STORAGE* storage, UCHAR* buf)
{
  _ux_utility_short_put_big_endian(buf, UX_SLAVE_CLASS_STORAGE_INQUIRY_PAGE_CODE_SERIAL);
  _ux_utility_short_put_big_endian(buf + k_inq_off_version, (USHORT)k_inq_serial_len);
  _ux_utility_memory_copy(buf + k_inq_vpd_hdr_len,
                          storage->ux_slave_class_storage_product_serial,
                          (ULONG)k_inq_serial_len); /* Use case of memcpy is verified. */
  return (ULONG)k_inq_serial_resp_len;
}

RA8_INTERNAL static UINT
internal_inquiry_reject(UX_SLAVE_CLASS_STORAGE* storage, ULONG lun, UX_SLAVE_ENDPOINT* endpoint_in)
{
#ifndef UX_DEVICE_STANDALONE
  _ux_device_stack_endpoint_stall(endpoint_in);
#else
  UX_PARAMETER_NOT_USED(endpoint_in);
#endif
  storage->ux_slave_class_storage_lun[lun].ux_slave_class_storage_request_sense_status =
    UX_DEVICE_CLASS_STORAGE_SENSE_STATUS(k_inq_sense_illegal,
                                         k_inq_sense_asc_field,
                                         k_inq_sense_ascq);
  storage->ux_slave_class_storage_csw_status = UX_SLAVE_CLASS_STORAGE_CSW_FAILED;
  return UX_ERROR;
}

RA8_INTERNAL static void internal_inquiry_send(UX_SLAVE_CLASS_STORAGE* storage,
                                               UX_SLAVE_ENDPOINT*      endpoint_in,
                                               UX_SLAVE_TRANSFER*      transfer_request,
                                               ULONG                   inquiry_length)
{
#ifdef UX_DEVICE_STANDALONE
  UX_PARAMETER_NOT_USED(endpoint_in);
  storage->ux_device_class_storage_state         = UX_DEVICE_CLASS_STORAGE_STATE_TRANS_START;
  storage->ux_device_class_storage_cmd_state     = UX_DEVICE_CLASS_STORAGE_CMD_READ;
  storage->ux_device_class_storage_transfer      = transfer_request;
  storage->ux_device_class_storage_device_length = inquiry_length;
  storage->ux_device_class_storage_data_length   = inquiry_length;
  storage->ux_device_class_storage_data_count    = 0;
#else
  if (inquiry_length != 0U) {
    _ux_device_stack_transfer_request(transfer_request, inquiry_length, inquiry_length);
  }
  if (storage->ux_slave_class_storage_host_length != inquiry_length) {
    storage->ux_slave_class_storage_csw_residue =
      storage->ux_slave_class_storage_host_length - inquiry_length;
    _ux_device_stack_endpoint_stall(endpoint_in);
  }
#endif
}

UINT _ux_device_class_storage_inquiry(UX_SLAVE_CLASS_STORAGE* storage,
                                      ULONG                   lun,
                                      UX_SLAVE_ENDPOINT*      endpoint_in,
                                      UX_SLAVE_ENDPOINT*      endpoint_out,
                                      UCHAR*                  cbwcb)
{
  UX_PARAMETER_NOT_USED(endpoint_out);
  UX_ASSERT(UX_SLAVE_REQUEST_DATA_MAX_LENGTH >= (ULONG)k_inq_serial_resp_len);
  UX_TRACE_IN_LINE_INSERT(UX_TRACE_DEVICE_CLASS_STORAGE_INQUIRY,
                          storage,
                          lun,
                          0,
                          0,
                          UX_TRACE_DEVICE_CLASS_EVENTS,
                          0,
                          0)
 
#ifndef UX_DEVICE_STANDALONE
  /* A data phase the host marked OUT cannot satisfy INQUIRY: phase error. */
  if (storage->ux_slave_class_storage_host_length != 0U) {
    if ((storage->ux_slave_class_storage_cbw_flags & (UCHAR)k_inq_dir_in_bit) == 0U) {
      _ux_device_stack_endpoint_stall(endpoint_out);
      storage->ux_slave_class_storage_csw_status = UX_SLAVE_CLASS_STORAGE_CSW_PHASE_ERROR;
      return (UX_ERROR);
    }
  }
#endif
 
  UX_SLAVE_TRANSFER* transfer_request = &endpoint_in->ux_slave_endpoint_transfer_request;
  UCHAR*             buf              = transfer_request->ux_slave_transfer_request_data_pointer;
  const UCHAR        evpd = (UCHAR)(cbwcb[k_inq_cdb_off_evpd] & (UCHAR)k_inq_cdb_evpd_bit);
  const UCHAR        page = cbwcb[UX_SLAVE_CLASS_STORAGE_INQUIRY_PAGE_CODE];
  ULONG              inquiry_length = storage->ux_slave_class_storage_host_length;
 
  _ux_utility_memory_set(buf,
                         0,
                         UX_SLAVE_CLASS_STORAGE_INQUIRY_RESPONSE_LENGTH); /* Use case of memset is
                                                                             verified. */
  storage->ux_slave_class_storage_csw_status = UX_SLAVE_CLASS_STORAGE_CSW_PASSED;
 
  ULONG response_length = 0U;
  if (evpd == 0U) {
    /* Standard INQUIRY: SPC requires PAGE CODE = 0 when EVPD is clear. */
    if (page != (UCHAR)UX_SLAVE_CLASS_STORAGE_INQUIRY_PAGE_CODE_STANDARD) {
      return internal_inquiry_reject(storage, lun, endpoint_in);
    }
    internal_inquiry_fill_standard(storage, lun, buf);
    response_length = UX_SLAVE_CLASS_STORAGE_INQUIRY_RESPONSE_LENGTH;
  } else if (page == (UCHAR)UX_SLAVE_CLASS_STORAGE_INQUIRY_PAGE_CODE_STANDARD) {
    response_length = internal_inquiry_fill_vpd_pages(buf);
  } else if (page == (UCHAR)UX_SLAVE_CLASS_STORAGE_INQUIRY_PAGE_CODE_SERIAL) {
    response_length = internal_inquiry_fill_serial(storage, buf);
  } else {
    return internal_inquiry_reject(storage, lun, endpoint_in);
  }
 
  if (inquiry_length > response_length) {
    inquiry_length = response_length;
  }
 
  internal_inquiry_send(storage, endpoint_in, transfer_request, inquiry_length);
  return (UX_SUCCESS);
}