path: root/bsps/shared/dev/serial/legacy-console.c

/**
 * @file
 *
 * @ingroup Console
 *
 * @brief Extension of the generic libchip console driver shell
 */

/*
 *  COPYRIGHT (c) 1989-2011, 2016.
 *  On-Line Applications Research Corporation (OAR).
 *
 *  The license and distribution terms for this file may be
 *  found in the file LICENSE in this distribution or at
 *  http://www.rtems.org/license/LICENSE.
 */

#include <bsp.h>
#include <bsp/fatal.h>
#include <rtems/libio.h>
#include <rtems/console.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <termios.h>

#include <rtems/termiostypes.h>
#include <libchip/serial.h>
#include "legacy-console.h"

unsigned long               Console_Port_Count  = 0;
console_tbl               **Console_Port_Tbl    = NULL;
console_data               *Console_Port_Data   = NULL;
rtems_device_minor_number   Console_Port_Minor  = 0;
static bool                 console_initialized = false;

/*
 *  console_find_console_entry
 *
 *  This method is used to search the console entries for a
 *  specific device entry.
 */
console_tbl* console_find_console_entry(
  const char                *match,
  size_t                     length,
  rtems_device_minor_number *match_minor
)
{
  rtems_device_minor_number  minor;

  /*
   * The the match name is NULL get the minor number entry.
   */
  if (match == NULL) {
    if (*match_minor < Console_Port_Count)
      return Console_Port_Tbl[*match_minor];
    return NULL;
  }

  for (minor=0; minor < Console_Port_Count ; minor++) {
    console_tbl  *cptr = Console_Port_Tbl[minor];

    /*
     * Console table entries include /dev/ prefix, device names passed
     * in on command line do not.
     */
    if ( !strncmp( cptr->sDeviceName, match, length ) ) {
      *match_minor = minor;
      return cptr;
    }
  }

  return NULL;
}

/*
 *  console_initialize_data
 *
 *  This method is used to initialize the table of pointers to the
 *  serial port configuration structure entries.
 */
void console_initialize_data(void)
{
  int i;

  if ( Console_Port_Tbl )
    return;

  /*
   * Allocate memory for the table of device pointers.
   */
  Console_Port_Count = Console_Configuration_Count;
  Console_Port_Tbl   = malloc( Console_Port_Count * sizeof( console_tbl * ) );
  if (Console_Port_Tbl == NULL)
    bsp_fatal( BSP_FATAL_CONSOLE_NO_MEMORY_0 );

  /*
   * Allocate memory for the table of device specific data pointers.
   */
  Console_Port_Data  = calloc( Console_Port_Count, sizeof( console_data ) );
  if ( Console_Port_Data == NULL ) {
    bsp_fatal( BSP_FATAL_CONSOLE_NO_MEMORY_3 );
  }

  /*
   * Fill in the Console Table
   */
  for (i=0 ; i < Console_Port_Count ; i++) {
    Console_Port_Tbl[i] = &Console_Configuration_Ports[i];
  }
}

/*
 *  console_register_devices
 *
 *  This method is used to add dynamically discovered devices to the
 *  set of serial ports supported.
 */
void console_register_devices(
  console_tbl *new_ports,
  size_t       number_of_ports
)
{
  int  old_number_of_ports;
  int  i;

  /*
   * Initialize the console data elements
   */
  console_initialize_data();

  /*
   *  console_initialize() has been invoked so it is now too late to
   *  register devices.
   */
  if ( console_initialized ) {
    bsp_fatal( BSP_FATAL_CONSOLE_MULTI_INIT );
  }

  /*
   *  Allocate memory for the console port extension
   */
  old_number_of_ports = Console_Port_Count;
  Console_Port_Count += number_of_ports;
  Console_Port_Tbl = realloc(
    Console_Port_Tbl,
    Console_Port_Count * sizeof(console_tbl *)
  );
  if ( Console_Port_Tbl == NULL ) {
    bsp_fatal( BSP_FATAL_CONSOLE_NO_MEMORY_1 );
  }

  /*
   * Since we can only add devices before console_initialize(),
   * the data area will contain no information and must be zero
   * before it is used. So extend the area and zero it out.
   */
  Console_Port_Data = realloc(
    Console_Port_Data,
    Console_Port_Count * sizeof(console_data)
  );
  if ( Console_Port_Data == NULL ) {
    bsp_fatal( BSP_FATAL_CONSOLE_NO_MEMORY_2 );
  }
  memset(Console_Port_Data, '\0', Console_Port_Count * sizeof(console_data));

  /*
   *  Now add the new devices at the end.
   */
  for (i=0 ; i < number_of_ports ; i++) {
    Console_Port_Tbl[old_number_of_ports + i]  = &new_ports[i];
  }
}

/*
 *  console_open
 *
 *  open a port as a termios console.
 */
rtems_device_driver console_open(
  rtems_device_major_number major,
  rtems_device_minor_number minor,
  void                    * arg
)
{
  rtems_status_code              status;
  rtems_libio_open_close_args_t *args = arg;
  rtems_libio_ioctl_args_t       IoctlArgs;
  struct termios                 Termios;
  rtems_termios_callbacks        Callbacks;
  console_tbl                   *cptr;
  struct rtems_termios_tty      *current_tty;

  /*
   * Verify the port number is valid.
   */
  if ( minor > Console_Port_Count ) {
    return RTEMS_INVALID_NUMBER;
  }

  /*
   * Open the port as a termios console driver.
   */

  cptr = Console_Port_Tbl[minor];
  Callbacks.firstOpen            = cptr->pDeviceFns->deviceFirstOpen;
  Callbacks.lastClose            = cptr->pDeviceFns->deviceLastClose;
  Callbacks.pollRead             = cptr->pDeviceFns->deviceRead;
  Callbacks.write                = cptr->pDeviceFns->deviceWrite;
  Callbacks.setAttributes        = cptr->pDeviceFns->deviceSetAttributes;
  if (cptr->pDeviceFlow != NULL) {
    Callbacks.stopRemoteTx  = cptr->pDeviceFlow->deviceStopRemoteTx;
    Callbacks.startRemoteTx = cptr->pDeviceFlow->deviceStartRemoteTx;
  } else {
    Callbacks.stopRemoteTx  = NULL;
    Callbacks.startRemoteTx = NULL;
  }
  Callbacks.outputUsesInterrupts = cptr->pDeviceFns->deviceOutputUsesInterrupts;

  /* XXX what about
   *        Console_Port_Tbl[minor].ulMargin,
   *        Console_Port_Tbl[minor].ulHysteresis);
   */

  status = rtems_termios_open( major, minor, arg, &Callbacks );
  Console_Port_Data[minor].termios_data = args->iop->data1;

  /* Get tty pointur from the Console_Port_Data */
  current_tty = Console_Port_Data[minor].termios_data;

  if ( (current_tty->refcount == 1) ) {

    /*
     *  If this BSP has a preferred default rate, then use that.
     */
    #if defined(BSP_DEFAULT_BAUD_RATE)
      rtems_termios_set_initial_baud( current_tty, BSP_DEFAULT_BAUD_RATE );
    #endif

    /*
     * If it's the first open, modified, if need, the port parameters
     */
    if ( minor != Console_Port_Minor ) {
      /*
       * If this is not the console we do not want ECHO and so forth
       */
      IoctlArgs.iop     = args->iop;
      IoctlArgs.command = TIOCGETA;
      IoctlArgs.buffer  = &Termios;
      rtems_termios_ioctl( &IoctlArgs );

      Termios.c_lflag   = ICANON;
      IoctlArgs.command = TIOCSETA;
      rtems_termios_ioctl( &IoctlArgs );
    }
  }

  if (rtems_libio_iop_is_readable(args->iop) &&
      cptr->pDeviceFlow &&
      cptr->pDeviceFlow->deviceStartRemoteTx) {
    cptr->pDeviceFlow->deviceStartRemoteTx(minor);
  }

  return status;
}

/*
 *  console_close
 *
 *  This routine closes a port that has been opened as console.
 */
rtems_device_driver console_close(
  rtems_device_major_number major,
  rtems_device_minor_number minor,
  void                    * arg
)
{
  rtems_libio_open_close_args_t *args = arg;
  struct rtems_termios_tty      *current_tty;
  console_tbl                   *cptr;

  cptr  = Console_Port_Tbl[minor];

  /* Get tty pointer from the Console_Port_Data */
  current_tty = Console_Port_Data[minor].termios_data;

  /* Get the tty refcount to determine if we need to do deviceStopRemoteTx.
   * Stop only if it's the last one opened.
   */
  if ( (current_tty->refcount == 1) ) {
    if (rtems_libio_iop_is_readable(args->iop) &&
          cptr->pDeviceFlow &&
          cptr->pDeviceFlow->deviceStopRemoteTx) {
      cptr->pDeviceFlow->deviceStopRemoteTx(minor);
    }
  }

  return rtems_termios_close (arg);
}

/*
 *  console_initialize
 *
 *  Routine called to initialize the console device driver.
 */
rtems_device_driver console_initialize(
  rtems_device_major_number  major,
  rtems_device_minor_number  minor_arg,
  void                      *arg
)
{
  rtems_status_code          status;
  rtems_device_minor_number  minor;
  console_tbl               *port;

  /*
   * If we have no devices which were registered earlier then we
   * must still initialize pointers for Console_Port_Tbl and
   * Console_Port_Data.
   */
  console_initialize_data();

  /*
   *  console_initialize has been invoked so it is now too late to
   *  register devices.
   */
  console_initialized = true;

  /*
   *  Initialize the termio interface, our table of pointers to device
   *  information structures, and determine if the user has explicitly
   *  specified which device is to be used for the console.
   */
  rtems_termios_initialize();
  bsp_console_select();

  /*
   *  Iterate over all of the console devices we know about
   *  and initialize them.
   */
  for (minor=0 ; minor < Console_Port_Count ; minor++) {
    /*
     *  First perform the configuration dependent probe, then the
     *  device dependent probe
     */
    port = Console_Port_Tbl[minor];

    if ( (!port->deviceProbe || port->deviceProbe(minor)) &&
         port->pDeviceFns->deviceProbe(minor)) {

      if (port->sDeviceName != NULL) {
        status = rtems_io_register_name( port->sDeviceName, major, minor );
        if (status != RTEMS_SUCCESSFUL) {
          bsp_fatal( BSP_FATAL_CONSOLE_REGISTER_DEV_0 );
        }
      }

      if (minor == Console_Port_Minor) {
        status = rtems_io_register_name( CONSOLE_DEVICE_NAME, major, minor );
        if (status != RTEMS_SUCCESSFUL) {
          bsp_fatal( BSP_FATAL_CONSOLE_REGISTER_DEV_1 );
        }
      }

      /*
       * Initialize the hardware device.
       */
      port->pDeviceFns->deviceInitialize(minor);

    }
  }

  return RTEMS_SUCCESSFUL;
}

/*
 *  console_read
 *
 *  This routine uses the termios driver to read a character.
 */
rtems_device_driver console_read(
  rtems_device_major_number major,
  rtems_device_minor_number minor,
  void                    * arg
)
{
  return rtems_termios_read (arg);
}

/*
 *  console_write
 *
 *  this routine uses the termios driver to write a character.
 */
rtems_device_driver console_write(
  rtems_device_major_number major,
  rtems_device_minor_number minor,
  void                    * arg
)
{
  return rtems_termios_write (arg);
}