m5206sio.c

IXP425的BSP代码

    (
    M5206_CHAN * pChan
    )
    {
    M5206_WRITE (pChan->cr, M5206_UART_CR_TX_ENABLE);
    return (OK);
    }


/******************************************************************************
*
* m5206CallbackInstall - 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:
* Returns OK on success, or ENOSYS for an unsupported callback type.
*/

LOCAL int m5206CallbackInstall
    (
    M5206_CHAN *	pChan,
    int		callbackType,
    STATUS	(*callback)(),
    void *      callbackArg
    )
    {
    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);
	}
    }

/******************************************************************************
*
* m5206PollOutput - output a character in polled mode.
*
* This routine polls the status register to see if the TxRDY bit has been set.
* This signals that the transmit holding register is empty and that the
* UART is ready for transmission.
*
* RETURNS:
* Returns OK if a character sent, EIO on device error, EAGAIN
* if the output buffer is full.
*/

LOCAL int m5206PollOutput
    (
    M5206_CHAN *pChan,
    char	outChar
    )
    {
    char statusReg;

    statusReg = M5206_READ (pChan->sr);

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

    if ((statusReg & M5206_UART_SR_TXRDY) == 0x00)
	return (EAGAIN);

    /* write out the character */

    M5206_WRITE (pChan->tb, outChar);

    return (OK);
    }


/******************************************************************************
*
* m5206PollInput - poll the device for input.
*
* This routine polls the status register to see if the RxRDY bit is set.
* This gets set when the UART receives a character and signals the
* pressence of a character in the receive buffer.
*
* RETURNS:
* Returns OK if a character arrived, EIO on device error, EAGAIN
* if the input buffer if empty.
*/

LOCAL int m5206PollInput
    (
    M5206_CHAN *pChan,
    char *	thisChar
    )
    {
    char statusReg;

    statusReg = M5206_READ (pChan->sr);

    if ((statusReg & M5206_UART_SR_RXRDY) == 0x00)
	return (EAGAIN);

    *thisChar = M5206_READ (pChan->rb);

    return (OK);
    }


/******************************************************************************
*
* m5206ModeSet - change channel mode setting
*
* This driver supports both polled and interrupt modes and is capable of
* switching between modes dynamically. If interrupt mode is desired this
* routine enables the channels receiver, transmitter interrupt and the
* received break condition interrupt. If polled mode is desired the xmitrs for
* the specified channel is enabled.
*
* RETURNS:
* Returns a status of OK if the mode was set else ERROR.
*/

LOCAL STATUS m5206ModeSet
    (
    M5206_CHAN * pChan,
    UINT	newMode
    )
    {
    int oldlevel;

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

    oldlevel = intLock ();

    if (newMode == SIO_MODE_INT && pChan->intEnable)
        {
	/* Enable the interrupts for receiver/transmitter conditions */

	m5206ImrSetClr (pChan, M5206_UART_IMR_TXRDY | M5206_UART_IMR_RXRDY, 0);
        }
    else
        {
	/* Disable interrupts and enable the transmitter for the channel */

	m5206ImrSetClr (pChan, 0, M5206_UART_IMR_TXRDY | M5206_UART_IMR_RXRDY);
	M5206_WRITE (pChan->cr, M5206_UART_CR_TX_ENABLE);
        }

    intUnlock (oldlevel);
    pChan->mode = newMode;

    return (OK);
    }


/******************************************************************************
*
* m5206BaudSet - change baud rate for channel
*
* This routine sets the baud rate for the UART. The interrupts are disabled
* during chip access.
*
* RETURNS:
* Returns a status of OK if the baud rate was set else ERROR.
*/

LOCAL STATUS  m5206BaudSet
    (
    M5206_CHAN * pChan,
    UINT	baud
    )
    {
    UINT val;
    int oldlevel;

    if (!baud)
	return (ERROR);
    val = (pChan->clkRate / 32) / baud;
    if ((val < 2) || (val > 0xffff))
	return (ERROR);

    oldlevel = intLock ();
    M5206_WRITE (pChan->bg1, val >> 8);
    M5206_WRITE (pChan->bg2, val);
    intUnlock (oldlevel);

    return (OK);
    }


/******************************************************************************
*
* m5206OptsSet - set the serial options
*
* Set the channel operating mode to that specified.  All sioLib options
* are supported: CLOCAL, CREAD, CSIZE, PARENB, and PARODD.
*
* Note, this routine disables the transmitter.  The calling routine
* may have to re-enable it.
*
* RETURNS:
* Returns OK to indicate success, otherwise ERROR is returned
*/

LOCAL STATUS m5206OptsSet
    (
    M5206_CHAN * pChan, /* ptr to channel */
    UINT options	/* new hardware options */
    )
    {
    int mr1Value;
    int mr2Value;
    int lvl;

    if (pChan == NULL || options & 0xffffff00)
	return ERROR;

    /* Reset the transmitters  & receivers  */

    switch (options & CSIZE)
	{
	case CS5:
	    mr1Value = M5206_UART_MR1_BITS_CHAR_5;
	    break;
	case CS6:
	    mr1Value = M5206_UART_MR1_BITS_CHAR_6;
	    break;
	case CS7:
	    mr1Value = M5206_UART_MR1_BITS_CHAR_7;
	    break;
	default:
	case CS8:
	    mr1Value = M5206_UART_MR1_BITS_CHAR_8;
	    break;
	}

    if (options & STOPB)
	mr2Value = M5206_UART_MR2_STOP_BITS_2;
    else
	mr2Value = M5206_UART_MR2_STOP_BITS_1;

    switch (options & (PARENB|PARODD))
	{
	case PARENB|PARODD:
	    mr1Value |= M5206_UART_MR1_ODD_PARITY;
	    break;
	case PARENB:
	    mr1Value |= M5206_UART_MR1_EVEN_PARITY;
	    break;
	case PARODD:
	    mr1Value |= M5206_UART_MR1_PAR_MODE_MULTI;
	    break;
	default:
	case 0:
	    mr1Value |= M5206_UART_MR1_NO_PARITY; break;
	}

    if (options & CLOCAL)
	{
	/* clocal enables hardware flow control */
	mr1Value |= M5206_UART_MR1_RX_RTS;
	mr2Value |= M5206_UART_MR2_TX_CTS;
	}

    lvl = intLock ();

    /* now reset the channel mode registers */

    M5206_WRITE (pChan->cr, M5206_UART_CR_RESET_MODE_PTR
		 | M5206_UART_CR_RX_DISABLE
		 | M5206_UART_CR_TX_DISABLE);
    M5206_WRITE (pChan->cr, M5206_UART_CR_RESET_TX);
    M5206_WRITE (pChan->cr, M5206_UART_CR_RESET_RX);

    M5206_WRITE (pChan->mr, mr1Value);  /* mode register 1  */
    M5206_WRITE (pChan->mr, mr2Value);  /* mode register 2  */

    if (options & CREAD)
	M5206_WRITE (pChan->cr, M5206_UART_CR_RX_ENABLE);

    intUnlock (lvl);

    pChan->options = options;

    return OK;
    }


/******************************************************************************
*
* m5206Ioctl - special device control
*
* RETURNS:
* Returns OK on success, EIO on device error, ENOSYS on unsupported
* request.
*/

LOCAL int m5206Ioctl
    (
    M5206_CHAN *	pChan,		/* device to control */
    int		request,		/* request code */
    void *	someArg			/* some argument */
    )
    {
    STATUS result;
    int     arg = (int)someArg;

    switch (request)
	{
	case SIO_BAUD_SET:
	    return (m5206BaudSet (pChan, arg) == OK ? OK : EIO);

	case SIO_BAUD_GET:
	    *(int *)arg = pChan->baudRate;
	    return (OK);

	case SIO_MODE_SET:
	    return (m5206ModeSet (pChan, arg) == OK ? OK : EIO);

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

	case SIO_AVAIL_MODES_GET:
	    *(int *)arg = SIO_MODE_INT | SIO_MODE_POLL;
	    return (OK);

	case SIO_HW_OPTS_SET:
	    /* change options, then set mode to restart chip correctly */
	    result = m5206OptsSet (pChan, arg);
	    m5206ModeSet (pChan, pChan->mode);
	    return result;

	case SIO_HW_OPTS_GET:
	    return pChan->options;

	default:
	    return (ENOSYS);
	}
    }


/******************************************************************************
*
* m5206IntWr - handle a transmitter interrupt
*
* This routine handles write interrupts from the UART. This isr is invoked
* when the TxRDY bit in the interrupt status register has been set. If there
* is no character to transmit the transmitter is disabled.
*
* RETURNS: N/A
*/

LOCAL void m5206IntWr
    (
    M5206_CHAN * pChan
    )
    {
    char            outChar;

    if ((*pChan->getTxChar) (pChan->getTxArg, &outChar) != ERROR)
	{
	/* if char available, tx it */
	M5206_WRITE (pChan->tb, outChar);
	}
    else
        {
	M5206_WRITE (pChan->cr, M5206_UART_CR_TX_DISABLE);
        }
    }


/*****************************************************************************
*
* m5206IntRd - handle a reciever interrupt
*
* This routine handles read interrupts from the UART.
* The UART has been programmed to generate read interrupts when the RXRDY
* status bit has been set in the interrupt status register. When a character
* has been received it is removed from the receive buffer.
*
* RETURNS: N/A
*/

LOCAL void m5206IntRd
    (
    M5206_CHAN * pChan
    )
    {
    UCHAR	inchar;

    while (M5206_READ(pChan->sr) & M5206_UART_SR_RXRDY)
        {
	inchar = M5206_READ (pChan->rb);
	(*pChan->putRcvChar) (pChan->putRcvArg, inchar);
	if (pChan->mode != SIO_MODE_INT)
	    break;
        }
    }


/*******************************************************************************
*
* m5206Int - handle all interrupts in one vector
*
* All interrupts share a single interrupt vector.
* We identify each interrupting source and service it.
* We must service all interrupt sources for those systems with edge-
* sensitive interrupt controllers.
*
* RETURNS: N/A
*/

void m5206Int
    (
    M5206_CHAN * pChan
    )
    {
    UCHAR        intStatus;

    /* loop until all sources have been handled */
    while (intStatus = (M5206_READ(pChan->isr) & pChan->imrCopy))
	{
	if (intStatus & M5206_UART_ISR_TXRDY)
	    m5206IntWr (pChan);
	if (intStatus & M5206_UART_ISR_RXRDY)
	    m5206IntRd (pChan);
	if (pChan->mode != SIO_MODE_INT)
	    break;
	}
    }