summaryrefslogtreecommitdiffstats
path: root/serial_ftdi.c
diff options
context:
space:
mode:
Diffstat (limited to 'serial_ftdi.c')
-rw-r--r--serial_ftdi.c671
1 files changed, 671 insertions, 0 deletions
diff --git a/serial_ftdi.c b/serial_ftdi.c
new file mode 100644
index 000000000..6019bfe84
--- /dev/null
+++ b/serial_ftdi.c
@@ -0,0 +1,671 @@
+/*
+ * libdivecomputer
+ *
+ * Copyright (C) 2008 Jef Driesen
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301 USA
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h> // malloc, free
+#include <string.h> // strerror
+#include <errno.h> // errno
+#include <sys/time.h> // gettimeofday
+#include <time.h> // nanosleep
+#include <stdio.h>
+
+#include <libusb.h>
+#include <ftdi.h>
+
+#include "serial.h"
+#include "context-private.h"
+
+#define MODEM_DCD 0b10000000
+#define MODEM_RNG 0b01000000
+#define MODEM_DSR 0b00100000
+#define MODEM_CTS 0b00010000
+
+#define VID 0x0403 // Vendor ID of FTDI
+
+#define MAX_BACKOFF 500 // Max milliseconds to wait before timing out.
+
+struct serial_t {
+ /* Library ftdi_ctx. */
+ dc_context_t *context;
+ /*
+ * The file descriptor corresponding to the serial port.
+ * Also a libftdi_ftdi_ctx could be used?
+ */
+ struct ftdi_context *ftdi_ctx;
+ long timeout;
+ /*
+ * Serial port settings are saved into this variable immediately
+ * after the port is opened. These settings are restored when the
+ * serial port is closed.
+ * Saving this using libftdi context or libusb. Search further.
+ * Custom implementation using libftdi functions could be done.
+ */
+
+ /* Half-duplex settings */
+ int halfduplex;
+ unsigned int baudrate;
+ unsigned int nbits;
+};
+
+// Used internally for opening ftdi devices
+int
+open_ftdi_device (struct ftdi_context *ftdi_ctx)
+{
+ int accepted_pids[] = { 0x6001, 0x6010, 0x6011, // Suunto (Smart Interface), Heinrichs Weikamp
+ 0xF460, // Oceanic
+ 0xF680, // Suunto
+ 0x87D0, // Cressi (Leonardo)
+ };
+ int num_accepted_pids = 6;
+ int i, pid, ret;
+ for (i = 0; i < num_accepted_pids; i++) {
+ pid = accepted_pids[i];
+ ret = ftdi_usb_open (ftdi_ctx, VID, pid);
+ if (ret == -3) // Device not found
+ continue;
+ else
+ return ret;
+ }
+ // No supported devices are attached.
+ return ret;
+}
+
+int
+serial_enumerate (serial_callback_t callback, void *userdata)
+{
+ // Unimplemented.
+ return -1;
+}
+
+
+//
+// Open the serial port.
+// Initialise ftdi_context and use it to open the device
+//
+
+int
+serial_open (serial_t **out, dc_context_t *context, const char* name)
+{
+ if (out == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ INFO (context, "Open: name=%s", name ? name : "");
+
+ // Allocate memory.
+ serial_t *device = (serial_t *) malloc (sizeof (serial_t));
+ if (device == NULL) {
+ SYSERROR (context, errno);
+ return -1; // ENOMEM (Not enough space)
+ }
+
+ struct ftdi_context *ftdi_ctx = ftdi_new();
+ if (ftdi_ctx == NULL) {
+ SYSERROR (context, errno);
+ return -1; // ENOMEM (Not enough space)
+ }
+
+ // Library context.
+ device->context = context;
+
+ // Default to blocking reads.
+ device->timeout = -1;
+
+ // Default to full-duplex.
+ device->halfduplex = 0;
+ device->baudrate = 0;
+ device->nbits = 0;
+
+ // Initialize device ftdi context
+ ftdi_init(ftdi_ctx);
+
+ if (ftdi_set_interface(ftdi_ctx,INTERFACE_ANY)) {
+ ERROR (context, ftdi_get_error_string(ftdi_ctx));
+ return -1;
+ }
+
+ if (open_ftdi_device(ftdi_ctx) < 0) {
+ ERROR (context, ftdi_get_error_string(ftdi_ctx));
+ return -1;
+ }
+
+ if (ftdi_usb_reset(ftdi_ctx)) {
+ ERROR (context, ftdi_get_error_string(ftdi_ctx));
+ return -1;
+ }
+
+ if (ftdi_usb_purge_buffers(ftdi_ctx)) {
+ ERROR (context, ftdi_get_error_string(ftdi_ctx));
+ return -1;
+ }
+
+ device->ftdi_ctx = ftdi_ctx;
+ *out = device;
+
+ return 0;
+}
+
+//
+// Close the serial port.
+//
+
+int
+serial_close (serial_t *device)
+{
+ if (device == NULL)
+ return 0;
+
+ // Restore the initial terminal attributes.
+ // See if it is possible using libusb or libftdi
+
+ int ret = ftdi_usb_close(device->ftdi_ctx);
+ if (ret < 0) {
+ ERROR (device->context, "Unable to close the ftdi device : %d (%s)\n",
+ ret, ftdi_get_error_string(device->ftdi_ctx));
+ return ret;
+ }
+
+ ftdi_free(device->ftdi_ctx);
+
+ // Free memory.
+ free (device);
+
+ return 0;
+}
+
+//
+// Configure the serial port (baudrate, databits, parity, stopbits and flowcontrol).
+//
+
+int
+serial_configure (serial_t *device, int baudrate, int databits, int parity, int stopbits, int flowcontrol)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ INFO (device->context, "Configure: baudrate=%i, databits=%i, parity=%i, stopbits=%i, flowcontrol=%i",
+ baudrate, databits, parity, stopbits, flowcontrol);
+
+ enum ftdi_bits_type ft_bits;
+ enum ftdi_stopbits_type ft_stopbits;
+ enum ftdi_parity_type ft_parity;
+
+ if (ftdi_set_baudrate(device->ftdi_ctx, baudrate) < 0) {
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1;
+ }
+
+ // Set the character size.
+ switch (databits) {
+ case 7:
+ ft_bits = BITS_7;
+ break;
+ case 8:
+ ft_bits = BITS_8;
+ break;
+ default:
+ return -1;
+ }
+
+ // Set the parity type.
+ switch (parity) {
+ case SERIAL_PARITY_NONE: // No parity
+ ft_parity = NONE;
+ break;
+ case SERIAL_PARITY_EVEN: // Even parity
+ ft_parity = EVEN;
+ break;
+ case SERIAL_PARITY_ODD: // Odd parity
+ ft_parity = ODD;
+ break;
+ default:
+
+ return -1;
+ }
+
+ // Set the number of stop bits.
+ switch (stopbits) {
+ case 1: // One stopbit
+ ft_stopbits = STOP_BIT_1;
+ break;
+ case 2: // Two stopbits
+ ft_stopbits = STOP_BIT_2;
+ break;
+ default:
+ return -1;
+ }
+
+ // Set the attributes
+ if (ftdi_set_line_property(device->ftdi_ctx, ft_bits, ft_stopbits, ft_parity)) {
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1;
+ }
+
+ // Set the flow control.
+ switch (flowcontrol) {
+ case SERIAL_FLOWCONTROL_NONE: // No flow control.
+ if (ftdi_setflowctrl(device->ftdi_ctx, SIO_DISABLE_FLOW_CTRL) < 0) {
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1;
+ }
+ break;
+ case SERIAL_FLOWCONTROL_HARDWARE: // Hardware (RTS/CTS) flow control.
+ if (ftdi_setflowctrl(device->ftdi_ctx, SIO_RTS_CTS_HS) < 0) {
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1;
+ }
+ break;
+ case SERIAL_FLOWCONTROL_SOFTWARE: // Software (XON/XOFF) flow control.
+ if (ftdi_setflowctrl(device->ftdi_ctx, SIO_XON_XOFF_HS) < 0) {
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1;
+ }
+ break;
+ default:
+ return -1;
+ }
+
+ device->baudrate = baudrate;
+ device->nbits = 1 + databits + stopbits + (parity ? 1 : 0);
+
+ return 0;
+}
+
+//
+// Configure the serial port (timeouts).
+//
+
+int
+serial_set_timeout (serial_t *device, long timeout)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ INFO (device->context, "Timeout: value=%li", timeout);
+
+ device->timeout = timeout;
+
+ return 0;
+}
+
+
+//
+// Configure the serial port (recommended size of the input/output buffers).
+//
+
+int
+serial_set_queue_size (serial_t *device, unsigned int input, unsigned int output)
+{
+ if (device == NULL)
+ return -1; // ERROR_INVALID_PARAMETER (The parameter is incorrect)
+
+ ftdi_read_data_set_chunksize(device->ftdi_ctx, output);
+ ftdi_write_data_set_chunksize(device->ftdi_ctx, input);
+
+ return 0;
+}
+
+
+int
+serial_set_halfduplex (serial_t *device, int value)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ // Most ftdi chips support full duplex operation. ft232rl does.
+ // Crosscheck other chips.
+
+ device->halfduplex = value;
+
+ return 0;
+}
+
+int
+serial_set_latency (serial_t *device, unsigned int milliseconds)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ // Default for ftdi device is 16ms and can be set in the range
+ // 1 - 255 ms with 1ms least count.
+
+ if (milliseconds < 1 || milliseconds > 255)
+ return -1;
+ ftdi_set_latency_timer(device->ftdi_ctx, milliseconds);
+
+ return 0;
+}
+
+int
+serial_read (serial_t *device, void *data, unsigned int size)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ // The total timeout.
+ long timeout = device->timeout;
+
+ // The absolute target time.
+ struct timeval tve;
+
+ static int backoff = 1;
+ int init = 1;
+ unsigned int nbytes = 0;
+ while (nbytes < size) {
+ struct timeval tvt;
+ if (timeout > 0) {
+ struct timeval now;
+ if (gettimeofday (&now, NULL) != 0) {
+ SYSERROR (device->context, errno);
+ return -1;
+ }
+
+ if (init) {
+ // Calculate the initial timeout.
+ tvt.tv_sec = (timeout / 1000);
+ tvt.tv_usec = (timeout % 1000) * 1000;
+ // Calculate the target time.
+ timeradd (&now, &tvt, &tve);
+ } else {
+ // Calculate the remaining timeout.
+ if (timercmp (&now, &tve, <))
+ timersub (&tve, &now, &tvt);
+ else
+ timerclear (&tvt);
+ }
+ init = 0;
+ } else if (timeout == 0) {
+ timerclear (&tvt);
+ }
+
+ int n = ftdi_read_data (device->ftdi_ctx, (char *) data + nbytes, size - nbytes);
+ if (n < 0) {
+ if (n == LIBUSB_ERROR_INTERRUPTED)
+ continue; //Retry.
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1; //Error during read call.
+ } else if (n == 0) {
+ // Exponential backoff.
+ if (backoff > MAX_BACKOFF) {
+ ERROR(device->context, "FTDI read timed out.");
+ return -1;
+ }
+ serial_sleep(device, backoff);
+ backoff *= 2;
+ } else {
+ // Reset backoff to 1 on success.
+ backoff = 1;
+ }
+
+ nbytes += n;
+ }
+
+ HEXDUMP (device->context, DC_LOGLEVEL_INFO, "Read", (unsigned char *) data, nbytes);
+
+ return nbytes;
+}
+
+
+int
+serial_write (serial_t *device, const void *data, unsigned int size)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ struct timeval tve, tvb;
+ if (device->halfduplex) {
+ // Get the current time.
+ if (gettimeofday (&tvb, NULL) != 0) {
+ SYSERROR (device->context, errno);
+ return -1;
+ }
+ }
+
+ unsigned int nbytes = 0;
+ while (nbytes < size) {
+
+ int n = ftdi_write_data (device->ftdi_ctx, (char *) data + nbytes, size - nbytes);
+ if (n < 0) {
+ if (n == LIBUSB_ERROR_INTERRUPTED)
+ continue; // Retry.
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1; // Error during write call.
+ } else if (n == 0) {
+ break; // EOF.
+ }
+
+ nbytes += n;
+ }
+
+ if (device->halfduplex) {
+ // Get the current time.
+ if (gettimeofday (&tve, NULL) != 0) {
+ SYSERROR (device->context, errno);
+ return -1;
+ }
+
+ // Calculate the elapsed time (microseconds).
+ struct timeval tvt;
+ timersub (&tve, &tvb, &tvt);
+ unsigned long elapsed = tvt.tv_sec * 1000000 + tvt.tv_usec;
+
+ // Calculate the expected duration (microseconds). A 2 millisecond fudge
+ // factor is added because it improves the success rate significantly.
+ unsigned long expected = 1000000.0 * device->nbits / device->baudrate * size + 0.5 + 2000;
+
+ // Wait for the remaining time.
+ if (elapsed < expected) {
+ unsigned long remaining = expected - elapsed;
+
+ // The remaining time is rounded up to the nearest millisecond to
+ // match the Windows implementation. The higher resolution is
+ // pointless anyway, since we already added a fudge factor above.
+ serial_sleep (device, (remaining + 999) / 1000);
+ }
+ }
+
+ HEXDUMP (device->context, DC_LOGLEVEL_INFO, "Write", (unsigned char *) data, nbytes);
+
+ return nbytes;
+}
+
+
+int
+serial_flush (serial_t *device, int queue)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ INFO (device->context, "Flush: queue=%u, input=%i, output=%i", queue,
+ serial_get_received (device),
+ serial_get_transmitted (device));
+
+ switch (queue) {
+ case SERIAL_QUEUE_INPUT:
+ if (ftdi_usb_purge_tx_buffer(device->ftdi_ctx)) {
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1;
+ }
+ break;
+ case SERIAL_QUEUE_OUTPUT:
+ if (ftdi_usb_purge_rx_buffer(device->ftdi_ctx)) {
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1;
+ }
+ break;
+ default:
+ if (ftdi_usb_purge_buffers(device->ftdi_ctx)) {
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1;
+ }
+ break;
+ }
+
+ return 0;
+}
+
+
+int
+serial_send_break (serial_t *device)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)a
+
+ INFO (device->context, "Break : One time period.");
+
+ // no direct functions for sending break signals in libftdi.
+ // there is a suggestion to lower the baudrate and sending NUL
+ // and resetting the baudrate up again. But it has flaws.
+ // Not implementing it before researching more.
+
+ return -1;
+}
+
+
+int
+serial_set_break (serial_t *device, int level)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ INFO (device->context, "Break: value=%i", level);
+
+ // Not implemented in libftdi yet. Research it further.
+
+ return -1;
+}
+
+
+int
+serial_set_dtr (serial_t *device, int level)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ INFO (device->context, "DTR: value=%i", level);
+
+ if (ftdi_setdtr(device->ftdi_ctx, level)) {
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1;
+ }
+
+ return 0;
+}
+
+
+int
+serial_set_rts (serial_t *device, int level)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ INFO (device->context, "RTS: value=%i", level);
+
+ if (ftdi_setrts(device->ftdi_ctx, level)) {
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1;
+ }
+
+ return 0;
+}
+
+
+int
+serial_get_received (serial_t *device)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ // Direct access is not encouraged. But function implementation
+ // is not available. The return quantity might be anything.
+ // Find out further about its possible values and correct way of
+ // access.
+ int bytes = device->ftdi_ctx->readbuffer_remaining;
+
+ return bytes;
+}
+
+
+int
+serial_get_transmitted (serial_t *device)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ // This is not possible using libftdi. Look further into it.
+ return -1;
+}
+
+
+int
+serial_get_line (serial_t *device, int line)
+{
+ if (device == NULL)
+ return -1; // EINVAL (Invalid argument)
+
+ unsigned short int status[2] = {0};
+
+ if(ftdi_poll_modem_status(device->ftdi_ctx, status)) {
+ ERROR (device->context, ftdi_get_error_string(device->ftdi_ctx));
+ return -1;
+ }
+
+ switch (line) {
+ case SERIAL_LINE_DCD:
+ return (status[0] & MODEM_DCD) == MODEM_DCD;
+ case SERIAL_LINE_CTS:
+ return (status[0] & MODEM_CTS) == MODEM_CTS;
+ case SERIAL_LINE_DSR:
+ return (status[0] & MODEM_DSR) == MODEM_DSR;
+ case SERIAL_LINE_RNG:
+ return (status[0] & MODEM_RNG) == MODEM_RNG;
+ default:
+ return -1;
+ }
+
+ return 0;
+}
+
+
+int
+serial_sleep (serial_t *device, unsigned long timeout)
+{
+ if (device == NULL)
+ return -1;
+
+ INFO (device->context, "Sleep: value=%lu", timeout);
+
+ struct timespec ts;
+ ts.tv_sec = (timeout / 1000);
+ ts.tv_nsec = (timeout % 1000) * 1000000;
+
+ while (nanosleep (&ts, &ts) != 0) {
+ if (errno != EINTR ) {
+ SYSERROR (device->context, errno);
+ return -1;
+ }
+ }
+
+
+ return 0;
+}
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-12-27 22:48:49 +0000