gdb/ser-unix.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

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

  3.    Copyright (C) 1992-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. #include "defs.h"
  21. #include "serial.h"
  22. #include "ser-base.h"
  23. #include "ser-unix.h"

  25. #include <fcntl.h>
  26. #include <sys/types.h>
  27. #include "terminal.h"
  28. #include <sys/socket.h>
  29. #include <sys/time.h>

  31. #include "gdb_select.h"
  32. #include "gdbcmd.h"
  33. #include "filestuff.h"

  35. #ifdef HAVE_TERMIOS

  37. ‌struct hardwire_ttystate
  38.   {
  39.     struct termios termios;
  40.   };

  42. #ifdef CRTSCTS
  43. /* Boolean to explicitly enable or disable h/w flow control.  */
  44. ‌static int serial_hwflow;
  45. static void
  46. ‌show_serial_hwflow (struct ui_file *file, int from_tty,
  47.                     struct cmd_list_element *c, const char *value)
  48. {
  49.   fprintf_filtered (file, _("Hardware flow control is %s.\n"), value);
  50. }
  51. #endif

  53. #endif /* termios */

  55. #ifdef HAVE_TERMIO

  57. /* It is believed that all systems which have added job control to SVR3
  58.    (e.g. sco) have also added termios.  Even if not, trying to figure out
  59.    all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
  60.    bewildering.  So we don't attempt it.  */

  62. ‌struct hardwire_ttystate
  63.   {
  64.     struct termio termio;
  65.   };
  66. #endif /* termio */

  68. #ifdef HAVE_SGTTY
  69. ‌struct hardwire_ttystate
  70.   {
  71.     struct sgttyb sgttyb;
  72.     struct tchars tc;
  73.     struct ltchars ltc;
  74.     /* Line discipline flags.  */
  75.     int lmode;
  76.   };
  77. #endif /* sgtty */

  79. static int hardwire_open (struct serial *scb, const char *name);
  80. static void hardwire_raw (struct serial *scb);
  81. static int wait_for (struct serial *scb, int timeout);
  82. static int hardwire_readchar (struct serial *scb, int timeout);
  83. static int do_hardwire_readchar (struct serial *scb, int timeout);
  84. static int rate_to_code (int rate);
  85. static int hardwire_setbaudrate (struct serial *scb, int rate);
  86. static void hardwire_close (struct serial *scb);
  87. static int get_tty_state (struct serial *scb,
  88.                           struct hardwire_ttystate * state);
  89. static int set_tty_state (struct serial *scb,
  90.                           struct hardwire_ttystate * state);
  91. static serial_ttystate hardwire_get_tty_state (struct serial *scb);
  92. static int hardwire_set_tty_state (struct serial *scb, serial_ttystate state);
  93. static int hardwire_noflush_set_tty_state (struct serial *, serial_ttystate,
  94.                                            serial_ttystate);
  95. static void hardwire_print_tty_state (struct serial *, serial_ttystate,
  96.                                       struct ui_file *);
  97. static int hardwire_drain_output (struct serial *);
  98. static int hardwire_flush_output (struct serial *);
  99. static int hardwire_flush_input (struct serial *);
  100. static int hardwire_send_break (struct serial *);
  101. static int hardwire_setstopbits (struct serial *, int);

  103. void _initialize_ser_hardwire (void);

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

  107. static int
  108. ‌hardwire_open (struct serial *scb, const char *name)
  109. {
  110.   scb->fd = gdb_open_cloexec (name, O_RDWR, 0);
  111.   if (scb->fd < 0)
  112.     return -1;

  114.   return 0;
  115. }

  117. static int
  118. ‌get_tty_state (struct serial *scb, struct hardwire_ttystate *state)
  119. {
  120. #ifdef HAVE_TERMIOS
  121.   if (tcgetattr (scb->fd, &state->termios) < 0)
  122.     return -1;

  124.   return 0;
  125. #endif

  127. #ifdef HAVE_TERMIO
  128.   if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
  129.     return -1;
  130.   return 0;
  131. #endif

  133. #ifdef HAVE_SGTTY
  134.   if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
  135.     return -1;
  136.   if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
  137.     return -1;
  138.   if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
  139.     return -1;
  140.   if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
  141.     return -1;

  143.   return 0;
  144. #endif
  145. }

  147. static int
  148. ‌set_tty_state (struct serial *scb, struct hardwire_ttystate *state)
  149. {
  150. #ifdef HAVE_TERMIOS
  151.   if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
  152.     return -1;

  154.   return 0;
  155. #endif

  157. #ifdef HAVE_TERMIO
  158.   if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
  159.     return -1;
  160.   return 0;
  161. #endif

  163. #ifdef HAVE_SGTTY
  164.   if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
  165.     return -1;
  166.   if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0)
  167.     return -1;
  168.   if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0)
  169.     return -1;
  170.   if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0)
  171.     return -1;

  173.   return 0;
  174. #endif
  175. }

  177. static serial_ttystate
  178. ‌hardwire_get_tty_state (struct serial *scb)
  179. {
  180.   struct hardwire_ttystate *state;

  182.   state = (struct hardwire_ttystate *) xmalloc (sizeof *state);

  184.   if (get_tty_state (scb, state))
  185.     {
  186.       xfree (state);
  187.       return NULL;
  188.     }

  190.   return (serial_ttystate) state;
  191. }

  193. static serial_ttystate
  194. ‌hardwire_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
  195. {
  196.   struct hardwire_ttystate *state;

  198.   state = (struct hardwire_ttystate *) xmalloc (sizeof *state);
  199.   *state = *(struct hardwire_ttystate *) ttystate;

  201.   return (serial_ttystate) state;
  202. }

  204. static int
  205. ‌hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
  206. {
  207.   struct hardwire_ttystate *state;

  209.   state = (struct hardwire_ttystate *) ttystate;

  211.   return set_tty_state (scb, state);
  212. }

  214. static int
  215. ‌hardwire_noflush_set_tty_state (struct serial *scb,
  216.                                 serial_ttystate new_ttystate,
  217.                                 serial_ttystate old_ttystate)
  218. {
  219.   struct hardwire_ttystate new_state;
  220. #ifdef HAVE_SGTTY
  221.   struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
  222. #endif

  224.   new_state = *(struct hardwire_ttystate *) new_ttystate;

  226.   /* Don't change in or out of raw mode; we don't want to flush input.
  227.      termio and termios have no such restriction; for them flushing input
  228.      is separate from setting the attributes.  */

  230. #ifdef HAVE_SGTTY
  231.   if (state->sgttyb.sg_flags & RAW)
  232.     new_state.sgttyb.sg_flags |= RAW;
  233.   else
  234.     new_state.sgttyb.sg_flags &= ~RAW;

  236.   /* I'm not sure whether this is necessary; the manpage just mentions
  237.      RAW not CBREAK.  */
  238.   if (state->sgttyb.sg_flags & CBREAK)
  239.     new_state.sgttyb.sg_flags |= CBREAK;
  240.   else
  241.     new_state.sgttyb.sg_flags &= ~CBREAK;
  242. #endif

  244.   return set_tty_state (scb, &new_state);
  245. }

  247. static void
  248. ‌hardwire_print_tty_state (struct serial *scb,
  249.                           serial_ttystate ttystate,
  250.                           struct ui_file *stream)
  251. {
  252.   struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
  253.   int i;

  255. #ifdef HAVE_TERMIOS
  256.   fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
  257.                     (int) state->termios.c_iflag,
  258.                     (int) state->termios.c_oflag);
  259.   fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n",
  260.                     (int) state->termios.c_cflag,
  261.                     (int) state->termios.c_lflag);
  262. #if 0
  263.   /* This not in POSIX, and is not really documented by those systems
  264.      which have it (at least not Sun).  */
  265.   fprintf_filtered (stream, "c_line = 0x%x.\n", state->termios.c_line);
  266. #endif
  267.   fprintf_filtered (stream, "c_cc: ");
  268.   for (i = 0; i < NCCS; i += 1)
  269.     fprintf_filtered (stream, "0x%x ", state->termios.c_cc[i]);
  270.   fprintf_filtered (stream, "\n");
  271. #endif

  273. #ifdef HAVE_TERMIO
  274.   fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
  275.                     state->termio.c_iflag, state->termio.c_oflag);
  276.   fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
  277.                     state->termio.c_cflag, state->termio.c_lflag,
  278.                     state->termio.c_line);
  279.   fprintf_filtered (stream, "c_cc: ");
  280.   for (i = 0; i < NCC; i += 1)
  281.     fprintf_filtered (stream, "0x%x ", state->termio.c_cc[i]);
  282.   fprintf_filtered (stream, "\n");
  283. #endif

  285. #ifdef HAVE_SGTTY
  286.   fprintf_filtered (stream, "sgttyb.sg_flags = 0x%x.\n",
  287.                     state->sgttyb.sg_flags);

  289.   fprintf_filtered (stream, "tchars: ");
  290.   for (i = 0; i < (int) sizeof (struct tchars); i++)
  291.     fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->tc)[i]);
  292.   fprintf_filtered (stream, "\n");

  294.   fprintf_filtered (stream, "ltchars: ");
  295.   for (i = 0; i < (int) sizeof (struct ltchars); i++)
  296.     fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->ltc)[i]);
  297.   fprintf_filtered (stream, "\n");

  299.   fprintf_filtered (stream, "lmode:  0x%x\n", state->lmode);
  300. #endif
  301. }

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

  306. static int
  307. ‌hardwire_drain_output (struct serial *scb)
  308. {
  309. #ifdef HAVE_TERMIOS
  310.   return tcdrain (scb->fd);
  311. #endif

  313. #ifdef HAVE_TERMIO
  314.   return ioctl (scb->fd, TCSBRK, 1);
  315. #endif

  317. #ifdef HAVE_SGTTY
  318.   /* Get the current state and then restore it using TIOCSETP,
  319.      which should cause the output to drain and pending input
  320.      to be discarded.  */
  321.   {
  322.     struct hardwire_ttystate state;

  324.     if (get_tty_state (scb, &state))
  325.       {
  326.         return (-1);
  327.       }
  328.     else
  329.       {
  330.         return (ioctl (scb->fd, TIOCSETP, &state.sgttyb));
  331.       }
  332.   }
  333. #endif
  334. }

  336. static int
  337. ‌hardwire_flush_output (struct serial *scb)
  338. {
  339. #ifdef HAVE_TERMIOS
  340.   return tcflush (scb->fd, TCOFLUSH);
  341. #endif

  343. #ifdef HAVE_TERMIO
  344.   return ioctl (scb->fd, TCFLSH, 1);
  345. #endif

  347. #ifdef HAVE_SGTTY
  348.   /* This flushes both input and output, but we can't do better.  */
  349.   return ioctl (scb->fd, TIOCFLUSH, 0);
  350. #endif
  351. }

  353. static int
  354. ‌hardwire_flush_input (struct serial *scb)
  355. {
  356.   ser_base_flush_input (scb);

  358. #ifdef HAVE_TERMIOS
  359.   return tcflush (scb->fd, TCIFLUSH);
  360. #endif

  362. #ifdef HAVE_TERMIO
  363.   return ioctl (scb->fd, TCFLSH, 0);
  364. #endif

  366. #ifdef HAVE_SGTTY
  367.   /* This flushes both input and output, but we can't do better.  */
  368.   return ioctl (scb->fd, TIOCFLUSH, 0);
  369. #endif
  370. }

  372. static int
  373. ‌hardwire_send_break (struct serial *scb)
  374. {
  375. #ifdef HAVE_TERMIOS
  376.   return tcsendbreak (scb->fd, 0);
  377. #endif

  379. #ifdef HAVE_TERMIO
  380.   return ioctl (scb->fd, TCSBRK, 0);
  381. #endif

  383. #ifdef HAVE_SGTTY
  384.   {
  385.     int status;

  387.     status = ioctl (scb->fd, TIOCSBRK, 0);

  389.     /* Can't use usleep; it doesn't exist in BSD 4.2.  */
  390.     /* Note that if this gdb_select() is interrupted by a signal it will not
  391.        wait the full length of time.  I think that is OK.  */
  392.     gdb_usleep (250000);
  393.     status = ioctl (scb->fd, TIOCCBRK, 0);
  394.     return status;
  395.   }
  396. #endif
  397. }

  399. static void
  400. ‌hardwire_raw (struct serial *scb)
  401. {
  402.   struct hardwire_ttystate state;

  404.   if (get_tty_state (scb, &state))
  405.     fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n",
  406.                         safe_strerror (errno));

  408. #ifdef HAVE_TERMIOS
  409.   state.termios.c_iflag = 0;
  410.   state.termios.c_oflag = 0;
  411.   state.termios.c_lflag = 0;
  412.   state.termios.c_cflag &= ~(CSIZE | PARENB);
  413.   state.termios.c_cflag |= CLOCAL | CS8;
  414. #ifdef CRTSCTS
  415.   /* h/w flow control.  */
  416.   if (serial_hwflow)
  417.     state.termios.c_cflag |= CRTSCTS;
  418.   else
  419.     state.termios.c_cflag &= ~CRTSCTS;
  420. #ifdef CRTS_IFLOW
  421.   if (serial_hwflow)
  422.     state.termios.c_cflag |= CRTS_IFLOW;
  423.   else
  424.     state.termios.c_cflag &= ~CRTS_IFLOW;
  425. #endif
  426. #endif
  427.   state.termios.c_cc[VMIN] = 0;
  428.   state.termios.c_cc[VTIME] = 0;
  429. #endif

  431. #ifdef HAVE_TERMIO
  432.   state.termio.c_iflag = 0;
  433.   state.termio.c_oflag = 0;
  434.   state.termio.c_lflag = 0;
  435.   state.termio.c_cflag &= ~(CSIZE | PARENB);
  436.   state.termio.c_cflag |= CLOCAL | CS8;
  437.   state.termio.c_cc[VMIN] = 0;
  438.   state.termio.c_cc[VTIME] = 0;
  439. #endif

  441. #ifdef HAVE_SGTTY
  442.   state.sgttyb.sg_flags |= RAW | ANYP;
  443.   state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
  444. #endif

  446.   scb->current_timeout = 0;

  448.   if (set_tty_state (scb, &state))
  449.     fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n",
  450.                         safe_strerror (errno));
  451. }

  453. /* Wait for input on scb, with timeout seconds.  Returns 0 on success,
  454.    otherwise SERIAL_TIMEOUT or SERIAL_ERROR.

  456.    For termio{s}, we actually just setup VTIME if necessary, and let the
  457.    timeout occur in the read() in hardwire_read().  */

  459. /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
  460.    ser_base*() until the old TERMIOS/SGTTY/... timer code has been
  461.    flushed. .  */

  463. /* NOTE: cagney/1999-09-30: Much of the code below is dead.  The only
  464.    possible values of the TIMEOUT parameter are ONE and ZERO.
  465.    Consequently all the code that tries to handle the possability of
  466.    an overflowed timer is unnecessary.  */

  468. static int
  469. ‌wait_for (struct serial *scb, int timeout)
  470. {
  471. #ifdef HAVE_SGTTY
  472.   while (1)
  473.     {
  474.       struct timeval tv;
  475.       fd_set readfds;
  476.       int numfds;

  478.       /* NOTE: Some OS's can scramble the READFDS when the select()
  479.          call fails (ex the kernel with Red Hat 5.2).  Initialize all
  480.          arguments before each call.  */

  482.       tv.tv_sec = timeout;
  483.       tv.tv_usec = 0;

  485.       FD_ZERO (&readfds);
  486.       FD_SET (scb->fd, &readfds);

  488.       if (timeout >= 0)
  489.         numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, &tv);
  490.       else
  491.         numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, 0);

  493.       if (numfds <= 0)
  494.         if (numfds == 0)
  495.           return SERIAL_TIMEOUT;
  496.         else if (errno == EINTR)
  497.           continue;
  498.         else
  499.           return SERIAL_ERROR;        /* Got an error from select or poll.  */

  501.       return 0;
  502.     }
  503. #endif /* HAVE_SGTTY */

  505. #if defined HAVE_TERMIO || defined HAVE_TERMIOS
  506.   if (timeout == scb->current_timeout)
  507.     return 0;

  509.   scb->current_timeout = timeout;

  511.   {
  512.     struct hardwire_ttystate state;

  514.     if (get_tty_state (scb, &state))
  515.       fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n",
  516.                           safe_strerror (errno));

  518. #ifdef HAVE_TERMIOS
  519.     if (timeout < 0)
  520.       {
  521.         /* No timeout.  */
  522.         state.termios.c_cc[VTIME] = 0;
  523.         state.termios.c_cc[VMIN] = 1;
  524.       }
  525.     else
  526.       {
  527.         state.termios.c_cc[VMIN] = 0;
  528.         state.termios.c_cc[VTIME] = timeout * 10;
  529.         if (state.termios.c_cc[VTIME] != timeout * 10)
  530.           {

  532.             /* If c_cc is an 8-bit signed character, we can't go
  533.                bigger than this.  If it is always unsigned, we could use
  534.                25.  */

  536.             scb->current_timeout = 12;
  537.             state.termios.c_cc[VTIME] = scb->current_timeout * 10;
  538.             scb->timeout_remaining = timeout - scb->current_timeout;
  539.           }
  540.       }
  541. #endif

  543. #ifdef HAVE_TERMIO
  544.     if (timeout < 0)
  545.       {
  546.         /* No timeout.  */
  547.         state.termio.c_cc[VTIME] = 0;
  548.         state.termio.c_cc[VMIN] = 1;
  549.       }
  550.     else
  551.       {
  552.         state.termio.c_cc[VMIN] = 0;
  553.         state.termio.c_cc[VTIME] = timeout * 10;
  554.         if (state.termio.c_cc[VTIME] != timeout * 10)
  555.           {
  556.             /* If c_cc is an 8-bit signed character, we can't go
  557.                bigger than this.  If it is always unsigned, we could use
  558.                25.  */

  560.             scb->current_timeout = 12;
  561.             state.termio.c_cc[VTIME] = scb->current_timeout * 10;
  562.             scb->timeout_remaining = timeout - scb->current_timeout;
  563.           }
  564.       }
  565. #endif

  567.     if (set_tty_state (scb, &state))
  568.       fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n",
  569.                           safe_strerror (errno));

  571.     return 0;
  572.   }
  573. #endif /* HAVE_TERMIO || HAVE_TERMIOS */
  574. }

  576. /* Read a character with user-specified timeout.  TIMEOUT is number of
  577.    seconds to wait, or -1 to wait forever.  Use timeout of 0 to effect
  578.    a poll.  Returns char if successful.  Returns SERIAL_TIMEOUT if
  579.    timeout expired, EOF if line dropped dead, or SERIAL_ERROR for any
  580.    other error (see errno in that case).  */

  582. /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
  583.    ser_base*() until the old TERMIOS/SGTTY/... timer code has been
  584.    flushed.  */

  586. /* NOTE: cagney/1999-09-16: This function is not identical to
  587.    ser_base_readchar() as part of replacing it with ser_base*()
  588.    merging will be required - this code handles the case where read()
  589.    times out due to no data while ser_base_readchar() doesn't expect
  590.    that.  */

  592. static int
  593. ‌do_hardwire_readchar (struct serial *scb, int timeout)
  594. {
  595.   int status, delta;
  596.   int detach = 0;

  598.   if (timeout > 0)
  599.     timeout++;

  601.   /* We have to be able to keep the GUI alive here, so we break the
  602.      original timeout into steps of 1 second, running the "keep the
  603.      GUI alive" hook each time through the loop.

  605.      Also, timeout = 0 means to poll, so we just set the delta to 0,
  606.      so we will only go through the loop once.  */

  608.   delta = (timeout == 0 ? 0 : 1);
  609.   while (1)
  610.     {

  612.       /* N.B. The UI may destroy our world (for instance by calling
  613.          remote_stop,) in which case we want to get out of here as
  614.          quickly as possible.  It is not safe to touch scb, since
  615.          someone else might have freed it.  The
  616.          deprecated_ui_loop_hook signals that we should exit by
  617.          returning 1.  */

  619.       if (deprecated_ui_loop_hook)
  620.         detach = deprecated_ui_loop_hook (0);

  622.       if (detach)
  623.         return SERIAL_TIMEOUT;

  625.       scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta);
  626.       status = wait_for (scb, delta);

  628.       if (status < 0)
  629.         return status;

  631.       status = read (scb->fd, scb->buf, BUFSIZ);

  633.       if (status <= 0)
  634.         {
  635.           if (status == 0)
  636.             {
  637.               /* Zero characters means timeout (it could also be EOF, but
  638.                  we don't (yet at least) distinguish).  */
  639.               if (scb->timeout_remaining > 0)
  640.                 {
  641.                   timeout = scb->timeout_remaining;
  642.                   continue;
  643.                 }
  644.               else if (scb->timeout_remaining < 0)
  645.                 continue;
  646.               else
  647.                 return SERIAL_TIMEOUT;
  648.             }
  649.           else if (errno == EINTR)
  650.             continue;
  651.           else
  652.             return SERIAL_ERROR;        /* Got an error from read.  */
  653.         }

  655.       scb->bufcnt = status;
  656.       scb->bufcnt--;
  657.       scb->bufp = scb->buf;
  658.       return *scb->bufp++;
  659.     }
  660. }

  662. static int
  663. ‌hardwire_readchar (struct serial *scb, int timeout)
  664. {
  665.   return generic_readchar (scb, timeout, do_hardwire_readchar);
  666. }


  669. #ifndef B19200
  670. ‌#define B19200 EXTA
  671. #endif

  673. #ifndef B38400
  674. ‌#define B38400 EXTB
  675. #endif

  677. /* Translate baud rates from integers to damn B_codes.  Unix should
  678.    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */

  680. static struct
  681. {
  682.   int rate;
  683.   int code;
  684. }
  685. ‌baudtab[] =
  686. {
  687.   {
  688.     50, B50
  689.   }
  690.   ,
  691.   {
  692.     75, B75
  693.   }
  694.   ,
  695.   {
  696.     110, B110
  697.   }
  698.   ,
  699.   {
  700.     134, B134
  701.   }
  702.   ,
  703.   {
  704.     150, B150
  705.   }
  706.   ,
  707.   {
  708.     200, B200
  709.   }
  710.   ,
  711.   {
  712.     300, B300
  713.   }
  714.   ,
  715.   {
  716.     600, B600
  717.   }
  718.   ,
  719.   {
  720.     1200, B1200
  721.   }
  722.   ,
  723.   {
  724.     1800, B1800
  725.   }
  726.   ,
  727.   {
  728.     2400, B2400
  729.   }
  730.   ,
  731.   {
  732.     4800, B4800
  733.   }
  734.   ,
  735.   {
  736.     9600, B9600
  737.   }
  738.   ,
  739.   {
  740.     19200, B19200
  741.   }
  742.   ,
  743.   {
  744.     38400, B38400
  745.   }
  746.   ,
  747. #ifdef B57600
  748.   {
  749.     57600, B57600
  750.   }
  751.   ,
  752. #endif
  753. #ifdef B115200
  754.   {
  755.     115200, B115200
  756.   }
  757.   ,
  758. #endif
  759. #ifdef B230400
  760.   {
  761.     230400, B230400
  762.   }
  763.   ,
  764. #endif
  765. #ifdef B460800
  766.   {
  767.     460800, B460800
  768.   }
  769.   ,
  770. #endif
  771.   {
  772.     -1, -1
  773.   }
  774.   ,
  775. };

  777. static int
  778. ‌rate_to_code (int rate)
  779. {
  780.   int i;

  782.   for (i = 0; baudtab[i].rate != -1; i++)
  783.     {
  784.       /* test for perfect macth.  */
  785.       if (rate == baudtab[i].rate)
  786.         return baudtab[i].code;
  787.       else
  788.         {
  789.           /* check if it is in between valid values.  */
  790.           if (rate < baudtab[i].rate)
  791.             {
  792.               if (i)
  793.                 {
  794.                   warning (_("Invalid baud rate %d.  "
  795.                              "Closest values are %d and %d."),
  796.                            rate, baudtab[i - 1].rate, baudtab[i].rate);
  797.                 }
  798.               else
  799.                 {
  800.                   warning (_("Invalid baud rate %d.  Minimum value is %d."),
  801.                            rate, baudtab[0].rate);
  802.                 }
  803.               return -1;
  804.             }
  805.         }
  806.     }

  808.   /* The requested speed was too large.  */
  809.   warning (_("Invalid baud rate %d.  Maximum value is %d."),
  810.             rate, baudtab[i - 1].rate);
  811.   return -1;
  812. }

  814. static int
  815. ‌hardwire_setbaudrate (struct serial *scb, int rate)
  816. {
  817.   struct hardwire_ttystate state;
  818.   int baud_code = rate_to_code (rate);

  820.   if (baud_code < 0)
  821.     {
  822.       /* The baud rate was not valid.
  823.          A warning has already been issued.  */
  824.       errno = EINVAL;
  825.       return -1;
  826.     }

  828.   if (get_tty_state (scb, &state))
  829.     return -1;

  831. #ifdef HAVE_TERMIOS
  832.   cfsetospeed (&state.termios, baud_code);
  833.   cfsetispeed (&state.termios, baud_code);
  834. #endif

  836. #ifdef HAVE_TERMIO
  837. #ifndef CIBAUD
  838. ‌#define CIBAUD CBAUD
  839. #endif

  841.   state.termio.c_cflag &= ~(CBAUD | CIBAUD);
  842.   state.termio.c_cflag |= baud_code;
  843. #endif

  845. #ifdef HAVE_SGTTY
  846.   state.sgttyb.sg_ispeed = baud_code;
  847.   state.sgttyb.sg_ospeed = baud_code;
  848. #endif

  850.   return set_tty_state (scb, &state);
  851. }

  853. static int
  854. ‌hardwire_setstopbits (struct serial *scb, int num)
  855. {
  856.   struct hardwire_ttystate state;
  857.   int newbit;

  859.   if (get_tty_state (scb, &state))
  860.     return -1;

  862.   switch (num)
  863.     {
  864.     case SERIAL_1_STOPBITS:
  865.       newbit = 0;
  866.       break;
  867.     case SERIAL_1_AND_A_HALF_STOPBITS:
  868.     case SERIAL_2_STOPBITS:
  869.       newbit = 1;
  870.       break;
  871.     default:
  872.       return 1;
  873.     }

  875. #ifdef HAVE_TERMIOS
  876.   if (!newbit)
  877.     state.termios.c_cflag &= ~CSTOPB;
  878.   else
  879.     state.termios.c_cflag |= CSTOPB;        /* two bits */
  880. #endif

  882. #ifdef HAVE_TERMIO
  883.   if (!newbit)
  884.     state.termio.c_cflag &= ~CSTOPB;
  885.   else
  886.     state.termio.c_cflag |= CSTOPB;        /* two bits */
  887. #endif

  889. #ifdef HAVE_SGTTY
  890.   return 0;                        /* sgtty doesn't support this */
  891. #endif

  893.   return set_tty_state (scb, &state);
  894. }

  896. static void
  897. ‌hardwire_close (struct serial *scb)
  898. {
  899.   if (scb->fd < 0)
  900.     return;

  902.   close (scb->fd);
  903.   scb->fd = -1;
  904. }



  908. /* The hardwire ops.  */

  910. ‌static const struct serial_ops hardwire_ops =
  911. {
  912.   "hardwire",
  913.   hardwire_open,
  914.   hardwire_close,
  915.   NULL,
  916.   /* FIXME: Don't replace this with the equivalent ser_base*() until
  917.      the old TERMIOS/SGTTY/... timer code has been flushed.  cagney
  918.      1999-09-16.  */
  919.   hardwire_readchar,
  920.   ser_base_write,
  921.   hardwire_flush_output,
  922.   hardwire_flush_input,
  923.   hardwire_send_break,
  924.   hardwire_raw,
  925.   hardwire_get_tty_state,
  926.   hardwire_copy_tty_state,
  927.   hardwire_set_tty_state,
  928.   hardwire_print_tty_state,
  929.   hardwire_noflush_set_tty_state,
  930.   hardwire_setbaudrate,
  931.   hardwire_setstopbits,
  932.   hardwire_drain_output,
  933.   ser_base_async,
  934.   ser_unix_read_prim,
  935.   ser_unix_write_prim
  936. };

  938. void
  939. ‌_initialize_ser_hardwire (void)
  940. {
  941.   serial_add_interface (&hardwire_ops);

  943. #ifdef HAVE_TERMIOS
  944. #ifdef CRTSCTS
  945.   add_setshow_boolean_cmd ("remoteflow", no_class,
  946.                            &serial_hwflow, _("\
  947. Set use of hardware flow control for remote serial I/O."), _("\
  948. Show use of hardware flow control for remote serial I/O."), _("\
  949. Enable or disable hardware flow control (RTS/CTS) on the serial port\n\
  950. when debugging using remote targets."),
  951.                            NULL,
  952.                            show_serial_hwflow,
  953.                            &setlist, &showlist);
  954. #endif
  955. #endif
  956. }

  958. int
  959. ‌ser_unix_read_prim (struct serial *scb, size_t count)
  960. {
  961.   int status;

  963.   while (1)
  964.     {
  965.       status = read (scb->fd, scb->buf, count);
  966.       if (status != -1 || errno != EINTR)
  967.         break;
  968.     }
  969.   return status;
  970. }

  972. int
  973. ‌ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
  974. {
  975.   /* ??? Historically, GDB has not retried calls to "write" that
  976.      result in EINTR.  */
  977.   return write (scb->fd, buf, len);
  978. }