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