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

// Constants
#define DELAY_COUNT   0x9248*8L  
#define _IFREQ  48000            
#define _CFREQ  48000            

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

#include "testdly.h"

// Global Variables
volatile BOOL   GotSUD;
BOOL      Rwuen;
BOOL      Selfpwr;
volatile BOOL   Sleep;     

WORD   pDeviceDscr;   
WORD   pDeviceQualDscr;
WORD   pHighSpeedConfigDscr;
WORD   pFullSpeedConfigDscr;   
WORD   pConfigDscr;
WORD   pOtherConfigDscr;   
WORD   pStringDscr;   

// Prototypes
void ParseControlTransfer(void);
void TD_Init(void);
void TD_Poll(void);
BOOL TD_Suspend(void);
BOOL TD_Resume(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 EZUSB_Delay(WORD ms);
extern void EZUSB_DELAY1MS(void); 
extern void EZUSB_Susp(void);  
void EZUSB_Resume(void);
STRINGDSCR xdata *	EZUSB_GetStringDscr(BYTE StrIdx);

const char code  EPCS_Offset_Lookup_Table[] =
{
   0,    
   1,    
   2,    
   2,    
   3,    
   3,    
   4,    
   4,    
   5,    
   5,    
};

#define epcs(EP) (EPCS_Offset_Lookup_Table[(EP & 0x7E) | (EP > 128)] + 0xE6A1)

void main(void)
{
   DWORD   i;
   WORD   offset;
   DWORD   DevDescrLen;
   DWORD   j=0;
   WORD   IntDescrAddr;
   WORD   ExtDescrAddr;

   Sleep = FALSE;         
   Rwuen = FALSE;         
   Selfpwr = FALSE;       
   GotSUD = FALSE;        

   TD_Init();

   pDeviceDscr = (WORD)&DeviceDscr;
   pDeviceQualDscr = (WORD)&DeviceQualDscr;
   pHighSpeedConfigDscr = (WORD)&HighSpeedConfigDscr;
   pFullSpeedConfigDscr = (WORD)&FullSpeedConfigDscr;
   pStringDscr = (WORD)&StringDscr;

   if ((WORD)&DeviceDscr & 0xe000)
   {
      IntDescrAddr = INTERNAL_DSCR_ADDR;
      ExtDescrAddr = (WORD)&DeviceDscr;
      DevDescrLen = (WORD)&UserDscr - (WORD)&DeviceDscr + 2;
      for (i = 0; i < DevDescrLen; i++)
         *((BYTE xdata *)IntDescrAddr+i) = 0xCD;
      for (i = 0; i < DevDescrLen; i++)
         *((BYTE xdata *)IntDescrAddr+i) = *((BYTE xdata *)ExtDescrAddr+i);
      pDeviceDscr = IntDescrAddr;
      offset = (WORD)&DeviceDscr - INTERNAL_DSCR_ADDR;
      pDeviceQualDscr -= offset;
      pConfigDscr -= offset;
      pOtherConfigDscr -= offset;
      pHighSpeedConfigDscr -= offset;
      pFullSpeedConfigDscr -= offset;
      pStringDscr -= offset;
   }

   EZUSB_IRQ_ENABLE();           
   EZUSB_ENABLE_RSMIRQ();        

   INTSETUP |= (bmAV2EN | bmAV4EN);  

   USBIE |= bmSUDAV | bmSUTOK | bmSUSP | bmURES | bmHSGRANT;  
   EA = 1;     

#ifndef NO_RENUM
   if(!(USBCS & bmRENUM))
   {
       UsbDisconnect(TRUE); 
   }
#endif

   USBCS &=~bmDISCON;

   CKCON = (CKCON&(~bmSTRETCH)) | FW_STRETCH_VALUE; 

   Sleep = FALSE;

   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;

   switch(SETUPDAT[1])
   {
      case SC_GET_DESCRIPTOR:  
         if(DR_GetDescriptor())
            switch(SETUPDAT[3])         
            {
               case GD_DEVICE: 
                  SUDPTRH = MSB(pDeviceDscr);
                  SUDPTRL = LSB(pDeviceDscr);
                  break;
               case GD_DEVICE_QUALIFIER:   
                  SUDPTRH = MSB(pDeviceQualDscr);
                  SUDPTRL = LSB(pDeviceQualDscr);
                  break;
               case GD_CONFIGURATION:      
                  SUDPTRH = MSB(pConfigDscr);
                  SUDPTRL = LSB(pConfigDscr);
                  break;
               case GD_OTHER_SPEED_CONFIGURATION: 
                  SUDPTRH = MSB(pOtherConfigDscr);
                  SUDPTRL = LSB(pOtherConfigDscr);
                  break;
               case GD_STRING:      
                  if(dscr_ptr = (void *)EZUSB_GetStringDscr(SETUPDAT[2]))
                  {
                     SUDPTRH = MSB(dscr_ptr);
                     SUDPTRL = LSB(dscr_ptr);
                  }
                  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:          
                  EP0BUF[0] = ((BYTE)Rwuen << 1) | (BYTE)Selfpwr;
                  EP0BUF[1] = 0;
                  EP0BCH = 0;
                  EP0BCL = 2;
                  break;
               case GS_INTERFACE:       
                  EP0BUF[0] = 0;
                  EP0BUF[1] = 0;
                  EP0BCH = 0;
                  EP0BCL = 2;
                  break;
               case GS_ENDPOINT:        
                  EP0BUF[0] = *(BYTE xdata *) epcs(SETUPDAT[4]) & bmEPSTALL;
                  EP0BUF[1] = 0;
                  EP0BCH = 0;
                  EP0BCL = 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)
                  {
                     *(BYTE xdata *) epcs(SETUPDAT[4]) &= ~bmEPSTALL;
                     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 if(SETUPDAT[2] == 2)
                     break;
                  else
                     EZUSB_STALL_EP0();  
                  break;
               case FT_ENDPOINT:         
                  *(BYTE xdata *) epcs(SETUPDAT[4]) |= bmEPSTALL;
                  break;
            }
         break;
      default:                 
         if(DR_VendorCmnd())
            EZUSB_STALL_EP0(); 
   }

   EP0CS |= bmHSNAK;
}

void UsbDisconnect(BOOL renum)
{
   if(renum)                              
      USBCS |= (bmDISCON | bmRENUM);      
   else
      USBCS |= bmDISCON;    
		
   EZUSB_Delay(1500);    

   USBIRQ = 0xff;        
   EPIRQ = 0xff;
   EZUSB_IRQ_CLEAR();

   USBCS &=~bmDISCON;    
}

void EZUSB_Delay(WORD ms)
{
   if ((CPUCS & bmCLKSPD) == 0)          
      ms = (ms + 1) / 2;                 
   else if ((CPUCS & bmCLKSPD) == bmCLKSPD1) 
      ms = ms * 2;

	while(ms--) ;
		EZUSB_DELAY1MS();
}

STRINGDSCR xdata * EZUSB_GetStringDscr(BYTE StrIdx)
{
	STRINGDSCR xdata *	dscr;

	dscr = (STRINGDSCR xdata *) pStringDscr;

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

	return(NULL);
}

void EZUSB_Resume(void)
{
	if( ((WAKEUPCS & bmWUEN)&&(WAKEUPCS & bmWU)) ||  
		((WAKEUPCS & bmWU2EN)&&(WAKEUPCS & bmWU2)) )
	{
		USBCS |= bmSIGRESUME;
		EZUSB_Delay(20);
		USBCS &= ~bmSIGRESUME;
	}
}

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