sl811.c

ls811的USB FAT文件系统

/*******************************Copyright (c)***************************************

                              桑海为实业发展有限公司
                         自  动  化  钢  琴  研  究  所
                           http://www.pianoshw.com
                           E-mail:[e-mail]

----------------------------------文件信息-------------------------------------------

文  件  名 : SL811.C
创  建  人 : 吴应斌
创 建 日 期: 2004-6-7 9:46
功 能 描 述: SL811-USB协议层

************************************************************************************/
#include <COMMON.H>
#include <SL811.H>
#include <HAL.H>
#include <HPI.H>

/*---------------------------------公共变量声明------------------------------------*/

extern XXGFLAGS bdata bXXGFlags;

XXGPKG usbstack;
unsigned char remainder;
extern UART_CMD_BLOCK xdata UartCmdBlock;
extern UART_RSP_BLOCK xdata UartRspBlock;
unsigned char xdata DBUF[BUFFER_LENGTH];			//512
extern unsigned char xdata UARTBUF[UARTBUF_LENGTH];	//UART收发缓冲区28672
pUSBDEV  idata	uDev;	

/*---------------------------------------------------------------------------------*/
code unsigned char cmd_test_createfile[]=
	{0x07,
	 0x54,0x45,0x53,0x54,0x20,0x20,0x20,0x20,
	 0x44,0x41,0x54,0x20,0x20,0x75,0xcd,0xb4,
	 0xe2,0x2e,0xe2,0x20,0x20,0xce,0xb4,0xe2,
	 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
	 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
	 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
	 0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
	 0x20,0x20,0x20,0x20,0x20,0x20,0x20
	 };
code unsigned char cmd_test_writefile[]=
	{
	0x09,
	0x00,
	0x00,0x70,
	0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
	0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
	0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
	0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
	0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
	0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,
	0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20
	};

void USBReset(void)
{
	unsigned char temp;
	
    temp=SL811Read(CtrlReg);   
 	SL811Write(CtrlReg,temp|0x08);
	DelayMs(25);		
	 	
    SL811Write(CtrlReg,temp);    
}

//*****************************************************************************************
// usbXfer:
// successful transfer = return TRUE
// fail transfer = return FALSE
//*****************************************************************************************
unsigned char usbXfer(void)
{  
	
	unsigned char	xferLen, data0, data1,cmd;
	unsigned char intr,result,remainder,dataX,bufLen,addr,timeout;
	
	dataX=timeout=0;
	data0 = EP0_Buf;									// DATA0 buffer address
	data1 = data0 + (unsigned char)usbstack.wPayload;	// DATA1 buffer address
	bXXGFlags.bits.DATA_STOP=FALSE;
	bXXGFlags.bits.TIMEOUT_ERR=FALSE;
	
	if (usbstack.wLen >= usbstack.wPayload)  		// select proper data payload
		xferLen = usbstack.wPayload;				// limit to wPayload size 
	else											// else take < payload len
		xferLen = usbstack.wLen;					
	
	if (usbstack.pid==PID_IN)						// for current IN tokens
	{												//
		cmd = sDATA0_RD;							// FS/FS on Hub, sync to sof
	}
	else if(usbstack.pid==PID_OUT)					// for OUT tokens
	{  	
		if(xferLen)									// only when there are	
			SL811BufWrite(data0,usbstack.buffer,xferLen); 	// data to transfer on USB
		
		cmd = sDATA0_WR;
		bXXGFlags.bits.bData1 = uDev.bData1[usbstack.endpoint];
        uDev.bData1[usbstack.endpoint] = (uDev.bData1[usbstack.endpoint] ? 0 : 1); // DataToggle
		
		if(bXXGFlags.bits.bData1)
          	cmd |= 0x40;                              // Set Data1 bit in command
	}
	else											// for current SETUP/OUT tokens
	{  	
		if(xferLen)									// only when there are	
		{
			intr=usbstack.setup.wLength;
			usbstack.setup.wValue=WordSwap(usbstack.setup.wValue);
			usbstack.setup.wIndex=WordSwap(usbstack.setup.wIndex);
			usbstack.setup.wLength=WordSwap(usbstack.setup.wLength);
			SL811BufWrite(data0,(unsigned char *)&usbstack.setup,xferLen); 	// data to transfer on USB
			usbstack.setup.wLength=intr;
		}
		cmd = sDATA0_WR;						// FS/FS on Hub, sync to sof
	}
	
	if (usbstack.endpoint == 0 && usbstack.pid != PID_SETUP) 	// for Ep0's IN/OUT token
		cmd |= 0x40; 					// always set DATA1
	
	SL811Write(EP0Status,((usbstack.endpoint&0x0F)|usbstack.pid));	// PID + EP address
	SL811Write(EP0Counter,usbstack.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
	
	/* Main loop for completing a wLen data trasnfer */
	
	while(TRUE)
	{   
		while(TRUE)												// always ensure requested device is
		{														// inserted at all time, then you will
			intr = SL811Read(IntStatus);
				
			if((intr & USB_RESET) || (intr & INSERT_REMOVE))	// proceed to parse result from slave 
			{													// device.
				bXXGFlags.bits.DATA_STOP = TRUE;								// if device is removed, set DATA_STOP
				return FALSE;									// flag true, so that main loop will 
			}													// 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
		
		/*while-----------ACK------------*/
		if (result & EP0_ACK)									// Transmission ACK
		{	
			if(usbstack.pid == PID_SETUP)								// do nothing for SETUP/OUT token 
				break;											// exit while(1) immediately

			else if(usbstack.pid == PID_OUT)
			{
				usbstack.wLen  -= (WORD)xferLen;
				usbstack.buffer += xferLen;
				
				if(!usbstack.wLen)
					break;

				if (usbstack.wLen >= usbstack.wPayload)  		// select proper data payload
					xferLen = usbstack.wPayload;			// limit to wPayload size 
				else							// else take < payload len
					xferLen = usbstack.wLen;	
				
				addr=data0;
				SL811BufWrite(addr,usbstack.buffer,xferLen);
					
				cmd = sDATA0_WR;
				bXXGFlags.bits.bData1 = uDev.bData1[usbstack.endpoint];
        		uDev.bData1[usbstack.endpoint] = (uDev.bData1[usbstack.endpoint] ? 0 : 1); // DataToggle
		
				if(bXXGFlags.bits.bData1)
          			cmd |= 0x40;   
          			 
				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
			} //PID OUT
			else if(usbstack.pid == PID_IN)
			{													// for IN token only
				usbstack.wLen  -= (WORD)xferLen;	// update remainding wLen value
				cmd	^= 0x40;    			// toggle DATA0/DATA1
				dataX ++;				// point to next dataX
				
				if(remainder==xferLen)			// empty data detected
					bufLen = 0;			// do not overwriten previous data
				else					// reset bufLen to zero
					bufLen = xferLen;		// update previous buffer length
				
				if(!remainder && usbstack.wLen)							// remainder==0 when last xferLen
				{												// was all completed or wLen!=0
					addr    = (dataX & 1) ? data1:data0; 		// select next address for data
					xferLen = (BYTE)(usbstack.wLen>=usbstack.wPayload) ? usbstack.wPayload:usbstack.wLen;	// get data length required
					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
				}				

				if(bufLen)										
				{	
					SL811BufRead(((dataX&1)?data0:data1), usbstack.buffer, bufLen);
					usbstack.buffer += bufLen;								
				}

				if(remainder || !usbstack.wLen)
					break;
			}						
		}
			
		/*----------NAK-------------------*/
		if (result & EP0_NAK)									// NAK Detected
		{														
			if(usbstack.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	break;											// normal data endpoint, exit now !!! , non-zero ep
		}
	
		/*--------TIMEOUT-----------------*/
		if (result & EP0_TIMEOUT)								// TIMEOUT Detected
		{														
			if(usbstack.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 
				bXXGFlags.bits.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
			//result=result;
			break;
		//-----------------------ERROR----------------------------
		if (result & EP0_ERROR)  								// ERROR detected
			//result=result;
			break;
	}	// end of While(1)
   
	if (result & EP0_ACK) 	// on ACK transmission
		return TRUE;		// return OK

	return FALSE;			// fail transmission

}

unsigned char ep0Xfer(void)
{
	usbstack.endpoint=0;
	usbstack.pid=PID_SETUP;
	usbstack.wLen=8;
	
	if(!usbXfer()) 
   		return FALSE;
	
	usbstack.pid  = PID_IN;
	usbstack.wLen=usbstack.setup.wLength;
	
   	if(usbstack.wLen)											// if there are data for transfer
	{
		if (usbstack.setup.bmRequest & 0x80)		// host-to-device : IN token
		{
			usbstack.pid  = PID_IN;