--- /dev/null
+/* purge_test.c
+ *
+ * Test for purge TX/RX functions.
+ *
+ * The chip must be wired to loop TX data to RX data (loopback).
+ *
+ * This program works with "standard" linux drivers and the FTDI1 library.
+ *
+ * Usage: purge_test [-b baud] [-i interface] [-n msg-size] [-N note] device-specifier
+ * See usage below for more information on command usage.
+ *
+ * This program works well with the FT4231H which is newer and has large
+ * FIFOs. This program does not work well with FT232, either pre or post
+ * switching the SIO_RESET_PURGE_TX/SIO_RESET_PURGE_RX values.
+ *
+ * This needs testing with other devices, which I do not have.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <signal.h>
+#include <errno.h>
+/* Prevent deprecated messages when building library */
+#define _FTDI_DISABLE_DEPRECATED
+#include <ftdi.h>
+
+#include <termios.h> // For baudcodes & linux UARTs
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+
+static struct ftdi_context *ftdi = NULL;
+static int dev_fd = -1;
+static char * dev_string = NULL;
+static int latency_specified = 0;
+static int latency = 5;
+static int baud = 9600;
+static int baud_code = -1;
+static enum ftdi_interface interface = INTERFACE_A;
+static int msg_size = 80;
+static int broken_purge_test = 0;
+
+static const int latency_min = 2;
+static const int latency_max = 255;
+
+static volatile long long usec_test_start;
+
+
+
+static int ascii2int(const char * str, const char * pgm_name);
+static int baud_2_baud_code(int baud);
+static long int char_cnt_2_usec(int char_count);
+static long int drain();
+static int flush(int queue_selector);
+static long long int get_time_usec();
+
+static const int flushQueueSelector[] = {
+ TCIFLUSH, TCOFLUSH, TCIOFLUSH }; /* See /usr/include/bits/termios.h */
+static const char * flushTestName[] = {
+ "Input-only", "Output-only", "Input+Output" };
+static const char * expected[] = {
+ "last portion of message",
+ "first portion of message",
+ "mid-message characters",
+};
+
+
+static const char * chip_types[] = {
+ "am",
+ "bm",
+ "2232C",
+ "R",
+ "2232H",
+ "4232H",
+ "232H",
+ "230X",
+};
+
+#ifndef ARRAY_SIZE
+# define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
+#endif
+
+
+
+/**********************************************************************
+ */
+static void
+usage(const char *argv0)
+{
+ fprintf(stderr,
+ "Usage: %s [options...] device-specifier\n"
+ "Flush test for UARTS.\n"
+ " with loopback connector\n"
+ " [-b baud] baud rate (e.g., 300, 600, 1200, ...230400)\n"
+ " [-i {a|b|c|d}] FTDI interface for chips which have multiple UARTS\n"
+ " [-l latency] Latency (%d..%d)\n"
+ " [-n msg-size] Number of bytes in test message\n"
+ " [-N note] Note for the output\n"
+ " [-P] Use broken libftdi1 purge methods (over new flush)\n"
+ "\n"
+ " device-specifier String specifying the UART. If the first character\n"
+ " is the '/' character, the program assumes a Linux UART\n"
+ " is to be tested and the string would be something like\n"
+ " '/dev/ttyS0' or '/dev/ttyUSB0'. Otherwise, the program\n"
+ " assumes an FTDI device is being tested with the FTDI1\n"
+ " library. The device-specifier must be a string\n"
+ " accepted by the ftdi_usb_open_string function. An\n"
+ " example would be 'i:0x0403:0x6011[:index]'.\n"
+ "\n"
+ "NOTE: To function correctly, this program requires a loopback connector\n"
+ " attached to the UART under test.\n"
+ "\n"
+ "Adapted from stream_test.c 2018. Eric Schott <els6@psu.edu>\n"
+ "Copyright (C) 2009 Micah Dowty <micah@navi.cx>\n"
+ "Adapted for use with libftdi (C) 2010 Uwe Bonnes <bon@elektron.ikp.physik.tu-darmstadt.de>\n",
+ argv0, latency_min, latency_max);
+ exit(1);
+}
+
+
+/**********************************************************************
+ */
+int main(int argc, char **argv)
+{
+ int c, i;
+ int option_index;
+ int test;
+ unsigned char * msg;
+ unsigned char * retMsg;
+ char * note = NULL;
+ char * note_default = NULL;
+ size_t retMsgSize;
+ long int msg_xmit_time_us;
+ static struct option long_options[] = {{NULL},};
+
+ while ((c = getopt_long(argc, argv, "n:b:i:l:N:P", long_options, &option_index)) !=- 1)
+ switch (c)
+ {
+ case -1:
+ break;
+ case 'b':
+ baud = ascii2int(optarg, argv[0]);
+ break;
+ case 'i':
+ if (optarg == NULL || strlen(optarg) != 1)
+ usage(argv[0]);
+ switch (optarg[0])
+ {
+ case 'a':
+ case 'A':
+ interface = INTERFACE_A;
+ break;
+
+ case 'b':
+ case 'B':
+ interface = INTERFACE_B;
+ break;
+
+ case 'c':
+ case 'C':
+ interface = INTERFACE_C;
+ break;
+
+ case 'd':
+ case 'D':
+ interface = INTERFACE_D;
+ break;
+
+ default:
+ usage(argv[0]);
+ }
+ break;
+ case 'l':
+ latency = ascii2int(optarg, argv[0]);
+ if (latency < latency_min || latency > latency_max)
+ {
+ fprintf(stderr, "latency [-l] must be an integer in the range %d..%d\n",
+ latency_min, latency_max);
+ usage(argv[0]);
+ }
+ latency_specified = 1;
+ break;
+ case 'n':
+ msg_size = ascii2int(optarg, argv[0]);
+ if (msg_size < 1)
+ {
+ fprintf(stderr, "msg-size [-n] must be an integer greater than 0\n");
+ usage(argv[0]);
+ }
+ break;
+ case 'N':
+ note = optarg;
+ break;
+ case 'P':
+ broken_purge_test = 1;
+ break;
+ default:
+ usage(argv[0]);
+ }
+
+ if (optind == argc)
+ usage(argv[0]);
+
+ if (optind == argc - 1)
+ {
+ // Exactly one extra argument- a dump file
+ dev_string = argv[optind];
+ }
+ else if (optind < argc)
+ {
+ // Too many extra args
+ usage(argv[0]);
+ }
+
+ baud_code = baud_2_baud_code(baud);
+ if (baud_code < 1)
+ {
+ fprintf(stderr, "Invalid baud [-b]\n");
+ usage(argv[0]);
+ }
+
+ if (dev_string[0] == '/')
+ {
+ struct termios termios;
+
+ if (latency_specified) {
+ fprintf(stderr, "Latency (-l) option not support on this device; ignored\n");
+ }
+
+ if (broken_purge_test) {
+ fprintf(stderr, "Broken-purge (-P) option not support with Linux kernel driver\n");
+ return EXIT_FAILURE;
+ }
+
+ dev_fd = open(dev_string, O_NOCTTY | O_RDWR);
+ if (dev_fd < 0)
+ {
+ fprintf(stderr, "Error opening Linux device \"%s\": %s\n",
+ dev_string, strerror(errno));
+ return EXIT_FAILURE;
+ }
+
+ if (! isatty(dev_fd))
+ {
+ fprintf(stderr, "Not a TTY device: \"%s\"\n", dev_string);
+ return EXIT_FAILURE;
+ }
+
+ if (tcgetattr(dev_fd, &termios) == -1)
+ {
+ fprintf(stderr, "Error getting TTY attributes for \"%s\": %s\n",
+ dev_string, strerror(errno));
+ return EXIT_FAILURE;
+ }
+
+ note_default = "Linux kernel driver";
+
+ cfmakeraw(&termios);
+
+ termios.c_cflag &=
+ ~(CSTOPB | CRTSCTS);
+
+ termios.c_cflag &= ~CSIZE;
+ termios.c_cflag |= CS8;
+
+ cfsetspeed(&termios, baud_code);
+
+ termios.c_cflag |=
+ CLOCAL;
+
+ termios.c_cc[VMIN] = 1; // Character at a time input
+ termios.c_cc[VTIME] = 0; // with blocking
+
+ if (tcsetattr(dev_fd, TCSAFLUSH, &termios) == -1) {
+ fprintf(stderr, "Error setting TTY attributes for \"%s\": %s\n",
+ dev_string, strerror(errno));
+ return EXIT_FAILURE;
+ }
+ }
+ else
+ {
+
+ if ((ftdi = ftdi_new()) == 0)
+ {
+ fprintf(stderr, "ftdi_new failed\n");
+ return EXIT_FAILURE;
+ }
+
+ if (ftdi_set_interface(ftdi, interface) < 0)
+ {
+ fprintf(stderr, "ftdi_set_interface failed\n");
+ ftdi_free(ftdi);
+ return EXIT_FAILURE;
+ }
+
+ if (ftdi_usb_open_string(ftdi, dev_string) < 0)
+ {
+ fprintf(stderr,"Error opening ftdi device \"%s\": %s\n", dev_string,
+ ftdi_get_error_string(ftdi));
+ ftdi_free(ftdi);
+ return EXIT_FAILURE;
+ }
+
+ if(ftdi_set_latency_timer(ftdi, (unsigned char) latency))
+ {
+ if (latency_specified &&
+ (ftdi->type == TYPE_AM || ftdi->type == TYPE_232H)) {
+ fprintf(stderr, "Latency (-l) option not support on this device; ignored\n");
+ } else if (ftdi->type != TYPE_AM && ftdi->type != TYPE_232H) {
+ fprintf(stderr,"Error setting latency for ftdi device \"%s\" (%d): %s\n",
+ dev_string, ftdi->type, ftdi_get_error_string(ftdi));
+ ftdi_free(ftdi);
+ return EXIT_FAILURE;
+ }
+ }
+
+ if (ftdi_set_line_property2(ftdi, BITS_8, STOP_BIT_1, NONE, BREAK_OFF) < 0)
+ {
+ fprintf(stderr,"Error setting line properties ftdi device \"%s\": %s\n", dev_string,
+ ftdi_get_error_string(ftdi));
+ ftdi_free(ftdi);
+ return EXIT_FAILURE;
+ }
+
+ if (ftdi_set_baudrate(ftdi, baud) < 0)
+ {
+ fprintf(stderr,"Error setting baud rate for ftdi device \"%s\": %s\n", dev_string,
+ ftdi_get_error_string(ftdi));
+ ftdi_free(ftdi);
+ return EXIT_FAILURE;
+ }
+
+ if (ftdi_setflowctrl(ftdi, SIO_DISABLE_FLOW_CTRL))
+ {
+ fprintf(stderr,"Error setting flow control for ftdi device \"%s\": %s\n", dev_string,
+ ftdi_get_error_string(ftdi));
+ ftdi_free(ftdi);
+ return EXIT_FAILURE;
+ }
+
+ if (broken_purge_test)
+ note_default = "libftdi w/ deprecated purge";
+ else
+ note_default = "libftdi w/ new flush methods";
+ }
+
+ printf("Purge (tcflush) test for device %s\n", dev_string);
+ printf("Note: %s\n", (note ? note : note_default));
+
+ if (dev_fd < 0)
+ {
+ if (ftdi->type >0 && ftdi->type < ARRAY_SIZE(chip_types))
+ printf("FTDI chip type is %d (%s)\n",
+ ftdi->type, chip_types[ftdi->type]);
+ else
+ printf("FTDI chip type is %d (unknown)\n", ftdi->type);
+ }
+
+ printf("# purge_test" );
+ for (c = 1; c < argc; ++c)
+ {
+ const char *p = argv[c];
+ while (*p != '\0')
+ {
+ if (*p == ' ')
+ break;
+ ++p;
+ }
+ if (*p == ' ')
+ printf(" '%s'", argv[c]);
+ else
+ printf(" %s", argv[c]);
+ }
+ printf("\n");
+
+ msg_xmit_time_us = char_cnt_2_usec(msg_size);
+ printf("%d chars at %d baud takes about %.0f ms to transmit\n", msg_size,
+ baud, msg_xmit_time_us * .001);
+
+ msg = malloc(msg_size + 1);
+ if (msg == NULL)
+ {
+ fprintf(stderr, "Could not allocate send message buffer\n");
+ return EXIT_FAILURE;
+ }
+
+ {
+ char dataChar = '0' + ((get_time_usec() / 1000) % 31);
+ char next = 'A';
+ for (i = 0; i < msg_size; ++i) {
+ if (dataChar == '`')
+ {
+ msg[i] = next++;
+ ++dataChar;
+ }
+ else
+ msg[i] = dataChar++;
+
+ if (dataChar > 'z') {
+ dataChar = '`';
+ }
+ }
+ msg[msg_size] = '\0';
+ }
+
+ printf("TX Message is \"%s\"\n", msg);
+
+ retMsgSize = 2 * msg_size;
+ retMsg = malloc(retMsgSize);
+ if (retMsg == NULL)
+ {
+ fprintf(stderr, "Could not allocate received message buffer\n");
+ return EXIT_FAILURE;
+ }
+
+ flush(TCIOFLUSH);
+
+ for (test = 0; test <= 2; ++test)
+ {
+ long long usec_delay;
+ long long usec_to_now;
+ int rc;
+
+ printf("\n******** Test purge %s; expect %s ********\n"
+ " -- Flushing UART\n",
+ flushTestName[test], expected[test]);
+ flush(TCIOFLUSH);
+ usleep(msg_xmit_time_us);
+ flush(TCIOFLUSH);
+ usleep(100000);
+
+ usec_test_start = get_time_usec();
+ if (dev_fd >= 0)
+ rc = write(dev_fd, msg, msg_size);
+ else
+ rc = ftdi_write_data(ftdi, msg, msg_size);
+
+ if (rc != msg_size)
+ {
+ fprintf(stderr, "Data write was short: %d: %s\n",
+ rc, ftdi_get_error_string(ftdi));
+ exit(1);
+ }
+ usec_to_now = get_time_usec() - usec_test_start;
+ usec_delay = msg_xmit_time_us / 2 - usec_to_now;
+ if (usec_delay < 0)
+ usec_delay = 0;
+ printf(" -- %9.1f ms Write completes; delaying to TX midpoint (%.1f ms)\n",
+ usec_to_now * .001, usec_delay * .001);
+ if (usec_delay > 0)
+ usleep(usec_delay);
+
+ printf(" -- %9.1f ms Issuing %s flush (purge)\n",
+ (get_time_usec() - usec_test_start) * .001,
+ flushTestName[test]);
+ flush(flushQueueSelector[test]);
+
+ printf(" -- %9.1f ms Calling drain to wait for transmit to complete\n",
+ (get_time_usec() - usec_test_start) * .001);
+ drain();
+
+ usec_to_now = get_time_usec() - usec_test_start;
+
+ /* If input only flush, check drain time. */
+ if (flushQueueSelector[test] == TCIFLUSH &&
+ usec_to_now < (msg_xmit_time_us * 90ll) / 100ll)
+ {
+ usec_delay = (msg_xmit_time_us * 110ll) / 100ll - usec_to_now;
+ printf(" -- %9.1f ms Drain() completed too early; expected at least %.1f ms\n"
+ " Delaying for %.1f ms\n",
+ usec_to_now * .001,
+ ((msg_xmit_time_us * 90ll) / 100ll) * .001,
+ usec_delay * .001);
+ usleep(usec_delay);
+ }
+ else
+ {
+ printf(" -- %9.1f ms Drain() reports completed; timing OK; delaying for 4 bytes\n",
+ (get_time_usec() - usec_test_start) * .001);
+ usleep(char_cnt_2_usec(4));
+ }
+
+ printf(" -- %9.1f ms Reading data.\n",
+ (get_time_usec() - usec_test_start) * .001);
+ if (dev_fd >= 0)
+ rc = read(dev_fd, retMsg, retMsgSize);
+ else
+ rc = ftdi_read_data(ftdi, retMsg, retMsgSize - 1);
+
+ usec_to_now = get_time_usec() - usec_test_start;
+ if (rc < 0)
+ {
+ fprintf(stderr, " -- %9.1f ms Read returned error %s\n",
+ usec_to_now * .001,
+ (dev_fd >= 0 ? strerror(errno) : ftdi_get_error_string(ftdi)));
+ exit(1);
+ }
+ retMsg[rc] = '\0';
+ printf(" -- %9.1f ms Read returns %d bytes; msg: \"%s\"\n",
+ usec_to_now * .001, rc, retMsg);
+
+ usleep(char_cnt_2_usec(10));
+
+ }
+
+
+ if (dev_fd >= 0)
+ {
+ close(dev_fd);
+ }
+ else
+ {
+ ftdi_usb_close(ftdi);
+ ftdi_free(ftdi);
+ }
+
+ exit (0);
+}
+
+/**********************************************************************
+ */
+static int ascii2int(const char * str, const char * pgm_name)
+{
+ int rc;
+ char * endptr;
+ if (str == NULL || strlen(str) == 0)
+ usage(pgm_name);
+ rc = strtol(str, &endptr, 10);
+ if (endptr == str || *endptr != '\0')
+ usage(pgm_name);
+ return rc;
+}
+
+
+/**********************************************************************
+ */
+static struct Baud_Table {
+ int32_t baud, baud_code;
+} baud_table [] =
+{
+ { 50, B50 },
+ { 75, B75 },
+ { 110, B110 },
+ { 134, B134 },
+ { 150, B150 },
+ { 200, B200 },
+ { 300, B300 },
+ { 600, B600 },
+ { 1200, B1200 },
+ { 1800, B1800 },
+ { 2400, B2400 },
+ { 4800, B4800 },
+ { 9600, B9600 },
+ { 19200, B19200 },
+ { 38400, B38400 },
+ { 57600, B57600 },
+ { 115200, B115200 },
+ { 230400, B230400 },
+ { -1, -1, }
+};
+
+/**********************************************************************
+ */
+static int baud_2_baud_code(int baud)
+{
+ struct Baud_Table *p;
+
+ for (p = baud_table ; p->baud != -1; ++p) {
+ if (p->baud == baud)
+ break;
+ }
+ return p->baud_code;
+}
+
+
+static long int char_cnt_2_usec(int char_count)
+{
+ long long bits = 8 + 1 + 1; /* Number of bits in each character */
+ bits *= (char_count == 0 ? 1 : char_count); /* Total number of bits */
+ bits *= 1000000; /* Convert to us */
+ lldiv_t parts = lldiv(bits, baud); /* Number of us for message */
+ return (parts.quot + 1);
+}
+
+
+static long int drain()
+{
+ long int rc = 0;
+ long long start_time = get_time_usec();
+ if (dev_fd >= 0)
+ rc = tcdrain(dev_fd);
+ else
+ {
+ long int sleep_interval = char_cnt_2_usec(10);
+ while (1) {
+ unsigned short modem_status = 0;
+ int rc = ftdi_poll_modem_status(ftdi, &modem_status);
+ if (rc < 0)
+ return -1;
+ if (modem_status & (1 << (6 + 8))) {
+ break;
+ }
+ usleep(sleep_interval);
+ }
+ }
+ if (rc < 0)
+ return rc;
+ usleep(char_cnt_2_usec(2));
+ return get_time_usec() - start_time;
+}
+
+
+static int flush(int queue_selector)
+{
+ int rc;
+ if (dev_fd >= 0)
+ rc = tcflush(dev_fd, queue_selector);
+ else if (! broken_purge_test)
+ {
+ switch (queue_selector) {
+
+ case TCIOFLUSH:
+ rc = ftdi_tcioflush(ftdi);
+ break;
+
+ case TCIFLUSH:
+ rc = ftdi_tciflush(ftdi);
+ break;
+
+ case TCOFLUSH:
+ rc = ftdi_tcoflush(ftdi);
+ break;
+
+ default:
+ errno = EINVAL;
+ return -1;
+ }
+ }
+ else
+ {
+ switch (queue_selector) {
+
+ case TCIOFLUSH:
+ rc = ftdi_usb_purge_buffers(ftdi);
+ break;
+
+ case TCIFLUSH:
+ rc = ftdi_usb_purge_rx_buffer(ftdi);
+ break;
+
+ case TCOFLUSH:
+ rc = ftdi_usb_purge_tx_buffer(ftdi);
+ break;
+
+ default:
+ errno = EINVAL;
+ return -1;
+ }
+ }
+
+ return rc;
+}
+
+
+static long long int get_time_usec()
+{
+ struct timeval tv;
+ gettimeofday(&tv, NULL);
+ return tv.tv_sec * 1000000ll + tv.tv_usec;
+}
git://developer.intra2net.com / libftdi / commitdiff