Merge branch 'iq' into interleaved_rg

11 files changed, 1191 insertions, 45 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5fb110f..84bc55d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -24,6 +24,11 @@ project(libosmo-fl2k C)
 
 include(GNUInstallDirs)
 
+# CMP0075 Include file check macros honor CMAKE_REQUIRED_LIBRARIES
+if(POLICY CMP0075)
+    cmake_policy(SET CMP0075 NEW)
+endif()
+
 #select the release build type by default to get optimization flags
 if(NOT CMAKE_BUILD_TYPE)
    set(CMAKE_BUILD_TYPE "Release")
diff --git a/contrib/jenkins.sh b/contrib/jenkins.sh
new file mode 100755
index 0000000..8c3b1cf
--- /dev/null
+++ b/contrib/jenkins.sh
@@ -0,0 +1,18 @@
+#!/bin/sh -ex
+# This is how we build on jenkins.osmocom.org.
+
+CFLAGS="-Werror"
+
+if ! [ -x "$(command -v osmo-clean-workspace.sh)" ]; then
+	echo "Error: We need to have scripts/osmo-clean-workspace.sh from osmo-ci.git in PATH!"
+	exit 2
+fi
+
+osmo-clean-workspace.sh
+cmake \
+	-DINSTALL_UDEV_RULES=ON \
+	-DCMAKE_C_FLAGS="$CFLAGS" \
+	.
+make $PARALLEL_MAKE
+make DESTDIR="_install" install
+osmo-clean-workspace.sh
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index f63780a..543226e 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -79,24 +79,36 @@ add_executable(fl2k_file fl2k_file.c)
 add_executable(fl2k_tcp fl2k_tcp.c)
 add_executable(fl2k_test fl2k_test.c)
 add_executable(fl2k_fm fl2k_fm.c rds_waveforms.c rds_mod.c)
-set(INSTALL_TARGETS libosmo-fl2k_shared libosmo-fl2k_static fl2k_file fl2k_tcp fl2k_test fl2k_fm)
+add_executable(fl2k_garage fl2k_garage.c)
+add_executable(fl2k_iq fl2k_iq.c)
+set(INSTALL_TARGETS libosmo-fl2k_shared libosmo-fl2k_static fl2k_file fl2k_tcp fl2k_test fl2k_fm fl2k_garage fl2k_iq)
 
-target_link_libraries(fl2k_file libosmo-fl2k_shared 
+target_link_libraries(fl2k_file libosmo-fl2k_shared
     ${LIBUSB_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
 )
 
-target_link_libraries(fl2k_tcp libosmo-fl2k_shared 
+target_link_libraries(fl2k_tcp libosmo-fl2k_shared
     ${LIBUSB_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
 )
 
-target_link_libraries(fl2k_test libosmo-fl2k_shared 
+target_link_libraries(fl2k_test libosmo-fl2k_shared
     ${LIBUSB_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
 )
 
-target_link_libraries(fl2k_fm libosmo-fl2k_shared 
+target_link_libraries(fl2k_fm libosmo-fl2k_shared
+    ${LIBUSB_LIBRARIES}
+    ${CMAKE_THREAD_LIBS_INIT}
+)
+
+target_link_libraries(fl2k_garage libosmo-fl2k_shared
+    ${LIBUSB_LIBRARIES}
+    ${CMAKE_THREAD_LIBS_INIT}
+)
+
+target_link_libraries(fl2k_iq libosmo-fl2k_shared
     ${LIBUSB_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
 )
@@ -105,6 +117,8 @@ target_link_libraries(fl2k_fm libosmo-fl2k_shared
 if(UNIX)
 target_link_libraries(fl2k_test m)
 target_link_libraries(fl2k_fm m)
+target_link_libraries(fl2k_garage m)
+target_link_libraries(fl2k_iq m)
 endif()
 
 if(WIN32 AND NOT MINGW)
@@ -112,10 +126,14 @@ target_link_libraries(fl2k_file libgetopt_static)
 target_link_libraries(fl2k_tcp ws2_32 libgetopt_static)
 target_link_libraries(fl2k_test libgetopt_static)
 target_link_libraries(fl2k_fm libgetopt_static)
+target_link_libraries(fl2k_garage libgetopt_static)
+target_link_libraries(fl2k_iq libgetopt_static)
 set_property(TARGET fl2k_file APPEND PROPERTY COMPILE_DEFINITIONS "libosmo-fl2k_STATIC" )
 set_property(TARGET fl2k_tcp APPEND PROPERTY COMPILE_DEFINITIONS "libosmo-fl2k_STATIC" )
 set_property(TARGET fl2k_test APPEND PROPERTY COMPILE_DEFINITIONS "libosmo-fl2k_STATIC" )
 set_property(TARGET fl2k_fm APPEND PROPERTY COMPILE_DEFINITIONS "libosmo-fl2k_STATIC" )
+set_property(TARGET fl2k_garage APPEND PROPERTY COMPILE_DEFINITIONS "libosmo-fl2k_STATIC" )
+set_property(TARGET fl2k_iq APPEND PROPERTY COMPILE_DEFINITIONS "libosmo-fl2k_STATIC" )
 endif()
 
 if(MINGW)
diff --git a/src/fl2k_file.c b/src/fl2k_file.c
index 2cea6ff..6829deb 100644
--- a/src/fl2k_file.c
+++ b/src/fl2k_file.c
@@ -89,6 +89,12 @@ void fl2k_callback(fl2k_data_info_t *data_info)
 	int left = required_samples;
 	static uint32_t repeat_cnt = 0;
 
+	if (data_info->device_error) {
+		fprintf(stderr, "Device error, exiting.\n");
+		do_exit = 1;
+		return;
+	}
+
 	data_info->sampletype_signed = 1;
 	if (interleaved) {
 		data_info->iq_buf = txbuf;
@@ -103,7 +109,7 @@ void fl2k_callback(fl2k_data_info_t *data_info)
 			fprintf(stderr, "File Error\n");
 
 		if (feof(file)) {
-			if (repeat) {
+			if (repeat && (r > 0)) {
 				repeat_cnt++;
 				fprintf(stderr, "repeat %d\n", repeat_cnt);
 				rewind(file);
diff --git a/src/fl2k_fm.c b/src/fl2k_fm.c
index 4aae95b..b22efcd 100644
--- a/src/fl2k_fm.c
+++ b/src/fl2k_fm.c
@@ -73,7 +73,7 @@ uint32_t samp_rate = 100000000;
 #define PILOT_FREQ	19000	/* In Hz */
 #define STEREO_CARRIER	38000	/* In Hz */
 
-int delta_freq = 75000;
+int deviation = 75000;
 int carrier_freq = 97000000;
 int carrier_per_signal;
 int input_freq = 44100;
@@ -153,17 +153,17 @@ typedef struct {
 	unsigned long int phase_slope;
 } dds_t;
 
-inline void dds_setphase(dds_t *dds, double phase)
+static inline void dds_setphase(dds_t *dds, double phase)
 {
 	dds->phase = phase * ANG_INCR;
 }
 
-inline double dds_getphase(dds_t *dds)
+static inline double dds_getphase(dds_t *dds)
 {
 	return dds->phase / ANG_INCR;
 }
 
-inline void dds_set_freq(dds_t *dds, double freq, double fslope)
+static inline void dds_set_freq(dds_t *dds, double freq, double fslope)
 {
 	dds->fslope = fslope;
 	dds->phase_step = (freq / dds->sample_freq) * 2 * M_PI * ANG_INCR;
@@ -196,7 +196,7 @@ dds_t dds_init(double sample_freq, double freq, double phase)
 	return dds;
 }
 
-inline int8_t dds_real(dds_t *dds)
+static inline int8_t dds_real(dds_t *dds)
 {
 	int tmp;
 
@@ -209,7 +209,7 @@ inline int8_t dds_real(dds_t *dds)
 	return sine_table[tmp];
 }
 
-inline void dds_real_buf(dds_t *dds, int8_t *buf, int count)
+static inline void dds_real_buf(dds_t *dds, int8_t *buf, int count)
 {
 	int i;
 	for (i = 0; i < count; i++)
@@ -267,7 +267,7 @@ static void *fm_worker(void *arg)
 	pthread_exit(NULL);
 }
 
-inline int writelen(int maxlen)
+static inline int writelen(int maxlen)
 {
 	int rp = readpos;
 	int len;
@@ -283,13 +283,13 @@ inline int writelen(int maxlen)
 	return r;
 }
 
-inline double modulate_sample(int lastwritepos, double lastfreq, double sample)
+static inline double modulate_sample(int lastwritepos, double lastfreq, double sample)
 {
 	double freq, slope;
 
 	/* Calculate modulator frequency at this point to lessen
 	 * the calculations needed in the signal generator */
-	freq = sample * delta_freq;
+	freq = sample * deviation;
 	freq += carrier_freq;
 
 	/* What we do here is calculate a linear "slope" from
@@ -419,6 +419,7 @@ void fm_modulator_stereo(int use_rds)
 void fl2k_callback(fl2k_data_info_t *data_info)
 {
 	if (data_info->device_error) {
+		fprintf(stderr, "Device error, exiting.\n");
 		do_exit = 1;
 		pthread_cond_signal(&fm_cond);
 	}
@@ -467,7 +468,7 @@ int main(int argc, char **argv)
 			carrier_freq = (uint32_t)atof(optarg);
 			break;
 		case 'f':
-			delta_freq = (uint32_t)atof(optarg);
+			deviation = (uint32_t)atof(optarg);
 			break;
 		case 'i':
 			input_freq = (uint32_t)atof(optarg);
diff --git a/src/fl2k_garage.c b/src/fl2k_garage.c
new file mode 100644
index 0000000..d50922e
--- /dev/null
+++ b/src/fl2k_garage.c
@@ -0,0 +1,545 @@
+/*
+ * osmo-fl2k, turns FL2000-based USB 3.0 to VGA adapters into
+ * low cost DACs
+ *
+ * Copyright (C) 2019 by Felix Erckenbrecht <eligs@eligs.de>
+ *
+ * based on fl2k_fm code by:
+ * Copyright (C) 2016-2018 by Steve Markgraf <steve@steve-m.de>
+ *
+ * based on FM modulator code from VGASIG:
+ * Copyright (C) 2009 by Bartek Kania <mbk@gnarf.org>
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <errno.h>
+#include <stdint.h>
+
+#ifndef _WIN32
+#include <unistd.h>
+#include <fcntl.h>
+#include <getopt.h>
+#else
+#include <windows.h>
+#include <io.h>
+#include <fcntl.h>
+#include "getopt/getopt.h"
+#endif
+
+#include <math.h>
+#include <pthread.h>
+
+#include "osmo-fl2k.h"
+#include "rds_mod.h"
+
+#define BUFFER_SAMPLES_SHIFT	16
+#define BUFFER_SAMPLES		(1 << BUFFER_SAMPLES_SHIFT)
+#define BUFFER_SAMPLES_MASK	((1 << BUFFER_SAMPLES_SHIFT)-1)
+
+#define AUDIO_BUF_SIZE		4096
+
+#define BASEBAND_SAMPLES_PER_CHIP 3
+#define BASEBAND_WORD_BITS 12
+#define BASEBAND_CHIPS_PER_BIT 3
+#define BASEBAND_CHIPS_PER_WORD (BASEBAND_WORD_BITS * BASEBAND_CHIPS_PER_BIT)
+#define BASEBAND_CHIPS_PER_SPACE BASEBAND_CHIPS_PER_WORD
+#define BASEBAND_SPACE_HIGH_CHIPS 1
+#define BASEBAND_SPACE_LOW_CHIPS (BASEBAND_CHIPS_PER_SPACE - BASEBAND_SPACE_HIGH_CHIPS)
+#define BASEBAND_CHIPS_TOTAL (BASEBAND_CHIPS_PER_SPACE + BASEBAND_CHIPS_PER_WORD)
+
+fl2k_dev_t *dev = NULL;
+int do_exit = 0;
+
+pthread_t am_thread;
+pthread_mutex_t cb_mutex;
+pthread_mutex_t am_mutex;
+pthread_cond_t cb_cond;
+pthread_cond_t am_cond;
+
+int16_t *sample_buf;
+int sample_buf_size;
+
+int8_t *txbuf = NULL;
+int8_t *ambuf = NULL;
+int8_t *buf1 = NULL;
+int8_t *buf2 = NULL;
+
+uint32_t samp_rate = 100000000;
+
+double mod_index = 0.9;
+int carrier_freq = 40685000;
+int carrier_per_signal;
+
+double *ampbuf;
+double *slopebuf;
+int writepos, readpos;
+
+void usage(void)
+{
+	fprintf(stderr,
+		"fl2k_garage, a garage door opener for FL2K VGA dongles\n\n"
+		"Usage:"
+		"\t[-d device index (default: 0)]\n"
+		"\t[-f carrier frequency (default: 40.685 MHz)]\n"
+		"\t[-c garage door code (12 Bit)]\n"
+		"\t[-b chip period in us (default 320 us)]\n"
+		"\t[-s samplerate in Hz (default: 100 MS/s)]\n"
+	);
+	exit(1);
+}
+
+#ifdef _WIN32
+BOOL WINAPI
+sighandler(int signum)
+{
+	if (CTRL_C_EVENT == signum) {
+		fprintf(stderr, "Signal caught, exiting!\n");
+		fl2k_stop_tx(dev);
+		do_exit = 1;
+		pthread_cond_signal(&am_cond);
+		return TRUE;
+	}
+	return FALSE;
+}
+#else
+static void sighandler(int signum)
+{
+	fprintf(stderr, "Signal caught, exiting!\n");
+	fl2k_stop_tx(dev);
+	do_exit = 1;
+	pthread_cond_signal(&am_cond);
+}
+#endif
+
+/* DDS Functions */
+
+#ifndef M_PI
+# define M_PI		3.14159265358979323846	/* pi */
+# define M_PI_2		1.57079632679489661923	/* pi/2 */
+# define M_PI_4		0.78539816339744830962	/* pi/4 */
+# define M_1_PI		0.31830988618379067154	/* 1/pi */
+# define M_2_PI		0.63661977236758134308	/* 2/pi */
+#endif
+#define DDS_2PI		(M_PI * 2)		/* 2 * Pi */
+#define DDS_3PI2	(M_PI_2 * 3)		/* 3/2 * pi */
+
+#define SIN_TABLE_ORDER	8
+#define SIN_TABLE_SHIFT	(32 - SIN_TABLE_ORDER)
+#define SIN_TABLE_LEN	(1 << SIN_TABLE_ORDER)
+#define ANG_INCR	(0xffffffff / DDS_2PI)
+
+int16_t sine_table[SIN_TABLE_LEN];
+int sine_table_init = 0;
+
+typedef struct {
+	double sample_freq;
+	double freq;
+	unsigned long int phase;
+	unsigned long int phase_step;
+	double amplitude;
+	double ampslope;
+} dds_t;
+
+static inline void dds_set_freq(dds_t *dds, double freq)
+{
+	dds->freq = freq;
+	dds->phase_step = (freq / dds->sample_freq) * 2 * M_PI * ANG_INCR;
+}
+
+static inline void dds_set_amp(dds_t *dds, double amplitude, double ampslope)
+{
+	dds->amplitude = amplitude;
+	dds->ampslope  = ampslope;
+}
+
+dds_t dds_init(double sample_freq, double freq, double phase, double amp)
+{
+	dds_t dds;
+	int i;
+
+	dds.sample_freq = sample_freq;
+	dds.phase = phase * ANG_INCR;
+	dds_set_freq(&dds, freq);
+	dds_set_amp(&dds, amp, 0);
+	/* Initialize sine table, prescaled for 16 bit signed integer */
+	if (!sine_table_init) {
+		double incr = 1.0 / (double)SIN_TABLE_LEN;
+		for (i = 0; i < SIN_TABLE_LEN; i++)
+			sine_table[i] = sin(incr * i * DDS_2PI) * 32767;
+
+		sine_table_init = 1;
+	}
+
+	return dds;
+}
+
+static inline int8_t dds_real(dds_t *dds)
+{
+	int tmp;
+	int32_t amp;
+
+	// advance dds generator
+	tmp = dds->phase >> SIN_TABLE_SHIFT;
+	dds->phase += dds->phase_step;
+	dds->phase &= 0xffffffff;
+
+	amp = (int32_t)(dds->amplitude * 255) * sine_table[tmp];
+	dds->amplitude += dds->ampslope;
+
+	return (int8_t)(amp >> 16) ;
+}
+
+static inline void dds_real_buf(dds_t *dds, int8_t *buf, int count)
+{
+	int i;
+	for (i = 0; i < count; i++)
+		buf[i] = dds_real(dds);
+}
+
+/* Signal generation and some helpers */
+
+/* Generate the radio signal using the pre-calculated amplitude information
+ * in the amp buffer */
+static void *am_worker(void *arg)
+{
+	register double freq;
+	register double tmp;
+	dds_t carrier;
+	int8_t *tmp_ptr;
+	uint32_t len = 0;
+	uint32_t readlen, remaining;
+	int buf_prefilled = 0;
+
+	/* Prepare the oscillators */
+	carrier = dds_init(samp_rate, carrier_freq, 1, 0);
+
+	while (!do_exit) {
+		dds_set_amp(&carrier, ampbuf[readpos], slopebuf[readpos]);
+		readpos++;
+		readpos &= BUFFER_SAMPLES_MASK;
+
+		/* check if we reach the end of the buffer */
+		if ((len + carrier_per_signal) > FL2K_BUF_LEN) {
+			readlen = FL2K_BUF_LEN - len;
+			remaining = carrier_per_signal - readlen;
+			dds_real_buf(&carrier, &ambuf[len], readlen);
+
+			if (buf_prefilled) {
+				/* swap buffers */
+				tmp_ptr = ambuf;
+				ambuf = txbuf;
+				txbuf = tmp_ptr;
+				pthread_cond_wait(&cb_cond, &cb_mutex);
+			}
+
+			dds_real_buf(&carrier, ambuf, remaining);
+			len = remaining;
+
+			buf_prefilled = 1;
+		} else {
+			dds_real_buf(&carrier, &ambuf[len], carrier_per_signal);
+			len += carrier_per_signal;
+		}
+
+		pthread_cond_signal(&am_cond);
+	}
+
+	pthread_exit(NULL);
+}
+
+static inline int writelen(int maxlen)
+{
+	int rp = readpos;
+	int len;
+	int r;
+
+	if (rp < writepos)
+		rp += BUFFER_SAMPLES;
+
+	len = rp - writepos;
+
+	r = len > maxlen ? maxlen : len;
+
+	return r;
+}
+
+static inline int32_t modulate_sample_am(int lastwritepos, double lastamp, int16_t sample)
+{
+	double amp, slope;
+
+	/* Calculate modulator amplitude at this point to lessen
+	 * the calculations needed in the signal generator */
+	amp = 1 - ((double)sample * mod_index);
+
+	/* What we do here is calculate a linear "slope" from
+	the previous sample to this one. This is then used by
+	the modulator to gently increase/decrease the amplitude
+	with each sample without the need to recalculate
+	the dds parameters. In fact this gives us a very
+	efficient and pretty good interpolation filter. */
+	slope = amp - lastamp;
+	slope /= carrier_per_signal;
+	slopebuf[lastwritepos] = slope;
+	ampbuf[writepos]       = amp;
+
+	return amp;
+}
+
+void am_modulator(const int code_input)
+{
+	int counter = 0;
+	int code;
+	unsigned int i;
+	unsigned int b = 0;
+	size_t len;
+	int32_t lastamp = 0;
+	uint32_t lastwritepos = writepos;
+	int16_t sample = 0;
+	int samplebuf_pos = 0;
+
+	/*
+	 *  3*640 us = 1,92 ms pro Symbol
+	 *  12 Symbole Daten (12 Bit)
+	 *  11 Symbole Pause, 1 Symbol 1 (synch)
+	 *
+	 *  1 = __-
+	 *  0 = _--
+	 */
+	while (!do_exit) {
+		len = writelen(AUDIO_BUF_SIZE);
+		if (len > 1) {
+			if (len == 0)
+				do_exit = 1;
+
+			for (i = 0; i < len; i++) {
+				/* Modulate and buffer the sample */
+				sample = sample_buf[samplebuf_pos++];
+				if(samplebuf_pos >= BASEBAND_SAMPLES_PER_CHIP * BASEBAND_CHIPS_TOTAL){
+					samplebuf_pos = 0;
+				}
+				lastamp = modulate_sample_am(lastwritepos, lastamp, sample);
+				lastwritepos = writepos++;
+				writepos %= BUFFER_SAMPLES;
+			}
+		} else {
+			pthread_cond_wait(&am_cond, &am_mutex);
+		}
+	}
+}
+
+void prepare_baseband(const int code_input, int16_t * sbuf){
+	int counter;
+	int b;
+	int sample_no;
+	int16_t sample;
+	int msb_first_code;
+
+	msb_first_code = 0;
+	// change to msb first and invert
+	for(b = 0;b<12;b++){
+		msb_first_code <<= 1;
+		msb_first_code |= code_input & (1<<b) ? 0 : 1;
+	}
+
+	sample_no = 0;
+	for(counter=0;counter < (BASEBAND_CHIPS_PER_SPACE + BASEBAND_CHIPS_PER_WORD) ; counter++){
+		for(b=0 ; b<BASEBAND_SAMPLES_PER_CHIP ; b++){
+			if(counter < (BASEBAND_SPACE_LOW_CHIPS)){
+				sample = 0;
+			}
+			else if(counter < (BASEBAND_CHIPS_PER_SPACE)){
+				// synch symbol
+				sample = 1;
+			}
+			else{
+				int m;
+				m = counter % BASEBAND_CHIPS_PER_BIT;
+				if(m == 0){
+					sample = 0;
+				}
+				else if(m == 1){
+					sample = (msb_first_code & 1);
+				}
+				else{
+					sample = 1;
+					if(b == BASEBAND_SAMPLES_PER_CHIP-1){
+						msb_first_code >>= 1;
+					}
+				}
+			}
+			sbuf[counter * BASEBAND_SAMPLES_PER_CHIP + b] = sample;
+		}
+	}
+}
+
+void fl2k_callback(fl2k_data_info_t *data_info)
+{
+	if (data_info->device_error) {
+		fprintf(stderr, "Device error, exiting.\n");
+		do_exit = 1;
+		pthread_cond_signal(&am_cond);
+	}
+
+	pthread_cond_signal(&cb_cond);
+
+	data_info->sampletype_signed = 1;
+	data_info->r_buf = (char *)txbuf;
+}
+
+int main(int argc, char **argv)
+{
+	int r, opt;
+	uint32_t buf_num = 0;
+	int dev_index = 0;
+	pthread_attr_t attr;
+	char *filename = NULL;
+	int option_index = 0;
+	int code = 0;
+	int chiptime_us = 320;
+
+#ifndef _WIN32
+	struct sigaction sigact, sigign;
+#endif
+
+	static struct option long_options[] =
+	{
+		{0, 0, 0, 0}
+	};
+
+	while (1) {
+		opt = getopt_long(argc, argv, "b:c:f:m:s:", long_options, &option_index);
+		/* end of options reached */
+		if (opt == -1)
+			break;
+
+		switch (opt) {
+		case 0:
+			break;
+		case 'b':
+			chiptime_us = atoi(optarg);
+			break;
+		case 'c':
+			code = atoi(optarg);
+			code &= 4095;
+			break;
+		case 'f':
+			carrier_freq = (uint32_t)atof(optarg);
+			break;
+		case 'm':
+			mod_index = atof(optarg);
+			break;
+		case 's':
+			samp_rate = (uint32_t)atof(optarg);
+			break;
+		default:
+			usage();
+			break;
+		}
+	}
+
+	if (argc < optind) {
+		usage();
+	}
+
+	/* allocate buffer */
+	buf1 = malloc(FL2K_BUF_LEN);
+	buf2 = malloc(FL2K_BUF_LEN);
+	if (!buf1 || !buf2) {
+		fprintf(stderr, "malloc error!\n");
+		exit(1);
+	}
+
+	ambuf = buf1;
+	txbuf = buf2;
+
+	/* Decoded audio */
+	slopebuf 	= malloc(BUFFER_SAMPLES * sizeof(double));
+	ampbuf  	= malloc(BUFFER_SAMPLES * sizeof(double));
+	slopebuf    = malloc(BUFFER_SAMPLES * sizeof(double));
+	sample_buf  = malloc((BASEBAND_SAMPLES_PER_CHIP * BASEBAND_CHIPS_TOTAL) * sizeof(int16_t));
+	readpos 	= 0;
+	writepos 	= 1;
+
+	fprintf(stderr, "Samplerate:\t%3.2f MHz\n", (double)samp_rate/1000000);
+	fprintf(stderr, "Carrier:\t%3.3f MHz\n", (double)carrier_freq/1000000);
+	fprintf(stderr, "Mod Index:\t%3.1f %%\n",
+					(double)(mod_index * 100));
+	fprintf(stderr, "Chip period:\t%d us\n", chiptime_us);
+
+	pthread_mutex_init(&cb_mutex, NULL);
+	pthread_mutex_init(&am_mutex, NULL);
+	pthread_cond_init(&cb_cond, NULL);
+	pthread_cond_init(&am_cond, NULL);
+	pthread_attr_init(&attr);
+
+	prepare_baseband(code, sample_buf);
+
+	fl2k_open(&dev, (uint32_t)dev_index);
+	if (NULL == dev) {
+		fprintf(stderr, "Failed to open fl2k device #%d.\n", dev_index);
+		goto out;
+	}
+
+	r = pthread_create(&am_thread, &attr, am_worker, NULL);
+	if (r < 0) {
+		fprintf(stderr, "Error spawning AM worker thread!\n");
+		goto out;
+	}
+
+	pthread_attr_destroy(&attr);
+	r = fl2k_start_tx(dev, fl2k_callback, NULL, 0);
+
+	/* Set the sample rate */
+	r = fl2k_set_sample_rate(dev, samp_rate);
+	if (r < 0)
+		fprintf(stderr, "WARNING: Failed to set sample rate. %d\n", r);
+
+	/* read back actual frequency */
+	samp_rate = fl2k_get_sample_rate(dev);
+
+	/* Calculate needed constants */
+	carrier_per_signal = (int)((double) samp_rate * chiptime_us/(1000000*BASEBAND_SAMPLES_PER_CHIP) + 0.5);
+	printf("Cps :\t%d\n", carrier_per_signal);
+#ifndef _WIN32
+	sigact.sa_handler = sighandler;
+	sigemptyset(&sigact.sa_mask);
+	sigact.sa_flags = 0;
+	sigign.sa_handler = SIG_IGN;
+	sigaction(SIGINT, &sigact, NULL);
+	sigaction(SIGTERM, &sigact, NULL);
+	sigaction(SIGQUIT, &sigact, NULL);
+	sigaction(SIGPIPE, &sigign, NULL);
+#else
+	SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
+#endif
+
+	am_modulator(code);
+
+out:
+	fl2k_close(dev);
+
+	free(ampbuf);
+	free(slopebuf);
+	free(buf1);
+	free(buf2);
+
+	return 0;
+}
diff --git a/src/fl2k_iq.c b/src/fl2k_iq.c
new file mode 100644
index 0000000..2dce59b
--- /dev/null
+++ b/src/fl2k_iq.c
@@ -0,0 +1,525 @@
+/*
+ * osmo-fl2k, turns FL2000-based USB 3.0 to VGA adapters into
+ * low cost DACs
+ *
+ * fl2k-iq
+ * Copyright (C) 2020 by Felix Erckenbrecht <eligs@eligs.de>
+ *
+ * based on fl2k-fm code:
+ * Copyright (C) 2016-2018 by Steve Markgraf <steve@steve-m.de>
+ *
+ * based on FM modulator code from VGASIG:
+ * Copyright (C) 2009 by Bartek Kania <mbk@gnarf.org>
+ *
+ * SPDX-License-Identifier: GPL-2.0+
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <string.h>
+#include <errno.h>
+
+#ifndef _WIN32
+#include <unistd.h>
+#include <fcntl.h>
+#include <getopt.h>
+#else
+#include <windows.h>
+#include <io.h>
+#include <fcntl.h>
+#include "getopt/getopt.h"
+#endif
+
+#include <math.h>
+#include <complex.h>
+#include <pthread.h>
+
+#include "osmo-fl2k.h"
+#include "rds_mod.h"
+
+#define BUFFER_SAMPLES_SHIFT	16
+#define BUFFER_SAMPLES		(1 << BUFFER_SAMPLES_SHIFT)
+#define BUFFER_SAMPLES_MASK	((1 << BUFFER_SAMPLES_SHIFT)-1)
+
+#define BASEBAND_BUF_SIZE		2048
+
+fl2k_dev_t *dev = NULL;
+volatile int do_exit = 0;
+
+pthread_t iq_thread;
+pthread_mutex_t cb_mutex;
+pthread_mutex_t iq_mutex;
+pthread_cond_t cb_cond;
+pthread_cond_t iq_cond;
+
+FILE *file;
+int8_t *txbuf = NULL;
+int8_t *ambuf = NULL;
+int8_t *buf1 = NULL;
+int8_t *buf2 = NULL;
+
+uint32_t samp_rate = 96000000;
+
+int base_freq = 1440000;
+int rf_to_baseband_sample_ratio;
+int input_freq = 48000;
+
+complex float *ampbuf;
+complex float *slopebuf;
+int writepos, readpos;
+int swap_iq = 0;
+
+void usage(void)
+{
+	fprintf(stderr,
+        "fl2k_iq, an IQ modulator for FL2K VGA dongles\n\n"
+        "Usage:"
+        "\t[-d device index (default: 0)]\n"
+        "\t[-c center frequency (default: 1440 kHz)]\n"
+        "\t[-i input baseband sample rate (default: 48000 Hz)]\n"
+        "\t[-s samplerate in Hz (default: 96 MS/s)]\n"
+        "\t[-w swap I & Q (invert spectrum)\n"
+        "\tfilename (use '-' to read from stdin)\n\n"
+	);
+	exit(1);
+}
+
+#ifdef _WIN32
+BOOL WINAPI
+sighandler(int signum)
+{
+	if (CTRL_C_EVENT == signum) {
+		fprintf(stderr, "Signal caught, exiting!\n");
+		fl2k_stop_tx(dev);
+		do_exit = 1;
+		pthread_cond_signal(&iq_cond);
+		return TRUE;
+	}
+	return FALSE;
+}
+#else
+static void sighandler(int signum)
+{
+	fprintf(stderr, "Signal caught, exiting!\n");
+	fl2k_stop_tx(dev);
+	do_exit = 1;
+	pthread_cond_signal(&iq_cond);
+}
+#endif
+
+/* DDS Functions */
+
+#ifndef M_PI
+# define M_PI		3.14159265358979323846	/* pi */
+# define M_PI_2		1.57079632679489661923	/* pi/2 */
+# define M_PI_4		0.78539816339744830962	/* pi/4 */
+# define M_1_PI		0.31830988618379067154	/* 1/pi */
+# define M_2_PI		0.63661977236758134308	/* 2/pi */
+#endif
+#define DDS_2PI		(M_PI * 2)		/* 2 * Pi */
+#define DDS_3PI2	(M_PI_2 * 3)		/* 3/2 * pi */
+
+#define TRIG_TABLE_ORDER	8
+#define TRIG_TABLE_SHIFT	(32 - TRIG_TABLE_ORDER)
+#define TRIG_TABLE_LEN	(1 << TRIG_TABLE_ORDER)
+#define ANG_INCR	(0xffffffff / DDS_2PI)
+
+struct trigonometric_table_S {
+    int     initialized;
+    int16_t sine[TRIG_TABLE_LEN];
+    int16_t cosine[TRIG_TABLE_LEN];
+};
+
+static struct trigonometric_table_S trig_table = { .initialized = 0 };
+
+typedef struct {
+	float sample_freq;
+	float freq;
+	unsigned long int phase;
+	unsigned long int phase_step;
+	complex float amplitude;
+	complex float ampslope;
+} dds_t;
+
+static inline void dds_set_freq(dds_t *dds, float freq)
+{
+	dds->freq = freq;
+	dds->phase_step = (freq / dds->sample_freq) * 2 * M_PI * ANG_INCR;
+}
+
+static inline void dds_set_amp(dds_t *dds, complex float amplitude, complex float ampslope)
+{
+	dds->amplitude = amplitude;
+	dds->ampslope  = ampslope;
+}
+
+dds_t dds_init(float sample_freq, float freq, float phase, float amp)
+{
+	dds_t dds;
+	int i;
+
+	dds.sample_freq = sample_freq;
+	dds.phase = phase * ANG_INCR;
+	dds_set_freq(&dds, freq);
+	dds_set_amp(&dds, amp, 0);
+	/* Initialize sine table, prescaled for 16 bit signed integer */
+	if (!trig_table.initialized) {
+		float incr = 1.0 / (float)TRIG_TABLE_LEN;
+		for (i = 0; i < TRIG_TABLE_LEN; i++){
+			trig_table.sine[i]   = sin(incr * i * DDS_2PI) * 32767;
+            trig_table.cosine[i] = cos(incr * i * DDS_2PI) * 32767;
+		}
+
+		trig_table.initialized = 1;
+	}
+
+	return dds;
+}
+
+static inline int8_t dds_real(dds_t *dds)
+{
+	int tmp;
+	int32_t amp_i, amp_q;
+	int8_t amp8;
+
+	// advance dds generator
+	tmp = dds->phase >> TRIG_TABLE_SHIFT;
+	dds->phase += dds->phase_step;
+	dds->phase &= 0xffffffff;
+
+	//amp = 255;
+	amp_i = creal(dds->amplitude) * 23170.0;		// 0..15, * 1/SQRT(2)
+	amp_q = cimag(dds->amplitude) * 23170.0;
+	amp_i = amp_i * trig_table.sine[tmp];           // 0..31, * 1/SQRT(2)
+    amp_q = amp_q * trig_table.cosine[tmp];         // 0..31, * 1/SQRT(2)
+	amp8 = (int8_t) ((amp_i + amp_q) >> 24);        // 0..31 >> 24 => 0..8
+	dds->amplitude += dds->ampslope;
+	return amp8;
+}
+
+static inline void dds_real_buf(dds_t *dds, int8_t *buf, int count)
+{
+	int i;
+	for (i = 0; i < count; i++)
+		buf[i] = dds_real(dds);
+}
+
+/* Signal generation and some helpers */
+
+/* Generate the radio signal using the pre-calculated amplitude information
+ * in the amp buffer */
+static void *iq_worker(void *arg)
+{
+	register float freq;
+	register float tmp;
+	dds_t base_signal;
+	int8_t *tmp_ptr;
+	uint32_t len = 0;
+	uint32_t readlen, remaining;
+	int buf_prefilled = 0;
+
+	/* Prepare the oscillators */
+	base_signal = dds_init(samp_rate, base_freq, 0, 1);
+
+	while (!do_exit) {
+		dds_set_amp(&base_signal, ampbuf[readpos], slopebuf[readpos]);
+		readpos++;
+		readpos &= BUFFER_SAMPLES_MASK;
+
+		/* check if we reach the end of the buffer */
+		if ((len + rf_to_baseband_sample_ratio) > FL2K_BUF_LEN) {
+			readlen = FL2K_BUF_LEN - len;
+			remaining = rf_to_baseband_sample_ratio - readlen;
+			dds_real_buf(&base_signal, &ambuf[len], readlen);
+
+			if (buf_prefilled) {
+				/* swap buffers */
+				tmp_ptr = ambuf;
+				ambuf = txbuf;
+				txbuf = tmp_ptr;
+				pthread_mutex_lock(&cb_mutex);
+				pthread_cond_wait(&cb_cond, &cb_mutex);
+				pthread_mutex_unlock(&cb_mutex);
+			}
+
+			dds_real_buf(&base_signal, ambuf, remaining);
+			len = remaining;
+
+			buf_prefilled = 1;
+		} else {
+			dds_real_buf(&base_signal, &ambuf[len], rf_to_baseband_sample_ratio);
+			len += rf_to_baseband_sample_ratio;
+		}
+		pthread_mutex_lock(&iq_mutex);
+		pthread_cond_signal(&iq_cond);
+		pthread_mutex_unlock(&iq_mutex);
+	}
+
+	pthread_exit(NULL);
+}
+
+static inline int writelen(int maxlen)
+{
+	int rp = readpos;
+	int len;
+	int r;
+
+	if (rp < writepos)
+		rp += BUFFER_SAMPLES;
+
+	len = rp - writepos;
+
+	r = len > maxlen ? maxlen : len;
+
+	return r;
+}
+
+static inline float complex modulate_sample_iq(const int lastwritepos, const float complex lastamp, const float complex sample)
+{
+	float complex amp;
+	float complex slope;
+
+	/* Calculate modulator amplitudes at this point to lessen
+	 * the calculations needed in the signal generator */
+	amp = sample;
+
+	/* What we do here is calculate a linear "slope" from
+	the previous sample to this one. This is then used by
+	the modulator to gently increase/decrease the amplitude
+	with each sample without the need to recalculate
+	the dds parameters. In fact this gives us a very
+	efficient and pretty good interpolation filter. */
+	slope = amp - lastamp;
+	slope = slope * 1.0/ (float) rf_to_baseband_sample_ratio;
+	slopebuf[writepos] = slope;
+	ampbuf[writepos]   = lastamp;
+
+	return amp;
+}
+
+
+void iq_modulator()
+{
+	unsigned int i;
+	size_t len;
+	float freq;
+	float complex lastamp = 0;
+	int16_t baseband_buf[BASEBAND_BUF_SIZE][2];
+	uint32_t lastwritepos = writepos;
+	float complex sample;
+
+	while (!do_exit) {
+		int swap = swap_iq;
+		len = writelen(BASEBAND_BUF_SIZE);
+		if (len > 1) {
+			len = fread(baseband_buf, 4, len, file);
+
+			if (len == 0){
+				if(ferror(file)){
+					do_exit = 1;
+				}
+			}
+
+			for (i = 0; i < len; i++) {
+				sample = (float) baseband_buf[i][0+swap] / 32768.0 + I * (float) baseband_buf[i][1-swap] / 32768.0;
+
+				/* Modulate and buffer the sample */
+				lastamp = modulate_sample_iq(lastwritepos, lastamp, sample);
+				lastwritepos = writepos++;
+				writepos %= BUFFER_SAMPLES;
+			}
+		} else {
+			pthread_mutex_lock(&iq_mutex);
+			pthread_cond_wait(&iq_cond, &iq_mutex);
+			pthread_mutex_unlock(&iq_mutex);
+		}
+	}
+}
+
+
+void fl2k_callback(fl2k_data_info_t *data_info)
+{
+	if (data_info->device_error) {
+		fprintf(stderr, "Device error, exiting.\n");
+		do_exit = 1;
+		pthread_mutex_lock(&iq_mutex);
+		pthread_cond_signal(&iq_cond);
+		pthread_mutex_unlock(&iq_mutex);
+	}
+
+	pthread_cond_signal(&cb_cond);
+
+	data_info->sampletype_signed = 1;
+	data_info->r_buf = (char *)txbuf;
+}
+
+int main(int argc, char **argv)
+{
+	int r, opt;
+	uint32_t buf_num = 0;
+	int dev_index = 0;
+	pthread_attr_t attr;
+	char *filename = NULL;
+	int option_index = 0;
+	int input_freq_specified = 0;
+
+#ifndef _WIN32
+	struct sigaction sigact, sigign;
+#endif
+
+	static struct option long_options[] =
+	{
+		{0, 0, 0, 0}
+	};
+
+	while (1) {
+		opt = getopt_long(argc, argv, "wd:c:i:s:", long_options, &option_index);
+
+		/* end of options reached */
+		if (opt == -1)
+			break;
+
+		switch (opt) {
+		case 0:
+			break;
+		case 'd':
+			dev_index = (uint32_t)atoi(optarg);
+			break;
+		case 'c':
+			base_freq = (uint32_t)atof(optarg);
+			break;
+		case 'i':
+			input_freq = (uint32_t)atof(optarg);
+			input_freq_specified = 1;
+			break;
+		case 's':
+			samp_rate = (uint32_t)atof(optarg);
+			break;
+		case 'w':
+			swap_iq = 1;
+			break;
+		default:
+			usage();
+			break;
+		}
+	}
+
+	if (argc <= optind) {
+		usage();
+	} else {
+		filename = argv[optind];
+	}
+
+	if (dev_index < 0) {
+		exit(1);
+	}
+
+	if (strcmp(filename, "-") == 0) { /* Read samples from stdin */
+		file = stdin;
+#ifdef _WIN32
+		_setmode(_fileno(stdin), _O_BINARY);
+#endif
+	} else {
+		file = fopen(filename, "rb");
+		if (!file) {
+			fprintf(stderr, "Failed to open %s\n", filename);
+			return -ENOENT;
+		}
+	}
+
+	/* allocate buffer */
+	buf1 = malloc(FL2K_BUF_LEN);
+	buf2 = malloc(FL2K_BUF_LEN);
+	if (!buf1 || !buf2) {
+		fprintf(stderr, "malloc error!\n");
+		exit(1);
+	}
+
+	ambuf = buf1;
+	txbuf = buf2;
+
+	/* Decoded audio */
+	slopebuf 	= malloc(BUFFER_SAMPLES * sizeof(float complex));
+	ampbuf  	= malloc(BUFFER_SAMPLES * sizeof(float complex));
+	readpos 	= 0;
+	writepos 	= 1;
+
+	fprintf(stderr, "Samplerate:       %3.2f MHz\n", (float)samp_rate/1000000);
+	fprintf(stderr, "Center frequency: %5.0f kHz\n", (float)base_freq/1000);
+	if(swap_iq)
+		fprintf(stderr, "Spectral inversion active.\n");
+
+	pthread_mutex_init(&cb_mutex, NULL);
+	pthread_mutex_init(&iq_mutex, NULL);
+	pthread_cond_init(&cb_cond, NULL);
+	pthread_cond_init(&iq_cond, NULL);
+	pthread_attr_init(&attr);
+
+	fl2k_open(&dev, (uint32_t)dev_index);
+	if (NULL == dev) {
+		fprintf(stderr, "Failed to open fl2k device #%d.\n", dev_index);
+		goto out;
+	}
+
+	r = pthread_create(&iq_thread, &attr, iq_worker, NULL);
+	if (r < 0) {
+		fprintf(stderr, "Error spawning IQ worker thread!\n");
+		goto out;
+	}
+
+	pthread_attr_destroy(&attr);
+	r = fl2k_start_tx(dev, fl2k_callback, NULL, 0);
+
+	/* Set the sample rate */
+	r = fl2k_set_sample_rate(dev, samp_rate);
+	if (r < 0)
+		fprintf(stderr, "WARNING: Failed to set sample rate. %d\n", r);
+
+	/* read back actual frequency */
+	samp_rate = fl2k_get_sample_rate(dev);
+
+	/* Calculate needed constants */
+	rf_to_baseband_sample_ratio = samp_rate / input_freq;
+
+#ifndef _WIN32
+	sigact.sa_handler = sighandler;
+	sigemptyset(&sigact.sa_mask);
+	sigact.sa_flags = 0;
+	sigign.sa_handler = SIG_IGN;
+	sigaction(SIGINT, &sigact, NULL);
+	sigaction(SIGTERM, &sigact, NULL);
+	sigaction(SIGQUIT, &sigact, NULL);
+	sigaction(SIGPIPE, &sigign, NULL);
+#else
+	SetConsoleCtrlHandler( (PHANDLER_ROUTINE) sighandler, TRUE );
+#endif
+
+	iq_modulator();
+
+out:
+	fl2k_close(dev);
+
+	if (file != stdin)
+		fclose(file);
+
+	free(ampbuf);
+	free(slopebuf);
+	free(buf1);
+	free(buf2);
+
+	return 0;
+}
diff --git a/src/fl2k_tcp.c b/src/fl2k_tcp.c
index bd01758..871ac26 100644
--- a/src/fl2k_tcp.c
+++ b/src/fl2k_tcp.c
@@ -107,6 +107,12 @@ void fl2k_callback(fl2k_data_info_t *data_info)
 	int r;
 	struct timeval tv = { 1, 0 };
 
+	if (data_info->device_error) {
+		fprintf(stderr, "Device error, exiting.\n");
+		do_exit = 1;
+		return;
+	}
+
 	if (!connected)
 		return;
 
@@ -122,6 +128,12 @@ void fl2k_callback(fl2k_data_info_t *data_info)
 
 		if (r) {
 			received = recv(sock, txbuf + (FL2K_BUF_LEN - left), left, 0);
+			if (!received) {
+				fprintf(stderr, "Connection was closed!\n");
+				fl2k_stop_tx(dev);
+				do_exit = 1;
+			}
+
 			left -= received;
 		}
 	}
@@ -233,8 +245,8 @@ int main(int argc, char **argv)
 		sleep_ms(500);
 
 out:
-	free(txbuf);
 	fl2k_close(dev);
+	free(txbuf);
 	closesocket(s);
 #ifdef _WIN32
 	WSACleanup();
diff --git a/src/fl2k_test.c b/src/fl2k_test.c
index 6d82922..b166dda 100644
--- a/src/fl2k_test.c
+++ b/src/fl2k_test.c
@@ -213,6 +213,12 @@ static void ppm_test(uint32_t len)
 
 void fl2k_callback(fl2k_data_info_t *data_info)
 {
+	if (data_info->device_error) {
+		fprintf(stderr, "Device error, exiting.\n");
+		do_exit = 1;
+		return;
+	}
+
 	/* drop first couple of callbacks until everything is settled */
 	if (cb_cnt > 20) {
 		ppm_test(FL2K_BUF_LEN);
@@ -222,7 +228,6 @@ void fl2k_callback(fl2k_data_info_t *data_info)
 		data_info->r_buf = buffer;
 		cb_cnt++;
 	}
-
 }
 
 int main(int argc, char **argv)
@@ -295,9 +300,6 @@ int main(int argc, char **argv)
 	while (!do_exit)
 		sleep_ms(500);
 
-	if (do_exit)
-		fprintf(stderr, "\nUser cancel, exiting...\n");
-
 exit:
 	fl2k_close(dev);
 	free(buffer);
diff --git a/src/libosmo-fl2k.c b/src/libosmo-fl2k.c
index c5959c3..3e166e0 100644
--- a/src/libosmo-fl2k.c
+++ b/src/libosmo-fl2k.c
@@ -2,7 +2,7 @@
  * osmo-fl2k, turns FL2000-based USB 3.0 to VGA adapters into
  * low cost DACs
  *
- * Copyright (C) 2016-2018 by Steve Markgraf <steve@steve-m.de>
+ * Copyright (C) 2016-2020 by Steve Markgraf <steve@steve-m.de>
  *
  * SPDX-License-Identifier: GPL-2.0+
  *
@@ -250,9 +250,9 @@ int fl2k_set_sample_rate(fl2k_dev_t *dev, uint32_t target_freq)
 				error = sample_clock - (double)target_freq;
 
 				/* Keep closest match */
-				if (fabsf(error) < last_error) {
+				if (fabs(error) < last_error) {
 					result_reg = reg;
-					last_error = fabsf(error);
+					last_error = fabs(error);
 				}
 			}
 		}
@@ -262,7 +262,7 @@ int fl2k_set_sample_rate(fl2k_dev_t *dev, uint32_t target_freq)
 	error = sample_clock - (double)target_freq;
 	dev->rate = sample_clock;
 
-	if (fabsf(error) > 1)
+	if (fabs(error) > 1)
 		fprintf(stderr, "Requested sample rate %d not possible, using"
 		                " %f, error is %f\n", target_freq, sample_clock, error); 
 
@@ -444,11 +444,16 @@ int fl2k_open(fl2k_dev_t **out_dev, uint32_t index)
 		fprintf(stderr, "usb_claim_interface 0 error %d\n", r);
 		goto err;
 	}
-	r = libusb_claim_interface(dev->devh, 1);
 
+	r = libusb_set_interface_alt_setting(dev->devh, 0, 1);
 	if (r < 0) {
-		fprintf(stderr, "usb_claim_interface 1 error %d\n", r);
-		goto err;
+		fprintf(stderr, "Failed to switch interface 0 to "
+				"altsetting 1, trying to use interface 1\n");
+
+		r = libusb_claim_interface(dev->devh, 1);
+		if (r < 0) {
+			fprintf(stderr, "Could not claim interface 1: %d\n", r);
+		}
 	}
 
 	r = fl2k_init_device(dev);
@@ -529,6 +534,7 @@ static void LIBUSB_CALL _libusb_callback(struct libusb_transfer *xfer)
 	fl2k_xfer_info_t *next_xfer_info;
 	fl2k_dev_t *dev = (fl2k_dev_t *)xfer_info->dev;
 	struct libusb_transfer *next_xfer = NULL;
+	int r = 0;
 
 	if (LIBUSB_TRANSFER_COMPLETED == xfer->status) {
 		/* resubmit transfer */
@@ -541,8 +547,7 @@ static void LIBUSB_CALL _libusb_callback(struct libusb_transfer *xfer)
 
 				/* Submit next filled transfer */
 				next_xfer_info->state = BUF_SUBMITTED;
-				libusb_submit_transfer(next_xfer);
-
+				r = libusb_submit_transfer(next_xfer);
 				xfer_info->state = BUF_EMPTY;
 				pthread_cond_signal(&dev->buf_cond);
 			} else {
@@ -551,17 +556,21 @@ static void LIBUSB_CALL _libusb_callback(struct libusb_transfer *xfer)
 				 * stops to output data and hangs
 				 * (happens only in the hacked 'gapless'
 				 * mode without HSYNC and VSYNC)  */
-				libusb_submit_transfer(xfer);
+				r = libusb_submit_transfer(xfer);
 				pthread_cond_signal(&dev->buf_cond);
 				dev->underflow_cnt++;
 			}
 		}
-	} else if (LIBUSB_TRANSFER_CANCELLED != xfer->status) {
+	}
+
+	if (((LIBUSB_TRANSFER_CANCELLED != xfer->status) &&
+	     (LIBUSB_TRANSFER_COMPLETED != xfer->status)) ||
+	     (r == LIBUSB_ERROR_NO_DEVICE)) {
 			dev->dev_lost = 1;
 			fl2k_stop_tx(dev);
 			pthread_cond_signal(&dev->buf_cond);
-			fprintf(stderr, "cb transfer status: %d, "
-				"canceling...\n", xfer->status);
+			fprintf(stderr, "cb transfer status: %d, submit "
+				"transfer %d, canceling...\n", xfer->status, r);
 	}
 }
 
@@ -569,6 +578,10 @@ static int fl2k_alloc_submit_transfers(fl2k_dev_t *dev)
 {
 	unsigned int i;
 	int r = 0;
+	const char *incr_usbfs = "Please increase your allowed usbfs buffer"
+				 " size with the following command:\n"
+				 "echo 0 > /sys/module/usbcore/parameters/"
+				 "usbfs_memory_mb\n";
 
 	if (!dev)
 		return FL2K_ERROR_INVALID_PARAM;
@@ -609,8 +622,9 @@ static int fl2k_alloc_submit_transfers(fl2k_dev_t *dev)
 			}
 		} else {
 			fprintf(stderr, "Failed to allocate zero-copy "
-					"buffer for transfer %d\nFalling "
-					"back to buffers in userspace\n", i);
+					"buffer for transfer %d\n%sFalling "
+					"back to buffers in userspace\n",
+					i, incr_usbfs);
 			dev->use_zerocopy = 0;
 			break;
 		}
@@ -664,12 +678,8 @@ static int fl2k_alloc_submit_transfers(fl2k_dev_t *dev)
 		dev->xfer_info[i].state = BUF_SUBMITTED;
 
 		if (r < 0) {
-			fprintf(stderr, "Failed to submit transfer %i\n"
-					"Please increase your allowed " 
-					"usbfs buffer size with the "
-					"following command:\n"
-					"echo 0 > /sys/module/usbcore"
-					"/parameters/usbfs_memory_mb\n", i);
+			fprintf(stderr, "Failed to submit transfer %i\n%s",
+					i, incr_usbfs);
 			break;
 		}
 	}
@@ -777,6 +787,11 @@ static void *fl2k_usb_worker(void *arg)
 		}
 	}
 
+	/* wake up sample worker */
+	pthread_cond_signal(&dev->buf_cond);
+
+	/* wait for sample worker thread to finish before freeing buffers */
+	pthread_join(dev->sample_worker_thread, NULL);  
 	_fl2k_free_async_buffers(dev);
 	dev->async_status = next_status;
 
@@ -954,7 +969,6 @@ static void *fl2k_sample_worker(void *arg)
 	if (dev->dev_lost && dev->cb) {
 		data_info.device_error = 1;
 		dev->cb(&data_info);
-		fl2k_stop_tx(dev);
 	}
 
 	pthread_exit(NULL);
diff --git a/src/rds_mod.c b/src/rds_mod.c
index 8e31b0d..687aa65 100644
--- a/src/rds_mod.c
+++ b/src/rds_mod.c
@@ -38,8 +38,8 @@ extern double waveform_biphase[576];
 struct {
 	uint16_t pi;
 	int ta;
-	char ps[PS_LENGTH];
-	char rt[RT_LENGTH];
+	char ps[PS_LENGTH+1];
+	char rt[RT_LENGTH+1];
 } rds_params = { 0 };
 
 /* The RDS error-detection code generator polynomial is