uart.c

uc/fs文件系统

/******************************************************************************************/
/*	Name:UART.C 																									*/
/* Note:Routines for enabling the UARTs and sending/receiving data via them					*/
/* Time:2001.8.29																									*/
/* Modified by:Leon																								*/
/* Fuctions: Uart2Tx() Uart2Rx() UARTEnable() UARTSendChar() dputchar()							*/
/*				 getch() kbhit()																				*/ 			 
/* Copyright (c) 1998-1999 Cirrus Logic, Inc.															*/
/******************************************************************************************/
#include "conreg.h"
#include "uart.h"
#include "irq.h"

#include <stdarg.h>

extern void ResetPortA(void);
extern void PutByteA(int);

/************************************************************************/
/*               INITIALIZE UART GLOBAL VARIABLE                    	*/
/************************************************************************/

/* Define references to external structures */
SERIAL_DEV   uart_dev_init;
UART_BUFFER  RxQ[NUM_OF_SERIAL_DEV],TxQ[NUM_OF_SERIAL_DEV]; 

#if 1
// AT91_MCK/BAUDRATE/16
#if AT91_MCK == 24000000
BaudTable U_BaudRate[BAUD_TABLE]={ 
/* for 24MHz UART clock */
   9600,156,
   19200,78,
   38400,39,
   57600,26,
   115200,13
};
//default 9600

#else
BaudTable U_BaudRate[BAUD_TABLE]={
/* for 32.768MHz UART clock */
   9600,213,
   19200,106,
   38400,53,
   57600,35,
   115200,17
};
//default 115200
#endif

#endif
extern int int_done;
int uart_done=0;
int uart_com1_done=0;
/************************************************************************/
/*	UART Initialize            					*/
/*   	This function is used to initialize the input and output        */
/*   	control variables.	                                        */
/*      called by put_char			                        */
/************************************************************************/
uint32  UART_Initialize(int uart_port)
{
	if (uart_port == 0 ) {	/* Initialize UART channel 0 */
	    	Disable_Int(US0IRQ_INT);  			/* UART0 interrupt disabled */

	    	uart_dev_init.com_port  =  0; //SERIAL_DEV0;    /* com 0 */
	    	uart_dev_init.baud_rate = baudrate;
	    	uart_dev_init.data_mode = (UCON_RXM_INTREQ|UCON_TXM_INTREQ|UCON_RXSTAT_INT);
	    	uart_dev_init.parity    = ULCON_PMD_NO;   /* No parity */
	    	uart_dev_init.stop_bits = 0;              /* one bit */
	    	uart_dev_init.data_bits = ULCON_WL8;      /* 8bits */

	    	uart_dev_init.clk_sel = 0;                /* internal clock */

	    	UART_Init(&uart_dev_init);    
		Enable_Int(US0IRQ_INT);	
		return SUCCESS1;
	} else if (uart_port == 1 ) {/* Initialize UART channel 1 */	
		Disable_Int(US1IRQ_INT);  			/* UART1 interrupt disabled */
	    	uart_dev_init.com_port = 1; //SERIAL_DEV1;     /* com 1 */
		uart_dev_init.baud_rate =baudrate1;
		uart_dev_init.data_mode = (UCON_RXM_INTREQ|UCON_TXM_INTREQ|UCON_RXSTAT_INT);
	    	uart_dev_init.parity    = ULCON_PMD_NO;   /* No parity */
	    	uart_dev_init.stop_bits = 0;              /* one bit */
	    	uart_dev_init.data_bits = ULCON_WL8;      /* 8bits */

	    	uart_dev_init.clk_sel = 0;                /* internal clock */
	    	UART_Init(&uart_dev_init);

	    	Enable_Int(US1IRQ_INT);  /* Global interrupt disabled */
		return SUCCESS1;
	}
	return ERROR;
}

/************************************************************************/
/* 	Uart main Init function 					*/
/*	called by Uart_Initialize					*/
/************************************************************************/
uint32 UART_Init(SERIAL_DEV *s) 
{
     	uint32    rUARTBRD;
     	int temp;

	   if(s->com_port != 0 && s->com_port !=1) return ERROR;
	   
     	/* UART interrupt off */
     	UARTTxIntOff(s->com_port);
	UARTRxIntOff(s->com_port);

     	/* Initialize UART transmit & receive Queue */
     	TxQInit(s->com_port);
     	RxQInit(s->com_port);
	
     	if(s->com_port) 
     	{   
	     /* default baud rate will be set. sysconf.h */
	    rUARTBRD = U_BaudRate[BaudRateVal(s->baud_rate)].div;	
//     	    rUARTBRD = AT91_MCK/baudrate1/16;          /*CD=Clock/BaudRate/16*/
          /* Interrupt service routine setup */
//in interruput init
        
		US1_MR=0x000008C0;
		//Normal mode,1 stop bit,no parity,
                //Asynchoronous mode,8-bit,MCKI,   
		US1_RTOR=(int)0x0;
		//;US_RTOR Disable Receive Time-out 
		US1_TTGR=(int)0x0;
		//;US_TTGR Disable Transmitter time-guard
        	US1_BRGR  = rUARTBRD;
			
           US1_CR=0x0000010c;//Reset Receiver;Reset Transmitter;Reset Status bits
           temp=US1_CSR;
           US1_CR=0x00000050;//Receiver Enable;Transmitter Enable       
     	} 
     	else 
     	{
	     	rUARTBRD = U_BaudRate[BaudRateVal(s->baud_rate)].div;	
	//     	rUARTBRD = AT91_MCK/baudrate/16;          /*CD=Clock/BaudRate/16*/
	       /* Interrupt service routine setup */
		//in interruput init

        
		US0_MR=0x000008C0;
		//Normal mode,1 stop bit,no parity,
                //Asynchoronous mode,8-bit,MCKI,   
		US0_RTOR=(int)0x0;
		//;US_RTOR Disable Receive Time-out 
		US0_TTGR=(int)0x0;
		//;US_TTGR Disable Transmitter time-guard
        	US0_BRGR  = rUARTBRD;
		
           US0_CR=0x0000000c;           
           US0_CR=0x00000100;//Reset Receiver;Reset Transmitter;Reset Status bits
           US0_CR=0x00000050;//Receiver Enable;Transmitter Enable  
                   

     	}
	if (s->com_port ==SERIAL_DEV0) 
		uart_done= 1;	
	else if (s->com_port ==SERIAL_DEV1) 
		uart_com1_done = 1;	
    
     return(SUCCESS1);
}

/************************************************************************/
/*	Tx queue initialize					        */
/*      This function is used to initialize Tx queue		        */
/*      called by Uart_Init                                             */
/************************************************************************/
void TxQInit(uint32 channel)
{
    int i;

    for(i=0; i < MAXEVENT; i++)  
    {
          TxQ[channel].buff[i] = '\0';
    }

    TxQ[channel].wptr = 0;
    TxQ[channel].rptr = 0;
}
/************************************************************************/
/*	Rx queue initialize					        */
/*      This function is used to initialize Rx queue		        */
/*      called by Uart_Init                                             */
/************************************************************************/
/* Receive Que initialize */
void RxQInit(uint32 channel)
{
    int i;

    for(i=0; i < MAXEVENT; i++) 
    {
         RxQ[channel].buff[i] = '\0';
    }

    RxQ[channel].wptr = 0;
    RxQ[channel].rptr = 0;

}
/************************************************************************/
/*	Uart0 isr						        */
/************************************************************************/
void Uart0isr(void)
{
	int temp,serial_drv = SERIAL_DEV0;
	temp=US0_CSR;
	
	if(temp & (USTAT_TXB_EMPTY|USTAT_TX_READY)) 
    	{
    		US0_CR=0x00000040;
          	if(TxQ[0].rptr == MAXEVENT)
                 	TxQ[0].rptr=0; /*loop back for the queue*/

          	if(TxQ[0].rptr != TxQ[0].wptr) 
          	{
             		US0_THR = TxQ[0].buff[TxQ[0].rptr++];
          	}
          	UARTTxIntOff(0);
    	}
   	   	
	if(!(temp & (USTAT_ERROR))&&(temp&USTAT_RCV_READY))
	// NO frame,parity,overrun err
	{
             if(RxQ[0].wptr+1 != RxQ[0].rptr)
             {
                   RxQ[0].buff[RxQ[0].wptr++] = US0_RHR;
                   if(RxQ[0].wptr == MAXEVENT)
                           RxQ[0].wptr = 0; /*loop back*/
             }
#if 1 /* 2004/5/20 AM11:10, Stphen Yee*/			 
      /*  Modifed by Stephen Yee */
	  if(serial_drv == 0)
             UARTRxIntOff(0);
	  else
#endif	  	
	      UARTRxIntOn(0);
	}
    	US0_CR=0x00000100;

}

#if 0
/************************************************************************/
/*	Uart1 isr						        */
/************************************************************************/
void Uart1isr(void)
{
	int temp;
	temp=US1_CSR;
    	if(temp& USTAT_TXB_EMPTY) 
    	{
          	if(++TxQ[1].rptr == MAXEVENT)
                 	TxQ[1].rptr=0; /*loop back*/
          	if(TxQ[1].rptr != TxQ[1].wptr) 
          	{
             		US1_THR = TxQ[1].buff[TxQ[1].rptr];
          	}
        UARTTxIntOff(1);          	
    	}

    	if(!(temp & USTAT_ERROR)) 
	{
             if(RxQ[1].wptr+1 != RxQ[1].rptr)
             {
                   RxQ[1].buff[RxQ[1].wptr++] = US1_RHR;
                   if(RxQ[1].wptr == MAXEVENT)
                          RxQ[1].wptr = 0; /*loop back*/
             }
         UARTRxIntOn(1);
	}
	
    US1_CR=0x00000100;
}
#else
/************************************************************************/
/*	Uart1 isr								*/
/************************************************************************/
void Uart1isr(void)
{
	int temp,serial_drv = SERIAL_DEV0;
	temp=US1_CSR;
	
	if(temp & (USTAT_TXB_EMPTY|USTAT_TX_READY)) 
		{
			US1_CR=0x00000040;
			if(TxQ[1].rptr == MAXEVENT)
					TxQ[1].rptr=0; /*loop back for the queue*/

			if(TxQ[1].rptr != TxQ[1].wptr) 
			{
					US1_THR = TxQ[1].buff[TxQ[1].rptr++];
			}
			UARTTxIntOff(1);
		}
		
	if(!(temp & (USTAT_ERROR))&&(temp&USTAT_RCV_READY))
	// NO frame,parity,overrun err
	{
			 if(RxQ[1].wptr+1 != RxQ[1].rptr)