/*FUNCTION*----------------------------------------------------------------
*
* Function Name : disk_ioctl
* Returned Value :
* Comments : The disk_ioctl function controls device specified features
* and miscellaneous functions other than disk read/write
*
*END*--------------------------------------------------------------------*/
uint_8 disk_ioctl
(
/* [IN] Drive number */
uint_8 Drive,
/* [IN] Control command code */
uint_8 Command,
/* [IN/OUT] Parameter and data buffer */
void* Buff
)
{
uint_32 res = USB_OK;
static CAPACITY_LIST capacity_list;
static INQUIRY_DATA_FORMAT inquiry;
static REQ_SENSE_DATA_FORMAT req_sense;
UNUSED(Drive)
if (UFI_TEST_UNIT_READY == Command)
{
/* Send read_capacity SCSI command */
bCallBack = FALSE;
bStatus = usb_mass_ufi_test_unit_ready(&pCmd);
if ((bStatus != USB_OK) && (bStatus != USB_STATUS_TRANSFER_QUEUED))
{
res = USBERR_ERROR;
}
else
{
/* Wait till command comes back */
while(!bCallBack)
{
Poll();
}
if (!bStatus)
{
res = USB_OK;
}
else
{
res = USBERR_ERROR;
}
}
}
else if(UFI_MODE_SENSE == Command)
{
/* Send mode sense SCSI command */
bCallBack = FALSE;
bStatus = usb_mass_ufi_mode_sense(&pCmd,
2, //PC
0x3F, //page code
buff_in,
(uint_32)0x08);
if ((bStatus != USB_OK) && (bStatus != USB_STATUS_TRANSFER_QUEUED))
{
res = USBERR_ERROR;
}
else
{
/* Wait till command comes back */
while(!bCallBack)
Poll();
if (!bStatus)
res = USB_OK;
else
res = USBERR_ERROR;
}
}
else if(UFI_VERIFY == Command)
{
/* Send mode sense SCSI command */
bCallBack = FALSE;
bStatus = usb_mass_ufi_verify(
&pCmd,
0x400, // block address
1 //length to be verified
);
if ((bStatus != USB_OK) && (bStatus != USB_STATUS_TRANSFER_QUEUED))
{
res = USBERR_ERROR;
}
else
{
/* Wait till command comes back */
while(!bCallBack)
Poll();
if (!bStatus)
res = USB_OK;
else
res = USBERR_ERROR;
}
}
else if(UFI_WRITE10 == Command)
{
/* Send mode sense SCSI command */
bCallBack = FALSE;
bStatus = usb_mass_ufi_write_10(&pCmd, start_lba, buff_out, lba_length, 1);
if ((bStatus != USB_OK) && (bStatus != USB_STATUS_TRANSFER_QUEUED))
{
res = USBERR_ERROR;
}
else
{
/* Wait till command comes back */
while(!bCallBack)
Poll();
if (!bStatus)
res = USB_OK;
else
res = USBERR_ERROR;
}
}
else if(UFI_READ10 == Command)
{
/* Send mode sense SCSI command */
bCallBack = FALSE;
bStatus = usb_mass_ufi_read_10(&pCmd, start_lba, buff_in, lba_length, 1);
if ((bStatus != USB_OK) && (bStatus != USB_STATUS_TRANSFER_QUEUED))
{
res = USBERR_ERROR;
}
else
{
/* Wait till command comes back */
while(!bCallBack)
Poll();
if (!bStatus)
res = USB_OK;
else
res = USBERR_ERROR;
}
}
else if(UFI_START_STOP == Command)
{
/* Send mode sense SCSI command */
bCallBack = FALSE;
bStatus = usb_mass_ufi_start_stop(&pCmd, 0, 1);
if ((bStatus != USB_OK) && (bStatus != USB_STATUS_TRANSFER_QUEUED))
{
res = USBERR_ERROR;
}
else
{
/* Wait till command comes back */
while(!bCallBack)
Poll();
if (!bStatus)
res = USB_OK;
else
res = USBERR_ERROR;
}
}
else if(UFI_PREVENT_ALLOW_MEDIUM_ROMVAL == Command)
{
/* Send mode sense SCSI command */
bCallBack = FALSE;
bStatus = usb_mass_ufi_prevent_allow_medium_removal(
&pCmd,
1 // prevent
);
if ((bStatus != USB_OK) && (bStatus != USB_STATUS_TRANSFER_QUEUED))
{
res = USBERR_ERROR;
}
else
{
/* Wait till command comes back */
while(!bCallBack)
Poll();
if (!bStatus)
res = USB_OK;
else
res = USBERR_ERROR;
}
}
else if (UFI_READ_CAPACITY == Command)
{
/* Send read_capacity SCSI command */
bCallBack = FALSE;
bStatus = usb_mass_ufi_read_capacity(&pCmd, (uchar_ptr)&read_capacity,
sizeof(MASS_STORAGE_READ_CAPACITY_CMD_STRUCT_INFO));
if ((bStatus != USB_OK) && (bStatus != USB_STATUS_TRANSFER_QUEUED))
{
res = USBERR_ERROR;
}
else
{
/* Wait till command comes back */
while(!bCallBack)
Poll();
if (!bStatus){
start_lba = (HOST_READ_BEOCT_32(read_capacity.BLLBA) + 1) >> 1;
/* Length of each LBA */
lba_length = HOST_READ_BEOCT_32(read_capacity.BLENGTH);
res = USB_OK;
}
else{
_mqx_int _io_usb_mfs_open_internal
(
IO_USB_MFS_STRUCT_PTR info_ptr,
CLASS_CALL_STRUCT_PTR ccs_ptr
)
{ /* Body */
uint_32 i;
USB_STATUS error;
REQ_SENSE_DATA_FORMAT sense;
error = usb_mass_ufi_inquiry(&info_ptr->COMMAND, (uchar_ptr) &info_ptr->INQUIRY_DATA, sizeof(INQUIRY_DATA_FORMAT));
if ((error!=MQX_OK) && (error!=USB_STATUS_TRANSFER_QUEUED)) {
return IO_ERROR_INQUIRE;
} /* Endif */
if (_lwsem_wait_ticks(&info_ptr->COMMAND_DONE, USBCFG_MFS_LWSEM_TIMEOUT) != MQX_OK) {
/* Send the call now */
/* Wait for the completion */
usb_mass_ufi_cancel(&info_ptr->COMMAND);
return IO_ERROR_TIMEOUT;
} /* Endif */
if (info_ptr->COMMAND_STATUS != MQX_OK) {
return IO_ERROR_INQUIRE;
} /* Endif */
for (i = 0; i < USBCFG_MFS_MAX_RETRIES; i++)
{
if (i) {
/* Delay for a user-specified amount of time */
_time_delay_ticks(USBCFG_MFS_OPEN_READ_CAPACITY_RETRY_DELAY);
}
/* Send the call now */
error = usb_mass_ufi_read_capacity(&info_ptr->COMMAND, (uchar_ptr) &info_ptr->CAPACITY,
sizeof(MASS_STORAGE_READ_CAPACITY_CMD_STRUCT_INFO));
if ((error!=MQX_OK) && (error!=USB_STATUS_TRANSFER_QUEUED)) {
return IO_ERROR_READ;
} /* Endif */
if (_lwsem_wait_ticks(&info_ptr->COMMAND_DONE, USBCFG_MFS_LWSEM_TIMEOUT) != MQX_OK) {
usb_mass_ufi_cancel(&info_ptr->COMMAND);
return IO_ERROR_TIMEOUT;
} /* Endif */
if (info_ptr->COMMAND_STATUS == MQX_OK)
break;
error = usb_mass_ufi_request_sense(&info_ptr->COMMAND, (char_ptr)&sense, sizeof(REQ_SENSE_DATA_FORMAT));
if ((error!=MQX_OK) && (error!=USB_STATUS_TRANSFER_QUEUED)) {
return IO_ERROR_READ;
}
if (_lwsem_wait_ticks(&info_ptr->COMMAND_DONE, USBCFG_MFS_LWSEM_TIMEOUT) != MQX_OK) {
usb_mass_ufi_cancel(&info_ptr->COMMAND);
return IO_ERROR_TIMEOUT;
}
}
if (info_ptr->COMMAND_STATUS == MQX_OK) {
info_ptr->BCOUNT = LONG_BE_TO_HOST(*(uint_32*)&info_ptr->CAPACITY.BLLBA);
info_ptr->BLENGTH = LONG_BE_TO_HOST(*(uint_32*)&info_ptr->CAPACITY.BLENGTH);
/* should read this to support low level format */
info_ptr->NUMBER_OF_HEADS = 0;
info_ptr->NUMBER_OF_TRACKS = 0;
info_ptr->SECTORS_PER_TRACK = 0;
info_ptr->SIZE_BYTES = info_ptr->BLENGTH * info_ptr->BCOUNT;
} /* Endif */
return (_mqx_int)info_ptr->COMMAND_STATUS;
} /* Endbody */
static void usb_host_mass_test_storage
(
void
)
{ /* Body */
USB_STATUS status = USB_OK;
uint_8 bLun = 0;
INQUIRY_DATA_FORMAT inquiry;
CAPACITY_LIST capacity_list;
#if 0
MODE_SELECT_PARAMETER_LIST md_list;
#endif
MASS_STORAGE_READ_CAPACITY_CMD_STRUCT_INFO read_capacity;
REQ_SENSE_DATA_FORMAT req_sense;
FORMAT_UNIT_PARAMETER_BLOCK formatunit = { 0};
_mqx_int block_len;
DEVICE_DESCRIPTOR_PTR pdd;
CBW_STRUCT_PTR cbw_ptr = pCmd->CBW_PTR;
CSW_STRUCT_PTR csw_ptr = pCmd->CSW_PTR;
USB_mem_zero(buff_out,0x0F);
USB_mem_zero(buff_in,0x400C);
USB_mem_zero(pCmd->CSW_PTR,sizeof(CSW_STRUCT));
USB_mem_zero(pCmd->CBW_PTR,sizeof(CBW_STRUCT));
USB_mem_zero(pCmd,sizeof(COMMAND_OBJECT_STRUCT));
pCmd->CBW_PTR = cbw_ptr;
pCmd->CSW_PTR = csw_ptr;
pCmd->LUN = bLun;
pCmd->CALL_PTR = (pointer)&mass_device.class_intf;
pCmd->CALLBACK = usb_host_mass_bulk_callback;
printf("\n =============START OF A NEW SESSION==================");
if (USB_OK != _usb_hostdev_get_descriptor(
mass_device.dev_handle,
NULL,
USB_DESC_TYPE_DEV,
0,
0,
(pointer *) &pdd))
{
printf ("\nCould not retrieve device descriptor.");
return;
}
else
printf("\nVID = 0x%04x, PID = 0x%04x", SHORT_LE_TO_HOST(*(uint_16*)pdd->idVendor), SHORT_LE_TO_HOST(*(uint_16*)pdd->idProduct));
/* Test the GET MAX LUN command */
printf("\nTesting: GET MAX LUN Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_class_mass_getmaxlun_bulkonly(
(pointer)&mass_device.class_intf, &bLun,
usb_host_mass_ctrl_callback);
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack) {;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the TEST UNIT READY command */
printf("Testing: TEST UNIT READY Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_test_unit_ready(pCmd);
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the REQUEST SENSE command */
printf("Testing: REQUEST SENSE Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_request_sense(pCmd, &req_sense,
sizeof(REQ_SENSE_DATA_FORMAT));
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the INQUIRY command */
printf("Testing: INQUIRY Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_inquiry(pCmd, (uchar_ptr) &inquiry,
sizeof(INQUIRY_DATA_FORMAT));
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the REQUEST SENSE command */
printf("Testing: REQUEST SENSE Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_request_sense(pCmd, &req_sense,
sizeof(REQ_SENSE_DATA_FORMAT));
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the READ FORMAT CAPACITY command */
printf("Testing: READ FORMAT CAPACITIES Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_format_capacity(pCmd, (uchar_ptr)&capacity_list,
sizeof(CAPACITY_LIST));
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the REQUEST SENSE command */
printf("Testing: REQUEST SENSE Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_request_sense(pCmd, &req_sense,
sizeof(REQ_SENSE_DATA_FORMAT));
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the READ CAPACITY command */
printf("Testing: READ CAPACITY Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_read_capacity(pCmd, (uchar_ptr)&read_capacity,
sizeof(MASS_STORAGE_READ_CAPACITY_CMD_STRUCT_INFO));
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
block_len = HOST_TO_BE_LONG(* (uint_32 *) &read_capacity.BLENGTH);
#if 0
/* Test the MODE SELECT command */
printf("Testing: MODE SELECT Command");
fflush(stdout);
bCallBack = FALSE;
//md_list. Fill parameters here
USB_mem_zero (&md_list, sizeof (MODE_SELECT_PARAMETER_LIST));
md_list.MODE_PARAM_HEADER.BLENGTH[1] = 0x06;
status = usb_mass_ufi_mode_select(pCmd, &md_list, 8);
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
#endif
/* Test the REQUEST SENSE command */
printf("Testing: REQUEST SENSE Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_request_sense(pCmd, &req_sense,
sizeof(REQ_SENSE_DATA_FORMAT));
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the READ(10) command */
printf("Testing: READ(10) Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_read_10(pCmd, 0, buff_in, block_len, 1);
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the MODE SENSE command */
printf("Testing: MODE SENSE Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_mode_sense(pCmd,
2, //PC
0x3F, //page code
buff_in,
(uint_32)0x08);
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the PREVENT ALLOW command */
printf("Testing: PREVENT-ALLOW MEDIUM REMOVAL Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_prevent_allow_medium_removal(
pCmd,
1 // prevent
);
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the REQUEST SENSE command */
printf("Testing: REQUEST SENSE Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_request_sense(pCmd, &req_sense,
sizeof(REQ_SENSE_DATA_FORMAT));
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the VERIFY command */
printf("Testing: VERIFY Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_verify(
pCmd,
0x400, // block address
1 //length to be verified
);
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the WRITE(10) command */
printf("Testing: WRITE(10) Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_write_10(pCmd, 8, buff_out, block_len, 1);
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the REQUEST SENSE command */
printf("Testing: REQUEST SENSE Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_request_sense(pCmd, &req_sense,
sizeof(REQ_SENSE_DATA_FORMAT));
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
/* Test the START-STOP UNIT command */
printf("Testing: START-STOP UNIT Command");
fflush(stdout);
bCallBack = FALSE;
status = usb_mass_ufi_start_stop(pCmd, 0, 1);
if ((status != USB_OK) && (status != USB_STATUS_TRANSFER_QUEUED))
{
printf ("\n...ERROR");
return;
}
else
{
/* Wait till command comes back */
while (!bCallBack){;}
if (!bStatus) {
printf("...OK\n");
}
else {
printf("...Unsupported by device (bStatus=0x%x)\n", bStatus);
}
}
printf("\nTest done!");
fflush(stdout);
} /* Endbody */
