blob: 02845aa938b0f3974dd6fc5d7f4cc5138ac96be4 [file] [log] [blame]
/* Serial interface for local (hardwired) serial ports on Un*x like systems
Copyright (C) 1992-2024 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 3 of the License, or
(at your option) any later version.
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.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "serial.h"
#include "ser-base.h"
#include "ser-unix.h"
#include <fcntl.h>
#include <sys/types.h>
#include "terminal.h"
#include <sys/socket.h>
#include "gdbsupport/gdb_sys_time.h"
#include "gdbsupport/gdb_select.h"
#include "cli/cli-cmds.h"
#include "gdbsupport/filestuff.h"
#include <termios.h>
#include "gdbsupport/scoped_ignore_sigttou.h"
struct hardwire_ttystate
{
struct termios termios;
};
#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)
{
gdb_printf (file, _("Hardware flow control is %s.\n"), value);
}
#endif
static void hardwire_raw (struct serial *scb);
static int rate_to_code (int rate);
static void 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);
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 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 void hardwire_send_break (struct serial *);
static int hardwire_setstopbits (struct serial *, int);
/* Open up a real live device for serial I/O. */
static void
hardwire_open (struct serial *scb, const char *name)
{
scb->fd = gdb_open_cloexec (name, O_RDWR, 0).release ();
if (scb->fd < 0)
perror_with_name ("could not open device");
}
static int
get_tty_state (struct serial *scb, struct hardwire_ttystate *state)
{
if (tcgetattr (scb->fd, &state->termios) < 0)
return -1;
return 0;
}
static int
set_tty_state (struct serial *scb, struct hardwire_ttystate *state)
{
if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
return -1;
return 0;
}
static serial_ttystate
hardwire_get_tty_state (struct serial *scb)
{
struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
if (get_tty_state (scb, state))
{
xfree (state);
return NULL;
}
return (serial_ttystate) state;
}
static serial_ttystate
hardwire_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
{
struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
*state = *(struct hardwire_ttystate *) ttystate;
return (serial_ttystate) state;
}
static int
hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
{
struct hardwire_ttystate *state;
state = (struct hardwire_ttystate *) ttystate;
return set_tty_state (scb, state);
}
static void
hardwire_print_tty_state (struct serial *scb,
serial_ttystate ttystate,
struct ui_file *stream)
{
struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
int i;
gdb_printf (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
(int) state->termios.c_iflag,
(int) state->termios.c_oflag);
gdb_printf (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n",
(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). */
gdb_printf (stream, "c_line = 0x%x.\n", state->termios.c_line);
#endif
gdb_printf (stream, "c_cc: ");
for (i = 0; i < NCCS; i += 1)
gdb_printf (stream, "0x%x ", state->termios.c_cc[i]);
gdb_printf (stream, "\n");
}
/* Wait for the output to drain away, as opposed to flushing
(discarding) it. */
static int
hardwire_drain_output (struct serial *scb)
{
/* Ignore SIGTTOU which may occur during the drain. */
scoped_ignore_sigttou ignore_sigttou;
return tcdrain (scb->fd);
}
static int
hardwire_flush_output (struct serial *scb)
{
return tcflush (scb->fd, TCOFLUSH);
}
static int
hardwire_flush_input (struct serial *scb)
{
ser_base_flush_input (scb);
return tcflush (scb->fd, TCIFLUSH);
}
static void
hardwire_send_break (struct serial *scb)
{
if (tcsendbreak (scb->fd, 0) == -1)
perror_with_name ("sending break");
}
static void
hardwire_raw (struct serial *scb)
{
struct hardwire_ttystate state;
if (get_tty_state (scb, &state))
gdb_printf (gdb_stderr, "get_tty_state failed: %s\n",
safe_strerror (errno));
state.termios.c_iflag = 0;
state.termios.c_oflag = 0;
state.termios.c_lflag = 0;
state.termios.c_cflag &= ~CSIZE;
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;
if (set_tty_state (scb, &state))
gdb_printf (gdb_stderr, "set_tty_state failed: %s\n",
safe_strerror (errno));
}
#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[] =
{
{
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
{
57600, B57600
}
,
#endif
#ifdef B115200
{
115200, B115200
}
,
#endif
#ifdef B230400
{
230400, B230400
}
,
#endif
#ifdef B460800
{
460800, B460800
}
,
#endif
#ifdef B500000
{
500000, B500000
}
,
#endif
#ifdef B576000
{
576000, B576000
}
,
#endif
#ifdef B921600
{
921600, B921600
}
,
#endif
#ifdef B1000000
{
1000000, B1000000
}
,
#endif
#ifdef B1152000
{
1152000, B1152000
}
,
#endif
#ifdef B1500000
{
1500000, B1500000
}
,
#endif
#ifdef B2000000
{
2000000, B2000000
}
,
#endif
#ifdef B2500000
{
2500000, B2500000
}
,
#endif
#ifdef B3000000
{
3000000, B3000000
}
,
#endif
#ifdef B3500000
{
3500000, B3500000
}
,
#endif
#ifdef B4000000
{
4000000, B4000000
}
,
#endif
{
-1, -1
}
,
};
static int
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)
{
error (_("Invalid baud rate %d. "
"Closest values are %d and %d."),
rate, baudtab[i - 1].rate, baudtab[i].rate);
}
else
{
error (_("Invalid baud rate %d. Minimum value is %d."),
rate, baudtab[0].rate);
}
}
}
}
/* The requested speed was too large. */
error (_("Invalid baud rate %d. Maximum value is %d."),
rate, baudtab[i - 1].rate);
}
static void
hardwire_setbaudrate (struct serial *scb, int rate)
{
struct hardwire_ttystate state;
int baud_code = rate_to_code (rate);
if (get_tty_state (scb, &state))
perror_with_name ("could not get tty state");
cfsetospeed (&state.termios, baud_code);
cfsetispeed (&state.termios, baud_code);
if (set_tty_state (scb, &state))
perror_with_name ("could not set tty state");
}
static int
hardwire_setstopbits (struct serial *scb, int num)
{
struct hardwire_ttystate state;
int newbit;
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;
}
if (!newbit)
state.termios.c_cflag &= ~CSTOPB;
else
state.termios.c_cflag |= CSTOPB; /* two bits */
return set_tty_state (scb, &state);
}
/* Implement the "setparity" serial_ops callback. */
static int
hardwire_setparity (struct serial *scb, int parity)
{
struct hardwire_ttystate state;
int newparity = 0;
if (get_tty_state (scb, &state))
return -1;
switch (parity)
{
case GDBPARITY_NONE:
newparity = 0;
break;
case GDBPARITY_ODD:
newparity = PARENB | PARODD;
break;
case GDBPARITY_EVEN:
newparity = PARENB;
break;
default:
internal_warning ("Incorrect parity value: %d", parity);
return -1;
}
state.termios.c_cflag &= ~(PARENB | PARODD);
state.termios.c_cflag |= newparity;
return set_tty_state (scb, &state);
}
static void
hardwire_close (struct serial *scb)
{
if (scb->fd < 0)
return;
close (scb->fd);
scb->fd = -1;
}
/* The hardwire ops. */
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
};
void _initialize_ser_hardwire ();
void
_initialize_ser_hardwire ()
{
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_read_prim (struct serial *scb, size_t count)
{
int result = read (scb->fd, scb->buf, count);
if (result == -1 && errno != EINTR)
perror_with_name ("error while reading");
return result;
}
int
ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
{
int result = write (scb->fd, buf, len);
if (result == -1 && errno != EINTR)
perror_with_name ("error while writing");
return result;
}