uart.c

ARM7 UART CODE CONTROL UART 1 and 2

/*                                                                      */
/*   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 UartTxLisr(uint32 channel)
{
 DWORD buf;
 BYTE  idx,i;

 /* if(UARTSTAT(channel) & USTAT_TXB_EMPTY)
    {
          if(TxQ[channel].rptr == MAXEVENT)
                 TxQ[channel].rptr=0;

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

    UARTTxIntOff(channel);       */
/*  if(UARTSTAT(channel) & USTAT_TXB_EMPTY)
    {    */
      if(Dword(TXSCOBF_TL)!=Dword(TXSCOBF_HD))
      {
       idx=Dword(TXSCOBF_TL);
       buf=TXSCOBUF+idx*0x20;
       for(i=1;i<=Byte(buf);i++)
       {
         while(1)
         {
         if(UARTSTAT(channel) & USTAT_TXB_EMPTY)
         {
          UARTTXH(channel)=Byte(buf+i);
          break;
          }
         }
       }
        idx=idx+1;
        if(idx>30)
         idx=0;
        Dword(TXSCOBF_TL)=idx;
      }
/*    }      */
}

void Uart0TxLisr(void)
{
        UartTxLisr(0);  
}

void Uart1TxLisr(void)
{
        UartTxLisr(1);    
}

/* Rcv, Error Interrupt Service Routine */
void UartRxErrLisr(uint32 channel)
{
  BYTE data,flag;
  BYTE idx;
  DWORD buf;
  /*   if(!(UARTSTAT(channel) & USTAT_ERROR))
        {
             if(RxQ[channel].wptr+1 != RxQ[channel].rptr)
             {
                   temp=UARTRXB(channel);
                   RxQ[channel].buff[RxQ[channel].wptr++] = temp;
                   if(RxQ[channel].wptr == MAXEVENT)
                           RxQ[channel].wptr = 0;
             }
        }

        UARTRxIntOff(channel);                             */
        if(!(UARTSTAT(channel) & USTAT_ERROR))
        {
             if((Dword(RXSCOBF_HD)+1)!=Dword(RXSCOBF_TL))
             {
                idx=Dword(RXSCOBF_HD);
                buf=RXSCOBUF+(idx*0x20);
                data=UARTRXB(channel);
                if(data == START && scoflag==0)
                  {
                    Byte(buf)=1;
                    Byte((buf+1))=START;
                    scoflag=1;
                    return;
                  }
                if(data!=STOP && Byte((buf+1))==START)
                  {
                   if(data==START && scoflag==1)
                    {
                      Byte(buf)=Byte(buf)+1;
                      Byte(buf+Byte(buf))=data;
                      scoflag=2;
                    }
                    else if(data==START && scoflag==2)
                    {
                      scoflag=1;
                    }
                    else
                    {
                      Byte(buf)=Byte(buf)+1;
                      Byte(buf+Byte(buf))=data;
                    }
                   return;
                  }
                if(data==STOP && Byte((buf+1))==START)
                {
                  if(scoflag==2)
                   {
                       Byte(buf+Byte(buf))=data;
                       scoflag=1;
                       return;
                   }
                  Byte(buf)=Byte(buf)+1;
                  Byte(buf+Byte(buf))=data;
                  idx=idx+1;
                  if(idx>30)
                    idx=0;
                  Dword(RXSCOBF_HD)=idx;
                  scoflag=0;
                  return;
                }
             }
        }
}
/* Rcv, Error Interrupt Service Routine */
void Uart0RxErrLisr(void)
{
        UartRxErrLisr(0);
}

void Uart1RxErrLisr(void)
{
        UartRxErrLisr(1);
}



void UARTTxIntOn(uint32 n)
{
        /* Enable Interrupt */
        Enable_Int(nUART_TX_INT(n));
        //SetPendingBit(nUART_TX_INT(n));    
}

void UARTRxIntOn(uint32 n)
{
        /* Enable Interrupt */
        Enable_Int(nUART_RX_ERR_INT(n));
}


void UARTTxIntOff(uint32 n)
{
            Disable_Int(nUART_TX_INT(n));
}

void UARTRxIntOff(uint32 n)
{
        Disable_Int(nUART_RX_ERR_INT(n));
}


/************************************************************************/
/*                                                                      */
/*  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*/