1 /* Serial interface for local (hardwired) serial ports on Windows systems
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
33 #include <sys/types.h>
35 #include "gdb_assert.h"
36 #include "gdb_string.h"
38 void _initialize_ser_windows (void);
40 struct ser_windows_state
48 /* Open up a real live device for serial I/O. */
51 ser_windows_open (struct serial *scb, const char *name)
54 struct ser_windows_state *state;
55 COMMTIMEOUTS timeouts;
57 /* Only allow COM ports. */
58 if (strncmp (name, "COM", 3) != 0)
64 h = CreateFile (name, GENERIC_READ | GENERIC_WRITE, 0, NULL,
65 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL);
66 if (h == INVALID_HANDLE_VALUE)
72 scb->fd = _open_osfhandle ((long) h, O_RDWR);
79 if (!SetCommMask (h, EV_RXCHAR))
85 timeouts.ReadIntervalTimeout = MAXDWORD;
86 timeouts.ReadTotalTimeoutConstant = 0;
87 timeouts.ReadTotalTimeoutMultiplier = 0;
88 timeouts.WriteTotalTimeoutConstant = 0;
89 timeouts.WriteTotalTimeoutMultiplier = 0;
90 if (!SetCommTimeouts (h, &timeouts))
96 state = xmalloc (sizeof (struct ser_windows_state));
97 memset (state, 0, sizeof (struct ser_windows_state));
100 /* Create a manual reset event to watch the input buffer. */
101 state->ov.hEvent = CreateEvent (0, TRUE, FALSE, 0);
103 /* Create a (currently unused) handle to record exceptions. */
104 state->except_event = CreateEvent (0, TRUE, FALSE, 0);
109 /* Wait for the output to drain away, as opposed to flushing (discarding)
113 ser_windows_drain_output (struct serial *scb)
115 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
117 return (FlushFileBuffers (h) != 0) ? 0 : -1;
121 ser_windows_flush_output (struct serial *scb)
123 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
125 return (PurgeComm (h, PURGE_TXCLEAR) != 0) ? 0 : -1;
129 ser_windows_flush_input (struct serial *scb)
131 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
133 return (PurgeComm (h, PURGE_RXCLEAR) != 0) ? 0 : -1;
137 ser_windows_send_break (struct serial *scb)
139 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
141 if (SetCommBreak (h) == 0)
144 /* Delay for 250 milliseconds. */
147 if (ClearCommBreak (h))
154 ser_windows_raw (struct serial *scb)
156 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
159 if (GetCommState (h, &state) == 0)
162 state.fParity = FALSE;
163 state.fOutxCtsFlow = FALSE;
164 state.fOutxDsrFlow = FALSE;
165 state.fDtrControl = DTR_CONTROL_ENABLE;
166 state.fDsrSensitivity = FALSE;
170 state.fAbortOnError = FALSE;
172 state.Parity = NOPARITY;
174 scb->current_timeout = 0;
176 if (SetCommState (h, &state) == 0)
177 warning (_("SetCommState failed\n"));
181 ser_windows_setstopbits (struct serial *scb, int num)
183 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
186 if (GetCommState (h, &state) == 0)
191 case SERIAL_1_STOPBITS:
192 state.StopBits = ONESTOPBIT;
194 case SERIAL_1_AND_A_HALF_STOPBITS:
195 state.StopBits = ONE5STOPBITS;
197 case SERIAL_2_STOPBITS:
198 state.StopBits = TWOSTOPBITS;
204 return (SetCommState (h, &state) != 0) ? 0 : -1;
208 ser_windows_setbaudrate (struct serial *scb, int rate)
210 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
213 if (GetCommState (h, &state) == 0)
216 state.BaudRate = rate;
218 return (SetCommState (h, &state) != 0) ? 0 : -1;
222 ser_windows_close (struct serial *scb)
224 struct ser_windows_state *state;
226 /* Stop any pending selects. */
227 CancelIo ((HANDLE) _get_osfhandle (scb->fd));
229 CloseHandle (state->ov.hEvent);
230 CloseHandle (state->except_event);
242 ser_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
244 struct ser_windows_state *state;
247 HANDLE h = (HANDLE) _get_osfhandle (scb->fd);
251 *except = state->except_event;
252 *read = state->ov.hEvent;
254 if (state->in_progress)
257 /* Reset the mask - we are only interested in any characters which
258 arrive after this point, not characters which might have arrived
259 and already been read. */
261 /* This really, really shouldn't be necessary - just the second one.
262 But otherwise an internal flag for EV_RXCHAR does not get
263 cleared, and we get a duplicated event, if the last batch
264 of characters included at least two arriving close together. */
265 if (!SetCommMask (h, 0))
266 warning (_("ser_windows_wait_handle: reseting mask failed"));
268 if (!SetCommMask (h, EV_RXCHAR))
269 warning (_("ser_windows_wait_handle: reseting mask failed (2)"));
271 /* There's a potential race condition here; we must check cbInQue
272 and not wait if that's nonzero. */
274 ClearCommError (h, &errors, &status);
275 if (status.cbInQue > 0)
277 SetEvent (state->ov.hEvent);
281 state->in_progress = 1;
282 ResetEvent (state->ov.hEvent);
283 state->lastCommMask = -2;
284 if (WaitCommEvent (h, &state->lastCommMask, &state->ov))
286 gdb_assert (state->lastCommMask & EV_RXCHAR);
287 SetEvent (state->ov.hEvent);
290 gdb_assert (GetLastError () == ERROR_IO_PENDING);
294 ser_windows_read_prim (struct serial *scb, size_t count)
296 struct ser_windows_state *state;
298 DWORD bytes_read, bytes_read_tmp;
303 if (state->in_progress)
305 WaitForSingleObject (state->ov.hEvent, INFINITE);
306 state->in_progress = 0;
307 ResetEvent (state->ov.hEvent);
310 memset (&ov, 0, sizeof (OVERLAPPED));
311 ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
312 h = (HANDLE) _get_osfhandle (scb->fd);
314 if (!ReadFile (h, scb->buf, /* count */ 1, &bytes_read, &ov))
316 if (GetLastError () != ERROR_IO_PENDING
317 || !GetOverlappedResult (h, &ov, &bytes_read, TRUE))
321 CloseHandle (ov.hEvent);
326 ser_windows_write_prim (struct serial *scb, const void *buf, size_t len)
328 struct ser_windows_state *state;
333 memset (&ov, 0, sizeof (OVERLAPPED));
334 ov.hEvent = CreateEvent (0, FALSE, FALSE, 0);
335 h = (HANDLE) _get_osfhandle (scb->fd);
336 if (!WriteFile (h, buf, len, &bytes_written, &ov))
338 if (GetLastError () != ERROR_IO_PENDING
339 || !GetOverlappedResult (h, &ov, &bytes_written, TRUE))
343 CloseHandle (ov.hEvent);
344 return bytes_written;
347 struct ser_console_state
361 console_select_thread (void *arg)
363 struct serial *scb = arg;
364 struct ser_console_state *state;
369 h = (HANDLE) _get_osfhandle (scb->fd);
373 HANDLE wait_events[2];
377 SetEvent (state->have_stopped);
379 wait_events[0] = state->start_select;
380 wait_events[1] = state->exit_select;
382 if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE) != WAIT_OBJECT_0)
385 ResetEvent (state->have_stopped);
388 wait_events[0] = state->stop_select;
391 event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
393 if (event_index == WAIT_OBJECT_0
394 || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
397 if (event_index != WAIT_OBJECT_0 + 1)
399 /* Wait must have failed; assume an error has occured, e.g.
400 the handle has been closed. */
401 SetEvent (state->except_event);
405 /* We've got a pending event on the console. See if it's
407 if (!PeekConsoleInput (h, &record, 1, &n_records) || n_records != 1)
409 /* Something went wrong. Maybe the console is gone. */
410 SetEvent (state->except_event);
414 if (record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown)
416 WORD keycode = record.Event.KeyEvent.wVirtualKeyCode;
418 /* Ignore events containing only control keys. We must
419 recognize "enhanced" keys which we are interested in
420 reading via getch, if they do not map to ASCII. But we
421 do not want to report input available for e.g. the
422 control key alone. */
424 if (record.Event.KeyEvent.uChar.AsciiChar != 0
425 || keycode == VK_PRIOR
426 || keycode == VK_NEXT
428 || keycode == VK_HOME
429 || keycode == VK_LEFT
431 || keycode == VK_RIGHT
432 || keycode == VK_DOWN
433 || keycode == VK_INSERT
434 || keycode == VK_DELETE)
436 /* This is really a keypress. */
437 SetEvent (state->read_event);
442 /* Otherwise discard it and wait again. */
443 ReadConsoleInput (h, &record, 1, &n_records);
451 if (PeekNamedPipe ((HANDLE) _get_osfhandle (fd), NULL, 0, NULL, NULL, NULL))
458 pipe_select_thread (void *arg)
460 struct serial *scb = arg;
461 struct ser_console_state *state;
466 h = (HANDLE) _get_osfhandle (scb->fd);
470 HANDLE wait_events[2];
473 SetEvent (state->have_stopped);
475 wait_events[0] = state->start_select;
476 wait_events[1] = state->exit_select;
478 if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE) != WAIT_OBJECT_0)
481 ResetEvent (state->have_stopped);
484 if (!PeekNamedPipe (h, NULL, 0, NULL, &n_avail, NULL))
486 SetEvent (state->except_event);
492 SetEvent (state->read_event);
496 /* Delay 10ms before checking again, but allow the stop event
498 if (WaitForSingleObject (state->stop_select, 10) == WAIT_OBJECT_0)
506 ser_console_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
508 struct ser_console_state *state = scb->state;
515 is_tty = isatty (scb->fd);
516 if (!is_tty && !fd_is_pipe (scb->fd))
523 state = xmalloc (sizeof (struct ser_console_state));
524 memset (state, 0, sizeof (struct ser_console_state));
527 /* Create auto reset events to wake, stop, and exit the select
529 state->start_select = CreateEvent (0, FALSE, FALSE, 0);
530 state->stop_select = CreateEvent (0, FALSE, FALSE, 0);
531 state->exit_select = CreateEvent (0, FALSE, FALSE, 0);
533 /* Create a manual reset event to signal whether the thread is
534 stopped. This must be manual reset, because we may wait on
535 it multiple times without ever starting the thread. */
536 state->have_stopped = CreateEvent (0, TRUE, FALSE, 0);
538 /* Create our own events to report read and exceptions separately. */
539 state->read_event = CreateEvent (0, FALSE, FALSE, 0);
540 state->except_event = CreateEvent (0, FALSE, FALSE, 0);
543 state->thread = CreateThread (NULL, 0, console_select_thread, scb, 0,
546 state->thread = CreateThread (NULL, 0, pipe_select_thread, scb, 0,
550 *read = state->read_event;
551 *except = state->except_event;
553 /* Start from a blank state. */
554 ResetEvent (state->read_event);
555 ResetEvent (state->except_event);
556 ResetEvent (state->stop_select);
558 /* First check for a key already in the buffer. If there is one,
559 we don't need a thread. This also catches the second key of
560 multi-character returns from getch, for instance for arrow
561 keys. The second half is in a C library internal buffer,
562 and PeekConsoleInput will not find it. */
565 SetEvent (state->read_event);
569 /* Otherwise, start the select thread. */
570 SetEvent (state->start_select);
574 ser_console_done_wait_handle (struct serial *scb)
576 struct ser_console_state *state = scb->state;
581 SetEvent (state->stop_select);
582 WaitForSingleObject (state->have_stopped, INFINITE);
586 ser_console_close (struct serial *scb)
588 struct ser_console_state *state = scb->state;
592 SetEvent (state->exit_select);
594 WaitForSingleObject (state->thread, INFINITE);
596 CloseHandle (state->start_select);
597 CloseHandle (state->stop_select);
598 CloseHandle (state->exit_select);
599 CloseHandle (state->have_stopped);
601 CloseHandle (state->read_event);
602 CloseHandle (state->except_event);
608 struct ser_console_ttystate
613 static serial_ttystate
614 ser_console_get_tty_state (struct serial *scb)
616 if (isatty (scb->fd))
618 struct ser_console_ttystate *state;
619 state = (struct ser_console_ttystate *) xmalloc (sizeof *state);
627 struct net_windows_state
643 net_windows_select_thread (void *arg)
645 struct serial *scb = arg;
646 struct net_windows_state *state, state_copy;
653 HANDLE wait_events[2];
654 WSANETWORKEVENTS events;
656 SetEvent (state->have_stopped);
658 wait_events[0] = state->start_select;
659 wait_events[1] = state->exit_select;
661 if (WaitForMultipleObjects (2, wait_events, FALSE, INFINITE) != WAIT_OBJECT_0)
664 ResetEvent (state->have_stopped);
666 wait_events[0] = state->stop_select;
667 wait_events[1] = state->sock_event;
669 event_index = WaitForMultipleObjects (2, wait_events, FALSE, INFINITE);
671 if (event_index == WAIT_OBJECT_0
672 || WaitForSingleObject (state->stop_select, 0) == WAIT_OBJECT_0)
675 if (event_index != WAIT_OBJECT_0 + 1)
677 /* Some error has occured. Assume that this is an error
679 SetEvent (state->except_event);
683 /* Enumerate the internal network events, and reset the object that
684 signalled us to catch the next event. */
685 WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
687 gdb_assert (events.lNetworkEvents & (FD_READ | FD_CLOSE));
689 if (events.lNetworkEvents & FD_READ)
690 SetEvent (state->read_event);
692 if (events.lNetworkEvents & FD_CLOSE)
693 SetEvent (state->except_event);
698 net_windows_wait_handle (struct serial *scb, HANDLE *read, HANDLE *except)
700 struct net_windows_state *state = scb->state;
702 /* Start from a clean slate. */
703 ResetEvent (state->read_event);
704 ResetEvent (state->except_event);
705 ResetEvent (state->stop_select);
707 *read = state->read_event;
708 *except = state->except_event;
710 /* Check any pending events. This both avoids starting the thread
711 unnecessarily, and handles stray FD_READ events (see below). */
712 if (WaitForSingleObject (state->sock_event, 0) == WAIT_OBJECT_0)
714 WSANETWORKEVENTS events;
717 /* Enumerate the internal network events, and reset the object that
718 signalled us to catch the next event. */
719 WSAEnumNetworkEvents (scb->fd, state->sock_event, &events);
721 /* You'd think that FD_READ or FD_CLOSE would be set here. But,
722 sometimes, neither is. I suspect that the FD_READ is set and
723 the corresponding event signalled while recv is running, and
724 the FD_READ is then lowered when recv consumes all the data,
725 but there's no way to un-signal the event. This isn't a
726 problem for the call in net_select_thread, since any new
727 events after this point will not have been drained by recv.
728 It just means that we can't have the obvious assert here. */
730 /* If there is a read event, it might be still valid, or it might
731 not be - it may have been signalled before we last called
732 recv. Double-check that there is data. */
733 if (events.lNetworkEvents & FD_READ)
735 unsigned long available;
737 if (ioctlsocket (scb->fd, FIONREAD, &available) == 0
740 SetEvent (state->read_event);
744 /* Oops, no data. This call to recv will cause future
745 data to retrigger the event, e.g. while we are
746 in net_select_thread. */
747 recv (scb->fd, NULL, 0, 0);
750 /* If there's a close event, then record it - it is obviously
751 still valid, and it will not be resignalled. */
752 if (events.lNetworkEvents & FD_CLOSE)
754 SetEvent (state->except_event);
758 /* If we set either handle, there's no need to wake the thread. */
763 /* Start the select thread. */
764 SetEvent (state->start_select);
768 net_windows_done_wait_handle (struct serial *scb)
770 struct net_windows_state *state = scb->state;
772 SetEvent (state->stop_select);
773 WaitForSingleObject (state->have_stopped, INFINITE);
777 net_windows_open (struct serial *scb, const char *name)
779 struct net_windows_state *state;
783 ret = net_open (scb, name);
787 state = xmalloc (sizeof (struct net_windows_state));
788 memset (state, 0, sizeof (struct net_windows_state));
791 /* Create auto reset events to wake, stop, and exit the select
793 state->start_select = CreateEvent (0, FALSE, FALSE, 0);
794 state->stop_select = CreateEvent (0, FALSE, FALSE, 0);
795 state->exit_select = CreateEvent (0, FALSE, FALSE, 0);
797 /* Create a manual reset event to signal whether the thread is
798 stopped. This must be manual reset, because we may wait on
799 it multiple times without ever starting the thread. */
800 state->have_stopped = CreateEvent (0, TRUE, FALSE, 0);
802 /* Associate an event with the socket. */
803 state->sock_event = CreateEvent (0, TRUE, FALSE, 0);
804 WSAEventSelect (scb->fd, state->sock_event, FD_READ | FD_CLOSE);
806 /* Create our own events to report read and close separately. */
807 state->read_event = CreateEvent (0, FALSE, FALSE, 0);
808 state->except_event = CreateEvent (0, FALSE, FALSE, 0);
810 /* And finally start the select thread. */
811 state->thread = CreateThread (NULL, 0, net_windows_select_thread, scb, 0,
819 net_windows_close (struct serial *scb)
821 struct net_windows_state *state = scb->state;
823 SetEvent (state->exit_select);
824 WaitForSingleObject (state->thread, INFINITE);
826 CloseHandle (state->read_event);
827 CloseHandle (state->except_event);
829 CloseHandle (state->start_select);
830 CloseHandle (state->stop_select);
831 CloseHandle (state->exit_select);
832 CloseHandle (state->have_stopped);
834 CloseHandle (state->sock_event);
842 _initialize_ser_windows (void)
845 struct serial_ops *ops;
847 /* First register the serial port driver. */
849 ops = XMALLOC (struct serial_ops);
850 memset (ops, 0, sizeof (struct serial_ops));
851 ops->name = "hardwire";
853 ops->open = ser_windows_open;
854 ops->close = ser_windows_close;
856 ops->flush_output = ser_windows_flush_output;
857 ops->flush_input = ser_windows_flush_input;
858 ops->send_break = ser_windows_send_break;
860 /* These are only used for stdin; we do not need them for serial
861 ports, so supply the standard dummies. */
862 ops->get_tty_state = ser_base_get_tty_state;
863 ops->set_tty_state = ser_base_set_tty_state;
864 ops->print_tty_state = ser_base_print_tty_state;
865 ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
867 ops->go_raw = ser_windows_raw;
868 ops->setbaudrate = ser_windows_setbaudrate;
869 ops->setstopbits = ser_windows_setstopbits;
870 ops->drain_output = ser_windows_drain_output;
871 ops->readchar = ser_base_readchar;
872 ops->write = ser_base_write;
873 ops->async = ser_base_async;
874 ops->read_prim = ser_windows_read_prim;
875 ops->write_prim = ser_windows_write_prim;
876 ops->wait_handle = ser_windows_wait_handle;
878 serial_add_interface (ops);
880 /* Next create the dummy serial driver used for terminals. We only
881 provide the TTY-related methods. */
883 ops = XMALLOC (struct serial_ops);
884 memset (ops, 0, sizeof (struct serial_ops));
886 ops->name = "terminal";
889 ops->close = ser_console_close;
890 ops->get_tty_state = ser_console_get_tty_state;
891 ops->set_tty_state = ser_base_set_tty_state;
892 ops->print_tty_state = ser_base_print_tty_state;
893 ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
894 ops->drain_output = ser_base_drain_output;
895 ops->wait_handle = ser_console_wait_handle;
896 ops->done_wait_handle = ser_console_done_wait_handle;
898 serial_add_interface (ops);
900 /* If WinSock works, register the TCP/UDP socket driver. */
902 if (WSAStartup (MAKEWORD (1, 0), &wsa_data) != 0)
903 /* WinSock is unavailable. */
906 ops = XMALLOC (struct serial_ops);
907 memset (ops, 0, sizeof (struct serial_ops));
910 ops->open = net_windows_open;
911 ops->close = net_windows_close;
912 ops->readchar = ser_base_readchar;
913 ops->write = ser_base_write;
914 ops->flush_output = ser_base_flush_output;
915 ops->flush_input = ser_base_flush_input;
916 ops->send_break = ser_base_send_break;
917 ops->go_raw = ser_base_raw;
918 ops->get_tty_state = ser_base_get_tty_state;
919 ops->set_tty_state = ser_base_set_tty_state;
920 ops->print_tty_state = ser_base_print_tty_state;
921 ops->noflush_set_tty_state = ser_base_noflush_set_tty_state;
922 ops->setbaudrate = ser_base_setbaudrate;
923 ops->setstopbits = ser_base_setstopbits;
924 ops->drain_output = ser_base_drain_output;
925 ops->async = ser_base_async;
926 ops->read_prim = net_read_prim;
927 ops->write_prim = net_write_prim;
928 ops->wait_handle = net_windows_wait_handle;
929 ops->done_wait_handle = net_windows_done_wait_handle;
930 serial_add_interface (ops);