gdb/ser-unix.c

   1 /* Serial interface for local (hardwired) serial ports on Un*x like systems
   2    Copyright 1992, 1993, 1994 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 |= CLOCAL | 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 |= CLOCAL | 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   scb->timeout_remaining = 0;
 395
 396 #ifdef HAVE_SGTTY
 397   {
 398     struct timeval tv;
 399     fd_set readfds;
 400
 401     FD_ZERO (&readfds);
 402
 403     tv.tv_sec = timeout;
 404     tv.tv_usec = 0;
 405
 406     FD_SET(scb->fd, &readfds);
 407
 408     while (1)
 409       {
 410         int numfds;
 411
 412         if (timeout >= 0)
 413           numfds = select(scb->fd+1, &readfds, 0, 0, &tv);
 414         else
 415           numfds = select(scb->fd+1, &readfds, 0, 0, 0);
 416
 417         if (numfds <= 0)
 418           if (numfds == 0)
 419             return SERIAL_TIMEOUT;
 420           else if (errno == EINTR)
 421             continue;
 422           else
 423             return SERIAL_ERROR;        /* Got an error from select or poll */
 424
 425         return 0;
 426       }
 427   }
 428 #endif  /* HAVE_SGTTY */
 429
 430 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
 431   if (timeout == scb->current_timeout)
 432     return 0;
 433
 434   scb->current_timeout = timeout;
 435
 436   {
 437     struct hardwire_ttystate state;
 438
 439     if (get_tty_state(scb, &state))
 440       fprintf_unfiltered(gdb_stderr, "get_tty_state failed: %s\n", safe_strerror(errno));
 441
 442 #ifdef HAVE_TERMIOS
 443     if (timeout < 0)
 444       {
 445         /* No timeout.  */
 446         state.termios.c_cc[VTIME] = 0;
 447         state.termios.c_cc[VMIN] = 1;
 448       }
 449     else
 450       {
 451         state.termios.c_cc[VMIN] = 0;
 452         state.termios.c_cc[VTIME] = timeout * 10;
 453         if (state.termios.c_cc[VTIME] != timeout * 10)
 454           {
 455
 456             /* If c_cc is an 8-bit signed character, we can't go
 457                bigger than this.  If it is always unsigned, we could use
 458                25.  */
 459
 460             scb->current_timeout = 12;
 461             state.termios.c_cc[VTIME] = scb->current_timeout * 10;
 462             scb->timeout_remaining = timeout - scb->current_timeout;
 463           }
 464       }
 465 #endif
 466
 467 #ifdef HAVE_TERMIO
 468     if (timeout < 0)
 469       {
 470         /* No timeout.  */
 471         state.termio.c_cc[VTIME] = 0;
 472         state.termio.c_cc[VMIN] = 1;
 473       }
 474     else
 475       {
 476         state.termio.c_cc[VMIN] = 0;
 477         state.termio.c_cc[VTIME] = timeout * 10;
 478         if (state.termio.c_cc[VTIME] != timeout * 10)
 479           {
 480             /* If c_cc is an 8-bit signed character, we can't go
 481                bigger than this.  If it is always unsigned, we could use
 482                25.  */
 483
 484             scb->current_timeout = 12;
 485             state.termio.c_cc[VTIME] = scb->current_timeout * 10;
 486             scb->timeout_remaining = timeout - scb->current_timeout;
 487           }
 488       }
 489 #endif
 490
 491     if (set_tty_state (scb, &state))
 492       fprintf_unfiltered(gdb_stderr, "set_tty_state failed: %s\n", safe_strerror(errno));
 493
 494     return 0;
 495   }
 496 #endif  /* HAVE_TERMIO || HAVE_TERMIOS */
 497 }
 498
 499 /* Read a character with user-specified timeout.  TIMEOUT is number of seconds
 500    to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
 501    char if successful.  Returns SERIAL_TIMEOUT if timeout expired, EOF if line
 502    dropped dead, or SERIAL_ERROR for any other error (see errno in that case).  */
 503
 504 static int
 505 hardwire_readchar(scb, timeout)
 506      serial_t scb;
 507      int timeout;
 508 {
 509   int status;
 510
 511   if (scb->bufcnt-- > 0)
 512     return *scb->bufp++;
 513
 514   while (1)
 515     {
 516       status = wait_for (scb, timeout);
 517
 518       if (status < 0)
 519         return status;
 520
 521       scb->bufcnt = read (scb->fd, scb->buf, BUFSIZ);
 522
 523       if (scb->bufcnt <= 0)
 524         {
 525           if (scb->bufcnt == 0)
 526             {
 527               /* Zero characters means timeout (it could also be EOF, but
 528                  we don't (yet at least) distinguish).  */
 529               if (scb->timeout_remaining > 0)
 530                 {
 531                   timeout = scb->timeout_remaining;
 532                   continue;
 533                 }
 534               else
 535                 return SERIAL_TIMEOUT;
 536             }
 537           else if (errno == EINTR)
 538             continue;
 539           else
 540             return SERIAL_ERROR;        /* Got an error from read */
 541         }
 542
 543       scb->bufcnt--;
 544       scb->bufp = scb->buf;
 545       return *scb->bufp++;
 546     }
 547 }
 548
 549 #ifndef B19200
 550 #define B19200 EXTA
 551 #endif
 552
 553 #ifndef B38400
 554 #define B38400 EXTB
 555 #endif
 556
 557 /* Translate baud rates from integers to damn B_codes.  Unix should
 558    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 559
 560 static struct
 561 {
 562   int rate;
 563   int code;
 564 }
 565 baudtab[] =
 566 {
 567   {50, B50},
 568   {75, B75},
 569   {110, B110},
 570   {134, B134},
 571   {150, B150},
 572   {200, B200},
 573   {300, B300},
 574   {600, B600},
 575   {1200, B1200},
 576   {1800, B1800},
 577   {2400, B2400},
 578   {4800, B4800},
 579   {9600, B9600},
 580   {19200, B19200},
 581   {38400, B38400},
 582   {-1, -1},
 583 };
 584
 585 static int
 586 rate_to_code(rate)
 587      int rate;
 588 {
 589   int i;
 590
 591   for (i = 0; baudtab[i].rate != -1; i++)
 592     if (rate == baudtab[i].rate)
 593       return baudtab[i].code;
 594
 595   return -1;
 596 }
 597
 598 static int
 599 hardwire_setbaudrate(scb, rate)
 600      serial_t scb;
 601      int rate;
 602 {
 603   struct hardwire_ttystate state;
 604
 605   if (get_tty_state(scb, &state))
 606     return -1;
 607
 608 #ifdef HAVE_TERMIOS
 609   cfsetospeed (&state.termios, rate_to_code (rate));
 610   cfsetispeed (&state.termios, rate_to_code (rate));
 611 #endif
 612
 613 #ifdef HAVE_TERMIO
 614 #ifndef CIBAUD
 615 #define CIBAUD CBAUD
 616 #endif
 617
 618   state.termio.c_cflag &= ~(CBAUD | CIBAUD);
 619   state.termio.c_cflag |= rate_to_code (rate);
 620 #endif
 621
 622 #ifdef HAVE_SGTTY
 623   state.sgttyb.sg_ispeed = rate_to_code (rate);
 624   state.sgttyb.sg_ospeed = rate_to_code (rate);
 625 #endif
 626
 627   return set_tty_state (scb, &state);
 628 }
 629
 630 static int
 631 hardwire_setstopbits(scb, num)
 632      serial_t scb;
 633      int num;
 634 {
 635   struct hardwire_ttystate state;
 636   int newbit;
 637
 638   if (get_tty_state(scb, &state))
 639     return -1;
 640
 641   switch (num)
 642     {
 643     case SERIAL_1_STOPBITS:
 644       newbit = 0;
 645       break;
 646     case SERIAL_1_AND_A_HALF_STOPBITS:
 647     case SERIAL_2_STOPBITS:
 648       newbit = 1;
 649       break;
 650     default:
 651       return 1;
 652     }
 653
 654 #ifdef HAVE_TERMIOS
 655   if (!newbit)
 656     state.termios.c_cflag &= ~CSTOPB;
 657   else
 658     state.termios.c_cflag |= CSTOPB; /* two bits */
 659 #endif
 660
 661 #ifdef HAVE_TERMIO
 662   if (!newbit)
 663     state.termio.c_cflag &= ~CSTOPB;
 664   else
 665     state.termio.c_cflag |= CSTOPB; /* two bits */
 666 #endif
 667
 668 #ifdef HAVE_SGTTY
 669   return 0;                     /* sgtty doesn't support this */
 670 #endif
 671
 672   return set_tty_state (scb, &state);
 673 }
 674
 675 static int
 676 hardwire_write(scb, str, len)
 677      serial_t scb;
 678      const char *str;
 679      int len;
 680 {
 681   int cc;
 682
 683   while (len > 0)
 684     {
 685       cc = write(scb->fd, str, len);
 686
 687       if (cc < 0)
 688         return 1;
 689       len -= cc;
 690       str += cc;
 691     }
 692   return 0;
 693 }
 694
 695 static void
 696 hardwire_close(scb)
 697      serial_t scb;
 698 {
 699   if (scb->fd < 0)
 700     return;
 701
 702   close(scb->fd);
 703   scb->fd = -1;
 704 }
 705
 706 static struct serial_ops hardwire_ops =
 707 {
 708   "hardwire",
 709   0,
 710   hardwire_open,
 711   hardwire_close,
 712   hardwire_readchar,
 713   hardwire_write,
 714   hardwire_flush_output,
 715   hardwire_flush_input,
 716   hardwire_send_break,
 717   hardwire_raw,
 718   hardwire_get_tty_state,
 719   hardwire_set_tty_state,
 720   hardwire_print_tty_state,
 721   hardwire_noflush_set_tty_state,
 722   hardwire_setbaudrate,
 723   hardwire_setstopbits,
 724 };
 725
 726 void
 727 _initialize_ser_hardwire ()
 728 {
 729   serial_add_interface (&hardwire_ops);
 730 }