old-cross-binutils/gdb/ser-unix.c

1364 lines
31 KiB
C
Raw Normal View History

/* Serial interface for local (hardwired) serial ports on Un*x like systems
2001-03-06 08:22:02 +00:00
Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
Free Software Foundation, Inc.
1999-07-07 20:19:36 +00:00
This file is part of GDB.
1999-07-07 20:19:36 +00:00
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
(at your option) any later version.
1999-07-07 20:19:36 +00:00
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
1999-07-07 20:19:36 +00:00
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. */
#include "defs.h"
#include "serial.h"
1999-09-22 03:28:34 +00:00
#include "ser-unix.h"
#include <fcntl.h>
#include <sys/types.h>
#include "terminal.h"
1999-09-22 03:28:34 +00:00
#include <sys/socket.h>
#include <sys/time.h>
#include "gdb_string.h"
#include "event-loop.h"
#ifdef HAVE_TERMIOS
struct hardwire_ttystate
1999-07-07 20:19:36 +00:00
{
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
1999-07-07 20:19:36 +00:00
{
struct termio termio;
};
#endif /* termio */
#ifdef HAVE_SGTTY
struct hardwire_ttystate
1999-07-07 20:19:36 +00:00
{
struct sgttyb sgttyb;
struct tchars tc;
struct ltchars ltc;
/* Line discipline flags. */
int lmode;
};
#endif /* sgtty */
2001-07-11 17:52:32 +00:00
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));
1999-09-22 03:28:34 +00:00
static int rate_to_code (int rate);
2001-07-11 17:52:32 +00:00
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);
static int do_unix_readchar (struct serial *scb, int timeout);
1999-10-05 23:13:56 +00:00
static timer_handler_func push_event;
static handler_func fd_event;
2001-07-11 17:52:32 +00:00
static void reschedule (struct serial *scb);
1999-10-05 23:13:56 +00:00
1999-09-22 03:28:34 +00:00
void _initialize_ser_hardwire (void);
extern int (*ui_loop_hook) (int);
/* Open up a real live device for serial I/O */
static int
2001-07-11 17:52:32 +00:00
hardwire_open (struct serial *scb, const char *name)
{
scb->fd = open (name, O_RDWR);
if (scb->fd < 0)
return -1;
return 0;
}
static int
2001-07-11 17:52:32 +00:00
get_tty_state (struct serial *scb, struct hardwire_ttystate *state)
{
#ifdef HAVE_TERMIOS
1999-07-07 20:19:36 +00:00
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
2001-07-11 17:52:32 +00:00
set_tty_state (struct serial *scb, struct hardwire_ttystate *state)
{
#ifdef HAVE_TERMIOS
1999-07-07 20:19:36 +00:00
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
2001-07-11 17:52:32 +00:00
hardwire_get_tty_state (struct serial *scb)
{
struct hardwire_ttystate *state;
1999-07-07 20:19:36 +00:00
state = (struct hardwire_ttystate *) xmalloc (sizeof *state);
1999-07-07 20:19:36 +00:00
if (get_tty_state (scb, state))
return NULL;
1999-07-07 20:19:36 +00:00
return (serial_ttystate) state;
}
static int
2001-07-11 17:52:32 +00:00
hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
{
struct hardwire_ttystate *state;
1999-07-07 20:19:36 +00:00
state = (struct hardwire_ttystate *) ttystate;
1999-07-07 20:19:36 +00:00
return set_tty_state (scb, state);
}
static int
2001-07-11 17:52:32 +00:00
hardwire_noflush_set_tty_state (struct serial *scb,
1999-09-22 03:28:34 +00:00
serial_ttystate new_ttystate,
serial_ttystate old_ttystate)
{
struct hardwire_ttystate new_state;
#ifdef HAVE_SGTTY
struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
#endif
1999-07-07 20:19:36 +00:00
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;
/* 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
return set_tty_state (scb, &new_state);
}
static void
2001-07-11 17:52:32 +00:00
hardwire_print_tty_state (struct serial *scb,
1999-09-22 03:28:34 +00:00
serial_ttystate ttystate,
2000-02-02 00:21:19 +00:00
struct ui_file *stream)
{
struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
int i;
#ifdef HAVE_TERMIOS
1999-09-22 03:28:34 +00:00
fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
1999-10-05 23:13:56 +00:00
(int) state->termios.c_iflag,
(int) state->termios.c_oflag);
1999-09-22 03:28:34 +00:00
fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n",
1999-10-05 23:13:56 +00:00
(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). */
1999-09-22 03:28:34 +00:00
fprintf_filtered (stream, "c_line = 0x%x.\n", state->termios.c_line);
#endif
1999-09-22 03:28:34 +00:00
fprintf_filtered (stream, "c_cc: ");
for (i = 0; i < NCCS; i += 1)
1999-09-22 03:28:34 +00:00
fprintf_filtered (stream, "0x%x ", state->termios.c_cc[i]);
fprintf_filtered (stream, "\n");
#endif
#ifdef HAVE_TERMIO
1999-09-22 03:28:34 +00:00
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)
1999-09-22 03:28:34 +00:00
fprintf_filtered (stream, "0x%x ", state->termio.c_cc[i]);
fprintf_filtered (stream, "\n");
#endif
#ifdef HAVE_SGTTY
1999-09-22 03:28:34 +00:00
fprintf_filtered (stream, "sgttyb.sg_flags = 0x%x.\n",
state->sgttyb.sg_flags);
1999-09-22 03:28:34 +00:00
fprintf_filtered (stream, "tchars: ");
1999-07-07 20:19:36 +00:00
for (i = 0; i < (int) sizeof (struct tchars); i++)
1999-09-22 03:28:34 +00:00
fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->tc)[i]);
fprintf_filtered (stream, "\n");
1999-09-22 03:28:34 +00:00
fprintf_filtered (stream, "ltchars: ");
1999-07-07 20:19:36 +00:00
for (i = 0; i < (int) sizeof (struct ltchars); i++)
1999-09-22 03:28:34 +00:00
fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->ltc)[i]);
fprintf_filtered (stream, "\n");
1999-09-22 03:28:34 +00:00
fprintf_filtered (stream, "lmode: 0x%x\n", state->lmode);
#endif
}
/* Wait for the output to drain away, as opposed to flushing (discarding) it */
static int
2001-07-11 17:52:32 +00:00
hardwire_drain_output (struct serial *scb)
{
#ifdef HAVE_TERMIOS
return tcdrain (scb->fd);
#endif
#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));
}
}
1999-07-07 20:19:36 +00:00
#endif
}
static int
2001-07-11 17:52:32 +00:00
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);
1999-07-07 20:19:36 +00:00
#endif
}
static int
2001-07-11 17:52:32 +00:00
hardwire_flush_input (struct serial *scb)
{
1999-10-05 23:13:56 +00:00
ser_unix_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);
1999-07-07 20:19:36 +00:00
#endif
}
static int
2001-07-11 17:52:32 +00:00
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;
}
1999-07-07 20:19:36 +00:00
#endif
}
static void
2001-07-11 17:52:32 +00:00
hardwire_raw (struct serial *scb)
{
struct hardwire_ttystate state;
1999-07-07 20:19:36 +00:00
if (get_tty_state (scb, &state))
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;
1999-07-07 20:19:36 +00:00
state.termios.c_cflag &= ~(CSIZE | PARENB);
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;
1999-07-07 20:19:36 +00:00
state.termio.c_cflag &= ~(CSIZE | PARENB);
state.termio.c_cflag |= CLOCAL | CS8;
state.termio.c_cc[VMIN] = 0;
state.termio.c_cc[VTIME] = 0;
#endif
#ifdef HAVE_SGTTY
state.sgttyb.sg_flags |= RAW | ANYP;
state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
#endif
scb->current_timeout = 0;
if (set_tty_state (scb, &state))
1999-07-07 20:19:36 +00:00
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().
*/
1999-10-05 23:13:56 +00:00
/* 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. */
1999-09-22 03:28:34 +00:00
static int
2001-07-11 17:52:32 +00:00
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;
}
1999-07-07 20:19:36 +00:00
#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;
1999-07-07 20:19:36 +00:00
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))
1999-07-07 20:19:36 +00:00
fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
return 0;
}
1999-07-07 20:19:36 +00:00
#endif /* HAVE_TERMIO || HAVE_TERMIOS */
}
/* 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). */
1999-09-22 03:28:34 +00:00
/* 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
2001-07-11 17:52:32 +00:00
do_hardwire_readchar (struct serial *scb, int timeout)
{
1999-04-26 18:34:20 +00:00
int status, delta;
int detach = 0;
if (timeout > 0)
timeout++;
1999-04-26 18:34:20 +00:00
/* 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. */
1999-07-07 20:19:36 +00:00
1999-04-26 18:34:20 +00:00
delta = (timeout == 0 ? 0 : 1);
while (1)
{
1999-04-26 18:34:20 +00:00
/* 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)
1999-07-07 20:19:36 +00:00
detach = ui_loop_hook (0);
1999-04-26 18:34:20 +00:00
if (detach)
return SERIAL_TIMEOUT;
scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta);
status = wait_for (scb, delta);
if (status < 0)
return status;
1999-10-05 23:13:56 +00:00
status = read (scb->fd, scb->buf, BUFSIZ);
1999-10-05 23:13:56 +00:00
if (status <= 0)
{
1999-10-05 23:13:56 +00:00
if (status == 0)
{
/* Zero characters means timeout (it could also be EOF, but
1999-07-07 20:19:36 +00:00
we don't (yet at least) distinguish). */
if (scb->timeout_remaining > 0)
{
timeout = scb->timeout_remaining;
continue;
}
1999-07-07 20:19:36 +00:00
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 */
}
1999-10-05 23:13:56 +00:00
scb->bufcnt = status;
scb->bufcnt--;
scb->bufp = scb->buf;
return *scb->bufp++;
}
}
1999-10-05 23:13:56 +00:00
static int
2001-07-11 17:52:32 +00:00
hardwire_readchar (struct serial *scb, int timeout)
1999-10-05 23:13:56 +00:00
{
return generic_readchar (scb, timeout, do_hardwire_readchar);
}
#ifndef B19200
#define B19200 EXTA
#endif
#ifndef B38400
#define B38400 EXTB
#endif
/* Translate baud rates from integers to damn B_codes. Unix should
have outgrown this crap years ago, but even POSIX wouldn't buck it. */
static struct
{
int rate;
int code;
}
baudtab[] =
{
1999-07-07 20:19:36 +00:00
{
50, B50
}
,
{
75, B75
}
,
{
110, B110
}
,
{
134, B134
}
,
{
150, B150
}
,
{
200, B200
}
,
{
300, B300
}
,
{
600, B600
}
,
{
1200, B1200
}
,
{
1800, B1800
}
,
{
2400, B2400
}
,
{
4800, B4800
}
,
{
9600, B9600
}
,
{
19200, B19200
}
,
{
38400, B38400
}
,
#ifdef B57600
1999-07-07 20:19:36 +00:00
{
57600, B57600
}
,
#endif
#ifdef B115200
1999-07-07 20:19:36 +00:00
{
115200, B115200
}
,
#endif
#ifdef B230400
1999-07-07 20:19:36 +00:00
{
230400, B230400
}
,
#endif
#ifdef B460800
1999-07-07 20:19:36 +00:00
{
460800, B460800
}
,
#endif
1999-07-07 20:19:36 +00:00
{
-1, -1
}
,
};
1999-07-07 20:19:36 +00:00
static int
1999-09-22 03:28:34 +00:00
rate_to_code (int rate)
{
int i;
for (i = 0; baudtab[i].rate != -1; i++)
{
/* 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
2001-07-11 17:52:32 +00:00
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;
}
1999-07-07 20:19:36 +00:00
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);
}
static int
2001-07-11 17:52:32 +00:00
hardwire_setstopbits (struct serial *scb, int num)
{
struct hardwire_ttystate state;
int newbit;
1999-07-07 20:19:36 +00:00
if (get_tty_state (scb, &state))
return -1;
switch (num)
{
case SERIAL_1_STOPBITS:
newbit = 0;
break;
case SERIAL_1_AND_A_HALF_STOPBITS:
case SERIAL_2_STOPBITS:
newbit = 1;
break;
default:
return 1;
}
#ifdef HAVE_TERMIOS
if (!newbit)
state.termios.c_cflag &= ~CSTOPB;
else
1999-07-07 20:19:36 +00:00
state.termios.c_cflag |= CSTOPB; /* two bits */
#endif
#ifdef HAVE_TERMIO
if (!newbit)
state.termio.c_cflag &= ~CSTOPB;
else
1999-07-07 20:19:36 +00:00
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
2001-07-11 17:52:32 +00:00
hardwire_close (struct serial *scb)
{
if (scb->fd < 0)
return;
1999-07-07 20:19:36 +00:00
close (scb->fd);
scb->fd = -1;
}
1999-09-22 03:28:34 +00:00
/* Generic operations used by all UNIX/FD based serial interfaces. */
serial_ttystate
2001-07-11 17:52:32 +00:00
ser_unix_nop_get_tty_state (struct serial *scb)
1999-09-22 03:28:34 +00:00
{
/* allocate a dummy */
return (serial_ttystate) XMALLOC (int);
}
int
2001-07-11 17:52:32 +00:00
ser_unix_nop_set_tty_state (struct serial *scb, serial_ttystate ttystate)
1999-09-22 03:28:34 +00:00
{
return 0;
}
void
2001-07-11 17:52:32 +00:00
ser_unix_nop_raw (struct serial *scb)
1999-09-22 03:28:34 +00:00
{
return; /* Always in raw mode */
}
/* Wait for input on scb, with timeout seconds. Returns 0 on success,
otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
int
2001-07-11 17:52:32 +00:00
ser_unix_wait_for (struct serial *scb, int timeout)
1999-09-22 03:28:34 +00:00
{
while (1)
{
int numfds;
struct timeval tv;
fd_set readfds, exceptfds;
1999-09-22 03:28:34 +00:00
/* 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. */
1999-09-22 03:28:34 +00:00
tv.tv_sec = timeout;
tv.tv_usec = 0;
1999-09-22 03:28:34 +00:00
FD_ZERO (&readfds);
FD_ZERO (&exceptfds);
FD_SET (scb->fd, &readfds);
FD_SET (scb->fd, &exceptfds);
1999-09-22 03:28:34 +00:00
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). */
1999-10-05 23:13:56 +00:00
static int
2001-07-11 17:52:32 +00:00
do_unix_readchar (struct serial *scb, int timeout)
1999-09-22 03:28:34 +00:00
{
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. */
1999-09-22 03:28:34 +00:00
delta = (timeout == 0 ? 0 : 1);
1999-09-22 03:28:34 +00:00
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);
if (timeout > 0)
timeout -= delta;
1999-09-22 03:28:34 +00:00
/* If we got a character or an error back from wait_for, then we can
break from the loop before the timeout is completed. */
1999-09-22 03:28:34 +00:00
if (status != SERIAL_TIMEOUT)
{
break;
}
1999-09-22 03:28:34 +00:00
/* If we have exhausted the original timeout, then generate
a SERIAL_TIMEOUT, and pass it out of the loop. */
1999-09-22 03:28:34 +00:00
else if (timeout == 0)
{
status = SERIAL_TIMEOUT;
break;
1999-09-22 03:28:34 +00:00
}
}
1999-09-22 03:28:34 +00:00
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 */
1999-09-22 03:28:34 +00:00
}
scb->bufcnt = status;
scb->bufcnt--;
scb->bufp = scb->buf;
return *scb->bufp++;
1999-09-22 03:28:34 +00:00
}
1999-10-05 23:13:56 +00:00
/* 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.
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 int
2001-07-11 17:52:32 +00:00
generic_readchar (struct serial *scb, int timeout,
int (do_readchar) (struct serial *scb, int timeout))
1999-10-05 23:13:56 +00:00
{
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;
}
int
2001-07-11 17:52:32 +00:00
ser_unix_readchar (struct serial *scb, int timeout)
1999-10-05 23:13:56 +00:00
{
return generic_readchar (scb, timeout, do_unix_readchar);
}
1999-09-22 03:28:34 +00:00
int
2001-07-11 17:52:32 +00:00
ser_unix_nop_noflush_set_tty_state (struct serial *scb,
1999-09-22 03:28:34 +00:00
serial_ttystate new_ttystate,
serial_ttystate old_ttystate)
{
return 0;
}
void
2001-07-11 17:52:32 +00:00
ser_unix_nop_print_tty_state (struct serial *scb,
1999-09-22 03:28:34 +00:00
serial_ttystate ttystate,
2000-02-02 00:21:19 +00:00
struct ui_file *stream)
1999-09-22 03:28:34 +00:00
{
/* Nothing to print. */
return;
}
int
2001-07-11 17:52:32 +00:00
ser_unix_nop_setbaudrate (struct serial *scb, int rate)
1999-09-22 03:28:34 +00:00
{
return 0; /* Never fails! */
}
int
2001-07-11 17:52:32 +00:00
ser_unix_nop_setstopbits (struct serial *scb, int num)
1999-09-22 03:28:34 +00:00
{
return 0; /* Never fails! */
}
int
2001-07-11 17:52:32 +00:00
ser_unix_write (struct serial *scb, const char *str, int len)
1999-09-22 03:28:34 +00:00
{
int cc;
while (len > 0)
{
cc = write (scb->fd, str, len);
if (cc < 0)
return 1;
len -= cc;
str += cc;
}
return 0;
}
int
2001-07-11 17:52:32 +00:00
ser_unix_nop_flush_output (struct serial *scb)
1999-09-22 03:28:34 +00:00
{
return 0;
}
int
2001-07-11 17:52:32 +00:00
ser_unix_flush_input (struct serial *scb)
1999-09-22 03:28:34 +00:00
{
1999-10-05 23:13:56 +00:00
if (scb->bufcnt >= 0)
{
scb->bufcnt = 0;
scb->bufp = scb->buf;
return 0;
}
else
return SERIAL_ERROR;
1999-09-22 03:28:34 +00:00
}
int
2001-07-11 17:52:32 +00:00
ser_unix_nop_send_break (struct serial *scb)
1999-09-22 03:28:34 +00:00
{
return 0;
}
int
2001-07-11 17:52:32 +00:00
ser_unix_nop_drain_output (struct serial *scb)
1999-09-22 03:28:34 +00:00
{
return 0;
}
1999-10-05 23:13:56 +00:00
/* Event handling for ASYNC serial code.
At any time the SERIAL device either: has an empty FIFO and is
waiting on a FD event; or has a non-empty FIFO/error condition and
is constantly scheduling timer events.
ASYNC only stops pestering its client when it is de-async'ed or it
is told to go away. */
/* Value of scb->async_state: */
enum {
/* >= 0 (TIMER_SCHEDULED) */
/* The ID of the currently scheduled timer event. This state is
rarely encountered. Timer events are one-off so as soon as the
event is delivered the state is shanged to NOTHING_SCHEDULED. */
FD_SCHEDULED = -1,
/* The fd_event() handler is scheduled. It is called when ever the
file descriptor becomes ready. */
NOTHING_SCHEDULED = -2
/* Either no task is scheduled (just going into ASYNC mode) or a
timer event has just gone off and the current state has been
forced into nothing scheduled. */
};
/* Identify and schedule the next ASYNC task based on scb->async_state
and scb->buf* (the input FIFO). A state machine is used to avoid
the need to make redundant calls into the event-loop - the next
scheduled task is only changed when needed. */
1999-09-22 03:28:34 +00:00
static void
2001-07-11 17:52:32 +00:00
reschedule (struct serial *scb)
1999-10-05 23:13:56 +00:00
{
if (serial_is_async_p (scb))
1999-10-05 23:13:56 +00:00
{
int next_state;
switch (scb->async_state)
{
case FD_SCHEDULED:
if (scb->bufcnt == 0)
next_state = FD_SCHEDULED;
else
{
delete_file_handler (scb->fd);
next_state = create_timer (0, push_event, scb);
}
break;
case NOTHING_SCHEDULED:
if (scb->bufcnt == 0)
{
add_file_handler (scb->fd, fd_event, scb);
next_state = FD_SCHEDULED;
}
else
{
next_state = create_timer (0, push_event, scb);
}
break;
default: /* TIMER SCHEDULED */
if (scb->bufcnt == 0)
{
delete_timer (scb->async_state);
add_file_handler (scb->fd, fd_event, scb);
next_state = FD_SCHEDULED;
}
else
next_state = scb->async_state;
break;
}
if (serial_debug_p (scb))
1999-10-05 23:13:56 +00:00
{
switch (next_state)
{
case FD_SCHEDULED:
if (scb->async_state != FD_SCHEDULED)
fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n",
scb->fd);
break;
default: /* TIMER SCHEDULED */
if (scb->async_state == FD_SCHEDULED)
fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n",
scb->fd);
break;
}
}
scb->async_state = next_state;
}
}
/* FD_EVENT: This is scheduled when the input FIFO is empty (and there
is no pending error). As soon as data arrives, it is read into the
input FIFO and the client notified. The client should then drain
the FIFO using readchar(). If the FIFO isn't immediatly emptied,
push_event() is used to nag the client until it is. */
static void
fd_event (int error, void *context)
{
2001-07-11 17:52:32 +00:00
struct serial *scb = context;
1999-10-05 23:13:56 +00:00
if (error != 0)
{
scb->bufcnt = SERIAL_ERROR;
}
else if (scb->bufcnt == 0)
{
/* Prime the input FIFO. The readchar() function is used to
pull characters out of the buffer. See also
generic_readchar(). */
int nr;
do
{
nr = read (scb->fd, scb->buf, BUFSIZ);
}
while (nr == -1 && errno == EINTR);
if (nr == 0)
{
scb->bufcnt = SERIAL_EOF;
}
else if (nr > 0)
{
scb->bufcnt = nr;
scb->bufp = scb->buf;
}
else
{
scb->bufcnt = SERIAL_ERROR;
}
}
scb->async_handler (scb, scb->async_context);
reschedule (scb);
}
/* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
error). Nag the client until all the data has been read. In the
case of errors, the client will need to close or de-async the
device before naging stops. */
static void
push_event (void *context)
1999-09-22 03:28:34 +00:00
{
2001-07-11 17:52:32 +00:00
struct serial *scb = context;
1999-10-05 23:13:56 +00:00
scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */
scb->async_handler (scb, scb->async_context);
/* re-schedule */
reschedule (scb);
1999-09-22 03:28:34 +00:00
}
1999-10-05 23:13:56 +00:00
/* Put the SERIAL device into/out-of ASYNC mode. */
1999-09-22 03:28:34 +00:00
void
2001-07-11 17:52:32 +00:00
ser_unix_async (struct serial *scb,
1999-09-22 03:28:34 +00:00
int async_p)
{
if (async_p)
{
1999-10-05 23:13:56 +00:00
/* Force a re-schedule. */
scb->async_state = NOTHING_SCHEDULED;
if (serial_debug_p (scb))
1999-10-05 23:13:56 +00:00
fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
scb->fd);
reschedule (scb);
1999-09-22 03:28:34 +00:00
}
else
{
if (serial_debug_p (scb))
1999-10-05 23:13:56 +00:00
fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
scb->fd);
/* De-schedule whatever tasks are currently scheduled. */
1999-10-05 23:13:56 +00:00
switch (scb->async_state)
{
case FD_SCHEDULED:
delete_file_handler (scb->fd);
break;
NOTHING_SCHEDULED:
break;
default: /* TIMER SCHEDULED */
delete_timer (scb->async_state);
break;
}
1999-09-22 03:28:34 +00:00
}
}
void
1999-09-22 03:28:34 +00:00
_initialize_ser_hardwire (void)
{
1999-09-22 03:28:34 +00:00
struct serial_ops *ops = XMALLOC (struct serial_ops);
memset (ops, 0, sizeof (struct serial_ops));
1999-09-22 03:28:34 +00:00
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;
1999-10-05 23:13:56 +00:00
ops->write = ser_unix_write;
1999-09-22 03:28:34 +00:00
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);
}