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 |= 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   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
 538             return SERIAL_ERROR;        /* Got an error from read */
 539         }
 540
 541       scb->bufcnt--;
 542       scb->bufp = scb->buf;
 543       return *scb->bufp++;
 544     }
 545 }
 546
 547 #ifndef B19200
 548 #define B19200 EXTA
 549 #endif
 550
 551 #ifndef B38400
 552 #define B38400 EXTB
 553 #endif
 554
 555 /* Translate baud rates from integers to damn B_codes.  Unix should
 556    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 557
 558 static struct
 559 {
 560   int rate;
 561   int code;
 562 }
 563 baudtab[] =
 564 {
 565   {50, B50},
 566   {75, B75},
 567   {110, B110},
 568   {134, B134},
 569   {150, B150},
 570   {200, B200},
 571   {300, B300},
 572   {600, B600},
 573   {1200, B1200},
 574   {1800, B1800},
 575   {2400, B2400},
 576   {4800, B4800},
 577   {9600, B9600},
 578   {19200, B19200},
 579   {38400, B38400},
 580   {-1, -1},
 581 };
 582
 583 static int
 584 rate_to_code(rate)
 585      int rate;
 586 {
 587   int i;
 588
 589   for (i = 0; baudtab[i].rate != -1; i++)
 590     if (rate == baudtab[i].rate)
 591       return baudtab[i].code;
 592
 593   return -1;
 594 }
 595
 596 static int
 597 hardwire_setbaudrate(scb, rate)
 598      serial_t scb;
 599      int rate;
 600 {
 601   struct hardwire_ttystate state;
 602
 603   if (get_tty_state(scb, &state))
 604     return -1;
 605
 606 #ifdef HAVE_TERMIOS
 607   cfsetospeed (&state.termios, rate_to_code (rate));
 608   cfsetispeed (&state.termios, rate_to_code (rate));
 609 #endif
 610
 611 #ifdef HAVE_TERMIO
 612 #ifndef CIBAUD
 613 #define CIBAUD CBAUD
 614 #endif
 615
 616   state.termio.c_cflag &= ~(CBAUD | CIBAUD);
 617   state.termio.c_cflag |= rate_to_code (rate);
 618 #endif
 619
 620 #ifdef HAVE_SGTTY
 621   state.sgttyb.sg_ispeed = rate_to_code (rate);
 622   state.sgttyb.sg_ospeed = rate_to_code (rate);
 623 #endif
 624
 625   return set_tty_state (scb, &state);
 626 }
 627
 628 static int
 629 hardwire_write(scb, str, len)
 630      serial_t scb;
 631      const char *str;
 632      int len;
 633 {
 634   int cc;
 635
 636   while (len > 0)
 637     {
 638       cc = write(scb->fd, str, len);
 639
 640       if (cc < 0)
 641         return 1;
 642       len -= cc;
 643       str += cc;
 644     }
 645   return 0;
 646 }
 647
 648 static void
 649 hardwire_close(scb)
 650      serial_t scb;
 651 {
 652   if (scb->fd < 0)
 653     return;
 654
 655   close(scb->fd);
 656   scb->fd = -1;
 657 }
 658
 659 static struct serial_ops hardwire_ops =
 660 {
 661   "hardwire",
 662   0,
 663   hardwire_open,
 664   hardwire_close,
 665   hardwire_readchar,
 666   hardwire_write,
 667   hardwire_flush_output,
 668   hardwire_flush_input,
 669   hardwire_send_break,
 670   hardwire_raw,
 671   hardwire_get_tty_state,
 672   hardwire_set_tty_state,
 673   hardwire_print_tty_state,
 674   hardwire_noflush_set_tty_state,
 675   hardwire_setbaudrate,
 676 };
 677
 678 void
 679 _initialize_ser_hardwire ()
 680 {
 681   serial_add_interface (&hardwire_ops);
 682 }