1 /* Serial interface for local (hardwired) serial ports on Un*x like systems
2 Copyright 1992, 1993 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
23 #include <sys/types.h>
25 #if !defined (HAVE_TERMIOS) && !defined (HAVE_TERMIO) && !defined (HAVE_SGTTY)
33 struct hardwire_ttystate
35 struct termios termios;
43 /* It is believed that all systems which have added job control to SVR3
44 (e.g. sco) have also added termios. Even if not, trying to figure out
45 all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
46 bewildering. So we don't attempt it. */
48 struct hardwire_ttystate
55 /* Needed for the code which uses select(). We would include <sys/select.h>
56 too if it existed on all systems. */
61 struct hardwire_ttystate
66 /* Line discipline flags. */
70 /* This is only used for the ultra. Does it have pid_t? */
78 static int hardwire_open PARAMS ((serial_t scb, const char *name));
79 static void hardwire_raw PARAMS ((serial_t scb));
80 static int wait_for PARAMS ((serial_t scb, int timeout));
81 static int hardwire_readchar PARAMS ((serial_t scb, int timeout));
82 static int rate_to_code PARAMS ((int rate));
83 static int hardwire_setbaudrate PARAMS ((serial_t scb, int rate));
84 static int hardwire_write PARAMS ((serial_t scb, const char *str, int len));
85 static void hardwire_restore PARAMS ((serial_t scb));
86 static void hardwire_close PARAMS ((serial_t scb));
87 static int get_tty_state PARAMS ((serial_t scb, struct hardwire_ttystate *state));
88 static int set_tty_state PARAMS ((serial_t scb, struct hardwire_ttystate *state));
89 static serial_ttystate hardwire_get_tty_state PARAMS ((serial_t scb));
90 static int hardwire_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
92 /* Open up a real live device for serial I/O */
95 hardwire_open(scb, name)
99 scb->fd = open (name, O_RDWR);
107 get_tty_state(scb, state)
109 struct hardwire_ttystate *state;
112 pid_t new_process_group;
114 if (tcgetattr(scb->fd, &state->termios) < 0)
120 new_process_group = tcgetpgrp (scb->fd);
121 if (new_process_group == (pid_t)-1)
123 state->process_group = new_process_group;
128 if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
134 if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
136 if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
138 if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
140 if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
146 return ioctl (scb->fd, TIOCGPGRP, &state->process_group);
151 set_tty_state(scb, state)
153 struct hardwire_ttystate *state;
156 if (tcsetattr(scb->fd, TCSANOW, &state->termios) < 0)
162 return tcsetpgrp (scb->fd, state->process_group);
166 if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
172 if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
178 return ioctl (scb->fd, TIOCSPGRP, &state->process_group);
182 static serial_ttystate
183 hardwire_get_tty_state(scb)
186 struct hardwire_ttystate *state;
188 state = (struct hardwire_ttystate *)xmalloc(sizeof *state);
190 if (get_tty_state(scb, state))
193 return (serial_ttystate)state;
197 hardwire_set_tty_state(scb, ttystate)
199 serial_ttystate ttystate;
201 struct hardwire_ttystate *state;
203 state = (struct hardwire_ttystate *)ttystate;
205 return set_tty_state(scb, state);
209 hardwire_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
211 serial_ttystate new_ttystate;
212 serial_ttystate old_ttystate;
214 struct hardwire_ttystate new_state;
215 struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
217 new_state = *(struct hardwire_ttystate *)new_ttystate;
220 /* I'm not sure whether this is necessary; the manpage makes no mention
221 of discarding input when switching to/from ICANON. */
222 if (state->termios.c_lflag & ICANON)
223 new_state.termios.c_lflag |= ICANON;
225 new_state.termios.c_lflag &= ~ICANON;
229 /* I'm not sure whether this is necessary; the manpage makes no mention
230 of discarding input when switching to/from ICANON. */
231 if (state->termio.c_lflag & ICANON)
232 new_state.termio.c_lflag |= ICANON;
234 new_state.termio.c_lflag &= ~ICANON;
238 if (state->sgttyb.sg_flags & RAW)
239 new_state.sgttyb.sg_flags |= RAW;
241 new_state.sgttyb.sg_flags &= ~RAW;
243 /* I'm not sure whether this is necessary; the manpage just mentions
245 if (state->sgttyb.sg_flags & CBREAK)
246 new_state.sgttyb.sg_flags |= CBREAK;
248 new_state.sgttyb.sg_flags &= ~CBREAK;
251 return set_tty_state (scb, &new_state);
255 hardwire_print_tty_state (scb, ttystate)
257 serial_ttystate ttystate;
259 struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
263 printf_filtered ("Process group = %d\n", state->process_group);
265 printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
266 state->termios.c_iflag, state->termios.c_oflag);
267 printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x\n",
268 state->termios.c_cflag, state->termios.c_lflag);
270 /* This not in POSIX, and is not really documented by those systems
271 which have it (at least not Sun). */
272 printf_filtered ("c_line = 0x%x.\n", state->termios.c_line);
274 printf_filtered ("c_cc: ");
275 for (i = 0; i < NCCS; i += 1)
276 printf_filtered ("0x%x ", state->termios.c_cc[i]);
277 printf_filtered ("\n");
281 printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
282 state->termio.c_iflag, state->termio.c_oflag);
283 printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
284 state->termio.c_cflag, state->termio.c_lflag,
285 state->termio.c_line);
286 printf_filtered ("c_cc: ");
287 for (i = 0; i < NCC; i += 1)
288 printf_filtered ("0x%x ", state->termio.c_cc[i]);
289 printf_filtered ("\n");
293 printf_filtered ("Process group = %d\n", state->process_group);
295 printf_filtered ("sgttyb.sg_flags = 0x%x.\n", state->sgttyb.sg_flags);
297 printf_filtered ("tchars: ");
298 for (i = 0; i < (int)sizeof (struct tchars); i++)
299 printf_filtered ("0x%x ", ((unsigned char *)&state->tc)[i]);
300 printf_filtered ("\n");
302 printf_filtered ("ltchars: ");
303 for (i = 0; i < (int)sizeof (struct ltchars); i++)
304 printf_filtered ("0x%x ", ((unsigned char *)&state->ltc)[i]);
305 printf_filtered ("\n");
307 printf_filtered ("lmode: 0x%x\n", state->lmode);
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);
333 struct hardwire_ttystate state;
335 if (get_tty_state(scb, &state))
336 fprintf(stderr, "get_tty_state failed: %s\n", safe_strerror(errno));
339 state.termios.c_iflag = 0;
340 state.termios.c_oflag = 0;
341 state.termios.c_lflag = 0;
342 state.termios.c_cflag &= ~(CSIZE|PARENB);
343 state.termios.c_cflag |= CS8;
344 state.termios.c_cc[VMIN] = 0;
345 state.termios.c_cc[VTIME] = 0;
349 state.termio.c_iflag = 0;
350 state.termio.c_oflag = 0;
351 state.termio.c_lflag = 0;
352 state.termio.c_cflag &= ~(CSIZE|PARENB);
353 state.termio.c_cflag |= CS8;
354 state.termio.c_cc[VMIN] = 0;
355 state.termio.c_cc[VTIME] = 0;
359 state.sgttyb.sg_flags |= RAW | ANYP;
360 state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
363 scb->current_timeout = 0;
365 if (set_tty_state (scb, &state))
366 fprintf(stderr, "set_tty_state failed: %s\n", safe_strerror(errno));
369 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
370 otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
372 For termio{s}, we actually just setup VTIME if necessary, and let the
373 timeout occur in the read() in hardwire_read().
377 wait_for(scb, timeout)
392 FD_SET(scb->fd, &readfds);
397 numfds = select(scb->fd+1, &readfds, 0, 0, &tv);
399 numfds = select(scb->fd+1, &readfds, 0, 0, 0);
403 return SERIAL_TIMEOUT;
404 else if (errno == EINTR)
407 return SERIAL_ERROR; /* Got an error from select or poll */
412 #endif /* HAVE_SGTTY */
414 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
415 if (timeout == scb->current_timeout)
419 struct hardwire_ttystate state;
421 if (get_tty_state(scb, &state))
422 fprintf(stderr, "get_tty_state failed: %s\n", safe_strerror(errno));
425 state.termios.c_cc[VTIME] = timeout * 10;
429 state.termio.c_cc[VTIME] = timeout * 10;
432 scb->current_timeout = timeout;
434 if (set_tty_state (scb, &state))
435 fprintf(stderr, "set_tty_state failed: %s\n", safe_strerror(errno));
439 #endif /* HAVE_TERMIO || HAVE_TERMIOS */
442 /* Read a character with user-specified timeout. TIMEOUT is number of seconds
443 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
444 char if successful. Returns -2 if timeout expired, EOF if line dropped
445 dead, or -3 for any other error (see errno in that case). */
448 hardwire_readchar(scb, timeout)
454 if (scb->bufcnt-- > 0)
457 status = wait_for(scb, timeout);
462 scb->bufcnt = read(scb->fd, scb->buf, BUFSIZ);
464 if (scb->bufcnt <= 0)
465 if (scb->bufcnt == 0)
466 return SERIAL_TIMEOUT; /* 0 chars means timeout [may need to
467 distinguish between EOF & timeouts
470 return SERIAL_ERROR; /* Got an error from read */
473 scb->bufp = scb->buf;
485 /* Translate baud rates from integers to damn B_codes. Unix should
486 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
519 for (i = 0; baudtab[i].rate != -1; i++)
520 if (rate == baudtab[i].rate)
521 return baudtab[i].code;
527 hardwire_setbaudrate(scb, rate)
531 struct hardwire_ttystate state;
533 if (get_tty_state(scb, &state))
537 cfsetospeed (&state.termios, rate_to_code (rate));
538 cfsetispeed (&state.termios, rate_to_code (rate));
546 state.termio.c_cflag &= ~(CBAUD | CIBAUD);
547 state.termio.c_cflag |= rate_to_code (rate);
551 state.sgttyb.sg_ispeed = rate_to_code (rate);
552 state.sgttyb.sg_ospeed = rate_to_code (rate);
555 return set_tty_state (scb, &state);
559 hardwire_set_process_group (scb, ttystate, group)
561 serial_ttystate ttystate;
564 #if defined (HAVE_SGTTY) || defined (HAVE_TERMIOS)
565 ((struct hardwire_ttystate *)ttystate)->process_group = group;
571 hardwire_write(scb, str, len)
580 cc = write(scb->fd, str, len);
601 static struct serial_ops hardwire_ops =
609 hardwire_flush_output,
611 hardwire_get_tty_state,
612 hardwire_set_tty_state,
613 hardwire_print_tty_state,
614 hardwire_noflush_set_tty_state,
615 hardwire_setbaudrate,
616 hardwire_set_process_group
620 #if defined (HAVE_TERMIOS)
624 /* This is here because this is where we figure out whether we (probably)
625 have job control. Just using job_control only does part of it because
626 setpgid or setpgrp might not exist on a system without job control.
627 It might be considered misplaced (on the other hand, process groups and
628 job control are closely related to ttys).
630 For a more clean implementation, in libiberty, put a setpgid which merely
631 calls setpgrp and a setpgrp which does nothing (any system with job control
632 will have one or the other). */
639 #if defined (NEED_POSIX_SETPGID) || defined (HAVE_TERMIOS)
640 /* Do all systems with termios have setpgid? I hope so. */
641 retval = setpgid (0, 0);
643 #if defined (TIOCGPGRP)
644 #if defined(USG) && !defined(SETPGRP_ARGS)
647 retval = setpgrp (getpid (), getpid ());
649 #endif /* TIOCGPGRP. */
650 #endif /* NEED_POSIX_SETPGID */
656 _initialize_ser_hardwire ()
658 serial_add_interface (&hardwire_ops);
660 /* OK, figure out whether we have job control. */
662 #if defined (HAVE_TERMIOS)
663 /* Do all systems with termios have the POSIX way of identifying job
664 control? I hope so. */
665 #ifdef _POSIX_JOB_CONTROL
668 job_control = sysconf (_SC_JOB_CONTROL);
673 /* See comment at top of file about trying to support process groups
683 #endif /* TIOCGPGRP */