//////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------//
//-- Copyright 2001 VAutomation Inc. Nashua NH USA. All rights reserved.//
//-- This software is provided under license and contains proprietary   //
//-- and confidential material which is the property of VAutomation Inc.//
//-- HTTP://www.vautomation.com											//
//----------------------------------------------------------------------//
//////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////
// MainEntry.cpp 
/////////////////////////////////////////////////////////
 
/////////////////////////////////////////////////////////
// Common API headers
/////////////////////////////////////////////////////////
#include "USB1_Common.h"



//////////////////////////////////////////////////////////
// Non-API includes
//////////////////////////////////////////////////////////



//////////////////////////////////////////////////////////
// Global information shared with the IRQ function
//////////////////////////////////////////////////////////
BufferDescriptorTableType *g_BufferDescriptorTablePtr;
UnSignedLong		   g_CurrentTestProgress;
bool			   g_DoneWithDeviceTests = false;
bool                       g_DoneWithHostTests = false;
bool                       g_DoneWithOTGTests = false;
bool                       g_DoneWithLineStateTests = false;

/////////////////////////////////////////////////////////
// Global hardware information
//////////////////////////////////////////////////////////

CVirtualComponentInterface		*g_host_dma;
CVirtualComponentInterface		*g_usb_initiator;
CMessageIO						*g_message_interface;
CInterruptControllerInterface	*g_interrupt_cntrl;


/////////////////////////////////////////////////////////
// Local Functions
//////////////////////////////////////////////////////////
bool MainTestThread();

void InitBDTptrs(UnSignedLong Status, 
		 BufferDescriptor **currBDT_ptr,
		 BufferDescriptor **sendBDT_ptr,
		 BufferDescriptor **nxtRcvBDT_ptr); 


//////////////////////////////////////////////////////////
// IRQ callback functions
//
// when we get an interrupt read the interrupt status 
// register, clear the interrupt and pass along the cause 
// of the interrupt to the main code
//
//////////////////////////////////////////////////////////

void InterruptCallbackIRQ_5( void )
{
  BufferDescriptor *currBDT_ptr=NULL;
  BufferDescriptor *sendBDT_ptr=NULL;
  BufferDescriptor *nxtRcvBDT_ptr=NULL;
  UnSignedLong IntStatus_write = 0x0;
  UnSignedLong bDirection;
  UnSignedLong *rcv_pkt_ptr=NULL;

  // g_message_interface->PrintStringStdioLF( "InterruptCallback Called for USB");
  UnSignedLong USB_IntStatus;
  UnSignedLong USB_IntEnable;
  UnSignedLong USB_ErrStatus;
  UnSignedLong USB_ErrEnable;
  UnSignedLong USB_Status;
  UnSignedLong USB_IntMasked;
  UnSignedLong USB_OTG_IStat;
  UnSignedLong USB_OTG_Stat;
  UnSignedLong USB_Ctrl;


  g_CurrentTestProgress++;	

  // Save values of some USB registers
  if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_IntStatus),
				   int_stat_addr, 
				   sizeof(UnSignedLong), false ) == false )
  {
    SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
  }

  if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_IntEnable),
				   int_enbl_addr, 
				   sizeof(UnSignedLong), false ) == false )
  {
    SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
  }

  if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_ErrStatus),
				   err_stat_addr, 
				   sizeof(UnSignedLong), false ) == false )
  {
    SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
     
  }

  if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_ErrEnable),
				   err_enbl_addr, 
				   sizeof(UnSignedLong), false ) == false )
  {
    SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
  }

  if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_Status),
				   usb_stat_addr, 
				   sizeof(UnSignedLong), false ) == false )
  {
    SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
  }

  // read otg interrupt status
  if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_IStat),
				   otg_istat_addr, 
				   sizeof(UnSignedLong), false ) == false )
  {
    SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
  }

  USB_IntMasked = USB_IntStatus & USB_IntEnable;
  bDirection = (USB_Status >> 3) & 0x01;

  InitBDTptrs(USB_Status, &currBDT_ptr, &sendBDT_ptr, &nxtRcvBDT_ptr); 

  switch (g_CurrentTestProgress) 
    {
    case 1:
      
      // A reset interrupt
      if (USB_IntMasked == 0x01) 
	{ 	// Reset Interrupt

	  // Set the value to clear the interrupt
	  IntStatus_write = 0x01;
		
	  // at end of USB Reset set endpoint 0 control to enable RXD TXD and Setup tokens
	  UnSignedLong endpt0_ctrl = 0x0D;

	  if( g_usb_initiator->WriteBuffer( end_ctl0_addr, 
					    (AddressType)(&endpt0_ctrl), 
					    sizeof(UnSignedLong), false ) == false )
	    {
	      SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
	    }
			
	  // at end of USB Reset enable interrupts
	  UnSignedLong int_enb      = 0xB9;
	  if( g_usb_initiator->WriteBuffer( int_enbl_addr, 
					    (AddressType)(&int_enb), 
					    sizeof(UnSignedLong), false ) == false ) 
	    {
	      SystemAbort("Error Write Buffer", (g_CurrentTestProgress<<4) | 3 );
	    }

	}
      else 
	{
	  SystemAbort("Error - Did not get reset interrupt", (g_CurrentTestProgress<<4) | 1 );
      
	}

      break;

    case 2:
    case 4:
    case 6:
    case 8:
    
      // A token Done Interrupt for a setup packet
      if (USB_IntMasked == 0x08 && bDirection == 0) 
	{

	  // Make sure the packet is a setup packet
	  if (currBDT_ptr->pid == 0xd) 
	    {
	      // Value to clear interrupt
	      IntStatus_write = USB_IntMasked;

	      // Write the packet length
	      sendBDT_ptr->bytecnt = currBDT_ptr->bytecnt;

	      // Set the pid
	      sendBDT_ptr->pid = 0;

	      // Set the own bit on the transmit packet
	      sendBDT_ptr->own = 1;
	      
	      // clear txd suspend
	      UnSignedLong txd_suspend_clr = 0x01;
	      if( g_usb_initiator->WriteBuffer( usb_ctrl_addr, 
						(AddressType)(&txd_suspend_clr), 
						sizeof(UnSignedLong), false ) == false )
		{
		  SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 3 );
		}
	    }
	  else 
	    {
	      SystemAbort("Error - Not a setup packet", (g_CurrentTestProgress<<4) | 2 );
	    }
	}
      else 
	{
	  SystemAbort("Error - No token done interrupt for RX packet", (g_CurrentTestProgress<<4) | 1 );
	}	
      break;
      
      
    case 3:
    case 5:
    case 7:
    case 9:

      // Now there should be a token done interrupt caused by the respond data going out
      if (USB_IntMasked == 0x8 && bDirection == 1) // token done, tx packet
	{ 
	  // Value to clear interrupt
	  IntStatus_write = USB_IntStatus;

	  // Set the max packet size
	  nxtRcvBDT_ptr->bytecnt = 8;

	  // Set the pid
	  nxtRcvBDT_ptr->pid = 0;

	  // Set the own bit on the next RX packet
	  nxtRcvBDT_ptr->own = 1;
	}
      else
	{
	  SystemAbort("Error - No token done interrupt for TX packet", (g_CurrentTestProgress<<4) | 1);
	}
      break;

    case 10:

      // A packet should be received... and we should switch into host mode
      if (USB_IntMasked == 0x8 && bDirection == 0) // token done, rx packet
      {
	  // Check if the packet is a null data1 packet
	  if (currBDT_ptr->pid == 0x1 && currBDT_ptr->data0_1 == 0 && 
	      currBDT_ptr->bytecnt == 0)
	    {
	      IntStatus_write = USB_IntStatus;
	    }
	  else 
	    {
	      SystemAbort("Error - Packet not a NULL data1 packet", (g_CurrentTestProgress<<4) | 2 );
	    }
      	UnSignedLong turn_all_off      = 0x00;
		if( g_usb_initiator->WriteBuffer( int_enbl_addr, 
							(AddressType)(&turn_all_off), 
							sizeof(UnSignedLong), false ) == false )
		{
		  SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
		}
      }
      else 
	    {
	    SystemAbort("Error - No token done interrupt for RX packet", (g_CurrentTestProgress<<4) | 1 );	
	    }	
      break;

	case 11:

	  // Value to clear interrupt
	  IntStatus_write = USB_IntStatus;

      // this should be a line state change interrupt -- we should be in SE0 State
      if  (USB_OTG_IStat & 0x20) 

        {
         if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_Ctrl),
		    		   usb_ctrl_addr, 
				   sizeof(UnSignedLong), false ) == false )
         {
          SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
         }
         if ((USB_Ctrl & 0x40) == 0)
           {
           SystemAbort("Error Not in SE0 State -- Linestate Testing", (g_CurrentTestProgress<<4) );
           }
         if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
		  		   usb_ctrl_addr, 
				   sizeof(UnSignedLong), false ) == false )
         {
           SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
         }
         if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
		    		   otg_stat_addr, 
				   sizeof(UnSignedLong), false ) == false )
         {
          SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
         }
         if ((USB_OTG_Stat & 0x20) == 0)
           {
           SystemAbort("Error Linestate Stable Not Set -- Linestate Testing", (g_CurrentTestProgress<<4) );
           }

      }
      else 
	    {
	    SystemAbort("Error - Didn't Receive Line State Change Interrupt", (g_CurrentTestProgress<<4) | 1 );	
	    }	
      break;

    case 12:

	  // Value to clear interrupt
	  IntStatus_write = USB_IntStatus;

      // this should be a line state change interrupt -- we should be in J State
      if  (USB_OTG_IStat & 0x20) 

        {
         if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_Ctrl),
		    		   usb_ctrl_addr, 
				   sizeof(UnSignedLong), false ) == false )
         {
          SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
         }
         if ((USB_Ctrl & 0x80) == 0)
           {
           SystemAbort("Error Not in J State -- Linestate Testing", (g_CurrentTestProgress<<4) );
           }
         if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
		  		   usb_ctrl_addr, 
				   sizeof(UnSignedLong), false ) == false )
         {
           SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
         }
         if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
		    		   otg_stat_addr, 
				   sizeof(UnSignedLong), false ) == false )
         {
          SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
         }
         if ((USB_OTG_Stat & 0x20) == 0)
           {
           SystemAbort("Error Linestate Stable Not Set -- Linestate Testing", (g_CurrentTestProgress<<4) );
           }

         // turn on resume interrupt
	     UnSignedLong int_enb      = 0x20;
		 if( g_usb_initiator->WriteBuffer( int_enbl_addr, 
					    (AddressType)(&int_enb), 
					    sizeof(UnSignedLong), false ) == false ) 
		 {
	      SystemAbort("Error Write Buffer", (g_CurrentTestProgress<<4) | 3 );
		 }   

      }
      else 
	    {
	    SystemAbort("Error - Didn't Receive Line State Change Interrupt", (g_CurrentTestProgress<<4) | 1 );	
	    }	
      break;

    case 13:

       // this should be a resume interrupt -- we should be in k State

      // this should be a line state change interrupt -- we should be in J State
      if  (USB_IntStatus & 0x20) 

        {
         if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_Ctrl),
		    		   usb_ctrl_addr, 
				   sizeof(UnSignedLong), false ) == false )
         {
          SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
         }
         if ((USB_Ctrl & 0x80) | (USB_Ctrl & 0x40))
           {
           SystemAbort("Error Not in K State -- Linestate Testing", (g_CurrentTestProgress<<4) );
           }
         if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
		  		   usb_ctrl_addr, 
				   sizeof(UnSignedLong), false ) == false )
         {
           SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
         }
         if (USB_OTG_Stat & 0x20)
           {
           SystemAbort("Error Linestate Stable Still Set -- Linestate Testing", (g_CurrentTestProgress<<4) );
           }

         // turn off resume interrupt
	     UnSignedLong int_dis      = 0x00;
	     if( g_usb_initiator->WriteBuffer( int_enbl_addr, 
					    (AddressType)(&int_dis), 
					    sizeof(UnSignedLong), false ) == false ) 
	    {
	      SystemAbort("Error Write Buffer", (g_CurrentTestProgress<<4) | 3 );
	    }
	    if( g_usb_initiator->WriteBuffer( otg_ctrl_addr, 
					    (AddressType)(&int_dis), 
					    sizeof(UnSignedLong), false ) == false ) 
	    {
	      SystemAbort("Error Write Buffer", (g_CurrentTestProgress<<4) | 3 );
	    }   
     }
      else 
	    {
	    SystemAbort("Error - Didn't receive Resume Interrupt", (g_CurrentTestProgress<<4) | 1 );	
	    }	
      break;

    case 14:
		 
		 // this should be an otg ID interrupt checking id pin
		if (USB_OTG_IStat & 0x80) 
		{
			UnSignedLong turn_all_off      = 0x00;
			if( g_usb_initiator->WriteBuffer( otg_ctrl_addr, 
							(AddressType)(&turn_all_off), 
							sizeof(UnSignedLong), false ) == false )
			{
			  SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
			}

		    // read otg status
			if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
						   otg_stat_addr, 
						   sizeof(UnSignedLong), false ) == false )
			{
				SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
			}

			if( !(USB_OTG_Stat & 0x80 ) )
			{
				SystemAbort("Error - !(USB_OTG_Stat & 0x80 ) == true, ( IDStatus not set ) not expected result for this interrupt.", (g_CurrentTestProgress<<4) | 1 );
			}
		}
		else 
		{
		  SystemAbort("Error - Not an OTG ID Interrupt as expected.", (g_CurrentTestProgress<<4) | 1 );
		}

     break;

	 case 15:
         //OTG disconnect
		 // this should be an otg ID interrupt
		if (USB_OTG_IStat & 0x80) 
		{
			UnSignedLong vbus_charge_on      = 0x02;
			if( g_usb_initiator->WriteBuffer( otg_ctrl_addr, 
							(AddressType)(&vbus_charge_on), 
							sizeof(UnSignedLong), false ) == false )
			{
			  SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
			}

            //turn on session valid interript enable
			UnSignedLong enable_sess_vld_int      = 0x08;
			if( g_usb_initiator->WriteBuffer( otg_ictrl_addr, 
							(AddressType)(&enable_sess_vld_int), 
							sizeof(UnSignedLong), false ) == false )
			{
			  SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
			}

			// read otg status
			if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
						   otg_stat_addr, 
						   sizeof(UnSignedLong), false ) == false )
			{
				SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
			}

			if( (USB_OTG_Stat & 0x80 ) )
			{
				SystemAbort("Error - (USB_OTG_Stat & 0x80 ) == true,  ( IDStatus not clear ) not expected result for this interrupt.", (g_CurrentTestProgress<<4) | 1 );
			}
		}
		else 
		{
		  SystemAbort("Error - Not an OTG ID Interrupt as expected.", (g_CurrentTestProgress<<4) | 1 );
		}


     break;

	 case 16:
		 // this should be an otg session valid interrupt
		if (USB_OTG_IStat & 0x08) 
		{
			UnSignedLong all_off      = 0x00;
			if( g_usb_initiator->WriteBuffer( otg_ctrl_addr, 
							(AddressType)(&all_off), 
							sizeof(UnSignedLong), false ) == false )
			{
			  SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
			}

			// read otg status
			if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
						   otg_stat_addr, 
						   sizeof(UnSignedLong), false ) == false )
			{
				SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
			}

			if( !(USB_OTG_Stat & 0x08 ) )
			{
				SystemAbort("Error - !(USB_OTG_Stat & 0x08 ) == true, ( session valid not set ) not expected result for this interrupt.", (g_CurrentTestProgress<<4) | 1 );
			}
		}
		else 
		{
		  SystemAbort("Error - Not an otg session valid interrupt, as expected.", (g_CurrentTestProgress<<4) | 1 );
		}

     break;

	 case 17:
         
		 // this should be an otg end of session valid interrupt
		if (USB_OTG_IStat & 0x08) 
		{
			UnSignedLong vbus_discharge_on      = 0x01;
			if( g_usb_initiator->WriteBuffer( otg_ctrl_addr, 
							(AddressType)(&vbus_discharge_on), 
							sizeof(UnSignedLong), false ) == false )
			{
			  SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
			}

            //turn on vbus valid interrupt enable
			UnSignedLong enable_vbus_vld_int      = 0x01;
			if( g_usb_initiator->WriteBuffer( otg_ictrl_addr, 
							(AddressType)(&enable_vbus_vld_int), 
							sizeof(UnSignedLong), false ) == false )
			{
			  SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
			}

            // read otg status
			if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
						   otg_stat_addr, 
						   sizeof(UnSignedLong), false ) == false )
			{
				SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
			}

			if( (USB_OTG_Stat & 0x08 ) )
			{
				SystemAbort("Error - (USB_OTG_Stat & 0x08 ) == true, ( session valid not cleared ) not expected result for this interrupt.", (g_CurrentTestProgress<<4) | 1 );
			}
		}
		else 
		{
		  SystemAbort("Error - Not an otg end of session valid interrupt, as expected.", (g_CurrentTestProgress<<4) | 1 );
		}

     break;

	 case 18:
         
		 // this should be an otg vbus valid interrupt
		if (USB_OTG_IStat & 0x01) 
		{
			UnSignedLong turn_all_off      = 0x00;
			if( g_usb_initiator->WriteBuffer( otg_ctrl_addr, 
							(AddressType)(&turn_all_off), 
							sizeof(UnSignedLong), false ) == false )
			{
			  SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
			}

			// read otg status
			if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
						   otg_stat_addr, 
						   sizeof(UnSignedLong), false ) == false )
			{
				SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
			}

			if( !(USB_OTG_Stat & 0x01 ) )
			{
				SystemAbort("Error - !(USB_OTG_Stat & 0x01 ) == true,  ( vbus valid not set ) not expected result for this interrupt.", (g_CurrentTestProgress<<4) | 1 );
			}
		}
		else 
		{
		  SystemAbort("Error - Not an otg vbus valid interrupt, as expected.", (g_CurrentTestProgress<<4) | 1 );
		}

     break;

	 case 19:
         
		 // this should be an otg end of vbus valid interrupt
		if (USB_OTG_IStat & 0x01) 
		{
			UnSignedLong turn_vbus_on_and_charge_on = 0x0A;
			if( g_usb_initiator->WriteBuffer( otg_ctrl_addr, 
							(AddressType)(&turn_vbus_on_and_charge_on), 
							sizeof(UnSignedLong), false ) == false )
			{
			  SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
			}

            //turn on session end interrupt enable
			UnSignedLong enable_sess_end_int      = 0x04;
			if( g_usb_initiator->WriteBuffer( otg_ictrl_addr, 
							(AddressType)(&enable_sess_end_int), 
							sizeof(UnSignedLong), false ) == false )
			{
			  SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
			}

			// read otg status
			if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
						   otg_stat_addr, 
						   sizeof(UnSignedLong), false ) == false )
			{
				SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
			}

			if( (USB_OTG_Stat & 0x01 ) )
			{
				SystemAbort("Error - (USB_OTG_Stat & 0x01 ) == true, ( vbus valid not cleared ) not expected result for this interrupt.", (g_CurrentTestProgress<<4) | 1 );
			}
		}
		else 
		{
		  SystemAbort("Error - Not an otg end of vbus valid interrupt, as expected.", (g_CurrentTestProgress<<4) | 1 );
		}

     break;

	 case 20:
         
		 // this should be an otg b session end interrupt
		if (USB_OTG_IStat & 0x04) 
		{
			UnSignedLong turn_all_off = 0x00;
			if( g_usb_initiator->WriteBuffer( otg_ctrl_addr, 
							(AddressType)(&turn_all_off), 
							sizeof(UnSignedLong), false ) == false )
			{
			  SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
			}

			// read otg status
			if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
						   otg_stat_addr, 
						   sizeof(UnSignedLong), false ) == false )
			{
				SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
			}

			if( !(USB_OTG_Stat & 0x04 ) )
			{
				SystemAbort("Error - !(USB_OTG_Stat & 0x04 ) == true, ( b session end not set ) not expected result for this interrupt.", (g_CurrentTestProgress<<4) | 1 );
			}
		}
		else 
		{
		  SystemAbort("Error - Not an otg b session end interrupt, as expected.", (g_CurrentTestProgress<<4) | 1 );
		}

     break;

	 case 21:
         
		 // this should be an otg end of b session valid interrupt
		if ( (USB_OTG_IStat & 0x04) ) 
		{

			// read otg status
			if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_OTG_Stat),
					   otg_stat_addr, 
					   sizeof(UnSignedLong), false ) == false )
				{
				SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
				}

			if( (USB_OTG_Stat & 0x04 ) )
				{
				SystemAbort("Error - (USB_OTG_Stat & 0x04 ) == true, ( b session end not cleared ) not expected result for this interrupt.", (g_CurrentTestProgress<<4) | 1 );
				}

			// turn off OTG interrupt enables
			UnSignedLong otg_int_dis      = 0x00;
			if( g_usb_initiator->WriteBuffer( otg_ictrl_addr, 
					    (AddressType)(&otg_int_dis), 
					    sizeof(UnSignedLong), false ) == false ) 
				{
					SystemAbort("Error Write Buffer", (g_CurrentTestProgress<<4) | 3 );
				}
		}
		else 
		{
		  SystemAbort("Error - Not an otg end of b session valid interrupt, as expected.", (g_CurrentTestProgress<<4) | 1 );
		}

     break;

    case 22:

      // Should now be in host mode... this should be an SOF interrupt
      if (USB_IntMasked == 0x04) 
	{
	  IntStatus_write = 0x04;
	  UnSignedLong pid_out      = 0x10;
	  if( g_usb_initiator->WriteBuffer( hst_tokn_addr, 
					    (AddressType)(&pid_out), 
					    sizeof(UnSignedLong), false ) == false )
	    {
	      SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
	    }
	}
      else 
	{
	  SystemAbort("Error - No SOF interrupt in host mode", (g_CurrentTestProgress<<4) | 1 );
	}

      break;	
    
    case 23:

      // Token Done interrupt for TX packet
      if (USB_IntMasked == 0x8 && bDirection == 1) // token done, tx packet
	{
	  IntStatus_write = 0x08;

	  // Now send an IN token
	  UnSignedLong pid_in      = 0x90;
	  if( g_usb_initiator->WriteBuffer( hst_tokn_addr, 
					    (AddressType)(&pid_in), 
					    sizeof(UnSignedLong), false ) == false )
	    {
	      SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 2 );
	    }
	}
      else
	{
	  SystemAbort("Error - No token done interrupt for TX packet", (g_CurrentTestProgress<<4) | 1 );
	}
      break;
    
    case 24:

      // Token Done interrupt for RX packet
      if (USB_IntMasked == 0x8 && bDirection == 0) // token done, rx packet
	{
	  IntStatus_write = 0x08;
	  // Now check the returned packet
	  rcv_pkt_ptr = (UnSignedLong *) currBDT_ptr->buffer_addr;

	  for (int i=0; i<16; i++) 
	  {
	    if ( rcv_pkt_ptr[i] !=  host_pkt[i])
		{
			SystemAbort("Error Receive Packet Check", (g_CurrentTestProgress<<4 | 0x02));
		}
	  }

      // turns off host mode
	  UnSignedLong usb_ctrl = 0x00;
	  if( g_usb_initiator->WriteBuffer( usb_ctrl_addr, 
					    (AddressType)(&usb_ctrl), 
					    sizeof(UnSignedLong), false ) == false )
	    {
	      SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 0x03 );
	    }
	  UnSignedLong int_enb      = 0x00;
	  if( g_usb_initiator->WriteBuffer( int_enbl_addr, 
					    (AddressType)(&int_enb), 
					    sizeof(UnSignedLong), false ) == false ) 
	    {
	      SystemAbort("Error Write Buffer", (g_CurrentTestProgress<<4) | 3 );
	    }
	}
      else
	{
	  SystemAbort("Error - No token done interrupt for RX packet", (g_CurrentTestProgress<<4) | 1 );
		
	}
      break;


    default:
      break;
    }

	// clear the interrupt 
	if( g_usb_initiator->WriteBuffer( int_stat_addr, 
					(AddressType)(&IntStatus_write), 
					sizeof(UnSignedLong), false ) == false )
	{
		SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 15 );
	}


	// clear the interrupt 
	if( g_usb_initiator->WriteBuffer( otg_istat_addr, 
					(AddressType)(&USB_OTG_IStat), 
					sizeof(UnSignedLong), false ) == false )
	{
		SystemAbort("Error WriteBuffer", (g_CurrentTestProgress<<4) | 11 );
	}

	// read back the otg clear register
	UnSignedLong tmp;
	if( g_usb_initiator->ReadBuffer( (AddressType)(&tmp), 
									 otg_istat_addr, 
									 sizeof(UnSignedLong), false ) == false )
	{
		SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) | 11 );
	}



	if (g_CurrentTestProgress == 10)
	{
		g_DoneWithDeviceTests = true;
	}
	else
	if (g_CurrentTestProgress == 13)
	{
		g_DoneWithLineStateTests = true;
	}
	else
	if (g_CurrentTestProgress == 21)
	{
		//SystemAbort("OTG ID_PIN Tested!");
		g_DoneWithOTGTests = true;
	}
	else
	if (g_CurrentTestProgress >= 24)
	{
		//SystemAbort("Tests Completed!");
		g_DoneWithHostTests = true;
  
	}
    
}

// Get a pointer to the current BDT
void InitBDTptrs(UnSignedLong Status, 
		 BufferDescriptor **currBDT_ptr,
		 BufferDescriptor **sendBDT_ptr,
		 BufferDescriptor **nxtRcvBDT_ptr) 
{

  unsigned char *tmp = (unsigned char *)g_BufferDescriptorTablePtr; //Assign two times make compile warning go away
  BufferDescriptor *BDT_ptr = (BufferDescriptor *)tmp;

  *currBDT_ptr = &(BDT_ptr[Status>>2]);

  *sendBDT_ptr = &(BDT_ptr[(Status>>2)^0x2]);

  *nxtRcvBDT_ptr = &(BDT_ptr[(Status>>2)^0x3]);

}

///////////////////////////////////////////////////////////////////////////
// Main Hardware Create
///////////////////////////////////////////////////////////////////////////

bool AddAllIRQCallbacks()
{
  //  g_message_interface->PrintStringStdioLF( "Add the IRQ0-IRQ7 callback!");

  for( IRQNumberType i=IRQ_0; i<=IRQ_7; i = (IRQNumberType)(i + 1) )
  {
	if( g_interrupt_cntrl->AddIRQ(InterruptCallbackIRQ_5,i, 0 ) == false )
	{
	  SystemAbort("Error: Adding Interrupt for Controller Device", 0);
	}
  }

  return( true );
}


bool RemoveAllIRQCallbacks()
{
  //  g_message_interface->PrintStringStdioLF( "Add the IRQ0-IRQ7 callback!");

  for( IRQNumberType i=IRQ_0; i<=IRQ_7; i = (IRQNumberType)(i + 1) )
  {
      if( g_interrupt_cntrl->RemoveIRQ(InterruptCallbackIRQ_5,i, 0 ) == false )
	  {
		SystemAbort("Error: Adding Interrupt for Controller Device", 0);
	  }
  }

  return( true );
}

bool HardwareCreate()
{
  g_message_interface = new CMessageIO();
  g_host_dma = new CVirtualComponentInterface();
  g_usb_initiator = new CVirtualComponentInterface();
  g_interrupt_cntrl = new CInterruptControllerInterface();

  //--------------------------------------------------
  //Create a device for the tests
  //--------------------------------------------------
  //g_message_interface->PrintStringStdioLF( "Create a device for tests.");

  if( g_usb_initiator->Create("device_1_", BVCI_INITIATOR) == false )
    {
      SystemAbort("Error: Creating BVCI_INITIATOR Device", 0);
    }

  if( g_host_dma->Create("device_1_", BVCI_TARGET_CONNECTED_TO_HOST_MEMORY_DEVICE) == false )
    {
      SystemAbort("Error: Creating BVCI_TARGET_CONNECTED_TO_HOST_MEMORY_DEVICE Device", 0);
    }

  if( g_interrupt_cntrl->Create( "pirq_1_" ) == false )
    {
      SystemAbort("Error: Creating Interrupt Controller Device", 0);
    }

  SystemCreateThread( MainTestThread ); 

  return(true);
}

///////////////////////////////////////////////////////////////////////////
// Main Hardware Destroy
///////////////////////////////////////////////////////////////////////////
bool HardwareDestroy()
{
 delete g_host_dma;
 delete g_usb_initiator;
 delete g_message_interface;
 delete g_interrupt_cntrl;

  return(true);
}



///////////////////////////////////////////////////////////////////////////
// Main Software Test 
///////////////////////////////////////////////////////////////////////////
bool MainTestThread()
{	

	//Memory segments for access by the core.
	CMemorySegment host_packet_memory_segment;
	CMemorySegment host_rcv_memory_segment;
	CMemorySegment setup_address1_segment;
	CMemorySegment setup_address2_segment;

	//--------------------------------------------------
	// Test Progress Variable
	//--------------------------------------------------
	g_CurrentTestProgress = 0;
	if( SystemWait(50) == false )
	{
		return( false );
	}
	//--------------------------------------------------
	// Create a BDT in memory for the device to access
	//--------------------------------------------------
	CMemorySegment bd_table_memory_segment;

	if( bd_table_memory_segment.Create( sizeof(BufferDescriptorTableType), 512, 0 ) == false )
	{
		SystemAbort("Error: CMemorySegment::Create failed in MainTestThread!", 0);
		return( false );
	}

	//--------------------------------------------------
	//Grab the working address and assign it to the BD table pointer.
	//--------------------------------------------------
	g_BufferDescriptorTablePtr = (BufferDescriptorTableType *)bd_table_memory_segment.GetWorkingAddress();

	//--------------------------------------------------
	//Add the callback so that the interrupts will enter the function above.
	//--------------------------------------------------
	AddAllIRQCallbacks();

	//--------------------------------------------------
	//fills in the bdt memory
	//--------------------------------------------------
	if( SetMemoryForTable( g_BufferDescriptorTablePtr, setup_address1_segment, setup_address2_segment ) == false )
	{
		return( false );
	}

	//if( bd_table_memory_segment.PrintWorkingDataBytes( *g_message_interface ) == false )
	//{
	//	return( false );
	//}

	//--------------------------------------------------
	// call usb init to set up registers
	//--------------------------------------------------
	if( DevUsbInit( g_usb_initiator, g_message_interface, g_BufferDescriptorTablePtr ) == false )
	{	
		SystemAbort("Error: DEVICE Init USB!", 0);
	}

	//--------------------------------------------------
	// Wait for simple device tests to finish
	 //--------------------------------------------------
	while (g_DoneWithDeviceTests == false)
    {
		if( SystemWait(1) == false )
		{
			return( false );
		}
    }

	//--------------------------------------------------
	// now check if the hardware has a host
	//--------------------------------------------------
	UnSignedLong USB_AddInfo;

	if( g_usb_initiator->ReadBuffer( (AddressType)(&USB_AddInfo),
				   add_info_addr, 
				   sizeof(UnSignedLong), false ) == false )
	{
		SystemAbort("Error ReadBuffer", (g_CurrentTestProgress<<4) );
	}

	if (USB_AddInfo & 0x01) // host enabled
	{

	    //--------------------------------------------------
        // start otg tests
        // turn on host mode
	    //--------------------------------------------------
        UnSignedLong en_host_mode = 0x08;
        if( g_usb_initiator->WriteBuffer( usb_ctrl_addr, 
				  (AddressType)(&en_host_mode), 
				  sizeof(UnSignedLong), false ) == false )
        {
           SystemAbort("Error write buffer!", 0);
        }

       //
       UnSignedLong en_linestate_int = 0x20;
       if( g_usb_initiator->WriteBuffer( otg_ictrl_addr, 
				  (AddressType)(&en_linestate_int), 
				  sizeof(UnSignedLong), false ) == false )
       {
           SystemAbort("Error write buffer!", 0);
       }


	//--------------------------------------------------
        // Wait for linestate test to finish
        //--------------------------------------------------
	while (g_DoneWithLineStateTests == false)
    {
		if( SystemWait(1) == false )
		{
			return( false );
		}
    }

       //--------------------------------------------------
       // turn on the id_pin interrupt
       //--------------------------------------------------
       UnSignedLong en_id_int = 0x80;
       if( g_usb_initiator->WriteBuffer( otg_ictrl_addr, 
				  (AddressType)(&en_id_int), 
				  sizeof(UnSignedLong), false ) == false )
       {
			SystemAbort("Error write buffer!", 0);
       }

	   //--------------------------------------------------
       // turn on the vbus signal which loopbacks to id
	   //--------------------------------------------------
        UnSignedLong vbus_on = 0x08;
        if( g_usb_initiator->WriteBuffer( otg_ctrl_addr, 
				  (AddressType)(&vbus_on), 
				  sizeof(UnSignedLong), false ) == false )
       {
                SystemAbort("Error write buffer!", 0);
       }

		//--------------------------------------------------
        // now wait for interrupt
		//--------------------------------------------------
        while (g_DoneWithOTGTests == false)
		{
			  if( SystemWait (1) == false )
			  {
				  return( false );
			  }
		}

	    //--------------------------------------------------
        // turn off host mode to clear SOF counter
	    //--------------------------------------------------
        UnSignedLong dis_host_mode = 0x00;
        if( g_usb_initiator->WriteBuffer( usb_ctrl_addr, 
				  (AddressType)(&dis_host_mode), 
				  sizeof(UnSignedLong), false ) == false )
        {
           SystemAbort("Error write buffer!", 0);
        }

		//--------------------------------------------------
        // call host usb init to set up registers
		//--------------------------------------------------
		if( HostUsbInit( g_usb_initiator, g_message_interface, g_BufferDescriptorTablePtr, host_packet_memory_segment, host_rcv_memory_segment ) == false )
		{	
			SystemAbort("Error: HOST Init USB!", 0);
		}


        //--------------------------------------------------
		// Wait for Host test to finish
		//--------------------------------------------------
		while (g_DoneWithHostTests == false)
		{
			  if( SystemWait (1) == false )
			  {
				  return( false );
			  }
		}

        // now test the otg interrupts

 
	}


	RemoveAllIRQCallbacks();

   
	return true;
}