* Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
* Copyright (C) 2010-2012 Uwe Hermann <uwe@hermann-uwe.de>
* Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
+ * Copyright (C) 2014 Uffe Jakobsen <uffe@uffe.org>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
*
* @param serial Previously initialized serial port structure.
* @param[in] flags Flags to use when opening the serial port. Possible flags
- * include SERIAL_RDWR, SERIAL_RDONLY, SERIAL_NONBLOCK.
+ * include SERIAL_RDWR, SERIAL_RDONLY.
*
* If the serial structure contains a serialcomm string, it will be
* passed to serial_set_paramstr() after the port is opened.
else if (flags & SERIAL_RDONLY)
sp_flags = SP_MODE_READ;
- serial->nonblocking = (flags & SERIAL_NONBLOCK) ? 1 : 0;
-
ret = sp_open(serial->data, sp_flags);
switch (ret) {
return SR_OK;
}
+/**
+ * Drain serial port buffers.
+ *
+ * @param serial Previously initialized serial port structure.
+ *
+ * @retval SR_OK Success.
+ * @retval SR_ERR Failure.
+ */
+SR_PRIV int serial_drain(struct sr_serial_dev_inst *serial)
+{
+ int ret;
+ char *error;
+
+ if (!serial) {
+ sr_dbg("Invalid serial port.");
+ return SR_ERR;
+ }
+
+ if (!serial->data) {
+ sr_dbg("Cannot drain unopened serial port %s.", serial->port);
+ return SR_ERR;
+ }
+
+ sr_spew("Draining serial port %s.", serial->port);
+
+ ret = sp_drain(serial->data);
+
+ if (ret == SP_ERR_FAIL) {
+ error = sp_last_error_message();
+ sr_err("Error draining port (%d): %s.",
+ sp_last_error_code(), error);
+ sp_free_error_message(error);
+ return SR_ERR;
+ }
+
+ return SR_OK;
+}
+
static int _serial_write(struct sr_serial_dev_inst *serial,
- const void *buf, size_t count, int nonblocking)
+ const void *buf, size_t count, int nonblocking, unsigned int timeout_ms)
{
ssize_t ret;
char *error;
if (nonblocking)
ret = sp_nonblocking_write(serial->data, buf, count);
else
- ret = sp_blocking_write(serial->data, buf, count, 0);
+ ret = sp_blocking_write(serial->data, buf, count, timeout_ms);
switch (ret) {
case SP_ERR_ARG:
}
/**
- * Write a number of bytes to the specified serial port.
+ * Write a number of bytes to the specified serial port, blocking until finished.
*
* @param serial Previously initialized serial port structure.
* @param[in] buf Buffer containing the bytes to write.
* @param[in] count Number of bytes to write.
+ * @param[in] timeout_ms Timeout in ms, or 0 for no timeout.
*
* @retval SR_ERR_ARG Invalid argument.
* @retval SR_ERR Other error.
- * @retval other The number of bytes written.
- */
-SR_PRIV int serial_write(struct sr_serial_dev_inst *serial,
- const void *buf, size_t count)
-{
- return _serial_write(serial, buf, count, serial->nonblocking);
-}
-
-/**
- * Write a number of bytes to the specified serial port, blocking until finished.
- * @copydetails serial_write()
+ * @retval other The number of bytes written. If this is less than the number
+ * specified in the call, the timeout was reached.
*/
SR_PRIV int serial_write_blocking(struct sr_serial_dev_inst *serial,
- const void *buf, size_t count)
+ const void *buf, size_t count, unsigned int timeout_ms)
{
- return _serial_write(serial, buf, count, 0);
+ return _serial_write(serial, buf, count, 0, timeout_ms);
}
/**
* Write a number of bytes to the specified serial port, return immediately.
- * @copydetails serial_write()
+ *
+ * @param serial Previously initialized serial port structure.
+ * @param[in] buf Buffer containing the bytes to write.
+ * @param[in] count Number of bytes to write.
+ *
+ * @retval SR_ERR_ARG Invalid argument.
+ * @retval SR_ERR Other error.
+ * @retval other The number of bytes written.
*/
SR_PRIV int serial_write_nonblocking(struct sr_serial_dev_inst *serial,
const void *buf, size_t count)
{
- return _serial_write(serial, buf, count, 1);
+ return _serial_write(serial, buf, count, 1, 0);
}
static int _serial_read(struct sr_serial_dev_inst *serial, void *buf,
- size_t count, int nonblocking)
+ size_t count, int nonblocking, unsigned int timeout_ms)
{
ssize_t ret;
char *error;
if (nonblocking)
ret = sp_nonblocking_read(serial->data, buf, count);
else
- ret = sp_blocking_read(serial->data, buf, count, 0);
+ ret = sp_blocking_read(serial->data, buf, count, timeout_ms);
switch (ret) {
case SP_ERR_ARG:
}
/**
- * Read a number of bytes from the specified serial port.
+ * Read a number of bytes from the specified serial port, block until finished.
*
* @param serial Previously initialized serial port structure.
* @param buf Buffer where to store the bytes that are read.
* @param[in] count The number of bytes to read.
+ * @param[in] timeout_ms Timeout in ms, or 0 for no timeout.
*
* @retval SR_ERR_ARG Invalid argument.
* @retval SR_ERR Other error.
- * @retval other The number of bytes read.
- */
-SR_PRIV int serial_read(struct sr_serial_dev_inst *serial, void *buf,
- size_t count)
-{
- return _serial_read(serial, buf, count, serial->nonblocking);
-}
-
-/**
- * Read a number of bytes from the specified serial port, block until finished.
- * @copydetails serial_read()
+ * @retval other The number of bytes read. If this is less than the number
+ * requested, the timeout was reached.
*/
SR_PRIV int serial_read_blocking(struct sr_serial_dev_inst *serial, void *buf,
- size_t count)
+ size_t count, unsigned int timeout_ms)
{
- return _serial_read(serial, buf, count, 0);
+ return _serial_read(serial, buf, count, 0, timeout_ms);
}
/**
* Try to read up to @a count bytes from the specified serial port, return
* immediately with what's available.
- * @copydetails serial_read()
+ *
+ * @param serial Previously initialized serial port structure.
+ * @param buf Buffer where to store the bytes that are read.
+ * @param[in] count The number of bytes to read.
+ *
+ * @retval SR_ERR_ARG Invalid argument.
+ * @retval SR_ERR Other error.
+ * @retval other The number of bytes read.
*/
SR_PRIV int serial_read_nonblocking(struct sr_serial_dev_inst *serial, void *buf,
size_t count)
{
- return _serial_read(serial, buf, count, 1);
+ return _serial_read(serial, buf, count, 1, 0);
}
/**
SR_PRIV int serial_readline(struct sr_serial_dev_inst *serial, char **buf,
int *buflen, gint64 timeout_ms)
{
- gint64 start;
+ gint64 start, remaining;
int maxlen, len;
if (!serial) {
return -1;
}
- timeout_ms *= 1000;
start = g_get_monotonic_time();
+ remaining = timeout_ms;
maxlen = *buflen;
*buflen = len = 0;
len = maxlen - *buflen - 1;
if (len < 1)
break;
- len = serial_read(serial, *buf + *buflen, 1);
+ len = sp_blocking_read(serial->data, *buf + *buflen, 1, remaining);
if (len > 0) {
*buflen += len;
*(*buf + *buflen) = '\0';
break;
}
}
- if (g_get_monotonic_time() - start > timeout_ms)
+ /* Reduce timeout by time elapsed. */
+ remaining = timeout_ms - ((g_get_monotonic_time() - start) / 1000);
+ if (remaining <= 0)
/* Timeout */
break;
if (len < 1)
switch (src->key) {
case SR_CONF_CONN:
*serial_device = g_variant_get_string(src->data, NULL);
- sr_dbg("Parsed serial device: %s", *serial_device);
+ sr_dbg("Parsed serial device: %s.", *serial_device);
break;
-
case SR_CONF_SERIALCOMM:
*serial_options = g_variant_get_string(src->data, NULL);
- sr_dbg("Parsed serial options: %s", *serial_options);
+ sr_dbg("Parsed serial options: %s.", *serial_options);
break;
}
}
if (!*serial_device) {
- sr_dbg("No serial device specified");
+ sr_dbg("No serial device specified.");
return SR_ERR;
}
return SR_OK;
}
+/**
+ * Create/allocate a new sr_serial_port structure.
+ *
+ * @param name The OS dependent name of the serial port. Must not be NULL.
+ * @param description An end user friendly description for the serial port.
+ * Can be NULL (in that case the empty string is used
+ * as description).
+ *
+ * @return The newly allocated sr_serial_port struct.
+ */
+static struct sr_serial_port *sr_serial_new(const char *name,
+ const char *description)
+{
+ struct sr_serial_port *serial;
+
+ if (!name)
+ return NULL;
+
+ serial = g_malloc(sizeof(struct sr_serial_port));
+ serial->name = g_strdup(name);
+ serial->description = g_strdup(description ? description : "");
+
+ return serial;
+}
+
+/**
+ * Free a previously allocated sr_serial_port structure.
+ *
+ * @param serial The sr_serial_port struct to free. Must not be NULL.
+ */
+SR_API void sr_serial_free(struct sr_serial_port *serial)
+{
+ if (!serial)
+ return;
+ g_free(serial->name);
+ g_free(serial->description);
+ g_free(serial);
+}
+
+/**
+ * List available serial devices.
+ *
+ * @return A GSList of strings containing the path of the serial devices or
+ * NULL if no serial device is found. The returned list must be freed
+ * by the caller.
+ */
+SR_API GSList *sr_serial_list(const struct sr_dev_driver *driver)
+{
+ GSList *tty_devs = NULL;
+ struct sp_port **ports;
+ struct sr_serial_port *port;
+ int i;
+
+ /* Currently unused, but will be used by some drivers later on. */
+ (void)driver;
+
+ if (sp_list_ports(&ports) != SP_OK)
+ return NULL;
+
+ for (i = 0; ports[i]; i++) {
+ port = sr_serial_new(sp_get_port_name(ports[i]),
+ sp_get_port_description(ports[i]));
+ tty_devs = g_slist_append(tty_devs, port);
+ }
+
+ sp_free_port_list(ports);
+
+ return tty_devs;
+}
+
/**
* Find USB serial devices via the USB vendor ID and product ID.
*
if (sp_list_ports(&ports) != SP_OK)
return NULL;
- for (i=0; ports[i]; i++)
+ for (i = 0; ports[i]; i++)
if (sp_get_port_transport(ports[i]) == SP_TRANSPORT_USB &&
sp_get_port_usb_vid_pid(ports[i], &vid, &pid) == SP_OK &&
- vid == vendor_id && pid == product_id)
+ vid == vendor_id && pid == product_id) {
tty_devs = g_slist_prepend(tty_devs,
- g_strdup(sp_get_port_name(ports[i])));
+ g_strdup(sp_get_port_name(ports[i])));
+ }
sp_free_port_list(ports);
+
return tty_devs;
}
+
+SR_PRIV int serial_timeout(struct sr_serial_dev_inst *port, int num_bytes)
+{
+ struct sp_port_config *config;
+ int timeout_ms, bits, baud, tmp;
+
+ /* Default to 1s. */
+ timeout_ms = 1000;
+
+ if (sp_new_config(&config) < 0)
+ return timeout_ms;
+
+ bits = baud = 0;
+ do {
+ if (sp_get_config(port->data, config) < 0)
+ break;
+
+ /* Start bit. */
+ bits = 1;
+ if (sp_get_config_bits(config, &tmp) < 0)
+ break;
+ bits += tmp;
+ if (sp_get_config_stopbits(config, &tmp) < 0)
+ break;
+ bits += tmp;
+ if (sp_get_config_baudrate(config, &tmp) < 0)
+ break;
+ baud = tmp;
+ } while (FALSE);
+
+ if (bits && baud) {
+ /* Throw in 10ms for misc OS overhead. */
+ timeout_ms = 10;
+ timeout_ms += ((1000.0 / baud) * bits) * num_bytes;
+ }
+
+ sp_free_config(config);
+
+ return timeout_ms;
+}