arch/arm/plat-feroceon/mv_hal/usb/device/mvUsbDevSend.c - kernel/prism - Git at Google

 /*******************************************************************************

 This software file (the "File") is distributed by Marvell International Ltd.
 or its affiliate(s) under the terms of the GNU General Public License Version 2,
 June 1991 (the "License").  You may use, redistribute and/or modify this File
 in accordance with the terms and conditions of the License, a copy of which
 is available along with the File in the license.txt file or by writing to the
 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
 or on the worldwide web at http://www.gnu.org/licenses/gpl.txt.

 THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
 WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
 DISCLAIMED.  The GPL License provides additional details about this warranty
 disclaimer.

 (C) Copyright 2004 - 2007 Marvell Semiconductor Israel Ltd. All Rights Reserved.
 (C) Copyright 1999 - 2004 Chipidea Microelectronica, S.A. All Rights Reserved.

 *******************************************************************************/

 #include "usb/api/mvUsbDevApi.h"
 #include "usb/device/mvUsbDevPrv.h"

 #if defined(USB_UNDERRUN_WA)

 typedef struct
 {
     uint_8*     buff_ptr[MAX_XDS_FOR_TR_CALLS];
     uint_32     size[MAX_XDS_FOR_TR_CALLS];
     uint_8      ep_num[MAX_XDS_FOR_TR_CALLS];
     int         head;
     int         tail;
     int         tail_dma;
     int         num;
     int         num_dma;

 } USB_SEND_QUEUE;

 uint_8*         usbSramBase;
 int             usbSramSize;
 int		        usbSramPartSize;
 USB_SEND_QUEUE  usbSendQueue;

 uint_32         usbSentSize = 0;
 uint_32         usbDmaSize = 0;

 #define S_FREE	    0
 #define S_BUSY	    1

 uint_32		    dma_index = 0;
 uint_32		    sent_index = 0;
 uint_32		    sram_parts[USB_SRAM_MAX_PARTS];


 void    _usb_reset_send_queue(void)
 {
     int     i;

     usbSendQueue.num = 0;
 	usbSendQueue.num_dma = 0;
     usbSendQueue.head = 0;
     usbSendQueue.tail = 0;
 	usbSendQueue.tail_dma = 0;
     for(i=0; i<MAX_XDS_FOR_TR_CALLS; i++)
     {
         usbSendQueue.size[i] = 0;
         usbSendQueue.buff_ptr[i] = NULL;
         usbSendQueue.ep_num[i] = 0;
     }
 	usbSramPartSize = usbSramSize/global_wa_sram_parts;

     for(i=0; i<global_wa_sram_parts; i++)
     {
 		sram_parts[i] = S_FREE;
     }
 }

 uint_8 _usb_prepare_to_send(void*   handle)
 {
     XD_STRUCT_PTR               xd_ptr;
     USB_DEV_STATE_STRUCT_PTR    usb_dev_ptr;
     uint_8*                     buff_ptr;
     uint_8*			            tmp_buff;
     uint_32                     size;
     int                         num_dma, tail_dma, i;
     uint_8			            error = 0;

     usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;

     tail_dma = usbSendQueue.tail_dma;
     num_dma = usbSendQueue.num_dma;
     buff_ptr = usbSendQueue.buff_ptr[tail_dma];
     size = usbSendQueue.size[tail_dma];

     if(num_dma == 0)
 	    return 0;

 /*
     USB_printf("_usb_prepare_to_send: num=%d, tail=%d, sentSize=%d, size=%d, buff=%p\n",
                 num_dma, tail_dma, usbSentSize, size, buff_ptr);
 */
     for(i=0; i<global_wa_sram_parts; i++)
     {
 	    if(sram_parts[dma_index] != S_FREE)
 	        break;

 	    if(usbDmaSize >= usbSendQueue.size[tail_dma])
 	    {
 	        /* Remove from the usbSendQueues */
 	        num_dma--;
             tail_dma++;
             if(tail_dma == MAX_XDS_FOR_TR_CALLS)
                 tail_dma = 0;

             usbSendQueue.tail_dma = tail_dma;
             usbSendQueue.num_dma = num_dma;
             usbDmaSize = 0;

             if(num_dma == 0)
                 break;
         }

 	    buff_ptr = usbSendQueue.buff_ptr[tail_dma] + usbDmaSize;
 	    size = MIN(usbSramPartSize, (usbSendQueue.size[tail_dma] - usbDmaSize) );

 	    usbDmaSize += size;

 	    if(size > global_wa_threshold)
 	    {
 	        tmp_buff = buff_ptr;
 	        buff_ptr = (uint_8*)((int)usbSramBase + (dma_index * usbSramPartSize));
 	        USB_idma_copy(buff_ptr, tmp_buff, size);

 	        sram_parts[dma_index] = S_BUSY;
             dma_index++;
             if(dma_index == global_wa_sram_parts)
                 dma_index = 0;
 	    }


 	    /* Get a transfer descriptor */
 	    USB_XD_QGET(usb_dev_ptr->XD_HEAD, usb_dev_ptr->XD_TAIL, xd_ptr);

 	    usb_dev_ptr->XD_ENTRIES--;
 	    USB_dcache_flush((pointer)buff_ptr, size);

 	    /* Initialize the new transfer descriptor */
 	    xd_ptr->EP_NUM = usbSendQueue.ep_num[tail_dma];
 	    xd_ptr->BDIRECTION = ARC_USB_SEND;
 	    xd_ptr->WTOTALLENGTH = size;
 	    xd_ptr->WSOFAR = 0;
 	    xd_ptr->WSTARTADDRESS = buff_ptr;
 	    xd_ptr->BSTATUS = ARC_USB_STATUS_TRANSFER_ACCEPTED;

 	    error = _usb_dci_vusb20_add_dTD(handle, xd_ptr);

 	    if(error)
 	        break;
     }

     return error;
 }


 /*FUNCTION*-------------------------------------------------------------
 *
 *  Function Name  : usbSendComplete
 *  Returned Value : None
 *  Comments       :
 *        Callback for send transfer complete event.
 *
 *END*-----------------------------------------------------------------*/
 void    usbSendComplete(void* handle, uint_8 type, boolean setup, uint_8 dir,
                         uint_8_ptr buffer, uint_32 length, uint_8 error)
 {
     /* Check if this complete is one from the sendQueue */
     if( (usbSendQueue.ep_num[usbSendQueue.tail] == type) &&
         (usbSendQueue.num > 0) )
     {
         USB_DEV_STATE_STRUCT_PTR    usb_dev_ptr;
         uint_8*                     buff_ptr;
         uint_32                     size;
         int                         num, tail;

         usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;

         tail = usbSendQueue.tail;
         num = usbSendQueue.num;
         buff_ptr = usbSendQueue.buff_ptr[tail];
         size = usbSendQueue.size[tail];
 /*
         USB_printf("usbSendComplete: num=%d, tail=%d, usbSentSize=%d, type=%d, length=%d (%d), buff=%p (%p)\n",
                 num, tail, usbSentSize, type, length, usbSendQueue.size[tail],
                 buffer, usbSendQueue.buff_ptr[tail]);
 */
         usbSentSize += length;

 	    /* if the buffer was on the SRAM */
 	    if( ((unsigned)buffer >= (unsigned)usbSramBase) &&
 	    ((unsigned)buffer < ((unsigned)usbSramBase + (usbSramPartSize * global_wa_sram_parts))) )
 	    {
 	        sram_parts[sent_index] = S_FREE;
             sent_index++;
             if(sent_index == global_wa_sram_parts)
                 sent_index = 0;
 	    }

         if(usbSentSize >= usbSendQueue.size[tail])
         {
             /* Remove from the usbSendQueues */
             num--;
             tail++;
             if(tail == MAX_XDS_FOR_TR_CALLS)
                 tail = 0;

             usbSendQueue.tail = tail;
             usbSendQueue.num = num;
             usbSentSize = 0;

             /* Call complete callback */
             _usb_device_call_service(handle, type, setup, dir,
                          buff_ptr, size, error);

             if(num == 0)
                 return;
         }

 	    error = _usb_prepare_to_send(handle);
         if (error)
         {
             USB_printf("usbSendComplete, add_dTD failed\n");
         }

     }
     else
     {
         /* Call complete callback */
         _usb_device_call_service(handle, type, setup, dir,
                         buffer, length, error);
     }
 }
 #endif /* USB_UNDERRUN_WA */


 /*FUNCTION*-------------------------------------------------------------
 *
 *  Function Name  : _usb_device_send_data
 *  Returned Value : USB_OK or error code
 *  Comments       :
 *        Sends data on a specified endpoint.
 *
 *END*-----------------------------------------------------------------*/
 uint_8 _usb_device_send_data
    (
       /* [IN] the USB_USB_dev_initialize state structure */
       _usb_device_handle         handle,

       /* [IN] the Endpoint number */
       uint_8                     ep_num,

       /* [IN] buffer to send */
       uint_8_ptr                 buff_ptr,

       /* [IN] length of the transfer */
       uint_32                    size
    )
 { /* Body */
    int 	                        lockKey;
    uint_8                       error = 0;
    XD_STRUCT_PTR                xd_ptr;
    USB_DEV_STATE_STRUCT_PTR     usb_dev_ptr;
    boolean                      toSend = TRUE;

    usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;

    ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_TX,
        "send_data: handle=%p, ep=%d, pBuf=0x%x, size=%d, EP_QH=%p\n",
        handle, ep_num, (unsigned)buff_ptr, (int)size, usb_dev_ptr->EP_QUEUE_HEAD_PTR);

    ARC_DEBUG_CODE(ARC_DEBUG_FLAG_STATS, (usb_dev_ptr->STATS.usb_send_count++));

    lockKey = USB_lock();

    if (!usb_dev_ptr->XD_ENTRIES)
    {
       USB_unlock(lockKey);
       USB_printf("_usb_device_send_data, transfer in progress\n");
       return ARC_USB_STATUS_TRANSFER_IN_PROGRESS;
    } /* Endif */

 #if defined(USB_UNDERRUN_WA)
     {
         int 			                head;
        	VUSB20_EP_QUEUE_HEAD_STRUCT* 	ep_queue_head_ptr;

 		ep_queue_head_ptr = (VUSB20_EP_QUEUE_HEAD_STRUCT_PTR)usb_dev_ptr->EP_QUEUE_HEAD_PTR +
                        						                  2*ep_num + ARC_USB_SEND;

         if( ((ep_queue_head_ptr->MAX_PKT_LENGTH >> 16) & 0x7FF) > global_wa_threshold)
         {
             /* Only Endpoints with maxPktSize more than 128 bytes need special processing */
             if( (size > global_wa_threshold) ||
                 (usbSendQueue.num != 0) )
             {
 /*
                 USB_printf("_usb_device_send_data: ep_num=%d, maxPktSize=%d, size=%d\n",
                         ep_num, (ep_queue_head_ptr->MAX_PKT_LENGTH >> 16) & 0x7FF, size);
 */
                 /* Check if usbSendQueue is not Full */
                 if(usbSendQueue.num == MAX_XDS_FOR_TR_CALLS)
                 {
                     USB_printf("ep=%d: usbSendQueue is FULL\n", ep_num);
                     USB_unlock(lockKey);
                     return USBERR_TX_FAILED;
                 }

                 /* Add to usbSendQueu */
                 head = usbSendQueue.head;

                 usbSendQueue.num++;
 		        usbSendQueue.num_dma++;
                 usbSendQueue.size[head] = size;
                 usbSendQueue.buff_ptr[head] = buff_ptr;
                 usbSendQueue.ep_num[head] = ep_num;

                 head++;
                 if(head == MAX_XDS_FOR_TR_CALLS)
                     head = 0;

                 usbSendQueue.head = head;

                 /* Process first usbSendQueue element if possible */
                 if(usbSendQueue.num == 1)
                 {
 		            error = _usb_prepare_to_send(handle);
 		        }
 		        toSend = FALSE;
             }
         }
     }
 #endif /* USB_UNDERRUN_WA */

     if(toSend == TRUE)
     {
         /* Get a transfer descriptor */
         USB_XD_QGET(usb_dev_ptr->XD_HEAD, usb_dev_ptr->XD_TAIL, xd_ptr);

         usb_dev_ptr->XD_ENTRIES--;

         if(buff_ptr != NULL)
             USB_dcache_flush((pointer)buff_ptr, size);

         /* Initialize the new transfer descriptor */
         xd_ptr->EP_NUM = ep_num;
         xd_ptr->BDIRECTION = ARC_USB_SEND;
         xd_ptr->WTOTALLENGTH = size;
         xd_ptr->WSOFAR = 0;
         xd_ptr->WSTARTADDRESS = buff_ptr;
         xd_ptr->BSTATUS = ARC_USB_STATUS_TRANSFER_ACCEPTED;

         error = _usb_dci_vusb20_add_dTD(handle, xd_ptr);
     }
     USB_unlock(lockKey);

     if (error)
     {
         USB_printf("_usb_device_send_data, transfer failed\n");
         return USBERR_TX_FAILED;
     } /* Endif */
     return error;

 } /* EndBody */
	/*******************************************************************************

	This software file (the "File") is distributed by Marvell International Ltd.
	or its affiliate(s) under the terms of the GNU General Public License Version 2,
	June 1991 (the "License"). You may use, redistribute and/or modify this File
	in accordance with the terms and conditions of the License, a copy of which
	is available along with the File in the license.txt file or by writing to the
	Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	or on the worldwide web at http://www.gnu.org/licenses/gpl.txt.

	THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE IMPLIED
	WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY
	DISCLAIMED. The GPL License provides additional details about this warranty
	disclaimer.

	(C) Copyright 2004 - 2007 Marvell Semiconductor Israel Ltd. All Rights Reserved.
	(C) Copyright 1999 - 2004 Chipidea Microelectronica, S.A. All Rights Reserved.

	*******************************************************************************/

	#include "usb/api/mvUsbDevApi.h"
	#include "usb/device/mvUsbDevPrv.h"

	#if defined(USB_UNDERRUN_WA)

	typedef struct
	{
	uint_8* buff_ptr[MAX_XDS_FOR_TR_CALLS];
	uint_32 size[MAX_XDS_FOR_TR_CALLS];
	uint_8 ep_num[MAX_XDS_FOR_TR_CALLS];
	int head;
	int tail;
	int tail_dma;
	int num;
	int num_dma;

	} USB_SEND_QUEUE;

	uint_8* usbSramBase;
	int usbSramSize;
	int usbSramPartSize;
	USB_SEND_QUEUE usbSendQueue;

	uint_32 usbSentSize = 0;
	uint_32 usbDmaSize = 0;

	#define S_FREE 0
	#define S_BUSY 1

	uint_32 dma_index = 0;
	uint_32 sent_index = 0;
	uint_32 sram_parts[USB_SRAM_MAX_PARTS];


	void _usb_reset_send_queue(void)
	{
	int i;

	usbSendQueue.num = 0;
	usbSendQueue.num_dma = 0;
	usbSendQueue.head = 0;
	usbSendQueue.tail = 0;
	usbSendQueue.tail_dma = 0;
	for(i=0; i<MAX_XDS_FOR_TR_CALLS; i++)
	{
	usbSendQueue.size[i] = 0;
	usbSendQueue.buff_ptr[i] = NULL;
	usbSendQueue.ep_num[i] = 0;
	}
	usbSramPartSize = usbSramSize/global_wa_sram_parts;

	for(i=0; i<global_wa_sram_parts; i++)
	{
	sram_parts[i] = S_FREE;
	}
	}

	uint_8 _usb_prepare_to_send(void* handle)
	{
	XD_STRUCT_PTR xd_ptr;
	USB_DEV_STATE_STRUCT_PTR usb_dev_ptr;
	uint_8* buff_ptr;
	uint_8* tmp_buff;
	uint_32 size;
	int num_dma, tail_dma, i;
	uint_8 error = 0;

	usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;

	tail_dma = usbSendQueue.tail_dma;
	num_dma = usbSendQueue.num_dma;
	buff_ptr = usbSendQueue.buff_ptr[tail_dma];
	size = usbSendQueue.size[tail_dma];

	if(num_dma == 0)
	return 0;

	/*
	USB_printf("_usb_prepare_to_send: num=%d, tail=%d, sentSize=%d, size=%d, buff=%p\n",
	num_dma, tail_dma, usbSentSize, size, buff_ptr);
	*/
	for(i=0; i<global_wa_sram_parts; i++)
	{
	if(sram_parts[dma_index] != S_FREE)
	break;

	if(usbDmaSize >= usbSendQueue.size[tail_dma])
	{
	/* Remove from the usbSendQueues */
	num_dma--;
	tail_dma++;
	if(tail_dma == MAX_XDS_FOR_TR_CALLS)
	tail_dma = 0;

	usbSendQueue.tail_dma = tail_dma;
	usbSendQueue.num_dma = num_dma;
	usbDmaSize = 0;

	if(num_dma == 0)
	break;
	}

	buff_ptr = usbSendQueue.buff_ptr[tail_dma] + usbDmaSize;
	size = MIN(usbSramPartSize, (usbSendQueue.size[tail_dma] - usbDmaSize) );

	usbDmaSize += size;

	if(size > global_wa_threshold)
	{
	tmp_buff = buff_ptr;
	buff_ptr = (uint_8)((int)usbSramBase + (dma_index usbSramPartSize));
	USB_idma_copy(buff_ptr, tmp_buff, size);

	sram_parts[dma_index] = S_BUSY;
	dma_index++;
	if(dma_index == global_wa_sram_parts)
	dma_index = 0;
	}


	/* Get a transfer descriptor */
	USB_XD_QGET(usb_dev_ptr->XD_HEAD, usb_dev_ptr->XD_TAIL, xd_ptr);

	usb_dev_ptr->XD_ENTRIES--;
	USB_dcache_flush((pointer)buff_ptr, size);

	/* Initialize the new transfer descriptor */
	xd_ptr->EP_NUM = usbSendQueue.ep_num[tail_dma];
	xd_ptr->BDIRECTION = ARC_USB_SEND;
	xd_ptr->WTOTALLENGTH = size;
	xd_ptr->WSOFAR = 0;
	xd_ptr->WSTARTADDRESS = buff_ptr;
	xd_ptr->BSTATUS = ARC_USB_STATUS_TRANSFER_ACCEPTED;

	error = _usb_dci_vusb20_add_dTD(handle, xd_ptr);

	if(error)
	break;
	}

	return error;
	}


	/FUNCTION-------------------------------------------------------------
	*
	* Function Name : usbSendComplete
	* Returned Value : None
	* Comments :
	* Callback for send transfer complete event.
	*
	END-----------------------------------------------------------------*/
	void usbSendComplete(void* handle, uint_8 type, boolean setup, uint_8 dir,
	uint_8_ptr buffer, uint_32 length, uint_8 error)
	{
	/* Check if this complete is one from the sendQueue */
	if( (usbSendQueue.ep_num[usbSendQueue.tail] == type) &&
	(usbSendQueue.num > 0) )
	{
	USB_DEV_STATE_STRUCT_PTR usb_dev_ptr;
	uint_8* buff_ptr;
	uint_32 size;
	int num, tail;

	usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;

	tail = usbSendQueue.tail;
	num = usbSendQueue.num;
	buff_ptr = usbSendQueue.buff_ptr[tail];
	size = usbSendQueue.size[tail];
	/*
	USB_printf("usbSendComplete: num=%d, tail=%d, usbSentSize=%d, type=%d, length=%d (%d), buff=%p (%p)\n",
	num, tail, usbSentSize, type, length, usbSendQueue.size[tail],
	buffer, usbSendQueue.buff_ptr[tail]);
	*/
	usbSentSize += length;

	/* if the buffer was on the SRAM */
	if( ((unsigned)buffer >= (unsigned)usbSramBase) &&
	((unsigned)buffer < ((unsigned)usbSramBase + (usbSramPartSize * global_wa_sram_parts))) )
	{
	sram_parts[sent_index] = S_FREE;
	sent_index++;
	if(sent_index == global_wa_sram_parts)
	sent_index = 0;
	}

	if(usbSentSize >= usbSendQueue.size[tail])
	{
	/* Remove from the usbSendQueues */
	num--;
	tail++;
	if(tail == MAX_XDS_FOR_TR_CALLS)
	tail = 0;

	usbSendQueue.tail = tail;
	usbSendQueue.num = num;
	usbSentSize = 0;

	/* Call complete callback */
	_usb_device_call_service(handle, type, setup, dir,
	buff_ptr, size, error);

	if(num == 0)
	return;
	}

	error = _usb_prepare_to_send(handle);
	if (error)
	{
	USB_printf("usbSendComplete, add_dTD failed\n");
	}

	}
	else
	{
	/* Call complete callback */
	_usb_device_call_service(handle, type, setup, dir,
	buffer, length, error);
	}
	}
	#endif /* USB_UNDERRUN_WA */


	/FUNCTION-------------------------------------------------------------
	*
	* Function Name : _usb_device_send_data
	* Returned Value : USB_OK or error code
	* Comments :
	* Sends data on a specified endpoint.
	*
	END-----------------------------------------------------------------*/
	uint_8 _usb_device_send_data
	(
	/* [IN] the USB_USB_dev_initialize state structure */
	_usb_device_handle handle,

	/* [IN] the Endpoint number */
	uint_8 ep_num,

	/* [IN] buffer to send */
	uint_8_ptr buff_ptr,

	/* [IN] length of the transfer */
	uint_32 size
	)
	{ /* Body */
	int lockKey;
	uint_8 error = 0;
	XD_STRUCT_PTR xd_ptr;
	USB_DEV_STATE_STRUCT_PTR usb_dev_ptr;
	boolean toSend = TRUE;

	usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;

	ARC_DEBUG_TRACE(ARC_DEBUG_FLAG_TX,
	"send_data: handle=%p, ep=%d, pBuf=0x%x, size=%d, EP_QH=%p\n",
	handle, ep_num, (unsigned)buff_ptr, (int)size, usb_dev_ptr->EP_QUEUE_HEAD_PTR);

	ARC_DEBUG_CODE(ARC_DEBUG_FLAG_STATS, (usb_dev_ptr->STATS.usb_send_count++));

	lockKey = USB_lock();

	if (!usb_dev_ptr->XD_ENTRIES)
	{
	USB_unlock(lockKey);
	USB_printf("_usb_device_send_data, transfer in progress\n");
	return ARC_USB_STATUS_TRANSFER_IN_PROGRESS;
	} /* Endif */

	#if defined(USB_UNDERRUN_WA)
	{
	int head;
	VUSB20_EP_QUEUE_HEAD_STRUCT* ep_queue_head_ptr;

	ep_queue_head_ptr = (VUSB20_EP_QUEUE_HEAD_STRUCT_PTR)usb_dev_ptr->EP_QUEUE_HEAD_PTR +
	2*ep_num + ARC_USB_SEND;

	if( ((ep_queue_head_ptr->MAX_PKT_LENGTH >> 16) & 0x7FF) > global_wa_threshold)
	{
	/* Only Endpoints with maxPktSize more than 128 bytes need special processing */
	if( (size > global_wa_threshold) \|\|
	(usbSendQueue.num != 0) )
	{
	/*
	USB_printf("_usb_device_send_data: ep_num=%d, maxPktSize=%d, size=%d\n",
	ep_num, (ep_queue_head_ptr->MAX_PKT_LENGTH >> 16) & 0x7FF, size);
	*/
	/* Check if usbSendQueue is not Full */
	if(usbSendQueue.num == MAX_XDS_FOR_TR_CALLS)
	{
	USB_printf("ep=%d: usbSendQueue is FULL\n", ep_num);
	USB_unlock(lockKey);
	return USBERR_TX_FAILED;
	}

	/* Add to usbSendQueu */
	head = usbSendQueue.head;

	usbSendQueue.num++;
	usbSendQueue.num_dma++;
	usbSendQueue.size[head] = size;
	usbSendQueue.buff_ptr[head] = buff_ptr;
	usbSendQueue.ep_num[head] = ep_num;

	head++;
	if(head == MAX_XDS_FOR_TR_CALLS)
	head = 0;

	usbSendQueue.head = head;

	/* Process first usbSendQueue element if possible */
	if(usbSendQueue.num == 1)
	{
	error = _usb_prepare_to_send(handle);
	}
	toSend = FALSE;
	}
	}
	}
	#endif /* USB_UNDERRUN_WA */

	if(toSend == TRUE)
	{
	/* Get a transfer descriptor */
	USB_XD_QGET(usb_dev_ptr->XD_HEAD, usb_dev_ptr->XD_TAIL, xd_ptr);

	usb_dev_ptr->XD_ENTRIES--;

	if(buff_ptr != NULL)
	USB_dcache_flush((pointer)buff_ptr, size);

	/* Initialize the new transfer descriptor */
	xd_ptr->EP_NUM = ep_num;
	xd_ptr->BDIRECTION = ARC_USB_SEND;
	xd_ptr->WTOTALLENGTH = size;
	xd_ptr->WSOFAR = 0;
	xd_ptr->WSTARTADDRESS = buff_ptr;
	xd_ptr->BSTATUS = ARC_USB_STATUS_TRANSFER_ACCEPTED;

	error = _usb_dci_vusb20_add_dTD(handle, xd_ptr);
	}
	USB_unlock(lockKey);

	if (error)
	{
	USB_printf("_usb_device_send_data, transfer failed\n");
	return USBERR_TX_FAILED;
	} /* Endif */
	return error;

	} /* EndBody */