/*
** ===================================================================
** Method : usb_mems_USB_Class_Mems_Send_Data (component USB_MEMS_CLASS)
** Description :
** This fucntion is used by Application to send data through
** Mems class
** Parameters :
** NAME - DESCRIPTION
** controller_ID -
** ep_num -
** app_buff -
** size -
** Returns :
** --- - Error code
** ===================================================================
*/
uint_8 USB_Class_Mems_Send_Data(
uint_8 controller_ID,
uint_8 ep_num,
uint_8_ptr app_buff,
USB_PACKET_SIZE size
)
{
uint_8 status = USB_OK;
PTR_USB_CLASS_MEMS_QUEUE queue_tmp;
uint_8 index;
uint_8 producer, queue_num;
USB_ENDPOINTS *usb_ep_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(controller_ID);
/* map the endpoint num to the index of the endpoint structure */
for(index = 0; index < usb_ep_data->count; index++)
{
if(usb_ep_data->ep[index].ep_num == ep_num)
break;
}
producer = g_mems_endpoint_data.ep[index].bin_producer;
queue_num = g_mems_endpoint_data.ep[index].queue_num;
//if queue_num==1,there is already a queue,USB is busy
//if queue_num!=1,there USB queue is empty
if(MAX_QUEUE_ELEMS != queue_num)
{
/* the bin is not full*/
/* put all send request parameters in the endpoint data structure */
queue_tmp = &(g_mems_endpoint_data.ep[index].queue[producer]);
queue_tmp->controller_ID = controller_ID;
queue_tmp->channel = ep_num;
queue_tmp->app_buff = app_buff;
queue_tmp->size = size;
/* increment producer bin by 1*/
if (producer == (MAX_QUEUE_ELEMS - 1))
{
g_mems_endpoint_data.ep[index].bin_producer = 0;
}
else
{
g_mems_endpoint_data.ep[index].bin_producer++;
}
g_mems_endpoint_data.ep[index].queue_num++;
if(g_mems_endpoint_data.ep[index].queue_num == 1)
{
status = USB_Class_Send_Data(controller_ID, ep_num, app_buff,size);
}
}
else /* bin is full */
{
status = USBERR_DEVICE_BUSY;
}
return status;
}
/**************************************************************************//*!
*
* @name USB_Service_Video_Isochronous
*
* @brief The funtion ic callback function of Video Isochronous IN endpoint
*
* @param event
*
* @return None
*
****************************************************************************
* The function is called in response to Isochronous IN Service
******************************************************************************/
void USB_Service_Video_Isochronous(PTR_USB_DEV_EVENT_STRUCT event)
{
#if IMPLEMENT_QUEUING
uint_8 index;
uint_8 producer, consumer;
/*Body*/
USB_ENDPOINTS *usb_ep_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(event->controller_ID);
/* map the endpoint num to the index of the endpoint structure */
for(index = 0; index < usb_ep_data->count; index++)
{
if(usb_ep_data->ep[index].ep_num ==event->ep_num)
break;
}/*EndFor*/
producer = g_video_endpoint_data.ep[index].bin_producer;
/* if there are no errors de-queue the queue and decrement the no. of
transfers left, else send the same data again */
if(event->errors == 0)
{
/* de-queue if the send is complete without an error */
if ((MAX_QUEUE_ELEMS-1) == g_video_endpoint_data.ep[index].bin_consumer)
{
g_video_endpoint_data.ep[index].bin_consumer = 0;
} else {
g_video_endpoint_data.ep[index].bin_consumer++;
}/*EndIf*/
g_video_endpoint_data.ep[index].queue_num--;
}/*EndIf*/
consumer = g_video_endpoint_data.ep[index].bin_consumer;
if(0 != g_video_endpoint_data.ep[index].queue_num)
{
/*if bin is not empty */
USB_CLASS_VIDEO_QUEUE queue;
/* send the next packet in queue */
queue = g_video_endpoint_data.ep[index].queue[consumer];
(void)USB_Class_Send_Data(queue.controller_ID, queue.channel,
queue.app_buff, queue.size);
}/*EndIf*/
#endif
if(g_video_class_callback != NULL)
{
uint_8 event_type = USB_APP_SEND_COMPLETE;
if(event->errors != 0)
{
event_type = USB_APP_ERROR;
}/*EndIf*/
g_video_class_callback(event->controller_ID, event_type,
(uint_8*)(&(event->errors)));
}/*EndIf*/
}/*EndBody*/
/**************************************************************************//*!
*
* @name USB_Class_CDC_Service_Dic_Bulk_In
*
* @brief The funtion is callback function of DIC Bulk In Endpoint
*
* @param event : Pointer to USB Event Structure
*
* @return None
*
******************************************************************************
* Called by Lower Layer when Data on DIC SEND Interface is sent
*****************************************************************************/
static void USB_Class_CDC_Service_Dic_Bulk_In (
PTR_USB_DEV_EVENT_STRUCT event /* [IN] Pointer to USB Event Structure */
)
{
APP_DATA_STRUCT bulk_in_recv;
#if IMPLEMENT_QUEUING
uint_8 index;
uint_8 producer, consumer;
USB_ENDPOINTS *usb_ep_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(event->controller_ID);
USB_CLASS_CDC_QUEUE queue;
bulk_in_recv.data_ptr = event->buffer_ptr;
bulk_in_recv.data_size = event->len;
/* map the endpoint num to the index of the endpoint structure */
for(index = 0; index < usb_ep_data->count; index++)
{
if(usb_ep_data->ep[index].ep_num == event->ep_num)
break;
}
producer = g_cdc_ep[index].bin_producer;
/* if there are no errors de-queue the queue and decrement the no. of
transfers left, else send the same data again */
if(event->errors == 0)
{
g_cdc_ep[index].bin_consumer++;
}
consumer = g_cdc_ep[index].bin_consumer;
if(consumer != producer)
{/*if bin is not empty */
queue = g_cdc_ep[index].queue[consumer%MAX_QUEUE_ELEMS];
(void)USB_Class_Send_Data(queue.controller_ID, queue.channel,
queue.app_data.data_ptr, queue.app_data.data_size);
}
#endif
if(g_cdc_class_callback != NULL)
{
if(event->errors != 0)
{
g_cdc_class_callback(event->controller_ID, USB_APP_ERROR,
(uint_8*)(&(event->errors)));
}
else
{
g_cdc_class_callback(event->controller_ID, USB_APP_SEND_COMPLETE,
(void*)&bulk_in_recv);
}
}
}
/**************************************************************************//*!
*
* @name USB_Class_CDC_Send_Data
*
* @brief This function is used to send data from CDC Class over send endpoints
*
* @param controller_ID : Controller ID
* @param ep_num : Endpoint number
* @param app_buff : Buffer to send
* @param size : Length of the transfer
*
* @return status
* USB_OK : When Successfull
* Others : Errors
******************************************************************************
* Helper function. Sends DATA over CIC and DIC Interfaces to Host
*****************************************************************************/
uint_8 USB_Class_CDC_Send_Data (
uint_8 controller_ID, /* [IN] Controller ID */
uint_8 ep_num, /* [IN] Endpoint Number */
uint_8_ptr app_buff, /* Pointer to Application Buffer */
USB_PACKET_SIZE size /* Size of Application Buffer */
)
{
uint_8 status = USB_OK;
#if IMPLEMENT_QUEUING
uint_8 index;
uint_8 producer, consumer;
USB_ENDPOINTS *usb_ep_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(controller_ID);
/* map the endpoint num to the index of the endpoint structure */
for(index = 0; index < usb_ep_data->count; index++)
{
if(usb_ep_data->ep[index].ep_num == ep_num)
{
break;
}
}
producer = g_cdc_ep[index].bin_producer;
consumer = g_cdc_ep[index].bin_consumer;
if(((uint_8)(producer - consumer)) != (uint_8)(MAX_QUEUE_ELEMS))
{
/* the bin is not full*/
uint_8 queue_num = (uint_8)(producer % MAX_QUEUE_ELEMS);
/* put all send request parameters in the endpoint data structure */
g_cdc_ep[index].queue[queue_num].controller_ID = controller_ID;
g_cdc_ep[index].queue[queue_num].channel = ep_num;
g_cdc_ep[index].queue[queue_num].app_data.data_ptr = app_buff;
g_cdc_ep[index].queue[queue_num].app_data.data_size = size;
/* increment producer bin by 1*/
g_cdc_ep[index].bin_producer = ++producer;
if((uint_8)(producer - consumer) == (uint_8)1)
{
#endif
status = USB_Class_Send_Data(controller_ID, ep_num, app_buff,size);
#if IMPLEMENT_QUEUING
}
}
else /* bin is full */
{
status = USBERR_DEVICE_BUSY;
}
#endif
return status;
}
/*
** ===================================================================
** Method : USB_Service_Mems_Status_Interrupt (component USB_MEMS_CLASS)
**
** Description :
** The funtion is callback function of Mems Status Interrupt
** endpoint
** This method is internal. It is used by Processor Expert only.
** ===================================================================
*/
static void USB_Service_Mems_Status_Interrupt(
PTR_USB_DEV_EVENT_STRUCT event
)
{
uint_8 index;
uint_8 producer, consumer;
USB_ENDPOINTS *usb_ep_data = (USB_ENDPOINTS *)USB_Desc_Get_Endpoints(event->controller_ID);
/* map the endpoint num to the index of the endpoint structure */
for(index = 0; index < usb_ep_data->count; index++)
{
if(usb_ep_data->ep[index].ep_num == event->ep_num)
break;
}
producer = g_mems_endpoint_data.ep[index].bin_producer;
consumer = g_mems_endpoint_data.ep[index].bin_consumer;
/* if there are no errors de-queue the queue and decrement the no. of
transfers left, else send the same data again */
if (event->errors == 0)
{
/* de-queue if the send is complete without an error */
if((MAX_QUEUE_ELEMS-1) == consumer)
{
g_mems_endpoint_data.ep[index].bin_consumer = 0;
}
else
{
g_mems_endpoint_data.ep[index].bin_consumer++;
}
}
consumer = g_mems_endpoint_data.ep[index].bin_consumer;
g_mems_endpoint_data.ep[index].queue_num--;
if(0 == g_mems_endpoint_data.ep[index].queue_num)
{
/*if bin is not empty */
USB_CLASS_MEMS_QUEUE queue;
/* send the next packet in queue */
queue = g_mems_endpoint_data.ep[index].queue[consumer];
(void)USB_Class_Send_Data(queue.controller_ID, queue.channel,
queue.app_buff, queue.size);
}
if(g_param_callback != NULL)
{
uint_8 event_type = USB_APP_SEND_COMPLETE;
if(event->errors != 0)
{
event_type = USB_APP_ERROR;
}
g_param_callback(event->controller_ID, event_type,
(uint_8*)(&(event->errors)));
}
}
/**************************************************************************//*!
*
* @name USB_Class_Video_Init
*
* @brief The funtion initializes the Device and Controller layer
*
* @param controller_ID : Controller ID
* @param video_class_callback : Video Class Callback
* @param vendor_req_callback : Vendor Request Callback
* @param param_callback : Class requests Callback
*
* @return status:
* USB_OK : When Successfull
* Others : When Error
*
******************************************************************************
*This function initializes the Video Class layer and layers it is dependent on
*****************************************************************************/
uint_8 USB_Class_Video_Init (
uint_8 controller_ID, /* [IN] Controller ID */
USB_CLASS_CALLBACK video_class_callback, /* [IN] Video Class Callback */
USB_REQ_FUNC vendor_req_callback, /* [IN] Vendor Request Callback */
USB_CLASS_CALLBACK param_callback /* [ IN] Video Class requests Callback */
)
{
uint_8 index;
uint_8 status = USB_OK;
USB_ENDPOINTS *ep_desc_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(controller_ID);
#ifndef COMPOSITE_DEV
/* Initialize the device layer*/
status = _usb_device_init(controller_ID,NULL,
(uint_8)(ep_desc_data->count+1), TRUE);
if(status == USB_OK)
{
/* Initialize the generic class functions */
status = USB_Class_Init(controller_ID,USB_Class_Video_Event,
USB_Other_Requests);
if(status == USB_OK)
{
#endif
g_video_endpoint_data.count = ep_desc_data->count;
for(index = 0; index < ep_desc_data->count; index++)
{
g_video_endpoint_data.ep[index].endpoint =
ep_desc_data->ep[index].ep_num;
g_video_endpoint_data.ep[index].type =
ep_desc_data->ep[index].type;
g_video_endpoint_data.ep[index].bin_consumer = 0x00;
g_video_endpoint_data.ep[index].bin_producer = 0x00;
g_video_endpoint_data.ep[index].queue_num = 0x00;
}
/* save the video class callback pointer */
g_video_class_callback = video_class_callback;
/* save the vendor request callback pointer */
g_vendor_req_callback = vendor_req_callback;
/* Save the callback to ask application for class specific params*/
g_param_callback = param_callback;
#ifndef COMPOSITE_DEV
}
}
#endif
return status;
}
/**************************************************************************//*!
*
* @name USB_Class_CDC_Init
*
* @brief The function initializes the Device and Controller layer
*
* @param controller_ID: Controller ID
* @param cdc_class_callback: CDC Class Callback
* @param vendor_req_callback: vendor specific class request callback
* @param param_callback: PSTN Callback
*
* @return status
* USB_OK : When Successfull
* Others : Errors
******************************************************************************
* This function initializes the CDC Class layer and layers it is dependent upon
*****************************************************************************/
uint_8 USB_Class_CDC_Init (
uint_8 controller_ID, /* [IN] Controller ID */
USB_CLASS_CALLBACK cdc_class_callback, /* [IN] CDC Class Callback */
USB_REQ_FUNC vendor_req_callback, /* [IN] Vendor Request Callback */
USB_CLASS_CALLBACK pstn_callback, /* [IN] PSTN Callback */
uint_8 bVregEn /* Enables or disables internal regulator */
)
{
uint_8 index,status = USB_OK;
USB_ENDPOINTS *usb_ep_data =
(USB_ENDPOINTS *)USB_Desc_Get_Endpoints(controller_ID);
#ifndef COMPOSITE_DEV
/* Initialize the device layer*/
status = _usb_device_init(controller_ID, NULL,
(uint_8)(usb_ep_data->count+1), bVregEn);
/* +1 is for Control Endpoint */
if(status == USB_OK)
{
/* Initialize the generic class functions */
status = USB_Class_Init(controller_ID,USB_Class_CDC_Event,
USB_Other_Requests);
#endif
#if IMPLEMENT_QUEUING
for(index = 0; index < usb_ep_data->count; index++)
{
g_cdc_ep[index].endpoint = usb_ep_data->ep[index].ep_num;
g_cdc_ep[index].type = usb_ep_data->ep[index].type;
g_cdc_ep[index].bin_consumer = 0x00;
g_cdc_ep[index].bin_producer = 0x00;
}
#endif
#if PSTN_SUBCLASS_NOTIF_SUPPORT
/* Initialize the pstn subclass functions */
status = USB_Class_CDC_Pstn_Init(controller_ID,pstn_callback);
#endif
if(status == USB_OK)
{
/* save the callback pointer */
g_cdc_class_callback = cdc_class_callback;
/* save the callback pointer */
g_vendor_req_callback = vendor_req_callback;
}
#ifndef COMPOSITE_DEV
}
#endif
return status;
}
/*
** ===================================================================
** Method : usb_device_USB_LDD_OnDeviceSof (component USB_DEVICE_STACK)
**
** Description :
** Called after the Sof is received, OnSof() event is enabled and
** USB module is enabled. See SetEventMask() and GetEventMask()
** methods. The event services the event of the inherited
** component and eventually invokes other events.
** This method is internal. It is used by Processor Expert only.
** ===================================================================
*/
void USB_LDD_OnDeviceSof(LDD_TUserData *UserDataPtr, uint16_t FrameNumber)
{
/* Write your code here ... */
uint_8 queue_num,index;
USB_ENDPOINTS *usb_ep_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(CONTROLLER_ID);
//map the endpoint num to the index of the endpoint structure
for(index = 0; index < usb_ep_data->count; index++)
{
if(usb_ep_data->ep[index].ep_num == 1)
break;
}
//first send USB data
if( ( G_FrameNumber == S_FrameNumber ) && ( first == 0 ) )
{
//tARMPtr->armStatus.isRequiringData = TRUE;
SwapARMDataBuffer();
TransmitMCUData();
tARMPtr->foreBuffer[6] = 0;//wait time:from preparing sending to real sending
S_FrameNumber += 100;
S_FrameNumber &= 0x3ff;
first = 1;
}
if( G_FrameNumber <= 100 )
flag = 0;
if( ( G_FrameNumber == S_FrameNumber ) && ( first == 1 ) && ( flag == 0 ) )
{
//tARMPtr->armStatus.isRequiringData = TRUE;
//If the bin of USB is full,do not swap the buffer
queue_num = g_audio_endpoint_data.ep[index].queue_num;
if(MAX_QUEUE_ELEMS != queue_num)//the USB sending queue is empty(not full),we can swap the buffer
{
SwapARMDataBuffer();
TransmitMCUData();
tARMPtr->foreBuffer[6] = 0;//wait time:from preparing sending to real sending
}
S_FrameNumber += 100;
S_FrameNumber &= 0x3ff;//when frame number more than 1024,reset it 0
if( G_FrameNumber >= 924 )//when frame number loop,S_FrameNumber is a little value(eg:52),then the G_FrameNumber(>1000) is more than S_FrameNumber
flag = 1;
}
}
/*
** ===================================================================
** Method : USB_Class_Mems_Init (component USB_MEMS_CLASS)
** Description :
** The funtion initializes the Device and Controller layer
** Parameters :
** NAME - DESCRIPTION
** controller_ID -
** mems_class_callback -
** vendor_req_callback -
** param_callback -
** Returns :
** --- - Error code
** ===================================================================
*/
uint_8 USB_Class_Mems_Init(
uint_8 controller_ID,
USB_CLASS_CALLBACK mems_class_callback,
USB_REQ_FUNC vendor_req_callback,
USB_CLASS_CALLBACK param_callback
)
{
uint_8 index;
USB_ENDPOINTS *ep_desc_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(controller_ID);
/* Initialize the device layer*/
uint_8 status = _usb_device_init(controller_ID, NULL,
(uint_8)(ep_desc_data->count+1));
if(status == USB_OK)
{
/* Initialize the generic class functions */
status = USB_Class_Init(controller_ID,USB_Class_Mems_Event,
USB_Other_Requests);
if(status == USB_OK)
{
g_mems_endpoint_data.count = ep_desc_data->count;
for(index = 0; index < ep_desc_data->count; index++)
{
g_mems_endpoint_data.ep[index].endpoint =
ep_desc_data->ep[index].ep_num;
g_mems_endpoint_data.ep[index].type =
ep_desc_data->ep[index].type;
g_mems_endpoint_data.ep[index].bin_consumer = 0x00;
g_mems_endpoint_data.ep[index].bin_producer = 0x00;
g_mems_endpoint_data.ep[index].queue_num = 0x00;
}
/* save the Mems class callback pointer */
g_mems_class_callback = mems_class_callback;
/* save the vendor request callback pointer */
g_vendor_req_callback = vendor_req_callback;
/* Save the callback to ask application for class specific params*/
g_param_callback = param_callback;
}
}
return status;
}
/**************************************************************************//*!
*
* @name USB_Service_Hid
*
* @brief The function is a callback function of HID endpoint
*
* @param event : Pointer to USB Event Structure
*
* @return None
*
******************************************************************************
* This function is called from lower layer when data is transfer is completed
* on HID endpoint (non control endpoint)
*****************************************************************************/
void USB_Service_Hid (
PTR_USB_DEV_EVENT_STRUCT event /* [IN] Pointer to USB Event Structure */
)
{
uint_8 index;
uint_8 producer, consumer;
USB_ENDPOINTS *ep_desc_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(event->controller_ID);
/* map the endpoint num to the index of the endpoint structure */
index = USB_Map_Ep_To_Struct_Index(event->controller_ID, event->ep_num);
producer = g_hid_endpoint_data.ep[index].bin_producer;
/* if there are no errors de-queue the queue and decrement the no. of
transfers left, else send the same data again */
if(event->errors == 0)
{
/* de-queue if the send is complete without an error */
g_hid_endpoint_data.ep[index].bin_consumer++;
}
else
{
/* notify the application of the error */
g_hid_class_callback(event->controller_ID, USB_APP_ERROR,
(uint_8*)(&(event->errors)));
}
consumer = g_hid_endpoint_data.ep[index].bin_consumer;
if(consumer != producer)
{
/*if bin is not empty */
USB_CLASS_HID_QUEUE queue;
/* send the next packet in queue */
queue = g_hid_endpoint_data.ep[index].
queue[consumer % MAX_QUEUE_ELEMS];
(void)USB_Class_Send_Data(queue.controller_ID, queue.channel,
queue.app_buff, queue.size);
}
/* notify the app of the send complete */
g_hid_class_callback(event->controller_ID, USB_APP_SEND_COMPLETE, 0);
}
/**************************************************************************//*!
*
* @name USB_Map_Ep_To_Struct_Index
*
* @brief The funtion maps the endpoint number to the index of the endpoint
* data structure
*
* @param controller_ID : Controller ID
* @param ep_num : Endpoint number
*
* @return index : mapped index
*
******************************************************************************
* Returns the index of the endpoint info array for the particular endpoint
* number
*****************************************************************************/
static uint_8 USB_Map_Ep_To_Struct_Index (
uint_8 controller_ID, /* [IN] Controller ID */
uint_8 ep_num /* Endpoint Number */
)
{
uint_8 index = 0;
USB_ENDPOINTS *ep_desc_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(controller_ID);
/* map the endpoint num to the index of the endpoint structure */
for(index = 0; index < ep_desc_data->count; index++)
{
if(ep_desc_data->ep[index].ep_num == ep_num)
{
break;
}
}
return index;
}
/**************************************************************************//*!
*
* @name USB_Class_CDC_Service_Cic_Notify
*
* @brief The function is callback function of CIC Notification endpoint
*
* @param event : Pointer to USB Event Structure
*
* @return None
*
******************************************************************************
* Called by Lower layer when data on CIC Endpoint is sent
*****************************************************************************/
void USB_Class_CDC_Service_Cic_Notify (
PTR_USB_DEV_EVENT_STRUCT event /* [IN] Pointer to USB Event Structure */
)
{
#if IMPLEMENT_QUEUING
uint_8 index;
uint_8 producer, consumer;
USB_ENDPOINTS *usb_ep_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(event->controller_ID);
USB_CLASS_CDC_QUEUE queue;
/* map the endpoint num to the index of the endpoint structure */
for(index = 0; index < usb_ep_data->count; index++)
{
if(usb_ep_data->ep[index].ep_num == event->ep_num)
break;
}
producer = g_cdc_ep[index].bin_producer;
/* if there are no errors de-queue the queue and decrement the no. of
transfers left, else send the same data again */
if(event->errors == 0)
{
g_cdc_ep[index].bin_consumer++;
}
consumer = g_cdc_ep[index].bin_consumer;
if(consumer != producer)
{/*if bin is not empty */
queue = g_cdc_ep[index].queue[consumer%%MAX_QUEUE_ELEMS];
(void)USB_Class_Send_Data(queue.controller_ID, queue.channel,
queue.app_data.data_ptr, queue.app_data.data_size);
}
/**************************************************************************//*!
*
* @name USB_Class_CDC_Event
*
* @brief The funtion initializes CDC endpoints
*
* @param controller_ID : Controller ID
* @param event : Event Type
* @param val : Pointer to configuration Value
*
* @return None
*
******************************************************************************
*
*****************************************************************************/
static void USB_Class_CDC_Event (
uint_8 controller_ID, /* [IN] Controller ID */
uint_8 event, /* [IN] Event Type */
void* val /* [OUT] Pointer to configuration Value */
)
{
uint_8 index;
USB_ENDPOINTS *usb_ep_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(controller_ID);
if(event == USB_APP_ENUM_COMPLETE)
{
uint_8 count;
count = usb_ep_data->count;
/* deinitialize all endpoints in case they were initialized */
while(count > 0)
{
USB_EP_STRUCT_PTR ep_struct_ptr=
(USB_EP_STRUCT_PTR) (&usb_ep_data->ep[count - 1]);
(void)USB_Device_Deinit_EndPoint(controller_ID,
ep_struct_ptr->ep_num, ep_struct_ptr->direction);
count--;
}
/* intialize all non control endpoints */
while(count < usb_ep_data->count)
{
USB_EP_STRUCT_PTR ep_struct=
(USB_EP_STRUCT_PTR) (&usb_ep_data->ep[count]);
(void)USB_Device_Init_EndPoint(controller_ID, ep_struct, FALSE);
/* register callback service for Non Control EndPoints */
switch(ep_struct->type)
{
#if CIC_NOTIF_ELEM_SUPPORT
case USB_INTERRUPT_PIPE :
(void)USB_Device_Register_Service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Class_CDC_Service_Cic_Notify);
break;
#endif
#if !DIC_ISOCHRONOUS_SETTING
case USB_BULK_PIPE :
if(ep_struct->direction == USB_RECV)
{
(void)USB_Device_Register_Service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Class_CDC_Service_Dic_Bulk_Out);
}
else
{
(void)USB_Device_Register_Service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Class_CDC_Service_Dic_Bulk_In);
}
break;
#else
case USB_ISOCHRONOUS_PIPE :
if(ep_struct->direction == USB_RECV)
{
(void)USB_Device_Register_Service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Class_CDC_Service_Dic_Iso_Out);
}
else
{
(void)USB_Device_Register_Service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Class_CDC_Service_Dic_Iso_In);
}
break;
#endif
default:
break;
}
/* set the EndPoint Status as Idle in the device layer */
(void)USB_Device_Set_Status(controller_ID,
(uint_8)(USB_STATUS_ENDPOINT | ep_struct->ep_num |
(ep_struct->direction << USB_COMPONENT_DIRECTION_SHIFT)),
(uint_8)USB_STATUS_IDLE);
count++;
}
}
else if(event == USB_APP_BUS_RESET)
{
#if IMPLEMENT_QUEUING
for(index = 0; index < usb_ep_data->count; index++)
{
g_cdc_ep[index].bin_consumer = 0x00;
g_cdc_ep[index].bin_producer = 0x00;
}
#endif
}
if(g_cdc_class_callback != NULL)
{
g_cdc_class_callback(controller_ID, event, val);
}
}
/**************************************************************************//*!
*
* @name USB_Class_Video_Send_Data
*
* @brief This fucntion is used by Application to send data through Video class
*
* @param controller_ID : Controller ID
* @param ep_num : Endpoint number
* @param app_buff : Buffer to send
* @param size : Length of the transfer
*
* @return status:
* USB_OK : When Successfull
* Others : When Error
*
******************************************************************************
* This fucntion is used by Application to send data through Video class
*****************************************************************************/
uint_8 USB_Class_Video_Send_Data (
uint_8 controller_ID, /* [IN] Controller ID */
uint_8 ep_num, /* [IN] Endpoint Number */
uint_8_ptr app_buff, /* [IN] Buffer to Send */
USB_PACKET_SIZE size /* [IN] Length of the Transfer */
)
{
uint_8 status = USB_OK;
PTR_USB_CLASS_VIDEO_QUEUE queue_tmp;
#if IMPLEMENT_QUEUING
uint_8 index;
uint_8 producer, queue_num;
USB_ENDPOINTS *usb_ep_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(controller_ID);
/*Body*/
/* map the endpoint num to the index of the endpoint structure */
for(index = 0; index < usb_ep_data->count; index++)
{
if(usb_ep_data->ep[index].ep_num == ep_num)
break;
}/*EndFor*/
producer = g_video_endpoint_data.ep[index].bin_producer;
queue_num = g_video_endpoint_data.ep[index].queue_num;
if(MAX_QUEUE_ELEMS != queue_num)
{
/* the bin is not full*/
/* put all send request parameters in the endpoint data structure */
queue_tmp = &(g_video_endpoint_data.ep[index].queue[producer]);
queue_tmp->controller_ID = controller_ID;
queue_tmp->channel = ep_num;
queue_tmp->app_buff = app_buff;
queue_tmp->size = size;
/* increment producer bin by 1*/
if (producer == (MAX_QUEUE_ELEMS - 1))
{
g_video_endpoint_data.ep[index].bin_producer = 0;
} /*Else*/
else
{
g_video_endpoint_data.ep[index].bin_producer++;
}/*EndElse*/
g_video_endpoint_data.ep[index].queue_num++;
if(g_video_endpoint_data.ep[index].queue_num == 1)
{
#endif
status = USB_Class_Send_Data(controller_ID, ep_num, app_buff,size);
#if IMPLEMENT_QUEUING
}/*EndIf*/
}/*Else*/
else /* bin is full */
{
status = USBERR_DEVICE_BUSY;
}/*EndIf*/
#endif
return status;
}/*EndBody*/
/**************************************************************************//*!
*
* @name USB_Class_Hid_Event
*
* @brief The function initializes HID endpoint
*
* @param controller_ID : Controller ID
* @param event : Event Type
* @param val : Pointer to configuration Value
*
* @return None
*
******************************************************************************
* The funtion initializes the HID endpoints when Enumeration complete event is
* received
*****************************************************************************/
void USB_Class_Hid_Event (
uint_8 controller_ID, /* [IN] Controller ID */
uint_8 event, /* [IN] Event Type */
void* val /* [IN] Pointer to configuration Value */
)
{
uint_8 index;
if(event == USB_APP_ENUM_COMPLETE)
{
uint_8 index_num = 0;
uint_8 count = 0,ep_count = 0;
USB_ENDPOINTS *ep_desc_data;
#ifdef COMPOSITE_DEV
DEV_ARCHITECTURE_STRUCT_PTR dev_arc_ptr;
CLASS_ARC_STRUCT_PTR dev_class_ptr;
dev_arc_ptr = (DEV_ARCHITECTURE_STRUCT *)USB_Desc_Get_Class_Architecture(controller_ID);
for(count = 0; count < dev_arc_ptr->cl_count; count++)
{
dev_class_ptr = (CLASS_ARC_STRUCT_PTR)dev_arc_ptr->value[count];
/* Initializes sub_classes */
ep_count = dev_class_ptr->value[0];
if(dev_class_ptr->class_type == 0x03/*HID_CC*/)
break;
index_num +=dev_class_ptr->value[0];
}
/* get the endpoints from the descriptor module */
ep_desc_data = (USB_ENDPOINTS *)USB_Desc_Get_Endpoints(controller_ID);
#else
/* get the endpoints from the descriptor module */
ep_desc_data = (USB_ENDPOINTS *)USB_Desc_Get_Endpoints(controller_ID);
ep_count = ep_desc_data->count;
#endif
/* deinitialize all endpoints in case they were initialized */
for(count=index_num;count<ep_count+index_num;count++)
{
USB_EP_STRUCT_PTR ep_struct_ptr=
(USB_EP_STRUCT_PTR) (&ep_desc_data->ep[count]);
(void)_usb_device_deinit_endpoint(&controller_ID,
ep_struct_ptr->ep_num, ep_struct_ptr->direction);
}
/* intialize all non control endpoints */
for(count=index_num;count<ep_count+index_num;count++)
{
USB_EP_STRUCT_PTR ep_struct=
(USB_EP_STRUCT_PTR)&ep_desc_data->ep[count];
(void)_usb_device_init_endpoint(&controller_ID, ep_struct->ep_num,
ep_struct->size, ep_struct->direction, ep_struct->type,
TRUE);
/* register callback service for the endpoint */
(void)_usb_device_register_service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Service_Hid);
/* set the EndPoint Status as Idle in the device layer */
(void)_usb_device_set_status(&controller_ID,
(uint_8)(USB_STATUS_ENDPOINT | HID_ENDPOINT |
(ep_struct->direction << USB_COMPONENT_DIRECTION_SHIFT)),
USB_STATUS_IDLE);
}
}
else if((event == USB_APP_BUS_RESET) || (event == USB_APP_CONFIG_CHANGED))
{
/* clear producer and consumer on reset */
for(index = 0; index < g_hid_endpoint_data.count; index++)
{
g_hid_endpoint_data.ep[index].bin_consumer = 0x00;
g_hid_endpoint_data.ep[index].bin_producer = 0x00;
g_hid_endpoint_data.ep[index].queue_num = 0x00;
}
}
if(g_hid_class_callback != NULL)
{
/* notify the application of the event */
g_hid_class_callback(controller_ID, event, val);
}
}
/*
** ===================================================================
** Method : USB_Class_Mems_Event (component USB_MEMS_CLASS)
**
** Description :
** The funtion initializes Mems endpoint
** This method is internal. It is used by Processor Expert only.
** ===================================================================
*/
static void USB_Class_Mems_Event(
uint_8 controller_ID,
uint_8 event,
void* val
)
{
uint_8 index;
if(event == USB_APP_ENUM_COMPLETE)
{
uint_8 count;
/* get the endpoints from the descriptor module */
USB_ENDPOINTS *ep_desc_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(controller_ID);
count = ep_desc_data->count;
/* deinitialize all endpoints in case they were initialized */
while(count > 0)
{
USB_EP_STRUCT_PTR ep_struct_ptr=
(USB_EP_STRUCT_PTR) (&ep_desc_data->ep[count - 1]);
(void)_usb_device_deinit_endpoint(&controller_ID,
ep_struct_ptr->ep_num, ep_struct_ptr->direction);
count--;
}
/* intialize all non control endpoints */
while(count < ep_desc_data->count)
{
USB_EP_STRUCT_PTR ep_struct=
(USB_EP_STRUCT_PTR)&ep_desc_data->ep[count];
(void)_usb_device_init_endpoint(&controller_ID, ep_struct->ep_num,
ep_struct->size, ep_struct->direction, ep_struct->type, TRUE);
/* register callback service for the endpoint */
switch(ep_struct->type)
{
case USB_INTERRUPT_PIPE:
(void)_usb_device_register_service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Service_Mems_Status_Interrupt);
break;
case USB_BULK_PIPE :
if(ep_struct->direction == USB_RECV)
{
(void)_usb_device_register_service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Class_MEMS_Service_Dic_Bulk_Out);
}
else
{
(void)_usb_device_register_service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Class_MEMS_Service_Dic_Bulk_In);
}
break;
default:
break;
}
/* set the EndPoint Status as Idle in the device layer */
(void)_usb_device_set_status(&controller_ID,
(uint_8)(USB_STATUS_ENDPOINT | 1|
(ep_struct->direction << USB_COMPONENT_DIRECTION_SHIFT)),
USB_STATUS_IDLE);
count++;
}
}
else if(event == USB_APP_BUS_RESET)
{
/* clear producer and consumer on reset */
for(index = 0; index < g_mems_endpoint_data.count; index++)
{
g_mems_endpoint_data.ep[index].bin_consumer = 0x00;
g_mems_endpoint_data.ep[index].bin_producer = 0x00;
g_mems_endpoint_data.ep[index].queue_num = 0x00;
}
}
if(g_mems_class_callback != NULL)
{
/* notify the event to the application */
g_mems_class_callback(controller_ID, event, val);
}
}
/**************************************************************************//*!
*
* @name USB_Class_CDC_Event
*
* @brief The function initializes CDC endpoints
*
* @param controller_ID : Controller ID
* @param event : Event Type
* @param val : Pointer to configuration Value
*
* @return None
*
******************************************************************************
*
*****************************************************************************/
void USB_Class_CDC_Event (
uint_8 controller_ID, /* [IN] Controller ID */
uint_8 event, /* [IN] Event Type */
void* val /* [OUT] Pointer to configuration Value */
)
{
uint_8 index;
USB_ENDPOINTS *usb_ep_data = (USB_ENDPOINTS *)
USB_Desc_Get_Endpoints(controller_ID);
if(event == USB_APP_ENUM_COMPLETE)
{
uint_8 count = 0,ep_count = 0;
uint_8 index_num = 0;
#ifdef COMPOSITE_DEV
DEV_ARCHITECTURE_STRUCT_PTR dev_arc_ptr;
CLASS_ARC_STRUCT_PTR dev_class_ptr;
dev_arc_ptr = (DEV_ARCHITECTURE_STRUCT *)USB_Desc_Get_Class_Architecture(controller_ID);
for(count = 0; count < dev_arc_ptr->cl_count; count++)
{
dev_class_ptr = (CLASS_ARC_STRUCT_PTR)dev_arc_ptr->value[count];
/* Initializes sub_classes */
ep_count = dev_class_ptr->value[0];
if(dev_class_ptr->class_type == 0x02/*CDC_CC*/)
break;
index_num +=dev_class_ptr->value[0];
}
#else
ep_count = usb_ep_data->count;
#endif
for(count=index_num; count<ep_count+index_num; count++)
{
USB_EP_STRUCT_PTR ep_struct_ptr=
(USB_EP_STRUCT_PTR) (&usb_ep_data->ep[count]);
(void)_usb_device_deinit_endpoint(&controller_ID,
ep_struct_ptr->ep_num, ep_struct_ptr->direction);
}
/* intialize all non control endpoints */
for(count=index_num; count<ep_count+index_num; count++)
{
USB_EP_STRUCT_PTR ep_struct=
(USB_EP_STRUCT_PTR) (&usb_ep_data->ep[count]);
(void)_usb_device_init_endpoint(&controller_ID, ep_struct->ep_num,
ep_struct->size, ep_struct->direction, ep_struct->type, FALSE);
/* register callback service for Non Control EndPoints */
switch(ep_struct->type)
{
#if CIC_NOTIF_ELEM_SUPPORT
case USB_INTERRUPT_PIPE :
(void)_usb_device_register_service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Class_CDC_Service_Cic_Notify);
break;
#endif
#if !DIC_ISOCHRONOUS_SETTING
case USB_BULK_PIPE :
#ifdef MULTIPLE_DEVICES
if(ep_struct->direction == USB_RECV)
{
(void)_usb_device_register_service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Class_CDC_Service_Dic_Bulk_Out);
}
else
{
(void)_usb_device_register_service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Class_CDC_Service_Dic_Bulk_In);
}
#endif
break;
#else
case USB_ISOCHRONOUS_PIPE :
if(ep_struct->direction == USB_RECV)
{
(void)_usb_device_register_service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Class_CDC_Service_Dic_Iso_Out);
}
else
{
(void)_usb_device_register_service(controller_ID,
(uint_8)(USB_SERVICE_EP0+ep_struct->ep_num),
USB_Class_CDC_Service_Dic_Iso_In);
}
break;
#endif
default:
break;
}
/* set the EndPoint Status as Idle in the device layer */
(void)_usb_device_set_status(&controller_ID,
(uint_8)(USB_STATUS_ENDPOINT | ep_struct->ep_num |
(ep_struct->direction << USB_COMPONENT_DIRECTION_SHIFT)),
(uint_8)USB_STATUS_IDLE);
}
}
else if(event == USB_APP_BUS_RESET)
{
#if IMPLEMENT_QUEUING
for(index = 0; index < usb_ep_data->count; index++)
{
g_cdc_ep[index].bin_consumer = 0x00;
g_cdc_ep[index].bin_producer = 0x00;
}
#endif
}
if(g_cdc_class_callback != NULL)
{
g_cdc_class_callback(controller_ID, event, val);
}
}
