/*FUNCTION*----------------------------------------------------------------
*
* Function Name : usb_class_video_control_recv_data
* Returned Value : USB_OK if command has been passed on USB.
* Comments :
* This function is used to recv interrupt data
*
*END*--------------------------------------------------------------------*/
usb_status usb_class_video_control_recv_data
(
/* [IN] Class Interface structure pointer */
video_command_t* com_ptr,
/* [IN] The buffer address */
uint8_t * buffer,
/* [IN] The buffer address */
uint16_t length
)
{
usb_video_control_struct_t* video_control_ptr;
tr_struct_t* tr_ptr;
usb_status status;
if ((com_ptr == NULL) || (com_ptr->class_control_handle == NULL))
{
return USBERR_ERROR;
}
video_control_ptr = (usb_video_control_struct_t*)com_ptr->class_control_handle;
if ((video_control_ptr == NULL) || (buffer == NULL))
{
#ifdef _DEBUG
USB_PRINTF("input parameter error\n");
#endif
return USBERR_ERROR;
}
video_control_ptr->recv_callback = com_ptr->callback_fn;
video_control_ptr->recv_param = com_ptr->callback_param;
if (video_control_ptr->dev_handle == NULL)
{
return USBERR_ERROR;
}
if (usb_host_get_tr(video_control_ptr->host_handle, usb_class_video_control_recv_callback, video_control_ptr, &tr_ptr) != USB_OK)
{
#ifdef _DEBUG
USB_PRINTF("error to get tr\n");
#endif
return USBERR_ERROR;
}
tr_ptr->rx_buffer = buffer;
tr_ptr->rx_length = length;
status = usb_host_recv_data(video_control_ptr->host_handle, video_control_ptr->control_interrupt_in_pipe, tr_ptr);
if (status != USB_OK)
{
#ifdef _DEBUG
USB_PRINTF("\nError in usb_class_video_recv_data: %x", status);
#endif
usb_host_release_tr(video_control_ptr->host_handle, tr_ptr);
return USBERR_ERROR;
}
return USB_OK;
}
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : usb_audio_recv_data
* Returned Value : USB status
* Comments :
* Receive data on isochronous IN pipe.
*
*END*--------------------------------------------------------------------*/
usb_status usb_class_audio_recv_data
(
/* [IN] audio control class interface pointer */
audio_command_t* audio_ptr,
/* [IN] buffer pointer */
uint8_t * buffer,
/* [IN] data length */
uint32_t buf_size
)
{ /* Body */
audio_stream_struct_t* audio_class;
usb_status status = USBERR_ERROR;
//uint16_t request_value;
tr_struct_t* tr_ptr;
//usb_audio_command_t* p_endpoint_command;
if ((audio_ptr == NULL) || (audio_ptr->class_stream_handle == NULL))
{
return USBERR_ERROR;
}
audio_class = (audio_stream_struct_t*)audio_ptr->class_stream_handle;
if ((audio_class == NULL) || (buffer == NULL))
{
USB_PRINTF("input parameter error\n");
return USBERR_ERROR;
}
audio_class->recv_callback = audio_ptr->callback_fn;
audio_class->recv_param = audio_ptr->callback_param;
if (audio_class->dev_handle == NULL)
{
return USBERR_ERROR;
}
if (usb_host_get_tr(audio_class->host_handle, usb_class_audio_recv_callback, audio_class, &tr_ptr) != USB_OK)
{
USB_PRINTF("error to get tr\n");
return USBERR_ERROR;
}
tr_ptr->rx_buffer = buffer;
tr_ptr->rx_length = buf_size;
status = usb_host_recv_data(audio_class->host_handle, audio_class->iso_in_pipe, tr_ptr);
if (status != USB_OK)
{
USB_PRINTF("\nError in _usb_host_recv_data: %x", (unsigned int)status);
usb_host_release_tr(audio_class->host_handle, tr_ptr);
return USBERR_ERROR;
}
return USB_OK;
} /* Endbody */
usb_status usb_class_cdc_init_ipipe
(
/* ACM interface instance */
cdc_class_call_struct_t * acm_instance
)
{ /* Body */
usb_status status = USBERR_NO_INTERFACE;
usb_acm_class_intf_struct_t * if_acm_ptr;
tr_struct_t* tr_ptr;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_cdc_init_ipipe");
#endif
/* Validity checking, always needed when passing data to lower API */
if (usb_class_cdc_intf_validate(acm_instance)) {
if_acm_ptr = (usb_acm_class_intf_struct_t *) acm_instance->class_intf_handle;
USB_CDC_ACM_lock();
if (if_acm_ptr->interrupt_pipe != NULL) {
if (usb_host_get_tr(if_acm_ptr->host_handle, usb_class_cdc_int_acm_callback, if_acm_ptr, &tr_ptr) != USB_OK)
{
printf("usb_class_cdc_init_ipipe: error to get tr\n");
return USBERR_ERROR;
}
tr_ptr->rx_buffer = (uint8_t *) &if_acm_ptr->interrupt_buffer;
tr_ptr->rx_length = sizeof(if_acm_ptr->interrupt_buffer);
status = usb_host_recv_data(if_acm_ptr->host_handle, if_acm_ptr->interrupt_pipe, tr_ptr);
if (status != USB_OK)
{
printf("\nError in usb_class_cdc_init_ipipe: %x", status);
usb_host_release_tr(if_acm_ptr->host_handle, tr_ptr);
return USBERR_ERROR;
}
}
else{
status = USBERR_OPEN_PIPE_FAILED;
}
USB_CDC_ACM_unlock();
}
#ifdef _HOST_DEBUG_
if (!status) {
DEBUG_LOG_TRACE("usb_class_cdc_init_ipipe, SUCCESSFUL");
}
else {
DEBUG_LOG_TRACE("usb_class_cdc_init_ipipe, FAILED");
}
#endif
return status;
}
static void usb_class_cdc_int_acm_callback
(
/* [IN] pointer to pipe */
void * tr_ptr,
/* [IN] user-defined parameter */
void * param,
/* [IN] buffer address */
uint8_t * buffer,
/* [IN] length of data transferred */
uint32_t len,
/* [IN] status, hopefully USB_OK or USB_DONE */
uint32_t status
)
{ /* Body */
//cdc_class_call_struct_t * acm_parser;
tr_struct_t* tr_int_ptr;
usb_acm_class_intf_struct_t * if_acm_ptr = (usb_acm_class_intf_struct_t *)param;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_cdc_int_acm_callback");
#endif
if(USB_OK == status)
{
if (usb_host_release_tr(if_acm_ptr->host_handle, tr_ptr) != USB_OK)
{
printf("usb_class_cdc_int_acm_callback: _usb_host_release_tr failed\n");
}
}
else
{
/* In case of error, e.g. KHCI_ATOM_TR_TO, need to re-issue tr for interrupt pipe */
USB_CDC_ACM_lock();
if (if_acm_ptr->interrupt_pipe != NULL) {
if (usb_host_get_tr(if_acm_ptr->host_handle, usb_class_cdc_int_acm_callback, if_acm_ptr, &tr_int_ptr) != USB_OK)
{
printf("usb_class_cdc_int_acm_callback: error to get tr\n");
}
tr_int_ptr->rx_buffer = (uint8_t *) &if_acm_ptr->interrupt_buffer;
tr_int_ptr->rx_length = sizeof(if_acm_ptr->interrupt_buffer);
status = usb_host_recv_data(if_acm_ptr->host_handle, if_acm_ptr->interrupt_pipe, tr_int_ptr);
if (status != USB_OK)
{
printf("\nError in usb_class_cdc_int_acm_callback: %x", status);
usb_host_release_tr(if_acm_ptr->host_handle, tr_int_ptr);
}
}
else{
status = USBERR_OPEN_PIPE_FAILED;
}
USB_CDC_ACM_unlock();
}
/* we do not use USB_ACM_INT_PIPE_FREE in this version at all */
// _lwevent_set(if_ptr->acm_event, USB_ACM_INT_PIPE_FREE);
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_cdc_int_acm_callback, SUCCESSFUL");
#endif
} /*EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : usb_class_hub_recv_bitmap
* Returned Value : None
* Comments :
* Starts interrupt endpoint to poll for interrupt on specified hub
*END*--------------------------------------------------------------------*/
usb_status usb_class_hub_recv_bitmap
(
/* [IN] Class Interface structure pointer */
hub_command_t* com_ptr,
/* [IN] The buffer address */
uint8_t * buffer,
/* size of buffer to be used */
uint8_t length
)
{
usb_hub_class_struct_t* hub_class;
tr_struct_t* tr_ptr;
usb_status status = USBERR_NO_INTERFACE;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("usb_class_hub_recv_bitmap");
#endif
//USB_PRINTF("r \n");
if ((com_ptr == NULL) || (com_ptr->class_ptr == NULL))
{
return USBERR_ERROR;
}
hub_class = (usb_hub_class_struct_t*)com_ptr->class_ptr;
if ((hub_class == NULL) || (buffer == NULL))
{
USB_PRINTF("input parameter error\n");
return USBERR_ERROR;
}
hub_class->interrupt_callback = com_ptr->callback_fn;
hub_class->interrupt_param = com_ptr->callback_param;
if (hub_class->dev_handle == NULL)
{
return USBERR_ERROR;
}
if (hub_class->in_interrupt)
{
return USBERR_ERROR;
}
if (usb_host_get_tr(hub_class->host_handle, usb_class_hub_int_callback, hub_class, &tr_ptr) != USB_OK)
{
USB_PRINTF("error to get tr\n");
return USBERR_ERROR;
}
tr_ptr->rx_buffer = buffer;
tr_ptr->rx_length = length;
status = usb_host_recv_data(hub_class->host_handle, hub_class->interrupt_pipe, tr_ptr);
if (status != USB_OK)
{
USB_PRINTF("\nError in usb_class_hub_recv_bitmap: %x", (unsigned int)status);
usb_host_release_tr(hub_class->host_handle, tr_ptr);
return USBERR_ERROR;
}
hub_class->in_interrupt = TRUE;
return USB_OK;
}
