uart.c

S3C44b0X 的中断程序代码................

//44BTEST : uart.c
#include <string.h>
#include <stdlib.h>
#include "..\inc\44b.h"
#include "..\inc\44blib.h"
#include "..\inc\def.h"
#include "..\inc\rtc.h"
#define KEY_BUFLEN 100
#define AFC_BUFLEN 0x100
char Uart_IntGetkey(void);
void Uart_Port(void);
void Return_Port(void);
void __irq Uart0_TxFifoInt(void);
void __irq Uart0_RxFifoInt(void); 
void __irq Uart0_RxFifoErrorInt(void);
void __irq Uart0_RxInt(void);
void __irq Uart0_TxInt(void);
void __irq Uart1_TxFifoInt(void);
void __irq Uart1_RxFifoInt(void);
void __irq Uart1_RxFifoErrorInt(void);
void __irq Uart1_RxInt(void);
void __irq Uart1_TxInt(void);
void __irq U1AFC_TxInt(void);
void __irq U0AFC_RxInt(void);
void __irq U0AFC_RxErrorInt(void);
void __irq Exint2(void);
void __irq Test_Done(void);
void __irq Error(void);

static unsigned char keyBuf[KEY_BUFLEN];
volatile static int keyBufRdPt=0;
volatile static int keyBufWrPt=0;
volatile char out=1;
volatile static char *uart0TxStr;
volatile static char *uart1TxStr;
volatile U32 save_UC,save_UE,save_UF,save_UPC,save_UPE,save_UPF;
void Uart_Port(void)
{
	save_UC=rPCONC;//for nRTS0,nCTS0
	save_UE=rPCONE;//for TxD0,RxD0
	save_UF=rPCONF;//for nRTS1,TxD1,RxD1,nCTS1
	save_UPC=rPUPC;
	save_UPE=rPUPE;
	save_UPF=rPUPF;
	rPCONC 	|=0xf0000000;
	rPUPC 	|=0xc000;//Uart port pull-up disable
	rPCONE	=(rPCONE &0x3ffeb)|0x28;
	rPUPE 	|=0x6;
	rPCONF	=(rPCONF &0x3ff)+0x124800;
	rPUPF 	|=0x1e0;
}
void Return_Port(void)
{
	rPCONC=save_UC;
	rPCONE=save_UE;
	rPCONF=save_UF;
	rPUPC=save_UPC;
	rPUPE=save_UPE;
	rPUPF=save_UPF;
}
char Uart_IntGetkey(void)
{
	if(keyBufRdPt==KEY_BUFLEN)
		keyBufRdPt=0;
	while(keyBufWrPt==keyBufRdPt); //until FIFO is triggered
	
	return keyBuf[keyBufRdPt++];
}
////////UART 0 TEST////////////////
void Test_Uart0Fifo(void)
{
	int key;
	Uart_Port();
	keyBufRdPt=keyBufWrPt=0;
	pISR_UTXD0=(unsigned)Uart0_TxFifoInt;
	pISR_URXD0=(unsigned)Uart0_RxFifoInt;
	pISR_UERR01=(unsigned)Uart0_RxFifoErrorInt;
	/*********** UART0 Tx FIFO test with interrupt ***********/
	Uart_Printf("[Uart channel 0 tx FIFO Interrupt Test]\n");
	Uart_TxEmpty(0); //wait until tx shifter is empty.
	uart0TxStr="UART0 Tx FIFO interrupt test is good!!!!\r\n";
	rUFCON0=(2<<6)|(1<<4)|(6)|1;
	//FIFO trigger:tx/rx:8byte,tx/rx_fifo reset(will be cleared),FIFO enable.
	rUCON0 = 0x244; //tx:levl,rx:edge,error int,normal*2,interrupt(Start)
	rINTMSK=~(BIT_GLOBAL|BIT_UTXD0);
	Delay(500);
	/*********** UART0 Tx FIFO test with BDMA0 ***********/
	Uart_Init(0,115200);
	Uart_Printf("\n[Uart0 FIFO Tx Test by BDMA0]\n");
	uart0TxStr="UART0 Tx FIFO Test by BDMA0 is good!!!!\r\n";
	Uart_TxEmpty(0);
	rUCON0=0x48; //tx:BDMA0 rx:disable
	rBDICNT0=0;
	rBDCON0 =0x0;
	rBDISRC0=(unsigned int)uart0TxStr|(0<<30)|(1<<28); // byte,inc
	rBDIDES0=UTXH0 |(1<<30)|(3<<28); //L/B endian,M2IO,fix
	rBDICNT0=strlen((char *)uart0TxStr)|(2<<30)|(1<<26)|(0<<20); //UART0,start,polling
	rBDICNT0 |= (1<<20); //enable
	while(!((rBDCON0&0x30)==0x20));
	Uart_TxEmpty(0);
	/*********** UART0 Rx FIFO test with interrupt ***********/
	rUCON0=0x245|0x80; //tx:level,rx:edge,tx/rx:int,rcv_time_out enabled,error int enable
	Uart_Printf("\n[Uart channel 0 FIFO Rx Interrupt Test]:Type any key!!!\n");
	Uart_Printf("You have to see the typed character. To quit, press Enter key.\n");
	rINTMSK=~(BIT_GLOBAL|BIT_URXD0|BIT_UERR01);
	while( (rUFSTAT0&0xf) >0 )
		key=RdURXH0(); //To clear the Rx FIFO
	rUERSTAT0; //To clear the error state
	while((key=Uart_IntGetkey())!='\r')
	Uart_SendByte(key);
	rUFCON0=(2<<6)|(1<<4)|(6)|0;
	//FIFO trigger:tx/rx:8byte, txrx_fifo reset(will be cleared), FIFO disable.
	rINTMSK=~BIT_GLOBAL;
	rUCON0=0x45; //rcv_time_out disabled
	Uart_Printf("\n");
	Return_Port();
}

void __irq Uart0_TxFifoInt(void)
{
	while( !(rUFSTAT0 & 0x200) && (*uart0TxStr != '\0') ) //until tx fifo full or end of string
	{
		rUTXH0=*uart0TxStr++;
		//for(i=0;i<700;i++); //to avoid overwriting FIFO
	}
	rI_ISPC=BIT_UTXD0;
	if(*uart0TxStr == '\0')	// SET_INTMSK_IRQ(BIT_UTXD0);//work around for ES2
	{ //ES3
		rINTMSK |= BIT_UTXD0; //ES3
		rI_ISPC=BIT_UTXD0; //ES3
	} //ES3
}
void __irq Uart0_RxFifoInt(void)
{
	rI_ISPC=BIT_URXD0;
	// if(rUFSTAT0==0)
	// Uart_Printf("time out\n");
	while( (rUFSTAT0&0xf) >0 ) //until FIFO is empty
	{
		keyBuf[keyBufWrPt++]=rURXH0;//rx buffer->keyBuf[]
		if(keyBufWrPt==KEY_BUFLEN)
			keyBufWrPt=0;
	}
}
void __irq Uart0_RxFifoErrorInt(void)
{
	rI_ISPC=BIT_UERR01;
	Uart_Printf("UERSTAT0 = 0x%x\n", rUERSTAT0 & 0xf);
	while( (rUFSTAT0&0xf) >0 )
	{
		keyBuf[keyBufWrPt++]=rURXH0;
		if(keyBufWrPt==KEY_BUFLEN)
			keyBufWrPt=0;
	}
}
void Test_Uart0(void)
{
	int key;
	Uart_Port();
	keyBufRdPt=keyBufWrPt=0;
	pISR_UTXD0=(unsigned)Uart0_TxInt;
	pISR_URXD0=(unsigned)Uart0_RxInt;
	/*********** UART0 Tx test with interrupt ***********/
	Uart_Printf("[Uart channel 0 tx Interrupt Test]\n");
	Uart_TxEmpty(0); //wait until tx shifter is empty.
	uart0TxStr="UART0 Tx interrupt test is good!!!!\r\n";
	rUCON0 = 0x244; //tx:level,rx:edge,error int,normal*2,interrupt(Start)
	rINTMSK=~(BIT_GLOBAL|BIT_UTXD0);
	Delay(3000);
	/*********** UART0 Tx test with BDMA0 ***********/
	rUCON0 = 0x245;//for BDMA0
	Uart_Printf("\n[Uart0 Tx Test by BDMA0]\n");
	uart0TxStr="UART0 Tx Test by BDMA0 is good!!!!\r\n";
	Uart_TxEmpty(0);
	rUCON0=0x48; //tx:BDMA0 rx:disable
	rBDICNT0=0x0;
	rBDCON0 =0x0;
	rBDISRC0=(unsigned int)uart0TxStr|(0<<30)|(1<<28); // byte,inc
	rBDIDES0=UTXH0 |(1<<30)|(3<<28); //L/B endian,M2IO,fix
	rBDICNT0=strlen((char *)uart0TxStr)|(2<<30)|(1<<26)|(0<<20); //UART0,
	rBDICNT0 |= (1<<20); //enable
	while(!((rBDCON0&0x30)==0x20));
	Uart_TxEmpty(0);
	/*********** UART0 Rx test with interrupt ***********/
	rUCON0=0x45; //tx:int rx:int
	Uart_Printf("\n[Uart channel 0 Rx Interrupt Test]:Type any key!!!\n");
	Uart_Printf("You will see the typed character. To quit, press Enter key.\n");
	Uart_TxEmpty(0);
	rINTMSK=~(BIT_GLOBAL|BIT_URXD0);
	keyBufRdPt=keyBufWrPt=0;
	while((key=Uart_IntGetkey())!='\r')
	Uart_SendByte(key);
	rINTMSK=~BIT_GLOBAL;
	Uart_Printf("\n");
	Return_Port();
}
void __irq Uart0_RxInt(void)
{
	rI_ISPC=BIT_URXD0;
	keyBuf[keyBufWrPt++]=RdURXH0();
	if(keyBufWrPt==KEY_BUFLEN)
		keyBufWrPt=0;
}
//unsigned int txcount=0;
void __irq Uart0_TxInt(void)
{
	// rI_ISPC=BIT_UTXD0; //This cann't make the pending bit be cleared in the level trigger mode.
	if(*uart0TxStr != '\0')
	{
		WrUTXH0(*uart0TxStr++);
		rI_ISPC=BIT_UTXD0; //Because UART operates using level trigger mode.
	}
	else
	// {
	// rUCON0 &= 0x3f3; //workaround
	// rI_ISPC=BIT_UTXD0; //This cann't make the pending bit be cleared in the level trigger mode.
	// rINTMSK|=BIT_UTXD0;
	// }
	// WrUTXH0('@');
	{ //ES3
		rINTMSK |= BIT_UTXD0; //ES3
		rI_ISPC=BIT_UTXD0; //ES3
	} //ES3
}
////////UART 1 TEST////////////////
void Test_Uart1Fifo(void)
{
	int key;
	Uart_Port();
	keyBufRdPt=keyBufWrPt=0;
	pISR_UTXD1=(unsigned)Uart1_TxFifoInt;
	pISR_URXD1=(unsigned)Uart1_RxFifoInt;
	pISR_UERR01=(unsigned)Uart1_RxFifoErrorInt;
	/*********** UART1 Tx FIFO test with interrupt ***********/
	Uart_Printf("[Uart channel 1 tx FIFO Interrupt Test]\n");
	Uart_Printf("Plug the serial cable into ch1 connector!!! \n");
	Uart_Printf("Then, press any key through UART ch1.\n");
	Uart_Select(1);
	Uart_Getch();
	uart1TxStr="UART1 Tx FIFO interrupt test is good!!\r\n";
	rUFCON1=(2<<6)|(1<<4)|(6)|1;
	//FIFO trigger:tx/rx:8byte,tx/rx_fifo reset(will be cleared),FIFO enable.
	rUCON1 = 0x244; //rx:edge,tx:level,error int,normal*2,interrupt(Start)
	rINTMSK=~(BIT_GLOBAL|BIT_UTXD1);
	Delay(500);
	/*********** UART1 Tx FIFO test with BDMA1 ***********/
	Uart_Init(0,115200);
	Uart_Printf("\n[Uart1 FIFO Tx Test by BDMA1]\n");
	uart1TxStr="UART1 Tx Test by BDMA0 is good!!!!\r\n";
	Uart_TxEmpty(1);
	rUCON1=0x4c; //tx:BDMA1 rx:disable
	rBDICNT1=0;
	rBDCON1 =0x0;
	rBDISRC1=(unsigned int)uart1TxStr|(0<<30)|(1<<28); // byte,inc
	rBDIDES1=UTXH1 |(1<<30)|(3<<28); //L/B endian,M2IO,fix
	rBDICNT1=strlen((char *)uart1TxStr)|(2<<30)|(1<<26)|(0<<20); //UART1,start,polling
	rBDICNT1 |= (1<<20); //enable
	while((rBDCON1&0x30)==0x10);
	Uart_TxEmpty(1);
	/*********** UART1 Rx FIFO test with interrupt ***********/
	rUCON1=0x245|0x80; //rx:edge,tx:level,tx/rx:int,rcv_time_out enabled,error int enable
	Uart_Printf("\n[Uart channel 1 FIFO Rx Interrupt Test]:Type any key!!!\n");
	Uart_Printf("You have to see the typed character. To quit, press Enter key.\n");
	rINTMSK=~(BIT_GLOBAL|BIT_URXD1|BIT_UERR01);
	keyBufRdPt=keyBufWrPt=0;
	while( (rUFSTAT1&0xf) >0 )
	key=RdURXH1(); //To clear the Rx FIFO
	rUERSTAT1; //To clear the error state
	while((key=Uart_IntGetkey())!='\r')
	Uart_SendByte(key);
	rUFCON1=(2<<6)|(1<<4)|(6)|0;
	//FIFO trigger:tx/rx:8byte, txrx_fifo reset(will be cleared), FIFO disable.
	rINTMSK=~BIT_GLOBAL;
	rUCON1=0x45; //rcv_time_out disabled
	Uart_Printf("\n");
	Uart_Printf("Plug the serial cable into ch0 as before this test!!!\n");
	Uart_Printf("Then, press any key through UART ch 0.\n");
	Uart_Select(0);
	Uart_Getch();
	Return_Port();
}
void __irq Uart1_TxFifoInt(void)
{
	int i;
	while( !(rUFSTAT1 == 16) && (*uart1TxStr != '\0') ) //until tx fifo full or end of string
	{
		rUTXH1=*uart1TxStr++;
		for(i=0;i<700;i++); //to avoid overwriting FIFO
	}
	rI_ISPC=BIT_UTXD1;
	if(*uart1TxStr == '\0')
	// SET_INTMSK_IRQ(BIT_UTXD1);//work around for ES2
	{ //ES3
		rINTMSK |= BIT_UTXD1; //ES3
		rI_ISPC=BIT_UTXD1; //ES3
	} //ES3
}

void __irq Uart1_RxFifoInt(void)
{
	rI_ISPC=BIT_URXD1;
	// if(rUFSTAT1==0)
	// Uart_Printf("time out\n");
	while( (rUFSTAT1&0xf) >0 ) //until FIFO is empty
	{
		keyBuf[keyBufWrPt++]=rURXH1;//rx buffer->keyBuf[]
		if(keyBufWrPt==KEY_BUFLEN)
			keyBufWrPt=1;