/*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*********************************************************************/

#include "osint.h"
#include "../host.h"

/*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
   )
{
   _usb_host_queue_pkts(handle, pipe_descr_ptr);
}

/*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
   )
{
   _usb_host_queue_pkts(handle, pipe_descr_ptr);
}

/*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
   )
{
   _usb_host_queue_pkts(handle, pipe_descr_ptr);
}

/*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
   )
{
   /* Cancel the transaction at hardware level if required */
}

/*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
   )
{
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   usb_host_ptr->DEV_PTR->BDTPAGE1 =
      (K1_TO_PHYS(usb_host_ptr->USB_BDT_PAGE) >> 8) & 0xff;
   usb_host_ptr->DEV_PTR->BDTPAGE2 =
      (K1_TO_PHYS(usb_host_ptr->USB_BDT_PAGE) >> 16) & 0xff;
   usb_host_ptr->DEV_PTR->BDTPAGE3 =
      (K1_TO_PHYS(usb_host_ptr->USB_BDT_PAGE) >> 24) & 0xff;
}

/*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
   )
{
   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));
}

/*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
   )
{
   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));
}

/*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
   )
{
   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;

   temp = 0;
   sched_int_pipe = sched_ctrl_pipe = sched_bulk_pipe = 0;

   /* 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;
         }
      } 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;
		   }
      } 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;
		   }
      }

      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;
      }
      
      /* Initiate the appropriate transfer and update the current head of the 
      ** respective pipe 
      */
      if (i == 0 || (temp != pipe_descr_ptr)) {
         temp = pipe_descr_ptr;
//PRINTF("sched_pending: call initiate_bdt\n");
         _usb_host_vusb11_initiate_correct_bdt(handle, pipe_descr_ptr);
         _usb_host_update_current_head(handle, pipe_descr_ptr->PIPETYPE);
      }
      
   }
}

/*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
   )
{
   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;
   temp = 0;

   /* 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);
         }
      } else {
         break;
      }
   }
}

/*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
   )
{
#if 0
PRINTF("init_correct_bdt: PackPend %d, FirstPhase %d, SendPhase %d, TODO1 %d, TODO2 %d\n",
   pipe_descr_ptr->PACKETPENDING,
   pipe_descr_ptr->FIRST_PHASE,
   pipe_descr_ptr->SEND_PHASE,
   pipe_descr_ptr->TODO1,
   pipe_descr_ptr->TODO2);
#endif

   /* 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);
               }
            } 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);
               }
            }
         }
      } 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);
         }
      }
   }
}

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

void _usb_hci_vusb11_isr
   (
      /* [IN] the USB Host state structure */
      _usb_host_handle                  handle
   )
{
   uint_8 direction;
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   uint_32  status, error_status;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   /* 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;
      }

      /* 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) {
PRINTF("hci_isr: RESET\n");
         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->TOK_THIS_FRAME++;
//PRINTF("hci_isr: TOKEN_DONE TOK_IN_PROGRESS %d, tok/frm %d, ticks = %d\n", usb_host_ptr->SND_TOK_IN_PROGRESS, usb_host_ptr->TOK_THIS_FRAME, osGetCount());
            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 0
	    /* XXX
	     * The value of status doesn't get touched between the test
	     * that got us in here and this statement, so the following
	     * if condition is always false
	     */
            if ((!usb_host_ptr->SND_TOK_IN_PROGRESS) && 
               !(status & VUSB_INT_STAT_TOKEN_DONE)) 
            {
               _usb_host_vusb11_sched_pending_pkts((pointer)usb_host_ptr);
            }
#else
            if (!usb_host_ptr->SND_TOK_IN_PROGRESS) {
               _usb_host_vusb11_sched_pending_pkts((pointer)usb_host_ptr);
            }
#endif
            
         }
         
         if (status & VUSB_INT_STAT_SOF) {
#if 0
if (usb_host_ptr->SND_TOK_IN_PROGRESS)
    PRINTF("hci_isr: SOF at ticks = %d, tokens last frame %d\n", osGetCount(), usb_host_ptr->TOK_THIS_FRAME);
#endif
            usb_host_ptr->TOK_THIS_FRAME = 0;
            
            /* 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);
            }
            
            /* 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);
            }
         }

         /* Check if attach interrupt */      
         if (status & VUSB_INT_STAT_ATTACH) {
PRINTF("hci_isr: ATTACH\n");
            _usb_host_vusb11_process_attach((pointer)usb_host_ptr);
         }
         
         if (status & VUSB_INT_STAT_RESUME) {
PRINTF("hci_isr: RESUME\n");
            /* 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);
         }
         
      }
   }
//PRINTF("/");

}

/*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 */
   uint_8 which;

   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   which = usb_host_ptr->CTLR_NUM;

   /* Set the BDT page address in SRAM */      
   usb_host_ptr->USB_BDT_PAGE = (HOST_BDT_STRUCT_PTR)
           PHYS_TO_K1(which ? USB1_BDT_SRAM : USB0_BDT_SRAM);
      
   /*
    * Get the base address of the VUSB registers
    *
    * Note that the ARC host driver does not touch the OTG
    * registers, so the register base pointer points at
    * the Interrupt Status register.
    */
   usb_host_ptr->DEV_PTR = (USB_STRUCT_PTR)
           PHYS_TO_K1((which ? USB1_BASE_REG : USB0_BASE_REG) +
			   (USB0_INT_STAT_REG - USB0_BASE_REG));

   /* The address of the endpoint registers */      
   usb_host_ptr->ENDPT_HOST_RG = (USB_REGISTER_PTR)
           ((uint_32)usb_host_ptr->DEV_PTR + 
                           (USB0_ENDPT0_REG - USB0_INT_STAT_REG));
   
   *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);
   
   /* 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
   )
{
   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;

   /*
    * XXX if VI is active, we can use libultra timers here
    */
   dummy_delay = 0xffff0000;

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

}

/*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
   )
{
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
PRINTF("host_reset_the_device at ticks = %d\n", osGetCount());
   
   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);   
PRINTF("host_reset_the_device finished at ticks = %d\n", osGetCount());
}

/*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
   )
{
   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) {
PRINTF("host_attach: SE0\n");
      _usb_host_vusb11_process_detach(handle);
      return;
   }
   
   /* check the low speed bit */   
   if (usb_host_ptr->DEV_PTR->ADDRESS & VUSB_ADDR_LS_EN) {
PRINTF("host_attach: LS\n");
      /* 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 {
PRINTF("host_attach: not really LS, set to FS\n");
         usb_host_ptr->SPEED = 0;
         usb_host_ptr->NO_HUB = 0;  /* if we see a full speed device there 
                                    ** may be a hub. 
                                    */
      }
   } else { /* currently high speed */
PRINTF("host_attach: FS\n");
      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 {
PRINTF("host_attach: not really FS, set to LS\n");
         /* 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;
      }
   }

   /* 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 registered for the attach 
   ** event 
   */
   _usb_host_call_service(usb_host_ptr, USB_SERVICE_ATTACH, 0);
   
}

/*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
   )
{
   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);
}

/*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
   )
{
   uint_16                newPid;
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   HOST_BDT_STRUCT_PTR         real_bdt_p;
   HOST_BDT_STRUCT             copy_bdt;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

//PRINTF("host_send_in_token: pipep 0x%x\n", pipe_descr_ptr);
   /* Get Next IN BDT */   
   real_bdt_p = _usb_host_vusb11_get_next_in_bdt(handle);
   _usb_bdt_copy_swab(real_bdt_p, &copy_bdt);

   /* Buffer to receive data */
   copy_bdt.ADDR.PB = (uchar_ptr)K1_TO_PHYS(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 */
      copy_bdt.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 
      */
      copy_bdt.BC = 0xFF;
   }
   
   copy_bdt.PID = newPid;

   /* Copy back to hw BDT, but pass memory version to buffer routine */
   _usb_bdt_copy_swab(&copy_bdt, real_bdt_p);
   _usb_host_buffer_bdt(handle, &copy_bdt);

   _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;
}

/*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
   )
{
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   HOST_BDT_STRUCT_PTR real_bdt_ptr;
   HOST_BDT_STRUCT copy_bdt;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
//PRINTF("host_send_out_token: pipep 0x%x\n", pipe_descr_ptr);

   /* Get the Next OUT BDT */
   real_bdt_ptr = (HOST_BDT_STRUCT_PTR)_usb_host_vusb11_get_next_out_bdt(handle);
   _usb_bdt_copy_swab(real_bdt_ptr, &copy_bdt);

   /* Data to send */   
   copy_bdt.ADDR.PB = (uchar_ptr)K1_TO_PHYS(pipe_descr_ptr->TX2_PTR);
   
   if (pipe_descr_ptr->MUSTSENDNULL) {
      /* Send a zero length token */
      copy_bdt.BC = 0;
      /* Send it on Data1 */
      copy_bdt.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 */
         copy_bdt.BC = pipe_descr_ptr->MAX_PKT_SIZE;
      } else {
         copy_bdt.BC = pipe_descr_ptr->TODO2;
      }
      copy_bdt.PID = (pipe_descr_ptr->NEXTDATA01 | VUSB_BD_PID_OWN);
   }
   
   _usb_bdt_copy_swab(&copy_bdt, real_bdt_ptr);
   _usb_host_buffer_bdt(handle, &copy_bdt);

   _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;
   
}

/*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
   )
{
   USB_HOST_STATE_STRUCT_PTR usb_host_ptr;
   int waitprint = 0;
   int waitprintbackoff = 64;
   
   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 */
      if (waitprint-- == 0) {
         PRINTF("host: TOKEN_BUSY wait (backoff %d)\n", waitprintbackoff);	   /* XXX */
	 waitprint = waitprintbackoff;
	 waitprintbackoff <<= 2;
      }
   }

   //PRINTF("host_send_token: address 0x%x, token 0x%x, type 0x%x at ticks = %d\n", bAddress, bToken, bType, osGetCount());
   *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;
}

/*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
   )
{
   MP_STRUCT   mp_struct;
   uint_32 status;
   HOST_BDT_STRUCT_PTR BDT_ptr;
   HOST_BDT_STRUCT     copy_bdt;
   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);

          /* Copy BDT from hw to be manipulated */
          _usb_bdt_copy_swab(BDT_ptr, &copy_bdt);
#ifdef __VUSB32_BDT_HACK__
	  /* hack */
	  if (copy_bdt.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));
             _usb_bdt_copy_swab(BDT_ptr, &copy_bdt);
	  }
#endif
   } else {
      BDT_ptr = (HOST_BDT_STRUCT_PTR)
         ((uint_32)usb_host_ptr->USB_BDT_PAGE | 
         usb_host_ptr->USB_IN);

          /* Copy BDT from hw to be manipulated */
          _usb_bdt_copy_swab(BDT_ptr, &copy_bdt);
#ifdef __VUSB32_BDT_HACK__
	  /* hack */
	  if (copy_bdt.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));
             _usb_bdt_copy_swab(BDT_ptr, &copy_bdt);
	  }
#endif
   }

//PRINTF("host_token_done: dir %d, bdt 0x%x, d0/1 %d, TOK_BUF %d, PKT_QD %d\n", direction, BDT_ptr, (copy_bdt.PID & 0x40)>>6, usb_host_ptr->USB_TOKEN_BUFFERED, usb_host_ptr->NEXT_PKT_QUEUED);

   /* 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;
      }
   } 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;
   }
   
   /* Get the status */
   status = VUSB_GET_STATUS(&copy_bdt);
   
   /* Get the number of bytes received */
#ifdef V8
   mp_struct.B.H = VUSB_GET_BYTE_COUNT_HIGH(&copy_bdt);
   mp_struct.B.L = VUSB_GET_BYTE_COUNT_LOW(&copy_bdt);
#else   
   mp_struct.W = VUSB_GET_BYTE_COUNT(&copy_bdt);
#endif

//PRINTF("host_token_done: dir %d, bdt 0x%x, got %d, status 0x%x, errorstat 0x%x\n", direction, BDT_ptr, mp_struct.W, status, error_status);

   /* if not an Isochronous transfer */   
   if (pipe_descr_ptr->PIPETYPE != USB_ISOCHRONOUS_PIPE) {
//PRINTF("process_token_done: not ISOC pipe\n");
      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) {
//PRINTF("process_token_done: NAK (cur NAK count %d)\n", pipe_descr_ptr->CURRENT_NAK_COUNT);
            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;
               }
            }
         }
         
         if (status & VUSB_BD_STALL_PID) {
PRINTF("process_token_done: STALL\n");
            _usb_host_call_service(usb_host_ptr, USB_SERVICE_STALL_PACKET, 
               pipe_descr_ptr->SOFAR);
         }
         
         /* Look ahead for transmitting next token */
         if (usb_host_ptr->NEXT_PKT_QUEUED) {
//PRINTF("process_token_done: NEXT_PKT_QUEUED, call resend\n");
            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);
         }
         
//PRINTF("process_token_done: return\n");
         return;
      }
//PRINTF("process_token_done: not ISOC pipe, fall thru\n");
   }
   
   /* 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) {
//PRINTF("process_token_done: not control pipe\n");
      /* 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;
      }
      /* 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 {
   
//PRINTF("process_token_done: control pipe\n");
      /* 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;
      }
      
      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;
      }
   }
   
   /* 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);
   }
   
   switch (pipe_descr_ptr->USB_PIPE_TRANSACTION_STATE) {
      case 0:
//PRINTF("process_token_done: case 0\n");
         /* 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;
               }
            }
            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);
         }
         break;
      case 1:
         /* Following case is for Control transfers */
         if (pipe_descr_ptr->SEND_PHASE) {
//PRINTF("process_token_done: case 1 SEND\n");
            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 {
//PRINTF("process_token_done: case 1 RECV, TODO1 %d, FIRST PHASE %d\n", pipe_descr_ptr->TODO1, pipe_descr_ptr->FIRST_PHASE);
            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);
               }
            }
         }
         pipe_descr_ptr->FIRST_PHASE = FALSE;
         break;
      case 2:
         /* Following case is for Control transfers */
         /* Transaction complete */
//PRINTF("process_token_done: case 2, call svc for pipe %d\n", pipe_descr_ptr->PIPE_ID);
         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;
   }
   
}

/*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
   )
{
   USB_HOST_STATE_STRUCT_PTR  usb_host_ptr;
   HOST_BDT_STRUCT_PTR        bdt_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
   
   pipe_descr_ptr->STATUS = USB_STATUS_TRANSFER_IN_PROGRESS;
   
   bdt_ptr = &usb_host_ptr->USB_TEMP_SND_BDT;
//PRINTF("host_init_send_bdt 0x%x, TOK_BUF %d, PKT_QD %d\n", bdt_ptr, usb_host_ptr->USB_TOKEN_BUFFERED, usb_host_ptr->NEXT_PKT_QUEUED); 
   
   bdt_ptr->ADDR.PB = (uchar_ptr)K1_TO_PHYS(pipe_descr_ptr->TX1_PTR);
   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) {
      bdt_ptr->BC = pipe_descr_ptr->MAX_PKT_SIZE;
   } else {
      bdt_ptr->BC = pipe_descr_ptr->TODO1;
   }
  
   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, 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);
      }
      
      _usb_host_vusb11_resend_token(handle, USB_SEND);
      return;
   }
  
   if (!usb_host_ptr->NEXT_PKT_QUEUED) {
      _usb_host_buffer_next_bdt(handle, 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);
      }
      
      usb_host_ptr->NEXT_PIPE_ID = pipe_descr_ptr->PIPE_ID;
      return;
   }

}

/*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
   )
{
   USB_HOST_STATE_STRUCT_PTR  usb_host_ptr;
   HOST_BDT_STRUCT_PTR        bdt_ptr;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   pipe_descr_ptr->STATUS = USB_STATUS_TRANSFER_IN_PROGRESS;   
   
   bdt_ptr = &usb_host_ptr->USB_TEMP_RCV_BDT;
//PRINTF("host_init_recv_bdt 0x%x, TOK_BUF %d, PKT_QD %d\n", bdt_ptr, usb_host_ptr->USB_TOKEN_BUFFERED, usb_host_ptr->NEXT_PKT_QUEUED); 

   bdt_ptr->ADDR.PB = (uchar_ptr)K1_TO_PHYS(pipe_descr_ptr->RX_PTR);
   /* Also enable data toggle synchronization */
   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) {
      bdt_ptr->BC = pipe_descr_ptr->MAX_PKT_SIZE;
   } else {
      bdt_ptr->BC = pipe_descr_ptr->TODO1;
   }

   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, 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);
      }
      
      _usb_host_vusb11_resend_token(handle, USB_RECV);
      return;
   }
  
   if (!usb_host_ptr->NEXT_PKT_QUEUED) {
      _usb_host_buffer_next_bdt(handle, 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);
      }
      
      usb_host_ptr->NEXT_PIPE_ID = pipe_descr_ptr->PIPE_ID;
      return;
   }

}

/*FUNCTION*-------------------------------------------------------------
*
*  Function Name  : _usb_host_vusb11_init_setup_bdt
*  Returned Value : None
*  Comments       :
*     Initialize a BDT for a Setup transaction
*
*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
   )
{
   USB_HOST_STATE_STRUCT_PTR  usb_host_ptr;
   HOST_BDT_STRUCT_PTR        real_bdt_ptr;
   HOST_BDT_STRUCT            copy_bdt;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;
  
//PRINTF("host_init_setup_bdt: pipe %d\n", pipe_descr_ptr->PIPE_ID);
   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;

   real_bdt_ptr = (HOST_BDT_STRUCT_PTR)_usb_host_vusb11_get_next_out_bdt(handle);
//PRINTF("host_init_setup_bdt: pipe %d, bdt 0x%x\n", pipe_descr_ptr->PIPE_ID, real_bdt_ptr);
   /* Copy hw BDT to memory and swap bytes */
   _usb_bdt_copy_swab(real_bdt_ptr, &copy_bdt);
   copy_bdt.BC = 0x08;
   /* need physical address here */
   copy_bdt.ADDR.PB = (uchar_ptr)K1_TO_PHYS(pipe_descr_ptr->TX1_PTR);
   copy_bdt.PID = (pipe_descr_ptr->NEXTDATA01 | VUSB_BD_PID_OWN);
   /* Copy BDT back to hw and swap bytes */
   /* XXX do we need this? */
   _usb_bdt_copy_swab(&copy_bdt, real_bdt_ptr);
   pipe_descr_ptr->NEXTDATA01 ^= VUSB_BD_PID_DATA01;
   /* Buffer BDT in memory format */
   _usb_host_buffer_bdt(handle, &copy_bdt);

   _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);

}

/*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
   )
{
   USB_HOST_STATE_STRUCT_PTR  usb_host_ptr;
   HOST_BDT_STRUCT_PTR        real_bdt_ptr;
   HOST_BDT_STRUCT            copy_bdt;
   
   usb_host_ptr = (USB_HOST_STATE_STRUCT_PTR)handle;

   /* resend last token after resetting the bdt */
   if (bDirection == USB_SEND)  {
      real_bdt_ptr = _usb_host_vusb11_get_next_out_bdt(handle);
   } else {
      real_bdt_ptr = _usb_host_vusb11_get_next_in_bdt(handle);
   }

//PRINTF("resend_token: dir %d, bdt 0x%x, TOK_BUF %d, PKT_QD %d\n", bDirection, real_bdt_ptr, usb_host_ptr->USB_TOKEN_BUFFERED, usb_host_ptr->NEXT_PKT_QUEUED);
   /* get the bdt from hw and byte swap it */ 
   _usb_bdt_copy_swab(real_bdt_ptr, &copy_bdt); 
   if (usb_host_ptr->USB_TOKEN_BUFFERED) {
      copy_bdt.BC = usb_host_ptr->USB_BUFFERED_BDT.BC;
      copy_bdt.ADDR = usb_host_ptr->USB_BUFFERED_BDT.ADDR;
      copy_bdt.PID = usb_host_ptr->USB_BUFFERED_BDT.PID;
      /* copy the new bdt back to the hw (and swab it) */ 
      _usb_bdt_copy_swab(&copy_bdt, real_bdt_ptr);
      _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;      
   }
   
   if (usb_host_ptr->NEXT_PKT_QUEUED) {
      copy_bdt.BC = usb_host_ptr->USB_NEXT_BUFFERED_BDT.BC;
      copy_bdt.ADDR = usb_host_ptr->USB_NEXT_BUFFERED_BDT.ADDR;
      copy_bdt.PID = usb_host_ptr->USB_NEXT_BUFFERED_BDT.PID;
      /* copy the new bdt back to the hw (and swab it) */ 
      _usb_bdt_copy_swab(&copy_bdt, real_bdt_ptr);
      _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);
   }
  
}

/*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
   )
{
   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;
}

/*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
   )
{
   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;
}

/*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
   )
{
   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;
}

/*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
   )
{
   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;
}