host_811.c

sl811 c8051F驱动程序 保证绝对可以使用 USB通信协议USB1.1

//////////////////////////////////////////////////////////////////////////////
//author:dragon;www.8dragon.com
//2004年完成于桃龙源
//
//////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <c8051F020.h>
#include "host_811.h"
#include "MAIN.H"
xdata BYTE SL811H_ADDR	  _at_	0x4000;		//A0=0
xdata BYTE SL811H_DATA  _at_	0x4001;		//A0=1
//////////////////////////////////////////////////////////////////////////
BYTE   xdata bBUF[256];			// at 0x2000 for general descriptors data
USBDEV idata uDev;		// Multiple USB devices attributes, Max 5 devices
//////////////////////////////////////////////////////////////////////////
Control bdata USB_Control;  //全局命令控制变量
BYTE  bData1;				//乒乓操作标志
BYTE  d1,d2;
//*****************************************************************************************
// Byte Read from SL811H
// a = register address
// return = data in register
//*****************************************************************************************
BYTE SL811Read(BYTE idata 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(BYTE idata a, BYTE idata 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(BYTE addr, BYTE *s, BYTE c)
{	
	BYTE idata i;
	////////////////////////////////////////////////////////////////////////
	i=c;
	SL811H_ADDR = addr;	
   	while (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(BYTE addr, BYTE *s, BYTE c)
{	
	SL811H_ADDR = addr;	
   	while (c--) 
		SL811H_DATA = *s++;
}
void DelayMs(BYTE nFactor)
{
	BYTE i;
	BYTE j;
	
	for(i=0; i<nFactor; i++)
		{
		Clr_WDT();
		for(j=0;j<240;j++)
		       j=j;
		}
}

WORD WordSwap(WORD input)
{
	return(((input&0x00FF)<<8)|((input&0xFF00)>>8));
}
DWORD DWordSwap(DWORD dData)
{
    dData = (dData&0xff)<<24|(dData&0xff00)<<8|(dData&0xff000000)>>24|(dData&0xff0000)>>8;
	return dData;
}

void USBReset()
{
	BYTE temp;
	BYTE i;	
	////////////////////////////////////////////////////////////////////////
/*	SL811Write(cSOFcnt,0xae);
	SL811Write(CtrlReg,0x48);
	DelayMs(10);
	SL811Write(CtrlReg,0x00);
	DelayMs(10);*/
	i=SL811Read(IntStatus);
	if(i&0x80)	
	{ 	
 		SL811Write(cDATASet,0xe0);
		SL811Write(cSOFcnt,0xae);
		SL811Write(CtrlReg,0x05);
		//SL811Write(0x00, 0x01);     //Arm Transfers
	}	
	SL811Write(EP0Status,0x50);
	SL811Write(EP0Counter,0x00);
    SL811Write(EP0Control,0x01);
    DelayMs(150);  
    temp=SL811Read(CtrlReg);   
 	SL811Write(CtrlReg,temp|0x08);
	DelayMs(15);		
	SL811Write(CtrlReg,temp | 0x18); 
	DelayMs(15);//Delay(200);	
	SL811Write(CtrlReg,temp | 0x08); 
	DelayMs(15);//Delay(200);
    SL811Write(CtrlReg,temp);
    DelayMs(150);
	//DelayMs(400);//Delay(2000);    
}



//*****************************************************************************************
// usbXfer:
// successful transfer = return TRUE
// fail transfer = return FALSE
//*****************************************************************************************
unsigned  char  usbXfer(BYTE usbaddr, BYTE endpoint, BYTE pid,WORD wPayload, WORD wLen, BYTE *buffer)
{  		                                                                                                                                                           
	BYTE 	cmd, result, timeout, intr;
    BYTE	xferLen, bufLen, data0, data1, dataX, addr,remainder;	
    ////////////////////////////////////////////////////////////////////////
	//------------------------------------------------
	// Default setting for usb trasnfer
	//------------------------------------------------
		//result 	  = SL811Read(EP0Status);
		//printf("result=%x\n\r",result);
	bufLen = dataX = timeout = 0;					//reset all
	data0 = EP0_Buf;								// DATA0 buffer address
	data1 = 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(data0,buffer,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
	}
	//------------------------------------------------
	// 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
	//------------------------------------------------
	// Main loop for completing a wLen data trasnfer
	//---------------------- --------------------------
	while(TRUE)
	{   
		//---------------Wait for done interrupt------------------
		while(TRUE)												// always ensure requested device is
		{	
			SL811Write(IntStatus,INT_CLEAR); 												// inserted at all time, then you will
			intr = SL811Read(IntStatus);						// wait for interrupt to be done, and 
		    intr=0x81;
			result 	  = SL811Read(EP0Status);
			remainder = SL811Read(EP0Counter);	
		
 			 DelayMs(7);
			 
			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)								
				break;											// interrupt done !!!
		}

		SL811Write(IntStatus,INT_CLEAR); 						// clear interrupt status
		result 	  = SL811Read(0x03);						// 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)
				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