X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=serialport.c;h=d356057525c3e56a6afe5aefaccd28374552468f;hb=75f468923b9805207ce62f007f85c13444df314b;hp=d7164b86f9d9076d797f6732996422c1065ec206;hpb=bd72614f08d13a336403f8dbc3e41d038b7bf18b;p=libserialport.git

diff --git a/serialport.c b/serialport.c
index d7164b8..d356057 100644
--- a/serialport.c
+++ b/serialport.c
@@ -21,8 +21,6 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <config.h>
-#include "libserialport.h"
 #include "libserialport_internal.h"
 
 static const struct std_baudrate std_baudrates[] = {
@@ -55,177 +53,6 @@ static enum sp_return get_config(struct sp_port *port, struct port_data *data,
 static enum sp_return set_config(struct sp_port *port, struct port_data *data,
 	const struct sp_port_config *config);
 
-/* Timing abstraction */
-
-struct time {
-#ifdef _WIN32
-	int64_t ticks;
-#else
-	struct timeval tv;
-#endif
-};
-
-struct timeout {
-	unsigned int ms, limit_ms;
-	struct time start, now, end, delta, delta_max;
-	struct timeval delta_tv;
-	bool calls_started, overflow;
-};
-
-static void time_get(struct time *time)
-{
-#ifdef _WIN32
-	LARGE_INTEGER count;
-	QueryPerformanceCounter(&count);
-	time->ticks = count.QuadPart;
-#elif defined(HAVE_CLOCK_GETTIME)
-	struct timespec ts;
-	if (clock_gettime(CLOCK_MONOTONIC, &ts) == -1)
-		clock_gettime(CLOCK_REALTIME, &ts);
-	time->tv.tv_sec = ts.tv_sec;
-	time->tv.tv_usec = ts.tv_nsec / 1000;
-#elif defined(__APPLE__)
-	mach_timebase_info_data_t info;
-	mach_timebase_info(&info);
-	uint64_t ticks = mach_absolute_time();
-	uint64_t ns = (ticks * info.numer) / info.denom;
-	time->tv.tv_sec = ns / 1000000000;
-	time->tv.tv_usec = (ns % 1000000000) / 1000;
-#else
-	gettimeofday(&time->tv, NULL);
-#endif
-}
-
-static void time_set_ms(struct time *time, unsigned int ms)
-{
-#ifdef _WIN32
-	LARGE_INTEGER frequency;
-	QueryPerformanceFrequency(&frequency);
-	time->ticks = ms * (frequency.QuadPart / 1000);
-#else
-	time->tv.tv_sec = ms / 1000;
-	time->tv.tv_usec = (ms % 1000) * 1000;
-#endif
-}
-
-static void time_add(const struct time *a,
-		const struct time *b, struct time *result)
-{
-#ifdef _WIN32
-	result->ticks = a->ticks + b->ticks;
-#else
-	timeradd(&a->tv, &b->tv, &result->tv);
-#endif
-}
-
-static void time_sub(const struct time *a,
-		const struct time *b, struct time *result)
-{
-#ifdef _WIN32
-	result->ticks = a->ticks - b->ticks;
-#else
-	timersub(&a->tv, &b->tv, &result->tv);
-#endif
-}
-
-static bool time_greater(const struct time *a, const struct time *b)
-{
-#ifdef _WIN32
-	return (a->ticks > b->ticks);
-#else
-	return timercmp(&a->tv, &b->tv, >);
-#endif
-}
-
-static void time_as_timeval(const struct time *time, struct timeval *tv)
-{
-#ifdef _WIN32
-	LARGE_INTEGER frequency;
-	QueryPerformanceFrequency(&frequency);
-	tv->tv_sec = time->ticks / frequency.QuadPart;
-	tv->tv_usec = (time->ticks % frequency.QuadPart) /
-		(frequency.QuadPart / 1000000);
-#else
-	*tv = time->tv;
-#endif
-}
-
-static unsigned int time_as_ms(const struct time *time)
-{
-#ifdef _WIN32
-	LARGE_INTEGER frequency;
-	QueryPerformanceFrequency(&frequency);
-	return time->ticks / (frequency.QuadPart / 1000);
-#else
-	return time->tv.tv_sec * 1000 + time->tv.tv_usec / 1000;
-#endif
-}
-
-static void timeout_start(struct timeout *timeout, unsigned int timeout_ms)
-{
-	timeout->ms = timeout_ms;
-
-	/* Get time at start of operation. */
-	time_get(&timeout->start);
-	/* Define duration of timeout. */
-	time_set_ms(&timeout->delta, timeout_ms);
-	/* Calculate time at which we should give up. */
-	time_add(&timeout->start, &timeout->delta, &timeout->end);
-	/* Disable limit unless timeout_limit() called. */
-	timeout->limit_ms = 0;
-	/* First blocking call has not yet been made. */
-	timeout->calls_started = false;
-}
-
-static void timeout_limit(struct timeout *timeout, unsigned int limit_ms)
-{
-	timeout->limit_ms = limit_ms;
-	timeout->overflow = (timeout->ms > timeout->limit_ms);
-	time_set_ms(&timeout->delta_max, timeout->limit_ms);
-}
-
-static bool timeout_check(struct timeout *timeout)
-{
-	if (!timeout->calls_started)
-		return false;
-
-	if (timeout->ms == 0)
-		return false;
-
-	time_get(&timeout->now);
-	time_sub(&timeout->end, &timeout->now, &timeout->delta);
-	if (timeout->limit_ms)
-		if ((timeout->overflow = time_greater(&timeout->delta, &timeout->delta_max)))
-			timeout->delta = timeout->delta_max;
-
-	return time_greater(&timeout->now, &timeout->end);
-}
-
-static void timeout_update(struct timeout *timeout)
-{
-	timeout->calls_started = true;
-}
-
-#ifndef _WIN32
-static struct timeval *timeout_timeval(struct timeout *timeout)
-{
-	if (timeout->ms == 0)
-		return NULL;
-
-	time_as_timeval(&timeout->delta, &timeout->delta_tv);
-
-	return &timeout->delta_tv;
-}
-#endif
-
-static unsigned int timeout_remaining_ms(struct timeout *timeout)
-{
-	if (timeout->limit_ms && timeout->overflow)
-		return timeout->limit_ms;
-	else
-		return time_as_ms(&timeout->delta);
-}
-
 SP_API enum sp_return sp_get_port_by_name(const char *portname, struct sp_port **port_ptr)
 {
 	struct sp_port *port;
@@ -955,40 +782,62 @@ SP_API enum sp_return sp_blocking_write(struct sp_port *port, const void *buf,
 		RETURN_INT(0);
 
 #ifdef _WIN32
-	DWORD bytes_written = 0;
+	DWORD remaining_ms, write_size, bytes_written, total_bytes_written = 0;
+	const uint8_t *write_ptr = (uint8_t *) buf;
+	bool result;
+	struct timeout timeout;
+
+	timeout_start(&timeout, timeout_ms);
 
 	TRY(await_write_completion(port));
 
-	/* Set timeout. */
-	if (port->timeouts.WriteTotalTimeoutConstant != timeout_ms) {
-		port->timeouts.WriteTotalTimeoutConstant = timeout_ms;
-		if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
-			RETURN_FAIL("SetCommTimeouts() failed");
-	}
+	while (total_bytes_written < count) {
 
-	/* Reduce count if it exceeds the WriteFile limit. */
-	if (count > WRITEFILE_MAX_SIZE)
-		count = WRITEFILE_MAX_SIZE;
+		if (timeout_check(&timeout))
+			break;
 
-	/* 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) {
-			if (GetLastError() == ERROR_SEM_TIMEOUT) {
-				DEBUG("Write timed out");
-				RETURN_INT(0);
-			} else {
-				RETURN_FAIL("GetOverlappedResult() failed");
+		remaining_ms = timeout_remaining_ms(&timeout);
+
+		if (port->timeouts.WriteTotalTimeoutConstant != remaining_ms) {
+			port->timeouts.WriteTotalTimeoutConstant = remaining_ms;
+			if (SetCommTimeouts(port->hdl, &port->timeouts) == 0)
+				RETURN_FAIL("SetCommTimeouts() failed");
+		}
+
+		/* Reduce write size if it exceeds the WriteFile limit. */
+		write_size = count - total_bytes_written;
+		if (write_size > WRITEFILE_MAX_SIZE)
+			write_size = WRITEFILE_MAX_SIZE;
+
+		/* Start write. */
+
+		result = WriteFile(port->hdl, write_ptr, write_size, NULL, &port->write_ovl);
+
+		timeout_update(&timeout);
+
+		if (result) {
+			DEBUG("Write completed immediately");
+			bytes_written = write_size;
+		} else if (GetLastError() == ERROR_IO_PENDING) {
+			DEBUG("Waiting for write to complete");
+			if (GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE) == 0) {
+				if (GetLastError() == ERROR_SEM_TIMEOUT) {
+					DEBUG("Write timed out");
+					break;
+				} else {
+					RETURN_FAIL("GetOverlappedResult() failed");
+				}
 			}
+			DEBUG_FMT("Write completed, %d/%d bytes written", bytes_written, write_size);
+		} else {
+			RETURN_FAIL("WriteFile() failed");
 		}
-		DEBUG_FMT("Write completed, %d/%d bytes written", bytes_written, count);
-		RETURN_INT(bytes_written);
-	} else {
-		RETURN_FAIL("WriteFile() failed");
+
+		write_ptr += bytes_written;
+		total_bytes_written += bytes_written;
 	}
+
+	RETURN_INT(total_bytes_written);
 #else
 	size_t bytes_written = 0;
 	unsigned char *ptr = (unsigned char *) buf;