uart.c

三星2413芯片的测试代码,对进行驱动开发很有帮助.

//====================================================================
// File Name : rtc.c
// Function  : S3C2413 RTC Test Program
// Date      : Sep. 27, 2005
// Version   : 0.0
// History
//   0.0 : Programming start (Sep. 27, 2005)
//====================================================================


#include <stdio.h>
#include <stdlib.h>

#include "2413addr.h"
#include "System.h"
#include "Exception.h"
#include "Console.h"
#include "def.h"
#include "Uart.h"

#define CH0			0
#define CH1			1
#define CH2			2

#define DISABLE		0
#define INTORPOL	1
#define DMAREQ0		2
#define DMAREQ1		3

#define AFCDIS		0
#define AFCEN		1

#define NP			0	// No Parity
#define OP			4	// Odd Parity
#define EP			5	// Even Parity
#define PF1			6	// Parity force 1
#define PF0			7	// Parity force 0

#define TXEMPTY		0
#define TX16BYTE	1
#define TX32BYTE	2
#define TX48BYTE	3

#define RX1BYTE		0
#define RX8BYTE		1
#define RX16BYTE	2
#define RX32BYTE	3

#define UEXTCLK		1
#define UPCLK		2
#define USYSCLK		3

#define RxBUFFER _NONCACHE_STARTADDRESS+0x1000
#define TxBUFFER _NONCACHE_STARTADDRESS+0x3000

#define RxBUFFER2 _NONCACHE_STARTADDRESS+0x200000
// for high UART Test jungil 0705 range 1Mbyte distance TX, RX
#define uRxBUFFER _NONCACHE_STARTADDRESS+0x200000
#define uTxBUFFER _NONCACHE_STARTADDRESS


void Uart0_Tx_Polling(void);
void Uart0_Tx_Interrupt(void);
void Uart0_Tx_Interrupt_Fifo(void);
void Uart0_Tx_DMA1(void);
void Uart0_Tx_DMA1_Fifo(void);

void Uart0_Rx_Polling(void);
void Uart0_Rx_Interrupt(void);
void Uart0_Rx_Interrupt_Fifo(void);
void Uart0_Rx_DMA3(void);
void Uart0_Rx_DMA3_Fifo(void);
void Uart0_TxRx_LoopBack_Test(void);
void Uart0_Fifo_TrigLv_Test(void);
void Uart0_Tx_Fifo_TrigLv(void);
void Uart0_Rx_Fifo_TrigLv(void);
void Uart0_Afc_nRTS_TrigLv(void);
void Uart0_Tx_MaxSpeed(void);
void Uart0_Rx_MaxSpeed(void);
void Uart0_Send_Break(void);
void Uart0_AFC_TX_Test(void);
void Mem_Init_Tx(void);
void Uart0_AFC_RX_Test(void);
void __irq uUART0_Rx_Fifo_ISR(void);
void __irq	uUART0_Tx_Fifo_ISR(void);


void __irq UART0_Tx_ISR(void);
void __irq UART0_Tx_Fifo_ISR(void);

void __irq UART0_Rx_ISR(void);
void __irq UART0_Rx_Fifo_ISR(void);

void Uart_Tx_DMA1_Set(void);
void Uart_Rx_DMA3_Set(void);

void __irq Uart_Dma1Tx_Int(void);
void __irq Uart_Dma3Rx_Int(void);

void Uart_DataFormatSet(U32 ch, U32 ParityMode, U32 StopBitNum, U32 DataBitNum);
void Uart_FunctionSet(U32 ch, U32 Tx, U32 Rx);
void Uart_BaudRateSet(U32 ch, U32 bps);
void Uart_Select(U32 ch);
void Uart_Port_Init(void);
void Uart_Port_Return(void);
void RxBufferClear(void);
void SelectUartClockSource(U32 ch, U32 clksrc);

void Uart_FifoLvSet(U32 ch, U32 tx, U32 rx);
void Uart_FifoDisable(U32 ch);
void Uart_FifoEnable(U32 ch);
void Uart_FifoReset(U32 ch);

void Uart0_Tx_CLK_Change(void);
void Uart0_Tx_Polling_High_BaudRate(void);
void Uart0_Tx_DMA1_High_Baudrate(void);
void Uart0_Tx_DMA1_Fifo_High_Baudrate(void);
void Data_init_UART(void);
void Uart_Tx_DMA1_Set_1Mbyte(void);
void Uart_Rx_DMA3_Set_1Mbyte(void);
void Uart0_Rx_Polling_High_Baudrate(void);
void Uart0_Rx_DMA3_High_Baudrate(void);
void Uart0_Rx_DMA3_Fifo_High_Baudrate(void);

void Uart0_Rx_Fifo_TrigLv_Test(void);
void Uart0_Tx_Fifo_TrigLv_Test(void);


void __irq UART1_Rx_Fifo_ISR_Jung(void);
void Uart0_Tx_Fifo_TrigLv_Jung(void);
void PCLK_Using_Test(void);
void UARTCLK_Using_Test(void);
void EXTCLK_Using_Test(void);


volatile U32 UERSTAT;
volatile U32 iIRQ = 0, iIRQ_TX = 0;
volatile U32 uPCLK = 2, uSelTest = 0;

volatile unsigned S8 *uuartRxStr;
volatile unsigned S8 *uuartTxStr;
volatile U32 uIsTxDone, uIsRxDone;
volatile U32 uUERSTAT, uDMARoop=0, uTxRoop=0, uRxRoop=0;

void GPIO_Control(void)
{
	U32 temp;
	U32 key;
	rGPHDN |= (1<<8);
	rGPHDAT |= (1<<8);
	rGPHCON = (rGPHCON & ~(3<<16))|(1<<16);

	while(1) {
		key = Uart_GetKey();
		if(key=='x')break;
		if(key!=0) {
			temp = (rGPHDAT>>8) & 1;
			rGPHDAT = (rGPHCON & ~(1<<8))|((temp^1)<<8);
			}
		}
}

typedef struct tagUART
{
    volatile U32 ULCON;		//0x0
    volatile U32 UCON;		//0x4
    volatile U32 UFCON;		//0x8
    volatile U32 UMCON;		//0xc
    volatile U32 UTRSTAT;    //0x10	Read Only
    volatile U32 UERSTAT;    //0x14	Read Only
    volatile U32 UFSTAT;      //0x18	Read Only
    volatile U32 UMSTAT;     //0x1c	Read Only
    volatile U32 UTXH;	      //0x20	Write Only
    volatile U32 URXH;	      //0x24	Read Only
    volatile U32 UBRDIV;      //0x28
    volatile U32 UDIVSLOT;  //0x2c
}UART;

UART *pUART;

const unsigned int nSlotTable[16] = {0x0000, 0x0080, 0x0808, 0x0888, 0x2222, 0x4924, 0x4a52, 0x54aa,
				     				0x5555, 0xd555, 0xd5d5, 0xddd5, 0xdddd, 0xdfdd, 0xdfdf, 0xffdf};

U32 saved_rGPHCON, saved_rGPHDAT, saved_rGPHDN;
U32 saved_ULCON, saved_UCON, saved_UFCON, saved_UMCON, saved_UBRDIV, saved_UDIVSLOT;

static S8 TestString1[]="abcdefghijklmnopqrstuvwxyz1234567890->UART Tx polling test is First!!!!\rABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890->UART Tx polling test is Second!!!!\rabcdefghijklmnopqrstuvwxyz1234567890->UART Tx polling test is Third!!!!\r\n";
static S8 TestString2[]="1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ->UART Tx interrupt test is First!!!!\rabcdefghijklmnopqrstuvwxyz1234567890->UART Tx interrupt test is Second!!!!\r1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ->UART Tx interrupt test is Third!!!!\r\n";	
static S8 TestString3[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890->UART Tx int with fifo test is First!!!!\r1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ->UART Tx int with fifo test is Second!!!!\rABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890->UART Tx int with fifo test is Third!!!!\r\n";
static S8 TestString4[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890123456789012345678901234->UART DMA Mode           Test!!!!\r\n";
static S8 TestString5[]="ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890123456789012345678901234->UART DMA Mode with FIFO Test!!!!\r\n";

volatile unsigned S8 *uartTxStr, *uartRxStr;
volatile unsigned S8 *tx_ptr, *rx_ptr;

volatile U32 IsTxDone, IsRxDone;

void * uart_func[][2]=
{
	(void *)Uart0_Tx_Polling,			"Uart0 Tx Polling Mode       ",
//	(void *)Uart0_Rx_Polling,			"Uart0 Rx Polling Mode       ",
	(void *)Uart0_Tx_Interrupt,		"Uart0 Tx Interrupt Mode    ",
//	(void *)Uart0_Rx_Interrupt,		"Uart0 Rx Interrupt Mode    ",
	(void *)Uart0_Tx_Interrupt_Fifo,	"Uart0 Tx Interrupt w/ FIFO",
//	(void *)Uart0_Rx_Interrupt_Fifo,	"Uart0 Rx Interrupt w/ FIFO",
	(void *)Uart0_Tx_DMA1,			"Uart0 Tx DMA Mode          ",
//	(void *)Uart0_Rx_DMA3,			"Uart0 Rx DMA Mode	    ",
	(void *)Uart0_Tx_DMA1_Fifo,		"Uart0 Tx DMA with FIFO    ",
//	(void *)Uart0_Rx_DMA3_Fifo,		"Uart0 Rx DMA with FIFO    ",
//	(void *)Uart0_Tx_MaxSpeed,		"Uart0 Tx Speed Test(921kbps)		",
//	(void *)Uart0_Rx_MaxSpeed,		"Uart0 Rx Speed Test(921kbps)		",
//	(void *)Uart0_TxRx_LoopBack_Test,"Uart0 Tx/Rx Loop Back Test",
//	(void *)Uart0_Fifo_TrigLv_Test,	"Uart0 FIFO Trig Level Test   ",
//	(void *)Uart0_AFC_TX_Test,   	"Uart0 AFC TX Test ",
//	(void *)Uart0_AFC_RX_Test,   	"Uart0 AFC RX Test ",
//	(void *)Uart0_Send_Break,		"Uart0 Send Break Test        ",
//	(void *)Uart0_Tx_CLK_Change,    "UART1(PC) TX CLK Change      ",
//	(void *)Uart0_Tx_Polling_High_BaudRate,   "UART0 TX Polling Mode - High Baud Rate      ",
//	(void *)Uart0_Rx_Polling_High_Baudrate,   "UART0 RX Polling Mode - High Baud Rate      ",
//	(void *)Uart0_Tx_DMA1_High_Baudrate,      "UART0 TX DMA     Mode - High Baud Rate         ",
//  (void *)Uart0_Rx_DMA3_High_Baudrate,      "UART0 RX DMA     Mode - High Baud Rate         ",
//	(void *)Uart0_Tx_DMA1_Fifo_High_Baudrate, "UART0 TX DMA     Mode With FIFO - High Baud Rate     ",
//  (void *)Uart0_Rx_DMA3_Fifo_High_Baudrate, "UART0 RX DMA     Mode with FIFO - High Baud Rate     ",
//  (void *)Uart0_Tx_Fifo_TrigLv_Jung,		"Uart0 FIFO Trig Level Test by Jung",
//	(void *)GPIO_Control,				"General Purpose I/O Control",
	0,0
};

void * uart_fifo[][2]=
{
	(void *)Uart0_Tx_Fifo_TrigLv,		"Uart0 Tx FIFO Trig Level Test ",
	(void *)Uart0_Rx_Fifo_TrigLv,		"Uart0 Rx FIFO Trig Level Test ",
	0,0
};
/*
void Uart0_Send_Break(void)
{
	U32 i;
	Uart_Port_Init();							// GPIO port init.

	Uart_DataFormatSet(0,NP,1,8);				// Channel 0, No Parity, One Stop Bit, 8-Bit Data
	Uart_FunctionSet(CH0,INTORPOL,DISABLE);	// Tx -> Polling, Rx -> Disable
	Uart_BaudRateSet(CH0,115200);			// Channel 0, 115200BPS
	Uart_FifoDisable(0);
	Uart_TxEmpty(0);
	
	uartTxStr=TestString3;
	i=0;
	while(1) {
		getchar();
		printf("%d",i);
		if(rUTRSTAT0&0x4) {
			WrUTXH0(*uartTxStr);
			printf("%c",*uartTxStr);
			if(*uartTxStr == '\0') break;
			uartTxStr++;
			i++;
			}
		if(i==20) {
			rUCON0|=(1<<4);
			printf("Send Break\n");
			i++;
			}
		}

	Uart_Port_Return();						// Restore GPIO port state
}
*/
void Uart0_Send_Break(void)
{
	char cKey;
	
	Uart_Port_Init();
	Uart_DataFormatSet(0,NP,1,8);			// Channel 0, No Parity, One Stop Bit, 8-Bit Data
	Uart_FunctionSet(CH0,INTORPOL,DISABLE);	// Tx -> Polling, Rx -> Disable
	Uart_BaudRateSet(CH0,115200);			// Channel 0, 115200BPS
	Uart_FifoDisable(0);
	Uart_TxEmpty(0);

	printf("You want break signal out and get any key, and then Check Signal\n");	
	printf("If You enter 'x' , Test End!\n");
	while(1)
	{
		cKey = getchar();
		if ( cKey == 'x')
		{
			break;
		}
		rUCON0 = rUCON0 | (1<<4);
	}
		
	Uart_Port_Return();		
}
void Ch10_Uart(void)
{
	int i=0;

	while(1)
	{
		i=0;
		printf("\n");
		printf("================= UART Test =====================\n");
		printf("1. Two Boards Needs for UART Tx/Rx Test\n" );
		printf("   A: Only TX Mode Board B: Only RX Mode Board\n" );				
		printf("2. Board A and B are connected with cross cable\n");
		printf("   cross cable : board A(TxD) --- board B(RxD)\n");
		printf("                 board A(CTS) --- board B(RTS)\n");
		printf("3. Test Sequence -> one. RX Mode Start\n");
		printf("                    two. TX Mode Start\n");
		printf("=================================================\n\n");
		
				
		while(1)
		{   //display menu
//			if((i+1)%2)printf("\n");
			printf("%2d:%s",i,uart_func[i][1]);
			i++;
			if((int)(uart_func[i][0])==0)
			{
				printf("\n");
				break;
			}
			printf("\n");
		}

		printf("\nPress Enter key to exit : ");
		i = GetIntNum();
		if(i==-1) break;		// return.
		if(i>=0 && (i<((sizeof(uart_func)-1)/8)) )	// select and execute...
			( (void (*)(void)) (uart_func[i][0]) )();
	}

}

void Uart0_Fifo_TrigLv_Test(void)
{
	int i=0;

	while(1)
	{
		i=0;
		printf("\n\n");
		while(1)
		{   //display menu
			printf("%2d:%s",i,uart_fifo[i][1]);
			i++;
			if((int)(uart_fifo[i][0])==0)
			{
				printf("\n");
				break;
			}
			printf("\n");
		}

		printf("\nPress Enter key to exit : ");
		i = GetIntNum();
		if(i==-1) break;		// return.
		if(i>=0 && (i<((sizeof(uart_fifo)-1)/8)) )	// select and execute...
			( (void (*)(void)) (uart_fifo[i][0]) )();
	}
}

void Uart0_Tx_Polling(void)
{
	Uart_Port_Init();							// GPIO port init.

	Uart_DataFormatSet(0,NP,1,8);				// Channel 0, No Parity, One Stop Bit, 8-Bit Data
	Uart_FunctionSet(CH0,INTORPOL,DISABLE);	// Tx -> Polling, Rx -> Disable
	Uart_BaudRateSet(CH0,115200);			// Channel 0, 115200BPS
	Uart_FifoDisable(0);

	uartTxStr=TestString1;
	while(1) {
		if(rUTRSTAT0&0x4) {
			WrUTXH0(*uartTxStr);
			if(*uartTxStr == '\0') break;
			uartTxStr++;
			}
		}

	Uart_Port_Return();						// Restore GPIO port state
}

void Uart0_Tx_Interrupt(void)
{
	Uart_Port_Init();							// GPIO port init.

	Uart_DataFormatSet(0,NP,1,8);				// Channel 0, No Parity, One Stop Bit, 8-Bit Data
	Uart_FunctionSet(CH0,INTORPOL,DISABLE);	// Tx -> Polling, Rx -> Disable
	Uart_BaudRateSet(CH0,115200);			// Channel 0, 115200BPS
	Uart_FifoDisable(0);

	uartTxStr=TestString2;
	IsTxDone=FALSE;
	
	pISR_UART0 = (U32)UART0_Tx_ISR;
	rINTMSK &= ~(BIT_UART0);
	rINTSUBMSK &= ~(BIT_SUB_TXD0);

	while(IsTxDone==FALSE);

	rINTSUBMSK |= (BIT_SUB_TXD0);
	rINTMSK |= (BIT_UART0);
	
	Uart_Port_Return();						// Restore GPIO port state
}

void Uart0_Tx_Interrupt_Fifo(void)
{
	Uart_Port_Init();							// GPIO port init.

	Uart_DataFormatSet(0,NP,1,8);				// Channel 0, No Parity, One Stop Bit, 8-Bit Data
	Uart_FunctionSet(CH0,INTORPOL,DISABLE);	// Tx -> Polling, Rx -> Disable
	Uart_BaudRateSet(CH0,115200);			// Channel 0, 115200BPS
	Uart_FifoLvSet(0,TX48BYTE,RX1BYTE);		// Rx Trigger Level is not necessary
//	rUMCON0 = (1<<4);						// AFC Enable

	uartTxStr=TestString3;
	IsTxDone=FALSE;
	
	pISR_UART0 = (U32)UART0_Tx_Fifo_ISR;
	rINTMSK &= ~(BIT_UART0);
	rINTSUBMSK &= ~(BIT_SUB_TXD0);

	while(IsTxDone==FALSE);

	rINTSUBMSK |= (BIT_SUB_TXD0);
	rINTMSK |= (BIT_UART0);
	
	Uart_Port_Return();						// Restore GPIO port state
}

void Uart0_Tx_DMA1(void)
{
	int i;
	
	Uart_Port_Init();							// GPIO port init.

	Uart_DataFormatSet(0,NP,1,8);				// Channel 0, No Parity, One Stop Bit, 8-Bit Data
	Uart_BaudRateSet(CH0,115200);			// Channel 0, 115200BPS
	Uart_FifoDisable(0);

//	uartTxStr=TxBUFFER;
	uartTxStr=TestString4;

/*	for(i=0;i<94;i++)
		*(uartTxStr+i)=(char)(i+33);
		*(uartTxStr+i)='\n';
		*(uartTxStr+i+1)='\0';		
*/	
	Uart_Tx_DMA1_Set();
	Uart_FunctionSet(CH0,DMAREQ0,DISABLE);	// Tx -> DMA Request, Rx -> Disable

	while(IsTxDone==FALSE);

	rINTMSK|=(BIT_DMA1);
	
	Uart_Port_Return();						// Restore GPIO port state
}

void Uart0_Tx_DMA1_Fifo(void)
{
	int i;
	
	Uart_Port_Init();							// GPIO port init.

	Uart_DataFormatSet(0,NP,1,8);				// Channel 0, No Parity, One Stop Bit, 8-Bit Data
	Uart_BaudRateSet(CH0,115200);			// Channel 0, 115200BPS
	
//	uartTxStr=TxBUFFER;
	uartTxStr=TestString5;
	
/*	for(i=126;i>32;i--)
		*(uartTxStr+(126-i))=(char)(i);
		*(uartTxStr+(126-i))='\n';
		*(uartTxStr+(126-i+1))='\0';
*/
	Uart_FifoLvSet(0,TX48BYTE,RX1BYTE);		// Rx Trigger Level is not necessary
	Uart_Tx_DMA1_Set();
	Uart_FunctionSet(CH0,DMAREQ0,DISABLE);	// Tx -> DMA Request, Rx -> Disable

	while(IsTxDone==FALSE);

	rINTMSK|=(BIT_DMA1);
	
	Uart_Port_Return();						// Restore GPIO port state
}

void Uart0_Rx_Polling(void)
{
	Uart_Port_Init();							// GPIO port init.

	Uart_DataFormatSet(0,NP,1,8);				// Channel 0, No Parity, One Stop Bit, 8-Bit Data
	Uart_FunctionSet(CH0,DISABLE,INTORPOL);	// Rx -> Polling, Tx -> Disable
	Uart_BaudRateSet(CH0,115200);			// Channel 0, 115200BPS
	Uart_FifoDisable(0);

	uartRxStr=RxBUFFER;
	RxBufferClear();
	
	while(1) {
		if(rUTRSTAT0&0x1) {
			*uartRxStr=RdURXH0();
			if(*uartRxStr == '\0') break;
			uartRxStr++;
			}
		}

	uartRxStr=RxBUFFER;
	
	while(1) {
		printf("%c",*uartRxStr);
		if(*uartRxStr == '\0') break;
		uartRxStr++;
		}

	Uart_TxEmpty(0);
	Uart_Port_Return();						// Restore GPIO port state

	Uart_TxEmpty(1);
	Delay(1000);
}

void Uart0_Rx_Interrupt(void)
{
	Uart_Port_Init();							// GPIO port init.

	Uart_DataFormatSet(0,NP,1,8);				// Channel 0, No Parity, One Stop Bit, 8-Bit Data
	Uart_FunctionSet(CH0,DISABLE,INTORPOL);	// Rx -> Interrupt, Tx -> Disable
	Uart_BaudRateSet(CH0,115200);			// Channel 0, 115200BPS
	Uart_FifoDisable(0);

	uartRxStr=RxBUFFER;
	RxBufferClear();

	IsRxDone=FALSE;
	
	pISR_UART0 = (U32)UART0_Rx_ISR;
	rINTMSK &= ~(BIT_UART0);
	rINTSUBMSK &= ~(BIT_SUB_RXD0|BIT_SUB_ERR0);

	while(IsRxDone==FALSE);

	rINTSUBMSK |= (BIT_SUB_RXD0|BIT_SUB_ERR0);
	rINTMSK |= (BIT_UART0);
	
	uartRxStr=RxBUFFER;
	
	while(1) {
		printf("%c",*uartRxStr);