return (EAGAIN);    /* no input available at this time */

    /* got a character */
    *thisChar = (char)UARTRBR(pChan->regs);

    return (OK);
}

LOCAL int lpc2210ModeSet
    (
    LPC2210_CHAN * pChan,        /* channel */
    uint_t          newMode       /* new mode */
    )
{
    UINT32    temp;

    if ((newMode != SIO_MODE_POLL) && (newMode != SIO_MODE_INT))    
        return (EIO);

    /* Don't enter interrupt mode unless it is allowed. */
    if ((newMode == SIO_MODE_INT) && (!lpc2210IntrMode))
        return (EIO);

    /* set the new mode */
    pChan->mode = newMode;

    if (pChan->mode == SIO_MODE_INT)
    {
        temp = UARTFCR(pChan->regs);
        temp |= 6;                                      /*Reset RX and TX mode bits*/
        UARTFCR(pChan->regs) = temp;
        intEnable(pChan->intLevel);
    }
    else
    {
        temp = UARTFCR(pChan->regs);
        temp |= 6;                                      /*Reset RX and TX mode bits*/
        UARTFCR(pChan->regs) = temp;
        intDisable (pChan->intLevel);
    }
    
    return (OK);
}

LOCAL STATUS lpc2210Hup
    (
    LPC2210_CHAN * pChan     /* pointer to channel */
    )
{
    FAST int     oldlevel;    /* current interrupt level mask */

    oldlevel = intLock ();
    intUnlock (oldlevel);

    return (OK);
}    

/*******************************************************************************
*
* lpc2210Open - Set the modem control lines 
*
* Set the modem control lines(RTS, DTR) TRUE if not already set.  
*
* RETURNS: OK
*/
LOCAL STATUS lpc2210Open
    (
    LPC2210_CHAN * pChan     /* pointer to channel */
    )
{
    FAST int     oldlevel;    /* current interrupt level mask */

    oldlevel = intLock ();

    /* set RTS and DTR active */

/*    SNGKS32C_SIO_REG_WRITE(pChan, SNGKS32C_USTAT, USTAT_DTR_HIGH);    */
    intUnlock (oldlevel);

    return (OK);
}

LOCAL int lpc2210OptSet
    (
    LPC2210_CHAN * pChan,        /* channel */
    uint_t    newOpts              /* new options */
    )
{
    UINT8 dataBits = 0x03;
    UINT8 stopBits = 0x00;
    int  lvl;
    UINT8 temp=PARITY_NONE;
    UINT32 result;    

    if (pChan == NULL || newOpts & 0xffffff00)
        return EIO;

    /* do nothing if options already set */
    if (pChan->options == newOpts)
        return OK;

    /* ignore requests for unsupported options */

    /* decode individual request elements */

    switch (newOpts & CSIZE)
    {
        case CS5:
            dataBits = 0x00; break;
        case CS6:
            dataBits = 0x01; break;
        case CS7:
            dataBits = 0x02; break;
        default:
        case CS8:
            dataBits = 0x03; break;
    }

    if (newOpts & STOPB)
        stopBits = 0x01;
    else
        stopBits = 0x00;

    switch (newOpts & (PARENB|PARODD))
    {
        case PARENB|PARODD:
            /* enable odd parity */
            temp=PARITY_ODD;
            break;

        case PARENB:
            /* enable even parity */
            temp=PARITY_EVEN; 
            break;

        case PARODD:
            /* invalid mode, not normally used. */
            break;

        default:
        case 0:
            temp=PARITY_NONE ;/* no parity */
            break;
    }

    lvl = intLock ();
    /*
     * Reset the device according to dataBits, stopBits, hdweFlowCtrl,
     * rcvrEnable, and parity selections.
     */
    result = UARTLCR(pChan->regs);   
    result &= 0xC0;
    UARTLCR(pChan->regs) = result | dataBits | (stopBits<<2) | (temp<<3);

    intUnlock (lvl);

    pChan->options = newOpts;

    return (OK);
}

/*******************************************************************************
*
* lpc2210Ioctl - special device control
*
* This routine handles the IOCTL messages from the user. It supports commands 
* to get/set baud rate, mode(INT,POLL), hardware options(parity, number of 
* data bits) and modem control(RTS/CTS and DTR/DSR handshakes).
* The ioctl commands SIO_HUP and SIO_OPEN are used to implement the HUPCL(hang
* up on last close) function.
*
* As on a UNIX system, requesting a baud rate of zero is translated into
* a hangup request.  The DTR and RTS lines are dropped.  This should cause
* a connected modem to drop the connection.  The SIO_HUP command will only
* hangup if the HUPCL option is active.  The SIO_OPEN function will raise
* DTR and RTS lines whenever it is called. Use the BAUD_RATE=0 function
* to hangup when HUPCL is not active.
*
* The CLOCAL option will disable hardware flow control.  When selected,
* hardware flow control is not used.  When not selected hardware flow control
* is based on the RTS/CTS signals.  CTS is the clear to send input
* from the other end.  It must be true for this end to begin sending new
* characters.  In most drivers, the RTS signal will be assumed to be connected
* to the opposite end's CTS signal and can be used to control output from
* the other end.  Raising RTS asserts CTS at the other end and the other end
* can send data.  Lowering RTS de-asserts CTS and the other end will stop
* sending data. (This is non-EIA defined use of RTS).
*
* RETURNS: OK on success, ENOSYS on unsupported request, EIO on failed
* request.
*/

LOCAL int lpc2210Ioctl
    (
    SIO_CHAN *    pSioChan,        /* device to control */
    int        request,        /* request code */
    void *    someArg            /* some argument */
    )
{
    LPC2210_CHAN *pChan = (LPC2210_CHAN *) pSioChan;
    int     oldlevel;        /* current interrupt level mask */
    DWORD arg = (DWORD)someArg;
    
    switch (request)
    {
        case SIO_BAUD_SET:
        {
            DWORD Fdiv = (Fpclk / 16) / arg;
            DWORD temp = 0;
            
            if (arg == 0)
                return lpc2210Hup (pChan);

            if (arg < LPC2210_BAUD_MIN || arg > LPC2210_BAUD_MAX)
            {
                return (EIO);
            }

            oldlevel = intLock ();
            temp = UARTLCR(pChan->regs);
            UARTLCR(pChan->regs) = temp | 0x80;
            U0DLM = Fdiv / 256;							
            U0DLL = Fdiv % 256;
            UARTLCR(pChan->regs) = temp;
            intUnlock(oldlevel);
            pChan->baudRate = arg;
            return (OK);
        }
            break;

        case SIO_BAUD_GET:
            /* Get the baud rate and return OK */
            *(DWORD *)arg = pChan->baudRate;
            break;

        case SIO_MODE_SET:
            return (lpc2210ModeSet (pChan, arg));

        case SIO_MODE_GET:
            *(int *)arg = pChan->mode;
            return (OK);

        case SIO_AVAIL_MODES_GET:
            /* Get the available modes and return OK.  */
            *(int *)arg = SIO_MODE_INT | SIO_MODE_POLL; 
            return (OK);

        case SIO_HW_OPTS_SET:
            return (lpc2210OptSet (pChan, arg));

        case SIO_HW_OPTS_GET:
            /*
             * Optional command to get the hardware options (as defined
             * in sioLib.h). Return OK or ENOSYS if this command is not
             * implemented.  Note: if this command is unimplemented, it
             * will be assumed that the driver options are CREAD | CS8
             * (e.g., eight data bits, one stop bit, no parity, ints enabled).
             */
            *(int *)arg = pChan->options;
            return (OK);

        case SIO_HUP:
            /* check if hupcl option is enabled */
            if (pChan->options & HUPCL) 
                return (lpc2210Hup (pChan));
            return (OK);

        case SIO_OPEN:
            return (lpc2210Open (pChan)); /* always open */

        default:
            return (ENOSYS);
    }
    return (ENOSYS);
}

/*******************************************************************************
*
* dummyCallback - dummy callback routine
*
* RETURNS: ERROR.
*/

LOCAL STATUS dummyCallback (void)
    {
    return (ERROR);
    }