#include "DataTypes.h" 
#include "MessageIO.h"
#include "VirtualComponentInterface.h"
#include "SystemAccess.h"
#include "USB1_Common.h"


//////////////////////////////////////////////////////////
// Non-API includes
//////////////////////////////////////////////////////////
#include <memory.h>
#include <stdio.h>
//////////////////////////////////////////////////////////
// Structs
//////////////////////////////////////////////////////////
struct RegEntry
{
	char			*m_reg_name;
	AddressType		m_reg_address;
	UnSignedLong    m_reg_data;
};

//////////////////////////////////////////////////////////
// Global information
// these are the registers that are written to in the setup 
// routine.
//////////////////////////////////////////////////////////

const int g_total_reset_entries = 31;
static RegEntry g_RegResetEntryArray[g_total_reset_entries] =
{
  {"ID_FIELD",   0x00, 0x04},
  {"ID_COMP",    0x04, 0xFB},
  {"OTG_ICTRL",  0x14, 0x00},
  {"OTG_CTRL",   0x1C, 0x00},
  {"INT_ENABLE", 0x84, 0x00},
  {"ERR_STATUS", 0x88, 0x00},
  {"ERR_ENABLE", 0x8C, 0x00},
  {"ADDRESSREG", 0x98, 0x00},
  {"BDT_PAGE1",  0x9C, 0x00},
  {"FRAMENUMLOW",0xA0, 0x00},
  {"FRAMENUMHI", 0xA4, 0x00},
  {"TOKEN", 	 0xA8, 0x00},
  {"SOF_THDL",   0xAC, 0x00},
  {"BDT_PAGE2",  0xB0, 0x00},
  {"BDT_PAGE3",  0xB4, 0x00},
  {"ENDPCTL0",   0xC0, 0x00},
  {"ENDPCTL1",   0xC4, 0x00},
  {"ENDPCTL2",   0xC8, 0x00},
  {"ENDPCTL3",   0xCC, 0x00},
  {"ENDPCTL4",   0xD0, 0x00},
  {"ENDPCTL5",   0xD4, 0x00},
  {"ENDPCTL6",   0xD8, 0x00},
  {"ENDPCTL7",   0xDC, 0x00},
  {"ENDPCTL8",   0xE0, 0x00},
  {"ENDPCTL9",   0xE4, 0x00},
  {"ENDPCTL10",  0xE8, 0x00},
  {"ENDPCTL11",  0xEC, 0x00},
  {"ENDPCTL12",  0xF0, 0x00},
  {"ENDPCTL13",  0xF4, 0x00},
  {"ENDPCTL14",  0xF8, 0x00},
  {"ENDPCTL15",  0xFC, 0x00}
};

const int g_total_rdwr_entries = 9;
static RegEntry g_RegRdWrEntryArray[g_total_rdwr_entries] =
{
  {"ERR_ENABLE", 0x8C, 0xff},
  {"ADDRESSREG", 0x98, 0xef},
  {"BDT_PAGE1",  0x9C, 0xff},
  {"BDT_PAGE2",  0xB0, 0xff},
  {"BDT_PAGE3",  0xB4, 0xff},
  {"ENDPCTL0",   0xC0, 0x1f},
  {"ENDPCTL1",   0xC4, 0x1f},
  {"ENDPCTL2",   0xC8, 0x1f},
  {"ENDPCTL3",   0xCC, 0x1f}
};

const int g_total_data_checks = 4;
static UnSignedLong g_RdWrDataArray[g_total_data_checks] =
{
  0xff,
  0xaa,
  0x55,
  0x00
};

const int g_total_setup_regs = 8;
static RegEntry g_SetupRegEntryArray[g_total_setup_regs] = 
{	
    {"OTG_ICTRL",  0x14, 0x00 },
    {"OTG_CTRL",   0x1c, 0x00 },
	{"CONTROL"	 , 0x94, 0x00 },
	{"INT_ENABLE", 0x84, 0x00 },
	{"ERR_ENABLE", 0x8C, 0x00 },
	{"ADDRESSREG", 0x98, 0x00 },
	{"FRAMENUMLOW",0xA0, 0x00 },
	{"FRAMENUMHI", 0xA4, 0x00 }
};

const int g_total_enable_regs = 5;

static RegEntry g_EnableRegEntryArray[g_total_enable_regs] = 
{	
	{"INT_STATUS", 0x80, 0xFF },
	{"INT_ENABLE", 0x84, 0x01 },
	{"CONTROL"	 , 0x94, 0x02 },
	{"CONTROL"	 , 0x94, 0x01 },
    {"OTG_CTRL",   0x1c, 0x80 }

};

///////////////////////////////////////////////////////////////////////////
// Function Defines
//
// SetMemoryForTable     -- Allocates meory and initializes the BDT
// SetupTableAddressRegs -- Write the address of the BDT into USB regs.
///////////////////////////////////////////////////////////////////////////
void register_test(CVirtualComponentInterface *usb_initiator);

bool SetupTableAddressRegs(CVirtualComponentInterface *usb_initiator, 
						   CMessageIO *message_interface, 
						   BufferDescriptorTableType *bd_table_ptr);


/////////////////////////////////////////////////////////////////////////////
// DevUsbInit procedure
// allocates and initializes memory for buffer descriptors
// sets up USB 1.1 registers for a device then reads them back
// allocates and initializes the USB receive and transmit buffers
//////////////////////////////////////////////////////////////////////////////

bool DevUsbInit( CVirtualComponentInterface *usb_initiator, 
		 CMessageIO *message_interface, 
		 BufferDescriptorTableType *bd_table_ptr)
{
  

  register_test(usb_initiator);
	
  // writes the page regs.
  if( SetupTableAddressRegs( usb_initiator, message_interface, bd_table_ptr ) == false ) 
    {
      return(false);
    }

  // initializes the setup registers
  int i=0;
  for( i=0; i<g_total_setup_regs; i++ )
    {
      if( usb_initiator->WriteBuffer( (AddressType)g_SetupRegEntryArray[i].m_reg_address, (AddressType)(&(g_SetupRegEntryArray[i].m_reg_data)), sizeof(UnSignedLong), false) == false )
	{
	  SystemAbort("Error During WriteBuffer!", 7);
	}
    }


  // Disable Endpoint control registers
  //  message_interface->PrintStringStdioLF( "Disable  Endpoint control");
  for( i=0; i<g_MAX_ENDPOINTS; i++ )
    {
      UnSignedLong value = 0x00;
      if( usb_initiator->WriteBuffer( end_ctl0_addr + (i*4), (AddressType)(&(value)), sizeof(UnSignedLong), false) == false )
	{
	  SystemAbort("Error During WriteBuffer!", 7);
	}
    }

  // Enable Endpoint control registers
  for( i=0; i<g_MAX_ENDPOINTS; i++ )
    {
      UnSignedLong value = 0x0D;
      if( usb_initiator->WriteBuffer( end_ctl0_addr + (i*4), (AddressType)(&(value)), sizeof(UnSignedLong), false) == false )
	{
	  SystemAbort("Error During WriteBuffer!", 7);
	}
    }

  // now clear interrupt, enable interface and enable interrupts 
  for( i=0; i<g_total_enable_regs; i++ )
    {
      if( usb_initiator->WriteBuffer( (AddressType)g_EnableRegEntryArray[i].m_reg_address, (AddressType)(&(g_EnableRegEntryArray[i].m_reg_data)), sizeof(UnSignedLong), false) == false )
	{
	  SystemAbort("Error During WriteBuffer!", 7);
	}
    }
	
  return(true);
}

/////////////////////////////////////////////////////////////////////////////
// HostUsbInit procedure
// sets up USB 1.1 registers for a host
// initializes the USB receive transmit buffer
//////////////////////////////////////////////////////////////////////////////
//AddressType     host_pkt_addr;
//AddressType     host_rcv_addr;

bool HostUsbInit( CVirtualComponentInterface *usb_initiator, 
				  CMessageIO *message_interface, 
				  BufferDescriptorTableType *bd_table_ptr,
				  CMemorySegment& host_packet_memory_segment,
				  CMemorySegment& host_rcv_memory_segment )
{
  const int end_point_buffer_size = 64;

  //Allocate the memory for host packets.
  if( host_packet_memory_segment.Create( end_point_buffer_size, MAX_CACHE_SIZE_IN_BYTES, 0 ) == false )
  {
	  SystemAbort("Error: CMemorySegment::Create failed host_packet_memory_segment in HostUsbInit!", 0);
	  return( false );
  }

  // Setup the host packet to go out, using the allocated data segment in memory
  volatile UnSignedLong* host_pkt_ptr = (volatile UnSignedLong*) host_packet_memory_segment.GetWorkingAddress();


  //Copy all the data from the static host packet to the new allocated packet.
  for (int i=0; i<16; i++)
  {
    host_pkt_ptr[i] = host_pkt[i];
  }


  // Setup the BDT for the host packet and assign the pointer to the new packet working address.
  (*bd_table_ptr)[0][1][0].rsrvd1_0 = 0;
  (*bd_table_ptr)[0][1][0].buffer_addr = (unsigned int)host_pkt_ptr;
  (*bd_table_ptr)[0][1][0].rsrvd15_8 = 0;
  (*bd_table_ptr)[0][1][0].rsrvd31_26 = 0;
  (*bd_table_ptr)[0][1][0].bytecnt = 64;
  (*bd_table_ptr)[0][1][0].data0_1 = 0;
  (*bd_table_ptr)[0][1][0].pid = 0;
  (*bd_table_ptr)[0][1][0].own = 1;



  //Allocate the memory for host packets.
  if( host_rcv_memory_segment.Create( end_point_buffer_size, MAX_CACHE_SIZE_IN_BYTES, 0 ) == false )
  {
	  SystemAbort("Error: CMemorySegment::Create host_rcv_memory_segment failed in HostUsbInit!", 0);
	  return( false );
  }

  // Setup the BDT for the host receive packet and assign the pointer to the new packet working address.
  (*bd_table_ptr)[0][0][0].rsrvd1_0 = 0;
  (*bd_table_ptr)[0][0][0].buffer_addr = (volatile unsigned int) host_rcv_memory_segment.GetWorkingAddress();
  (*bd_table_ptr)[0][0][0].rsrvd15_8 = 0;
  (*bd_table_ptr)[0][0][0].rsrvd31_26 = 0;
  (*bd_table_ptr)[0][0][0].bytecnt = 64;
  (*bd_table_ptr)[0][0][0].data0_1 = 0;
  (*bd_table_ptr)[0][0][0].pid = 0;
  (*bd_table_ptr)[0][0][0].own = 1;

  // Clear the Error register
  UnSignedLong usb_clear_error = 0xff;
  if( usb_initiator->WriteBuffer( err_stat_addr, 
				  (AddressType)(&usb_clear_error), 
				  sizeof(UnSignedLong), false ) == false )
    {
      SystemAbort("Error Write buffer!", 0);
    }

  // clear any interrupts that have occured
  UnSignedLong usb_int_clear = 0x0E;
  if( usb_initiator->WriteBuffer( int_stat_addr, 
				  (AddressType)(&usb_int_clear), 
				  sizeof(UnSignedLong), false ) == false )
    {
      SystemAbort("Error Write buffer!", 0);
    }


  // turn off reset interrupts
  UnSignedLong usb_rst_int_dis = 0x0E;
  if( usb_initiator->WriteBuffer( int_enbl_addr, 
				  (AddressType)(&usb_rst_int_dis), 
				  sizeof(UnSignedLong), false ) == false )
    {
      SystemAbort("Error Write buffer!", 0);
    }

  // turn off the pull up and turn on the pull downs
  UnSignedLong otg_ctrl_host = 0x30;
  if( usb_initiator->WriteBuffer( otg_ctrl_addr, 
				  (AddressType)(&otg_ctrl_host), 
				  sizeof(UnSignedLong), false ) == false )
    {
      SystemAbort("Error Write buffer!", 0);
    }

  // enable host mode and do a reset
  UnSignedLong host_mode_en_rst = 0x1B;
  if( usb_initiator->WriteBuffer( usb_ctrl_addr, 
				  (AddressType)(&host_mode_en_rst), 
				  sizeof(UnSignedLong), false ) == false )
    {
      SystemAbort("Error Write buffer!", 0);
    }

  //Burn time, this should burn at least 4us at 48mhz. ( a reset needs 2us )
  if( SystemWait( 100) == false )
  {
		SystemAbort("SystemWait failed during wait for reset to complete.", 0);
  }
  
  // turn off reset
  UnSignedLong host_mode_en = 0x09;
  if( usb_initiator->WriteBuffer( usb_ctrl_addr, 
				  (AddressType)(&host_mode_en), 
				  sizeof(UnSignedLong), false ) == false )
    {
      SystemAbort("Error write buffer!", 0);
    }
    
  return(true);
}

//////////////////////////////////////////////////////////////////////
//
// SetMemoryForTable
//
// allocates memory for the Buffer Descriptor Table and initializes
// the table
// 
//////////////////////////////////////////////////////////////////////

bool SetMemoryForTable( BufferDescriptorTableType *bd_table_ptr , 
						CMemorySegment& setup_address1_segment,
						CMemorySegment& setup_address2_segment)
{
  const int end_point_buffer_size = 16;

  if( setup_address1_segment.Create( end_point_buffer_size, MAX_CACHE_SIZE_IN_BYTES, 0 ) == false )
  {
	  SystemAbort("Error: CMemorySegment::Create failed setup_address1_segment in SetMemoryForTable!", 0);
	  return( false );
  }

  if( setup_address2_segment.Create( end_point_buffer_size, MAX_CACHE_SIZE_IN_BYTES, 0 ) == false )
  {
	  SystemAbort("Error: CMemorySegment::Create failed setup_address2_segment in SetMemoryForTable!", 0);
	  return( false );
  }
 
  // BDT for the first recieved packet
  (*bd_table_ptr)[0][0][0].rsrvd1_0 = 0;
  (*bd_table_ptr)[0][0][0].buffer_addr = setup_address1_segment.GetWorkingAddress();
  (*bd_table_ptr)[0][0][0].rsrvd15_8 = 0;
  (*bd_table_ptr)[0][0][0].rsrvd31_26 = 0;
  (*bd_table_ptr)[0][0][0].bytecnt = 8;
  (*bd_table_ptr)[0][0][0].data0_1 = 0;
  (*bd_table_ptr)[0][0][0].pid = 0;
  (*bd_table_ptr)[0][0][0].own = 1;

  // BDT for the second recieved packet
  (*bd_table_ptr)[0][0][1].rsrvd1_0 = 0;
  (*bd_table_ptr)[0][0][1].buffer_addr = setup_address2_segment.GetWorkingAddress();
  (*bd_table_ptr)[0][0][1].rsrvd15_8 = 0;
  (*bd_table_ptr)[0][0][1].rsrvd31_26 = 0;
  (*bd_table_ptr)[0][0][1].bytecnt = 8;
  (*bd_table_ptr)[0][0][1].data0_1 = 1;
  (*bd_table_ptr)[0][0][1].pid = 0;
  (*bd_table_ptr)[0][0][1].own = 0;

  // BDT for the first transmit packet, point the buffer to
  // the first received buffer because we will echo that packet
  (*bd_table_ptr)[0][1][0].rsrvd1_0 = 0;
  (*bd_table_ptr)[0][1][0].buffer_addr = setup_address1_segment.GetWorkingAddress();
  (*bd_table_ptr)[0][1][0].rsrvd15_8 = 0;
  (*bd_table_ptr)[0][1][0].rsrvd31_26 = 0;
  (*bd_table_ptr)[0][1][0].bytecnt = 8;
  (*bd_table_ptr)[0][1][0].data0_1 = 0;
  (*bd_table_ptr)[0][1][0].pid = 0;
  (*bd_table_ptr)[0][1][0].own = 0;

  // BDT for the second transmit packet, point the buffer to
  // the second received buffer because we will echo that packet
  (*bd_table_ptr)[0][1][1].rsrvd1_0 = 0;
  (*bd_table_ptr)[0][1][1].buffer_addr = setup_address2_segment.GetWorkingAddress();
  (*bd_table_ptr)[0][1][1].rsrvd15_8 = 0;
  (*bd_table_ptr)[0][1][1].rsrvd31_26 = 0;
  (*bd_table_ptr)[0][1][1].bytecnt = 8;
  (*bd_table_ptr)[0][1][1].data0_1 = 1;
  (*bd_table_ptr)[0][1][1].pid = 0;
  (*bd_table_ptr)[0][1][1].own = 0;

  return( true );

}

////////////////////////////////////////////////////////////////////////
//
// SetupTableAddressRegs
//
// This procedure takes the address of the buffer descriptor table and
// splits it into the three bytes needed by the USB 1.1 page registers and
// then writes them into the USB 1.1 page registers
//
////////////////////////////////////////////////////////////////////////

bool SetupTableAddressRegs(CVirtualComponentInterface *usb_initiator, 
			   CMessageIO *message_interface, 
			   BufferDescriptorTableType *bd_table_ptr)
{
  AddressType bd_table_reg_address_0 = bdt_pag0_addr;
  AddressType bd_table_reg_address_1 = bdt_pag1_addr;
  AddressType bd_table_reg_address_2 = bdt_pag2_addr;

  UnSignedLong bd_table_reg_data_0 = (((AddressType)bd_table_ptr) & 0x0000FF00) >> 8;
  UnSignedLong bd_table_reg_data_1 = (((AddressType)bd_table_ptr) & 0x00FF0000) >> 16;
  UnSignedLong bd_table_reg_data_2 = (((AddressType)bd_table_ptr) & 0xFF000000) >> 24;
	

  if( usb_initiator->WriteBuffer( bd_table_reg_address_0, 
				  (AddressType)(&bd_table_reg_data_0), 
				  sizeof(AddressType), false) == false )
    {
      SystemAbort("Error During BDT Page Register 0 Write!", 6);
    }

  if( usb_initiator->WriteBuffer( bd_table_reg_address_1, (AddressType)(&bd_table_reg_data_1), sizeof(AddressType), false) == false )
    {
      SystemAbort("Error During BDT Page Register 1 Write!", 6);
    }

  if( usb_initiator->WriteBuffer( bd_table_reg_address_2, (AddressType)(&bd_table_reg_data_2), sizeof(AddressType), false) == false )
    {
      SystemAbort("Error During BDT Page Register 2 Write!", 6);
    }

  return(true);
}

void register_test(CVirtualComponentInterface *usb_initiator)
{

  UnSignedLong rd_data, wr_data;

  // Check the reset values of the registers
  int i=0;
  for ( i=0; i<g_total_reset_entries; i++)
    {
      if( usb_initiator->ReadBuffer( (AddressType)&rd_data, (AddressType)(g_RegResetEntryArray[i].m_reg_address), sizeof(UnSignedLong), false) == false )
	{
	  SystemAbort("Error ReadBuffer", 1 );
	}
      if ( g_RegResetEntryArray[i].m_reg_data != rd_data )
	{
	  SystemAbort("Error register reset test", 1 );
	}
    }

  // Now check the registers which are read/writeable
  int j=0;
  for ( i=0; i<g_total_data_checks; i++)
    {
      for ( j=0; j<g_total_rdwr_entries; j++)
	{
	  wr_data = g_RdWrDataArray[i] & g_RegRdWrEntryArray[j].m_reg_data;;
	  if( usb_initiator->WriteBuffer( g_RegRdWrEntryArray[j].m_reg_address, (AddressType)&wr_data, sizeof(AddressType), false) == false )
	      {
		SystemAbort("Error WriteBuffer", i+2 );
	      }
	}
      for ( j=0; j<g_total_rdwr_entries; j++)
	{
	  wr_data = g_RdWrDataArray[i] & g_RegRdWrEntryArray[j].m_reg_data;;
	  if( usb_initiator->ReadBuffer( (AddressType)&rd_data, (AddressType)(g_RegRdWrEntryArray[j].m_reg_address), sizeof(UnSignedLong), false) == false )
	    {
	      SystemAbort("Error ReadBuffer", i+2 );
	    }
	  if ( wr_data != rd_data ) 
	    {
	      SystemAbort("Error Register read write test", i+2 );
	    }
	}
    }
}