/* Serial interface for local (hardwired) serial ports on Un*x like systems
- Copyright 1992, 1993, 1994, 1998-1999 Free Software Foundation, Inc.
+
+ Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2003,
+ 2004, 2005, 2007, 2008, 2009 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 "ser-base.h"
#include "ser-unix.h"
#include <fcntl.h>
#include <sys/types.h>
#include "terminal.h"
-#ifdef HAVE_SYS_WAIT_H
-#include <sys/wait.h>
-#endif
#include <sys/socket.h>
#include <sys/time.h>
+#include "gdb_select.h"
#include "gdb_string.h"
-#include "event-loop.h"
-
+#include "gdbcmd.h"
#ifdef HAVE_TERMIOS
{
struct termios termios;
};
+
+#ifdef CRTSCTS
+/* Boolean to explicitly enable or disable h/w flow control. */
+static int 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
+
#endif /* termios */
#ifdef HAVE_TERMIO
};
#endif /* sgtty */
-static int hardwire_open (serial_t scb, const char *name);
-static void hardwire_raw (serial_t scb);
-static int wait_for (serial_t scb, int timeout);
-static int hardwire_readchar (serial_t scb, int timeout);
+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 rate_to_code (int rate);
-static int hardwire_setbaudrate (serial_t scb, int rate);
-static int hardwire_write (serial_t scb, const char *str, int len);
-static void hardwire_close (serial_t scb);
-static int get_tty_state (serial_t scb, struct hardwire_ttystate * state);
-static int set_tty_state (serial_t scb, struct hardwire_ttystate * state);
-static serial_ttystate hardwire_get_tty_state (serial_t scb);
-static int hardwire_set_tty_state (serial_t scb, serial_ttystate state);
-static int hardwire_noflush_set_tty_state (serial_t, serial_ttystate,
- serial_ttystate);
-static void hardwire_print_tty_state (serial_t, serial_ttystate, struct gdb_file *);
-static int hardwire_drain_output (serial_t);
-static int hardwire_flush_output (serial_t);
-static int hardwire_flush_input (serial_t);
-static int hardwire_send_break (serial_t);
-static int hardwire_setstopbits (serial_t, int);
+static int hardwire_setbaudrate (struct serial *scb, int rate);
+static void hardwire_close (struct serial *scb);
+static int get_tty_state (struct serial *scb,
+ struct hardwire_ttystate * state);
+static int set_tty_state (struct serial *scb,
+ 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_flush_output (struct serial *);
+static int hardwire_flush_input (struct serial *);
+static int hardwire_send_break (struct serial *);
+static int hardwire_setstopbits (struct serial *, int);
void _initialize_ser_hardwire (void);
-extern int (*ui_loop_hook) (int);
-
/* Open up a real live device for serial I/O */
static int
-hardwire_open (serial_t scb, const char *name)
+hardwire_open (struct serial *scb, const char *name)
{
scb->fd = open (name, O_RDWR);
if (scb->fd < 0)
}
static int
-get_tty_state (serial_t scb, struct hardwire_ttystate *state)
+get_tty_state (struct serial *scb, struct hardwire_ttystate *state)
{
#ifdef HAVE_TERMIOS
if (tcgetattr (scb->fd, &state->termios) < 0)
}
static int
-set_tty_state (serial_t scb, struct hardwire_ttystate *state)
+set_tty_state (struct serial *scb, struct hardwire_ttystate *state)
{
#ifdef HAVE_TERMIOS
if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
}
static serial_ttystate
-hardwire_get_tty_state (serial_t scb)
+hardwire_get_tty_state (struct serial *scb)
{
struct hardwire_ttystate *state;
}
static int
-hardwire_set_tty_state (serial_t scb, serial_ttystate ttystate)
+hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
{
struct hardwire_ttystate *state;
}
static int
-hardwire_noflush_set_tty_state (serial_t scb,
+hardwire_noflush_set_tty_state (struct serial *scb,
serial_ttystate new_ttystate,
serial_ttystate old_ttystate)
{
}
static void
-hardwire_print_tty_state (serial_t scb,
+hardwire_print_tty_state (struct serial *scb,
serial_ttystate ttystate,
- struct gdb_file *stream)
+ struct ui_file *stream)
{
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",
- state->termios.c_iflag, state->termios.c_oflag);
+ (int) state->termios.c_iflag,
+ (int) state->termios.c_oflag);
fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n",
- state->termios.c_cflag, state->termios.c_lflag);
+ (int) state->termios.c_cflag,
+ (int) state->termios.c_lflag);
#if 0
/* This not in POSIX, and is not really documented by those systems
which have it (at least not Sun). */
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 ("\n");
+ fprintf_filtered (stream, "\n");
fprintf_filtered (stream, "ltchars: ");
for (i = 0; i < (int) sizeof (struct ltchars); i++)
/* Wait for the output to drain away, as opposed to flushing (discarding) it */
static int
-hardwire_drain_output (serial_t scb)
+hardwire_drain_output (struct serial *scb)
{
#ifdef HAVE_TERMIOS
return tcdrain (scb->fd);
}
static int
-hardwire_flush_output (serial_t scb)
+hardwire_flush_output (struct serial *scb)
{
#ifdef HAVE_TERMIOS
return tcflush (scb->fd, TCOFLUSH);
}
static int
-hardwire_flush_input (serial_t scb)
+hardwire_flush_input (struct serial *scb)
{
- scb->bufcnt = 0;
- scb->bufp = scb->buf;
+ ser_base_flush_input (scb);
#ifdef HAVE_TERMIOS
return tcflush (scb->fd, TCIFLUSH);
}
static int
-hardwire_send_break (serial_t scb)
+hardwire_send_break (struct serial *scb)
{
#ifdef HAVE_TERMIOS
return tcsendbreak (scb->fd, 0);
#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);
+ /* Note that if this gdb_select() is interrupted by a signal it will not
+ wait the full length of time. I think that is OK. */
+ gdb_usleep (250000);
status = ioctl (scb->fd, TIOCCBRK, 0);
return status;
}
}
static void
-hardwire_raw (serial_t scb)
+hardwire_raw (struct serial *scb)
{
struct hardwire_ttystate state;
state.termios.c_lflag = 0;
state.termios.c_cflag &= ~(CSIZE | PARENB);
state.termios.c_cflag |= CLOCAL | CS8;
+#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
+#endif
state.termios.c_cc[VMIN] = 0;
state.termios.c_cc[VTIME] = 0;
#endif
timeout occur in the read() in hardwire_read().
*/
-/* FIXME: Don't replace this with the equivalent ser_unix*() until the
- old TERMIOS/SGTTY/... timer code has been flushed. cagney
- 1999-09-16. */
+/* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
+ ser_base*() 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 (serial_t scb, int timeout)
+wait_for (struct serial *scb, int timeout)
{
#ifdef HAVE_SGTTY
- {
- struct timeval tv;
- fd_set readfds;
+ while (1)
+ {
+ struct timeval tv;
+ fd_set readfds;
+ int numfds;
- FD_ZERO (&readfds);
+ /* 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;
+ tv.tv_sec = timeout;
+ tv.tv_usec = 0;
- FD_SET (scb->fd, &readfds);
+ FD_ZERO (&readfds);
+ FD_SET (scb->fd, &readfds);
- while (1)
- {
- int numfds;
+ if (timeout >= 0)
+ numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, &tv);
+ else
+ numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, 0);
- if (timeout >= 0)
- numfds = select (scb->fd + 1, &readfds, 0, 0, &tv);
+ if (numfds <= 0)
+ if (numfds == 0)
+ return SERIAL_TIMEOUT;
+ else if (errno == EINTR)
+ continue;
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 SERIAL_ERROR; /* Got an error from select or poll */
- return 0;
- }
- }
+ return 0;
+ }
#endif /* HAVE_SGTTY */
#if defined HAVE_TERMIO || defined HAVE_TERMIOS
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
+ ser_base*() 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*()
+ ser_base_readchar() as part of replacing it with ser_base*()
merging will be required - this code handles the case where read()
- times out due to no data while ser_unix_readchar() doesn't expect
+ times out due to no data while ser_base_readchar() doesn't expect
that. */
static int
-hardwire_readchar (serial_t scb, int timeout)
+do_hardwire_readchar (struct serial *scb, int timeout)
{
int status, delta;
int detach = 0;
- if (scb->bufcnt-- > 0)
- return *scb->bufp++;
-
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. */
+ /* 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 ui_loop_hook signals that
- we should exit by returning 1. */
+ someone else might have freed it. The
+ deprecated_ui_loop_hook signals that we should exit by
+ returning 1. */
- if (ui_loop_hook)
- detach = ui_loop_hook (0);
+ if (deprecated_ui_loop_hook)
+ detach = deprecated_ui_loop_hook (0);
if (detach)
return SERIAL_TIMEOUT;
if (status < 0)
return status;
- /* NOTE: cagney/1999-09-17: See ser_unix_readchar() for reason
- why ASYNC reads are character by character. */
-
- scb->bufcnt = read (scb->fd, scb->buf,
- (SERIAL_IS_ASYNC_P (scb) ? 1 : BUFSIZ));
+ status = read (scb->fd, scb->buf, BUFSIZ);
- if (scb->bufcnt <= 0)
+ if (status <= 0)
{
- if (scb->bufcnt == 0)
+ if (status == 0)
{
/* Zero characters means timeout (it could also be EOF, but
we don't (yet at least) distinguish). */
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
int i;
for (i = 0; baudtab[i].rate != -1; i++)
- if (rate == baudtab[i].rate)
- return baudtab[i].code;
-
+ {
+ /* test for perfect macth. */
+ if (rate == baudtab[i].rate)
+ return baudtab[i].code;
+ else
+ {
+ /* 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);
+ }
+ else
+ {
+ warning (_("Invalid baud rate %d. Minimum value is %d."),
+ rate, baudtab[0].rate);
+ }
+ return -1;
+ }
+ }
+ }
+
+ /* The requested speed was too large. */
+ warning (_("Invalid baud rate %d. Maximum value is %d."),
+ rate, baudtab[i - 1].rate);
return -1;
}
static int
-hardwire_setbaudrate (serial_t scb, int rate)
+hardwire_setbaudrate (struct serial *scb, int rate)
{
struct hardwire_ttystate state;
+ int baud_code = rate_to_code (rate);
+
+ if (baud_code < 0)
+ {
+ /* The baud rate was not valid.
+ A warning has already been issued. */
+ errno = EINVAL;
+ return -1;
+ }
if (get_tty_state (scb, &state))
return -1;
#ifdef HAVE_TERMIOS
- cfsetospeed (&state.termios, rate_to_code (rate));
- cfsetispeed (&state.termios, rate_to_code (rate));
+ cfsetospeed (&state.termios, baud_code);
+ cfsetispeed (&state.termios, baud_code);
#endif
#ifdef HAVE_TERMIO
#endif
state.termio.c_cflag &= ~(CBAUD | CIBAUD);
- state.termio.c_cflag |= rate_to_code (rate);
+ state.termio.c_cflag |= baud_code;
#endif
#ifdef HAVE_SGTTY
- state.sgttyb.sg_ispeed = rate_to_code (rate);
- state.sgttyb.sg_ospeed = rate_to_code (rate);
+ state.sgttyb.sg_ispeed = baud_code;
+ state.sgttyb.sg_ospeed = baud_code;
#endif
return set_tty_state (scb, &state);
}
static int
-hardwire_setstopbits (scb, num)
- serial_t scb;
- int num;
+hardwire_setstopbits (struct serial *scb, int num)
{
struct hardwire_ttystate state;
int newbit;
return set_tty_state (scb, &state);
}
-/* FIXME: Don't replace this with the equivalent ser_unix*() until the
- old TERMIOS/SGTTY/... timer code has been flushed. cagney
- 1999-09-16. */
-
-static int
-hardwire_write (serial_t scb, const char *str, int len)
-{
- int cc;
-
- while (len > 0)
- {
- cc = write (scb->fd, str, len);
-
- if (cc < 0)
- return 1;
- len -= cc;
- str += cc;
- }
- return 0;
-}
-
-
static void
-hardwire_close (serial_t scb)
+hardwire_close (struct serial *scb)
{
if (scb->fd < 0)
return;
close (scb->fd);
scb->fd = -1;
}
-
\f
-/* Generic operations used by all UNIX/FD based serial interfaces. */
-
-serial_ttystate
-ser_unix_nop_get_tty_state (serial_t scb)
-{
- /* allocate a dummy */
- return (serial_ttystate) XMALLOC (int);
-}
-
-int
-ser_unix_nop_set_tty_state (serial_t scb, serial_ttystate ttystate)
-{
- return 0;
-}
-
-void
-ser_unix_nop_raw (serial_t scb)
-{
- return; /* Always in raw mode */
-}
-
-/* Wait for input on scb, with timeout seconds. Returns 0 on success,
- otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
-
-int
-ser_unix_wait_for (serial_t scb, int timeout)
-{
- int numfds;
- struct timeval tv;
- fd_set readfds, exceptfds;
-
- FD_ZERO (&readfds);
- FD_ZERO (&exceptfds);
-
- tv.tv_sec = timeout;
- tv.tv_usec = 0;
-
- FD_SET (scb->fd, &readfds);
- FD_SET (scb->fd, &exceptfds);
-
- while (1)
- {
- if (timeout >= 0)
- numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, &tv);
- else
- numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, 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;
- }
-}
-
-/* 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). */
-
-int
-ser_unix_readchar (serial_t scb, int timeout)
-{
- int status;
- int delta;
-
- if (scb->bufcnt-- > 0)
- return *scb->bufp++;
-
- /* 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 ui_loop_hook signals that
- we should exit by returning 1. */
-
- if (ui_loop_hook)
- {
- if (ui_loop_hook (0))
- return SERIAL_TIMEOUT;
- }
-
- status = ser_unix_wait_for (scb, delta);
- 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)
- {
- /* FIXME: cagney/1999-09-17: ASYNC: The ASYNC serial code needs
- to be modified so that it agressivly tries to drain its local
- input buffer. Until this is done, the read() below can only
- take in single characters. This is to ensure that
- unprocessed data doesn't end up sitting in the input fifo. */
- scb->bufcnt = read (scb->fd, scb->buf,
- (SERIAL_IS_ASYNC_P (scb) ? 1 : BUFSIZ));
- if (scb->bufcnt != -1 || errno != EINTR)
- break;
- }
-
- if (scb->bufcnt <= 0)
- {
- if (scb->bufcnt == 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 */
- }
-
- scb->bufcnt--;
- scb->bufp = scb->buf;
- return *scb->bufp++;
-}
-
-int
-ser_unix_nop_noflush_set_tty_state (serial_t scb,
- serial_ttystate new_ttystate,
- serial_ttystate old_ttystate)
-{
- return 0;
-}
-
-void
-ser_unix_nop_print_tty_state (serial_t scb,
- serial_ttystate ttystate,
- struct gdb_file *stream)
-{
- /* Nothing to print. */
- return;
-}
-
-int
-ser_unix_nop_setbaudrate (serial_t scb, int rate)
-{
- return 0; /* Never fails! */
-}
-
-int
-ser_unix_nop_setstopbits (serial_t scb, int num)
-{
- return 0; /* Never fails! */
-}
-
-int
-ser_unix_write (serial_t scb, const char *str, int len)
-{
- int cc;
-
- while (len > 0)
- {
- cc = write (scb->fd, str, len);
-
- if (cc < 0)
- return 1;
- len -= cc;
- str += cc;
- }
- return 0;
-}
-
-int
-ser_unix_nop_flush_output (serial_t scb)
-{
- return 0;
-}
-
-int
-ser_unix_nop_flush_input (serial_t scb)
-{
- return 0;
-}
-
-int
-ser_unix_nop_send_break (serial_t scb)
-{
- return 0;
-}
-
-int
-ser_unix_nop_drain_output (serial_t scb)
-{
- return 0;
-}
-
-static void
-ser_unix_event (int error, int fd, gdb_client_data context)
-{
- serial_t scb = context;
- scb->async_handler (error, scb->async_context, fd);
-}
-
-void
-ser_unix_async (serial_t scb,
- int async_p)
-{
- if (async_p)
- {
- add_file_handler (scb->fd, ser_unix_event, scb);
- }
- else
- {
- delete_file_handler (scb->fd);
- }
-}
-
+\f
void
_initialize_ser_hardwire (void)
{
struct serial_ops *ops = XMALLOC (struct serial_ops);
- memset (ops, sizeof (struct serial_ops), 0);
+ 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
+ /* FIXME: Don't replace this with the equivalent ser_base*() until
the old TERMIOS/SGTTY/... timer code has been flushed. cagney
1999-09-16. */
ops->readchar = hardwire_readchar;
- /* 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->write = hardwire_write;
+ ops->write = ser_base_write;
ops->flush_output = hardwire_flush_output;
ops->flush_input = hardwire_flush_input;
ops->send_break = hardwire_send_break;
ops->setbaudrate = hardwire_setbaudrate;
ops->setstopbits = hardwire_setstopbits;
ops->drain_output = hardwire_drain_output;
- ops->async = ser_unix_async;
+ ops->async = ser_base_async;
+ ops->read_prim = ser_unix_read_prim;
+ ops->write_prim = ser_unix_write_prim;
serial_add_interface (ops);
+
+#ifdef HAVE_TERMIOS
+#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
+#endif
+}
+
+int
+ser_unix_read_prim (struct serial *scb, size_t count)
+{
+ int status;
+
+ while (1)
+ {
+ status = read (scb->fd, scb->buf, count);
+ if (status != -1 || errno != EINTR)
+ break;
+ }
+ return status;
+}
+
+int
+ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
+{
+ /* ??? Historically, GDB has not retried calls to "write" that
+ result in EINTR. */
+ return write (scb->fd, buf, len);
}
projects / deliverable / binutils-gdb.git / blobdiff