uart.c

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

		{
			IsTxDone=TRUE;
			break;
		}
		else
			uartTxStr++;
	}

	if(IsTxDone!=TRUE)
	{
		rINTMSK &= ~(BIT_UART0);
		rINTSUBMSK &= ~(BIT_SUB_TXD0);
	}
	iIRQ_TX++;	
}

void __irq UART0_Rx_ISR(void)
{
	UERSTAT=rUERSTAT0;

	rINTSUBMSK |= (BIT_SUB_RXD0|BIT_SUB_ERR0);
	rINTMSK |= (BIT_UART0);
	ClearPending(BIT_UART0);		// Clear source pending

	if(rSUBSRCPND&BIT_SUB_RXD0)
	{
		*uartRxStr=RdURXH0();
		if(*uartRxStr == '\0')
		{
			IsRxDone=TRUE;
		}
		else
		{
			uartRxStr++;
		}
		rSUBSRCPND=BIT_SUB_RXD0;	// Clear Sub int pending        
	}	// if(rSUBSRCPND&BIT_SUB_RXD0)


#if 0
	else {

		if(UERSTAT&0x1) {	// Overrun Error
			printf("Overrun Error\n");
			}	// if(UERSTAT&0x1)
		else if(UERSTAT&0x2) {	// Parity Error
			printf("Parity Error\n");
			}	// if(UERSTAT&0x2)
		else if(UERSTAT&0x4) {	// Frame Error
			printf("Frame Error\n");
			}	// if(UERSTAT&0x4)
		else if(UERSTAT&0x8) {	// Break Error
			printf("Break Error\n");
			}	// if(UERSTAT&0x8)
		else {
			printf("Why Rx Int?\n");
			}
		}

#else
	if(rSUBSRCPND&BIT_SUB_ERR0) {

		if(UERSTAT&0x1) 	// Overrun Error
			printf("Overrun Error\n");
		if(UERSTAT&0x2) 	// Parity Error
			printf("Parity Error\n");
		if(UERSTAT&0x4) 	// Frame Error
			printf("Frame Error\n");
		if(UERSTAT&0x8) 	// Break Error
			printf("Break Error\n");
		printf("UERSTAT [0x%08x]\n",UERSTAT);
		rSUBSRCPND=BIT_SUB_ERR0;
	}
#endif

	rINTMSK &= ~(BIT_UART0);
	rINTSUBMSK &= ~(BIT_SUB_RXD0|BIT_SUB_ERR0);

}

#if 0
void __irq UART0_Rx_ISR(void)
{
	rINTSUBMSK |= (BIT_SUB_RXD0|BIT_SUB_ERR0);
	rINTMSK |= (BIT_UART0);
	ClearPending(BIT_UART0);		// Clear source pending

	if(rSUBSRCPND&BIT_SUB_RXD0) {
		rSUBSRCPND=BIT_SUB_RXD0;	// Clear Sub int pending        
		*uartRxStr=RdURXH0();
		if(*uartRxStr == '\0')
			IsRxDone=TRUE;
		else {
			uartRxStr++;
//			rINTSUBMSK &= ~(BIT_SUB_RXD0|BIT_SUB_ERR0);
//			rINTMSK &= ~(BIT_UART0);
			}
		}
	else if(rUERSTAT0&0x1) {	// Overrun Error
		rSUBSRCPND=BIT_SUB_ERR0;	// Clear Sub int pending        
		printf("Overrun Error\n");
		}
	else if(rUERSTAT0&0x2) {	// Parity Error
		rSUBSRCPND=BIT_SUB_ERR0;	// Clear Sub int pending        
		printf("Parity Error\n");
		}
	else if(rUERSTAT0&0x4) {	// Frame Error
		rSUBSRCPND=BIT_SUB_ERR0;	// Clear Sub int pending        
		printf("Frame Error\n");
		}
	else if(rUERSTAT0&0x8) {	// Break Signal
		rSUBSRCPND=BIT_SUB_ERR0;	// Clear Sub int pending        
		printf("Break Signal\n");	
		}
	else {
		rSUBSRCPND=BIT_SUB_ERR0;	// Clear Sub int pending        
		printf("Why Rx Int?\n");
		}

	rINTSUBMSK &= ~(BIT_SUB_RXD0|BIT_SUB_ERR0);
	rINTMSK &= ~(BIT_UART0);
}
#endif

void __irq UART0_Rx_Fifo_ISR(void)
{
	UERSTAT=rUERSTAT0;

	rINTSUBMSK |= (BIT_SUB_RXD0|BIT_SUB_ERR0);
	rINTMSK |= (BIT_UART0);
	ClearPending(BIT_UART0);		// Clear source pending

	if(rSUBSRCPND&BIT_SUB_RXD0)
	{
//		while(rUFSTAT0&0x1f)
		while(rUFSTAT0&0x3f)		
		{
			*uartRxStr=RdURXH0();
			if(*uartRxStr == '\0')
			{
				IsRxDone=TRUE;
				break;
			}
			else
			{
				uartRxStr++;
			}
		}	// while(rUFSTAT0&0x1f)
		rSUBSRCPND=BIT_SUB_RXD0;	// Clear Sub int pending        
	}	// if(rSUBSRCPND&BIT_SUB_RXD0)
	iIRQ++;

#if 0
		else {
	
			if(UERSTAT&0x1) {	// Overrun Error
				printf("Overrun Error\n");
				}	// if(UERSTAT&0x1)
			else if(UERSTAT&0x2) {	// Parity Error
				printf("Parity Error\n");
				}	// if(UERSTAT&0x2)
			else if(UERSTAT&0x4) {	// Frame Error
				printf("Frame Error\n");
				}	// if(UERSTAT&0x4)
			else if(UERSTAT&0x8) {	// Break Error
				printf("Break Error\n");
				}	// if(UERSTAT&0x8)
			else {
				printf("Why Rx Int?\n");
				}
			}
	
#else
		if(rSUBSRCPND&BIT_SUB_ERR0) {
	
			if(UERSTAT&0x1) 	// Overrun Error
				printf("Overrun Error\n");
			if(UERSTAT&0x2) 	// Parity Error
				printf("Parity Error\n");
			if(UERSTAT&0x4) 	// Frame Error
				printf("Frame Error\n");
			if(UERSTAT&0x8) 	// Break Error
				printf("Break Error\n");
			printf("UERSTAT [0x%08x]\n",UERSTAT);
			rSUBSRCPND=BIT_SUB_ERR0;
		}
#endif

	rINTMSK &= ~(BIT_UART0);
	rINTSUBMSK &= ~(BIT_SUB_RXD0|BIT_SUB_ERR0);
} //__irq UART0_Rx_Fifo_ISR

void __irq UART1_Rx_Fifo_ISR_Jung(void)
{
	UERSTAT=rUERSTAT1;

	rINTSUBMSK |= (BIT_SUB_RXD1|BIT_SUB_ERR1);
	rINTMSK |= (BIT_UART1);
	ClearPending(BIT_UART1);		// Clear source pending

//	IsRxDone=TRUE;	// while(rUFSTAT0&0x1f)
	iIRQ++;
	WrUTXH0(iIRQ);

	if ( iIRQ > 3) IsRxDone = TRUE ;

	rSUBSRCPND=BIT_SUB_RXD1;	// Clear Sub int pending        

	if(rSUBSRCPND&BIT_SUB_ERR1)
	{
		if(UERSTAT&0x1) 	// Overrun Error
			printf("Overrun Error\n");
		if(UERSTAT&0x2) 	// Parity Error
			printf("Parity Error\n");
		if(UERSTAT&0x4) 	// Frame Error
			printf("Frame Error\n");
		if(UERSTAT&0x8) 	// Break Error
			printf("Break Error\n");
		printf("UERSTAT [0x%08x]\n",UERSTAT);
		rSUBSRCPND=BIT_SUB_ERR1;
	}
	rINTMSK &= ~(BIT_UART1);
	rINTSUBMSK &= ~(BIT_SUB_RXD1|BIT_SUB_ERR1);
} //__irq UART0_Rx_Fifo_ISR




#if 0
void __irq UART0_Rx_Fifo_ISR(void)
{
	rINTSUBMSK |= (BIT_SUB_RXD0|BIT_SUB_ERR0);
	rINTMSK |= (BIT_UART0);
	ClearPending(BIT_UART0);		// Clear source pending

	if(rSUBSRCPND&BIT_SUB_RXD0) {
		rSUBSRCPND=BIT_SUB_RXD0;	// Clear Sub int pending        

		while(rUFSTAT0&0x1f) {
			*uartRxStr=RdURXH0();

			if(*uartRxStr == '\0') {
				IsRxDone=TRUE;
				break;
				}
			else
				uartRxStr++;
			}

//		if(IsRxDone!=TRUE) {
//			rINTMSK &= ~(BIT_UART0);
//			rINTSUBMSK &= ~(BIT_SUB_RXD0|BIT_SUB_ERR0);
//			}

		}
	else if(rUERSTAT0&0x1) {	// Overrun Error
		rSUBSRCPND=BIT_SUB_ERR0;	// Clear Sub int pending        
		printf("Overrun Error\n");
		}
	else if(rUERSTAT0&0x2) {	// Parity Error
		rSUBSRCPND=BIT_SUB_ERR0;	// Clear Sub int pending        
		printf("Parity Error\n");
		}
	else if(rUERSTAT0&0x4) {	// Frame Error
		rSUBSRCPND=BIT_SUB_ERR0;	// Clear Sub int pending        
		printf("Frame Error\n");
		}
	else if(rUERSTAT0&0x8) {	// Break Signal
		rSUBSRCPND=BIT_SUB_ERR0;	// Clear Sub int pending        
		printf("Break Signal\n");

#if 0		
		while(rUFSTAT0&0x1f) {
			*uartRxStr=RdURXH0();

			if(*uartRxStr == '\0') {
				IsRxDone=TRUE;
				break;
				}
			else
				uartRxStr++;
			}
#endif
		}
	else {
		rSUBSRCPND=BIT_SUB_ERR0;	// Clear Sub int pending        
		printf("Why Rx Int?\n");
		}

	printf("U");

	while(rUFSTAT0&0x1f) {
		*uartRxStr=RdURXH0();
	
		if(*uartRxStr == '\0') {
			IsRxDone=TRUE;
			break;
			}
		else
			uartRxStr++;
		}

	if(IsRxDone!=TRUE) {
		rINTMSK &= ~(BIT_UART0);
		rINTSUBMSK &= ~(BIT_SUB_RXD0|BIT_SUB_ERR0);
		}
}
#endif

void __irq Uart_Dma1Tx_Int(void)
{
	rINTMSK|=(BIT_DMA1);
	ClearPending(BIT_DMA1);

	IsTxDone=TRUE;

	rINTMSK &= ~(BIT_DMA1);
}

void __irq Uart_Dma3Rx_Int(void)
{
	rINTMSK|=(BIT_DMA3);
	ClearPending(BIT_DMA3);

	IsRxDone=TRUE;

	rINTMSK &= ~(BIT_DMA3);
}

//=============================================================================================//
void RxBufferClear(void)
{
	int i;
	int *ptrBuf;

	ptrBuf=RxBUFFER;

	for(i=0;i<0x1000;i+=4)
		*(ptrBuf+i) = 0;
}

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

	pUART->UFCON &= ~(0xf<<4);
	pUART->UFCON |= (tx<<6)|(rx<<4);	// Fifo Level Set
}

void Uart_FifoDisable(U32 ch)
{
	Uart_Select(ch);
//	pUART->UCON &= ~(3<<8);	// Tx, Rx => Interrupt Type is Pulse
	pUART->UFCON &= ~1;	// Fifo Disable
}


void Uart_FifoEnable(U32 ch)
{
	Uart_Select(ch);

//	pUART->UCON |= (3<<8);	// Tx, Rx => Interrupt Type is Level
	pUART->UFCON |= 1;	// Fifo Enable
}

void Uart_FifoReset(U32 ch)
{
	Uart_Select(ch);
	pUART->UFCON |= (3<<1);	// Fifo Tx,Rx Reset
}

void Uart_BaudRateSet(U32 ch, U32 bps)
{
	int DIV_VAL, nSlot;
	int UClk;

	Uart_Select(ch);

#if 0
	switch((pUART->UCON >>10)&0x3) {
		case 0:
		case 2:
			SystemCLK();
			UClk=PCLK;
//			printf("UClk = %d\n",UClk);
			break;
		case 1:
			printf("Uart_Baud_Rate_Set (UEXTCLK)\n");	while(1);
			break;
		case 3:
			rCLKDIVN = (rCLKDIVN & ~(0xf<<8))|(3<<8);	// UARTCLK=MPLL/4
			rCLKSRC |= (1<<8);	// UARTSYSCLK = FOUT(MPLL) 
			rCLKCON = (1<<14);	// UARTCLK Enable
			SystemCLK();
			UClk=	MPLL >> ((rCLKDIVN>>8)&0xf);
//			printf("UClk = %d\n",UClk);
			break;
		}
#endif

	SystemCLK();
	UClk=PCLK;

	DIV_VAL = ( (int)(UClk/16./bps+0.5) -1 );   //Baud rate divisior
	nSlot = (int)((DIV_VAL - (int)DIV_VAL) * 16);

	pUART->UBRDIV = 0;
	pUART->UDIVSLOT = 0;

	pUART->UBRDIV = DIV_VAL;
	pUART->UDIVSLOT = nSlotTable[nSlot];
}

void Uart_FunctionSet(U32 ch, U32 Tx, U32 Rx)
{
	Uart_Select(ch);
	pUART->UCON &= ~(0x3ff);

 	if (Rx != DISABLE) pUART->UCON |= (1<<7)|(1<<6);	// Rx Time Out En. Rx Error Status Int. En.

	pUART->UCON &= ~(3<<8);		// Tx, Rx => Interrupt Type is Pulse
	pUART->UCON = (pUART->UCON & ~(0xf)) | ((Tx<<2)|Rx) ;
}

void Uart_DataFormatSet(U32 ch, U32 ParityMode, U32 StopBitNum, U32 DataBitNum)
{
	Uart_Select(ch);
	pUART->ULCON = 0;
	if((StopBitNum<1)||(StopBitNum>2)) printf("Uart_Line_Set Error (StopBitNum)\n");
	if((DataBitNum<5)||(DataBitNum>8)) printf("Uart_Line_Set Error (DataBitNum)\n");
	pUART->ULCON = (ParityMode<<3)|((StopBitNum-1)<<2)|(DataBitNum-5);
}

void Uart_Port_Init(void)
{
	saved_rGPHCON=rGPHCON;			// GPIO Configuration Backup
	saved_rGPHDAT=rGPHDAT;
	saved_rGPHDN=rGPHDN;

	saved_ULCON = rULCON1;
	saved_UCON = rUCON1;
	saved_UFCON = rUFCON1;
	saved_UMCON = rUMCON1;
	saved_UBRDIV = rUBRDIV1;
	saved_UDIVSLOT = rUDIVSLOT1;

	rGPHCON = (rGPHCON&~(0xfff))|(0xaaa);	// GPIO -> RXD 0,1,2 TXD 0,1,2
	rGPHDN = 0x7fff;						// Pull-down Disable
}

void Uart_Select(U32 ch)
{
	switch(ch) {
		case 0:
			pUART = (void *)(0x50000000);
			break;
		case 1:
			pUART = (void *)(0x50004000);
			break;
		case 2:
			pUART = (void *)(0x50008000);
			break;
		default:
			printf("[Error] Select Uart\n");
			while(1);
		}
}

void Uart_Port_Return(void)
{
	rGPHCON=saved_rGPHCON;	// GPIO Configuration Recovery
	rGPHDAT=saved_rGPHDAT;
	rGPHDN=saved_rGPHDN;

	 rULCON1 = saved_ULCON;
	 rUCON1 = saved_UCON;
	 rUFCON1 = saved_UFCON;
	 rUMCON1 = saved_UMCON;
	 rUBRDIV1 = saved_UBRDIV;
	 rUDIVSLOT1 = saved_UDIVSLOT;
}

void SelectUartClockSource(U32 ch, U32 clksrc)
{
	Uart_Select(ch);
	pUART->UCON = (pUART->UCON & ~(3<<10))|(clksrc<<10);
}

// -------------------------------- jungil 0911 ---------------------------------------------
// ------------------------------------------------------------------------------------------

void Uart0_Tx_CLK_Change(void)
{
	int i=0;

	printf("Input Test Setting [0:PCLK-UARTCK 1:PCLK-EXTCLK 2: EXTCLK-UARTCLK] ==");
	uSelTest = GetIntNum();
	printf("\n");
		
	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
	
	while(1)
	{
		
		switch(uSelTest)
		{
			case 0: 
				PCLK_Using_Test();    // Using PCLK
				UARTCLK_Using_Test(); // Using UARTCLK
				PCLK_Using_Test();    // Using PCLK
				break;
			case 1:
				PCLK_Using_Test();    // Using PCLK
				EXTCLK_Using_Test(); // Using UARTCLK
				PCLK_Using_Test();    // Using PCLK
				break;
			case 2:
				EXTCLK_Using_Test(); // Using UARTCLK
				UARTCLK_Using_Test(); // Using UARTCLK
				EXTCLK_Using_Test(); // Using UARTCLK
				break;
			default: 
				break;
		}
		
		i++;
		printf("\n");
		if ( i > 5 ) break;
	}

	getchar();
	Uart_Port_Return();						// Restore GPIO port state
}

void PCLK_Using_Test(void)
{
	SelectUartClockSource(1,uPCLK);             // Using PCLK
 	Uart_DataFormatSet(1,NP,1,8);				// Channel 0, No Parity, One Stop Bit, 8-Bit Data
	Uart_FunctionSet(CH1,INTORPOL,INTORPOL);	// Tx -> Polling, Rx -> Disable
    rUBRDIV1 = 34; // PCLK is 66.5Mhz
    rUDIVSLOT1 = 0x1ffff;
	printf("UART PCLK Using Print Out!! OK? \n");
	Uart_TxEmpty(1);
}

void UARTCLK_Using_Test(void)