uart.c

移植在鱼板上运行的ucos

/*************************************************************************/
/*                                                                       */
/* FILE NAME                                      VERSION                */
/*                                                                       */
/*      uart.c                     KS32C5000(A)/50100  SNDS100 Ver1.0    */
/*                                                                       */
/* COMPONENT                                                             */
/*                                                                       */
/*                                                                       */
/* DESCRIPTION                                                           */
/*                                                                       */
/*      UART library functions.                                          */
/*                                                                       */
/* AUTHOR                                                                */
/*                                                                       */
/*      Young Sun KIM, Samsung Electronics, Inc.                         */
/*                                                                       */
/* DATA STRUCTURES                                                       */
/*                                                                       */
/*                                                                       */
/* FUNCTIONS                                                             */
/*                                                                       */
/*       UART_Initialize                    Initialize serial driver     */
/*       i_getc                             Get a character from buffer  */
/*       i_gets                             Get a string from buffer     */
/*       i_putc                             print a character            */
/*       i_puts                             Print a string               */
/*       i_printf                           formmatted print             */
/*       BaudRateVal                        return baudrate divisor val. */
/*                                                                       */
/* DEPENDENCIES                                                          */
/*                                                                       */
/*                                                                       */
/* HISTORY                                                               */
/*                                                                       */
/*         NAME            DATE                    REMARKS               */
/*                                                                       */
/*         in4maker     05-31-1999      Created initial version 1.0      */
/*                                                                       */
/*************************************************************************/
#include "all.h"
//#include <stdarg.h>
//#include <stdio.h>
//#include <string.h>
//#include "apdialog.h"
//#include "snds.h"
//#include "uart.h"
//#include "isr.h"
//#include "pollio.h"
//#include "sysconf.h"

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



BaudTable U_BaudRate[BAUD_TABLE] = {
/* for 50MHz/2 UART clock */
           9600,  0x00a20,
          19200,  0x00500,
          38400,  0x00280,
          57600,  0x001a0,
          115200, 0x000d0,
          230400, 0x00060,
          460800, 0x00020   // not available 
};


/************************************************************************/
/*                                                                      */
/*  FUNCTION                               "UART_Initialize"            */
/*                                                                      */
/*                                                                      */
/*  DESCRIPTION                                                         */
/*                                                                      */
/*      This function is used to initialize the input and output        */
/*      control variables.                                              */
/*                                                                      */
/*  AUTHOR                                                              */
/*                                                                      */
/*                                                                      */
/*  CALLED FROM                                                         */
/*                                                                      */
/*                                                                      */
/*  ROUTINES CALLED                                                     */
/*                                                                      */
/*      None                                                            */
/*                                                                      */
/*  INPUTS                                                              */
/*                                                                      */
/*      None                                                            */
/*                                                                      */
/*  OUTPUTS                                                             */
/*                                                                      */
/*      Initialization of global structures                             */
/*                                                                      */
/************************************************************************/
uint32  UART_Initialize()
{
    /*****************************/
    /* Initialize UART channel 0 */
    /*****************************/
    uart_dev_init.com_port  = 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);             

    /*****************************/
    /* Initialize UART channel 1 */
    /*****************************/
    uart_dev_init.com_port = SERIAL_DEV1;     /* com 0 */
    UART_Init(&uart_dev_init);
    return(SUCCESS);
}

/***************************/
/* Uart main Init function */
/***************************/
uint32 UART_Init(SERIAL_DEV *s) 
{
     uint32    rUARTBRD;

     /* UART interrupt off */
     UARTRxIntOff(s->com_port);		
     UARTTxIntOff(s->com_port);

     /* Initialize UART transmit & receive Queue */
     TxQInit(s->com_port);
     RxQInit(s->com_port);

     /* default baud rate will be set. sysconf.h */
     rUARTBRD = U_BaudRate[BaudRateVal(s->baud_rate)].div;

     if(s->com_port) 
     {   
          /* Interrupt service routine setup */
        SysSetInterrupt(nUART1_TX_INT, Uart1TxLisr);
        SysSetInterrupt(nUART1_RX_ERR_INT, Uart1RxErrLisr);
        UARTLCON1 = s->data_bits|s->stop_bits|s->parity|s->clk_sel;
        UARTCONT1 = s->data_mode;
        UARTBRD1  = rUARTBRD;
     } 
     else 
     {
        /* Interrupt service routine setup */
        SysSetInterrupt(nUART0_TX_INT, Uart0TxLisr);
        SysSetInterrupt(nUART0_RX_ERR_INT, Uart0RxErrLisr);
          /* UART mode, default baud rate setup */
        UARTLCON0 = s->data_bits|s->stop_bits|s->parity|s->clk_sel;
        UARTCONT0 = s->data_mode;
        UARTBRD0  = rUARTBRD; 
     }
     return(SUCCESS);
}


/************************************************************************/
/*                                                                      */
/*  FUNCTION                               "UART_Que_Init"              */
/*                                                                      */
/*                                                                      */
/*  DESCRIPTION                                                         */
/*                                                                      */
/*      This function is used to initialize the input and output        */
/*      control variables.                                              */
/*                                                                      */
/*  AUTHOR                                                              */
/*                                                                      */
/*                                                                      */
/*  CALLED FROM                                                         */
/*                                                                      */
/*                                                                      */
/*  ROUTINES CALLED                                                     */
/*                                                                      */
/*      None                                                            */
/*                                                                      */
/*  INPUTS                                                              */
/*                                                                      */
/*      None                                                            */
/*                                                                      */
/*  OUTPUTS                                                             */
/*                                                                      */
/*      Initialization of global structures                             */
/*                                                                      */
/************************************************************************/

/* Transmit Que initialize */
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;
}

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

}


/************************************************************************/
/*                                                                      */
/*  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)
{
	int Temp;
	if(!(UARTSTAT0 & USTAT_ERROR)) 
	{
             Temp=RxQ[0].wptr+1;
             if(Temp==MAXEVENT)
             	Temp=0;/*loop back*/
             if(Temp!= RxQ[0].rptr)
             {
                   RxQ[0].buff[RxQ[0].wptr] = UARTRXB0;
                   RxQ[0].wptr = Temp; /*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)
{
	int Temp;
	if(!(UARTSTAT1 & USTAT_ERROR))