1 /* Serial interface for local (hardwired) serial ports on Un*x like systems
3 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2003,
4 2004, 2005, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6 This file is part of GDB.
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.
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.
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/>. */
27 #include <sys/types.h>
29 #include <sys/socket.h>
32 #include "gdb_select.h"
33 #include "gdb_string.h"
38 struct hardwire_ttystate
40 struct termios termios;
44 /* Boolean to explicitly enable or disable h/w flow control. */
45 static int serial_hwflow;
47 show_serial_hwflow (struct ui_file *file, int from_tty,
48 struct cmd_list_element *c, const char *value)
50 fprintf_filtered (file, _("Hardware flow control is %s.\n"), value);
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. */
63 struct hardwire_ttystate
70 struct hardwire_ttystate
75 /* Line discipline flags. */
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,
96 static void hardwire_print_tty_state (struct serial *, serial_ttystate,
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);
104 void _initialize_ser_hardwire (void);
106 /* Open up a real live device for serial I/O */
109 hardwire_open (struct serial *scb, const char *name)
111 scb->fd = open (name, O_RDWR);
119 get_tty_state (struct serial *scb, struct hardwire_ttystate *state)
122 if (tcgetattr (scb->fd, &state->termios) < 0)
129 if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
135 if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
137 if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
139 if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
141 if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
149 set_tty_state (struct serial *scb, struct hardwire_ttystate *state)
152 if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
159 if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
165 if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
167 if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0)
169 if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0)
171 if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0)
178 static serial_ttystate
179 hardwire_get_tty_state (struct serial *scb)
181 struct hardwire_ttystate *state;
183 state = (struct hardwire_ttystate *) xmalloc (sizeof *state);
185 if (get_tty_state (scb, state))
188 return (serial_ttystate) state;
192 hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
194 struct hardwire_ttystate *state;
196 state = (struct hardwire_ttystate *) ttystate;
198 return set_tty_state (scb, state);
202 hardwire_noflush_set_tty_state (struct serial *scb,
203 serial_ttystate new_ttystate,
204 serial_ttystate old_ttystate)
206 struct hardwire_ttystate new_state;
208 struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
211 new_state = *(struct hardwire_ttystate *) new_ttystate;
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. */
218 if (state->sgttyb.sg_flags & RAW)
219 new_state.sgttyb.sg_flags |= RAW;
221 new_state.sgttyb.sg_flags &= ~RAW;
223 /* I'm not sure whether this is necessary; the manpage just mentions
225 if (state->sgttyb.sg_flags & CBREAK)
226 new_state.sgttyb.sg_flags |= CBREAK;
228 new_state.sgttyb.sg_flags &= ~CBREAK;
231 return set_tty_state (scb, &new_state);
235 hardwire_print_tty_state (struct serial *scb,
236 serial_ttystate ttystate,
237 struct ui_file *stream)
239 struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
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);
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);
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");
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");
273 fprintf_filtered (stream, "sgttyb.sg_flags = 0x%x.\n",
274 state->sgttyb.sg_flags);
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");
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");
286 fprintf_filtered (stream, "lmode: 0x%x\n", state->lmode);
290 /* Wait for the output to drain away, as opposed to flushing (discarding) it */
293 hardwire_drain_output (struct serial *scb)
296 return tcdrain (scb->fd);
300 return ioctl (scb->fd, TCSBRK, 1);
304 /* Get the current state and then restore it using TIOCSETP,
305 which should cause the output to drain and pending input
308 struct hardwire_ttystate state;
310 if (get_tty_state (scb, &state))
316 return (ioctl (scb->fd, TIOCSETP, &state.sgttyb));
323 hardwire_flush_output (struct serial *scb)
326 return tcflush (scb->fd, TCOFLUSH);
330 return ioctl (scb->fd, TCFLSH, 1);
334 /* This flushes both input and output, but we can't do better. */
335 return ioctl (scb->fd, TIOCFLUSH, 0);
340 hardwire_flush_input (struct serial *scb)
342 ser_base_flush_input (scb);
345 return tcflush (scb->fd, TCIFLUSH);
349 return ioctl (scb->fd, TCFLSH, 0);
353 /* This flushes both input and output, but we can't do better. */
354 return ioctl (scb->fd, TIOCFLUSH, 0);
359 hardwire_send_break (struct serial *scb)
362 return tcsendbreak (scb->fd, 0);
366 return ioctl (scb->fd, TCSBRK, 0);
373 status = ioctl (scb->fd, TIOCSBRK, 0);
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. */
379 status = ioctl (scb->fd, TIOCCBRK, 0);
386 hardwire_raw (struct serial *scb)
388 struct hardwire_ttystate state;
390 if (get_tty_state (scb, &state))
391 fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
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;
400 /* h/w flow control. */
402 state.termios.c_cflag |= CRTSCTS;
404 state.termios.c_cflag &= ~CRTSCTS;
407 state.termios.c_cflag |= CRTS_IFLOW;
409 state.termios.c_cflag &= ~CRTS_IFLOW;
412 state.termios.c_cc[VMIN] = 0;
413 state.termios.c_cc[VTIME] = 0;
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;
427 state.sgttyb.sg_flags |= RAW | ANYP;
428 state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
431 scb->current_timeout = 0;
433 if (set_tty_state (scb, &state))
434 fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
437 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
438 otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
440 For termio{s}, we actually just setup VTIME if necessary, and let the
441 timeout occur in the read() in hardwire_read().
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
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. */
454 wait_for (struct serial *scb, int timeout)
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. */
471 FD_SET (scb->fd, &readfds);
474 numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, &tv);
476 numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, 0);
480 return SERIAL_TIMEOUT;
481 else if (errno == EINTR)
484 return SERIAL_ERROR; /* Got an error from select or poll */
488 #endif /* HAVE_SGTTY */
490 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
491 if (timeout == scb->current_timeout)
494 scb->current_timeout = timeout;
497 struct hardwire_ttystate state;
499 if (get_tty_state (scb, &state))
500 fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
506 state.termios.c_cc[VTIME] = 0;
507 state.termios.c_cc[VMIN] = 1;
511 state.termios.c_cc[VMIN] = 0;
512 state.termios.c_cc[VTIME] = timeout * 10;
513 if (state.termios.c_cc[VTIME] != timeout * 10)
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
520 scb->current_timeout = 12;
521 state.termios.c_cc[VTIME] = scb->current_timeout * 10;
522 scb->timeout_remaining = timeout - scb->current_timeout;
531 state.termio.c_cc[VTIME] = 0;
532 state.termio.c_cc[VMIN] = 1;
536 state.termio.c_cc[VMIN] = 0;
537 state.termio.c_cc[VTIME] = timeout * 10;
538 if (state.termio.c_cc[VTIME] != timeout * 10)
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
544 scb->current_timeout = 12;
545 state.termio.c_cc[VTIME] = scb->current_timeout * 10;
546 scb->timeout_remaining = timeout - scb->current_timeout;
551 if (set_tty_state (scb, &state))
552 fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
556 #endif /* HAVE_TERMIO || HAVE_TERMIOS */
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). */
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
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
575 do_hardwire_readchar (struct serial *scb, int timeout)
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.
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. */
590 delta = (timeout == 0 ? 0 : 1);
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
601 if (deprecated_ui_loop_hook)
602 detach = deprecated_ui_loop_hook (0);
605 return SERIAL_TIMEOUT;
607 scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta);
608 status = wait_for (scb, delta);
613 status = read (scb->fd, scb->buf, BUFSIZ);
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)
623 timeout = scb->timeout_remaining;
626 else if (scb->timeout_remaining < 0)
629 return SERIAL_TIMEOUT;
631 else if (errno == EINTR)
634 return SERIAL_ERROR; /* Got an error from read */
637 scb->bufcnt = status;
639 scb->bufp = scb->buf;
645 hardwire_readchar (struct serial *scb, int timeout)
647 return generic_readchar (scb, timeout, do_hardwire_readchar);
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. */
760 rate_to_code (int rate)
764 for (i = 0; baudtab[i].rate != -1; i++)
766 /* test for perfect macth. */
767 if (rate == baudtab[i].rate)
768 return baudtab[i].code;
771 /* check if it is in between valid values. */
772 if (rate < baudtab[i].rate)
776 warning (_("Invalid baud rate %d. Closest values are %d and %d."),
777 rate, baudtab[i - 1].rate, baudtab[i].rate);
781 warning (_("Invalid baud rate %d. Minimum value is %d."),
782 rate, baudtab[0].rate);
789 /* The requested speed was too large. */
790 warning (_("Invalid baud rate %d. Maximum value is %d."),
791 rate, baudtab[i - 1].rate);
796 hardwire_setbaudrate (struct serial *scb, int rate)
798 struct hardwire_ttystate state;
799 int baud_code = rate_to_code (rate);
803 /* The baud rate was not valid.
804 A warning has already been issued. */
809 if (get_tty_state (scb, &state))
813 cfsetospeed (&state.termios, baud_code);
814 cfsetispeed (&state.termios, baud_code);
822 state.termio.c_cflag &= ~(CBAUD | CIBAUD);
823 state.termio.c_cflag |= baud_code;
827 state.sgttyb.sg_ispeed = baud_code;
828 state.sgttyb.sg_ospeed = baud_code;
831 return set_tty_state (scb, &state);
835 hardwire_setstopbits (struct serial *scb, int num)
837 struct hardwire_ttystate state;
840 if (get_tty_state (scb, &state))
845 case SERIAL_1_STOPBITS:
848 case SERIAL_1_AND_A_HALF_STOPBITS:
849 case SERIAL_2_STOPBITS:
858 state.termios.c_cflag &= ~CSTOPB;
860 state.termios.c_cflag |= CSTOPB; /* two bits */
865 state.termio.c_cflag &= ~CSTOPB;
867 state.termio.c_cflag |= CSTOPB; /* two bits */
871 return 0; /* sgtty doesn't support this */
874 return set_tty_state (scb, &state);
878 hardwire_close (struct serial *scb)
889 _initialize_ser_hardwire (void)
891 struct serial_ops *ops = XMALLOC (struct serial_ops);
893 memset (ops, 0, sizeof (struct serial_ops));
894 ops->name = "hardwire";
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
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);
921 add_setshow_boolean_cmd ("remoteflow", no_class,
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."),
929 &setlist, &showlist);
935 ser_unix_read_prim (struct serial *scb, size_t count)
941 status = read (scb->fd, scb->buf, count);
942 if (status != -1 || errno != EINTR)
949 ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
951 /* ??? Historically, GDB has not retried calls to "write" that
953 return write (scb->fd, buf, len);