d12int.c

dsp芯片TMS320C5416实验程序

#include "DataType.h"
#include "D12Def.h" 
#include "UsbDesc.h"

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

static int send_remain;
static U32 send_ptr;

unsigned char magic[4] = { 0x24, 0x4d, 0x5a, 0x4c };

ioport unsigned port1000;

unsigned int ep5_ptr = 0;
int ep5_remain = 0;
int usb_ok = 0;

void Delay(U32 Time);

U8 UsbInit()
{
	UsbSendDescF = 0;

	if(D12RdChipId()!=0x1012 )
		return STATUS_ERR;
		
	D12RdInt();
	D12RdFrameNumber();
	D12RdEpStat(0);
	D12RdEpStat(1);
	D12RdEpStat(2);
	D12RdEpStat(3);		
	D12RdEpStat(4);
	D12RdEpStat(5);
	D12RdLastTrStat(0);
	D12RdLastTrStat(1);
	D12RdLastTrStat(2);
	D12RdLastTrStat(3);
	D12RdLastTrStat(4);
	D12RdLastTrStat(5);
	D12RdInt();		

	D12SetMode(D12NoLazyClk, D12EpCfg1 | D12Pll12M);
	asm("  rpt  #0F000h");
	asm("  nop");

	D12SetMode(D12NoLazyClk|D12SoftConnect, D12EpCfg1 | D12Pll12M);
	asm("  rpt  #0F000h");
	asm("  nop");

	return STATUS_OK;
}

void UsbDisc()
{
	D12SetMode(D12NoLazyClk, D12EpCfg1 | D12Pll12M);
	asm("  rpt  #0F000h");
	asm("  nop");
}

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

#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	Ep1PacketSize		16
#define	Ep2PacketSize		64
#define	EndpCnt				4
#define	UsbTotalCfgDescSize	(UsbCfgDescSize+UsbItfDescSize+EndpCnt*UsbEndpDescSize)

static struct{
	UsbDevDesc DevDesc;
	U8 CfgDesc[9];
	U8 ItfDesc[9];
	U8 Endp2Desc[7];
	U8 Endp3Desc[7];
	U8 Endp4Desc[7];
	U8 Endp5Desc[7];

}ThisDevDesc =
				{
					{
						UsbDevDescSize,
						UsbDevDescType,
						0x10, 0x01,
						
						0, 0, 0,
						
						Ep0PacketSize,
	
						0x71, 0x04,
						
						0x22, 0x02,
						
						0x13, 0x1,
						
						0, 0, 0,
						
						1
					},
					
					{
						UsbCfgDescSize,
						UsbCfgDescType,
						UsbTotalCfgDescSize,0, 
						1,
						1,
						04,		//0,
						0xc0,	//0x60,
						0x32,	//0x01,
					},
					{
						UsbItfDescSize,
						UsbItfDescType,
						0,
						0,
						EndpCnt,
						
						0xdc, 0xa0, 0xb0,
						0
					}, 
					{
						UsbEndpDescSize,
						UsbEndpDescType,
						0x81,
						UsbEndpInterrupt,
						Ep1PacketSize,
						0,
						10,
					},
					{
						UsbEndpDescSize,
						UsbEndpDescType,
						0x1,
						UsbEndpInterrupt,
						Ep1PacketSize,
						0,
						10,
					},	
					{
						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] = (D12RdDat()&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);
	
	usb_ok = 1;
	
	return STATUS_OK;	
}

void UsbSendDesc()
{
	UsbSendDescF = (send_remain>=Ep0PacketSize);	
	D12WrEp(1, (U8 *)send_ptr, (send_remain>Ep0PacketSize)?Ep0PacketSize:send_remain);
			
	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(5, usb_config^1);
	D12WrEp(1, SetupPkt, 0);
	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)
{
	if((SetupPkt[2]==0)&&(SetupPkt[3]==0))
		return STATUS_OK;				/* OK */
	
	return STATUS_ERR;				
}

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

U8 UsbGetMaxLun(U8 *SetupPkt)
{
	if(SetupPkt[1]!=0xfe)
		return STATUS_ERR;			
		
	SetupPkt[0] = 0;
	D12WrEp(1, SetupPkt, 1);
	return STATUS_OK;		
}

U8 (*StdDevReq[])(U8 *SetupPkt) = {
	UsbGetStatus,						/* 0x00 */
	UsbClrFeature,						/* 0x01 */
	UsbReserved,						/* 0x02 */
	UsbSetFeature,						/* 0x03 */
	UsbReserved,						/* 0x04 */
	UsbSetAddress,						/* 0x05 */
	UsbGetDescriptor,					/* 0x06 */
	UsbReserved,						/* 0x07 */
	UsbGetConfiguration,				/* 0x08 */
	UsbSetConfiguration,				/* 0x09 */
	UsbGetInterface,					/* 0x0a */
	UsbSetInterface,					/* 0x0b */
	UsbReserved,						/* 0x0c */
	UsbReserved,						/* 0x0d */
	UsbReserved,						/* 0x0e */
	UsbReserved							/* 0x0f */
}; 

unsigned char buffer[1024];

int pos = 0;

/********************** D12 interrupt process ******************/
void D12Ep0IntProc()
{
	int i;
	U8 SetupPkt[8];
	U8 LastTrStat;	
	
	UsbSendDescF = 0;
	
	LastTrStat = D12RdLastTrStat(0);

	if(D12RdEp(0, SetupPkt, 8)==8)
	{			
		for( i = 0; i < 8; i++) buffer[pos++] = SetupPkt[i];
		
		D12AckEp(0);
		D12AckEp(1);
			
		if(!StdDevReq[SetupPkt[1]&0xf](SetupPkt));
			return;
	}
		
	D12SetEpStat(0, D12EpStall);
	D12SetEpStat(1, D12EpStall);		
}

void D12Ep1IntProc()
{
	U8 LastTrStat;

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

void D12Ep2IntProc()
{
	U8 		size;
	u_pkt* 	pkt;
	
	U8 Ep1OutBuf[Ep1PacketSize];

	D12RdLastTrStat(2);	
	
	size = D12RdEp(2, Ep1OutBuf, Ep1PacketSize);
	
	if(size!=0)
	{
		if(	(Ep1OutBuf[0]==magic[0])&&
			(Ep1OutBuf[1]==magic[1])&&
			(Ep1OutBuf[2]==magic[2])&&
			(Ep1OutBuf[3]==magic[3]))
		{
			pkt = (u_pkt*)Ep1OutBuf;
			port1000 = pkt->data;
		}
	}
}

void D12Ep3IntProc()
{
	D12RdLastTrStat(3);	
}

void D12Ep4IntProc()
{
	u_pkt* 	pkt;

	U8 size;
	U8 EpStat;
	U8 Ep2OutBuf[Ep2PacketSize*2];

	D12RdLastTrStat(4);	
	
	size = D12RdBulkEp(Ep2OutBuf);
}

void D12Ep5IntProc()
{
	U8   stat;
	U8   cnt ;
	
	stat = D12RdLastTrStat(5);
	
	if((D12SelEp(5)&0x01)==0x01) return;

	cnt = (ep5_remain>Ep2PacketSize)?Ep2PacketSize:ep5_remain;
	
	if(cnt)
	{
		D12WrEp(5, (U8*)ep5_ptr, cnt );
		ep5_remain -= cnt;
		ep5_ptr+=cnt;
	}
}

void D12BusRstProc()
{
}

void D12SuspChgProc()
{
}

interrupt void  usbd12_int() 	
{
	unsigned int int_value;
	
	int_value = UsbQueryInt();
		
	if(int_value)
	{
		UsbIntProc(int_value);			
	}
	
	#define IFR	*(volatile unsigned int*)0x01
	IFR = 0x100;
	
	return;
}

void  usbd12_isr(void) 	
{
	unsigned int int_value;
	
	int_value = UsbQueryInt();
		
	if(int_value)
	{
		UsbIntProc(int_value);			
	}
	
	return;
}