#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;

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;	 

	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();
}