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