sl811hst.c

该原码包含有wince 和 linux 的移植和应用原码

			{
				if(++timeout >= TIMEOUT_RETRY)
				{	
				    timeout--;
					break;										// exit on the timeout detected	
				}
				SL811Write(IntStatus,INT_CLEAR);				// clear interrupt status, need to
				SL811Write(EP0Control,cmd);						// re-arm and request for last cmd again
			}
			else												
			{													// all other data endpoint, data transfer 
				TIMEOUT_ERR = TRUE;								// failed, set flag to terminate transfer
				break;											// happens when data transfer on a device
			}													// through the hub
		}

		//-----------------------STALL----------------------------
		if (result & EP0_STALL)  								// STALL detected
			return TRUE;										// for unsupported request.
																		
		//----------------------OVEFLOW---------------------------
		if (result & EP0_OVERFLOW)  							// OVERFLOW detected
			break;
		//-----------------------ERROR----------------------------
		if (result & EP0_ERROR)  								// ERROR detected
			break;
	}	// end of While(1)
   
	if (result & EP0_ACK) 	// on ACK transmission
		return TRUE;		// return OK

	return FALSE;			// fail transmission
}

//*****************************************************************************************
// Control Endpoint 0's USB Data Xfer
// ep0Xfer, endpoint 0 data transfer
//*****************************************************************************************
int ep0Xfer(BYTE usbaddr, WORD payload, pSetupPKG setup, BYTE *pData)
{
	xdata BYTE	pid  = PID_IN;
	xdata WORD	wLen = setup->wLength;		// swap back for correct length
	xdata BYTE	ep0 = 0;					// always endpoint zero

	//----------------------------------------------------
	// SETUP token with 8-byte request on endpoint 0
	//----------------------------------------------------
	if (!usbXfer(usbaddr, ep0, PID_SETUP, 0, payload, 8, (BYTE*)setup)) {
		Uart_Printf("SETUP token error\n");
   		return FALSE;
   	}

	//----------------------------------------------------
	// IN or OUT data stage on endpoint 0	
	//----------------------------------------------------
   	if (wLen)											// if there are data for transfer
	{
		if (setup->bmRequest & 0x80)					// host-to-device : IN token
		{
			pid  = PID_OUT;	
			if(!usbXfer(usbaddr, ep0, PID_IN, 0, payload, wLen, pData))
				return FALSE;
			payload = 0;
		}
		else											// device-to-host : OUT token
   		{							
			if(!usbXfer(usbaddr, ep0, PID_OUT, 0, payload, wLen, pData))
				return FALSE;
		}
	}

	//----------------------------------------------------
	// Status stage IN or OUT zero-length data packet
	//----------------------------------------------------
	if(!usbXfer(usbaddr, ep0, pid, 0, payload, 0, NULL))
		return FALSE;

	return TRUE;											
}

//*****************************************************************************************
// Control endpoint
//*****************************************************************************************
int VendorCmd(BYTE usbaddr,BYTE bReq,BYTE bCmd,WORD wValue,WORD wIndex,WORD wLen,BYTE *pData)
{ 
    xdata SetupPKG setup;

    setup.bmRequest  = bReq;
    setup.bRequest   = bCmd;
    setup.wValue     = WordSwap(wValue);
    setup.wIndex     = wIndex;
    setup.wLength    = wLen;

   	return ep0Xfer(usbaddr, uDev[usbaddr].wPayLoad[0], &setup, pData);
}

//*****************************************************************************************
// Set Device Address : 
//*****************************************************************************************
int SetAddress(WORD addr)
{
	return VendorCmd(0,0,SET_ADDRESS, WordSwap(addr), 0, 0, NULL);
}

//*****************************************************************************************
// Set Device Configuration : 
//*****************************************************************************************
int Set_Configuration(BYTE usbaddr, WORD wVal)
{
	return VendorCmd(usbaddr, 0, SET_CONFIG, WordSwap(wVal), 0, 0, NULL);
}

//*****************************************************************************************
// Get Device Descriptor : Device, Configuration, String
//*****************************************************************************************
int GetDesc(BYTE usbaddr, WORD wValue, 	WORD wIndex, WORD wLen, BYTE *desc)
{ 
	return VendorCmd(usbaddr, 0x80, GET_DESCRIPTOR, wValue, wIndex, wLen, desc);
}

//*****************************************************************************************
// HID Get_Desc :
//*****************************************************************************************
int GetHid_Desc(BYTE usbaddr, WORD wValue, WORD wLen, BYTE *desc)
{ 
	return VendorCmd(usbaddr, 0x81, GET_DESCRIPTOR, wValue, 0, wLen, desc);
}

//*****************************************************************************************
// GetHUBDesc :
//*****************************************************************************************
int GetHubDesc(BYTE usbaddr, WORD wValue, WORD wLen, BYTE *desc)
{ 
	return VendorCmd(usbaddr, 0xA0, GET_DESCRIPTOR, wValue, 0, wLen, desc);
}

//*****************************************************************************************
// Get Status : (HUB)
//*****************************************************************************************
int GetStatus(BYTE usbaddr, BYTE *desc)
{ 
	return VendorCmd(usbaddr, 0x80, GET_STATUS, 0, 0, 2, desc);		 
}

//*****************************************************************************************
// PortFeature : (SET_FEATURE, CLEAR_FEATURE)
//*****************************************************************************************
int PortFeature(BYTE usbaddr, BYTE bReq, WORD wValue, BYTE cPort)
{ 
	return VendorCmd(usbaddr, 0x23, bReq, WordSwap(wValue), WordSwap((WORD)cPort), 0, NULL);		  
}

//*****************************************************************************************
// GetPortStatus :
//*****************************************************************************************
int GetPortStatus(BYTE usbaddr, BYTE cPort, BYTE *desc)
{ 
	return VendorCmd(usbaddr, 0xA3, GET_STATUS, 0, WordSwap((WORD)cPort), 0x04, desc);
}

//*****************************************************************************************
// GetDevInfo :
//*****************************************************************************************
WORD GetDevInfo(BYTE *DevInfo)
{ 
  BYTE EpAddr;
  int i;
  BYTE DescBufLen = 0;

		for(EpAddr = 1; (EpAddr < MAX_DEV); EpAddr++)
		{
			if(uHub.bPortPresent[EpAddr])
			{
					 	DevInfo[DescBufLen++] = EpAddr;							// USB Address
 						DevInfo[DescBufLen++]	= uHub.bPortNumber[EpAddr];			// Port Number
						DevInfo[DescBufLen++] = uHub.bPortSpeed[EpAddr];			// Device Speed (from enum)
						DevInfo[DescBufLen++] = uDev[EpAddr].bClass;				// Class Type (from enum)
						(WORD)DevInfo[DescBufLen++] = uDev[EpAddr].wVID;			// VID
						DescBufLen++;
						(WORD)DevInfo[DescBufLen++] = uDev[EpAddr].wPID;			// PID
						DescBufLen++;
						DevInfo[DescBufLen++] = (BYTE)uDev[EpAddr].wPayLoad[0];	// Ep0 MaxPktSize (max 64 bytes)
						DevInfo[DescBufLen++] = uDev[EpAddr].bNumOfEPs;			// Number of data endpoints
						for(i=0;i<uDev[EpAddr].bNumOfEPs;i++)		// save all data endpoints info
						{												
							DevInfo[DescBufLen++] 	= uDev[EpAddr].bEPAddr[i+1];	// ep address/direction
							DevInfo[DescBufLen++] 	= uDev[EpAddr].bAttr[i+1];		// transfer type
							(WORD)DevInfo[DescBufLen++] = uDev[EpAddr].wPayLoad[i+1];	// max data payload
							DescBufLen++;                                       // 2 byte payload
							DevInfo[DescBufLen++] 	= uDev[EpAddr].bInterval[i+1];	// polling interval
						}	
			}
		}
		return(DescBufLen);
}

//*****************************************************************************************
// USB Data Endpoint Read/Write
// wLen is in low byte first format
//*****************************************************************************************
int DataRW(BYTE usbaddr, BYTE epaddr, WORD wPayload, WORD wLen, BYTE *pData)
{
	xdata BYTE pid = PID_OUT;

	if(epaddr & 0x80)	// get direction of transfer
		pid = PID_IN;				

	if(usbXfer(usbaddr,epaddr&0x0F,pid,0,wPayload,wLen,pData))
		return TRUE;

	return FALSE;
}

//*****************************************************************************************
// 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 
	xdata BYTE uAddr = 0;							// for enumeration to Address #0
	xdata BYTE epLen;
	xdata 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)
    EZUSB_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
		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
	//------------------------------------------------
	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
	
		Uart_Printf("VID 0x%x, PID 0x%x\n", uDev[usbaddr].wVID, uDev[usbaddr].wPID);

	//------------------------------------------------
	// 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,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;

	//------------------------------------------------