uart.c

ARM开发代码以及bootloader的初始化程序参考

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

}


/************************************************************************/
/*                                                                      */
/*  FUNCTION                                "UART_INT_LISR"             */
/*                                                                      */
/*   Uart0TxLisr()                                                      */
/*   Uart0RxErrLisr()                                                   */
/*   Uart1TxLisr()                                                      */
/*   Uart1RxErrLisr()                                                   */
/*   UARTRxIntOn()                                                      */
/*   UARTTxIntOn()                                                      */
/*   UARTRxIntOff()                                                     */
/*   UARTTxIntOff()                                                     */
/*                                                                      */
/*  DESCRIPTION                                                         */
/*                                                                      */
/*                                                                      */
/*  AUTHOR                                                              */
/*                                                                      */
/*                                                                      */
/*  CALLED FROM                                                         */
/*                                                                      */
/*                                                                      */
/*  ROUTINES CALLED                                                     */
/*                                                                      */
/*                                                                      */
/*  INPUTS                                                              */
/*                                                                      */
/*      Interrupt Control Register                                      */
/*                                                                      */
/*  OUTPUTS                                                             */
/*                                                                      */
/*      NONE                                                            */
/*                                                                      */
/* HISTORY                                                              */
/*                                                                      */
/*         NAME            DATE                    REMARKS              */
/*                                                                      */
/*        in4maker      06-01-1999      Created initial version 1.0     */
/*                                                                      */
/************************************************************************/

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)
{
	if(!(UARTSTAT0 & USTAT_ERROR)) 
	{
             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*/
             }
	}

        UARTRxIntOff(0);
}


void Uart1TxLisr(void)
{
    if(UARTSTAT1 & USTAT_TXB_EMPTY) 
    {
          if(++TxQ[1].rptr == MAXEVENT)
                 TxQ[1].rptr=0; /*loop back*/

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

    UARTTxIntOff(1);
}

void Uart1RxErrLisr(void)
{
	if(!(UARTSTAT1 & USTAT_ERROR)) 
	{
             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 */
#ifdef KS32C50100
	/* KS32C50100 */
	Enable_Int(nUART1_RX_ERR_INT);
#else
	/* KS32C5000 */
	Enable_Int(nUART1_RX_INT);
	Enable_Int(nUART1_ERROR_INT);
#endif
     }
     else {
	/* Enable Interrupt */
#ifdef KS32C50100
	/* KS32C50100 */
	Enable_Int(nUART0_RX_ERR_INT);
#else
	/* KS32C5000 */
	Enable_Int(nUART0_RX_INT);
	Enable_Int(nUART0_ERROR_INT);
#endif
     }
}


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 */
#ifdef KS32C50100
	/* KS32C50100 */
	Disable_Int(nUART1_RX_ERR_INT);
        //Clear_PendingBit(nUART1_RX_ERR_INT) ;
#else
	/* KS32C5000 */
	Disable_Int(nUART1_RX_INT);
	Disable_Int(nUART1_ERROR_INT);
        //Clear_PendingBit(nUART1_RX_INT) ;
        //Clear_PendingBit(nUART1_ERROR_INT) ;
#endif
     }
     else {
        /* Disable Interrupt */
#ifdef KS32C50100
	/* KS32C50100 */
	Disable_Int(nUART0_RX_ERR_INT);
        //Clear_PendingBit(nUART0_RX_ERR_INT) ;
#else
	/* KS32C5000 */
	Disable_Int(nUART0_RX_INT);
	Disable_Int(nUART0_ERROR_INT);
        //Clear_PendingBit(nUART0_RX_INT) ;
        //Clear_PendingBit(nUART0_ERROR_INT) ;
#endif
     }
}


/************************************************************************/
/*                                                                      */
/*  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');