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 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     if (get_tty_state (scb, &state))
 310       {
 311         return (-1);
 312       }
 313     else
 314       {
 315         return (ioctl (scb->fd, TIOCSETP, &state.sgttyb));
 316       }
 317   }
 318 #endif
 319 }
 320
 321 static int
 322 hardwire_flush_output (struct serial *scb)
 323 {
 324 #ifdef HAVE_TERMIOS
 325   return tcflush (scb->fd, TCOFLUSH);
 326 #endif
 327
 328 #ifdef HAVE_TERMIO
 329   return ioctl (scb->fd, TCFLSH, 1);
 330 #endif
 331
 332 #ifdef HAVE_SGTTY
 333   /* This flushes both input and output, but we can't do better.  */
 334   return ioctl (scb->fd, TIOCFLUSH, 0);
 335 #endif
 336 }
 337
 338 static int
 339 hardwire_flush_input (struct serial *scb)
 340 {
 341   ser_base_flush_input (scb);
 342
 343 #ifdef HAVE_TERMIOS
 344   return tcflush (scb->fd, TCIFLUSH);
 345 #endif
 346
 347 #ifdef HAVE_TERMIO
 348   return ioctl (scb->fd, TCFLSH, 0);
 349 #endif
 350
 351 #ifdef HAVE_SGTTY
 352   /* This flushes both input and output, but we can't do better.  */
 353   return ioctl (scb->fd, TIOCFLUSH, 0);
 354 #endif
 355 }
 356
 357 static int
 358 hardwire_send_break (struct serial *scb)
 359 {
 360 #ifdef HAVE_TERMIOS
 361   return tcsendbreak (scb->fd, 0);
 362 #endif
 363
 364 #ifdef HAVE_TERMIO
 365   return ioctl (scb->fd, TCSBRK, 0);
 366 #endif
 367
 368 #ifdef HAVE_SGTTY
 369   {
 370     int status;
 371
 372     status = ioctl (scb->fd, TIOCSBRK, 0);
 373
 374     /* Can't use usleep; it doesn't exist in BSD 4.2.  */
 375     /* Note that if this gdb_select() is interrupted by a signal it will not
 376        wait the full length of time.  I think that is OK.  */
 377     gdb_usleep (250000);
 378     status = ioctl (scb->fd, TIOCCBRK, 0);
 379     return status;
 380   }
 381 #endif
 382 }
 383
 384 static void
 385 hardwire_raw (struct serial *scb)
 386 {
 387   struct hardwire_ttystate state;
 388
 389   if (get_tty_state (scb, &state))
 390     fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
 391
 392 #ifdef HAVE_TERMIOS
 393   state.termios.c_iflag = 0;
 394   state.termios.c_oflag = 0;
 395   state.termios.c_lflag = 0;
 396   state.termios.c_cflag &= ~(CSIZE | PARENB);
 397   state.termios.c_cflag |= CLOCAL | CS8;
 398 #ifdef CRTSCTS
 399   /* h/w flow control.  */
 400   if (serial_hwflow)
 401     state.termios.c_cflag |= CRTSCTS;
 402   else
 403     state.termios.c_cflag &= ~CRTSCTS;
 404 #ifdef CRTS_IFLOW
 405   if (serial_hwflow)
 406     state.termios.c_cflag |= CRTS_IFLOW;
 407   else
 408     state.termios.c_cflag &= ~CRTS_IFLOW;
 409 #endif
 410 #endif
 411   state.termios.c_cc[VMIN] = 0;
 412   state.termios.c_cc[VTIME] = 0;
 413 #endif
 414
 415 #ifdef HAVE_TERMIO
 416   state.termio.c_iflag = 0;
 417   state.termio.c_oflag = 0;
 418   state.termio.c_lflag = 0;
 419   state.termio.c_cflag &= ~(CSIZE | PARENB);
 420   state.termio.c_cflag |= CLOCAL | CS8;
 421   state.termio.c_cc[VMIN] = 0;
 422   state.termio.c_cc[VTIME] = 0;
 423 #endif
 424
 425 #ifdef HAVE_SGTTY
 426   state.sgttyb.sg_flags |= RAW | ANYP;
 427   state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
 428 #endif
 429
 430   scb->current_timeout = 0;
 431
 432   if (set_tty_state (scb, &state))
 433     fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
 434 }
 435
 436 /* Wait for input on scb, with timeout seconds.  Returns 0 on success,
 437    otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
 438
 439    For termio{s}, we actually just setup VTIME if necessary, and let the
 440    timeout occur in the read() in hardwire_read().
 441  */
 442
 443 /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
 444    ser_base*() until the old TERMIOS/SGTTY/... timer code has been
 445    flushed. . */
 446
 447 /* NOTE: cagney/1999-09-30: Much of the code below is dead.  The only
 448    possible values of the TIMEOUT parameter are ONE and ZERO.
 449    Consequently all the code that tries to handle the possability of
 450    an overflowed timer is unnecessary. */
 451
 452 static int
 453 wait_for (struct serial *scb, int timeout)
 454 {
 455 #ifdef HAVE_SGTTY
 456   while (1)
 457     {
 458       struct timeval tv;
 459       fd_set readfds;
 460       int numfds;
 461
 462       /* NOTE: Some OS's can scramble the READFDS when the select()
 463          call fails (ex the kernel with Red Hat 5.2).  Initialize all
 464          arguments before each call. */
 465
 466       tv.tv_sec = timeout;
 467       tv.tv_usec = 0;
 468
 469       FD_ZERO (&readfds);
 470       FD_SET (scb->fd, &readfds);
 471
 472       if (timeout >= 0)
 473         numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, &tv);
 474       else
 475         numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, 0);
 476
 477       if (numfds <= 0)
 478         if (numfds == 0)
 479           return SERIAL_TIMEOUT;
 480         else if (errno == EINTR)
 481           continue;
 482         else
 483           return SERIAL_ERROR;  /* Got an error from select or poll */
 484
 485       return 0;
 486     }
 487 #endif /* HAVE_SGTTY */
 488
 489 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
 490   if (timeout == scb->current_timeout)
 491     return 0;
 492
 493   scb->current_timeout = timeout;
 494
 495   {
 496     struct hardwire_ttystate state;
 497
 498     if (get_tty_state (scb, &state))
 499       fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
 500
 501 #ifdef HAVE_TERMIOS
 502     if (timeout < 0)
 503       {
 504         /* No timeout.  */
 505         state.termios.c_cc[VTIME] = 0;
 506         state.termios.c_cc[VMIN] = 1;
 507       }
 508     else
 509       {
 510         state.termios.c_cc[VMIN] = 0;
 511         state.termios.c_cc[VTIME] = timeout * 10;
 512         if (state.termios.c_cc[VTIME] != timeout * 10)
 513           {
 514
 515             /* If c_cc is an 8-bit signed character, we can't go
 516                bigger than this.  If it is always unsigned, we could use
 517                25.  */
 518
 519             scb->current_timeout = 12;
 520             state.termios.c_cc[VTIME] = scb->current_timeout * 10;
 521             scb->timeout_remaining = timeout - scb->current_timeout;
 522           }
 523       }
 524 #endif
 525
 526 #ifdef HAVE_TERMIO
 527     if (timeout < 0)
 528       {
 529         /* No timeout.  */
 530         state.termio.c_cc[VTIME] = 0;
 531         state.termio.c_cc[VMIN] = 1;
 532       }
 533     else
 534       {
 535         state.termio.c_cc[VMIN] = 0;
 536         state.termio.c_cc[VTIME] = timeout * 10;
 537         if (state.termio.c_cc[VTIME] != timeout * 10)
 538           {
 539             /* If c_cc is an 8-bit signed character, we can't go
 540                bigger than this.  If it is always unsigned, we could use
 541                25.  */
 542
 543             scb->current_timeout = 12;
 544             state.termio.c_cc[VTIME] = scb->current_timeout * 10;
 545             scb->timeout_remaining = timeout - scb->current_timeout;
 546           }
 547       }
 548 #endif
 549
 550     if (set_tty_state (scb, &state))
 551       fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
 552
 553     return 0;
 554   }
 555 #endif /* HAVE_TERMIO || HAVE_TERMIOS */
 556 }
 557
 558 /* Read a character with user-specified timeout.  TIMEOUT is number of seconds
 559    to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
 560    char if successful.  Returns SERIAL_TIMEOUT if timeout expired, EOF if line
 561    dropped dead, or SERIAL_ERROR for any other error (see errno in that case).  */
 562
 563 /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
 564    ser_base*() until the old TERMIOS/SGTTY/... timer code has been
 565    flushed. */
 566
 567 /* NOTE: cagney/1999-09-16: This function is not identical to
 568    ser_base_readchar() as part of replacing it with ser_base*()
 569    merging will be required - this code handles the case where read()
 570    times out due to no data while ser_base_readchar() doesn't expect
 571    that. */
 572
 573 static int
 574 do_hardwire_readchar (struct serial *scb, int timeout)
 575 {
 576   int status, delta;
 577   int detach = 0;
 578
 579   if (timeout > 0)
 580     timeout++;
 581
 582   /* We have to be able to keep the GUI alive here, so we break the
 583      original timeout into steps of 1 second, running the "keep the
 584      GUI alive" hook each time through the loop.
 585
 586      Also, timeout = 0 means to poll, so we just set the delta to 0,
 587      so we will only go through the loop once.  */
 588
 589   delta = (timeout == 0 ? 0 : 1);
 590   while (1)
 591     {
 592
 593       /* N.B. The UI may destroy our world (for instance by calling
 594          remote_stop,) in which case we want to get out of here as
 595          quickly as possible.  It is not safe to touch scb, since
 596          someone else might have freed it.  The
 597          deprecated_ui_loop_hook signals that we should exit by
 598          returning 1.  */
 599
 600       if (deprecated_ui_loop_hook)
 601         detach = deprecated_ui_loop_hook (0);
 602
 603       if (detach)
 604         return SERIAL_TIMEOUT;
 605
 606       scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta);
 607       status = wait_for (scb, delta);
 608
 609       if (status < 0)
 610         return status;
 611
 612       status = read (scb->fd, scb->buf, BUFSIZ);
 613
 614       if (status <= 0)
 615         {
 616           if (status == 0)
 617             {
 618               /* Zero characters means timeout (it could also be EOF, but
 619                  we don't (yet at least) distinguish).  */
 620               if (scb->timeout_remaining > 0)
 621                 {
 622                   timeout = scb->timeout_remaining;
 623                   continue;
 624                 }
 625               else if (scb->timeout_remaining < 0)
 626                 continue;
 627               else
 628                 return SERIAL_TIMEOUT;
 629             }
 630           else if (errno == EINTR)
 631             continue;
 632           else
 633             return SERIAL_ERROR;        /* Got an error from read */
 634         }
 635
 636       scb->bufcnt = status;
 637       scb->bufcnt--;
 638       scb->bufp = scb->buf;
 639       return *scb->bufp++;
 640     }
 641 }
 642
 643 static int
 644 hardwire_readchar (struct serial *scb, int timeout)
 645 {
 646   return generic_readchar (scb, timeout, do_hardwire_readchar);
 647 }
 648
 649
 650 #ifndef B19200
 651 #define B19200 EXTA
 652 #endif
 653
 654 #ifndef B38400
 655 #define B38400 EXTB
 656 #endif
 657
 658 /* Translate baud rates from integers to damn B_codes.  Unix should
 659    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 660
 661 static struct
 662 {
 663   int rate;
 664   int code;
 665 }
 666 baudtab[] =
 667 {
 668   {
 669     50, B50
 670   }
 671   ,
 672   {
 673     75, B75
 674   }
 675   ,
 676   {
 677     110, B110
 678   }
 679   ,
 680   {
 681     134, B134
 682   }
 683   ,
 684   {
 685     150, B150
 686   }
 687   ,
 688   {
 689     200, B200
 690   }
 691   ,
 692   {
 693     300, B300
 694   }
 695   ,
 696   {
 697     600, B600
 698   }
 699   ,
 700   {
 701     1200, B1200
 702   }
 703   ,
 704   {
 705     1800, B1800
 706   }
 707   ,
 708   {
 709     2400, B2400
 710   }
 711   ,
 712   {
 713     4800, B4800
 714   }
 715   ,
 716   {
 717     9600, B9600
 718   }
 719   ,
 720   {
 721     19200, B19200
 722   }
 723   ,
 724   {
 725     38400, B38400
 726   }
 727   ,
 728 #ifdef B57600
 729   {
 730     57600, B57600
 731   }
 732   ,
 733 #endif
 734 #ifdef B115200
 735   {
 736     115200, B115200
 737   }
 738   ,
 739 #endif
 740 #ifdef B230400
 741   {
 742     230400, B230400
 743   }
 744   ,
 745 #endif
 746 #ifdef B460800
 747   {
 748     460800, B460800
 749   }
 750   ,
 751 #endif
 752   {
 753     -1, -1
 754   }
 755   ,
 756 };
 757
 758 static int
 759 rate_to_code (int rate)
 760 {
 761   int i;
 762
 763   for (i = 0; baudtab[i].rate != -1; i++)
 764     {
 765       /* test for perfect macth. */
 766       if (rate == baudtab[i].rate)
 767         return baudtab[i].code;
 768       else
 769         {
 770           /* check if it is in between valid values. */
 771           if (rate < baudtab[i].rate)
 772             {
 773               if (i)
 774                 {
 775                   warning (_("Invalid baud rate %d.  Closest values are %d and %d."),
 776                             rate, baudtab[i - 1].rate, baudtab[i].rate);
 777                 }
 778               else
 779                 {
 780                   warning (_("Invalid baud rate %d.  Minimum value is %d."),
 781                             rate, baudtab[0].rate);
 782                 }
 783               return -1;
 784             }
 785         }
 786     }
 787
 788   /* The requested speed was too large. */
 789   warning (_("Invalid baud rate %d.  Maximum value is %d."),
 790             rate, baudtab[i - 1].rate);
 791   return -1;
 792 }
 793
 794 static int
 795 hardwire_setbaudrate (struct serial *scb, int rate)
 796 {
 797   struct hardwire_ttystate state;
 798   int baud_code = rate_to_code (rate);
 799
 800   if (baud_code < 0)
 801     {
 802       /* The baud rate was not valid.
 803          A warning has already been issued. */
 804       errno = EINVAL;
 805       return -1;
 806     }
 807
 808   if (get_tty_state (scb, &state))
 809     return -1;
 810
 811 #ifdef HAVE_TERMIOS
 812   cfsetospeed (&state.termios, baud_code);
 813   cfsetispeed (&state.termios, baud_code);
 814 #endif
 815
 816 #ifdef HAVE_TERMIO
 817 #ifndef CIBAUD
 818 #define CIBAUD CBAUD
 819 #endif
 820
 821   state.termio.c_cflag &= ~(CBAUD | CIBAUD);
 822   state.termio.c_cflag |= baud_code;
 823 #endif
 824
 825 #ifdef HAVE_SGTTY
 826   state.sgttyb.sg_ispeed = baud_code;
 827   state.sgttyb.sg_ospeed = baud_code;
 828 #endif
 829
 830   return set_tty_state (scb, &state);
 831 }
 832
 833 static int
 834 hardwire_setstopbits (struct serial *scb, int num)
 835 {
 836   struct hardwire_ttystate state;
 837   int newbit;
 838
 839   if (get_tty_state (scb, &state))
 840     return -1;
 841
 842   switch (num)
 843     {
 844     case SERIAL_1_STOPBITS:
 845       newbit = 0;
 846       break;
 847     case SERIAL_1_AND_A_HALF_STOPBITS:
 848     case SERIAL_2_STOPBITS:
 849       newbit = 1;
 850       break;
 851     default:
 852       return 1;
 853     }
 854
 855 #ifdef HAVE_TERMIOS
 856   if (!newbit)
 857     state.termios.c_cflag &= ~CSTOPB;
 858   else
 859     state.termios.c_cflag |= CSTOPB;    /* two bits */
 860 #endif
 861
 862 #ifdef HAVE_TERMIO
 863   if (!newbit)
 864     state.termio.c_cflag &= ~CSTOPB;
 865   else
 866     state.termio.c_cflag |= CSTOPB;     /* two bits */
 867 #endif
 868
 869 #ifdef HAVE_SGTTY
 870   return 0;                     /* sgtty doesn't support this */
 871 #endif
 872
 873   return set_tty_state (scb, &state);
 874 }
 875
 876 static void
 877 hardwire_close (struct serial *scb)
 878 {
 879   if (scb->fd < 0)
 880     return;
 881
 882   close (scb->fd);
 883   scb->fd = -1;
 884 }
 885 \f
 886 \f
 887 void
 888 _initialize_ser_hardwire (void)
 889 {
 890   struct serial_ops *ops = XMALLOC (struct serial_ops);
 891   memset (ops, 0, sizeof (struct serial_ops));
 892   ops->name = "hardwire";
 893   ops->next = 0;
 894   ops->open = hardwire_open;
 895   ops->close = hardwire_close;
 896   /* FIXME: Don't replace this with the equivalent ser_base*() until
 897      the old TERMIOS/SGTTY/... timer code has been flushed. cagney
 898      1999-09-16. */
 899   ops->readchar = hardwire_readchar;
 900   ops->write = ser_base_write;
 901   ops->flush_output = hardwire_flush_output;
 902   ops->flush_input = hardwire_flush_input;
 903   ops->send_break = hardwire_send_break;
 904   ops->go_raw = hardwire_raw;
 905   ops->get_tty_state = hardwire_get_tty_state;
 906   ops->set_tty_state = hardwire_set_tty_state;
 907   ops->print_tty_state = hardwire_print_tty_state;
 908   ops->noflush_set_tty_state = hardwire_noflush_set_tty_state;
 909   ops->setbaudrate = hardwire_setbaudrate;
 910   ops->setstopbits = hardwire_setstopbits;
 911   ops->drain_output = hardwire_drain_output;
 912   ops->async = ser_base_async;
 913   ops->read_prim = ser_unix_read_prim;
 914   ops->write_prim = ser_unix_write_prim;
 915   serial_add_interface (ops);
 916
 917 #ifdef HAVE_TERMIOS
 918 #ifdef CRTSCTS
 919   add_setshow_boolean_cmd ("remoteflow", no_class,
 920                            &serial_hwflow, _("\
 921 Set use of hardware flow control for remote serial I/O."), _("\
 922 Show use of hardware flow control for remote serial I/O."), _("\
 923 Enable or disable hardware flow control (RTS/CTS) on the serial port\n\
 924 when debugging using remote targets."),
 925                            NULL,
 926                            show_serial_hwflow,
 927                            &setlist, &showlist);
 928 #endif
 929 #endif
 930 }
 931
 932 int
 933 ser_unix_read_prim (struct serial *scb, size_t count)
 934 {
 935   int status;
 936
 937   while (1)
 938     {
 939       status = read (scb->fd, scb->buf, count);
 940       if (status != -1 || errno != EINTR)
 941         break;
 942     }
 943   return status;
 944 }
 945
 946 int
 947 ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
 948 {
 949   /* ??? Historically, GDB has not retried calls to "write" that
 950      result in EINTR.  */
 951   return write (scb->fd, buf, len);
 952 }