[deliverable/binutils-gdb.git] / gdb / ser-unix.c

/* Serial interface for local (hardwired) serial ports on Un*x like systems

   Copyright (C) 1992-2019 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 "defs.h"
#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 "common/gdb_sys_time.h"

#include "gdb_select.h"
#include "gdbcmd.h"
#include "common/filestuff.h"
#include <termios.h>

struct hardwire_ttystate
  {
    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

static int hardwire_open (struct serial *scb, const char *name);
static void hardwire_raw (struct serial *scb);
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);
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 int hardwire_send_break (struct serial *);
static int hardwire_setstopbits (struct serial *, int);

/* Open up a real live device for serial I/O.  */

static int
hardwire_open (struct serial *scb, const char *name)
{
  scb->fd = gdb_open_cloexec (name, O_RDWR, 0);
  if (scb->fd < 0)
    return -1;

  return 0;
}

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;

  fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
		    (int) state->termios.c_iflag,
		    (int) state->termios.c_oflag);
  fprintf_filtered (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).  */
  fprintf_filtered (stream, "c_line = 0x%x.\n", state->termios.c_line);
#endif
  fprintf_filtered (stream, "c_cc: ");
  for (i = 0; i < NCCS; i += 1)
    fprintf_filtered (stream, "0x%x ", state->termios.c_cc[i]);
  fprintf_filtered (stream, "\n");
}

/* Wait for the output to drain away, as opposed to flushing
   (discarding) it.  */

static int
hardwire_drain_output (struct serial *scb)
{
  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 int
hardwire_send_break (struct serial *scb)
{
  return tcsendbreak (scb->fd, 0);
}

static void
hardwire_raw (struct serial *scb)
{
  struct hardwire_ttystate state;

  if (get_tty_state (scb, &state))
    fprintf_unfiltered (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))
    fprintf_unfiltered (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
  {
    -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)
	        {
	          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 (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;

  cfsetospeed (&state.termios, baud_code);
  cfsetispeed (&state.termios, baud_code);

  return set_tty_state (scb, &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 (__FILE__, __LINE__,
			"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;
}
\f
\f

/* 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)
{
  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)
{
  return read (scb->fd, scb->buf, count);
}

int
ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
{
  return write (scb->fd, buf, len);
}
Commit	Line	Data
	1	/* Serial interface for local (hardwired) serial ports on Un*x like systems
	2
	3	Copyright (C) 1992-2019 Free Software Foundation, Inc.
	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 3 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	19
	20	#include "defs.h"
	21	#include "serial.h"
	22	#include "ser-base.h"
	23	#include "ser-unix.h"
	24
	25	#include <fcntl.h>
	26	#include <sys/types.h>
	27	#include "terminal.h"
	28	#include <sys/socket.h>
	29	#include "common/gdb_sys_time.h"
	30
	31	#include "gdb_select.h"
	32	#include "gdbcmd.h"
	33	#include "common/filestuff.h"
	34	#include <termios.h>
	35
	36	struct hardwire_ttystate
	37	{
	38	struct termios termios;
	39	};
	40
	41	#ifdef CRTSCTS
	42	/* Boolean to explicitly enable or disable h/w flow control. */
	43	static int serial_hwflow;
	44	static void
	45	show_serial_hwflow (struct ui_file *file, int from_tty,
	46	struct cmd_list_element c, const char value)
	47	{
	48	fprintf_filtered (file, _("Hardware flow control is %s.\n"), value);
	49	}
	50	#endif
	51
	52	static int hardwire_open (struct serial scb, const char name);
	53	static void hardwire_raw (struct serial *scb);
	54	static int rate_to_code (int rate);
	55	static int hardwire_setbaudrate (struct serial *scb, int rate);
	56	static int hardwire_setparity (struct serial *scb, int parity);
	57	static void hardwire_close (struct serial *scb);
	58	static int get_tty_state (struct serial *scb,
	59	struct hardwire_ttystate * state);
	60	static int set_tty_state (struct serial *scb,
	61	struct hardwire_ttystate * state);
	62	static serial_ttystate hardwire_get_tty_state (struct serial *scb);
	63	static int hardwire_set_tty_state (struct serial *scb, serial_ttystate state);
	64	static void hardwire_print_tty_state (struct serial *, serial_ttystate,
	65	struct ui_file *);
	66	static int hardwire_drain_output (struct serial *);
	67	static int hardwire_flush_output (struct serial *);
	68	static int hardwire_flush_input (struct serial *);
	69	static int hardwire_send_break (struct serial *);
	70	static int hardwire_setstopbits (struct serial *, int);
	71
	72	/* Open up a real live device for serial I/O. */
	73
	74	static int
	75	hardwire_open (struct serial scb, const char name)
	76	{
	77	scb->fd = gdb_open_cloexec (name, O_RDWR, 0);
	78	if (scb->fd < 0)
	79	return -1;
	80
	81	return 0;
	82	}
	83
	84	static int
	85	get_tty_state (struct serial scb, struct hardwire_ttystate state)
	86	{
	87	if (tcgetattr (scb->fd, &state->termios) < 0)
	88	return -1;
	89
	90	return 0;
	91	}
	92
	93	static int
	94	set_tty_state (struct serial scb, struct hardwire_ttystate state)
	95	{
	96	if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
	97	return -1;
	98
	99	return 0;
	100	}
	101
	102	static serial_ttystate
	103	hardwire_get_tty_state (struct serial *scb)
	104	{
	105	struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
	106
	107	if (get_tty_state (scb, state))
	108	{
	109	xfree (state);
	110	return NULL;
	111	}
	112
	113	return (serial_ttystate) state;
	114	}
	115
	116	static serial_ttystate
	117	hardwire_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
	118	{
	119	struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
	120
	121	state = (struct hardwire_ttystate *) ttystate;
	122
	123	return (serial_ttystate) state;
	124	}
	125
	126	static int
	127	hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
	128	{
	129	struct hardwire_ttystate *state;
	130
	131	state = (struct hardwire_ttystate *) ttystate;
	132
	133	return set_tty_state (scb, state);
	134	}
	135
	136	static void
	137	hardwire_print_tty_state (struct serial *scb,
	138	serial_ttystate ttystate,
	139	struct ui_file *stream)
	140	{
	141	struct hardwire_ttystate state = (struct hardwire_ttystate ) ttystate;
	142	int i;
	143
	144	fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
	145	(int) state->termios.c_iflag,
	146	(int) state->termios.c_oflag);
	147	fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n",
	148	(int) state->termios.c_cflag,
	149	(int) state->termios.c_lflag);
	150	#if 0
	151	/* This not in POSIX, and is not really documented by those systems
	152	which have it (at least not Sun). */
	153	fprintf_filtered (stream, "c_line = 0x%x.\n", state->termios.c_line);
	154	#endif
	155	fprintf_filtered (stream, "c_cc: ");
	156	for (i = 0; i < NCCS; i += 1)
	157	fprintf_filtered (stream, "0x%x ", state->termios.c_cc[i]);
	158	fprintf_filtered (stream, "\n");
	159	}
	160
	161	/* Wait for the output to drain away, as opposed to flushing
	162	(discarding) it. */
	163
	164	static int
	165	hardwire_drain_output (struct serial *scb)
	166	{
	167	return tcdrain (scb->fd);
	168	}
	169
	170	static int
	171	hardwire_flush_output (struct serial *scb)
	172	{
	173	return tcflush (scb->fd, TCOFLUSH);
	174	}
	175
	176	static int
	177	hardwire_flush_input (struct serial *scb)
	178	{
	179	ser_base_flush_input (scb);
	180
	181	return tcflush (scb->fd, TCIFLUSH);
	182	}
	183
	184	static int
	185	hardwire_send_break (struct serial *scb)
	186	{
	187	return tcsendbreak (scb->fd, 0);
	188	}
	189
	190	static void
	191	hardwire_raw (struct serial *scb)
	192	{
	193	struct hardwire_ttystate state;
	194
	195	if (get_tty_state (scb, &state))
	196	fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n",
	197	safe_strerror (errno));
	198
	199	state.termios.c_iflag = 0;
	200	state.termios.c_oflag = 0;
	201	state.termios.c_lflag = 0;
	202	state.termios.c_cflag &= ~CSIZE;
	203	state.termios.c_cflag \|= CLOCAL \| CS8;
	204	#ifdef CRTSCTS
	205	/* h/w flow control. */
	206	if (serial_hwflow)
	207	state.termios.c_cflag \|= CRTSCTS;
	208	else
	209	state.termios.c_cflag &= ~CRTSCTS;
	210	#ifdef CRTS_IFLOW
	211	if (serial_hwflow)
	212	state.termios.c_cflag \|= CRTS_IFLOW;
	213	else
	214	state.termios.c_cflag &= ~CRTS_IFLOW;
	215	#endif
	216	#endif
	217	state.termios.c_cc[VMIN] = 0;
	218	state.termios.c_cc[VTIME] = 0;
	219
	220	if (set_tty_state (scb, &state))
	221	fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n",
	222	safe_strerror (errno));
	223	}
	224
	225	#ifndef B19200
	226	#define B19200 EXTA
	227	#endif
	228
	229	#ifndef B38400
	230	#define B38400 EXTB
	231	#endif
	232
	233	/* Translate baud rates from integers to damn B_codes. Unix should
	234	have outgrown this crap years ago, but even POSIX wouldn't buck it. */
	235
	236	static struct
	237	{
	238	int rate;
	239	int code;
	240	}
	241	baudtab[] =
	242	{
	243	{
	244	50, B50
	245	}
	246	,
	247	{
	248	75, B75
	249	}
	250	,
	251	{
	252	110, B110
	253	}
	254	,
	255	{
	256	134, B134
	257	}
	258	,
	259	{
	260	150, B150
	261	}
	262	,
	263	{
	264	200, B200
	265	}
	266	,
	267	{
	268	300, B300
	269	}
	270	,
	271	{
	272	600, B600
	273	}
	274	,
	275	{
	276	1200, B1200
	277	}
	278	,
	279	{
	280	1800, B1800
	281	}
	282	,
	283	{
	284	2400, B2400
	285	}
	286	,
	287	{
	288	4800, B4800
	289	}
	290	,
	291	{
	292	9600, B9600
	293	}
	294	,
	295	{
	296	19200, B19200
	297	}
	298	,
	299	{
	300	38400, B38400
	301	}
	302	,
	303	#ifdef B57600
	304	{
	305	57600, B57600
	306	}
	307	,
	308	#endif
	309	#ifdef B115200
	310	{
	311	115200, B115200
	312	}
	313	,
	314	#endif
	315	#ifdef B230400
	316	{
	317	230400, B230400
	318	}
	319	,
	320	#endif
	321	#ifdef B460800
	322	{
	323	460800, B460800
	324	}
	325	,
	326	#endif
	327	{
	328	-1, -1
	329	}
	330	,
	331	};
	332
	333	static int
	334	rate_to_code (int rate)
	335	{
	336	int i;
	337
	338	for (i = 0; baudtab[i].rate != -1; i++)
	339	{
	340	/* test for perfect macth. */
	341	if (rate == baudtab[i].rate)
	342	return baudtab[i].code;
	343	else
	344	{
	345	/* check if it is in between valid values. */
	346	if (rate < baudtab[i].rate)
	347	{
	348	if (i)
	349	{
	350	warning (_("Invalid baud rate %d. "
	351	"Closest values are %d and %d."),
	352	rate, baudtab[i - 1].rate, baudtab[i].rate);
	353	}
	354	else
	355	{
	356	warning (_("Invalid baud rate %d. Minimum value is %d."),
	357	rate, baudtab[0].rate);
	358	}
	359	return -1;
	360	}
	361	}
	362	}
	363
	364	/* The requested speed was too large. */
	365	warning (_("Invalid baud rate %d. Maximum value is %d."),
	366	rate, baudtab[i - 1].rate);
	367	return -1;
	368	}
	369
	370	static int
	371	hardwire_setbaudrate (struct serial *scb, int rate)
	372	{
	373	struct hardwire_ttystate state;
	374	int baud_code = rate_to_code (rate);
	375
	376	if (baud_code < 0)
	377	{
	378	/* The baud rate was not valid.
	379	A warning has already been issued. */
	380	errno = EINVAL;
	381	return -1;
	382	}
	383
	384	if (get_tty_state (scb, &state))
	385	return -1;
	386
	387	cfsetospeed (&state.termios, baud_code);
	388	cfsetispeed (&state.termios, baud_code);
	389
	390	return set_tty_state (scb, &state);
	391	}
	392
	393	static int
	394	hardwire_setstopbits (struct serial *scb, int num)
	395	{
	396	struct hardwire_ttystate state;
	397	int newbit;
	398
	399	if (get_tty_state (scb, &state))
	400	return -1;
	401
	402	switch (num)
	403	{
	404	case SERIAL_1_STOPBITS:
	405	newbit = 0;
	406	break;
	407	case SERIAL_1_AND_A_HALF_STOPBITS:
	408	case SERIAL_2_STOPBITS:
	409	newbit = 1;
	410	break;
	411	default:
	412	return 1;
	413	}
	414
	415	if (!newbit)
	416	state.termios.c_cflag &= ~CSTOPB;
	417	else
	418	state.termios.c_cflag \|= CSTOPB; /* two bits */
	419
	420	return set_tty_state (scb, &state);
	421	}
	422
	423	/* Implement the "setparity" serial_ops callback. */
	424
	425	static int
	426	hardwire_setparity (struct serial *scb, int parity)
	427	{
	428	struct hardwire_ttystate state;
	429	int newparity = 0;
	430
	431	if (get_tty_state (scb, &state))
	432	return -1;
	433
	434	switch (parity)
	435	{
	436	case GDBPARITY_NONE:
	437	newparity = 0;
	438	break;
	439	case GDBPARITY_ODD:
	440	newparity = PARENB \| PARODD;
	441	break;
	442	case GDBPARITY_EVEN:
	443	newparity = PARENB;
	444	break;
	445	default:
	446	internal_warning (__FILE__, __LINE__,
	447	"Incorrect parity value: %d", parity);
	448	return -1;
	449	}
	450
	451	state.termios.c_cflag &= ~(PARENB \| PARODD);
	452	state.termios.c_cflag \|= newparity;
	453
	454	return set_tty_state (scb, &state);
	455	}
	456
	457
	458	static void
	459	hardwire_close (struct serial *scb)
	460	{
	461	if (scb->fd < 0)
	462	return;
	463
	464	close (scb->fd);
	465	scb->fd = -1;
	466	}
	467	\f
	468	\f
	469
	470	/* The hardwire ops. */
	471
	472	static const struct serial_ops hardwire_ops =
	473	{
	474	"hardwire",
	475	hardwire_open,
	476	hardwire_close,
	477	NULL,
	478	ser_base_readchar,
	479	ser_base_write,
	480	hardwire_flush_output,
	481	hardwire_flush_input,
	482	hardwire_send_break,
	483	hardwire_raw,
	484	hardwire_get_tty_state,
	485	hardwire_copy_tty_state,
	486	hardwire_set_tty_state,
	487	hardwire_print_tty_state,
	488	hardwire_setbaudrate,
	489	hardwire_setstopbits,
	490	hardwire_setparity,
	491	hardwire_drain_output,
	492	ser_base_async,
	493	ser_unix_read_prim,
	494	ser_unix_write_prim
	495	};
	496
	497	void
	498	_initialize_ser_hardwire (void)
	499	{
	500	serial_add_interface (&hardwire_ops);
	501
	502	#ifdef CRTSCTS
	503	add_setshow_boolean_cmd ("remoteflow", no_class,
	504	&serial_hwflow, _("\
	505	Set use of hardware flow control for remote serial I/O."), _("\
	506	Show use of hardware flow control for remote serial I/O."), _("\
	507	Enable or disable hardware flow control (RTS/CTS) on the serial port\n\
	508	when debugging using remote targets."),
	509	NULL,
	510	show_serial_hwflow,
	511	&setlist, &showlist);
	512	#endif
	513	}
	514
	515	int
	516	ser_unix_read_prim (struct serial *scb, size_t count)
	517	{
	518	return read (scb->fd, scb->buf, count);
	519	}
	520
	521	int
	522	ser_unix_write_prim (struct serial scb, const void buf, size_t len)
	523	{
	524	return write (scb->fd, buf, len);
	525	}