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;
42 /* It is believed that all systems which have added job control to SVR3
43 (e.g. sco) have also added termios. Even if not, trying to figure out
44 all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
45 bewildering. So we don't attempt it. */
47 struct hardwire_ttystate
54 /* Needed for the code which uses select(). We would include <sys/select.h>
55 too if it existed on all systems. */
60 struct hardwire_ttystate
65 /* Line discipline flags. */
70 static int hardwire_open PARAMS ((serial_t scb, const char *name));
71 static void hardwire_raw PARAMS ((serial_t scb));
72 static int wait_for PARAMS ((serial_t scb, int timeout));
73 static int hardwire_readchar PARAMS ((serial_t scb, int timeout));
74 static int rate_to_code PARAMS ((int rate));
75 static int hardwire_setbaudrate PARAMS ((serial_t scb, int rate));
76 static int hardwire_write PARAMS ((serial_t scb, const char *str, int len));
77 /* FIXME: static void hardwire_restore PARAMS ((serial_t scb)); */
78 static void hardwire_close PARAMS ((serial_t scb));
79 static int get_tty_state PARAMS ((serial_t scb, struct hardwire_ttystate *state));
80 static int set_tty_state PARAMS ((serial_t scb, struct hardwire_ttystate *state));
81 static serial_ttystate hardwire_get_tty_state PARAMS ((serial_t scb));
82 static int hardwire_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
84 /* Open up a real live device for serial I/O */
87 hardwire_open(scb, name)
91 scb->fd = open (name, O_RDWR);
99 get_tty_state(scb, state)
101 struct hardwire_ttystate *state;
106 if (tcgetattr(scb->fd, &state->termios) < 0)
113 if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
119 if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
121 if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
123 if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
125 if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
133 set_tty_state(scb, state)
135 struct hardwire_ttystate *state;
138 if (tcsetattr(scb->fd, TCSANOW, &state->termios) < 0)
145 if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
151 if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
153 if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0)
155 if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0)
157 if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0)
164 static serial_ttystate
165 hardwire_get_tty_state(scb)
168 struct hardwire_ttystate *state;
170 state = (struct hardwire_ttystate *)xmalloc(sizeof *state);
172 if (get_tty_state(scb, state))
175 return (serial_ttystate)state;
179 hardwire_set_tty_state(scb, ttystate)
181 serial_ttystate ttystate;
183 struct hardwire_ttystate *state;
185 state = (struct hardwire_ttystate *)ttystate;
187 return set_tty_state(scb, state);
191 hardwire_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
193 serial_ttystate new_ttystate;
194 serial_ttystate old_ttystate;
196 struct hardwire_ttystate new_state;
197 struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
199 new_state = *(struct hardwire_ttystate *)new_ttystate;
201 /* Don't change in or out of raw mode; we don't want to flush input.
202 termio and termios have no such restriction; for them flushing input
203 is separate from setting the attributes. */
206 if (state->sgttyb.sg_flags & RAW)
207 new_state.sgttyb.sg_flags |= RAW;
209 new_state.sgttyb.sg_flags &= ~RAW;
211 /* I'm not sure whether this is necessary; the manpage just mentions
213 if (state->sgttyb.sg_flags & CBREAK)
214 new_state.sgttyb.sg_flags |= CBREAK;
216 new_state.sgttyb.sg_flags &= ~CBREAK;
219 return set_tty_state (scb, &new_state);
223 hardwire_print_tty_state (scb, ttystate)
225 serial_ttystate ttystate;
227 struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
231 printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
232 state->termios.c_iflag, state->termios.c_oflag);
233 printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x\n",
234 state->termios.c_cflag, state->termios.c_lflag);
236 /* This not in POSIX, and is not really documented by those systems
237 which have it (at least not Sun). */
238 printf_filtered ("c_line = 0x%x.\n", state->termios.c_line);
240 printf_filtered ("c_cc: ");
241 for (i = 0; i < NCCS; i += 1)
242 printf_filtered ("0x%x ", state->termios.c_cc[i]);
243 printf_filtered ("\n");
247 printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
248 state->termio.c_iflag, state->termio.c_oflag);
249 printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
250 state->termio.c_cflag, state->termio.c_lflag,
251 state->termio.c_line);
252 printf_filtered ("c_cc: ");
253 for (i = 0; i < NCC; i += 1)
254 printf_filtered ("0x%x ", state->termio.c_cc[i]);
255 printf_filtered ("\n");
259 printf_filtered ("sgttyb.sg_flags = 0x%x.\n", state->sgttyb.sg_flags);
261 printf_filtered ("tchars: ");
262 for (i = 0; i < (int)sizeof (struct tchars); i++)
263 printf_filtered ("0x%x ", ((unsigned char *)&state->tc)[i]);
264 printf_filtered ("\n");
266 printf_filtered ("ltchars: ");
267 for (i = 0; i < (int)sizeof (struct ltchars); i++)
268 printf_filtered ("0x%x ", ((unsigned char *)&state->ltc)[i]);
269 printf_filtered ("\n");
271 printf_filtered ("lmode: 0x%x\n", state->lmode);
276 hardwire_flush_output (scb)
280 return tcflush (scb->fd, TCOFLUSH);
284 return ioctl (scb->fd, TCFLSH, 1);
288 /* This flushes both input and output, but we can't do better. */
289 return ioctl (scb->fd, TIOCFLUSH, 0);
294 hardwire_flush_input (scb)
298 return tcflush (scb->fd, TCIFLUSH);
302 return ioctl (scb->fd, TCFLSH, 0);
306 /* This flushes both input and output, but we can't do better. */
307 return ioctl (scb->fd, TIOCFLUSH, 0);
312 hardwire_send_break (scb)
316 return tcsendbreak (scb->fd, 0);
320 return ioctl (scb->fd, TCSBRK, 0);
326 struct timeval timeout;
328 status = ioctl (scb->fd, TIOCSBRK, 0);
330 /* Can't use usleep; it doesn't exist in BSD 4.2. */
331 /* Note that if this select() is interrupted by a signal it will not wait
332 the full length of time. I think that is OK. */
334 timeout.tv_usec = 250000;
335 select (0, 0, 0, 0, &timeout);
336 status = ioctl (scb->fd, TIOCCBRK, 0);
346 struct hardwire_ttystate state;
348 if (get_tty_state(scb, &state))
349 fprintf_unfiltered(gdb_stderr, "get_tty_state failed: %s\n", safe_strerror(errno));
352 state.termios.c_iflag = 0;
353 state.termios.c_oflag = 0;
354 state.termios.c_lflag = 0;
355 state.termios.c_cflag &= ~(CSIZE|PARENB);
356 state.termios.c_cflag |= CS8;
357 state.termios.c_cc[VMIN] = 0;
358 state.termios.c_cc[VTIME] = 0;
362 state.termio.c_iflag = 0;
363 state.termio.c_oflag = 0;
364 state.termio.c_lflag = 0;
365 state.termio.c_cflag &= ~(CSIZE|PARENB);
366 state.termio.c_cflag |= CS8;
367 state.termio.c_cc[VMIN] = 0;
368 state.termio.c_cc[VTIME] = 0;
372 state.sgttyb.sg_flags |= RAW | ANYP;
373 state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
376 scb->current_timeout = 0;
378 if (set_tty_state (scb, &state))
379 fprintf_unfiltered(gdb_stderr, "set_tty_state failed: %s\n", safe_strerror(errno));
382 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
383 otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
385 For termio{s}, we actually just setup VTIME if necessary, and let the
386 timeout occur in the read() in hardwire_read().
390 wait_for(scb, timeout)
403 FD_SET(scb->fd, &readfds);
410 numfds = select(scb->fd+1, &readfds, 0, 0, &tv);
412 numfds = select(scb->fd+1, &readfds, 0, 0, 0);
416 return SERIAL_TIMEOUT;
417 else if (errno == EINTR)
420 return SERIAL_ERROR; /* Got an error from select or poll */
425 #endif /* HAVE_SGTTY */
427 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
428 if (timeout == scb->current_timeout)
432 struct hardwire_ttystate state;
434 if (get_tty_state(scb, &state))
435 fprintf_unfiltered(gdb_stderr, "get_tty_state failed: %s\n", safe_strerror(errno));
441 state.termios.c_cc[VTIME] = 0;
442 state.termios.c_cc[VMIN] = 1;
446 state.termios.c_cc[VMIN] = 0;
447 state.termios.c_cc[VTIME] = timeout * 10;
448 if (state.termios.c_cc[VTIME] != timeout * 10)
450 warning ("Timeout value %d too large, using %d", timeout,
451 state.termios.c_cc[VTIME] / 10);
460 state.termio.c_cc[VTIME] = 0;
461 state.termio.c_cc[VMIN] = 1;
465 state.termio.c_cc[VMIN] = 0;
466 state.termio.c_cc[VTIME] = timeout * 10;
467 if (state.termio.c_cc[VTIME] != timeout * 10)
469 warning ("Timeout value %d too large, using %d", timeout,
470 state.termio.c_cc[VTIME] / 10);
475 scb->current_timeout = timeout;
477 if (set_tty_state (scb, &state))
478 fprintf_unfiltered(gdb_stderr, "set_tty_state failed: %s\n", safe_strerror(errno));
482 #endif /* HAVE_TERMIO || HAVE_TERMIOS */
485 /* Read a character with user-specified timeout. TIMEOUT is number of seconds
486 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
487 char if successful. Returns SERIAL_TIMEOUT if timeout expired, EOF if line
488 dropped dead, or SERIAL_ERROR for any other error (see errno in that case). */
491 hardwire_readchar(scb, timeout)
497 if (scb->bufcnt-- > 0)
500 status = wait_for(scb, timeout);
505 scb->bufcnt = read(scb->fd, scb->buf, BUFSIZ);
507 if (scb->bufcnt <= 0)
508 if (scb->bufcnt == 0)
509 return SERIAL_TIMEOUT; /* 0 chars means timeout [may need to
510 distinguish between EOF & timeouts
513 return SERIAL_ERROR; /* Got an error from read */
516 scb->bufp = scb->buf;
528 /* Translate baud rates from integers to damn B_codes. Unix should
529 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
562 for (i = 0; baudtab[i].rate != -1; i++)
563 if (rate == baudtab[i].rate)
564 return baudtab[i].code;
570 hardwire_setbaudrate(scb, rate)
574 struct hardwire_ttystate state;
576 if (get_tty_state(scb, &state))
580 cfsetospeed (&state.termios, rate_to_code (rate));
581 cfsetispeed (&state.termios, rate_to_code (rate));
589 state.termio.c_cflag &= ~(CBAUD | CIBAUD);
590 state.termio.c_cflag |= rate_to_code (rate);
594 state.sgttyb.sg_ispeed = rate_to_code (rate);
595 state.sgttyb.sg_ospeed = rate_to_code (rate);
598 return set_tty_state (scb, &state);
602 hardwire_write(scb, str, len)
611 cc = write(scb->fd, str, len);
632 static struct serial_ops hardwire_ops =
640 hardwire_flush_output,
641 hardwire_flush_input,
644 hardwire_get_tty_state,
645 hardwire_set_tty_state,
646 hardwire_print_tty_state,
647 hardwire_noflush_set_tty_state,
648 hardwire_setbaudrate,
652 _initialize_ser_hardwire ()
654 serial_add_interface (&hardwire_ops);