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

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

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

#include "testdly.h"

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

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

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 (EZUSB_HIGHSPEED())
   {
      pConfigDscr = pHighSpeedConfigDscr;
      pOtherConfigDscr = pFullSpeedConfigDscr;
   }
   else
   {
      pConfigDscr = pFullSpeedConfigDscr;
      pOtherConfigDscr = pHighSpeedConfigDscr;
   }

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