/********************************************************************************\
\*  USB.c	V1.00													    *\

\*  Copyright 2004 by SEED Electronic Technology LTD.                           *\
\*  All rights reserved. SEED Electronic Technology LTD.                        *\
\*  Restricted rights to use, duplicate or disclose this code are               *\
\*  granted through contract.    											    *\
                                             
\*	Designed by: Hongshuai.Li												    *\
\********************************************************************************/
/********************************************************************************\
\*	The usb.c routine contain several applied functions which may be used in
 USB_Test.c. *\
\********************************************************************************/

#include <csl.h>
#include <csl_emif.h>
#include <csl_irq.h>
#include <DEC6713.h>
#include "usb.h"
#include "sx2.h"

Uint32 USBTimeOut = 0x0400;
BOOL ReadFlag;
static Uint8 setupCnt = 0;
static BOOL setupDat = False;
/* global variables */
Uint8 irqValue;			 /* interrupt register value */
Uint8 SetupBuff[8];		 /* setup transaction buffer */
BOOL sx2Ready;			 /* status byte for POST */ 
BOOL sx2BusActivity;	 /* status byte for suspend */ 
BOOL sx2EnumOK;			 /* status byte for enumeration complete */
BOOL sx2EP0Buf;			 /* status for endpoint 0 buffer */
BOOL sx2Setup;			 /* setup flag set in Int0() ISR */
BOOL FLAGS_READ = False; /* FIFO */

/********************************************************************************\
\*USB_Command_Write()		-Write USB CY7C68001 command registers or endpoint 0.
\*Parameters:	To be written data.
\*Return: No.
\********************************************************************************/
Uint16 USB_Command_Write(Uint16 regdat)
{
	Uint16 *pdata;
	Uint32 Address;
	Address = USB_Base_16Add;
	Address += USB_Command_Add;
	pdata = (Uint16 *)(Address);
	*pdata = (regdat & 0x00FF);
	return TRUE;
}
	/* Note: Must judge READY status before write command register. */
	
/********************************************************************************/

/********************************************************************************\
\*USB_Command_Read()		-Read CY7C68001 command registers.
\*Parameters:	
\*Return: The related register value.
\********************************************************************************/
Uint16 USB_Command_Read()
{
	Uint16 *pdata;
	Uint32 Address = 0;	
	
	Address = USB_Base_16Add;
	Address += USB_Command_Add;
	
	pdata = (Uint16 *)Address;
	return(*pdata & 0x00FF);
}
/********************************************************************************/

/********************************************************************************\
\*SX2_Fifo_WriteSingle()
\*Parameters:
\*Returns:
\********************************************************************************/
Uint16 SX2_Fifo_WriteSingle(Uint16 USB_Fifo_Id,Uint16 USBdata)
{
	/*
 	switch(channel)
 		{
 	     case 0:
 	     		{
 	     			(*(Uint32 *)(0x90280000+(0<<2))) = USBdata;
 	     		    return(True);
 	     		}
 	     case 1:
 	     		{
 	     			(*(Uint32 *)(0x90280000+(1<<2))) = USBdata;
 	     			return(True);
 	     		}
 	     case 2:
 	      		{
 	      			(*(Uint32 *)(0x90280000+(2<<2))) = USBdata;
 	      			return(True);
 	      		}
 	     case 3:
 	     		{
 	     			(*(Uint32 *)(0x90280000+(3<<2))) = USBdata;
 	     			return(True);
 	     		}
 	     default: return(False);
 		}
 		*/
	
//	Uint32 *pdata;
	Uint32 Address;
	Address = USB_Base_16Add;
	Address += USB_Fifo_Id<<1;
    (*(Uint16 *)Address) = USBdata;
	//*pdata = USBdata;
	return True;
	
}
/********************************************************************************/

/********************************************************************************\
\*USB_Fifo_ReadSingle()		-Read FIFO data buffer.
\*Parameters:
\*Returns:
\********************************************************************************/
Uint16 SX2_Fifo_ReadSingle(Uint16 USB_Fifo_Id)
{
	Uint32 Address;
	Uint16 *pdata;
	Address = USB_Base_16Add;
	Address += USB_Fifo_Id<<1;
	pdata = (Uint16 *)Address;
	return(*pdata & 0xFFFF);
}
/********************************************************************************/
/********************************************************************************\
\*USB_ComWriteByte()		-Write to CY7C68001 command interface.
\*Parameters: The related register valve.
\*Return: True when successing,False when failuring.
\********************************************************************************/
extern BOOL USB_ComWriteByte(Uint16 value)
{
	Uint16 TimerCounter = 0;
	/* USB ready or not. */
	Uint8 StateAdd;
	
	StateAdd = DEC6713_STAT_REG;
	while(!(DEC6713_cpld_rget(StateAdd) & 0x01))
	{
		if(TimerCounter++ > USBTimeOut)
		{
			return False;
		}
	}
	
	/* USB ready */
//	while(1)
//	{
	USB_Command_Write(value);
//	}
	return True;
}
/********************************************************************************/
/********************************************************************************\
\* Write_USBReg()		-Write CY7C68001 register.
\* Parameters: Addr. Address of register.
			   Value. Value of register.
\* Return: True when successing,False when failuring.
\********************************************************************************/
Uint16 Write_SX2reg(Uint8 Addr,Uint16 value)
{
	Uint32 TimerCounter = 0;
	Uint8 StateAdd;
	Addr = Addr & 0x3F;
	/* Write address. */
	if(!USB_ComWriteByte(0x80 | Addr))
	{
		return False;
	}
	/* Write high nibble of register data. */
	USB_ComWriteByte(value >> 4 &0x0F);
	/* Write low nibble of register data. */
	USB_ComWriteByte(value  & 0x0F);
	/* Wait ready ok. */
	StateAdd = DEC6713_STAT_REG;
	while(!(DEC6713_cpld_rget(StateAdd) & 0x01))
	{
		if(TimerCounter++ > USBTimeOut)
		{
			return False;
		}
	}
	return True;
}
/********************************************************************************/
/********************************************************************************\
\* Read_USBReg()		-Read CY7C68001 register.
\* Parameters: Addr. Address of register.
			   Value. Value of register.
\* Return: True when successing,False when failuring.
\********************************************************************************/
Uint16 Read_SX2reg(Uint8 Addr,Uint16 *value)
{
//	Uint32 value;
	Uint32 TimerCounter = 0;
	Uint8 StateAdd;
	Uint32 ReadMark = 1;
	StateAdd = DEC6713_STAT_REG;
	
	while(!(DEC6713_cpld_rget(StateAdd) & 0x01))
	{
		if(TimerCounter++ > USBTimeOut)
		{
			return False;
		}
	}
	
	/* Clear the high two bit of the addr. */
	Addr = Addr & 0x3F;
	/* Write 'read register' command to SX2.  */
	USB_Command_Write(0xC0 | Addr);
	
	/* Set read flag to indicate to the interrupt routine that we
	   are expecting an interrupt to read back the contents of the
	   addressed register. The interrupt latency of the SX2 is in
	   tens of microseconds, so it's safe to write this flag after
	   the initial 'read' byte is written.  */
	/* Set ReadFlag as Ture,the interrupt routine return ReadFlag with False only. */
	ReadFlag = True;

	/* Wait for readflag to be cleared by an interrupt. */
	while(ReadMark)
	{	
		ReadMark = ReadFlag;
	}
	
	/* Wait the ready is ok. */
	StateAdd = DEC6713_STAT_REG;
	
	while(!(DEC6713_cpld_rget(StateAdd) & 0x01))
	{
		if(TimerCounter++ > USBTimeOut)
		{
			return False;
		}
	}
	
	*value = USB_Command_Read();
	//asm(" NOP");
	
	return True;
}
/********************************************************************************/
/********************************************************************************\
\* SX2_Fifo_Write()		-Write buffer to USB FIFO.
\* Parameters:	USB_Fifo_Id. The selected endpoint.
				pdata. The pointer to databuffer.
				Length. The length of databuffer.
\* Return: True when successing,False when failuring.
\********************************************************************************/
extern BOOL SX2_Fifo_Write(Uint16 USB_Fifo_Id,Uint16 *pdata,Uint16 Length)
{
	Uint16 i;
	for(i=0;i<=Length-1;i++)
	{
		//SX2_Fifo_WriteSingle(USB_Fifo_Id,pdata[i]);
		
		if(!SX2_Fifo_WriteSingle(USB_Fifo_Id,pdata[i]))
		{
			return False;
		}

	}
	return True;
}
/********************************************************************************/
/********************************************************************************\
\* USB_Fifo_Read()		-Read buffer to USB FIFO.
\* Parameters:	USB_Fifo_Id. The selected endpoint.
				pdata. The pointer to databuffer.
				Length. The length of databuffer.
\* Return: True when successing,False when failuring.
\********************************************************************************/
extern BOOL SX2_Fifo_Read(Uint16 USB_Fifo_Id,Uint16 *pdata,Uint16 Length)
{
	Uint16 i;
	for(i=0;i<=Length-1;i++)
	{
		pdata[i] = SX2_Fifo_ReadSingle(USB_Fifo_Id);
	}
	return True;
}
/********************************************************************************/
/********************************************************************************\
\* Load_Descriptor()		-Loads the descriptor memory of SX2.
\* Parameters:	Length.
				desc.
\* Return: True when successing,False when failuring.
\********************************************************************************/
extern BOOL Load_Descriptors(Uint16 Length, Uint8 *desc)
{
	Uint8 i;
	Uint8 TempValue = 0;
	/* write LSB of descriptor length,and the address of the Descriptor */
	if(!Write_SX2reg(SX2_DESC, Length))
	{
		return False;
	}

	/* write high nibble of MSB of descriptor length */
	TempValue = (Uint8)(Length>>12);
	USB_ComWriteByte(TempValue);

	TempValue = (Uint8)((Length & 0x0F00)>>8);
	/* write low nibble of MSB of descriptor length */
	USB_ComWriteByte(TempValue);
	
	
	for(i=0; i<Length; i++)
	{
		/* write high nibble of MSB of descriptor length */
		USB_ComWriteByte((desc[i] >> 4));
		/* write low nibble of MSB of descriptor length */
		USB_ComWriteByte((desc[i] & 0x0F));
	}

	return True;
}
/********************************************************************************\
\* USB_IntHandle() 	-USB interrupt handle routine. 	*\
\* Parameters:				*\
\* Return:					*\
\********************************************************************************/
extern interrupt void c_int6(void)
{
	/* During a read, an interrupt occurs after the host CPU requests a register 
	value to read. The host CPU then reads the data from the SX2. */
	if(ReadFlag)
	{
		ReadFlag = False;
	}
	/* Setup's are a special case. Whenever we get a setup 
	   the next eight interrupts represent the data of the
	   setup packet. */
	else if(setupDat)
	{
		/* read the setup data */
		SetupBuff[setupCnt++] = USB_Command_Read();
		/* stop when we have collected eight bytes */
		if(setupCnt > 7)
		{
			setupDat = False;
			sx2Setup = True;
		}
		else
		{
			USB_Command_Write(0xC0 | SX2_SETUP);
		}
     }
	/* If this is a new request, then we have to read the
		 value and parse the interrupt value. The value 
		 can't be parsed in the main loop, otherwise we could
		 get two interrupts back to back and trash the first 
		 one in the series. */
	 else
	 {
		/* read the interrupt register value */
		irqValue = USB_Command_Read();
		switch(irqValue)
		{
			case SX2_INT_SETUP:
				/* endpoint 0 setup */
				/* next eight interrupts are setup data */
				/* parse the interrupt register value */		
				setupDat = True;			
				setupCnt = 0;
				/* send read register command to SX2 */
				USB_Command_Write(0xC0 | SX2_SETUP);
				break;
			case SX2_INT_EP0BUF:
				/* endpoint 0 ready */
				sx2EP0Buf = True;
				break;
			case SX2_INT_FLAGS:
				/* FIFO flags -FF,PF,EF */
				FLAGS_READ = True;
				break;
			case SX2_INT_ENUMOK:
				/* enumeration successful */
				sx2EnumOK = True;
				break;
			case SX2_INT_BUSACTIVITY:
				/* detected either an absence or resumption of activity on the USB bus.	 */
				/* Indicates that the host is either suspending or resuming or that a 	 */
				/* self-powered device has been plugged into or unplugged from the USB.	 */
				/* If the SX2 is bus-powered, the host processor should put the SX2 into */ 
				/* a low-power mode after detecting a USB suspend condition.			 */
				sx2BusActivity = True;
				break;
			case SX2_INT_READY:
				/* awakened from low power mode via wakeup pin */
				/* or completed power on self test */
				sx2Ready = True;
				break;
			default:
				break;
			}
  	}
}
/********************************************************************************/
/*	End of USB.c	*/
/********************************************************************************/