]> sigrok.org Git - libserialport.git/blame_incremental - serialport.c
projects / libserialport.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Move timing routines to separate file.
[libserialport.git] / serialport.c
... / ...
CommitLineData
1/*
2 * This file is part of the libserialport project.
3 *
4 * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
5 * Copyright (C) 2010-2015 Uwe Hermann <uwe@hermann-uwe.de>
6 * Copyright (C) 2013-2015 Martin Ling <martin-libserialport@earth.li>
7 * Copyright (C) 2013 Matthias Heidbrink <m-sigrok@heidbrink.biz>
8 * Copyright (C) 2014 Aurelien Jacobs <aurel@gnuage.org>
9 *
10 * This program is free software: you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as
12 * published by the Free Software Foundation, either version 3 of the
13 * License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this program. If not, see <http://www.gnu.org/licenses/>.
22 */
23
24#include <config.h>
25#include "libserialport.h"
26#include "libserialport_internal.h"
27
28static const struct std_baudrate std_baudrates[] = {
29#ifdef _WIN32
30 /*
31 * The baudrates 50/75/134/150/200/1800/230400/460800 do not seem to
32 * have documented CBR_* macros.
33 */
34 BAUD(110), BAUD(300), BAUD(600), BAUD(1200), BAUD(2400), BAUD(4800),
35 BAUD(9600), BAUD(14400), BAUD(19200), BAUD(38400), BAUD(57600),
36 BAUD(115200), BAUD(128000), BAUD(256000),
37#else
38 BAUD(50), BAUD(75), BAUD(110), BAUD(134), BAUD(150), BAUD(200),
39 BAUD(300), BAUD(600), BAUD(1200), BAUD(1800), BAUD(2400), BAUD(4800),
40 BAUD(9600), BAUD(19200), BAUD(38400), BAUD(57600), BAUD(115200),
41 BAUD(230400),
42#if !defined(__APPLE__) && !defined(__OpenBSD__)
43 BAUD(460800),
44#endif
45#endif
46};
47
48#define NUM_STD_BAUDRATES ARRAY_SIZE(std_baudrates)
49
50void (*sp_debug_handler)(const char *format, ...) = sp_default_debug_handler;
51
52static enum sp_return get_config(struct sp_port *port, struct port_data *data,
53 struct sp_port_config *config);
54
55static enum sp_return set_config(struct sp_port *port, struct port_data *data,
56 const struct sp_port_config *config);
57
58SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port **port_ptr)
59{
60 struct sp_port *port;
61#ifndef NO_PORT_METADATA
62 enum sp_return ret;
63#endif
64 int len;
65
66 TRACE("%s, %p", portname, port_ptr);
67
68 if (!port_ptr)
69 RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
70
71 *port_ptr = NULL;
72
73 if (!portname)
74 RETURN_ERROR(SP_ERR_ARG, "Null port name");
75
76 DEBUG_FMT("Building structure for port %s", portname);
77
78#if !defined(_WIN32) && defined(HAVE_REALPATH)
79 /*
80 * get_port_details() below tries to be too smart and figure out
81 * some transport properties from the port name which breaks with
82 * symlinks. Therefore we canonicalize the portname first.
83 */
84 char pathbuf[PATH_MAX + 1];
85 char *res = realpath(portname, pathbuf);
86 if (!res)
87 RETURN_ERROR(SP_ERR_ARG, "Could not retrieve realpath behind port name");
88
89 portname = pathbuf;
90#endif
91
92 if (!(port = malloc(sizeof(struct sp_port))))
93 RETURN_ERROR(SP_ERR_MEM, "Port structure malloc failed");
94
95 len = strlen(portname) + 1;
96
97 if (!(port->name = malloc(len))) {
98 free(port);
99 RETURN_ERROR(SP_ERR_MEM, "Port name malloc failed");
100 }
101
102 memcpy(port->name, portname, len);
103
104#ifdef _WIN32
105 port->usb_path = NULL;
106 port->hdl = INVALID_HANDLE_VALUE;
107 port->write_buf = NULL;
108 port->write_buf_size = 0;
109#else
110 port->fd = -1;
111#endif
112
113 port->description = NULL;
114 port->transport = SP_TRANSPORT_NATIVE;
115 port->usb_bus = -1;
116 port->usb_address = -1;
117 port->usb_vid = -1;
118 port->usb_pid = -1;
119 port->usb_manufacturer = NULL;
120 port->usb_product = NULL;
121 port->usb_serial = NULL;
122 port->bluetooth_address = NULL;
123
124#ifndef NO_PORT_METADATA
125 if ((ret = get_port_details(port)) != SP_OK) {
126 sp_free_port(port);
127 return ret;
128 }
129#endif
130
131 *port_ptr = port;
132
133 RETURN_OK();
134}
135
136SP_API char *sp_get_port_name(const struct sp_port *port)
137{
138 TRACE("%p", port);
139
140 if (!port)
141 return NULL;
142
143 RETURN_STRING(port->name);
144}
145
146SP_API char *sp_get_port_description(const struct sp_port *port)
147{
148 TRACE("%p", port);
149
150 if (!port || !port->description)
151 return NULL;
152
153 RETURN_STRING(port->description);
154}
155
156SP_API enum sp_transport sp_get_port_transport(const struct sp_port *port)
157{
158 TRACE("%p", port);
159
160 if (!port)
161 RETURN_ERROR(SP_ERR_ARG, "Null port");
162
163 RETURN_INT(port->transport);
164}
165
166SP_API enum sp_return sp_get_port_usb_bus_address(const struct sp_port *port,
167 int *usb_bus,int *usb_address)
168{
169 TRACE("%p", port);
170
171 if (!port)
172 RETURN_ERROR(SP_ERR_ARG, "Null port");
173 if (port->transport != SP_TRANSPORT_USB)
174 RETURN_ERROR(SP_ERR_ARG, "Port does not use USB transport");
175 if (port->usb_bus < 0 || port->usb_address < 0)
176 RETURN_ERROR(SP_ERR_SUPP, "Bus and address values are not available");
177
178 if (usb_bus)
179 *usb_bus = port->usb_bus;
180 if (usb_address)
181 *usb_address = port->usb_address;
182
183 RETURN_OK();
184}
185
186SP_API enum sp_return sp_get_port_usb_vid_pid(const struct sp_port *port,
187 int *usb_vid, int *usb_pid)
188{
189 TRACE("%p", port);
190
191 if (!port)
192 RETURN_ERROR(SP_ERR_ARG, "Null port");
193 if (port->transport != SP_TRANSPORT_USB)
194 RETURN_ERROR(SP_ERR_ARG, "Port does not use USB transport");
195 if (port->usb_vid < 0 || port->usb_pid < 0)
196 RETURN_ERROR(SP_ERR_SUPP, "VID:PID values are not available");
197
198 if (usb_vid)
199 *usb_vid = port->usb_vid;
200 if (usb_pid)
201 *usb_pid = port->usb_pid;
202
203 RETURN_OK();
204}
205
206SP_API char *sp_get_port_usb_manufacturer(const struct sp_port *port)
207{
208 TRACE("%p", port);
209
210 if (!port || port->transport != SP_TRANSPORT_USB || !port->usb_manufacturer)
211 return NULL;
212
213 RETURN_STRING(port->usb_manufacturer);
214}
215
216SP_API char *sp_get_port_usb_product(const struct sp_port *port)
217{
218 TRACE("%p", port);
219
220 if (!port || port->transport != SP_TRANSPORT_USB || !port->usb_product)
221 return NULL;
222
223 RETURN_STRING(port->usb_product);
224}
225
226SP_API char *sp_get_port_usb_serial(const struct sp_port *port)
227{
228 TRACE("%p", port);
229
230 if (!port || port->transport != SP_TRANSPORT_USB || !port->usb_serial)
231 return NULL;
232
233 RETURN_STRING(port->usb_serial);
234}
235
236SP_API char *sp_get_port_bluetooth_address(const struct sp_port *port)
237{
238 TRACE("%p", port);
239
240 if (!port || port->transport != SP_TRANSPORT_BLUETOOTH
241 || !port->bluetooth_address)
242 return NULL;
243
244 RETURN_STRING(port->bluetooth_address);
245}
246
247SP_API enum sp_return sp_get_port_handle(const struct sp_port *port,
248 void *result_ptr)
249{
250 TRACE("%p, %p", port, result_ptr);
251
252 if (!port)
253 RETURN_ERROR(SP_ERR_ARG, "Null port");
254 if (!result_ptr)
255 RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
256
257#ifdef _WIN32
258 HANDLE *handle_ptr = result_ptr;
259 *handle_ptr = port->hdl;
260#else
261 int *fd_ptr = result_ptr;
262 *fd_ptr = port->fd;
263#endif
264
265 RETURN_OK();
266}
267
268SP_API enum sp_return sp_copy_port(const struct sp_port *port,
269 struct sp_port **copy_ptr)
270{
271 TRACE("%p, %p", port, copy_ptr);
272
273 if (!copy_ptr)
274 RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
275
276 *copy_ptr = NULL;
277
278 if (!port)
279 RETURN_ERROR(SP_ERR_ARG, "Null port");
280
281 if (!port->name)
282 RETURN_ERROR(SP_ERR_ARG, "Null port name");
283
284 DEBUG("Copying port structure");
285
286 RETURN_INT(sp_get_port_by_name(port->name, copy_ptr));
287}
288
289SP_API void sp_free_port(struct sp_port *port)
290{
291 TRACE("%p", port);
292
293 if (!port) {
294 DEBUG("Null port");
295 RETURN();
296 }
297
298 DEBUG("Freeing port structure");
299
300 if (port->name)
301 free(port->name);
302 if (port->description)
303 free(port->description);
304 if (port->usb_manufacturer)
305 free(port->usb_manufacturer);
306 if (port->usb_product)
307 free(port->usb_product);
308 if (port->usb_serial)
309 free(port->usb_serial);
310 if (port->bluetooth_address)
311 free(port->bluetooth_address);
312#ifdef _WIN32
313 if (port->usb_path)
314 free(port->usb_path);
315 if (port->write_buf)
316 free(port->write_buf);
317#endif
318
319 free(port);
320
321 RETURN();
322}
323
324SP_PRIV struct sp_port **list_append(struct sp_port **list,
325 const char *portname)
326{
327 void *tmp;
328 unsigned int count;
329
330 for (count = 0; list[count]; count++)
331 ;
332 if (!(tmp = realloc(list, sizeof(struct sp_port *) * (count + 2))))
333 goto fail;
334 list = tmp;
335 if (sp_get_port_by_name(portname, &list[count]) != SP_OK)
336 goto fail;
337 list[count + 1] = NULL;
338 return list;
339
340fail:
341 sp_free_port_list(list);
342 return NULL;
343}
344
345SP_API enum sp_return sp_list_ports(struct sp_port ***list_ptr)
346{
347#ifndef NO_ENUMERATION
348 struct sp_port **list;
349 int ret;
350#endif
351
352 TRACE("%p", list_ptr);
353
354 if (!list_ptr)
355 RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
356
357 *list_ptr = NULL;
358
359#ifdef NO_ENUMERATION
360 RETURN_ERROR(SP_ERR_SUPP, "Enumeration not supported on this platform");
361#else
362 DEBUG("Enumerating ports");
363
364 if (!(list = malloc(sizeof(struct sp_port *))))
365 RETURN_ERROR(SP_ERR_MEM, "Port list malloc failed");
366
367 list[0] = NULL;
368
369 ret = list_ports(&list);
370
371 if (ret == SP_OK) {
372 *list_ptr = list;
373 } else {
374 sp_free_port_list(list);
375 *list_ptr = NULL;
376 }
377
378 RETURN_CODEVAL(ret);
379#endif
380}
381
382SP_API void sp_free_port_list(struct sp_port **list)
383{
384 unsigned int i;
385
386 TRACE("%p", list);
387
388 if (!list) {
389 DEBUG("Null list");
390 RETURN();
391 }
392
393 DEBUG("Freeing port list");
394
395 for (i = 0; list[i]; i++)
396 sp_free_port(list[i]);
397 free(list);
398
399 RETURN();
400}
401
402#define CHECK_PORT() do { \
403 if (!port) \
404 RETURN_ERROR(SP_ERR_ARG, "Null port"); \
405 if (!port->name) \
406 RETURN_ERROR(SP_ERR_ARG, "Null port name"); \
407} while (0)
408#ifdef _WIN32
409#define CHECK_PORT_HANDLE() do { \
410 if (port->hdl == INVALID_HANDLE_VALUE) \
411 RETURN_ERROR(SP_ERR_ARG, "Port not open"); \
412} while (0)
413#else
414#define CHECK_PORT_HANDLE() do { \
415 if (port->fd < 0) \
416 RETURN_ERROR(SP_ERR_ARG, "Port not open"); \
417} while (0)
418#endif
419#define CHECK_OPEN_PORT() do { \
420 CHECK_PORT(); \
421 CHECK_PORT_HANDLE(); \
422} while (0)
423
424#ifdef WIN32
425/** To be called after port receive buffer is emptied. */
426static enum sp_return restart_wait(struct sp_port *port)
427{
428 DWORD wait_result;
429
430 if (port->wait_running) {
431 /* Check status of running wait operation. */
432 if (GetOverlappedResult(port->hdl, &port->wait_ovl,
433 &wait_result, FALSE)) {
434 DEBUG("Previous wait completed");
435 port->wait_running = FALSE;
436 } else if (GetLastError() == ERROR_IO_INCOMPLETE) {
437 DEBUG("Previous wait still running");
438 RETURN_OK();
439 } else {
440 RETURN_FAIL("GetOverlappedResult() failed");
441 }
442 }
443
444 if (!port->wait_running) {
445 /* Start new wait operation. */
446 if (WaitCommEvent(port->hdl, &port->events,
447 &port->wait_ovl)) {
448 DEBUG("New wait returned, events already pending");
449 } else if (GetLastError() == ERROR_IO_PENDING) {
450 DEBUG("New wait running in background");
451 port->wait_running = TRUE;
452 } else {
453 RETURN_FAIL("WaitCommEvent() failed");
454 }
455 }
456
457 RETURN_OK();
458}
459#endif
460
461SP_API enum sp_return sp_open(struct sp_port *port, enum sp_mode flags)
462{
463 struct port_data data;
464 struct sp_port_config config;
465 enum sp_return ret;
466
467 TRACE("%p, 0x%x", port, flags);
468
469 CHECK_PORT();
470
471 if (flags > SP_MODE_READ_WRITE)
472 RETURN_ERROR(SP_ERR_ARG, "Invalid flags");
473
474 DEBUG_FMT("Opening port %s", port->name);
475
476#ifdef _WIN32
477 DWORD desired_access = 0, flags_and_attributes = 0, errors;
478 char *escaped_port_name;
479 COMSTAT status;
480
481 /* Prefix port name with '\\.\' to work with ports above COM9. */
482 if (!(escaped_port_name = malloc(strlen(port->name) + 5)))
483 RETURN_ERROR(SP_ERR_MEM, "Escaped port name malloc failed");
484 sprintf(escaped_port_name, "\\\\.\\%s", port->name);
485
486 /* Map 'flags' to the OS-specific settings. */
487 flags_and_attributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED;
488 if (flags & SP_MODE_READ)
489 desired_access |= GENERIC_READ;
490 if (flags & SP_MODE_WRITE)
491 desired_access |= GENERIC_WRITE;
492
493 port->hdl = CreateFile(escaped_port_name, desired_access, 0, 0,
494 OPEN_EXISTING, flags_and_attributes, 0);
495
496 free(escaped_port_name);
497
498 if (port->hdl == INVALID_HANDLE_VALUE)
499 RETURN_FAIL("Port CreateFile() failed");
500
501 /* All timeouts initially disabled. */
502 port->timeouts.ReadIntervalTimeout = 0;
503 port->timeouts.ReadTotalTimeoutMultiplier = 0;
504 port->timeouts.ReadTotalTimeoutConstant = 0;
505 port->timeouts.WriteTotalTimeoutMultiplier = 0;
506 port->timeouts.WriteTotalTimeoutConstant = 0;
507
508 if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) {
509 sp_close(port);
510 RETURN_FAIL("SetCommTimeouts() failed");
511 }
512
513 /* Prepare OVERLAPPED structures. */
514#define INIT_OVERLAPPED(ovl) do { \
515 memset(&port->ovl, 0, sizeof(port->ovl)); \
516 port->ovl.hEvent = INVALID_HANDLE_VALUE; \
517 if ((port->ovl.hEvent = CreateEvent(NULL, TRUE, TRUE, NULL)) \
518 == INVALID_HANDLE_VALUE) { \
519 sp_close(port); \
520 RETURN_FAIL(#ovl "CreateEvent() failed"); \
521 } \
522} while (0)
523
524 INIT_OVERLAPPED(read_ovl);
525 INIT_OVERLAPPED(write_ovl);
526 INIT_OVERLAPPED(wait_ovl);
527
528 /* Set event mask for RX and error events. */
529 if (SetCommMask(port->hdl, EV_RXCHAR | EV_ERR) == 0) {
530 sp_close(port);
531 RETURN_FAIL("SetCommMask() failed");
532 }
533
534 port->writing = FALSE;
535 port->wait_running = FALSE;
536
537 ret = restart_wait(port);
538
539 if (ret < 0) {
540 sp_close(port);
541 RETURN_CODEVAL(ret);
542 }
543#else
544 int flags_local = O_NONBLOCK | O_NOCTTY | O_CLOEXEC;
545
546 /* Map 'flags' to the OS-specific settings. */
547 if ((flags & SP_MODE_READ_WRITE) == SP_MODE_READ_WRITE)
548 flags_local |= O_RDWR;
549 else if (flags & SP_MODE_READ)
550 flags_local |= O_RDONLY;
551 else if (flags & SP_MODE_WRITE)
552 flags_local |= O_WRONLY;
553
554 if ((port->fd = open(port->name, flags_local)) < 0)
555 RETURN_FAIL("open() failed");
556#endif
557
558 ret = get_config(port, &data, &config);
559
560 if (ret < 0) {
561 sp_close(port);
562 RETURN_CODEVAL(ret);
563 }
564
565 /* Set sane port settings. */
566#ifdef _WIN32
567 data.dcb.fBinary = TRUE;
568 data.dcb.fDsrSensitivity = FALSE;
569 data.dcb.fErrorChar = FALSE;
570 data.dcb.fNull = FALSE;
571 data.dcb.fAbortOnError = FALSE;
572#else
573 /* Turn off all fancy termios tricks, give us a raw channel. */
574 data.term.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IMAXBEL);
575#ifdef IUCLC
576 data.term.c_iflag &= ~IUCLC;
577#endif
578 data.term.c_oflag &= ~(OPOST | ONLCR | OCRNL | ONOCR | ONLRET);
579#ifdef OLCUC
580 data.term.c_oflag &= ~OLCUC;
581#endif
582#ifdef NLDLY
583 data.term.c_oflag &= ~NLDLY;
584#endif
585#ifdef CRDLY
586 data.term.c_oflag &= ~CRDLY;
587#endif
588#ifdef TABDLY
589 data.term.c_oflag &= ~TABDLY;
590#endif
591#ifdef BSDLY
592 data.term.c_oflag &= ~BSDLY;
593#endif
594#ifdef VTDLY
595 data.term.c_oflag &= ~VTDLY;
596#endif
597#ifdef FFDLY
598 data.term.c_oflag &= ~FFDLY;
599#endif
600#ifdef OFILL
601 data.term.c_oflag &= ~OFILL;
602#endif
603 data.term.c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN);
604 data.term.c_cc[VMIN] = 0;
605 data.term.c_cc[VTIME] = 0;
606
607 /* Ignore modem status lines; enable receiver; leave control lines alone on close. */
608 data.term.c_cflag |= (CLOCAL | CREAD | HUPCL);
609#endif
610
611#ifdef _WIN32
612 if (ClearCommError(port->hdl, &errors, &status) == 0)
613 RETURN_FAIL("ClearCommError() failed");
614#endif
615
616 ret = set_config(port, &data, &config);
617
618 if (ret < 0) {
619 sp_close(port);
620 RETURN_CODEVAL(ret);
621 }
622
623 RETURN_OK();
624}
625
626SP_API enum sp_return sp_close(struct sp_port *port)
627{
628 TRACE("%p", port);
629
630 CHECK_OPEN_PORT();
631
632 DEBUG_FMT("Closing port %s", port->name);
633
634#ifdef _WIN32
635 /* Returns non-zero upon success, 0 upon failure. */
636 if (CloseHandle(port->hdl) == 0)
637 RETURN_FAIL("Port CloseHandle() failed");
638 port->hdl = INVALID_HANDLE_VALUE;
639
640 /* Close event handles for overlapped structures. */
641#define CLOSE_OVERLAPPED(ovl) do { \
642 if (port->ovl.hEvent != INVALID_HANDLE_VALUE && \
643 CloseHandle(port->ovl.hEvent) == 0) \
644 RETURN_FAIL(# ovl "event CloseHandle() failed"); \
645} while (0)
646 CLOSE_OVERLAPPED(read_ovl);
647 CLOSE_OVERLAPPED(write_ovl);
648 CLOSE_OVERLAPPED(wait_ovl);
649
650 if (port->write_buf) {
651 free(port->write_buf);
652 port->write_buf = NULL;
653 }
654#else
655 /* Returns 0 upon success, -1 upon failure. */
656 if (close(port->fd) == -1)
657 RETURN_FAIL("close() failed");
658 port->fd = -1;
659#endif
660
661 RETURN_OK();
662}
663
664SP_API enum sp_return sp_flush(struct sp_port *port, enum sp_buffer buffers)
665{
666 TRACE("%p, 0x%x", port, buffers);
667
668 CHECK_OPEN_PORT();
669
670 if (buffers > SP_BUF_BOTH)
671 RETURN_ERROR(SP_ERR_ARG, "Invalid buffer selection");
672
673 const char *buffer_names[] = {"no", "input", "output", "both"};
674
675 DEBUG_FMT("Flushing %s buffers on port %s",
676 buffer_names[buffers], port->name);
677
678#ifdef _WIN32
679 DWORD flags = 0;
680 if (buffers & SP_BUF_INPUT)
681 flags |= PURGE_RXCLEAR;
682 if (buffers & SP_BUF_OUTPUT)
683 flags |= PURGE_TXCLEAR;
684
685 /* Returns non-zero upon success, 0 upon failure. */
686 if (PurgeComm(port->hdl, flags) == 0)
687 RETURN_FAIL("PurgeComm() failed");
688
689 if (buffers & SP_BUF_INPUT)
690 TRY(restart_wait(port));
691#else
692 int flags = 0;
693 if (buffers == SP_BUF_BOTH)
694 flags = TCIOFLUSH;
695 else if (buffers == SP_BUF_INPUT)
696 flags = TCIFLUSH;
697 else if (buffers == SP_BUF_OUTPUT)
698 flags = TCOFLUSH;
699
700 /* Returns 0 upon success, -1 upon failure. */
701 if (tcflush(port->fd, flags) < 0)
702 RETURN_FAIL("tcflush() failed");
703#endif
704 RETURN_OK();
705}
706
707SP_API enum sp_return sp_drain(struct sp_port *port)
708{
709 TRACE("%p", port);
710
711 CHECK_OPEN_PORT();
712
713 DEBUG_FMT("Draining port %s", port->name);
714
715#ifdef _WIN32
716 /* Returns non-zero upon success, 0 upon failure. */
717 if (FlushFileBuffers(port->hdl) == 0)
718 RETURN_FAIL("FlushFileBuffers() failed");
719 RETURN_OK();
720#else
721 int result;
722 while (1) {
723#if defined(__ANDROID__) && (__ANDROID_API__ < 21)
724 /* Android only has tcdrain from platform 21 onwards.
725 * On previous API versions, use the ioctl directly. */
726 int arg = 1;
727 result = ioctl(port->fd, TCSBRK, &arg);
728#else
729 result = tcdrain(port->fd);
730#endif
731 if (result < 0) {
732 if (errno == EINTR) {
733 DEBUG("tcdrain() was interrupted");
734 continue;
735 } else {
736 RETURN_FAIL("tcdrain() failed");
737 }
738 } else {
739 RETURN_OK();
740 }
741 }
742#endif
743}
744
745#ifdef _WIN32
746static enum sp_return await_write_completion(struct sp_port *port)
747{
748 TRACE("%p", port);
749 DWORD bytes_written;
750 BOOL result;
751
752 /* Wait for previous non-blocking write to complete, if any. */
753 if (port->writing) {
754 DEBUG("Waiting for previous write to complete");
755 result = GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE);
756 port->writing = 0;
757 if (!result)
758 RETURN_FAIL("Previous write failed to complete");
759 DEBUG("Previous write completed");
760 }
761
762 RETURN_OK();
763}
764#endif
765
766SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf,
767 size_t count, unsigned int timeout_ms)
768{
769 TRACE("%p, %p, %d, %d", port, buf, count, timeout_ms);
770
771 CHECK_OPEN_PORT();
772
773 if (!buf)
774 RETURN_ERROR(SP_ERR_ARG, "Null buffer");
775
776 if (timeout_ms)
777 DEBUG_FMT("Writing %d bytes to port %s, timeout %d ms",
778 count, port->name, timeout_ms);
779 else
780 DEBUG_FMT("Writing %d bytes to port %s, no timeout",
781 count, port->name);
782
783 if (count == 0)
784 RETURN_INT(0);
785
786#ifdef _WIN32
787 DWORD bytes_written = 0;
788
789 TRY(await_write_completion(port));
790
791 /* Set timeout. */
792 if (port->timeouts.WriteTotalTimeoutConstant != timeout_ms) {
793 port->timeouts.WriteTotalTimeoutConstant = timeout_ms;
794 if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
795 RETURN_FAIL("SetCommTimeouts() failed");
796 }
797
798 /* Reduce count if it exceeds the WriteFile limit. */
799 if (count > WRITEFILE_MAX_SIZE)
800 count = WRITEFILE_MAX_SIZE;
801
802 /* Start write. */
803 if (WriteFile(port->hdl, buf, count, NULL, &port->write_ovl)) {
804 DEBUG("Write completed immediately");
805 RETURN_INT(count);
806 } else if (GetLastError() == ERROR_IO_PENDING) {
807 DEBUG("Waiting for write to complete");
808 if (GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE) == 0) {
809 if (GetLastError() == ERROR_SEM_TIMEOUT) {
810 DEBUG("Write timed out");
811 RETURN_INT(0);
812 } else {
813 RETURN_FAIL("GetOverlappedResult() failed");
814 }
815 }
816 DEBUG_FMT("Write completed, %d/%d bytes written", bytes_written, count);
817 RETURN_INT(bytes_written);
818 } else {
819 RETURN_FAIL("WriteFile() failed");
820 }
821#else
822 size_t bytes_written = 0;
823 unsigned char *ptr = (unsigned char *) buf;
824 struct timeout timeout;
825 fd_set fds;
826 int result;
827
828 timeout_start(&timeout, timeout_ms);
829
830 FD_ZERO(&fds);
831 FD_SET(port->fd, &fds);
832
833 /* Loop until we have written the requested number of bytes. */
834 while (bytes_written < count) {
835
836 if (timeout_check(&timeout))
837 break;
838
839 result = select(port->fd + 1, NULL, &fds, NULL, timeout_timeval(&timeout));
840
841 timeout_update(&timeout);
842
843 if (result < 0) {
844 if (errno == EINTR) {
845 DEBUG("select() call was interrupted, repeating");
846 continue;
847 } else {
848 RETURN_FAIL("select() failed");
849 }
850 } else if (result == 0) {
851 /* Timeout has expired. */
852 break;
853 }
854
855 /* Do write. */
856 result = write(port->fd, ptr, count - bytes_written);
857
858 if (result < 0) {
859 if (errno == EAGAIN)
860 /* This shouldn't happen because we did a select() first, but handle anyway. */
861 continue;
862 else
863 /* This is an actual failure. */
864 RETURN_FAIL("write() failed");
865 }
866
867 bytes_written += result;
868 ptr += result;
869 }
870
871 if (bytes_written < count)
872 DEBUG("Write timed out");
873
874 RETURN_INT(bytes_written);
875#endif
876}
877
878SP_API enum sp_return sp_nonblocking_write(struct sp_port *port,
879 const void *buf, size_t count)
880{
881 TRACE("%p, %p, %d", port, buf, count);
882
883 CHECK_OPEN_PORT();
884
885 if (!buf)
886 RETURN_ERROR(SP_ERR_ARG, "Null buffer");
887
888 DEBUG_FMT("Writing up to %d bytes to port %s", count, port->name);
889
890 if (count == 0)
891 RETURN_INT(0);
892
893#ifdef _WIN32
894 DWORD buf_bytes;
895
896 /* Check whether previous write is complete. */
897 if (port->writing) {
898 if (HasOverlappedIoCompleted(&port->write_ovl)) {
899 DEBUG("Previous write completed");
900 port->writing = 0;
901 } else {
902 DEBUG("Previous write not complete");
903 /* Can't take a new write until the previous one finishes. */
904 RETURN_INT(0);
905 }
906 }
907
908 /* Set timeout. */
909 if (port->timeouts.WriteTotalTimeoutConstant != 0) {
910 port->timeouts.WriteTotalTimeoutConstant = 0;
911 if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
912 RETURN_FAIL("SetCommTimeouts() failed");
913 }
914
915 /* Reduce count if it exceeds the WriteFile limit. */
916 if (count > WRITEFILE_MAX_SIZE)
917 count = WRITEFILE_MAX_SIZE;
918
919 /* Copy data to our write buffer. */
920 buf_bytes = min(port->write_buf_size, count);
921 memcpy(port->write_buf, buf, buf_bytes);
922
923 /* Start asynchronous write. */
924 if (WriteFile(port->hdl, port->write_buf, buf_bytes, NULL, &port->write_ovl) == 0) {
925 if (GetLastError() == ERROR_IO_PENDING) {
926 if ((port->writing = !HasOverlappedIoCompleted(&port->write_ovl)))
927 DEBUG("Asynchronous write completed immediately");
928 else
929 DEBUG("Asynchronous write running");
930 } else {
931 /* Actual failure of some kind. */
932 RETURN_FAIL("WriteFile() failed");
933 }
934 }
935
936 DEBUG("All bytes written immediately");
937
938 RETURN_INT(buf_bytes);
939#else
940 /* Returns the number of bytes written, or -1 upon failure. */
941 ssize_t written = write(port->fd, buf, count);
942
943 if (written < 0) {
944 if (errno == EAGAIN)
945 // Buffer is full, no bytes written.
946 RETURN_INT(0);
947 else
948 RETURN_FAIL("write() failed");
949 } else {
950 RETURN_INT(written);
951 }
952#endif
953}
954
955#ifdef _WIN32
956/* Restart wait operation if buffer was emptied. */
957static enum sp_return restart_wait_if_needed(struct sp_port *port, unsigned int bytes_read)
958{
959 DWORD errors;
960 COMSTAT comstat;
961
962 if (bytes_read == 0)
963 RETURN_OK();
964
965 if (ClearCommError(port->hdl, &errors, &comstat) == 0)
966 RETURN_FAIL("ClearCommError() failed");
967
968 if (comstat.cbInQue == 0)
969 TRY(restart_wait(port));
970
971 RETURN_OK();
972}
973#endif
974
975SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf,
976 size_t count, unsigned int timeout_ms)
977{
978 TRACE("%p, %p, %d, %d", port, buf, count, timeout_ms);
979
980 CHECK_OPEN_PORT();
981
982 if (!buf)
983 RETURN_ERROR(SP_ERR_ARG, "Null buffer");
984
985 if (timeout_ms)
986 DEBUG_FMT("Reading %d bytes from port %s, timeout %d ms",
987 count, port->name, timeout_ms);
988 else
989 DEBUG_FMT("Reading %d bytes from port %s, no timeout",
990 count, port->name);
991
992 if (count == 0)
993 RETURN_INT(0);
994
995#ifdef _WIN32
996 DWORD bytes_read = 0;
997
998 /* Set timeout. */
999 if (port->timeouts.ReadIntervalTimeout != 0 ||
1000 port->timeouts.ReadTotalTimeoutMultiplier != 0 ||
1001 port->timeouts.ReadTotalTimeoutConstant != timeout_ms) {
1002 port->timeouts.ReadIntervalTimeout = 0;
1003 port->timeouts.ReadTotalTimeoutMultiplier = 0;
1004 port->timeouts.ReadTotalTimeoutConstant = timeout_ms;
1005 if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
1006 RETURN_FAIL("SetCommTimeouts() failed");
1007 }
1008
1009 /* Start read. */
1010 if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl)) {
1011 DEBUG("Read completed immediately");
1012 bytes_read = count;
1013 } else if (GetLastError() == ERROR_IO_PENDING) {
1014 DEBUG("Waiting for read to complete");
1015 if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE) == 0)
1016 RETURN_FAIL("GetOverlappedResult() failed");
1017 DEBUG_FMT("Read completed, %d/%d bytes read", bytes_read, count);
1018 } else {
1019 RETURN_FAIL("ReadFile() failed");
1020 }
1021
1022 TRY(restart_wait_if_needed(port, bytes_read));
1023
1024 RETURN_INT(bytes_read);
1025
1026#else
1027 size_t bytes_read = 0;
1028 unsigned char *ptr = (unsigned char *) buf;
1029 struct timeout timeout;
1030 fd_set fds;
1031 int result;
1032
1033 timeout_start(&timeout, timeout_ms);
1034
1035 FD_ZERO(&fds);
1036 FD_SET(port->fd, &fds);
1037
1038 /* Loop until we have the requested number of bytes. */
1039 while (bytes_read < count) {
1040
1041 if (timeout_check(&timeout))
1042 /* Timeout has expired. */
1043 break;
1044
1045 result = select(port->fd + 1, &fds, NULL, NULL, timeout_timeval(&timeout));
1046
1047 timeout_update(&timeout);
1048
1049 if (result < 0) {
1050 if (errno == EINTR) {
1051 DEBUG("select() call was interrupted, repeating");
1052 continue;
1053 } else {
1054 RETURN_FAIL("select() failed");
1055 }
1056 } else if (result == 0) {
1057 /* Timeout has expired. */
1058 break;
1059 }
1060
1061 /* Do read. */
1062 result = read(port->fd, ptr, count - bytes_read);
1063
1064 if (result < 0) {
1065 if (errno == EAGAIN)
1066 /*
1067 * This shouldn't happen because we did a
1068 * select() first, but handle anyway.
1069 */
1070 continue;
1071 else
1072 /* This is an actual failure. */
1073 RETURN_FAIL("read() failed");
1074 }
1075
1076 bytes_read += result;
1077 ptr += result;
1078 }
1079
1080 if (bytes_read < count)
1081 DEBUG("Read timed out");
1082
1083 RETURN_INT(bytes_read);
1084#endif
1085}
1086
1087SP_API enum sp_return sp_blocking_read_next(struct sp_port *port, void *buf,
1088 size_t count, unsigned int timeout_ms)
1089{
1090 TRACE("%p, %p, %d, %d", port, buf, count, timeout_ms);
1091
1092 CHECK_OPEN_PORT();
1093
1094 if (!buf)
1095 RETURN_ERROR(SP_ERR_ARG, "Null buffer");
1096
1097 if (count == 0)
1098 RETURN_ERROR(SP_ERR_ARG, "Zero count");
1099
1100 if (timeout_ms)
1101 DEBUG_FMT("Reading next max %d bytes from port %s, timeout %d ms",
1102 count, port->name, timeout_ms);
1103 else
1104 DEBUG_FMT("Reading next max %d bytes from port %s, no timeout",
1105 count, port->name);
1106
1107#ifdef _WIN32
1108 DWORD bytes_read = 0;
1109
1110 /* If timeout_ms == 0, set maximum timeout. */
1111 DWORD timeout_val = (timeout_ms == 0 ? MAXDWORD - 1 : timeout_ms);
1112
1113 /* Set timeout. */
1114 if (port->timeouts.ReadIntervalTimeout != MAXDWORD ||
1115 port->timeouts.ReadTotalTimeoutMultiplier != MAXDWORD ||
1116 port->timeouts.ReadTotalTimeoutConstant != timeout_val) {
1117 port->timeouts.ReadIntervalTimeout = MAXDWORD;
1118 port->timeouts.ReadTotalTimeoutMultiplier = MAXDWORD;
1119 port->timeouts.ReadTotalTimeoutConstant = timeout_val;
1120 if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
1121 RETURN_FAIL("SetCommTimeouts() failed");
1122 }
1123
1124 /* Loop until we have at least one byte, or timeout is reached. */
1125 while (bytes_read == 0) {
1126 /* Start read. */
1127 if (ReadFile(port->hdl, buf, count, &bytes_read, &port->read_ovl)) {
1128 DEBUG("Read completed immediately");
1129 } else if (GetLastError() == ERROR_IO_PENDING) {
1130 DEBUG("Waiting for read to complete");
1131 if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE) == 0)
1132 RETURN_FAIL("GetOverlappedResult() failed");
1133 if (bytes_read > 0) {
1134 DEBUG("Read completed");
1135 } else if (timeout_ms > 0) {
1136 DEBUG("Read timed out");
1137 break;
1138 } else {
1139 DEBUG("Restarting read");
1140 }
1141 } else {
1142 RETURN_FAIL("ReadFile() failed");
1143 }
1144 }
1145
1146 TRY(restart_wait_if_needed(port, bytes_read));
1147
1148 RETURN_INT(bytes_read);
1149
1150#else
1151 size_t bytes_read = 0;
1152 struct timeout timeout;
1153 fd_set fds;
1154 int result;
1155
1156 timeout_start(&timeout, timeout_ms);
1157
1158 FD_ZERO(&fds);
1159 FD_SET(port->fd, &fds);
1160
1161 /* Loop until we have at least one byte, or timeout is reached. */
1162 while (bytes_read == 0) {
1163
1164 if (timeout_check(&timeout))
1165 /* Timeout has expired. */
1166 break;
1167
1168 result = select(port->fd + 1, &fds, NULL, NULL, timeout_timeval(&timeout));
1169
1170 timeout_update(&timeout);
1171
1172 if (result < 0) {
1173 if (errno == EINTR) {
1174 DEBUG("select() call was interrupted, repeating");
1175 continue;
1176 } else {
1177 RETURN_FAIL("select() failed");
1178 }
1179 } else if (result == 0) {
1180 /* Timeout has expired. */
1181 break;
1182 }
1183
1184 /* Do read. */
1185 result = read(port->fd, buf, count);
1186
1187 if (result < 0) {
1188 if (errno == EAGAIN)
1189 /* This shouldn't happen because we did a select() first, but handle anyway. */
1190 continue;
1191 else
1192 /* This is an actual failure. */
1193 RETURN_FAIL("read() failed");
1194 }
1195
1196 bytes_read = result;
1197 }
1198
1199 if (bytes_read == 0)
1200 DEBUG("Read timed out");
1201
1202 RETURN_INT(bytes_read);
1203#endif
1204}
1205
1206SP_API enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf,
1207 size_t count)
1208{
1209 TRACE("%p, %p, %d", port, buf, count);
1210
1211 CHECK_OPEN_PORT();
1212
1213 if (!buf)
1214 RETURN_ERROR(SP_ERR_ARG, "Null buffer");
1215
1216 DEBUG_FMT("Reading up to %d bytes from port %s", count, port->name);
1217
1218#ifdef _WIN32
1219 DWORD bytes_read;
1220
1221 /* Set timeout. */
1222 if (port->timeouts.ReadIntervalTimeout != MAXDWORD ||
1223 port->timeouts.ReadTotalTimeoutMultiplier != 0 ||
1224 port->timeouts.ReadTotalTimeoutConstant != 0) {
1225 port->timeouts.ReadIntervalTimeout = MAXDWORD;
1226 port->timeouts.ReadTotalTimeoutMultiplier = 0;
1227 port->timeouts.ReadTotalTimeoutConstant = 0;
1228 if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
1229 RETURN_FAIL("SetCommTimeouts() failed");
1230 }
1231
1232 /* Do read. */
1233 if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl) == 0)
1234 if (GetLastError() != ERROR_IO_PENDING)
1235 RETURN_FAIL("ReadFile() failed");
1236
1237 /* Get number of bytes read. */
1238 if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, FALSE) == 0)
1239 RETURN_FAIL("GetOverlappedResult() failed");
1240
1241 TRY(restart_wait_if_needed(port, bytes_read));
1242
1243 RETURN_INT(bytes_read);
1244#else
1245 ssize_t bytes_read;
1246
1247 /* Returns the number of bytes read, or -1 upon failure. */
1248 if ((bytes_read = read(port->fd, buf, count)) < 0) {
1249 if (errno == EAGAIN)
1250 /* No bytes available. */
1251 bytes_read = 0;
1252 else
1253 /* This is an actual failure. */
1254 RETURN_FAIL("read() failed");
1255 }
1256 RETURN_INT(bytes_read);
1257#endif
1258}
1259
1260SP_API enum sp_return sp_input_waiting(struct sp_port *port)
1261{
1262 TRACE("%p", port);
1263
1264 CHECK_OPEN_PORT();
1265
1266 DEBUG_FMT("Checking input bytes waiting on port %s", port->name);
1267
1268#ifdef _WIN32
1269 DWORD errors;
1270 COMSTAT comstat;
1271
1272 if (ClearCommError(port->hdl, &errors, &comstat) == 0)
1273 RETURN_FAIL("ClearCommError() failed");
1274 RETURN_INT(comstat.cbInQue);
1275#else
1276 int bytes_waiting;
1277 if (ioctl(port->fd, TIOCINQ, &bytes_waiting) < 0)
1278 RETURN_FAIL("TIOCINQ ioctl failed");
1279 RETURN_INT(bytes_waiting);
1280#endif
1281}
1282
1283SP_API enum sp_return sp_output_waiting(struct sp_port *port)
1284{
1285 TRACE("%p", port);
1286
1287 CHECK_OPEN_PORT();
1288
1289 DEBUG_FMT("Checking output bytes waiting on port %s", port->name);
1290
1291#ifdef _WIN32
1292 DWORD errors;
1293 COMSTAT comstat;
1294
1295 if (ClearCommError(port->hdl, &errors, &comstat) == 0)
1296 RETURN_FAIL("ClearCommError() failed");
1297 RETURN_INT(comstat.cbOutQue);
1298#else
1299 int bytes_waiting;
1300 if (ioctl(port->fd, TIOCOUTQ, &bytes_waiting) < 0)
1301 RETURN_FAIL("TIOCOUTQ ioctl failed");
1302 RETURN_INT(bytes_waiting);
1303#endif
1304}
1305
1306SP_API enum sp_return sp_new_event_set(struct sp_event_set **result_ptr)
1307{
1308 struct sp_event_set *result;
1309
1310 TRACE("%p", result_ptr);
1311
1312 if (!result_ptr)
1313 RETURN_ERROR(SP_ERR_ARG, "Null result");
1314
1315 *result_ptr = NULL;
1316
1317 if (!(result = malloc(sizeof(struct sp_event_set))))
1318 RETURN_ERROR(SP_ERR_MEM, "sp_event_set malloc() failed");
1319
1320 memset(result, 0, sizeof(struct sp_event_set));
1321
1322 *result_ptr = result;
1323
1324 RETURN_OK();
1325}
1326
1327static enum sp_return add_handle(struct sp_event_set *event_set,
1328 event_handle handle, enum sp_event mask)
1329{
1330 void *new_handles;
1331 enum sp_event *new_masks;
1332
1333 TRACE("%p, %d, %d", event_set, handle, mask);
1334
1335 if (!(new_handles = realloc(event_set->handles,
1336 sizeof(event_handle) * (event_set->count + 1))))
1337 RETURN_ERROR(SP_ERR_MEM, "Handle array realloc() failed");
1338
1339 event_set->handles = new_handles;
1340
1341 if (!(new_masks = realloc(event_set->masks,
1342 sizeof(enum sp_event) * (event_set->count + 1))))
1343 RETURN_ERROR(SP_ERR_MEM, "Mask array realloc() failed");
1344
1345 event_set->masks = new_masks;
1346
1347 ((event_handle *) event_set->handles)[event_set->count] = handle;
1348 event_set->masks[event_set->count] = mask;
1349
1350 event_set->count++;
1351
1352 RETURN_OK();
1353}
1354
1355SP_API enum sp_return sp_add_port_events(struct sp_event_set *event_set,
1356 const struct sp_port *port, enum sp_event mask)
1357{
1358 TRACE("%p, %p, %d", event_set, port, mask);
1359
1360 if (!event_set)
1361 RETURN_ERROR(SP_ERR_ARG, "Null event set");
1362
1363 if (!port)
1364 RETURN_ERROR(SP_ERR_ARG, "Null port");
1365
1366 if (mask > (SP_EVENT_RX_READY | SP_EVENT_TX_READY | SP_EVENT_ERROR))
1367 RETURN_ERROR(SP_ERR_ARG, "Invalid event mask");
1368
1369 if (!mask)
1370 RETURN_OK();
1371
1372#ifdef _WIN32
1373 enum sp_event handle_mask;
1374 if ((handle_mask = mask & SP_EVENT_TX_READY))
1375 TRY(add_handle(event_set, port->write_ovl.hEvent, handle_mask));
1376 if ((handle_mask = mask & (SP_EVENT_RX_READY | SP_EVENT_ERROR)))
1377 TRY(add_handle(event_set, port->wait_ovl.hEvent, handle_mask));
1378#else
1379 TRY(add_handle(event_set, port->fd, mask));
1380#endif
1381
1382 RETURN_OK();
1383}
1384
1385SP_API void sp_free_event_set(struct sp_event_set *event_set)
1386{
1387 TRACE("%p", event_set);
1388
1389 if (!event_set) {
1390 DEBUG("Null event set");
1391 RETURN();
1392 }
1393
1394 DEBUG("Freeing event set");
1395
1396 if (event_set->handles)
1397 free(event_set->handles);
1398 if (event_set->masks)
1399 free(event_set->masks);
1400
1401 free(event_set);
1402
1403 RETURN();
1404}
1405
1406SP_API enum sp_return sp_wait(struct sp_event_set *event_set,
1407 unsigned int timeout_ms)
1408{
1409 TRACE("%p, %d", event_set, timeout_ms);
1410
1411 if (!event_set)
1412 RETURN_ERROR(SP_ERR_ARG, "Null event set");
1413
1414#ifdef _WIN32
1415 if (WaitForMultipleObjects(event_set->count, event_set->handles, FALSE,
1416 timeout_ms ? timeout_ms : INFINITE) == WAIT_FAILED)
1417 RETURN_FAIL("WaitForMultipleObjects() failed");
1418
1419 RETURN_OK();
1420#else
1421 struct timeout timeout;
1422 int result;
1423 struct pollfd *pollfds;
1424 unsigned int i;
1425
1426 if (!(pollfds = malloc(sizeof(struct pollfd) * event_set->count)))
1427 RETURN_ERROR(SP_ERR_MEM, "pollfds malloc() failed");
1428
1429 for (i = 0; i < event_set->count; i++) {
1430 pollfds[i].fd = ((int *)event_set->handles)[i];
1431 pollfds[i].events = 0;
1432 pollfds[i].revents = 0;
1433 if (event_set->masks[i] & SP_EVENT_RX_READY)
1434 pollfds[i].events |= POLLIN;
1435 if (event_set->masks[i] & SP_EVENT_TX_READY)
1436 pollfds[i].events |= POLLOUT;
1437 if (event_set->masks[i] & SP_EVENT_ERROR)
1438 pollfds[i].events |= POLLERR;
1439 }
1440
1441 timeout_start(&timeout, timeout_ms);
1442 timeout_limit(&timeout, INT_MAX);
1443
1444 /* Loop until an event occurs. */
1445 while (1) {
1446
1447 if (timeout_check(&timeout)) {
1448 DEBUG("Wait timed out");
1449 break;
1450 }
1451
1452 result = poll(pollfds, event_set->count, timeout_remaining_ms(&timeout) || -1);
1453
1454 timeout_update(&timeout);
1455
1456 if (result < 0) {
1457 if (errno == EINTR) {
1458 DEBUG("poll() call was interrupted, repeating");
1459 continue;
1460 } else {
1461 free(pollfds);
1462 RETURN_FAIL("poll() failed");
1463 }
1464 } else if (result == 0) {
1465 DEBUG("poll() timed out");
1466 if (!timeout.overflow)
1467 break;
1468 } else {
1469 DEBUG("poll() completed");
1470 break;
1471 }
1472 }
1473
1474 free(pollfds);
1475 RETURN_OK();
1476#endif
1477}
1478
1479#ifdef USE_TERMIOS_SPEED
1480static enum sp_return get_baudrate(int fd, int *baudrate)
1481{
1482 void *data;
1483
1484 TRACE("%d, %p", fd, baudrate);
1485
1486 DEBUG("Getting baud rate");
1487
1488 if (!(data = malloc(get_termios_size())))
1489 RETURN_ERROR(SP_ERR_MEM, "termios malloc failed");
1490
1491 if (ioctl(fd, get_termios_get_ioctl(), data) < 0) {
1492 free(data);
1493 RETURN_FAIL("Getting termios failed");
1494 }
1495
1496 *baudrate = get_termios_speed(data);
1497
1498 free(data);
1499
1500 RETURN_OK();
1501}
1502
1503static enum sp_return set_baudrate(int fd, int baudrate)
1504{
1505 void *data;
1506
1507 TRACE("%d, %d", fd, baudrate);
1508
1509 DEBUG("Getting baud rate");
1510
1511 if (!(data = malloc(get_termios_size())))
1512 RETURN_ERROR(SP_ERR_MEM, "termios malloc failed");
1513
1514 if (ioctl(fd, get_termios_get_ioctl(), data) < 0) {
1515 free(data);
1516 RETURN_FAIL("Getting termios failed");
1517 }
1518
1519 DEBUG("Setting baud rate");
1520
1521 set_termios_speed(data, baudrate);
1522
1523 if (ioctl(fd, get_termios_set_ioctl(), data) < 0) {
1524 free(data);
1525 RETURN_FAIL("Setting termios failed");
1526 }
1527
1528 free(data);
1529
1530 RETURN_OK();
1531}
1532#endif /* USE_TERMIOS_SPEED */
1533
1534#ifdef USE_TERMIOX
1535static enum sp_return get_flow(int fd, struct port_data *data)
1536{
1537 void *termx;
1538
1539 TRACE("%d, %p", fd, data);
1540
1541 DEBUG("Getting advanced flow control");
1542
1543 if (!(termx = malloc(get_termiox_size())))
1544 RETURN_ERROR(SP_ERR_MEM, "termiox malloc failed");
1545
1546 if (ioctl(fd, TCGETX, termx) < 0) {
1547 free(termx);
1548 RETURN_FAIL("Getting termiox failed");
1549 }
1550
1551 get_termiox_flow(termx, &data->rts_flow, &data->cts_flow,
1552 &data->dtr_flow, &data->dsr_flow);
1553
1554 free(termx);
1555
1556 RETURN_OK();
1557}
1558
1559static enum sp_return set_flow(int fd, struct port_data *data)
1560{
1561 void *termx;
1562
1563 TRACE("%d, %p", fd, data);
1564
1565 DEBUG("Getting advanced flow control");
1566
1567 if (!(termx = malloc(get_termiox_size())))
1568 RETURN_ERROR(SP_ERR_MEM, "termiox malloc failed");
1569
1570 if (ioctl(fd, TCGETX, termx) < 0) {
1571 free(termx);
1572 RETURN_FAIL("Getting termiox failed");
1573 }
1574
1575 DEBUG("Setting advanced flow control");
1576
1577 set_termiox_flow(termx, data->rts_flow, data->cts_flow,
1578 data->dtr_flow, data->dsr_flow);
1579
1580 if (ioctl(fd, TCSETX, termx) < 0) {
1581 free(termx);
1582 RETURN_FAIL("Setting termiox failed");
1583 }
1584
1585 free(termx);
1586
1587 RETURN_OK();
1588}
1589#endif /* USE_TERMIOX */
1590
1591static enum sp_return get_config(struct sp_port *port, struct port_data *data,
1592 struct sp_port_config *config)
1593{
1594 unsigned int i;
1595
1596 TRACE("%p, %p, %p", port, data, config);
1597
1598 DEBUG_FMT("Getting configuration for port %s", port->name);
1599
1600#ifdef _WIN32
1601 if (!GetCommState(port->hdl, &data->dcb))
1602 RETURN_FAIL("GetCommState() failed");
1603
1604 for (i = 0; i < NUM_STD_BAUDRATES; i++) {
1605 if (data->dcb.BaudRate == std_baudrates[i].index) {
1606 config->baudrate = std_baudrates[i].value;
1607 break;
1608 }
1609 }
1610
1611 if (i == NUM_STD_BAUDRATES)
1612 /* BaudRate field can be either an index or a custom baud rate. */
1613 config->baudrate = data->dcb.BaudRate;
1614
1615 config->bits = data->dcb.ByteSize;
1616
1617 if (data->dcb.fParity)
1618 switch (data->dcb.Parity) {
1619 case NOPARITY:
1620 config->parity = SP_PARITY_NONE;
1621 break;
1622 case ODDPARITY:
1623 config->parity = SP_PARITY_ODD;
1624 break;
1625 case EVENPARITY:
1626 config->parity = SP_PARITY_EVEN;
1627 break;
1628 case MARKPARITY:
1629 config->parity = SP_PARITY_MARK;
1630 break;
1631 case SPACEPARITY:
1632 config->parity = SP_PARITY_SPACE;
1633 break;
1634 default:
1635 config->parity = -1;
1636 }
1637 else
1638 config->parity = SP_PARITY_NONE;
1639
1640 switch (data->dcb.StopBits) {
1641 case ONESTOPBIT:
1642 config->stopbits = 1;
1643 break;
1644 case TWOSTOPBITS:
1645 config->stopbits = 2;
1646 break;
1647 default:
1648 config->stopbits = -1;
1649 }
1650
1651 switch (data->dcb.fRtsControl) {
1652 case RTS_CONTROL_DISABLE:
1653 config->rts = SP_RTS_OFF;
1654 break;
1655 case RTS_CONTROL_ENABLE:
1656 config->rts = SP_RTS_ON;
1657 break;
1658 case RTS_CONTROL_HANDSHAKE:
1659 config->rts = SP_RTS_FLOW_CONTROL;
1660 break;
1661 default:
1662 config->rts = -1;
1663 }
1664
1665 config->cts = data->dcb.fOutxCtsFlow ? SP_CTS_FLOW_CONTROL : SP_CTS_IGNORE;
1666
1667 switch (data->dcb.fDtrControl) {
1668 case DTR_CONTROL_DISABLE:
1669 config->dtr = SP_DTR_OFF;
1670 break;
1671 case DTR_CONTROL_ENABLE:
1672 config->dtr = SP_DTR_ON;
1673 break;
1674 case DTR_CONTROL_HANDSHAKE:
1675 config->dtr = SP_DTR_FLOW_CONTROL;
1676 break;
1677 default:
1678 config->dtr = -1;
1679 }
1680
1681 config->dsr = data->dcb.fOutxDsrFlow ? SP_DSR_FLOW_CONTROL : SP_DSR_IGNORE;
1682
1683 if (data->dcb.fInX) {
1684 if (data->dcb.fOutX)
1685 config->xon_xoff = SP_XONXOFF_INOUT;
1686 else
1687 config->xon_xoff = SP_XONXOFF_IN;
1688 } else {
1689 if (data->dcb.fOutX)
1690 config->xon_xoff = SP_XONXOFF_OUT;
1691 else
1692 config->xon_xoff = SP_XONXOFF_DISABLED;
1693 }
1694
1695#else // !_WIN32
1696
1697 if (tcgetattr(port->fd, &data->term) < 0)
1698 RETURN_FAIL("tcgetattr() failed");
1699
1700 if (ioctl(port->fd, TIOCMGET, &data->controlbits) < 0)
1701 RETURN_FAIL("TIOCMGET ioctl failed");
1702
1703#ifdef USE_TERMIOX
1704 int ret = get_flow(port->fd, data);
1705
1706 if (ret == SP_ERR_FAIL && errno == EINVAL)
1707 data->termiox_supported = 0;
1708 else if (ret < 0)
1709 RETURN_CODEVAL(ret);
1710 else
1711 data->termiox_supported = 1;
1712#else
1713 data->termiox_supported = 0;
1714#endif
1715
1716 for (i = 0; i < NUM_STD_BAUDRATES; i++) {
1717 if (cfgetispeed(&data->term) == std_baudrates[i].index) {
1718 config->baudrate = std_baudrates[i].value;
1719 break;
1720 }
1721 }
1722
1723 if (i == NUM_STD_BAUDRATES) {
1724#ifdef __APPLE__
1725 config->baudrate = (int)data->term.c_ispeed;
1726#elif defined(USE_TERMIOS_SPEED)
1727 TRY(get_baudrate(port->fd, &config->baudrate));
1728#else
1729 config->baudrate = -1;
1730#endif
1731 }
1732
1733 switch (data->term.c_cflag & CSIZE) {
1734 case CS8:
1735 config->bits = 8;
1736 break;
1737 case CS7:
1738 config->bits = 7;
1739 break;
1740 case CS6:
1741 config->bits = 6;
1742 break;
1743 case CS5:
1744 config->bits = 5;
1745 break;
1746 default:
1747 config->bits = -1;
1748 }
1749
1750 if (!(data->term.c_cflag & PARENB) && (data->term.c_iflag & IGNPAR))
1751 config->parity = SP_PARITY_NONE;
1752 else if (!(data->term.c_cflag & PARENB) || (data->term.c_iflag & IGNPAR))
1753 config->parity = -1;
1754#ifdef CMSPAR
1755 else if (data->term.c_cflag & CMSPAR)
1756 config->parity = (data->term.c_cflag & PARODD) ? SP_PARITY_MARK : SP_PARITY_SPACE;
1757#endif
1758 else
1759 config->parity = (data->term.c_cflag & PARODD) ? SP_PARITY_ODD : SP_PARITY_EVEN;
1760
1761 config->stopbits = (data->term.c_cflag & CSTOPB) ? 2 : 1;
1762
1763 if (data->term.c_cflag & CRTSCTS) {
1764 config->rts = SP_RTS_FLOW_CONTROL;
1765 config->cts = SP_CTS_FLOW_CONTROL;
1766 } else {
1767 if (data->termiox_supported && data->rts_flow)
1768 config->rts = SP_RTS_FLOW_CONTROL;
1769 else
1770 config->rts = (data->controlbits & TIOCM_RTS) ? SP_RTS_ON : SP_RTS_OFF;
1771
1772 config->cts = (data->termiox_supported && data->cts_flow) ?
1773 SP_CTS_FLOW_CONTROL : SP_CTS_IGNORE;
1774 }
1775
1776 if (data->termiox_supported && data->dtr_flow)
1777 config->dtr = SP_DTR_FLOW_CONTROL;
1778 else
1779 config->dtr = (data->controlbits & TIOCM_DTR) ? SP_DTR_ON : SP_DTR_OFF;
1780
1781 config->dsr = (data->termiox_supported && data->dsr_flow) ?
1782 SP_DSR_FLOW_CONTROL : SP_DSR_IGNORE;
1783
1784 if (data->term.c_iflag & IXOFF) {
1785 if (data->term.c_iflag & IXON)
1786 config->xon_xoff = SP_XONXOFF_INOUT;
1787 else
1788 config->xon_xoff = SP_XONXOFF_IN;
1789 } else {
1790 if (data->term.c_iflag & IXON)
1791 config->xon_xoff = SP_XONXOFF_OUT;
1792 else
1793 config->xon_xoff = SP_XONXOFF_DISABLED;
1794 }
1795#endif
1796
1797 RETURN_OK();
1798}
1799
1800static enum sp_return set_config(struct sp_port *port, struct port_data *data,
1801 const struct sp_port_config *config)
1802{
1803 unsigned int i;
1804#ifdef __APPLE__
1805 BAUD_TYPE baud_nonstd;
1806
1807 baud_nonstd = B0;
1808#endif
1809#ifdef USE_TERMIOS_SPEED
1810 int baud_nonstd = 0;
1811#endif
1812
1813 TRACE("%p, %p, %p", port, data, config);
1814
1815 DEBUG_FMT("Setting configuration for port %s", port->name);
1816
1817#ifdef _WIN32
1818
1819 TRY(await_write_completion(port));
1820
1821 if (config->baudrate >= 0) {
1822 for (i = 0; i < NUM_STD_BAUDRATES; i++) {
1823 if (config->baudrate == std_baudrates[i].value) {
1824 data->dcb.BaudRate = std_baudrates[i].index;
1825 break;
1826 }
1827 }
1828
1829 if (i == NUM_STD_BAUDRATES)
1830 data->dcb.BaudRate = config->baudrate;
1831
1832 /* Allocate write buffer for 50ms of data at baud rate. */
1833 port->write_buf_size = max(config->baudrate / (8 * 20), 1);
1834 port->write_buf = realloc(port->write_buf,
1835 port->write_buf_size);
1836
1837 if (!port->write_buf)
1838 RETURN_ERROR(SP_ERR_MEM, "Allocating write buffer failed");
1839 }
1840
1841 if (config->bits >= 0)
1842 data->dcb.ByteSize = config->bits;
1843
1844 if (config->parity >= 0) {
1845 switch (config->parity) {
1846 case SP_PARITY_NONE:
1847 data->dcb.Parity = NOPARITY;
1848 break;
1849 case SP_PARITY_ODD:
1850 data->dcb.Parity = ODDPARITY;
1851 break;
1852 case SP_PARITY_EVEN:
1853 data->dcb.Parity = EVENPARITY;
1854 break;
1855 case SP_PARITY_MARK:
1856 data->dcb.Parity = MARKPARITY;
1857 break;
1858 case SP_PARITY_SPACE:
1859 data->dcb.Parity = SPACEPARITY;
1860 break;
1861 default:
1862 RETURN_ERROR(SP_ERR_ARG, "Invalid parity setting");
1863 }
1864 }
1865
1866 if (config->stopbits >= 0) {
1867 switch (config->stopbits) {
1868 /* Note: There's also ONE5STOPBITS == 1.5 (unneeded so far). */
1869 case 1:
1870 data->dcb.StopBits = ONESTOPBIT;
1871 break;
1872 case 2:
1873 data->dcb.StopBits = TWOSTOPBITS;
1874 break;
1875 default:
1876 RETURN_ERROR(SP_ERR_ARG, "Invalid stop bit setting");
1877 }
1878 }
1879
1880 if (config->rts >= 0) {
1881 switch (config->rts) {
1882 case SP_RTS_OFF:
1883 data->dcb.fRtsControl = RTS_CONTROL_DISABLE;
1884 break;
1885 case SP_RTS_ON:
1886 data->dcb.fRtsControl = RTS_CONTROL_ENABLE;
1887 break;
1888 case SP_RTS_FLOW_CONTROL:
1889 data->dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
1890 break;
1891 default:
1892 RETURN_ERROR(SP_ERR_ARG, "Invalid RTS setting");
1893 }
1894 }
1895
1896 if (config->cts >= 0) {
1897 switch (config->cts) {
1898 case SP_CTS_IGNORE:
1899 data->dcb.fOutxCtsFlow = FALSE;
1900 break;
1901 case SP_CTS_FLOW_CONTROL:
1902 data->dcb.fOutxCtsFlow = TRUE;
1903 break;
1904 default:
1905 RETURN_ERROR(SP_ERR_ARG, "Invalid CTS setting");
1906 }
1907 }
1908
1909 if (config->dtr >= 0) {
1910 switch (config->dtr) {
1911 case SP_DTR_OFF:
1912 data->dcb.fDtrControl = DTR_CONTROL_DISABLE;
1913 break;
1914 case SP_DTR_ON:
1915 data->dcb.fDtrControl = DTR_CONTROL_ENABLE;
1916 break;
1917 case SP_DTR_FLOW_CONTROL:
1918 data->dcb.fDtrControl = DTR_CONTROL_HANDSHAKE;
1919 break;
1920 default:
1921 RETURN_ERROR(SP_ERR_ARG, "Invalid DTR setting");
1922 }
1923 }
1924
1925 if (config->dsr >= 0) {
1926 switch (config->dsr) {
1927 case SP_DSR_IGNORE:
1928 data->dcb.fOutxDsrFlow = FALSE;
1929 break;
1930 case SP_DSR_FLOW_CONTROL:
1931 data->dcb.fOutxDsrFlow = TRUE;
1932 break;
1933 default:
1934 RETURN_ERROR(SP_ERR_ARG, "Invalid DSR setting");
1935 }
1936 }
1937
1938 if (config->xon_xoff >= 0) {
1939 switch (config->xon_xoff) {
1940 case SP_XONXOFF_DISABLED:
1941 data->dcb.fInX = FALSE;
1942 data->dcb.fOutX = FALSE;
1943 break;
1944 case SP_XONXOFF_IN:
1945 data->dcb.fInX = TRUE;
1946 data->dcb.fOutX = FALSE;
1947 break;
1948 case SP_XONXOFF_OUT:
1949 data->dcb.fInX = FALSE;
1950 data->dcb.fOutX = TRUE;
1951 break;
1952 case SP_XONXOFF_INOUT:
1953 data->dcb.fInX = TRUE;
1954 data->dcb.fOutX = TRUE;
1955 break;
1956 default:
1957 RETURN_ERROR(SP_ERR_ARG, "Invalid XON/XOFF setting");
1958 }
1959 }
1960
1961 if (!SetCommState(port->hdl, &data->dcb))
1962 RETURN_FAIL("SetCommState() failed");
1963
1964#else /* !_WIN32 */
1965
1966 int controlbits;
1967
1968 if (config->baudrate >= 0) {
1969 for (i = 0; i < NUM_STD_BAUDRATES; i++) {
1970 if (config->baudrate == std_baudrates[i].value) {
1971 if (cfsetospeed(&data->term, std_baudrates[i].index) < 0)
1972 RETURN_FAIL("cfsetospeed() failed");
1973
1974 if (cfsetispeed(&data->term, std_baudrates[i].index) < 0)
1975 RETURN_FAIL("cfsetispeed() failed");
1976 break;
1977 }
1978 }
1979
1980 /* Non-standard baud rate */
1981 if (i == NUM_STD_BAUDRATES) {
1982#ifdef __APPLE__
1983 /* Set "dummy" baud rate. */
1984 if (cfsetspeed(&data->term, B9600) < 0)
1985 RETURN_FAIL("cfsetspeed() failed");
1986 baud_nonstd = config->baudrate;
1987#elif defined(USE_TERMIOS_SPEED)
1988 baud_nonstd = 1;
1989#else
1990 RETURN_ERROR(SP_ERR_SUPP, "Non-standard baudrate not supported");
1991#endif
1992 }
1993 }
1994
1995 if (config->bits >= 0) {
1996 data->term.c_cflag &= ~CSIZE;
1997 switch (config->bits) {
1998 case 8:
1999 data->term.c_cflag |= CS8;
2000 break;
2001 case 7:
2002 data->term.c_cflag |= CS7;
2003 break;
2004 case 6:
2005 data->term.c_cflag |= CS6;
2006 break;
2007 case 5:
2008 data->term.c_cflag |= CS5;
2009 break;
2010 default:
2011 RETURN_ERROR(SP_ERR_ARG, "Invalid data bits setting");
2012 }
2013 }
2014
2015 if (config->parity >= 0) {
2016 data->term.c_iflag &= ~IGNPAR;
2017 data->term.c_cflag &= ~(PARENB | PARODD);
2018#ifdef CMSPAR
2019 data->term.c_cflag &= ~CMSPAR;
2020#endif
2021 switch (config->parity) {
2022 case SP_PARITY_NONE:
2023 data->term.c_iflag |= IGNPAR;
2024 break;
2025 case SP_PARITY_EVEN:
2026 data->term.c_cflag |= PARENB;
2027 break;
2028 case SP_PARITY_ODD:
2029 data->term.c_cflag |= PARENB | PARODD;
2030 break;
2031#ifdef CMSPAR
2032 case SP_PARITY_MARK:
2033 data->term.c_cflag |= PARENB | PARODD;
2034 data->term.c_cflag |= CMSPAR;
2035 break;
2036 case SP_PARITY_SPACE:
2037 data->term.c_cflag |= PARENB;
2038 data->term.c_cflag |= CMSPAR;
2039 break;
2040#else
2041 case SP_PARITY_MARK:
2042 case SP_PARITY_SPACE:
2043 RETURN_ERROR(SP_ERR_SUPP, "Mark/space parity not supported");
2044#endif
2045 default:
2046 RETURN_ERROR(SP_ERR_ARG, "Invalid parity setting");
2047 }
2048 }
2049
2050 if (config->stopbits >= 0) {
2051 data->term.c_cflag &= ~CSTOPB;
2052 switch (config->stopbits) {
2053 case 1:
2054 data->term.c_cflag &= ~CSTOPB;
2055 break;
2056 case 2:
2057 data->term.c_cflag |= CSTOPB;
2058 break;
2059 default:
2060 RETURN_ERROR(SP_ERR_ARG, "Invalid stop bits setting");
2061 }
2062 }
2063
2064 if (config->rts >= 0 || config->cts >= 0) {
2065 if (data->termiox_supported) {
2066 data->rts_flow = data->cts_flow = 0;
2067 switch (config->rts) {
2068 case SP_RTS_OFF:
2069 case SP_RTS_ON:
2070 controlbits = TIOCM_RTS;
2071 if (ioctl(port->fd, config->rts == SP_RTS_ON ? TIOCMBIS : TIOCMBIC, &controlbits) < 0)
2072 RETURN_FAIL("Setting RTS signal level failed");
2073 break;
2074 case SP_RTS_FLOW_CONTROL:
2075 data->rts_flow = 1;
2076 break;
2077 default:
2078 break;
2079 }
2080 if (config->cts == SP_CTS_FLOW_CONTROL)
2081 data->cts_flow = 1;
2082
2083 if (data->rts_flow && data->cts_flow)
2084 data->term.c_iflag |= CRTSCTS;
2085 else
2086 data->term.c_iflag &= ~CRTSCTS;
2087 } else {
2088 /* Asymmetric use of RTS/CTS not supported. */
2089 if (data->term.c_iflag & CRTSCTS) {
2090 /* Flow control can only be disabled for both RTS & CTS together. */
2091 if (config->rts >= 0 && config->rts != SP_RTS_FLOW_CONTROL) {
2092 if (config->cts != SP_CTS_IGNORE)
2093 RETURN_ERROR(SP_ERR_SUPP, "RTS & CTS flow control must be disabled together");
2094 }
2095 if (config->cts >= 0 && config->cts != SP_CTS_FLOW_CONTROL) {
2096 if (config->rts <= 0 || config->rts == SP_RTS_FLOW_CONTROL)
2097 RETURN_ERROR(SP_ERR_SUPP, "RTS & CTS flow control must be disabled together");
2098 }
2099 } else {
2100 /* Flow control can only be enabled for both RTS & CTS together. */
2101 if (((config->rts == SP_RTS_FLOW_CONTROL) && (config->cts != SP_CTS_FLOW_CONTROL)) ||
2102 ((config->cts == SP_CTS_FLOW_CONTROL) && (config->rts != SP_RTS_FLOW_CONTROL)))
2103 RETURN_ERROR(SP_ERR_SUPP, "RTS & CTS flow control must be enabled together");
2104 }
2105
2106 if (config->rts >= 0) {
2107 if (config->rts == SP_RTS_FLOW_CONTROL) {
2108 data->term.c_iflag |= CRTSCTS;
2109 } else {
2110 controlbits = TIOCM_RTS;
2111 if (ioctl(port->fd, config->rts == SP_RTS_ON ? TIOCMBIS : TIOCMBIC,
2112 &controlbits) < 0)
2113 RETURN_FAIL("Setting RTS signal level failed");
2114 }
2115 }
2116 }
2117 }
2118
2119 if (config->dtr >= 0 || config->dsr >= 0) {
2120 if (data->termiox_supported) {
2121 data->dtr_flow = data->dsr_flow = 0;
2122 switch (config->dtr) {
2123 case SP_DTR_OFF:
2124 case SP_DTR_ON:
2125 controlbits = TIOCM_DTR;
2126 if (ioctl(port->fd, config->dtr == SP_DTR_ON ? TIOCMBIS : TIOCMBIC, &controlbits) < 0)
2127 RETURN_FAIL("Setting DTR signal level failed");
2128 break;
2129 case SP_DTR_FLOW_CONTROL:
2130 data->dtr_flow = 1;
2131 break;
2132 default:
2133 break;
2134 }
2135 if (config->dsr == SP_DSR_FLOW_CONTROL)
2136 data->dsr_flow = 1;
2137 } else {
2138 /* DTR/DSR flow control not supported. */
2139 if (config->dtr == SP_DTR_FLOW_CONTROL || config->dsr == SP_DSR_FLOW_CONTROL)
2140 RETURN_ERROR(SP_ERR_SUPP, "DTR/DSR flow control not supported");
2141
2142 if (config->dtr >= 0) {
2143 controlbits = TIOCM_DTR;
2144 if (ioctl(port->fd, config->dtr == SP_DTR_ON ? TIOCMBIS : TIOCMBIC,
2145 &controlbits) < 0)
2146 RETURN_FAIL("Setting DTR signal level failed");
2147 }
2148 }
2149 }
2150
2151 if (config->xon_xoff >= 0) {
2152 data->term.c_iflag &= ~(IXON | IXOFF | IXANY);
2153 switch (config->xon_xoff) {
2154 case SP_XONXOFF_DISABLED:
2155 break;
2156 case SP_XONXOFF_IN:
2157 data->term.c_iflag |= IXOFF;
2158 break;
2159 case SP_XONXOFF_OUT:
2160 data->term.c_iflag |= IXON | IXANY;
2161 break;
2162 case SP_XONXOFF_INOUT:
2163 data->term.c_iflag |= IXON | IXOFF | IXANY;
2164 break;
2165 default:
2166 RETURN_ERROR(SP_ERR_ARG, "Invalid XON/XOFF setting");
2167 }
2168 }
2169
2170 if (tcsetattr(port->fd, TCSANOW, &data->term) < 0)
2171 RETURN_FAIL("tcsetattr() failed");
2172
2173#ifdef __APPLE__
2174 if (baud_nonstd != B0) {
2175 if (ioctl(port->fd, IOSSIOSPEED, &baud_nonstd) == -1)
2176 RETURN_FAIL("IOSSIOSPEED ioctl failed");
2177 /*
2178 * Set baud rates in data->term to correct, but incompatible
2179 * with tcsetattr() value, same as delivered by tcgetattr().
2180 */
2181 if (cfsetspeed(&data->term, baud_nonstd) < 0)
2182 RETURN_FAIL("cfsetspeed() failed");
2183 }
2184#elif defined(__linux__)
2185#ifdef USE_TERMIOS_SPEED
2186 if (baud_nonstd)
2187 TRY(set_baudrate(port->fd, config->baudrate));
2188#endif
2189#ifdef USE_TERMIOX
2190 if (data->termiox_supported)
2191 TRY(set_flow(port->fd, data));
2192#endif
2193#endif
2194
2195#endif /* !_WIN32 */
2196
2197 RETURN_OK();
2198}
2199
2200SP_API enum sp_return sp_new_config(struct sp_port_config **config_ptr)
2201{
2202 struct sp_port_config *config;
2203
2204 TRACE("%p", config_ptr);
2205
2206 if (!config_ptr)
2207 RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
2208
2209 *config_ptr = NULL;
2210
2211 if (!(config = malloc(sizeof(struct sp_port_config))))
2212 RETURN_ERROR(SP_ERR_MEM, "Config malloc failed");
2213
2214 config->baudrate = -1;
2215 config->bits = -1;
2216 config->parity = -1;
2217 config->stopbits = -1;
2218 config->rts = -1;
2219 config->cts = -1;
2220 config->dtr = -1;
2221 config->dsr = -1;
2222
2223 *config_ptr = config;
2224
2225 RETURN_OK();
2226}
2227
2228SP_API void sp_free_config(struct sp_port_config *config)
2229{
2230 TRACE("%p", config);
2231
2232 if (!config)
2233 DEBUG("Null config");
2234 else
2235 free(config);
2236
2237 RETURN();
2238}
2239
2240SP_API enum sp_return sp_get_config(struct sp_port *port,
2241 struct sp_port_config *config)
2242{
2243 struct port_data data;
2244
2245 TRACE("%p, %p", port, config);
2246
2247 CHECK_OPEN_PORT();
2248
2249 if (!config)
2250 RETURN_ERROR(SP_ERR_ARG, "Null config");
2251
2252 TRY(get_config(port, &data, config));
2253
2254 RETURN_OK();
2255}
2256
2257SP_API enum sp_return sp_set_config(struct sp_port *port,
2258 const struct sp_port_config *config)
2259{
2260 struct port_data data;
2261 struct sp_port_config prev_config;
2262
2263 TRACE("%p, %p", port, config);
2264
2265 CHECK_OPEN_PORT();
2266
2267 if (!config)
2268 RETURN_ERROR(SP_ERR_ARG, "Null config");
2269
2270 TRY(get_config(port, &data, &prev_config));
2271 TRY(set_config(port, &data, config));
2272
2273 RETURN_OK();
2274}
2275
2276#define CREATE_ACCESSORS(x, type) \
2277SP_API enum sp_return sp_set_##x(struct sp_port *port, type x) { \
2278 struct port_data data; \
2279 struct sp_port_config config; \
2280 TRACE("%p, %d", port, x); \
2281 CHECK_OPEN_PORT(); \
2282 TRY(get_config(port, &data, &config)); \
2283 config.x = x; \
2284 TRY(set_config(port, &data, &config)); \
2285 RETURN_OK(); \
2286} \
2287SP_API enum sp_return sp_get_config_##x(const struct sp_port_config *config, \
2288 type *x) { \
2289 TRACE("%p, %p", config, x); \
2290 if (!x) \
2291 RETURN_ERROR(SP_ERR_ARG, "Null result pointer"); \
2292 if (!config) \
2293 RETURN_ERROR(SP_ERR_ARG, "Null config"); \
2294 *x = config->x; \
2295 RETURN_OK(); \
2296} \
2297SP_API enum sp_return sp_set_config_##x(struct sp_port_config *config, \
2298 type x) { \
2299 TRACE("%p, %d", config, x); \
2300 if (!config) \
2301 RETURN_ERROR(SP_ERR_ARG, "Null config"); \
2302 config->x = x; \
2303 RETURN_OK(); \
2304}
2305
2306CREATE_ACCESSORS(baudrate, int)
2307CREATE_ACCESSORS(bits, int)
2308CREATE_ACCESSORS(parity, enum sp_parity)
2309CREATE_ACCESSORS(stopbits, int)
2310CREATE_ACCESSORS(rts, enum sp_rts)
2311CREATE_ACCESSORS(cts, enum sp_cts)
2312CREATE_ACCESSORS(dtr, enum sp_dtr)
2313CREATE_ACCESSORS(dsr, enum sp_dsr)
2314CREATE_ACCESSORS(xon_xoff, enum sp_xonxoff)
2315
2316SP_API enum sp_return sp_set_config_flowcontrol(struct sp_port_config *config,
2317 enum sp_flowcontrol flowcontrol)
2318{
2319 if (!config)
2320 RETURN_ERROR(SP_ERR_ARG, "Null configuration");
2321
2322 if (flowcontrol > SP_FLOWCONTROL_DTRDSR)
2323 RETURN_ERROR(SP_ERR_ARG, "Invalid flow control setting");
2324
2325 if (flowcontrol == SP_FLOWCONTROL_XONXOFF)
2326 config->xon_xoff = SP_XONXOFF_INOUT;
2327 else
2328 config->xon_xoff = SP_XONXOFF_DISABLED;
2329
2330 if (flowcontrol == SP_FLOWCONTROL_RTSCTS) {
2331 config->rts = SP_RTS_FLOW_CONTROL;
2332 config->cts = SP_CTS_FLOW_CONTROL;
2333 } else {
2334 if (config->rts == SP_RTS_FLOW_CONTROL)
2335 config->rts = SP_RTS_ON;
2336 config->cts = SP_CTS_IGNORE;
2337 }
2338
2339 if (flowcontrol == SP_FLOWCONTROL_DTRDSR) {
2340 config->dtr = SP_DTR_FLOW_CONTROL;
2341 config->dsr = SP_DSR_FLOW_CONTROL;
2342 } else {
2343 if (config->dtr == SP_DTR_FLOW_CONTROL)
2344 config->dtr = SP_DTR_ON;
2345 config->dsr = SP_DSR_IGNORE;
2346 }
2347
2348 RETURN_OK();
2349}
2350
2351SP_API enum sp_return sp_set_flowcontrol(struct sp_port *port,
2352 enum sp_flowcontrol flowcontrol)
2353{
2354 struct port_data data;
2355 struct sp_port_config config;
2356
2357 TRACE("%p, %d", port, flowcontrol);
2358
2359 CHECK_OPEN_PORT();
2360
2361 TRY(get_config(port, &data, &config));
2362
2363 TRY(sp_set_config_flowcontrol(&config, flowcontrol));
2364
2365 TRY(set_config(port, &data, &config));
2366
2367 RETURN_OK();
2368}
2369
2370SP_API enum sp_return sp_get_signals(struct sp_port *port,
2371 enum sp_signal *signals)
2372{
2373 TRACE("%p, %p", port, signals);
2374
2375 CHECK_OPEN_PORT();
2376
2377 if (!signals)
2378 RETURN_ERROR(SP_ERR_ARG, "Null result pointer");
2379
2380 DEBUG_FMT("Getting control signals for port %s", port->name);
2381
2382 *signals = 0;
2383#ifdef _WIN32
2384 DWORD bits;
2385 if (GetCommModemStatus(port->hdl, &bits) == 0)
2386 RETURN_FAIL("GetCommModemStatus() failed");
2387 if (bits & MS_CTS_ON)
2388 *signals |= SP_SIG_CTS;
2389 if (bits & MS_DSR_ON)
2390 *signals |= SP_SIG_DSR;
2391 if (bits & MS_RLSD_ON)
2392 *signals |= SP_SIG_DCD;
2393 if (bits & MS_RING_ON)
2394 *signals |= SP_SIG_RI;
2395#else
2396 int bits;
2397 if (ioctl(port->fd, TIOCMGET, &bits) < 0)
2398 RETURN_FAIL("TIOCMGET ioctl failed");
2399 if (bits & TIOCM_CTS)
2400 *signals |= SP_SIG_CTS;
2401 if (bits & TIOCM_DSR)
2402 *signals |= SP_SIG_DSR;
2403 if (bits & TIOCM_CAR)
2404 *signals |= SP_SIG_DCD;
2405 if (bits & TIOCM_RNG)
2406 *signals |= SP_SIG_RI;
2407#endif
2408 RETURN_OK();
2409}
2410
2411SP_API enum sp_return sp_start_break(struct sp_port *port)
2412{
2413 TRACE("%p", port);
2414
2415 CHECK_OPEN_PORT();
2416#ifdef _WIN32
2417 if (SetCommBreak(port->hdl) == 0)
2418 RETURN_FAIL("SetCommBreak() failed");
2419#else
2420 if (ioctl(port->fd, TIOCSBRK, 1) < 0)
2421 RETURN_FAIL("TIOCSBRK ioctl failed");
2422#endif
2423
2424 RETURN_OK();
2425}
2426
2427SP_API enum sp_return sp_end_break(struct sp_port *port)
2428{
2429 TRACE("%p", port);
2430
2431 CHECK_OPEN_PORT();
2432#ifdef _WIN32
2433 if (ClearCommBreak(port->hdl) == 0)
2434 RETURN_FAIL("ClearCommBreak() failed");
2435#else
2436 if (ioctl(port->fd, TIOCCBRK, 1) < 0)
2437 RETURN_FAIL("TIOCCBRK ioctl failed");
2438#endif
2439
2440 RETURN_OK();
2441}
2442
2443SP_API int sp_last_error_code(void)
2444{
2445 TRACE_VOID();
2446#ifdef _WIN32
2447 RETURN_INT(GetLastError());
2448#else
2449 RETURN_INT(errno);
2450#endif
2451}
2452
2453SP_API char *sp_last_error_message(void)
2454{
2455 TRACE_VOID();
2456
2457#ifdef _WIN32
2458 TCHAR *message;
2459 DWORD error = GetLastError();
2460
2461 DWORD length = FormatMessage(
2462 FORMAT_MESSAGE_ALLOCATE_BUFFER |
2463 FORMAT_MESSAGE_FROM_SYSTEM |
2464 FORMAT_MESSAGE_IGNORE_INSERTS,
2465 NULL,
2466 error,
2467 MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
2468 (LPTSTR) &message,
2469 0, NULL );
2470
2471 if (length >= 2 && message[length - 2] == '\r')
2472 message[length - 2] = '\0';
2473
2474 RETURN_STRING(message);
2475#else
2476 RETURN_STRING(strerror(errno));
2477#endif
2478}
2479
2480SP_API void sp_free_error_message(char *message)
2481{
2482 TRACE("%s", message);
2483
2484#ifdef _WIN32
2485 LocalFree(message);
2486#else
2487 (void)message;
2488#endif
2489
2490 RETURN();
2491}
2492
2493SP_API void sp_set_debug_handler(void (*handler)(const char *format, ...))
2494{
2495 TRACE("%p", handler);
2496
2497 sp_debug_handler = handler;
2498
2499 RETURN();
2500}
2501
2502SP_API void sp_default_debug_handler(const char *format, ...)
2503{
2504 va_list args;
2505 va_start(args, format);
2506 if (getenv("LIBSERIALPORT_DEBUG")) {
2507 fputs("sp: ", stderr);
2508 vfprintf(stderr, format, args);
2509 }
2510 va_end(args);
2511}
2512
2513SP_API int sp_get_major_package_version(void)
2514{
2515 return SP_PACKAGE_VERSION_MAJOR;
2516}
2517
2518SP_API int sp_get_minor_package_version(void)
2519{
2520 return SP_PACKAGE_VERSION_MINOR;
2521}
2522
2523SP_API int sp_get_micro_package_version(void)
2524{
2525 return SP_PACKAGE_VERSION_MICRO;
2526}
2527
2528SP_API const char *sp_get_package_version_string(void)
2529{
2530 return SP_PACKAGE_VERSION_STRING;
2531}
2532
2533SP_API int sp_get_current_lib_version(void)
2534{
2535 return SP_LIB_VERSION_CURRENT;
2536}
2537
2538SP_API int sp_get_revision_lib_version(void)
2539{
2540 return SP_LIB_VERSION_REVISION;
2541}
2542
2543SP_API int sp_get_age_lib_version(void)
2544{
2545 return SP_LIB_VERSION_AGE;
2546}
2547
2548SP_API const char *sp_get_lib_version_string(void)
2549{
2550 return SP_LIB_VERSION_STRING;
2551}
2552
2553/** @} */
Serial port access library