gdb/ser-unix.c

   1 /* Serial interface for local (hardwired) serial ports on Un*x like systems
   2
   3    Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
   4    2003, 2004 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 2 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, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "serial.h"
  25 #include "ser-unix.h"
  26
  27 #include <fcntl.h>
  28 #include <sys/types.h>
  29 #include "terminal.h"
  30 #include <sys/socket.h>
  31 #include <sys/time.h>
  32
  33 #include "gdb_string.h"
  34 #include "event-loop.h"
  35
  36 #ifdef HAVE_TERMIOS
  37
  38 struct hardwire_ttystate
  39   {
  40     struct termios termios;
  41   };
  42 #endif /* termios */
  43
  44 #ifdef HAVE_TERMIO
  45
  46 /* It is believed that all systems which have added job control to SVR3
  47    (e.g. sco) have also added termios.  Even if not, trying to figure out
  48    all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
  49    bewildering.  So we don't attempt it.  */
  50
  51 struct hardwire_ttystate
  52   {
  53     struct termio termio;
  54   };
  55 #endif /* termio */
  56
  57 #ifdef HAVE_SGTTY
  58 struct hardwire_ttystate
  59   {
  60     struct sgttyb sgttyb;
  61     struct tchars tc;
  62     struct ltchars ltc;
  63     /* Line discipline flags.  */
  64     int lmode;
  65   };
  66 #endif /* sgtty */
  67
  68 static int hardwire_open (struct serial *scb, const char *name);
  69 static void hardwire_raw (struct serial *scb);
  70 static int wait_for (struct serial *scb, int timeout);
  71 static int hardwire_readchar (struct serial *scb, int timeout);
  72 static int do_hardwire_readchar (struct serial *scb, int timeout);
  73 static int generic_readchar (struct serial *scb, int timeout,
  74                              int (*do_readchar) (struct serial *scb,
  75                                                  int timeout));
  76 static int rate_to_code (int rate);
  77 static int hardwire_setbaudrate (struct serial *scb, int rate);
  78 static void hardwire_close (struct serial *scb);
  79 static int get_tty_state (struct serial *scb,
  80                           struct hardwire_ttystate * state);
  81 static int set_tty_state (struct serial *scb,
  82                           struct hardwire_ttystate * state);
  83 static serial_ttystate hardwire_get_tty_state (struct serial *scb);
  84 static int hardwire_set_tty_state (struct serial *scb, serial_ttystate state);
  85 static int hardwire_noflush_set_tty_state (struct serial *, serial_ttystate,
  86                                            serial_ttystate);
  87 static void hardwire_print_tty_state (struct serial *, serial_ttystate,
  88                                       struct ui_file *);
  89 static int hardwire_drain_output (struct serial *);
  90 static int hardwire_flush_output (struct serial *);
  91 static int hardwire_flush_input (struct serial *);
  92 static int hardwire_send_break (struct serial *);
  93 static int hardwire_setstopbits (struct serial *, int);
  94
  95 static int do_unix_readchar (struct serial *scb, int timeout);
  96 static timer_handler_func push_event;
  97 static handler_func fd_event;
  98 static void reschedule (struct serial *scb);
  99
 100 void _initialize_ser_hardwire (void);
 101
 102 /* Open up a real live device for serial I/O */
 103
 104 static int
 105 hardwire_open (struct serial *scb, const char *name)
 106 {
 107   scb->fd = open (name, O_RDWR);
 108   if (scb->fd < 0)
 109     return -1;
 110
 111   return 0;
 112 }
 113
 114 static int
 115 get_tty_state (struct serial *scb, struct hardwire_ttystate *state)
 116 {
 117 #ifdef HAVE_TERMIOS
 118   if (tcgetattr (scb->fd, &state->termios) < 0)
 119     return -1;
 120
 121   return 0;
 122 #endif
 123
 124 #ifdef HAVE_TERMIO
 125   if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
 126     return -1;
 127   return 0;
 128 #endif
 129
 130 #ifdef HAVE_SGTTY
 131   if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
 132     return -1;
 133   if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
 134     return -1;
 135   if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
 136     return -1;
 137   if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
 138     return -1;
 139
 140   return 0;
 141 #endif
 142 }
 143
 144 static int
 145 set_tty_state (struct serial *scb, struct hardwire_ttystate *state)
 146 {
 147 #ifdef HAVE_TERMIOS
 148   if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
 149     return -1;
 150
 151   return 0;
 152 #endif
 153
 154 #ifdef HAVE_TERMIO
 155   if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
 156     return -1;
 157   return 0;
 158 #endif
 159
 160 #ifdef HAVE_SGTTY
 161   if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
 162     return -1;
 163   if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0)
 164     return -1;
 165   if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0)
 166     return -1;
 167   if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0)
 168     return -1;
 169
 170   return 0;
 171 #endif
 172 }
 173
 174 static serial_ttystate
 175 hardwire_get_tty_state (struct serial *scb)
 176 {
 177   struct hardwire_ttystate *state;
 178
 179   state = (struct hardwire_ttystate *) xmalloc (sizeof *state);
 180
 181   if (get_tty_state (scb, state))
 182     return NULL;
 183
 184   return (serial_ttystate) state;
 185 }
 186
 187 static int
 188 hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
 189 {
 190   struct hardwire_ttystate *state;
 191
 192   state = (struct hardwire_ttystate *) ttystate;
 193
 194   return set_tty_state (scb, state);
 195 }
 196
 197 static int
 198 hardwire_noflush_set_tty_state (struct serial *scb,
 199                                 serial_ttystate new_ttystate,
 200                                 serial_ttystate old_ttystate)
 201 {
 202   struct hardwire_ttystate new_state;
 203 #ifdef HAVE_SGTTY
 204   struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
 205 #endif
 206
 207   new_state = *(struct hardwire_ttystate *) new_ttystate;
 208
 209   /* Don't change in or out of raw mode; we don't want to flush input.
 210      termio and termios have no such restriction; for them flushing input
 211      is separate from setting the attributes.  */
 212
 213 #ifdef HAVE_SGTTY
 214   if (state->sgttyb.sg_flags & RAW)
 215     new_state.sgttyb.sg_flags |= RAW;
 216   else
 217     new_state.sgttyb.sg_flags &= ~RAW;
 218
 219   /* I'm not sure whether this is necessary; the manpage just mentions
 220      RAW not CBREAK.  */
 221   if (state->sgttyb.sg_flags & CBREAK)
 222     new_state.sgttyb.sg_flags |= CBREAK;
 223   else
 224     new_state.sgttyb.sg_flags &= ~CBREAK;
 225 #endif
 226
 227   return set_tty_state (scb, &new_state);
 228 }
 229
 230 static void
 231 hardwire_print_tty_state (struct serial *scb,
 232                           serial_ttystate ttystate,
 233                           struct ui_file *stream)
 234 {
 235   struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
 236   int i;
 237
 238 #ifdef HAVE_TERMIOS
 239   fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
 240                     (int) state->termios.c_iflag,
 241                     (int) state->termios.c_oflag);
 242   fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n",
 243                     (int) state->termios.c_cflag,
 244                     (int) state->termios.c_lflag);
 245 #if 0
 246   /* This not in POSIX, and is not really documented by those systems
 247      which have it (at least not Sun).  */
 248   fprintf_filtered (stream, "c_line = 0x%x.\n", state->termios.c_line);
 249 #endif
 250   fprintf_filtered (stream, "c_cc: ");
 251   for (i = 0; i < NCCS; i += 1)
 252     fprintf_filtered (stream, "0x%x ", state->termios.c_cc[i]);
 253   fprintf_filtered (stream, "\n");
 254 #endif
 255
 256 #ifdef HAVE_TERMIO
 257   fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
 258                     state->termio.c_iflag, state->termio.c_oflag);
 259   fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
 260                     state->termio.c_cflag, state->termio.c_lflag,
 261                     state->termio.c_line);
 262   fprintf_filtered (stream, "c_cc: ");
 263   for (i = 0; i < NCC; i += 1)
 264     fprintf_filtered (stream, "0x%x ", state->termio.c_cc[i]);
 265   fprintf_filtered (stream, "\n");
 266 #endif
 267
 268 #ifdef HAVE_SGTTY
 269   fprintf_filtered (stream, "sgttyb.sg_flags = 0x%x.\n",
 270                     state->sgttyb.sg_flags);
 271
 272   fprintf_filtered (stream, "tchars: ");
 273   for (i = 0; i < (int) sizeof (struct tchars); i++)
 274     fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->tc)[i]);
 275   fprintf_filtered (stream, "\n");
 276
 277   fprintf_filtered (stream, "ltchars: ");
 278   for (i = 0; i < (int) sizeof (struct ltchars); i++)
 279     fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->ltc)[i]);
 280   fprintf_filtered (stream, "\n");
 281
 282   fprintf_filtered (stream, "lmode:  0x%x\n", state->lmode);
 283 #endif
 284 }
 285
 286 /* Wait for the output to drain away, as opposed to flushing (discarding) it */
 287
 288 static int
 289 hardwire_drain_output (struct serial *scb)
 290 {
 291 #ifdef HAVE_TERMIOS
 292   return tcdrain (scb->fd);
 293 #endif
 294
 295 #ifdef HAVE_TERMIO
 296   return ioctl (scb->fd, TCSBRK, 1);
 297 #endif
 298
 299 #ifdef HAVE_SGTTY
 300   /* Get the current state and then restore it using TIOCSETP,
 301      which should cause the output to drain and pending input
 302      to be discarded. */
 303   {
 304     struct hardwire_ttystate state;
 305     if (get_tty_state (scb, &state))
 306       {
 307         return (-1);
 308       }
 309     else
 310       {
 311         return (ioctl (scb->fd, TIOCSETP, &state.sgttyb));
 312       }
 313   }
 314 #endif
 315 }
 316
 317 static int
 318 hardwire_flush_output (struct serial *scb)
 319 {
 320 #ifdef HAVE_TERMIOS
 321   return tcflush (scb->fd, TCOFLUSH);
 322 #endif
 323
 324 #ifdef HAVE_TERMIO
 325   return ioctl (scb->fd, TCFLSH, 1);
 326 #endif
 327
 328 #ifdef HAVE_SGTTY
 329   /* This flushes both input and output, but we can't do better.  */
 330   return ioctl (scb->fd, TIOCFLUSH, 0);
 331 #endif
 332 }
 333
 334 static int
 335 hardwire_flush_input (struct serial *scb)
 336 {
 337   ser_unix_flush_input (scb);
 338
 339 #ifdef HAVE_TERMIOS
 340   return tcflush (scb->fd, TCIFLUSH);
 341 #endif
 342
 343 #ifdef HAVE_TERMIO
 344   return ioctl (scb->fd, TCFLSH, 0);
 345 #endif
 346
 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 }
 352
 353 static int
 354 hardwire_send_break (struct serial *scb)
 355 {
 356 #ifdef HAVE_TERMIOS
 357   return tcsendbreak (scb->fd, 0);
 358 #endif
 359
 360 #ifdef HAVE_TERMIO
 361   return ioctl (scb->fd, TCSBRK, 0);
 362 #endif
 363
 364 #ifdef HAVE_SGTTY
 365   {
 366     int status;
 367     struct timeval timeout;
 368
 369     status = ioctl (scb->fd, TIOCSBRK, 0);
 370
 371     /* Can't use usleep; it doesn't exist in BSD 4.2.  */
 372     /* Note that if this select() is interrupted by a signal it will not wait
 373        the full length of time.  I think that is OK.  */
 374     timeout.tv_sec = 0;
 375     timeout.tv_usec = 250000;
 376     select (0, 0, 0, 0, &timeout);
 377     status = ioctl (scb->fd, TIOCCBRK, 0);
 378     return status;
 379   }
 380 #endif
 381 }
 382
 383 static void
 384 hardwire_raw (struct serial *scb)
 385 {
 386   struct hardwire_ttystate state;
 387
 388   if (get_tty_state (scb, &state))
 389     fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
 390
 391 #ifdef HAVE_TERMIOS
 392   state.termios.c_iflag = 0;
 393   state.termios.c_oflag = 0;
 394   state.termios.c_lflag = 0;
 395   state.termios.c_cflag &= ~(CSIZE | PARENB);
 396   state.termios.c_cflag |= CLOCAL | CS8;
 397   state.termios.c_cc[VMIN] = 0;
 398   state.termios.c_cc[VTIME] = 0;
 399 #endif
 400
 401 #ifdef HAVE_TERMIO
 402   state.termio.c_iflag = 0;
 403   state.termio.c_oflag = 0;
 404   state.termio.c_lflag = 0;
 405   state.termio.c_cflag &= ~(CSIZE | PARENB);
 406   state.termio.c_cflag |= CLOCAL | CS8;
 407   state.termio.c_cc[VMIN] = 0;
 408   state.termio.c_cc[VTIME] = 0;
 409 #endif
 410
 411 #ifdef HAVE_SGTTY
 412   state.sgttyb.sg_flags |= RAW | ANYP;
 413   state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
 414 #endif
 415
 416   scb->current_timeout = 0;
 417
 418   if (set_tty_state (scb, &state))
 419     fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
 420 }
 421
 422 /* Wait for input on scb, with timeout seconds.  Returns 0 on success,
 423    otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
 424
 425    For termio{s}, we actually just setup VTIME if necessary, and let the
 426    timeout occur in the read() in hardwire_read().
 427  */
 428
 429 /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
 430    ser_unix*() until the old TERMIOS/SGTTY/... timer code has been
 431    flushed. . */
 432
 433 /* NOTE: cagney/1999-09-30: Much of the code below is dead.  The only
 434    possible values of the TIMEOUT parameter are ONE and ZERO.
 435    Consequently all the code that tries to handle the possability of
 436    an overflowed timer is unnecessary. */
 437
 438 static int
 439 wait_for (struct serial *scb, int timeout)
 440 {
 441 #ifdef HAVE_SGTTY
 442   while (1)
 443     {
 444       struct timeval tv;
 445       fd_set readfds;
 446       int numfds;
 447
 448       /* NOTE: Some OS's can scramble the READFDS when the select()
 449          call fails (ex the kernel with Red Hat 5.2).  Initialize all
 450          arguments before each call. */
 451
 452       tv.tv_sec = timeout;
 453       tv.tv_usec = 0;
 454
 455       FD_ZERO (&readfds);
 456       FD_SET (scb->fd, &readfds);
 457
 458       if (timeout >= 0)
 459         numfds = select (scb->fd + 1, &readfds, 0, 0, &tv);
 460       else
 461         numfds = select (scb->fd + 1, &readfds, 0, 0, 0);
 462
 463       if (numfds <= 0)
 464         if (numfds == 0)
 465           return SERIAL_TIMEOUT;
 466         else if (errno == EINTR)
 467           continue;
 468         else
 469           return SERIAL_ERROR;  /* Got an error from select or poll */
 470
 471       return 0;
 472     }
 473 #endif /* HAVE_SGTTY */
 474
 475 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
 476   if (timeout == scb->current_timeout)
 477     return 0;
 478
 479   scb->current_timeout = timeout;
 480
 481   {
 482     struct hardwire_ttystate state;
 483
 484     if (get_tty_state (scb, &state))
 485       fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
 486
 487 #ifdef HAVE_TERMIOS
 488     if (timeout < 0)
 489       {
 490         /* No timeout.  */
 491         state.termios.c_cc[VTIME] = 0;
 492         state.termios.c_cc[VMIN] = 1;
 493       }
 494     else
 495       {
 496         state.termios.c_cc[VMIN] = 0;
 497         state.termios.c_cc[VTIME] = timeout * 10;
 498         if (state.termios.c_cc[VTIME] != timeout * 10)
 499           {
 500
 501             /* If c_cc is an 8-bit signed character, we can't go
 502                bigger than this.  If it is always unsigned, we could use
 503                25.  */
 504
 505             scb->current_timeout = 12;
 506             state.termios.c_cc[VTIME] = scb->current_timeout * 10;
 507             scb->timeout_remaining = timeout - scb->current_timeout;
 508           }
 509       }
 510 #endif
 511
 512 #ifdef HAVE_TERMIO
 513     if (timeout < 0)
 514       {
 515         /* No timeout.  */
 516         state.termio.c_cc[VTIME] = 0;
 517         state.termio.c_cc[VMIN] = 1;
 518       }
 519     else
 520       {
 521         state.termio.c_cc[VMIN] = 0;
 522         state.termio.c_cc[VTIME] = timeout * 10;
 523         if (state.termio.c_cc[VTIME] != timeout * 10)
 524           {
 525             /* If c_cc is an 8-bit signed character, we can't go
 526                bigger than this.  If it is always unsigned, we could use
 527                25.  */
 528
 529             scb->current_timeout = 12;
 530             state.termio.c_cc[VTIME] = scb->current_timeout * 10;
 531             scb->timeout_remaining = timeout - scb->current_timeout;
 532           }
 533       }
 534 #endif
 535
 536     if (set_tty_state (scb, &state))
 537       fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
 538
 539     return 0;
 540   }
 541 #endif /* HAVE_TERMIO || HAVE_TERMIOS */
 542 }
 543
 544 /* Read a character with user-specified timeout.  TIMEOUT is number of seconds
 545    to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
 546    char if successful.  Returns SERIAL_TIMEOUT if timeout expired, EOF if line
 547    dropped dead, or SERIAL_ERROR for any other error (see errno in that case).  */
 548
 549 /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
 550    ser_unix*() until the old TERMIOS/SGTTY/... timer code has been
 551    flushed. */
 552
 553 /* NOTE: cagney/1999-09-16: This function is not identical to
 554    ser_unix_readchar() as part of replacing it with ser_unix*()
 555    merging will be required - this code handles the case where read()
 556    times out due to no data while ser_unix_readchar() doesn't expect
 557    that. */
 558
 559 static int
 560 do_hardwire_readchar (struct serial *scb, int timeout)
 561 {
 562   int status, delta;
 563   int detach = 0;
 564
 565   if (timeout > 0)
 566     timeout++;
 567
 568   /* We have to be able to keep the GUI alive here, so we break the original
 569      timeout into steps of 1 second, running the "keep the GUI alive" hook
 570      each time through the loop.
 571      Also, timeout = 0 means to poll, so we just set the delta to 0, so we
 572      will only go through the loop once. */
 573
 574   delta = (timeout == 0 ? 0 : 1);
 575   while (1)
 576     {
 577
 578       /* N.B. The UI may destroy our world (for instance by calling
 579          remote_stop,) in which case we want to get out of here as
 580          quickly as possible.  It is not safe to touch scb, since
 581          someone else might have freed it.  The ui_loop_hook signals that
 582          we should exit by returning 1. */
 583
 584       if (ui_loop_hook)
 585         detach = ui_loop_hook (0);
 586
 587       if (detach)
 588         return SERIAL_TIMEOUT;
 589
 590       scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta);
 591       status = wait_for (scb, delta);
 592
 593       if (status < 0)
 594         return status;
 595
 596       status = read (scb->fd, scb->buf, BUFSIZ);
 597
 598       if (status <= 0)
 599         {
 600           if (status == 0)
 601             {
 602               /* Zero characters means timeout (it could also be EOF, but
 603                  we don't (yet at least) distinguish).  */
 604               if (scb->timeout_remaining > 0)
 605                 {
 606                   timeout = scb->timeout_remaining;
 607                   continue;
 608                 }
 609               else if (scb->timeout_remaining < 0)
 610                 continue;
 611               else
 612                 return SERIAL_TIMEOUT;
 613             }
 614           else if (errno == EINTR)
 615             continue;
 616           else
 617             return SERIAL_ERROR;        /* Got an error from read */
 618         }
 619
 620       scb->bufcnt = status;
 621       scb->bufcnt--;
 622       scb->bufp = scb->buf;
 623       return *scb->bufp++;
 624     }
 625 }
 626
 627 static int
 628 hardwire_readchar (struct serial *scb, int timeout)
 629 {
 630   return generic_readchar (scb, timeout, do_hardwire_readchar);
 631 }
 632
 633
 634 #ifndef B19200
 635 #define B19200 EXTA
 636 #endif
 637
 638 #ifndef B38400
 639 #define B38400 EXTB
 640 #endif
 641
 642 /* Translate baud rates from integers to damn B_codes.  Unix should
 643    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 644
 645 static struct
 646 {
 647   int rate;
 648   int code;
 649 }
 650 baudtab[] =
 651 {
 652   {
 653     50, B50
 654   }
 655   ,
 656   {
 657     75, B75
 658   }
 659   ,
 660   {
 661     110, B110
 662   }
 663   ,
 664   {
 665     134, B134
 666   }
 667   ,
 668   {
 669     150, B150
 670   }
 671   ,
 672   {
 673     200, B200
 674   }
 675   ,
 676   {
 677     300, B300
 678   }
 679   ,
 680   {
 681     600, B600
 682   }
 683   ,
 684   {
 685     1200, B1200
 686   }
 687   ,
 688   {
 689     1800, B1800
 690   }
 691   ,
 692   {
 693     2400, B2400
 694   }
 695   ,
 696   {
 697     4800, B4800
 698   }
 699   ,
 700   {
 701     9600, B9600
 702   }
 703   ,
 704   {
 705     19200, B19200
 706   }
 707   ,
 708   {
 709     38400, B38400
 710   }
 711   ,
 712 #ifdef B57600
 713   {
 714     57600, B57600
 715   }
 716   ,
 717 #endif
 718 #ifdef B115200
 719   {
 720     115200, B115200
 721   }
 722   ,
 723 #endif
 724 #ifdef B230400
 725   {
 726     230400, B230400
 727   }
 728   ,
 729 #endif
 730 #ifdef B460800
 731   {
 732     460800, B460800
 733   }
 734   ,
 735 #endif
 736   {
 737     -1, -1
 738   }
 739   ,
 740 };
 741
 742 static int
 743 rate_to_code (int rate)
 744 {
 745   int i;
 746
 747   for (i = 0; baudtab[i].rate != -1; i++)
 748     {
 749       /* test for perfect macth. */
 750       if (rate == baudtab[i].rate)
 751         return baudtab[i].code;
 752       else
 753         {
 754           /* check if it is in between valid values. */
 755           if (rate < baudtab[i].rate)
 756             {
 757               if (i)
 758                 {
 759                   warning ("Invalid baud rate %d.  Closest values are %d and %d.",
 760                             rate, baudtab[i - 1].rate, baudtab[i].rate);
 761                 }
 762               else
 763                 {
 764                   warning ("Invalid baud rate %d.  Minimum value is %d.",
 765                             rate, baudtab[0].rate);
 766                 }
 767               return -1;
 768             }
 769         }
 770     }
 771
 772   /* The requested speed was too large. */
 773   warning ("Invalid baud rate %d.  Maximum value is %d.",
 774             rate, baudtab[i - 1].rate);
 775   return -1;
 776 }
 777
 778 static int
 779 hardwire_setbaudrate (struct serial *scb, int rate)
 780 {
 781   struct hardwire_ttystate state;
 782   int baud_code = rate_to_code (rate);
 783
 784   if (baud_code < 0)
 785     {
 786       /* The baud rate was not valid.
 787          A warning has already been issued. */
 788       errno = EINVAL;
 789       return -1;
 790     }
 791
 792   if (get_tty_state (scb, &state))
 793     return -1;
 794
 795 #ifdef HAVE_TERMIOS
 796   cfsetospeed (&state.termios, baud_code);
 797   cfsetispeed (&state.termios, baud_code);
 798 #endif
 799
 800 #ifdef HAVE_TERMIO
 801 #ifndef CIBAUD
 802 #define CIBAUD CBAUD
 803 #endif
 804
 805   state.termio.c_cflag &= ~(CBAUD | CIBAUD);
 806   state.termio.c_cflag |= baud_code;
 807 #endif
 808
 809 #ifdef HAVE_SGTTY
 810   state.sgttyb.sg_ispeed = baud_code;
 811   state.sgttyb.sg_ospeed = baud_code;
 812 #endif
 813
 814   return set_tty_state (scb, &state);
 815 }
 816
 817 static int
 818 hardwire_setstopbits (struct serial *scb, int num)
 819 {
 820   struct hardwire_ttystate state;
 821   int newbit;
 822
 823   if (get_tty_state (scb, &state))
 824     return -1;
 825
 826   switch (num)
 827     {
 828     case SERIAL_1_STOPBITS:
 829       newbit = 0;
 830       break;
 831     case SERIAL_1_AND_A_HALF_STOPBITS:
 832     case SERIAL_2_STOPBITS:
 833       newbit = 1;
 834       break;
 835     default:
 836       return 1;
 837     }
 838
 839 #ifdef HAVE_TERMIOS
 840   if (!newbit)
 841     state.termios.c_cflag &= ~CSTOPB;
 842   else
 843     state.termios.c_cflag |= CSTOPB;    /* two bits */
 844 #endif
 845
 846 #ifdef HAVE_TERMIO
 847   if (!newbit)
 848     state.termio.c_cflag &= ~CSTOPB;
 849   else
 850     state.termio.c_cflag |= CSTOPB;     /* two bits */
 851 #endif
 852
 853 #ifdef HAVE_SGTTY
 854   return 0;                     /* sgtty doesn't support this */
 855 #endif
 856
 857   return set_tty_state (scb, &state);
 858 }
 859
 860 static void
 861 hardwire_close (struct serial *scb)
 862 {
 863   if (scb->fd < 0)
 864     return;
 865
 866   close (scb->fd);
 867   scb->fd = -1;
 868 }
 869
 870 \f
 871 /* Generic operations used by all UNIX/FD based serial interfaces. */
 872
 873 serial_ttystate
 874 ser_unix_nop_get_tty_state (struct serial *scb)
 875 {
 876   /* allocate a dummy */
 877   return (serial_ttystate) XMALLOC (int);
 878 }
 879
 880 int
 881 ser_unix_nop_set_tty_state (struct serial *scb, serial_ttystate ttystate)
 882 {
 883   return 0;
 884 }
 885
 886 void
 887 ser_unix_nop_raw (struct serial *scb)
 888 {
 889   return;                       /* Always in raw mode */
 890 }
 891
 892 /* Wait for input on scb, with timeout seconds.  Returns 0 on success,
 893    otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
 894
 895 int
 896 ser_unix_wait_for (struct serial *scb, int timeout)
 897 {
 898   while (1)
 899     {
 900       int numfds;
 901       struct timeval tv;
 902       fd_set readfds, exceptfds;
 903
 904       /* NOTE: Some OS's can scramble the READFDS when the select()
 905          call fails (ex the kernel with Red Hat 5.2).  Initialize all
 906          arguments before each call. */
 907
 908       tv.tv_sec = timeout;
 909       tv.tv_usec = 0;
 910
 911       FD_ZERO (&readfds);
 912       FD_ZERO (&exceptfds);
 913       FD_SET (scb->fd, &readfds);
 914       FD_SET (scb->fd, &exceptfds);
 915
 916       if (timeout >= 0)
 917         numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, &tv);
 918       else
 919         numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, 0);
 920
 921       if (numfds <= 0)
 922         {
 923           if (numfds == 0)
 924             return SERIAL_TIMEOUT;
 925           else if (errno == EINTR)
 926             continue;
 927           else
 928             return SERIAL_ERROR;        /* Got an error from select or poll */
 929         }
 930
 931       return 0;
 932     }
 933 }
 934
 935 /* Read a character with user-specified timeout.  TIMEOUT is number of seconds
 936    to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
 937    char if successful.  Returns -2 if timeout expired, EOF if line dropped
 938    dead, or -3 for any other error (see errno in that case). */
 939
 940 static int
 941 do_unix_readchar (struct serial *scb, int timeout)
 942 {
 943   int status;
 944   int delta;
 945
 946   /* We have to be able to keep the GUI alive here, so we break the original
 947      timeout into steps of 1 second, running the "keep the GUI alive" hook
 948      each time through the loop.
 949
 950      Also, timeout = 0 means to poll, so we just set the delta to 0, so we
 951      will only go through the loop once. */
 952
 953   delta = (timeout == 0 ? 0 : 1);
 954   while (1)
 955     {
 956
 957       /* N.B. The UI may destroy our world (for instance by calling
 958          remote_stop,) in which case we want to get out of here as
 959          quickly as possible.  It is not safe to touch scb, since
 960          someone else might have freed it.  The ui_loop_hook signals that
 961          we should exit by returning 1. */
 962
 963       if (ui_loop_hook)
 964         {
 965           if (ui_loop_hook (0))
 966             return SERIAL_TIMEOUT;
 967         }
 968
 969       status = ser_unix_wait_for (scb, delta);
 970       if (timeout > 0)
 971         timeout -= delta;
 972
 973       /* If we got a character or an error back from wait_for, then we can
 974          break from the loop before the timeout is completed. */
 975
 976       if (status != SERIAL_TIMEOUT)
 977         {
 978           break;
 979         }
 980
 981       /* If we have exhausted the original timeout, then generate
 982          a SERIAL_TIMEOUT, and pass it out of the loop. */
 983
 984       else if (timeout == 0)
 985         {
 986           status = SERIAL_TIMEOUT;
 987           break;
 988         }
 989     }
 990
 991   if (status < 0)
 992     return status;
 993
 994   while (1)
 995     {
 996       status = read (scb->fd, scb->buf, BUFSIZ);
 997       if (status != -1 || errno != EINTR)
 998         break;
 999     }
1000
1001   if (status <= 0)
1002     {
1003       if (status == 0)
1004         return SERIAL_TIMEOUT;  /* 0 chars means timeout [may need to
1005                                    distinguish between EOF & timeouts
1006                                    someday] */
1007       else
1008         return SERIAL_ERROR;    /* Got an error from read */
1009     }
1010
1011   scb->bufcnt = status;
1012   scb->bufcnt--;
1013   scb->bufp = scb->buf;
1014   return *scb->bufp++;
1015 }
1016
1017 /* Perform operations common to both old and new readchar. */
1018
1019 /* Return the next character from the input FIFO.  If the FIFO is
1020    empty, call the SERIAL specific routine to try and read in more
1021    characters.
1022
1023    Initially data from the input FIFO is returned (fd_event()
1024    pre-reads the input into that FIFO.  Once that has been emptied,
1025    further data is obtained by polling the input FD using the device
1026    specific readchar() function.  Note: reschedule() is called after
1027    every read.  This is because there is no guarentee that the lower
1028    level fd_event() poll_event() code (which also calls reschedule())
1029    will be called. */
1030
1031 static int
1032 generic_readchar (struct serial *scb, int timeout,
1033                   int (do_readchar) (struct serial *scb, int timeout))
1034 {
1035   int ch;
1036   if (scb->bufcnt > 0)
1037     {
1038       ch = *scb->bufp;
1039       scb->bufcnt--;
1040       scb->bufp++;
1041     }
1042   else if (scb->bufcnt < 0)
1043     {
1044       /* Some errors/eof are are sticky. */
1045       ch = scb->bufcnt;
1046     }
1047   else
1048     {
1049       ch = do_readchar (scb, timeout);
1050       if (ch < 0)
1051         {
1052           switch ((enum serial_rc) ch)
1053             {
1054             case SERIAL_EOF:
1055             case SERIAL_ERROR:
1056               /* Make the error/eof stick. */
1057               scb->bufcnt = ch;
1058               break;
1059             case SERIAL_TIMEOUT:
1060               scb->bufcnt = 0;
1061               break;
1062             }
1063         }
1064     }
1065   reschedule (scb);
1066   return ch;
1067 }
1068
1069 int
1070 ser_unix_readchar (struct serial *scb, int timeout)
1071 {
1072   return generic_readchar (scb, timeout, do_unix_readchar);
1073 }
1074
1075 int
1076 ser_unix_nop_noflush_set_tty_state (struct serial *scb,
1077                                     serial_ttystate new_ttystate,
1078                                     serial_ttystate old_ttystate)
1079 {
1080   return 0;
1081 }
1082
1083 void
1084 ser_unix_nop_print_tty_state (struct serial *scb,
1085                               serial_ttystate ttystate,
1086                               struct ui_file *stream)
1087 {
1088   /* Nothing to print.  */
1089   return;
1090 }
1091
1092 int
1093 ser_unix_nop_setbaudrate (struct serial *scb, int rate)
1094 {
1095   return 0;                     /* Never fails! */
1096 }
1097
1098 int
1099 ser_unix_nop_setstopbits (struct serial *scb, int num)
1100 {
1101   return 0;                     /* Never fails! */
1102 }
1103
1104 int
1105 ser_unix_write (struct serial *scb, const char *str, int len)
1106 {
1107   int cc;
1108
1109   while (len > 0)
1110     {
1111       cc = write (scb->fd, str, len);
1112
1113       if (cc < 0)
1114         return 1;
1115       len -= cc;
1116       str += cc;
1117     }
1118   return 0;
1119 }
1120
1121 int
1122 ser_unix_nop_flush_output (struct serial *scb)
1123 {
1124   return 0;
1125 }
1126
1127 int
1128 ser_unix_flush_input (struct serial *scb)
1129 {
1130   if (scb->bufcnt >= 0)
1131     {
1132       scb->bufcnt = 0;
1133       scb->bufp = scb->buf;
1134       return 0;
1135     }
1136   else
1137     return SERIAL_ERROR;
1138 }
1139
1140 int
1141 ser_unix_nop_send_break (struct serial *scb)
1142 {
1143   return 0;
1144 }
1145
1146 int
1147 ser_unix_nop_drain_output (struct serial *scb)
1148 {
1149   return 0;
1150 }
1151
1152
1153 \f
1154 /* Event handling for ASYNC serial code.
1155
1156    At any time the SERIAL device either: has an empty FIFO and is
1157    waiting on a FD event; or has a non-empty FIFO/error condition and
1158    is constantly scheduling timer events.
1159
1160    ASYNC only stops pestering its client when it is de-async'ed or it
1161    is told to go away. */
1162
1163 /* Value of scb->async_state: */
1164 enum {
1165   /* >= 0 (TIMER_SCHEDULED) */
1166   /* The ID of the currently scheduled timer event. This state is
1167      rarely encountered.  Timer events are one-off so as soon as the
1168      event is delivered the state is shanged to NOTHING_SCHEDULED. */
1169   FD_SCHEDULED = -1,
1170   /* The fd_event() handler is scheduled.  It is called when ever the
1171      file descriptor becomes ready. */
1172   NOTHING_SCHEDULED = -2
1173   /* Either no task is scheduled (just going into ASYNC mode) or a
1174      timer event has just gone off and the current state has been
1175      forced into nothing scheduled. */
1176 };
1177
1178 /* Identify and schedule the next ASYNC task based on scb->async_state
1179    and scb->buf* (the input FIFO).  A state machine is used to avoid
1180    the need to make redundant calls into the event-loop - the next
1181    scheduled task is only changed when needed. */
1182
1183 static void
1184 reschedule (struct serial *scb)
1185 {
1186   if (serial_is_async_p (scb))
1187     {
1188       int next_state;
1189       switch (scb->async_state)
1190         {
1191         case FD_SCHEDULED:
1192           if (scb->bufcnt == 0)
1193             next_state = FD_SCHEDULED;
1194           else
1195             {
1196               delete_file_handler (scb->fd);
1197               next_state = create_timer (0, push_event, scb);
1198             }
1199           break;
1200         case NOTHING_SCHEDULED:
1201           if (scb->bufcnt == 0)
1202             {
1203               add_file_handler (scb->fd, fd_event, scb);
1204               next_state = FD_SCHEDULED;
1205             }
1206           else
1207             {
1208               next_state = create_timer (0, push_event, scb);
1209             }
1210           break;
1211         default: /* TIMER SCHEDULED */
1212           if (scb->bufcnt == 0)
1213             {
1214               delete_timer (scb->async_state);
1215               add_file_handler (scb->fd, fd_event, scb);
1216               next_state = FD_SCHEDULED;
1217             }
1218           else
1219             next_state = scb->async_state;
1220           break;
1221         }
1222       if (serial_debug_p (scb))
1223         {
1224           switch (next_state)
1225             {
1226             case FD_SCHEDULED:
1227               if (scb->async_state != FD_SCHEDULED)
1228                 fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n",
1229                                     scb->fd);
1230               break;
1231             default: /* TIMER SCHEDULED */
1232               if (scb->async_state == FD_SCHEDULED)
1233                 fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n",
1234                                     scb->fd);
1235               break;
1236             }
1237         }
1238       scb->async_state = next_state;
1239     }
1240 }
1241
1242 /* FD_EVENT: This is scheduled when the input FIFO is empty (and there
1243    is no pending error).  As soon as data arrives, it is read into the
1244    input FIFO and the client notified.  The client should then drain
1245    the FIFO using readchar().  If the FIFO isn't immediatly emptied,
1246    push_event() is used to nag the client until it is. */
1247
1248 static void
1249 fd_event (int error, void *context)
1250 {
1251   struct serial *scb = context;
1252   if (error != 0)
1253     {
1254       scb->bufcnt = SERIAL_ERROR;
1255     }
1256   else if (scb->bufcnt == 0)
1257     {
1258       /* Prime the input FIFO.  The readchar() function is used to
1259          pull characters out of the buffer.  See also
1260          generic_readchar(). */
1261       int nr;
1262       do
1263         {
1264           nr = read (scb->fd, scb->buf, BUFSIZ);
1265         }
1266       while (nr == -1 && errno == EINTR);
1267       if (nr == 0)
1268         {
1269           scb->bufcnt = SERIAL_EOF;
1270         }
1271       else if (nr > 0)
1272         {
1273           scb->bufcnt = nr;
1274           scb->bufp = scb->buf;
1275         }
1276       else
1277         {
1278           scb->bufcnt = SERIAL_ERROR;
1279         }
1280     }
1281   scb->async_handler (scb, scb->async_context);
1282   reschedule (scb);
1283 }
1284
1285 /* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
1286    error).  Nag the client until all the data has been read.  In the
1287    case of errors, the client will need to close or de-async the
1288    device before naging stops. */
1289
1290 static void
1291 push_event (void *context)
1292 {
1293   struct serial *scb = context;
1294   scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */
1295   scb->async_handler (scb, scb->async_context);
1296   /* re-schedule */
1297   reschedule (scb);
1298 }
1299
1300 /* Put the SERIAL device into/out-of ASYNC mode.  */
1301
1302 void
1303 ser_unix_async (struct serial *scb,
1304                 int async_p)
1305 {
1306   if (async_p)
1307     {
1308       /* Force a re-schedule. */
1309       scb->async_state = NOTHING_SCHEDULED;
1310       if (serial_debug_p (scb))
1311         fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
1312                             scb->fd);
1313       reschedule (scb);
1314     }
1315   else
1316     {
1317       if (serial_debug_p (scb))
1318         fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
1319                             scb->fd);
1320       /* De-schedule whatever tasks are currently scheduled. */
1321       switch (scb->async_state)
1322         {
1323         case FD_SCHEDULED:
1324           delete_file_handler (scb->fd);
1325           break;
1326         case NOTHING_SCHEDULED:
1327           break;
1328         default: /* TIMER SCHEDULED */
1329           delete_timer (scb->async_state);
1330           break;
1331         }
1332     }
1333 }
1334
1335 void
1336 _initialize_ser_hardwire (void)
1337 {
1338   struct serial_ops *ops = XMALLOC (struct serial_ops);
1339   memset (ops, 0, sizeof (struct serial_ops));
1340   ops->name = "hardwire";
1341   ops->next = 0;
1342   ops->open = hardwire_open;
1343   ops->close = hardwire_close;
1344   /* FIXME: Don't replace this with the equivalent ser_unix*() until
1345      the old TERMIOS/SGTTY/... timer code has been flushed. cagney
1346      1999-09-16. */
1347   ops->readchar = hardwire_readchar;
1348   ops->write = ser_unix_write;
1349   ops->flush_output = hardwire_flush_output;
1350   ops->flush_input = hardwire_flush_input;
1351   ops->send_break = hardwire_send_break;
1352   ops->go_raw = hardwire_raw;
1353   ops->get_tty_state = hardwire_get_tty_state;
1354   ops->set_tty_state = hardwire_set_tty_state;
1355   ops->print_tty_state = hardwire_print_tty_state;
1356   ops->noflush_set_tty_state = hardwire_noflush_set_tty_state;
1357   ops->setbaudrate = hardwire_setbaudrate;
1358   ops->setstopbits = hardwire_setstopbits;
1359   ops->drain_output = hardwire_drain_output;
1360   ops->async = ser_unix_async;
1361   serial_add_interface (ops);
1362 }