X-Git-Url: http://sigrok.org/gitweb/?a=blobdiff_plain;f=serialport.c;h=07a0aaa54b915fac58053e83c7541c55de925c89;hb=573feabc63340ef853108762682dce8aa4644cb5;hp=da292ac650ffff5e1099733fe58271cf16b60248;hpb=e5c2630eeed1825889dfe7cf0aaeb734b047ea74;p=libserialport.git diff --git a/serialport.c b/serialport.c index da292ac..07a0aaa 100644 --- a/serialport.c +++ b/serialport.c @@ -2,8 +2,8 @@ * This file is part of the libserialport project. * * Copyright (C) 2010-2012 Bert Vermeulen - * Copyright (C) 2010-2012 Uwe Hermann - * Copyright (C) 2013 Martin Ling + * Copyright (C) 2010-2015 Uwe Hermann + * Copyright (C) 2013-2015 Martin Ling * Copyright (C) 2013 Matthias Heidbrink * Copyright (C) 2014 Aurelien Jacobs * @@ -21,6 +21,7 @@ * along with this program. If not, see . */ +#include #include "libserialport.h" #include "libserialport_internal.h" @@ -48,12 +49,19 @@ static const struct std_baudrate std_baudrates[] = { void (*sp_debug_handler)(const char *format, ...) = sp_default_debug_handler; +static void get_time(struct timeval *time); + static enum sp_return get_config(struct sp_port *port, struct port_data *data, struct sp_port_config *config); static enum sp_return set_config(struct sp_port *port, struct port_data *data, const struct sp_port_config *config); +static void get_time(struct timeval *time) +{ + gettimeofday(time, NULL); +} + SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port **port_ptr) { struct sp_port *port; @@ -74,6 +82,20 @@ SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port * DEBUG_FMT("Building structure for port %s", portname); +#if !defined(_WIN32) && defined(HAVE_REALPATH) + /* + * get_port_details() below tries to be too smart and figure out + * some transport properties from the port name which breaks with + * symlinks. Therefore we canonicalize the portname first. + */ + char pathbuf[PATH_MAX + 1]; + char *res = realpath(portname, pathbuf); + if (!res) + RETURN_ERROR(SP_ERR_ARG, "Could not retrieve realpath behind port name"); + + portname = pathbuf; +#endif + if (!(port = malloc(sizeof(struct sp_port)))) RETURN_ERROR(SP_ERR_MEM, "Port structure malloc failed"); @@ -89,6 +111,8 @@ SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port * #ifdef _WIN32 port->usb_path = NULL; port->hdl = INVALID_HANDLE_VALUE; + port->write_buf = NULL; + port->write_buf_size = 0; #else port->fd = -1; #endif @@ -295,6 +319,8 @@ SP_API void sp_free_port(struct sp_port *port) #ifdef _WIN32 if (port->usb_path) free(port->usb_path); + if (port->write_buf) + free(port->write_buf); #endif free(port); @@ -308,7 +334,8 @@ SP_PRIV struct sp_port **list_append(struct sp_port **list, void *tmp; unsigned int count; - for (count = 0; list[count]; count++); + for (count = 0; list[count]; count++) + ; if (!(tmp = realloc(list, sizeof(struct sp_port *) * (count + 2)))) goto fail; list = tmp; @@ -388,12 +415,12 @@ SP_API void sp_free_port_list(struct sp_port **list) #ifdef _WIN32 #define CHECK_PORT_HANDLE() do { \ if (port->hdl == INVALID_HANDLE_VALUE) \ - RETURN_ERROR(SP_ERR_ARG, "Invalid port handle"); \ + RETURN_ERROR(SP_ERR_ARG, "Port not open"); \ } while (0) #else #define CHECK_PORT_HANDLE() do { \ if (port->fd < 0) \ - RETURN_ERROR(SP_ERR_ARG, "Invalid port fd"); \ + RETURN_ERROR(SP_ERR_ARG, "Port not open"); \ } while (0) #endif #define CHECK_OPEN_PORT() do { \ @@ -627,6 +654,10 @@ SP_API enum sp_return sp_close(struct sp_port *port) CLOSE_OVERLAPPED(write_ovl); CLOSE_OVERLAPPED(wait_ovl); + if (port->write_buf) { + free(port->write_buf); + port->write_buf = NULL; + } #else /* Returns 0 upon success, -1 upon failure. */ if (close(port->fd) == -1) @@ -716,6 +747,27 @@ SP_API enum sp_return sp_drain(struct sp_port *port) #endif } +#ifdef _WIN32 +static enum sp_return await_write_completion(struct sp_port *port) +{ + TRACE("%p", port); + DWORD bytes_written; + BOOL result; + + /* Wait for previous non-blocking write to complete, if any. */ + if (port->writing) { + DEBUG("Waiting for previous write to complete"); + result = GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE); + port->writing = 0; + if (!result) + RETURN_FAIL("Previous write failed to complete"); + DEBUG("Previous write completed"); + } + + RETURN_OK(); +} +#endif + SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, size_t count, unsigned int timeout_ms) { @@ -738,17 +790,8 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, #ifdef _WIN32 DWORD bytes_written = 0; - BOOL result; - /* Wait for previous non-blocking write to complete, if any. */ - if (port->writing) { - DEBUG("Waiting for previous write to complete"); - result = GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE); - port->writing = 0; - if (!result) - RETURN_FAIL("Previous write failed to complete"); - DEBUG("Previous write completed"); - } + TRY(await_write_completion(port)); /* Set timeout. */ if (port->timeouts.WriteTotalTimeoutConstant != timeout_ms) { @@ -757,14 +800,24 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, RETURN_FAIL("SetCommTimeouts() failed"); } + /* Reduce count if it exceeds the WriteFile limit. */ + if (count > WRITEFILE_MAX_SIZE) + count = WRITEFILE_MAX_SIZE; + /* Start write. */ if (WriteFile(port->hdl, buf, count, NULL, &port->write_ovl)) { DEBUG("Write completed immediately"); RETURN_INT(count); } else if (GetLastError() == ERROR_IO_PENDING) { DEBUG("Waiting for write to complete"); - if (GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE) == 0) - RETURN_FAIL("GetOverlappedResult() failed"); + if (GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE) == 0) { + if (GetLastError() == ERROR_SEM_TIMEOUT) { + DEBUG("Write timed out"); + RETURN_INT(0); + } else { + RETURN_FAIL("GetOverlappedResult() failed"); + } + } DEBUG_FMT("Write completed, %d/%d bytes written", bytes_written, count); RETURN_INT(bytes_written); } else { @@ -780,7 +833,7 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, if (timeout_ms) { /* Get time at start of operation. */ - gettimeofday(&start, NULL); + get_time(&start); /* Define duration of timeout. */ delta.tv_sec = timeout_ms / 1000; delta.tv_usec = (timeout_ms % 1000) * 1000; @@ -799,7 +852,7 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, * select() is even run. */ if (timeout_ms && started) { - gettimeofday(&now, NULL); + get_time(&now); if (timercmp(&now, &end, >)) /* Timeout has expired. */ break; @@ -858,8 +911,7 @@ SP_API enum sp_return sp_nonblocking_write(struct sp_port *port, RETURN_INT(0); #ifdef _WIN32 - DWORD written = 0; - BYTE *ptr = (BYTE *) buf; + DWORD buf_bytes; /* Check whether previous write is complete. */ if (port->writing) { @@ -880,48 +932,43 @@ SP_API enum sp_return sp_nonblocking_write(struct sp_port *port, RETURN_FAIL("SetCommTimeouts() failed"); } - /* - * Keep writing data until the OS has to actually start an async IO - * for it. At that point we know the buffer is full. - */ - while (written < count) { - /* Copy first byte of user buffer. */ - port->pending_byte = *ptr++; - - /* Start asynchronous write. */ - if (WriteFile(port->hdl, &port->pending_byte, 1, NULL, &port->write_ovl) == 0) { - if (GetLastError() == ERROR_IO_PENDING) { - if (HasOverlappedIoCompleted(&port->write_ovl)) { - DEBUG("Asynchronous write completed immediately"); - port->writing = 0; - written++; - continue; - } else { - DEBUG("Asynchronous write running"); - port->writing = 1; - RETURN_INT(++written); - } - } else { - /* Actual failure of some kind. */ - RETURN_FAIL("WriteFile() failed"); - } + /* Reduce count if it exceeds the WriteFile limit. */ + if (count > WRITEFILE_MAX_SIZE) + count = WRITEFILE_MAX_SIZE; + + /* Copy data to our write buffer. */ + buf_bytes = min(port->write_buf_size, count); + memcpy(port->write_buf, buf, buf_bytes); + + /* Start asynchronous write. */ + if (WriteFile(port->hdl, port->write_buf, buf_bytes, NULL, &port->write_ovl) == 0) { + if (GetLastError() == ERROR_IO_PENDING) { + if ((port->writing = !HasOverlappedIoCompleted(&port->write_ovl))) + DEBUG("Asynchronous write completed immediately"); + else + DEBUG("Asynchronous write running"); } else { - DEBUG("Single byte written immediately"); - written++; + /* Actual failure of some kind. */ + RETURN_FAIL("WriteFile() failed"); } } DEBUG("All bytes written immediately"); - RETURN_INT(written); + RETURN_INT(buf_bytes); #else /* Returns the number of bytes written, or -1 upon failure. */ ssize_t written = write(port->fd, buf, count); - if (written < 0) - RETURN_FAIL("write() failed"); - else + if (written < 0) { + if (errno == EAGAIN) + // Buffer is full, no bytes written. + RETURN_INT(0); + else + RETURN_FAIL("write() failed"); + } else { RETURN_INT(written); + } #endif } @@ -998,7 +1045,7 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf, #else size_t bytes_read = 0; - unsigned char *ptr = (unsigned char *) buf; + unsigned char *ptr = (unsigned char *)buf; struct timeval start, delta, now, end = {0, 0}; int started = 0; fd_set fds; @@ -1006,7 +1053,7 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf, if (timeout_ms) { /* Get time at start of operation. */ - gettimeofday(&start, NULL); + get_time(&start); /* Define duration of timeout. */ delta.tv_sec = timeout_ms / 1000; delta.tv_usec = (timeout_ms % 1000) * 1000; @@ -1025,7 +1072,7 @@ SP_API enum sp_return sp_blocking_read(struct sp_port *port, void *buf, * select() is even run. */ if (timeout_ms && started) { - gettimeofday(&now, NULL); + get_time(&now); if (timercmp(&now, &end, >)) /* Timeout has expired. */ break; @@ -1111,9 +1158,8 @@ SP_API enum sp_return sp_blocking_read_next(struct sp_port *port, void *buf, /* Loop until we have at least one byte, or timeout is reached. */ while (bytes_read == 0) { /* Start read. */ - if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl)) { + if (ReadFile(port->hdl, buf, count, &bytes_read, &port->read_ovl)) { DEBUG("Read completed immediately"); - bytes_read = count; } else if (GetLastError() == ERROR_IO_PENDING) { DEBUG("Waiting for read to complete"); if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE) == 0) @@ -1144,7 +1190,7 @@ SP_API enum sp_return sp_blocking_read_next(struct sp_port *port, void *buf, if (timeout_ms) { /* Get time at start of operation. */ - gettimeofday(&start, NULL); + get_time(&start); /* Define duration of timeout. */ delta.tv_sec = timeout_ms / 1000; delta.tv_usec = (timeout_ms % 1000) * 1000; @@ -1163,7 +1209,7 @@ SP_API enum sp_return sp_blocking_read_next(struct sp_port *port, void *buf, * select() is even run. */ if (timeout_ms && started) { - gettimeofday(&now, NULL); + get_time(&now); if (timercmp(&now, &end, >)) /* Timeout has expired. */ break; @@ -1233,10 +1279,11 @@ SP_API enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf, /* Do read. */ if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl) == 0) - RETURN_FAIL("ReadFile() failed"); + if (GetLastError() != ERROR_IO_PENDING) + RETURN_FAIL("ReadFile() failed"); /* Get number of bytes read. */ - if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE) == 0) + if (GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, FALSE) == 0) RETURN_FAIL("GetOverlappedResult() failed"); TRY(restart_wait_if_needed(port, bytes_read)); @@ -1420,7 +1467,10 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set, RETURN_OK(); #else struct timeval start, delta, now, end = {0, 0}; - int started = 0; + const struct timeval max_delta = { + (INT_MAX / 1000), (INT_MAX % 1000) * 1000 + }; + int started = 0, timeout_overflow = 0; int result, timeout_remaining_ms; struct pollfd *pollfds; unsigned int i; @@ -1429,7 +1479,7 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set, RETURN_ERROR(SP_ERR_MEM, "pollfds malloc() failed"); for (i = 0; i < event_set->count; i++) { - pollfds[i].fd = ((int *) event_set->handles)[i]; + pollfds[i].fd = ((int *)event_set->handles)[i]; pollfds[i].events = 0; pollfds[i].revents = 0; if (event_set->masks[i] & SP_EVENT_RX_READY) @@ -1442,7 +1492,7 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set, if (timeout_ms) { /* Get time at start of operation. */ - gettimeofday(&start, NULL); + get_time(&start); /* Define duration of timeout. */ delta.tv_sec = timeout_ms / 1000; delta.tv_usec = (timeout_ms % 1000) * 1000; @@ -1457,17 +1507,24 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set, * to avoid any issues if a short timeout is reached before * poll() is even run. */ - if (timeout_ms && started) { - gettimeofday(&now, NULL); + if (!timeout_ms) { + timeout_remaining_ms = -1; + } else if (!started) { + timeout_overflow = (timeout_ms > INT_MAX); + timeout_remaining_ms = timeout_overflow ? INT_MAX : timeout_ms; + } else { + get_time(&now); if (timercmp(&now, &end, >)) { DEBUG("Wait timed out"); break; } timersub(&end, &now, &delta); + if ((timeout_overflow = timercmp(&delta, &max_delta, >))) + delta = max_delta; timeout_remaining_ms = delta.tv_sec * 1000 + delta.tv_usec / 1000; } - result = poll(pollfds, event_set->count, timeout_ms ? timeout_remaining_ms : -1); + result = poll(pollfds, event_set->count, timeout_remaining_ms); started = 1; if (result < 0) { @@ -1480,7 +1537,8 @@ SP_API enum sp_return sp_wait(struct sp_event_set *event_set, } } else if (result == 0) { DEBUG("poll() timed out"); - break; + if (!timeout_overflow) + break; } else { DEBUG("poll() completed"); break; @@ -1831,6 +1889,9 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, DEBUG_FMT("Setting configuration for port %s", port->name); #ifdef _WIN32 + + TRY(await_write_completion(port)); + if (config->baudrate >= 0) { for (i = 0; i < NUM_STD_BAUDRATES; i++) { if (config->baudrate == std_baudrates[i].value) { @@ -1841,6 +1902,14 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, if (i == NUM_STD_BAUDRATES) data->dcb.BaudRate = config->baudrate; + + /* Allocate write buffer for 50ms of data at baud rate. */ + port->write_buf_size = max(config->baudrate / (8 * 20), 1); + port->write_buf = realloc(port->write_buf, + port->write_buf_size); + + if (!port->write_buf) + RETURN_ERROR(SP_ERR_MEM, "Allocating write buffer failed"); } if (config->bits >= 0)