X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=serialport.c;h=7066091c7d7a3c6b879f0db1a33140cea023cf9c;hb=bf2cbd652f9b520dcd3de9c98f000b85de00dba6;hp=c89f44ea89ecc2318401a4d97a03e4d36e95daef;hpb=74510d4b59f755dc2db687e0e321eed25181cc37;p=libserialport.git diff --git a/serialport.c b/serialport.c index c89f44e..7066091 100644 --- a/serialport.c +++ b/serialport.c @@ -24,19 +24,380 @@ #include #include #include +#include +#include #ifdef _WIN32 #include +#include +#include #else -#include #include #include #endif -#include -#include +#ifdef __APPLE__ +#include +#include +#include +#endif +#ifdef __linux__ +#include "libudev.h" +#include "linux/serial.h" +#endif + +#include "libserialport.h" + +struct port_data { +#ifdef _WIN32 + DCB dcb; +#else + struct termios term; + int controlbits; +#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. */ +static int validate_port(struct sp_port *port); +static struct sp_port **list_append(struct sp_port **list, const char *portname); +static int get_config(struct sp_port *port, struct port_data *data, struct sp_port_config *config); +static int set_config(struct sp_port *port, struct port_data *data, const struct sp_port_config *config); + +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) + return SP_ERR_ARG; + + if (!(port = malloc(sizeof(struct sp_port)))) + return SP_ERR_MEM; + + len = strlen(portname) + 1; + + if (!(port->name = malloc(len))) + { + free(port); + return SP_ERR_MEM; + } + + memcpy(port->name, portname, len); + +#ifdef _WIN32 + port->hdl = INVALID_HANDLE_VALUE; +#else + port->fd = -1; +#endif + + *port_ptr = port; + + 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) + return; + + if (port->name) + free(port->name); + + free(port); +} + +static struct sp_port **list_append(struct sp_port **list, const char *portname) +{ + void *tmp; + unsigned int count; + + for (count = 0; list[count]; count++); + if (!(tmp = realloc(list, sizeof(struct sp_port *) * (count + 2)))) + goto fail; + list = tmp; + if (sp_get_port_by_name(portname, &list[count]) != SP_OK) + goto fail; + list[count + 1] = NULL; + return list; + +fail: + sp_free_port_list(list); + return NULL; +} + +int sp_list_ports(struct sp_port ***list_ptr) +{ + struct sp_port **list; + int ret = SP_OK; + + if (!(list = malloc(sizeof(struct sp_port **)))) + return SP_ERR_MEM; + + list[0] = NULL; + +#ifdef _WIN32 + HKEY key; + TCHAR *value, *data; + DWORD max_value_len, max_data_size, max_data_len; + DWORD value_len, data_size, data_len; + DWORD type, index = 0; + char *name; + int name_len; + + if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, _T("HARDWARE\\DEVICEMAP\\SERIALCOMM"), + 0, KEY_QUERY_VALUE, &key) != ERROR_SUCCESS) + { + ret = SP_ERR_FAIL; + goto out_done; + } + if (RegQueryInfoKey(key, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + &max_value_len, &max_data_size, NULL, NULL) != ERROR_SUCCESS) + { + ret = SP_ERR_FAIL; + goto out_close; + } + max_data_len = max_data_size / sizeof(TCHAR); + if (!(value = malloc((max_value_len + 1) * sizeof(TCHAR)))) + { + ret = SP_ERR_MEM; + goto out_close; + } + if (!(data = malloc((max_data_len + 1) * sizeof(TCHAR)))) + { + ret = SP_ERR_MEM; + goto out_free_value; + } + while ( + 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) + { + data_len = data_size / sizeof(TCHAR); + data[data_len] = '\0'; +#ifdef UNICODE + name_len = WideCharToMultiByte(CP_ACP, 0, data, -1, NULL, 0, NULL, NULL) +#else + name_len = data_len + 1; +#endif + if (!(name = malloc(name_len))) + { + ret = SP_ERR_MEM; + goto out; + } +#ifdef UNICODE + WideCharToMultiByte(CP_ACP, 0, data, -1, name, name_len, NULL, NULL); +#else + strcpy(name, data); +#endif + if (type == REG_SZ && !(list = list_append(list, name))) + { + ret = SP_ERR_MEM; + goto out; + } + index++; + } +out: + free(data); +out_free_value: + free(value); +out_close: + RegCloseKey(key); +out_done: +#endif +#ifdef __APPLE__ + mach_port_t master; + CFMutableDictionaryRef classes; + io_iterator_t iter; + char *path; + io_object_t port; + CFTypeRef cf_path; + Boolean result; + + if (IOMasterPort(MACH_PORT_NULL, &master) != KERN_SUCCESS) + { + ret = SP_ERR_FAIL; + goto out_done; + } + + if (!(classes = IOServiceMatching(kIOSerialBSDServiceValue))) + { + ret = SP_ERR_FAIL; + goto out_done; + } + + CFDictionarySetValue(classes, + CFSTR(kIOSerialBSDTypeKey), CFSTR(kIOSerialBSDAllTypes)); + + if (IOServiceGetMatchingServices(master, classes, &iter) != KERN_SUCCESS) + { + ret = SP_ERR_FAIL; + goto out_done; + } + + if (!(path = malloc(PATH_MAX))) + { + ret = SP_ERR_MEM; + goto out_release; + } + + while ((port = IOIteratorNext(iter))) { + cf_path = IORegistryEntryCreateCFProperty(port, + CFSTR(kIOCalloutDeviceKey), kCFAllocatorDefault, 0); + if (cf_path) { + result = CFStringGetCString(cf_path, + path, PATH_MAX, kCFStringEncodingASCII); + CFRelease(cf_path); + if (result && !(list = list_append(list, path))) + { + ret = SP_ERR_MEM; + IOObjectRelease(port); + goto out; + } + } + IOObjectRelease(port); + } +out: + free(path); +out_release: + IOObjectRelease(iter); +out_done: +#endif +#ifdef __linux__ + struct udev *ud; + struct udev_enumerate *ud_enumerate; + struct udev_list_entry *ud_list; + struct udev_list_entry *ud_entry; + const char *path; + struct udev_device *ud_dev, *ud_parent; + const char *name; + const char *driver; + int fd, ioctl_result; + struct serial_struct serial_info; + + ud = udev_new(); + ud_enumerate = udev_enumerate_new(ud); + udev_enumerate_add_match_subsystem(ud_enumerate, "tty"); + udev_enumerate_scan_devices(ud_enumerate); + ud_list = udev_enumerate_get_list_entry(ud_enumerate); + udev_list_entry_foreach(ud_entry, ud_list) + { + path = udev_list_entry_get_name(ud_entry); + ud_dev = udev_device_new_from_syspath(ud, path); + /* If there is no parent device, this is a virtual tty. */ + ud_parent = udev_device_get_parent(ud_dev); + if (ud_parent == NULL) + { + udev_device_unref(ud_dev); + continue; + } + name = udev_device_get_devnode(ud_dev); + /* The serial8250 driver has a hardcoded number of ports. + * The only way to tell which actually exist on a given system + * is to try to open them and make an ioctl call. */ + driver = udev_device_get_driver(ud_parent); + if (driver && !strcmp(driver, "serial8250")) + { + if ((fd = open(name, O_RDWR | O_NONBLOCK | O_NOCTTY)) < 0) + goto skip; + ioctl_result = ioctl(fd, TIOCGSERIAL, &serial_info); + close(fd); + if (ioctl_result != 0) + goto skip; + if (serial_info.type == PORT_UNKNOWN) + goto skip; + } + list = list_append(list, name); +skip: + udev_device_unref(ud_dev); + if (!list) + { + ret = SP_ERR_MEM; + goto out; + } + } +out: + udev_enumerate_unref(ud_enumerate); + udev_unref(ud); +#endif + + if (ret == SP_OK) + { + *list_ptr = list; + } + else + { + if (list) + sp_free_port_list(list); + + *list_ptr = NULL; + } + + return ret; +} -#include "serialport.h" +void sp_free_port_list(struct sp_port **list) +{ + unsigned int i; -static int sp_validate_port(struct sp_port *port) + for (i = 0; list[i]; i++) + sp_free_port(list[i]); + free(list); +} + +static int validate_port(struct sp_port *port) { if (port == NULL) return 0; @@ -50,31 +411,22 @@ static int sp_validate_port(struct sp_port *port) return 1; } -#define CHECK_PORT() do { if (!sp_validate_port(port)) return SP_ERR_ARG; } while (0) +#define CHECK_PORT() do { if (!validate_port(port)) return SP_ERR_ARG; } while (0) -/** - * Open the specified serial port. - * - * @param port Pointer to empty port structure allocated by caller. - * @param portname Name of port to open. - * @param flags Flags to use when opening the serial port. Possible flags - * are: SP_MODE_RDWR, SP_MODE_RDONLY, SP_MODE_NONBLOCK. - * - * @return SP_OK on success, SP_ERR_FAIL on failure, - * or SP_ERR_ARG if an invalid port or name is passed. - */ -int sp_open(struct sp_port *port, char *portname, int flags) +int sp_open(struct sp_port *port, int flags) { if (!port) return SP_ERR_ARG; - if (!portname) - return SP_ERR_ARG; - - port->name = portname; - #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; @@ -83,12 +435,19 @@ int sp_open(struct sp_port *port, char *portname, 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 port_data data; + struct sp_port_config config; + int ret; + /* Map 'flags' to the OS-specific settings. */ if (flags & SP_MODE_RDWR) flags_local |= O_RDWR; @@ -99,19 +458,39 @@ int sp_open(struct sp_port *port, char *portname, int flags) if ((port->fd = open(port->name, flags_local)) < 0) return SP_ERR_FAIL; + + ret = get_config(port, &data, &config); + + if (ret < 0) + { + sp_close(port); + return ret; + } + + /* 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); + + ret = set_config(port, &data, &config); + + if (ret < 0) + { + sp_close(port); + return ret; + } #endif return SP_OK; } -/** - * Close the specified serial port. - * - * @param port Pointer to port structure. - * - * @return SP_OK on success, SP_ERR_FAIL on failure, - * or SP_ERR_ARG if an invalid port is passed. - */ int sp_close(struct sp_port *port) { CHECK_PORT(); @@ -120,23 +499,17 @@ int sp_close(struct sp_port *port) /* Returns non-zero upon success, 0 upon failure. */ if (CloseHandle(port->hdl) == 0) return SP_ERR_FAIL; + port->hdl = INVALID_HANDLE_VALUE; #else /* Returns 0 upon success, -1 upon failure. */ if (close(port->fd) == -1) return SP_ERR_FAIL; + port->fd = -1; #endif return SP_OK; } -/** - * Flush serial port buffers. - * - * @param port Pointer to port structure. - * - * @return SP_OK on success, SP_ERR_FAIL on failure, - * or SP_ERR_ARG if an invalid port is passed. - */ int sp_flush(struct sp_port *port) { CHECK_PORT(); @@ -153,16 +526,6 @@ int sp_flush(struct sp_port *port) return SP_OK; } -/** - * Write a number of bytes to the specified serial port. - * - * @param port Pointer to port structure. - * @param buf Buffer containing the bytes to write. - * @param count Number of bytes to write. - * - * @return The number of bytes written, SP_ERR_FAIL on failure, - * or SP_ERR_ARG if an invalid port is passed. - */ int sp_write(struct sp_port *port, const void *buf, size_t count) { CHECK_PORT(); @@ -172,6 +535,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; @@ -179,23 +543,14 @@ 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 } -/** - * Read a number of bytes from the specified serial port. - * - * @param port Pointer to port structure. - * @param buf Buffer where to store the bytes that are read. - * @param count The number of bytes to read. - * - * @return The number of bytes read, SP_ERR_FAIL on failure, - * or SP_ERR_ARG if an invalid port is passed. - */ int sp_read(struct sp_port *port, void *buf, size_t count) { CHECK_PORT(); @@ -205,12 +560,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; @@ -218,301 +575,509 @@ int sp_read(struct sp_port *port, void *buf, size_t count) #endif } -/** - * Set serial parameters for the specified serial port. - * - * @param port Pointer to port structure. - * @param baudrate The baudrate to set. - * @param bits The number of data bits to use. - * @param parity The parity setting to use (0 = none, 1 = even, 2 = odd). - * @param stopbits The number of stop bits to use (1 or 2). - * @param flowcontrol The flow control settings to use (0 = none, 1 = RTS/CTS, - * 2 = XON/XOFF). - * - * @return The number of bytes read, SP_ERR_FAIL on failure, - * or SP_ERR_ARG if an invalid argument is passed. - */ -int sp_set_params(struct sp_port *port, int baudrate, - int bits, int parity, int stopbits, - int flowcontrol, int rts, int dtr) +static int get_config(struct sp_port *port, struct port_data *data, struct sp_port_config *config) { - CHECK_PORT(); + unsigned int i; #ifdef _WIN32 - DCB dcb; - - if (!GetCommState(port->hdl, &dcb)) + if (!GetCommState(port->hdl, &data->dcb)) 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; - break; - case 9600: - dcb.BaudRate = CBR_9600; - break; - case 14400: - dcb.BaudRate = CBR_14400; /* Not available on Unix? */ - break; - case 19200: - dcb.BaudRate = CBR_19200; - break; - case 38400: - dcb.BaudRate = CBR_38400; - break; - case 57600: - dcb.BaudRate = CBR_57600; - break; - case 115200: - dcb.BaudRate = CBR_115200; - break; - case 128000: - dcb.BaudRate = CBR_128000; /* Not available on Unix? */ - break; - case 256000: - dcb.BaudRate = CBR_256000; /* Not available on Unix? */ - break; - default: - return SP_ERR_ARG; + for (i = 0; i < NUM_STD_BAUDRATES; i++) { + if (data->dcb.BaudRate == std_baudrates[i].index) { + config->baudrate = std_baudrates[i].value; + break; + } } - switch (stopbits) { - /* Note: There's also ONE5STOPBITS == 1.5 (unneeded so far). */ - case 1: - dcb.StopBits = ONESTOPBIT; + 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: - dcb.StopBits = TWOSTOPBITS; + case TWOSTOPBITS: + config->stopbits = 2; break; default: - return SP_ERR_ARG; + config->stopbits = -1; } - 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; - break; - case SP_PARITY_ODD: - dcb.Parity = ODDPARITY; - break; - default: - return SP_ERR_ARG; + 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; } - if (rts != -1) { - if (rts) - dcb.fRtsControl = RTS_CONTROL_ENABLE; - else - dcb.fRtsControl = RTS_CONTROL_DISABLE; + 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; } - if (dtr != -1) { - if (dtr) - dcb.fDtrControl = DTR_CONTROL_ENABLE; + config->dsr = data->dcb.fOutxDsrFlow ? SP_DSR_FLOW_CONTROL : SP_DSR_IGNORE; + + if (data->dcb.fInX) { + if (data->dcb.fOutX) + config->xon_xoff = SP_XONXOFF_INOUT; + else + config->xon_xoff = SP_XONXOFF_IN; + } else { + if (data->dcb.fOutX) + config->xon_xoff = SP_XONXOFF_OUT; else - dcb.fDtrControl = DTR_CONTROL_DISABLE; + config->xon_xoff = SP_XONXOFF_DISABLED; } - if (!SetCommState(port->hdl, &dcb)) +#else // !_WIN32 + + if (tcgetattr(port->fd, &data->term) < 0) return SP_ERR_FAIL; -#else - struct termios term; - speed_t baud; - int controlbits; - if (tcgetattr(port->fd, &term) < 0) + if (ioctl(port->fd, TIOCMGET, &data->controlbits) < 0) return SP_ERR_FAIL; + for (i = 0; i < NUM_STD_BAUDRATES; i++) { + if (cfgetispeed(&data->term) == std_baudrates[i].index) { + config->baudrate = std_baudrates[i].value; + break; + } + } - switch (baudrate) { - case 50: - baud = B50; - break; - case 75: - baud = B75; - break; - case 110: - baud = B110; - break; - case 134: - baud = B134; - break; - case 150: - baud = B150; - break; - case 200: - baud = B200; - break; - case 300: - baud = B300; - break; - case 600: - baud = B600; - break; - case 1200: - baud = B1200; - break; - case 1800: - baud = B1800; - break; - case 2400: - baud = B2400; - break; - case 4800: - baud = B4800; - break; - case 9600: - baud = B9600; - break; - case 19200: - baud = B19200; - break; - case 38400: - baud = B38400; - break; - case 57600: - baud = B57600; + if (i == NUM_STD_BAUDRATES) + config->baudrate = -1; + + switch (data->term.c_cflag & CSIZE) { + case CS8: + config->bits = 8; break; - case 115200: - baud = B115200; + case CS7: + config->bits = 7; break; - case 230400: - baud = B230400; + case CS6: + config->bits = 6; break; -#if !defined(__APPLE__) && !defined(__OpenBSD__) - case 460800: - baud = B460800; + case CS5: + config->bits = 5; break; -#endif default: - return SP_ERR_ARG; + config->bits = -1; } - if (cfsetospeed(&term, baud) < 0) - return SP_ERR_FAIL; + 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; - if (cfsetispeed(&term, baud) < 0) - return SP_ERR_FAIL; + config->stopbits = (data->term.c_cflag & CSTOPB) ? 2 : 1; - term.c_cflag &= ~CSIZE; - switch (bits) { - case 8: - term.c_cflag |= CS8; - break; - case 7: - term.c_cflag |= CS7; - break; - default: - return SP_ERR_ARG; + 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; } - 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; + config->dtr = (data->controlbits & TIOCM_DTR) ? SP_DTR_ON : SP_DTR_OFF; + config->dsr = SP_DSR_IGNORE; +#endif + + return SP_OK; +} + +static int set_config(struct sp_port *port, struct port_data *data, const struct sp_port_config *config) +{ + unsigned int i; + +#ifdef _WIN32 + if (config->baudrate >= 0) + { + for (i = 0; i < NUM_STD_BAUDRATES; i++) { + if (config->baudrate == std_baudrates[i].value) { + data->dcb.BaudRate = std_baudrates[i].index; + break; + } + } + + if (i == NUM_STD_BAUDRATES) + data->dcb.BaudRate = config->baudrate; } - term.c_iflag &= ~(IXON | IXOFF); - term.c_cflag &= ~CRTSCTS; - switch (flowcontrol) { - case 0: - /* No flow control. */ - break; - case 1: - term.c_cflag |= CRTSCTS; - break; - case 2: - term.c_iflag |= IXON | IXOFF; - break; - default: - return SP_ERR_ARG; + if (config->bits >= 0) + data->dcb.ByteSize = config->bits; + + if (config->parity >= 0) { + switch (config->parity) { + /* Note: There's also SPACEPARITY, MARKPARITY (unneeded so far). */ + case SP_PARITY_NONE: + data->dcb.Parity = NOPARITY; + break; + case SP_PARITY_EVEN: + data->dcb.Parity = EVENPARITY; + break; + case SP_PARITY_ODD: + data->dcb.Parity = ODDPARITY; + break; + default: + return SP_ERR_ARG; + } } - term.c_iflag &= ~IGNPAR; - term.c_cflag &= ~(PARODD | PARENB); - switch (parity) { - case SP_PARITY_NONE: - term.c_iflag |= IGNPAR; - break; - case SP_PARITY_EVEN: - term.c_cflag |= PARENB; - break; - case SP_PARITY_ODD: - term.c_cflag |= PARENB | PARODD; - break; - default: - return SP_ERR_ARG; + if (config->stopbits >= 0) { + switch (config->stopbits) { + /* Note: There's also ONE5STOPBITS == 1.5 (unneeded so far). */ + case 1: + data->dcb.StopBits = ONESTOPBIT; + break; + case 2: + data->dcb.StopBits = TWOSTOPBITS; + break; + default: + return SP_ERR_ARG; + } } - /* 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; -#endif + if (config->rts >= 0) { + switch (config->rts) { + case SP_RTS_OFF: + data->dcb.fRtsControl = RTS_CONTROL_DISABLE; + break; + case SP_RTS_ON: + data->dcb.fRtsControl = RTS_CONTROL_ENABLE; + break; + case SP_RTS_FLOW_CONTROL: + data->dcb.fRtsControl = RTS_CONTROL_HANDSHAKE; + break; + default: + return SP_ERR_ARG; + } + } - /* Disable canonical mode, and don't echo input characters. */ - term.c_lflag &= ~(ICANON | ECHO); + if (config->cts >= 0) { + switch (config->cts) { + case SP_CTS_IGNORE: + data->dcb.fOutxCtsFlow = FALSE; + break; + case SP_CTS_FLOW_CONTROL: + data->dcb.fOutxCtsFlow = TRUE; + break; + default: + return SP_ERR_ARG; + } + } + + if (config->dtr >= 0) { + switch (config->dtr) { + case SP_DTR_OFF: + data->dcb.fDtrControl = DTR_CONTROL_DISABLE; + break; + case SP_DTR_ON: + data->dcb.fDtrControl = DTR_CONTROL_ENABLE; + break; + case SP_DTR_FLOW_CONTROL: + data->dcb.fDtrControl = DTR_CONTROL_HANDSHAKE; + break; + default: + return SP_ERR_ARG; + } + } + + if (config->dsr >= 0) { + switch (config->dsr) { + case SP_DSR_IGNORE: + data->dcb.fOutxDsrFlow = FALSE; + break; + case SP_DSR_FLOW_CONTROL: + data->dcb.fOutxDsrFlow = TRUE; + break; + default: + return SP_ERR_ARG; + } + } + + if (config->xon_xoff >= 0) { + switch (config->xon_xoff) { + case SP_XONXOFF_DISABLED: + data->dcb.fInX = FALSE; + data->dcb.fOutX = FALSE; + break; + case SP_XONXOFF_IN: + data->dcb.fInX = TRUE; + data->dcb.fOutX = FALSE; + break; + case SP_XONXOFF_OUT: + data->dcb.fInX = FALSE; + data->dcb.fOutX = TRUE; + break; + case SP_XONXOFF_INOUT: + data->dcb.fInX = TRUE; + data->dcb.fOutX = TRUE; + break; + default: + return SP_ERR_ARG; + } + } - /* Write the configured settings. */ - if (tcsetattr(port->fd, TCSADRAIN, &term) < 0) + if (!SetCommState(port->hdl, &data->dcb)) return SP_ERR_FAIL; - if (rts != -1) { - controlbits = TIOCM_RTS; - if (ioctl(port->fd, rts ? TIOCMBIS : TIOCMBIC, - &controlbits) < 0) - return SP_ERR_FAIL; +#else // !_WIN32 + + if (config->baudrate >= 0) + { + for (i = 0; i < NUM_STD_BAUDRATES; i++) { + if (config->baudrate == std_baudrates[i].value) { + 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; + break; + } + } + + if (i == NUM_STD_BAUDRATES) + return SP_ERR_ARG; + } + + if (config->bits >= 0) { + data->term.c_cflag &= ~CSIZE; + switch (config->bits) { + case 8: + data->term.c_cflag |= CS8; + break; + case 7: + data->term.c_cflag |= CS7; + break; + case 6: + data->term.c_cflag |= CS6; + break; + default: + return SP_ERR_ARG; + } + } + + if (config->parity >= 0) { + data->term.c_iflag &= ~IGNPAR; + data->term.c_cflag &= ~(PARENB | PARODD); + switch (config->parity) { + case SP_PARITY_NONE: + data->term.c_iflag |= IGNPAR; + break; + case SP_PARITY_EVEN: + data->term.c_cflag |= PARENB; + break; + case SP_PARITY_ODD: + data->term.c_cflag |= PARENB | PARODD; + break; + default: + return SP_ERR_ARG; + } } - if (dtr != -1) { - controlbits = TIOCM_DTR; - if (ioctl(port->fd, dtr ? TIOCMBIS : TIOCMBIC, - &controlbits) < 0) - return SP_ERR_FAIL; + if (config->stopbits >= 0) { + data->term.c_cflag &= ~CSTOPB; + switch (config->stopbits) { + case 1: + data->term.c_cflag &= ~CSTOPB; + break; + case 2: + data->term.c_cflag |= CSTOPB; + break; + default: + return SP_ERR_ARG; + } } + + if (config->rts >= 0 || config->cts >= 0) + { + /* Asymmetric use of RTS/CTS not supported yet. */ + + if (data->term.c_iflag & CRTSCTS) { + /* Flow control can only be disabled for both RTS & CTS together. */ + if (config->rts >= 0 && config->rts != SP_RTS_FLOW_CONTROL) { + if (config->cts != SP_CTS_IGNORE) + return SP_ERR_ARG; + } + if (config->cts >= 0 && config->cts != SP_CTS_FLOW_CONTROL) { + if (config->rts <= 0 || config->rts == SP_RTS_FLOW_CONTROL) + return SP_ERR_ARG; + } + } else { + /* Flow control can only be enabled for both RTS & CTS together. */ + if (((config->rts == SP_RTS_FLOW_CONTROL) && (config->cts != SP_CTS_FLOW_CONTROL)) || + ((config->cts == SP_CTS_FLOW_CONTROL) && (config->rts != SP_RTS_FLOW_CONTROL))) + return SP_ERR_ARG; + } + + if (config->rts >= 0) { + if (config->rts == SP_RTS_FLOW_CONTROL) { + data->term.c_iflag |= CRTSCTS; + } else { + int controlbits = TIOCM_RTS; + if (ioctl(port->fd, config->rts == SP_RTS_ON ? TIOCMBIS : TIOCMBIC, + &controlbits) < 0) + return SP_ERR_FAIL; + } + } + } + + if (config->dtr >= 0 || config->dsr >= 0) + { + /* DTR/DSR flow control not supported yet. */ + if (config->dtr == SP_DTR_FLOW_CONTROL || config->dsr == SP_DSR_FLOW_CONTROL) + return SP_ERR_ARG; + + if (config->dtr >= 0) { + int controlbits = TIOCM_DTR; + if (ioctl(port->fd, config->dtr == SP_DTR_ON ? TIOCMBIS : TIOCMBIC, + &controlbits) < 0) + return SP_ERR_FAIL; + } + } + + if (config->xon_xoff >= 0) { + data->term.c_iflag &= ~(IXON | IXOFF | IXANY); + switch (config->xon_xoff) { + case SP_XONXOFF_DISABLED: + break; + case SP_XONXOFF_IN: + data->term.c_iflag |= IXOFF; + break; + case SP_XONXOFF_OUT: + data->term.c_iflag |= IXON | IXANY; + break; + case SP_XONXOFF_INOUT: + data->term.c_iflag |= IXON | IXOFF | IXANY; + break; + default: + return SP_ERR_ARG; + } + } + + if (tcsetattr(port->fd, TCSADRAIN, &data->term) < 0) + return SP_ERR_FAIL; #endif return SP_OK; } -/** - * Get error code for failed operation. - * - * In order to obtain the correct result, this function should be called - * straight after the failure, before executing any other system operations. - * - * @return The system's numeric code for the error that caused the last - * operation to fail. - */ +#define TRY(x) do { int ret = x; if (ret != SP_OK) return ret; } while (0) + +int sp_set_config(struct sp_port *port, const struct sp_port_config *config) +{ + struct port_data data; + struct sp_port_config prev_config; + + CHECK_PORT(); + + if (!config) + return SP_ERR_ARG; + + TRY(get_config(port, &data, &prev_config)); + TRY(set_config(port, &data, config)); + + return SP_OK; +} + +#define CREATE_SETTER(x) int sp_set_##x(struct sp_port *port, int x) { \ + struct port_data data; \ + struct sp_port_config config; \ + CHECK_PORT(); \ + TRY(get_config(port, &data, &config)); \ + config.x = x; \ + TRY(set_config(port, &data, &config)); \ + 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_set_flowcontrol(struct sp_port *port, int flowcontrol) +{ + struct port_data data; + struct sp_port_config config; + + CHECK_PORT(); + + TRY(get_config(port, &data, &config)); + + if (flowcontrol == SP_FLOWCONTROL_XONXOFF) + config.xon_xoff = SP_XONXOFF_INOUT; + else + config.xon_xoff = SP_XONXOFF_DISABLED; + + if (flowcontrol == SP_FLOWCONTROL_RTSCTS) { + config.rts = SP_RTS_FLOW_CONTROL; + config.cts = SP_CTS_FLOW_CONTROL; + } else { + if (config.rts == SP_RTS_FLOW_CONTROL) + config.rts = SP_RTS_ON; + config.cts = SP_CTS_IGNORE; + } + + if (flowcontrol == SP_FLOWCONTROL_DTRDSR) { + config.dtr = SP_DTR_FLOW_CONTROL; + config.dsr = SP_DSR_FLOW_CONTROL; + } else { + if (config.dtr == SP_DTR_FLOW_CONTROL) + config.dtr = SP_DTR_ON; + config.dsr = SP_DSR_IGNORE; + } + + TRY(set_config(port, &data, &config)); + + return SP_OK; +} + int sp_last_error_code(void) { #ifdef _WIN32 @@ -522,16 +1087,6 @@ int sp_last_error_code(void) #endif } -/** - * Get error message for failed operation. - * - * In order to obtain the correct result, this function should be called - * straight after the failure, before executing other system operations. - * - * @return The system's message for the error that caused the last - * operation to fail. This string may be allocated by the function, - * and can be freed after use by calling sp_free_error_message. - */ char *sp_last_error_message(void) { #ifdef _WIN32 @@ -554,15 +1109,11 @@ char *sp_last_error_message(void) #endif } -/** - * Free error message. - * - * This function can be used to free a string returned by the - * sp_last_error_message function. - */ void sp_free_error_message(char *message) { #ifdef _WIN32 LocalFree(message); +#else + (void)message; #endif }