/* Serial interface for local (hardwired) serial ports on Un*x like systems
- Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
- 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 1992-2021 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "serial.h"
#include <sys/types.h>
#include "terminal.h"
#include <sys/socket.h>
-#include <sys/time.h>
+#include "gdbsupport/gdb_sys_time.h"
-#include "gdb_string.h"
-
-#ifdef HAVE_TERMIOS
+#include "gdbsupport/gdb_select.h"
+#include "gdbcmd.h"
+#include "gdbsupport/filestuff.h"
+#include <termios.h>
+#include "inflow.h"
struct hardwire_ttystate
{
struct termios termios;
};
-#endif /* termios */
-
-#ifdef HAVE_TERMIO
-
-/* It is believed that all systems which have added job control to SVR3
- (e.g. sco) have also added termios. Even if not, trying to figure out
- all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
- bewildering. So we don't attempt it. */
-struct hardwire_ttystate
- {
- struct termio termio;
- };
-#endif /* termio */
-
-#ifdef HAVE_SGTTY
-struct hardwire_ttystate
- {
- struct sgttyb sgttyb;
- struct tchars tc;
- struct ltchars ltc;
- /* Line discipline flags. */
- int lmode;
- };
-#endif /* sgtty */
+#ifdef CRTSCTS
+/* Boolean to explicitly enable or disable h/w flow control. */
+static bool serial_hwflow;
+static void
+show_serial_hwflow (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Hardware flow control is %s.\n"), value);
+}
+#endif
static int hardwire_open (struct serial *scb, const char *name);
static void hardwire_raw (struct serial *scb);
-static int wait_for (struct serial *scb, int timeout);
-static int hardwire_readchar (struct serial *scb, int timeout);
-static int do_hardwire_readchar (struct serial *scb, int timeout);
-static int generic_readchar (struct serial *scb, int timeout,
- int (*do_readchar) (struct serial *scb,
- int timeout));
static int rate_to_code (int rate);
static int hardwire_setbaudrate (struct serial *scb, int rate);
+static int hardwire_setparity (struct serial *scb, int parity);
static void hardwire_close (struct serial *scb);
static int get_tty_state (struct serial *scb,
struct hardwire_ttystate * state);
struct hardwire_ttystate * state);
static serial_ttystate hardwire_get_tty_state (struct serial *scb);
static int hardwire_set_tty_state (struct serial *scb, serial_ttystate state);
-static int hardwire_noflush_set_tty_state (struct serial *, serial_ttystate,
- serial_ttystate);
static void hardwire_print_tty_state (struct serial *, serial_ttystate,
struct ui_file *);
static int hardwire_drain_output (struct serial *);
static int hardwire_send_break (struct serial *);
static int hardwire_setstopbits (struct serial *, int);
-void _initialize_ser_hardwire (void);
-
-/* Open up a real live device for serial I/O */
+/* Open up a real live device for serial I/O. */
static int
hardwire_open (struct serial *scb, const char *name)
{
- scb->fd = open (name, O_RDWR);
+ scb->fd = gdb_open_cloexec (name, O_RDWR, 0);
if (scb->fd < 0)
return -1;
static int
get_tty_state (struct serial *scb, struct hardwire_ttystate *state)
{
-#ifdef HAVE_TERMIOS
if (tcgetattr (scb->fd, &state->termios) < 0)
return -1;
return 0;
-#endif
-
-#ifdef HAVE_TERMIO
- if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
- return -1;
- return 0;
-#endif
-
-#ifdef HAVE_SGTTY
- if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
- return -1;
- if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
- return -1;
- if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
- return -1;
- if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
- return -1;
-
- return 0;
-#endif
}
static int
set_tty_state (struct serial *scb, struct hardwire_ttystate *state)
{
-#ifdef HAVE_TERMIOS
if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
return -1;
return 0;
-#endif
-
-#ifdef HAVE_TERMIO
- if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
- return -1;
- return 0;
-#endif
-
-#ifdef HAVE_SGTTY
- if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
- return -1;
- if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0)
- return -1;
- if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0)
- return -1;
- if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0)
- return -1;
-
- return 0;
-#endif
}
static serial_ttystate
hardwire_get_tty_state (struct serial *scb)
{
- struct hardwire_ttystate *state;
-
- state = (struct hardwire_ttystate *) xmalloc (sizeof *state);
+ struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
if (get_tty_state (scb, state))
- return NULL;
+ {
+ xfree (state);
+ return NULL;
+ }
return (serial_ttystate) state;
}
-static int
-hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
+static serial_ttystate
+hardwire_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
{
- struct hardwire_ttystate *state;
+ struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
- state = (struct hardwire_ttystate *) ttystate;
+ *state = *(struct hardwire_ttystate *) ttystate;
- return set_tty_state (scb, state);
+ return (serial_ttystate) state;
}
static int
-hardwire_noflush_set_tty_state (struct serial *scb,
- serial_ttystate new_ttystate,
- serial_ttystate old_ttystate)
+hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
{
- struct hardwire_ttystate new_state;
-#ifdef HAVE_SGTTY
- struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
-#endif
-
- new_state = *(struct hardwire_ttystate *) new_ttystate;
-
- /* Don't change in or out of raw mode; we don't want to flush input.
- termio and termios have no such restriction; for them flushing input
- is separate from setting the attributes. */
-
-#ifdef HAVE_SGTTY
- if (state->sgttyb.sg_flags & RAW)
- new_state.sgttyb.sg_flags |= RAW;
- else
- new_state.sgttyb.sg_flags &= ~RAW;
+ struct hardwire_ttystate *state;
- /* I'm not sure whether this is necessary; the manpage just mentions
- RAW not CBREAK. */
- if (state->sgttyb.sg_flags & CBREAK)
- new_state.sgttyb.sg_flags |= CBREAK;
- else
- new_state.sgttyb.sg_flags &= ~CBREAK;
-#endif
+ state = (struct hardwire_ttystate *) ttystate;
- return set_tty_state (scb, &new_state);
+ return set_tty_state (scb, state);
}
static void
struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
int i;
-#ifdef HAVE_TERMIOS
fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
(int) state->termios.c_iflag,
(int) state->termios.c_oflag);
for (i = 0; i < NCCS; i += 1)
fprintf_filtered (stream, "0x%x ", state->termios.c_cc[i]);
fprintf_filtered (stream, "\n");
-#endif
-
-#ifdef HAVE_TERMIO
- fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
- state->termio.c_iflag, state->termio.c_oflag);
- fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
- state->termio.c_cflag, state->termio.c_lflag,
- state->termio.c_line);
- fprintf_filtered (stream, "c_cc: ");
- for (i = 0; i < NCC; i += 1)
- fprintf_filtered (stream, "0x%x ", state->termio.c_cc[i]);
- fprintf_filtered (stream, "\n");
-#endif
-
-#ifdef HAVE_SGTTY
- fprintf_filtered (stream, "sgttyb.sg_flags = 0x%x.\n",
- state->sgttyb.sg_flags);
-
- fprintf_filtered (stream, "tchars: ");
- for (i = 0; i < (int) sizeof (struct tchars); i++)
- fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->tc)[i]);
- fprintf_filtered (stream, "\n");
-
- fprintf_filtered (stream, "ltchars: ");
- for (i = 0; i < (int) sizeof (struct ltchars); i++)
- fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->ltc)[i]);
- fprintf_filtered (stream, "\n");
-
- fprintf_filtered (stream, "lmode: 0x%x\n", state->lmode);
-#endif
}
-/* Wait for the output to drain away, as opposed to flushing (discarding) it */
+/* Wait for the output to drain away, as opposed to flushing
+ (discarding) it. */
static int
hardwire_drain_output (struct serial *scb)
{
-#ifdef HAVE_TERMIOS
- return tcdrain (scb->fd);
-#endif
+ /* Ignore SIGTTOU which may occur during the drain. */
+ scoped_ignore_sigttou ignore_sigttou;
-#ifdef HAVE_TERMIO
- return ioctl (scb->fd, TCSBRK, 1);
-#endif
-
-#ifdef HAVE_SGTTY
- /* Get the current state and then restore it using TIOCSETP,
- which should cause the output to drain and pending input
- to be discarded. */
- {
- struct hardwire_ttystate state;
- if (get_tty_state (scb, &state))
- {
- return (-1);
- }
- else
- {
- return (ioctl (scb->fd, TIOCSETP, &state.sgttyb));
- }
- }
-#endif
+ return tcdrain (scb->fd);
}
static int
hardwire_flush_output (struct serial *scb)
{
-#ifdef HAVE_TERMIOS
return tcflush (scb->fd, TCOFLUSH);
-#endif
-
-#ifdef HAVE_TERMIO
- return ioctl (scb->fd, TCFLSH, 1);
-#endif
-
-#ifdef HAVE_SGTTY
- /* This flushes both input and output, but we can't do better. */
- return ioctl (scb->fd, TIOCFLUSH, 0);
-#endif
}
static int
hardwire_flush_input (struct serial *scb)
{
- ser_unix_flush_input (scb);
+ ser_base_flush_input (scb);
-#ifdef HAVE_TERMIOS
return tcflush (scb->fd, TCIFLUSH);
-#endif
-
-#ifdef HAVE_TERMIO
- return ioctl (scb->fd, TCFLSH, 0);
-#endif
-
-#ifdef HAVE_SGTTY
- /* This flushes both input and output, but we can't do better. */
- return ioctl (scb->fd, TIOCFLUSH, 0);
-#endif
}
static int
hardwire_send_break (struct serial *scb)
{
-#ifdef HAVE_TERMIOS
return tcsendbreak (scb->fd, 0);
-#endif
-
-#ifdef HAVE_TERMIO
- return ioctl (scb->fd, TCSBRK, 0);
-#endif
-
-#ifdef HAVE_SGTTY
- {
- int status;
- struct timeval timeout;
-
- status = ioctl (scb->fd, TIOCSBRK, 0);
-
- /* Can't use usleep; it doesn't exist in BSD 4.2. */
- /* Note that if this select() is interrupted by a signal it will not wait
- the full length of time. I think that is OK. */
- timeout.tv_sec = 0;
- timeout.tv_usec = 250000;
- select (0, 0, 0, 0, &timeout);
- status = ioctl (scb->fd, TIOCCBRK, 0);
- return status;
- }
-#endif
}
static void
struct hardwire_ttystate state;
if (get_tty_state (scb, &state))
- fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
+ fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n",
+ safe_strerror (errno));
-#ifdef HAVE_TERMIOS
state.termios.c_iflag = 0;
state.termios.c_oflag = 0;
state.termios.c_lflag = 0;
- state.termios.c_cflag &= ~(CSIZE | PARENB);
+ state.termios.c_cflag &= ~CSIZE;
state.termios.c_cflag |= CLOCAL | CS8;
- state.termios.c_cc[VMIN] = 0;
- state.termios.c_cc[VTIME] = 0;
-#endif
-
-#ifdef HAVE_TERMIO
- state.termio.c_iflag = 0;
- state.termio.c_oflag = 0;
- state.termio.c_lflag = 0;
- state.termio.c_cflag &= ~(CSIZE | PARENB);
- state.termio.c_cflag |= CLOCAL | CS8;
- state.termio.c_cc[VMIN] = 0;
- state.termio.c_cc[VTIME] = 0;
+#ifdef CRTSCTS
+ /* h/w flow control. */
+ if (serial_hwflow)
+ state.termios.c_cflag |= CRTSCTS;
+ else
+ state.termios.c_cflag &= ~CRTSCTS;
+#ifdef CRTS_IFLOW
+ if (serial_hwflow)
+ state.termios.c_cflag |= CRTS_IFLOW;
+ else
+ state.termios.c_cflag &= ~CRTS_IFLOW;
#endif
-
-#ifdef HAVE_SGTTY
- state.sgttyb.sg_flags |= RAW | ANYP;
- state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
#endif
-
- scb->current_timeout = 0;
+ state.termios.c_cc[VMIN] = 0;
+ state.termios.c_cc[VTIME] = 0;
if (set_tty_state (scb, &state))
- fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
-}
-
-/* Wait for input on scb, with timeout seconds. Returns 0 on success,
- otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
-
- For termio{s}, we actually just setup VTIME if necessary, and let the
- timeout occur in the read() in hardwire_read().
- */
-
-/* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
- ser_unix*() until the old TERMIOS/SGTTY/... timer code has been
- flushed. . */
-
-/* NOTE: cagney/1999-09-30: Much of the code below is dead. The only
- possible values of the TIMEOUT parameter are ONE and ZERO.
- Consequently all the code that tries to handle the possability of
- an overflowed timer is unnecessary. */
-
-static int
-wait_for (struct serial *scb, int timeout)
-{
-#ifdef HAVE_SGTTY
- while (1)
- {
- struct timeval tv;
- fd_set readfds;
- int numfds;
-
- /* NOTE: Some OS's can scramble the READFDS when the select()
- call fails (ex the kernel with Red Hat 5.2). Initialize all
- arguments before each call. */
-
- tv.tv_sec = timeout;
- tv.tv_usec = 0;
-
- FD_ZERO (&readfds);
- FD_SET (scb->fd, &readfds);
-
- if (timeout >= 0)
- numfds = select (scb->fd + 1, &readfds, 0, 0, &tv);
- else
- numfds = select (scb->fd + 1, &readfds, 0, 0, 0);
-
- if (numfds <= 0)
- if (numfds == 0)
- return SERIAL_TIMEOUT;
- else if (errno == EINTR)
- continue;
- else
- return SERIAL_ERROR; /* Got an error from select or poll */
-
- return 0;
- }
-#endif /* HAVE_SGTTY */
-
-#if defined HAVE_TERMIO || defined HAVE_TERMIOS
- if (timeout == scb->current_timeout)
- return 0;
-
- scb->current_timeout = timeout;
-
- {
- struct hardwire_ttystate state;
-
- if (get_tty_state (scb, &state))
- fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
-
-#ifdef HAVE_TERMIOS
- if (timeout < 0)
- {
- /* No timeout. */
- state.termios.c_cc[VTIME] = 0;
- state.termios.c_cc[VMIN] = 1;
- }
- else
- {
- state.termios.c_cc[VMIN] = 0;
- state.termios.c_cc[VTIME] = timeout * 10;
- if (state.termios.c_cc[VTIME] != timeout * 10)
- {
-
- /* If c_cc is an 8-bit signed character, we can't go
- bigger than this. If it is always unsigned, we could use
- 25. */
-
- scb->current_timeout = 12;
- state.termios.c_cc[VTIME] = scb->current_timeout * 10;
- scb->timeout_remaining = timeout - scb->current_timeout;
- }
- }
-#endif
-
-#ifdef HAVE_TERMIO
- if (timeout < 0)
- {
- /* No timeout. */
- state.termio.c_cc[VTIME] = 0;
- state.termio.c_cc[VMIN] = 1;
- }
- else
- {
- state.termio.c_cc[VMIN] = 0;
- state.termio.c_cc[VTIME] = timeout * 10;
- if (state.termio.c_cc[VTIME] != timeout * 10)
- {
- /* If c_cc is an 8-bit signed character, we can't go
- bigger than this. If it is always unsigned, we could use
- 25. */
-
- scb->current_timeout = 12;
- state.termio.c_cc[VTIME] = scb->current_timeout * 10;
- scb->timeout_remaining = timeout - scb->current_timeout;
- }
- }
-#endif
-
- if (set_tty_state (scb, &state))
- fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
-
- return 0;
- }
-#endif /* HAVE_TERMIO || HAVE_TERMIOS */
+ fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n",
+ safe_strerror (errno));
}
-/* Read a character with user-specified timeout. TIMEOUT is number of seconds
- to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
- char if successful. Returns SERIAL_TIMEOUT if timeout expired, EOF if line
- dropped dead, or SERIAL_ERROR for any other error (see errno in that case). */
-
-/* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
- ser_unix*() until the old TERMIOS/SGTTY/... timer code has been
- flushed. */
-
-/* NOTE: cagney/1999-09-16: This function is not identical to
- ser_unix_readchar() as part of replacing it with ser_unix*()
- merging will be required - this code handles the case where read()
- times out due to no data while ser_unix_readchar() doesn't expect
- that. */
-
-static int
-do_hardwire_readchar (struct serial *scb, int timeout)
-{
- int status, delta;
- int detach = 0;
-
- if (timeout > 0)
- timeout++;
-
- /* We have to be able to keep the GUI alive here, so we break the
- original timeout into steps of 1 second, running the "keep the
- GUI alive" hook each time through the loop.
-
- Also, timeout = 0 means to poll, so we just set the delta to 0,
- so we will only go through the loop once. */
-
- delta = (timeout == 0 ? 0 : 1);
- while (1)
- {
-
- /* N.B. The UI may destroy our world (for instance by calling
- remote_stop,) in which case we want to get out of here as
- quickly as possible. It is not safe to touch scb, since
- someone else might have freed it. The
- deprecated_ui_loop_hook signals that we should exit by
- returning 1. */
-
- if (deprecated_ui_loop_hook)
- detach = deprecated_ui_loop_hook (0);
-
- if (detach)
- return SERIAL_TIMEOUT;
-
- scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta);
- status = wait_for (scb, delta);
-
- if (status < 0)
- return status;
-
- status = read (scb->fd, scb->buf, BUFSIZ);
-
- if (status <= 0)
- {
- if (status == 0)
- {
- /* Zero characters means timeout (it could also be EOF, but
- we don't (yet at least) distinguish). */
- if (scb->timeout_remaining > 0)
- {
- timeout = scb->timeout_remaining;
- continue;
- }
- else if (scb->timeout_remaining < 0)
- continue;
- else
- return SERIAL_TIMEOUT;
- }
- else if (errno == EINTR)
- continue;
- else
- return SERIAL_ERROR; /* Got an error from read */
- }
-
- scb->bufcnt = status;
- scb->bufcnt--;
- scb->bufp = scb->buf;
- return *scb->bufp++;
- }
-}
-
-static int
-hardwire_readchar (struct serial *scb, int timeout)
-{
- return generic_readchar (scb, timeout, do_hardwire_readchar);
-}
-
-
#ifndef B19200
#define B19200 EXTA
#endif
for (i = 0; baudtab[i].rate != -1; i++)
{
- /* test for perfect macth. */
+ /* test for perfect macth. */
if (rate == baudtab[i].rate)
- return baudtab[i].code;
+ return baudtab[i].code;
else
- {
- /* check if it is in between valid values. */
- if (rate < baudtab[i].rate)
+ {
+ /* check if it is in between valid values. */
+ if (rate < baudtab[i].rate)
{
if (i)
- {
- warning (_("Invalid baud rate %d. Closest values are %d and %d."),
- rate, baudtab[i - 1].rate, baudtab[i].rate);
+ {
+ warning (_("Invalid baud rate %d. "
+ "Closest values are %d and %d."),
+ rate, baudtab[i - 1].rate, baudtab[i].rate);
}
else
- {
- warning (_("Invalid baud rate %d. Minimum value is %d."),
- rate, baudtab[0].rate);
+ {
+ warning (_("Invalid baud rate %d. Minimum value is %d."),
+ rate, baudtab[0].rate);
}
return -1;
}
- }
+ }
}
- /* The requested speed was too large. */
+ /* The requested speed was too large. */
warning (_("Invalid baud rate %d. Maximum value is %d."),
- rate, baudtab[i - 1].rate);
+ rate, baudtab[i - 1].rate);
return -1;
}
if (baud_code < 0)
{
/* The baud rate was not valid.
- A warning has already been issued. */
+ A warning has already been issued. */
errno = EINVAL;
return -1;
}
if (get_tty_state (scb, &state))
return -1;
-#ifdef HAVE_TERMIOS
cfsetospeed (&state.termios, baud_code);
cfsetispeed (&state.termios, baud_code);
-#endif
-
-#ifdef HAVE_TERMIO
-#ifndef CIBAUD
-#define CIBAUD CBAUD
-#endif
-
- state.termio.c_cflag &= ~(CBAUD | CIBAUD);
- state.termio.c_cflag |= baud_code;
-#endif
-
-#ifdef HAVE_SGTTY
- state.sgttyb.sg_ispeed = baud_code;
- state.sgttyb.sg_ospeed = baud_code;
-#endif
return set_tty_state (scb, &state);
}
return 1;
}
-#ifdef HAVE_TERMIOS
if (!newbit)
state.termios.c_cflag &= ~CSTOPB;
else
state.termios.c_cflag |= CSTOPB; /* two bits */
-#endif
-
-#ifdef HAVE_TERMIO
- if (!newbit)
- state.termio.c_cflag &= ~CSTOPB;
- else
- state.termio.c_cflag |= CSTOPB; /* two bits */
-#endif
-
-#ifdef HAVE_SGTTY
- return 0; /* sgtty doesn't support this */
-#endif
return set_tty_state (scb, &state);
}
-static void
-hardwire_close (struct serial *scb)
-{
- if (scb->fd < 0)
- return;
-
- close (scb->fd);
- scb->fd = -1;
-}
-
-\f
-/* Wait for input on scb, with timeout seconds. Returns 0 on success,
- otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
+/* Implement the "setparity" serial_ops callback. */
static int
-ser_unix_wait_for (struct serial *scb, int timeout)
+hardwire_setparity (struct serial *scb, int parity)
{
- while (1)
- {
- int numfds;
- struct timeval tv;
- fd_set readfds, exceptfds;
-
- /* NOTE: Some OS's can scramble the READFDS when the select()
- call fails (ex the kernel with Red Hat 5.2). Initialize all
- arguments before each call. */
-
- tv.tv_sec = timeout;
- tv.tv_usec = 0;
+ struct hardwire_ttystate state;
+ int newparity = 0;
- FD_ZERO (&readfds);
- FD_ZERO (&exceptfds);
- FD_SET (scb->fd, &readfds);
- FD_SET (scb->fd, &exceptfds);
+ if (get_tty_state (scb, &state))
+ return -1;
- if (timeout >= 0)
- numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, &tv);
- else
- numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, 0);
+ switch (parity)
+ {
+ case GDBPARITY_NONE:
+ newparity = 0;
+ break;
+ case GDBPARITY_ODD:
+ newparity = PARENB | PARODD;
+ break;
+ case GDBPARITY_EVEN:
+ newparity = PARENB;
+ break;
+ default:
+ internal_warning (__FILE__, __LINE__,
+ "Incorrect parity value: %d", parity);
+ return -1;
+ }
- if (numfds <= 0)
- {
- if (numfds == 0)
- return SERIAL_TIMEOUT;
- else if (errno == EINTR)
- continue;
- else
- return SERIAL_ERROR; /* Got an error from select or poll */
- }
+ state.termios.c_cflag &= ~(PARENB | PARODD);
+ state.termios.c_cflag |= newparity;
- return 0;
- }
+ return set_tty_state (scb, &state);
}
-/* Read a character with user-specified timeout. TIMEOUT is number of seconds
- to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
- char if successful. Returns -2 if timeout expired, EOF if line dropped
- dead, or -3 for any other error (see errno in that case). */
-static int
-do_unix_readchar (struct serial *scb, int timeout)
+static void
+hardwire_close (struct serial *scb)
{
- int status;
- int delta;
-
- /* We have to be able to keep the GUI alive here, so we break the
- original timeout into steps of 1 second, running the "keep the
- GUI alive" hook each time through the loop.
-
- Also, timeout = 0 means to poll, so we just set the delta to 0,
- so we will only go through the loop once. */
-
- delta = (timeout == 0 ? 0 : 1);
- while (1)
- {
-
- /* N.B. The UI may destroy our world (for instance by calling
- remote_stop,) in which case we want to get out of here as
- quickly as possible. It is not safe to touch scb, since
- someone else might have freed it. The
- deprecated_ui_loop_hook signals that we should exit by
- returning 1. */
-
- if (deprecated_ui_loop_hook)
- {
- if (deprecated_ui_loop_hook (0))
- return SERIAL_TIMEOUT;
- }
-
- status = ser_unix_wait_for (scb, delta);
- if (timeout > 0)
- timeout -= delta;
-
- /* If we got a character or an error back from wait_for, then we can
- break from the loop before the timeout is completed. */
-
- if (status != SERIAL_TIMEOUT)
- {
- break;
- }
-
- /* If we have exhausted the original timeout, then generate
- a SERIAL_TIMEOUT, and pass it out of the loop. */
-
- else if (timeout == 0)
- {
- status = SERIAL_TIMEOUT;
- break;
- }
- }
-
- if (status < 0)
- return status;
-
- while (1)
- {
- status = read (scb->fd, scb->buf, BUFSIZ);
- if (status != -1 || errno != EINTR)
- break;
- }
-
- if (status <= 0)
- {
- if (status == 0)
- return SERIAL_TIMEOUT; /* 0 chars means timeout [may need to
- distinguish between EOF & timeouts
- someday] */
- else
- return SERIAL_ERROR; /* Got an error from read */
- }
+ if (scb->fd < 0)
+ return;
- scb->bufcnt = status;
- scb->bufcnt--;
- scb->bufp = scb->buf;
- return *scb->bufp++;
+ close (scb->fd);
+ scb->fd = -1;
}
+\f
+\f
-/* Perform operations common to both old and new readchar. */
-
-/* Return the next character from the input FIFO. If the FIFO is
- empty, call the SERIAL specific routine to try and read in more
- characters.
+/* The hardwire ops. */
- Initially data from the input FIFO is returned (fd_event()
- pre-reads the input into that FIFO. Once that has been emptied,
- further data is obtained by polling the input FD using the device
- specific readchar() function. Note: reschedule() is called after
- every read. This is because there is no guarentee that the lower
- level fd_event() poll_event() code (which also calls reschedule())
- will be called. */
+static const struct serial_ops hardwire_ops =
+{
+ "hardwire",
+ hardwire_open,
+ hardwire_close,
+ NULL,
+ ser_base_readchar,
+ ser_base_write,
+ hardwire_flush_output,
+ hardwire_flush_input,
+ hardwire_send_break,
+ hardwire_raw,
+ hardwire_get_tty_state,
+ hardwire_copy_tty_state,
+ hardwire_set_tty_state,
+ hardwire_print_tty_state,
+ hardwire_setbaudrate,
+ hardwire_setstopbits,
+ hardwire_setparity,
+ hardwire_drain_output,
+ ser_base_async,
+ ser_unix_read_prim,
+ ser_unix_write_prim
+};
-static int
-generic_readchar (struct serial *scb, int timeout,
- int (do_readchar) (struct serial *scb, int timeout))
+void _initialize_ser_hardwire ();
+void
+_initialize_ser_hardwire ()
{
- int ch;
- if (scb->bufcnt > 0)
- {
- ch = *scb->bufp;
- scb->bufcnt--;
- scb->bufp++;
- }
- else if (scb->bufcnt < 0)
- {
- /* Some errors/eof are are sticky. */
- ch = scb->bufcnt;
- }
- else
- {
- ch = do_readchar (scb, timeout);
- if (ch < 0)
- {
- switch ((enum serial_rc) ch)
- {
- case SERIAL_EOF:
- case SERIAL_ERROR:
- /* Make the error/eof stick. */
- scb->bufcnt = ch;
- break;
- case SERIAL_TIMEOUT:
- scb->bufcnt = 0;
- break;
- }
- }
- }
- reschedule (scb);
- return ch;
+ serial_add_interface (&hardwire_ops);
+
+#ifdef CRTSCTS
+ add_setshow_boolean_cmd ("remoteflow", no_class,
+ &serial_hwflow, _("\
+Set use of hardware flow control for remote serial I/O."), _("\
+Show use of hardware flow control for remote serial I/O."), _("\
+Enable or disable hardware flow control (RTS/CTS) on the serial port\n\
+when debugging using remote targets."),
+ NULL,
+ show_serial_hwflow,
+ &setlist, &showlist);
+#endif
}
int
-ser_unix_readchar (struct serial *scb, int timeout)
+ser_unix_read_prim (struct serial *scb, size_t count)
{
- return generic_readchar (scb, timeout, do_unix_readchar);
+ return read (scb->fd, scb->buf, count);
}
-\f
-void
-_initialize_ser_hardwire (void)
+
+int
+ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
{
- struct serial_ops *ops = XMALLOC (struct serial_ops);
- memset (ops, 0, sizeof (struct serial_ops));
- ops->name = "hardwire";
- ops->next = 0;
- ops->open = hardwire_open;
- ops->close = hardwire_close;
- /* FIXME: Don't replace this with the equivalent ser_unix*() until
- the old TERMIOS/SGTTY/... timer code has been flushed. cagney
- 1999-09-16. */
- ops->readchar = hardwire_readchar;
- ops->write = ser_unix_write;
- ops->flush_output = hardwire_flush_output;
- ops->flush_input = hardwire_flush_input;
- ops->send_break = hardwire_send_break;
- ops->go_raw = hardwire_raw;
- ops->get_tty_state = hardwire_get_tty_state;
- ops->set_tty_state = hardwire_set_tty_state;
- ops->print_tty_state = hardwire_print_tty_state;
- ops->noflush_set_tty_state = hardwire_noflush_set_tty_state;
- ops->setbaudrate = hardwire_setbaudrate;
- ops->setstopbits = hardwire_setstopbits;
- ops->drain_output = hardwire_drain_output;
- ops->async = ser_unix_async;
- serial_add_interface (ops);
+ return write (scb->fd, buf, len);
}