#include "testheader.h"
#define ALLOCATE_EXTERN    
#include "testregs.h"
#include <stdio.h>

#define	DELAY_COUNT	0x9248

#define	min(a,b) (((a)<(b))?(a):(b))
#define	max(a,b) (((a)>(b))?(a):(b))

volatile BOOL	GotSUD;
BOOL		Rwuen;
BOOL		Selfpwr;
volatile BOOL	Sleep;

BOOL            RECINT0;

extern code DEVICEDSCR	DeviceDscr;   
extern code CONFIGDSCR	ConfigDscr;
extern code STRINGDSCR	StringDscr;

void ParseControlTransfer(void);

void TD_Init(void);
void TD_Poll(void);
BOOL TD_Resume(void);
BOOL TD_Suspend(void);
BOOL DR_GetDescriptor(void);
BOOL DR_SetConfiguration(void);
BOOL DR_GetConfiguration(void);
BOOL DR_SetInterface(void);
BOOL DR_GetInterface(void);
BOOL DR_GetStatus(void);
BOOL DR_ClearFeature(void);
BOOL DR_SetFeature(void);
BOOL DR_VendorCmnd(void);
//////////////////////////////////////////////////////////////////////		
void UsbDisconnect(BOOL renum);
void Delay(WORD ms);
extern void Delay1ms(void);  
extern void EZUSB_Susp(void);  
void EZUSB_Resume(void);
CONFIGDSCR*    GetConfigDscr(BYTE ConfigIdx);
STRINGDSCR*    EZUSB_GetStringDscr(BYTE StrIdx);
//////////////////////////////////////////////////////////////////////
void main(void)                                
{
	DWORD j = 0;
        
	Sleep = FALSE;			
	Rwuen = FALSE;			
        Selfpwr = TRUE;		        
	GotSUD = FALSE;			

	TD_Init();

        EUSB = 1; 

	EICON |= 0x20;	
                
	USBBAV = USBBAV | 1 & ~bmBREAK;	
 
	USBIEN |= bmSUDAV | bmSUTOK | bmSUSP | bmURES;	
	EA = 1;	

	EX0 = 1;  
        IT0=1;
	EX1 = 1;  
        IT1=1;
        
        ET0=1;
  
	while(!GotSUD)
		{
			if(!GotSUD)
				UsbDisconnect(TRUE);
			for(j=0;(j<DELAY_COUNT) && (!GotSUD);++j);
		}

	while(TRUE)			
	{
		if(GotSUD)		
		{
			ParseControlTransfer();	 
  			GotSUD = FALSE;		 
		}

		if (Sleep)
		    {
    		if(TD_Suspend())
    		    { 
    		    Sleep = FALSE;	 
    		    do
    		        {
       			    EZUSB_Susp();  
    		        }
                    while(!Rwuen && EZUSB_EXTWAKEUP());
                
    		EZUSB_Resume();	
    		TD_Resume();
    		    }   
		    }
		TD_Poll();
	}
}

void ParseControlTransfer(void)
{
        void	*dscr_ptr;
	DWORD	i;

	switch(SETUPDAT[1])    
	{		
		case SC_GET_DESCRIPTOR:				
		  	if(DR_GetDescriptor())
				switch(SETUPDAT[3])
				{       					
					case GD_DEVICE:		
						SUDPTRH = MSB(&DeviceDscr);     
						SUDPTRL = LSB(&DeviceDscr);
						break;
					case GD_CONFIGURATION:		
						if(dscr_ptr = (void *)GetConfigDscr(SETUPDAT[2]))    
						{      							
							SUDPTRH = MSB(dscr_ptr);
							SUDPTRL = LSB(dscr_ptr);
						}
						else
							EZUSB_STALL_EP0(); 
						break;
					case GD_STRING:			
						if(dscr_ptr = (void *)EZUSB_GetStringDscr(SETUPDAT[2]))   
						{							
							STRINGDSCR *sdp;
							BYTE len;

							sdp = dscr_ptr;

							len = sdp->length;
							if (len > SETUPDAT[6]) 
								len = SETUPDAT[6];
							
							while (len)
							{
								for(i=0; i<min(len,64); i++)
									*(IN0BUF+i) = *((BYTE xdata *)sdp+i);

								EZUSB_SET_EP_BYTES(IN0BUF_ID,min(len,64));	
								len -= min(len,64);

								while(EP0CS & 0x04)
									;
							}

							EZUSB_SET_EP_BYTES(IN0BUF_ID,0);	
							EP0CS = bmHS;
						}
						else 
							EZUSB_STALL_EP0();	
						break;
					default:				
						EZUSB_STALL_EP0();		
				}
			break;
		case SC_GET_INTERFACE:						
			DR_GetInterface();
			break;
		case SC_SET_INTERFACE:						
			DR_SetInterface();
			break;
		case SC_SET_CONFIGURATION:					
			DR_SetConfiguration();
			break;
		case SC_GET_CONFIGURATION:					
			DR_GetConfiguration();
			break;
		case SC_GET_STATUS:						
			if(DR_GetStatus())
				switch(SETUPDAT[0])
				{
					case GS_DEVICE:				
						IN0BUF[0] = ((BYTE)Rwuen << 1) | (BYTE)Selfpwr;
						IN0BUF[1] = 0;
						EZUSB_SET_EP_BYTES(IN0BUF_ID,2);
						break;
					case GS_INTERFACE:			
						IN0BUF[0] = 0;
						IN0BUF[1] = 0;
						EZUSB_SET_EP_BYTES(IN0BUF_ID,2);
						break;
					case GS_ENDPOINT:			
						IN0BUF[0] = EPIO[EPID(SETUPDAT[4])].cntrl & ~bmEPBUSY;
						IN0BUF[1] = 0;
						EZUSB_SET_EP_BYTES(IN0BUF_ID,2);
						break;
					default:				
						EZUSB_STALL_EP0();		
				}
			break;
		case SC_CLEAR_FEATURE:						
			if(DR_ClearFeature())
				switch(SETUPDAT[0])
				{
					case FT_DEVICE:				
						if(SETUPDAT[2] == 1)
							Rwuen = FALSE; 		
						else
							EZUSB_STALL_EP0();	
						break;
					case FT_ENDPOINT:			
						if(SETUPDAT[2] == 0)
                                                {
							EZUSB_UNSTALL_EP( EPID(SETUPDAT[4]) );  
                                                        EZUSB_RESET_DATA_TOGGLE( SETUPDAT[4] ); 
                                                }
						else
							EZUSB_STALL_EP0();	
						break;
				}
			break;
		case SC_SET_FEATURE:					
			if(DR_SetFeature())
				switch(SETUPDAT[0])
				{
					case FT_DEVICE:			
						if(SETUPDAT[2] == 1)
							Rwuen = TRUE;	
						else
							EZUSB_STALL_EP0();	
						break;
					case FT_ENDPOINT:			
						if(SETUPDAT[2] == 0)
							EZUSB_STALL_EP( EPID(SETUPDAT[4]) ); 
						else
							EZUSB_STALL_EP0();	
						break;
				}
			break;
		default:							
			if(DR_VendorCmnd())
				EZUSB_STALL_EP0();				
	}

	EP0CS |= bmBIT1;
}
//////////////////////////////////////////////////////////////////////
void UsbDisconnect(BOOL renum)
{
    
     	USBCS &=~bmDISCOE;		
	USBCS |=bmDISCON;		
                                        
	if(renum)			
		USBCS |=bmRENUM;	
	Delay(1500);			

	USBIRQ = 0xff;			
	IN07IRQ = 0xff; 		
	OUT07IRQ = 0xff;                         
	EZUSB_IRQ_CLEAR();                      

	USBCS &=~bmDISCON;		
	USBCS |=bmDISCOE;		
}

void Delay(WORD ms)
{
	while(ms--)
		Delay1ms();             
}

CONFIGDSCR*  GetConfigDscr(BYTE ConfigIdx)
{
	BYTE		index = 0;
	WORD		length;
	CONFIGDSCR	*dscr;

	dscr = &ConfigDscr;

	while(dscr->type == CONFIG_DSCR)
	{
		 if(index++ == ConfigIdx)
			return(dscr);
		length = dscr->config_len;

		SWAP_ENDIAN(length);  
		dscr = (CONFIGDSCR code *)((WORD)dscr + length);

	}
	return(NULL);
}

STRINGDSCR*	EZUSB_GetStringDscr(BYTE StrIdx)
{
	BYTE		index = 0;
	STRINGDSCR*	dscr;

	dscr = &StringDscr;

	while(dscr->type == STRING_DSCR)
	{
		if(index++ == StrIdx)
			return(dscr);
		dscr = (STRINGDSCR code *)((WORD)dscr + dscr->length);
	}

	return(NULL);
}
void EZUSB_Resume(void)
{
	if(USBCS & bmRWAKEUP)
	{
		USBCS |= bmSIGRESUME;
		Delay(20);
		USBCS &= ~bmSIGRESUME;
	}
}

void resume_isr(void) interrupt WKUP_VECT
{
	EZUSB_CLEAR_RSMIRQ();    
}

void ISR_IDTHALF(void) interrupt INT0_VECT
{
     RECINT0=TRUE;
}

void ISR_IDTFULL(void) interrupt INT1_VECT
{
     RECINT0=TRUE;
}

void ISR_TINER0(void) interrupt TMR0_VECT
{           
      BYTE temp;
      temp=PINSC;      
      OUTC = (~(temp&0x01))&(temp|0x01);
}