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 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. */
57 struct hardwire_ttystate
62 /* Line discipline flags. */
66 /* This is only used for the ultra. Does it have pid_t? */
74 static int hardwire_open
PARAMS ((serial_t scb
, const char *name
));
75 static void hardwire_raw
PARAMS ((serial_t scb
));
76 static int wait_for
PARAMS ((serial_t scb
, int timeout
));
77 static int hardwire_readchar
PARAMS ((serial_t scb
, int timeout
));
78 static int rate_to_code
PARAMS ((int rate
));
79 static int hardwire_setbaudrate
PARAMS ((serial_t scb
, int rate
));
80 static int hardwire_write
PARAMS ((serial_t scb
, const char *str
, int len
));
81 static void hardwire_restore
PARAMS ((serial_t scb
));
82 static void hardwire_close
PARAMS ((serial_t scb
));
83 static int get_tty_state
PARAMS ((serial_t scb
, struct hardwire_ttystate
*state
));
84 static int set_tty_state
PARAMS ((serial_t scb
, struct hardwire_ttystate
*state
));
85 static serial_ttystate hardwire_get_tty_state
PARAMS ((serial_t scb
));
86 static int hardwire_set_tty_state
PARAMS ((serial_t scb
, serial_ttystate state
));
88 /* Open up a real live device for serial I/O */
91 hardwire_open(scb
, name
)
95 scb
->fd
= open (name
, O_RDWR
);
103 get_tty_state(scb
, state
)
105 struct hardwire_ttystate
*state
;
108 pid_t new_process_group
;
110 if (tcgetattr(scb
->fd
, &state
->termios
) < 0)
116 new_process_group
= tcgetpgrp (scb
->fd
);
117 if (new_process_group
== (pid_t
)-1)
119 state
->process_group
= new_process_group
;
124 if (ioctl (scb
->fd
, TCGETA
, &state
->termio
) < 0)
130 return ioctl (scb
->fd
, TIOCGPGRP
, &state
->process_group
);
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 /* Need to ignore errors, at least if attach_flag is set. */
163 tcsetpgrp (scb
->fd
, state
->process_group
);
168 if (ioctl (scb
->fd
, TCSETA
, &state
->termio
) < 0)
174 /* Need to ignore errors, at least if attach_flag is set. */
175 ioctl (scb
->fd
, TIOCSPGRP
, &state
->process_group
);
180 if (ioctl (scb
->fd
, TIOCSETN
, &state
->sgttyb
) < 0)
186 /* Need to ignore errors, at least if attach_flag is set. */
187 ioctl (scb
->fd
, TIOCSPGRP
, &state
->process_group
);
192 static serial_ttystate
193 hardwire_get_tty_state(scb
)
196 struct hardwire_ttystate
*state
;
198 state
= (struct hardwire_ttystate
*)xmalloc(sizeof *state
);
200 if (get_tty_state(scb
, state
))
203 return (serial_ttystate
)state
;
207 hardwire_set_tty_state(scb
, ttystate
)
209 serial_ttystate ttystate
;
211 struct hardwire_ttystate
*state
;
213 state
= (struct hardwire_ttystate
*)ttystate
;
215 return set_tty_state(scb
, state
);
219 hardwire_noflush_set_tty_state (scb
, new_ttystate
, old_ttystate
)
221 serial_ttystate new_ttystate
;
222 serial_ttystate old_ttystate
;
224 struct hardwire_ttystate new_state
;
225 struct hardwire_ttystate
*state
= (struct hardwire_ttystate
*) old_ttystate
;
227 new_state
= *(struct hardwire_ttystate
*)new_ttystate
;
230 /* I'm not sure whether this is necessary; the manpage makes no mention
231 of discarding input when switching to/from ICANON. */
232 if (state
->termios
.c_lflag
& ICANON
)
233 new_state
.termios
.c_lflag
|= ICANON
;
235 new_state
.termios
.c_lflag
&= ~ICANON
;
239 /* I'm not sure whether this is necessary; the manpage makes no mention
240 of discarding input when switching to/from ICANON. */
241 if (state
->termio
.c_lflag
& ICANON
)
242 new_state
.termio
.c_lflag
|= ICANON
;
244 new_state
.termio
.c_lflag
&= ~ICANON
;
248 if (state
->sgttyb
.sg_flags
& RAW
)
249 new_state
.sgttyb
.sg_flags
|= RAW
;
251 new_state
.sgttyb
.sg_flags
&= ~RAW
;
253 /* I'm not sure whether this is necessary; the manpage just mentions
255 if (state
->sgttyb
.sg_flags
& CBREAK
)
256 new_state
.sgttyb
.sg_flags
|= CBREAK
;
258 new_state
.sgttyb
.sg_flags
&= ~CBREAK
;
261 return set_tty_state (scb
, &new_state
);
265 hardwire_print_tty_state (scb
, ttystate
)
267 serial_ttystate ttystate
;
269 struct hardwire_ttystate
*state
= (struct hardwire_ttystate
*) ttystate
;
272 printf_filtered ("Process group = %d\n", state
->process_group
);
275 printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
276 state
->termios
.c_iflag
, state
->termios
.c_oflag
);
277 printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x\n",
278 state
->termios
.c_cflag
, state
->termios
.c_lflag
);
280 /* This not in POSIX, and is not really documented by those systems
281 which have it (at least not Sun). */
282 printf_filtered ("c_line = 0x%x.\n", state
->termios
.c_line
);
284 printf_filtered ("c_cc: ");
285 for (i
= 0; i
< NCCS
; i
+= 1)
286 printf_filtered ("0x%x ", state
->termios
.c_cc
[i
]);
287 printf_filtered ("\n");
291 printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
292 state
->termio
.c_iflag
, state
->termio
.c_oflag
);
293 printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
294 state
->termio
.c_cflag
, state
->termio
.c_lflag
,
295 state
->termio
.c_line
);
296 printf_filtered ("c_cc: ");
297 for (i
= 0; i
< NCC
; i
+= 1)
298 printf_filtered ("0x%x ", state
->termio
.c_cc
[i
]);
299 printf_filtered ("\n");
303 printf_filtered ("sgttyb.sg_flags = 0x%x.\n", state
->sgttyb
.sg_flags
);
305 printf_filtered ("tchars: ");
306 for (i
= 0; i
< (int)sizeof (struct tchars
); i
++)
307 printf_filtered ("0x%x ", ((unsigned char *)&state
->tc
)[i
]);
308 printf_filtered ("\n");
310 printf_filtered ("ltchars: ");
311 for (i
= 0; i
< (int)sizeof (struct ltchars
); i
++)
312 printf_filtered ("0x%x ", ((unsigned char *)&state
->ltc
)[i
]);
313 printf_filtered ("\n");
315 printf_filtered ("lmode: 0x%x\n", state
->lmode
);
320 hardwire_flush_output (scb
)
324 return tcflush (scb
->fd
, TCOFLUSH
);
328 return ioctl (scb
->fd
, TCFLSH
, 1);
332 /* This flushes both input and output, but we can't do better. */
333 return ioctl (scb
->fd
, TIOCFLUSH
, 0);
341 struct hardwire_ttystate state
;
343 if (get_tty_state(scb
, &state
))
344 fprintf(stderr
, "get_tty_state failed: %s\n", safe_strerror(errno
));
347 state
.termios
.c_iflag
= 0;
348 state
.termios
.c_oflag
= 0;
349 state
.termios
.c_lflag
= 0;
350 state
.termios
.c_cflag
&= ~(CSIZE
|PARENB
);
351 state
.termios
.c_cflag
|= CS8
;
352 state
.termios
.c_cc
[VMIN
] = 0;
353 state
.termios
.c_cc
[VTIME
] = 0;
357 state
.termio
.c_iflag
= 0;
358 state
.termio
.c_oflag
= 0;
359 state
.termio
.c_lflag
= 0;
360 state
.termio
.c_cflag
&= ~(CSIZE
|PARENB
);
361 state
.termio
.c_cflag
|= CS8
;
362 state
.termio
.c_cc
[VMIN
] = 0;
363 state
.termio
.c_cc
[VTIME
] = 0;
367 state
.sgttyb
.sg_flags
|= RAW
| ANYP
;
368 state
.sgttyb
.sg_flags
&= ~(CBREAK
| ECHO
);
371 scb
->current_timeout
= 0;
373 if (set_tty_state (scb
, &state
))
374 fprintf(stderr
, "set_tty_state failed: %s\n", safe_strerror(errno
));
377 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
378 otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
380 For termio{s}, we actually just setup VTIME if necessary, and let the
381 timeout occur in the read() in hardwire_read().
385 wait_for(scb
, timeout
)
400 FD_SET(scb
->fd
, &readfds
);
405 numfds
= select(scb
->fd
+1, &readfds
, 0, 0, &tv
);
407 numfds
= select(scb
->fd
+1, &readfds
, 0, 0, 0);
411 return SERIAL_TIMEOUT
;
412 else if (errno
== EINTR
)
415 return SERIAL_ERROR
; /* Got an error from select or poll */
420 #endif /* HAVE_SGTTY */
422 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
423 if (timeout
== scb
->current_timeout
)
427 struct hardwire_ttystate state
;
429 if (get_tty_state(scb
, &state
))
430 fprintf(stderr
, "get_tty_state failed: %s\n", safe_strerror(errno
));
433 state
.termios
.c_cc
[VTIME
] = timeout
* 10;
437 state
.termio
.c_cc
[VTIME
] = timeout
* 10;
440 scb
->current_timeout
= timeout
;
442 if (set_tty_state (scb
, &state
))
443 fprintf(stderr
, "set_tty_state failed: %s\n", safe_strerror(errno
));
447 #endif /* HAVE_TERMIO || HAVE_TERMIOS */
450 /* Read a character with user-specified timeout. TIMEOUT is number of seconds
451 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
452 char if successful. Returns -2 if timeout expired, EOF if line dropped
453 dead, or -3 for any other error (see errno in that case). */
456 hardwire_readchar(scb
, timeout
)
462 if (scb
->bufcnt
-- > 0)
465 status
= wait_for(scb
, timeout
);
470 scb
->bufcnt
= read(scb
->fd
, scb
->buf
, BUFSIZ
);
472 if (scb
->bufcnt
<= 0)
473 if (scb
->bufcnt
== 0)
474 return SERIAL_TIMEOUT
; /* 0 chars means timeout [may need to
475 distinguish between EOF & timeouts
478 return SERIAL_ERROR
; /* Got an error from read */
481 scb
->bufp
= scb
->buf
;
493 /* Translate baud rates from integers to damn B_codes. Unix should
494 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
527 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
528 if (rate
== baudtab
[i
].rate
)
529 return baudtab
[i
].code
;
535 hardwire_setbaudrate(scb
, rate
)
539 struct hardwire_ttystate state
;
541 if (get_tty_state(scb
, &state
))
545 cfsetospeed (&state
.termios
, rate_to_code (rate
));
546 cfsetispeed (&state
.termios
, rate_to_code (rate
));
554 state
.termio
.c_cflag
&= ~(CBAUD
| CIBAUD
);
555 state
.termio
.c_cflag
|= rate_to_code (rate
);
559 state
.sgttyb
.sg_ispeed
= rate_to_code (rate
);
560 state
.sgttyb
.sg_ospeed
= rate_to_code (rate
);
563 return set_tty_state (scb
, &state
);
567 hardwire_set_process_group (scb
, ttystate
, group
)
569 serial_ttystate ttystate
;
572 ((struct hardwire_ttystate
*)ttystate
)->process_group
= group
;
577 hardwire_write(scb
, str
, len
)
586 cc
= write(scb
->fd
, str
, len
);
607 static struct serial_ops hardwire_ops
=
615 hardwire_flush_output
,
617 hardwire_get_tty_state
,
618 hardwire_set_tty_state
,
619 hardwire_print_tty_state
,
620 hardwire_noflush_set_tty_state
,
621 hardwire_setbaudrate
,
622 hardwire_set_process_group
626 #if defined (HAVE_TERMIOS)
630 /* This is here because this is where we figure out whether we (probably)
631 have job control. Just using job_control only does part of it because
632 setpgid or setpgrp might not exist on a system without job control.
633 It might be considered misplaced (on the other hand, process groups and
634 job control are closely related to ttys).
636 For a more clean implementation, in libiberty, put a setpgid which merely
637 calls setpgrp and a setpgrp which does nothing (any system with job control
638 will have one or the other). */
645 #if defined (NEED_POSIX_SETPGID) || defined (HAVE_TERMIOS)
646 /* Do all systems with termios have setpgid? I hope so. */
647 retval
= setpgid (0, 0);
649 #if defined (TIOCGPGRP)
650 #if defined(USG) && !defined(SETPGRP_ARGS)
653 retval
= setpgrp (getpid (), getpid ());
655 #endif /* TIOCGPGRP. */
656 #endif /* NEED_POSIX_SETPGID */
662 _initialize_ser_hardwire ()
664 serial_add_interface (&hardwire_ops
);
666 /* OK, figure out whether we have job control. */
668 #if defined (HAVE_TERMIOS)
669 /* Do all systems with termios have the POSIX way of identifying job
670 control? I hope so. */
671 #ifdef _POSIX_JOB_CONTROL
672 /* AIX defines _POSIX_JOB_CONTROL to an empty string, so I guess
673 defining _POSIX_JOB_CONTROL to 0 to mean no job control doesn't work
674 (I don't have the standard handy). */
677 job_control
= sysconf (_SC_JOB_CONTROL
);
680 #else /* not termios. */
686 #endif /* TIOCGPGRP */
688 #endif /* not termios. */