uart.c

本source code 為s3c4510的bootloader

   UARTTxIntOff(cn);			// disable tx int
   UARTRxIntOff(cn);			// disable rx int 
   UARTSetLoopBack(cn,0);		// clear loopback mode 	
  }
  
 TimerStop(1);				// reset timer 0
 TimerReset(1);

 Print("\nTx bytes=%d,%d, Rx bytes=%d,%d Errors=%d,%d",
   txcount[0], txcount[1], 
   rxcount[0], rxcount[1],
   errcount[0], errcount[1]
 );
 print_uart_err(); 			// 
 return(rvl);
}

////////////////////////////////////////////////////////////////////////////////
// UART External Loopback test /////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

int UARTExtLoopBackInt(int chan)
{
 int rvl = 1;				// return code 
 int cn;				// channel number 

// 
 TimerReset(1);					// reset timer 0
 TimerInit (1,(ONE_SECOND/TICKS_PER_SECOND));	// init timer  0
 TimerStart(1);					// start timer 0

 for(cn = 0; cn < 2; ++cn) 
  { 
   U32 ascii = 0;			// sended byte
   U32 wait = 0;			// next waited byte
   int txcount = 0; 			// tx bytes 
   int rxcount = 0; 			// tx bytes 
   int errcount = 0;			// errors
   int more = 1;			// exit flag
   U8 ch; 

   if((cn == chan || chan == -1) == 0) 
    {
      continue;
    }  

   Print("\nUART%d External Loopback Test", cn); 
   UARTRxIntOn(cn); 			// enable UART Rx Interrupt
   UARTTxIntOn(cn);			// enable UART Tx Interrupt
   Enable_Int(nGLOBAL_INT);		// enable global int 

   while(more) 
    {
     if(ascii < 1024 * 256)
      {
// send bytes 
       while(ascii < 1024 * 256)
        {
         if(i_putc(cn, ascii) == 0)
          {				// Tx Queue full
           break;				
          } 
	 txcount++;
         ascii++; 			// next sended byte
        } 
      }
     else 
     if(TxQ[cn].cnt == 0)
      {
// all test bytes are sended 
       more = 0;
       UARTWaitTxComp(cn);		// wait last byte transmit completition
       TimerWaitMs(1, 100);	
      }

     while(i_getc(cn, & ch) != 0)
      {
       rxcount++;				// rx bytes 
       if(ch != (U8) wait)
        {
// received byte not equal waited //////////////////////////////////////////////
         if(cn == CONSOLE) {		// write error to report buffer
           put_uart_err(txcount, rxcount, wait, ch); // 
         } else {
           Print("\nRx error sended=[0x%02x] wait=[0x%02x] receive=[0x%02x]", 
            (ascii & 0xFF), wait, ch);
         }
         rvl = 0;			// clear return code 
         wait = ch;			// reset wait byte
         errcount++;			// rx errors
        } 
       wait++;				// next waited byte
      }
    }

   UARTRxIntOff(cn); 			// enable UART Rx Interrupt
   UARTTxIntOff(cn);			// enable UART Tx Interrupt
   Print("\nTx bytes=%d, Rx bytes=%d, Errors=%d", txcount, rxcount, errcount);
   if(cn == CONSOLE) {			// print error report 
     print_uart_err(); 			// 
   }
  }

 TimerStop(1);				// reset timer 0
 TimerReset(1);
 return(rvl);
}

////////////////////////////////////////////////////////////////////////////////
// loopback test interrupt mode (original) /////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////


U32 UARTLoopBackInt(int channel)
{
 U32 txcount  = 0;			// transmit bytes 
 U32 rxcount  = 0;			// receive bytes 
 U32 errcount = 0;			// Rx errors (received byte not equal waited)
 int rvl = 1;				// return code
 int more = 1;				// continue flag 
 int ascii;				// sended byte
 U32 msstart;				// start millisecond 
 U32 mscur;				// current millisecond
 U32 mswait=0;
 TIME tm;				// TIME struct 
 U8 wait;				// waited byte
 U8 ch;					// received byte

 if(channel < 0 || channel > 1)
  {					// invalid channel number
   return(0);
  } 

// ptint test title ////////////////////////////////////////////////////////////
 Print("\n\nUART%d internal Loopback test (interrupt mode)...", channel);
 if(channel != CONSOLE)
  {
   Print("\nTo break test press any key...");
   while(kbd_hit()) {			// clear console input 
     ch = get_byte();
    }
  }

// wait UART transmit complete & set loopback mode ////////////////////////////
 UARTWaitTxComp(channel);		// wait UART0 transmit complete
 UARTSetLoopBack(channel, 1);		// set loop back mode

 TimerReset(1);					// reset timer 0
 TimerInit (1,(ONE_SECOND/TICKS_PER_SECOND));	// init timer  0
 TimerStart(1);					// start timer 0
//
 UARTRxIntOn(channel); 			// enable UART Rx Interrupt
 UARTTxIntOn(channel);			// enable UART Tx Interrupt
 Enable_Int(nGLOBAL_INT);		// enable global int 

// 
 GetSysTime(1, & tm);	
 msstart = tm.tm_ms + (tm.tm_sec + tm.tm_min * 60) * 1000;

 wait = 0;				// start waited byte 
 ascii = 0;				// start sended byte 

 while(more)
  {
//
   if(ascii < 1024 * 256)
    {
     while(ascii < 1024 * 256)
      {
       if(i_putc(channel, ascii) == 0)
        {				// Tx Queue full
         break;				
        } 

       txcount++; 			// calulate tx bytes
       ascii++; 			// next sended byte
      }
    }
   else
    {
     if(TxQ[channel].cnt == 0)
      {
// Tx queue empty => clear more flag /////////////////////////////////////////// 
       more = 0;
       UARTWaitTxComp(channel);		// wait last byte transmit completition
       TimerWaitMs(1, 100);	
      }
    } 


// receive & check bytes ///////////////////////////////////////////////////////

   while(i_getc(channel, & ch) != 0)
    {
     rxcount++;				// rx bytes 
     if(ch != wait)
      {
// received byte not equal waited //////////////////////////////////////////////
       if(channel == CONSOLE) {		// write error to report buffer
         put_uart_err(txcount, rxcount, wait, ch); // 
       } else {
         Print("\nRx error sended=[0x%02x] wait=[0x%02x] receive=[0x%02x]", 
          (ascii & 0xFF), wait, ch);
       }
       rvl = 0;				// clear return code 
       wait = ch;			// reset wait byte
       errcount++;			// rx errors
      } 
     wait++;				// next waited byte
    }

   if(channel == CONSOLE)
    {
     continue;
    } 

// 
   if(kbd_hit())
    {
/////////////////////////////////////////////////////////////////////////////////
// test breaked from console ////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
     ch = get_byte();			// 

     more = 1;
     while(more)
      {
       if(TxQ[channel].cnt == 0)
        {
         more = 0;
         UARTWaitTxComp(channel);	// wait last byte transmit completition
         TimerWaitMs(1,100);
        }

//        
       while(i_getc(channel, & ch) != 0)
        {
         rxcount++;			// rx bytes 
         if(ch != wait)
          {
// received byte not equal waited //////////////////////////////////////////////
           if(channel != 0)
            {
             Print("\nRx error sended=[0x%02x] wait=[0x%02x] receive=[0x%02x]", (ascii & 0xFF), wait, ch);
            }
           rvl = 0;			// clear return code 
           wait = ch;			// reset wait byte
           errcount++;			// rx errors
          } 
         wait++;			// next waited byte
        }
      }
    }
  }

//
 GetSysTime(1, & tm);
 mscur = tm.tm_ms + (tm.tm_sec + tm.tm_min * 60) * 1000;
 mscur -= msstart + mswait;

 TimerStop(1);				// reset timer 0
 TimerReset(1);

 UARTRxIntOff(channel); 		// disable UART Rx Interrupt
 UARTTxIntOff(channel);			// disable UART Tx Interrupt
 UARTSetLoopBack(channel, 0);		// clear loopback

 if(txcount != rxcount || errcount != 0)
  {
   rvl = 0;
  } 

// print test statistics ///////////////////////////////////////////////////////
 Print("\nTransmit bytes = [%d]", txcount);	// tx bytes 
 Print("\nBytes sec      = [%d]",(txcount * 1000 / mscur));
 Print("\nReceive bytes  = [%d]", rxcount);	// rx bytes 
 Print("\nReceive errors = [%d]", errcount);	// rx errors
// 
 Print("\nOverrun errors = [%d]", UART_ERR[channel].overrun);	
 Print("\nParity  errors = [%d]", UART_ERR[channel].parity );
 Print("\nFrame   errors = [%d]", UART_ERR[channel].frame  );
 Print("\nBreak          = [%d]", UART_ERR[channel].brdet  );
// clear error statistics //////////////////////////////////////////////////////
 UART_ERR[channel].overrun = 0;		// overrun errors
 UART_ERR[channel].parity  = 0;		// parity  errors
 UART_ERR[channel].frame   = 0;		// frame   errors
 UART_ERR[channel].brdet   = 0;		// 
// 
 if(rvl == 0 && channel == CONSOLE) {	
   print_uart_err();			// print uart rx error buffer
 } 

// 
 if(rvl == 1) 
  {
   Print("\nOk.\n");
  }
 else 
  {
   Print("\nFail.\n");
  } 
//
 return(rvl);
}

////////////////////////////////////////////////////////////////////////////////
// UART Loop back test in pooling mode /////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

U32 UARTAutoLoopBack(int channel)
{
 U32 rvl[2] = {1, 1};
 int cn;

 TimerReset(1);					// reset timer 0
 TimerInit (1,(ONE_SECOND/TICKS_PER_SECOND));	// init timer  0
 TimerStart(1);					// start timer 0
 
 for(cn = 0; cn < 2; ++cn) 
  {
   U32 ascii;				// sequence number
   U32 cnt;				// send bytes 
   U32 err;				// error count 
   U8 wait;				// waited rx byte 
   U8  ch;				// received byte 

   if((cn == channel || channel == -1) == 0)
    {
     continue;
    } 

//  UART Lop back test /////////////////////////////////////////////////////////
   Print("\nUART%d internal Loopback test (polling mode)...", cn);
   UARTRxIntOff(cn); 			/* disable UART0 Rx Interrupt */
   UARTTxIntOff(cn);			/* disable UART0 Tx Interrupt */ 
   UARTWaitTxComp(cn);			/* wait tx comp */
   UARTSetLoopBack(cn,1);		/* Set Loopback test mode */
   cnt = UARTGetSpeed(cn);		/* tx bytes count */
   err = 0;				/* error count */

   for(ascii = 0, wait = 0; cnt-- > 0; ascii++) 
    {
     put_char(cn, ascii);
     ch = get_char(cn);
     if(ch != (U8) wait) 
      {
       err += 1;
       rvl[cn] = 0;
       wait = ch; 	
       put_uart_err(ascii,ascii,(U8) ascii, ch);
      }
     wait++; 
    }
   UARTSetLoopBack(cn,0);		/* clear loopback mode */
   if(rvl[cn] == 1) 
    {
     Print("\nOk.\n");
    }
   else 
    {
     Print("\nFail. Tx bytes=[%d], Rx bytes=[%d],Err count=[%d]\n", 
            ascii, ascii, err);
     print_uart_err();
    } 
  }

 if(rvl[0] == 1 && rvl[1] == 1) 
  {
   return(1);
  }
 else 
  {
   return(0);
  }
}


/////////////////////////////////////////////////////////////////////////////////
// UART External loop back test in interrupt mode ///////////////////////////////
/////////////////////////////////////////////////////////////////////////////////


void StringEcho(U32 channel)
{
 U8 ch;

 do 
  {
   Print("\n\nString echo for UART");
   if(channel == 0)
    {
     Print("0 interrupt test.");
    }
   else
   if(channel == 1)
    {
     Print("1 interrupt test.");
    }
   else
    {
     while(1)
      {
       Print("\nSelect UART [0/1]");
       channel = get_upper();
       if(channel >= '0' && channel <= '1')
        {
         channel -= '0';
         break;
        }
      }
    }

 //
   Print("\nInput characters will be echoed on Console");
   Print("\nTo escape, enter ESC key : ");

   UARTTxIntOn(channel);		// Enable UART Tx Interrupts
   UARTRxIntOn(channel);		// Enable UART Rx Interrupts 
   Enable_Int(nGLOBAL_INT);

   do 
    {
     while( i_getc(channel,& ch) == 0); 
     while(!i_putc(channel,ch))
      {
      }
    }
    while(ch != KEY_CR && ch != KEY_ESC);

   UARTTxIntOff(channel);		// Enable UART Tx Interrupts
   UARTRxIntOff(channel);		// Enable UART Rx Interrupts 
  }
 while(ch != KEY_ESC);

// 
 Print("\n");
 UARTTxIntOff(channel);			// disable UART Tx Interrupts
 UARTRxIntOff(channel);			// disable UART Rx Interrupts 
}

#ifdef _KS32C50100_
/////////////////////////////////////////////////////////////////////////////////
// Print UARTLCON0, UARTLCON1 ///////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////

static int PrintUARTLCON(int num)
{
 U32 uartlcon;				// UARTLCON register value
 if(num == 0)
  {
   uartlcon = UARTLCON0;		// UARTLCON0
  }
 else
 if(num == 1)
  {
   uartlcon = UARTLCON1;		// UARTLCON1
  }
 else
  {
   return(0);
  }