{   

	return VendorCmd(usbaddr, 0, SET_CONFIG, wVal, 0, 0, NULL);
	
}

//*****************************************************************************************
// Get Device Descriptor : Device, Configuration, String
//*****************************************************************************************
		//~~device:wIndex應(yīng)該為0,wValue應(yīng)該是0x10;
		//~~configuration:wIndex應(yīng)該為0,wValue應(yīng)該為0x20
		//~~string:wIndex應(yīng)該為與字符串有關(guān)的語言id,wValue為0x30
int GetDesc(BYTE usbaddr, WORD wValue, 	WORD wIndex, WORD wLen, BYTE *desc)
{ 
	return VendorCmd(usbaddr, 0x80, GET_DESCRIPTOR, wValue, wIndex, wLen, desc);
}

//*****************************************************************************************
// USB Device Enumeration Process
// Support 1 confguration and interface #0 and alternate setting #0 only
// Support up to 1 control endpoint + 4 data endpoint only
//*****************************************************************************************
int EnumUsbDev(BYTE usbaddr)
{  
	int i;											// always reset USB transfer address 
	BYTE  uAddr = 0;			// for enumeration to Address #0//~~獲取地址前用此地址通信
	BYTE  epLen;
	WORD  strLang;

	//------------------------------------------------
	// Reset only Slave device attached directly
	//------------------------------------------------
	uDev[0].wPayLoad[0] = 64;						// default 64-byte payload of Endpoint 0, address #0
	if(usbaddr == 1)			//~~為什么要判斷? bus reset for the device attached to SL811HS only
		USBReset();									// that will always have the USB address = 0x01 (for a hub)
    	USB_Delay(25);

	//------------------------------------------------
	// Get USB Device Descriptors on EP0 & Addr 0
	// with default 64-byte payload
	//------------------------------------------------
	pDev =(pDevDesc)DBUF;							// ask for 64 bytes on Addr #0
	if (!GetDesc(uAddr,DEVICE,0,18,DBUF))			// and determine the wPayload size
													//~~device描述符長度18,先用uaddr=0地址來通信
		return FALSE;								// get correct wPayload of Endpoint 0
	
	uDev[usbaddr].wPayLoad[0]=pDev->bMaxPacketSize0;// on current non-zero USB address

	//------------------------------------------------
	// Set Slave USB Device Address
	//------------------------------------------------
	if (!SetAddress(usbaddr)) 						// set to specific USB address
		return FALSE;								//
	uAddr = usbaddr;								// transfer using this new address

	//------------------------------------------------
	// Get USB Device Descriptors on EP0 & Addr X//~~為什么又要讀device descriptors
	//------------------------------------------------
	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,(0x00ff&(WORD)(uDev[usbaddr].iMfg))|STRING,strLang,4,DBUF))
		return FALSE;								// get iManufacturer String descriptors
if (!GetDesc(uAddr,(0x00ff&(WORD)(uDev[usbaddr].iMfg))|STRING,strLang,pStr->bLength,DBUF)) 		
		return FALSE;			

	//------------------------------------------------
	// Get Slave USB Configuration Descriptors
	//------------------------------------------------
	pCfg = (pCfgDesc)DBUF;									
	if (!GetDesc(uAddr,CONFIGURATION,0,8,DBUF)) 		
		return FALSE;			
		//Uart_Printf("%x\n",pCfg->wLength);
		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)
		uDev[usbaddr].bEPAddr[i]  	= pEnp->bEPAdd;			// Ep address and direction
		uDev[usbaddr].bAttr[i]		= pEnp->bAttr;			// Attribute of Endpoint
			if(i==2)
				uDev[usbaddr].wPayLoad[2] 	=0x40;
			else	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;

	}
	return TRUE;
}


//*****************************************************************************************
// Full-speed and low-speed detect - Device atttached directly to SL811HS
//*****************************************************************************************
int speed_detect() 
{
	SLAVE_FOUND	= FALSE;				// Clear USB device found flag
	FULL_SPEED  = TRUE;					// Assume full speed 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
	USB_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
	USB_Delay(10);					// Delay for HW stablize

	if(SL811Read(IntStatus)&USB_RESET)
	{									// test for USB reset
		SL811Write(IntStatus,INT_CLEAR);// Clear Interrupt enable status
		USB_Delay(30);				// Blink LED - waiting for slave USB plug-in
		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         
		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
	}

	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

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


//*****************************************************************************************
// Detect USB Device  檢測USB  設(shè)備
//*****************************************************************************************
int slave_detect(void)
{
	//-------------------------------------------------------------------------
	// 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
			}	
		}
	}
	
	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
		SL811Write(IntStatus,INT_CLEAR); 			// clear interrupt status
		return TRUE;								// exit now !!!
	}
	return FALSE;
}
*/
//*****************************************************************************************
// SL811H variables initialization
//*****************************************************************************************

void sl811h_init(void)
{	
	SL811H_DATA = 0x00;
	SL811H_ADDR = 0x00;

	FULL_SPEED = TRUE;	
	SLAVE_FOUND = FALSE;
	SLAVE_ENUMERATED = FALSE;
	//set up Master and low Speed direct and SOF cnt high=0x2e
    	SL811Write(cSOFcnt,0x2e);
    	//SOF Counter Low=0xe0; 1ms interval
    	SL811Write(cDATASet,0xe0);
    	//setup 48MHz and EOP enable
    	SL811Write(CtrlReg, 0x05);

    	SL811Write(EP0Status, 0x50);    //Setup SOF token
    	SL811Write(EP0Counter, 0x00);     //
    	SL811Write(EP0Control, 0x01);     //start generate SOF or EOP
    	
    	USB_Delay(25);       //Hub required approx. 24.1ms
		RESET(0);//rPDATC&=(0<<12);
    	USB_Delay(5);
    	RESET(1);//rPDATC|=(1<<12);      //GPC12
}


void USB_Delay(WORD ms_time)		//~~從arm程序中copy過來的
{
	LWORD i;
	for( i = 0 ; i < 1000*ms_time ; i++ )
		;
}