m5200pscsio.c

mpc5200 for bsp,it is have passed built.

    int lvl;

    if ((*pChan->getTxChar) (pChan->getTxArg, &outChar) != ERROR)
	{
	lvl = intLock ();
        M5200_WRITE (pChan->cr, PSC_UART_CR_TX_ENABLE);
	M5200_WRITE (pChan->tb, outChar);
	intUnlock (lvl);
	}
#else
    M5200_WRITE (pChan->cr, PSC_UART_CR_TX_ENABLE);
#endif
    return (OK);
    }


/******************************************************************************
*
* m5200CallbackInstall - 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 m5200CallbackInstall
    (
    M5200_PSC_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);
	}
    }

/******************************************************************************
*
* m5200PollOutput - 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 m5200PollOutput
    (
    M5200_PSC_CHAN *pChan,
    char	outChar
    )
    {
    USHORT statusReg;

    statusReg = M5200_READ (pChan->sr);

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

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

    /* write out the character */

    M5200_WRITE (pChan->tb, outChar);

    return (OK);
    }


/******************************************************************************
*
* m5200PollInput - 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 m5200PollInput
    (
    M5200_PSC_CHAN *pChan,
    char *	thisChar
    )
    {
    USHORT statusReg;

    statusReg = M5200_READ (pChan->sr);

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

    *thisChar = (M5200_READ (pChan->rb) & 0xff000000) >> 24;

    return (OK);
    }


/******************************************************************************
*
* m5200ModeSet - 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 m5200ModeSet
    (
    M5200_PSC_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 */

	m5200ImrSetClr (pChan, PSC_UART_IMR_TXRDY | PSC_UART_IMR_RXRDY, 0);
        }
    else
        {
	/* Disable interrupts and enable the transmitter for the channel */

	m5200ImrSetClr (pChan, 0, PSC_UART_IMR_TXRDY | PSC_UART_IMR_RXRDY);
	M5200_WRITE (pChan->cr, PSC_UART_CR_TX_ENABLE);
        }

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

    return (OK);
    }


/******************************************************************************
*
* m5200BaudSet - 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  m5200BaudSet
    (
    M5200_PSC_CHAN * pChan,
    UINT	baud
    )
    {
    int oldlevel;
    ULONG aDivisor;
    ULONG aClockDivisor;
		
    if (!baud)
	return (ERROR);

    aDivisor = baud *16 * 2;
		
    aClockDivisor = (pChan->clkRate + aDivisor/2) / aDivisor;
    if ((aClockDivisor < 2) || (aClockDivisor > 0xffff))
	return (ERROR);

    oldlevel = intLock ();
    M5200_WRITE( pChan->dl, aClockDivisor & 0xff);		
    M5200_WRITE( pChan->dp, (aClockDivisor & 0xff00) >> 8);
    intUnlock (oldlevel);

    return (OK);
    }


/******************************************************************************
*
* m5200OptsSet - 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 m5200OptsSet
    (
    M5200_PSC_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 = PSC_UART_MR1_BITS_CHAR_5;
	    break;
	case CS6:
	    mr1Value = PSC_UART_MR1_BITS_CHAR_6;
	    break;
	case CS7:
	    mr1Value = PSC_UART_MR1_BITS_CHAR_7;
	    break;
	default:
	case CS8:
	    mr1Value = PSC_UART_MR1_BITS_CHAR_8;
	    break;
	}

    if (options & STOPB)
	mr2Value = PSC_UART_MR2_STOP_BITS_2;
    else
	mr2Value = PSC_UART_MR2_STOP_BITS_1;

    switch (options & (PARENB|PARODD))
	{
	case PARENB|PARODD:
	    mr1Value |= PSC_UART_MR1_ODD_PARITY;
	    break;
	case PARENB:
	    mr1Value |= PSC_UART_MR1_EVEN_PARITY;
	    break;
	case PARODD:
	    mr1Value |= PSC_UART_MR1_PAR_MODE_MULTI;
	    break;
	default:
	case 0:
	    mr1Value |= PSC_UART_MR1_NO_PARITY; break;
	}

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

    lvl = intLock ();

    /* now reset the channel mode registers */

    M5200_WRITE (pChan->cr, PSC_UART_CR_RESET_MODE_PTR
		 | PSC_UART_CR_RX_DISABLE
		 | PSC_UART_CR_TX_DISABLE);
    M5200_WRITE (pChan->cr, PSC_UART_CR_RESET_TX);
    M5200_WRITE (pChan->cr, PSC_UART_CR_RESET_RX);

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

    M5200_WRITE (pChan->cr, PSC_UART_CR_TX_ENABLE);
    if (options & CREAD)
	M5200_WRITE (pChan->cr, PSC_UART_CR_RX_ENABLE);

    intUnlock (lvl);

    pChan->options = options;

    return (OK);
    }


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

LOCAL int m5200Ioctl
    (
    M5200_PSC_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 (m5200BaudSet (pChan, arg) == OK ? OK : EIO);

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

	case SIO_MODE_SET:
	    return (m5200ModeSet (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 = m5200OptsSet (pChan, arg);
	    m5200ModeSet (pChan, pChan->mode);
	    return result;

	case SIO_HW_OPTS_GET:
	    return pChan->options;

	default:
	    return (ENOSYS);
	}
    }


/******************************************************************************
*
* m5200IntWr - handle a transmitter interrupt
*
* This routine handles write interrupts from the DUART. 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 for the channel is disabled.
*
* RETURNS: N/A
*/

LOCAL void m5200IntWr
    (
    M5200_PSC_CHAN * pChan
    )
    {
    char            outChar;

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


/*****************************************************************************
*
* m5200IntRd - 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 m5200IntRd
    (
    M5200_PSC_CHAN * pChan
    )
    {
    UINT16	inchar;

    while (M5200_READ(pChan->sr) & PSC_UART_SR_RXRDY)
        {
        inchar = (M5200_READ (pChan->rb) & 0xff000000) >> 24;
	(*pChan->putRcvChar) (pChan->putRcvArg, inchar);
	if (pChan->mode != SIO_MODE_INT)
	    break;
        }
    }


/*******************************************************************************
*
* m5200PscSioInt - 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 m5200PscSioInt
    (
    M5200_PSC_CHAN * pChan
    )
    {
    UINT16        intStatus;

    /* loop until all sources have been handled */
    while ((intStatus = (M5200_READ(pChan->isr) & pChan->imrCopy)) != 0)
	{
	if ((intStatus & PSC_UART_ISR_TXRDY) != 0)
	    m5200IntWr (pChan);
	if ((intStatus & PSC_UART_ISR_RXRDY) != 0)
	    m5200IntRd (pChan);
	if (pChan->mode != SIO_MODE_INT)
	    break;
	}
    }