1 /* Serial interface for local (hardwired) serial ports on Un*x like systems
2 Copyright 1992, 1993, 1994 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 #include <sys/types.h>
31 struct hardwire_ttystate
33 struct termios termios;
39 /* It is believed that all systems which have added job control to SVR3
40 (e.g. sco) have also added termios. Even if not, trying to figure out
41 all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
42 bewildering. So we don't attempt it. */
44 struct hardwire_ttystate
51 /* Needed for the code which uses select(). We would include <sys/select.h>
52 too if it existed on all systems. */
55 struct hardwire_ttystate
60 /* Line discipline flags. */
65 static int hardwire_open PARAMS ((serial_t scb, const char *name));
66 static void hardwire_raw PARAMS ((serial_t scb));
67 static int wait_for PARAMS ((serial_t scb, int timeout));
68 static int hardwire_readchar PARAMS ((serial_t scb, int timeout));
69 static int rate_to_code PARAMS ((int rate));
70 static int hardwire_setbaudrate PARAMS ((serial_t scb, int rate));
71 static int hardwire_write PARAMS ((serial_t scb, const char *str, int len));
72 static void hardwire_close PARAMS ((serial_t scb));
73 static int get_tty_state PARAMS ((serial_t scb, struct hardwire_ttystate *state));
74 static int set_tty_state PARAMS ((serial_t scb, struct hardwire_ttystate *state));
75 static serial_ttystate hardwire_get_tty_state PARAMS ((serial_t scb));
76 static int hardwire_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
77 static int hardwire_noflush_set_tty_state PARAMS ((serial_t, serial_ttystate,
79 static void hardwire_print_tty_state PARAMS ((serial_t, serial_ttystate));
80 static int hardwire_drain_output PARAMS ((serial_t));
81 static int hardwire_flush_output PARAMS ((serial_t));
82 static int hardwire_flush_input PARAMS ((serial_t));
83 static int hardwire_send_break PARAMS ((serial_t));
84 static int hardwire_setstopbits PARAMS ((serial_t, int));
86 /* Open up a real live device for serial I/O */
89 hardwire_open(scb, name)
93 scb->fd = open (name, O_RDWR);
101 get_tty_state(scb, state)
103 struct hardwire_ttystate *state;
108 if (tcgetattr(scb->fd, &state->termios) < 0)
115 if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
121 if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
123 if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
125 if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
127 if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
135 set_tty_state(scb, state)
137 struct hardwire_ttystate *state;
140 if (tcsetattr(scb->fd, TCSANOW, &state->termios) < 0)
147 if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
153 if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
155 if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0)
157 if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0)
159 if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0)
166 static serial_ttystate
167 hardwire_get_tty_state(scb)
170 struct hardwire_ttystate *state;
172 state = (struct hardwire_ttystate *)xmalloc(sizeof *state);
174 if (get_tty_state(scb, state))
177 return (serial_ttystate)state;
181 hardwire_set_tty_state(scb, ttystate)
183 serial_ttystate ttystate;
185 struct hardwire_ttystate *state;
187 state = (struct hardwire_ttystate *)ttystate;
189 return set_tty_state(scb, state);
193 hardwire_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
195 serial_ttystate new_ttystate;
196 serial_ttystate old_ttystate;
198 struct hardwire_ttystate new_state;
200 struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
203 new_state = *(struct hardwire_ttystate *)new_ttystate;
205 /* Don't change in or out of raw mode; we don't want to flush input.
206 termio and termios have no such restriction; for them flushing input
207 is separate from setting the attributes. */
210 if (state->sgttyb.sg_flags & RAW)
211 new_state.sgttyb.sg_flags |= RAW;
213 new_state.sgttyb.sg_flags &= ~RAW;
215 /* I'm not sure whether this is necessary; the manpage just mentions
217 if (state->sgttyb.sg_flags & CBREAK)
218 new_state.sgttyb.sg_flags |= CBREAK;
220 new_state.sgttyb.sg_flags &= ~CBREAK;
223 return set_tty_state (scb, &new_state);
227 hardwire_print_tty_state (scb, ttystate)
229 serial_ttystate ttystate;
231 struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
235 printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
236 state->termios.c_iflag, state->termios.c_oflag);
237 printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x\n",
238 state->termios.c_cflag, state->termios.c_lflag);
240 /* This not in POSIX, and is not really documented by those systems
241 which have it (at least not Sun). */
242 printf_filtered ("c_line = 0x%x.\n", state->termios.c_line);
244 printf_filtered ("c_cc: ");
245 for (i = 0; i < NCCS; i += 1)
246 printf_filtered ("0x%x ", state->termios.c_cc[i]);
247 printf_filtered ("\n");
251 printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
252 state->termio.c_iflag, state->termio.c_oflag);
253 printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
254 state->termio.c_cflag, state->termio.c_lflag,
255 state->termio.c_line);
256 printf_filtered ("c_cc: ");
257 for (i = 0; i < NCC; i += 1)
258 printf_filtered ("0x%x ", state->termio.c_cc[i]);
259 printf_filtered ("\n");
263 printf_filtered ("sgttyb.sg_flags = 0x%x.\n", state->sgttyb.sg_flags);
265 printf_filtered ("tchars: ");
266 for (i = 0; i < (int)sizeof (struct tchars); i++)
267 printf_filtered ("0x%x ", ((unsigned char *)&state->tc)[i]);
268 printf_filtered ("\n");
270 printf_filtered ("ltchars: ");
271 for (i = 0; i < (int)sizeof (struct ltchars); i++)
272 printf_filtered ("0x%x ", ((unsigned char *)&state->ltc)[i]);
273 printf_filtered ("\n");
275 printf_filtered ("lmode: 0x%x\n", state->lmode);
279 /* Wait for the output to drain away, as opposed to flushing (discarding) it */
282 hardwire_drain_output (scb)
286 return tcdrain (scb->fd);
290 return ioctl (scb->fd, TCSBRK, 1);
294 /* Get the current state and then restore it using TIOCSETP,
295 which should cause the output to drain and pending input
298 struct hardwire_ttystate state;
299 if (get_tty_state (scb, &state))
305 return (ioctl (scb->fd, TIOCSETP, &state.sgttyb));
312 hardwire_flush_output (scb)
316 return tcflush (scb->fd, TCOFLUSH);
320 return ioctl (scb->fd, TCFLSH, 1);
324 /* This flushes both input and output, but we can't do better. */
325 return ioctl (scb->fd, TIOCFLUSH, 0);
330 hardwire_flush_input (scb)
334 scb->bufp = scb->buf;
337 return tcflush (scb->fd, TCIFLUSH);
341 return ioctl (scb->fd, TCFLSH, 0);
345 /* This flushes both input and output, but we can't do better. */
346 return ioctl (scb->fd, TIOCFLUSH, 0);
351 hardwire_send_break (scb)
355 return tcsendbreak (scb->fd, 0);
359 return ioctl (scb->fd, TCSBRK, 0);
365 struct timeval timeout;
367 status = ioctl (scb->fd, TIOCSBRK, 0);
369 /* Can't use usleep; it doesn't exist in BSD 4.2. */
370 /* Note that if this select() is interrupted by a signal it will not wait
371 the full length of time. I think that is OK. */
373 timeout.tv_usec = 250000;
374 select (0, 0, 0, 0, &timeout);
375 status = ioctl (scb->fd, TIOCCBRK, 0);
385 struct hardwire_ttystate state;
387 if (get_tty_state(scb, &state))
388 fprintf_unfiltered(gdb_stderr, "get_tty_state failed: %s\n", safe_strerror(errno));
391 state.termios.c_iflag = 0;
392 state.termios.c_oflag = 0;
393 state.termios.c_lflag = 0;
394 state.termios.c_cflag &= ~(CSIZE|PARENB);
395 state.termios.c_cflag |= CLOCAL | CS8;
396 state.termios.c_cc[VMIN] = 0;
397 state.termios.c_cc[VTIME] = 0;
401 state.termio.c_iflag = 0;
402 state.termio.c_oflag = 0;
403 state.termio.c_lflag = 0;
404 state.termio.c_cflag &= ~(CSIZE|PARENB);
405 state.termio.c_cflag |= CLOCAL | CS8;
406 state.termio.c_cc[VMIN] = 0;
407 state.termio.c_cc[VTIME] = 0;
411 state.sgttyb.sg_flags |= RAW | ANYP;
412 state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
415 scb->current_timeout = 0;
417 if (set_tty_state (scb, &state))
418 fprintf_unfiltered(gdb_stderr, "set_tty_state failed: %s\n", safe_strerror(errno));
421 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
422 otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
424 For termio{s}, we actually just setup VTIME if necessary, and let the
425 timeout occur in the read() in hardwire_read().
429 wait_for(scb, timeout)
433 scb->timeout_remaining = 0;
445 FD_SET(scb->fd, &readfds);
452 numfds = select(scb->fd+1, &readfds, 0, 0, &tv);
454 numfds = select(scb->fd+1, &readfds, 0, 0, 0);
458 return SERIAL_TIMEOUT;
459 else if (errno == EINTR)
462 return SERIAL_ERROR; /* Got an error from select or poll */
467 #endif /* HAVE_SGTTY */
469 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
470 if (timeout == scb->current_timeout)
473 scb->current_timeout = timeout;
476 struct hardwire_ttystate state;
478 if (get_tty_state(scb, &state))
479 fprintf_unfiltered(gdb_stderr, "get_tty_state failed: %s\n", safe_strerror(errno));
485 state.termios.c_cc[VTIME] = 0;
486 state.termios.c_cc[VMIN] = 1;
490 state.termios.c_cc[VMIN] = 0;
491 state.termios.c_cc[VTIME] = timeout * 10;
492 if (state.termios.c_cc[VTIME] != timeout * 10)
495 /* If c_cc is an 8-bit signed character, we can't go
496 bigger than this. If it is always unsigned, we could use
499 scb->current_timeout = 12;
500 state.termios.c_cc[VTIME] = scb->current_timeout * 10;
501 scb->timeout_remaining = timeout - scb->current_timeout;
510 state.termio.c_cc[VTIME] = 0;
511 state.termio.c_cc[VMIN] = 1;
515 state.termio.c_cc[VMIN] = 0;
516 state.termio.c_cc[VTIME] = timeout * 10;
517 if (state.termio.c_cc[VTIME] != timeout * 10)
519 /* If c_cc is an 8-bit signed character, we can't go
520 bigger than this. If it is always unsigned, we could use
523 scb->current_timeout = 12;
524 state.termio.c_cc[VTIME] = scb->current_timeout * 10;
525 scb->timeout_remaining = timeout - scb->current_timeout;
530 if (set_tty_state (scb, &state))
531 fprintf_unfiltered(gdb_stderr, "set_tty_state failed: %s\n", safe_strerror(errno));
535 #endif /* HAVE_TERMIO || HAVE_TERMIOS */
538 /* Read a character with user-specified timeout. TIMEOUT is number of seconds
539 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
540 char if successful. Returns SERIAL_TIMEOUT if timeout expired, EOF if line
541 dropped dead, or SERIAL_ERROR for any other error (see errno in that case). */
544 hardwire_readchar(scb, timeout)
550 if (scb->bufcnt-- > 0)
555 status = wait_for (scb, timeout);
560 scb->bufcnt = read (scb->fd, scb->buf, BUFSIZ);
562 if (scb->bufcnt <= 0)
564 if (scb->bufcnt == 0)
566 /* Zero characters means timeout (it could also be EOF, but
567 we don't (yet at least) distinguish). */
568 if (scb->timeout_remaining > 0)
570 timeout = scb->timeout_remaining;
574 return SERIAL_TIMEOUT;
576 else if (errno == EINTR)
579 return SERIAL_ERROR; /* Got an error from read */
583 scb->bufp = scb->buf;
596 /* Translate baud rates from integers to damn B_codes. Unix should
597 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
642 for (i = 0; baudtab[i].rate != -1; i++)
643 if (rate == baudtab[i].rate)
644 return baudtab[i].code;
650 hardwire_setbaudrate(scb, rate)
654 struct hardwire_ttystate state;
656 if (get_tty_state(scb, &state))
660 cfsetospeed (&state.termios, rate_to_code (rate));
661 cfsetispeed (&state.termios, rate_to_code (rate));
669 state.termio.c_cflag &= ~(CBAUD | CIBAUD);
670 state.termio.c_cflag |= rate_to_code (rate);
674 state.sgttyb.sg_ispeed = rate_to_code (rate);
675 state.sgttyb.sg_ospeed = rate_to_code (rate);
678 return set_tty_state (scb, &state);
682 hardwire_setstopbits(scb, num)
686 struct hardwire_ttystate state;
689 if (get_tty_state(scb, &state))
694 case SERIAL_1_STOPBITS:
697 case SERIAL_1_AND_A_HALF_STOPBITS:
698 case SERIAL_2_STOPBITS:
707 state.termios.c_cflag &= ~CSTOPB;
709 state.termios.c_cflag |= CSTOPB; /* two bits */
714 state.termio.c_cflag &= ~CSTOPB;
716 state.termio.c_cflag |= CSTOPB; /* two bits */
720 return 0; /* sgtty doesn't support this */
723 return set_tty_state (scb, &state);
727 hardwire_write(scb, str, len)
736 cc = write(scb->fd, str, len);
757 static struct serial_ops hardwire_ops =
765 hardwire_flush_output,
766 hardwire_flush_input,
769 hardwire_get_tty_state,
770 hardwire_set_tty_state,
771 hardwire_print_tty_state,
772 hardwire_noflush_set_tty_state,
773 hardwire_setbaudrate,
774 hardwire_setstopbits,
775 hardwire_drain_output, /* wait for output to drain */
779 _initialize_ser_hardwire ()
781 serial_add_interface (&hardwire_ops);