source: rtems/c/src/lib/libbsp/powerpc/ppcn_60x/console/ns16550.c @ 0c04c377

/*
 *  This file contains the TTY driver for the NS16550
 *
 *  COPYRIGHT (c) 1998 by Radstone Technology
 *
 *
 * THIS FILE IS PROVIDED TO YOU, THE USER, "AS IS", WITHOUT WARRANTY OF ANY
 * KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK
 * AS TO THE QUALITY AND PERFORMANCE OF ALL CODE IN THIS FILE IS WITH YOU.
 *
 * You are hereby granted permission to use, copy, modify, and distribute
 * this file, provided that this notice, plus the above copyright notice
 * and disclaimer, appears in all copies. Radstone Technology will provide
 * no support for this code.
 *
 *  This driver uses the termios pseudo driver.
 */

#include <rtems.h>
#include <bsp.h>
#include <rtems/libio.h>
#include <stdlib.h>

#include "console.h"
#include "ns16550_p.h"

/*
 * Flow control is only supported when using interrupts
 */
console_flow ns16550_flow_RTSCTS =
{
        ns16550_negate_RTS,             /* deviceStopRemoteTx */
        ns16550_assert_RTS              /* deviceStartRemoteTx */
};

console_flow ns16550_flow_DTRCTS =
{
        ns16550_negate_DTR,             /* deviceStopRemoteTx */
        ns16550_assert_DTR              /* deviceStartRemoteTx */
};

console_fns ns16550_fns =
{
        ns16550_probe,                  /* deviceProbe */
        ns16550_open,                   /* deviceFirstOpen */
        ns16550_flush,                  /* deviceLastClose */
        NULL,                           /* deviceRead */
        ns16550_write_support_int,      /* deviceWrite */
        ns16550_initialize_interrupts,  /* deviceInitialize */
        ns16550_write_polled,           /* deviceWritePolled */
        FALSE,                          /* deviceOutputUsesInterrupts */
};

console_fns ns16550_fns_polled =
{
        ns16550_probe,                  /* deviceProbe */
        ns16550_open,                   /* deviceFirstOpen */
        ns16550_close,                  /* deviceLastClose */
        ns16550_inbyte_nonblocking_polled,      /* deviceRead */
        ns16550_write_support_polled,   /* deviceWrite */
        ns16550_init,                   /* deviceInitialize */
        ns16550_write_polled,           /* deviceWritePolled */
        FALSE,                          /* deviceOutputUsesInterrupts */
};

/*
 *  Console Device Driver Entry Points
 */
static boolean ns16550_probe(int minor)
{
        /*
         * If the configuration dependant probe has located the device then
         * assume it is there
         */
        return(TRUE);
}

static void ns16550_init(int minor)
{
        PSP_READ_REGISTERS      pNS16550Read;
        PSP_WRITE_REGISTERS     pNS16550Write;
        unsigned8               ucTrash;
        unsigned8               ucDataByte;
        unsigned32              ulBaudDivisor;
        ns16550_context         *pns16550Context;

        pns16550Context=(ns16550_context *)malloc(sizeof(ns16550_context));

        Console_Port_Data[minor].pDeviceContext=(void *)pns16550Context;
        pns16550Context->ucModemCtrl=SP_MODEM_IRQ;

        pNS16550Read=(PSP_READ_REGISTERS)Console_Port_Tbl[minor].ulCtrlPort1;
        pNS16550Write=(PSP_WRITE_REGISTERS)pNS16550Read;

        /* Clear the divisor latch, clear all interrupt enables,
         * and reset and
         * disable the FIFO's.
         */

        outport_byte(&pNS16550Write->LineControl, 0x0);
        outport_byte(&pNS16550Write->InterruptEnable, 0x0);

        /* Set the divisor latch and set the baud rate. */

        ulBaudDivisor=NS16550_Baud(
                (unsigned32)Console_Port_Tbl[minor].pDeviceParams);
        ucDataByte = SP_LINE_DLAB;
        outport_byte(&pNS16550Write->LineControl, ucDataByte);
        outport_byte(&pNS16550Write->TransmitBuffer, ulBaudDivisor&0xff);
        outport_byte(&pNS16550Write->InterruptEnable, (ulBaudDivisor>>8)&0xff);

        /* Clear the divisor latch and set the character size to eight bits */
        /* with one stop bit and no parity checking. */

        ucDataByte = EIGHT_BITS;
        outport_byte(&pNS16550Write->LineControl, ucDataByte);

        /* Enable and reset transmit and receive FIFOs. TJA     */
        ucDataByte = SP_FIFO_ENABLE;
        outport_byte(&pNS16550Write->FifoControl, ucDataByte);

        ucDataByte = SP_FIFO_ENABLE | SP_FIFO_RXRST | SP_FIFO_TXRST;
        outport_byte(&pNS16550Write->FifoControl, ucDataByte);

        /*
         * Disable interrupts
         */
        ucDataByte = 0;
        outport_byte(&pNS16550Write->InterruptEnable, ucDataByte);

        /* Set data terminal ready. */
        /* And open interrupt tristate line */

        outport_byte(&pNS16550Write->ModemControl,
                     pns16550Context->ucModemCtrl);

        inport_byte(&pNS16550Read->LineStatus, ucTrash);
        inport_byte(&pNS16550Read->ReceiveBuffer, ucTrash);
}

static int ns16550_open(
        int      major,
        int      minor,
        void    * arg
)
{
        PSP_WRITE_REGISTERS     pNS16550Write;

        pNS16550Write=(PSP_WRITE_REGISTERS)Console_Port_Tbl[minor].ulCtrlPort1;

        /*
         * Assert DTR
         */
        if(Console_Port_Tbl[minor].pDeviceFlow
           !=&ns16550_flow_DTRCTS)
        {
                ns16550_assert_DTR(minor);
        }

        return(RTEMS_SUCCESSFUL);
}

static int ns16550_close(
        int      major,
        int      minor,
        void    * arg
)
{
        PSP_WRITE_REGISTERS     pNS16550Write;

        pNS16550Write=(PSP_WRITE_REGISTERS)Console_Port_Tbl[minor].ulCtrlPort1;

        /*
         * Negate DTR
         */
        if(Console_Port_Tbl[minor].pDeviceFlow
           !=&ns16550_flow_DTRCTS)
        {
                ns16550_negate_DTR(minor);
        }

        return(RTEMS_SUCCESSFUL);
}

/* 
 *  ns16550_write_polled
 */
static void ns16550_write_polled(
        int   minor, 
        char  cChar
)
{
        PSP_READ_REGISTERS      pNS16550Read;
        PSP_WRITE_REGISTERS     pNS16550Write;
        unsigned char   ucLineStatus;
        int iTimeout;

        pNS16550Read=(PSP_READ_REGISTERS)Console_Port_Tbl[minor].ulCtrlPort1;
        pNS16550Write=(PSP_WRITE_REGISTERS)pNS16550Read;

        /*
         * wait for transmitter holding register to be empty
         */
        iTimeout=1000;
        inport_byte(&pNS16550Read->LineStatus, ucLineStatus);
        while ((ucLineStatus & SP_LSR_THOLD) == 0)
        {
                /*
                 * Yield while we wait
                 */
                if(_System_state_Is_up(_System_state_Get()))
                {
                        rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
                }
                inport_byte(&pNS16550Read->LineStatus, ucLineStatus);
                if(!--iTimeout)
                {
                        break;
                }
        }

        /*
         * transmit character
         */
        outport_byte(&pNS16550Write->TransmitBuffer, cChar);
}

/*
 * These routines provide control of the RTS and DTR lines
 */
/*
 *  ns16550_assert_RTS
 */
static void ns16550_assert_RTS(int minor)
{
        PSP_WRITE_REGISTERS     pNS16550Write;
        unsigned32 Irql;
        ns16550_context *pns16550Context;

        pns16550Context=(ns16550_context *)
                       Console_Port_Data[minor].pDeviceContext;

        pNS16550Write=(PSP_WRITE_REGISTERS)Console_Port_Tbl[minor].ulCtrlPort1;

        /*
         * Assert RTS
         */
        rtems_interrupt_disable(Irql);
        pns16550Context->ucModemCtrl|=SP_MODEM_RTS;
        outport_byte(&pNS16550Write->ModemControl,
                     pns16550Context->ucModemCtrl);
        rtems_interrupt_enable(Irql);
}

/*
 *  ns16550_negate_RTS
 */
static void ns16550_negate_RTS(int minor)
{
        PSP_WRITE_REGISTERS     pNS16550Write;
        unsigned32 Irql;
        ns16550_context *pns16550Context;

        pns16550Context=(ns16550_context *)
                       Console_Port_Data[minor].pDeviceContext;

        pNS16550Write=(PSP_WRITE_REGISTERS)Console_Port_Tbl[minor].ulCtrlPort1;

        /*
         * Negate RTS
         */
        rtems_interrupt_disable(Irql);
        pns16550Context->ucModemCtrl&=~SP_MODEM_RTS;
        outport_byte(&pNS16550Write->ModemControl,
                     pns16550Context->ucModemCtrl);
        rtems_interrupt_enable(Irql);
}

/*
 * These flow control routines utilise a connection from the local DTR
 * line to the remote CTS line
 */
/*
 *  ns16550_assert_DTR
 */
static void ns16550_assert_DTR(int minor)
{
        PSP_WRITE_REGISTERS     pNS16550Write;
        unsigned32 Irql;
        ns16550_context *pns16550Context;

        pns16550Context=(ns16550_context *)
                       Console_Port_Data[minor].pDeviceContext;

        pNS16550Write=(PSP_WRITE_REGISTERS)Console_Port_Tbl[minor].ulCtrlPort1;

        /*
         * Assert DTR
         */
        rtems_interrupt_disable(Irql);
        pns16550Context->ucModemCtrl|=SP_MODEM_DTR;
        outport_byte(&pNS16550Write->ModemControl,
                     pns16550Context->ucModemCtrl);
        rtems_interrupt_enable(Irql);
}

/*
 *  ns16550_negate_DTR
 */
static void ns16550_negate_DTR(int minor)
{
        PSP_WRITE_REGISTERS     pNS16550Write;
        unsigned32 Irql;
        ns16550_context *pns16550Context;

        pns16550Context=(ns16550_context *)
                       Console_Port_Data[minor].pDeviceContext;

        pNS16550Write=(PSP_WRITE_REGISTERS)Console_Port_Tbl[minor].ulCtrlPort1;

        /*
         * Negate DTR
         */
        rtems_interrupt_disable(Irql);
        pns16550Context->ucModemCtrl&=~SP_MODEM_DTR;
        outport_byte(&pNS16550Write->ModemControl,
                     pns16550Context->ucModemCtrl);
        rtems_interrupt_enable(Irql);
}

/*
 *  ns16550_isr
 *
 *  This routine is the console interrupt handler for COM1 and COM2
 *
 *  Input parameters:
 *    vector - vector number
 *
 *  Output parameters: NONE
 *
 *  Return values:     NONE
 */

static void ns16550_process(
        int             minor
)
{
        PSP_READ_REGISTERS      pNS16550Read;
        PSP_WRITE_REGISTERS     pNS16550Write;
        volatile unsigned8 ucLineStatus, ucInterruptId;
        char    cChar;

        pNS16550Read=(PSP_READ_REGISTERS)Console_Port_Tbl[minor].ulCtrlPort1;
        pNS16550Write=(PSP_WRITE_REGISTERS)pNS16550Read;

        do
        {
                /*
                 * Deal with any received characters
                 */
                while(TRUE)
                {
                        inport_byte(&pNS16550Read->LineStatus, ucLineStatus);
                        if(~ucLineStatus & SP_LSR_RDY)
                        {
                                break;
                        }
                        inport_byte(&pNS16550Read->ReceiveBuffer, cChar);
                        rtems_termios_enqueue_raw_characters(
                                Console_Port_Data[minor].termios_data,
                                &cChar, 1 );
                }

                while(TRUE)
                {
                        if(Ring_buffer_Is_empty(
                                &Console_Port_Data[minor].TxBuffer))
                        {
                                Console_Port_Data[minor].bActive=FALSE;
                                if(Console_Port_Tbl[minor].pDeviceFlow
                                   !=&ns16550_flow_RTSCTS)
                                {
                                        ns16550_negate_RTS(minor);
                                }
                                /*
                                 * There is no data to transmit
                                 */
                                break;
                        }

                        inport_byte(&pNS16550Read->LineStatus, ucLineStatus);
                        if(~ucLineStatus & SP_LSR_THOLD)
                        {
                                /*
                                 * We'll get another interrupt when
                                 * the transmitter holding reg. becomes
                                 * free again
                                 */
                                break;
                        }

                        Ring_buffer_Remove_character(
                                &Console_Port_Data[minor].TxBuffer,
                                cChar);
                        /*
                         * transmit character
                         */
                        outport_byte(&pNS16550Write->TransmitBuffer, cChar);
                }

                inport_byte(&pNS16550Read->InterruptId, ucInterruptId);
        }
        while((ucInterruptId&0xf)!=0x1);
}

static rtems_isr ns16550_isr(
  rtems_vector_number vector
)
{
        int     minor;

        for(minor=0;minor<Console_Port_Count;minor++)
        {
                if(vector==Console_Port_Tbl[minor].ulIntVector)
                {
                        ns16550_process(minor);
                }
        }
}

/*
 *  ns16550_flush
 */
static int ns16550_flush(int major, int minor, void *arg)
{
        while(!Ring_buffer_Is_empty(&Console_Port_Data[minor].TxBuffer))
        {
                /*
                 * Yield while we wait
                 */
                if(_System_state_Is_up(_System_state_Get()))
                {
                        rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
                }
        }

        ns16550_close(major, minor, arg);

        return(RTEMS_SUCCESSFUL);
}

/*
 *  ns16550_initialize_interrupts
 *
 *  This routine initializes the console's receive and transmit
 *  ring buffers and loads the appropriate vectors to handle the interrupts.
 *
 *  Input parameters:  NONE
 *
 *  Output parameters: NONE
 *
 *  Return values:     NONE
 */

static void ns16550_enable_interrupts(
        int minor
)
{
        PSP_WRITE_REGISTERS     pNS16550Write;
        unsigned8       ucDataByte;

        pNS16550Write=(PSP_WRITE_REGISTERS)Console_Port_Tbl[minor].ulCtrlPort1;

        /*
         * Enable interrupts
         */
        ucDataByte = SP_INT_RX_ENABLE | SP_INT_TX_ENABLE;
        outport_byte(&pNS16550Write->InterruptEnable, ucDataByte);

}

static void ns16550_initialize_interrupts(int minor)
{
        ns16550_init(minor);

        Ring_buffer_Initialize(&Console_Port_Data[minor].TxBuffer);

        Console_Port_Data[minor].bActive = FALSE;

        set_vector(ns16550_isr,
                   Console_Port_Tbl[minor].ulIntVector,
                   1);

        ns16550_enable_interrupts(minor);
}

/* 
 *  ns16550_write_support_int
 *
 *  Console Termios output entry point.
 *
 */
static int ns16550_write_support_int(
  int   minor, 
  const char *buf, 
  int   len)
{
        int i;
        unsigned32 Irql;

        for(i=0; i<len;)
        {
                if(Ring_buffer_Is_full(&Console_Port_Data[minor].TxBuffer))
                {
                        if(!Console_Port_Data[minor].bActive)
                        {
                                /*
                                 * Wake up the device
                                 */
                                rtems_interrupt_disable(Irql);
                                Console_Port_Data[minor].bActive = TRUE;
                                if(Console_Port_Tbl[minor].pDeviceFlow
                                   !=&ns16550_flow_RTSCTS)
                                {
                                        ns16550_assert_RTS(minor);
                                }
                                ns16550_process(minor);
                                rtems_interrupt_enable(Irql);
                        }
                        else
                        {
                                /*
                                 * Yield
                                 */
                                rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);
                        }

                        /*
                         * Wait for ring buffer to empty
                         */
                        continue;
                }
                else
                {
                        Ring_buffer_Add_character(
                                &Console_Port_Data[minor].TxBuffer,
                                buf[i]);
                        i++;
                }
        }

        /*
         * Ensure that characters are on the way
         */
        if(!Console_Port_Data[minor].bActive)
        {
                /*
                 * Wake up the device
                 */
                rtems_interrupt_disable(Irql);
                Console_Port_Data[minor].bActive = TRUE;
                if(Console_Port_Tbl[minor].pDeviceFlow
                   !=&ns16550_flow_RTSCTS)
                {
                        ns16550_assert_RTS(minor);
                }
                ns16550_process(minor);
                rtems_interrupt_enable(Irql);
        }

        return (len);
}

/* 
 *  ns16550_write_support_polled
 *
 *  Console Termios output entry point.
 *
 */
static int ns16550_write_support_polled(
  int   minor, 
  const char *buf, 
  int   len)
{
        int nwrite = 0;

        /*
         * poll each byte in the string out of the port.
         */
        while (nwrite < len)
        {
                /*
                 * transmit character
                 */
                ns16550_write_polled(minor, *buf++);
                nwrite++;
        }

        /*
         * return the number of bytes written.
         */
        return nwrite;
}

/* 
 *  ns16550_inbyte_nonblocking_polled 
 *
 *  Console Termios polling input entry point.
 */

static int ns16550_inbyte_nonblocking_polled( 
        int minor 
)
{
        PSP_READ_REGISTERS      pNS16550Read;
        unsigned char   ucLineStatus;
        char    cChar;

        pNS16550Read=(PSP_READ_REGISTERS)Console_Port_Tbl[minor].ulCtrlPort1;

        inport_byte(&pNS16550Read->LineStatus, ucLineStatus);
        if(ucLineStatus & SP_LSR_RDY)
        {
                inport_byte(&pNS16550Read->ReceiveBuffer, cChar);
                return((int)cChar);
        }
        else
        {
        return(-1);
        }
}