X-Git-Url: http://sigrok.org/gitweb/?a=blobdiff_plain;f=serialport.c;h=269992e83a6cc2efe7ad85883c970ce384d870a3;hb=067417af4fd8b619ed5ede2184cb450e35dc3ecd;hp=b47ddd931b50692e0d5e6470e0509d870d6b3583;hpb=f9796bcb869e25c1a75e000150d7371fcec648f6;p=libserialport.git diff --git a/serialport.c b/serialport.c index b47ddd9..269992e 100644 --- a/serialport.c +++ b/serialport.c @@ -29,6 +29,7 @@ #ifdef _WIN32 #include #include +#include #else #include #include @@ -43,13 +44,78 @@ #include "linux/serial.h" #endif -#include "serialport.h" +#include "libserialport.h" + +struct sp_port_data { +#ifdef _WIN32 + DCB dcb; +#else + struct termios term; + int controlbits; + int rts; + int cts; + int dtr; + int dsr; +#endif +}; + +/* Standard baud rates. */ +#ifdef _WIN32 +#define BAUD_TYPE DWORD +#define BAUD(n) {CBR_##n, n} +#else +#define BAUD_TYPE speed_t +#define BAUD(n) {B##n, n} +#endif + +struct std_baudrate { + BAUD_TYPE index; + int value; +}; + +const struct std_baudrate std_baudrates[] = { +#ifdef _WIN32 + /* + * The baudrates 50/75/134/150/200/1800/230400/460800 do not seem to + * have documented CBR_* macros. + */ + BAUD(110), BAUD(300), BAUD(600), BAUD(1200), BAUD(2400), BAUD(4800), + BAUD(9600), BAUD(14400), BAUD(19200), BAUD(38400), BAUD(57600), + BAUD(115200), BAUD(128000), BAUD(256000) +#else + BAUD(50), BAUD(75), BAUD(110), BAUD(134), BAUD(150), BAUD(200), BAUD(300), + BAUD(600), BAUD(1200), BAUD(1800), BAUD(2400), BAUD(4800), BAUD(9600), + BAUD(19200), BAUD(38400), BAUD(57600), BAUD(115200), BAUD(230400), +#if !defined(__APPLE__) && !defined(__OpenBSD__) + BAUD(460800) +#endif +#endif +}; + +#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) +#define NUM_STD_BAUDRATES ARRAY_SIZE(std_baudrates) + +/* Helper functions for configuring ports. */ +static int start_config(struct sp_port *port, struct sp_port_data *data); +static int set_baudrate(struct sp_port_data *data, int baudrate); +static int set_bits(struct sp_port_data *data, int bits); +static int set_parity(struct sp_port_data *data, int parity); +static int set_stopbits(struct sp_port_data *data, int stopbits); +static int set_rts(struct sp_port_data *data, int rts); +static int set_cts(struct sp_port_data *data, int cts); +static int set_dtr(struct sp_port_data *data, int dtr); +static int set_dsr(struct sp_port_data *data, int dsr); +static int set_xon_xoff(struct sp_port_data *data, int xon_xoff); +static int apply_config(struct sp_port *port, struct sp_port_data *data); int sp_get_port_by_name(const char *portname, struct sp_port **port_ptr) { struct sp_port *port; int len; + if (!port_ptr) + return SP_ERR_ARG; + *port_ptr = NULL; if (!portname) @@ -73,6 +139,19 @@ int sp_get_port_by_name(const char *portname, struct sp_port **port_ptr) return SP_OK; } +int sp_copy_port(const struct sp_port *port, struct sp_port **copy_ptr) +{ + if (!copy_ptr) + return SP_ERR_ARG; + + *copy_ptr = NULL; + + if (!port || !port->name) + return SP_ERR_ARG; + + return sp_get_port_by_name(port->name, copy_ptr); +} + void sp_free_port(struct sp_port *port) { if (!port) @@ -88,6 +167,7 @@ static struct sp_port **sp_list_append(struct sp_port **list, const char *portna { void *tmp; unsigned int count; + for (count = 0; list[count]; count++); if (!(tmp = realloc(list, sizeof(struct sp_port *) * (count + 2)))) goto fail; @@ -96,6 +176,7 @@ static struct sp_port **sp_list_append(struct sp_port **list, const char *portna goto fail; list[count + 1] = NULL; return list; + fail: sp_free_port_list(list); return NULL; @@ -107,7 +188,7 @@ int sp_list_ports(struct sp_port ***list_ptr) int ret = SP_OK; if (!(list = malloc(sizeof(struct sp_port **)))) - return SP_ERR_MEM;; + return SP_ERR_MEM; list[0] = NULL; @@ -144,7 +225,7 @@ int sp_list_ports(struct sp_port ***list_ptr) goto out_free_value; } while ( - value_len = max_value_len, + value_len = max_value_len + 1, data_size = max_data_size, RegEnumValue(key, index, value, &value_len, NULL, &type, (LPBYTE)data, &data_size) == ERROR_SUCCESS) @@ -205,7 +286,7 @@ out_done: CFDictionarySetValue(classes, CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDAllTypes)); - if (!(IOServiceGetMatchingServices(master, classes, &iter))) + if (IOServiceGetMatchingServices(master, classes, &iter) != KERN_SUCCESS) { ret = SP_ERR_FAIL; goto out_done; @@ -315,6 +396,7 @@ out: void sp_free_port_list(struct sp_port **list) { unsigned int i; + for (i = 0; list[i]; i++) sp_free_port(list[i]); free(list); @@ -343,6 +425,13 @@ int sp_open(struct sp_port *port, int flags) #ifdef _WIN32 DWORD desired_access = 0, flags_and_attributes = 0; + char *escaped_port_name; + + /* Prefix port name with '\\.\' to work with ports above COM9. */ + if (!(escaped_port_name = malloc(strlen(port->name + 5)))) + return SP_ERR_MEM; + sprintf(escaped_port_name, "\\\\.\\%s", port->name); + /* Map 'flags' to the OS-specific settings. */ desired_access |= GENERIC_READ; flags_and_attributes = FILE_ATTRIBUTE_NORMAL; @@ -351,12 +440,17 @@ int sp_open(struct sp_port *port, int flags) if (flags & SP_MODE_NONBLOCK) flags_and_attributes |= FILE_FLAG_OVERLAPPED; - port->hdl = CreateFile(port->name, desired_access, 0, 0, + port->hdl = CreateFile(escaped_port_name, desired_access, 0, 0, OPEN_EXISTING, flags_and_attributes, 0); + + free(escaped_port_name); + if (port->hdl == INVALID_HANDLE_VALUE) return SP_ERR_FAIL; #else int flags_local = 0; + struct sp_port_data data; + /* Map 'flags' to the OS-specific settings. */ if (flags & SP_MODE_RDWR) flags_local |= O_RDWR; @@ -367,6 +461,22 @@ int sp_open(struct sp_port *port, int flags) if ((port->fd = open(port->name, flags_local)) < 0) return SP_ERR_FAIL; + + start_config(port, &data); + + /* Turn off all serial port cooking. */ + data.term.c_iflag &= ~(ISTRIP | INLCR | ICRNL); + data.term.c_oflag &= ~(ONLCR | OCRNL | ONOCR); +#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__) + data.term.c_oflag &= ~OFILL; +#endif + /* Disable canonical mode, and don't echo input characters. */ + data.term.c_lflag &= ~(ICANON | ECHO); + + /* Ignore modem status lines; enable receiver */ + data.term.c_cflag |= (CLOCAL | CREAD); + + apply_config(port, &data); #endif return SP_OK; @@ -414,6 +524,7 @@ int sp_write(struct sp_port *port, const void *buf, size_t count) #ifdef _WIN32 DWORD written = 0; + /* Returns non-zero upon success, 0 upon failure. */ if (WriteFile(port->hdl, buf, count, &written, NULL) == 0) return SP_ERR_FAIL; @@ -421,10 +532,11 @@ int sp_write(struct sp_port *port, const void *buf, size_t count) #else /* Returns the number of bytes written, or -1 upon failure. */ ssize_t written = write(port->fd, buf, count); + if (written < 0) return SP_ERR_FAIL; else - return written;; + return written; #endif } @@ -437,12 +549,14 @@ int sp_read(struct sp_port *port, void *buf, size_t count) #ifdef _WIN32 DWORD bytes_read = 0; + /* Returns non-zero upon success, 0 upon failure. */ if (ReadFile(port->hdl, buf, count, &bytes_read, NULL) == 0) return SP_ERR_FAIL; return 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) return SP_ERR_FAIL; @@ -450,281 +564,516 @@ int sp_read(struct sp_port *port, void *buf, size_t count) #endif } -int sp_set_params(struct sp_port *port, int baudrate, - int bits, int parity, int stopbits, - int flowcontrol, int rts, int dtr) +static int start_config(struct sp_port *port, struct sp_port_data *data) { CHECK_PORT(); - #ifdef _WIN32 - DCB dcb; + if (!GetCommState(port->hdl, &data->dcb)) + return SP_ERR_FAIL; +#else + if (tcgetattr(port->fd, &data->term) < 0) + return SP_ERR_FAIL; - if (!GetCommState(port->hdl, &dcb)) + if (ioctl(port->fd, TIOCMGET, &data->controlbits) < 0) return SP_ERR_FAIL; - switch (baudrate) { - /* - * The baudrates 50/75/134/150/200/1800/230400/460800 do not seem to - * have documented CBR_* macros. - */ - case 110: - dcb.BaudRate = CBR_110; - break; - case 300: - dcb.BaudRate = CBR_300; - break; - case 600: - dcb.BaudRate = CBR_600; - break; - case 1200: - dcb.BaudRate = CBR_1200; - break; - case 2400: - dcb.BaudRate = CBR_2400; - break; - case 4800: - dcb.BaudRate = CBR_4800; + if (data->term.c_cflag & CRTSCTS) { + data->rts = SP_RTS_FLOW_CONTROL; + data->cts = SP_CTS_FLOW_CONTROL; + } else { + data->rts = (data->controlbits & TIOCM_RTS) ? SP_RTS_ON : SP_RTS_OFF; + data->cts = SP_CTS_IGNORE; + } + + data->dtr = (data->controlbits & TIOCM_DTR) ? SP_DTR_ON : SP_DTR_OFF; + data->dsr = SP_DSR_IGNORE; +#endif + return SP_OK; +} + +static int set_baudrate(struct sp_port_data *data, int baudrate) +{ + unsigned int i; + for (i = 0; i < NUM_STD_BAUDRATES; i++) { + if (baudrate == std_baudrates[i].value) { +#ifdef _WIN32 + data->dcb.BaudRate = std_baudrates[i].index; +#else + if (cfsetospeed(&data->term, std_baudrates[i].index) < 0) + return SP_ERR_FAIL; + + if (cfsetispeed(&data->term, std_baudrates[i].index) < 0) + return SP_ERR_FAIL; +#endif + break; + } + } + + if (i == NUM_STD_BAUDRATES) + return SP_ERR_ARG; + + return SP_OK; +} + +static int set_bits(struct sp_port_data *data, int bits) +{ +#ifdef _WIN32 + data->dcb.ByteSize = bits; +#else + data->term.c_cflag &= ~CSIZE; + switch (bits) { + case 8: + data->term.c_cflag |= CS8; break; - case 9600: - dcb.BaudRate = CBR_9600; + case 7: + data->term.c_cflag |= CS7; break; - case 14400: - dcb.BaudRate = CBR_14400; /* Not available on Unix? */ + case 6: + data->term.c_cflag |= CS6; break; - case 19200: - dcb.BaudRate = CBR_19200; + default: + return SP_ERR_ARG; + } +#endif + return SP_OK; +} + +static int set_parity(struct sp_port_data *data, int parity) +{ +#ifdef _WIN32 + switch (parity) { + /* Note: There's also SPACEPARITY, MARKPARITY (unneeded so far). */ + case SP_PARITY_NONE: + data->dcb.Parity = NOPARITY; break; - case 38400: - dcb.BaudRate = CBR_38400; + case SP_PARITY_EVEN: + data->dcb.Parity = EVENPARITY; break; - case 57600: - dcb.BaudRate = CBR_57600; + case SP_PARITY_ODD: + data->dcb.Parity = ODDPARITY; break; - case 115200: - dcb.BaudRate = CBR_115200; + default: + return SP_ERR_ARG; + } +#else + data->term.c_iflag &= ~IGNPAR; + data->term.c_cflag &= ~(PARENB | PARODD); + switch (parity) { + case SP_PARITY_NONE: + data->term.c_iflag |= IGNPAR; break; - case 128000: - dcb.BaudRate = CBR_128000; /* Not available on Unix? */ + case SP_PARITY_EVEN: + data->term.c_cflag |= PARENB; break; - case 256000: - dcb.BaudRate = CBR_256000; /* Not available on Unix? */ + case SP_PARITY_ODD: + data->term.c_cflag |= PARENB | PARODD; break; default: return SP_ERR_ARG; } +#endif + return SP_OK; +} +static int set_stopbits(struct sp_port_data *data, int stopbits) +{ +#ifdef _WIN32 switch (stopbits) { /* Note: There's also ONE5STOPBITS == 1.5 (unneeded so far). */ case 1: - dcb.StopBits = ONESTOPBIT; + data->dcb.StopBits = ONESTOPBIT; break; case 2: - dcb.StopBits = TWOSTOPBITS; + data->dcb.StopBits = TWOSTOPBITS; break; default: return SP_ERR_ARG; } - - switch (parity) { - /* Note: There's also SPACEPARITY, MARKPARITY (unneeded so far). */ - case SP_PARITY_NONE: - dcb.Parity = NOPARITY; - break; - case SP_PARITY_EVEN: - dcb.Parity = EVENPARITY; +#else + data->term.c_cflag &= ~CSTOPB; + switch (stopbits) { + case 1: + data->term.c_cflag &= ~CSTOPB; break; - case SP_PARITY_ODD: - dcb.Parity = ODDPARITY; + case 2: + data->term.c_cflag |= CSTOPB; break; default: return SP_ERR_ARG; } +#endif + return SP_OK; +} - if (rts != -1) { - if (rts) - dcb.fRtsControl = RTS_CONTROL_ENABLE; - else - dcb.fRtsControl = RTS_CONTROL_DISABLE; - } - - if (dtr != -1) { - if (dtr) - dcb.fDtrControl = DTR_CONTROL_ENABLE; - else - dcb.fDtrControl = DTR_CONTROL_DISABLE; - } - - if (!SetCommState(port->hdl, &dcb)) - return SP_ERR_FAIL; -#else - struct termios term; - speed_t baud; - int controlbits; - - if (tcgetattr(port->fd, &term) < 0) - return SP_ERR_FAIL; - - switch (baudrate) { - case 50: - baud = B50; - break; - case 75: - baud = B75; +static int set_rts(struct sp_port_data *data, int rts) +{ +#ifdef _WIN32 + switch (rts) { + case SP_RTS_OFF: + data->dcb.fRtsControl = RTS_CONTROL_DISABLE; break; - case 110: - baud = B110; + case SP_RTS_ON: + data->dcb.fRtsControl = RTS_CONTROL_ENABLE; break; - case 134: - baud = B134; + case SP_RTS_FLOW_CONTROL: + data->dcb.fRtsControl = RTS_CONTROL_HANDSHAKE; break; - case 150: - baud = B150; + default: + return SP_ERR_ARG; + } +#else + data->rts = rts; +#endif + return SP_OK; +} + +static int set_cts(struct sp_port_data *data, int cts) +{ +#ifdef _WIN32 + switch (cts) { + case SP_CTS_IGNORE: + data->dcb.fOutxCtsFlow = FALSE; break; - case 200: - baud = B200; + case SP_CTS_FLOW_CONTROL: + data->dcb.fOutxCtsFlow = TRUE; break; - case 300: - baud = B300; + default: + return SP_ERR_ARG; + } +#else + data->cts = cts; +#endif + return SP_OK; +} + +static int set_dtr(struct sp_port_data *data, int dtr) +{ +#ifdef _WIN32 + switch (dtr) { + case SP_DTR_OFF: + data->dcb.fDtrControl = DTR_CONTROL_DISABLE; break; - case 600: - baud = B600; + case SP_DTR_ON: + data->dcb.fDtrControl = DTR_CONTROL_ENABLE; break; - case 1200: - baud = B1200; + case SP_DTR_FLOW_CONTROL: + data->dcb.fDtrControl = DTR_CONTROL_HANDSHAKE; break; - case 1800: - baud = B1800; + default: + return SP_ERR_ARG; + } +#else + data->dtr = dtr; +#endif + return SP_OK; +} + +static int set_dsr(struct sp_port_data *data, int dsr) +{ +#ifdef _WIN32 + switch (dsr) { + case SP_DSR_IGNORE: + data->dcb.fOutxDsrFlow = FALSE; break; - case 2400: - baud = B2400; + case SP_DSR_FLOW_CONTROL: + data->dcb.fOutxDsrFlow = TRUE; break; - case 4800: - baud = B4800; + default: + return SP_ERR_ARG; + } +#else + data->dsr = dsr; +#endif + return SP_OK; +} + +static int set_xon_xoff(struct sp_port_data *data, int xon_xoff) +{ +#ifdef _WIN32 + switch (xon_xoff) { + case SP_XONXOFF_DISABLED: + data->dcb.fInX = FALSE; + data->dcb.fOutX = FALSE; break; - case 9600: - baud = B9600; + case SP_XONXOFF_IN: + data->dcb.fInX = TRUE; + data->dcb.fOutX = FALSE; break; - case 19200: - baud = B19200; + case SP_XONXOFF_OUT: + data->dcb.fInX = FALSE; + data->dcb.fOutX = TRUE; break; - case 38400: - baud = B38400; + case SP_XONXOFF_INOUT: + data->dcb.fInX = TRUE; + data->dcb.fOutX = TRUE; break; - case 57600: - baud = B57600; + default: + return SP_ERR_ARG; + } +#else + data->term.c_iflag &= ~(IXON | IXOFF | IXANY); + switch (xon_xoff) { + case SP_XONXOFF_DISABLED: break; - case 115200: - baud = B115200; + case SP_XONXOFF_IN: + data->term.c_iflag |= IXOFF; break; - case 230400: - baud = B230400; + case SP_XONXOFF_OUT: + data->term.c_iflag |= IXON | IXANY; break; -#if !defined(__APPLE__) && !defined(__OpenBSD__) - case 460800: - baud = B460800; + case SP_XONXOFF_INOUT: + data->term.c_iflag |= IXON | IXOFF | IXANY; break; -#endif default: return SP_ERR_ARG; } +#endif + return SP_OK; +} - if (cfsetospeed(&term, baud) < 0) +static int apply_config(struct sp_port *port, struct sp_port_data *data) +{ +#ifdef _WIN32 + if (!SetCommState(port->hdl, &data->dcb)) return SP_ERR_FAIL; +#else + int controlbits; - if (cfsetispeed(&term, baud) < 0) - return SP_ERR_FAIL; + /* Asymmetric use of RTS/CTS not supported yet. */ + if ((data->rts == SP_RTS_FLOW_CONTROL) != (data->cts == SP_CTS_FLOW_CONTROL)) + return SP_ERR_ARG; - term.c_cflag &= ~CSIZE; - switch (bits) { - case 8: - term.c_cflag |= CS8; - break; - case 7: - term.c_cflag |= CS7; - break; - default: + /* DTR/DSR flow control not supported yet. */ + if (data->dtr == SP_DTR_FLOW_CONTROL || data->dsr == SP_DSR_FLOW_CONTROL) return SP_ERR_ARG; + + if (data->rts == SP_RTS_FLOW_CONTROL) + data->term.c_iflag |= CRTSCTS; + else + { + controlbits = TIOCM_RTS; + if (ioctl(port->fd, data->rts == SP_RTS_ON ? TIOCMBIS : TIOCMBIC, + &controlbits) < 0) + return SP_ERR_FAIL; } - term.c_cflag &= ~CSTOPB; - switch (stopbits) { - case 1: - term.c_cflag &= ~CSTOPB; - break; - case 2: - term.c_cflag |= CSTOPB; - break; - default: - return SP_ERR_ARG; + controlbits = TIOCM_DTR; + if (ioctl(port->fd, data->dtr == SP_DTR_ON ? TIOCMBIS : TIOCMBIC, + &controlbits) < 0) + return SP_ERR_FAIL; + + /* Write the configured settings. */ + if (tcsetattr(port->fd, TCSADRAIN, &data->term) < 0) + return SP_ERR_FAIL; +#endif + return SP_OK; +} + +#define TRY(x) do { int ret = x; if (ret != SP_OK) return ret; } while (0) +#define TRY_SET(x, y) do { if (y >= 0) TRY(set_##x(&data, y)); } while (0) +#define TRY_SET_CONFIG(x) TRY_SET(x, config->x) + +int sp_set_config(struct sp_port *port, struct sp_port_config *config) +{ + struct sp_port_data data; + + TRY(start_config(port, &data)); + TRY_SET_CONFIG(baudrate); + TRY_SET_CONFIG(bits); + TRY_SET_CONFIG(parity); + TRY_SET_CONFIG(stopbits); + TRY_SET_CONFIG(rts); + TRY_SET_CONFIG(cts); + TRY_SET_CONFIG(dtr); + TRY_SET_CONFIG(dsr); + TRY_SET_CONFIG(xon_xoff); + TRY(apply_config(port, &data)); + + return SP_OK; +} + +int sp_get_config(struct sp_port *port, struct sp_port_config *config) +{ + struct sp_port_data data; + unsigned int i; + + TRY(start_config(port, &data)); + +#ifdef _WIN32 + for (i = 0; i < NUM_STD_BAUDRATES; i++) { + if (data.dcb.BaudRate == std_baudrates[i].index) { + config->baudrate = std_baudrates[i].value; + break; + } } - term.c_iflag &= ~(IXON | IXOFF | IXANY); - term.c_cflag &= ~CRTSCTS; - switch (flowcontrol) { - case 0: - /* No flow control. */ - break; - case 1: - term.c_cflag |= CRTSCTS; + if (i == NUM_STD_BAUDRATES) + /* BaudRate field can be either an index or a custom baud rate. */ + config->baudrate = data.dcb.BaudRate; + + config->bits = data.dcb.ByteSize; + + if (data.dcb.fParity) + switch (data.dcb.Parity) { + case NOPARITY: + config->parity = SP_PARITY_NONE; + break; + case EVENPARITY: + config->parity = SP_PARITY_EVEN; + break; + case ODDPARITY: + config->parity = SP_PARITY_ODD; + break; + default: + config->parity = -1; + } + else + config->parity = SP_PARITY_NONE; + + switch (data.dcb.StopBits) { + case ONESTOPBIT: + config->stopbits = 1; break; - case 2: - term.c_iflag |= IXON | IXOFF | IXANY; + case TWOSTOPBITS: + config->stopbits = 2; break; default: - return SP_ERR_ARG; + config->stopbits = -1; } - term.c_iflag &= ~IGNPAR; - term.c_cflag &= ~(PARENB | PARODD); - switch (parity) { - case SP_PARITY_NONE: - term.c_iflag |= IGNPAR; + switch (data.dcb.fRtsControl) { + case RTS_CONTROL_DISABLE: + config->rts = SP_RTS_OFF; + break; + case RTS_CONTROL_ENABLE: + config->rts = SP_RTS_ON; + break; + case RTS_CONTROL_HANDSHAKE: + config->rts = SP_RTS_FLOW_CONTROL; + break; + default: + config->rts = -1; + } + + config->cts = data.dcb.fOutxCtsFlow ? SP_CTS_FLOW_CONTROL : SP_CTS_IGNORE; + + switch (data.dcb.fDtrControl) { + case DTR_CONTROL_DISABLE: + config->dtr = SP_DTR_OFF; + break; + case DTR_CONTROL_ENABLE: + config->dtr = SP_DTR_ON; + break; + case DTR_CONTROL_HANDSHAKE: + config->dtr = SP_DTR_FLOW_CONTROL; + break; + default: + config->dtr = -1; + } + + config->dsr = data.dcb.fOutxDsrFlow ? SP_DSR_FLOW_CONTROL : SP_DSR_IGNORE; +#else + for (i = 0; i < NUM_STD_BAUDRATES; i++) { + if (cfgetispeed(&data.term) == std_baudrates[i].index) { + config->baudrate = std_baudrates[i].value; + break; + } + } + + if (i == NUM_STD_BAUDRATES) + config->baudrate = -1; + + switch (data.term.c_cflag & CSIZE) { + case CS8: + config->bits = 8; break; - case SP_PARITY_EVEN: - term.c_cflag |= PARENB; + case CS7: + config->bits = 7; break; - case SP_PARITY_ODD: - term.c_cflag |= PARENB | PARODD; + case CS6: + config->bits = 6; + break; + case CS5: + config->bits = 5; break; default: - return SP_ERR_ARG; + config->bits = -1; } - /* Turn off all serial port cooking. */ - term.c_iflag &= ~(ISTRIP | INLCR | ICRNL); - term.c_oflag &= ~(ONLCR | OCRNL | ONOCR); -#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__NetBSD__) - term.c_oflag &= ~OFILL; + if (!(data.term.c_cflag & PARENB) && (data.term.c_iflag & IGNPAR)) + config->parity = SP_PARITY_NONE; + else if (!(data.term.c_cflag & PARENB) || (data.term.c_iflag & IGNPAR)) + config->parity = -1; + else + config->parity = (data.term.c_cflag & PARODD) ? SP_PARITY_ODD : SP_PARITY_EVEN; + + config->stopbits = (data.term.c_cflag & CSTOPB) ? 2 : 1; + + if (data.term.c_cflag & CRTSCTS) { + config->rts = SP_RTS_FLOW_CONTROL; + config->cts = SP_CTS_FLOW_CONTROL; + } else { + config->rts = (data.controlbits & TIOCM_RTS) ? SP_RTS_ON : SP_RTS_OFF; + config->cts = SP_CTS_IGNORE; + } + + config->dtr = (data.controlbits & TIOCM_DTR) ? SP_DTR_ON : SP_DTR_OFF; + config->dsr = SP_DSR_IGNORE; #endif - /* Disable canonical mode, and don't echo input characters. */ - term.c_lflag &= ~(ICANON | ECHO); + return SP_OK; +} - /* Ignore modem status lines; enable receiver */ - term.c_cflag |= (CLOCAL | CREAD); +int sp_set_flowcontrol(struct sp_port *port, int flowcontrol) +{ + struct sp_port_data data; - /* Write the configured settings. */ - if (tcsetattr(port->fd, TCSADRAIN, &term) < 0) - return SP_ERR_FAIL; + TRY(start_config(port, &data)); - if (rts != -1) { - controlbits = TIOCM_RTS; - if (ioctl(port->fd, rts ? TIOCMBIS : TIOCMBIC, - &controlbits) < 0) - return SP_ERR_FAIL; + if (flowcontrol == SP_FLOWCONTROL_XONXOFF) + TRY_SET(xon_xoff, SP_XONXOFF_INOUT); + else + TRY_SET(xon_xoff, SP_XONXOFF_DISABLED); + + if (flowcontrol == SP_FLOWCONTROL_RTSCTS) { + TRY_SET(rts, SP_RTS_FLOW_CONTROL); + TRY_SET(cts, SP_CTS_FLOW_CONTROL); + } else { + TRY_SET(rts, SP_RTS_ON); + TRY_SET(cts, SP_CTS_IGNORE); } - if (dtr != -1) { - controlbits = TIOCM_DTR; - if (ioctl(port->fd, dtr ? TIOCMBIS : TIOCMBIC, - &controlbits) < 0) - return SP_ERR_FAIL; + if (flowcontrol == SP_FLOWCONTROL_DTRDSR) { + TRY_SET(dtr, SP_DTR_FLOW_CONTROL); + TRY_SET(dsr, SP_DSR_FLOW_CONTROL); + } else { + TRY_SET(dtr, SP_DTR_ON); + TRY_SET(dsr, SP_DSR_IGNORE); } -#endif + + TRY(apply_config(port, &data)); return SP_OK; } +#define CREATE_SETTER(x) int sp_set_##x(struct sp_port *port, int x) { \ + struct sp_port_data data; \ + TRY(start_config(port, &data)); \ + TRY(set_##x(&data, x)); \ + TRY(apply_config(port, &data)); \ + return SP_OK; \ +} + +CREATE_SETTER(baudrate) +CREATE_SETTER(bits) +CREATE_SETTER(parity) +CREATE_SETTER(stopbits) +CREATE_SETTER(rts) +CREATE_SETTER(cts) +CREATE_SETTER(dtr) +CREATE_SETTER(dsr) +CREATE_SETTER(xon_xoff) + int sp_last_error_code(void) { #ifdef _WIN32