sl811hst.c

三星公司的ARM44B0的SL811测试程序

			}													// know this condition and exit gracefully
			if(intr & USB_A_DONE)								
				break;											// interrupt done !!!
		}

		SL811Write(IntStatus,INT_CLEAR); 						// clear interrupt status
		result 	  = SL811Read(EP0Status);						// read EP0status register
		remainder = SL811Read(EP0Counter);						// remainder value in last pkt xfer
			
		Uart_Printf("EP0 Status %x\n", result);

		//-------------------------ACK----------------------------
		if (result & EP0_ACK)									// Transmission ACK
		{	

			// SETUP TOKEN
			if(pid == PID_SETUP)								// do nothing for SETUP/OUT token 
				break;											// exit while(1) immediately

			// OUT TOKEN				
			else if(pid == PID_OUT)
				break;

			// IN TOKEN
			else if(pid == PID_IN)
			{													// for IN token only
				wLen  -= (WORD)xferLen;							// update remainding wLen value
				cmd   ^= 0x40;    								// toggle DATA0/DATA1
				dataX++;										// point to next dataX

				//------------------------------------------------	
				// If host requested for more data than the slave 
				// have, and if the slave's data len is a multiple
				// of its endpoint payload size/last xferLen. Do 
				// not overwrite data in previous buffer.
				//------------------------------------------------	
				if(remainder==xferLen)							// empty data detected
					bufLen = 0;									// do not overwriten previous data
				else											// reset bufLen to zero
					bufLen = xferLen;							// update previous buffer length
				
				//------------------------------------------------	
				// Arm for next data transfer when requested data 
				// length have not reach zero, i.e. wLen!=0, and
				// last xferlen of data was completed, i.e.
				// remainder is equal to zero, not a short pkt
				//------------------------------------------------	
				if(!remainder && wLen)							// remainder==0 when last xferLen
				{												// was all completed or wLen!=0
					addr    = (dataX & 1) ? data1:data0; 		// select next address for data
					xferLen = (BYTE)(wLen>=wPayload) ? wPayload:wLen;	// get data length required
					if (FULL_SPEED)								// sync with SOF transfer
						cmd |= 0x20;							// always sync SOF when FS, regardless 
					//Uart_Printf("endpoint=%d,usbaddr=%d,data0=%d,xferLen=%d,cmd=%d",endpoint,usbaddr,data0,xferLen,cmd);
					SL811Write(EP0XferLen, xferLen); 			// select next xfer length
					SL811Write(EP0Address, addr);           	// data buffer addr 
					SL811Write(IntStatus,INT_CLEAR);			// is a LS is on Hub.
					SL811Write(EP0Control,cmd);					// Enable USB transfer and re-arm
				}				

				//------------------------------------------------
				// Copy last IN token data pkt from prev transfer
				// Check if there was data available during the
				// last data transfer
				//------------------------------------------------
				if(bufLen)										
				{	
					SL811BufRead(((dataX&1)?data0:data1), buffer, bufLen);
					buffer += bufLen;								
				}

				//------------------------------------------------
				// Terminate on short packets, i.e. remainder!=0
				// a short packet or empty data packet OR when 
				// requested data len have completed, i.e.wLen=0
				// For a LOWSPEED device, the 1st device descp,
				// wPayload is default to 64-byte, LS device will
				// only send back a max of 8-byte device descp,
				// and host detect this as a short packet, and 
				// terminate with OUT status stage
				//------------------------------------------------
				if(remainder || !wLen)
					break;
			}							
		}
		
		//-------------------------NAK----------------------------
		if (result & EP0_NAK)									// NAK Detected
		{														
			if(endpoint==0)										// on ep0 during enumeration of LS device
			{													// happen when slave is not fast enough,
				SL811Write(IntStatus,INT_CLEAR);				// clear interrupt status, need to
				SL811Write(EP0Control,cmd);						// re-arm and request for last cmd, IN token
                result = 0;                                     // respond to NAK status only
			}
			else												// normal data endpoint, exit now !!! , non-zero ep
				break;											// main loop control the interval polling
		}
		
		//-----------------------TIMEOUT--------------------------
		if (result & EP0_TIMEOUT)								// TIMEOUT Detected
		{														
			if(endpoint==0)										// happens when hub enumeration
			{
				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
// Dev contains the CRC of EP | Address
// ep0Xfer, endpoint 0 data transfer
// Return: -Fail -1    -Sucess 0   -non-zero remainder(0<wlen <setup->wlength)
//**********************************************************************************
int ep0Xfer(BYTE usbaddr, WORD payload, pSetupPKG setup, BYTE *pData)
{
	BYTE	pid  = PID_IN;
	WORD	wLen = setup->wLength;		// swap back for correct length
	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
// return:
//	-1 on failure, 0 on success > 0 if remainder
//*****************************************************************************************
int VendorCmd(BYTE usbaddr,BYTE bReq,BYTE bCmd,WORD wValue,WORD wIndex,WORD wLen,BYTE *pData)
{ 
    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