/*HEADER******************************************************************
**************************************************************************
*** 
*** Copyright (c) 2001-2002 ARC International.
*** All rights reserved                                          
***                                                              
*** This software embodies materials and concepts which are      
*** confidential to ARC International and is made
*** available solely pursuant to the terms of a written license   
*** agreement with ARC International             
***
*** File: vusbd11.c
***
*** Comments:      
***   This file contains the low-level VUSB1.1 routines.
***                                                               
**************************************************************************
*END*********************************************************************/
#ifdef __USB_OS_MQX__
#include "mqx.h"
#include "bsp.h"
#else
#include "devapi.h"
#include "usb.h"
#include "vusb11.h"
#endif
#include "usbprv.h"
#include "usbdprv.h"

#ifndef __USB_OS_MQX__
USB_DEV_STATE_STRUCT_PTR global_usb_device_state_struct_ptr;
extern volatile boolean IN_ISR;
#endif

/*FUNCTION*----------------------------------------------------------------
* 
* Function Name  : _usb_dci_vusb11_init
* Returned Value : USB_OK or error code
* Comments       :
*     Initializes the device layer, i.e. the VUSB, the VUSB DMA Buffer 
*     Descriptor Tables after which the VUSB device will be able to respond
*     to events on the bus. The initial
*     state for the USB device after initialization is the powered state.
* 
*END*--------------------------------------------------------------------*/
uint_8 _usb_dci_vusb11_init
   (
      /* [IN] handle to the usb device */
      _usb_device_handle handle
   )
{ /* Body */
   uint_32 i;
   
   USB_DEV_STATE_STRUCT_PTR usb_dev_ptr;
   
   usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;
   
   usb_dev_ptr->USB = (USB_STRUCT_PTR)_bsp_get_usb_base(usb_dev_ptr->DEV_NUM);
   usb_dev_ptr->ENDPT_REGS = (USB_REGISTER_PTR)((uint_32)usb_dev_ptr->USB + 
      0x40);
   
   usb_dev_ptr->USB_BDT_PAGE_BLOCK =
      USB_memalloc(sizeof(VUSB_ENDPOINT_BDT_STRUCT) * 
         usb_dev_ptr->MAX_ENDPOINTS * 2 * 2 + USB_BDT_ALIGN(1));
   if (usb_dev_ptr->USB_BDT_PAGE_BLOCK == NULL) {
      return USBERR_ALLOC;
   } /* Endif */
      
   usb_dev_ptr->USB_BDT_PAGE = (VUSB_ENDPOINT_BDT_STRUCT_PTR)
      USB_BDT_ALIGN((uint_32)&usb_dev_ptr->USB_BDT_PAGE_BLOCK[0]);
   
   /* 
   ** _usb_device_init initializes the USB interface.
   ** The BDTs are NOT intialized here. They
   ** are initialized as they are enabled.
   */

   /* disable the VUSB */
   usb_dev_ptr->USB->CONTROL = 0;
   /* mask all interupts */
   usb_dev_ptr->USB->INTENABLE = 0;
   /* Clear all interrupt */
   usb_dev_ptr->USB->INTSTATUS = 0xFF;

   /* mask no errors */
   usb_dev_ptr->USB->ERRORENABLE = 0xff;

   /* Current USB state (POWERED,DEFAULT,ADDRESS,CONFIG,SUSPEND) */
   usb_dev_ptr->USB_STATE = USB_STATE_POWERED;
   /* Current USB configuration selected */
   usb_dev_ptr->USB_CURR_CONFIG = 0;

   /* Set the Buffer Descriptor Table location in the USB regs */
   USB_SET_BDT_PAGE(usb_dev_ptr, usb_dev_ptr->USB_BDT_PAGE);

   /* disable all endpoints */
   for (i = 0; i < usb_dev_ptr->MAX_ENDPOINTS; i++) {
      usb_dev_ptr->ENDPT_REGS[i] = VUSB_ENDPT_DISABLE;
   } /* Endfor */

   /* reserve 2 bytes for a frame counter */
   usb_dev_ptr->USB_SOF_COUNT = 0xffff;

#ifndef __USB_OTG__

#ifdef __USB_OS_MQX__
   if (!(USB_install_isr(_bsp_get_usb_vector(usb_dev_ptr->DEV_NUM), 
      _usb_dci_vusb11_isr, (pointer)usb_dev_ptr)))
   {
      return USBERR_INSTALL_ISR;
   } /* Endbody */
#else
   USB_install_isr(_bsp_get_usb_vector(usb_dev_ptr->DEV_NUM), 
      _usb_dci_vusb11_isr, (pointer)usb_dev_ptr);
#endif /* USB_OS_MQX */

#endif /* USB_OTG */

   /* Reset the BDT Odd ping/pong bits to 0 */   
   usb_dev_ptr->USB->CONTROL = VUSB_CTL_ODD_RST;

   /* enable the USB */
   usb_dev_ptr->USB->CONTROL = VUSB_CTL_USB_EN;
   
   /* Init the service structure */
   usb_dev_ptr->SERVICE_HEAD_PTR = NULL;
   
   /* enable only bus reset interrupts at this point */
   usb_dev_ptr->USB->INTENABLE = VUSB_INT_ENABLE_RESET;

#ifndef __USB_OS_MQX__
   global_usb_device_state_struct_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;
#endif

   return USB_OK;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
* 
* Function Name  : _usb_dci_vusb11_isr
* Returned Value : None
* Comments       :
*     Catchall ISR for USB interrupts.  Handles all aspects of USB
*     interrupts.
* 
*END*--------------------------------------------------------------------*/
#ifndef __USB_OS_MQX__
DEVICE_INTERRUPT_ROUTINE_KEYWORD void _usb_dci_vusb11_isr
   (
      void
   )
#else
void _usb_dci_vusb11_isr
   (
      _usb_device_handle handle
   )
#endif
{ /* Body */
   XD_STRUCT_PTR                 pxd;
   BDT_STRUCT_PTR                temp_BDT_PTR;
   USB_DEV_STATE_STRUCT_PTR      usb_dev_ptr;
   uint_8                        direction, status, odd_even;
   uint_16                       wBytes;

#ifdef __USB_OS_MQX__
   usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;
#else
   usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)global_usb_device_state_struct_ptr;
#ifndef __USB_OTG__   
   IN_ISR = TRUE;
#endif
#endif
   
   while (TRUE) {
      /* clear error bits that we've seen */
      status = usb_dev_ptr->USB->ERRORSTATUS;
      usb_dev_ptr->USB->ERRORSTATUS = status;
      
      status = (usb_dev_ptr->USB->INTSTATUS & usb_dev_ptr->USB->INTENABLE);
      
      if (!status) {
         break;
      } /* Endif */
      
      direction = USB_REGISTER_STATUS_TXRX(usb_dev_ptr->USB);
      odd_even = USB_REGISTER_STATUS_ODDEVEN(usb_dev_ptr->USB);
      usb_dev_ptr->EP = USB_REGISTER_STATUS_ENDPOINT(usb_dev_ptr->USB);
      usb_dev_ptr->BDT_PTR = &usb_dev_ptr->USB_BDT_PAGE\
         [usb_dev_ptr->EP][direction][odd_even];
         
      wBytes = VUSB_GET_BC(usb_dev_ptr->BDT_PTR);
         
      /* Clear all enabled interrupts */
      usb_dev_ptr->USB->INTSTATUS = status;
         
      if (status & VUSB_INT_STAT_RESET) {
         /* A USB Bus Reset has occurred */
         _usb_dci_vusb11_bus_reset((_usb_device_handle)usb_dev_ptr);
         _usb_device_call_service((_usb_device_handle)usb_dev_ptr, 
            USB_SERVICE_BUS_RESET, 0, 0, 0, 0);
         /* Enqueue a recv buffer for receiving setup packet */
         usb_dev_ptr->XDRECV[0].SETUP_BUFFER_QUEUED = FALSE;
         usb_dev_ptr->XDSEND[0].SETUP_BUFFER_QUEUED = FALSE;
         _usb_device_recv_data((_usb_device_handle)usb_dev_ptr, 0, 
            (uchar_ptr)&usb_dev_ptr->XDRECV[0].SETUP_BUFFER, 8);
         usb_dev_ptr->XDRECV[0].SETUP_BUFFER_QUEUED = TRUE;
         usb_dev_ptr->XDSEND[0].SETUP_BUFFER_QUEUED = TRUE;
      } else if (status & VUSB_INT_STAT_TOKEN_DONE) {
         /* Usb Check For Suspend */
         if (usb_dev_ptr->BDT_PTR->REGISTER.BITMAP.PID == TOKEN_SETUP) {
            /* and the txd_suspend bit is set */
            if (usb_dev_ptr->USB->CONTROL & VUSB_CTL_TXD_SUSPEND) {
               
               temp_BDT_PTR = &usb_dev_ptr->USB_BDT_PAGE\
                  [usb_dev_ptr->EP][USB_SEND][0];
                  
               if (temp_BDT_PTR->REGISTER.BITMAP.OWNS) {
                  if (temp_BDT_PTR->REGISTER.BDTCTL & VUSB_BDT_STALL_BIT) {
                     temp_BDT_PTR->REGISTER.BDTCTL &= ~VUSB_BDT_STALL_BIT;
                     temp_BDT_PTR->REGISTER.BITMAP.OWNS = 0;
                  } /* Endif */
               } /* Endif */
               
               temp_BDT_PTR = &usb_dev_ptr->USB_BDT_PAGE\
                  [usb_dev_ptr->EP][USB_SEND][1];
                  
               if (temp_BDT_PTR->REGISTER.BITMAP.OWNS) {
                  if (temp_BDT_PTR->REGISTER.BDTCTL & VUSB_BDT_STALL_BIT) {
                     temp_BDT_PTR->REGISTER.BDTCTL &= ~VUSB_BDT_STALL_BIT;
                     temp_BDT_PTR->REGISTER.BITMAP.OWNS = 0;
                  } /* Endif */
               } /* Endif */
               
               /* Setup packet received so clear endpoint stall bit here in 
               ** case of a protcol stall 
               */
               
               usb_dev_ptr->ENDPT_REGS[usb_dev_ptr->EP] &= ~VUSB_EP_CTRL_STALL;
               usb_dev_ptr->XDSEND[usb_dev_ptr->EP].CTL &= ~VUSB_EP_CTRL_STALL;
               usb_dev_ptr->XDRECV[usb_dev_ptr->EP].CTL &= ~VUSB_EP_CTRL_STALL;
               
               /* dequeue any pending packets */
               if (usb_dev_ptr->XDSEND[usb_dev_ptr->EP].PACKETPENDING) {
                  _usb_device_cancel_transfer((_usb_device_handle)usb_dev_ptr, 
                     usb_dev_ptr->EP, USB_SEND);
               } /* Endif */
               
               /* clear the txd_suspend bit */
               usb_dev_ptr->USB->CONTROL &= ~VUSB_CTL_TXD_SUSPEND;
            } /* Endif */
         } /* Endif */
         
         if (direction == USB_SEND) {
            pxd = &usb_dev_ptr->XDSEND[usb_dev_ptr->EP];
         } else {
            pxd = &usb_dev_ptr->XDRECV[usb_dev_ptr->EP];
         } /* Endif */

         pxd->SOFAR += wBytes;
         pxd->UNACKNOWLEDGEDBYTES -= wBytes;
         
         if ((usb_dev_ptr->BDT_PTR->REGISTER.BITMAP.PID == TOKEN_SETUP) ||
            (!(pxd->CTL & VUSB_ENDPT_HSHK_BIT)))
         {

            /* clear endpoint stall bit here in case of a protcol stall */
            usb_dev_ptr->ENDPT_REGS[0] &= ~VUSB_EP_CTRL_STALL;
            
            /*
            ** Setup packets always arrive in their entirety, as they're only 8
            ** bytes and require no terminating null.  The same is true for
            ** isochronous endpoints (which don't even get acknowledgements).
            */
            /* The transfer has completed.  Reset the XD. */
            VUSB_CLEAR_CURRENT_BDT(usb_dev_ptr->BDT_PTR, pxd);
            if (pxd->PACKETPENDING) {
               /*
               ** Any remaining BDT should be removed, as it's not needed to
               ** complete this transaction.
               */
               VUSB_CLEAR_OTHER_BDT(usb_dev_ptr->BDT_PTR, pxd);
            } /* Endif */
            
            pxd->BDTCTL = 0;
            pxd->STATUS = USB_STATUS_IDLE;
            _usb_device_call_service((_usb_device_handle)usb_dev_ptr, 
               usb_dev_ptr->EP,
               /* If we have handshakes, it is a control endpoint -> setup */
               ((pxd->CTL & VUSB_ENDPT_HSHK_BIT) ? 1 : 0),
               direction, pxd->STARTADDRESS, pxd->SOFAR);
               
            /* Check if its Isochronous packet or Setup packet */
            if (pxd->CTL & VUSB_ENDPT_HSHK_BIT) {
               pxd->SETUP_BUFFER_QUEUED = FALSE;
               
               if (direction == USB_SEND) {
                  usb_dev_ptr->XDRECV[usb_dev_ptr->EP].SETUP_BUFFER_QUEUED = 
                     FALSE;
               } else {
                  usb_dev_ptr->XDSEND[usb_dev_ptr->EP].SETUP_BUFFER_QUEUED = 
                     FALSE;
               } /* Endif */
         
               /* Enqueue a recv buffer for receiving setup packet */
               _usb_device_recv_data((_usb_device_handle)usb_dev_ptr, 
                  usb_dev_ptr->EP,
                  (uchar_ptr)&usb_dev_ptr->XDRECV[usb_dev_ptr->EP].SETUP_BUFFER,\
                  8);
               pxd->SETUP_BUFFER_QUEUED = TRUE;
               
               if (direction == USB_SEND) {
                  usb_dev_ptr->XDRECV[usb_dev_ptr->EP].SETUP_BUFFER_QUEUED = 
                     TRUE;
               } else {
                  usb_dev_ptr->XDSEND[usb_dev_ptr->EP].SETUP_BUFFER_QUEUED = 
                     TRUE;
               } /* Endif */
            } /* Endif */
         } else if (usb_dev_ptr->BDT_PTR->BC == pxd->MAXPACKET) {
            VUSB_CLEAR_CURRENT_BDT(usb_dev_ptr->BDT_PTR, pxd);
            /*
            ** If there is still data for which a BDT has not been sent, we must
            ** send another BDT.  This includes zero-length BDTs on non-control
            ** endpoints for transactions that are a multiple of the endpoint's
            ** max packet size.
            */
            if (pxd->TODO || pxd->MUSTSENDNULL) {
               pxd->STATUS = USB_STATUS_TRANSFER_IN_PROGRESS;
               _usb_dci_vusb11_submit_BDT(usb_dev_ptr->BDT_PTR, pxd);
            } else if (pxd->PACKETPENDING  && pxd->UNACKNOWLEDGEDBYTES) {
               pxd->STATUS = USB_STATUS_TRANSFER_IN_PROGRESS;
            } else { 
               pxd->BDTCTL = 0;
               pxd->STATUS = USB_STATUS_IDLE;
            
               _usb_device_call_service((_usb_device_handle)usb_dev_ptr, 
                  usb_dev_ptr->EP, 0, direction, pxd->STARTADDRESS, pxd->SOFAR);
            } /* Endif */
         } else if (usb_dev_ptr->BDT_PTR->BC < pxd->MAXPACKET) {
            /*
            ** If we have received a short packet, the transaction is complete
            ** regardless of endpoint or the expected size.
            */
            VUSB_CLEAR_CURRENT_BDT(usb_dev_ptr->BDT_PTR, pxd);
            
            if (pxd->PACKETPENDING) {
               /*
               ** Any remaining BDT should be removed, as it's not needed to
               ** complete this transaction.
               */
               VUSB_CLEAR_OTHER_BDT(usb_dev_ptr->BDT_PTR, pxd);
            } /* Endif */
            
            pxd->BDTCTL = 0;
            pxd->STATUS = USB_STATUS_IDLE;
            
            _usb_device_call_service((_usb_device_handle)usb_dev_ptr, 
               usb_dev_ptr->EP, 0, direction, pxd->STARTADDRESS, pxd->SOFAR);
            
            if (pxd->TYPE == USB_CONTROL_ENDPOINT) {
               /* protocol stall - stall the other BD */
                  temp_BDT_PTR = VUSB_TOGGLE_BDT(usb_dev_ptr->BDT_PTR);
                  temp_BDT_PTR->REGISTER.BDTCTL = VUSB_BDT_STALL_BIT;
                  temp_BDT_PTR->REGISTER.BITMAP.OWNS = 1;
               if ((!direction) && (!wBytes)) {
                  pxd->CTL |= VUSB_EP_CTRL_STALL;
                  pxd->SETUP_BUFFER_QUEUED = FALSE;
                  usb_dev_ptr->XDSEND[usb_dev_ptr->EP].SETUP_BUFFER_QUEUED = 
                     FALSE;
                  /* Enqueue a recv buffer for receiving setup packet */
                  _usb_device_recv_data((_usb_device_handle)usb_dev_ptr, 
                     usb_dev_ptr->EP, (uchar_ptr)&pxd->SETUP_BUFFER, 8);
                  pxd->SETUP_BUFFER_QUEUED = TRUE;
                  usb_dev_ptr->XDSEND[usb_dev_ptr->EP].SETUP_BUFFER_QUEUED = 
                     TRUE;
               } /* Endif */
            } /* Endif */
            
         } /* Endif */
      } /* Endif */ 
      
      if (status & VUSB_INT_STAT_RESUME) {
         _usb_device_call_service((_usb_device_handle)usb_dev_ptr, 
            USB_SERVICE_RESUME, 0 , 0, NULL, 0);
      }  /* Endif */
      
      if (status & VUSB_INT_STAT_SOF) {
         _usb_device_call_service((_usb_device_handle)usb_dev_ptr, 
            USB_SERVICE_SOF, 0 , 0, NULL, 0);
      }  /* Endif */
      
      if (status & VUSB_INT_STAT_SLEEP) {
         _usb_device_call_service((_usb_device_handle)usb_dev_ptr, 
            USB_SERVICE_SLEEP, 0 , 0, NULL, 0);
      } /* Endif */ 
      
      if (status & VUSB_INT_STAT_ERROR) {
         _usb_device_call_service((_usb_device_handle)usb_dev_ptr, 
            USB_SERVICE_ERROR, 0 , 0, NULL, usb_dev_ptr->USB->ERRORSTATUS);
      } /* Endif */
      
      if (status & VUSB_INT_STAT_STALL) {
         _usb_device_call_service((_usb_device_handle)usb_dev_ptr, 
            USB_SERVICE_STALL, 0 , 0, NULL, 
            (usb_dev_ptr->USB->INTSTATUS & VUSB_INT_STAT_STALL));
      } /* Endif */
      
   } /* Endwhile */

#ifndef __USB_OS_MQX__
#ifndef __USB_OTG__
   IN_ISR = FALSE;
#endif   
#endif

} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
* 
* Function Name  : _usb_dci_vusb11_submit_BDT
* Returned Value : None
* Comments       :
*     Submits a BDT (along with packet buffer) to the VUSB.
* 
*END*--------------------------------------------------------------------*/
void _usb_dci_vusb11_submit_BDT
   (
      /* [IN] Pointer to the BDT to be released to the VUSB */
      BDT_STRUCT_PTR pBDT,
      
      /* [IN] Pointer to the transfer descriptor (XD) for this BDT */
      XD_STRUCT_PTR pxd
   )
{ /* Body */
   uint_16 wActualBytes;
   BDT_STRUCT pid;

   pxd->NEXTODDEVEN = VUSB_TOGGLE_BIT(pxd->NEXTODDEVEN);

   VUSB_SET_ADDRESS(pBDT, pxd->NEXTADDRESS);

   /* Use the specified size */
   wActualBytes = pxd->TODO;
   if (pxd->TODO > pxd->MAXPACKET) {
      /* Unless we can't.  Then just use max packet size */
      wActualBytes = pxd->MAXPACKET;
   } /* Endif */

   /* compute the BDT */
   /* Copy everything from the XD */
   pid.REGISTER.BDTCTL = pxd->BDTCTL;
   /* Set Data Toggle Synch */
   pid.REGISTER.BDTCTL |= VUSB_BDT_DTS_BIT;
   /* Sumbit the BDT */
   pid.REGISTER.BITMAP.OWNS = 1;

   /* if DATA01 is clear */
   if ((pxd->BDTCTL & VUSB_BDT_DATA01_BIT) == 0) {
      /* get value from bNextData01 */
      pid.REGISTER.BITMAP.DATA01 = pxd->NEXTDATA01;
   } /* Endif */

   /* clear DATA01 flag so we'll use bNextData01 next time */
   pxd->BDTCTL &= ~VUSB_BDT_DATA01_BIT;

   /* toggle bit for next packet */
   pxd->NEXTDATA01 = VUSB_TOGGLE_BIT(pid.REGISTER.BITMAP.DATA01);

   /* inc count of packets queued */
   pxd->PACKETPENDING++;

   /* Default is not to terminate with a null packet. */
   pxd->MUSTSENDNULL = FALSE;

   /*
   ** if it is not an ISO endpoint
   ** check if we need to 
   ** terminate with a null packet
   */
   if (pxd->CTL & VUSB_ENDPT_HSHK_BIT) {
      if (pxd->TODO == pxd->MAXPACKET) {
         /* Don't set the MUSTSENDNULL if it is a Setup packet */
         if (((pxd->TYPE != USB_CONTROL_ENDPOINT) && 
            (!pxd->DONT_ZERO_TERMINATE)) || 
            ((pxd->TYPE == USB_CONTROL_ENDPOINT) &&  
            (pxd->SETUP_BUFFER_QUEUED))) 
         {
            pxd->MUSTSENDNULL = TRUE;
         } /* Endif */
      } /* Endif */
   } /* Endif */

   pxd->NEXTADDRESS += wActualBytes;
   pxd->TODO -= wActualBytes;

   /* Actually write the BDT PID/DATA01/OWNS/BC data */
   VUSB_SET_BC(pBDT, wActualBytes);
   VUSB_COPY_OWN_DATA_PID(pBDT, &pid);

   return;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
* 
* Function Name  : _usb_dci_vusb11_read_setup
* Returned Value : None
* Comments       :
*     Reads the setup packet into the buffer provided by the user.
* 
*END*--------------------------------------------------------------------*/
void _usb_dci_vusb11_read_setup
   (
      /* [IN] Handle to the USB device */
      _usb_device_handle      handle,

      /* [IN] the Endpoint number */      
      uint_8                  ep_num,
            
      /* [IN] buffer for receiving Setup packet */
      uchar_ptr               buff_ptr
   )
{ /* Body */
   USB_DEV_STATE_STRUCT_PTR usb_dev_ptr;
   
   usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;
   
   /* Copy the setup packet from the BD to the user's buffer */
   USB_memcopy((uchar_ptr)usb_dev_ptr->BDT_PTR->ADDRESS, buff_ptr, 8);
   
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
* 
* Function Name  : _usb_dci_vusb11_submit_transfer
* Returned Value : None
* Comments       :
*     Submits a prepared transfer to the VUSB
* 
*END*--------------------------------------------------------------------*/
void _usb_dci_vusb11_submit_transfer
   (
      /* [IN] Handle to the USB device */
      _usb_device_handle handle,
      
      /* [IN] Direction of transfer.  Is it transmit? */
      uint_8             direction,
      
      /* [IN] Endpoint to submit transfer on */
      uint_8             ep
   )
{ /* Body */
   USB_DEV_STATE_STRUCT_PTR usb_dev_ptr;
   XD_STRUCT_PTR pxd;
   
   usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;
   
   if (direction == USB_SEND) {
      pxd = &usb_dev_ptr->XDSEND[ep];
   } else { 
      pxd = &usb_dev_ptr->XDRECV[ep];
   } /* Endif */
   
   if (pxd->TYPE == USB_CONTROL_ENDPOINT) {
      if ((pxd->CTL & VUSB_EP_CTRL_STALL) && (!direction)) {
         pxd->BDTCTL = (VUSB_BDT_DATA01_BIT | VUSB_EP_CTRL_STALL);
      } else {
         pxd->BDTCTL = VUSB_BDT_DATA01_BIT;
      } /* Endif */
   } else { 
      pxd->BDTCTL = 0;
   } /* Endif */
   
   /* Set the owns bit in the transfer descriptor */
   pxd->BDTCTL |= VUSB_BDT_OWNS_BIT;
   
   _usb_dci_vusb11_submit_BDT(
      &usb_dev_ptr->USB_BDT_PAGE[ep][direction][pxd->NEXTODDEVEN & 1], pxd);
      
   if (pxd->TODO || pxd->MUSTSENDNULL) {
      _usb_dci_vusb11_submit_BDT(
         &usb_dev_ptr->USB_BDT_PAGE[ep][direction][pxd->NEXTODDEVEN & 1], pxd);
   } /* Endif */
   
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
* 
* Function Name  : _usb_dci_vusb11_bus_reset
* Returned Value : None
* Comments       :
*     Called when a USB bus reset is asserted by the host
* 
*END*--------------------------------------------------------------------*/
void _usb_dci_vusb11_bus_reset
   (
      /* [IN] Handle to the USB device */
      _usb_device_handle handle
   )
{ /* Body */
   USB_DEV_STATE_STRUCT_PTR   usb_dev_ptr;
   uchar                      i;

   usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;
   
   /* saw a USB Bus Reset
   **
   ** we got the USB RESET indication. We simply need to go to the
   ** DEFAULT state and enable endpoint 0 at addr 0.
   ** First, assign EP0 an RX buffer
   */

   /* Reset BDT page. */
   USB_memzero(usb_dev_ptr->USB_BDT_PAGE, sizeof(VUSB_ENDPOINT_BDT_STRUCT) *
      usb_dev_ptr->MAX_ENDPOINTS * 2 * 2);

   usb_dev_ptr->USB_STATE = USB_STATE_DEFAULT;
   /* Current USB configuration is reset back to zero */
   usb_dev_ptr->USB_CURR_CONFIG = 0;

   /*
   ** These are special hardware writes that clear the status FIFO which
   ** is four bytes deep.
   **
   ** clear pending token done
   */
   usb_dev_ptr->USB->INTSTATUS = VUSB_INT_STAT_TOKEN_DONE;
   usb_dev_ptr->USB->INTSTATUS = VUSB_INT_STAT_TOKEN_DONE;
   usb_dev_ptr->USB->INTSTATUS = VUSB_INT_STAT_TOKEN_DONE;
   usb_dev_ptr->USB->INTSTATUS = VUSB_INT_STAT_TOKEN_DONE;

   /* USB addr=0 (default) */
   usb_dev_ptr->USB->ADDRESS = 0;
   
   /* clear the BDT ODD bits in the VUSB and keep VUSB enabled */
   usb_dev_ptr->USB->CONTROL = (VUSB_CTL_ODD_RST | VUSB_CTL_USB_EN);
   
   USB_memzero((uchar_ptr)usb_dev_ptr->XDSEND, 
      sizeof(XD_STRUCT) * usb_dev_ptr->MAX_ENDPOINTS);

   USB_memzero((uchar_ptr)usb_dev_ptr->XDRECV, 
      sizeof(XD_STRUCT) * usb_dev_ptr->MAX_ENDPOINTS);

   for (i = 0; i < usb_dev_ptr->MAX_ENDPOINTS; i++) {
      /*
      ** initialize the endpoint status of all endpoints to Disabled
      ** on Bus reset.
      */
      usb_dev_ptr->XDSEND[i].STATUS = USB_STATUS_DISABLED;
      usb_dev_ptr->XDRECV[i].STATUS = USB_STATUS_DISABLED;
   } /* Endfor */
   
   /* enable the VUSB */
   usb_dev_ptr->USB->CONTROL = VUSB_CTL_USB_EN;

   /*
   ** enable all ints
   */
    usb_dev_ptr->USB->INTENABLE = 0xFF; 

   return;
} /* Endbody */

/*FUNCTION*----------------------------------------------------------------
* 
* Function Name  : _usb_dci_vusb11_init_endpoint
* Returned Value : None
* Comments       :
*     Sets the endpoint registers e.g. to enable TX, RX, control
* 
*END*--------------------------------------------------------------------*/
void _usb_dci_vusb11_init_endpoint
   (
      /* [IN] Handle to the USB device */
      _usb_device_handle   handle,
            
      /* [IN] the endpoint number */
      uint_8               ep,
      
      /* [IN] The transfer descriptor for this endpoint */
      XD_STRUCT_PTR        pxd
   )
{ /* Body */
      USB_DEV_STATE_STRUCT_PTR usb_dev_ptr;
      
      usb_dev_ptr = (USB_DEV_STATE_STRUCT_PTR)handle;
      
      switch (pxd->TYPE) {
         case USB_ISOCHRONOUS_ENDPOINT:
            pxd->CTL = VUSB_ENDPT_ISO_BIDIR;
            usb_dev_ptr->ENDPT_REGS[ep] = VUSB_ENDPT_ISO_BIDIR;
            break;
         case USB_INTERRUPT_ENDPOINT:
            pxd->CTL = VUSB_ENDPT_BULK_BIDIR;
            usb_dev_ptr->ENDPT_REGS[ep] = VUSB_ENDPT_BULK_BIDIR;
            break;
         case USB_CONTROL_ENDPOINT:
            pxd->CTL = VUSB_ENDPT_CONTROL;
            usb_dev_ptr->ENDPT_REGS[ep] = VUSB_ENDPT_CONTROL;
            break;
         case USB_BULK_ENDPOINT:
            pxd->CTL = VUSB_ENDPT_BULK_BIDIR;
            usb_dev_ptr->ENDPT_REGS[ep] = VUSB_ENDPT_BULK_BIDIR;
         default:
            break;
      } /* Endswitch */
      
} /* EndBody */

/* EOF */