Subversion Repositories openrisc

/*

 *  This file contains the TTY driver for the National Semiconductor NS16550.

 *

 *  This part is widely cloned and second sourced.  It is found in a number

 *  of "Super IO" controllers.

 *

 *  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 <rtems/libio.h>

#include <stdlib.h>

#include <ringbuf.h>

#include <libchip/serial.h>

#include "ns16550_p.h"

#include "sersupp.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 = {

  libchip_serial_default_probe,   /* deviceProbe */

  ns16550_open,                   /* deviceFirstOpen */

  NULL,                           /* deviceLastClose */

  NULL,                           /* deviceRead */

  ns16550_write_support_int,      /* deviceWrite */

  ns16550_initialize_interrupts,  /* deviceInitialize */

  ns16550_write_polled,           /* deviceWritePolled */

  ns16550_set_attributes,         /* deviceSetAttributes */

  TRUE                            /* deviceOutputUsesInterrupts */

};

console_fns ns16550_fns_polled = {

  libchip_serial_default_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 */

  ns16550_set_attributes,              /* deviceSetAttributes */

  FALSE                                /* deviceOutputUsesInterrupts */

};

extern void set_vector( rtems_isr_entry, rtems_vector_number, int );

/*

 *  ns16550_init

 */

NS16550_STATIC void ns16550_init(int minor)

{

  unsigned32              pNS16550;

  unsigned8               ucTrash;

  unsigned8               ucDataByte;

  unsigned32              ulBaudDivisor;

  ns16550_context        *pns16550Context;

  setRegister_f           setReg;

  getRegister_f           getReg;

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

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

  pns16550Context->ucModemCtrl=SP_MODEM_IRQ;

  pNS16550 = Console_Port_Tbl[minor].ulCtrlPort1;

  setReg   = Console_Port_Tbl[minor].setRegister;

  getReg   = Console_Port_Tbl[minor].getRegister;

  /* Clear the divisor latch, clear all interrupt enables,

   * and reset and

   * disable the FIFO's.

   */

  (*setReg)(pNS16550, NS16550_LINE_CONTROL, 0x0);

  ns16550_enable_interrupts(minor, NS16550_DISABLE_ALL_INTR);

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

  ulBaudDivisor = NS16550_Baud(

    (unsigned32) Console_Port_Tbl[minor].ulClock,

    (unsigned32) Console_Port_Tbl[minor].pDeviceParams

  );

  ucDataByte = SP_LINE_DLAB;

  (*setReg)(pNS16550, NS16550_LINE_CONTROL, ucDataByte);

  /* XXX */

  (*setReg)(pNS16550, NS16550_TRANSMIT_BUFFER, ulBaudDivisor&0xff);

  (*setReg)(pNS16550, NS16550_INTERRUPT_ENABLE, (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;

  (*setReg)(pNS16550, NS16550_LINE_CONTROL, ucDataByte);

  /* Enable and reset transmit and receive FIFOs. TJA     */

  ucDataByte = SP_FIFO_ENABLE;

  (*setReg)(pNS16550, NS16550_FIFO_CONTROL, ucDataByte);

  ucDataByte = SP_FIFO_ENABLE | SP_FIFO_RXRST | SP_FIFO_TXRST;

  (*setReg)(pNS16550, NS16550_FIFO_CONTROL, ucDataByte);

  ns16550_enable_interrupts(minor, NS16550_DISABLE_ALL_INTR);

  /* Set data terminal ready. */

  /* And open interrupt tristate line */

  (*setReg)(pNS16550, NS16550_MODEM_CONTROL,pns16550Context->ucModemCtrl);

  ucTrash = (*getReg)(pNS16550, NS16550_LINE_STATUS );

  ucTrash = (*getReg)(pNS16550, NS16550_RECEIVE_BUFFER );

}

/*

 *  ns16550_open

 */

NS16550_STATIC int ns16550_open(

  int      major,

  int      minor,

  void    * arg

)

{

  /*

   * Assert DTR

   */

  if(Console_Port_Tbl[minor].pDeviceFlow != &ns16550_flow_DTRCTS) {

    ns16550_assert_DTR(minor);

  }

  return(RTEMS_SUCCESSFUL);

}

/*

 *  ns16550_close

 */

NS16550_STATIC int ns16550_close(

  int      major,

  int      minor,

  void    * arg

)

{

  /*

   * Negate DTR

   */

  if(Console_Port_Tbl[minor].pDeviceFlow != &ns16550_flow_DTRCTS) {

    ns16550_negate_DTR(minor);

  }

  return(RTEMS_SUCCESSFUL);

}

/*

 *  ns16550_write_polled

 */

NS16550_STATIC void ns16550_write_polled(

  int   minor,

  char  cChar

)

{

  unsigned32              pNS16550;

  unsigned char           ucLineStatus;

  int                     iTimeout;

  getRegister_f           getReg;

  setRegister_f           setReg;

  pNS16550 = Console_Port_Tbl[minor].ulCtrlPort1;

  getReg   = Console_Port_Tbl[minor].getRegister;

  setReg   = Console_Port_Tbl[minor].setRegister;

  /*

   * wait for transmitter holding register to be empty

   */

  iTimeout=1000;

  ucLineStatus = (*getReg)(pNS16550, NS16550_LINE_STATUS);

  while ((ucLineStatus & SP_LSR_THOLD) == 0) {

    /*

     * Yield while we wait

     */

#if 0

     if(_System_state_Is_up(_System_state_Get())) {

       rtems_task_wake_after(RTEMS_YIELD_PROCESSOR);

     }

#endif

     ucLineStatus = (*getReg)(pNS16550, NS16550_LINE_STATUS);

     if(!--iTimeout) {

       break;

     }

  }

  /*

   * transmit character

   */

  (*setReg)(pNS16550, NS16550_TRANSMIT_BUFFER, cChar);

}

/*

 * These routines provide control of the RTS and DTR lines

 */

/*

 *  ns16550_assert_RTS

 */

NS16550_STATIC int ns16550_assert_RTS(int minor)

{

  unsigned32              pNS16550;

  unsigned32              Irql;

  ns16550_context        *pns16550Context;

  setRegister_f           setReg;

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

  pNS16550 = Console_Port_Tbl[minor].ulCtrlPort1;

  setReg   = Console_Port_Tbl[minor].setRegister;

  /*

   * Assert RTS

   */

  rtems_interrupt_disable(Irql);

  pns16550Context->ucModemCtrl|=SP_MODEM_RTS;

  (*setReg)(pNS16550, NS16550_MODEM_CONTROL, pns16550Context->ucModemCtrl);

  rtems_interrupt_enable(Irql);

  return 0;

}

/*

 *  ns16550_negate_RTS

 */

NS16550_STATIC int ns16550_negate_RTS(int minor)

{

  unsigned32              pNS16550;

  unsigned32              Irql;

  ns16550_context        *pns16550Context;

  setRegister_f           setReg;

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

  pNS16550 = Console_Port_Tbl[minor].ulCtrlPort1;

  setReg   = Console_Port_Tbl[minor].setRegister;

  /*

   * Negate RTS

   */

  rtems_interrupt_disable(Irql);

  pns16550Context->ucModemCtrl&=~SP_MODEM_RTS;

  (*setReg)(pNS16550, NS16550_MODEM_CONTROL, pns16550Context->ucModemCtrl);

  rtems_interrupt_enable(Irql);

  return 0;

}

/*

 * These flow control routines utilise a connection from the local DTR

 * line to the remote CTS line

 */

/*

 *  ns16550_assert_DTR

 */

NS16550_STATIC int ns16550_assert_DTR(int minor)

{

  unsigned32              pNS16550;

  unsigned32              Irql;

  ns16550_context        *pns16550Context;

  setRegister_f           setReg;

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

  pNS16550 = Console_Port_Tbl[minor].ulCtrlPort1;

  setReg   = Console_Port_Tbl[minor].setRegister;

  /*

   * Assert DTR

   */

  rtems_interrupt_disable(Irql);

  pns16550Context->ucModemCtrl|=SP_MODEM_DTR;

  (*setReg)(pNS16550, NS16550_MODEM_CONTROL, pns16550Context->ucModemCtrl);

  rtems_interrupt_enable(Irql);

  return 0;

}

/*

 *  ns16550_negate_DTR

 */

NS16550_STATIC int ns16550_negate_DTR(int minor)

{

  unsigned32              pNS16550;

  unsigned32              Irql;

  ns16550_context        *pns16550Context;

  setRegister_f           setReg;

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

  pNS16550 = Console_Port_Tbl[minor].ulCtrlPort1;

  setReg   = Console_Port_Tbl[minor].setRegister;

  /*

   * Negate DTR

   */

  rtems_interrupt_disable(Irql);

  pns16550Context->ucModemCtrl&=~SP_MODEM_DTR;

  (*setReg)(pNS16550, NS16550_MODEM_CONTROL,pns16550Context->ucModemCtrl);

  rtems_interrupt_enable(Irql);

  return 0;

}

/*

 *  ns16550_set_attributes

 *

 *  This function sets the channel to reflect the requested termios

 *  port settings.

 */

NS16550_STATIC int ns16550_set_attributes(

  int                   minor,

  const struct termios *t

)

{

  unsigned32              pNS16550;

  unsigned32              ulBaudDivisor;

  unsigned8               ucLineControl;

  unsigned32              baud_requested;

  setRegister_f           setReg;

  getRegister_f           getReg;

  unsigned32              Irql;

  pNS16550 = Console_Port_Tbl[minor].ulCtrlPort1;

  setReg   = Console_Port_Tbl[minor].setRegister;

  getReg   = Console_Port_Tbl[minor].getRegister;

  /*

   *  Calculate the baud rate divisor

   */

  baud_requested = t->c_cflag & CBAUD;

  if (!baud_requested)

    baud_requested = B9600;              /* default to 9600 baud */

  ulBaudDivisor = NS16550_Baud(

    (unsigned32) Console_Port_Tbl[minor].ulClock,

    termios_baud_to_number(baud_requested)

  );

  ucLineControl = 0;

  /*

   *  Parity

   */

  if (t->c_cflag & PARENB) {

    ucLineControl |= SP_LINE_PAR;

    if (!(t->c_cflag & PARODD))

      ucLineControl |= SP_LINE_ODD;

  }

  /*

   *  Character Size

   */

  if (t->c_cflag & CSIZE) {

    switch (t->c_cflag & CSIZE) {

      case CS5:  ucLineControl |= FIVE_BITS;  break;

      case CS6:  ucLineControl |= SIX_BITS;   break;

      case CS7:  ucLineControl |= SEVEN_BITS; break;

      case CS8:  ucLineControl |= EIGHT_BITS; break;

    }

  } else {

    ucLineControl |= EIGHT_BITS;               /* default to 9600,8,N,1 */

  }

  /*

   *  Stop Bits

   */

  if (t->c_cflag & CSTOPB) {

    ucLineControl |= SP_LINE_STOP;              /* 2 stop bits */

  } else {

    ;                                           /* 1 stop bit */

  }

  /*

   *  Now actually set the chip

   */

  rtems_interrupt_disable(Irql);

    /*

     *  Set the baud rate

     */

    (*setReg)(pNS16550, NS16550_LINE_CONTROL, SP_LINE_DLAB);

    /* XXX are these registers right? */

    (*setReg)(pNS16550, NS16550_TRANSMIT_BUFFER, ulBaudDivisor&0xff);

    (*setReg)(pNS16550, NS16550_INTERRUPT_ENABLE, (ulBaudDivisor>>8)&0xff);

    /*

     *  Now write the line control

     */

    (*setReg)(pNS16550, NS16550_LINE_CONTROL, ucLineControl );

  rtems_interrupt_enable(Irql);

  return 0;

}

/*

 *  ns16550_process

 *

 *  This routine is the console interrupt handler for A port.

 */

NS16550_STATIC void ns16550_process(

        int             minor

)

{

  unsigned32              pNS16550;

  volatile unsigned8      ucLineStatus;

  volatile unsigned8      ucInterruptId;

  unsigned char           cChar;

  getRegister_f           getReg;

  setRegister_f           setReg;

  pNS16550 = Console_Port_Tbl[minor].ulCtrlPort1;

  getReg   = Console_Port_Tbl[minor].getRegister;

  setReg   = Console_Port_Tbl[minor].setRegister;

  do {

    /*

     * Deal with any received characters

     */

    while(TRUE) {

      ucLineStatus = (*getReg)(pNS16550, NS16550_LINE_STATUS);

      if(~ucLineStatus & SP_LSR_RDY) {

        break;

      }

      cChar = (*getReg)(pNS16550, NS16550_RECEIVE_BUFFER);

      rtems_termios_enqueue_raw_characters(

        Console_Port_Data[minor].termios_data,

        &cChar,

        1

      );

    }

    /*

     *  TX all the characters we can

     */

    while(TRUE) {

        ucLineStatus = (*getReg)(pNS16550, NS16550_LINE_STATUS);

        if(~ucLineStatus & SP_LSR_THOLD) {

          /*

           * We'll get another interrupt when

           * the transmitter holding reg. becomes

           * free again

           */

          break;

        }

#if 0

        /* XXX flow control not completely supported in libchip */

        if(Console_Port_Tbl[minor].pDeviceFlow != &ns16550_flow_RTSCTS) {

          ns16550_negate_RTS(minor);

        }

#endif

    rtems_termios_dequeue_characters(Console_Port_Data[minor].termios_data, 1);

    if (rtems_termios_dequeue_characters(

         Console_Port_Data[minor].termios_data, 1)) {

        if (Console_Port_Tbl[minor].pDeviceFlow != &ns16550_flow_RTSCTS) {

          ns16550_negate_RTS(minor);

        }

        Console_Port_Data[minor].bActive = FALSE;

        ns16550_enable_interrupts(minor, NS16550_ENABLE_ALL_INTR_EXCEPT_TX);

        break;

      }

      ucInterruptId = (*getReg)(pNS16550, NS16550_INTERRUPT_ID);

    }

  } while((ucInterruptId&0xf)!=0x1);

}

/*

 *  ns16550_isr

 */

NS16550_STATIC rtems_isr ns16550_isr(

  rtems_vector_number vector

)

{

  int     minor;

  for(minor=0;minor<Console_Port_Count;minor++) {

    if(Console_Port_Tbl[minor].ulIntVector == vector &&

       Console_Port_Tbl[minor].deviceType == SERIAL_NS16550 ) {

      ns16550_process(minor);

    }

  }

}

/*

 *  ns16550_enable_interrupts

 *

 *  This routine initializes the port to have the specified interrupts masked.

 */

NS16550_STATIC void ns16550_enable_interrupts(

  int minor,

  int mask

)

{

  unsigned32     pNS16550;

  setRegister_f  setReg;

  pNS16550 = Console_Port_Tbl[minor].ulCtrlPort1;

  setReg   = Console_Port_Tbl[minor].setRegister;

  (*setReg)(pNS16550, NS16550_INTERRUPT_ENABLE, mask);

}

/*

 *  ns16550_initialize_interrupts

 *

 *  This routine initializes the port to operate in interrupt driver mode.

 */

NS16550_STATIC void ns16550_initialize_interrupts(int minor)

{

  ns16550_init(minor);

  Console_Port_Data[minor].bActive = FALSE;

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

  ns16550_enable_interrupts(minor, NS16550_ENABLE_ALL_INTR);

}

/*

 *  ns16550_write_support_int

 *

 *  Console Termios output entry point.

 */

NS16550_STATIC int ns16550_write_support_int(

  int   minor,

  const char *buf,

  int   len

)

{

  unsigned32     Irql;

  unsigned32     pNS16550;

  setRegister_f  setReg;

  setReg   = Console_Port_Tbl[minor].setRegister;

  pNS16550 = Console_Port_Tbl[minor].ulCtrlPort1;

  /*

   *  We are using interrupt driven output and termios only sends us

   *  one character at a time.

   */

  if ( !len )

    return 0;

  if(Console_Port_Tbl[minor].pDeviceFlow != &ns16550_flow_RTSCTS) {

    ns16550_assert_RTS(minor);

  }

  rtems_interrupt_disable(Irql);

    if ( Console_Port_Data[minor].bActive == FALSE) {

      Console_Port_Data[minor].bActive = TRUE;

      ns16550_enable_interrupts(minor, NS16550_ENABLE_ALL_INTR);

    }

    (*setReg)(pNS16550, NS16550_TRANSMIT_BUFFER, *buf);

  rtems_interrupt_enable(Irql);

  return 1;

}

/*

 *  ns16550_write_support_polled

 *

 *  Console Termios output entry point.

 *

 */

NS16550_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.

 */

NS16550_STATIC int ns16550_inbyte_nonblocking_polled(

  int minor

)

{

  unsigned32           pNS16550;

  unsigned char        ucLineStatus;

  char                 cChar;

  getRegister_f        getReg;

  pNS16550 = Console_Port_Tbl[minor].ulCtrlPort1;

  getReg   = Console_Port_Tbl[minor].getRegister;

  ucLineStatus = (*getReg)(pNS16550, NS16550_LINE_STATUS);

  if(ucLineStatus & SP_LSR_RDY) {

    cChar = (*getReg)(pNS16550, NS16550_RECEIVE_BUFFER);

    return (int)cChar;

  } else {

    return -1;

  }

}