host_811.c

arm（s3c440b）读写u盘源程序

#include "host_811.h"
#include "DataType.h"
#include "console.h"
#include "UFI.h"
#include "FAT.h"
/////////////////////////////////////////////////////////////////////////
USBDEV   uDev;		// 设备描述符号
Control  USB_Control;  //全局命令控制变量
BYTE	bData1;
//*****************************************************************************************
// Byte Read from SL811H
// a = register address
// return = data in register
//*****************************************************************************************
U8 SL811Read(U8 a)
{  
	SL811H_ADDR=a;
	return SL811H_DATA;
	
}

//*****************************************************************************************
// Byte Write to SL811H
// a = register address
// d = data to be written to this register address
//*****************************************************************************************
void SL811Write(U8 a, U8 d)
{  
	SL811H_ADDR=a;
	SL811H_DATA=d;
}
//*****************************************************************************************
// Buffer Read from SL811H
// addr = buffer start address
// s    = return buffer address where data are to be save/read
// c	= buffer data length
//*****************************************************************************************
void SL811BufRead(U8 addr, U8 *s, U8 c)
{	
	U8 i;
	SL811H_ADDR=addr;
	
	for(i=0;i<c;i++)
		*s++ =SL811H_DATA;
}
//*****************************************************************************************
// Buffer Write  to SL811H
// addr = buffer start address
// s    = buffer address where data are to be written
// c	= buffer data length
//*****************************************************************************************
void SL811BufWrite(U8 addr, U8 *s, U8 c)
{	
	SL811H_ADDR=addr;
	while (c--) 
		SL811H_DATA = *s++;	
		
}
U8 SL811_GetRev(void)
{
	return SL811Read(0x0e);
		
}
//*****************************************************************************************
//Reverse the order of  two the Byte
//
//*****************************************************************************************
U16 WordSwap(U16 input)
{
	return(((input&0x00FF)<<8)|((input&0xFF00)>>8));
}
//*****************************************************************************************
//Reverse the order of  four the Byte
//
//*****************************************************************************************
U32 DWordSwap(U32 dData)
{
    dData = (dData&0xff)<<24|(dData&0xff00)<<8|(dData&0xff000000)>>24|(dData&0xff0000)>>8;
	return dData;
}

//*****************************************************************************************
// UsbReset during enumeration of device attached directly to SL811HS
//*****************************************************************************************

void USBReset()
{
	
	U8 temp;
    	temp=SL811Read(CtrlReg);   
 	SL811Write(CtrlReg,temp|0x08);
	Delay(250);		
    	SL811Write(CtrlReg,temp);
}
//*****************************************************************************************
// usbXfer:
// successful transfer = return TRUE
// fail transfer = return FALSE
//*****************************************************************************************
BYTE usbXfer(BYTE usbaddr, BYTE endpoint, BYTE pid,WORD wPayload, WORD wLen, BYTE *buffer)
{  
	BYTE 	cmd, result, timeout, intr,bEnd,offset;
    BYTE	xferLen, bufLen, data0, data1, dataX, addr,remainder;	
    ////////////////////////////////////////////////////////////////////////
	//------------------------------------------------
	// Default setting for usb trasnfer
	//------------------------------------------------
	bufLen = dataX = timeout = bEnd=0;					//reset all
	data0 = EP0_Buf;								// DATA0 buffer address
	offset=0;
	data1 =EP1_Buf;               //data0 + (BYTE)wPayload;					// DATA1 buffer address
	USB_Control.DATA_STOP =	USB_Control.TIMEOUT_ERR = FALSE;				// set default conditions
	//------------------------------------------------
	// Define data transfer payload
	//------------------------------------------------
	if (wLen >= wPayload)  							// select proper data payload
		xferLen = wPayload;							// limit to wPayload size 
	else											// else take < payload len
		xferLen = wLen;								//	

	//------------------------------------------------
	// For IN token
	//------------------------------------------------
	if (pid==PID_IN)								// for current IN tokens
	{
		cmd=sDATA0_RD;
	}
	//------------------------------------------------
	// For OUT token
	//------------------------------------------------
	else if(pid==PID_OUT)							// for OUT tokens
	{  	
	/*	if(xferLen)									// only when there are	
			SL811BufWrite((int)data0,buffer,(int)xferLen); 	// data to transfer on USB
		cmd=sDATA0_WR;
		bData1 = uDev.bData1[endpoint];
        uDev.bData1[endpoint] = (uDev.bData1[endpoint] ? 0 : 1); // DataToggle
		if(bData1)
			cmd |= 0x40;                             // Set Data1 bit in command
		*/
		SL811BufWrite(data0,(U8 *)buffer,xferLen); 	// data to transfer on USB
		cmd = sDATA0_WR;
								// FS/FS on Hub, sync to sof
		if(uDev.bData1[0]==1)
          		{
          		cmd |= 0x40;                              // Set Data1 bit in command
          		uDev.bData1[0]=0;
          		}
  		else
		uDev.bData1[0]=1;        	
          	
			wLen  -= (WORD)xferLen;
			buffer += xferLen;
		
        if(wLen)                               //write buffer for ping-pong
                {
					SL811BufWrite(data1,buffer,64);
                    wLen-= 64;
                    buffer+=64;
                    dataX++;
                }
        else
               bEnd = 1;
	}
	//------------------------------------------------
	// For SETUP/OUT token
	//------------------------------------------------
	else											// for current SETUP/OUT tokens
	{  	
		if(xferLen)									// only when there are	
			SL811BufWrite(data0,buffer,xferLen); 	// data to transfer on USB
		cmd = sDATA0_WR;
		
	}	
	//------------------------------------------------
	// For EP0's IN/OUT token data, start with DATA1
	// Control Endpoint0's status stage.
	// For data endpoint, IN/OUT data, start ????
	//------------------------------------------------
	if (endpoint == 0 && pid != PID_SETUP) 			// for Ep0's IN/OUT token
		cmd |= 0x40; 								// always set DATA1
		
	//------------------------------------------------
	// Arming of USB data transfer for the first pkt
	//------------------------------------------------
	SL811Write(EP0Status,((endpoint&0x0F)|pid));	// PID + EP address
	SL811Write(EP0Counter,usbaddr);					// USB address
	SL811Write(EP0Address,data0);					// buffer address, start with "data0"
	SL811Write(EP0XferLen,xferLen);					// data transfer length
	SL811Write(IntStatus,INT_CLEAR); 				// clear interrupt status
	SL811Write(EP0Control,cmd);						// Enable ARM and USB transfer start here

	SL811Write(EP1Status,((endpoint&0x0F)|pid));	// PID + EP address
	SL811Write(EP1Counter,usbaddr);			// USB address
	SL811Write(EP1Address,data1);					// buffer address, start with "data0"
	SL811Write(EP1XferLen,64);					// data transfer length

	//------------------------------------------------
	// Main loop for completing a wLen data trasnfer
	//---------------------- --------------------------
	while(TRUE)
	{   
		//---------------Wait for done interrupt------------------
		while(TRUE)												// always ensure requested device is
		{														// inserted at all time, then you will
			intr = SL811Read(IntStatus);						// wait for interrupt to be done, and 
			if((intr & USB_RESET) || (intr & INSERT_REMOVE))	// proceed to parse result from slave 
			{													// device.
				USB_Control.DATA_STOP = TRUE;								// if dhevice is removed, set DATA_STOP
				return FALSE;									// flag true, so that main loop will 
			}													// know tis condition and exit gracefully
			if(intr & USB_A_DONE&&(offset==0))								
				break;											// interrupt done !!!
			if((intr & USB_B_DONE)&&(offset>0))
				break;
		}

		SL811Write(IntStatus,INT_CLEAR); 						// clear interrupt status
		result 	  = SL811Read(EP0Status);						// read EP0status register
		remainder = SL811Read(EP0Counter);						// remainder value in last pkt xfer

		//-------------------------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&&(!bEnd))
				{
			
				cmd ^=0x40;	
									// always sync SOF when FS, regardless
				offset=(dataX & 1) ? 0x8:0x0;
				//SL811Write(EP0Address, (dataX & 1) ? EP1_Buf:EP0_Buf); // data buffer addr
                                SL811Write(EP0Control+offset,cmd);
                               if(uDev.bData1[0]==1)
				uDev.bData1[0]=0;
			     else
				uDev.bData1[0]=1;     
                                if(!wLen)
					bEnd =1;
				else
				{
            			dataX++;
                                SL811BufWrite((dataX & 1) ? EP1_Buf:EP0_Buf,buffer,64);
                                wLen-= 64;
                        		buffer+=64;
                        	//dataX++;
                                }
				
			} //PID OUT

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