isr.h

基于dsp2407a的探测系统程序（兼容usb和串口通讯）

/* Control endpoint TX/RX buffers */
CONTROL_XFER ControlData;

/* ISR static vars */
unsigned char  GenEpBuf[EP1_PACKET_SIZE];
unsigned char  EpBuf[EP2_PACKET_SIZE];
IO_REQUEST  ioRequest;
unsigned int ioSize, ioCount;

unsigned long ClockTicks = 0;
unsigned char MainEpBuf[256];
extern uchar UsbPort1InBuf[16]; 
extern const uchar UsbPort2NoData[64];
extern uchar UsbPort2InReady;
uchar UsbTemOrCur=UsbNoData;

BOOL bNoRAM; 
/************************/
#define IN_TOKEN_DMA 	1
#define OUT_TOKEN_DMA 	0

#define DMA_BUFFER_SIZE		256

#define DMA_IDLE	0
#define DMA_RUNNING	1
#define DMA_PENDING	2

#define SETUP_DMA_REQUEST 		0x0471
#define GET_FIRMWARE_VERSION    0x0472
#define GET_SET_TWAIN_REQUEST   0x0473
#define GET_BUFFER_SIZE		    0x0474

typedef struct _TWAIN_FILEINFO {
	unsigned char	bPage;    // bPage bit 7 - 5 map to uSize bit 18 - 16
	unsigned char	uSizeH;    // uSize bit 15 - 8
	unsigned char	uSizeL;    // uSize bit 7 - 0
} TWAIN_FILEINFO, *PTWAIN_FILEINFO;  
/******************************/

void bus_reset(void)
{
}

void ep0_rxdone(void)
{
	unsigned char ep_last, i,j;

	ep_last = D12_ReadLastTransactionStatus(0); // Clear interrupt flag
//	senddis("RLr:",buf,(long)ep_last); 

	if (ep_last & D12_SETUPPACKET) {

		ControlData.wLengthh = 0;
		ControlData.wCounth = 0;
        j= D12_ReadEndpoint(0, sizeof(ControlData.DeviceRequest),
			(unsigned char *)(&(ControlData.DeviceRequest)));
		if(j != sizeof(DEVICE_REQUEST) ) 
			{

			D12_SetEndpointStatus(0, 1);
			D12_SetEndpointStatus(1, 1);
			bEPPflags.bits.control_state = USB_IDLE;
			
			return;
		}
        /*数据结构调整*/
		ControlData.DeviceRequest.wValueh=CharToInt(ControlData.DeviceRequest.wValuel,
													ControlData.DeviceRequest.wValueh);
		ControlData.DeviceRequest.wIndexh=CharToInt(ControlData.DeviceRequest.wIndexl,
													ControlData.DeviceRequest.wIndexh);
		ControlData.DeviceRequest.wLengthh=CharToInt(ControlData.DeviceRequest.wLengthl,
													ControlData.DeviceRequest.wLengthh);

		// Acknowledge setup here to unlock in/out endp
		D12_AcknowledgeEndpoint(0);
		D12_AcknowledgeEndpoint(1);
//		senddis("ControlData.DeviceRequest.wLength is ",buf,(long)(ControlData.DeviceRequest.wLengthh));

		ControlData.wLengthh = ControlData.DeviceRequest.wLengthh;
		ControlData.wCounth = 0;

		if (ControlData.DeviceRequest.bmRequestType & (unsigned char)USB_ENDPOINT_DIRECTION_MASK) 
		{
			bEPPflags.bits.setup_packet = 1;
			bEPPflags.bits.control_state = USB_IDLE;		/* get command */
		}
		else {
			if (ControlData.DeviceRequest.wLengthh == 0) {
				bEPPflags.bits.setup_packet = 1;
				bEPPflags.bits.control_state = USB_IDLE;		/* set command */
			}
			else {
				if(ControlData.DeviceRequest.wLengthh > MAX_CONTROLDATA_SIZE) {
					bEPPflags.bits.control_state = USB_IDLE;
					D12_SetEndpointStatus(0, 1);
					D12_SetEndpointStatus(1, 1);
				}
				else {
					bEPPflags.bits.control_state = USB_RECEIVE;	/* set command with OUT token */
				}
			} // set command with data
		} // else set command
	} // if setup packet

	else if (bEPPflags.bits.control_state == USB_RECEIVE)
	 {
		i =	D12_ReadEndpoint(0, EP0_PACKET_SIZE,
			ControlData.dataBuffer + ControlData.wCounth);

		ControlData.wCounth += i;
		if( i != EP0_PACKET_SIZE || ControlData.wCounth >= ControlData.wLengthh)
		 {
			bEPPflags.bits.setup_packet = 1;
			bEPPflags.bits.control_state = USB_IDLE;
		}
	}

	else {
		bEPPflags.bits.control_state = USB_IDLE;
	}
}

void ep0_txdone(void)
{
	uchar j;
	short i = ControlData.wLengthh - ControlData.wCounth;

	j=D12_ReadLastTransactionStatus(1); // Clear interrupt flag
//	senddis("RLt:",buf,(long)j);

	if (bEPPflags.bits.control_state != USB_TRANSMIT) 
		return;

	if( i >= EP0_PACKET_SIZE) {
		D12_WriteEndpoint(1, EP0_PACKET_SIZE, ControlData.pData + ControlData.wCounth);
		ControlData.wCounth += EP0_PACKET_SIZE;

		bEPPflags.bits.control_state = USB_TRANSMIT;
	}
	else if( i != 0) {
		D12_WriteEndpoint(1, i, ControlData.pData + ControlData.wCounth);
		ControlData.wCounth += i;

		bEPPflags.bits.control_state = USB_IDLE;
	}
	else if (i == 0){
		D12_WriteEndpoint(1, 0, 0); // Send zero packet at the end ???

		bEPPflags.bits.control_state = USB_IDLE;
	}
}

void dma_eot(void)
{
}

void ep1_txdone(void)
{
	unsigned char len;
	D12_ReadLastTransactionStatus(3); /* Clear interrupt flag */  
	len=D12_WriteEndpoint(3,16,UsbPort1InBuf);
}

void ep1_rxdone(void)
{
	unsigned char len;

	D12_ReadLastTransactionStatus(2); /* Clear interrupt flag */

	len = D12_ReadEndpoint(2, sizeof(GenEpBuf), GenEpBuf);  
	

	if(len != 0)
		bEPPflags.bits.ep1_rxdone = 1;
}
void TxDataNum(int TxNum)
{
	ioSize=TxNum;
	ioCount=0;
}
void main_txdone(void)
{
	unsigned char len,i;
    unsigned char UsbTxData[64];
	D12_ReadLastTransactionStatus(5); /* Clear interrupt flag */
	
    if(UsbPort2InReady==1)
    {
	switch(UsbTemOrCur)
	{
case UsbTem:    
	len = ioSize - ioCount;
	if(len > 21)
	len = 21;
	UsbTxData[0]='J'; 
	for(i=0;i<len;i++)
	{
	UsbTxData[1+i*3]=TemData[i].TemDatah>>8;
	UsbTxData[2+i*3]=TemData[i].TemDatah&0x00ff;
	UsbTxData[3+i*3]=TemData[i].TemDatal;
	}
	D12_WriteEndpoint(5,1+len*3,UsbTxData);
	ioCount+=len;
	if(ioCount==ioSize)
	{
	UsbPort2InReady=0;
    UsbTemOrCur=UsbNoData;
    }
    break;
case UsbCur:
    len = ioSize - ioCount;
	if(len > 31)
	len = 31;
	UsbTxData[0]='M'; 
	for(i=0;i<len;i++)
	{
	UsbTxData[1+i*2]=curbuf[i]>>8;
	UsbTxData[2+i*2]=curbuf[i]&0x00ff;
	}
	UsbTxData[63]='M';
	D12_WriteEndpoint(5,2+len*2,UsbTxData);
	ioCount+=len;
	if(ioCount==ioSize)
	{
	UsbPort2InReady=0;
	UsbTemOrCur=UsbNoData;
	}
    break;
default:
    UsbPort2InReady=0;
    D12_WriteEndpoint(5, 64,UsbPort2NoData);
	}//switch(UsbTemOrCur) 
	}//if(UsbPort2InReady==1)
	else
	{
     D12_WriteEndpoint(5, 64,UsbPort2NoData);
	}

}

void main_rxdone(void)
{
	unsigned char len;

	D12_ReadLastTransactionStatus(4); /* Clear interrupt flag */

	if(bNoRAM)
	{
		len = D12_ReadEndpoint(4, 64, EpBuf + ioCount);  
		
//		   sendstring("EpBuf");
		}
	else
		len = D12_ReadEndpoint(4, 64, MainEpBuf + ioCount);
	ioCount += len;
	if(bNoRAM)
		len = D12_ReadEndpoint(4, 64, EpBuf + ioCount);
	else
		len = D12_ReadEndpoint(4, 64, MainEpBuf + ioCount);
	ioCount += len;
	if(ioCount >= ioSize) {
		if(bEPPflags.bits.dma_state == DMA_PENDING)
			bEPPflags.bits.setup_dma ++;
		else
			bEPPflags.bits.dma_state = DMA_IDLE;
	}
}


void fn_usb_isr()
{
	unsigned int i_st;

	bEPPflags.bits.in_isr = 1;

	i_st = D12_ReadInterruptRegister(); 
	if(i_st != 0) 
		{  
//		senddis(" Int_reg:",buf,(long)i_st);
		if(i_st & D12_INT_BUSRESET) 
		   {
			bus_reset();
			bEPPflags.bits.bus_reset = 1;
		    }
        if(i_st & D12_INT_EOT)
			dma_eot();
        if(i_st & D12_INT_SUSPENDCHANGE)
			bEPPflags.bits.suspend = 1;
        if(i_st & D12_INT_ENDP0IN)
			ep0_txdone();
		if(i_st & D12_INT_ENDP0OUT)
			ep0_rxdone();
		if(i_st & D12_INT_ENDP1IN)
			ep1_txdone();
		if(i_st & D12_INT_ENDP1OUT)
			ep1_rxdone();
		if(i_st & D12_INT_ENDP2IN)
			main_txdone();
		if(i_st & D12_INT_ENDP2OUT)
			main_rxdone();
		}

	bEPPflags.bits.in_isr = 0;
}