S3C2440 UART operation (FIFO interrupt mode)

 
3 independent serial ports, each of which can be

operated using DMA and interrupt modes. Each contains 2 64-byte FIFOs, one for receiving and one for transmitting.
 
Non-FIFO mode is equivalent to a register buffer mode of FIFO mode.
 
Each UART has 7 states, overrun error, check error, frame error, breakpoint, receive buffer ready, transmit buffer empty, transmit shift register empty.
 
When the data in the receive shift register is transferred to the FIFO, and the received data triggers  the threshold of the Rx FIFO, the Rx interrupt is generated.
 
When the data in the transmitter FIFO that has not yet been sent reaches the Tx FIFO threshold, the Tx interrupt is generated. (I think it should be understood as: the interrupt is generated when the FIFO in the transmitter is empty after the transmission is completed.)
 
 
Function: Enter 16 bytes on the serial port, including carriage return, and then the input characters will be echoed on the serial terminal.
 
 
Program code:
 
//Function declaration
void Uart_init(void);
void int_init(void);
void __irq Uart0(void);
void Main(void);


//Cache
static unsigned char mywords[100] = {0,0};
static int data_is_ready = 0;  
//Initialize uart
void Uart_init(void)
{
//Initialize pin
rGPHCON = 0x00faaa; //Set the pin to TXD0 and RXD0 mode
rGPHUP   = 0x7ff;   //No pull-up resistor
//Initialize UART
rULCON0 = 0x03; //Send 8 bits of data each time, one stop bit, no check, normal mode
rUCON0 = (0x05) | (1<<9); //Set reception and transmission to interrupt mode
rUFCON0 = (0x3<<6) | (0x2<<4) | (0x01<<0); //Enable FIFO, send 48 bytes, receive 16 bytes
rUMCON0 = 0;
//Set clock frequency
rUBRDIV0 = 26;
 }
 //Initialize interrupt
void int_init(void)
{
rINTMOD=0x0; //Interrupt mode register
   pISR_UART0 = (int)Uart0; //Set interrupt service function address
   rINTSUBMSK = ~(0x3);    //Open UART0 send and receive interrupt mask
rINTMSK = ~(0x1<<28);   //Open UART0 interrupt mask
//rSUBSRCPND=(BIT_SUB_TXD0); 
}




void Main(void)
{
MMU_Init();
int_init();
Uart_init();
while(1);
}


//Interrupt handling function
void __irq Uart0(void)
{
unsigned char *ps = mywords;
int i;
if(rSUBSRCPND & BIT_SUB_RXD0)   //Receive interrupt
{
rINTSUBMSK |= BIT_SUB_RXD0;  
while((rUFSTAT0&0x1f)>0)) 
{ 
           *ps++ = rURXH0;  
       }  
       data_is_ready = 1;        
       rSUBSRCPND = BIT_SUB_RXD0;  
}
//Send interrupt
else if(rSUBSRCPND & BIT_SUB_TXD0) 
{
rINTSUBMSK |= BIT_SUB_TXD0;    
          
       while(( !(rUFSTAT0&(1<<14))) && (*ps != '\r'))  
       {  
           rUTXH0 = *ps++;          
           for(i=0; i<100;i++);  
       }     
          
  
       data_is_ready = 0;  
  
       rSUBSRCPND = BIT_SUB_TXD0;  
   } 
   rSRCPND = BIT_UART0;  
   rINTPND = BIT_UART0;  
   if(data_is_ready)  
       rINTSUBMSK &= ~(BIT_SUB_TXD0);     
   else  
       rINTSUBMSK &= ~(BIT_SUB_RXD0); 
       //rINTSUBMSK &= ~(BIT_SUB_TXD0);
}
 
After testing, the function can be completed.