/* $Id: rs232c.c,v 1.2 1999/01/03 02:07:32 sybalsky Exp $ (C) Copyright Venue, All Rights Reserved
 */

/************************************************************************/
/*									*/
/*	(C) Copyright 1989-95 Venue. All Rights Reserved.		*/
/*	Manufactured in the United States of America.			*/
/*									*/
/************************************************************************/

#include "version.h"

#include <fcntl.h>
#include <sgtty.h>
#include <stdio.h>
#include <sys/select.h>

#include "lspglob.h"
#include "rs232c.h"

/*
 * Lisp Interface
 */
static DLRS232C_HDW_CONF *HardWareConfig;
static DLRS232C_IOP_GET_FLAG *RS232CGetFlag;
static DLRS232C_IOP_PUT_FLAG *RS232CPutFlag;
static DLRS232C_IOP_MISC_CMD *RS232CMiscCommand;
static DLRS232C_PARAMETER_OUTCOME *RS232CParameterOutcome;
static DLRS232C_DEVICE_STATUS *RS232CDeviceStatus;
static DLRS232C_PARAMETER_CSB *RS232CParameterCSB;
static DLword *RS232CGetCSB, *RS232CPutCSB;

/*
 * File descriptor
 */
extern fd_set LispReadFds;
int RS232C_Fd = -1;

int RS232C_remain_data;
static char *RS232C_Dev;
static struct termios RS232C_Mode;

/*
 * Following two signal handler vector is used to deal with SIGHUP signal
 * which is sent if CLOCAL flag is not set and a modem disconnect
 * is detected.
 */

static struct sigvec rs_hup_sv;
static struct sigvec prev_hup_sv;

void rs232c_hup_handler(void) {
  printf("Modem disconnect is detected.\n");
  fflush(stdout);
  return;
}

rs_install_hup_handler(void) {
  rs_hup_sv.sv_handler = rs232c_hup_handler;
  rs_hup_sv.sv_mask = rs_hup_sv.sv_flags = 0;
  sigvec(SIGHUP, &rs_hup_sv, &prev_hup_sv);
}

rs_restore_hup_handler(void) { sigvec(SIGHUP, &prev_hup_sv, (struct sigvec *)NULL); }

/*
 * Fatal Error, enter URAID
 */
void rs_error(char *msg)
{ error(msg); }

/*
 * Continuable Error
 */
void rs_cerror(char *msg)
{ printf(msg); }

/*
 * Invoked at boot time
 */
void rs232c_init(void) {
  RS232C_Dev = "/dev/ttyb"; /*Modify for target system */
  RS232C_Fd = -1;

  /* Pointer to IOPAGE */
  HardWareConfig = (DLRS232C_HDW_CONF *)&IOPage->dliophardwareconfig;
  RS232CGetFlag = (DLRS232C_IOP_GET_FLAG *)&IOPage->dlrs232cgetflag;
  RS232CPutFlag = (DLRS232C_IOP_PUT_FLAG *)&IOPage->dlrs232cputflag;
  RS232CMiscCommand = (DLRS232C_IOP_MISC_CMD *)&IOPage->dlrs232cmisccommand;
  RS232CParameterOutcome = (DLRS232C_PARAMETER_OUTCOME *)&IOPage->dlrs232cparameteroutcome;
  RS232CDeviceStatus = (DLRS232C_DEVICE_STATUS *)&IOPage->dlrs232cdevicestatus;
  RS232CParameterCSB = (DLRS232C_PARAMETER_CSB *)&IOPage->dlrs232cparametercsblo_11;
  RS232CGetCSB = (DLword *)&IOPage->dlrs232cgetcsblo;
  RS232CPutCSB = (DLword *)&IOPage->dlrs232cputcsblo;

  HardWareConfig->rs232c_absent = 0;
  RS232CMiscCommand->busy = 0;

} /* rs232c_init end */

#define MIN_CHARS 256
#define MIN_TIME 1

/*
 * Default set up for the RS232C file descriptor
 * The value of the other parameters not listed below can be changed by user.
 */
int rs232_fd_init(int fd)
{
  struct termios tio;

  if (ioctl(fd, TCGETS, &tio) < 0) {
    rs_error("RS232C: rs232c_fd_init: cannot get status");
    return 0;
  } else {
    /* Input Mode */
    tio.c_iflag &= ~IGNBRK;
    tio.c_iflag &= ~IGNPAR;
    tio.c_iflag &= ~IUCLC;

    /* Output Mode */
    tio.c_oflag |= OPOST;
    tio.c_oflag &= ~OLCUC;
    tio.c_oflag &= ~OFILL;
    tio.c_oflag &= ~OFDEL;
    tio.c_oflag &= ~NLDLY;
    tio.c_oflag &= ~CRDLY;
    tio.c_oflag &= ~BSDLY;
    tio.c_oflag &= ~VTDLY;
    tio.c_oflag &= ~FFDLY;

    /* Control Mode */
    tio.c_cflag |= CREAD;
    tio.c_cflag |= HUPCL;
    tio.c_cflag &= ~CIBAUD; /* Input Baudrate == Output Baudrate*/

    /* Local Modes */
    tio.c_lflag &= ~ISIG;
    tio.c_lflag &= ~ICANON;
    tio.c_lflag &= ~XCASE;
    tio.c_lflag &= ~ECHO;
    tio.c_lflag &= ~ECHOE;
    tio.c_lflag &= ~ECHOK;
    tio.c_lflag &= ~ECHONL;
    tio.c_lflag &= ~NOFLSH;
    tio.c_lflag &= ~TOSTOP;
    tio.c_lflag &= ~ECHOCTL;
    tio.c_lflag &= ~ECHOPRT;
    tio.c_lflag &= ~ECHOKE;
    tio.c_lflag &= ~FLUSHO;
    tio.c_lflag &= ~PENDIN;

    /* Minimum and Timeout */
    tio.c_cc[VMIN] = MIN_CHARS;
    tio.c_cc[VTIME] = MIN_TIME;

    RS232C_Mode = tio;

    if (ioctl(fd, TCSETS, &tio) < 0)
      rs_error("RS232C: rs232c_fd_init: cannot set status");
    else
      return 1;
  }
}

rs232c_open(void) {
  if (RS232C_Fd < 0) {
    if ((RS232C_Fd = open(RS232C_Dev, O_RDWR)) < 0)
      rs_error("RS232C: rs232c_open: cannot open");
    else {
      rs232_fd_init();

      /* Receive SIGIO on the descriptor */
      if (ioctl(RS232C_Fd, I_SETSIG, S_INPUT) < 0)
        rs_error("RS232C: rs232c_open: cannot set signal");
      else {
        rs_install_hup_handler();
        FD_SET(RS232C_Fd, &LispReadFds);
        RS232C_remain_data = 0;
      }
    }
  }
}

rs232c_close(void) {
  if (RS232C_Fd >= 0) {
    rs232c_abortinput();
    rs232c_abortoutput();

    rs_restore_hup_handler();

    FD_CLR(RS232C_Fd, &LispReadFds);

    /*
                    if (close(RS232C_Fd) < 0)
                      rs_error("RS232C: rs232c_close: cannot close");
    */
    close(RS232C_Fd);
    RS232C_Fd = -1;
  }
}

RS232C_readinit(void) {
  if (RS232C_remain_data) {
    /*
     * There are other data which we have not read yet.
     * Signaling SIGIO invokes rs232c_read.
     */
    kill(getpid(), SIGIO);
  }
}

rs232c_lisp_is_ready(void) { return (RS232CGetFlag->busy); }

static struct timeval sel_tv = {0, 0};

rs232c_read(void) {
  DLRS232C_IOCB *iocb;
  int count;
  fd_set readfds;

  if (RS232C_Fd >= 0) {
    if (RS232CGetFlag->busy) {
      iocb =
          (DLRS232C_IOCB *)NativeAligned4FromLAddr(((*(RS232CGetCSB + 1) & 0xff) << 16) + *RS232CGetCSB);

      if ((count =
               read(RS232C_Fd, (char *)NativeAligned2FromLAddr(((iocb->block_pointer_hi & 0xff) << 16) +
                                                          iocb->block_pointer_lo),
                    iocb->byte_count)) < 0) {
        ((DLRS232C_IOCB_TRANSFER_STATUS *)(&iocb->transfer_status))->success = 0;
        RS232CGetFlag->busy = 0;
        return;
      }

      ((DLRS232C_IOCB_TRANSFER_STATUS *)(&(iocb->transfer_status)))->success = 1;
      iocb->returned_byte_count = count;
      RS232CGetFlag->busy = 0;

      /*
       * We want to check if the some other data
       * remaining or not.
       */
      FD_ZERO(&readfds);
      FD_SET(RS232C_Fd, &readfds);
      if (select(RS232C_Fd + 1, &readfds, NULL, NULL, &sel_tv) > 0) {
        if (FD_ISSET(RS232C_Fd, &readfds))
          RS232C_remain_data = 1;
        else
          RS232C_remain_data = 0;
      } else {
        RS232C_remain_data = 0;
      }
    } else {
      /*
       * SIGIO handler, process_io_events, and the successive
       * rs232c_read has been called before Lisp prepares
       * the next buffer.  Turn on RS232C_remain_data to
       * specify to read the remaining data after.
       */
      RS232C_remain_data = 1;
    }
  }
}

#define MAX_WRITE_TRY 5

RS232C_write(void) {
  int size, count, trynum;
  char *buf;
  DLRS232C_IOCB *iocb;

  iocb = (DLRS232C_IOCB *)NativeAligned4FromLAddr(((*(RS232CPutCSB + 1) & 0xff) << 16) + *RS232CPutCSB);

  if (RS232CPutFlag->busy && RS232C_Fd >= 0) {
    if (iocb->put) {
      for (size = iocb->byte_count,
          buf = (char *)NativeAligned2FromLAddr(((iocb->block_pointer_hi & 0xff) << 16) +
                                           iocb->block_pointer_lo);
           size > 0; size -= count, buf += count) {
        trynum = 0;
        while (trynum < MAX_WRITE_TRY) {
          count = write(RS232C_Fd, buf, size);
          if (count >= 0) break;
          trynum++;
        }

        if (count < 0) {
          ((DLRS232C_IOCB_TRANSFER_STATUS *)(&(iocb->transfer_status)))->success = 0;
          RS232CPutFlag->busy = 0;
          return;
        }
      }

      ((DLRS232C_IOCB_TRANSFER_STATUS *)(&(iocb->transfer_status)))->success = 1;
      RS232CPutFlag->busy = 0;
    } else {
      ((DLRS232C_IOCB_TRANSFER_STATUS *)(&(iocb->transfer_status)))->success = 1;
      RS232CPutFlag->busy = 0;
    }
  } else {
    ((DLRS232C_IOCB_TRANSFER_STATUS *)(&(iocb->transfer_status)))->success = 1;
    RS232CPutFlag->busy = 0;
  }
}

RS232C_cmd(void) {
  if (RS232CMiscCommand->busy) {
    switch (RS232CMiscCommand->command) {
      case ON: rs232c_open(); break;
      case OFF: rs232c_close(); break;
      case BREAK_ON: rs232c_breakon(); break;
      case BREAK_OFF: rs232c_breakoff(); break;
      case ABORT_INPUT: rs232c_abortinput(); break;
      case ABORT_OUTPUT: rs232c_abortoutput(); break;
      case GET_STATUS: rs232c_getstatus(); break;
      case MAJOR_SET_PARAMETERS: rs232c_majorparam(); break;
      case MINOR_SET_PARAMETERS: rs232c_minorparam(); break;
      default: rs_error("RS232C : RS232C_cmd");
    }
    RS232CMiscCommand->busy = 0;
  } else {
    rs_cerror("RS232C : RS232C_cmd: device busy.");
  }
}

rs232c_breakon(void) {
  if (RS232C_Fd >= 0) {
    if (ioctl(RS232C_Fd, TIOCSBRK, 0) < 0) rs_cerror("RS232C: rs232c_breakon");
  }
}

rs232c_breakoff(void) {
  if (RS232C_Fd >= 0) {
    if (ioctl(RS232C_Fd, TIOCCBRK, 0) < 0) rs_cerror("RS232C: rs232c_breakoff");
  }
}

rs232c_abortinput(void) {
  if (RS232C_Fd >= 0) {
    if (ioctl(RS232C_Fd, TCFLSH, 0) < 0)
      rs_cerror("RS232C: rs232c_abortinput");
    else
      RS232C_remain_data = 0;
  }
}

rs232c_abortoutput(void) {
  if (RS232C_Fd >= 0) {
    if (ioctl(RS232C_Fd, TCFLSH, 1) < 0) rs_cerror("RS232C: rs232c_abortoutput");
  }
}

rs232c_getstatus(void) {
  int status;

  if (RS232C_Fd >= 0) {
    if (ioctl(RS232C_Fd, TIOCMGET, &status) < 0)
      rs_error("rs232c_getstatus : cannot get status");
    else {
      RS232CDeviceStatus->power_indication = ((status & TIOCM_LE) == TIOCM_LE);
      ((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->data_terminal_ready =
          ((status & TIOCM_DTR) == TIOCM_DTR);
      ((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->request_to_send =
          ((status & TIOCM_RTS) == TIOCM_RTS);
      RS232CDeviceStatus->clear_to_send = ((status & TIOCM_CTS) == TIOCM_CTS);
      RS232CDeviceStatus->carrier_detect = ((status & TIOCM_CAR) == TIOCM_CAR);
      RS232CDeviceStatus->ring_indicator = ((status & TIOCM_RNG) == TIOCM_RNG);
      RS232CDeviceStatus->data_set_ready = ((status & TIOCM_DSR) == TIOCM_DSR);
    }
  }
}

void rs_baud(u_int baud)
{
  switch (baud) {
    case 0: return B50;
    case 1: return B75;
    case 2: return B110;
    case 3: return B134;
    case 4: return B150;
    case 5: return B200;
    case 6: return B300;
    case 7: return B600;
    case 8: return B1200;
    case 9: return B1800;
    case 10: return B2400;
    case 11: return B4800;
    case 12: return B9600;
    case 13: return B19200;
    case 14: return B38400;
    default: rs_error("rs_baud: illegal baud rate.");
  }
}

void rs_csize(u_int csize)
{
  switch (csize) {
    case 0: return CS5;
    case 1: return CS6;
    case 2: return CS7;
    case 3: return CS8;
    default: rs_error("rs_csize: illegal character size");
  }
}

void rs_sbit(u_int sbit)
{
  switch (sbit) {
    case 0: return 0;
    case 1: return CSTOPB;
    default: rs_error("rs_bit: illegal stop bit");
  }
}

void rs232c_majorparam(void) {
  int baud, csize, sbit;

  if (RS232C_Fd >= 0) {
    baud = rs_baud((u_int)((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->line_speed);
    RS232C_Mode.c_cflag &= ~CBAUD;
    RS232C_Mode.c_cflag |= baud;

    csize = rs_csize((u_int)((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->char_length);
    RS232C_Mode.c_cflag &= ~CSIZE;
    RS232C_Mode.c_cflag |= csize;
    if (csize == CS8)
      RS232C_Mode.c_iflag &= ~ISTRIP;
    else
      RS232C_Mode.c_iflag |= ISTRIP;

    switch ((u_int)((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->parity) {
      case ODD:
        RS232C_Mode.c_iflag |= INPCK;
        RS232C_Mode.c_cflag |= PARENB;
        RS232C_Mode.c_cflag |= PARODD;
        break;

      case EVEN:
        RS232C_Mode.c_iflag |= INPCK;
        RS232C_Mode.c_cflag |= PARENB;
        RS232C_Mode.c_cflag &= ~PARODD;
        break;

      default: RS232C_Mode.c_iflag &= ~INPCK; RS232C_Mode.c_cflag &= ~PARENB;
    }

    sbit = rs_sbit((u_int)((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->stop_bits);
    RS232C_Mode.c_cflag &= ~CSTOPB;
    RS232C_Mode.c_cflag |= sbit;

    if (((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->flowcontrol_on) {
      RS232C_Mode.c_iflag |= IXON;
      RS232C_Mode.c_iflag |= IXOFF;
      RS232C_Mode.c_cc[VSTART] =
          (char)((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->flowcontrol_xon_char;
      RS232C_Mode.c_cc[VSTOP] =
          (char)((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->flowcontrol_xoff_char;
    } else {
      RS232C_Mode.c_iflag &= ~IXON;
      RS232C_Mode.c_iflag &= ~IXOFF;
    }

    switch ((u_int)((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->in_eol) {
      case CR:
        RS232C_Mode.c_iflag &= ~INLCR;
        RS232C_Mode.c_iflag &= ~IGNCR;
        RS232C_Mode.c_iflag &= ~ICRNL;
        break;

      case LF:
        RS232C_Mode.c_iflag |= INLCR;
        RS232C_Mode.c_iflag &= ~IGNCR;
        RS232C_Mode.c_iflag &= ~ICRNL;
        break;

      case CRLF:
      default: RS232C_Mode.c_iflag |= INLCR; RS232C_Mode.c_iflag |= IGNCR;
    }

    switch ((u_int)((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->out_eol) {
      case LF:
        RS232C_Mode.c_oflag &= ~ONLCR;
        RS232C_Mode.c_oflag &= ~OCRNL;
        RS232C_Mode.c_oflag &= ~ONOCR;
        RS232C_Mode.c_oflag &= ~ONLRET;
        break;

      case CRLF:
        RS232C_Mode.c_oflag |= ONLCR;
        RS232C_Mode.c_oflag &= ~OCRNL;
        RS232C_Mode.c_oflag &= ~ONOCR;
        RS232C_Mode.c_oflag &= ~ONLRET;
        break;

      case CR:
      default:
        RS232C_Mode.c_oflag &= ~ONLCR;
        RS232C_Mode.c_oflag &= ~OCRNL;
        RS232C_Mode.c_oflag &= ~ONOCR;
        RS232C_Mode.c_oflag |= ONLRET;
    }

    if (((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->input_max_bell)
      RS232C_Mode.c_iflag |= IMAXBEL;
    else
      RS232C_Mode.c_iflag &= ~IMAXBEL;

    if (((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->tab_expand)
      RS232C_Mode.c_oflag |= XTABS;
    else
      RS232C_Mode.c_oflag &= ~XTABS;

    if (((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->modem_status_line)
      RS232C_Mode.c_cflag &= ~CLOCAL;
    else
      RS232C_Mode.c_cflag |= CLOCAL;

    if (((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->rts_cts_control)
      RS232C_Mode.c_cflag |= CRTSCTS;
    else
      RS232C_Mode.c_cflag &= ~CRTSCTS;

    if (ioctl(RS232C_Fd, TCSETS, &RS232C_Mode) < 0)
      rs_error("rs232c_majorparam: cannot set params");
    else
      RS232CParameterOutcome->success = 1;
  }
}

void rs232c_minorparam(void) {
  int status;

  if (RS232C_Fd >= 0) {
    if (ioctl(RS232C_Fd, TIOCMGET, &status) < 0)
      rs_error("rs_minorparam: cannot get status");
    else {
      if (((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->data_terminal_ready)
        status |= TIOCM_DTR;
      else
        status &= ~TIOCM_DTR;

      if (((DLRS232C_PARAMETER_CSB *)RS232CParameterCSB)->request_to_send)
        status |= TIOCM_RTS;
      else
        status &= ~TIOCM_RTS;

      if (ioctl(RS232C_Fd, TIOCMSET, &status) < 0)
        rs_error("rs_minorparam: cannot set status");
      else
        RS232CParameterOutcome->success = 1;
    }
  }
}

/*
 * Following functions named as check_XXX are used for debug.
 */

void check_params(int fd)
{
  struct termios tos;

  if (ioctl(fd, TCGETS, &tos) < 0) {
    perror("IOCTL");
    exit(1);
  }

  check_brate(tos.c_cflag);
  check_csize(tos.c_cflag);
  check_sbit(tos.c_cflag);
  check_parity(tos.c_cflag);
  check_oflag(tos.c_oflag);

  check_canon(&tos);
}

void check_brate(u_long cf)
{
  int b;
  printf("Baud rate : ");
  switch (cf & CBAUD) {
    case B0: b = 0; break;
    case B50: b = 50; break;
    case B75: b = 75; break;
    case B110: b = 110; break;
    case B134: b = 134; break;
    case B200: b = 200; break;
    case B300: b = 300; break;
    case B600: b = 600; break;
    case B1200: b = 1200; break;
    case B1800: b = 1800; break;
    case B2400: b = 2400; break;
    case B4800: b = 4800; break;
    case B9600: b = 9600; break;
    case B19200: b = 19200; break;
    case B38400: b = 384000; break;
    default: printf("Illegal.\n");
  }
  printf("%d bps.\n", b);
}

void check_csize(u_long cf)
{
  int s;
  printf("Char size : ");
  switch (cf & CSIZE) {
    case CS5: s = 5; break;
    case CS6: s = 6; break;
    case CS7: s = 7; break;
    case CS8: s = 8; break;
    default: printf("Illegal.\n");
  }
  printf("%d chars.\n", s);
}

void check_sbit(u_long cf)
{
  int s;
  printf("Stop bit : ");
  if (cf & CSTOPB)
    printf("2 bits.\n");
  else
    printf("1 bit.\n");
}

void check_parity(u_long cf)
{
  if (cf & PARENB) {
    printf("Parity Enabled : ");
    if (cf & PARODD)
      printf("Odd.\n");
    else
      printf("Even.\n");
  } else {
    printf("Parity Disabled.\n");
  }
}

void check_canon(struct termios *tos)
{
  u_long lf;

  lf = tos->c_lflag;

  if (lf & ICANON) {
    printf("Canonical.\n");
  } else {
    printf("Non-Canonical.\n");
    printf("MIN : %d  ,  TIME : %d\n", (tos->c_cc)[VMIN], (tos->c_cc)[VTIME]);
  }
}

void check_oflag(u_long of)
{
  if ((OPOST & of) == OPOST) {
    printf("OPOST : O\n");
  } else {
    printf("OPOST : X\n");
  }

  if ((ONLCR & of) == ONLCR) {
    printf("ONLCR : O\n");
  } else {
    printf("ONLCR : X\n");
  }
  if ((OCRNL & of) == OCRNL) {
    printf("OCRNL : O\n");
  } else {
    printf("OCRNL : X\n");
  }

  if ((ONOCR & of) == ONOCR) {
    printf("ONOCR : O\n");
  } else {
    printf("ONOCR : X\n");
  }
  if ((ONLRET & of) == ONLRET) {
    printf("ONLRET : O\n");
  } else {
    printf("ONLRET : X\n");
  }
  if ((OFILL & of) == OFILL) {
    printf("OFILL : O\n");
  } else {
    printf("OFILL : X\n");
  }
  if ((OFDEL & of) == OFDEL) {
    printf("OFDEL : O\n");
  } else {
    printf("OFDEL : X\n");
  }
  switch (NLDLY & of) {
    case NL0: printf("NL0 \n"); break;
    case NL1: printf("NL1\n"); break;
  }
  switch (CRDLY & of) {
    case CR0: printf("NL0 \n"); break;
    case CR1: printf("CR1\n"); break;
    case CR2: printf("CR2\n"); break;
    case CR3: printf("CR3\n"); break;
  }
  switch (TABDLY & of) {
    case TAB0: printf("NL0 \n"); break;
    case TAB1: printf("TAB1\n"); break;
    case TAB2: printf("TAB2\n"); break;
    case XTABS: printf("XTABS\n"); break;
  }
  switch (BSDLY & of) {
    case BS0: printf("NL0 \n"); break;
    case BS1: printf("BS1\n"); break;
  }
  switch (VTDLY & of) {
    case VT0: printf("NL0 \n"); break;
    case VT1: printf("VT1\n"); break;
  }
  switch (FFDLY & of) {
    case FF0: printf("NL0 \n"); break;
    case FF1: printf("FF1\n"); break;
  }
}

/*
 * In dbx, "call rsc()".
 */
void rsc(void) {
  if (RS232C_Fd >= 0) check_params(RS232C_Fd);
}

/* Old debug function: not updated.

rs232c_debug( name, sw )
        char *name;
        int  sw;
{
        struct sgttyb mode;


        if ( sw == 1 ) {

        printf("DEBUG: %s\n",name);

        printf("DEBUG: \t\tRS232C_Dev = %s\n", RS232C_Dev);
        printf("DEBUG: \t\tRS232C_Fd  = %d\n", RS232C_Fd);

        if ( RS232C_Fd >= 0 ) {
                ioctl( RS232C_Fd, TIOCGETP, &mode );

        printf("DEBUG: \t\tRS232C_Mode.sg_ispeed = %#x\n", mode.sg_ispeed );
        printf("DEBUG: \t\tRS232C_Mode.sg_ospeed = %#x\n", mode.sg_ospeed );
        printf("DEBUG: \t\tRS232C_Mode.sg_erase  = %#x\n", mode.sg_erase  );
        printf("DEBUG: \t\tRS232C_Mode.sg_kill   = %#x\n", mode.sg_kill   );
        printf("DEBUG: \t\tRS232C_Mode.sg_flags  = %#x\n", mode.sg_flags  );

        } /+ if(RS232C_Fd) end +/

        } /+ if(sw) end +/

        if ( sw == 2 ) {

        printf("DEBUG: %s\n",name);

        printf("DEBUG:\n");
        printf("DEBUG: \t\tSymbol             Address    Contents\n");
        printf("DEBUG: \t\tIOPAGE             %#x\n",NativeAligned4FromLAddr(IOPAGE_OFFSET));
        printf("DEBUG: \t\tHardWareConfig     %#x    %#x\n", HardWareConfig, *(DLword*)
HardWareConfig);
        printf("DEBUG: \t\tRS232CGetFlag      %#x    %#x\n", RS232CGetFlag, *(DLword*)
RS232CGetFlag);
        printf("DEBUG: \t\tRS232CPutFlag      %#x    %#x\n", RS232CPutFlag, *(DLword*)
RS232CPutFlag);
        printf("DEBUG: \t\tRS232CMiscCommand  %#x    %#x\n", RS232CMiscCommand, *(DLword*)
RS232CMiscCommand);
        printf("DEBUG: \t\tRS232CGetCSB       %#x    %#x\n", RS232CGetCSB, (LispPTR)
(((*(RS232CGetCSB+1) & 0xff)<<16) + *RS232CGetCSB ));
        printf("DEBUG: \t\tRS232CPutCSB       %#x    %#x\n", RS232CPutCSB, (LispPTR)
(((*(RS232CPutCSB+1) & 0xff)<<16) + *RS232CPutCSB ));
        printf("DEBUG: \t\tRS232CParameterCSB %#x    %#x\n", RS232CParameterCSB, *(DLword*)
RS232CParameterCSB);
        printf("DEBUG: \t\t                              %#x\n", *(DLword*) (RS232CParameterCSB+1));
        printf("DEBUG: \t\t                              %#x\n", *(DLword*) (RS232CParameterCSB+2));
        printf("DEBUG: \t\t                              %#x\n", *(DLword*) (RS232CParameterCSB+3));
        printf("DEBUG: \t\t                              %#x\n", *(DLword*) (RS232CParameterCSB+4));
        printf("DEBUG: \t\t                              %#x\n", *(DLword*) (RS232CParameterCSB+5));
        printf("DEBUG: \t\t                              %#x\n", *(DLword*) (RS232CParameterCSB+6));
        printf("DEBUG: \t\t                              %#x\n", *(DLword*) (RS232CParameterCSB+7));
        if( RS232C_WrIOCB != NULL )
        printf("DEBUG: \t\tRS232C_WrIOCB      %#x    %#x\n", RS232C_WrIOCB,
*((LispPTR*)RS232C_WrIOCB));
        if( RS232C_RdIOCB != NULL )
        printf("DEBUG: \t\tRS232C_RdIOCB      %#x    %#x\n", RS232C_RdIOCB,
*((LispPTR*)RS232C_RdIOCB));

        /+
        if( RS232C_WrBufAddr != NULL )
        printf("DEBUG: \t\tRS232C_WrBufAddr   %s\n" , RS232C_WrBufAddr);
        if( RS232C_WrBufAddr != NULL )
        printf("DEBUG: \t\tRS232C_RdBufAddr   %s\n" , RS232C_RdBufAddr);
        +/

        } /+ if(sw) end +/

 } /+ rs232c_debug end +/

*/