X-Git-Url: http://sigrok.org/gitweb/?a=blobdiff_plain;f=serialport.c;h=0276567a4008008064e871ac24e7e63d8dd5e9fa;hb=6c8716e9dabb5aece68eec87bbf4e322ff92e6a2;hp=a0faf6aa03551a3eccbc6a490e9e8eecb8234372;hpb=b251be4b261f37483571ca999a14bafbfffecd43;p=libserialport.git diff --git a/serialport.c b/serialport.c index a0faf6a..0276567 100644 --- a/serialport.c +++ b/serialport.c @@ -34,8 +34,11 @@ #include #include #else +#include #include #include +#include +#include #endif #ifdef __APPLE__ #include @@ -47,11 +50,21 @@ #include "libudev.h" #include "linux/serial.h" #include "linux_termios.h" + +/* TCGETX/TCSETX is not available everywhere. */ #if defined(TCGETX) && defined(TCSETX) && defined(HAVE_TERMIOX) #define USE_TERMIOX #endif #endif +/* TIOCINQ/TIOCOUTQ is not available everywhere. */ +#if !defined(TIOCINQ) && defined(FIONREAD) +#define TIOCINQ FIONREAD +#endif +#if !defined(TIOCOUTQ) && defined(FIONWRITE) +#define TIOCOUTQ FIONWRITE +#endif + #ifndef _WIN32 #include "linux_termios.h" #endif @@ -60,10 +73,11 @@ struct sp_port { char *name; - int nonblocking; #ifdef _WIN32 HANDLE hdl; + COMMTIMEOUTS timeouts; OVERLAPPED write_ovl; + OVERLAPPED read_ovl; BYTE pending_byte; BOOL writing; #else @@ -221,7 +235,7 @@ char *sp_get_port_name(const struct sp_port *port) enum sp_return sp_get_port_handle(const struct sp_port *port, void *result_ptr) { - TRACE("%p", port); + TRACE("%p, %p", port, result_ptr); if (!port) RETURN_ERROR(SP_ERR_ARG, "Null port"); @@ -261,8 +275,7 @@ void sp_free_port(struct sp_port *port) { TRACE("%p", port); - if (!port) - { + if (!port) { DEBUG("Null port"); RETURN(); } @@ -573,20 +586,21 @@ void sp_free_port_list(struct sp_port **list) enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) { - TRACE("%p, %x", port, flags); + struct port_data data; + struct sp_port_config config; + enum sp_return ret; + + TRACE("%p, 0x%x", port, flags); CHECK_PORT(); - if (flags > (SP_MODE_READ | SP_MODE_WRITE | SP_MODE_NONBLOCK)) + if (flags > (SP_MODE_READ | SP_MODE_WRITE)) RETURN_ERROR(SP_ERR_ARG, "Invalid flags"); DEBUG("Opening port %s", port->name); - port->nonblocking = (flags & SP_MODE_NONBLOCK) ? 1 : 0; - #ifdef _WIN32 DWORD desired_access = 0, flags_and_attributes = 0; - COMMTIMEOUTS timeouts; char *escaped_port_name; /* Prefix port name with '\\.\' to work with ports above COM9. */ @@ -595,13 +609,11 @@ enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) sprintf(escaped_port_name, "\\\\.\\%s", port->name); /* Map 'flags' to the OS-specific settings. */ - flags_and_attributes = FILE_ATTRIBUTE_NORMAL; + flags_and_attributes = FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED; if (flags & SP_MODE_READ) desired_access |= GENERIC_READ; if (flags & SP_MODE_WRITE) desired_access |= GENERIC_WRITE; - if (flags & SP_MODE_NONBLOCK) - flags_and_attributes |= FILE_FLAG_OVERLAPPED; port->hdl = CreateFile(escaped_port_name, desired_access, 0, 0, OPEN_EXISTING, flags_and_attributes, 0); @@ -609,36 +621,38 @@ enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) free(escaped_port_name); if (port->hdl == INVALID_HANDLE_VALUE) - RETURN_FAIL("CreateFile() failed"); - - /* All timeouts disabled. */ - timeouts.ReadIntervalTimeout = 0; - timeouts.ReadTotalTimeoutMultiplier = 0; - timeouts.ReadTotalTimeoutConstant = 0; - timeouts.WriteTotalTimeoutMultiplier = 0; - timeouts.WriteTotalTimeoutConstant = 0; - - if (port->nonblocking) { - /* Set read timeout such that all reads return immediately. */ - timeouts.ReadIntervalTimeout = MAXDWORD; - /* Prepare OVERLAPPED structure for non-blocking writes. */ - memset(&port->write_ovl, 0, sizeof(port->write_ovl)); - if (!(port->write_ovl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL))) { - sp_close(port); - RETURN_FAIL("CreateEvent() failed"); - } - port->writing = FALSE; - } + RETURN_FAIL("port CreateFile() failed"); + + /* All timeouts initially disabled. */ + port->timeouts.ReadIntervalTimeout = 0; + port->timeouts.ReadTotalTimeoutMultiplier = 0; + port->timeouts.ReadTotalTimeoutConstant = 0; + port->timeouts.WriteTotalTimeoutMultiplier = 0; + port->timeouts.WriteTotalTimeoutConstant = 0; - if (SetCommTimeouts(port->hdl, &timeouts) == 0) { + if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) { sp_close(port); RETURN_FAIL("SetCommTimeouts() failed"); } + + /* Prepare OVERLAPPED structures. */ + memset(&port->read_ovl, 0, sizeof(port->read_ovl)); + memset(&port->write_ovl, 0, sizeof(port->write_ovl)); + port->read_ovl.hEvent = INVALID_HANDLE_VALUE; + port->write_ovl.hEvent = INVALID_HANDLE_VALUE; + if ((port->read_ovl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL)) == INVALID_HANDLE_VALUE) { + sp_close(port); + RETURN_FAIL("read event CreateEvent() failed"); + } + if ((port->write_ovl.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL)) == INVALID_HANDLE_VALUE) { + sp_close(port); + RETURN_FAIL("write event CreateEvent() failed"); + } + + port->writing = FALSE; + #else - int flags_local = 0; - struct port_data data; - struct sp_port_config config; - int ret; + int flags_local = O_NONBLOCK | O_NOCTTY; /* Map 'flags' to the OS-specific settings. */ if (flags & (SP_MODE_READ | SP_MODE_WRITE)) @@ -647,11 +661,10 @@ enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) flags_local |= O_RDONLY; else if (flags & SP_MODE_WRITE) flags_local |= O_WRONLY; - if (flags & SP_MODE_NONBLOCK) - flags_local |= O_NONBLOCK; if ((port->fd = open(port->name, flags_local)) < 0) RETURN_FAIL("open() failed"); +#endif ret = get_config(port, &data, &config); @@ -660,18 +673,51 @@ enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) RETURN_CODEVAL(ret); } + /* Set sane port settings. */ +#ifdef _WIN32 + data.dcb.fBinary = TRUE; + data.dcb.fDsrSensitivity = FALSE; + data.dcb.fErrorChar = FALSE; + data.dcb.fNull = FALSE; + data.dcb.fAbortOnError = TRUE; +#else /* Turn off all fancy termios tricks, give us a raw channel. */ - data.term.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP|INLCR|IGNCR|ICRNL|IUCLC|IMAXBEL); - data.term.c_oflag &= ~(OPOST|OLCUC|ONLCR|OCRNL|ONOCR|ONLRET|NLDLY|CRDLY|TABDLY|BSDLY|VTDLY|FFDLY); + data.term.c_iflag &= ~(IGNBRK | BRKINT | PARMRK | ISTRIP | INLCR | IGNCR | ICRNL | IMAXBEL); +#ifdef IUCLC + data.term.c_iflag &= ~IUCLC; +#endif + data.term.c_oflag &= ~(OPOST | ONLCR | OCRNL | ONOCR | ONLRET); +#ifdef OLCUC + data.term.c_oflag &= ~OLCUC; +#endif +#ifdef NLDLY + data.term.c_oflag &= ~NLDLY; +#endif +#ifdef CRDLY + data.term.c_oflag &= ~CRDLY; +#endif +#ifdef TABDLY + data.term.c_oflag &= ~TABDLY; +#endif +#ifdef BSDLY + data.term.c_oflag &= ~BSDLY; +#endif +#ifdef VTDLY + data.term.c_oflag &= ~VTDLY; +#endif +#ifdef FFDLY + data.term.c_oflag &= ~FFDLY; +#endif #ifdef OFILL data.term.c_oflag &= ~OFILL; #endif - data.term.c_lflag &= ~(ISIG|ICANON|ECHO|IEXTEN); + data.term.c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN); data.term.c_cc[VMIN] = 0; data.term.c_cc[VTIME] = 0; /* Ignore modem status lines; enable receiver; leave control lines alone on close. */ data.term.c_cflag |= (CLOCAL | CREAD | HUPCL); +#endif ret = set_config(port, &data, &config); @@ -679,7 +725,6 @@ enum sp_return sp_open(struct sp_port *port, enum sp_mode flags) sp_close(port); RETURN_CODEVAL(ret); } -#endif RETURN_OK(); } @@ -695,13 +740,14 @@ enum sp_return sp_close(struct sp_port *port) #ifdef _WIN32 /* Returns non-zero upon success, 0 upon failure. */ if (CloseHandle(port->hdl) == 0) - RETURN_FAIL("CloseHandle() failed"); + RETURN_FAIL("port CloseHandle() failed"); port->hdl = INVALID_HANDLE_VALUE; - if (port->nonblocking) { - /* Close event handle created for overlapped writes. */ - if (CloseHandle(port->write_ovl.hEvent) == 0) - RETURN_FAIL("CloseHandle() failed"); - } + /* Close event handle created for overlapped reads. */ + if (port->read_ovl.hEvent != INVALID_HANDLE_VALUE && CloseHandle(port->read_ovl.hEvent) == 0) + RETURN_FAIL("read event CloseHandle() failed"); + /* Close event handle created for overlapped writes. */ + if (port->write_ovl.hEvent != INVALID_HANDLE_VALUE && CloseHandle(port->write_ovl.hEvent) == 0) + RETURN_FAIL("write event CloseHandle() failed"); #else /* Returns 0 upon success, -1 upon failure. */ if (close(port->fd) == -1) @@ -714,7 +760,7 @@ enum sp_return sp_close(struct sp_port *port) enum sp_return sp_flush(struct sp_port *port, enum sp_buffer buffers) { - TRACE("%p, %x", port, buffers); + TRACE("%p, 0x%x", port, buffers); CHECK_OPEN_PORT(); @@ -763,16 +809,140 @@ enum sp_return sp_drain(struct sp_port *port) /* Returns non-zero upon success, 0 upon failure. */ if (FlushFileBuffers(port->hdl) == 0) RETURN_FAIL("FlushFileBuffers() failed"); + RETURN_OK(); #else - /* Returns 0 upon success, -1 upon failure. */ - if (tcdrain(port->fd) < 0) - RETURN_FAIL("tcdrain() failed"); + int result; + while (1) { + result = tcdrain(port->fd); + if (result < 0) { + if (errno == EINTR) { + DEBUG("tcdrain() was interrupted"); + continue; + } else { + RETURN_FAIL("tcdrain() failed"); + } + } else { + RETURN_OK(); + } + } #endif +} - RETURN_OK(); +enum sp_return sp_blocking_write(struct sp_port *port, const void *buf, size_t count, unsigned int timeout) +{ + TRACE("%p, %p, %d, %d", port, buf, count, timeout); + + CHECK_OPEN_PORT(); + + if (!buf) + RETURN_ERROR(SP_ERR_ARG, "Null buffer"); + + if (timeout) + DEBUG("Writing %d bytes to port %s, timeout %d ms", count, port->name, timeout); + else + DEBUG("Writing %d bytes to port %s, no timeout", count, port->name); + + if (count == 0) + RETURN_VALUE("0", 0); + +#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"); + } + + /* Set timeout. */ + port->timeouts.WriteTotalTimeoutConstant = timeout; + if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) + RETURN_FAIL("SetCommTimeouts() failed"); + + /* Start write. */ + if (WriteFile(port->hdl, buf, count, NULL, &port->write_ovl) == 0) { + if (GetLastError() == ERROR_IO_PENDING) { + DEBUG("Waiting for write to complete"); + GetOverlappedResult(port->hdl, &port->write_ovl, &bytes_written, TRUE); + DEBUG("Write completed, %d/%d bytes written", bytes_written, count); + RETURN_VALUE("%d", bytes_written); + } else { + RETURN_FAIL("WriteFile() failed"); + } + } else { + DEBUG("Write completed immediately"); + RETURN_VALUE("%d", count); + } +#else + size_t bytes_written = 0; + unsigned char *ptr = (unsigned char *) buf; + struct timeval start, delta, now, end = {0, 0}; + fd_set fds; + int result; + + if (timeout) { + /* Get time at start of operation. */ + gettimeofday(&start, NULL); + /* Define duration of timeout. */ + delta.tv_sec = timeout / 1000; + delta.tv_usec = (timeout % 1000) * 1000; + /* Calculate time at which we should give up. */ + timeradd(&start, &delta, &end); + } + + /* Loop until we have written the requested number of bytes. */ + while (bytes_written < count) + { + /* Wait until space is available. */ + FD_ZERO(&fds); + FD_SET(port->fd, &fds); + if (timeout) { + gettimeofday(&now, NULL); + if (timercmp(&now, &end, >)) { + DEBUG("write timed out"); + RETURN_VALUE("%d", bytes_written); + } + timersub(&end, &now, &delta); + } + result = select(port->fd + 1, NULL, &fds, NULL, timeout ? &delta : NULL); + if (result < 0) { + if (errno == EINTR) { + DEBUG("select() call was interrupted, repeating"); + continue; + } else { + RETURN_FAIL("select() failed"); + } + } else if (result == 0) { + DEBUG("write timed out"); + RETURN_VALUE("%d", bytes_written); + } + + /* Do write. */ + result = write(port->fd, ptr, count - bytes_written); + + if (result < 0) { + if (errno == EAGAIN) + /* This shouldn't happen because we did a select() first, but handle anyway. */ + continue; + else + /* This is an actual failure. */ + RETURN_FAIL("write() failed"); + } + + bytes_written += result; + ptr += result; + } + + RETURN_VALUE("%d", bytes_written); +#endif } -enum sp_return sp_write(struct sp_port *port, const void *buf, size_t count) +enum sp_return sp_nonblocking_write(struct sp_port *port, const void *buf, size_t count) { TRACE("%p, %p, %d", port, buf, count); @@ -790,53 +960,48 @@ enum sp_return sp_write(struct sp_port *port, const void *buf, size_t count) DWORD written = 0; BYTE *ptr = (BYTE *) buf; - if (port->nonblocking) { - /* Non-blocking write. */ - - /* Check whether previous write is complete. */ - if (port->writing) { - if (HasOverlappedIoCompleted(&port->write_ovl)) { - DEBUG("Previous write completed"); - port->writing = 0; - } else { - DEBUG("Previous write not complete"); - /* Can't take a new write until the previous one finishes. */ - RETURN_VALUE("0", 0); - } + /* Check whether previous write is complete. */ + if (port->writing) { + if (HasOverlappedIoCompleted(&port->write_ovl)) { + DEBUG("Previous write completed"); + port->writing = 0; + } else { + DEBUG("Previous write not complete"); + /* Can't take a new write until the previous one finishes. */ + RETURN_VALUE("0", 0); } + } - /* 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) { - DEBUG("Asynchronous write started"); - port->writing = 1; - RETURN_VALUE("%d", ++written); - } else { - /* Actual failure of some kind. */ - RETURN_FAIL("WriteFile() failed"); - } + /* Set timeout. */ + port->timeouts.WriteTotalTimeoutConstant = 0; + if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) + 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) { + DEBUG("Asynchronous write started"); + port->writing = 1; + RETURN_VALUE("%d", ++written); } else { - DEBUG("Single byte written immediately."); - written++; + /* Actual failure of some kind. */ + RETURN_FAIL("WriteFile() failed"); } - } - - DEBUG("All bytes written immediately."); - - } else { - /* Blocking write. */ - if (WriteFile(port->hdl, buf, count, &written, NULL) == 0) { - RETURN_FAIL("WriteFile() failed"); + } else { + DEBUG("Single byte written immediately."); + written++; } } + DEBUG("All bytes written immediately."); + RETURN_VALUE("%d", written); #else /* Returns the number of bytes written, or -1 upon failure. */ @@ -849,7 +1014,110 @@ enum sp_return sp_write(struct sp_port *port, const void *buf, size_t count) #endif } -enum sp_return sp_read(struct sp_port *port, void *buf, size_t count) +enum sp_return sp_blocking_read(struct sp_port *port, void *buf, size_t count, unsigned int timeout) +{ + TRACE("%p, %p, %d, %d", port, buf, count, timeout); + + CHECK_OPEN_PORT(); + + if (!buf) + RETURN_ERROR(SP_ERR_ARG, "Null buffer"); + + if (timeout) + DEBUG("Reading %d bytes from port %s, timeout %d ms", count, port->name, timeout); + else + DEBUG("Reading %d bytes from port %s, no timeout", count, port->name); + + if (count == 0) + RETURN_VALUE("0", 0); + +#ifdef _WIN32 + DWORD bytes_read = 0; + + /* Set timeout. */ + port->timeouts.ReadIntervalTimeout = 0; + port->timeouts.ReadTotalTimeoutConstant = timeout; + if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) + RETURN_FAIL("SetCommTimeouts() failed"); + + /* Start read. */ + if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl) == 0) { + if (GetLastError() == ERROR_IO_PENDING) { + DEBUG("Waiting for read to complete"); + GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE); + DEBUG("Read completed, %d/%d bytes read", bytes_read, count); + RETURN_VALUE("%d", bytes_read); + } else { + RETURN_FAIL("ReadFile() failed"); + } + } else { + DEBUG("Read completed immediately"); + RETURN_VALUE("%d", count); + } +#else + size_t bytes_read = 0; + unsigned char *ptr = (unsigned char *) buf; + struct timeval start, delta, now, end = {0, 0}; + fd_set fds; + int result; + + if (timeout) { + /* Get time at start of operation. */ + gettimeofday(&start, NULL); + /* Define duration of timeout. */ + delta.tv_sec = timeout / 1000; + delta.tv_usec = (timeout % 1000) * 1000; + /* Calculate time at which we should give up. */ + timeradd(&start, &delta, &end); + } + + /* Loop until we have the requested number of bytes. */ + while (bytes_read < count) + { + /* Wait until data is available. */ + FD_ZERO(&fds); + FD_SET(port->fd, &fds); + if (timeout) { + gettimeofday(&now, NULL); + if (timercmp(&now, &end, >)) + /* Timeout has expired. */ + RETURN_VALUE("%d", bytes_read); + timersub(&end, &now, &delta); + } + result = select(port->fd + 1, &fds, NULL, NULL, timeout ? &delta : NULL); + if (result < 0) { + if (errno == EINTR) { + DEBUG("select() call was interrupted, repeating"); + continue; + } else { + RETURN_FAIL("select() failed"); + } + } else if (result == 0) { + DEBUG("read timed out"); + RETURN_VALUE("%d", bytes_read); + } + + /* Do read. */ + result = read(port->fd, ptr, count - bytes_read); + + if (result < 0) { + if (errno == EAGAIN) + /* This shouldn't happen because we did a select() first, but handle anyway. */ + continue; + else + /* This is an actual failure. */ + RETURN_FAIL("read() failed"); + } + + bytes_read += result; + ptr += result; + } + + RETURN_VALUE("%d", bytes_read); +#endif +} + +enum sp_return sp_nonblocking_read(struct sp_port *port, void *buf, size_t count) { TRACE("%p, %p, %d", port, buf, count); @@ -861,19 +1129,29 @@ enum sp_return sp_read(struct sp_port *port, void *buf, size_t count) DEBUG("Reading up to %d bytes from port %s", count, port->name); #ifdef _WIN32 - DWORD bytes_read = 0; + DWORD bytes_read; - /* Returns non-zero upon success, 0 upon failure. */ - if (ReadFile(port->hdl, buf, count, &bytes_read, NULL) == 0) + /* Set timeout. */ + port->timeouts.ReadIntervalTimeout = MAXDWORD; + port->timeouts.ReadTotalTimeoutConstant = 0; + if (SetCommTimeouts(port->hdl, &port->timeouts) == 0) + RETURN_FAIL("SetCommTimeouts() failed"); + + /* Do read. */ + if (ReadFile(port->hdl, buf, count, NULL, &port->read_ovl) == 0) RETURN_FAIL("ReadFile() failed"); + + /* Get number of bytes read. */ + GetOverlappedResult(port->hdl, &port->read_ovl, &bytes_read, TRUE); + RETURN_VALUE("%d", bytes_read); #else ssize_t bytes_read; /* Returns the number of bytes read, or -1 upon failure. */ if ((bytes_read = read(port->fd, buf, count)) < 0) { - if (port->nonblocking && errno == EAGAIN) - /* Port is opened in nonblocking mode and there are no bytes available. */ + if (errno == EAGAIN) + /* No bytes available. */ bytes_read = 0; else /* This is an actual failure. */ @@ -883,6 +1161,52 @@ enum sp_return sp_read(struct sp_port *port, void *buf, size_t count) #endif } +enum sp_return sp_input_waiting(struct sp_port *port) +{ + TRACE("%p", port); + + CHECK_OPEN_PORT(); + + DEBUG("Checking input bytes waiting on port %s", port->name); + +#ifdef _WIN32 + DWORD errors; + COMSTAT comstat; + + if (ClearCommError(port->hdl, &errors, &comstat) == 0) + RETURN_FAIL("ClearComError() failed"); + RETURN_VALUE("%d", comstat.cbInQue); +#else + int bytes_waiting; + if (ioctl(port->fd, TIOCINQ, &bytes_waiting) < 0) + RETURN_FAIL("TIOCINQ ioctl failed"); + RETURN_VALUE("%d", bytes_waiting); +#endif +} + +enum sp_return sp_output_waiting(struct sp_port *port) +{ + TRACE("%p", port); + + CHECK_OPEN_PORT(); + + DEBUG("Checking output bytes waiting on port %s", port->name); + +#ifdef _WIN32 + DWORD errors; + COMSTAT comstat; + + if (ClearCommError(port->hdl, &errors, &comstat) == 0) + RETURN_FAIL("ClearComError() failed"); + RETURN_VALUE("%d", comstat.cbOutQue); +#else + int bytes_waiting; + if (ioctl(port->fd, TIOCOUTQ, &bytes_waiting) < 0) + RETURN_FAIL("TIOCOUTQ ioctl failed"); + RETURN_VALUE("%d", bytes_waiting); +#endif +} + #ifdef __linux__ static enum sp_return get_baudrate(int fd, int *baudrate) { @@ -1024,11 +1348,17 @@ static enum sp_return get_config(struct sp_port *port, struct port_data *data, case NOPARITY: config->parity = SP_PARITY_NONE; break; + case ODDPARITY: + config->parity = SP_PARITY_ODD; + break; case EVENPARITY: config->parity = SP_PARITY_EVEN; break; - case ODDPARITY: - config->parity = SP_PARITY_ODD; + case MARKPARITY: + config->parity = SP_PARITY_MARK; + break; + case SPACEPARITY: + config->parity = SP_PARITY_SPACE; break; default: config->parity = -1; @@ -1150,6 +1480,10 @@ static enum sp_return get_config(struct sp_port *port, struct port_data *data, config->parity = SP_PARITY_NONE; else if (!(data->term.c_cflag & PARENB) || (data->term.c_iflag & IGNPAR)) config->parity = -1; +#ifdef CMSPAR + else if (data->term.c_cflag & CMSPAR) + config->parity = (data->term.c_cflag & PARODD) ? SP_PARITY_MARK : SP_PARITY_SPACE; +#endif else config->parity = (data->term.c_cflag & PARODD) ? SP_PARITY_ODD : SP_PARITY_EVEN; @@ -1231,11 +1565,17 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, case SP_PARITY_NONE: data->dcb.Parity = NOPARITY; break; + case SP_PARITY_ODD: + data->dcb.Parity = ODDPARITY; + break; case SP_PARITY_EVEN: data->dcb.Parity = EVENPARITY; break; - case SP_PARITY_ODD: - data->dcb.Parity = ODDPARITY; + case SP_PARITY_MARK: + data->dcb.Parity = MARKPARITY; + break; + case SP_PARITY_SPACE: + data->dcb.Parity = SPACEPARITY; break; default: RETURN_ERROR(SP_ERR_ARG, "Invalid parity setting"); @@ -1394,6 +1734,9 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, if (config->parity >= 0) { data->term.c_iflag &= ~IGNPAR; data->term.c_cflag &= ~(PARENB | PARODD); +#ifdef CMSPAR + data->term.c_cflag &= ~CMSPAR; +#endif switch (config->parity) { case SP_PARITY_NONE: data->term.c_iflag |= IGNPAR; @@ -1404,6 +1747,20 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, case SP_PARITY_ODD: data->term.c_cflag |= PARENB | PARODD; break; +#ifdef CMSPAR + case SP_PARITY_MARK: + data->term.c_cflag |= PARENB | PARODD; + data->term.c_cflag |= CMSPAR; + break; + case SP_PARITY_SPACE: + data->term.c_cflag |= PARENB; + data->term.c_cflag |= CMSPAR; + break; +#else + case SP_PARITY_MARK: + case SP_PARITY_SPACE: + RETURN_ERROR(SP_ERR_SUPP, "Mark/space parity not supported"); +#endif default: RETURN_ERROR(SP_ERR_ARG, "Invalid parity setting"); } @@ -1529,7 +1886,7 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, } } - if (tcsetattr(port->fd, TCSADRAIN, &data->term) < 0) + if (tcsetattr(port->fd, TCSANOW, &data->term) < 0) RETURN_FAIL("tcsetattr() failed"); #ifdef __APPLE__ @@ -1557,9 +1914,10 @@ static enum sp_return set_config(struct sp_port *port, struct port_data *data, enum sp_return sp_new_config(struct sp_port_config **config_ptr) { - TRACE("%p", config_ptr); struct sp_port_config *config; + TRACE("%p", config_ptr); + if (!config_ptr) RETURN_ERROR(SP_ERR_ARG, "Null result pointer"); @@ -1640,7 +1998,7 @@ enum sp_return sp_set_##x(struct sp_port *port, type x) { \ RETURN_OK(); \ } \ enum sp_return sp_get_config_##x(const struct sp_port_config *config, type *x) { \ - TRACE("%p", config); \ + TRACE("%p, %p", config, x); \ if (!config) \ RETURN_ERROR(SP_ERR_ARG, "Null config"); \ *x = config->x; \ @@ -1849,7 +2207,7 @@ void sp_default_debug_handler(const char *format, ...) va_list args; va_start(args, format); if (getenv("LIBSERIALPORT_DEBUG")) { - fputs("libserialport: ", stderr); + fputs("sp: ", stderr); vfprintf(stderr, format, args); } va_end(args);