uart.c.bak

一个比较好的三星s3c4510的启动代码

/*                                                                      */
/*  ROUTINES CALLED                                                     */
/*                                                                      */
/*                                                                      */
/*  INPUTS                                                              */
/*                                                                      */
/*      Interrupt Control Register                                      */
/*                                                                      */
/*  OUTPUTS                                                             */
/*                                                                      */
/*      NONE                                                            */
/*                                                                      */
/* HISTORY                                                              */
/*                                                                      */
/*         NAME            DATE                    REMARKS              */
/*                                                                      */
/*                                                                      */
/************************************************************************/

void Uart0TxLisr(void)
{

    if(UARTSTAT0 & USTAT_TXB_EMPTY) 
    {
          if(TxQ[0].rptr == MAXEVENT)
                 TxQ[0].rptr=0; /*loop back*/

          if(TxQ[0].rptr != TxQ[0].wptr) 
          {
             UARTTXH0 = TxQ[0].buff[TxQ[0].rptr++];
          }
    }

    UARTTxIntOff(0);
}


/* Rcv, Error Interrupt Service Routine */
void Uart0RxErrLisr(void)
{
	char UartStat = UARTSTAT0;
	
//	if(!(UartStat & USTAT_ERROR)) 
//	{
	if(UartStat & USTAT_RCV_READY){ //by jwChoi

		
       	if(RxQ[0].wptr+1 != RxQ[0].rptr){
            RxQ[0].buff[RxQ[0].wptr++] = UARTRXB0;
               	if(RxQ[0].wptr == MAXEVENT)
                   	RxQ[0].wptr = 0; //loop back
           }
//           put_byte(UARTRXB0);
	}

//	}
	else {
 		if(UartStat & USTAT_OVERRUN){ Print("OVERRUN Error\r"); UARTSTAT0|=USTAT_OVERRUN;}
		if(UartStat & USTAT_PARITY){ Print("PARITY Error\r"); UARTSTAT0|=USTAT_PARITY;}
		if(UartStat & USTAT_FRAME){ Print("FRAME Error\r"); UARTSTAT0|=USTAT_FRAME;}
	}
    UARTRxIntOff(0);
}
void Uart1TxLisr(void)
{
    if(UARTSTAT1 & USTAT_TXB_EMPTY) 
    {
          //if(++TxQ[1].rptr == MAXEVENT)
          if(TxQ[1].rptr == MAXEVENT)
                 TxQ[1].rptr=0; /*loop back*/

          if(TxQ[1].rptr != TxQ[1].wptr) 
          {
             UARTTXH1 = TxQ[1].buff[TxQ[1].rptr++];
          }
    }

    UARTTxIntOff(1);
}

void Uart1RxErrLisr(void)
{
	if(!(UARTSTAT1 & USTAT_ERROR)) 
	{
		if(UARTSTAT1 & USTAT_RCV_READY){

             if(RxQ[1].wptr+1 != RxQ[1].rptr)
             {
                   RxQ[1].buff[RxQ[1].wptr++] = UARTRXB1;
                   if(RxQ[1].wptr == MAXEVENT)
                           RxQ[1].wptr = 0; /*loop back*/
             }

		}
	}

    UARTRxIntOff(1);
}



void UARTTxIntOn(uint32 channel)
{
    if(channel) {
	/* Enable Interrupt */
	Enable_Int(nUART1_TX_INT);
	//SetPendingBit(nUART1_TX_INT);
    }
    else {
	/* Enable Interrupt */
	Enable_Int(nUART0_TX_INT);
	//SetPendingBit(nUART0_TX_INT);
    }
}

void UARTRxIntOn(uint32 channel)
{
     if(channel) {
		/* Enable Interrupt */
		Enable_Int(nUART1_RX_ERR_INT);
     }
     else {
		/* Enable Interrupt */
		Enable_Int(nUART0_RX_ERR_INT);
     }
}


void UARTTxIntOff(uint32 channel)
{
     if(channel) {
	/* Enable Interrupt */
	Disable_Int(nUART1_TX_INT);
       // Clear_PendingBit(nUART1_TX_INT) ;
     }
     else {
	/* Disable Interrupt */
	Disable_Int(nUART0_TX_INT);
       // Clear_PendingBit(nUART0_TX_INT) ;
     }
}

void UARTRxIntOff(uint32 channel)
{
     if(channel) {
	/* Disable Interrupt */
	Disable_Int(nUART1_RX_ERR_INT);
        //Clear_PendingBit(nUART1_RX_ERR_INT) ;
     }
     else {
        /* Disable Interrupt */
	Disable_Int(nUART0_RX_ERR_INT);
        //Clear_PendingBit(nUART0_RX_ERR_INT) ;
     }
}


/************************************************************************/
/*                                                                      */
/*  FUNCTION                               "UART INTERRUPT FUNCTIONS"   */
/*                                                                      */
/*                                                                      */
/*      TxQWr                    Write data to transmit Que.            */
/*      RxQRd                    Read data from receive Que.            */
/*                                                                      */
/*  DESCRIPTION                                                         */
/*                                                                      */
/*      These Que management functions can be used in interrupt mode.   */
/*                                                                      */
/*  AUTHOR                                                              */
/*                                                                      */
/*                                                                      */
/*  CALLED FROM                                                         */
/*                                                                      */
/*      Application routines                                            */
/*                                                                      */
/*  ROUTINES CALLED                                                     */
/*                                                                      */
/*                                                                      */
/*  INPUTS                                                              */
/*                                                                      */
/*                                                                      */
/*  OUTPUTS                                                             */
/*                                                                      */
/*      return(c)              return character                         */
/*                                                                      */
/* HISTORY                                                              */
/*                                                                      */
/*         NAME            DATE                    REMARKS              */
/*                                                                      */
/*         in4maker     10-16-1998      Created initial version 1.0     */
/************************************************************************/

/* Transmit Que write function */
uint32 TxQWr(uint32 channel,uint8 data)
{
        if(TxQ[channel].wptr+1 == TxQ[channel].rptr) 
        {
            return(ERROR); /* ring buffer full state */
        }

        TxQ[channel].buff[TxQ[channel].wptr++] = data;

        if(TxQ[channel].wptr == MAXEVENT) 
        {
            TxQ[channel].wptr=0;
        }
        return(SUCCESS);
}


/* Receive Que read function */
uint8 RxQRd(uint32 channel)
{
     if(RxQ[channel].rptr == MAXEVENT) 
           RxQ[channel].rptr=0; /*loop back*/

     if(RxQ[channel].rptr == RxQ[channel].wptr) 
           return('\0');

     return(RxQ[channel].buff[RxQ[channel].rptr++]);
}

/************************************************************************/
/*                                                                      */
/*  FUNCTION                               "UART INTERRUPT FUNCTIONS"   */
/*                                                                      */
/*      i_getc()                                                        */
/*      i_gets()                                                        */
/*                                                                      */
/*  DESCRIPTION                                                         */
/*                                                                      */
/*      This function attempts to get a character from the serial       */
/*      driver's input queue.                                           */
/*                                                                      */
/*  AUTHOR                                                              */
/*                                                                      */
/*                                                                      */
/*  CALLED FROM                                                         */
/*                                                                      */
/*      Service routines that request serial input                      */
/*                                                                      */
/*  ROUTINES CALLED                                                     */
/*                                                                      */
/*                                                                      */
/*  INPUTS                                                              */
/*                                                                      */
/*                                                                      */
/*  OUTPUTS                                                             */
/*                                                                      */
/*      return(c)              return character                         */
/*                                                                      */
/* HISTORY                                                              */
/*                                                                      */
/*         NAME            DATE                    REMARKS              */
/*                                                                      */
/*         in4maker     06-01-1999      Created initial version 1.0     */
/*                                                                      */
/************************************************************************/
uint8 i_getc(uint32 channel)
{
    //uint8 InChar;

    UARTRxIntOn(channel);

    //InChar = RxQRd(channel);
    return(RxQRd(channel));

    //if(InChar != NULL) return(InChar);
    //else return(NULL);