1 /* Serial interface for local (hardwired) serial ports on Un*x like systems
2 Copyright 1992-1994, 1998-2000 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,
19 Boston, MA 02111-1307, USA. */
26 #include <sys/types.h>
28 #ifdef HAVE_SYS_WAIT_H
31 #include <sys/socket.h>
34 #include "gdb_string.h"
35 #include "event-loop.h"
39 struct hardwire_ttystate
41 struct termios termios
;
47 /* It is believed that all systems which have added job control to SVR3
48 (e.g. sco) have also added termios. Even if not, trying to figure out
49 all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
50 bewildering. So we don't attempt it. */
52 struct hardwire_ttystate
59 struct hardwire_ttystate
64 /* Line discipline flags. */
69 static int hardwire_open (serial_t scb
, const char *name
);
70 static void hardwire_raw (serial_t scb
);
71 static int wait_for (serial_t scb
, int timeout
);
72 static int hardwire_readchar (serial_t scb
, int timeout
);
73 static int do_hardwire_readchar (serial_t scb
, int timeout
);
74 static int generic_readchar (serial_t scb
, int timeout
, int (*do_readchar
) (serial_t scb
, int timeout
));
75 static int rate_to_code (int rate
);
76 static int hardwire_setbaudrate (serial_t scb
, int rate
);
77 static void hardwire_close (serial_t scb
);
78 static int get_tty_state (serial_t scb
, struct hardwire_ttystate
* state
);
79 static int set_tty_state (serial_t scb
, struct hardwire_ttystate
* state
);
80 static serial_ttystate
hardwire_get_tty_state (serial_t scb
);
81 static int hardwire_set_tty_state (serial_t scb
, serial_ttystate state
);
82 static int hardwire_noflush_set_tty_state (serial_t
, serial_ttystate
,
84 static void hardwire_print_tty_state (serial_t
, serial_ttystate
, struct ui_file
*);
85 static int hardwire_drain_output (serial_t
);
86 static int hardwire_flush_output (serial_t
);
87 static int hardwire_flush_input (serial_t
);
88 static int hardwire_send_break (serial_t
);
89 static int hardwire_setstopbits (serial_t
, int);
91 static int do_unix_readchar (serial_t scb
, int timeout
);
92 static timer_handler_func push_event
;
93 static handler_func fd_event
;
94 static void reschedule (serial_t scb
);
96 void _initialize_ser_hardwire (void);
98 extern int (*ui_loop_hook
) (int);
100 /* Open up a real live device for serial I/O */
103 hardwire_open (serial_t scb
, const char *name
)
105 scb
->fd
= open (name
, O_RDWR
);
113 get_tty_state (serial_t scb
, struct hardwire_ttystate
*state
)
116 if (tcgetattr (scb
->fd
, &state
->termios
) < 0)
123 if (ioctl (scb
->fd
, TCGETA
, &state
->termio
) < 0)
129 if (ioctl (scb
->fd
, TIOCGETP
, &state
->sgttyb
) < 0)
131 if (ioctl (scb
->fd
, TIOCGETC
, &state
->tc
) < 0)
133 if (ioctl (scb
->fd
, TIOCGLTC
, &state
->ltc
) < 0)
135 if (ioctl (scb
->fd
, TIOCLGET
, &state
->lmode
) < 0)
143 set_tty_state (serial_t scb
, struct hardwire_ttystate
*state
)
146 if (tcsetattr (scb
->fd
, TCSANOW
, &state
->termios
) < 0)
153 if (ioctl (scb
->fd
, TCSETA
, &state
->termio
) < 0)
159 if (ioctl (scb
->fd
, TIOCSETN
, &state
->sgttyb
) < 0)
161 if (ioctl (scb
->fd
, TIOCSETC
, &state
->tc
) < 0)
163 if (ioctl (scb
->fd
, TIOCSLTC
, &state
->ltc
) < 0)
165 if (ioctl (scb
->fd
, TIOCLSET
, &state
->lmode
) < 0)
172 static serial_ttystate
173 hardwire_get_tty_state (serial_t scb
)
175 struct hardwire_ttystate
*state
;
177 state
= (struct hardwire_ttystate
*) xmalloc (sizeof *state
);
179 if (get_tty_state (scb
, state
))
182 return (serial_ttystate
) state
;
186 hardwire_set_tty_state (serial_t scb
, serial_ttystate ttystate
)
188 struct hardwire_ttystate
*state
;
190 state
= (struct hardwire_ttystate
*) ttystate
;
192 return set_tty_state (scb
, state
);
196 hardwire_noflush_set_tty_state (serial_t scb
,
197 serial_ttystate new_ttystate
,
198 serial_ttystate old_ttystate
)
200 struct hardwire_ttystate new_state
;
202 struct hardwire_ttystate
*state
= (struct hardwire_ttystate
*) old_ttystate
;
205 new_state
= *(struct hardwire_ttystate
*) new_ttystate
;
207 /* Don't change in or out of raw mode; we don't want to flush input.
208 termio and termios have no such restriction; for them flushing input
209 is separate from setting the attributes. */
212 if (state
->sgttyb
.sg_flags
& RAW
)
213 new_state
.sgttyb
.sg_flags
|= RAW
;
215 new_state
.sgttyb
.sg_flags
&= ~RAW
;
217 /* I'm not sure whether this is necessary; the manpage just mentions
219 if (state
->sgttyb
.sg_flags
& CBREAK
)
220 new_state
.sgttyb
.sg_flags
|= CBREAK
;
222 new_state
.sgttyb
.sg_flags
&= ~CBREAK
;
225 return set_tty_state (scb
, &new_state
);
229 hardwire_print_tty_state (serial_t scb
,
230 serial_ttystate ttystate
,
231 struct ui_file
*stream
)
233 struct hardwire_ttystate
*state
= (struct hardwire_ttystate
*) ttystate
;
237 fprintf_filtered (stream
, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
238 (int) state
->termios
.c_iflag
,
239 (int) state
->termios
.c_oflag
);
240 fprintf_filtered (stream
, "c_cflag = 0x%x, c_lflag = 0x%x\n",
241 (int) state
->termios
.c_cflag
,
242 (int) state
->termios
.c_lflag
);
244 /* This not in POSIX, and is not really documented by those systems
245 which have it (at least not Sun). */
246 fprintf_filtered (stream
, "c_line = 0x%x.\n", state
->termios
.c_line
);
248 fprintf_filtered (stream
, "c_cc: ");
249 for (i
= 0; i
< NCCS
; i
+= 1)
250 fprintf_filtered (stream
, "0x%x ", state
->termios
.c_cc
[i
]);
251 fprintf_filtered (stream
, "\n");
255 fprintf_filtered (stream
, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
256 state
->termio
.c_iflag
, state
->termio
.c_oflag
);
257 fprintf_filtered (stream
, "c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
258 state
->termio
.c_cflag
, state
->termio
.c_lflag
,
259 state
->termio
.c_line
);
260 fprintf_filtered (stream
, "c_cc: ");
261 for (i
= 0; i
< NCC
; i
+= 1)
262 fprintf_filtered (stream
, "0x%x ", state
->termio
.c_cc
[i
]);
263 fprintf_filtered (stream
, "\n");
267 fprintf_filtered (stream
, "sgttyb.sg_flags = 0x%x.\n",
268 state
->sgttyb
.sg_flags
);
270 fprintf_filtered (stream
, "tchars: ");
271 for (i
= 0; i
< (int) sizeof (struct tchars
); i
++)
272 fprintf_filtered (stream
, "0x%x ", ((unsigned char *) &state
->tc
)[i
]);
273 fprintf_filtered ("\n");
275 fprintf_filtered (stream
, "ltchars: ");
276 for (i
= 0; i
< (int) sizeof (struct ltchars
); i
++)
277 fprintf_filtered (stream
, "0x%x ", ((unsigned char *) &state
->ltc
)[i
]);
278 fprintf_filtered (stream
, "\n");
280 fprintf_filtered (stream
, "lmode: 0x%x\n", state
->lmode
);
284 /* Wait for the output to drain away, as opposed to flushing (discarding) it */
287 hardwire_drain_output (serial_t scb
)
290 return tcdrain (scb
->fd
);
294 return ioctl (scb
->fd
, TCSBRK
, 1);
298 /* Get the current state and then restore it using TIOCSETP,
299 which should cause the output to drain and pending input
302 struct hardwire_ttystate state
;
303 if (get_tty_state (scb
, &state
))
309 return (ioctl (scb
->fd
, TIOCSETP
, &state
.sgttyb
));
316 hardwire_flush_output (serial_t scb
)
319 return tcflush (scb
->fd
, TCOFLUSH
);
323 return ioctl (scb
->fd
, TCFLSH
, 1);
327 /* This flushes both input and output, but we can't do better. */
328 return ioctl (scb
->fd
, TIOCFLUSH
, 0);
333 hardwire_flush_input (serial_t scb
)
335 ser_unix_flush_input (scb
);
338 return tcflush (scb
->fd
, TCIFLUSH
);
342 return ioctl (scb
->fd
, TCFLSH
, 0);
346 /* This flushes both input and output, but we can't do better. */
347 return ioctl (scb
->fd
, TIOCFLUSH
, 0);
352 hardwire_send_break (serial_t 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);
382 hardwire_raw (serial_t scb
)
384 struct hardwire_ttystate state
;
386 if (get_tty_state (scb
, &state
))
387 fprintf_unfiltered (gdb_stderr
, "get_tty_state failed: %s\n", safe_strerror (errno
));
390 state
.termios
.c_iflag
= 0;
391 state
.termios
.c_oflag
= 0;
392 state
.termios
.c_lflag
= 0;
393 state
.termios
.c_cflag
&= ~(CSIZE
| PARENB
);
394 state
.termios
.c_cflag
|= CLOCAL
| CS8
;
395 state
.termios
.c_cc
[VMIN
] = 0;
396 state
.termios
.c_cc
[VTIME
] = 0;
400 state
.termio
.c_iflag
= 0;
401 state
.termio
.c_oflag
= 0;
402 state
.termio
.c_lflag
= 0;
403 state
.termio
.c_cflag
&= ~(CSIZE
| PARENB
);
404 state
.termio
.c_cflag
|= CLOCAL
| CS8
;
405 state
.termio
.c_cc
[VMIN
] = 0;
406 state
.termio
.c_cc
[VTIME
] = 0;
410 state
.sgttyb
.sg_flags
|= RAW
| ANYP
;
411 state
.sgttyb
.sg_flags
&= ~(CBREAK
| ECHO
);
414 scb
->current_timeout
= 0;
416 if (set_tty_state (scb
, &state
))
417 fprintf_unfiltered (gdb_stderr
, "set_tty_state failed: %s\n", safe_strerror (errno
));
420 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
421 otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
423 For termio{s}, we actually just setup VTIME if necessary, and let the
424 timeout occur in the read() in hardwire_read().
427 /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
428 ser_unix*() until the old TERMIOS/SGTTY/... timer code has been
431 /* NOTE: cagney/1999-09-30: Much of the code below is dead. The only
432 possible values of the TIMEOUT parameter are ONE and ZERO.
433 Consequently all the code that tries to handle the possability of
434 an overflowed timer is unnecessary. */
437 wait_for (serial_t scb
, int timeout
)
449 FD_SET (scb
->fd
, &readfds
);
456 numfds
= select (scb
->fd
+ 1, &readfds
, 0, 0, &tv
);
458 numfds
= select (scb
->fd
+ 1, &readfds
, 0, 0, 0);
462 return SERIAL_TIMEOUT
;
463 else if (errno
== EINTR
)
466 return SERIAL_ERROR
; /* Got an error from select or poll */
471 #endif /* HAVE_SGTTY */
473 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
474 if (timeout
== scb
->current_timeout
)
477 scb
->current_timeout
= timeout
;
480 struct hardwire_ttystate state
;
482 if (get_tty_state (scb
, &state
))
483 fprintf_unfiltered (gdb_stderr
, "get_tty_state failed: %s\n", safe_strerror (errno
));
489 state
.termios
.c_cc
[VTIME
] = 0;
490 state
.termios
.c_cc
[VMIN
] = 1;
494 state
.termios
.c_cc
[VMIN
] = 0;
495 state
.termios
.c_cc
[VTIME
] = timeout
* 10;
496 if (state
.termios
.c_cc
[VTIME
] != timeout
* 10)
499 /* If c_cc is an 8-bit signed character, we can't go
500 bigger than this. If it is always unsigned, we could use
503 scb
->current_timeout
= 12;
504 state
.termios
.c_cc
[VTIME
] = scb
->current_timeout
* 10;
505 scb
->timeout_remaining
= timeout
- scb
->current_timeout
;
514 state
.termio
.c_cc
[VTIME
] = 0;
515 state
.termio
.c_cc
[VMIN
] = 1;
519 state
.termio
.c_cc
[VMIN
] = 0;
520 state
.termio
.c_cc
[VTIME
] = timeout
* 10;
521 if (state
.termio
.c_cc
[VTIME
] != timeout
* 10)
523 /* If c_cc is an 8-bit signed character, we can't go
524 bigger than this. If it is always unsigned, we could use
527 scb
->current_timeout
= 12;
528 state
.termio
.c_cc
[VTIME
] = scb
->current_timeout
* 10;
529 scb
->timeout_remaining
= timeout
- scb
->current_timeout
;
534 if (set_tty_state (scb
, &state
))
535 fprintf_unfiltered (gdb_stderr
, "set_tty_state failed: %s\n", safe_strerror (errno
));
539 #endif /* HAVE_TERMIO || HAVE_TERMIOS */
542 /* Read a character with user-specified timeout. TIMEOUT is number of seconds
543 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
544 char if successful. Returns SERIAL_TIMEOUT if timeout expired, EOF if line
545 dropped dead, or SERIAL_ERROR for any other error (see errno in that case). */
547 /* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
548 ser_unix*() until the old TERMIOS/SGTTY/... timer code has been
551 /* NOTE: cagney/1999-09-16: This function is not identical to
552 ser_unix_readchar() as part of replacing it with ser_unix*()
553 merging will be required - this code handles the case where read()
554 times out due to no data while ser_unix_readchar() doesn't expect
558 do_hardwire_readchar (serial_t scb
, int timeout
)
566 /* We have to be able to keep the GUI alive here, so we break the original
567 timeout into steps of 1 second, running the "keep the GUI alive" hook
568 each time through the loop.
569 Also, timeout = 0 means to poll, so we just set the delta to 0, so we
570 will only go through the loop once. */
572 delta
= (timeout
== 0 ? 0 : 1);
576 /* N.B. The UI may destroy our world (for instance by calling
577 remote_stop,) in which case we want to get out of here as
578 quickly as possible. It is not safe to touch scb, since
579 someone else might have freed it. The ui_loop_hook signals that
580 we should exit by returning 1. */
583 detach
= ui_loop_hook (0);
586 return SERIAL_TIMEOUT
;
588 scb
->timeout_remaining
= (timeout
< 0 ? timeout
: timeout
- delta
);
589 status
= wait_for (scb
, delta
);
594 status
= read (scb
->fd
, scb
->buf
, BUFSIZ
);
600 /* Zero characters means timeout (it could also be EOF, but
601 we don't (yet at least) distinguish). */
602 if (scb
->timeout_remaining
> 0)
604 timeout
= scb
->timeout_remaining
;
607 else if (scb
->timeout_remaining
< 0)
610 return SERIAL_TIMEOUT
;
612 else if (errno
== EINTR
)
615 return SERIAL_ERROR
; /* Got an error from read */
618 scb
->bufcnt
= status
;
620 scb
->bufp
= scb
->buf
;
626 hardwire_readchar (serial_t scb
, int timeout
)
628 return generic_readchar (scb
, timeout
, do_hardwire_readchar
);
640 /* Translate baud rates from integers to damn B_codes. Unix should
641 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
741 rate_to_code (int rate
)
745 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
746 if (rate
== baudtab
[i
].rate
)
747 return baudtab
[i
].code
;
753 hardwire_setbaudrate (serial_t scb
, int rate
)
755 struct hardwire_ttystate state
;
757 if (get_tty_state (scb
, &state
))
761 cfsetospeed (&state
.termios
, rate_to_code (rate
));
762 cfsetispeed (&state
.termios
, rate_to_code (rate
));
770 state
.termio
.c_cflag
&= ~(CBAUD
| CIBAUD
);
771 state
.termio
.c_cflag
|= rate_to_code (rate
);
775 state
.sgttyb
.sg_ispeed
= rate_to_code (rate
);
776 state
.sgttyb
.sg_ospeed
= rate_to_code (rate
);
779 return set_tty_state (scb
, &state
);
783 hardwire_setstopbits (scb
, num
)
787 struct hardwire_ttystate state
;
790 if (get_tty_state (scb
, &state
))
795 case SERIAL_1_STOPBITS
:
798 case SERIAL_1_AND_A_HALF_STOPBITS
:
799 case SERIAL_2_STOPBITS
:
808 state
.termios
.c_cflag
&= ~CSTOPB
;
810 state
.termios
.c_cflag
|= CSTOPB
; /* two bits */
815 state
.termio
.c_cflag
&= ~CSTOPB
;
817 state
.termio
.c_cflag
|= CSTOPB
; /* two bits */
821 return 0; /* sgtty doesn't support this */
824 return set_tty_state (scb
, &state
);
828 hardwire_close (serial_t scb
)
838 /* Generic operations used by all UNIX/FD based serial interfaces. */
841 ser_unix_nop_get_tty_state (serial_t scb
)
843 /* allocate a dummy */
844 return (serial_ttystate
) XMALLOC (int);
848 ser_unix_nop_set_tty_state (serial_t scb
, serial_ttystate ttystate
)
854 ser_unix_nop_raw (serial_t scb
)
856 return; /* Always in raw mode */
859 /* Wait for input on scb, with timeout seconds. Returns 0 on success,
860 otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
863 ser_unix_wait_for (serial_t scb
, int timeout
)
867 fd_set readfds
, exceptfds
;
870 FD_ZERO (&exceptfds
);
875 FD_SET (scb
->fd
, &readfds
);
876 FD_SET (scb
->fd
, &exceptfds
);
881 numfds
= select (scb
->fd
+ 1, &readfds
, 0, &exceptfds
, &tv
);
883 numfds
= select (scb
->fd
+ 1, &readfds
, 0, &exceptfds
, 0);
888 return SERIAL_TIMEOUT
;
889 else if (errno
== EINTR
)
892 return SERIAL_ERROR
; /* Got an error from select or poll */
899 /* Read a character with user-specified timeout. TIMEOUT is number of seconds
900 to wait, or -1 to wait forever. Use timeout of 0 to effect a poll. Returns
901 char if successful. Returns -2 if timeout expired, EOF if line dropped
902 dead, or -3 for any other error (see errno in that case). */
905 do_unix_readchar (serial_t scb
, int timeout
)
910 /* We have to be able to keep the GUI alive here, so we break the original
911 timeout into steps of 1 second, running the "keep the GUI alive" hook
912 each time through the loop.
914 Also, timeout = 0 means to poll, so we just set the delta to 0, so we
915 will only go through the loop once. */
917 delta
= (timeout
== 0 ? 0 : 1);
921 /* N.B. The UI may destroy our world (for instance by calling
922 remote_stop,) in which case we want to get out of here as
923 quickly as possible. It is not safe to touch scb, since
924 someone else might have freed it. The ui_loop_hook signals that
925 we should exit by returning 1. */
929 if (ui_loop_hook (0))
930 return SERIAL_TIMEOUT
;
933 status
= ser_unix_wait_for (scb
, delta
);
936 /* If we got a character or an error back from wait_for, then we can
937 break from the loop before the timeout is completed. */
939 if (status
!= SERIAL_TIMEOUT
)
944 /* If we have exhausted the original timeout, then generate
945 a SERIAL_TIMEOUT, and pass it out of the loop. */
947 else if (timeout
== 0)
949 status
= SERIAL_TIMEOUT
;
959 status
= read (scb
->fd
, scb
->buf
, BUFSIZ
);
960 if (status
!= -1 || errno
!= EINTR
)
967 return SERIAL_TIMEOUT
; /* 0 chars means timeout [may need to
968 distinguish between EOF & timeouts
971 return SERIAL_ERROR
; /* Got an error from read */
974 scb
->bufcnt
= status
;
976 scb
->bufp
= scb
->buf
;
980 /* Perform operations common to both old and new readchar. */
982 /* Return the next character from the input FIFO. If the FIFO is
983 empty, call the SERIAL specific routine to try and read in more
986 Initially data from the input FIFO is returned (fd_event()
987 pre-reads the input into that FIFO. Once that has been emptied,
988 further data is obtained by polling the input FD using the device
989 specific readchar() function. Note: reschedule() is called after
990 every read. This is because there is no guarentee that the lower
991 level fd_event() poll_event() code (which also calls reschedule())
995 generic_readchar (serial_t scb
, int timeout
,
996 int (do_readchar
) (serial_t scb
, int timeout
))
1005 else if (scb
->bufcnt
< 0)
1007 /* Some errors/eof are are sticky. */
1012 ch
= do_readchar (scb
, timeout
);
1015 switch ((enum serial_rc
) ch
)
1019 /* Make the error/eof stick. */
1022 case SERIAL_TIMEOUT
:
1033 ser_unix_readchar (serial_t scb
, int timeout
)
1035 return generic_readchar (scb
, timeout
, do_unix_readchar
);
1039 ser_unix_nop_noflush_set_tty_state (serial_t scb
,
1040 serial_ttystate new_ttystate
,
1041 serial_ttystate old_ttystate
)
1047 ser_unix_nop_print_tty_state (serial_t scb
,
1048 serial_ttystate ttystate
,
1049 struct ui_file
*stream
)
1051 /* Nothing to print. */
1056 ser_unix_nop_setbaudrate (serial_t scb
, int rate
)
1058 return 0; /* Never fails! */
1062 ser_unix_nop_setstopbits (serial_t scb
, int num
)
1064 return 0; /* Never fails! */
1068 ser_unix_write (serial_t scb
, const char *str
, int len
)
1074 cc
= write (scb
->fd
, str
, len
);
1085 ser_unix_nop_flush_output (serial_t scb
)
1091 ser_unix_flush_input (serial_t scb
)
1093 if (scb
->bufcnt
>= 0)
1096 scb
->bufp
= scb
->buf
;
1100 return SERIAL_ERROR
;
1104 ser_unix_nop_send_break (serial_t scb
)
1110 ser_unix_nop_drain_output (serial_t scb
)
1117 /* Event handling for ASYNC serial code.
1119 At any time the SERIAL device either: has an empty FIFO and is
1120 waiting on a FD event; or has a non-empty FIFO/error condition and
1121 is constantly scheduling timer events.
1123 ASYNC only stops pestering its client when it is de-async'ed or it
1124 is told to go away. */
1126 /* Value of scb->async_state: */
1128 /* >= 0 (TIMER_SCHEDULED) */
1129 /* The ID of the currently scheduled timer event. This state is
1130 rarely encountered. Timer events are one-off so as soon as the
1131 event is delivered the state is shanged to NOTHING_SCHEDULED. */
1133 /* The fd_event() handler is scheduled. It is called when ever the
1134 file descriptor becomes ready. */
1135 NOTHING_SCHEDULED
= -2
1136 /* Either no task is scheduled (just going into ASYNC mode) or a
1137 timer event has just gone off and the current state has been
1138 forced into nothing scheduled. */
1141 /* Identify and schedule the next ASYNC task based on scb->async_state
1142 and scb->buf* (the input FIFO). A state machine is used to avoid
1143 the need to make redundant calls into the event-loop - the next
1144 scheduled task is only changed when needed. */
1147 reschedule (serial_t scb
)
1149 if (SERIAL_IS_ASYNC_P (scb
))
1152 switch (scb
->async_state
)
1155 if (scb
->bufcnt
== 0)
1156 next_state
= FD_SCHEDULED
;
1159 delete_file_handler (scb
->fd
);
1160 next_state
= create_timer (0, push_event
, scb
);
1163 case NOTHING_SCHEDULED
:
1164 if (scb
->bufcnt
== 0)
1166 add_file_handler (scb
->fd
, fd_event
, scb
);
1167 next_state
= FD_SCHEDULED
;
1171 next_state
= create_timer (0, push_event
, scb
);
1174 default: /* TIMER SCHEDULED */
1175 if (scb
->bufcnt
== 0)
1177 delete_timer (scb
->async_state
);
1178 add_file_handler (scb
->fd
, fd_event
, scb
);
1179 next_state
= FD_SCHEDULED
;
1182 next_state
= scb
->async_state
;
1185 if (SERIAL_DEBUG_P (scb
))
1190 if (scb
->async_state
!= FD_SCHEDULED
)
1191 fprintf_unfiltered (gdb_stdlog
, "[fd%d->fd-scheduled]\n",
1194 default: /* TIMER SCHEDULED */
1195 if (scb
->async_state
== FD_SCHEDULED
)
1196 fprintf_unfiltered (gdb_stdlog
, "[fd%d->timer-scheduled]\n",
1201 scb
->async_state
= next_state
;
1205 /* FD_EVENT: This is scheduled when the input FIFO is empty (and there
1206 is no pending error). As soon as data arrives, it is read into the
1207 input FIFO and the client notified. The client should then drain
1208 the FIFO using readchar(). If the FIFO isn't immediatly emptied,
1209 push_event() is used to nag the client until it is. */
1212 fd_event (int error
, void *context
)
1214 serial_t scb
= context
;
1217 scb
->bufcnt
= SERIAL_ERROR
;
1219 else if (scb
->bufcnt
== 0)
1221 /* Prime the input FIFO. The readchar() function is used to
1222 pull characters out of the buffer. See also
1223 generic_readchar(). */
1227 nr
= read (scb
->fd
, scb
->buf
, BUFSIZ
);
1229 while (nr
== -1 && errno
== EINTR
);
1232 scb
->bufcnt
= SERIAL_EOF
;
1237 scb
->bufp
= scb
->buf
;
1241 scb
->bufcnt
= SERIAL_ERROR
;
1244 scb
->async_handler (scb
, scb
->async_context
);
1248 /* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
1249 error). Nag the client until all the data has been read. In the
1250 case of errors, the client will need to close or de-async the
1251 device before naging stops. */
1254 push_event (void *context
)
1256 serial_t scb
= context
;
1257 scb
->async_state
= NOTHING_SCHEDULED
; /* Timers are one-off */
1258 scb
->async_handler (scb
, scb
->async_context
);
1263 /* Put the SERIAL device into/out-of ASYNC mode. */
1266 ser_unix_async (serial_t scb
,
1271 /* Force a re-schedule. */
1272 scb
->async_state
= NOTHING_SCHEDULED
;
1273 if (SERIAL_DEBUG_P (scb
))
1274 fprintf_unfiltered (gdb_stdlog
, "[fd%d->asynchronous]\n",
1280 if (SERIAL_DEBUG_P (scb
))
1281 fprintf_unfiltered (gdb_stdlog
, "[fd%d->synchronous]\n",
1283 /* De-schedule what ever tasks are currently scheduled. */
1284 switch (scb
->async_state
)
1287 delete_file_handler (scb
->fd
);
1291 default: /* TIMER SCHEDULED */
1292 delete_timer (scb
->async_state
);
1299 _initialize_ser_hardwire (void)
1301 struct serial_ops
*ops
= XMALLOC (struct serial_ops
);
1302 memset (ops
, sizeof (struct serial_ops
), 0);
1303 ops
->name
= "hardwire";
1305 ops
->open
= hardwire_open
;
1306 ops
->close
= hardwire_close
;
1307 /* FIXME: Don't replace this with the equivalent ser_unix*() until
1308 the old TERMIOS/SGTTY/... timer code has been flushed. cagney
1310 ops
->readchar
= hardwire_readchar
;
1311 ops
->write
= ser_unix_write
;
1312 ops
->flush_output
= hardwire_flush_output
;
1313 ops
->flush_input
= hardwire_flush_input
;
1314 ops
->send_break
= hardwire_send_break
;
1315 ops
->go_raw
= hardwire_raw
;
1316 ops
->get_tty_state
= hardwire_get_tty_state
;
1317 ops
->set_tty_state
= hardwire_set_tty_state
;
1318 ops
->print_tty_state
= hardwire_print_tty_state
;
1319 ops
->noflush_set_tty_state
= hardwire_noflush_set_tty_state
;
1320 ops
->setbaudrate
= hardwire_setbaudrate
;
1321 ops
->setstopbits
= hardwire_setstopbits
;
1322 ops
->drain_output
= hardwire_drain_output
;
1323 ops
->async
= ser_unix_async
;
1324 serial_add_interface (ops
);