diff --git a/software/e1-tracer/main.c b/software/e1-tracer/main.c
new file mode 100644
index 0000000..9d004a3
--- /dev/null
+++ b/software/e1-tracer/main.c
@@ -0,0 +1,451 @@
+/* (C) 2019 by Sylvain Munaut <tnt@246tNt.com>
+ * (C) 2019-2020 by Harald Welte <laforge@gnumonks.org>
+ * All Rights Reserved
+ *
+ * SPDX-License-Identifier: GPL-2.0-or-later
+ *
+ * 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 the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ */
+
+#include <errno.h>
+#include <getopt.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sched.h>
+#include <errno.h>
+
+#include <sys/time.h>
+
+#include <libusb.h>
+
+#include "idt82v2081.h"
+#include "idt82v2081_usb.h"
+#include "idt82v2081_regs.h"
+
+
+static int g_do_exit = 0;
+
+#define USB_VID		0x1d50
+#define USB_PID		0x6151
+#define EP_DATA_IN0	0x81
+#define EP_DATA_IN1	0x82
+
+struct e1_streamer;
+struct flow;
+
+typedef int (*xfer_cb_t)(struct e1_streamer *e1s, struct flow *flow, uint8_t *buf, int size);
+
+struct flow_entry {
+	uint8_t *buf;
+	struct libusb_transfer *xfr;
+};
+
+struct flow {
+	struct e1_streamer *parent;
+	xfer_cb_t cb;
+
+	int ep;
+	int count;
+	int size;
+	int ppx;
+	struct flow_entry *entries;
+};
+
+struct e1_streamer {
+	struct libusb_device_handle *devh;
+	struct flow data_in[2];
+	struct idt82 liu[2];
+	FILE *fh;
+};
+
+struct e1_chunk_hdr {
+	uint32_t magic;
+	struct {
+		uint64_t sec;
+		uint64_t usec;
+	} time;
+	int16_t len;
+	uint8_t ep;
+} __attribute__((packed));
+
+
+static int
+cb_xfr_data_in(struct e1_streamer *e1s, struct flow *flow, uint8_t *buf, int size)
+{
+	struct e1_chunk_hdr hdr;
+	struct timeval tv;
+	int rc;
+
+	hdr.magic = 0xe115600d;	/* E1 is good */
+
+	gettimeofday(&tv, NULL);
+	hdr.time.sec  = tv.tv_sec;
+	hdr.time.usec = tv.tv_usec;
+
+	hdr.ep = flow->ep;
+	hdr.len = size;
+
+	if (size < 0) {
+		printf("EP %02x - Err %d: %s\n", flow->ep, size, libusb_strerror(size));
+		return 0;
+	}
+
+	if (!e1s->fh)
+		return 0;
+
+	rc = fwrite(&hdr, sizeof(struct e1_chunk_hdr), 1, e1s->fh);
+	if (rc != 1) {
+		fprintf(stderr, "[!] Short write: %d != %zd", rc, sizeof(struct e1_chunk_hdr));
+		if (rc == -1)
+			fprintf(stderr, ", %s\n", strerror(errno));
+		else
+			fprintf(stderr, "\n");
+		g_do_exit = 1;
+	}
+
+	if (size > 0) {
+		rc = fwrite(buf, size, 1, e1s->fh);
+		if (rc != 1) {
+			fprintf(stderr, "[!] Short write: %d != %zd", rc, sizeof(struct e1_chunk_hdr));
+			if (rc == -1)
+				fprintf(stderr, ", %s\n", strerror(errno));
+			else
+				fprintf(stderr, "\n");
+			g_do_exit = 1;
+		}
+	}
+
+	return 0;
+}
+
+static void LIBUSB_CALL cb_xfr(struct libusb_transfer *xfr)
+{
+	struct flow *flow = (struct flow *) xfr->user_data;
+	struct e1_streamer *e1s = flow->parent;
+	int j, rv, len;
+
+#if 0
+	fprintf(stderr, "transfer status (%02x) %d [%d %d] [%d %d]\n", flow->ep, xfr->status,
+		xfr->iso_packet_desc[0].status,
+		xfr->iso_packet_desc[0].actual_length,
+		xfr->iso_packet_desc[1].status,
+		xfr->iso_packet_desc[1].actual_length
+	);
+#endif
+
+	if (xfr->status != LIBUSB_TRANSFER_COMPLETED) {
+		fprintf(stderr, "[!] XFR status != completed (%d)\n", xfr->status);
+		g_do_exit = 1;
+	}
+
+	len = 0;
+
+	if (flow->ep & 0x80) {
+		for (j=0; j<flow->ppx; j++) {
+			flow->cb(e1s, flow,
+				libusb_get_iso_packet_buffer_simple(xfr, j),
+				(xfr->iso_packet_desc[j].status == LIBUSB_TRANSFER_COMPLETED) ?
+					xfr->iso_packet_desc[j].actual_length : -1
+			);
+			if (!(xfr->iso_packet_desc[j].status == LIBUSB_TRANSFER_COMPLETED)) {
+				fprintf(stderr, "[!] ISO packet status != completed (%d)\n",
+					xfr->iso_packet_desc[j].status);
+			}
+
+			len += (xfr->iso_packet_desc[j].length = flow->size);
+		}
+	} else {
+		for (j=0; j<flow->ppx; j++)
+			len += (xfr->iso_packet_desc[j].length = flow->cb(e1s, flow, &xfr->buffer[len], flow->size));
+	}
+
+	libusb_fill_iso_transfer(xfr, e1s->devh, flow->ep,
+		xfr->buffer, len, flow->ppx,
+		cb_xfr, flow, 0
+	);
+
+	rv = libusb_submit_transfer(xfr);
+	if (rv) {
+		fprintf(stderr, "[!] Error re-submitting buffer (%d): %s\n", rv, libusb_strerror(rv));
+		g_do_exit = 1;
+	}
+}
+
+
+static void
+_e1s_flow_fini(struct flow *flow)
+{
+	int i;
+
+	for (i=0; i<flow->count; i++)
+		free(flow->entries[i].buf);
+
+	free(flow->entries);
+}
+
+static void
+_e1s_flow_init(struct e1_streamer *e1s, struct flow *flow, xfer_cb_t cb, int ep, int count, int size, int ppx)
+{
+	int i;
+
+	flow->parent  = e1s;
+	flow->cb      = cb;
+	flow->ep      = ep;
+	flow->count   = count;
+	flow->size    = size;
+	flow->ppx     = ppx;
+	flow->entries = calloc(count, sizeof(struct flow_entry));
+
+	for (i=0; i<count; i++)
+		flow->entries[i].buf = malloc(size * ppx);
+}
+
+static int
+_e1s_flow_start(struct e1_streamer *e1s, struct flow *flow)
+{
+	struct libusb_transfer *xfr;
+	int i, j, rv, len;
+
+	for (i=0; i<flow->count; i++)
+	{
+		xfr = libusb_alloc_transfer(flow->ppx);
+		if (!xfr)
+			return -ENOMEM;
+
+		len = 0;
+
+		if (flow->ep & 0x80) {
+			for (j=0; j<flow->ppx; j++)
+				len += (xfr->iso_packet_desc[j].length = flow->size);
+		} else {
+			for (j=0; j<flow->ppx; j++)
+				len += (xfr->iso_packet_desc[j].length = flow->cb(e1s, flow, &flow->entries[i].buf[len], flow->size));
+		}
+
+		libusb_fill_iso_transfer(xfr, e1s->devh, flow->ep,
+			flow->entries[i].buf, len, flow->ppx,
+			cb_xfr, flow, 0
+		);
+
+		rv = libusb_submit_transfer(xfr);
+		if (rv) {
+			return rv;
+		}
+
+		flow->entries[i].xfr = xfr;
+	}
+
+	return 0;
+}
+
+
+static void
+e1s_release(struct e1_streamer *e1s)
+{
+	if (!e1s)
+		return;
+
+	_e1s_flow_fini(&e1s->data_in[0]);
+	_e1s_flow_fini(&e1s->data_in[1]);
+
+	if (e1s->devh) {
+		libusb_release_interface(e1s->devh, 0);
+		libusb_close(e1s->devh);
+	}
+
+	free(e1s);
+}
+
+static struct e1_streamer *
+e1s_new(bool monitor, const char *out_file, bool append, int nx, int ppx)
+{
+	struct e1_streamer *e1s = NULL;
+	int rv;
+
+	e1s = calloc(1, sizeof(struct e1_streamer));
+	if (!e1s)
+		return NULL;
+
+	e1s->devh = libusb_open_device_with_vid_pid(NULL, USB_VID, USB_PID);
+	if (!e1s->devh) {
+		fprintf(stderr, "Error finding USB device\n");
+		goto err;
+	}
+
+	rv = libusb_claim_interface(e1s->devh, 0);
+	if (rv < 0) {
+		fprintf(stderr, "Error claiming interface: %s\n", libusb_error_name(rv));
+		goto err;
+	}
+
+	rv = libusb_set_interface_alt_setting(e1s->devh, 0, 1);
+	if (rv < 0) {
+		fprintf(stderr, "Error enabling interface: %s\n", libusb_error_name(rv));
+		goto err;
+	}
+
+	_e1s_flow_init(e1s, &e1s->data_in[0], cb_xfr_data_in, EP_DATA_IN0, nx, 388, ppx);
+	_e1s_flow_init(e1s, &e1s->data_in[1], cb_xfr_data_in, EP_DATA_IN1, nx, 388, ppx);
+
+	idt82_usb_init(&e1s->liu[0], e1s->devh, EP_DATA_IN0);
+	idt82_usb_init(&e1s->liu[1], e1s->devh, EP_DATA_IN1);
+	idt82_init(&e1s->liu[0], monitor);
+	idt82_init(&e1s->liu[1], monitor);
+
+	if (out_file) {
+		e1s->fh = fopen(out_file, append ? "ab" : "wb");
+		if (!e1s->fh)
+			fprintf(stderr, "[1] Failed to open recording file\n");
+	}
+
+	return e1s;
+
+err:
+	e1s_release(e1s);
+	return NULL;
+}
+
+struct options {
+	/* Transfer config */
+	int nx;
+	int ppx;
+
+	/* Output */
+	const char *out_filename;
+	bool out_append;
+
+	/* PHY */
+	bool monitor;
+
+	/* OS */
+	bool realtime;
+};
+
+static void
+opts_defaults(struct options *opts)
+{
+	memset(opts, 0x00, sizeof(struct options));
+
+	opts->nx = 2;
+	opts->ppx = 4;
+}
+
+static void
+opts_help(void)
+{
+	fprintf(stderr, " -a           Output : append mode\n");
+	fprintf(stderr, " -o FILE      Output : filename\n");
+	fprintf(stderr, " -n NX        Xfer   : Number of queued transfers (default: 2)\n");
+	fprintf(stderr, " -p PPX       Xfer   : Number of packets per transfer (default: 4)\n");
+	fprintf(stderr, " -m           PHY    : Monitor mode (i.e. high gain)\n");
+	fprintf(stderr, " -r           OS     : Set real-time priority on process\n");
+	fprintf(stderr, " -h           help\n");
+}
+
+static int
+opts_parse(struct options *opts, int argc, char *argv[])
+{
+	const char *opts_short = "ao:n:p:mrh";
+	int opt;
+
+	while ((opt = getopt(argc, argv, opts_short)) != -1)
+	{
+		switch(opt) {
+		case 'a':
+			opts->out_append = true;
+			break;
+
+		case 'o':
+			opts->out_filename = optarg;
+			break;
+
+		case 'n':
+			opts->nx = atoi(optarg);
+			if (opts->nx <= 0) {
+				fprintf(stderr, "[!] Invalid nx value ignored\n");
+				opts->nx = 2;
+			}
+			break;
+
+		case 'p':
+			opts->ppx = atoi(optarg);
+			if (opts->ppx <= 0) {
+				fprintf(stderr, "[!] Invalid ppx value ignored\n");
+				opts->ppx = 4;
+			}
+			break;
+
+		case 'm':
+			opts->monitor = true;
+			break;
+
+		case 'r':
+			opts->realtime = true;
+			break;
+
+		case 'h':
+		default:
+			opts_help();
+			exit(1);
+		}
+	}
+
+	return 0;
+}
+
+int main(int argc, char *argv[])
+{
+	struct e1_streamer *e1s;
+	struct sched_param sp;
+	struct options opts;
+	int rv;
+
+	opts_defaults(&opts);
+	opts_parse(&opts, argc, argv);
+
+	if (opts.realtime) {
+		memset(&sp, 0x00, sizeof(sp));
+		sp.sched_priority = 50;
+		rv = sched_setscheduler(0, SCHED_RR, &sp);
+		printf("%d %d\n", rv, errno);
+		perror("sched_setscheduler");
+	}
+
+	rv = libusb_init(NULL);
+	if (rv < 0) {
+		fprintf(stderr, "Error initializing libusb: %s\n", libusb_error_name(rv));
+		return rv;
+	}
+
+	e1s = e1s_new(opts.monitor, opts.out_filename, opts.out_append, opts.nx, opts.ppx);
+	if (!e1s)
+		goto out;
+
+	_e1s_flow_start(e1s, &e1s->data_in[0]);
+	_e1s_flow_start(e1s, &e1s->data_in[1]);
+
+	while (!g_do_exit) {
+		rv = libusb_handle_events(NULL);
+		if (rv != LIBUSB_SUCCESS)
+			break;
+	}
+
+out:
+	e1s_release(e1s);
+
+	libusb_exit(NULL);
+
+	return 0;
+}