/*FUNCTION*----------------------------------------------------------------
*
* Function Name : OTG_App_Load_Unload_Task
* Returned Value : none
* Comments :
*
*
*END*--------------------------------------------------------------------*/
void OTG_App_Load_Unload_Task(uint32_t event)
{
if (event & OTG_UNLOAD_DEVICE)
{
OS_Lock();
DEV_APP_uninit();
OS_Event_clear(g_otg_app_event_handle,OTG_UNLOAD_DEVICE);
OS_Unlock();
}
if (event & OTG_UNLOAD_HOST)
{
OS_Lock();
HOST_APP_uninit();
OS_Event_clear(g_otg_app_event_handle,OTG_UNLOAD_HOST);
OS_Unlock();
}
if (event & OTG_LOAD_DEVICE)
{
OS_Lock();
DEV_APP_init();
OS_Event_clear(g_otg_app_event_handle,OTG_LOAD_DEVICE);
OS_Unlock();
}
if (event & OTG_LOAD_HOST)
{
OS_Lock();
HOST_APP_init();
OS_Event_clear(g_otg_app_event_handle,OTG_LOAD_HOST);
OS_Unlock();
}
}
/*************************************************************************//*!
*
* @name USB_Cdc_Ep_Mutex_Unlock
*
* @brief The function unlocks the mutex for RTOS. For BM, enable interrupt.
*
* @param none.
* @return none.
*
*****************************************************************************/
void USB_Cdc_Ep_Mutex_Unlock(cdc_device_struct_t * cdc_obj_ptr, uint8_t ep_num)
{
uint8_t index, type, direction;
index = USB_Map_Ep_To_Struct_Index(cdc_obj_ptr, ep_num);
type = cdc_obj_ptr->ep[index].type;
direction = cdc_obj_ptr->ep[index].direction;
#if (((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK) && (USE_RTOS)))
switch(type)
{
case USB_BULK_PIPE:
if(direction == USB_SEND)
{
OS_Mutex_unlock(cdc_obj_ptr->send_mutex);
}
else if(direction == USB_RECV)
{
OS_Mutex_unlock(cdc_obj_ptr->recv_mutex);
}
break;
case USB_INTERRUPT_PIPE:
break;
default:
break;
}
#else
OS_Unlock();
#endif
}
/*************************************************************************//*!
*
* @name USB_Cdc_Mutex_Unlock
*
* @brief The function unlocks the mutex for RTOS. For BM, enable interrupt.
*
* @param none.
* @return none.
*
*****************************************************************************/
void USB_Cdc_Mutex_Unlock(os_mutex_handle handle)
{
#if (((OS_ADAPTER_ACTIVE_OS == OS_ADAPTER_SDK) && (USE_RTOS)))
OS_Mutex_unlock(handle);
#else
OS_Unlock();
#endif
}
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : OTG_App_Init
* Returned Value : none
* Comments :
*
*
*END*--------------------------------------------------------------------*/
void OTG_App_Init()
{
/* Initialize the current platform. Call for the _bsp_platform_init which is specific to each processor family */
OS_Lock();
g_otg_handle = NULL;
g_otg_state = 0;
g_dev_type = dev_b;
g_sess_vld = FALSE;
g_vbus_err = FALSE;
g_otg_app_event_handle = OS_Event_create(0);
printf("\n\r otg module is initilalizing:");
_usb_otg_init(USBCFG_DEFAULT_OTG_CONTROLLER, (otg_int_struct_t *)&g_otg_init, &g_otg_handle);
printf("\n\rPress P to print the menu:");
OS_Unlock();
}
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_host_ch9_set_feature
* Returned Value : USB_OK, or error status
* Comments :
* Function to process standard device request in Chapter 9.
* See Table 9-3 p. 250 of USB 2.0 specification.
*
*END*--------------------------------------------------------------------*/
usb_status _usb_host_ch9_set_feature
(
/* usb device */
usb_device_instance_handle dev_handle,
/* request type device/interface/endpoint */
uint8_t req_type,
/* device = 0, or interface/endpoint */
uint8_t intf_endpt,
/* feature selection */
uint16_t feature
)
{ /* Body */
usb_setup_t request = req_prototype;
usb_status error = USB_OK;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_host_ch9_set_feature");
#endif
switch (req_type) {
case REQ_TYPE_DEVICE:
break;
case REQ_TYPE_INTERFACE:
case REQ_TYPE_ENDPOINT:
*(uint16_t*)request.windex = USB_HOST_TO_LE_SHORT(intf_endpt);
break;
default:
OS_Unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_host_ch9_set_feature, invalid param");
#endif
return USB_log_error(__FILE__,__LINE__,USBERR_INVALID_BMREQ_TYPE);
} /* EndSwitch */
request.bmrequesttype = (uint8_t)(req_type | REQ_TYPE_OUT);
request.brequest = REQ_SET_FEATURE;
*(uint16_t*)request.wvalue = USB_HOST_TO_LE_SHORT(feature);
error = usb_host_ch9_dev_req(dev_handle, &request, NULL);
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_host_ch9_set_feature, SUCCESSFUL");
#endif
return USB_log_error(__FILE__,__LINE__,error);
} /* EndBody */
/*FUNCTION*----------------------------------------------------------------
*
* Function Name : _usb_hostdev_cntrl_request
* Returned Value : USB_OK, or error status
* Comments :
* Function to process class- or vendor-specific control pipe device
* requests.
*
*END*--------------------------------------------------------------------*/
usb_status _usb_hostdev_cntrl_request
(
/* usb device */
usb_device_instance_handle dev_handle,
/* Device Request to send */
usb_setup_t* devreq,
/* buffer to send/receive */
uint8_t * buff_ptr,
/* callback upon completion */
tr_callback callback,
/* [IN] the parameter to pass back to the callback function */
void* callback_param
)
{ /* Body */
dev_instance_t* dev_ptr;
usb_pipe_handle pipe_handle;
tr_struct_t tr;
usb_status error = USB_OK;
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_hostdev_cntrl_request");
#endif
/* Verify that device handle is valid */
OS_Lock();
error = usb_hostdev_validate(dev_handle);
if (error != USB_OK)
{
OS_Unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_hostdev_cntrl_request, invalid device handle");
#endif
return USB_log_error(__FILE__,__LINE__,USBERR_DEVICE_NOT_FOUND);
} /* Endif */
dev_ptr = (dev_instance_t*)dev_handle;
if (dev_ptr->state < DEVSTATE_ENUM_OK)
{
OS_Unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_hostdev_cntrl_request, no device found");
#endif
return USB_log_error(__FILE__,__LINE__,USBERR_DEVICE_NOT_FOUND);
} /* Endif */
pipe_handle = dev_ptr->control_pipe;
usb_hostdev_tr_init(&tr, callback, callback_param);
/* Set TR buffer length as required */
if ((REQ_TYPE_IN & devreq->bmrequesttype) != 0)
{
tr.rx_buffer = buff_ptr;
tr.rx_length = USB_SHORT_UNALIGNED_LE_TO_HOST(devreq->wlength);
}
else
{
tr.TX_BUFFER = buff_ptr;
tr.tx_length = USB_SHORT_UNALIGNED_LE_TO_HOST(devreq->wlength);
} /* EndIf */
tr.setup_packet = *devreq;
error = _usb_host_send_setup(dev_ptr->host, pipe_handle, &tr);
OS_Unlock();
#ifdef _HOST_DEBUG_
DEBUG_LOG_TRACE("_usb_hostdev_cntrl_request,SUCCESSFUL");
#endif
return USB_log_error(__FILE__,__LINE__,error);
}
/*FUNCTION*-------------------------------------------------------------------
*
* Function Name : usb_otg_init
* Returned Value : initialization message
* Comments : Initializes OTG stack
*
*
*END*----------------------------------------------------------------------*/
usb_status usb_otg_init
(
/* [IN] the USB device controller to initialize */
uint8_t controller_id,
/*[IN] address of the OTG initialization structure */
otg_int_struct_t * init_struct_ptr,
/* [IN] the USB otg board init handle */
otg_board_init board_init_callback,
/* [OUT] the USB host handle */
usb_otg_handle * handle
)
{
usb_status error = USB_OK;
const usb_otg_api_functions_struct_t * otg_api = NULL;
usb_otg_state_struct_t * usb_otg_ptr = NULL;
if ((init_struct_ptr == NULL) || (handle == NULL))
{
#if ((defined _OTG_DEBUG_) && (_OTG_DEBUG))
DEBUG_LOG_TRACE ("usb_otg_init invalid parameters");
#endif
return USBERR_ERROR;
}
_usb_otg_get_api(controller_id, &otg_api);
if (otg_api == NULL)
{
return USBERR_ERROR;
}
/* Initialize the USB interface. */
if (otg_api->otg_preinit != NULL)
{
error = otg_api->otg_preinit((usb_otg_handle *) (&(usb_otg_ptr)));
if (error || (usb_otg_ptr == NULL))
{
#if ((defined _OTG_DEBUG_) && (_OTG_DEBUG))
DEBUG_LOG_TRACE ("usb_OTG_init preinit failure");
#endif
return USBERR_ALLOC;
}
}
g_usb_otg_handle = usb_otg_ptr;
usb_otg_ptr->otg_controller_api = otg_api;
if( NULL !=board_init_callback )
{
error = (uint32_t)board_init_callback(controller_id);
}
else
{
error = USB_OK;
}
if(USB_OK == error)
{
error = usb_otg_soc_init(controller_id);
}
if (error != USB_OK)
{
if (otg_api->otg_shutdown != NULL)
{
error = otg_api->otg_shutdown(usb_otg_ptr);
}
#if ((defined _OTG_DEBUG_) && (_OTG_DEBUG))
DEBUG_LOG_TRACE ("_usb_host_init: BSP-specific USB initialization failure");
#endif
return USB_log_error(__FILE__, __LINE__, USBERR_UNKNOWN_ERROR);
}
usb_otg_ptr->init_struct = init_struct_ptr;
/* initialize the event used for application signaling and for ISR*/
usb_otg_ptr->otg_app_event = OS_Event_create(0);
usb_otg_ptr->otg_isr_event = OS_Event_create(0);
usb_otg_ptr->device_state = USB_OTG_DEVSTATE_UNDEFINED;
usb_otg_ptr->sub_state = USB_OTG_SM_UNDEFINED;
usb_otg_ptr->power_up = TRUE;
if (otg_api->otg_init != NULL)
{
error = otg_api->otg_init(controller_id, usb_otg_ptr);
}
if (error != USB_OK)
{
if (otg_api->otg_shutdown != NULL)
{
error = otg_api->otg_shutdown(usb_otg_ptr);
}
#if ((defined _OTG_DEBUG_) && (_OTG_DEBUG))
DEBUG_LOG_TRACE ("_usb_host_init: BSP-specific USB initialization failure");
#endif
return USB_log_error(__FILE__, __LINE__, USBERR_UNKNOWN_ERROR);
}
error = _usb_otg_task_create(usb_otg_ptr);
if (error != USB_OK)
{
if (otg_api->otg_shutdown != NULL)
{
otg_api->otg_shutdown(usb_otg_ptr);
}
(void) OS_Event_destroy(usb_otg_ptr->otg_app_event);
(void) OS_Event_destroy(usb_otg_ptr->otg_isr_event);
OS_Mem_free(usb_otg_ptr);
usb_otg_ptr = NULL;
OS_Unlock();
return error;
}
*handle = (usb_otg_handle) usb_otg_ptr;
return USB_OK;
}
