sl811hs.c

SL811HS USB CHIP 使用及控制程序

//***************************************************************************************************
//SL811HS.C
//**********************************************************************************************
// Byte Write to SL811H
// addr = register address
// cData = data to be written to this register address
//**********************************************************************************************
#include <SL811HS.h>
//***********************************************************************************************
void SL811HSWrite(U8 addr,U8 cData)
{
	WriteAddressEN;
	USB_CS = addr;
	WriteDataEN;
	USB_CS = cData;
}
//**********************************************************************************************
// Byte Read from SL811H
// addr = register address
// return = data in register
//**********************************************************************************************
U8 SL811HSRead(U8 addr)
{
	U8 cdata;
	
	WriteAddressEN;
	USB_CS = addr;
	WriteDataEN;
	cdata=USB_CS;
	return(cdata);
}
//*********************************************************************************************
// Buffer Read from SL811H
// addr = buffer start address
// buffer    = return buffer address where data are to be save/read
// cLen	= buffer data length
//*********************************************************************************************
void SL811HSBulkRead(U8 addr,U8 *buffer,U16 cLen)
{
	if(cLen<=0) 
		return;
	WriteAddressEN;
	USB_CS = addr;
	WriteDataEN;
	while(cLen)
		{
			*buffer =USB_CS;
			buffer++;
			cLen--;
		}
}
//********************************************************************************************
// Buffer Write  to SL811H
// addr = buffer start address
// buffer  = buffer address where data are to be written
// cLen	= buffer data length
//********************************************************************************************
void SL811HSBulkWrite(U8 addr,U8 *buffer,U16 cLen)
{
	if(cLen<=0)
		return;
	WriteAddressEN;
	USB_CS = addr;
	WriteDataEN;
	while(cLen)
		{
			USB_CS =*buffer;
			buffer++;
			cLen--;
		}
}
//********************************************************************************************
//usb initial when system on
//********************************************************************************************
void USBInitial(void)
{
	//SL811HSWrite(IntEna,0x60);
	//Delay(T10ms);
	SL811HSWrite(EP0Status,0xc0);
	SL811HSWrite(0x07,0xc0);
	USBAddress=0;
	SL811HSWrite(EP0Counter,0x00);
	SL811HSWrite(EP0Address,MemStart);
	SL811HSWrite(EP0XferLen,ENP_LEN);
	SL811HSWrite(EP0Control,0x00);
	SL811HSWrite(CtrlReg,0x08);
	Delay(T10ms);
	SL811HSWrite(CtrlReg,0x01);
	SL811HSWrite(DATASet,0xe0);
	SL811HSWrite(CSOFcnt,0xae);
	SL811HSWrite(IntEna,0x73);
	SL811HSWrite(CtrlReg,0x05);
	SL811HSWrite(EP0Control,0x01);
}
//****************************************************************************************
//test sl811hs Reg(0x10...0xff)
//****************************************************************************************
void USBRWTest(void)
{
	U8 addr;

	//------------------------------------------------------
	addr=MemStart;
	while(addr<MemEND)
		{
			SL811HSWrite(addr,addr);   //write test data
			addr++;
		}
	//-----------------------------------------------------
	addr=MemStart;
	while(addr<MemEND)
		{
			if(SL811HSRead(addr)!=addr)  //read test data
				ShowError(SL811HSRWNG);
			addr++;
		}
}
//***************************************************************************************
// usbXfer:
// successful transfer = return TRUE
// fail transfer = return FALSE
//***************************************************************************************
//void USBXfer(U8 usbaddr,U8 EndPoint,U8 pid,U16 leng,U8 *buffer)
void USBXfer(U8 USBaddress,U8 EndPoint,U8 pid,U8 *Buffer,U32 DataLengh)
{
	U8 cLen;
	U8 cEnd;
	U8 CountA;

	SL811HSWrite(EP0Address,MemStart);
	SL811HSWrite(EP0Status,((pid & 0xf0)+(EndPoint & 0x0f)));
	SL811HSWrite(EP0Counter,USBaddress);
	do
		{
			cEnd=FALSE;
			if(DataLengh>ENP_LEN)
				{
					cLen=ENP_LEN;
					DataLengh=DataLengh-cLen;
				}
			else
				{
					cLen=DataLengh;
					DataLengh=DataLengh-cLen;
				}
			SetInterrupt(InterruptT1s*20); //20s
			//--------------------------------------------------------
			if(pid!=PID_IN)
				SL811HSBulkWrite(MemStart,Buffer,cLen);
			//--------------------------------------------------------
			while(cEnd==FALSE)
				{
					if(pid==PID_IN)
						{
							SL811HSWrite(EP0XferLen,cLen);
							if(FlagDataType==DATA0)
								SL811HSWrite(EP0Control,(0x27 & XBit2));
							else 
								SL811HSWrite(EP0Control,(0x67 & XBit2));
						}
					else //
						{
							SL811HSWrite(EP0XferLen,cLen);
							if(FlagDataType==DATA0)
								SL811HSWrite(EP0Control,0x27);
							else 
								SL811HSWrite(EP0Control,0x67);
						}
					//--------------------------------------------------------
					//check USB Transfer End
					CountA=0;
					while((SL811HSRead(EP0Control) & 0x01)==1)
						{
							if(FlagDelay!=1) 
								ShowError(UsbTimeOut);
								CountA++;
							if(CountA>200)
								break;
						}
					//--------------------------------------------------------
					//CHECK ACK
					if((SL811HSRead(EP0Status)& 0x01)==1)
						cEnd=TRUE;
				}
			//-------------------------------------------------------------
			if(pid==PID_IN)
					SL811HSBulkRead(MemStart,Buffer,cLen);
			FlagDataType=~FlagDataType;
			if(DataLengh>0)
				Buffer=Buffer+cLen;
		}while(DataLengh!=0);
		FlagDelay=0;
}
//************************************************************************************************
//Control endpoint
//************************************************************************************************
void VendorCmd(U8 USBaddress,U8 cEndPoint,U8 *setup,U8 *Buffer,U16 DataLengh)
{
	U8 pid;
    pid=PID_IN;
	FlagDataType=DATA0;
	//----------------------------------------------------
	// SETUP token with 8-byte request on endpoint 0
	//----------------------------------------------------
	USBXfer(USBAddress,cEndPoint,PID_SETUP,setup,8);
	//----------------------------------------------------
	// IN or OUT data stage on endpoint 0	
	//----------------------------------------------------
	if(DataLengh)                            // if there are data for transfer
		{
			if(setup[0]&0x80)          // host-to-device : IN token
				{
					pid=PID_OUT;
					USBXfer(USBaddress,cEndPoint,PID_IN,Buffer,DataLengh);
				}
			else                        // device-to-host : OUT token
					USBXfer(USBaddress,cEndPoint,PID_OUT,Buffer,DataLengh);
		}
	//----------------------------------------------------
	// Status stage IN or OUT zero-length data packet
	//----------------------------------------------------
	FlagDataType=DATA1;
	USBXfer(USBaddress,cEndPoint,pid,TEMP_BUFFER,0);
}
//***********************************************************************************************
//Get Device Descriptor : Device, Configuration, String
//**********************************************************************************************
void GetDescriptor(U8 *Setup)
{
	VendorCmd(USBAddress,ep0,Setup,DATA_BUFFER,0x12);
	ENP_LEN=DATA_BUFFER[7];
}
//***********************************************************************************************
//Set Device Address : 
//**********************************************************************************************
void SetAddress(void)
{
	VendorCmd(USBAddress,ep0,StrSetAddress,TEMP_BUFFER,0);
	USBAddress=0x02;
}
//**********************************************************************************************
//// Get Device Configuration : 
//**********************************************************************************************
void GetConfiguration(U8 *Setup)
{
	VendorCmd(USBAddress,ep0,Setup,DATA_BUFFER,0x0ff);
}
//**********************************************************************************************
//// Set Device Configure : 
//**********************************************************************************************
void SetConfigure(void)
{
	VendorCmd(USBAddress,ep0,StrSetConfigure,TEMP_BUFFER,0);
}
//**********************************************************************************************
//check Vender ID / Product ID 
//***********************************************************************************************
void CheckUsbID(void)
{ 
	U16 vender_id,product_id;

	vender_id=DATA_BUFFER[9];
	vender_id=(vender_id<<8)| DATA_BUFFER[8];
    if(vender_id!=VenderID)
		ShowError(UsbIDNG);

	product_id=DATA_BUFFER[11];
	product_id=(product_id<<8)|DATA_BUFFER[10];
	switch(product_id)
		{
			case ProductID_A6G:
				RunInModelStatus=A6LengthRunIn;
				MaxRunInLength=5.9*600;
				break;
			case ProductID_A6PlusG:
				RunInModelStatus=A6PlusLengthRunIn;
				MaxRunInLength=7.1*600;
				break;
	       case ProductID_A600G:
		   		RunInModelStatus=A6PlusLengthRunIn;
				MaxRunInLength=7.1*600;
				break;
			case ProductID_FB2100G:
		   		RunInModelStatus=FB2100LengthRunIn;
				MaxRunInLength=12*1200;
				break;
			case ProductID_FB1880G:
		   		RunInModelStatus=FB2100LengthRunIn;
				MaxRunInLength=12*1200;
				break;
			case ProductID_DSeriesG:
		   		RunInModelStatus=FB2100LengthRunIn;
				MaxRunInLength=12*1200;
				break;
			case ProductID_FB2400UG:
		   		RunInModelStatus=FB2400LengthRunIn;
				MaxRunInLength=12*1200;
				break;
			case ProductID_FB1200G:
		   		RunInModelStatus=FB1200LengthRunIn;
				MaxRunInLength=12*600;
				break;
			default:
				ShowError(UsbIDNG);
		}
}
//**********************************************************************************************
//check device string id
//**********************************************************************************************
void CheckASICStringID(void)
{   
	U8 CharA,CharB;

	CharA=2;
	CharB=0;
	while(CharB<14)
		{
			if(DATA_BUFFER[CharA]!=ASICStringID[CharB])
				ShowError(ASICIDNG);
			CharA=CharA+2;
			CharB++;
		}
}
//===================END SL811HS SUPROGRAM=====================================================