gdb/ser-unix.c

   1 /* Serial interface for local (hardwired) serial ports on Un*x like systems
   2    Copyright 1992, 1993 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "serial.h"
  22 #include <fcntl.h>
  23 #include <sys/types.h>
  24
  25 #if !defined (HAVE_TERMIOS) && !defined (HAVE_TERMIO) && !defined (HAVE_SGTTY)
  26 #define HAVE_SGTTY
  27 #endif
  28
  29 #ifdef HAVE_TERMIOS
  30 #include <termios.h>
  31 #include <unistd.h>
  32
  33 struct hardwire_ttystate
  34 {
  35   struct termios termios;
  36 };
  37 #endif /* termios */
  38
  39 #ifdef HAVE_TERMIO
  40 #include <termio.h>
  41
  42 /* It is believed that all systems which have added job control to SVR3
  43    (e.g. sco) have also added termios.  Even if not, trying to figure out
  44    all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
  45    bewildering.  So we don't attempt it.  */
  46
  47 struct hardwire_ttystate
  48 {
  49   struct termio termio;
  50 };
  51 #endif /* termio */
  52
  53 #ifdef HAVE_SGTTY
  54 /* Needed for the code which uses select().  We would include <sys/select.h>
  55    too if it existed on all systems.  */
  56 #include <sys/time.h>
  57
  58 #include <sgtty.h>
  59
  60 struct hardwire_ttystate
  61 {
  62   struct sgttyb sgttyb;
  63   struct tchars tc;
  64   struct ltchars ltc;
  65   /* Line discipline flags.  */
  66   int lmode;
  67 };
  68 #endif /* sgtty */
  69
  70 static int hardwire_open PARAMS ((serial_t scb, const char *name));
  71 static void hardwire_raw PARAMS ((serial_t scb));
  72 static int wait_for PARAMS ((serial_t scb, int timeout));
  73 static int hardwire_readchar PARAMS ((serial_t scb, int timeout));
  74 static int rate_to_code PARAMS ((int rate));
  75 static int hardwire_setbaudrate PARAMS ((serial_t scb, int rate));
  76 static int hardwire_write PARAMS ((serial_t scb, const char *str, int len));
  77 /* FIXME: static void hardwire_restore PARAMS ((serial_t scb)); */
  78 static void hardwire_close PARAMS ((serial_t scb));
  79 static int get_tty_state PARAMS ((serial_t scb, struct hardwire_ttystate *state));
  80 static int set_tty_state PARAMS ((serial_t scb, struct hardwire_ttystate *state));
  81 static serial_ttystate hardwire_get_tty_state PARAMS ((serial_t scb));
  82 static int hardwire_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
  83
  84 /* Open up a real live device for serial I/O */
  85
  86 static int
  87 hardwire_open(scb, name)
  88      serial_t scb;
  89      const char *name;
  90 {
  91   scb->fd = open (name, O_RDWR);
  92   if (scb->fd < 0)
  93     return -1;
  94
  95   return 0;
  96 }
  97
  98 static int
  99 get_tty_state(scb, state)
 100      serial_t scb;
 101      struct hardwire_ttystate *state;
 102 {
 103 #ifdef HAVE_TERMIOS
 104   extern int errno;
 105
 106   if (tcgetattr(scb->fd, &state->termios) < 0)
 107     return -1;
 108
 109   return 0;
 110 #endif
 111
 112 #ifdef HAVE_TERMIO
 113   if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
 114     return -1;
 115   return 0;
 116 #endif
 117
 118 #ifdef HAVE_SGTTY
 119   if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
 120     return -1;
 121   if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
 122     return -1;
 123   if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
 124     return -1;
 125   if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
 126     return -1;
 127
 128   return 0;
 129 #endif
 130 }
 131
 132 static int
 133 set_tty_state(scb, state)
 134      serial_t scb;
 135      struct hardwire_ttystate *state;
 136 {
 137 #ifdef HAVE_TERMIOS
 138   if (tcsetattr(scb->fd, TCSANOW, &state->termios) < 0)
 139     return -1;
 140
 141   return 0;
 142 #endif
 143
 144 #ifdef HAVE_TERMIO
 145   if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
 146     return -1;
 147   return 0;
 148 #endif
 149
 150 #ifdef HAVE_SGTTY
 151   if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
 152     return -1;
 153   if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0)
 154     return -1;
 155   if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0)
 156     return -1;
 157   if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0)
 158     return -1;
 159
 160   return 0;
 161 #endif
 162 }
 163
 164 static serial_ttystate
 165 hardwire_get_tty_state(scb)
 166      serial_t scb;
 167 {
 168   struct hardwire_ttystate *state;
 169
 170   state = (struct hardwire_ttystate *)xmalloc(sizeof *state);
 171
 172   if (get_tty_state(scb, state))
 173     return NULL;
 174
 175   return (serial_ttystate)state;
 176 }
 177
 178 static int
 179 hardwire_set_tty_state(scb, ttystate)
 180      serial_t scb;
 181      serial_ttystate ttystate;
 182 {
 183   struct hardwire_ttystate *state;
 184
 185   state = (struct hardwire_ttystate *)ttystate;
 186
 187   return set_tty_state(scb, state);
 188 }
 189
 190 static int
 191 hardwire_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
 192      serial_t scb;
 193      serial_ttystate new_ttystate;
 194      serial_ttystate old_ttystate;
 195 {
 196   struct hardwire_ttystate new_state;
 197   struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
 198
 199   new_state = *(struct hardwire_ttystate *)new_ttystate;
 200
 201   /* Don't change in or out of raw mode; we don't want to flush input.
 202      termio and termios have no such restriction; for them flushing input
 203      is separate from setting the attributes.  */
 204
 205 #ifdef HAVE_SGTTY
 206   if (state->sgttyb.sg_flags & RAW)
 207     new_state.sgttyb.sg_flags |= RAW;
 208   else
 209     new_state.sgttyb.sg_flags &= ~RAW;
 210
 211   /* I'm not sure whether this is necessary; the manpage just mentions
 212      RAW not CBREAK.  */
 213   if (state->sgttyb.sg_flags & CBREAK)
 214     new_state.sgttyb.sg_flags |= CBREAK;
 215   else
 216     new_state.sgttyb.sg_flags &= ~CBREAK;
 217 #endif
 218
 219   return set_tty_state (scb, &new_state);
 220 }
 221
 222 static void
 223 hardwire_print_tty_state (scb, ttystate)
 224      serial_t scb;
 225      serial_ttystate ttystate;
 226 {
 227   struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
 228   int i;
 229
 230 #ifdef HAVE_TERMIOS
 231   printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
 232                    state->termios.c_iflag, state->termios.c_oflag);
 233   printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x\n",
 234                    state->termios.c_cflag, state->termios.c_lflag);
 235 #if 0
 236   /* This not in POSIX, and is not really documented by those systems
 237      which have it (at least not Sun).  */
 238   printf_filtered ("c_line = 0x%x.\n", state->termios.c_line);
 239 #endif
 240   printf_filtered ("c_cc: ");
 241   for (i = 0; i < NCCS; i += 1)
 242     printf_filtered ("0x%x ", state->termios.c_cc[i]);
 243   printf_filtered ("\n");
 244 #endif
 245
 246 #ifdef HAVE_TERMIO
 247   printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
 248                    state->termio.c_iflag, state->termio.c_oflag);
 249   printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
 250                    state->termio.c_cflag, state->termio.c_lflag,
 251                    state->termio.c_line);
 252   printf_filtered ("c_cc: ");
 253   for (i = 0; i < NCC; i += 1)
 254     printf_filtered ("0x%x ", state->termio.c_cc[i]);
 255   printf_filtered ("\n");
 256 #endif
 257
 258 #ifdef HAVE_SGTTY
 259   printf_filtered ("sgttyb.sg_flags = 0x%x.\n", state->sgttyb.sg_flags);
 260
 261   printf_filtered ("tchars: ");
 262   for (i = 0; i < (int)sizeof (struct tchars); i++)
 263     printf_filtered ("0x%x ", ((unsigned char *)&state->tc)[i]);
 264   printf_filtered ("\n");
 265
 266   printf_filtered ("ltchars: ");
 267   for (i = 0; i < (int)sizeof (struct ltchars); i++)
 268     printf_filtered ("0x%x ", ((unsigned char *)&state->ltc)[i]);
 269   printf_filtered ("\n");
 270
 271   printf_filtered ("lmode:  0x%x\n", state->lmode);
 272 #endif
 273 }
 274
 275 static int
 276 hardwire_flush_output (scb)
 277      serial_t scb;
 278 {
 279 #ifdef HAVE_TERMIOS
 280   return tcflush (scb->fd, TCOFLUSH);
 281 #endif
 282
 283 #ifdef HAVE_TERMIO
 284   return ioctl (scb->fd, TCFLSH, 1);
 285 #endif
 286
 287 #ifdef HAVE_SGTTY
 288   /* This flushes both input and output, but we can't do better.  */
 289   return ioctl (scb->fd, TIOCFLUSH, 0);
 290 #endif
 291 }
 292
 293 static int
 294 hardwire_flush_input (scb)
 295      serial_t scb;
 296 {
 297 #ifdef HAVE_TERMIOS
 298   return tcflush (scb->fd, TCIFLUSH);
 299 #endif
 300
 301 #ifdef HAVE_TERMIO
 302   return ioctl (scb->fd, TCFLSH, 0);
 303 #endif
 304
 305 #ifdef HAVE_SGTTY
 306   /* This flushes both input and output, but we can't do better.  */
 307   return ioctl (scb->fd, TIOCFLUSH, 0);
 308 #endif
 309 }
 310
 311 static int
 312 hardwire_send_break (scb)
 313      serial_t scb;
 314 {
 315 #ifdef HAVE_TERMIOS
 316   return tcsendbreak (scb->fd, 0);
 317 #endif
 318
 319 #ifdef HAVE_TERMIO
 320   return ioctl (scb->fd, TCSBRK, 0);
 321 #endif
 322
 323 #ifdef HAVE_SGTTY
 324   {
 325     int status;
 326     struct timeval timeout;
 327
 328     status = ioctl (scb->fd, TIOCSBRK, 0);
 329
 330     /* Can't use usleep; it doesn't exist in BSD 4.2.  */
 331     /* Note that if this select() is interrupted by a signal it will not wait
 332        the full length of time.  I think that is OK.  */
 333     timeout.tv_sec = 0;
 334     timeout.tv_usec = 250000;
 335     select (0, 0, 0, 0, &timeout);
 336     status = ioctl (scb->fd, TIOCCBRK, 0);
 337     return status;
 338   }
 339 #endif
 340 }
 341
 342 static void
 343 hardwire_raw(scb)
 344      serial_t scb;
 345 {
 346   struct hardwire_ttystate state;
 347
 348   if (get_tty_state(scb, &state))
 349     fprintf_unfiltered(gdb_stderr, "get_tty_state failed: %s\n", safe_strerror(errno));
 350
 351 #ifdef HAVE_TERMIOS
 352   state.termios.c_iflag = 0;
 353   state.termios.c_oflag = 0;
 354   state.termios.c_lflag = 0;
 355   state.termios.c_cflag &= ~(CSIZE|PARENB);
 356   state.termios.c_cflag |= CS8;
 357   state.termios.c_cc[VMIN] = 0;
 358   state.termios.c_cc[VTIME] = 0;
 359 #endif
 360
 361 #ifdef HAVE_TERMIO
 362   state.termio.c_iflag = 0;
 363   state.termio.c_oflag = 0;
 364   state.termio.c_lflag = 0;
 365   state.termio.c_cflag &= ~(CSIZE|PARENB);
 366   state.termio.c_cflag |= CS8;
 367   state.termio.c_cc[VMIN] = 0;
 368   state.termio.c_cc[VTIME] = 0;
 369 #endif
 370
 371 #ifdef HAVE_SGTTY
 372   state.sgttyb.sg_flags |= RAW | ANYP;
 373   state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
 374 #endif
 375
 376   scb->current_timeout = 0;
 377
 378   if (set_tty_state (scb, &state))
 379     fprintf_unfiltered(gdb_stderr, "set_tty_state failed: %s\n", safe_strerror(errno));
 380 }
 381
 382 /* Wait for input on scb, with timeout seconds.  Returns 0 on success,
 383    otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
 384
 385    For termio{s}, we actually just setup VTIME if necessary, and let the
 386    timeout occur in the read() in hardwire_read().
 387  */
 388
 389 static int
 390 wait_for(scb, timeout)
 391      serial_t scb;
 392      int timeout;
 393 {
 394 #ifdef HAVE_SGTTY
 395   struct timeval tv;
 396   fd_set readfds;
 397
 398   FD_ZERO (&readfds);
 399
 400   tv.tv_sec = timeout;
 401   tv.tv_usec = 0;
 402
 403   FD_SET(scb->fd, &readfds);
 404
 405   while (1)
 406     {
 407       int numfds;
 408
 409       if (timeout >= 0)
 410         numfds = select(scb->fd+1, &readfds, 0, 0, &tv);
 411       else
 412         numfds = select(scb->fd+1, &readfds, 0, 0, 0);
 413
 414       if (numfds <= 0)
 415         if (numfds == 0)
 416           return SERIAL_TIMEOUT;
 417         else if (errno == EINTR)
 418           continue;
 419         else
 420           return SERIAL_ERROR;  /* Got an error from select or poll */
 421
 422       return 0;
 423     }
 424
 425 #endif  /* HAVE_SGTTY */
 426
 427 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
 428   if (timeout == scb->current_timeout)
 429     return 0;
 430
 431   {
 432     struct hardwire_ttystate state;
 433
 434     if (get_tty_state(scb, &state))
 435       fprintf_unfiltered(gdb_stderr, "get_tty_state failed: %s\n", safe_strerror(errno));
 436
 437 #ifdef HAVE_TERMIOS
 438     state.termios.c_cc[VTIME] = timeout * 10;
 439 #endif
 440
 441 #ifdef HAVE_TERMIO
 442     state.termio.c_cc[VTIME] = timeout * 10;
 443 #endif
 444
 445     scb->current_timeout = timeout;
 446
 447     if (set_tty_state (scb, &state))
 448       fprintf_unfiltered(gdb_stderr, "set_tty_state failed: %s\n", safe_strerror(errno));
 449
 450     return 0;
 451   }
 452 #endif  /* HAVE_TERMIO || HAVE_TERMIOS */
 453 }
 454
 455 /* Read a character with user-specified timeout.  TIMEOUT is number of seconds
 456    to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
 457    char if successful.  Returns SERIAL_TIMEOUT if timeout expired, EOF if line
 458    dropped dead, or SERIAL_ERROR for any other error (see errno in that case).  */
 459
 460 static int
 461 hardwire_readchar(scb, timeout)
 462      serial_t scb;
 463      int timeout;
 464 {
 465   int status;
 466
 467   if (scb->bufcnt-- > 0)
 468     return *scb->bufp++;
 469
 470   status = wait_for(scb, timeout);
 471
 472   if (status < 0)
 473     return status;
 474
 475   scb->bufcnt = read(scb->fd, scb->buf, BUFSIZ);
 476
 477   if (scb->bufcnt <= 0)
 478     if (scb->bufcnt == 0)
 479       return SERIAL_TIMEOUT;    /* 0 chars means timeout [may need to
 480                                    distinguish between EOF & timeouts
 481                                    someday] */
 482     else
 483       return SERIAL_ERROR;      /* Got an error from read */
 484
 485   scb->bufcnt--;
 486   scb->bufp = scb->buf;
 487   return *scb->bufp++;
 488 }
 489
 490 #ifndef B19200
 491 #define B19200 EXTA
 492 #endif
 493
 494 #ifndef B38400
 495 #define B38400 EXTB
 496 #endif
 497
 498 /* Translate baud rates from integers to damn B_codes.  Unix should
 499    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 500
 501 static struct
 502 {
 503   int rate;
 504   int code;
 505 }
 506 baudtab[] =
 507 {
 508   {50, B50},
 509   {75, B75},
 510   {110, B110},
 511   {134, B134},
 512   {150, B150},
 513   {200, B200},
 514   {300, B300},
 515   {600, B600},
 516   {1200, B1200},
 517   {1800, B1800},
 518   {2400, B2400},
 519   {4800, B4800},
 520   {9600, B9600},
 521   {19200, B19200},
 522   {38400, B38400},
 523   {-1, -1},
 524 };
 525
 526 static int
 527 rate_to_code(rate)
 528      int rate;
 529 {
 530   int i;
 531
 532   for (i = 0; baudtab[i].rate != -1; i++)
 533     if (rate == baudtab[i].rate)
 534       return baudtab[i].code;
 535
 536   return -1;
 537 }
 538
 539 static int
 540 hardwire_setbaudrate(scb, rate)
 541      serial_t scb;
 542      int rate;
 543 {
 544   struct hardwire_ttystate state;
 545
 546   if (get_tty_state(scb, &state))
 547     return -1;
 548
 549 #ifdef HAVE_TERMIOS
 550   cfsetospeed (&state.termios, rate_to_code (rate));
 551   cfsetispeed (&state.termios, rate_to_code (rate));
 552 #endif
 553
 554 #ifdef HAVE_TERMIO
 555 #ifndef CIBAUD
 556 #define CIBAUD CBAUD
 557 #endif
 558
 559   state.termio.c_cflag &= ~(CBAUD | CIBAUD);
 560   state.termio.c_cflag |= rate_to_code (rate);
 561 #endif
 562
 563 #ifdef HAVE_SGTTY
 564   state.sgttyb.sg_ispeed = rate_to_code (rate);
 565   state.sgttyb.sg_ospeed = rate_to_code (rate);
 566 #endif
 567
 568   return set_tty_state (scb, &state);
 569 }
 570
 571 static int
 572 hardwire_write(scb, str, len)
 573      serial_t scb;
 574      const char *str;
 575      int len;
 576 {
 577   int cc;
 578
 579   while (len > 0)
 580     {
 581       cc = write(scb->fd, str, len);
 582
 583       if (cc < 0)
 584         return 1;
 585       len -= cc;
 586       str += cc;
 587     }
 588   return 0;
 589 }
 590
 591 static void
 592 hardwire_close(scb)
 593      serial_t scb;
 594 {
 595   if (scb->fd < 0)
 596     return;
 597
 598   close(scb->fd);
 599   scb->fd = -1;
 600 }
 601
 602 static struct serial_ops hardwire_ops =
 603 {
 604   "hardwire",
 605   0,
 606   hardwire_open,
 607   hardwire_close,
 608   hardwire_readchar,
 609   hardwire_write,
 610   hardwire_flush_output,
 611   hardwire_flush_input,
 612   hardwire_send_break,
 613   hardwire_raw,
 614   hardwire_get_tty_state,
 615   hardwire_set_tty_state,
 616   hardwire_print_tty_state,
 617   hardwire_noflush_set_tty_state,
 618   hardwire_setbaudrate,
 619 };
 620
 621 void
 622 _initialize_ser_hardwire ()
 623 {
 624   serial_add_interface (&hardwire_ops);
 625 }