d12int.c

arm7下面控制D12的程序源码

#include "def.h"
#include "D12Def.h" 
#include "UsbDesc.h"
//#include "utils.h"


#define	STATUS_ERR	1
#define	STATUS_OK	0



#define	TEST_USB_BUFFER_SIZE 128




static U8 usb_remote_wake;
static U8 usb_config;
static U8 UsbSendDescF;

static int send_remain;
static U32 send_ptr;

U8 g_Command = 0;			//上位机发来的命令
U8 g_DataLen = 0;   //处理的数据长度
unsigned long g_Address = 0;
unsigned long	g_Count = 0;

int memcpy( U8* To , U8* From , int len )
{
	int i = 0;

	for( i = 0 ; i < len ; i ++ )
	{
		*(To+i) = *(From+i);
		
	}
	return 0;
}

void Delay(unsigned int count)
{
  unsigned int i, j;
  for(i = 0; i < count; i++)
  	for(j = 0; j < 1650; j++);

}

U8 UsbInit()
{
/*
	rPCONG = rPCONG | 0x0003;  //将PG0作为D12中断的输入
	rPUPG = rPUPG & 0xfe;
	rEXTINT &= 0x7ffffff8;
	rEXTINT |= 0x02;  //下降沿有效
*/
	UsbSendDescF = 0;

	if(D12RdChipId()!=0x1210 )
		return STATUS_ERR;

	D12SetDma(MyD12DmaCfg);
	if(D12GetDma()!=MyD12DmaCfg)
		return STATUS_ERR;

	D12SetMode(MyD12EpCfgOff, D12Pll24M);
	Delay(100);
	D12SetMode(MyD12EpCfgOn, D12Pll24M);

	g_DataLen = 0;
	g_Command = 0;
	g_Address = 0xc00000;

	return STATUS_OK;
}

///////////////////////////////

#define	UsbDevDescType	1
#define	UsbCfgDescType	2
#define	UsbStrDescType	3
#define	UsbItfDescType	4
#define	UsbEndpDescType	5
#define	UsbPwrDescType	6

#define	UsbDevDescSize	18
#define	UsbCfgDescSize	9
#define	UsbItfDescSize	9
#define	UsbEndpDescSize	7

#define	UsbEndpControl		0
#define	UsbEndpIsochronous	1
#define	UsbEndpBulk			2
#define	UsbEndpInterrupt	3	

////////////////////////////////////////

#define	UsbClassMassStorage	8

#define	UsbSubClassRbc		1
#define	UsbSubClassSff8020i	2
#define	UsbSubClassQic157	3
#define	UsbSubClassUfi		4
#define	UsbSubClassSff8070i	5
#define	UsbSubClassScsi		6

#define	UsbProtocolCbi0	0
#define	UsbProtocolCbi1	1
#define	UsbProtocolBulk	0x50
////////////////////////////////////////

#define	Ep0PacketSize	16
#define	Ep2PacketSize	64
#define	EndpCnt	2
#define	UsbTotalCfgDescSize	UsbCfgDescSize+UsbItfDescSize+EndpCnt*UsbEndpDescSize
static __packed struct
{
	UsbDevDesc DevDesc;
	U8 CfgDesc[9];
	U8 ItfDesc[9];
	U8 Endp4Desc[7];
	U8 Endp5Desc[7];

}ThisDevDesc =
				{
					{
						UsbDevDescSize,
						UsbDevDescType,
						0x110,
						0, 0, 0,
						Ep0PacketSize,
						0x471,
						0x222,
						0x113,
						0, 0, 0,
						1
					},
					{
						UsbCfgDescSize,
						UsbCfgDescType,
						UsbTotalCfgDescSize, 0,
						1,
						1,
						0,
						0x80,
						0x32
					},
					{
						UsbItfDescSize,
						UsbItfDescType,
						0,
						0,
						EndpCnt,
						UsbClassMassStorage,
						UsbSubClassUfi,
						UsbProtocolBulk,
						0
					},
					{
						UsbEndpDescSize,
						UsbEndpDescType,
						0x82,
						UsbEndpBulk,
						Ep2PacketSize,
						0,
						0
					},
					{
						UsbEndpDescSize,
						UsbEndpDescType,
						0x2,
						UsbEndpBulk,
						Ep2PacketSize,
						0,
						0
					}					
				};

/****************** standard device request ****************/
U8 UsbGetStatus(U8 *SetupPkt)
{
	if(SetupPkt[2]|SetupPkt[3]|SetupPkt[5]|SetupPkt[7])
		return 1;
	if(SetupPkt[6]!=2)
		return 1;
	if(SetupPkt[0]==0x80)
	{
		if(SetupPkt[4])
			return 1;
		SetupPkt[0] = usb_remote_wake?1:0;
		SetupPkt[1] = 0;
	}
	else
	if(SetupPkt[0]==0x81)
	{
		if(SetupPkt[4])
			return 1;
		SetupPkt[0] = 0;
		SetupPkt[1] = 0;		
	}
	else
	if(SetupPkt[0]==0x82)
	{
		D12SelEp((SetupPkt[4]*2)|((SetupPkt[4]&0x80)?1:0));
		SetupPkt[1] = (D12Dat&2)?1:0;
		SetupPkt[0] = 0;
	}
	else
		return 1;

	D12WrEp(1, SetupPkt, 2);
	return 0;		
}

U8 UsbClrFeature(U8 *SetupPkt)
{

	if(SetupPkt[0]&0x80)
		return STATUS_ERR;
	if(SetupPkt[3]|SetupPkt[5]|SetupPkt[6]|SetupPkt[7])	
		return STATUS_ERR;
		
	if(SetupPkt[0]&0x1f)
	{
		if((SetupPkt[0]&0x1f)!=2)
			return STATUS_ERR;
		D12SetEpStat((SetupPkt[4]*2)|((SetupPkt[4]&0x80)?1:0),0);
	}
	else
	{
		if(SetupPkt[4])
			return STATUS_ERR;
		usb_remote_wake = 0;
	}
	
	D12WrEp(1, SetupPkt, 0);
	return STATUS_OK;
}

U8 UsbSetFeature(U8 *SetupPkt)
{
	if(!(SetupPkt[0]&0x80))
		return STATUS_ERR;
	if(SetupPkt[3]|SetupPkt[5]|SetupPkt[6]|SetupPkt[7])
		return STATUS_ERR;
		
	if(SetupPkt[0]&0x1f)
	{
		if((SetupPkt[0]&0x1f)!=2)
			return STATUS_ERR;
		D12SetEpStat((SetupPkt[4]*2)|((SetupPkt[4]&0x80)?1:0),1);
	}
	else
	{
		if(SetupPkt[4])
			return STATUS_ERR;
		usb_remote_wake = 1;
	}
	
	D12WrEp(1, SetupPkt, 0);
	return STATUS_OK;
}

U8 UsbSetAddress(U8 *SetupPkt)
{

	if(SetupPkt[0]|SetupPkt[3]|SetupPkt[4]|SetupPkt[5]|SetupPkt[6]|SetupPkt[7])
		return STATUS_ERR;
		
	D12SetAddr(SetupPkt[2]|0x80);
	D12WrEp(1, SetupPkt, 0);
	return STATUS_OK;	
}

void UsbSendDesc()
{
//	U8 i;

	UsbSendDescF = send_remain>=Ep0PacketSize;	
	D12WrEp(1, (U8 *)send_ptr, (send_remain>Ep0PacketSize)?Ep0PacketSize:send_remain);
	
//	putch('@');
//	for(i=0; i<((send_remain>Ep0PacketSize)?Ep0PacketSize:send_remain); i++)
//		printf("%x,", *(U8 *)(send_ptr+i));	
		
	send_remain -= Ep0PacketSize;
	send_ptr    += Ep0PacketSize;
	
}

U8 UsbGetDescriptor(U8 *SetupPkt)
{
	
	if(SetupPkt[0]!=0x80)
		return STATUS_ERR;
		
	switch	(SetupPkt[3])
	{
	case UsbDevDescType:
		send_ptr = (U32)&ThisDevDesc;
		send_remain = UsbDevDescSize;
		break;
	case UsbCfgDescType:
		send_ptr = (U32)&ThisDevDesc.CfgDesc;
		send_remain = UsbTotalCfgDescSize;
		break;
	case UsbStrDescType:		
		return STATUS_ERR;	
	default:
		return STATUS_ERR;	
	}

	if(!SetupPkt[7]&&(SetupPkt[6]<send_remain))
		send_remain = SetupPkt[6];

	UsbSendDesc();	
	return STATUS_OK;	
}

U8 UsbGetConfiguration(U8 *SetupPkt)
{
	if(SetupPkt[0]!=0x80)
		return STATUS_ERR;
	if(SetupPkt[2]|SetupPkt[3]|SetupPkt[4]|SetupPkt[5]|SetupPkt[7])
		return STATUS_ERR;
	if(SetupPkt[6]!=1)
		return STATUS_ERR;
		
	SetupPkt[0] = usb_config?1:0;
	D12WrEp(1, SetupPkt, 1);	
	return STATUS_OK;	
}

U8 UsbSetConfiguration(U8 *SetupPkt)
{
	if(SetupPkt[0]|SetupPkt[3]|SetupPkt[4]|SetupPkt[5]|SetupPkt[6]|SetupPkt[7])
		return STATUS_ERR;
	if(SetupPkt[2]&0xfe)
		return STATUS_ERR;
		
	usb_config = SetupPkt[2]&1;
	D12SetEp(usb_config);
//	D12SetEpStat(4, usb_config^1);
		D12SetEpStat(4, 0);
//	D12SetEpStat(5, usb_config^1);
		D12SetEpStat(5, 0);
	D12WrEp(1, SetupPkt, 0);
//	puts("Device attached!\n");
	return STATUS_OK;
}

U8 UsbGetInterface(U8 *SetupPkt)
{
	if(SetupPkt[0]!=0x81)
		return STATUS_ERR;
	if(SetupPkt[2]|SetupPkt[3]|SetupPkt[4]|SetupPkt[5]|SetupPkt[7])
		return STATUS_ERR;
	if(SetupPkt[6]!=1)
		return STATUS_ERR;
		
	SetupPkt[0] = 0;
	D12WrEp(1, SetupPkt, 1);
	return STATUS_OK;
}

U8 UsbSetInterface(U8 *SetupPkt)
{
	return STATUS_ERR;
}

U8 UsbReserved(U8 *SetupPkt)
{
	return STATUS_ERR;	
}

U8 (*StdDevReq[])(U8 *SetupPkt) = {
	UsbGetStatus,
	UsbClrFeature,
	UsbReserved,
	UsbSetFeature,
	UsbReserved,
	UsbSetAddress,
	UsbGetDescriptor,
	UsbReserved,
	UsbGetConfiguration,
	UsbSetConfiguration,
	UsbGetInterface,
	UsbSetInterface,
	UsbReserved,
	UsbReserved,
	UsbReserved,
	UsbReserved
}; 

/********************** D12 interrupt process ******************/
//端点0的中断处理程序
void D12Ep0IntProc()
{
	U8 SetupPkt[8];
	U8 nRet = 0;
	
	UsbSendDescF = 0;
	
	nRet = D12RdLastTrStat(0);
	//if(D12Cmd&0x20)	
	if(nRet & 0x20)  //modified by yangkai	
		if(D12RdEp(0, SetupPkt, 8)==8)
		{
			D12AckEp(0);
			D12AckEp(1);
			
			/*{
				int i;
		
				putch('\n');
				for(i=0; i<8; i++)
					printf("%x,", SetupPkt[i]);
			}*/
				
			if(!StdDevReq[SetupPkt[1]&0xf](SetupPkt));
				return;
		}
		
	//D12SetEpStat(0, D12EpStall);	
	//D12SetEpStat(1, D12EpStall);	
	D12SetEpStat(0, 0);
	D12SetEpStat(1, 0);		
}

//端点1的中断处理程序
void D12Ep1IntProc()
{
	U8 i;
	
/*	
	U8 size;
	U8 Ep1OutBuf[64];
	unsigned char test[]="数据";
	D12RdLastTrStat(1);	
	size = D12RdEp(1, Ep1OutBuf, 64);
	*(volatile unsigned int *)0xc400030 =  size;
	
*/	

	i = D12RdLastTrStat(1);
	if(UsbSendDescF)
		UsbSendDesc();
		
}

//端点2的中断处理程序
void D12Ep2IntProc()
{
	//D12SetEpStat(2, D12EpStall);
	D12SetEpStat(2, 0);
}

//端点3的中断处理程序
void D12Ep3IntProc()
{
	//D12SetEpStat(3, D12EpStall);
	D12SetEpStat(3, 0);
}

/*****************************************************************************
*端点4的中断处理程序
帧格式
   头部    命令   长度    地址   备份   数据
0x5A 0xA5
   2字节   1字节  1字节  4字节  2字节  54字节
******************************************************************************/
void D12Ep4IntProc()
{
	U8 size;
	U8 DataLen = 0;
	U8 Buffer[Ep2PacketSize];

	//unsigned char test[]="数据";
	
	D12RdLastTrStat(4);	
	size = D12RdEp(4, Buffer, Ep2PacketSize);
	D12WrEp( 5 , Buffer , size );
	

	DataLen = Buffer[3];
	if( Buffer[0] == 0x5A &&
		Buffer[1] == 0xA5 &&
		Buffer[2] == 0x01 )
	{
		g_Address = *(unsigned long*)(Buffer+4);
		memcpy( (U8*)g_Address , Buffer+10 , size-10 );  //复制数据到指定的地址中去.
		g_Address += (size-10);
//		g_Command = Buffer[2];
//		g_DataLen = DataLen;
	}
	else if( Buffer[0] == 0x5A &&
			 Buffer[1] == 0xA5 &&
			 Buffer[2] == 0x03 )
	{
		g_Command = Buffer[2];
		g_DataLen = DataLen;
	}
	else if( size > 0 )
	{
		memcpy( (U8*)g_Address , Buffer , size );  //复制数据到指定的地址中去.
		g_Address += size;
	}
	g_Count++;
		
	return ;
	
}

//端点5的中断处理程序
void D12Ep5IntProc()
{
	D12RdLastTrStat(5);	
	g_Command = 0;
	g_DataLen = 0;
	//g_Address = 0xc00000;
}

void D12BusRstProc()
{
}

void D12SuspChgProc()
{
}