gdb/ser-unix.c

   1 /* Serial interface for local (hardwired) serial ports on Un*x like systems
   2
   3    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2003,
   4    2004, 2005, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "serial.h"
  23 #include "ser-base.h"
  24 #include "ser-unix.h"
  25
  26 #include <fcntl.h>
  27 #include <sys/types.h>
  28 #include "terminal.h"
  29 #include <sys/socket.h>
  30 #include <sys/time.h>
  31
  32 #include "gdb_select.h"
  33 #include "gdb_string.h"
  34 #include "gdbcmd.h"
  35
  36 #ifdef HAVE_TERMIOS
  37
  38 struct hardwire_ttystate
  39   {
  40     struct termios termios;
  41   };
  42
  43 #ifdef CRTSCTS
  44 /* Boolean to explicitly enable or disable h/w flow control.  */
  45 static int serial_hwflow;
  46 static void
  47 show_serial_hwflow (struct ui_file *file, int from_tty,
  48                     struct cmd_list_element *c, const char *value)
  49 {
  50   fprintf_filtered (file, _("Hardware flow control is %s.\n"), value);
  51 }
  52 #endif
  53
  54 #endif /* termios */
  55
  56 #ifdef HAVE_TERMIO
  57
  58 /* It is believed that all systems which have added job control to SVR3
  59    (e.g. sco) have also added termios.  Even if not, trying to figure out
  60    all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
  61    bewildering.  So we don't attempt it.  */
  62
  63 struct hardwire_ttystate
  64   {
  65     struct termio termio;
  66   };
  67 #endif /* termio */
  68
  69 #ifdef HAVE_SGTTY
  70 struct hardwire_ttystate
  71   {
  72     struct sgttyb sgttyb;
  73     struct tchars tc;
  74     struct ltchars ltc;
  75     /* Line discipline flags.  */
  76     int lmode;
  77   };
  78 #endif /* sgtty */
  79
  80 static int hardwire_open (struct serial *scb, const char *name);
  81 static void hardwire_raw (struct serial *scb);
  82 static int wait_for (struct serial *scb, int timeout);
  83 static int hardwire_readchar (struct serial *scb, int timeout);
  84 static int do_hardwire_readchar (struct serial *scb, int timeout);
  85 static int rate_to_code (int rate);
  86 static int hardwire_setbaudrate (struct serial *scb, int rate);
  87 static void hardwire_close (struct serial *scb);
  88 static int get_tty_state (struct serial *scb,
  89                           struct hardwire_ttystate * state);
  90 static int set_tty_state (struct serial *scb,
  91                           struct hardwire_ttystate * state);
  92 static serial_ttystate hardwire_get_tty_state (struct serial *scb);
  93 static int hardwire_set_tty_state (struct serial *scb, serial_ttystate state);
  94 static int hardwire_noflush_set_tty_state (struct serial *, serial_ttystate,
  95                                            serial_ttystate);
  96 static void hardwire_print_tty_state (struct serial *, serial_ttystate,
  97                                       struct ui_file *);
  98 static int hardwire_drain_output (struct serial *);
  99 static int hardwire_flush_output (struct serial *);
 100 static int hardwire_flush_input (struct serial *);
 101 static int hardwire_send_break (struct serial *);
 102 static int hardwire_setstopbits (struct serial *, int);
 103
 104 void _initialize_ser_hardwire (void);
 105
 106 /* Open up a real live device for serial I/O */
 107
 108 static int
 109 hardwire_open (struct serial *scb, const char *name)
 110 {
 111   scb->fd = open (name, O_RDWR);
 112   if (scb->fd < 0)
 113     return -1;
 114
 115   return 0;
 116 }
 117
 118 static int
 119 get_tty_state (struct serial *scb, struct hardwire_ttystate *state)
 120 {
 121 #ifdef HAVE_TERMIOS
 122   if (tcgetattr (scb->fd, &state->termios) < 0)
 123     return -1;
 124
 125   return 0;
 126 #endif
 127
 128 #ifdef HAVE_TERMIO
 129   if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
 130     return -1;
 131   return 0;
 132 #endif
 133
 134 #ifdef HAVE_SGTTY
 135   if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
 136     return -1;
 137   if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
 138     return -1;
 139   if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
 140     return -1;
 141   if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
 142     return -1;
 143
 144   return 0;
 145 #endif
 146 }
 147
 148 static int
 149 set_tty_state (struct serial *scb, struct hardwire_ttystate *state)
 150 {
 151 #ifdef HAVE_TERMIOS
 152   if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
 153     return -1;
 154
 155   return 0;
 156 #endif
 157
 158 #ifdef HAVE_TERMIO
 159   if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
 160     return -1;
 161   return 0;
 162 #endif
 163
 164 #ifdef HAVE_SGTTY
 165   if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
 166     return -1;
 167   if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0)
 168     return -1;
 169   if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0)
 170     return -1;
 171   if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0)
 172     return -1;
 173
 174   return 0;
 175 #endif
 176 }
 177
 178 static serial_ttystate
 179 hardwire_get_tty_state (struct serial *scb)
 180 {
 181   struct hardwire_ttystate *state;
 182
 183   state = (struct hardwire_ttystate *) xmalloc (sizeof *state);
 184
 185   if (get_tty_state (scb, state))
 186     return NULL;
 187
 188   return (serial_ttystate) state;
 189 }
 190
 191 static int
 192 hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
 193 {
 194   struct hardwire_ttystate *state;
 195
 196   state = (struct hardwire_ttystate *) ttystate;
 197
 198   return set_tty_state (scb, state);
 199 }
 200
 201 static int
 202 hardwire_noflush_set_tty_state (struct serial *scb,
 203                                 serial_ttystate new_ttystate,
 204                                 serial_ttystate old_ttystate)
 205 {
 206   struct hardwire_ttystate new_state;
 207 #ifdef HAVE_SGTTY
 208   struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
 209 #endif
 210
 211   new_state = *(struct hardwire_ttystate *) new_ttystate;
 212
 213   /* Don't change in or out of raw mode; we don't want to flush input.
 214      termio and termios have no such restriction; for them flushing input
 215      is separate from setting the attributes.  */
 216
 217 #ifdef HAVE_SGTTY
 218   if (state->sgttyb.sg_flags & RAW)
 219     new_state.sgttyb.sg_flags |= RAW;
 220   else
 221     new_state.sgttyb.sg_flags &= ~RAW;
 222
 223   /* I'm not sure whether this is necessary; the manpage just mentions
 224      RAW not CBREAK.  */
 225   if (state->sgttyb.sg_flags & CBREAK)
 226     new_state.sgttyb.sg_flags |= CBREAK;
 227   else
 228     new_state.sgttyb.sg_flags &= ~CBREAK;
 229 #endif
 230
 231   return set_tty_state (scb, &new_state);
 232 }
 233
 234 static void
 235 hardwire_print_tty_state (struct serial *scb,
 236                           serial_ttystate ttystate,
 237                           struct ui_file *stream)
 238 {
 239   struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
 240   int i;
 241
 242 #ifdef HAVE_TERMIOS
 243   fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
 244                     (int) state->termios.c_iflag,
 245                     (int) state->termios.c_oflag);
 246   fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n",
 247                     (int) state->termios.c_cflag,
 248                     (int) state->termios.c_lflag);
 249 #if 0
 250   /* This not in POSIX, and is not really documented by those systems
 251      which have it (at least not Sun).  */
 252   fprintf_filtered (stream, "c_line = 0x%x.\n", state->termios.c_line);
 253 #endif
 254   fprintf_filtered (stream, "c_cc: ");
 255   for (i = 0; i < NCCS; i += 1)
 256     fprintf_filtered (stream, "0x%x ", state->termios.c_cc[i]);
 257   fprintf_filtered (stream, "\n");
 258 #endif
 259
 260 #ifdef HAVE_TERMIO
 261   fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
 262                     state->termio.c_iflag, state->termio.c_oflag);
 263   fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
 264                     state->termio.c_cflag, state->termio.c_lflag,
 265                     state->termio.c_line);
 266   fprintf_filtered (stream, "c_cc: ");
 267   for (i = 0; i < NCC; i += 1)
 268     fprintf_filtered (stream, "0x%x ", state->termio.c_cc[i]);
 269   fprintf_filtered (stream, "\n");
 270 #endif
 271
 272 #ifdef HAVE_SGTTY
 273   fprintf_filtered (stream, "sgttyb.sg_flags = 0x%x.\n",
 274                     state->sgttyb.sg_flags);
 275
 276   fprintf_filtered (stream, "tchars: ");
 277   for (i = 0; i < (int) sizeof (struct tchars); i++)
 278     fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->tc)[i]);
 279   fprintf_filtered (stream, "\n");
 280
 281   fprintf_filtered (stream, "ltchars: ");
 282   for (i = 0; i < (int) sizeof (struct ltchars); i++)
 283     fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->ltc)[i]);
 284   fprintf_filtered (stream, "\n");
 285
 286   fprintf_filtered (stream, "lmode:  0x%x\n", state->lmode);
 287 #endif
 288 }
 289
 290 /* Wait for the output to drain away, as opposed to flushing (discarding) it */
 291
 292 static int
 293 hardwire_drain_output (struct serial *scb)
 294 {
 295 #ifdef HAVE_TERMIOS
 296   return tcdrain (scb->fd);
 297 #endif
 298
 299 #ifdef HAVE_TERMIO
 300   return ioctl (scb->fd, TCSBRK, 1);
 301 #endif
 302
 303 #ifdef HAVE_SGTTY
 304   /* Get the current state and then restore it using TIOCSETP,
 305      which should cause the output to drain and pending input
 306      to be discarded. */
 307   {
 308     struct hardwire_ttystate state;
 309
 310     if (get_tty_state (scb, &state))
 311       {
 312         return (-1);
 313       }
 314     else
 315       {
 316         return (ioctl (scb->fd, TIOCSETP, &state.sgttyb));
 317       }
 318   }
 319 #endif
 320 }
 321
 322 static int
 323 hardwire_flush_output (struct serial *scb)
 324 {
 325 #ifdef HAVE_TERMIOS
 326   return tcflush (scb->fd, TCOFLUSH);
 327 #endif
 328
 329 #ifdef HAVE_TERMIO
 330   return ioctl (scb->fd, TCFLSH, 1);
 331 #endif
 332
 333 #ifdef HAVE_SGTTY
 334   /* This flushes both input and output, but we can't do better.  */
 335   return ioctl (scb->fd, TIOCFLUSH, 0);
 336 #endif
 337 }
 338
 339 static int
 340 hardwire_flush_input (struct serial *scb)
 341 {
 342   ser_base_flush_input (scb);
 343
 344 #ifdef HAVE_TERMIOS
 345   return tcflush (scb->fd, TCIFLUSH);
 346 #endif
 347
 348 #ifdef HAVE_TERMIO
 349   return ioctl (scb->fd, TCFLSH, 0);
 350 #endif
 351
 352 #ifdef HAVE_SGTTY
 353   /* This flushes both input and output, but we can't do better.  */
 354   return ioctl (scb->fd, TIOCFLUSH, 0);
 355 #endif
 356 }
 357
 358 static int
 359 hardwire_send_break (struct serial *scb)
 360 {
 361 #ifdef HAVE_TERMIOS
 362   return tcsendbreak (scb->fd, 0);
 363 #endif
 364
 365 #ifdef HAVE_TERMIO
 366   return ioctl (scb->fd, TCSBRK, 0);
 367 #endif
 368
 369 #ifdef HAVE_SGTTY
 370   {
 371     int status;
 372
 373     status = ioctl (scb->fd, TIOCSBRK, 0);
 374
 375     /* Can't use usleep; it doesn't exist in BSD 4.2.  */
 376     /* Note that if this gdb_select() is interrupted by a signal it will not
 377        wait the full length of time.  I think that is OK.  */
 378     gdb_usleep (250000);
 379     status = ioctl (scb->fd, TIOCCBRK, 0);
 380     return status;
 381   }
 382 #endif
 383 }
 384
 385 static void
 386 hardwire_raw (struct serial *scb)
 387 {
 388   struct hardwire_ttystate state;
 389
 390   if (get_tty_state (scb, &state))
 391     fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n",
 392                         safe_strerror (errno));
 393
 394 #ifdef HAVE_TERMIOS
 395   state.termios.c_iflag = 0;
 396   state.termios.c_oflag = 0;
 397   state.termios.c_lflag = 0;
 398   state.termios.c_cflag &= ~(CSIZE | PARENB);
 399   state.termios.c_cflag |= CLOCAL | CS8;
 400 #ifdef CRTSCTS
 401   /* h/w flow control.  */
 402   if (serial_hwflow)
 403     state.termios.c_cflag |= CRTSCTS;
 404   else
 405     state.termios.c_cflag &= ~CRTSCTS;
 406 #ifdef CRTS_IFLOW
 407   if (serial_hwflow)
 408     state.termios.c_cflag |= CRTS_IFLOW;
 409   else
 410     state.termios.c_cflag &= ~CRTS_IFLOW;
 411 #endif
 412 #endif
 413   state.termios.c_cc[VMIN] = 0;
 414   state.termios.c_cc[VTIME] = 0;
 415 #endif
 416
 417 #ifdef HAVE_TERMIO
 418   state.termio.c_iflag = 0;
 419   state.termio.c_oflag = 0;
 420   state.termio.c_lflag = 0;
 421   state.termio.c_cflag &= ~(CSIZE | PARENB);
 422   state.termio.c_cflag |= CLOCAL | CS8;
 423   state.termio.c_cc[VMIN] = 0;
 424   state.termio.c_cc[VTIME] = 0;
 425 #endif
 426
 427 #ifdef HAVE_SGTTY
 428   state.sgttyb.sg_flags |= RAW | ANYP;
 429   state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
 430 #endif
 431
 432   scb->current_timeout = 0;
 433
 434   if (set_tty_state (scb, &state))
 435     fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n",
 436                         safe_strerror (errno));
 437 }
 438
 439 /* Wait for input on scb, with timeout seconds.  Returns 0 on success,
 440    otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
 441
 442    For termio{s}, we actually just setup VTIME if necessary, and let the
 443    timeout occur in the read() in hardwire_read().
 444  */
 445
 446 /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
 447    ser_base*() until the old TERMIOS/SGTTY/... timer code has been
 448    flushed. . */
 449
 450 /* NOTE: cagney/1999-09-30: Much of the code below is dead.  The only
 451    possible values of the TIMEOUT parameter are ONE and ZERO.
 452    Consequently all the code that tries to handle the possability of
 453    an overflowed timer is unnecessary. */
 454
 455 static int
 456 wait_for (struct serial *scb, int timeout)
 457 {
 458 #ifdef HAVE_SGTTY
 459   while (1)
 460     {
 461       struct timeval tv;
 462       fd_set readfds;
 463       int numfds;
 464
 465       /* NOTE: Some OS's can scramble the READFDS when the select()
 466          call fails (ex the kernel with Red Hat 5.2).  Initialize all
 467          arguments before each call. */
 468
 469       tv.tv_sec = timeout;
 470       tv.tv_usec = 0;
 471
 472       FD_ZERO (&readfds);
 473       FD_SET (scb->fd, &readfds);
 474
 475       if (timeout >= 0)
 476         numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, &tv);
 477       else
 478         numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, 0);
 479
 480       if (numfds <= 0)
 481         if (numfds == 0)
 482           return SERIAL_TIMEOUT;
 483         else if (errno == EINTR)
 484           continue;
 485         else
 486           return SERIAL_ERROR;  /* Got an error from select or poll */
 487
 488       return 0;
 489     }
 490 #endif /* HAVE_SGTTY */
 491
 492 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
 493   if (timeout == scb->current_timeout)
 494     return 0;
 495
 496   scb->current_timeout = timeout;
 497
 498   {
 499     struct hardwire_ttystate state;
 500
 501     if (get_tty_state (scb, &state))
 502       fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n",
 503                           safe_strerror (errno));
 504
 505 #ifdef HAVE_TERMIOS
 506     if (timeout < 0)
 507       {
 508         /* No timeout.  */
 509         state.termios.c_cc[VTIME] = 0;
 510         state.termios.c_cc[VMIN] = 1;
 511       }
 512     else
 513       {
 514         state.termios.c_cc[VMIN] = 0;
 515         state.termios.c_cc[VTIME] = timeout * 10;
 516         if (state.termios.c_cc[VTIME] != timeout * 10)
 517           {
 518
 519             /* If c_cc is an 8-bit signed character, we can't go
 520                bigger than this.  If it is always unsigned, we could use
 521                25.  */
 522
 523             scb->current_timeout = 12;
 524             state.termios.c_cc[VTIME] = scb->current_timeout * 10;
 525             scb->timeout_remaining = timeout - scb->current_timeout;
 526           }
 527       }
 528 #endif
 529
 530 #ifdef HAVE_TERMIO
 531     if (timeout < 0)
 532       {
 533         /* No timeout.  */
 534         state.termio.c_cc[VTIME] = 0;
 535         state.termio.c_cc[VMIN] = 1;
 536       }
 537     else
 538       {
 539         state.termio.c_cc[VMIN] = 0;
 540         state.termio.c_cc[VTIME] = timeout * 10;
 541         if (state.termio.c_cc[VTIME] != timeout * 10)
 542           {
 543             /* If c_cc is an 8-bit signed character, we can't go
 544                bigger than this.  If it is always unsigned, we could use
 545                25.  */
 546
 547             scb->current_timeout = 12;
 548             state.termio.c_cc[VTIME] = scb->current_timeout * 10;
 549             scb->timeout_remaining = timeout - scb->current_timeout;
 550           }
 551       }
 552 #endif
 553
 554     if (set_tty_state (scb, &state))
 555       fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n",
 556                           safe_strerror (errno));
 557
 558     return 0;
 559   }
 560 #endif /* HAVE_TERMIO || HAVE_TERMIOS */
 561 }
 562
 563 /* Read a character with user-specified timeout.  TIMEOUT is number of
 564    seconds to wait, or -1 to wait forever.  Use timeout of 0 to effect
 565    a poll.  Returns char if successful.  Returns SERIAL_TIMEOUT if
 566    timeout expired, EOF if line dropped dead, or SERIAL_ERROR for any
 567    other error (see errno in that case).  */
 568
 569 /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
 570    ser_base*() until the old TERMIOS/SGTTY/... timer code has been
 571    flushed. */
 572
 573 /* NOTE: cagney/1999-09-16: This function is not identical to
 574    ser_base_readchar() as part of replacing it with ser_base*()
 575    merging will be required - this code handles the case where read()
 576    times out due to no data while ser_base_readchar() doesn't expect
 577    that. */
 578
 579 static int
 580 do_hardwire_readchar (struct serial *scb, int timeout)
 581 {
 582   int status, delta;
 583   int detach = 0;
 584
 585   if (timeout > 0)
 586     timeout++;
 587
 588   /* We have to be able to keep the GUI alive here, so we break the
 589      original timeout into steps of 1 second, running the "keep the
 590      GUI alive" hook each time through the loop.
 591
 592      Also, timeout = 0 means to poll, so we just set the delta to 0,
 593      so we will only go through the loop once.  */
 594
 595   delta = (timeout == 0 ? 0 : 1);
 596   while (1)
 597     {
 598
 599       /* N.B. The UI may destroy our world (for instance by calling
 600          remote_stop,) in which case we want to get out of here as
 601          quickly as possible.  It is not safe to touch scb, since
 602          someone else might have freed it.  The
 603          deprecated_ui_loop_hook signals that we should exit by
 604          returning 1.  */
 605
 606       if (deprecated_ui_loop_hook)
 607         detach = deprecated_ui_loop_hook (0);
 608
 609       if (detach)
 610         return SERIAL_TIMEOUT;
 611
 612       scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta);
 613       status = wait_for (scb, delta);
 614
 615       if (status < 0)
 616         return status;
 617
 618       status = read (scb->fd, scb->buf, BUFSIZ);
 619
 620       if (status <= 0)
 621         {
 622           if (status == 0)
 623             {
 624               /* Zero characters means timeout (it could also be EOF, but
 625                  we don't (yet at least) distinguish).  */
 626               if (scb->timeout_remaining > 0)
 627                 {
 628                   timeout = scb->timeout_remaining;
 629                   continue;
 630                 }
 631               else if (scb->timeout_remaining < 0)
 632                 continue;
 633               else
 634                 return SERIAL_TIMEOUT;
 635             }
 636           else if (errno == EINTR)
 637             continue;
 638           else
 639             return SERIAL_ERROR;        /* Got an error from read.  */
 640         }
 641
 642       scb->bufcnt = status;
 643       scb->bufcnt--;
 644       scb->bufp = scb->buf;
 645       return *scb->bufp++;
 646     }
 647 }
 648
 649 static int
 650 hardwire_readchar (struct serial *scb, int timeout)
 651 {
 652   return generic_readchar (scb, timeout, do_hardwire_readchar);
 653 }
 654
 655
 656 #ifndef B19200
 657 #define B19200 EXTA
 658 #endif
 659
 660 #ifndef B38400
 661 #define B38400 EXTB
 662 #endif
 663
 664 /* Translate baud rates from integers to damn B_codes.  Unix should
 665    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 666
 667 static struct
 668 {
 669   int rate;
 670   int code;
 671 }
 672 baudtab[] =
 673 {
 674   {
 675     50, B50
 676   }
 677   ,
 678   {
 679     75, B75
 680   }
 681   ,
 682   {
 683     110, B110
 684   }
 685   ,
 686   {
 687     134, B134
 688   }
 689   ,
 690   {
 691     150, B150
 692   }
 693   ,
 694   {
 695     200, B200
 696   }
 697   ,
 698   {
 699     300, B300
 700   }
 701   ,
 702   {
 703     600, B600
 704   }
 705   ,
 706   {
 707     1200, B1200
 708   }
 709   ,
 710   {
 711     1800, B1800
 712   }
 713   ,
 714   {
 715     2400, B2400
 716   }
 717   ,
 718   {
 719     4800, B4800
 720   }
 721   ,
 722   {
 723     9600, B9600
 724   }
 725   ,
 726   {
 727     19200, B19200
 728   }
 729   ,
 730   {
 731     38400, B38400
 732   }
 733   ,
 734 #ifdef B57600
 735   {
 736     57600, B57600
 737   }
 738   ,
 739 #endif
 740 #ifdef B115200
 741   {
 742     115200, B115200
 743   }
 744   ,
 745 #endif
 746 #ifdef B230400
 747   {
 748     230400, B230400
 749   }
 750   ,
 751 #endif
 752 #ifdef B460800
 753   {
 754     460800, B460800
 755   }
 756   ,
 757 #endif
 758   {
 759     -1, -1
 760   }
 761   ,
 762 };
 763
 764 static int
 765 rate_to_code (int rate)
 766 {
 767   int i;
 768
 769   for (i = 0; baudtab[i].rate != -1; i++)
 770     {
 771       /* test for perfect macth. */
 772       if (rate == baudtab[i].rate)
 773         return baudtab[i].code;
 774       else
 775         {
 776           /* check if it is in between valid values. */
 777           if (rate < baudtab[i].rate)
 778             {
 779               if (i)
 780                 {
 781                   warning (_("Invalid baud rate %d.  "
 782                              "Closest values are %d and %d."),
 783                            rate, baudtab[i - 1].rate, baudtab[i].rate);
 784                 }
 785               else
 786                 {
 787                   warning (_("Invalid baud rate %d.  Minimum value is %d."),
 788                            rate, baudtab[0].rate);
 789                 }
 790               return -1;
 791             }
 792         }
 793     }
 794
 795   /* The requested speed was too large. */
 796   warning (_("Invalid baud rate %d.  Maximum value is %d."),
 797             rate, baudtab[i - 1].rate);
 798   return -1;
 799 }
 800
 801 static int
 802 hardwire_setbaudrate (struct serial *scb, int rate)
 803 {
 804   struct hardwire_ttystate state;
 805   int baud_code = rate_to_code (rate);
 806
 807   if (baud_code < 0)
 808     {
 809       /* The baud rate was not valid.
 810          A warning has already been issued. */
 811       errno = EINVAL;
 812       return -1;
 813     }
 814
 815   if (get_tty_state (scb, &state))
 816     return -1;
 817
 818 #ifdef HAVE_TERMIOS
 819   cfsetospeed (&state.termios, baud_code);
 820   cfsetispeed (&state.termios, baud_code);
 821 #endif
 822
 823 #ifdef HAVE_TERMIO
 824 #ifndef CIBAUD
 825 #define CIBAUD CBAUD
 826 #endif
 827
 828   state.termio.c_cflag &= ~(CBAUD | CIBAUD);
 829   state.termio.c_cflag |= baud_code;
 830 #endif
 831
 832 #ifdef HAVE_SGTTY
 833   state.sgttyb.sg_ispeed = baud_code;
 834   state.sgttyb.sg_ospeed = baud_code;
 835 #endif
 836
 837   return set_tty_state (scb, &state);
 838 }
 839
 840 static int
 841 hardwire_setstopbits (struct serial *scb, int num)
 842 {
 843   struct hardwire_ttystate state;
 844   int newbit;
 845
 846   if (get_tty_state (scb, &state))
 847     return -1;
 848
 849   switch (num)
 850     {
 851     case SERIAL_1_STOPBITS:
 852       newbit = 0;
 853       break;
 854     case SERIAL_1_AND_A_HALF_STOPBITS:
 855     case SERIAL_2_STOPBITS:
 856       newbit = 1;
 857       break;
 858     default:
 859       return 1;
 860     }
 861
 862 #ifdef HAVE_TERMIOS
 863   if (!newbit)
 864     state.termios.c_cflag &= ~CSTOPB;
 865   else
 866     state.termios.c_cflag |= CSTOPB;    /* two bits */
 867 #endif
 868
 869 #ifdef HAVE_TERMIO
 870   if (!newbit)
 871     state.termio.c_cflag &= ~CSTOPB;
 872   else
 873     state.termio.c_cflag |= CSTOPB;     /* two bits */
 874 #endif
 875
 876 #ifdef HAVE_SGTTY
 877   return 0;                     /* sgtty doesn't support this */
 878 #endif
 879
 880   return set_tty_state (scb, &state);
 881 }
 882
 883 static void
 884 hardwire_close (struct serial *scb)
 885 {
 886   if (scb->fd < 0)
 887     return;
 888
 889   close (scb->fd);
 890   scb->fd = -1;
 891 }
 892 \f
 893 \f
 894 void
 895 _initialize_ser_hardwire (void)
 896 {
 897   struct serial_ops *ops = XMALLOC (struct serial_ops);
 898
 899   memset (ops, 0, sizeof (struct serial_ops));
 900   ops->name = "hardwire";
 901   ops->next = 0;
 902   ops->open = hardwire_open;
 903   ops->close = hardwire_close;
 904   /* FIXME: Don't replace this with the equivalent ser_base*() until
 905      the old TERMIOS/SGTTY/... timer code has been flushed. cagney
 906      1999-09-16. */
 907   ops->readchar = hardwire_readchar;
 908   ops->write = ser_base_write;
 909   ops->flush_output = hardwire_flush_output;
 910   ops->flush_input = hardwire_flush_input;
 911   ops->send_break = hardwire_send_break;
 912   ops->go_raw = hardwire_raw;
 913   ops->get_tty_state = hardwire_get_tty_state;
 914   ops->set_tty_state = hardwire_set_tty_state;
 915   ops->print_tty_state = hardwire_print_tty_state;
 916   ops->noflush_set_tty_state = hardwire_noflush_set_tty_state;
 917   ops->setbaudrate = hardwire_setbaudrate;
 918   ops->setstopbits = hardwire_setstopbits;
 919   ops->drain_output = hardwire_drain_output;
 920   ops->async = ser_base_async;
 921   ops->read_prim = ser_unix_read_prim;
 922   ops->write_prim = ser_unix_write_prim;
 923   serial_add_interface (ops);
 924
 925 #ifdef HAVE_TERMIOS
 926 #ifdef CRTSCTS
 927   add_setshow_boolean_cmd ("remoteflow", no_class,
 928                            &serial_hwflow, _("\
 929 Set use of hardware flow control for remote serial I/O."), _("\
 930 Show use of hardware flow control for remote serial I/O."), _("\
 931 Enable or disable hardware flow control (RTS/CTS) on the serial port\n\
 932 when debugging using remote targets."),
 933                            NULL,
 934                            show_serial_hwflow,
 935                            &setlist, &showlist);
 936 #endif
 937 #endif
 938 }
 939
 940 int
 941 ser_unix_read_prim (struct serial *scb, size_t count)
 942 {
 943   int status;
 944
 945   while (1)
 946     {
 947       status = read (scb->fd, scb->buf, count);
 948       if (status != -1 || errno != EINTR)
 949         break;
 950     }
 951   return status;
 952 }
 953
 954 int
 955 ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
 956 {
 957   /* ??? Historically, GDB has not retried calls to "write" that
 958      result in EINTR.  */
 959   return write (scb->fd, buf, len);
 960 }