//------------------------------------------------
	if (!GetDesc(uAddr,DEVICE,0,(pDev->bLength),DBUF)) 	
		return FALSE;								// For this current device:
	uDev[usbaddr].wVID 	 = pDev->idVendor;			// save VID
	uDev[usbaddr].wPID 	 = pDev->idProduct;			// save PID
	uDev[usbaddr].iMfg 	 = pDev->iManufacturer;		// save Mfg Index
	uDev[usbaddr].iPdt 	 = pDev->iProduct;			// save Product Index

	//------------------------------------------------
	// Get String Descriptors
	//------------------------------------------------
	pStr = (pStrDesc)DBUF;	
	if (!GetDesc(uAddr,STRING,0,4,DBUF)) 			// Get string language
		return FALSE;								
	strLang = pStr->wLang;							// get iManufacturer String length
	if (!GetDesc(uAddr,(WORD)(uDev[usbaddr].iMfg<<8)|STRING,strLang,4,DBUF)) 		
		return FALSE;								// get iManufacturer String descriptors
	if (!GetDesc(uAddr,(WORD)(uDev[usbaddr].iMfg<<8)|STRING,strLang,pStr->bLength,DBUF)) 		
		return FALSE;			

	//------------------------------------------------
	// Get Slave USB Configuration Descriptors
	//------------------------------------------------
	pCfg = (pCfgDesc)DBUF;									
	if (!GetDesc(uAddr,CONFIGURATION,0,8,DBUF)) 		
		return FALSE;										
//	if (!GetDesc(uAddr,CONFIGURATION,0,WordSwap(pCfg->wLength),DBUF)) 	
	if (!GetDesc(uAddr,CONFIGURATION,0,pCfg->wLength,DBUF)) 
		return FALSE;		

	pIfc = (pIntfDesc)(DBUF + 9);					// point to Interface Descp
	uDev[usbaddr].bClass 	= pIfc->iClass;			// update to class type
	uDev[usbaddr].bNumOfEPs = (pIfc->bEndPoints <= MAX_EP) ? pIfc->bEndPoints : MAX_EP;

	//------------------------------------------------
	// Set configuration (except for HUB device)
	//------------------------------------------------

	if (uDev[usbaddr].bClass!=HUBCLASS)				// enumerating a FS/LS non-hub device
		if (!Set_Configuration(uAddr,DEVICE))		// connected directly to SL811HS
				return FALSE;

	//------------------------------------------------
	// For each slave endpoints, get its attributes
	// Excluding endpoint0, only data endpoints
	//------------------------------------------------
	epLen = 0;
	for (i=1; i<=uDev[usbaddr].bNumOfEPs; i++)				// For each data endpoint
	{
		pEnp = (pEPDesc)(DBUF + 9 + 9 + epLen);	   			// point to Endpoint Descp(non-HID)
		if(pIfc->iClass == HIDCLASS)	
			pEnp = (pEPDesc)(DBUF + 9 + 9 + 9 + epLen);		// update pointer to Endpoint(HID)
		uDev[usbaddr].bEPAddr[i]  	= pEnp->bEPAdd;			// Ep address and direction
		uDev[usbaddr].bAttr[i]		= pEnp->bAttr;			// Attribute of Endpoint
		uDev[usbaddr].wPayLoad[i] 	= pEnp->wPayLoad;		// Payload of Endpoint
		uDev[usbaddr].bInterval[i] 	= pEnp->bInterval;		// Polling interval
	       uDev[usbaddr].bData1[i] = 0;			            // init data toggle
		epLen += 7;
	}

	//------------------------------------------------
	// Get Hid Report Descriptors
	//------------------------------------------------
	if(pIfc->iClass == HIDCLASS)
	{	
		pHid = (pHidDesc)(DBUF + 9 + 9);	   				// point to HID-CLASS descp
		if (!GetHid_Desc(uAddr,HID_REPORT,pHid->wItemLength,DBUF))
			return FALSE;
	}

	//------------------------------------------------
	// Get HUB Class Specific Descriptor (per port switching)
	//------------------------------------------------
	if(uDev[usbaddr].bClass==HUBCLASS)
    {														// enumerating a HUB device		
   		pHub =(pHubDesc)DBUF;								// Ask for 71 bytes ???
	    if (!GetHubDesc(uAddr,0x00,0x47,DBUF))
			return FALSE;									// Get Hub Desriptor
		if (!GetStatus(uAddr,STATUS)) 
			return FALSE;     								// Get Status
		if (!Set_Configuration(uAddr,DEVICE))
			return FALSE;  									// Set configuration

		pNumPort = pHub->bNbrPort;							// save no. of ports available
		for(i=1; i<=pNumPort; i++)							// ClearPortFeature: C_PORT_CONNECTION off
		    if(!PortFeature(uAddr,SET_FEATURE, PORT_POWER,i))	
				return FALSE;

		for(i=1; i<=pNumPort; i++)							// SetPortFeature: PORT_POWER on
		{
		    if(!PortFeature(uAddr,CLEAR_FEATURE, C_PORT_CONNECTION, i)) 	
				return FALSE;								
		}

//		if( !GetPortStatus(uAddr,1,STATUS) ) 			//
//			return FALSE;
//		EZUSB_Delay(5);
		for(i=1; i<=pHub->bNbrPort; i++)					// GetPortStatus(wHubStatus,wHubChange)
		   if( !GetPortStatus(uAddr,i,STATUS) ) 			//
			return FALSE;								//

		if( !PortFeature(uAddr,SET_FEATURE, 0x04, 1) ) 			//
			return FALSE;
		
		for(i=2;i<=pNumPort+1;i++)							// clear port present status
		{													// address #2..#5 only
			uHub.bPortPresent[i] = 0;						// clear status
			uHub.bPortNumber[i] = 0;						//
		}
		HUB_DEVICE = TRUE;									// Set Hub flag, as long as a hub is attached 
	}														// directly to the HUB_DEVICE will be set

	return TRUE;
}

//*****************************************************************************************
// Full-speed and low-speed detect - Device atttached directly to SL811HS
//*****************************************************************************************
int speed_detect() 
{
	BYTE	TESTSTATUS;
	
	pNumPort	= 0;					// zero no. of downstream ports
	SLAVE_FOUND	= FALSE;				// Clear USB device found flag
	FULL_SPEED  = TRUE;					// Assume full speed device
	HUB_DEVICE  = FALSE;				// not HUB device
	DATA_STOP	= FALSE;				//
 
	SL811Write(cSOFcnt,0xAE);      		// Set SOF high counter, no change D+/D-, host mode
	SL811Write(CtrlReg,0x08);      		// Reset USB engine, full-speed setup, suspend disable
	EZUSB_Delay(10);					// Delay for HW stablize
	SL811Write(CtrlReg,0x00);      		// Set to normal operation
	SL811Write(IntEna,0x61);      		// USB-A, Insert/Remove, USB_Resume.
	SL811Write(IntStatus,INT_CLEAR);	// Clear Interrupt enable status
	EZUSB_Delay(10);					// Delay for HW stablize

	if(SL811Read(IntStatus)&USB_RESET)
	{									// test for USB reset
		SL811Write(IntStatus,INT_CLEAR);// Clear Interrupt enable status
		EZUSB_Delay(30);				// Blink LED - waiting for slave USB plug-in
//		LightLed(0,0);					// Keep the attach led off
//		OUTB ^= ACTIVE_BLINK;			// Blink Active LED
//		OUTA |= PORTX_LED;				// clear debug LEDs
		return 0;						// exit speed_detect()
	}

	if((SL811Read(IntStatus)&USB_DPLUS)==0)	// Checking full or low speed	
	{									// ** Low Speed is detected ** //
		SL811Write(cSOFcnt,0xEE);   	// Set up host and low speed direct and SOF cnt
		SL811Write(cDATASet,0xE0); 		// SOF Counter Low = 0xE0; 1ms interval
		SL811Write(CtrlReg,0x21);  		// Setup 6MHz and EOP enable         
		uHub.bPortSpeed[1] = 1;			// low speed for Device #1
		FULL_SPEED = FALSE;				// low speed device flag
	}
	else	
	{									// ** Full Speed is detected ** //
		SL811Write(cSOFcnt,0xAE);   	// Set up host & full speed direct and SOF cnt
		SL811Write(cDATASet,0xE0);  	// SOF Counter Low = 0xE0; 1ms interval
		SL811Write(CtrlReg,0x05);   	// Setup 48MHz and SOF enable
		uHub.bPortSpeed[1] = 0;			// full speed for Device #1
	}

//	OUTB |= ACTIVE_BLINK;				// clear Active LED
	LightLed(0,0);						// clear Active LED
	SLAVE_FOUND = TRUE;					// Set USB device found flag
	SLAVE_ENUMERATED = FALSE;			// no slave device enumeration

	SL811Write(EP0Status,0x50);   		// Setup SOF Token, EP0
	SL811Write(EP0Counter,0x00);		// reset to zero count
	SL811Write(EP0Control,0x01);   		// start generate SOF or EOP

	EZUSB_Delay(25);					// Hub required approx. 24.1mS
	SL811Write(IntStatus,INT_CLEAR);	// Clear Interrupt status
	return 0;    						// exit speed_detect();
}

//*****************************************************************************************
// Detect USB Device
//*****************************************************************************************
int slave_detect(void)
{
	int retDataRW = FALSE;
	int DevAddr;
	
	//-------------------------------------------------------------------------
	// Wait for EZUSB enumeration
	//-------------------------------------------------------------------------
	if(!CONFIG_DONE)						// start SL811H after EZ-USB is configured
		return 0;

	//-------------------------------------------------------------------------
	// Wait for SL811HS enumeration
	//-------------------------------------------------------------------------
	if(!SLAVE_ENUMERATED)					// only if slave is not configured
	{
		speed_detect();						// wait for an USB device to be inserted to 
		if(SLAVE_FOUND)						// the SL811HST host
		{
	  		if(EnumUsbDev(1))				// enumerate USB device, assign USB address = #1
			{
			   	SLAVE_ENUMERATED = TRUE;	// Set slave USB device enumerated flag
				uHub.bPortPresent[1] = 1;	// set device addr #1 present
//				Set_ezDEV(1);				// inform master of new attach/detach
			}	
		}
	}

	//-------------------------------------------------------------------------
	// SL811HS enumerated, proceed accordingly
	//-------------------------------------------------------------------------
	else									
	{													
//		OUTB &= ~ACTIVE_BLINK;				// Turn on Active LED, indicate successful slave enum
		LightLed(0,1);						// Turn on Active LED, indicate successful slave enum
		if(Slave_Detach())					// test for slave device detach ???
			return 0;						// exit now.
		//----------------------------------------------
		// HUB DEVICE Polling (Addr #1, EndPt #1)		
		//----------------------------------------------
		// Polling of Hub deivce Endpoint #1 for any Port Attachement
		// for onboard HUB device, after enumeration, start to
		// transfer IN token to check for ports attachment
		// wLen = wPayload = 1 byte, always use USB address #1
		// if return is TRUE, a data pkt was ACK, data in HubChange
		// else is a NAK, no data was received 
		if(HUB_DEVICE && dsPoll)									
		{	
			//HubPortEnum();											
			
			retDataRW = DataRW(HUB_ADDR,uDev[1].bEPAddr[1],uDev[1].wPayLoad[1],1,HubChange);
			if(retDataRW) 
			{											
				HubPortEnum();	
//				Set_ezDEV(1);                           // inform master of new attach/detach
			}
													
			EZUSB_Delay(10);							// maintain a polling interval 
		}												
	} // end of else

	return 0;
}

//*****************************************************************************************
// Slave_Detach
//*****************************************************************************************
int Slave_Detach(void)
{
	if( (SL811Read(IntStatus)&INSERT_REMOVE) || (SL811Read(IntStatus)&USB_RESET) )
	{												// Test USB detached?
		SLAVE_ENUMERATED = FALSE;					// return to un-enumeration
		uHub.bPortPresent[1] = 0;					// Device #1 not present

//		Set_ezDEV(1);								// inform master of slave detach
		SL811Write(IntStatus,INT_CLEAR); 			// clear interrupt status
		return TRUE;								// exit now !!!
	}

	return FALSE;
}


//*****************************************************************************************
// SL811H variables initialization
//*****************************************************************************************
void sl811h_init(void)
{	
	int i;

	for(i=0;i<MAX_DEV;i++)
	{
		uHub.bPortPresent[i] = 0;
		uHub.bPortNumber[i] = 0;
	}

	SL811H_DATA = 0x00;
	SL811H_ADDR = 0x00;
	pNumPort	= 0x00;			

	FULL_SPEED = TRUE;	
	HUB_DEVICE = FALSE;
	SLAVE_FOUND = FALSE;
	SLAVE_ENUMERATED = FALSE;
	BULK_OUT_DONE = FALSE;
	DESC_XFER = FALSE;
	DATA_XFER = FALSE;
	DATA_XFER_OUT = FALSE;
	DATA_INPROCESS = FALSE;
	pLS_HUB = FALSE;

    dsPoll = 1;				    // poll downstream port conections

	//----------------------------
	// SL811H + EZUSB I/Os setup
	//----------------------------
//	PORTBCFG &= 0xAC;			// Select i/o function for PB6, PB4, PB1, PB0
//	OEB      |= 0x43;			// Set  PB6(Output), PB4(Input), PB1(Output), PB0(Output) 
//	OUTB     |= 0x43;			// Default output high

//	PORTACFG &= 0x0F;			// Select i/o function for PA7~PA4
//	OEA      |= 0xF0;			// Set PA7~PA4(Output)
//	OUTA     |= 0xF0;			// Default output high

	//----------------------------
	// Debug Monitor I/Os setup
	//----------------------------
//	PORTBCFG |= 0x0C;			// Select alternate function RxD1(PB2) & RxD1(PB3)
//	PORTCCFG |= 0xC0;			// Select alternate function nWR(PC6) & nRD(PC7)
								// Also needed for SL811H
	//----------------------------
	// SL811HST hardware reset
	//----------------------------

	
//	OUTB &= ~nRESET;			// reset SL811HST
//    PCDATDIR &= 0xFFFE;  //Pc.0 standard io
//	EZUSB_Delay(5);				// for 5ms
//	PCDATDIR |= 0x0001;  //Pc.0 standard io
//	OUTB |= nRESET;				// clear reset
//	OUTB &= ~nHOST_SLAVE_MODE;	// set to Host mode
}