1 /* Serial interface for local (hardwired) serial ports on Un*x like systems 2 3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2003, 4 2004, 2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "serial.h" 23 #include "ser-base.h" 24 #include "ser-unix.h" 25 26 #include <fcntl.h> 27 #include <sys/types.h> 28 #include "terminal.h" 29 #include <sys/socket.h> 30 #include <sys/time.h> 31 32 #include "gdb_select.h" 33 #include "gdb_string.h" 34 #include "gdbcmd.h" 35 36 #ifdef HAVE_TERMIOS 37 38 struct hardwire_ttystate 39 { 40 struct termios termios; 41 }; 42 43 #ifdef CRTSCTS 44 /* Boolean to explicitly enable or disable h/w flow control. */ 45 static int serial_hwflow; 46 static void 47 show_serial_hwflow (struct ui_file *file, int from_tty, 48 struct cmd_list_element *c, const char *value) 49 { 50 fprintf_filtered (file, _("Hardware flow control is %s.\n"), value); 51 } 52 #endif 53 54 #endif /* termios */ 55 56 #ifdef HAVE_TERMIO 57 58 /* It is believed that all systems which have added job control to SVR3 59 (e.g. sco) have also added termios. Even if not, trying to figure out 60 all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty 61 bewildering. So we don't attempt it. */ 62 63 struct hardwire_ttystate 64 { 65 struct termio termio; 66 }; 67 #endif /* termio */ 68 69 #ifdef HAVE_SGTTY 70 struct hardwire_ttystate 71 { 72 struct sgttyb sgttyb; 73 struct tchars tc; 74 struct ltchars ltc; 75 /* Line discipline flags. */ 76 int lmode; 77 }; 78 #endif /* sgtty */ 79 80 static int hardwire_open (struct serial *scb, const char *name); 81 static void hardwire_raw (struct serial *scb); 82 static int wait_for (struct serial *scb, int timeout); 83 static int hardwire_readchar (struct serial *scb, int timeout); 84 static int do_hardwire_readchar (struct serial *scb, int timeout); 85 static int rate_to_code (int rate); 86 static int hardwire_setbaudrate (struct serial *scb, int rate); 87 static void hardwire_close (struct serial *scb); 88 static int get_tty_state (struct serial *scb, 89 struct hardwire_ttystate * state); 90 static int set_tty_state (struct serial *scb, 91 struct hardwire_ttystate * state); 92 static serial_ttystate hardwire_get_tty_state (struct serial *scb); 93 static int hardwire_set_tty_state (struct serial *scb, serial_ttystate state); 94 static int hardwire_noflush_set_tty_state (struct serial *, serial_ttystate, 95 serial_ttystate); 96 static void hardwire_print_tty_state (struct serial *, serial_ttystate, 97 struct ui_file *); 98 static int hardwire_drain_output (struct serial *); 99 static int hardwire_flush_output (struct serial *); 100 static int hardwire_flush_input (struct serial *); 101 static int hardwire_send_break (struct serial *); 102 static int hardwire_setstopbits (struct serial *, int); 103 104 void _initialize_ser_hardwire (void); 105 106 /* Open up a real live device for serial I/O */ 107 108 static int 109 hardwire_open (struct serial *scb, const char *name) 110 { 111 scb->fd = open (name, O_RDWR); 112 if (scb->fd < 0) 113 return -1; 114 115 return 0; 116 } 117 118 static int 119 get_tty_state (struct serial *scb, struct hardwire_ttystate *state) 120 { 121 #ifdef HAVE_TERMIOS 122 if (tcgetattr (scb->fd, &state->termios) < 0) 123 return -1; 124 125 return 0; 126 #endif 127 128 #ifdef HAVE_TERMIO 129 if (ioctl (scb->fd, TCGETA, &state->termio) < 0) 130 return -1; 131 return 0; 132 #endif 133 134 #ifdef HAVE_SGTTY 135 if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0) 136 return -1; 137 if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0) 138 return -1; 139 if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0) 140 return -1; 141 if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0) 142 return -1; 143 144 return 0; 145 #endif 146 } 147 148 static int 149 set_tty_state (struct serial *scb, struct hardwire_ttystate *state) 150 { 151 #ifdef HAVE_TERMIOS 152 if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0) 153 return -1; 154 155 return 0; 156 #endif 157 158 #ifdef HAVE_TERMIO 159 if (ioctl (scb->fd, TCSETA, &state->termio) < 0) 160 return -1; 161 return 0; 162 #endif 163 164 #ifdef HAVE_SGTTY 165 if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0) 166 return -1; 167 if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0) 168 return -1; 169 if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0) 170 return -1; 171 if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0) 172 return -1; 173 174 return 0; 175 #endif 176 } 177 178 static serial_ttystate 179 hardwire_get_tty_state (struct serial *scb) 180 { 181 struct hardwire_ttystate *state; 182 183 state = (struct hardwire_ttystate *) xmalloc (sizeof *state); 184 185 if (get_tty_state (scb, state)) 186 return NULL; 187 188 return (serial_ttystate) state; 189 } 190 191 static int 192 hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate) 193 { 194 struct hardwire_ttystate *state; 195 196 state = (struct hardwire_ttystate *) ttystate; 197 198 return set_tty_state (scb, state); 199 } 200 201 static int 202 hardwire_noflush_set_tty_state (struct serial *scb, 203 serial_ttystate new_ttystate, 204 serial_ttystate old_ttystate) 205 { 206 struct hardwire_ttystate new_state; 207 #ifdef HAVE_SGTTY 208 struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate; 209 #endif 210 211 new_state = *(struct hardwire_ttystate *) new_ttystate; 212 213 /* Don't change in or out of raw mode; we don't want to flush input. 214 termio and termios have no such restriction; for them flushing input 215 is separate from setting the attributes. */ 216 217 #ifdef HAVE_SGTTY 218 if (state->sgttyb.sg_flags & RAW) 219 new_state.sgttyb.sg_flags |= RAW; 220 else 221 new_state.sgttyb.sg_flags &= ~RAW; 222 223 /* I'm not sure whether this is necessary; the manpage just mentions 224 RAW not CBREAK. */ 225 if (state->sgttyb.sg_flags & CBREAK) 226 new_state.sgttyb.sg_flags |= CBREAK; 227 else 228 new_state.sgttyb.sg_flags &= ~CBREAK; 229 #endif 230 231 return set_tty_state (scb, &new_state); 232 } 233 234 static void 235 hardwire_print_tty_state (struct serial *scb, 236 serial_ttystate ttystate, 237 struct ui_file *stream) 238 { 239 struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate; 240 int i; 241 242 #ifdef HAVE_TERMIOS 243 fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n", 244 (int) state->termios.c_iflag, 245 (int) state->termios.c_oflag); 246 fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n", 247 (int) state->termios.c_cflag, 248 (int) state->termios.c_lflag); 249 #if 0 250 /* This not in POSIX, and is not really documented by those systems 251 which have it (at least not Sun). */ 252 fprintf_filtered (stream, "c_line = 0x%x.\n", state->termios.c_line); 253 #endif 254 fprintf_filtered (stream, "c_cc: "); 255 for (i = 0; i < NCCS; i += 1) 256 fprintf_filtered (stream, "0x%x ", state->termios.c_cc[i]); 257 fprintf_filtered (stream, "\n"); 258 #endif 259 260 #ifdef HAVE_TERMIO 261 fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n", 262 state->termio.c_iflag, state->termio.c_oflag); 263 fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n", 264 state->termio.c_cflag, state->termio.c_lflag, 265 state->termio.c_line); 266 fprintf_filtered (stream, "c_cc: "); 267 for (i = 0; i < NCC; i += 1) 268 fprintf_filtered (stream, "0x%x ", state->termio.c_cc[i]); 269 fprintf_filtered (stream, "\n"); 270 #endif 271 272 #ifdef HAVE_SGTTY 273 fprintf_filtered (stream, "sgttyb.sg_flags = 0x%x.\n", 274 state->sgttyb.sg_flags); 275 276 fprintf_filtered (stream, "tchars: "); 277 for (i = 0; i < (int) sizeof (struct tchars); i++) 278 fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->tc)[i]); 279 fprintf_filtered (stream, "\n"); 280 281 fprintf_filtered (stream, "ltchars: "); 282 for (i = 0; i < (int) sizeof (struct ltchars); i++) 283 fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->ltc)[i]); 284 fprintf_filtered (stream, "\n"); 285 286 fprintf_filtered (stream, "lmode: 0x%x\n", state->lmode); 287 #endif 288 } 289 290 /* Wait for the output to drain away, as opposed to flushing (discarding) it */ 291 292 static int 293 hardwire_drain_output (struct serial *scb) 294 { 295 #ifdef HAVE_TERMIOS 296 return tcdrain (scb->fd); 297 #endif 298 299 #ifdef HAVE_TERMIO 300 return ioctl (scb->fd, TCSBRK, 1); 301 #endif 302 303 #ifdef HAVE_SGTTY 304 /* Get the current state and then restore it using TIOCSETP, 305 which should cause the output to drain and pending input 306 to be discarded. */ 307 { 308 struct hardwire_ttystate state; 309 310 if (get_tty_state (scb, &state)) 311 { 312 return (-1); 313 } 314 else 315 { 316 return (ioctl (scb->fd, TIOCSETP, &state.sgttyb)); 317 } 318 } 319 #endif 320 } 321 322 static int 323 hardwire_flush_output (struct serial *scb) 324 { 325 #ifdef HAVE_TERMIOS 326 return tcflush (scb->fd, TCOFLUSH); 327 #endif 328 329 #ifdef HAVE_TERMIO 330 return ioctl (scb->fd, TCFLSH, 1); 331 #endif 332 333 #ifdef HAVE_SGTTY 334 /* This flushes both input and output, but we can't do better. */ 335 return ioctl (scb->fd, TIOCFLUSH, 0); 336 #endif 337 } 338 339 static int 340 hardwire_flush_input (struct serial *scb) 341 { 342 ser_base_flush_input (scb); 343 344 #ifdef HAVE_TERMIOS 345 return tcflush (scb->fd, TCIFLUSH); 346 #endif 347 348 #ifdef HAVE_TERMIO 349 return ioctl (scb->fd, TCFLSH, 0); 350 #endif 351 352 #ifdef HAVE_SGTTY 353 /* This flushes both input and output, but we can't do better. */ 354 return ioctl (scb->fd, TIOCFLUSH, 0); 355 #endif 356 } 357 358 static int 359 hardwire_send_break (struct serial *scb) 360 { 361 #ifdef HAVE_TERMIOS 362 return tcsendbreak (scb->fd, 0); 363 #endif 364 365 #ifdef HAVE_TERMIO 366 return ioctl (scb->fd, TCSBRK, 0); 367 #endif 368 369 #ifdef HAVE_SGTTY 370 { 371 int status; 372 373 status = ioctl (scb->fd, TIOCSBRK, 0); 374 375 /* Can't use usleep; it doesn't exist in BSD 4.2. */ 376 /* Note that if this gdb_select() is interrupted by a signal it will not 377 wait the full length of time. I think that is OK. */ 378 gdb_usleep (250000); 379 status = ioctl (scb->fd, TIOCCBRK, 0); 380 return status; 381 } 382 #endif 383 } 384 385 static void 386 hardwire_raw (struct serial *scb) 387 { 388 struct hardwire_ttystate state; 389 390 if (get_tty_state (scb, &state)) 391 fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno)); 392 393 #ifdef HAVE_TERMIOS 394 state.termios.c_iflag = 0; 395 state.termios.c_oflag = 0; 396 state.termios.c_lflag = 0; 397 state.termios.c_cflag &= ~(CSIZE | PARENB); 398 state.termios.c_cflag |= CLOCAL | CS8; 399 #ifdef CRTSCTS 400 /* h/w flow control. */ 401 if (serial_hwflow) 402 state.termios.c_cflag |= CRTSCTS; 403 else 404 state.termios.c_cflag &= ~CRTSCTS; 405 #ifdef CRTS_IFLOW 406 if (serial_hwflow) 407 state.termios.c_cflag |= CRTS_IFLOW; 408 else 409 state.termios.c_cflag &= ~CRTS_IFLOW; 410 #endif 411 #endif 412 state.termios.c_cc[VMIN] = 0; 413 state.termios.c_cc[VTIME] = 0; 414 #endif 415 416 #ifdef HAVE_TERMIO 417 state.termio.c_iflag = 0; 418 state.termio.c_oflag = 0; 419 state.termio.c_lflag = 0; 420 state.termio.c_cflag &= ~(CSIZE | PARENB); 421 state.termio.c_cflag |= CLOCAL | CS8; 422 state.termio.c_cc[VMIN] = 0; 423 state.termio.c_cc[VTIME] = 0; 424 #endif 425 426 #ifdef HAVE_SGTTY 427 state.sgttyb.sg_flags |= RAW | ANYP; 428 state.sgttyb.sg_flags &= ~(CBREAK | ECHO); 429 #endif 430 431 scb->current_timeout = 0; 432 433 if (set_tty_state (scb, &state)) 434 fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno)); 435 } 436 437 /* Wait for input on scb, with timeout seconds. Returns 0 on success, 438 otherwise SERIAL_TIMEOUT or SERIAL_ERROR. 439 440 For termio{s}, we actually just setup VTIME if necessary, and let the 441 timeout occur in the read() in hardwire_read(). 442 */ 443 444 /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent 445 ser_base*() until the old TERMIOS/SGTTY/... timer code has been 446 flushed. . */ 447 448 /* NOTE: cagney/1999-09-30: Much of the code below is dead. The only 449 possible values of the TIMEOUT parameter are ONE and ZERO. 450 Consequently all the code that tries to handle the possability of 451 an overflowed timer is unnecessary. */ 452 453 static int 454 wait_for (struct serial *scb, int timeout) 455 { 456 #ifdef HAVE_SGTTY 457 while (1) 458 { 459 struct timeval tv; 460 fd_set readfds; 461 int numfds; 462 463 /* NOTE: Some OS's can scramble the READFDS when the select() 464 call fails (ex the kernel with Red Hat 5.2). Initialize all 465 arguments before each call. */ 466 467 tv.tv_sec = timeout; 468 tv.tv_usec = 0; 469 470 FD_ZERO (&readfds); 471 FD_SET (scb->fd, &readfds); 472 473 if (timeout >= 0) 474 numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, &tv); 475 else 476 numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, 0); 477 478 if (numfds <= 0) 479 if (numfds == 0) 480 return SERIAL_TIMEOUT; 481 else if (errno == EINTR) 482 continue; 483 else 484 return SERIAL_ERROR; /* Got an error from select or poll */ 485 486 return 0; 487 } 488 #endif /* HAVE_SGTTY */ 489 490 #if defined HAVE_TERMIO || defined HAVE_TERMIOS 491 if (timeout == scb->current_timeout) 492 return 0; 493 494 scb->current_timeout = timeout; 495 496 { 497 struct hardwire_ttystate state; 498 499 if (get_tty_state (scb, &state)) 500 fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno)); 501 502 #ifdef HAVE_TERMIOS 503 if (timeout < 0) 504 { 505 /* No timeout. */ 506 state.termios.c_cc[VTIME] = 0; 507 state.termios.c_cc[VMIN] = 1; 508 } 509 else 510 { 511 state.termios.c_cc[VMIN] = 0; 512 state.termios.c_cc[VTIME] = timeout * 10; 513 if (state.termios.c_cc[VTIME] != timeout * 10) 514 { 515 516 /* If c_cc is an 8-bit signed character, we can't go 517 bigger than this. If it is always unsigned, we could use 518 25. */ 519 520 scb->current_timeout = 12; 521 state.termios.c_cc[VTIME] = scb->current_timeout * 10; 522 scb->timeout_remaining = timeout - scb->current_timeout; 523 } 524 } 525 #endif 526 527 #ifdef HAVE_TERMIO 528 if (timeout < 0) 529 { 530 /* No timeout. */ 531 state.termio.c_cc[VTIME] = 0; 532 state.termio.c_cc[VMIN] = 1; 533 } 534 else 535 { 536 state.termio.c_cc[VMIN] = 0; 537 state.termio.c_cc[VTIME] = timeout * 10; 538 if (state.termio.c_cc[VTIME] != timeout * 10) 539 { 540 /* If c_cc is an 8-bit signed character, we can't go 541 bigger than this. If it is always unsigned, we could use 542 25. */ 543 544 scb->current_timeout = 12; 545 state.termio.c_cc[VTIME] = scb->current_timeout * 10; 546 scb->timeout_remaining = timeout - scb->current_timeout; 547 } 548 } 549 #endif 550 551 if (set_tty_state (scb, &state)) 552 fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno)); 553 554 return 0; 555 } 556 #endif /* HAVE_TERMIO || HAVE_TERMIOS */ 557 } 558 559 /* Read a character with user-specified timeout. TIMEOUT is number of seconds 560 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns 561 char if successful. Returns SERIAL_TIMEOUT if timeout expired, EOF if line 562 dropped dead, or SERIAL_ERROR for any other error (see errno in that case). */ 563 564 /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent 565 ser_base*() until the old TERMIOS/SGTTY/... timer code has been 566 flushed. */ 567 568 /* NOTE: cagney/1999-09-16: This function is not identical to 569 ser_base_readchar() as part of replacing it with ser_base*() 570 merging will be required - this code handles the case where read() 571 times out due to no data while ser_base_readchar() doesn't expect 572 that. */ 573 574 static int 575 do_hardwire_readchar (struct serial *scb, int timeout) 576 { 577 int status, delta; 578 int detach = 0; 579 580 if (timeout > 0) 581 timeout++; 582 583 /* We have to be able to keep the GUI alive here, so we break the 584 original timeout into steps of 1 second, running the "keep the 585 GUI alive" hook each time through the loop. 586 587 Also, timeout = 0 means to poll, so we just set the delta to 0, 588 so we will only go through the loop once. */ 589 590 delta = (timeout == 0 ? 0 : 1); 591 while (1) 592 { 593 594 /* N.B. The UI may destroy our world (for instance by calling 595 remote_stop,) in which case we want to get out of here as 596 quickly as possible. It is not safe to touch scb, since 597 someone else might have freed it. The 598 deprecated_ui_loop_hook signals that we should exit by 599 returning 1. */ 600 601 if (deprecated_ui_loop_hook) 602 detach = deprecated_ui_loop_hook (0); 603 604 if (detach) 605 return SERIAL_TIMEOUT; 606 607 scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta); 608 status = wait_for (scb, delta); 609 610 if (status < 0) 611 return status; 612 613 status = read (scb->fd, scb->buf, BUFSIZ); 614 615 if (status <= 0) 616 { 617 if (status == 0) 618 { 619 /* Zero characters means timeout (it could also be EOF, but 620 we don't (yet at least) distinguish). */ 621 if (scb->timeout_remaining > 0) 622 { 623 timeout = scb->timeout_remaining; 624 continue; 625 } 626 else if (scb->timeout_remaining < 0) 627 continue; 628 else 629 return SERIAL_TIMEOUT; 630 } 631 else if (errno == EINTR) 632 continue; 633 else 634 return SERIAL_ERROR; /* Got an error from read */ 635 } 636 637 scb->bufcnt = status; 638 scb->bufcnt--; 639 scb->bufp = scb->buf; 640 return *scb->bufp++; 641 } 642 } 643 644 static int 645 hardwire_readchar (struct serial *scb, int timeout) 646 { 647 return generic_readchar (scb, timeout, do_hardwire_readchar); 648 } 649 650 651 #ifndef B19200 652 #define B19200 EXTA 653 #endif 654 655 #ifndef B38400 656 #define B38400 EXTB 657 #endif 658 659 /* Translate baud rates from integers to damn B_codes. Unix should 660 have outgrown this crap years ago, but even POSIX wouldn't buck it. */ 661 662 static struct 663 { 664 int rate; 665 int code; 666 } 667 baudtab[] = 668 { 669 { 670 50, B50 671 } 672 , 673 { 674 75, B75 675 } 676 , 677 { 678 110, B110 679 } 680 , 681 { 682 134, B134 683 } 684 , 685 { 686 150, B150 687 } 688 , 689 { 690 200, B200 691 } 692 , 693 { 694 300, B300 695 } 696 , 697 { 698 600, B600 699 } 700 , 701 { 702 1200, B1200 703 } 704 , 705 { 706 1800, B1800 707 } 708 , 709 { 710 2400, B2400 711 } 712 , 713 { 714 4800, B4800 715 } 716 , 717 { 718 9600, B9600 719 } 720 , 721 { 722 19200, B19200 723 } 724 , 725 { 726 38400, B38400 727 } 728 , 729 #ifdef B57600 730 { 731 57600, B57600 732 } 733 , 734 #endif 735 #ifdef B115200 736 { 737 115200, B115200 738 } 739 , 740 #endif 741 #ifdef B230400 742 { 743 230400, B230400 744 } 745 , 746 #endif 747 #ifdef B460800 748 { 749 460800, B460800 750 } 751 , 752 #endif 753 { 754 -1, -1 755 } 756 , 757 }; 758 759 static int 760 rate_to_code (int rate) 761 { 762 int i; 763 764 for (i = 0; baudtab[i].rate != -1; i++) 765 { 766 /* test for perfect macth. */ 767 if (rate == baudtab[i].rate) 768 return baudtab[i].code; 769 else 770 { 771 /* check if it is in between valid values. */ 772 if (rate < baudtab[i].rate) 773 { 774 if (i) 775 { 776 warning (_("Invalid baud rate %d. Closest values are %d and %d."), 777 rate, baudtab[i - 1].rate, baudtab[i].rate); 778 } 779 else 780 { 781 warning (_("Invalid baud rate %d. Minimum value is %d."), 782 rate, baudtab[0].rate); 783 } 784 return -1; 785 } 786 } 787 } 788 789 /* The requested speed was too large. */ 790 warning (_("Invalid baud rate %d. Maximum value is %d."), 791 rate, baudtab[i - 1].rate); 792 return -1; 793 } 794 795 static int 796 hardwire_setbaudrate (struct serial *scb, int rate) 797 { 798 struct hardwire_ttystate state; 799 int baud_code = rate_to_code (rate); 800 801 if (baud_code < 0) 802 { 803 /* The baud rate was not valid. 804 A warning has already been issued. */ 805 errno = EINVAL; 806 return -1; 807 } 808 809 if (get_tty_state (scb, &state)) 810 return -1; 811 812 #ifdef HAVE_TERMIOS 813 cfsetospeed (&state.termios, baud_code); 814 cfsetispeed (&state.termios, baud_code); 815 #endif 816 817 #ifdef HAVE_TERMIO 818 #ifndef CIBAUD 819 #define CIBAUD CBAUD 820 #endif 821 822 state.termio.c_cflag &= ~(CBAUD | CIBAUD); 823 state.termio.c_cflag |= baud_code; 824 #endif 825 826 #ifdef HAVE_SGTTY 827 state.sgttyb.sg_ispeed = baud_code; 828 state.sgttyb.sg_ospeed = baud_code; 829 #endif 830 831 return set_tty_state (scb, &state); 832 } 833 834 static int 835 hardwire_setstopbits (struct serial *scb, int num) 836 { 837 struct hardwire_ttystate state; 838 int newbit; 839 840 if (get_tty_state (scb, &state)) 841 return -1; 842 843 switch (num) 844 { 845 case SERIAL_1_STOPBITS: 846 newbit = 0; 847 break; 848 case SERIAL_1_AND_A_HALF_STOPBITS: 849 case SERIAL_2_STOPBITS: 850 newbit = 1; 851 break; 852 default: 853 return 1; 854 } 855 856 #ifdef HAVE_TERMIOS 857 if (!newbit) 858 state.termios.c_cflag &= ~CSTOPB; 859 else 860 state.termios.c_cflag |= CSTOPB; /* two bits */ 861 #endif 862 863 #ifdef HAVE_TERMIO 864 if (!newbit) 865 state.termio.c_cflag &= ~CSTOPB; 866 else 867 state.termio.c_cflag |= CSTOPB; /* two bits */ 868 #endif 869 870 #ifdef HAVE_SGTTY 871 return 0; /* sgtty doesn't support this */ 872 #endif 873 874 return set_tty_state (scb, &state); 875 } 876 877 static void 878 hardwire_close (struct serial *scb) 879 { 880 if (scb->fd < 0) 881 return; 882 883 close (scb->fd); 884 scb->fd = -1; 885 } 886 887 888 void 889 _initialize_ser_hardwire (void) 890 { 891 struct serial_ops *ops = XMALLOC (struct serial_ops); 892 893 memset (ops, 0, sizeof (struct serial_ops)); 894 ops->name = "hardwire"; 895 ops->next = 0; 896 ops->open = hardwire_open; 897 ops->close = hardwire_close; 898 /* FIXME: Don't replace this with the equivalent ser_base*() until 899 the old TERMIOS/SGTTY/... timer code has been flushed. cagney 900 1999-09-16. */ 901 ops->readchar = hardwire_readchar; 902 ops->write = ser_base_write; 903 ops->flush_output = hardwire_flush_output; 904 ops->flush_input = hardwire_flush_input; 905 ops->send_break = hardwire_send_break; 906 ops->go_raw = hardwire_raw; 907 ops->get_tty_state = hardwire_get_tty_state; 908 ops->set_tty_state = hardwire_set_tty_state; 909 ops->print_tty_state = hardwire_print_tty_state; 910 ops->noflush_set_tty_state = hardwire_noflush_set_tty_state; 911 ops->setbaudrate = hardwire_setbaudrate; 912 ops->setstopbits = hardwire_setstopbits; 913 ops->drain_output = hardwire_drain_output; 914 ops->async = ser_base_async; 915 ops->read_prim = ser_unix_read_prim; 916 ops->write_prim = ser_unix_write_prim; 917 serial_add_interface (ops); 918 919 #ifdef HAVE_TERMIOS 920 #ifdef CRTSCTS 921 add_setshow_boolean_cmd ("remoteflow", no_class, 922 &serial_hwflow, _("\ 923 Set use of hardware flow control for remote serial I/O."), _("\ 924 Show use of hardware flow control for remote serial I/O."), _("\ 925 Enable or disable hardware flow control (RTS/CTS) on the serial port\n\ 926 when debugging using remote targets."), 927 NULL, 928 show_serial_hwflow, 929 &setlist, &showlist); 930 #endif 931 #endif 932 } 933 934 int 935 ser_unix_read_prim (struct serial *scb, size_t count) 936 { 937 int status; 938 939 while (1) 940 { 941 status = read (scb->fd, scb->buf, count); 942 if (status != -1 || errno != EINTR) 943 break; 944 } 945 return status; 946 } 947 948 int 949 ser_unix_write_prim (struct serial *scb, const void *buf, size_t len) 950 { 951 /* ??? Historically, GDB has not retried calls to "write" that 952 result in EINTR. */ 953 return write (scb->fd, buf, len); 954 } 955