_mqx_int _io_usb_mfs_read_sector_internal
(
/* [IN] USB MFS state structure */
IO_USB_MFS_STRUCT_PTR info_ptr,
/* [IN] The sector number to read */
uint_32 sector,
/* [IN] How many sectors should read */
uint_16 how_many_sectors,
/* [IN] Location to read data into */
uchar_ptr data_ptr
)
{ /* Body */
uint_32 read_size;
USB_STATUS error;
_mqx_int io_result = IO_ERROR;
uint_32 tries;
/* UFI_READ10 command */
read_size = info_ptr->BLENGTH * how_many_sectors;
/* Send the call now */
for (tries=0;tries<USBCFG_MFS_MAX_RETRIES;tries++) {
error = usb_mass_ufi_read_10(
&info_ptr->COMMAND, sector, data_ptr, read_size, how_many_sectors);
if ((error==MQX_OK) || (error==USB_STATUS_TRANSFER_QUEUED)) {
if (_lwsem_wait_ticks(&info_ptr->COMMAND_DONE, USBCFG_MFS_LWSEM_TIMEOUT) == MQX_OK) {
if (info_ptr->COMMAND_STATUS == MQX_OK) {
io_result = (_mqx_int)how_many_sectors;
break;
} /* Endif */
} else {
/* Wait for the completion*/
usb_mass_ufi_cancel(&info_ptr->COMMAND);
} /* Endif */
}
else
{
printf("\nUSBMFS retrying read sector");
} /* Endif */
} /* Endif */
return(io_result);
} /* Endbody */
uint32_t OS_Sem_wait(os_sem_handle sem, uint32_t timeout)
{
uint32_t result = _lwsem_wait_ticks((LWSEM_STRUCT_PTR)sem, timeout);
if (result == MQX_LWSEM_WAIT_TIMEOUT)
{
return (uint32_t)OS_SEM_TIMEOUT;
}
else if (result == MQX_OK)
{
return (uint32_t)OS_SEM_OK;
}
else
{
return (uint32_t)OS_SEM_ERROR;
}
}
_mqx_int _io_usb_mfs_write_sector_long_internal
(
/* [IN] USB MFS state structure */
IO_USB_MFS_STRUCT_PTR info_ptr,
/* [IN] The sector number to write */
uint_32 sector,
/* [IN] How many sectors should read */
uint_32 how_many_sectors,
/* [IN] Source data location */
uchar_ptr data_ptr
)
{ /* Body */
uint_32 write_size;
USB_STATUS error;
_mqx_int io_result = IO_ERROR;
uint_32 tries;
if (sector <= info_ptr->BCOUNT) {
write_size = info_ptr->BLENGTH * how_many_sectors;
for (tries=0;tries<USBCFG_MFS_MAX_RETRIES;tries++) {
error = usb_mass_ufi_write_12(&info_ptr->COMMAND,
sector, data_ptr, write_size, how_many_sectors);
if ((error==MQX_OK) || (error==USB_STATUS_TRANSFER_QUEUED)) {
if (_lwsem_wait_ticks(&info_ptr->COMMAND_DONE, USBCFG_MFS_LWSEM_TIMEOUT) == MQX_OK) {
if (info_ptr->COMMAND_STATUS == MQX_OK) {
io_result = (_mqx_int) how_many_sectors;
break;
} /* Endif */
} else {
/* Send the call now */
usb_mass_ufi_cancel(&info_ptr->COMMAND);
}
/* Wait for the completion*/
} /* Endif */
}
} /* Endif */
return (io_result);
} /* Endbody */
/*TASK---------------------------------------------------------------
*
* Task Name : LWSemB
* Comments :
*
*END*--------------------------------------------------------------*/
void LWSemB
(
uint32_t parameter
)
{
_mqx_uint sem_result;
while ( TRUE ) {
/* wait for lw semaphore until it is available */
sem_result = _lwsem_wait_ticks(&lwsem, NO_TIMEOUT);
if (sem_result != MQX_OK) {
/* waiting on semaphore sem.Sem1 failed */
}
/* semaphore obtained, perform work */
_time_delay_ticks(1);
/* semaphore protected work done, release semaphore */
sem_result = _lwsem_post(&lwsem);
}
}
_mqx_int _io_usb_mfs_ioctl_stop
(
IO_USB_MFS_STRUCT_PTR info_ptr
)
{ /* Body */
MASS_STORAGE_START_STOP_UNIT_STRUCT_INFO start_stop;
USB_STATUS error;
_mqx_int io_result = IO_ERROR;
start_stop.START = 0;
start_stop.LOEJ = 0;
error = usb_mass_ufi_start_stop(&info_ptr->COMMAND, start_stop.LOEJ, start_stop.START);
if ((error==MQX_OK) || (error==USB_STATUS_TRANSFER_QUEUED)) {
if (_lwsem_wait_ticks(&info_ptr->COMMAND_DONE, USBCFG_MFS_LWSEM_TIMEOUT) == MQX_OK) {
if (info_ptr->COMMAND_STATUS == MQX_OK) {
io_result = MQX_OK;
} /* Endif */
} else {
usb_mass_ufi_cancel(&info_ptr->COMMAND);
} /* Endif */
} /* Endif */
return(io_result);
} /* Endbody */
_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 */
/*!
* \brief MQX API handler for usermode - part of wrapper around standard MQX API
* which require privilege mode.
*
* \param[in] api_no API number - number of wrapped function
* \param[in] params generic parameter - direct use with called MQX API fn
*
* \return uint32_t return of called function
*/
uint32_t _mqx_api_call_handler
(
// [IN] API number - number of wrapped function
MQX_API_NUMBER_ENUM api_no,
// [IN] generic parameter - direct use with called MQX API fn
MQX_API_CALL_PARAMS_PTR params
)
{
int32_t res = -1;
uint32_t param0 = params->param0;
uint32_t param1 = params->param1;
uint32_t param2 = params->param2;
uint32_t param3 = params->param3;
uint32_t param4 = params->param4;
switch (api_no) {
// _lwsem
case MQX_API_LWSEM_POLL:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)))
res = (uint32_t)_lwsem_poll((LWSEM_STRUCT_PTR)param0);
break;
case MQX_API_LWSEM_POST:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)))
res = _lwsem_post((LWSEM_STRUCT_PTR)param0);
break;
case MQX_API_LWSEM_WAIT:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)))
res = _lwsem_wait((LWSEM_STRUCT_PTR)param0);
break;
case MQX_API_LWSEM_CREATE:
res = _lwsem_create_internal((LWSEM_STRUCT_PTR)param0, (_mqx_int)param1, (bool)param2, TRUE);
break;
#if MQX_HAS_TICK
case MQX_API_LWSEM_WAIT_FOR:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)) && (!param1 || _psp_mem_check_access(param1, sizeof(MQX_TICK_STRUCT), MPU_UM_RW)))
res = _lwsem_wait_for((LWSEM_STRUCT_PTR)param0, (MQX_TICK_STRUCT_PTR)param1);
break;
case MQX_API_LWSEM_WAIT_TICKS:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)))
res = _lwsem_wait_ticks((LWSEM_STRUCT_PTR)param0, (_mqx_uint)param1);
break;
case MQX_API_LWSEM_WAIT_UNTIL:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0)) && (!param1 || _psp_mem_check_access(param1, sizeof(MQX_TICK_STRUCT), MPU_UM_RW)))
res = _lwsem_wait_until((LWSEM_STRUCT_PTR)param0, (MQX_TICK_STRUCT_PTR)param1);
break;
case MQX_API_LWSEM_DESTROY:
if (MQX_OK == (res = _lwsem_usr_check((LWSEM_STRUCT_PTR)param0))) {
res = _lwsem_destroy_internal((LWSEM_STRUCT_PTR)param0, TRUE);
}
break;
#endif // MQX_HAS_TICK
// _lwevent
#if MQX_USE_LWEVENTS
case MQX_API_LWEVENT_CLEAR:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0)))
res = _lwevent_clear((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1);
break;
case MQX_API_LWEVENT_SET:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0)))
res = _lwevent_set((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1);
break;
case MQX_API_LWEVENT_SET_AUTO_CLEAR:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0)))
res = _lwevent_set_auto_clear((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1);
break;
case MQX_API_LWEVENT_WAIT_FOR:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0)) && \
(!param3 || _psp_mem_check_access(param3, sizeof(MQX_TICK_STRUCT), MPU_UM_RW))) {
res = _lwevent_wait_for((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1, (bool)param2, (MQX_TICK_STRUCT_PTR)param3);
}
break;
case MQX_API_LWEVENT_WAIT_FOR_TICKS:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0))) {
res = _lwevent_wait_ticks((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1, (bool)param2, (_mqx_uint)param3);
}
break;
case MQX_API_LWEVENT_WAIT_UNTIL:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0)) && \
(!param3 || _psp_mem_check_access(param3, sizeof(MQX_TICK_STRUCT), MPU_UM_RW))) {
res = _lwevent_wait_until((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1, (bool)param2, (MQX_TICK_STRUCT_PTR)param3);
}
break;
case MQX_API_LWEVENT_GET_SIGNALLED:
res = _lwevent_get_signalled();
break;
case MQX_API_LWEVENT_CREATE:
res = _lwevent_create_internal((LWEVENT_STRUCT_PTR)param0, (_mqx_uint)param1, TRUE);
break;
case MQX_API_LWEVENT_DESTROY:
if (MQX_OK == (res = _lwevent_usr_check((LWEVENT_STRUCT_PTR)param0))) {
res = _lwevent_destroy_internal((LWEVENT_STRUCT_PTR)param0, TRUE);
}
break;
#endif
#if MQX_USE_LWMSGQ
case MQX_API_LWMSGQ_INIT:
res = _lwmsgq_init_internal((void *)param0, (_mqx_uint)param1, (_mqx_uint)param2, TRUE);
break;
case MQX_API_LWMSGQ_RECEIVE:
if (MQX_OK == (res = _lwmsgq_usr_check((LWMSGQ_STRUCT_PTR)param0)) && \
_psp_mem_check_access(param1, ((LWMSGQ_STRUCT_PTR)param0)->MSG_SIZE, MPU_UM_RW) && \
(!param4 || _psp_mem_check_access(param4, sizeof(MQX_TICK_STRUCT), MPU_UM_RW)))
res = _lwmsgq_receive((void *)param0, (_mqx_max_type_ptr)param1, (_mqx_uint)param2, (_mqx_uint)param3, (MQX_TICK_STRUCT_PTR)param4);
break;
case MQX_API_LWMSGQ_SEND:
if (MQX_OK == (res = _lwmsgq_usr_check((LWMSGQ_STRUCT_PTR)param0)) && \
_psp_mem_check_access(param1, ((LWMSGQ_STRUCT_PTR)param0)->MSG_SIZE, MPU_UM_RW))
res = _lwmsgq_send((void *)param0, (_mqx_max_type_ptr)param1, (_mqx_uint)param2);
break;
#endif // MQX_USE_LWMSGQ
case MQX_API_TASK_CREATE:
res = _task_create_internal((_processor_number)param0, (_mqx_uint)param1, (uint32_t)param2, TRUE);
break;
case MQX_API_TASK_DESTROY:
res = _task_destroy_internal((_task_id)param0, TRUE);
break;
case MQX_API_TASK_ABORT:
res = _task_abort_internal((_task_id)param0, TRUE);
break;
case MQX_API_TASK_READY:
_task_ready((void *)param0);
res = MQX_OK; // irelevant, function is without return value
break;
case MQX_API_TASK_SET_ERROR:
res = _task_set_error((_mqx_uint)param0);
break;
case MQX_API_TASK_GET_TD:
res = (uint32_t)_task_get_td((_task_id)param0);
break;
#if MQX_USE_LWMEM
case MQX_API_LWMEM_ALLOC:
res = (uint32_t)_usr_lwmem_alloc_internal((_mem_size)param0);
break;
case MQX_API_LWMEM_ALLOC_FROM:
if (_psp_mem_check_access(param0, sizeof(LWMEM_POOL_STRUCT), MPU_UM_RW) && \
_psp_mem_check_access((uint32_t)(((LWMEM_POOL_STRUCT_PTR)param0)->POOL_ALLOC_START_PTR), (char*)(((LWMEM_POOL_STRUCT_PTR)param0)->POOL_ALLOC_END_PTR) - (char*)(((LWMEM_POOL_STRUCT_PTR)param0)->POOL_ALLOC_START_PTR), MPU_UM_RW))
res = (uint32_t)_lwmem_alloc_from((_lwmem_pool_id)param0, (_mem_size)param1);
else
res = 0; // NULL, allocation failed
break;
case MQX_API_LWMEM_FREE:
if (_psp_mem_check_access(param0, 4, MPU_UM_RW))
res = _lwmem_free((void *)param0);
break;
case MQX_API_LWMEM_CREATE_POOL:\
if (_psp_mem_check_access(param0, sizeof(LWMEM_POOL_STRUCT), MPU_UM_RW) && \
_psp_mem_check_access(param1, param2, MPU_UM_RW))
res = (uint32_t)_lwmem_create_pool((LWMEM_POOL_STRUCT_PTR)param0, (void *)param1, (_mem_size)param2);
break;
case MQX_API_LWMEM_REALLOC:
if (_psp_mem_check_access(param0, 4, MPU_UM_RW))
res = (uint32_t)_lwmem_realloc((void *)param0,(_mem_size)param1);
break;
#endif // MQX_USE_LWMEM
// _time
case MQX_API_TIME_DELAY:
_time_delay(param0);
res = MQX_OK; // irelevant, function is without return value
break;
#if MQX_HAS_TICK
case MQX_API_TIME_DELAY_TICKS:
_time_delay_ticks(param0);
res = MQX_OK; // irelevant, function is without return value
break;
case MQX_API_TIME_GET_ELAPSED_TICKS:
if (_psp_mem_check_access(param0, sizeof(MQX_TICK_STRUCT), MPU_UM_RW)) {
_time_get_elapsed_ticks((MQX_TICK_STRUCT_PTR)param0);
res = MQX_OK; // irelevant, function is without return value
}
else {
_task_set_error(MQX_ACCESS_ERROR);
}
break;
#endif // MQX_HAS_TICK
default:
while (1);
}
return res;
}
