/* sngks32cSio.c - Samsung S3C44B0X serial driver */


/* Copyright 1984-2001 Wind River Systems, Inc. */
#include "copyright_wrs.h"

/*
modification history
--------------------
01o,27jul04,a_m  BSP定制 for 多刃劍開發板
01c,30nov01,m_h  Save pChan->baudRate when setting baud
01b,26apr01,m_h  convert tabs to spaces for readability
01a,12apr01,m_h  created from snds100 template.
*/

/*
DESCRIPTION

This is the serial I/O driver for Samsung's KS32C50100 microprocessor which is an
ARM based processor with several integrated peripherals.  It has an interrupt
controller, two 32-bit timers, one Ethernet controller,two HDLC controllers,
one IIC controller, general purpose I/O ports, and a 2 channel DMA controller.

The 2 UART channels integrated with the processor are controlled by this
driver.  Both the UARTs can work in interrupt mode as well as DMA mode.
This driver supports only the interrupt mode for the UARTs.

All the UART registers are accessible as 32-bit integers from the internal
system registers.  The macros SNGKS32C_REG_READ and SNGKS32C_REG_WRITE read and write
32-bit integers from and to the given addresses.  SNGKS32C_SIO_DEFAULT_BAUD is
defined to 38400 in this file.  This is the default baud rate with which 
the UART channels will be initialized.  The channels are also initialized 
with one start bit, one stop bit, 8 bit data and no parity bits.

The driver is typically only called only by the BSP. The directly callable
routines in this module are sngks32cDevInit(), sngks32cDevInit2(), sngks32cIntRcv(), 
sngks32cIntTx(), and sngks32cIntErr().

The BSP calls sngks32cDevInit() to initialize or reset the device.
It connects the driver's interrupt handlers (sngks32cIntRcv(), sngks32cIntTx(),
and sngks32cIntErr()), using intConnect().
After connecting the interrupt handlers, the BSP calls sngks32cDevInit2()
to inform the driver that interrupt mode operation is now possible.

INCLUDES:
sngks32cSio.h sioLib.h

SEE ALSO:
<Samsung KS32C50100 User's Manual>

*/

#include "vxWorks.h"
#include "sioLib.h"
#include "intLib.h"
#include "errno.h"
#include "sngks32cSio.h"
#include "ioLib.h"

#define SNGKS32C_BAUD_MIN         1200
#define SNGKS32C_BAUD_MAX         460860
#define SNGKS32C_SIO_DEFAULT_BAUD 38400

/* Hardware abstraction macros */

/* local defines  */

#ifndef SNGKS32C_SIO_REG_READ
#define SNGKS32C_SIO_REG_READ(pChan, reg, result) \
    ((result) = (*(volatile UINT32 *)((UINT32)(pChan)->regs + (reg))))
#endif    /*SNGKS32C_SIO_REG_READ*/

#ifndef SNGKS32C_SIO_REG_WRITE
#define SNGKS32C_SIO_REG_WRITE(pChan, reg, data) \
    ((*(volatile UINT32 *)((UINT32)(pChan)->regs + (reg))) = (data))
#endif    /*SNGKS32C_SIO_REG_WRITE*/


/* for backward compatibility */

#ifndef    SIO_HUP
#   define SIO_OPEN    0x100A    /* open channel, raise DTR, RTS */
#   define SIO_HUP     0x100B    /* hang-up, lower DTR, RTS */
#endif

/* forward static declarations */

LOCAL int    sngks32cTxStartup (SIO_CHAN * pSioChan);
LOCAL int    sngks32cCallbackInstall (SIO_CHAN *pSioChan, int callbackType,
                                      STATUS (*callback)(), void *callbackArg);
LOCAL int    sngks32cPollOutput (SIO_CHAN *pSioChan, char    outChar);
LOCAL int    sngks32cPollInput (SIO_CHAN *pSioChan, char *thisChar);
LOCAL int    sngks32cIoctl (SIO_CHAN *pSioChan, int request, void *arg);
LOCAL STATUS dummyCallback (void);

/* local variables */

LOCAL    SIO_DRV_FUNCS sngks32cSioDrvFuncs =
    {
    sngks32cIoctl,
    sngks32cTxStartup,
    sngks32cCallbackInstall,
    sngks32cPollInput,
    sngks32cPollOutput
    };

LOCAL BOOL sngks32cIntrMode = FALSE;    /* interrupt mode allowed flag */

/******************************************************************************
*
* sngks32cDevInit - initialize a SNGKS32C_DUSART
*
* This routine initializes the driver
* function pointers and then resets the chip in a quiescent state.
* The BSP must have already initialized all the device addresses and the
* baudFreq fields in the SNGKS32C_DUSART structure before passing it to
* this routine.
*
* RETURNS: N/A
*/

void sngks32cDevInit
    (
    SNGKS32C_CHAN * pChan
    )
    {
    /* initialize each channel's driver function pointers */

    pChan->sio.pDrvFuncs    = &sngks32cSioDrvFuncs;

    /* install dummy driver callbacks */

    pChan->getTxChar     = dummyCallback;
    pChan->putRcvChar    = dummyCallback;
    
    /* reset the chip */

	/*SNGKS32C_SIO_REG_WRITE(pChan,SNGKS32C_ULCON,(INT_CLK | PARITY_NONE | ONE_STOP | WORD_LEN));*/
	/*  : deleeted and added */
	SNGKS32C_SIO_REG_WRITE(pChan,SNGKS32C_ULCON,(PARITY_NONE | ONE_STOP | WORD_LEN));
	SNGKS32C_SIO_REG_WRITE(pChan,S3C44B0X_UFCON,0x97);	/*0值禁止使用FIFO*/
	SNGKS32C_SIO_REG_WRITE(pChan,S3C44B0X_UMCON,0);

    /* setting polled mode is one way to make the device quiet */

    sngks32cIoctl ((SIO_CHAN *)pChan, SIO_MODE_SET, (void *)SIO_MODE_POLL);
    sngks32cIoctl ((SIO_CHAN *)pChan, SIO_BAUD_SET, (void *)SNGKS32C_SIO_DEFAULT_BAUD);

    }

/******************************************************************************
*
* sngks32cDevInit2 - initialize a SNGKS32C_DUSART, part 2
*
* This routine is called by the BSP after interrupts have been connected.
* The driver can now operate in interrupt mode.  Before this routine is
* called only polled mode operations should be allowed.
*
* RETURNS: N/A
* ARGSUSED
*/

void sngks32cDevInit2
    (
    SNGKS32C_CHAN * pChan        /* device to initialize */
    )
    {
    char      outchar = '\0';
    UINT32    status;

    /* 
     * Dummy write to TXBUF to start TX empty interrupt
     */

    SNGKS32C_SIO_REG_WRITE(pChan,SNGKS32C_UTXBUF,outchar);

    /* Interrupt mode is allowed */

    /*SNGKS32C_SIO_REG_WRITE(pChan,SNGKS32C_UCON,UCON_RX|UCON_TX|UCON_BREAK);*/
	/*  : deleted and added */
    SNGKS32C_SIO_REG_WRITE(pChan,SNGKS32C_UCON,UCON_TX_LEVEL|UCON_RX|UCON_TX|0x80);
    SNGKS32C_SIO_REG_READ(pChan,SNGKS32C_USTAT, status);    
    while ((status & USTAT_TX_READY) != USTAT_TX_READY)
        SNGKS32C_SIO_REG_READ(pChan,SNGKS32C_USTAT, status); /*  : added */
    /*SNGKS32C_SIO_REG_WRITE(pChan,SNGKS32C_UCON,UCON_RX|UCON_TX);*/
	/*  : deleted and added */
    SNGKS32C_SIO_REG_WRITE(pChan,SNGKS32C_UCON,UCON_TX_LEVEL|UCON_RX|UCON_TX|0x80);
    sngks32cIntrMode = TRUE;
    }

/******************************************************************************
*
* sngks32cIntRcv - handle a channel's receive-character interrupt
*
* RETURNS: N/A
*/ 

void sngks32cIntRcv
    (
    SNGKS32C_CHAN *    pChan        /* channel generating the interrupt */
    )
    {
    char            inChar;
    UINT32        status;
    FAST int     oldlevel;    		/*  : added */
 
	oldlevel = intLock ();			/*  : added */

    /*
     * Grab the input character from the chip and hand it off via a
     * callback. For chips with input FIFO's it is more efficient
     * to empty the entire FIFO here.
     */
    /*SNGKS32C_SIO_REG_READ(pChan,SNGKS32C_USTAT, status);

    if((status & USTAT_RX_READY) == USTAT_RX_READY)
        {
        SNGKS32C_SIO_REG_READ(pChan,SNGKS32C_URXBUF, inChar);
        (*pChan->putRcvChar) (pChan->putRcvArg, inChar);
        }*/
	/*  : deleted and added, 循環處理FIFO */
    while(1){
		SNGKS32C_SIO_REG_READ(pChan,S3C44B0X_UFSTAT, status);
    	if((status & UFSTAT_RX_COUNT) == 0) break;
        SNGKS32C_SIO_REG_READ(pChan,SNGKS32C_URXBUF, inChar);
        (*pChan->putRcvChar) (pChan->putRcvArg, inChar);
    }
	
	intUnlock (oldlevel);			/*  : added */
    }
static int sending = 0;		/*  : added */		
/******************************************************************************
*
* sngks32cIntTx - handle a channels transmitter-ready interrupt
*
* RETURNS: N/A
*/ 

void sngks32cIntTx
    (
    SNGKS32C_CHAN *    pChan        /* channel generating the interrupt */
    )
    {
    char      outChar;
    UINT32    status;
    FAST int     oldlevel; 	/*  : added */
    /*
     * If there's a character to transmit then write it out, else reset
     * the transmitter. For chips with output FIFO's it is more efficient
     * to fill the entire FIFO here.
     */

    /*SNGKS32C_SIO_REG_READ(pChan,SNGKS32C_USTAT, status);    

    if((status & USTAT_TX_READY) != USTAT_TX_READY)    
        return;*/
	/*  : deleted and added, 針對FIFO */
 	SNGKS32C_SIO_REG_READ(pChan,S3C44B0X_UFSTAT, status);
	
	if((status & UFSTAT_TX_FULL) == UFSTAT_TX_FULL) 
		return;

	oldlevel = intLock ();	/*  : added */

    if ((*pChan->getTxChar) (pChan->getTxArg, &outChar) != ERROR){
        SNGKS32C_SIO_REG_WRITE(pChan, SNGKS32C_UTXBUF, outChar);
		while(1){			/*  : added */
			SNGKS32C_SIO_REG_READ(pChan,S3C44B0X_UFSTAT, status);    
    		if((status & UFSTAT_TX_FULL) == UFSTAT_TX_FULL) break;

			if ((*pChan->getTxChar) (pChan->getTxArg, &outChar) == ERROR) break;

			SNGKS32C_SIO_REG_WRITE(pChan, SNGKS32C_UTXBUF, outChar);
		}	
    }	
    else
        {    
        intDisable (pChan->intLevelTx);
		sending = 0;		/*  : added */
        /**(UINT32 *) S3C44B0X_INTPEND = (1 << pChan->intLevelTx);*/
		/*  : deleted and added */
		*(UINT32 *) S3C44B0X_I_ISPC = (1 << pChan->intLevelTx);
        }
    intUnlock (oldlevel);
    }
/******************************************************************************
*
* sngks32cTxStartup - start the interrupt transmitter
*
* RETURNS: OK on success, ENOSYS if the device is polled-only, or
* EIO on hardware error.
*/

LOCAL int sngks32cTxStartup
    (
    SIO_CHAN * pSioChan                 /* channel to start */
    )
    {
    char      outChar;			/*  : added */
    UINT32    status;			/*  : added */
    FAST int     oldlevel;    	/*  : added */

    SNGKS32C_CHAN * pChan = (SNGKS32C_CHAN *)pSioChan;
	/*  : deleted */
    /**(UINT32 *) SNGKS32C_INTPENDTST |= (1 << pChan->intLevelTx);*/

	/*  : added */
	SNGKS32C_SIO_REG_READ(pChan,S3C44B0X_UFSTAT, status);    
    if((status & UFSTAT_TX_FULL) == UFSTAT_TX_FULL)    
        return (OK);
	if(sending == 1) return OK;
    oldlevel = intLock ();
	
    intEnable (pChan->intLevelTx);

	/*  : added */
	sending = 1;
    if ((*pChan->getTxChar) (pChan->getTxArg, &outChar) != ERROR)
        SNGKS32C_SIO_REG_WRITE(pChan, SNGKS32C_UTXBUF, outChar);
    intUnlock (oldlevel);


    return (OK);
    }

/******************************************************************************
*
* sngks32cCallbackInstall - install ISR callbacks to get/put chars
*
* This driver allows interrupt callbacks for transmitting characters
* and receiving characters. In general, drivers may support other
* types of callbacks too.
*
* RETURNS: OK on success, or ENOSYS for an unsupported callback type.
*/ 

LOCAL int sngks32cCallbackInstall
    (
    SIO_CHAN *    pSioChan,               /* channel */
    int           callbackType,           /* type of callback */
    STATUS        (*callback)(),          /* callback */
    void *        callbackArg             /* parameter to callback */
    )
    {
    SNGKS32C_CHAN * pChan = (SNGKS32C_CHAN *)pSioChan;

    switch (callbackType)
    {
    case SIO_CALLBACK_GET_TX_CHAR:
        pChan->getTxChar    = callback;
        pChan->getTxArg     = callbackArg;
        return (OK);

    case SIO_CALLBACK_PUT_RCV_CHAR:
        pChan->putRcvChar    = callback;
        pChan->putRcvArg     = callbackArg;
        return (OK);

    default:
        return (ENOSYS);
    }
    }

/*******************************************************************************
*
* sngks32cPollOutput - output a character in polled mode
*
* RETURNS: OK if a character arrived, EIO on device error, EAGAIN
* if the output buffer if full. ENOSYS if the device is
* interrupt-only.
*/

LOCAL int sngks32cPollOutput
    (
    SIO_CHAN *pSioChan,
    char      outChar
    )
    {
    SNGKS32C_CHAN * pChan = (SNGKS32C_CHAN *)pSioChan;
    UINT32    status;

    /* is the transmitter ready to accept a character? */

    SNGKS32C_SIO_REG_READ (pChan, SNGKS32C_USTAT, status);
    if ((status & USTAT_TX_READY) == 0x00)
        return (EAGAIN);

    /* write out the character */

    SNGKS32C_SIO_REG_WRITE(pChan, SNGKS32C_UTXBUF, outChar);
    return (OK);
    }

/******************************************************************************
*
* sngks32cPollInput - poll the device for input
*
* RETURNS: OK if a character arrived, EIO on device error, EAGAIN
* if the input buffer if empty, ENOSYS if the device is
* interrupt-only.
*/

LOCAL int sngks32cPollInput
    (
    SIO_CHAN *    pSioChan,
    char *        thisChar
    )
    {
    SNGKS32C_CHAN * pChan = (SNGKS32C_CHAN *)pSioChan;
    UINT32    status;

    SNGKS32C_SIO_REG_READ (pChan,SNGKS32C_USTAT, status);

    if ((status & USTAT_RX_AVAIL) == 0x00)
        return (EAGAIN);    /* no input available at this time */

    /* got a character */

    SNGKS32C_SIO_REG_READ(pChan, SNGKS32C_URXBUF, *thisChar);

    return (OK);
    }

/******************************************************************************
*
* sngks32cModeSet - toggle between interrupt and polled mode
*
* RETURNS: OK on success, EIO on unsupported mode.