/*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: vusbh11.c
***
*** Comments:      
***   This file contains the low-level Host API functions specific to the VUSB 
***   chip.
***                                                               
**************************************************************************
*END*********************************************************************/
#ifdef __USB_OS_MQX__
#include "mqx.h"
#include "bsp.h"
#else
#include "types.h"
#include "vusb11.h"
#include "usb.h"
#include "hostapi.h"
#endif
#include "usbhprv.h"
#include "usbprv.h"

#ifndef __USB_OS_MQX__
extern volatile boolean IN_ISR;
#endif


/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_hci_vusb11_send_data
*  Returned Value : None
*  Comments       :
*        Send the data
*END*-----------------------------------------------------------------*/

void _usb_hci_vusb11_send_data
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle,

      /* The pipe descriptor to queue */            
      PIPE_DESCRIPTOR_STRUCT_PTR     pipe_descr_ptr
   )
{ /* Body */
   _usb_host_queue_pkts(handle, pipe_descr_ptr);
} /* EndBody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_hci_vusb11_send_setup
*  Returned Value : None
*  Comments       :
*        Send Setup packet
*END*-----------------------------------------------------------------*/

void _usb_hci_vusb11_send_setup
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle,

      /* The pipe descriptor to queue */            
      PIPE_DESCRIPTOR_STRUCT_PTR     pipe_descr_ptr
   )
{ /* Body */
   _usb_host_queue_pkts(handle, pipe_descr_ptr);
} /* EndBody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_hci_vusb11_recv_data
*  Returned Value : None
*  Comments       :
*        Receive data
*END*-----------------------------------------------------------------*/

void _usb_hci_vusb11_recv_data
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle,

      /* The pipe descriptor to queue */            
      PIPE_DESCRIPTOR_STRUCT_PTR     pipe_descr_ptr
   )
{ /* Body */
   _usb_host_queue_pkts(handle, pipe_descr_ptr);
} /* EndBody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_hci_vusb11_cancel_transfer
*  Returned Value : None
*  Comments       :
*        Cancel a transfer
*END*-----------------------------------------------------------------*/

void _usb_hci_vusb11_cancel_transfer
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle,

      /* The pipe descriptor to queue */            
      PIPE_DESCRIPTOR_STRUCT_PTR     pipe_descr_ptr
   )
{ /* Body */
   /* Cancel the transaction at hardware level if required */
} /* EndBody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_set_bdt_page
*  Returned Value : None
*  Comments       :
*        Initialize the VUSB BDT Page register
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_set_bdt_page
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle
   )
{ /* Body */
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   usb_host_ptr->DEV_PTR->BDTPAGE1   =  
      (((uint_32)usb_host_ptr->USB_BDT_PAGE) >> 8);
   usb_host_ptr->DEV_PTR->BDTPAGE2  =  
      (((uint_32)usb_host_ptr->USB_BDT_PAGE) >> 16);
   usb_host_ptr->DEV_PTR->BDTPAGE3  =  
      (((uint_32)usb_host_ptr->USB_BDT_PAGE) >> 24);
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_get_next_in_bdt
*  Returned Value : Address of the next IN BDT to use
*  Comments       :
*        Get the address of the next IN BDT
*END*-----------------------------------------------------------------*/

HOST_BDT_STRUCT_PTR _usb_host_vusb11_get_next_in_bdt
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle
   )
{ /* Body */                                   
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   
   usb_host_ptr->USB_IN ^= VUSB_BDT_ODD_EVEN_BIT;
   
   return ((HOST_BDT_STRUCT_PTR)((uint_32)usb_host_ptr->USB_BDT_PAGE | 
      usb_host_ptr->USB_IN));
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_get_next_out_bdt
*  Returned Value : Address of the next OUT BDT to use
*  Comments       :
*        Get the address of the next OUT BDT
*END*-----------------------------------------------------------------*/

HOST_BDT_STRUCT_PTR _usb_host_vusb11_get_next_out_bdt
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle
   )
{ /* Body */                                   
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   
   /* toggle odd/even and use result */   
   usb_host_ptr->USB_OUT ^= VUSB_BDT_ODD_EVEN_BIT;
   /* create pointer to current out bdt */
   
   return ((HOST_BDT_STRUCT_PTR)((uint_32)usb_host_ptr->USB_BDT_PAGE | 
      usb_host_ptr->USB_OUT));
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_sched_pending_pkts
*  Returned Value : None
*  Comments       :
*        Schedule the pending packets based on the types (not for isochronous 
*  packets)
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_sched_pending_pkts
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle           handle
   )
{ /* Body */
   PIPE_DESCRIPTOR_STRUCT_PTR pipe_descr_ptr, temp;
   uint_8 i;
   boolean sched_int_pipe, sched_ctrl_pipe, sched_bulk_pipe;
   
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   /* Schedule two transfers if they are on different pipes */
   for (i=0;i<2;i++) {
      /* Check if packets are pending on any of the queue types in the order 
      ** as follows: 
      */
      if (usb_host_ptr->CURRENT_INTR_HEAD != -1) {
         pipe_descr_ptr = 
            &usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR\
            [usb_host_ptr->CURRENT_INTR_HEAD];
		   if (!pipe_descr_ptr->CURRENT_INTERVAL) {
		      sched_int_pipe = TRUE;
            pipe_descr_ptr->CURRENT_INTERVAL = pipe_descr_ptr->INTERVAL;
		   } else {
		      sched_int_pipe = FALSE;
		   } /* Endif */
      } else if (usb_host_ptr->CURRENT_CTRL_HEAD != -1) {
         pipe_descr_ptr = 
            &usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR\
            [usb_host_ptr->CURRENT_CTRL_HEAD];
		   if (!pipe_descr_ptr->CURRENT_INTERVAL) {
		      sched_ctrl_pipe = TRUE;
		   } else {
		      sched_ctrl_pipe = FALSE;
		   } /* Endif */
      } else if (usb_host_ptr->CURRENT_BULK_HEAD != -1) {
         pipe_descr_ptr = 
            &usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR\
            [usb_host_ptr->CURRENT_BULK_HEAD];
		   if (!pipe_descr_ptr->CURRENT_INTERVAL) {
		      sched_bulk_pipe = TRUE;
		   } else {
		      sched_bulk_pipe = FALSE;
		   } /* Endif */
      } /* Endif */

      if ((usb_host_ptr->CURRENT_INTR_HEAD != -1) && (sched_int_pipe)) {
         pipe_descr_ptr = 
            &usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR\
            [usb_host_ptr->CURRENT_INTR_HEAD];
      } else if ((usb_host_ptr->CURRENT_CTRL_HEAD != -1) && (sched_ctrl_pipe)) {
         pipe_descr_ptr = 
            &usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR\
            [usb_host_ptr->CURRENT_CTRL_HEAD];
      } else if ((usb_host_ptr->CURRENT_BULK_HEAD != -1) && (sched_bulk_pipe)) {
         pipe_descr_ptr = 
            &usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR\
            [usb_host_ptr->CURRENT_BULK_HEAD];
      } else {
         break;
      } /* Endif */
      
      /* Initiate the appropriate transfer and update the current head of the 
      ** respective pipe 
      */
      if (!(i && (temp == pipe_descr_ptr))) {
         temp = pipe_descr_ptr;
         _usb_host_vusb11_initiate_correct_bdt(handle, pipe_descr_ptr);
         _usb_host_update_current_head(handle, pipe_descr_ptr->PIPETYPE);
      } /* Endif */
      
   } /* Endfor */
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_sched_iso_pkts
*  Returned Value : None
*  Comments       :
*        Schedule the pending Isochronous packets
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_sched_iso_pkts
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle           handle
   )
{ /* Body */
   PIPE_DESCRIPTOR_STRUCT_PTR pipe_descr_ptr, temp;
   uint_8 i;
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   /* Schedule 2 transfers if they are on different pipes */
   for (i=0;i<2;i++) {
      if (usb_host_ptr->CURRENT_ISO_HEAD != -1) {
         pipe_descr_ptr = 
            &usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR\
            [usb_host_ptr->CURRENT_ISO_HEAD];
         /* Initiate the appropriate transfer and update the current head for 
         ** that pipe type queue 
         */
         if (!(i && (temp == pipe_descr_ptr))) {
            temp = pipe_descr_ptr;
            _usb_host_vusb11_initiate_correct_bdt(handle, pipe_descr_ptr);
            _usb_host_update_current_head(handle, pipe_descr_ptr->PIPETYPE);
         } /* Endif */
      } else {
         break;
      } /* Endif */
   } /* Endfor */
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_initiate_correct_bdt
*  Returned Value : None
*  Comments       :
*        Initiate the correct BDT while scheduling
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_initiate_correct_bdt
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle                  handle,
            
      /* [IN] the pipe descriptor address */
      PIPE_DESCRIPTOR_STRUCT_PTR        pipe_descr_ptr
   )
{ /* Body */

   /* Check if a packet is pending on this pipe */   
   if (pipe_descr_ptr->PACKETPENDING) {
      if (pipe_descr_ptr->PIPETYPE == USB_CONTROL_PIPE) {
         if (pipe_descr_ptr->FIRST_PHASE) {
            _usb_host_vusb11_init_setup_bdt(handle, pipe_descr_ptr);
         } else {
            if (pipe_descr_ptr->SEND_PHASE) {
               if (!pipe_descr_ptr->TODO2) { /* Complete */
                  /* Setup transaction complete. Send an opposite 
                  ** direction token on Data1 
                  */
                  _usb_host_vusb11_send_in_token(handle, pipe_descr_ptr);
               } else { /* partial */
                  /* Setup transaction not complete. Send more data */
                  _usb_host_vusb11_send_out_token(handle, pipe_descr_ptr);
               } /* Endif */
            } else {
               if (!pipe_descr_ptr->TODO1) { /* Complete */
                  /* Setup transaction complete. Send an opposite 
                  ** direction token on Data1 
                  */
                  _usb_host_vusb11_send_out_token(handle, pipe_descr_ptr);
               } else { /* partial */
                  _usb_host_vusb11_send_in_token(handle, pipe_descr_ptr);
               } /* Endif */
            } /* Endif */
         } /* Endif */
      } else { 
         if (pipe_descr_ptr->DIRECTION == USB_SEND) {
            _usb_host_vusb11_init_send_bdt(handle, pipe_descr_ptr);
         } else {
            _usb_host_vusb11_init_recv_bdt(handle, pipe_descr_ptr);
         } /* Endif */
      } /* Endif */
   } /* Endif */
} /* EndBody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_hci_vusb11_isr
*  Returned Value : None
*  Comments       :
*        Service all the interrupts in the VUSB1.1 hardware
*END*-----------------------------------------------------------------*/

#ifdef __USB_OS_MQX__
void _usb_hci_vusb11_isr
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle
   )
#else
void HOST_INTERRUPT_ROUTINE_KEYWORD _usb_hci_vusb11_isr
   (
      void
   )
#endif
{ /* Body */
   uint_8 status_flag = 0, direction;
   PIPE_DESCRIPTOR_STRUCT_PTR pipe_descr_ptr = NULL;
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   uint_32  status, error_status;
   
#ifdef __USB_OS_MQX__
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
#else
#ifndef __USB_OTG__
   IN_ISR = TRUE;
#endif
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)usb_host_state_struct_ptr;
#endif

   /* We use a while loop to process all the interrupts while we are in the 
   ** loop so that we don't miss any interrupts 
   */
   while (TRUE) {

      /* Check the error status */
      error_status = (usb_host_ptr->DEV_PTR->ERRORSTATUS & 
         usb_host_ptr->DEV_PTR->ERRORENABLE);
      
      /* Clear the errors */   
      usb_host_ptr->DEV_PTR->ERRORSTATUS = error_status;

      /* Check if any of the enabled interrupts are asserted */
      status = (usb_host_ptr->DEV_PTR->INTSTATUS & 
         usb_host_ptr->DEV_PTR->INTENABLE);
         
      if (!status) {
         /* No more interrupts pending to be serviced */
         break;
      } /* Endif */

      /* Get the direction of the transfer */      
      direction = ((usb_host_ptr->DEV_PTR->STATUS >> VUSB_STAT_DIRECTION_BIT) & 
         0x01);
      
      /* Clear all enabled interrupts */
      usb_host_ptr->DEV_PTR->INTSTATUS = status;

      /* Check if Reset interrupt */      
      if (status & VUSB_INT_STAT_RESET) {
         usb_host_ptr->DEV_PTR->INTENABLE = (VUSB_INT_ENB_ATTACH | 
            VUSB_INT_ENB_SOF_TOK);
         usb_host_ptr->DEV_PTR->CONTROL = VUSB_CTRL_HOST_MODE_EN;
         _usb_host_vusb11_process_attach((pointer)usb_host_ptr);
      } else {
         /* Check if token done interrupt */      
         if (status & VUSB_INT_STAT_TOKEN_DONE) {
            usb_host_ptr->USB_PKT_PENDING--;
            usb_host_ptr->SND_TOK_IN_PROGRESS = FALSE;
            _usb_host_vusb11_process_token_done((pointer)usb_host_ptr, 
               direction, error_status);
            /* If there are no packet being processed then schedule any other 
            ** pending packets (except the isochronous transactions) 
            */
            if ((!usb_host_ptr->SND_TOK_IN_PROGRESS) && 
               !(status & VUSB_INT_STAT_TOKEN_DONE)) 
            {
               _usb_host_vusb11_sched_pending_pkts((pointer)usb_host_ptr);
            } /* Endif */
            
         } /* Endif */
         
         if (status & VUSB_INT_STAT_SOF) {
            /* Schedule Isochronous transfer everytime there is a SOF 
            ** interrupt 
            */
            if (!usb_host_ptr->SND_TOK_IN_PROGRESS) {
               _usb_host_vusb11_sched_iso_pkts((pointer)usb_host_ptr);
            } /* Endif */
            
            /* Update the current interval on the interrupt pipes if any on the 
            ** interrupt pipe queue
            */
            _usb_host_update_interval_for_pipes((pointer)usb_host_ptr);
            
            if (!usb_host_ptr->SND_TOK_IN_PROGRESS) {
               _usb_host_vusb11_sched_pending_pkts((pointer)usb_host_ptr);
            } /* Endif */
         } /* Endif */

         /* Check if attach interrupt */      
         if (status & VUSB_INT_STAT_ATTACH) {
            _usb_host_vusb11_process_attach((pointer)usb_host_ptr);
         } /* Endif */
         
         if (status & VUSB_INT_STAT_RESUME) {
            /* Call the callback function if there was one registered for 
            ** the remote-wakeup/resume 
            */
            usb_host_ptr->DEV_PTR->INTENABLE &= ~VUSB_INT_ENB_RESUME;
            _usb_host_call_service(usb_host_ptr, USB_SERVICE_HOST_RESUME, 0);
         } /* Endif */
         
      } /* Endif */
   } /* EndWhile */

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

} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_hci_vusb11_init
*  Returned Value : error or USB_OK
*  Comments       :
*        Initialize the VUSB1.1 hardware
*END*-----------------------------------------------------------------*/

uint_8  _usb_hci_vusb11_init
   (
      /* the USB Host State structure */
      _usb_host_handle     handle
   )
{ /* Body */
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   uint_8   vector;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   /* Allocate memory for the Buffer descriptor table */   
   usb_host_ptr->USB_BDT_PAGE_BASE = 
      (HOST_BDT_STRUCT_PTR)USB_memalloc((sizeof(HOST_BDT_STRUCT) * 2 * 2) + 512);
      
   if (usb_host_ptr->USB_BDT_PAGE_BASE == NULL) {
      return USBERR_ALLOC_BD_TABLE;
   } /* Endif */

   /* Align the BDT page on a 512 byte boundary */      
   usb_host_ptr->USB_BDT_PAGE = (HOST_BDT_STRUCT_PTR)USB_MEM512_ALIGN\
      ((uint_32)usb_host_ptr->USB_BDT_PAGE_BASE);
      
   /* Get the base address of the VUSB registers */
   usb_host_ptr->DEV_PTR = 
      (USB_STRUCT_PTR)_bsp_get_usb_base(usb_host_ptr->DEV_NUM);

   /* The address of the endpoint registers */      
   usb_host_ptr->ENDPT_HOST_RG = ((uchar_ptr)usb_host_ptr->DEV_PTR + 
      VUSB_ENDPT_REG_OFFSET);
   
   *usb_host_ptr->ENDPT_HOST_RG = VUSB_ENDPT_DISABLE;
   usb_host_ptr->DEV_PTR->CONTROL = 0x00;        /* Disable VUSB */
   usb_host_ptr->DEV_PTR->INTENABLE = 0x00; /* Mask all interupts */
   usb_host_ptr->DEV_PTR->INTSTATUS = 0xFF;   /* Clear all interupts */
   usb_host_ptr->DEV_PTR->CONTROL = VUSB_CTRL_ODD_RST;
   usb_host_ptr->DEV_PTR->ADDRESS = 0;

   /* Set the Buffer Descriptor Table address */
   _usb_host_vusb11_set_bdt_page(handle);
   
   /* Get the interrupt vector number for the VUSB host */
   vector = _bsp_get_usb_vector(usb_host_ptr->DEV_NUM);

#ifndef __USB_OTG__

#ifdef __USB_OS_MQX__
   if (!(USB_install_isr(vector, _usb_hci_vusb11_isr, (pointer)usb_host_ptr))) {
      return USBERR_INSTALL_ISR;
   } /* Endbody */
#else
   USB_install_isr(vector, _usb_hci_vusb11_isr, 
      (pointer)usb_host_ptr);
#endif /* USB_OS_MQX */

#endif /* ARC_USB_OTG */

   /* Enable the host mode */   
   usb_host_ptr->DEV_PTR->CONTROL = VUSB_CTRL_HOST_MODE_EN;

   /* Typical value for 64 bytes packets is 74 so we keep enough time for 
   ** the transaction to complete 
   */
   usb_host_ptr->DEV_PTR->SOFTHRESHOLDLO = 74;
   
   /* Enable Attach interrupt only */                                          
   usb_host_ptr->DEV_PTR->INTENABLE = VUSB_INT_ENB_ATTACH;
   
   return USB_OK;
   
} /* EndBody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_delay
*  Returned Value : None
*  Comments       :
*        Delay for specified number of milliseconds.
*END*-----------------------------------------------------------------*/

void _usb_host_delay
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle,
      
      /* [IN] time to wait in ms */
      uint_32 delay
   )
{ /* Body */
   MP_STRUCT16   o1, o2;
   volatile uint_32 dummy_delay;
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   o1.B.L = usb_host_ptr->DEV_PTR->FRAMENUMLO;
   o1.B.H = usb_host_ptr->DEV_PTR->FRAMENUMHI;
   o1.W = (o1.W + delay) & 0x7ff;

   dummy_delay = 0xffff0000;

   do {
         o2.B.L = usb_host_ptr->DEV_PTR->FRAMENUMLO;
         o2.B.H = usb_host_ptr->DEV_PTR->FRAMENUMHI;
         dummy_delay++;
   } while ((o1.W != o2.W) && dummy_delay);

} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_reset_the_device
*  Returned Value : None
*  Comments       :
*        Reset the device after it is attached to the host
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_reset_the_device
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle
   )
{ /* Body */
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   
   /* assert reset on the USB */
   usb_host_ptr->DEV_PTR->CONTROL = (VUSB_CTRL_HOST_MODE_EN | VUSB_CTRL_RESET);
   
   /* Delay for the reset process to complete */
   _usb_host_delay(handle, USB_RESET_DELAY);
   
   /* End the reset */
   usb_host_ptr->DEV_PTR->CONTROL = VUSB_CTRL_HOST_MODE_EN;
   
   /* Enable host mode and start generating SOFs */   
   usb_host_ptr->DEV_PTR->CONTROL = (VUSB_CTRL_HOST_MODE_EN | VUSB_CTRL_USB_EN);

   /* Delay for the reset recovery period */
   _usb_host_delay(handle, USB_RESET_RECOVERY_DELAY);   
   
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_process_attach
*  Returned Value : None
*  Comments       :
*        Process the VUSB Attach interrupt
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_process_attach
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle
   )
{ /* Body */
   uint_32  b;
   
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   usb_host_ptr->DEV_PTR->ERRORENABLE = 0xff;          /* enable all errors */

   /* Delay for the debounce interval */   
   _usb_host_delay(handle, USB_DEBOUNCE_DELAY);

   /* Check if the device is attached or detached */
   b = usb_host_ptr->DEV_PTR->CONTROL;

   if (b & VUSB_CTRL_SINGLE_ENDED_0) {
      _usb_host_vusb11_process_detach(handle);
      return;
   } /* Endif */
   
   /* check the low speed bit */   
   if (usb_host_ptr->DEV_PTR->ADDRESS & VUSB_ADDR_LS_EN) {
      /* currently low speed */
      if (b & VUSB_CTRL_JSTATE) {
         usb_host_ptr->SPEED = VUSB_ENDPT_CTL_HOST_WO_HUB;
         usb_host_ptr->NO_HUB = VUSB_ENDPT_CTL_HOST_WO_HUB;
      } else {
         usb_host_ptr->SPEED = 0;
         usb_host_ptr->NO_HUB = 0;  /* if we see a full speed device there 
                                    ** may be a hub. 
                                    */
      } /* Endif */
   } else { /* currently high speed */
      if (b & VUSB_CTRL_JSTATE) {
         /* Full-speed device */
         usb_host_ptr->SPEED = 0x00;
         usb_host_ptr->NO_HUB = 0x00;
         
         /* Tell VUSB that we have a high-speed device */
         usb_host_ptr->DEV_PTR->ADDRESS = 0x00;
      } else {
         /* Low-speed device */
         usb_host_ptr->SPEED = VUSB_ENDPT_CTL_HOST_WO_HUB;
         
         /* if we see a low speed device there is no hub. */
         usb_host_ptr->NO_HUB = VUSB_ENDPT_CTL_HOST_WO_HUB;
         
         /* Tell VUSB that we have a low-speed device */
         usb_host_ptr->DEV_PTR->ADDRESS = VUSB_ADDR_LS_EN;
      } /* Endif */
   } /* Endif */

   /* enable ep0 */   
   *usb_host_ptr->ENDPT_HOST_RG = 
      (VUSB_ENDPT_CONTROL | usb_host_ptr->NO_HUB);
   
   /* Reset the device */
   _usb_host_vusb11_reset_the_device(handle);

   /* Clear the attach and reset interrupt */   
   usb_host_ptr->DEV_PTR->INTSTATUS = (VUSB_INT_STAT_ATTACH | 
      VUSB_INT_STAT_RESET);

   /* Enable the token done, SOF and reset interrupts */   
   
   usb_host_ptr->DEV_PTR->INTENABLE = (VUSB_INT_ENB_TOK_DNE | 
      VUSB_INT_ENB_USB_RST | VUSB_INT_ENB_SOF_TOK); 
   
   
   /* Set the Odd data out */
   usb_host_ptr->USB_OUT = (VUSB_BDT_ODD_EVEN_BIT |
      VUSB_BDT_OUT_BIT);
   
   /* Set the Odd data In */
   usb_host_ptr->USB_IN = (VUSB_BDT_ODD_EVEN_BIT |
     VUSB_BDT_IN_BIT);

   /* Call the callback function of there was one register for the attach 
   ** event 
   */
   _usb_host_call_service(usb_host_ptr, USB_SERVICE_ATTACH, 0);
   
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_process_detach
*  Returned Value : None
*  Comments       :
*        Process the VUSB Detach event
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_process_detach
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle
   )
{ /* Body */
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   /* Cancel if there are any pending tokens */
   usb_host_ptr->SND_TOK_IN_PROGRESS = FALSE;

   /* Set the Buffer Descriptor Table address */
   _usb_host_vusb11_set_bdt_page((pointer)usb_host_ptr);

   /* Reset all the attached device specific values */
   usb_host_ptr->DEV_PTR->ADDRESS = 0;
   usb_host_ptr->SPEED = 0x00;  /* causes speed bit to be cleared */
   usb_host_ptr->NO_HUB = 0x00; /* hub bit cleared */
   *usb_host_ptr->ENDPT_HOST_RG = (VUSB_ENDPT_CONTROL | 
      usb_host_ptr->NO_HUB);   /* enable ep0 */

   /* Set the ODD/EVEN BDT to even and enable the host mode */   
   usb_host_ptr->DEV_PTR->CONTROL = VUSB_CTRL_ODD_RST;
   usb_host_ptr->DEV_PTR->CONTROL = VUSB_CTRL_HOST_MODE_EN;
   
   /* Clear all interrupts */
   usb_host_ptr->DEV_PTR->INTSTATUS = 0xFF;
   
   /* Enable attach interrupt */
   usb_host_ptr->DEV_PTR->INTENABLE = VUSB_INT_ENB_ATTACH;
   
   /* Call the callback function if there was one registered for a detach 
   ** event 
   */
   _usb_host_call_service(usb_host_ptr, USB_SERVICE_DETACH, 0);
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_send_in_token
*  Returned Value : None
*  Comments       :
*        Send the IN token to receive data after the first phase of Setup 
*  transaction is complete. This routine is also used for sending a zero length 
*  IN packet for the handshake phase of a Setup transaction.
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_send_in_token
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle               handle,
      
      /* Pipe descriptor address */      
      PIPE_DESCRIPTOR_STRUCT_PTR     pipe_descr_ptr
   )
{ /* Body */
   MP_STRUCT              mp_struct;
   uint_16                newPid;
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   /* Get Next IN BDT */   
   mp_struct.BDT_PTR = _usb_host_vusb11_get_next_in_bdt(handle);

   /* Buffer to receive data */
   mp_struct.BDT_PTR->ADDR.PB = (uchar_ptr)pipe_descr_ptr->RX_PTR;
   newPid = (pipe_descr_ptr->NEXTDATA01 | VUSB_BD_DTS_ENABLE | VUSB_BD_PID_OWN);

   if (pipe_descr_ptr->MUSTSENDNULL) {
      /* Send a zero length token */
      mp_struct.BDT_PTR->BC = 0;
      /* Send it on Data1 */
      newPid |= VUSB_BD_PID_DATA01;
      pipe_descr_ptr->MUSTSENDNULL = FALSE;
   } else {
      /* Doesn't matter what length. The device will packetize into 
      ** MAX_PACKET_SIZE and send 
      */
      mp_struct.BDT_PTR->BC = 0xFF;
   } /* Endif */
   
   mp_struct.BDT_PTR->PID = newPid;
   
   _usb_host_buffer_bdt(handle, mp_struct.BDT_PTR);

   _usb_host_buffer_token(handle, pipe_descr_ptr->ADDRESS, (VUSB_TOKEN_IN | 
      pipe_descr_ptr->EP), VUSB_ENDPT_CONTROL);
   
   /* IN Token */
   _usb_host_vusb11_send_token(handle, pipe_descr_ptr->ADDRESS, (VUSB_TOKEN_IN | 
      pipe_descr_ptr->EP), VUSB_ENDPT_CONTROL);
   pipe_descr_ptr->NEXTDATA01 ^= VUSB_BD_PID_DATA01;
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_send_out_token
*  Returned Value : None
*  Comments       :
*        Send the OUT token to send data after the first phase of Setup 
*  transaction is complete. This routine is also used for sending a zero length 
*  OUT packet for the handshake phase of a setup token
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_send_out_token
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle,
      
      /* [IN] the pipe descriptor address */
      PIPE_DESCRIPTOR_STRUCT_PTR pipe_descr_ptr
   )
{ /* Body */
   MP_STRUCT                         mp_struct;
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   /* Get the Next OUT BDT */
   mp_struct.BDT_PTR = (HOST_BDT_STRUCT_PTR)_usb_host_vusb11_get_next_out_bdt(handle);

   /* Data to send */   
   mp_struct.BDT_PTR->ADDR.PB = (uchar_ptr)pipe_descr_ptr->TX2_PTR;
   
   if (pipe_descr_ptr->MUSTSENDNULL) {
      /* Send a zero length token */
      mp_struct.BDT_PTR->BC = 0;
      /* Send it on Data1 */
      mp_struct.BDT_PTR->PID = (pipe_descr_ptr->NEXTDATA01 | 
         VUSB_BD_PID_OWN | VUSB_BD_PID_DATA01);
      pipe_descr_ptr->MUSTSENDNULL = FALSE;
   } else {
      if (pipe_descr_ptr->TODO2 > pipe_descr_ptr->MAX_PKT_SIZE) {
         /* Send only MAX_PACKET_SIZE packets */
         mp_struct.BDT_PTR->BC = pipe_descr_ptr->MAX_PKT_SIZE;
      } else {
         mp_struct.BDT_PTR->BC = pipe_descr_ptr->TODO2;
      } /* Endif */
      mp_struct.BDT_PTR->PID = (pipe_descr_ptr->NEXTDATA01 | VUSB_BD_PID_OWN);
   } /* Endif */
   
   _usb_host_buffer_bdt(handle, mp_struct.BDT_PTR);

   _usb_host_buffer_token(handle, pipe_descr_ptr->ADDRESS, (VUSB_TOKEN_OUT | 
      pipe_descr_ptr->EP), VUSB_ENDPT_CONTROL);

   /* setup */
   _usb_host_vusb11_send_token(handle, pipe_descr_ptr->ADDRESS, 
      (VUSB_TOKEN_OUT | pipe_descr_ptr->EP), VUSB_ENDPT_CONTROL);
   pipe_descr_ptr->NEXTDATA01 ^= VUSB_BD_PID_DATA01;
   pipe_descr_ptr->PACKETPENDING = FALSE;
   
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_send_token
*  Returned Value : None
*  Comments       :
*     Send a Token
*
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_send_token
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle,
      
      /* Address */
      uint_8 bAddress,
      
      /* Token */
      uint_8 bToken,
      
      /* Type of token */
      uint_8 bType
   )
{ /* Body */
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   
   usb_host_ptr->USB_PKT_PENDING++;
   usb_host_ptr->SND_TOK_IN_PROGRESS = TRUE;

   while (usb_host_ptr->DEV_PTR->CONTROL & VUSB_CTRL_TOKEN_BUSY) {
      /* Wait until previous token transmission is done */
   } /* EndWhile */

   *usb_host_ptr->ENDPT_HOST_RG = (bType | 
      usb_host_ptr->NO_HUB);
   
   usb_host_ptr->DEV_PTR->ADDRESS = (bAddress | 
      usb_host_ptr->SPEED);
   usb_host_ptr->DEV_PTR->TOKEN = bToken;
   
   return;
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_process_token_done
*  Returned Value : None
*  Comments       :
*     Process the Token Done interrupt on the VUSB1.1 hardware
*
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_process_token_done
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle,
            
      /* [IN] direction of the last processed token */
      uint_8                  direction,
            
      /* The error status register value */
      uint_32                 error_status
   )
{ /* Body */
   MP_STRUCT   mp_struct;
   uint_32 status;
   HOST_BDT_STRUCT_PTR BDT_ptr;
   PIPE_DESCRIPTOR_STRUCT_PTR pipe_descr_ptr;
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   
   pipe_descr_ptr = 
      &usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR\
      [usb_host_ptr->CURRENT_PIPE_ID]; 
      
   /* Get the correct BDT */
   if (direction == USB_SEND)  {
      BDT_ptr = (HOST_BDT_STRUCT_PTR)
         ((uint_32)usb_host_ptr->USB_BDT_PAGE | 
         usb_host_ptr->USB_OUT);

#ifdef __VUSB32_BDT_HACK__
	  /* hack */
	  if (BDT_ptr->PID & VUSB_BD_PID_OWN) {
	     BDT_ptr = (HOST_BDT_STRUCT_PTR)
            ((uint_32)usb_host_ptr->USB_BDT_PAGE | 
             (usb_host_ptr->USB_OUT ^ VUSB_BDT_ODD_EVEN_BIT));
	  } /* Endif */
#endif
   } else {
      BDT_ptr = (HOST_BDT_STRUCT_PTR)
         ((uint_32)usb_host_ptr->USB_BDT_PAGE | 
         usb_host_ptr->USB_IN);

#ifdef __VUSB32_BDT_HACK__
	  /* hack */
	  if (BDT_ptr->PID & VUSB_BD_PID_OWN) {
	     BDT_ptr = (HOST_BDT_STRUCT_PTR)
            ((uint_32)usb_host_ptr->USB_BDT_PAGE | 
             (usb_host_ptr->USB_IN ^ VUSB_BDT_ODD_EVEN_BIT));
	  } /* Endif */
#endif
   } /* Endif */
   
   /* Following is used to look ahead and transmit tokens */
   if (usb_host_ptr->USB_TOKEN_BUFFERED && 
      usb_host_ptr->NEXT_PKT_QUEUED) 
   {
      if (usb_host_ptr->CURRENT_PIPE_ID == 
         usb_host_ptr->NEXT_PIPE_ID) 
      {
         usb_host_ptr->NEXT_PKT_QUEUED = FALSE;
      } else {
         usb_host_ptr->USB_TOKEN_BUFFERED = FALSE;
      } /* Endif */
   } else if (usb_host_ptr->USB_TOKEN_BUFFERED) {
      usb_host_ptr->USB_TOKEN_BUFFERED = FALSE;   
   } else if ((usb_host_ptr->NEXT_PKT_QUEUED) && 
      (usb_host_ptr->CURRENT_PIPE_ID == usb_host_ptr->NEXT_PIPE_ID)) 
   {
      usb_host_ptr->NEXT_PKT_QUEUED = FALSE;
   } /* Endif */
   
   /* Get the status */
   status = VUSB_GET_STATUS(BDT_ptr);
   
   /* Get the number of bytes received */
#ifdef V8
   mp_struct.B.H = VUSB_GET_BYTE_COUNT_HIGH(BDT_ptr);
   mp_struct.B.L = VUSB_GET_BYTE_COUNT_LOW(BDT_ptr);
#else   
   mp_struct.W = VUSB_GET_BYTE_COUNT(BDT_ptr);
#endif

   /* if not an Isochronous transfer */   
   if (pipe_descr_ptr->PIPETYPE != USB_ISOCHRONOUS_PIPE) {
      if ((!status) || (status == VUSB_BD_NAK_PID) || 
         (status == 0x3C) || (error_status)) 
      {
         pipe_descr_ptr->NEXTDATA01 ^= VUSB_BD_PID_DATA01; /* Need to check */
         if (status == VUSB_BD_NAK_PID) {
            if (pipe_descr_ptr->CURRENT_NAK_COUNT) {
               pipe_descr_ptr->CURRENT_NAK_COUNT--;
               if (!pipe_descr_ptr->CURRENT_NAK_COUNT) {
                  pipe_descr_ptr->CURRENT_INTERVAL = 1;
               } /* Endif */
            } /* Endif */
         } /* Endif */
         
         if (status & VUSB_BD_STALL_PID) {
            _usb_host_call_service(usb_host_ptr, USB_SERVICE_STALL_PACKET, 
               pipe_descr_ptr->SOFAR);
         } /* Endif */
         
         /* Look ahead for transmitting next token */
         if (usb_host_ptr->NEXT_PKT_QUEUED) {
            usb_host_ptr->CURRENT_PIPE_ID = usb_host_ptr->NEXT_PIPE_ID;
            _usb_host_vusb11_resend_token(handle, 
               usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR\
               [usb_host_ptr->CURRENT_PIPE_ID].DIRECTION);
         } /* Endif */
         
         return;
      } /* Endif */
   } /* Endif */
   
   /* reset the counter if a non-NAK, valid transfer occured */
   pipe_descr_ptr->CURRENT_NAK_COUNT = pipe_descr_ptr->NAK_COUNT;

   if (pipe_descr_ptr->PIPETYPE != USB_CONTROL_PIPE) {
      /* Increment the buffer pointer */
      if (direction == USB_SEND)  {
         pipe_descr_ptr->TX1_PTR += mp_struct.W;
      } else {
         pipe_descr_ptr->RX_PTR += mp_struct.W;
      } /* Endif */
      /* Decrement the total bytes to be sent/received */
      pipe_descr_ptr->TODO1 -= mp_struct.W;
      /* Increment the total number of bytes sent/received */
      pipe_descr_ptr->SOFAR += mp_struct.W;
   } else {
   
      /* Increment the buffer pointers for Setup transactions */
      if ((pipe_descr_ptr->SEND_PHASE) && (!pipe_descr_ptr->FIRST_PHASE)) {
         pipe_descr_ptr->TX2_PTR += mp_struct.W;
         pipe_descr_ptr->TODO2 -= mp_struct.W;
         /* Increment the total number of bytes sent/received */
         pipe_descr_ptr->SOFAR += mp_struct.W;
      } /* Endif */
      
      if (direction == USB_RECV)  {
         pipe_descr_ptr->RX_PTR += mp_struct.W;
         pipe_descr_ptr->TODO1 -= mp_struct.W;
         /* Increment the total number of bytes sent/received */
         pipe_descr_ptr->SOFAR += mp_struct.W;
      } /* Endif */
   } /* Endif */
   
   /* Look ahead for transmitting next token */
   if (usb_host_ptr->NEXT_PKT_QUEUED) {
      usb_host_ptr->CURRENT_PIPE_ID = usb_host_ptr->NEXT_PIPE_ID;
      _usb_host_vusb11_resend_token(handle, 
         usb_host_ptr->PIPE_DESCRIPTOR_BASE_PTR\
         [usb_host_ptr->CURRENT_PIPE_ID].DIRECTION);
   } /* Endif */
   
   switch (pipe_descr_ptr->USB_PIPE_TRANSACTION_STATE) {
      case 0:
         /* Case for Non-Control transactions */
         if ((!pipe_descr_ptr->TODO1) || 
            (mp_struct.W < pipe_descr_ptr->MAX_PKT_SIZE))
         {
            if (pipe_descr_ptr->PIPETYPE != USB_ISOCHRONOUS_PIPE) {
               if ((!pipe_descr_ptr->DONT_ZERO_TERMINATE) && 
                  (mp_struct.W == pipe_descr_ptr->MAX_PKT_SIZE)) 
               {
                  break;
               } /* Endif */
            } /* Endif */
            pipe_descr_ptr->STATUS = USB_STATUS_IDLE;
            pipe_descr_ptr->PACKETPENDING = FALSE;
            _usb_host_update_current_head((pointer)usb_host_ptr, pipe_descr_ptr->PIPETYPE);
            _usb_host_call_service(usb_host_ptr, pipe_descr_ptr->PIPE_ID, 
               pipe_descr_ptr->SOFAR);
         } /* Endif */
         break;
      case 1:
         /* Following case is for Control transfers */
         if (pipe_descr_ptr->SEND_PHASE) {
            if (!pipe_descr_ptr->TODO2) { /* Complete */
               pipe_descr_ptr->USB_PIPE_TRANSACTION_STATE++;
               /* Setup transaction complete. Send an opposite 
               ** direction token on Data1 
               */
               pipe_descr_ptr->MUSTSENDNULL = TRUE;
               _usb_host_vusb11_send_in_token(handle, pipe_descr_ptr);
            } else { /* partial */
               /* Setup transaction not complete. Send more data */
               _usb_host_vusb11_send_out_token(handle, pipe_descr_ptr);
            } /* Endif */
         } else {
            if (!pipe_descr_ptr->TODO1) { /* Complete */
               pipe_descr_ptr->MUSTSENDNULL = TRUE;
               /* Setup transaction complete. Send an opposite 
               ** direction token on Data1 
               */
               _usb_host_vusb11_send_out_token(handle, pipe_descr_ptr);
               pipe_descr_ptr->USB_PIPE_TRANSACTION_STATE++;
            } else { /* partial */
               if ((mp_struct.W < pipe_descr_ptr->MAX_PKT_SIZE) && 
                  (!pipe_descr_ptr->FIRST_PHASE)) 
               {
                  pipe_descr_ptr->MUSTSENDNULL = TRUE;
                  _usb_host_vusb11_send_out_token(handle, pipe_descr_ptr);
                  pipe_descr_ptr->USB_PIPE_TRANSACTION_STATE++;
               } else {
                  _usb_host_vusb11_send_in_token(handle, pipe_descr_ptr);
               } /* Endif */
            } /* Endif */
         } /* Endif */
         pipe_descr_ptr->FIRST_PHASE = FALSE;
         break;
      case 2:
         /* Following case is for Control transfers */
         /* Transaction complete */
         pipe_descr_ptr->PACKETPENDING = FALSE;
         pipe_descr_ptr->STATUS = USB_STATUS_IDLE;
         pipe_descr_ptr->SEND_PHASE = FALSE;
         _usb_host_update_current_head((pointer)usb_host_ptr, pipe_descr_ptr->PIPETYPE);
         _usb_host_call_service(usb_host_ptr, pipe_descr_ptr->PIPE_ID, 
            pipe_descr_ptr->SOFAR);
         break;
      default:
         return;
   } /* EndSwitch */
   
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_init_send_bdt
*  Returned Value : None
*  Comments       :
*     Initialize a BDT for a send operation
*
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_init_send_bdt
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle,

      /* Pipe descriptor */
      PIPE_DESCRIPTOR_STRUCT_PTR pipe_descr_ptr
   )
{ /* Body */
   MP_STRUCT                  mp_struct;
   USB_HOST_STATE_STRUCT_PTR  usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   
   pipe_descr_ptr->STATUS = USB_STATUS_TRANSFER_IN_PROGRESS;
   
   mp_struct.BDT_PTR = &usb_host_ptr->USB_TEMP_SND_BDT;
   
   mp_struct.BDT_PTR->ADDR.PB = (uchar_ptr)pipe_descr_ptr->TX1_PTR;
   mp_struct.BDT_PTR->PID = (VUSB_BD_PID_OWN | pipe_descr_ptr->NEXTDATA01);
   pipe_descr_ptr->NEXTDATA01 ^= VUSB_BD_PID_DATA01;
   
   if (pipe_descr_ptr->TODO1 > pipe_descr_ptr->MAX_PKT_SIZE) {
      mp_struct.BDT_PTR->BC = pipe_descr_ptr->MAX_PKT_SIZE;
   } else {
      mp_struct.BDT_PTR->BC = pipe_descr_ptr->TODO1;
   } /* Endif */
   
   if (!usb_host_ptr->USB_TOKEN_BUFFERED) {
      usb_host_ptr->CURRENT_PIPE_ID = pipe_descr_ptr->PIPE_ID;
      pipe_descr_ptr->USB_PIPE_TRANSACTION_STATE = 0;
      _usb_host_buffer_bdt(handle, mp_struct.BDT_PTR);
      
      if (pipe_descr_ptr->PIPETYPE == USB_ISOCHRONOUS_PIPE) {
         _usb_host_buffer_token(handle, pipe_descr_ptr->ADDRESS, 
            (VUSB_TOKEN_OUT | pipe_descr_ptr->EP), VUSB_ENDPT_ISO_TX);
      } else {
         _usb_host_buffer_token(handle, pipe_descr_ptr->ADDRESS, 
            (VUSB_TOKEN_OUT | pipe_descr_ptr->EP), VUSB_ENDPT_CONTROL);
      } /* Endif */
      
      _usb_host_vusb11_resend_token(handle, USB_SEND);
   } else if (!usb_host_ptr->NEXT_PKT_QUEUED) {
      _usb_host_buffer_next_bdt(handle, mp_struct.BDT_PTR);
      
      if (pipe_descr_ptr->PIPETYPE == USB_ISOCHRONOUS_PIPE) {
         _usb_host_buffer_next_token(handle, pipe_descr_ptr->ADDRESS, 
            (VUSB_TOKEN_OUT | pipe_descr_ptr->EP), 
            VUSB_ENDPT_ISO_TX);
      } else {
         _usb_host_buffer_next_token(handle, pipe_descr_ptr->ADDRESS, 
            (VUSB_TOKEN_OUT | pipe_descr_ptr->EP), VUSB_ENDPT_CONTROL);
      } /* Endif */
      
      usb_host_ptr->NEXT_PIPE_ID = pipe_descr_ptr->PIPE_ID;
   } /* Endif */

} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_init_recv_bdt
*  Returned Value : None
*  Comments       :
*     Initialize a BDT for a Receive operation
*
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_init_recv_bdt
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle,

      /* Pipe descriptor */
      PIPE_DESCRIPTOR_STRUCT_PTR     pipe_descr_ptr
   )
{ /* Body */
   MP_STRUCT                  mp_struct;
   USB_HOST_STATE_STRUCT_PTR  usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   pipe_descr_ptr->STATUS = USB_STATUS_TRANSFER_IN_PROGRESS;   
   
   mp_struct.BDT_PTR = &usb_host_ptr->USB_TEMP_RCV_BDT;

   mp_struct.BDT_PTR->ADDR.PB = (uchar_ptr)pipe_descr_ptr->RX_PTR;
   /* Also enable data toggle synchronization */
   mp_struct.BDT_PTR->PID = (pipe_descr_ptr->NEXTDATA01 | VUSB_BD_DTS_ENABLE | 
      VUSB_BD_PID_OWN);
   pipe_descr_ptr->NEXTDATA01 ^= VUSB_BD_PID_DATA01;

   if (pipe_descr_ptr->TODO1 > pipe_descr_ptr->MAX_PKT_SIZE) {
      mp_struct.BDT_PTR->BC = pipe_descr_ptr->MAX_PKT_SIZE;
   } else {
      mp_struct.BDT_PTR->BC = pipe_descr_ptr->TODO1;
   } /* Endif */

      if (!usb_host_ptr->USB_TOKEN_BUFFERED) {
      pipe_descr_ptr->USB_PIPE_TRANSACTION_STATE = 0;
      usb_host_ptr->CURRENT_PIPE_ID = pipe_descr_ptr->PIPE_ID;
      _usb_host_buffer_bdt(handle, mp_struct.BDT_PTR);
      
      if (pipe_descr_ptr->PIPETYPE == USB_ISOCHRONOUS_PIPE) {
         _usb_host_buffer_token(handle, pipe_descr_ptr->ADDRESS, 
            (VUSB_TOKEN_IN | pipe_descr_ptr->EP), VUSB_ENDPT_ISO_RX);
      } else {
         _usb_host_buffer_token(handle, pipe_descr_ptr->ADDRESS, 
            (VUSB_TOKEN_IN | pipe_descr_ptr->EP), VUSB_ENDPT_CONTROL);
      } /* Endif */
      
      _usb_host_vusb11_resend_token(handle, USB_RECV);
   } else if (!usb_host_ptr->NEXT_PKT_QUEUED) {
      _usb_host_buffer_next_bdt(handle, mp_struct.BDT_PTR);
      
      if (pipe_descr_ptr->PIPETYPE == USB_ISOCHRONOUS_PIPE) {
         _usb_host_buffer_next_token(handle, pipe_descr_ptr->ADDRESS, 
            (VUSB_TOKEN_IN | pipe_descr_ptr->EP), VUSB_ENDPT_ISO_RX);
      } else {
         _usb_host_buffer_next_token(handle, pipe_descr_ptr->ADDRESS, 
            (VUSB_TOKEN_IN | pipe_descr_ptr->EP), VUSB_ENDPT_CONTROL);
      } /* Endif */
      
      usb_host_ptr->NEXT_PIPE_ID = pipe_descr_ptr->PIPE_ID;
   } /* Endif */

} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_init_setup_bdt
*  Returned Value : None
*  Comments       :
*     Initialize a BDT for a Setup tranaction
*
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_init_setup_bdt
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle        handle,
      
      /* Pipe descriptor */
      PIPE_DESCRIPTOR_STRUCT_PTR pipe_descr_ptr
   )
{ /* Body */
   static MP_STRUCT                  mp_struct;
   USB_HOST_STATE_STRUCT_PTR         usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   
   pipe_descr_ptr->USB_PIPE_TRANSACTION_STATE = 1;
   pipe_descr_ptr->STATUS = USB_STATUS_TRANSFER_IN_PROGRESS;
   
   usb_host_ptr->CURRENT_PIPE_ID = pipe_descr_ptr->PIPE_ID;

   mp_struct.BDT_PTR = (HOST_BDT_STRUCT_PTR)_usb_host_vusb11_get_next_out_bdt(handle);
   mp_struct.BDT_PTR->BC = 0x08;
   mp_struct.BDT_PTR->ADDR.PB = (uchar_ptr)pipe_descr_ptr->TX1_PTR;
   mp_struct.BDT_PTR->PID = (pipe_descr_ptr->NEXTDATA01 | VUSB_BD_PID_OWN);
   pipe_descr_ptr->NEXTDATA01 ^= VUSB_BD_PID_DATA01;
   _usb_host_buffer_bdt(handle, mp_struct.BDT_PTR);

   _usb_host_buffer_token(handle, pipe_descr_ptr->ADDRESS, 
      VUSB_TOKEN_SETUP, VUSB_ENDPT_CONTROL);

   /* setup ep0 */
   _usb_host_vusb11_send_token(handle, pipe_descr_ptr->ADDRESS, 
      (VUSB_TOKEN_SETUP | pipe_descr_ptr->EP), VUSB_ENDPT_CONTROL);

} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_resend_token
*  Returned Value : None
*  Comments       :
*     Resend a Token
*
*END*-----------------------------------------------------------------*/

void _usb_host_vusb11_resend_token
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle           handle,
      
      /* Send/Receive */
      uint_8  bDirection
   )
{ /* Body */
   MP_STRUCT   mp_struct;
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   /* resend last token after resetting the bdt */
   if (bDirection == USB_SEND)  {
      mp_struct.BDT_PTR = _usb_host_vusb11_get_next_out_bdt(handle);
   } else {
      mp_struct.BDT_PTR = _usb_host_vusb11_get_next_in_bdt(handle);
   } /* Endif */
   
   if (usb_host_ptr->USB_TOKEN_BUFFERED) {
      mp_struct.BDT_PTR->BC = usb_host_ptr->USB_BUFFERED_BDT.BC;
      mp_struct.BDT_PTR->ADDR = usb_host_ptr->USB_BUFFERED_BDT.ADDR;
      mp_struct.BDT_PTR->PID = usb_host_ptr->USB_BUFFERED_BDT.PID;
      _usb_host_vusb11_send_token(handle, usb_host_ptr->USB_BUFFERED_ADDRESS, 
         usb_host_ptr->USB_BUFFERED_TOKEN, 
         usb_host_ptr->USB_BUFFERED_TYPE);
      _usb_host_buffer_token(handle, usb_host_ptr->USB_BUFFERED_ADDRESS, 
         usb_host_ptr->USB_BUFFERED_TOKEN, 
         usb_host_ptr->USB_BUFFERED_TYPE);
      return;      
   } /* Endif */  
   
   if (usb_host_ptr->NEXT_PKT_QUEUED) {
      mp_struct.BDT_PTR->BC = usb_host_ptr->USB_NEXT_BUFFERED_BDT.BC;
      mp_struct.BDT_PTR->ADDR = usb_host_ptr->USB_NEXT_BUFFERED_BDT.ADDR;
      mp_struct.BDT_PTR->PID = usb_host_ptr->USB_NEXT_BUFFERED_BDT.PID;
      _usb_host_vusb11_send_token(handle, usb_host_ptr->USB_NEXT_BUFFERED_ADDRESS, 
         usb_host_ptr->USB_NEXT_BUFFERED_TOKEN, 
         usb_host_ptr->USB_NEXT_BUFFERED_TYPE);
      _usb_host_buffer_next_token(handle, usb_host_ptr->USB_NEXT_BUFFERED_ADDRESS, 
         usb_host_ptr->USB_NEXT_BUFFERED_TOKEN, 
         usb_host_ptr->USB_NEXT_BUFFERED_TYPE);
   } /* Endif */
  
} /* EndBody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_buffer_bdt
*  Returned Value : None
*  Comments       :
*        Buffer a BDT
*END*-----------------------------------------------------------------*/

void _usb_host_buffer_bdt
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle           handle,
            
      /* The descriptor to buffer */
      HOST_BDT_STRUCT_PTR BDT_ptr
   )
{ /* Body */
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   
   usb_host_ptr->USB_BUFFERED_BDT.PID = BDT_ptr->PID;
   usb_host_ptr->USB_BUFFERED_BDT.BC = BDT_ptr->BC;
   usb_host_ptr->USB_BUFFERED_BDT.ADDR = BDT_ptr->ADDR;
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_buffer_next_bdt
*  Returned Value : None
*  Comments       :
*        Buffer the Next BDT to be processed
*END*-----------------------------------------------------------------*/

void _usb_host_buffer_next_bdt
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle           handle,
      
      /* [IN] the address of the descriptor to buffer */
      HOST_BDT_STRUCT_PTR BDT_ptr
   )
{ /* Body */
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   
   usb_host_ptr->USB_NEXT_BUFFERED_BDT.PID = BDT_ptr->PID;
   usb_host_ptr->USB_NEXT_BUFFERED_BDT.BC = BDT_ptr->BC;
   usb_host_ptr->USB_NEXT_BUFFERED_BDT.ADDR = BDT_ptr->ADDR;
} /* Endbody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_buffer_token
*  Returned Value : None
*  Comments       :
*        Buffer a Token to transmit
*END*-----------------------------------------------------------------*/

void _usb_host_buffer_token
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle           handle,
      
      /* Address */
      uint_8 bAddress,
      
      /* Token */
      uint_8 bToken,
      
      /* Type of token */
      uint_8 bType
   )
{ /* Body */
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   
   usb_host_ptr->USB_BUFFERED_ADDRESS = bAddress;
   usb_host_ptr->USB_BUFFERED_TOKEN = bToken;
   usb_host_ptr->USB_BUFFERED_TYPE = bType;
   usb_host_ptr->USB_TOKEN_BUFFERED = TRUE;
} /* EndBody */

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_buffer_next_token
*  Returned Value : None
*  Comments       :
*        Buffer the next Token to transmit
*END*-----------------------------------------------------------------*/

void _usb_host_buffer_next_token
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle           handle,
      
      /* Address */
      uint_8 bAddress,
      
      /* Token */
      uint_8 bToken,
      
      /* Type of token */
      uint_8 bType
   )
{ /* Body */
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   
   usb_host_ptr->USB_NEXT_BUFFERED_ADDRESS = bAddress;
   usb_host_ptr->USB_NEXT_BUFFERED_TOKEN = bToken;
   usb_host_ptr->USB_NEXT_BUFFERED_TYPE = bType;
   usb_host_ptr->NEXT_PKT_QUEUED = TRUE;
} /* EndBody */

/* EOF */