treewide: remove FSF address

Remove the paragraph about writing to the Free Software Foundation's
mailing address. The FSF has changed addresses in the past, and may do
so again. In 2021 this is not useful, let's rather have a bit less
boilerplate at the start of source files.

Change-Id: I8ba71ab9ccde4ba25151ecbeb2a323f706b57d43

.gitignore

@@ -5,6 +5,9 @@
 Transceiver52M/osmo-trx-uhd
 Transceiver52M/osmo-trx-usrp1
 Transceiver52M/osmo-trx-lms
+Transceiver52M/osmo-trx-ipc
+
+.clang-format
 
 # tests
 tests/CommonLibs/BitVectorTest
@@ -19,6 +22,7 @@ tests/CommonLibs/VectorTest
 tests/CommonLibs/PRBSTest
 tests/Transceiver52M/convolve_test
 tests/Transceiver52M/LMSDeviceTest
+Transceiver52M/device/ipc/ipc-driver-test
 
 # automake/autoconf
 *.in
@@ -60,6 +64,13 @@ doc/manuals/*.pdf
 doc/manuals/*__*.png
 doc/manuals/*.check
 doc/manuals/generated/
-doc/manuals/osmomsc-usermanual.xml
+doc/manuals/vty/osmotrx-*-vty-reference.xml
+doc/manuals/vty/osmotrx-*-vty-reference.xml.inc.gen
+doc/manuals/vty/osmotrx-*-vty-reference.xml.inc.merged
 doc/manuals/common
 doc/manuals/build
+
+contrib/osmo-trx.spec
+!contrib/osmo-trx.spec.in
+
+utils/osmo-prbs-tool

CommonLibs/Logger.h

@@ -50,19 +50,19 @@ extern "C" {
 #endif
 
 #define LOG(level) \
-	Log(DMAIN, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[tid=" << pthread_self() << "] "
+	Log(DMAIN, LOGL_##level, __BASE_FILE__, __LINE__).get()
 
 #define LOGC(category, level) \
-	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[tid=" << pthread_self() << "] "
+	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get()
 
 #define LOGLV(category, level) \
-	Log(category, level, __BASE_FILE__, __LINE__).get() <<  "[tid=" << pthread_self() << "] "
+	Log(category, level, __BASE_FILE__, __LINE__).get()
 
 #define LOGSRC(category, level, file, line) \
-	Log(category, level, file, line).get() <<  "[tid=" << pthread_self() << "] "
+	Log(category, level, file, line).get()
 
 #define LOGCHAN(chan, category, level) \
-	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[tid=" << pthread_self() << "][chan=" << chan << "] "
+	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[chan=" << chan << "] "
 
 /**
 	A C++ stream-based thread-safe logger.

CommonLibs/PRBS.h

@@ -12,10 +12,6 @@
  * 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
  */
 
 #ifndef PRBS_H

CommonLibs/Threads.cpp

@@ -32,11 +32,9 @@
 #include "Timeval.h"
 #include "Logger.h"
 
-#ifndef gettid
-#include <sys/syscall.h>
-#define gettid() syscall(SYS_gettid)
-#endif
-
+extern "C" {
+#include <osmocom/core/thread.h>
+}
 
 using namespace std;
 
@@ -51,7 +49,7 @@ void lockCout()
 {
 	gStreamLock.lock();
 	Timeval entryTime;
-	cout << entryTime << " " << pthread_self() << ": ";
+	cout << entryTime << " " << osmo_gettid() << ": ";
 }
 
 
@@ -66,7 +64,7 @@ void lockCerr()
 {
 	gStreamLock.lock();
 	Timeval entryTime;
-	cerr << entryTime << " " << pthread_self() << ": ";
+	cerr << entryTime << " " << osmo_gettid() << ": ";
 }
 
 void unlockCerr()
@@ -114,7 +112,7 @@ void Signal::wait(Mutex& wMutex, unsigned timeout) const
 void set_selfthread_name(const char *name)
 {
 	pthread_t selfid = pthread_self();
-	pid_t tid = gettid();
+	pid_t tid = osmo_gettid();
 	if (pthread_setname_np(selfid, name) == 0) {
 		LOG(INFO) << "Thread "<< selfid << " (task " << tid << ") set name: " << name;
 	} else {

CommonLibs/Utils.cpp

@@ -12,10 +12,6 @@
  * 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
  */
 
 #include <vector>

CommonLibs/Utils.h

@@ -12,10 +12,6 @@
  * 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
  */
 
 #pragma once

CommonLibs/Vector.h

@@ -36,6 +36,11 @@
 #include <assert.h>
 #include <stdlib.h>
 
+#ifndef __OPTIMIZE__
+#define assert_no_opt(x) assert(x)
+#else
+#define assert_no_opt(x)
+#endif
 // We can't use Logger.h in this file...
 extern int gVectorDebug;
 #define BVDEBUG(msg) if (gVectorDebug) {std::cout << msg;}
@@ -81,8 +86,8 @@ template <class T> class Vector {
 	/** Return the size of the Vector. */
 	size_t size() const
 	{
-		assert(mStart>=mData);
-		assert(mEnd>=mStart);
+		assert_no_opt(mStart>=mData);
+		assert_no_opt(mEnd>=mStart);
 		return mEnd - mStart;
 	}
 
@@ -112,7 +117,7 @@ template <class T> class Vector {
 	/** Reduce addressable size of the Vector, keeping content. */
 	void shrink(size_t newSize)
 	{
-		assert(newSize <= mEnd - mStart);
+		assert_no_opt(newSize <= mEnd - mStart);
 		mEnd = mStart + newSize;
 	}
 
@@ -199,7 +204,7 @@ template <class T> class Vector {
 	{
 		T* wStart = mStart + start;
 		T* wEnd = wStart + span;
-		assert(wEnd<=mEnd);
+		assert_no_opt(wEnd<=mEnd);
 		return Vector<T>(NULL,wStart,wEnd);
 	}
 
@@ -208,7 +213,7 @@ template <class T> class Vector {
 	{
 		T* wStart = mStart + start;
 		T* wEnd = wStart + span;
-		assert(wEnd<=mEnd);
+		assert_no_opt(wEnd<=mEnd);
 		return Vector<T>(NULL,wStart,wEnd);
 	}
 
@@ -228,8 +233,8 @@ template <class T> class Vector {
 		unsigned int i;
 		T* dst = other.mStart + start;
 		T* src = mStart;
-		assert(dst+span<=other.mEnd);
-		assert(mStart+span<=mEnd);
+		assert_no_opt(dst+span<=other.mEnd);
+		assert_no_opt(mStart+span<=mEnd);
 		for (i = 0; i < span; i++, src++, dst++)
 			*dst = *src;
 		/*TODO if not non-trivially copiable type class, optimize:
@@ -250,8 +255,8 @@ template <class T> class Vector {
 	void segmentCopyTo(Vector<T>& other, size_t start, size_t span) const
 	{
 		const T* base = mStart + start;
-		assert(base+span<=mEnd);
-		assert(other.mStart+span<=other.mEnd);
+		assert_no_opt(base+span<=mEnd);
+		assert_no_opt(other.mStart+span<=other.mEnd);
 		memcpy(other.mStart,base,span*sizeof(T));
 	}
 
@@ -265,8 +270,8 @@ template <class T> class Vector {
 	{
 		const T* baseFrom = mStart + from;
 		T* baseTo = mStart + to;
-		assert(baseFrom+span<=mEnd);
-		assert(baseTo+span<=mEnd);
+		assert_no_opt(baseFrom+span<=mEnd);
+		assert_no_opt(baseTo+span<=mEnd);
 		memmove(baseTo,baseFrom,span*sizeof(T));
 	}
 
@@ -280,7 +285,7 @@ template <class T> class Vector {
 	{
 		T* dp=mStart+start;
 		T* end=dp+length;
-		assert(end<=mEnd);
+		assert_no_opt(end<=mEnd);
 		while (dp<end) *dp++=val;
 	}
 
@@ -292,13 +297,13 @@ template <class T> class Vector {
 
 	T& operator[](size_t index)
 	{
-		assert(mStart+index<mEnd);
+		assert_no_opt(mStart+index<mEnd);
 		return mStart[index];
 	}
 
 	const T& operator[](size_t index) const
 	{
-		assert(mStart+index<mEnd);
+		assert_no_opt(mStart+index<mEnd);
 		return mStart[index];
 	}
 

CommonLibs/config_defs.h

@@ -5,6 +5,8 @@
  * osmo-trx (CXX, dir Transceiver52)
  */
 
+#include <stdbool.h>
+
 enum FillerType {
   FILLER_DUMMY,
   FILLER_ZERO,
@@ -18,3 +20,41 @@ enum ReferenceType {
   REF_EXTERNAL,
   REF_GPS,
 };
+
+/* Maximum number of physical RF channels */
+#define TRX_CHAN_MAX 8
+
+struct trx_ctx;
+
+struct trx_chan {
+	struct trx_ctx *trx; /* backpointer */
+	unsigned int idx; /* channel index */
+	char *rx_path;
+	char *tx_path;
+};
+
+struct trx_cfg {
+	char *bind_addr;
+	char *remote_addr;
+	char *dev_args;
+	unsigned int base_port;
+	unsigned int tx_sps;
+	unsigned int rx_sps;
+	unsigned int rtsc;
+	unsigned int rach_delay;
+	enum ReferenceType clock_ref;
+	enum FillerType filler;
+	bool multi_arfcn;
+	double offset;
+	double freq_offset_khz;
+	double rssi_offset;
+	int ul_fn_offset;
+	bool force_rssi_offset; /* Force value set in VTY? */
+	bool swap_channels;
+	bool ext_rach;
+	bool egprs;
+	unsigned int sched_rr;
+	unsigned int stack_size;
+	unsigned int num_chans;
+	struct trx_chan chans[TRX_CHAN_MAX];
+};

CommonLibs/debug.c

@@ -21,18 +21,6 @@
  * See the COPYING file in the main directory for details.
  */
 
-#include "config.h"
-
-/* If HAVE_GETTID, then "_GNU_SOURCE" may need to be defined to use gettid() */
-#if HAVE_GETTID
-#define _GNU_SOURCE
-#endif
-
-#include <sys/types.h>
-#include <unistd.h>
-#include <sys/syscall.h>
-#include "config.h"
-
 #include <osmocom/core/logging.h>
 #include <osmocom/core/utils.h>
 #include "debug.h"
@@ -81,21 +69,15 @@ static const struct log_info_cat default_categories[] = {
 		.color = NULL,
 		.enabled = 1, .loglevel = LOGL_NOTICE,
 	},
+	[DCTR] = {
+		.name = "DCTR",
+		.description = "Rate counter related logging",
+		.color = NULL,
+		.enabled = 1, .loglevel = LOGL_NOTICE,
+	},
 };
 
 const struct log_info log_info = {
 	.cat = default_categories,
 	.num_cat = ARRAY_SIZE(default_categories),
 };
-
-pid_t my_gettid(void)
-{
-#if HAVE_GETTID
-	return gettid();
-#elif defined(LINUX) && defined(__NR_gettid)
-	return (pid_t) syscall(__NR_gettid);
-#else
-	#pragma message ("use pid as tid")
-	return getpid();
-#endif
-}

CommonLibs/debug.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <stdbool.h>
-#include <sys/types.h>
 
 #include <osmocom/core/logging.h>
 
@@ -16,14 +15,9 @@ enum {
 	DTRXDUL,
 	DDEV,
 	DDEVDRV,
+	DCTR,
 };
 
-pid_t my_gettid(void);
-
-#define CLOGC(category, level, fmt, args...) do { \
-	LOGP(category, level, "[tid=%ld] " fmt, (long int) my_gettid(), ##args);  \
-} while(0)
-
 #define CLOGCHAN(chan, category, level, fmt, args...) do { \
-	LOGP(category, level, "[tid=%ld][chan=%zu] " fmt, (long int) my_gettid(), chan, ##args);  \
+	LOGP(category, level, "[chan=%zu] " fmt, chan, ##args);  \
 } while(0)

CommonLibs/osmo_signal.h

@@ -43,6 +43,7 @@ enum SS_DEVICE {
 	   (struct device_counters). Must be sent with PTHREAD_CANCEL_DISABLE
 	   to avoid deadlocks in case osmo-trx process is asked to exit. */
 	S_DEVICE_COUNTER_CHANGE,
+	S_TRX_COUNTER_CHANGE, /* same, but for Transceiver class */
 };
 
 /* signal cb for signal <SS_DEVICE,S_DEVICE_COUNTER_CHANGE> */
@@ -55,3 +56,16 @@ struct device_counters {
 	unsigned int tx_dropped_events;
 	unsigned int tx_dropped_samples;
 };
+
+/* signal cb for signal <SS_DEVICE,S_TRX_COUNTER_CHANGE> */
+struct trx_counters {
+	size_t chan;
+	unsigned int tx_stale_bursts;
+	unsigned int tx_unavailable_bursts;
+	unsigned int tx_trxd_fn_repeated;
+	unsigned int tx_trxd_fn_outoforder;
+	unsigned int tx_trxd_fn_skipped;
+	unsigned int rx_empty_burst;
+	unsigned int rx_clipping;
+	unsigned int rx_no_burst_detected;
+};

CommonLibs/trx_rate_ctr.cpp

@@ -67,21 +67,24 @@ extern "C" {
 #include "Threads.h"
 #include "Logger.h"
 
-/* Used in ctrs_pending, when set it means that channel slot contains unused
+/* Used in dev_ctrs_pending, when set it means that channel slot contains unused
    (non-pending) counter data */
 #define PENDING_CHAN_NONE SIZE_MAX
 
 static void *trx_rate_ctr_ctx;
 
 static struct rate_ctr_group** rate_ctrs;
-static struct device_counters* ctrs_pending;
+static struct device_counters* dev_ctrs_pending;
+static struct trx_counters* trx_ctrs_pending;
 static size_t chan_len;
-static struct osmo_fd rate_ctr_timerfd;
-static Mutex rate_ctr_mutex;
+static struct osmo_fd dev_rate_ctr_timerfd;
+static struct osmo_fd trx_rate_ctr_timerfd;
+static Mutex dev_rate_ctr_mutex;
+static Mutex trx_rate_ctr_mutex;
 
 struct osmo_timer_list threshold_timer;
 static LLIST_HEAD(threshold_list);
-static int threshold_timer_sched_secs;
+static unsigned int threshold_timer_sched_secs;
 static bool threshold_initied;
 
 const struct value_string rate_ctr_intv[] = {
@@ -93,22 +96,38 @@ const struct value_string rate_ctr_intv[] = {
 };
 
 const struct value_string trx_chan_ctr_names[] = {
-	{ TRX_CTR_RX_OVERRUNS,	"rx_overruns" },
-	{ TRX_CTR_TX_UNDERRUNS,	"tx_underruns" },
-	{ TRX_CTR_RX_DROP_EV,	"rx_drop_events" },
-	{ TRX_CTR_RX_DROP_SMPL,	"rx_drop_samples" },
-	{ TRX_CTR_TX_DROP_EV,	"tx_drop_events" },
-	{ TRX_CTR_TX_DROP_SMPL,	"tx_drop_samples" },
+	{ TRX_CTR_DEV_RX_OVERRUNS,	"rx_overruns" },
+	{ TRX_CTR_DEV_TX_UNDERRUNS,	"tx_underruns" },
+	{ TRX_CTR_DEV_RX_DROP_EV,	"rx_drop_events" },
+	{ TRX_CTR_DEV_RX_DROP_SMPL,	"rx_drop_samples" },
+	{ TRX_CTR_DEV_TX_DROP_EV,	"tx_drop_events" },
+	{ TRX_CTR_DEV_TX_DROP_SMPL,	"tx_drop_samples" },
+	{ TRX_CTR_TRX_TX_STALE_BURSTS,	"tx_stale_bursts" },
+	{ TRX_CTR_TRX_TX_UNAVAILABLE_BURSTS, "tx_unavailable_bursts" },
+	{ TRX_CTR_TRX_TRXD_FN_REPEATED,	"tx_trxd_fn_repeated" },
+	{ TRX_CTR_TRX_TRXD_FN_OUTOFORDER, "tx_trxd_fn_outoforder" },
+	{ TRX_CTR_TRX_TRXD_FN_SKIPPED,	"tx_trxd_fn_skipped" },
+	{ TRX_CTR_TRX_RX_EMPTY_BURST,	"rx_empty_burst" },
+	{ TRX_CTR_TRX_RX_CLIPPING,	"rx_clipping" },
+	{ TRX_CTR_TRX_RX_NO_BURST_DETECTED, "rx_no_burst_detected" },
 	{ 0, NULL }
 };
 
 static const struct rate_ctr_desc trx_chan_ctr_desc[] = {
-	[TRX_CTR_RX_OVERRUNS]		= { "device:rx_overruns",	"Number of Rx overruns in FIFO queue" },
-	[TRX_CTR_TX_UNDERRUNS]		= { "device:tx_underruns",	"Number of Tx underruns in FIFO queue" },
-	[TRX_CTR_RX_DROP_EV]		= { "device:rx_drop_events",	"Number of times Rx samples were dropped by HW" },
-	[TRX_CTR_RX_DROP_SMPL]		= { "device:rx_drop_samples",	"Number of Rx samples dropped by HW" },
-	[TRX_CTR_TX_DROP_EV]		= { "device:tx_drop_events",	"Number of times Tx samples were dropped by HW" },
-	[TRX_CTR_TX_DROP_SMPL]		= { "device:tx_drop_samples",	"Number of Tx samples dropped by HW" }
+	[TRX_CTR_DEV_RX_OVERRUNS]		= { "device:rx_overruns",	"Number of Rx overruns in FIFO queue" },
+	[TRX_CTR_DEV_TX_UNDERRUNS]		= { "device:tx_underruns",	"Number of Tx underruns in FIFO queue" },
+	[TRX_CTR_DEV_RX_DROP_EV]		= { "device:rx_drop_events",	"Number of times Rx samples were dropped by HW" },
+	[TRX_CTR_DEV_RX_DROP_SMPL]		= { "device:rx_drop_samples",	"Number of Rx samples dropped by HW" },
+	[TRX_CTR_DEV_TX_DROP_EV]		= { "device:tx_drop_events",	"Number of times Tx samples were dropped by HW" },
+	[TRX_CTR_DEV_TX_DROP_SMPL]		= { "device:tx_drop_samples",	"Number of Tx samples dropped by HW" },
+	[TRX_CTR_TRX_TX_STALE_BURSTS]		= { "trx:tx_stale_bursts",	"Number of Tx burts dropped by TRX due to arriving too late" },
+	[TRX_CTR_TRX_TX_UNAVAILABLE_BURSTS]	= { "trx:tx_unavailable_bursts","Number of Tx burts unavailable (not enqueued) at the time they should be transmitted" },
+	[TRX_CTR_TRX_TRXD_FN_REPEATED]		= { "trx:tx_trxd_fn_repeated",	"Number of Tx burts received from TRXD with repeated FN" },
+	[TRX_CTR_TRX_TRXD_FN_OUTOFORDER]	= { "trx:tx_trxd_fn_outoforder","Number of Tx burts received from TRXD with a past FN" },
+	[TRX_CTR_TRX_TRXD_FN_SKIPPED]		= { "trx:tx_trxd_fn_skipped",	"Number of Tx burts potentially skipped due to FN jumps" },
+	[TRX_CTR_TRX_RX_EMPTY_BURST]		= { "trx:rx_empty_burst",	"Number of Rx bursts empty" },
+	[TRX_CTR_TRX_RX_CLIPPING]		= { "trx:rx_clipping",		"Number of Rx bursts discarded due to clipping" },
+	[TRX_CTR_TRX_RX_NO_BURST_DETECTED]	= { "trx:rx_no_burst_detected",	"Number of Rx burts discarded due to burst detection error" },
 };
 
 static const struct rate_ctr_group_desc trx_chan_ctr_group_desc = {
@@ -119,34 +138,68 @@ static const struct rate_ctr_group_desc trx_chan_ctr_group_desc = {
 	.ctr_desc			= trx_chan_ctr_desc,
 };
 
-static int rate_ctr_timerfd_cb(struct osmo_fd *ofd, unsigned int what) {
+static int dev_rate_ctr_timerfd_cb(struct osmo_fd *ofd, unsigned int what) {
 	size_t chan;
 	struct rate_ctr *ctr;
-	LOGC(DMAIN, NOTICE) << "Main thread is updating counters";
-	rate_ctr_mutex.lock();
+	LOGC(DCTR, INFO) << "Main thread is updating Device counters";
+	dev_rate_ctr_mutex.lock();
 	for (chan = 0; chan < chan_len; chan++) {
-		if (ctrs_pending[chan].chan == PENDING_CHAN_NONE)
+		if (dev_ctrs_pending[chan].chan == PENDING_CHAN_NONE)
 			continue;
-		LOGCHAN(chan, DMAIN, INFO) << "rate_ctr update";
-		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_RX_OVERRUNS];
-		rate_ctr_add(ctr, ctrs_pending[chan].rx_overruns - ctr->current);
-		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_TX_UNDERRUNS];
-		rate_ctr_add(ctr, ctrs_pending[chan].tx_underruns - ctr->current);
-		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_RX_DROP_EV];
-		rate_ctr_add(ctr, ctrs_pending[chan].rx_dropped_events - ctr->current);
-		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_RX_DROP_SMPL];
-		rate_ctr_add(ctr, ctrs_pending[chan].rx_dropped_samples - ctr->current);
-		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_TX_DROP_EV];
-		rate_ctr_add(ctr, ctrs_pending[chan].tx_dropped_events - ctr->current);
-		ctr = &rate_ctrs[chan]->ctr[TRX_CTR_TX_DROP_SMPL];
-		rate_ctr_add(ctr, ctrs_pending[chan].tx_dropped_samples - ctr->current);
+		LOGCHAN(chan, DCTR, DEBUG) << "rate_ctr update";
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_RX_OVERRUNS);
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].rx_overruns - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_TX_UNDERRUNS);
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].tx_underruns - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_RX_DROP_EV);
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].rx_dropped_events - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_RX_DROP_SMPL);
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].rx_dropped_samples - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_TX_DROP_EV);
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].tx_dropped_events - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_DEV_TX_DROP_SMPL);
+		rate_ctr_add(ctr, dev_ctrs_pending[chan].tx_dropped_samples - ctr->current);
 
 		/* Mark as done */
-		ctrs_pending[chan].chan = PENDING_CHAN_NONE;
+		dev_ctrs_pending[chan].chan = PENDING_CHAN_NONE;
 	}
-	if (osmo_timerfd_disable(&rate_ctr_timerfd) < 0)
-		LOGC(DMAIN, ERROR) << "Failed to disable timerfd";
-	rate_ctr_mutex.unlock();
+	if (osmo_timerfd_disable(&dev_rate_ctr_timerfd) < 0)
+		LOGC(DCTR, ERROR) << "Failed to disable timerfd";
+	dev_rate_ctr_mutex.unlock();
+	return 0;
+}
+
+static int trx_rate_ctr_timerfd_cb(struct osmo_fd *ofd, unsigned int what) {
+	size_t chan;
+	struct rate_ctr *ctr;
+	LOGC(DCTR, INFO) << "Main thread is updating Transceiver counters";
+	trx_rate_ctr_mutex.lock();
+	for (chan = 0; chan < chan_len; chan++) {
+		if (trx_ctrs_pending[chan].chan == PENDING_CHAN_NONE)
+			continue;
+		LOGCHAN(chan, DCTR, DEBUG) << "rate_ctr update";
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TX_STALE_BURSTS);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_stale_bursts - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TX_UNAVAILABLE_BURSTS);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_unavailable_bursts - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TRXD_FN_REPEATED);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_trxd_fn_repeated - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TRXD_FN_OUTOFORDER);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_trxd_fn_outoforder - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_TRXD_FN_SKIPPED);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].tx_trxd_fn_skipped - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_RX_EMPTY_BURST);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].rx_empty_burst - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_RX_CLIPPING);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].rx_clipping - ctr->current);
+		ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], TRX_CTR_TRX_RX_NO_BURST_DETECTED);
+		rate_ctr_add(ctr, trx_ctrs_pending[chan].rx_no_burst_detected - ctr->current);
+		/* Mark as done */
+		trx_ctrs_pending[chan].chan = PENDING_CHAN_NONE;
+	}
+	if (osmo_timerfd_disable(&trx_rate_ctr_timerfd) < 0)
+		LOGC(DCTR, ERROR) << "Failed to disable timerfd";
+	trx_rate_ctr_mutex.unlock();
 	return 0;
 }
 
@@ -154,23 +207,37 @@ static int rate_ctr_timerfd_cb(struct osmo_fd *ofd, unsigned int what) {
 static int device_sig_cb(unsigned int subsys, unsigned int signal,
 			 void *handler_data, void *signal_data)
 {
-	struct device_counters *ctr;
+	struct device_counters *dev_ctr;
+	struct trx_counters *trx_ctr;
 	/* Delay sched around 20 ms, in case we receive several calls from several
 	 * channels batched */
 	struct timespec next_sched = {.tv_sec = 0, .tv_nsec = 20*1000*1000};
 	/* no automatic re-trigger */
 	struct timespec intv_sched = {.tv_sec = 0, .tv_nsec = 0};
+	char err_buf[256];
 
 	switch (signal) {
 	case S_DEVICE_COUNTER_CHANGE:
-		ctr = (struct device_counters *)signal_data;
-		LOGCHAN(ctr->chan, DMAIN, NOTICE) << "Received counter change from radioDevice";
-		rate_ctr_mutex.lock();
-		ctrs_pending[ctr->chan] = *ctr;
-		if (osmo_timerfd_schedule(&rate_ctr_timerfd, &next_sched, &intv_sched) < 0) {
-			LOGC(DMAIN, ERROR) << "Failed to schedule timerfd: " << errno << " = "<< strerror(errno);
+		dev_ctr = (struct device_counters *)signal_data;
+		LOGCHAN(dev_ctr->chan, DCTR, INFO) << "Received counter change from radioDevice";
+		dev_rate_ctr_mutex.lock();
+		dev_ctrs_pending[dev_ctr->chan] = *dev_ctr;
+		if (osmo_timerfd_schedule(&dev_rate_ctr_timerfd, &next_sched, &intv_sched) < 0) {
+			LOGC(DCTR, ERROR) << "Failed to schedule timerfd: " << errno
+					  << " = "<< strerror_r(errno, err_buf, sizeof(err_buf));
 		}
-		rate_ctr_mutex.unlock();
+		dev_rate_ctr_mutex.unlock();
+		break;
+	case S_TRX_COUNTER_CHANGE:
+		trx_ctr = (struct trx_counters *)signal_data;
+		LOGCHAN(trx_ctr->chan, DCTR, INFO) << "Received counter change from Transceiver";
+		trx_rate_ctr_mutex.lock();
+		trx_ctrs_pending[trx_ctr->chan] = *trx_ctr;
+		if (osmo_timerfd_schedule(&trx_rate_ctr_timerfd, &next_sched, &intv_sched) < 0) {
+			LOGC(DCTR, ERROR) << "Failed to schedule timerfd: " << errno
+					  << " = "<< strerror_r(errno, err_buf, sizeof(err_buf));
+		}
+		trx_rate_ctr_mutex.unlock();
 		break;
 	default:
 		break;
@@ -195,15 +262,15 @@ static void threshold_timer_cb(void *data)
 	struct ctr_threshold *ctr_thr;
 	struct rate_ctr *rate_ctr;
 	size_t chan;
-	LOGC(DMAIN, DEBUG) << "threshold_timer_cb fired!";
+	LOGC(DCTR, DEBUG) << "threshold_timer_cb fired!";
 
 	llist_for_each_entry(ctr_thr, &threshold_list, list) {
 		for (chan = 0; chan < chan_len; chan++) {
-			rate_ctr = &rate_ctrs[chan]->ctr[ctr_thr->ctr_id];
-			LOGCHAN(chan, DMAIN, INFO) << "checking threshold: " << ctr_threshold_2_vty_str(ctr_thr)
+			rate_ctr = rate_ctr_group_get_ctr(rate_ctrs[chan], ctr_thr->ctr_id);
+			LOGCHAN(chan, DCTR, INFO) << "checking threshold: " << ctr_threshold_2_vty_str(ctr_thr)
 						   << " ("<< rate_ctr->intv[ctr_thr->intv].rate << " vs " << ctr_thr->val << ")";
 			if (rate_ctr->intv[ctr_thr->intv].rate >= ctr_thr->val) {
-				LOGCHAN(chan, DMAIN, FATAL) << "threshold reached, stopping! " << ctr_threshold_2_vty_str(ctr_thr)
+				LOGCHAN(chan, DCTR, FATAL) << "threshold reached, stopping! " << ctr_threshold_2_vty_str(ctr_thr)
 							   << " ("<< rate_ctr->intv[ctr_thr->intv].rate << " vs " << ctr_thr->val << ")";
 				osmo_signal_dispatch(SS_MAIN, S_MAIN_STOP_REQUIRED, NULL);
 				return;
@@ -255,13 +322,13 @@ static void threshold_timer_update_intv() {
 
 	llist_for_each_entry(ctr, &threshold_list, list) {
 		secs = ctr_threshold_2_seconds(ctr);
-		if( min_secs > secs)
+		if (min_secs > secs)
 			min_secs = secs;
 	}
 
 
-	threshold_timer_sched_secs = OSMO_MAX(min_secs / 2 - 1, 1);
-	LOGC(DMAIN, INFO) << "New ctr-error-threshold check interval: "
+	threshold_timer_sched_secs = OSMO_MAX((int)(min_secs / 2 - 1), 1);
+	LOGC(DCTR, INFO) << "New ctr-error-threshold check interval: "
 			  << threshold_timer_sched_secs << " seconds";
 	osmo_timer_schedule(&threshold_timer, threshold_timer_sched_secs, 0);
 }
@@ -272,20 +339,27 @@ void trx_rate_ctr_init(void *ctx, struct trx_ctx* trx_ctx)
 	size_t  i;
 	trx_rate_ctr_ctx = ctx;
 	chan_len = trx_ctx->cfg.num_chans;
-	ctrs_pending = (struct device_counters*) talloc_zero_size(ctx, chan_len * sizeof(struct device_counters));
+	dev_ctrs_pending = (struct device_counters*) talloc_zero_size(ctx, chan_len * sizeof(struct device_counters));
+	trx_ctrs_pending = (struct trx_counters*) talloc_zero_size(ctx, chan_len * sizeof(struct trx_counters));
 	rate_ctrs = (struct rate_ctr_group**) talloc_zero_size(ctx, chan_len * sizeof(struct rate_ctr_group*));
 
 	for (i = 0; i < chan_len; i++) {
-		ctrs_pending[i].chan = PENDING_CHAN_NONE;
+		dev_ctrs_pending[i].chan = PENDING_CHAN_NONE;
+		trx_ctrs_pending[i].chan = PENDING_CHAN_NONE;
 		rate_ctrs[i] = rate_ctr_group_alloc(ctx, &trx_chan_ctr_group_desc, i);
 		if (!rate_ctrs[i]) {
-			LOGCHAN(i, DMAIN, ERROR) << "Failed to allocate rate ctr";
+			LOGCHAN(i, DCTR, ERROR) << "Failed to allocate rate ctr";
 			exit(1);
 		}
 	}
-	rate_ctr_timerfd.fd = -1;
-	if (osmo_timerfd_setup(&rate_ctr_timerfd, rate_ctr_timerfd_cb, NULL) < 0) {
-		LOGC(DMAIN, ERROR) << "Failed to setup timerfd";
+	dev_rate_ctr_timerfd.fd = -1;
+	if (osmo_timerfd_setup(&dev_rate_ctr_timerfd, dev_rate_ctr_timerfd_cb, NULL) < 0) {
+		LOGC(DCTR, ERROR) << "Failed to setup timerfd";
+		exit(1);
+	}
+	trx_rate_ctr_timerfd.fd = -1;
+	if (osmo_timerfd_setup(&trx_rate_ctr_timerfd, trx_rate_ctr_timerfd_cb, NULL) < 0) {
+		LOGC(DCTR, ERROR) << "Failed to setup timerfd";
 		exit(1);
 	}
 	osmo_signal_register_handler(SS_DEVICE, device_sig_cb, NULL);
@@ -302,7 +376,7 @@ void trx_rate_ctr_threshold_add(struct ctr_threshold *ctr)
 
 	new_ctr = talloc_zero(trx_rate_ctr_ctx, struct ctr_threshold);
 	*new_ctr = *ctr;
-	LOGC(DMAIN, NOTICE) << "Adding new threshold check: " << ctr_threshold_2_vty_str(new_ctr);
+	LOGC(DCTR, NOTICE) << "Adding new threshold check: " << ctr_threshold_2_vty_str(new_ctr);
 	llist_add(&new_ctr->list, &threshold_list);
 	threshold_timer_update_intv();
 }
@@ -317,7 +391,7 @@ int trx_rate_ctr_threshold_del(struct ctr_threshold *del_ctr)
 		    ctr->val != del_ctr->val)
 			continue;
 
-		LOGC(DMAIN, NOTICE) << "Deleting threshold check: " << ctr_threshold_2_vty_str(del_ctr);
+		LOGC(DCTR, NOTICE) << "Deleting threshold check: " << ctr_threshold_2_vty_str(del_ctr);
 		llist_del(&ctr->list);
 		talloc_free(ctr);
 		threshold_timer_update_intv();

CommonLibs/trx_rate_ctr.h

@@ -4,12 +4,20 @@
 #include <osmocom/vty/command.h>
 
 enum TrxCtr {
-	TRX_CTR_RX_OVERRUNS,
-	TRX_CTR_TX_UNDERRUNS,
-	TRX_CTR_RX_DROP_EV,
-	TRX_CTR_RX_DROP_SMPL,
-	TRX_CTR_TX_DROP_EV,
-	TRX_CTR_TX_DROP_SMPL,
+	TRX_CTR_DEV_RX_OVERRUNS,
+	TRX_CTR_DEV_TX_UNDERRUNS,
+	TRX_CTR_DEV_RX_DROP_EV,
+	TRX_CTR_DEV_RX_DROP_SMPL,
+	TRX_CTR_DEV_TX_DROP_EV,
+	TRX_CTR_DEV_TX_DROP_SMPL,
+	TRX_CTR_TRX_TX_STALE_BURSTS,
+	TRX_CTR_TRX_TX_UNAVAILABLE_BURSTS,
+	TRX_CTR_TRX_TRXD_FN_REPEATED,
+	TRX_CTR_TRX_TRXD_FN_OUTOFORDER,
+	TRX_CTR_TRX_TRXD_FN_SKIPPED,
+	TRX_CTR_TRX_RX_EMPTY_BURST,
+	TRX_CTR_TRX_RX_CLIPPING,
+	TRX_CTR_TRX_RX_NO_BURST_DETECTED,
 };
 
 struct ctr_threshold {

CommonLibs/trx_vty.c

@@ -67,6 +67,15 @@ static const struct value_string filler_types[] = {
 	{ 0,			NULL }
 };
 
+static const struct value_string filler_docs[] = {
+	{ FILLER_DUMMY,		"Send a Dummy Burst on C0 (TRX0) and empty burst on other channels" },
+	{ FILLER_ZERO,		"Send an empty burst (default)" },
+	{ FILLER_NORM_RAND,	"Send a GMSK modulated Normal Burst with random bits (spectrum mask testing)" },
+	{ FILLER_EDGE_RAND,	"Send an 8-PSK modulated Normal Burst with random bits (spectrum mask testing)" },
+	{ FILLER_ACCESS_RAND,	"Send an Access Burst with random bits (Rx/Tx alignment testing)" },
+	{ 0,			NULL }
+};
+
 
 struct trx_ctx *trx_from_vty(struct vty *v)
 {
@@ -112,7 +121,7 @@ DEFUN(cfg_trx, cfg_trx_cmd,
 }
 
 DEFUN(cfg_bind_ip, cfg_bind_ip_cmd,
-	"bind-ip A.B.C.D",
+	"bind-ip " VTY_IPV4_CMD,
 	"Set the IP address for the local bind\n"
 	"IPv4 Address\n")
 {
@@ -124,7 +133,7 @@ DEFUN(cfg_bind_ip, cfg_bind_ip_cmd,
 }
 
 DEFUN(cfg_remote_ip, cfg_remote_ip_cmd,
-	"remote-ip A.B.C.D",
+	"remote-ip " VTY_IPV4_CMD,
 	"Set the IP address for the remote BTS\n"
 	"IPv4 Address\n")
 {
@@ -162,7 +171,9 @@ DEFUN(cfg_dev_args, cfg_dev_args_cmd,
 DEFUN(cfg_tx_sps, cfg_tx_sps_cmd,
 	"tx-sps (1|4)",
 	"Set the Tx Samples-per-Symbol\n"
-	"Tx Samples-per-Symbol\n")
+	"Tx Samples-per-Symbol\n"
+	"1 Sample-per-Symbol\n"
+	"4 Samples-per-Symbol\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
@@ -174,7 +185,9 @@ DEFUN(cfg_tx_sps, cfg_tx_sps_cmd,
 DEFUN(cfg_rx_sps, cfg_rx_sps_cmd,
 	"rx-sps (1|4)",
 	"Set the Rx Samples-per-Symbol\n"
-	"Rx Samples-per-Symbol\n")
+	"Rx Samples-per-Symbol\n"
+	"1 Sample-per-Symbol\n"
+	"4 Samples-per-Symbol\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
@@ -199,7 +212,8 @@ DEFUN(cfg_clock_ref, cfg_clock_ref_cmd,
 
 DEFUN(cfg_multi_arfcn, cfg_multi_arfcn_cmd,
 	"multi-arfcn (disable|enable)",
-	"Enable multi-ARFCN transceiver (default=disable)\n")
+	"Multi-ARFCN transceiver mode (default=disable)\n"
+	"Enable multi-ARFCN mode\n" "Disable multi-ARFCN mode\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
@@ -230,21 +244,52 @@ DEFUN(cfg_offset, cfg_offset_cmd,
 	return CMD_SUCCESS;
 }
 
+DEFUN_ATTR(cfg_freq_offset, cfg_freq_offset_cmd,
+	   "freq-offset FLOAT",
+	   "Apply an artificial offset to Rx/Tx carrier frequency\n"
+	   "Frequency offset in kHz (e.g. -145300)\n",
+	   CMD_ATTR_HIDDEN)
+{
+	struct trx_ctx *trx = trx_from_vty(vty);
+
+	trx->cfg.freq_offset_khz = atof(argv[0]);
+
+	return CMD_SUCCESS;
+}
+
 DEFUN(cfg_rssi_offset, cfg_rssi_offset_cmd,
-	"rssi-offset FLOAT",
+	"rssi-offset FLOAT [relative]",
 	"Set the RSSI to dBm offset in dB (default=0)\n"
-	"RSSI to dBm offset in dB\n")
+	"RSSI to dBm offset in dB\n"
+	"Add to the default rssi-offset value instead of completely replacing it\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
 	trx->cfg.rssi_offset = atof(argv[0]);
+	trx->cfg.force_rssi_offset = (argc == 1);
+
+	return CMD_SUCCESS;
+}
+
+
+DEFUN_ATTR(cfg_ul_fn_offset, cfg_ul_fn_offset_cmd,
+	"ul-fn-offset <-10-10>",
+	"Adjusts the uplink frame FN by the specified amount\n"
+	"Frame Number offset\n",
+	CMD_ATTR_HIDDEN)
+{
+	struct trx_ctx *trx = trx_from_vty(vty);
+
+	trx->cfg.ul_fn_offset = atoi(argv[0]);
 
 	return CMD_SUCCESS;
 }
 
 DEFUN(cfg_swap_channels, cfg_swap_channels_cmd,
 	"swap-channels (disable|enable)",
-	"Swap channels (default=disable)\n")
+	"Swap primary and secondary channels of the PHY (if any)\n"
+	"Do not swap primary and secondary channels (default)\n"
+	"Swap primary and secondary channels\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
@@ -261,7 +306,9 @@ DEFUN(cfg_swap_channels, cfg_swap_channels_cmd,
 
 DEFUN(cfg_egprs, cfg_egprs_cmd,
 	"egprs (disable|enable)",
-	"Enable EDGE receiver (default=disable)\n")
+	"EGPRS (8-PSK demodulation) support (default=disable)\n"
+	"Disable EGPRS (8-PSK demodulation) support\n"
+	"Enable EGPRS (8-PSK demodulation) support\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
@@ -278,7 +325,9 @@ DEFUN(cfg_egprs, cfg_egprs_cmd,
 
 DEFUN(cfg_ext_rach, cfg_ext_rach_cmd,
 	"ext-rach (disable|enable)",
-	"Enable extended (11-bit) RACH (default=disable)\n")
+	"11-bit Access Burst correlation support (default=disable)\n"
+	"Disable 11-bit Access Burst (TS1 & TS2) correlation\n"
+	"Enable 11-bit Access Burst (TS1 & TS2) correlation\n")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 
@@ -291,7 +340,7 @@ DEFUN(cfg_ext_rach, cfg_ext_rach_cmd,
 	return CMD_SUCCESS;
 }
 
-DEFUN(cfg_rt_prio, cfg_rt_prio_cmd,
+DEFUN_DEPRECATED(cfg_rt_prio, cfg_rt_prio_cmd,
 	"rt-prio <1-32>",
 	"Set the SCHED_RR real-time priority\n"
 	"Real time priority\n")
@@ -299,6 +348,8 @@ DEFUN(cfg_rt_prio, cfg_rt_prio_cmd,
 	struct trx_ctx *trx = trx_from_vty(vty);
 
 	trx->cfg.sched_rr = atoi(argv[0]);
+	vty_out (vty, "%% 'rt-prio %u' is deprecated, use 'policy rr %u' under 'sched' node instead%s",
+		 trx->cfg.sched_rr, trx->cfg.sched_rr, VTY_NEWLINE);
 
 	return CMD_SUCCESS;
 }
@@ -315,20 +366,11 @@ DEFUN(cfg_stack_size, cfg_stack_size_cmd,
 	return CMD_SUCCESS;
 }
 
-DEFUN(cfg_filler, cfg_filler_type_cmd,
-	"filler type (zero|dummy|random-nb-gmsk|random-nb-8psk|random-ab)",
+#define CFG_FILLER_DOC_STR \
 	"Filler burst settings\n"
-	"Filler burst type (default=zero)\n"
-	"Send an empty burst when there is nothing to send (default)\n"
-	"Send a dummy burst when there is nothing to send on C0 (TRX0) and empty burst on other channels."
-	" Use for OpenBTS compatibility only, don't use with OsmoBTS as it breaks encryption.\n"
-	"Send a GMSK modulated Normal Burst with random bits when there is nothing to send."
-	" Use for spectrum mask testing. Configure 'filler tsc' to set training sequence.\n"
-	"Send an 8-PSK modulated Normal Burst with random bits when there is nothing to send."
-	" Use for spectrum mask testing. Configure 'filler tsc' to set training sequence.\n"
-	"Send an Access Burst with random bits when there is nothing to send. Use for Rx/Tx alignment."
-	" Configure 'filler access-burst-delay' to introduce artificial delay.\n"
-)
+
+DEFUN(cfg_filler, cfg_filler_type_cmd,
+      "AUTO-GENERATED", "AUTO-GENERATED")
 {
 	struct trx_ctx *trx = trx_from_vty(vty);
 	// trx->cfg.filler is unsigned, so we need an interim int var to detect errors
@@ -345,7 +387,7 @@ DEFUN(cfg_filler, cfg_filler_type_cmd,
 
 DEFUN(cfg_test_rtsc, cfg_filler_tsc_cmd,
 	"filler tsc <0-7>",
-	"Filler burst settings\n"
+	CFG_FILLER_DOC_STR
 	"Set the TSC for GMSK/8-PSK Normal Burst random fillers. Used only with 'random-nb-gmsk' and"
 	" 'random-nb-8psk' filler types. (default=0)\n"
 	"TSC\n")
@@ -359,7 +401,7 @@ DEFUN(cfg_test_rtsc, cfg_filler_tsc_cmd,
 
 DEFUN(cfg_test_rach_delay, cfg_filler_rach_delay_cmd,
 	"filler access-burst-delay <0-68>",
-	"Filler burst settings\n"
+	CFG_FILLER_DOC_STR
 	"Set the delay for Access Burst random fillers. Used only with 'random-ab' filler type. (default=0)\n"
 	"RACH delay in symbols\n")
 {
@@ -390,7 +432,7 @@ static int vty_intv_name_2_id(const char* str) {
 	return -1;
 }
 
-#define THRESHOLD_ARGS "(rx_overruns|tx_underruns|rx_drop_events|rx_drop_samples|tx_drop_events|tx_drop_samples)"
+#define THRESHOLD_ARGS "(rx_overruns|tx_underruns|rx_drop_events|rx_drop_samples|tx_drop_events|tx_drop_samples|tx_stale_bursts|tx_unavailable_bursts|tx_trxd_fn_repeated|tx_trxd_fn_outoforder|tx_trxd_fn_skipped)"
 #define THRESHOLD_STR_VAL(s) "Set threshold value for rate_ctr device:" OSMO_STRINGIFY_VAL(s) "\n"
 #define THRESHOLD_STRS \
 	THRESHOLD_STR_VAL(rx_overruns) \
@@ -398,7 +440,13 @@ static int vty_intv_name_2_id(const char* str) {
 	THRESHOLD_STR_VAL(rx_drop_events) \
 	THRESHOLD_STR_VAL(rx_drop_samples) \
 	THRESHOLD_STR_VAL(tx_drop_events) \
-	THRESHOLD_STR_VAL(tx_drop_samples)
+	THRESHOLD_STR_VAL(tx_drop_samples) \
+	THRESHOLD_STR_VAL(tx_stale_bursts) \
+	THRESHOLD_STR_VAL(tx_unavailable_bursts) \
+	THRESHOLD_STR_VAL(tx_trxd_fn_repeated) \
+	THRESHOLD_STR_VAL(tx_trxd_fn_outoforder) \
+	THRESHOLD_STR_VAL(tx_trxd_fn_skipped) \
+	""
 #define INTV_ARGS "(per-second|per-minute|per-hour|per-day)"
 #define INTV_STR_VAL(s) "Threshold value sampled " OSMO_STRINGIFY_VAL(s) "\n"
 #define INTV_STRS \
@@ -407,12 +455,13 @@ static int vty_intv_name_2_id(const char* str) {
 	INTV_STR_VAL(per-hour) \
 	INTV_STR_VAL(per-day)
 
-DEFUN(cfg_ctr_error_threshold, cfg_ctr_error_threshold_cmd,
-	"ctr-error-threshold " THRESHOLD_ARGS " <0-65535> " INTV_ARGS,
-	"Threshold rate for error counter\n"
-	THRESHOLD_STRS
-	"Value to set for threshold\n"
-	INTV_STRS)
+DEFUN_ATTR(cfg_ctr_error_threshold, cfg_ctr_error_threshold_cmd,
+	   "ctr-error-threshold " THRESHOLD_ARGS " <0-65535> " INTV_ARGS,
+	   "Threshold rate for error counter\n"
+	   THRESHOLD_STRS
+	   "Value to set for threshold\n"
+	   INTV_STRS,
+	   CMD_ATTR_IMMEDIATE)
 {
 	int rc;
 	struct ctr_threshold ctr;
@@ -438,12 +487,13 @@ DEFUN(cfg_ctr_error_threshold, cfg_ctr_error_threshold_cmd,
 	return CMD_SUCCESS;
 }
 
-DEFUN(cfg_no_ctr_error_threshold, cfg_no_ctr_error_threshold_cmd,
-	"no ctr-error-threshold " THRESHOLD_ARGS " <0-65535> " INTV_ARGS,
-	NO_STR "Threshold rate for error counter\n"
-	THRESHOLD_STRS
-	"Value to set for threshold\n"
-	INTV_STRS)
+DEFUN_ATTR(cfg_no_ctr_error_threshold, cfg_no_ctr_error_threshold_cmd,
+	   "no ctr-error-threshold " THRESHOLD_ARGS " <0-65535> " INTV_ARGS,
+	   NO_STR "Threshold rate for error counter\n"
+	   THRESHOLD_STRS
+	   "Value to set for threshold\n"
+	   INTV_STRS,
+	   CMD_ATTR_IMMEDIATE)
 {
 	int rc;
 	struct ctr_threshold ctr;
@@ -512,6 +562,12 @@ DEFUN(cfg_chan_rx_path, cfg_chan_rx_path_cmd,
 {
 	struct trx_chan *chan = vty->index;
 
+	if (chan->trx->cfg.multi_arfcn && chan->idx > 0) {
+		vty_out(vty, "%% Setting 'rx-path' for chan %u in multi-ARFCN mode "
+			     "does not make sense, because only chan 0 is used%s",
+			chan->idx, VTY_NEWLINE);
+	}
+
 	osmo_talloc_replace_string(chan->trx, &chan->rx_path, argv[0]);
 
 	return CMD_SUCCESS;
@@ -524,6 +580,12 @@ DEFUN(cfg_chan_tx_path, cfg_chan_tx_path_cmd,
 {
 	struct trx_chan *chan = vty->index;
 
+	if (chan->trx->cfg.multi_arfcn && chan->idx > 0) {
+		vty_out(vty, "%% Setting 'tx-path' for chan %u in multi-ARFCN mode "
+			     "does not make sense, because only chan 0 is used%s",
+			chan->idx, VTY_NEWLINE);
+	}
+
 	osmo_talloc_replace_string(chan->trx, &chan->tx_path, argv[0]);
 
 	return CMD_SUCCESS;
@@ -558,8 +620,11 @@ static int config_write_trx(struct vty *vty)
 	vty_out(vty, " multi-arfcn %s%s", trx->cfg.multi_arfcn ? "enable" : "disable", VTY_NEWLINE);
 	if (trx->cfg.offset != 0)
 		vty_out(vty, " offset %f%s", trx->cfg.offset, VTY_NEWLINE);
-	if (trx->cfg.rssi_offset != 0)
-		vty_out(vty, " rssi-offset %f%s", trx->cfg.rssi_offset, VTY_NEWLINE);
+	if (trx->cfg.freq_offset_khz != 0)
+		vty_out(vty, " freq-offset %f%s", trx->cfg.freq_offset_khz, VTY_NEWLINE);
+	if (!(trx->cfg.rssi_offset == 0 && !trx->cfg.force_rssi_offset))
+		vty_out(vty, " rssi-offset %f%s%s", trx->cfg.rssi_offset,
+			trx->cfg.force_rssi_offset ? " relative": "", VTY_NEWLINE);
 	vty_out(vty, " swap-channels %s%s", trx->cfg.swap_channels ? "enable" : "disable", VTY_NEWLINE);
 	vty_out(vty, " egprs %s%s", trx->cfg.egprs ? "enable" : "disable", VTY_NEWLINE);
 	vty_out(vty, " ext-rach %s%s", trx->cfg.ext_rach ? "enable" : "disable", VTY_NEWLINE);
@@ -573,6 +638,8 @@ static int config_write_trx(struct vty *vty)
 		vty_out(vty, " filler access-burst-delay %u%s", trx->cfg.rach_delay, VTY_NEWLINE);
 	if (trx->cfg.stack_size != 0)
 		vty_out(vty, " stack-size %u%s", trx->cfg.stack_size, VTY_NEWLINE);
+	if (trx->cfg.ul_fn_offset != 0)
+		vty_out(vty, " ul-fn-offset %d%s", trx->cfg.ul_fn_offset, VTY_NEWLINE);
 	trx_rate_ctr_threshold_write_config(vty, " ");
 
 	for (i = 0; i < trx->cfg.num_chans; i++) {
@@ -694,12 +761,19 @@ struct trx_ctx *vty_trx_ctx_alloc(void *talloc_ctx)
 	trx->cfg.tx_sps = DEFAULT_TX_SPS;
 	trx->cfg.rx_sps = DEFAULT_RX_SPS;
 	trx->cfg.filler = FILLER_ZERO;
+	trx->cfg.rssi_offset = 0.0f;
 
 	return trx;
 }
 
 int trx_vty_init(struct trx_ctx* trx)
 {
+	cfg_filler_type_cmd.string = vty_cmd_string_from_valstr(trx, filler_types,
+		"filler type (", "|", ")", 0);
+	cfg_filler_type_cmd.doc = vty_cmd_string_from_valstr(trx, filler_docs,
+		CFG_FILLER_DOC_STR "What to do when there is nothing to send "
+		"(filler type, default=zero)\n", "\n", "", 0);
+
 	g_trx_ctx = trx;
 	install_element_ve(&show_trx_cmd);
 
@@ -715,6 +789,7 @@ int trx_vty_init(struct trx_ctx* trx)
 	install_element(TRX_NODE, &cfg_clock_ref_cmd);
 	install_element(TRX_NODE, &cfg_multi_arfcn_cmd);
 	install_element(TRX_NODE, &cfg_offset_cmd);
+	install_element(TRX_NODE, &cfg_freq_offset_cmd);
 	install_element(TRX_NODE, &cfg_rssi_offset_cmd);
 	install_element(TRX_NODE, &cfg_swap_channels_cmd);
 	install_element(TRX_NODE, &cfg_egprs_cmd);
@@ -728,6 +803,7 @@ int trx_vty_init(struct trx_ctx* trx)
 	install_element(TRX_NODE, &cfg_stack_size_cmd);
 
 	install_element(TRX_NODE, &cfg_chan_cmd);
+	install_element(TRX_NODE, &cfg_ul_fn_offset_cmd);
 	install_node(&chan_node, dummy_config_write);
 	install_element(CHAN_NODE, &cfg_chan_rx_path_cmd);
 	install_element(CHAN_NODE, &cfg_chan_tx_path_cmd);

CommonLibs/trx_vty.h

@@ -8,8 +8,6 @@ extern struct vty_app_info g_vty_info;
 extern const struct value_string clock_ref_names[];
 extern const struct value_string filler_names[];
 
-/* Maximum number of physical RF channels */
-#define TRX_CHAN_MAX 8
 /* Maximum number of carriers in multi-ARFCN mode */
 #define TRX_MCHAN_MAX 3
 
@@ -35,38 +33,8 @@ extern const struct value_string filler_names[];
 #define DEFAULT_TRX_IP		"127.0.0.1"
 #define DEFAULT_CHANS		1
 
-struct trx_ctx;
-
-struct trx_chan {
-	struct trx_ctx *trx; /* backpointer */
-	unsigned int idx; /* channel index */
-	char *rx_path;
-	char *tx_path;
-};
-
 struct trx_ctx {
-	struct {
-		char *bind_addr;
-		char *remote_addr;
-		char *dev_args;
-		unsigned int base_port;
-		unsigned int tx_sps;
-		unsigned int rx_sps;
-		unsigned int rtsc;
-		unsigned int rach_delay;
-		enum ReferenceType clock_ref;
-		enum FillerType filler;
-		bool multi_arfcn;
-		double offset;
-		double rssi_offset;
-		bool swap_channels;
-		bool ext_rach;
-		bool egprs;
-		unsigned int sched_rr;
-		unsigned int stack_size;
-		unsigned int num_chans;
-		struct trx_chan chans[TRX_CHAN_MAX];
-	} cfg;
+	struct trx_cfg cfg;
 };
 
 int trx_vty_init(struct trx_ctx* trx);

Makefile.am

@@ -28,17 +28,22 @@ AM_CXXFLAGS = -Wall -pthread
 
 # Order must be preserved
 SUBDIRS = \
-	doc \
 	CommonLibs \
 	GSM \
 	Transceiver52M \
 	contrib \
-	tests
+	tests \
+	utils \
+	doc \
+	$(NULL)
 
 EXTRA_DIST = \
 	LEGAL \
 	COPYING \
-	README.md
+	README.md \
+	contrib/osmo-trx.spec.in \
+	debian \
+	$(NULL)
 
 AM_DISTCHECK_CONFIGURE_FLAGS = \
 	--with-systemdsystemunitdir=$$dc_install_base/$(systemdsystemunitdir)

README.md

@@ -1,5 +1,5 @@
-About OsmTRX
-============
+About OsmoTRX
+=============
 
 OsmoTRX is a software-defined radio transceiver that implements the Layer 1
 physical layer of a BTS comprising the following 3GPP specifications:
@@ -9,14 +9,12 @@ physical layer of a BTS comprising the following 3GPP specifications:
 * TS 05.04 "Modulation"
 * TS 05.10 "Radio subsystem synchronization"
 
-OsmoTRX is based on the transceiver code from the
+OsmoTRX is originally based on the transceiver code from the
 [OpenBTS](https://osmocom.org/projects/osmobts/wiki/OpenBTS) project, but setup
 to operate independently with the purpose of using with non-OpenBTS software and
-projects, while still maintaining backwards compatibility with OpenBTS when
-possible. Currently there are numerous features contained in OsmoTRX that extend
-the functionality of the OpenBTS transceiver. These features include enhanced
-support for various embedded platforms - notably ARM - and dual channel
-diversity support for the Fairwaves umtrx.
+projects, specifically within the Osmocom stack.  Used together with
+[OsmoBTS](https://osmocom.org/projects/osmobts/wiki) you can get a pretty
+standard GSM BTS with Abis interface as per the relevant 3GPP specifications.
 
 Homepage
 --------
@@ -31,7 +29,7 @@ You can clone from the official osmo-trx.git repository using
 
         git clone git://git.osmocom.org/osmo-trx.git
 
-There is a cgit interface at <http://git.osmocom.org/osmo-trx/>
+There is a cgit interface at <https://git.osmocom.org/osmo-trx/>
 
 Documentation
 -------------
@@ -39,7 +37,7 @@ Documentation
 Doxygen-generated API documentation is generated during the build process, but
 also available online for each of the sub-libraries at User Manual for OsmoTRX
 can be generated during the build process, and is also available online at
-<http://ftp.osmocom.org/docs/latest/osmotrx-usermanual.pdf>.
+<https://ftp.osmocom.org/docs/latest/osmotrx-usermanual.pdf>.
 
 Mailing List
 ------------

Transceiver52M/ChannelizerBase.cpp

@@ -244,6 +244,7 @@ ChannelizerBase::~ChannelizerBase()
 		free(subFilters[i]);
 		delete[] hist[i];
 	}
+	free(subFilters);
 
 	fft_free(fftInput);
 	fft_free(fftOutput);

Transceiver52M/Makefile.am

@@ -105,10 +105,12 @@ osmo_trx_lms_LDADD = \
 osmo_trx_lms_CPPFLAGS  = $(AM_CPPFLAGS) $(LMS_CFLAGS)
 endif
 
+if DEVICE_IPC
 bin_PROGRAMS += osmo-trx-ipc
 osmo_trx_ipc_SOURCES = osmo-trx.cpp
 osmo_trx_ipc_LDADD = \
 	$(builddir)/device/ipc/libdevice.la \
-	$(COMMON_LDADD) \
-	$(UHD_LIBS)
-osmo_trx_ipc_CPPFLAGS  = $(AM_CPPFLAGS) $(UHD_CFLAGS)
+	$(COMMON_LDADD)
+osmo_trx_ipc_CPPFLAGS  = $(AM_CPPFLAGS)
+endif
+

Transceiver52M/Resampler.cpp

@@ -13,10 +13,6 @@
  * 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
  */
 
 #include <stdlib.h>
@@ -99,6 +95,7 @@ void Resampler::initFilters(float bw)
 		reverse(&part[0], &part[filt_len]);
 }
 
+#ifndef __OPTIMIZE__
 static bool check_vec_len(int in_len, int out_len, int p, int q)
 {
 	if (in_len % q) {
@@ -129,14 +126,15 @@ static bool check_vec_len(int in_len, int out_len, int p, int q)
 
 	return true;
 }
+#endif
 
 int Resampler::rotate(const float *in, size_t in_len, float *out, size_t out_len)
 {
 	int n, path;
-
+#ifndef __OPTIMIZE__
 	if (!check_vec_len(in_len, out_len, p, q))
 		return -1;
-
+#endif
 	/* Generate output from precomputed input/output paths */
 	for (size_t i = 0; i < out_len; i++) {
 		n = in_index[i];

Transceiver52M/Resampler.h

@@ -13,10 +13,6 @@
  * 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
  */
 
 #ifndef _RESAMPLER_H_

Transceiver52M/Transceiver.cpp

@@ -37,6 +37,7 @@ extern "C" {
 #include <osmocom/core/utils.h>
 #include <osmocom/core/socket.h>
 #include <osmocom/core/bits.h>
+#include <osmocom/vty/cpu_sched_vty.h>
 }
 
 #ifdef HAVE_CONFIG_H
@@ -52,8 +53,17 @@ Transceiver *transceiver;
 /* Number of running values use in noise average */
 #define NOISE_CNT			20
 
+
+static void dispatch_trx_rate_ctr_change(TransceiverState *state, unsigned int chan) {
+        thread_enable_cancel(false);
+        state->ctrs.chan = chan;
+        osmo_signal_dispatch(SS_DEVICE, S_TRX_COUNTER_CHANGE, &state->ctrs);
+        thread_enable_cancel(true);
+}
+
 TransceiverState::TransceiverState()
-  : mRetrans(false), mNoiseLev(0.0), mNoises(NOISE_CNT), mPower(0.0)
+  : mFiller(FILLER_ZERO), mRetrans(false), mNoiseLev(0.0), mNoises(NOISE_CNT),
+    mPower(0.0), mMuted(false), first_dl_fn_rcv()
 {
   for (int i = 0; i < 8; i++) {
     chanType[i] = Transceiver::NONE;
@@ -65,6 +75,7 @@ TransceiverState::TransceiverState()
     for (int n = 0; n < 102; n++)
       fillerTable[n][i] = NULL;
   }
+  memset(&ctrs, 0, sizeof(struct trx_counters));
 }
 
 TransceiverState::~TransceiverState()
@@ -86,6 +97,8 @@ bool TransceiverState::init(FillerType filler, size_t sps, float scale, size_t r
   if ((sps != 1) && (sps != 4))
     return false;
 
+  mFiller = filler;
+
   for (size_t n = 0; n < 8; n++) {
     for (size_t i = 0; i < 102; i++) {
       switch (filler) {
@@ -119,26 +132,21 @@ bool TransceiverState::init(FillerType filler, size_t sps, float scale, size_t r
   return false;
 }
 
-Transceiver::Transceiver(int wBasePort,
-                         const char *TRXAddress,
-                         const char *GSMcoreAddress,
-                         size_t tx_sps, size_t rx_sps, size_t chans,
+Transceiver::Transceiver(const struct trx_cfg *cfg,
                          GSM::Time wTransmitLatency,
-                         RadioInterface *wRadioInterface,
-                         double wRssiOffset, int wStackSize)
-  : mBasePort(wBasePort), mLocalAddr(TRXAddress), mRemoteAddr(GSMcoreAddress),
-    mClockSocket(-1), mTransmitLatency(wTransmitLatency), mRadioInterface(wRadioInterface),
-    rssiOffset(wRssiOffset), stackSize(wStackSize),
-    mSPSTx(tx_sps), mSPSRx(rx_sps), mChans(chans), mExtRACH(false), mEdge(false),
-    mOn(false), mForceClockInterface(false),
-    mTxFreq(0.0), mRxFreq(0.0), mTSC(0), mMaxExpectedDelayAB(0), mMaxExpectedDelayNB(0),
-    mWriteBurstToDiskMask(0)
+                         RadioInterface *wRadioInterface)
+  : cfg(cfg), mClockSocket(-1),
+    mRxLowerLoopThread(nullptr), mTxLowerLoopThread(nullptr),
+    mTransmitLatency(wTransmitLatency), mRadioInterface(wRadioInterface),
+    mChans(cfg->num_chans), mOn(false), mForceClockInterface(false),
+    mTxFreq(0.0), mRxFreq(0.0), mTSC(0), mMaxExpectedDelayAB(0),
+    mMaxExpectedDelayNB(0), mWriteBurstToDiskMask(0)
 {
   txFullScale = mRadioInterface->fullScaleInputValue();
   rxFullScale = mRadioInterface->fullScaleOutputValue();
 
-  for (int i = 0; i < 8; i++) {
-    for (int j = 0; j < 8; j++)
+  for (size_t i = 0; i < ARRAY_SIZE(mHandover); i++) {
+    for (size_t j = 0; j < ARRAY_SIZE(mHandover[i]); j++)
       mHandover[i][j] = false;
   }
 }
@@ -186,11 +194,9 @@ int Transceiver::ctrl_sock_cb(struct osmo_fd *bfd, unsigned int flags)
  * are still expected to report clock indications through control channel
  * activity.
  */
-bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
-                       bool edge, bool ext_rach)
+bool Transceiver::init()
 {
   int d_srcport, d_dstport, c_srcport, c_dstport;
-
   if (!mChans) {
     LOG(FATAL) << "No channels assigned";
     return false;
@@ -201,9 +207,6 @@ bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
     return false;
   }
 
-  mExtRACH = ext_rach;
-  mEdge = edge;
-
   mDataSockets.resize(mChans, -1);
   mCtrlSockets.resize(mChans);
   mTxPriorityQueueServiceLoopThreads.resize(mChans);
@@ -215,27 +218,28 @@ bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
   mVersionTRXD.resize(mChans);
 
   /* Filler table retransmissions - support only on channel 0 */
-  if (filler == FILLER_DUMMY)
+  if (cfg->filler == FILLER_DUMMY)
     mStates[0].mRetrans = true;
 
   /* Setup sockets */
   mClockSocket = osmo_sock_init2(AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP,
-				    mLocalAddr.c_str(), mBasePort,
-				    mRemoteAddr.c_str(), mBasePort + 100,
+				    cfg->bind_addr, cfg->base_port,
+				    cfg->remote_addr, cfg->base_port + 100,
 				    OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
   if (mClockSocket < 0)
     return false;
 
   for (size_t i = 0; i < mChans; i++) {
     int rv;
-    c_srcport = mBasePort + 2 * i + 1;
-    c_dstport = mBasePort + 2 * i + 101;
-    d_srcport = mBasePort + 2 * i + 2;
-    d_dstport = mBasePort + 2 * i + 102;
+    FillerType filler = cfg->filler;
+    c_srcport = cfg->base_port + 2 * i + 1;
+    c_dstport = cfg->base_port + 2 * i + 101;
+    d_srcport = cfg->base_port + 2 * i + 2;
+    d_dstport = cfg->base_port + 2 * i + 102;
 
     rv = osmo_sock_init2_ofd(&mCtrlSockets[i].conn_bfd, AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP,
-                                      mLocalAddr.c_str(), c_srcport,
-                                      mRemoteAddr.c_str(), c_dstport,
+                                      cfg->bind_addr, c_srcport,
+                                      cfg->remote_addr, c_dstport,
 				      OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
     if (rv < 0)
       return false;
@@ -245,8 +249,8 @@ bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
 
 
     mDataSockets[i] = osmo_sock_init2(AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP,
-                                      mLocalAddr.c_str(), d_srcport,
-                                      mRemoteAddr.c_str(), d_dstport,
+                                      cfg->bind_addr, d_srcport,
+                                      cfg->remote_addr, d_dstport,
 				      OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
     if (mDataSockets[i] < 0)
       return false;
@@ -254,7 +258,7 @@ bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
     if (i && filler == FILLER_DUMMY)
       filler = FILLER_ZERO;
 
-    mStates[i].init(filler, mSPSTx, txFullScale, rtsc, rach_delay);
+    mStates[i].init(filler, cfg->tx_sps, txFullScale, cfg->rtsc, cfg->rach_delay);
   }
 
   /* Randomize the central clock */
@@ -296,8 +300,8 @@ bool Transceiver::start()
   }
 
   /* Device is running - launch I/O threads */
-  mRxLowerLoopThread = new Thread(stackSize);
-  mTxLowerLoopThread = new Thread(stackSize);
+  mRxLowerLoopThread = new Thread(cfg->stack_size);
+  mTxLowerLoopThread = new Thread(cfg->stack_size);
   mTxLowerLoopThread->start((void * (*)(void*))
                             TxLowerLoopAdapter,(void*) this);
   mRxLowerLoopThread->start((void * (*)(void*))
@@ -308,14 +312,14 @@ bool Transceiver::start()
     TrxChanThParams *params = (TrxChanThParams *)malloc(sizeof(struct TrxChanThParams));
     params->trx = this;
     params->num = i;
-    mRxServiceLoopThreads[i] = new Thread(stackSize);
+    mRxServiceLoopThreads[i] = new Thread(cfg->stack_size);
     mRxServiceLoopThreads[i]->start((void * (*)(void*))
                             RxUpperLoopAdapter, (void*) params);
 
     params = (TrxChanThParams *)malloc(sizeof(struct TrxChanThParams));
     params->trx = this;
     params->num = i;
-    mTxPriorityQueueServiceLoopThreads[i] = new Thread(stackSize);
+    mTxPriorityQueueServiceLoopThreads[i] = new Thread(cfg->stack_size);
     mTxPriorityQueueServiceLoopThreads[i]->start((void * (*)(void*))
                             TxUpperLoopAdapter, (void*) params);
   }
@@ -388,11 +392,11 @@ void Transceiver::addRadioVector(size_t chan, BitVector &bits,
 
   /* Use the number of bits as the EDGE burst indicator */
   if (bits.size() == EDGE_BURST_NBITS)
-    burst = modulateEdgeBurst(bits, mSPSTx);
+    burst = modulateEdgeBurst(bits, cfg->tx_sps);
   else
-    burst = modulateBurst(bits, 8 + (wTime.TN() % 4 == 0), mSPSTx);
+    burst = modulateBurst(bits, 8 + (wTime.TN() % 4 == 0), cfg->tx_sps);
 
-  scaleVector(*burst, txFullScale * pow(10, -RSSI / 10));
+  scaleVector(*burst, txFullScale * pow(10, (double) -RSSI / 20));
 
   radio_burst = new radioVector(wTime, burst);
 
@@ -420,24 +424,29 @@ void Transceiver::pushRadioVector(GSM::Time &nowTime)
   std::vector<signalVector *> bursts(mChans);
   std::vector<bool> zeros(mChans);
   std::vector<bool> filler(mChans, true);
+  bool ratectr_changed;
+
+  TN = nowTime.TN();
 
   for (size_t i = 0; i < mChans; i ++) {
     state = &mStates[i];
+    ratectr_changed = false;
+
+    zeros[i] = state->chanType[TN] == NONE || state->mMuted;
+
+    Mutex *mtx = mTxPriorityQueues[i].getMutex();
+    mtx->lock();
 
     while ((burst = mTxPriorityQueues[i].getStaleBurst(nowTime))) {
-      LOGCHAN(i, DTRXDDL, NOTICE) << "dumping STALE burst in TRX->SDR interface ("
+      LOGCHAN(i, DTRXDDL, INFO) << "dumping STALE burst in TRX->SDR interface ("
                   << burst->getTime() <<" vs " << nowTime << "), retrans=" << state->mRetrans;
+      state->ctrs.tx_stale_bursts++;
+      ratectr_changed = true;
       if (state->mRetrans)
         updateFillerTable(i, burst);
       delete burst;
     }
 
-    TN = nowTime.TN();
-    modFN = nowTime.FN() % state->fillerModulus[TN];
-
-    bursts[i] = state->fillerTable[modFN][TN];
-    zeros[i] = state->chanType[TN] == NONE;
-
     if ((burst = mTxPriorityQueues[i].getCurrentBurst(nowTime))) {
       bursts[i] = burst->getVector();
 
@@ -449,7 +458,21 @@ void Transceiver::pushRadioVector(GSM::Time &nowTime)
       }
 
       delete burst;
+    } else {
+      modFN = nowTime.FN() % state->fillerModulus[TN];
+      bursts[i] = state->fillerTable[modFN][TN];
+      if (i == 0 && state->mFiller == FILLER_ZERO) {
+        LOGCHAN(i, DTRXDDL, INFO) << "No Tx burst available for " << nowTime
+                                    << ", retrans=" << state->mRetrans;
+        state->ctrs.tx_unavailable_bursts++;
+        ratectr_changed = true;
+      }
     }
+
+    mtx->unlock();
+
+    if (ratectr_changed)
+      dispatch_trx_rate_ctr_change(state, i);
   }
 
   mRadioInterface->driveTransmitRadio(bursts, zeros);
@@ -534,16 +557,16 @@ CorrType Transceiver::expectedCorrType(GSM::Time currTime,
     break;
   case IV:
   case VI:
-    return mExtRACH ? EXT_RACH : RACH;
+    return cfg->ext_rach ? EXT_RACH : RACH;
     break;
   case V: {
     int mod51 = burstFN % 51;
     if ((mod51 <= 36) && (mod51 >= 14))
-      return mExtRACH ? EXT_RACH : RACH;
+      return cfg->ext_rach ? EXT_RACH : RACH;
     else if ((mod51 == 4) || (mod51 == 5))
-      return mExtRACH ? EXT_RACH : RACH;
+      return cfg->ext_rach ? EXT_RACH : RACH;
     else if ((mod51 == 45) || (mod51 == 46))
-      return mExtRACH ? EXT_RACH : RACH;
+      return cfg->ext_rach ? EXT_RACH : RACH;
     else if (mHandover[burstTN][sdcch4_subslot[burstFN % 102]])
       return RACH;
     else
@@ -561,11 +584,11 @@ CorrType Transceiver::expectedCorrType(GSM::Time currTime,
   case XIII: {
     int mod52 = burstFN % 52;
     if ((mod52 == 12) || (mod52 == 38))
-      return mExtRACH ? EXT_RACH : RACH;
+      return cfg->ext_rach ? EXT_RACH : RACH;
     else if ((mod52 == 25) || (mod52 == 51))
       return IDLE;
     else /* Enable 8-PSK burst detection if EDGE is enabled */
-      return mEdge ? EDGE : TSC;
+      return cfg->egprs ? EDGE : TSC;
     break;
   }
   case LOOPBACK:
@@ -590,6 +613,13 @@ void writeToFile(radioVector *radio_burst, size_t chan)
   outfile.close();
 }
 
+double Transceiver::rssiOffset(size_t chan)
+{
+  if (cfg->force_rssi_offset)
+        return cfg->rssi_offset;
+  return mRadioInterface->rssiOffset(chan) + cfg->rssi_offset;
+}
+
 /*
  * Pull bursts from the FIFO and handle according to the slot
  * and burst correlation type. Equalzation is currently disabled.
@@ -608,6 +638,8 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
   GSM::Time burstTime;
   SoftVector *rxBurst;
   TransceiverState *state = &mStates[chan];
+  bool ctr_changed = false;
+  double rssi_offset;
 
   /* Blocking FIFO read */
   radioVector *radio_burst = mReceiveFIFO[chan]->read();
@@ -617,7 +649,7 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
   }
 
   /* Set time and determine correlation type */
-  burstTime = radio_burst->getTime();
+  burstTime = radio_burst->getTime() + cfg->ul_fn_offset;
   CorrType type = expectedCorrType(burstTime, chan);
 
   /* Initialize struct bi */
@@ -646,9 +678,13 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
     return -ENOENT;
   }
 
+  /* If TRX RF is locked/muted by BTS, send idle burst indications */
+  if (state->mMuted)
+    goto ret_idle;
+
   /* Select the diversity channel with highest energy */
   for (size_t i = 0; i < radio_burst->chans(); i++) {
-    float pow = energyDetect(*radio_burst->getVector(i), 20 * mSPSRx);
+    float pow = energyDetect(*radio_burst->getVector(i), 20 * cfg->rx_sps);
     if (pow > max) {
       max = pow;
       max_i = i;
@@ -657,7 +693,9 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
   }
 
   if (max_i < 0) {
-    LOGCHAN(chan, DTRXDUL, FATAL) << "Received empty burst";
+    LOGCHAN(chan, DTRXDUL, INFO) << "Received empty burst";
+    state->ctrs.rx_empty_burst++;
+    ctr_changed = true;
     goto ret_idle;
   }
 
@@ -671,8 +709,9 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
     state->mNoiseLev = state->mNoises.avg();
   }
 
-  bi->rssi = 20.0 * log10(rxFullScale / avg) + rssiOffset;
-  bi->noise = 20.0 * log10(rxFullScale / state->mNoiseLev) + rssiOffset;
+  rssi_offset = rssiOffset(chan);
+  bi->rssi = 20.0 * log10(rxFullScale / avg) + rssi_offset;
+  bi->noise = 20.0 * log10(rxFullScale / state->mNoiseLev) + rssi_offset;
 
   if (type == IDLE)
     goto ret_idle;
@@ -681,20 +720,24 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
             mMaxExpectedDelayAB : mMaxExpectedDelayNB;
 
   /* Detect normal or RACH bursts */
-  rc = detectAnyBurst(*burst, mTSC, BURST_THRESH, mSPSRx, type, max_toa, &ebp);
+  rc = detectAnyBurst(*burst, mTSC, BURST_THRESH, cfg->rx_sps, type, max_toa, &ebp);
   if (rc <= 0) {
-    if (rc == -SIGERR_CLIP)
-      LOGCHAN(chan, DTRXDUL, NOTICE) << "Clipping detected on received RACH or Normal Burst";
-    else if (rc != SIGERR_NONE)
-      LOGCHAN(chan, DTRXDUL, NOTICE) << "Unhandled RACH or Normal Burst detection error";
+    if (rc == -SIGERR_CLIP) {
+      LOGCHAN(chan, DTRXDUL, INFO) << "Clipping detected on received RACH or Normal Burst";
+      state->ctrs.rx_clipping++;
+      ctr_changed = true;
+    } else if (rc != SIGERR_NONE) {
+      LOGCHAN(chan, DTRXDUL, INFO) << "Unhandled RACH or Normal Burst detection error";
+      state->ctrs.rx_no_burst_detected++;
+      ctr_changed = true;
+    }
     goto ret_idle;
   }
 
-  type = (CorrType) rc;
+  rxBurst = demodAnyBurst(*burst, (CorrType) rc, cfg->rx_sps, &ebp);
   bi->toa = ebp.toa;
   bi->tsc = ebp.tsc;
   bi->ci = ebp.ci;
-  rxBurst = demodAnyBurst(*burst, mSPSRx, ebp.amp, ebp.toa, type);
 
   /* EDGE demodulator returns 444 (gSlotLen * 3) bits */
   if (rxBurst->size() == EDGE_BURST_NBITS) {
@@ -713,6 +756,8 @@ int Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
   return 0;
 
 ret_idle:
+  if (ctr_changed)
+    dispatch_trx_rate_ctr_change(state, chan);
   bi->idle = true;
   delete radio_burst;
   return 0;
@@ -760,7 +805,7 @@ void Transceiver::ctrl_sock_send(ctrl_msg& m, int chan)
   struct osmo_fd *conn_bfd = &s.conn_bfd;
 
   s.txmsgqueue.push_back(m);
-  conn_bfd->when |= OSMO_FD_WRITE;
+  osmo_fd_write_enable(conn_bfd);
 }
 
 int Transceiver::ctrl_sock_write(int chan)
@@ -775,7 +820,7 @@ int Transceiver::ctrl_sock_write(int chan)
   while (s.txmsgqueue.size()) {
     const ctrl_msg m = s.txmsgqueue.front();
 
-    s.conn_bfd.when &= ~OSMO_FD_WRITE;
+    osmo_fd_write_disable(&s.conn_bfd);
 
     /* try to send it over the socket */
     rc = write(s.conn_bfd.fd, m.data, strlen(m.data) + 1);
@@ -783,7 +828,7 @@ int Transceiver::ctrl_sock_write(int chan)
       goto close;
     if (rc < 0) {
       if (errno == EAGAIN) {
-        s.conn_bfd.when |= OSMO_FD_WRITE;
+        osmo_fd_write_enable(&s.conn_bfd);
         break;
       }
       goto close;
@@ -887,7 +932,7 @@ int Transceiver::ctrl_sock_handle_rx(int chan)
               (int) round(20.0 * log10(rxFullScale / lev)));
     }
     else {
-      sprintf(response,"RSP NOISELEV 1  0");
+      sprintf(response,"RSP NOISELEV 1 0");
     }
   } else if (match_cmd(command, "SETPOWER", &params)) {
     int power;
@@ -902,11 +947,14 @@ int Transceiver::ctrl_sock_handle_rx(int chan)
     power = mRadioInterface->setPowerAttenuation(power, chan);
     mStates[chan].mPower = power;
     sprintf(response, "RSP ADJPOWER 0 %d", power);
+} else if (match_cmd(command, "NOMTXPOWER", NULL)) {
+    int power = mRadioInterface->getNominalTxPower(chan);
+    sprintf(response, "RSP NOMTXPOWER 0 %d", power);
   } else if (match_cmd(command, "RXTUNE", &params)) {
     // tune receiver
     int freqKhz;
     sscanf(params, "%d", &freqKhz);
-    mRxFreq = freqKhz * 1e3;
+    mRxFreq = (freqKhz + cfg->freq_offset_khz) * 1e3;
     if (!mRadioInterface->tuneRx(mRxFreq, chan)) {
        LOGCHAN(chan, DTRXCTRL, FATAL) << "RX failed to tune";
        sprintf(response,"RSP RXTUNE 1 %d",freqKhz);
@@ -917,7 +965,7 @@ int Transceiver::ctrl_sock_handle_rx(int chan)
     // tune txmtr
     int freqKhz;
     sscanf(params, "%d", &freqKhz);
-    mTxFreq = freqKhz * 1e3;
+    mTxFreq = (freqKhz + cfg->freq_offset_khz) * 1e3;
     if (!mRadioInterface->tuneTx(mTxFreq, chan)) {
        LOGCHAN(chan, DTRXCTRL, FATAL) << "TX failed to tune";
        sprintf(response,"RSP TXTUNE 1 %d",freqKhz);
@@ -955,13 +1003,19 @@ int Transceiver::ctrl_sock_handle_rx(int chan)
     LOGCHAN(chan, DTRXCTRL, INFO) << "BTS requests TRXD version switch: " << version_recv;
     if (version_recv > TRX_DATA_FORMAT_VER) {
       LOGCHAN(chan, DTRXCTRL, INFO) << "rejecting TRXD version " << version_recv
-                                    << "in favor of " <<  TRX_DATA_FORMAT_VER;
+                                    << " in favor of " <<  TRX_DATA_FORMAT_VER;
       sprintf(response, "RSP SETFORMAT %u %u", TRX_DATA_FORMAT_VER, version_recv);
     } else {
       LOGCHAN(chan, DTRXCTRL, NOTICE) << "switching to TRXD version " << version_recv;
       mVersionTRXD[chan] = version_recv;
       sprintf(response, "RSP SETFORMAT %u %u", version_recv, version_recv);
     }
+  } else if (match_cmd(command, "RFMUTE", &params)) {
+    // (Un)mute RF TX and RX
+    unsigned mute;
+    sscanf(params, "%u", &mute);
+    mStates[chan].mMuted = mute ? true : false;
+    sprintf(response, "RSP RFMUTE 0 %u", mute);
   } else if (match_cmd(command, "_SETBURSTTODISKMASK", &params)) {
     // debug command! may change or disappear without notice
     // set a mask which bursts to dump to disk
@@ -986,6 +1040,7 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
   struct trxd_hdr_v01_dl *dl;
   char buffer[sizeof(*dl) + EDGE_BURST_NBITS];
   uint32_t fn;
+  uint8_t tn;
 
   // check data socket
   msgLen = read(mDataSockets[chan], buffer, sizeof(buffer));
@@ -999,8 +1054,8 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
       burstLen = gSlotLen;
       break;
     case sizeof(*dl) + EDGE_BURST_NBITS: /* EDGE burst */
-      if (mSPSTx != 4) {
-        LOGCHAN(chan, DTRXDDL, ERROR) << "EDGE burst received but SPS is set to " << mSPSTx;
+      if (cfg->tx_sps != 4) {
+        LOGCHAN(chan, DTRXDDL, ERROR) << "EDGE burst received but SPS is set to " << cfg->tx_sps;
         return false;
       }
       burstLen = EDGE_BURST_NBITS;
@@ -1014,6 +1069,7 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
 
   /* Convert TDMA FN to the host endianness */
   fn = osmo_load32be(&dl->common.fn);
+  tn = dl->common.tn;
 
   /* Make sure we support the received header format */
   switch (dl->common.version) {
@@ -1027,7 +1083,44 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
   }
 
   LOGCHAN(chan, DTRXDDL, DEBUG) << "Rx TRXD message (hdr_ver=" << unsigned(dl->common.version)
-    << "): fn=" << fn << ", tn=" << unsigned(dl->common.tn) << ", burst_len=" << burstLen;
+    << "): fn=" << fn << ", tn=" << unsigned(tn) << ", burst_len=" << burstLen;
+
+  TransceiverState *state = &mStates[chan];
+  GSM::Time currTime = GSM::Time(fn, tn);
+
+  /* Verify proper FN order in DL stream */
+  if (state->first_dl_fn_rcv[tn]) {
+    int32_t delta = GSM::FNDelta(currTime.FN(), state->last_dl_time_rcv[tn].FN());
+    if (delta == 1) {
+        /* usual expected scenario, continue code flow */
+    } else if (delta == 0) {
+      LOGCHAN(chan, DTRXDDL, INFO) << "Rx TRXD msg with repeated FN " << currTime;
+      state->ctrs.tx_trxd_fn_repeated++;
+      dispatch_trx_rate_ctr_change(state, chan);
+      return true;
+    } else if (delta < 0) {
+      LOGCHAN(chan, DTRXDDL, INFO) << "Rx TRXD msg with previous FN " << currTime
+                                     << " vs last " << state->last_dl_time_rcv[tn];
+       state->ctrs.tx_trxd_fn_outoforder++;
+       dispatch_trx_rate_ctr_change(state, chan);
+       /* Allow adding radio vector below, since it gets sorted in the queue */
+    } else if (chan == 0 && state->mFiller == FILLER_ZERO) {
+        /* delta > 1. Some FN was lost in the middle. We can only easily rely
+         * on consecutive FNs in TRX0 since it must transmit continuously in all
+         * setups. Also, osmo-trx supports optionally filling empty bursts on
+         * its own. In that case bts-trx is not obliged to submit all bursts. */
+      LOGCHAN(chan, DTRXDDL, INFO) << "Rx TRXD msg with future FN " << currTime
+                                     << " vs last " << state->last_dl_time_rcv[tn]
+                                     << ", " << delta - 1 << " FN lost";
+      state->ctrs.tx_trxd_fn_skipped += delta - 1;
+      dispatch_trx_rate_ctr_change(state, chan);
+    }
+    if (delta > 0)
+      state->last_dl_time_rcv[tn] = currTime;
+  } else { /* Initial check, simply store state */
+    state->first_dl_fn_rcv[tn] = true;
+    state->last_dl_time_rcv[tn] = currTime;
+  }
 
   BitVector newBurst(burstLen);
   BitVector::iterator itr = newBurst.begin();
@@ -1035,8 +1128,6 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
   while (itr < newBurst.end())
     *itr++ = *bufferItr++;
 
-  GSM::Time currTime = GSM::Time(fn, dl->common.tn);
-
   addRadioVector(chan, newBurst, dl->tx_att, currTime);
 
   return true;
@@ -1053,6 +1144,8 @@ bool Transceiver::driveReceiveRadio()
     return false;
 
   if (mForceClockInterface || mTransmitDeadlineClock > mLastClockUpdateTime + GSM::Time(216,0)) {
+    if (mForceClockInterface)
+      LOGC(DTRXCLK, NOTICE) << "Sending CLOCK indications";
     mForceClockInterface = false;
     return writeClockInterface();
   }
@@ -1069,11 +1162,13 @@ void Transceiver::logRxBurst(size_t chan, const struct trx_ul_burst_ind *bi)
     else os << "-";
   }
 
+  double rssi_offset = rssiOffset(chan);
+
   LOGCHAN(chan, DTRXDUL, DEBUG) << std::fixed << std::right
     << " time: "   << unsigned(bi->tn) << ":" << bi->fn
-    << " RSSI: "   << std::setw(5) << std::setprecision(1) << (bi->rssi - rssiOffset)
+    << " RSSI: "   << std::setw(5) << std::setprecision(1) << (bi->rssi - rssi_offset)
                    << "dBFS/" << std::setw(6) << -bi->rssi << "dBm"
-    << " noise: "  << std::setw(5) << std::setprecision(1) << (bi->noise - rssiOffset)
+    << " noise: "  << std::setw(5) << std::setprecision(1) << (bi->noise - rssi_offset)
                    << "dBFS/" << std::setw(6) << -bi->noise << "dBm"
     << " TOA: "    << std::setw(5) << std::setprecision(2) << bi->toa
     << " C/I: "    << std::setw(5) << std::setprecision(2) << bi->ci << "dB"
@@ -1093,7 +1188,7 @@ bool Transceiver::driveReceiveFIFO(size_t chan)
     return false; /* other errors: we want to stop the process */
   }
 
-  if (!bi.idle)
+  if (!bi.idle && log_check_level(DTRXDUL, LOGL_DEBUG))
     logRxBurst(chan, &bi);
 
   switch (mVersionTRXD[chan]) {
@@ -1191,6 +1286,7 @@ void *RxUpperLoopAdapter(TrxChanThParams *params)
 
   snprintf(thread_name, 16, "RxUpper%zu", num);
   set_selfthread_name(thread_name);
+  OSMO_ASSERT(osmo_cpu_sched_vty_apply_localthread() == 0);
 
   while (1) {
     if (!trx->driveReceiveFIFO(num)) {
@@ -1206,6 +1302,7 @@ void *RxUpperLoopAdapter(TrxChanThParams *params)
 void *RxLowerLoopAdapter(Transceiver *transceiver)
 {
   set_selfthread_name("RxLower");
+  OSMO_ASSERT(osmo_cpu_sched_vty_apply_localthread() == 0);
 
   while (1) {
     if (!transceiver->driveReceiveRadio()) {
@@ -1221,6 +1318,7 @@ void *RxLowerLoopAdapter(Transceiver *transceiver)
 void *TxLowerLoopAdapter(Transceiver *transceiver)
 {
   set_selfthread_name("TxLower");
+  OSMO_ASSERT(osmo_cpu_sched_vty_apply_localthread() == 0);
 
   while (1) {
     transceiver->driveTxFIFO();
@@ -1239,6 +1337,7 @@ void *TxUpperLoopAdapter(TrxChanThParams *params)
 
   snprintf(thread_name, 16, "TxUpper%zu", num);
   set_selfthread_name(thread_name);
+  OSMO_ASSERT(osmo_cpu_sched_vty_apply_localthread() == 0);
 
   while (1) {
     if (!trx->driveTxPriorityQueue(num)) {

Transceiver52M/Transceiver.h

@@ -63,6 +63,7 @@ struct TransceiverState {
   /* The filler table */
   signalVector *fillerTable[102][8];
   int fillerModulus[8];
+  FillerType mFiller;
   bool mRetrans;
 
   /* Most recent channel estimate of all timeslots */
@@ -83,33 +84,35 @@ struct TransceiverState {
 
   /* Shadowed downlink attenuation */
   int mPower;
+
+  /* RF emission and reception disabled, as per NM Administrative State Locked */
+  bool mMuted;
+
+  /* counters */
+  struct trx_counters ctrs;
+
+  /* Used to keep track of lost and out of order frames */
+  bool first_dl_fn_rcv[8];
+  GSM::Time last_dl_time_rcv[8];
 };
 
 /** The Transceiver class, responsible for physical layer of basestation */
 class Transceiver {
 public:
   /** Transceiver constructor
-      @param wBasePort base port number of UDP sockets
-      @param TRXAddress IP address of the TRX, as a string
-      @param GSMcoreAddress IP address of the GSM core, as a string
-      @param wSPS number of samples per GSM symbol
+      @param cfg VTY populated config
       @param wTransmitLatency initial setting of transmit latency
       @param radioInterface associated radioInterface object
   */
-  Transceiver(int wBasePort,
-              const char *TRXAddress,
-              const char *GSMcoreAddress,
-              size_t tx_sps, size_t rx_sps, size_t chans,
+  Transceiver(const struct trx_cfg *cfg,
               GSM::Time wTransmitLatency,
-              RadioInterface *wRadioInterface,
-              double wRssiOffset, int stackSize);
+              RadioInterface *wRadioInterface);
 
   /** Destructor */
   ~Transceiver();
 
   /** Start the control loop */
-  bool init(FillerType filler, size_t rtsc, unsigned rach_delay,
-            bool edge, bool ext_rach);
+  bool init(void);
 
   /** attach the radioInterface receive FIFO */
   bool receiveFIFO(VectorFIFO *wFIFO, size_t chan)
@@ -122,7 +125,7 @@ public:
   }
 
   /** accessor for number of channels */
-  size_t numChans() const { return mChans; };
+  size_t numChans() const { return cfg->num_chans; };
 
   /** Codes for channel combinations */
   typedef enum {
@@ -145,7 +148,6 @@ public:
   } ChannelCombination;
 
 private:
-
 struct ctrl_msg {
   char data[101];
   ctrl_msg() {};
@@ -166,10 +168,7 @@ struct ctrl_sock_state {
   }
 };
 
-  int mBasePort;
-  std::string mLocalAddr;
-  std::string mRemoteAddr;
-
+  const struct trx_cfg *cfg;	///< VTY populated config
   std::vector<int> mDataSockets;  ///< socket for writing to/reading from GSM core
   std::vector<ctrl_sock_state> mCtrlSockets;  ///< socket for writing/reading control commands from GSM core
   int mClockSocket;               ///< socket for writing clock updates to GSM core
@@ -191,9 +190,6 @@ struct ctrl_sock_state {
   double txFullScale;                     ///< full scale input to radio
   double rxFullScale;                     ///< full scale output to radio
 
-  double rssiOffset;                      ///< RSSI to dBm conversion offset
-  int stackSize;                      ///< stack size for threads, 0 = OS default
-
   /** modulate and add a burst to the transmit queue */
   void addRadioVector(size_t chan, BitVector &bits,
                       int RSSI, GSM::Time &wTime);
@@ -222,12 +218,7 @@ struct ctrl_sock_state {
   /** drive handling of control messages from GSM core */
   int ctrl_sock_handle_rx(int chan);
 
-  int mSPSTx;                          ///< number of samples per Tx symbol
-  int mSPSRx;                          ///< number of samples per Rx symbol
   size_t mChans;
-
-  bool mExtRACH;
-  bool mEdge;
   bool mOn;	                           ///< flag to indicate that transceiver is powered on
   bool mForceClockInterface;           ///< flag to indicate whether IND CLOCK shall be sent unconditionally after transceiver is started
   bool mHandover[8][8];                ///< expect handover to the timeslot/subslot
@@ -269,7 +260,7 @@ protected:
   friend void *RxLowerLoopAdapter(Transceiver *transceiver);
   friend void *TxLowerLoopAdapter(Transceiver *transceiver);
 
-
+  double rssiOffset(size_t chan);
   void reset();
 
   void logRxBurst(size_t chan, const struct trx_ul_burst_ind *bi);

Transceiver52M/arch/arm/convert.c

@@ -13,10 +13,6 @@
  * 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
  */
 
 #include <malloc.h>

Transceiver52M/arch/arm/convert_neon.S

@@ -13,10 +13,6 @@
  * 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
  */
 
 	.syntax unified

Transceiver52M/arch/arm/convolve.c

@@ -13,10 +13,6 @@
  * 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
  */
 
 #include <malloc.h>

Transceiver52M/arch/arm/convolve_neon.S

@@ -13,10 +13,6 @@
  * 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

Transceiver52M/arch/arm/mult.c

@@ -13,10 +13,6 @@
  * 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
  */
 
 #include <malloc.h>

Transceiver52M/arch/arm/mult_neon.S

@@ -13,10 +13,6 @@
  * 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
  */
 
 	.syntax unified

Transceiver52M/arch/arm/scale.c

@@ -13,10 +13,6 @@
  * 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
  */
 
 #include <malloc.h>

Transceiver52M/arch/arm/scale_neon.S

@@ -13,10 +13,6 @@
  * 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
  */
 
 	.syntax unified

Transceiver52M/arch/common/convert_base.c

@@ -13,10 +13,6 @@
  * 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
  */
 
 #include "convert.h"

Transceiver52M/arch/common/convolve_base.c

@@ -13,10 +13,6 @@
  * 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
  */
 
 #include <malloc.h>

Transceiver52M/arch/x86/convert.c

@@ -11,10 +11,6 @@
  * 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
  */
 
 #include <malloc.h>

Transceiver52M/arch/x86/convert_sse_3.c

@@ -11,10 +11,6 @@
  * 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
  */
 
 #include <malloc.h>

Transceiver52M/arch/x86/convert_sse_3.h

@@ -11,10 +11,6 @@
  * 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
  */
 
 #pragma once

Transceiver52M/arch/x86/convert_sse_4_1.c

@@ -11,10 +11,6 @@
  * 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
  */
 
 #include <malloc.h>

Transceiver52M/arch/x86/convert_sse_4_1.h

@@ -11,10 +11,6 @@
  * 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
  */
 
 #pragma once

Transceiver52M/arch/x86/convolve.c

@@ -11,10 +11,6 @@
  * 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
  */
 
 #include <malloc.h>
@@ -99,9 +95,10 @@ int convolve_real(const float *x, int x_len,
 		  const float *h, int h_len,
 		  float *y, int y_len, int start, int len)
 {
+#ifndef __OPTIMIZE__
 	if (bounds_check(x_len, h_len, y_len, start, len) < 0)
 		return -1;
-
+#endif
 	memset(y, 0, len * 2 * sizeof(float));
 
 	switch (h_len) {
@@ -138,9 +135,10 @@ int convolve_complex(const float *x, int x_len,
 		     float *y, int y_len,
 		     int start, int len)
 {
+#ifndef __OPTIMIZE__
 	if (bounds_check(x_len, h_len, y_len, start, len) < 0)
 		return -1;
-
+#endif
 	memset(y, 0, len * 2 * sizeof(float));
 
 	if (!(h_len % 8))

Transceiver52M/arch/x86/convolve_sse_3.c

@@ -11,10 +11,6 @@
  * 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
  */
 
 #include <malloc.h>

Transceiver52M/arch/x86/convolve_sse_3.h

@@ -11,10 +11,6 @@
  * 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
  */
 
 #pragma once

Transceiver52M/device/Makefile.am

@@ -2,9 +2,9 @@ include $(top_srcdir)/Makefile.common
 
 SUBDIRS = common
 
-#if DEVICE_IPC
+if DEVICE_IPC
 SUBDIRS += ipc
-#endif
+endif
 
 if DEVICE_USRP1
 SUBDIRS += usrp1

Transceiver52M/device/common/Makefile.am

@@ -1,7 +1,7 @@
 include $(top_srcdir)/Makefile.common
 
 AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES)
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(LMS_CFLAGS)
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS)
 
 
 noinst_HEADERS = radioDevice.h smpl_buf.h

Transceiver52M/device/common/radioDevice.h

@@ -125,17 +125,11 @@ class RadioDevice {
   /** return minimum Rx Gain **/
   virtual double minRxGain(void) = 0;
 
-  /** sets the transmit chan gain, returns the gain setting **/
-  virtual double setTxGain(double dB, size_t chan = 0) = 0;
+  /** return base RSSI offset to apply for received samples **/
+  virtual double rssiOffset(size_t chan) = 0;
 
-  /** get transmit gain */
-  virtual double getTxGain(size_t chan = 0) = 0;
-
-  /** return maximum Tx Gain **/
-  virtual double maxTxGain(void) = 0;
-
-  /** return minimum Tx Gain **/
-  virtual double minTxGain(void) = 0;
+  /** returns the Nominal transmit output power of the transceiver in dBm, negative on error **/
+  virtual int getNominalTxPower(size_t chan = 0) = 0;
 
   /** sets the RX path to use, returns true if successful and false otherwise */
   virtual bool setRxAntenna(const std::string &ant, size_t chan = 0) = 0;
@@ -160,6 +154,9 @@ class RadioDevice {
   virtual double getRxFreq(size_t chan = 0) = 0;
   virtual double getSampleRate()=0;
 
+  virtual double setPowerAttenuation(int atten, size_t chan) = 0;
+  virtual double getPowerAttenuation(size_t chan=0) = 0;
+
   protected:
   size_t tx_sps, rx_sps;
   InterfaceType iface;
@@ -192,6 +189,13 @@ class RadioDevice {
 	for (i = 0; i < tx_paths.size(); i++) {
 		if (tx_paths[i] == "")
 			continue;
+		if (iface == MULTI_ARFCN && i > 0) {
+			LOGCHAN(i, DDEV, NOTICE) << "Not setting Tx antenna "
+						 << tx_paths[i]
+						 << " for a logical channel";
+			continue;
+		}
+
 		LOGCHAN(i, DDEV, DEBUG) << "Configuring Tx antenna " << tx_paths[i];
 		if (!setTxAntenna(tx_paths[i], i)) {
 			LOGCHAN(i, DDEV, ALERT) << "Failed configuring Tx antenna " << tx_paths[i];
@@ -202,6 +206,13 @@ class RadioDevice {
 	for (i = 0; i < rx_paths.size(); i++) {
 		if (rx_paths[i] == "")
 			continue;
+		if (iface == MULTI_ARFCN && i > 0) {
+			LOGCHAN(i, DDEV, NOTICE) << "Not setting Rx antenna "
+						 << rx_paths[i]
+						 << " for a logical channel";
+			continue;
+		}
+
 		LOGCHAN(i, DDEV, DEBUG) << "Configuring Rx antenna " << rx_paths[i];
 		if (!setRxAntenna(rx_paths[i], i)) {
 			LOGCHAN(i, DDEV, ALERT) << "Failed configuring Rx antenna " << rx_paths[i];

Transceiver52M/device/common/smpl_buf.cpp

@@ -28,9 +28,9 @@
 #include <inttypes.h>
 
 smpl_buf::smpl_buf(size_t len)
-	: buf_len(len), time_start(0), time_end(0),
-	  data_start(0), data_end(0)
+	: buf_len(len)
 {
+	reset();
 	data = new uint32_t[len];
 }
 
@@ -39,6 +39,14 @@ smpl_buf::~smpl_buf()
 	delete[] data;
 }
 
+void smpl_buf::reset()
+{
+	time_start = 0;
+	time_end = 0;
+	data_start = 0;
+	data_end = 0;
+}
+
 ssize_t smpl_buf::avail_smpls(TIMESTAMP timestamp) const
 {
 	if (timestamp < time_start)

Transceiver52M/device/common/smpl_buf.h

@@ -44,6 +44,10 @@ public:
 	smpl_buf(size_t len);
 	~smpl_buf();
 
+	/** Reset this buffer, keeps the size
+	*/
+	void reset();
+
 	/** Query number of samples available for reading
 	    @param timestamp time of first sample
 	    @return number of available samples or error

Transceiver52M/device/ipc/IPCDevice.cpp

@@ -4,38 +4,40 @@
 *
 * SPDX-License-Identifier: AGPL-3.0+
 *
-	This program is free software: you can redistribute it and/or modify
-	it under the terms of the GNU Affero General Public License as published by
-	the Free Software Foundation, either version 3 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 Affero General Public License for more details.
-
-	You should have received a copy of the GNU Affero General Public License
-	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 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 Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* See the COPYING file in the main directory for details.
 */
 
-#include <stdint.h>
-#include <string.h>
-#include <stdlib.h>
+#include <cstdint>
+#include <cstring>
+#include <cstdlib>
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "Logger.h"
+#include "Threads.h"
+#include "IPCDevice.h"
+#include "smpl_buf.h"
+
+extern "C" {
 #include <sys/mman.h>
 #include <sys/stat.h> /* For mode constants */
 #include <fcntl.h> /* For O_* constants */
 
-#include <map>
-
-#include "trx_vty.h"
-#include "Logger.h"
-#include "Threads.h"
-#include "Utils.h"
-#include "IPCDevice.h"
-
-extern "C" {
 #include "osmo_signal.h"
-#include <osmocom/core/application.h>
 #include <osmocom/core/talloc.h>
 #include <osmocom/core/select.h>
 #include <osmocom/core/socket.h>
@@ -44,11 +46,9 @@ extern "C" {
 #include <osmocom/core/msgb.h>
 #include <osmocom/core/select.h>
 #include <osmocom/core/timer.h>
-}
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
+#include "ipc_shm.h"
+}
 
 #define SAMPLE_BUF_SZ (1 << 20)
 
@@ -58,52 +58,56 @@ static int ipc_chan_sock_cb(struct osmo_fd *bfd, unsigned int flags);
 
 IPCDevice::IPCDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface, size_t chan_num, double lo_offset,
 		     const std::vector<std::string> &tx_paths, const std::vector<std::string> &rx_paths)
-	: RadioDevice(tx_sps, rx_sps, iface, chan_num, lo_offset, tx_paths, rx_paths),
-	  tmp_state(IPC_IF_MSG_GREETING_REQ), shm(NULL), started(false)
+	: RadioDevice(tx_sps, rx_sps, iface, chan_num, lo_offset, tx_paths, rx_paths), tx_attenuation(),
+	  tmp_state(IPC_IF_MSG_GREETING_REQ), shm(NULL), shm_dec(0), started(false)
 {
 	LOGC(DDEV, INFO) << "creating IPC device...";
 
-	//m_IPC_stream_rx.resize(chans);
-	//m_IPC_stream_tx.resize(chans);
 	rx_gains.resize(chans);
 	tx_gains.resize(chans);
 
 	rx_buffers.resize(chans);
 
+	sk_chan_state.resize(chans, ipc_per_trx_sock_state());
+
 	/* Set up per-channel Rx timestamp based Ring buffers */
 	for (size_t i = 0; i < rx_buffers.size(); i++)
 		rx_buffers[i] = new smpl_buf(SAMPLE_BUF_SZ / sizeof(uint32_t));
-
-	memset(&sk_chan_state, 0, sizeof(sk_chan_state));
 }
 
 IPCDevice::~IPCDevice()
 {
-	//unsigned int i;
 	LOGC(DDEV, INFO) << "Closing IPC device";
 	/* disable all channels */
 
 	for (size_t i = 0; i < rx_buffers.size(); i++)
 		delete rx_buffers[i];
 
-	for (unsigned int i = 0; i < ARRAY_SIZE(sk_chan_state); i++)
+	ipc_sock_close(&master_sk_state);
+
+	for (unsigned int i = 0; i < sk_chan_state.size(); i++)
 		ipc_sock_close(&sk_chan_state[i]);
 
 	for (auto i : shm_io_rx_streams)
 		ipc_shm_close(i);
 	for (auto i : shm_io_tx_streams)
 		ipc_shm_close(i);
+
+	if (shm_dec)
+		talloc_free(shm_dec);
 }
 
 int IPCDevice::ipc_shm_connect(const char *shm_name)
 {
 	int fd;
+	char err_buf[256];
 	size_t shm_len;
 	int rc;
 
 	LOGP(DDEV, LOGL_NOTICE, "Opening shm path %s\n", shm_name);
 	if ((fd = shm_open(shm_name, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR)) < 0) {
-		LOGP(DDEV, LOGL_ERROR, "shm_open %d: %s\n", errno, strerror(errno));
+		LOGP(DDEV, LOGL_ERROR, "shm_open %d: %s\n", errno,
+		     strerror_r(errno, err_buf, sizeof(err_buf)));
 		rc = -errno;
 		goto err_shm_open;
 	}
@@ -111,7 +115,8 @@ int IPCDevice::ipc_shm_connect(const char *shm_name)
 	// Get size of the allocated memory
 	struct stat shm_stat;
 	if (fstat(fd, &shm_stat) < 0) {
-		LOGP(DDEV, LOGL_ERROR, "fstat %d: %s\n", errno, strerror(errno));
+		LOGP(DDEV, LOGL_ERROR, "fstat %d: %s\n", errno,
+		     strerror_r(errno, err_buf, sizeof(err_buf)));
 		rc = -errno;
 		goto err_mmap;
 	}
@@ -120,12 +125,13 @@ int IPCDevice::ipc_shm_connect(const char *shm_name)
 
 	LOGP(DDEV, LOGL_NOTICE, "mmaping shared memory fd %d (size=%zu)\n", fd, shm_len);
 	if ((shm = mmap(NULL, shm_len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)) == MAP_FAILED) {
-		LOGP(DDEV, LOGL_ERROR, "mmap %d: %s\n", errno, strerror(errno));
+		LOGP(DDEV, LOGL_ERROR, "mmap %d: %s\n", errno,
+		     strerror_r(errno, err_buf, sizeof(err_buf)));
 		rc = -errno;
 		goto err_mmap;
 	}
 	LOGP(DDEV, LOGL_NOTICE, "mmap'ed shared memory at addr %p\n", shm);
-	LOGP(DDEV, LOGL_NOTICE, "%s\n", osmo_hexdump((const unsigned char *)shm, 80));
+	//	LOGP(DDEV, LOGL_NOTICE, "%s\n", osmo_hexdump((const unsigned char *)shm, 80));
 	/* After a call to mmap(2) the file descriptor may be closed without affecting the memory mapping. */
 	close(fd);
 	return 0;
@@ -136,7 +142,7 @@ err_shm_open:
 	return rc;
 }
 
-static int ipc_sock_send(struct ipc_sock_state *state, struct msgb *msg);
+static int ipc_sock_send(struct ipc_per_trx_sock_state *state, struct msgb *msg);
 
 static struct msgb *ipc_msgb_alloc(uint8_t msg_type)
 {
@@ -153,7 +159,7 @@ static struct msgb *ipc_msgb_alloc(uint8_t msg_type)
 	return msg;
 }
 
-static int ipc_tx_greeting_req(struct ipc_sock_state *state, uint8_t req_version)
+static int ipc_tx_greeting_req(struct ipc_per_trx_sock_state *state, uint8_t req_version)
 {
 	struct msgb *msg;
 	struct ipc_sk_if *ipc_prim;
@@ -171,7 +177,7 @@ static int ipc_tx_greeting_req(struct ipc_sock_state *state, uint8_t req_version
 	return ipc_sock_send(state, msg);
 }
 
-static int ipc_tx_info_req(struct ipc_sock_state *state)
+static int ipc_tx_info_req(struct ipc_per_trx_sock_state *state)
 {
 	struct msgb *msg;
 	//struct ipc_sk_if *ipc_prim;
@@ -187,7 +193,7 @@ static int ipc_tx_info_req(struct ipc_sock_state *state)
 	return ipc_sock_send(state, msg);
 }
 
-int IPCDevice::ipc_tx_open_req(struct ipc_sock_state *state, uint32_t num_chans, uint32_t ref)
+int IPCDevice::ipc_tx_open_req(struct ipc_per_trx_sock_state *state, uint32_t num_chans, uint32_t ref)
 {
 	struct msgb *msg;
 	struct ipc_sk_if *ipc_prim;
@@ -202,7 +208,8 @@ int IPCDevice::ipc_tx_open_req(struct ipc_sock_state *state, uint32_t num_chans,
 	ipc_prim = (struct ipc_sk_if *)msg->data;
 	ipc_prim->u.open_req.num_chans = num_chans;
 
-	/* FIXME: pass fractional freq */
+	/* FIXME: this is actually the sps value, not the sample rate!
+	 * sample rate is looked up according to the sps rate by uhd backend */
 	ipc_prim->u.open_req.rx_sample_freq_num = rx_sps;
 	ipc_prim->u.open_req.rx_sample_freq_den = 1;
 	ipc_prim->u.open_req.tx_sample_freq_num = tx_sps;
@@ -253,8 +260,10 @@ int IPCDevice::ipc_rx_info_cnf(const struct ipc_sk_if_info_cnf *info_cnf)
 	current_info_cnf = *info_cnf;
 	unsigned int i;
 
-	if (info_cnf->max_num_chans < chans)
+	if (info_cnf->max_num_chans < chans) {
+		LOGC(DDEV, ERROR) << "chan num mismatch:" << info_cnf->max_num_chans << " vs " << chans;
 		return -1;
+	}
 
 	/* Here:
 	 * verify info_cnf->max_num_chans >= requested chans
@@ -264,17 +273,20 @@ int IPCDevice::ipc_rx_info_cnf(const struct ipc_sk_if_info_cnf *info_cnf)
 	 * cache rx/tx paths per channel, and make sure it matches the one the user wants to set
 	 */
 
-	LOGC(DDEV, NOTICE) << "Rx Info CNF:"
-			   << " name=" << info_cnf->dev_desc << std::endl
-			   << " max_num_chans=" << info_cnf->max_num_chans << " feature_mask=" << info_cnf->feature_mask
-			   << " min_rx_gain=" << info_cnf->min_rx_gain << " max_rx_gain=" << info_cnf->max_rx_gain
-			   << " min_tx_gain=" << info_cnf->min_tx_gain << " max_tx_gain=" << info_cnf->max_tx_gain;
+	LOGC(DDEV, NOTICE)
+		<< "Rx Info CNF:"
+		<< " name=" << info_cnf->dev_desc << std::endl
+		<< " max_num_chans=" << info_cnf->max_num_chans << " feature_mask=" << info_cnf->feature_mask;
 	for (i = 0; i < info_cnf->max_num_chans; i++) {
 		int j = 0;
 		bool rx_found = false, tx_found = false;
 		while (strcmp(info_cnf->chan_info[i].rx_path[j], "") != 0) {
 			LOGC(DDEV, NOTICE)
-				<< "chan " << i << ": RxPath[" << j << "]: " << info_cnf->chan_info[i].rx_path[j];
+				<< "chan " << i << ": RxPath[" << j << "]: " << info_cnf->chan_info[i].rx_path[j]
+				<< " min_rx_gain=" << info_cnf->chan_info[i].min_rx_gain
+				<< " max_rx_gain=" << info_cnf->chan_info[i].max_rx_gain
+				<< " min_tx_gain=" << info_cnf->chan_info[i].min_tx_gain
+				<< " max_tx_gain=" << info_cnf->chan_info[i].max_tx_gain;
 
 			if (rx_paths.size() < (i + 1) ||
 			    strcmp(rx_paths[i].c_str(), info_cnf->chan_info[i].rx_path[j]) == 0) {
@@ -322,10 +334,9 @@ int IPCDevice::ipc_rx_open_cnf(const struct ipc_sk_if_open_cnf *open_cnf)
 		int rc;
 		LOGC(DDEV, NOTICE) << "chan " << i << ": sk_path=" << open_cnf->chan_info[i].chan_ipc_sk_path;
 
-		/* FIXME: current limit 8 chans, make dynamic */
-		if (i < 8) {
-			struct ipc_sock_state *state = &sk_chan_state[i];
-			memset(state, 0x00, sizeof(*state));
+		/* FIXME: current limit IPC_MAX_NUM_TRX chans, make dynamic */
+		if (i < IPC_MAX_NUM_TRX) {
+			struct ipc_per_trx_sock_state *state = &sk_chan_state[i];
 
 			INIT_LLIST_HEAD(&state->upqueue);
 			rc = osmo_sock_unix_init_ofd(&state->conn_bfd, SOCK_SEQPACKET, 0,
@@ -353,12 +364,17 @@ int IPCDevice::ipc_rx_open_cnf(const struct ipc_sk_if_open_cnf *open_cnf)
 	/* server inits both producers */
 	for (unsigned int i = 0; i < shm_dec->num_chans; i++) {
 		LOGC(DDEV, NOTICE)
-			<< "shm: chan" << i << "/dl: num_buffers=" << shm_dec->channels[0]->dl_stream->num_buffers;
+			<< "shm: chan" << i << "/dl: num_buffers=" << shm_dec->channels[i]->dl_stream->num_buffers;
 		LOGC(DDEV, NOTICE)
-			<< "shm: chan" << i << "/dl: buffer_size=" << shm_dec->channels[0]->dl_stream->buffer_size;
+			<< "shm: chan" << i << "/dl: buffer_size=" << shm_dec->channels[i]->dl_stream->buffer_size;
+		LOGC(DDEV, NOTICE)
+			<< "shm: chan" << i << "/ul: num_buffers=" << shm_dec->channels[i]->ul_stream->num_buffers;
+		LOGC(DDEV, NOTICE)
+			<< "shm: chan" << i << "/ul: buffer_size=" << shm_dec->channels[i]->ul_stream->buffer_size;
 		shm_io_rx_streams.push_back(ipc_shm_init_consumer(shm_dec->channels[i]->ul_stream));
 		shm_io_tx_streams.push_back(ipc_shm_init_consumer(shm_dec->channels[i]->dl_stream));
-		//		shm_io_tx_streams.push_back(ipc_shm_init_producer(shm_dec->channels[i]->dl_stream));
+		// we should init a producer here, but delegating all producers and therefore lock management
+		// to the other side is the reasonable approach to circumvent shutdown issues
 	}
 
 	tmp_state = IPC_IF_MSG_OPEN_CNF;
@@ -389,24 +405,56 @@ int IPCDevice::ipc_rx(uint8_t msg_type, struct ipc_sk_if *ipc_prim)
 
 int IPCDevice::ipc_rx_chan_start_cnf(ipc_sk_chan_if_op_rc *ret, uint8_t chan_nr)
 {
-	tmp_state = IPC_IF_MSG_START_CNF;
+	if (chan_nr >= chans) {
+		LOGC(DDEV, NOTICE) << "shm: illegal start response for chan #" << chan_nr << " ?!?";
+		return 0;
+	}
 	return 0;
 }
 int IPCDevice::ipc_rx_chan_stop_cnf(ipc_sk_chan_if_op_rc *ret, uint8_t chan_nr)
 {
+	if (chan_nr >= chans) {
+		LOGC(DDEV, NOTICE) << "shm: illegal stop response for chan #" << chan_nr << " ?!?";
+		return 0;
+	}
 	return 0;
 }
 int IPCDevice::ipc_rx_chan_setgain_cnf(ipc_sk_chan_if_gain *ret, uint8_t chan_nr)
 {
+	if (chan_nr >= chans) {
+		LOGC(DDEV, NOTICE) << "shm: illegal setgain response for chan #" << chan_nr << " ?!?";
+		return 0;
+	}
+
 	ret->is_tx ? tx_gains[chan_nr] = ret->gain : rx_gains[chan_nr] = ret->gain;
 	return 0;
 }
+int IPCDevice::ipc_rx_chan_settxattn_cnf(ipc_sk_chan_if_tx_attenuation *ret, uint8_t chan_nr)
+{
+	if (chan_nr >= chans) {
+		LOGC(DDEV, NOTICE) << "shm: illegal tx attn response for chan #" << chan_nr << " ?!?";
+		return 0;
+	}
+
+	tx_attenuation[chan_nr] = ret->attenuation;
+	return 0;
+}
 int IPCDevice::ipc_rx_chan_setfreq_cnf(ipc_sk_chan_if_freq_cnf *ret, uint8_t chan_nr)
 {
+	if (chan_nr >= chans) {
+		LOGC(DDEV, NOTICE) << "shm: illegal setfreq response for chan #" << chan_nr << " ?!?";
+		return 0;
+	}
+
 	return 0;
 }
 int IPCDevice::ipc_rx_chan_notify_underflow(ipc_sk_chan_if_notfiy *ret, uint8_t chan_nr)
 {
+	if (chan_nr >= chans) {
+		LOGC(DDEV, NOTICE) << "shm: illegal underfloww notification for chan #" << chan_nr << " ?!?";
+		return 0;
+	}
+
 	m_ctr[chan_nr].tx_underruns += 1;
 	osmo_signal_dispatch(SS_DEVICE, S_DEVICE_COUNTER_CHANGE, &m_ctr[chan_nr]);
 
@@ -414,6 +462,11 @@ int IPCDevice::ipc_rx_chan_notify_underflow(ipc_sk_chan_if_notfiy *ret, uint8_t
 }
 int IPCDevice::ipc_rx_chan_notify_overflow(ipc_sk_chan_if_notfiy *ret, uint8_t chan_nr)
 {
+	if (chan_nr >= chans) {
+		LOGC(DDEV, NOTICE) << "shm: illegal overflow notification for chan #" << chan_nr << " ?!?";
+		return 0;
+	}
+
 	m_ctr[chan_nr].rx_overruns += 1;
 	osmo_signal_dispatch(SS_DEVICE, S_DEVICE_COUNTER_CHANGE, &m_ctr[chan_nr]);
 	return 0;
@@ -442,6 +495,9 @@ int IPCDevice::ipc_chan_rx(uint8_t msg_type, struct ipc_sk_chan_if *ipc_prim, ui
 	case IPC_IF_NOTIFY_OVERFLOW:
 		rc = ipc_rx_chan_notify_overflow(&ipc_prim->u.notify, chan_nr);
 		break;
+	case IPC_IF_MSG_SETTXATTN_CNF:
+		rc = ipc_rx_chan_settxattn_cnf(&ipc_prim->u.txatten_cnf, chan_nr);
+		break;
 	default:
 		LOGP(DMAIN, LOGL_ERROR, "Received unknown IPC msg type %d\n", msg_type);
 		rc = -EINVAL;
@@ -450,10 +506,9 @@ int IPCDevice::ipc_chan_rx(uint8_t msg_type, struct ipc_sk_chan_if *ipc_prim, ui
 	return rc;
 }
 
-static int ipc_sock_send(struct ipc_sock_state *state, struct msgb *msg)
+static int ipc_sock_send(struct ipc_per_trx_sock_state *state, struct msgb *msg)
 {
 	struct osmo_fd *conn_bfd;
-	//struct ipc_sk_if *ipc_prim = (struct ipc_sk_if *) msg->data;
 
 	if (!state) {
 		LOGP(DMAIN, LOGL_INFO,
@@ -471,12 +526,12 @@ static int ipc_sock_send(struct ipc_sock_state *state, struct msgb *msg)
 		return -EIO;
 	}
 	msgb_enqueue(&state->upqueue, msg);
-	conn_bfd->when |= BSC_FD_WRITE;
+	osmo_fd_write_enable(conn_bfd);
 
 	return 0;
 }
 
-void IPCDevice::ipc_sock_close(struct ipc_sock_state *state)
+void IPCDevice::ipc_sock_close(struct ipc_per_trx_sock_state *state)
 {
 	if (state == 0)
 		return;
@@ -542,7 +597,7 @@ int IPCDevice::ipc_sock_read(struct osmo_fd *bfd)
 
 close:
 	msgb_free(msg);
-	ipc_sock_close(&sk_state);
+	ipc_sock_close(&master_sk_state);
 	return -1;
 }
 
@@ -579,6 +634,9 @@ int IPCDevice::ipc_chan_sock_read(struct osmo_fd *bfd)
 		return 0;
 	}
 
+	/* store mask of last received messages so we can check later */
+	sk_chan_state[bfd->priv_nr].messages_processed_mask |= (1 << (ipc_prim->msg_type - IPC_IF_CHAN_MSG_OFFSET));
+
 	rc = ipc_chan_rx(ipc_prim->msg_type, ipc_prim, bfd->priv_nr);
 
 	/* as we always synchronously process the message in IPC_rx() and
@@ -597,15 +655,15 @@ int IPCDevice::ipc_sock_write(struct osmo_fd *bfd)
 {
 	int rc;
 
-	while (!llist_empty(&sk_state.upqueue)) {
+	while (!llist_empty(&master_sk_state.upqueue)) {
 		struct msgb *msg, *msg2;
 		struct ipc_sk_if *ipc_prim;
 
 		/* peek at the beginning of the queue */
-		msg = llist_entry(sk_state.upqueue.next, struct msgb, list);
+		msg = llist_entry(master_sk_state.upqueue.next, struct msgb, list);
 		ipc_prim = (struct ipc_sk_if *)msg->data;
 
-		bfd->when &= ~BSC_FD_WRITE;
+		osmo_fd_write_disable(bfd);
 
 		/* bug hunter 8-): maybe someone forgot msgb_put(...) ? */
 		if (!msgb_length(msg)) {
@@ -622,7 +680,7 @@ int IPCDevice::ipc_sock_write(struct osmo_fd *bfd)
 			goto close;
 		if (rc < 0) {
 			if (errno == EAGAIN) {
-				bfd->when |= BSC_FD_WRITE;
+				osmo_fd_write_enable(bfd);
 				break;
 			}
 			goto close;
@@ -630,14 +688,14 @@ int IPCDevice::ipc_sock_write(struct osmo_fd *bfd)
 
 	dontsend:
 		/* _after_ we send it, we can deueue */
-		msg2 = msgb_dequeue(&sk_state.upqueue);
+		msg2 = msgb_dequeue(&master_sk_state.upqueue);
 		assert(msg == msg2);
 		msgb_free(msg);
 	}
 	return 0;
 
 close:
-	ipc_sock_close(&sk_state);
+	ipc_sock_close(&master_sk_state);
 	return -1;
 }
 
@@ -652,7 +710,7 @@ int IPCDevice::ipc_chan_sock_write(struct osmo_fd *bfd)
 		/* peek at the beginning of the queue */
 		msg = llist_entry(sk_chan_state[bfd->priv_nr].upqueue.next, struct msgb, list);
 		ipc_prim = (struct ipc_sk_chan_if *)msg->data;
-		bfd->when &= ~BSC_FD_WRITE;
+		osmo_fd_write_disable(bfd);
 		/* bug hunter 8-): maybe someone forgot msgb_put(...) ? */
 		if (!msgb_length(msg)) {
 			LOGP(DDEV, LOGL_ERROR,
@@ -668,14 +726,14 @@ int IPCDevice::ipc_chan_sock_write(struct osmo_fd *bfd)
 			goto close;
 		if (rc < 0) {
 			if (errno == EAGAIN) {
-				bfd->when |= BSC_FD_WRITE;
+				osmo_fd_write_enable(bfd);
 				break;
 			}
 			goto close;
 		}
 
 	dontsend:
-		/* _after_ we send it, we can deueue */
+		/* _after_ we send it, we can dequeue */
 		msg2 = msgb_dequeue(&sk_chan_state[bfd->priv_nr].upqueue);
 		assert(msg == msg2);
 		msgb_free(msg);
@@ -692,12 +750,12 @@ static int ipc_sock_cb(struct osmo_fd *bfd, unsigned int flags)
 	IPCDevice *device = static_cast<IPCDevice *>(bfd->data);
 	int rc = 0;
 
-	if (flags & BSC_FD_READ)
+	if (flags & OSMO_FD_READ)
 		rc = device->ipc_sock_read(bfd);
 	if (rc < 0)
 		return rc;
 
-	if (flags & BSC_FD_WRITE)
+	if (flags & OSMO_FD_WRITE)
 		rc = device->ipc_sock_write(bfd);
 
 	return rc;
@@ -708,12 +766,12 @@ static int ipc_chan_sock_cb(struct osmo_fd *bfd, unsigned int flags)
 	IPCDevice *device = static_cast<IPCDevice *>(bfd->data);
 	int rc = 0;
 
-	if (flags & BSC_FD_READ)
+	if (flags & OSMO_FD_READ)
 		rc = device->ipc_chan_sock_read(bfd);
 	if (rc < 0)
 		return rc;
 
-	if (flags & BSC_FD_WRITE)
+	if (flags & OSMO_FD_WRITE)
 		rc = device->ipc_chan_sock_write(bfd);
 
 	return rc;
@@ -721,7 +779,7 @@ static int ipc_chan_sock_cb(struct osmo_fd *bfd, unsigned int flags)
 
 int IPCDevice::open(const std::string &args, int ref, bool swap_channels)
 {
-	std::string k,v;
+	std::string k, v;
 	std::string::size_type keyend;
 	int rc;
 
@@ -729,37 +787,36 @@ int IPCDevice::open(const std::string &args, int ref, bool swap_channels)
 		k = args.substr(0, keyend++);
 		v = args.substr(keyend);
 	}
-	if(k != "ipc_msock" || !v.length()) {
-			LOGC(DDEV, ERROR) << "Invalid device args provided, expected  \"dev-args ipc_msock=/path/to/socket\"\n";
-			return -1;
+	if (k != "ipc_msock" || !v.length()) {
+		LOGC(DDEV, ERROR) << "Invalid device args provided, expected  \"dev-args ipc_msock=/path/to/socket\"\n";
+		return -1;
 	}
 
 	LOGC(DDEV, INFO) << "Opening IPC device" << v << "..";
 
-	memset(&sk_state, 0x00, sizeof(sk_state));
-	INIT_LLIST_HEAD(&sk_state.upqueue);
-	rc = osmo_sock_unix_init_ofd(&sk_state.conn_bfd, SOCK_SEQPACKET, 0, v.c_str(), OSMO_SOCK_F_CONNECT);
+	INIT_LLIST_HEAD(&master_sk_state.upqueue);
+	rc = osmo_sock_unix_init_ofd(&master_sk_state.conn_bfd, SOCK_SEQPACKET, 0, v.c_str(), OSMO_SOCK_F_CONNECT);
 	if (rc < 0) {
-		LOGC(DDEV, ERROR) << "Failed to connect to the BTS (" << v << "). "
+		LOGC(DDEV, ERROR) << "Failed to connect to the IPC device (" << v << "). "
 				  << "Retrying...\n";
-		osmo_timer_setup(&sk_state.timer, ipc_sock_timeout, NULL);
-		osmo_timer_schedule(&sk_state.timer, 5, 0);
+		osmo_timer_setup(&master_sk_state.timer, ipc_sock_timeout, NULL);
+		osmo_timer_schedule(&master_sk_state.timer, 5, 0);
 		return -1;
 	}
-	sk_state.conn_bfd.cb = ipc_sock_cb;
-	sk_state.conn_bfd.data = this;
+	master_sk_state.conn_bfd.cb = ipc_sock_cb;
+	master_sk_state.conn_bfd.data = this;
 
-	ipc_tx_greeting_req(&sk_state, IPC_SOCK_API_VERSION);
+	ipc_tx_greeting_req(&master_sk_state, IPC_SOCK_API_VERSION);
 	/* Wait until confirmation is recieved */
 	while (tmp_state != IPC_IF_MSG_GREETING_CNF)
 		osmo_select_main(0);
 
-	ipc_tx_info_req(&sk_state);
+	ipc_tx_info_req(&master_sk_state);
 	/* Wait until confirmation is recieved */
 	while (tmp_state != IPC_IF_MSG_INFO_CNF)
 		osmo_select_main(0);
 
-	ipc_tx_open_req(&sk_state, chans, ref);
+	ipc_tx_open_req(&master_sk_state, chans, ref);
 	/* Wait until confirmation is recieved */
 	while (tmp_state != IPC_IF_MSG_OPEN_CNF)
 		osmo_select_main(0);
@@ -778,6 +835,123 @@ out_close:
 	return -1;
 }
 
+void IPCDevice::manually_poll_sock_fds()
+{
+	struct timeval wait = { 0, 100000 };
+	fd_set crfds, cwfds;
+	char err_buf[256];
+	int max_fd = 0;
+
+	FD_ZERO(&crfds);
+	FD_ZERO(&cwfds);
+	for (unsigned int i = 0; i < chans; i++) {
+		struct osmo_fd *curr_fd = &sk_chan_state[i].conn_bfd;
+		max_fd = curr_fd->fd > max_fd ? curr_fd->fd : max_fd;
+
+		if (curr_fd->when & OSMO_FD_READ)
+			FD_SET(curr_fd->fd, &crfds);
+		if (curr_fd->when & OSMO_FD_WRITE)
+			FD_SET(curr_fd->fd, &cwfds);
+	}
+
+	if (select(max_fd + 1, &crfds, &cwfds, 0, &wait) < 0) {
+		LOGP(DDEV, LOGL_ERROR, "select() failed: %s\n",
+		     strerror_r(errno, err_buf, sizeof(err_buf)));
+		return;
+	}
+
+	for (unsigned int i = 0; i < chans; i++) {
+		int flags = 0;
+		struct osmo_fd *ofd = &sk_chan_state[i].conn_bfd;
+
+		if (FD_ISSET(ofd->fd, &crfds)) {
+			flags |= OSMO_FD_READ;
+			FD_CLR(ofd->fd, &crfds);
+		}
+
+		if (FD_ISSET(ofd->fd, &cwfds)) {
+			flags |= OSMO_FD_WRITE;
+			FD_CLR(ofd->fd, &cwfds);
+		}
+		if (flags)
+			ipc_chan_sock_cb(ofd, flags);
+	}
+}
+
+bool IPCDevice::send_chan_wait_rsp(uint32_t chan, struct msgb *msg_to_send, uint32_t expected_rsp_msg_id)
+{
+	struct timeval timer_now, timeout;
+
+	sk_chan_state[chan].messages_processed_mask = 0;
+	ipc_sock_send(&sk_chan_state[chan], msg_to_send);
+
+	gettimeofday(&timeout, 0);
+	timeout.tv_sec += 2;
+
+	while (!(sk_chan_state[chan].messages_processed_mask & (1 << (expected_rsp_msg_id - IPC_IF_CHAN_MSG_OFFSET)))) {
+		/* just poll here, we're already in select, so there is no other way to drive
+	 * the fds and "wait" for a response or retry */
+		manually_poll_sock_fds();
+
+		gettimeofday(&timer_now, 0);
+		if (timercmp(&timer_now, &timeout, >))
+			return false;
+	}
+	return true;
+}
+
+bool IPCDevice::send_all_chan_wait_rsp(uint32_t msgid_to_send, uint32_t msgid_to_expect)
+{
+	struct msgb *msg;
+	struct ipc_sk_chan_if *ipc_prim;
+	struct timeval timer_now, timeout;
+
+	for (unsigned int i = 0; i < chans; i++) {
+		msg = ipc_msgb_alloc(msgid_to_send);
+		if (!msg)
+			return -ENOMEM;
+		ipc_prim = (struct ipc_sk_chan_if *)msg->data;
+		ipc_prim->u.start_req.dummy = 0;
+
+		sk_chan_state[i].messages_processed_mask = 0;
+		ipc_sock_send(&sk_chan_state[i], msg);
+	}
+
+	gettimeofday(&timeout, 0);
+	timeout.tv_sec += 2;
+
+	unsigned int msg_received_count = 0;
+	while (msg_received_count != chans) {
+		msg_received_count = 0;
+
+		/* just poll here, we're already in select, so there is no other way to drive
+		 * the fds and "wait" for a response or retry */
+		manually_poll_sock_fds();
+
+		for (unsigned int i = 0; i < sk_chan_state.size(); i++)
+			if (sk_chan_state[i].messages_processed_mask &
+			    (1 << (msgid_to_expect - IPC_IF_CHAN_MSG_OFFSET)))
+				msg_received_count++;
+
+		gettimeofday(&timer_now, 0);
+		if (timercmp(&timer_now, &timeout, >))
+			return false;
+	}
+
+	return true;
+}
+
+/* the call stack is rather difficult here, we're already in select:
+>~"#0  IPCDevice::start (this=<optimized out>) at IPCDevice.cpp:789\n"
+>~"#1  in RadioInterface::start (this=0x614000001640) at radioInterface.cpp:187\n"
+>~"#2  in Transceiver::start (this=<optimized out>) at Transceiver.cpp:293\n"
+>~"#3  in Transceiver::ctrl_sock_handle_rx (this=0x61600000b180, chan=0) at Transceiver.cpp:838\n"
+>~"#4  in Transceiver::ctrl_sock_cb (bfd=<optimized out>, flags=1) at Transceiver.cpp:168\n"
+>~"#5  in osmo_fd_disp_fds (_rset=<optimized out>, _wset=<optimized out>, _eset=<optimized out>) at select.c:227\n"
+>~"#6  _osmo_select_main (polling=<optimized out>) at select.c:265\n"
+>~"#7  in osmo_select_main (polling=128) at select.c:274\n"
+>~"#8  in main (argc=<optimized out>, argv=<optimized out>) at osmo-trx.cpp:649\n"
+ * */
 bool IPCDevice::start()
 {
 	LOGC(DDEV, INFO) << "starting IPC...";
@@ -787,20 +961,17 @@ bool IPCDevice::start()
 		return true;
 	}
 
-	struct msgb *msg;
-	struct ipc_sk_chan_if *ipc_prim;
+	if (!(send_all_chan_wait_rsp(IPC_IF_MSG_START_REQ, IPC_IF_MSG_START_CNF))) {
+		LOGC(DDEV, ERR) << "start timeout!";
+		return false;
+	}
 
-	msg = ipc_msgb_alloc(IPC_IF_MSG_START_REQ);
-	if (!msg)
-		return -ENOMEM;
-	ipc_prim = (struct ipc_sk_chan_if *)msg->data;
-	ipc_prim->u.start_req.dummy = 0;
-
-	ipc_sock_send(&sk_chan_state[0], msg);
-	while (tmp_state != IPC_IF_MSG_START_CNF)
-		osmo_select_main(0);
-
-	flush_recv(10);
+	int max_bufs_to_flush = 0;
+	for (unsigned int i = 0; i < shm_dec->num_chans; i++) {
+		int buf_per_chan = shm_dec->channels[i]->ul_stream->num_buffers;
+		max_bufs_to_flush = max_bufs_to_flush < buf_per_chan ? buf_per_chan : max_bufs_to_flush;
+	}
+	flush_recv(max_bufs_to_flush);
 
 	started = true;
 	return true;
@@ -808,84 +979,68 @@ bool IPCDevice::start()
 
 bool IPCDevice::stop()
 {
-	//unsigned int i;
-
 	if (!started)
 		return true;
 
-	struct msgb *msg;
-	struct ipc_sk_chan_if *ipc_prim;
+	if (!(send_all_chan_wait_rsp(IPC_IF_MSG_STOP_REQ, IPC_IF_MSG_STOP_CNF))) {
+		LOGC(DDEV, ERR) << "stop timeout!";
+		return false;
+	}
 
-	msg = ipc_msgb_alloc(IPC_IF_MSG_STOP_REQ);
-	if (!msg)
-		return -ENOMEM;
-	ipc_prim = (struct ipc_sk_chan_if *)msg->data;
-	ipc_prim->u.start_req.dummy = 0;
+	LOGC(DDEV, NOTICE) << "All channels stopped, terminating...";
 
-	ipc_sock_send(&sk_chan_state[0], msg);
+	/* reset internal buffer timestamps */
+	for (size_t i = 0; i < rx_buffers.size(); i++)
+		rx_buffers[i]->reset();
 
 	started = false;
 	return true;
 }
 
-/* do rx/tx calibration - depends on gain, freq and bw */
-bool IPCDevice::do_calib(size_t chan)
-{
-	LOGCHAN(chan, DDEV, INFO) << "Calibrating";
-	return true;
-}
-
-/* do rx/tx filter config - depends on bw only? */
-bool IPCDevice::do_filters(size_t chan)
-{
-	LOGCHAN(chan, DDEV, INFO) << "Setting filters";
-	return true;
-}
-
-double IPCDevice::maxTxGain()
-{
-	//return dev_param_map.at(m_dev_type).max_tx_gain;
-	return current_info_cnf.max_tx_gain;
-}
-
-double IPCDevice::minTxGain()
-{
-	return current_info_cnf.min_tx_gain;
-}
-
 double IPCDevice::maxRxGain()
 {
-	return current_info_cnf.max_rx_gain;
+	return current_info_cnf.chan_info[0].max_rx_gain;
 }
 
 double IPCDevice::minRxGain()
 {
-	return current_info_cnf.min_rx_gain;
+	return current_info_cnf.chan_info[0].min_rx_gain;
 }
 
-double IPCDevice::setTxGain(double dB, size_t chan)
+int IPCDevice::getNominalTxPower(size_t chan)
+{
+	return current_info_cnf.chan_info[chan].nominal_tx_power;
+}
+
+double IPCDevice::setPowerAttenuation(int atten, size_t chan)
 {
 	struct msgb *msg;
 	struct ipc_sk_chan_if *ipc_prim;
 
-	if (dB > maxTxGain())
-		dB = maxTxGain();
-	if (dB < minTxGain())
-		dB = minTxGain();
+	if (chan >= chans)
+		return 0;
 
-	LOGCHAN(chan, DDEV, NOTICE) << "Setting TX gain to " << dB << " dB";
+	LOGCHAN(chan, DDEV, NOTICE) << "Setting TX attenuation to " << atten << " dB"
+				    << " chan " << chan;
 
-	msg = ipc_msgb_alloc(IPC_IF_MSG_SETGAIN_REQ);
+	msg = ipc_msgb_alloc(IPC_IF_MSG_SETTXATTN_REQ);
 	if (!msg)
 		return -ENOMEM;
 	ipc_prim = (struct ipc_sk_chan_if *)msg->data;
-	ipc_prim->u.set_gain_req.is_tx = 1;
-	ipc_prim->u.set_gain_req.gain = dB;
+	ipc_prim->u.txatten_req.attenuation = atten;
 
-	ipc_sock_send(&sk_chan_state[chan], msg);
+	if (!send_chan_wait_rsp(chan, msg, IPC_IF_MSG_SETTXATTN_CNF))
+		LOGCHAN(chan, DDEV, ERROR) << "Setting TX attenuation timeout! ";
 
-	tx_gains[chan] = dB;
-	return tx_gains[chan];
+	return atten;
+}
+
+double IPCDevice::getPowerAttenuation(size_t chan)
+{
+	if (chan >= chans)
+		return 0;
+
+	return tx_attenuation[chan];
 }
 
 double IPCDevice::setRxGain(double dB, size_t chan)
@@ -907,9 +1062,9 @@ double IPCDevice::setRxGain(double dB, size_t chan)
 	ipc_prim->u.set_gain_req.is_tx = 0;
 	ipc_prim->u.set_gain_req.gain = dB;
 
-	ipc_sock_send(&sk_chan_state[chan], msg);
+	if (!send_chan_wait_rsp(chan, msg, IPC_IF_MSG_SETGAIN_CNF))
+		LOGCHAN(chan, DDEV, ERROR) << "Setting RX gain timeout! ";
 
-	rx_gains[chan] = dB;
 	return rx_gains[chan];
 }
 
@@ -917,14 +1072,14 @@ bool IPCDevice::flush_recv(size_t num_pkts)
 {
 	std::vector<uint16_t> tmp(4096);
 	uint64_t tmps;
-	uint32_t read;
+	uint32_t read = 0;
 
 	for (uint32_t j = 0; j < num_pkts; j++) {
 		for (unsigned int i = 0; i < chans; i++)
-			read = ipc_shm_read(shm_io_rx_streams[i], (uint16_t *)&tmp.front(), 4096 / 2, &tmps, 1);
+			read = ipc_shm_read(shm_io_rx_streams[i], (uint16_t *)&tmp.front(), 4096 / 2, &tmps, 3);
 	}
 	ts_initial = tmps + read;
-	return ts_initial;
+
 	LOGC(DDEV, INFO) << "Initial timestamp " << ts_initial << std::endl;
 	return true;
 }
@@ -975,7 +1130,7 @@ TIMESTAMP IPCDevice::initialReadTimestamp(void)
 // NOTE: Assumes sequential reads
 int IPCDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun, TIMESTAMP timestamp, bool *underrun)
 {
-	int rc, num_smpls, expect_smpls;
+	int rc, num_smpls; //, expect_smpls;
 	ssize_t avail_smpls;
 	TIMESTAMP expect_timestamp;
 	unsigned int i;
@@ -1004,22 +1159,17 @@ int IPCDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun, T
 			uint64_t recv_timestamp = 0;
 
 			thread_enable_cancel(false);
-
 			num_smpls = ipc_shm_read(shm_io_rx_streams[i], (uint16_t *)bufs[i], len - avail_smpls,
 						 &recv_timestamp, 1);
 			expect_timestamp = timestamp + avail_smpls;
 			thread_enable_cancel(true);
 
+			if (num_smpls == -ETIMEDOUT)
+				continue;
+
 			LOGCHAN(i, DDEV, DEBUG)
 			"Received timestamp = " << (TIMESTAMP)recv_timestamp << " (" << num_smpls << ")";
 
-			expect_smpls = len - avail_smpls;
-			//			if (expect_smpls != num_smpls)
-			//				LOGCHAN(i, DDEV, NOTICE)
-			//					<< "Unexpected recv buffer len: expect " << expect_smpls << " got " << num_smpls
-			//					<< ", diff=" << expect_smpls - num_smpls;
-
-			//expect_timestamp = timestamp + avail_smpls;
 			if (expect_timestamp != (TIMESTAMP)recv_timestamp)
 				LOGCHAN(i, DDEV, ERROR) << "Unexpected recv buffer timestamp: expect "
 							<< expect_timestamp << " got " << recv_timestamp << ", diff="
@@ -1029,7 +1179,8 @@ int IPCDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun, T
 
 			rc = rx_buffers[i]->write(bufs[i], num_smpls, (TIMESTAMP)recv_timestamp);
 			if (rc < 0) {
-				LOGCHAN(i, DDEV, ERROR) << rx_buffers[i]->str_code(rc);
+				LOGCHAN(i, DDEV, ERROR)
+					<< rx_buffers[i]->str_code(rc) << " num smpls: " << num_smpls << " chan: " << i;
 				LOGCHAN(i, DDEV, ERROR) << rx_buffers[i]->str_status(timestamp);
 				if (rc != smpl_buf::ERROR_OVERFLOW)
 					return 0;
@@ -1064,12 +1215,10 @@ int IPCDevice::writeSamples(std::vector<short *> &bufs, int len, bool *underrun,
 
 	for (i = 0; i < chans; i++) {
 		LOGCHAN(i, DDEV, DEBUG) << "send buffer of len " << len << " timestamp " << std::hex << timestamp;
-		//		thread_enable_cancel(false);
+		thread_enable_cancel(false);
 		rc = ipc_shm_enqueue(shm_io_tx_streams[i], timestamp, len, (uint16_t *)bufs[i]);
+		thread_enable_cancel(true);
 
-		//		rc = LMS_SendStream(&m_lms_stream_tx[i], bufs[i], len, &tx_metadata, 100);
-		//		update_stream_stats_tx(i, underrun);
-		//		thread_enable_cancel(true);
 		if (rc != len) {
 			LOGCHAN(i, DDEV, ERROR) << "LMS: Device Tx timed out (" << rc << " vs exp " << len << ").";
 			return -1;
@@ -1097,7 +1246,7 @@ bool IPCDevice::setTxFreq(double wFreq, size_t chan)
 	ipc_prim->u.set_freq_req.is_tx = 1;
 	ipc_prim->u.set_freq_req.freq = wFreq;
 
-	return ipc_sock_send(&sk_chan_state[chan], msg) < 0 ? false : true;
+	return send_chan_wait_rsp(chan, msg, IPC_IF_MSG_SETFREQ_CNF);
 }
 
 bool IPCDevice::setRxFreq(double wFreq, size_t chan)
@@ -1113,7 +1262,7 @@ bool IPCDevice::setRxFreq(double wFreq, size_t chan)
 	ipc_prim->u.set_freq_req.is_tx = 0;
 	ipc_prim->u.set_freq_req.freq = wFreq;
 
-	return ipc_sock_send(&sk_chan_state[chan], msg) < 0 ? false : true;
+	return send_chan_wait_rsp(chan, msg, IPC_IF_MSG_SETFREQ_CNF);
 }
 
 RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps, InterfaceType iface, size_t chans, double lo_offset,

Transceiver52M/device/ipc/IPCDevice.h

@@ -4,21 +4,29 @@
 *
 * SPDX-License-Identifier: AGPL-3.0+
 *
-* This software is distributed under multiple licenses; see the COPYING file in
-* the main directory for licensing information for this specific distribution.
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU Affero General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
 *
-* This use of this software may be subject to additional restrictions.
-* See the LEGAL file in the main directory for details.
-
-    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.
-
+* 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 Affero General Public License for more details.
+*
+* You should have received a copy of the GNU Affero General Public License
+* along with this program.  If not, see <http://www.gnu.org/licenses/>.
+* See the COPYING file in the main directory for details.
 */
 
 #ifndef _IPC_DEVICE_H_
 #define _IPC_DEVICE_H_
 
+#include <cstdint>
+#include <cstddef>
+#include <climits>
+#include <string>
+
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -27,31 +35,32 @@ extern "C" {
 #include <osmocom/core/select.h>
 #include <osmocom/core/timer.h>
 #include "shm.h"
-#include "ipc_shm.h"
 }
 
 #include "radioDevice.h"
-#include "smpl_buf.h"
 
-#include <sys/time.h>
-#include <math.h>
-#include <limits.h>
-#include <string>
-#include <iostream>
-#include <lime/LimeSuite.h>
+class smpl_buf;
 
-struct ipc_sock_state {
+#define IPC_MAX_NUM_TRX 8
+
+struct ipc_per_trx_sock_state {
 	struct osmo_fd conn_bfd; /* fd for connection to the BTS */
 	struct osmo_timer_list timer; /* socket connect retry timer */
 	struct llist_head upqueue; /* queue for sending messages */
+	uint32_t messages_processed_mask; // (=| IPC_IF_MSG_xxx-IPC_IF_CHAN_MSG_OFFSET) bitmask
+	ipc_per_trx_sock_state() : conn_bfd(), timer(), upqueue(), messages_processed_mask()
+	{
+		conn_bfd.fd = -1;
+	}
 };
 
-/** A class to handle a LimeSuite supported device */
 class IPCDevice : public RadioDevice {
     protected:
-	struct ipc_sock_state sk_state;
-	/* FIXME: current limit 8 chans, make dynamic */
-	struct ipc_sock_state sk_chan_state[8];
+	struct ipc_per_trx_sock_state master_sk_state;
+
+	std::vector<struct ipc_per_trx_sock_state> sk_chan_state;
+
+	uint32_t tx_attenuation[IPC_MAX_NUM_TRX];
 	uint8_t tmp_state;
 	char shm_name[SHM_NAME_MAX];
 	int ipc_shm_connect(const char *shm_name);
@@ -59,10 +68,9 @@ class IPCDevice : public RadioDevice {
 	struct ipc_shm_region *shm_dec;
 
 	std::vector<smpl_buf *> rx_buffers;
-	double actualSampleRate; ///< the actual USRP sampling rate
+	double actualSampleRate;
 
-	bool started; ///< flag indicates LMS has started
-	bool skipRx; ///< set if LMS is transmit-only.
+	bool started;
 
 	TIMESTAMP ts_initial, ts_offset;
 
@@ -75,59 +83,73 @@ class IPCDevice : public RadioDevice {
 	std::vector<struct ipc_shm_io *> shm_io_rx_streams;
 	std::vector<struct ipc_shm_io *> shm_io_tx_streams;
 
-	bool do_calib(size_t chan);
-	bool do_filters(size_t chan);
-	int get_ant_idx(const std::string &name, bool dir_tx, size_t chan);
-	virtual bool flush_recv(size_t num_pkts);
+	bool flush_recv(size_t num_pkts);
 	void update_stream_stats_rx(size_t chan, bool *overrun);
 	void update_stream_stats_tx(size_t chan, bool *underrun);
-	bool do_clock_src_freq(enum ReferenceType ref, double freq);
+	void manually_poll_sock_fds();
+
+	void ipc_sock_close(ipc_per_trx_sock_state *state);
+
+	int ipc_rx(uint8_t msg_type, struct ipc_sk_if *ipc_prim);
+	int ipc_rx_greeting_cnf(const struct ipc_sk_if_greeting *greeting_cnf);
+	int ipc_rx_info_cnf(const struct ipc_sk_if_info_cnf *info_cnf);
+	int ipc_rx_open_cnf(const struct ipc_sk_if_open_cnf *open_cnf);
+	int ipc_tx_open_req(struct ipc_per_trx_sock_state *state, uint32_t num_chans, uint32_t ref);
+
+	int ipc_chan_rx(uint8_t msg_type, ipc_sk_chan_if *ipc_prim, uint8_t chan_nr);
+	int ipc_rx_chan_start_cnf(ipc_sk_chan_if_op_rc *ret, uint8_t chan_nr);
+	int ipc_rx_chan_stop_cnf(ipc_sk_chan_if_op_rc *ret, uint8_t chan_nr);
+	int ipc_rx_chan_setgain_cnf(ipc_sk_chan_if_gain *ret, uint8_t chan_nr);
+	int ipc_rx_chan_setfreq_cnf(ipc_sk_chan_if_freq_cnf *ret, uint8_t chan_nr);
+	int ipc_rx_chan_notify_underflow(ipc_sk_chan_if_notfiy *ret, uint8_t chan_nr);
+	int ipc_rx_chan_notify_overflow(ipc_sk_chan_if_notfiy *ret, uint8_t chan_nr);
+	int ipc_rx_chan_settxattn_cnf(ipc_sk_chan_if_tx_attenuation *ret, uint8_t chan_nr);
+
+	bool send_chan_wait_rsp(uint32_t chan, struct msgb *msg_to_send, uint32_t expected_rsp_msg_id);
+	bool send_all_chan_wait_rsp(uint32_t msgid_to_send, uint32_t msgid_to_expect);
 
     public:
-	virtual void ipc_sock_close(ipc_sock_state *state);
-	virtual int ipc_sock_read(struct osmo_fd *bfd);
-	virtual int ipc_sock_write(struct osmo_fd *bfd);
-	virtual int ipc_rx(uint8_t msg_type, struct ipc_sk_if *ipc_prim);
-	virtual int ipc_rx_greeting_cnf(const struct ipc_sk_if_greeting *greeting_cnf);
-	virtual int ipc_rx_info_cnf(const struct ipc_sk_if_info_cnf *info_cnf);
-	virtual int ipc_rx_open_cnf(const struct ipc_sk_if_open_cnf *open_cnf);
-	virtual int ipc_tx_open_req(struct ipc_sock_state *state, uint32_t num_chans, uint32_t ref);
+	int ipc_sock_read(struct osmo_fd *bfd);
+	int ipc_sock_write(struct osmo_fd *bfd);
+	int ipc_chan_sock_read(osmo_fd *bfd);
+	int ipc_chan_sock_write(osmo_fd *bfd);
 
 	/** Object constructor */
 	IPCDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface, size_t chan_num, double lo_offset,
 		  const std::vector<std::string> &tx_paths, const std::vector<std::string> &rx_paths);
 	virtual ~IPCDevice() override;
 
-	/** Instantiate the LMS */
+	/** Instantiate the IPC */
 	virtual int open(const std::string &args, int ref, bool swap_channels) override;
 
-	/** Start the LMS */
+	/** Start the IPC */
 	virtual bool start() override;
 
-	/** Stop the LMS */
+	/** Stop the IPC */
 	virtual bool stop() override;
 
+	/* FIXME: any != USRP1 will do for now... */
 	enum TxWindowType getWindowType() override
 	{
 		return TX_WINDOW_LMS1;
 	}
 
 	/**
-	Read samples from the LMS.
+	Read samples from the IPC.
 	@param buf preallocated buf to contain read result
 	@param len number of samples desired
 	@param overrun Set if read buffer has been overrun, e.g. data not being read fast enough
 	@param timestamp The timestamp of the first samples to be read
-	@param underrun Set if LMS does not have data to transmit, e.g. data not being sent fast enough
+	@param underrun Set if IPC does not have data to transmit, e.g. data not being sent fast enough
 	@return The number of samples actually read
 	*/
 	virtual int readSamples(std::vector<short *> &buf, int len, bool *overrun, TIMESTAMP timestamp = 0xffffffff,
 				bool *underrun = NULL) override;
 	/**
-	Write samples to the LMS.
+	Write samples to the IPC.
 	@param buf Contains the data to be written.
 	@param len number of samples to write.
-	@param underrun Set if LMS does not have data to transmit, e.g. data not being sent fast enough
+	@param underrun Set if IPC does not have data to transmit, e.g. data not being sent fast enough
 	@param timestamp The timestamp of the first sample of the data buffer.
 	@return The number of samples actually written
 	*/
@@ -176,20 +198,13 @@ class IPCDevice : public RadioDevice {
 	/** return minimum Rx Gain **/
 	virtual double minRxGain(void) override;
 
-	/** sets the transmit chan gain, returns the gain setting **/
-	virtual double setTxGain(double dB, size_t chan = 0) override;
+	/* FIXME: return rx_gains[chan] ? receive factor from IPC Driver? */
+	double rssiOffset(size_t chan) { return 0.0f; };
 
-	/** get transmit gain */
-	virtual double getTxGain(size_t chan = 0) override
-	{
-		return tx_gains[chan];
-	}
+	double setPowerAttenuation(int atten, size_t chan) override;
+	double getPowerAttenuation(size_t chan = 0) override;
 
-	/** return maximum Tx Gain **/
-	virtual double maxTxGain(void) override;
-
-	/** return minimum Rx Gain **/
-	virtual double minTxGain(void) override;
+	virtual int getNominalTxPower(size_t chan = 0) override;
 
 	/** sets the RX path to use, returns true if successful and false otherwise */
 	virtual bool setRxAntenna(const std::string &ant, size_t chan = 0) override;
@@ -222,15 +237,6 @@ class IPCDevice : public RadioDevice {
 	{
 		return actualSampleRate;
 	}
-	int ipc_chan_sock_read(osmo_fd *bfd);
-	int ipc_chan_sock_write(osmo_fd *bfd);
-	int ipc_chan_rx(uint8_t msg_type, ipc_sk_chan_if *ipc_prim, uint8_t chan_nr);
-	int ipc_rx_chan_start_cnf(ipc_sk_chan_if_op_rc *ret, uint8_t chan_nr);
-	int ipc_rx_chan_stop_cnf(ipc_sk_chan_if_op_rc *ret, uint8_t chan_nr);
-	int ipc_rx_chan_setgain_cnf(ipc_sk_chan_if_gain *ret, uint8_t chan_nr);
-	int ipc_rx_chan_setfreq_cnf(ipc_sk_chan_if_freq_cnf *ret, uint8_t chan_nr);
-	int ipc_rx_chan_notify_underflow(ipc_sk_chan_if_notfiy *ret, uint8_t chan_nr);
-	int ipc_rx_chan_notify_overflow(ipc_sk_chan_if_notfiy *ret, uint8_t chan_nr);
 };
 
 #endif // _IPC_DEVICE_H_

Transceiver52M/device/ipc/Makefile.am

@@ -1,29 +1,43 @@
 include $(top_srcdir)/Makefile.common
 
 AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/../common
-AM_CFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
+AM_CFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS)
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS)
 AM_LDFLAGS = -lpthread -lrt
 
-noinst_HEADERS = IPCDevice.h shm.h ../uhd/UHDDevice.h uhdwrap.h
+noinst_HEADERS = IPCDevice.h shm.h ipc_shm.h ipc_chan.h ipc_sock.h
+
+if DEVICE_UHD
+noinst_HEADERS += ../uhd/UHDDevice.h uhdwrap.h ipc-driver-test.h
+endif
 
 noinst_LTLIBRARIES = libdevice.la
 
-libdevice_la_SOURCES = ipc-driver-test.c IPCDevice.cpp shm.c ../uhd/UHDDevice.cpp uhdwrap.cpp ipc_shm.c ipc_chan.c ipc_sock.c 
+libdevice_la_SOURCES = IPCDevice.cpp shm.c ipc_shm.c ipc_chan.c ipc_sock.c
 libdevice_la_LIBADD = $(top_builddir)/Transceiver52M/device/common/libdevice_common.la
-libdevice_la_CXXFLAGS = $(AM_CXXFLAGS) $(UHD_CFLAGS) -DIPCMAGIC
+libdevice_la_CXXFLAGS = $(AM_CXXFLAGS) -DIPCMAGIC
+
+#work around distclean issue on older autotools vers:
+#a direct build of ../uhd/UHDDevice.cpp tries to clean
+#../uhd/.dep/UHDDevice.Plo twice and fails
+uhddev_ipc.cpp:
+	echo "#include \"../uhd/UHDDevice.cpp\"" >$@
+CLEANFILES= uhddev_ipc.cpp
+BUILT_SOURCES = uhddev_ipc.cpp
+
+if DEVICE_UHD
 
 bin_PROGRAMS = ipc-driver-test
 #ipc_driver_test_SHORTNAME = drvt
-ipc_driver_test_SOURCES = ipc-driver-test.c uhdwrap.cpp ipc_shm.c ipc_chan.c ipc_sock.c ../uhd/UHDDevice.cpp
+ipc_driver_test_SOURCES = ipc-driver-test.c uhdwrap.cpp ipc_shm.c ipc_chan.c ipc_sock.c uhddev_ipc.cpp
 ipc_driver_test_LDADD = \
         shm.lo \
+	$(top_builddir)/Transceiver52M/device/common/libdevice_common.la \
+	$(COMMON_LA)
 	$(LIBOSMOCORE_LIBS) \
-	$(LIBOSMOCTRL_LIBS) \
-	$(LIBOSMOVTY_LIBS)
+	$(NULL)
 ipc_driver_test_CXXFLAGS = $(AM_CXXFLAGS) $(UHD_CFLAGS)
 ipc_driver_test_CPPFLAGS  = $(AM_CPPFLAGS) $(UHD_CFLAGS)
 ipc_driver_test_CFLAGS  = $(AM_CFLAGS) $(UHD_CFLAGS)
 ipc_driver_test_LDFLAGS  = $(AM_LDFLAGS) $(UHD_LIBS)
-ipc_driver_test_LDADD += $(top_builddir)/Transceiver52M/device/common/libdevice_common.la $(top_builddir)/CommonLibs/libcommon.la
-
+endif

Transceiver52M/device/ipc/ipc-driver-test.c

@@ -4,21 +4,19 @@
 *
 * SPDX-License-Identifier: 0BSD
 *
-    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
 */
-#ifdef __cplusplus
-extern "C" {
-#endif
 
 #define _GNU_SOURCE
 #include <pthread.h>
 
-
 #include <debug.h>
 
 #include <stdio.h>
@@ -51,6 +49,7 @@ extern "C" {
 #include "ipc_sock.h"
 
 #define DEFAULT_SHM_NAME "/osmo-trx-ipc-driver-shm2"
+#define IPC_SOCK_PATH_PREFIX "/tmp"
 
 static void *tall_ctx;
 struct ipc_sock_state *global_ipc_sock_state;
@@ -65,17 +64,19 @@ void *global_dev;
 
 static struct ipc_shm_region *decoded_region;
 
-/* Debug Areas of the code */
-//enum { DMAIN,
-//};
+static struct {
+	int msocknum;
+	char *ud_prefix_dir;
+} cmdline_cfg;
+
 static const struct log_info_cat default_categories[] = {
 	[DMAIN] = {
 		.name = "DMAIN",
-        		.color = NULL,
+		.color = NULL,
 		.description = "Main generic category",
-		 .loglevel = LOGL_DEBUG,.enabled = 1,
+		.loglevel = LOGL_DEBUG,.enabled = 1,
 	},
-    [DDEV] = {
+	[DDEV] = {
 		.name = "DDEV",
 		.description = "Device/Driver specific code",
 		.color = NULL,
@@ -87,9 +88,6 @@ const struct log_info log_infox = {
 	.cat = default_categories,
 	.num_cat = ARRAY_SIZE(default_categories),
 };
-#ifdef __cplusplus
-}
-#endif
 
 #include "uhdwrap.h"
 
@@ -193,7 +191,8 @@ static int ipc_tx_open_cnf(int rc, uint32_t num_chans, int32_t timingoffset)
 
 	chan_info = ipc_prim->u.open_cnf.chan_info;
 	for (i = 0; i < num_chans; i++) {
-		snprintf(chan_info->chan_ipc_sk_path, sizeof(chan_info->chan_ipc_sk_path), "%s_%d", IPC_SOCK_PATH_PREFIX, i);
+		snprintf(chan_info->chan_ipc_sk_path, sizeof(chan_info->chan_ipc_sk_path),"%s/ipc_sock%d_%d",
+			 cmdline_cfg.ud_prefix_dir, cmdline_cfg.msocknum, i);
 		/* FIXME: dynamc chan limit, currently 8 */
 		if (i < 8)
 			ipc_sock_init(chan_info->chan_ipc_sk_path, &global_ctrl_socks[i], ipc_chan_sock_accept, i);
@@ -222,6 +221,7 @@ int ipc_rx_open_req(struct ipc_sk_if_open_req *open_req)
 {
 	/* calculate size needed */
 	unsigned int len;
+	unsigned int i;
 
 	global_dev = uhdwrap_open(open_req);
 
@@ -232,14 +232,14 @@ int ipc_rx_open_req(struct ipc_sk_if_open_req *open_req)
 	/* Here we verify num_chans, rx_path, tx_path, clockref, etc. */
 	int rc = ipc_shm_setup(DEFAULT_SHM_NAME, len);
 	len = ipc_shm_encode_region((struct ipc_shm_raw_region *)shm, open_req->num_chans, 4, shmbuflen);
-	LOGP(DMAIN, LOGL_NOTICE, "%s\n", osmo_hexdump((const unsigned char *)shm, 80));
+	//	LOGP(DMAIN, LOGL_NOTICE, "%s\n", osmo_hexdump((const unsigned char *)shm, 80));
 
 	/* set up our own copy of the decoded area, we have to do it here,
-	 *  since the uhd wrapper does not allow starting single channels
+	* since the uhd wrapper does not allow starting single channels
 	* additionally go for the producer init for both, so only we are responsible for the init, instead
-     * of splitting it with the client and causing potential races if one side uses it too early */
+	* of splitting it with the client and causing potential races if one side uses it too early */
 	decoded_region = ipc_shm_decode_region(0, (struct ipc_shm_raw_region *)shm);
-	for (unsigned int i = 0; i < open_req->num_chans; i++) {
+	for (i = 0; i < open_req->num_chans; i++) {
 		//		ios_tx_to_device[i] = ipc_shm_init_consumer(decoded_region->channels[i]->dl_stream);
 		ios_tx_to_device[i] = ipc_shm_init_producer(decoded_region->channels[i]->dl_stream);
 		ios_rx_from_device[i] = ipc_shm_init_producer(decoded_region->channels[i]->ul_stream);
@@ -249,11 +249,14 @@ int ipc_rx_open_req(struct ipc_sk_if_open_req *open_req)
 	return 0;
 }
 
+volatile bool ul_running = false;
+volatile bool dl_running = false;
+
 void *uplink_thread(void *x_void_ptr)
 {
 	uint32_t chann = decoded_region->num_chans;
-
-	pthread_setname_np(pthread_self(), "uplink rx");
+	ul_running = true;
+	pthread_setname_np(pthread_self(), "uplink_rx");
 
 	while (!ipc_exit_requested) {
 		int32_t read = uhdwrap_read(global_dev, chann);
@@ -266,7 +269,8 @@ void *uplink_thread(void *x_void_ptr)
 void *downlink_thread(void *x_void_ptr)
 {
 	int chann = decoded_region->num_chans;
-	pthread_setname_np(pthread_self(), "downlink tx");
+	dl_running = true;
+	pthread_setname_np(pthread_self(), "downlink_tx");
 
 	while (!ipc_exit_requested) {
 		bool underrun;
@@ -279,14 +283,21 @@ int ipc_rx_chan_start_req(struct ipc_sk_chan_if_op_void *req, uint8_t chan_nr)
 {
 	struct msgb *msg;
 	struct ipc_sk_chan_if *ipc_prim;
-	int rc;
+	int rc = 0;
 
-	/* no per-chan start/stop */
 	rc = uhdwrap_start(global_dev, chan_nr);
 
-	pthread_t rx, tx;
-	pthread_create(&rx, NULL, uplink_thread, 0);
-	pthread_create(&tx, NULL, downlink_thread, 0);
+	/* no per-chan start/stop */
+	if (!dl_running || !ul_running) {
+		/* chan != first chan start will "fail", which is fine, usrp can't start/stop chans independently */
+		if (rc) {
+			LOGP(DMAIN, LOGL_INFO, "starting rx/tx threads.. req for chan:%d\n", chan_nr);
+			pthread_t rx, tx;
+			pthread_create(&rx, NULL, uplink_thread, 0);
+			pthread_create(&tx, NULL, downlink_thread, 0);
+		}
+	} else
+		LOGP(DMAIN, LOGL_INFO, "starting rx/tx threads request ignored.. req for chan:%d\n", chan_nr);
 
 	msg = ipc_msgb_alloc(IPC_IF_MSG_START_CNF);
 	if (!msg)
@@ -348,6 +359,23 @@ int ipc_rx_chan_setfreq_req(struct ipc_sk_chan_if_freq_req *req, uint8_t chan_nr
 	return ipc_chan_sock_send(msg, chan_nr);
 }
 
+int ipc_rx_chan_settxatten_req(struct ipc_sk_chan_if_tx_attenuation *req, uint8_t chan_nr)
+{
+	struct msgb *msg;
+	struct ipc_sk_chan_if *ipc_prim;
+	double rv;
+
+	rv = uhdwrap_set_txatt(global_dev, req->attenuation, chan_nr);
+
+	msg = ipc_msgb_alloc(IPC_IF_MSG_SETTXATTN_CNF);
+	if (!msg)
+		return -ENOMEM;
+	ipc_prim = (struct ipc_sk_chan_if *)msg->data;
+	ipc_prim->u.txatten_cnf.attenuation = rv;
+
+	return ipc_chan_sock_send(msg, chan_nr);
+}
+
 int ipc_sock_init(const char *path, struct ipc_sock_state **global_state_var,
 		  int (*sock_callback_fn)(struct osmo_fd *fd, unsigned int what), int n)
 {
@@ -372,10 +400,7 @@ int ipc_sock_init(const char *path, struct ipc_sock_state **global_state_var,
 		return -1;
 	}
 
-	bfd->when = BSC_FD_READ;
-	bfd->cb = sock_callback_fn;
-	bfd->data = state;
-	bfd->priv_nr = n;
+	osmo_fd_setup(bfd, bfd->fd, OSMO_FD_READ, sock_callback_fn, state, n);
 
 	rc = osmo_fd_register(bfd);
 	if (rc < 0) {
@@ -385,8 +410,6 @@ int ipc_sock_init(const char *path, struct ipc_sock_state **global_state_var,
 		return rc;
 	}
 
-	//osmo_signal_register_handler(SS_GLOBAL, IPC_if_signal_cb, NULL);
-
 	LOGP(DMAIN, LOGL_INFO, "Started listening on IPC socket: %s\n", path);
 
 	return 0;
@@ -394,26 +417,22 @@ int ipc_sock_init(const char *path, struct ipc_sock_state **global_state_var,
 
 static void print_help(void)
 {
-	printf(	"ipc-driver-test Usage:\n"
-		" -h  --help		This message\n"
-		" -n  --sock-num NR	Master socket suffix number NR\n"
-	      );
+	printf("ipc-driver-test Usage:\n"
+	       " -h  --help		This message\n"
+	       " -u  --unix-sk-dir DIR	Existing directory where to create the Master socket\n"
+	       " -n  --sock-num NR	Master socket suffix number NR\n");
 }
 
-static int msocknum = 0;
-
 static void handle_options(int argc, char **argv)
 {
 	while (1) {
 		int option_index = 0, c;
-		const struct option long_options[] = {
-			{ "help", 0, 0, 'h' },
-			{ "sock-num", 1, 0, 'n' },
-			{0,0,0,0}
-		};
+		const struct option long_options[] = { { "help", 0, 0, 'h' },
+						       { "unix-sk-dir", 1, 0, 'u' },
+						       { "sock-num", 1, 0, 'n' },
+						       { 0, 0, 0, 0 } };
 
-		c = getopt_long(argc, argv, "hn:",
-				long_options, &option_index);
+		c = getopt_long(argc, argv, "hu:n:", long_options, &option_index);
 		if (c == -1)
 			break;
 
@@ -422,9 +441,13 @@ static void handle_options(int argc, char **argv)
 			print_help();
 			exit(0);
 			break;
-		case 'n':
-			msocknum = atoi(optarg);
+		case 'u':
+			cmdline_cfg.ud_prefix_dir = talloc_strdup(tall_ctx, optarg);
 			break;
+		case 'n':
+			cmdline_cfg.msocknum = atoi(optarg);
+			break;
+
 		default:
 			exit(2);
 			break;
@@ -437,31 +460,33 @@ static void handle_options(int argc, char **argv)
 	}
 }
 
-#if defined(IPCMAGIC) && defined(__cplusplus)
-extern "C" int osmo_ctx_init(const char *id);
-
-extern "C" int magicmain(int argc, char **argv)
-{
-	osmo_ctx_init("main");
-	osmo_select_init();
-
-#else
 int main(int argc, char **argv)
 {
-#endif
-	char ipc_msock_path[sizeof(IPC_SOCK_PATH_PREFIX)+3];
+	char ipc_msock_path[128];
 	tall_ctx = talloc_named_const(NULL, 0, "OsmoTRX");
 	msgb_talloc_ctx_init(tall_ctx, 0);
 	osmo_init_logging2(tall_ctx, &log_infox);
 	log_enable_multithread();
 
 	handle_options(argc, argv);
-	snprintf(ipc_msock_path,sizeof(ipc_msock_path), "%s%d", IPC_SOCK_PATH_PREFIX, msocknum);
+
+	if (!cmdline_cfg.ud_prefix_dir)
+		cmdline_cfg.ud_prefix_dir = talloc_strdup(tall_ctx, IPC_SOCK_PATH_PREFIX);
+
+
+	snprintf(ipc_msock_path, sizeof(ipc_msock_path), "%s/ipc_sock%d", cmdline_cfg.ud_prefix_dir, cmdline_cfg.msocknum);
 
 	LOGP(DMAIN, LOGL_INFO, "Starting %s\n", argv[0]);
 	ipc_sock_init(ipc_msock_path, &global_ipc_sock_state, ipc_sock_accept, 0);
 	while (!ipc_exit_requested)
 		osmo_select_main(0);
-	//ipc_sock_close()
+
+	if (global_dev) {
+		unsigned int i;
+		for (i = 0; i < decoded_region->num_chans; i++)
+			uhdwrap_stop(global_dev, i);
+	}
+
+	ipc_sock_close(global_ipc_sock_state);
 	return 0;
 }

Transceiver52M/device/ipc/ipc-driver-test.h

@@ -4,12 +4,14 @@
 *
 * SPDX-License-Identifier: 0BSD
 *
-    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 #pragma once
 
@@ -25,7 +27,7 @@ extern struct ipc_shm_io *ios_rx_from_device[8];
 
 struct ipc_sock_state {
 	struct osmo_fd listen_bfd; /* fd for listen socket */
-	struct osmo_fd conn_bfd; /* fd for connection to lcr */
+	struct osmo_fd conn_bfd; /* fd for connection */
 	struct llist_head upqueue; /* queue for sending messages */
 };
 
@@ -40,3 +42,4 @@ int ipc_rx_chan_start_req(struct ipc_sk_chan_if_op_void *req, uint8_t chan_nr);
 int ipc_rx_chan_stop_req(struct ipc_sk_chan_if_op_void *req, uint8_t chan_nr);
 int ipc_rx_chan_setgain_req(struct ipc_sk_chan_if_gain *req, uint8_t chan_nr);
 int ipc_rx_chan_setfreq_req(struct ipc_sk_chan_if_freq_req *req, uint8_t chan_nr);
+int ipc_rx_chan_settxatten_req(struct ipc_sk_chan_if_tx_attenuation *req, uint8_t chan_nr);

Transceiver52M/device/ipc/ipc_chan.c

@@ -4,12 +4,14 @@
 *
 * SPDX-License-Identifier: 0BSD
 *
-    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 #include <stdio.h>
 #include <stdlib.h>
@@ -57,8 +59,11 @@ static int ipc_chan_rx(uint8_t msg_type, struct ipc_sk_chan_if *ipc_prim, uint8_
 	case IPC_IF_MSG_SETFREQ_REQ:
 		rc = ipc_rx_chan_setfreq_req(&ipc_prim->u.set_freq_req, chan_nr);
 		break;
+	case IPC_IF_MSG_SETTXATTN_REQ:
+		rc = ipc_rx_chan_settxatten_req(&ipc_prim->u.txatten_req, chan_nr);
+		break;
 	default:
-		LOGP(DMAIN, LOGL_ERROR, "Received unknown IPC msg type %d\n", msg_type);
+		LOGP(DDEV, LOGL_ERROR, "Received unknown IPC msg type 0x%02x on chan %d\n", msg_type, chan_nr);
 		rc = -EINVAL;
 	}
 
@@ -91,7 +96,7 @@ static int ipc_chan_sock_read(struct osmo_fd *bfd)
 	}
 
 	if (rc < (int)sizeof(*ipc_prim)) {
-		LOGP(DMAIN, LOGL_ERROR,
+		LOGP(DDEV, LOGL_ERROR,
 		     "Received %d bytes on Unix Socket, but primitive size "
 		     "is %zu, discarding\n",
 		     rc, sizeof(*ipc_prim));
@@ -122,7 +127,7 @@ int ipc_chan_sock_send(struct msgb *msg, uint8_t chan_nr)
 		return -EINVAL;
 
 	if (!state) {
-		LOGP(DMAIN, LOGL_INFO,
+		LOGP(DDEV, LOGL_INFO,
 		     "IPC socket not created, "
 		     "dropping message\n");
 		msgb_free(msg);
@@ -130,14 +135,14 @@ int ipc_chan_sock_send(struct msgb *msg, uint8_t chan_nr)
 	}
 	conn_bfd = &state->conn_bfd;
 	if (conn_bfd->fd <= 0) {
-		LOGP(DMAIN, LOGL_NOTICE,
+		LOGP(DDEV, LOGL_NOTICE,
 		     "IPC socket not connected, "
 		     "dropping message\n");
 		msgb_free(msg);
 		return -EIO;
 	}
 	msgb_enqueue(&state->upqueue, msg);
-	conn_bfd->when |= BSC_FD_WRITE;
+	osmo_fd_write_enable(conn_bfd);
 
 	return 0;
 }
@@ -155,11 +160,11 @@ static int ipc_chan_sock_write(struct osmo_fd *bfd)
 		msg = llist_entry(state->upqueue.next, struct msgb, list);
 		ipc_prim = (struct ipc_sk_chan_if *)msg->data;
 
-		bfd->when &= ~BSC_FD_WRITE;
+		osmo_fd_write_disable(bfd);
 
 		/* bug hunter 8-): maybe someone forgot msgb_put(...) ? */
 		if (!msgb_length(msg)) {
-			LOGP(DMAIN, LOGL_ERROR,
+			LOGP(DDEV, LOGL_ERROR,
 			     "message type (%d) with ZERO "
 			     "bytes!\n",
 			     ipc_prim->msg_type);
@@ -172,14 +177,14 @@ static int ipc_chan_sock_write(struct osmo_fd *bfd)
 			goto close;
 		if (rc < 0) {
 			if (errno == EAGAIN) {
-				bfd->when |= BSC_FD_WRITE;
+				osmo_fd_write_enable(bfd);
 				break;
 			}
 			goto close;
 		}
 
 	dontsend:
-		/* _after_ we send it, we can deueue */
+		/* _after_ we send it, we can dequeue */
 		msg2 = msgb_dequeue(&state->upqueue);
 		assert(msg == msg2);
 		msgb_free(msg);
@@ -195,12 +200,12 @@ static int ipc_chan_sock_cb(struct osmo_fd *bfd, unsigned int flags)
 {
 	int rc = 0;
 
-	if (flags & BSC_FD_READ)
+	if (flags & OSMO_FD_READ)
 		rc = ipc_chan_sock_read(bfd);
 	if (rc < 0)
 		return rc;
 
-	if (flags & BSC_FD_WRITE)
+	if (flags & OSMO_FD_WRITE)
 		rc = ipc_chan_sock_write(bfd);
 
 	return rc;
@@ -217,27 +222,25 @@ int ipc_chan_sock_accept(struct osmo_fd *bfd, unsigned int flags)
 	len = sizeof(un_addr);
 	rc = accept(bfd->fd, (struct sockaddr *)&un_addr, &len);
 	if (rc < 0) {
-		LOGP(DMAIN, LOGL_ERROR, "Failed to accept a new connection\n");
+		LOGP(DDEV, LOGL_ERROR, "Failed to accept a new connection\n");
 		return -1;
 	}
 
 	if (conn_bfd->fd >= 0) {
-		LOGP(DMAIN, LOGL_NOTICE,
+		LOGP(DDEV, LOGL_NOTICE,
 		     "osmo-trx connects but we already have "
 		     "another active connection ?!?\n");
 		/* We already have one IPC connected, this is all we support */
-		state->listen_bfd.when &= ~BSC_FD_READ;
+		osmo_fd_read_disable(&state->listen_bfd);
 		close(rc);
 		return 0;
 	}
 
-	conn_bfd->fd = rc;
-	conn_bfd->when = BSC_FD_READ;
-	conn_bfd->cb = ipc_chan_sock_cb;
-	conn_bfd->data = state;
+	/* copy chan nr, required for proper bfd<->chan # mapping */
+	osmo_fd_setup(conn_bfd, rc, OSMO_FD_READ, ipc_chan_sock_cb, state, bfd->priv_nr);
 
 	if (osmo_fd_register(conn_bfd) != 0) {
-		LOGP(DMAIN, LOGL_ERROR,
+		LOGP(DDEV, LOGL_ERROR,
 		     "Failed to register new connection "
 		     "fd\n");
 		close(conn_bfd->fd);
@@ -245,10 +248,7 @@ int ipc_chan_sock_accept(struct osmo_fd *bfd, unsigned int flags)
 		return -1;
 	}
 
-	LOGP(DMAIN, LOGL_NOTICE, "Unix socket connected to external osmo-trx\n");
-
-	/* send current info */
-	//IPC_tx_info_ind();
+	LOGP(DDEV, LOGL_NOTICE, "Unix socket connected to external osmo-trx\n");
 
 	return 0;
 }

Transceiver52M/device/ipc/ipc_chan.h

@@ -4,12 +4,14 @@
 *
 * SPDX-License-Identifier: 0BSD
 *
-    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 #ifndef IPC_CHAN_H
 #define IPC_CHAN_H

Transceiver52M/device/ipc/ipc_shm.c

@@ -4,12 +4,14 @@
 *
 * SPDX-License-Identifier: 0BSD
 *
-    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 #ifdef __cplusplus
 extern "C" {
@@ -24,12 +26,15 @@ extern "C" {
 #include <string.h>
 #include <stdio.h>
 #include <errno.h>
+#include <osmocom/core/panic.h>
+
+#include <debug.h>
 
 #ifdef __cplusplus
 }
 #endif
 
-#define SAMPLE_SIZE_BYTE sizeof(uint16_t) * 2
+#define SAMPLE_SIZE_BYTE (sizeof(uint16_t) * 2)
 
 struct ipc_shm_io *ipc_shm_init_consumer(struct ipc_shm_stream *s)
 {
@@ -56,52 +61,44 @@ struct ipc_shm_io *ipc_shm_init_producer(struct ipc_shm_stream *s)
 	struct ipc_shm_io *r = ipc_shm_init_consumer(s);
 	rv = pthread_mutexattr_init(&att);
 	if (rv != 0) {
-		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
-		exit(EXIT_FAILURE);
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
 	}
 
 	rv = pthread_mutexattr_setrobust(&att, PTHREAD_MUTEX_ROBUST);
 	if (rv != 0) {
-		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
-		exit(EXIT_FAILURE);
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
 	}
 
 	rv = pthread_mutexattr_setpshared(&att, PTHREAD_PROCESS_SHARED);
 	if (rv != 0) {
-		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
-		exit(EXIT_FAILURE);
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
 	}
 
 	rv = pthread_mutex_init((pthread_mutex_t *)&r->this_stream->lock, &att);
 	if (rv != 0) {
-		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
-		exit(EXIT_FAILURE);
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
 	}
 
 	pthread_mutexattr_destroy(&att);
 
 	rv = pthread_condattr_setpshared(&t1, PTHREAD_PROCESS_SHARED);
 	if (rv != 0) {
-		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
-		exit(EXIT_FAILURE);
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
 	}
 
 	rv = pthread_condattr_setpshared(&t2, PTHREAD_PROCESS_SHARED);
 	if (rv != 0) {
-		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
-		exit(EXIT_FAILURE);
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
 	}
 
 	rv = pthread_cond_init((pthread_cond_t *)&r->this_stream->cf, &t1);
 	if (rv != 0) {
-		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
-		exit(EXIT_FAILURE);
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
 	}
 
 	rv = pthread_cond_init((pthread_cond_t *)&r->this_stream->ce, &t2);
 	if (rv != 0) {
-		fprintf(stderr, "%s:%d rv:%d", __FILE__, __LINE__, rv);
-		exit(EXIT_FAILURE);
+		osmo_panic("%s:%d rv:%d", __FILE__, __LINE__, rv);
 	}
 
 	pthread_condattr_destroy(&t1);
@@ -115,8 +112,7 @@ struct ipc_shm_io *ipc_shm_init_producer(struct ipc_shm_stream *s)
 void ipc_shm_close(struct ipc_shm_io *r)
 {
 	if (r) {
-		if (r->buf_ptrs)
-			free(r->buf_ptrs);
+		free(r->buf_ptrs);
 		free(r);
 	}
 }

Transceiver52M/device/ipc/ipc_shm.h

@@ -4,12 +4,14 @@
 *
 * SPDX-License-Identifier: 0BSD
 *
-Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 #ifndef IPC_SHM_H
 #define IPC_SHM_H
@@ -26,7 +28,7 @@ extern "C" {
 #endif
 
 struct ipc_shm_io {
-	volatile struct ipc_shm_raw_stream *this_stream; // plus num_buffers at end
+	volatile struct ipc_shm_raw_stream *this_stream;
 	volatile struct ipc_shm_raw_smpl_buf **volatile buf_ptrs;
 	uint32_t partial_read_begin_ptr;
 };

Transceiver52M/device/ipc/ipc_sock.c

@@ -4,12 +4,14 @@
 *
 * SPDX-License-Identifier: 0BSD
 *
-    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 #include <stdio.h>
 #include <stdlib.h>
@@ -54,7 +56,7 @@ static int ipc_rx(uint8_t msg_type, struct ipc_sk_if *ipc_prim)
 		rc = ipc_rx_open_req(&ipc_prim->u.open_req);
 		break;
 	default:
-		LOGP(DMAIN, LOGL_ERROR, "Received unknown IPC msg type %d\n", msg_type);
+		LOGP(DDEV, LOGL_ERROR, "Received unknown IPC msg type 0x%02x\n", msg_type);
 		rc = -EINVAL;
 	}
 
@@ -65,10 +67,9 @@ int ipc_sock_send(struct msgb *msg)
 {
 	struct ipc_sock_state *state = global_ipc_sock_state;
 	struct osmo_fd *conn_bfd;
-	//struct ipc_sk_if *ipc_prim = (struct ipc_sk_if *) msg->data;
 
 	if (!state) {
-		LOGP(DMAIN, LOGL_INFO,
+		LOGP(DDEV, LOGL_INFO,
 		     "IPC socket not created, "
 		     "dropping message\n");
 		msgb_free(msg);
@@ -76,14 +77,14 @@ int ipc_sock_send(struct msgb *msg)
 	}
 	conn_bfd = &state->conn_bfd;
 	if (conn_bfd->fd <= 0) {
-		LOGP(DMAIN, LOGL_NOTICE,
+		LOGP(DDEV, LOGL_NOTICE,
 		     "IPC socket not connected, "
 		     "dropping message\n");
 		msgb_free(msg);
 		return -EIO;
 	}
 	msgb_enqueue(&state->upqueue, msg);
-	conn_bfd->when |= BSC_FD_WRITE;
+	osmo_fd_write_enable(conn_bfd);
 
 	return 0;
 }
@@ -92,7 +93,7 @@ void ipc_sock_close(struct ipc_sock_state *state)
 {
 	struct osmo_fd *bfd = &state->conn_bfd;
 
-	LOGP(DMAIN, LOGL_NOTICE, "IPC socket has LOST connection\n");
+	LOGP(DDEV, LOGL_NOTICE, "IPC socket has LOST connection\n");
 
 	ipc_exit_requested = 1;
 
@@ -101,7 +102,7 @@ void ipc_sock_close(struct ipc_sock_state *state)
 	osmo_fd_unregister(bfd);
 
 	/* re-enable the generation of ACCEPT for new connections */
-	state->listen_bfd.when |= BSC_FD_READ;
+	osmo_fd_read_enable(&state->listen_bfd);
 
 	/* flush the queue */
 	while (!llist_empty(&state->upqueue)) {
@@ -136,7 +137,7 @@ int ipc_sock_read(struct osmo_fd *bfd)
 	}
 
 	if (rc < (int)sizeof(*ipc_prim)) {
-		LOGP(DMAIN, LOGL_ERROR,
+		LOGP(DDEV, LOGL_ERROR,
 		     "Received %d bytes on Unix Socket, but primitive size "
 		     "is %zu, discarding\n",
 		     rc, sizeof(*ipc_prim));
@@ -171,11 +172,11 @@ static int ipc_sock_write(struct osmo_fd *bfd)
 		msg = llist_entry(state->upqueue.next, struct msgb, list);
 		ipc_prim = (struct ipc_sk_if *)msg->data;
 
-		bfd->when &= ~BSC_FD_WRITE;
+		osmo_fd_write_disable(bfd);
 
 		/* bug hunter 8-): maybe someone forgot msgb_put(...) ? */
 		if (!msgb_length(msg)) {
-			LOGP(DMAIN, LOGL_ERROR,
+			LOGP(DDEV, LOGL_ERROR,
 			     "message type (%d) with ZERO "
 			     "bytes!\n",
 			     ipc_prim->msg_type);
@@ -188,7 +189,7 @@ static int ipc_sock_write(struct osmo_fd *bfd)
 			goto close;
 		if (rc < 0) {
 			if (errno == EAGAIN) {
-				bfd->when |= BSC_FD_WRITE;
+				osmo_fd_write_enable(bfd);
 				break;
 			}
 			goto close;
@@ -211,12 +212,12 @@ static int ipc_sock_cb(struct osmo_fd *bfd, unsigned int flags)
 {
 	int rc = 0;
 
-	if (flags & BSC_FD_READ)
+	if (flags & OSMO_FD_READ)
 		rc = ipc_sock_read(bfd);
 	if (rc < 0)
 		return rc;
 
-	if (flags & BSC_FD_WRITE)
+	if (flags & OSMO_FD_WRITE)
 		rc = ipc_sock_write(bfd);
 
 	return rc;
@@ -234,27 +235,24 @@ int ipc_sock_accept(struct osmo_fd *bfd, unsigned int flags)
 	len = sizeof(un_addr);
 	rc = accept(bfd->fd, (struct sockaddr *)&un_addr, &len);
 	if (rc < 0) {
-		LOGP(DMAIN, LOGL_ERROR, "Failed to accept a new connection\n");
+		LOGP(DDEV, LOGL_ERROR, "Failed to accept a new connection\n");
 		return -1;
 	}
 
 	if (conn_bfd->fd >= 0) {
-		LOGP(DMAIN, LOGL_NOTICE,
+		LOGP(DDEV, LOGL_NOTICE,
 		     "ip clent connects but we already have "
 		     "another active connection ?!?\n");
 		/* We already have one IPC connected, this is all we support */
-		state->listen_bfd.when &= ~BSC_FD_READ;
+		osmo_fd_read_disable(&state->listen_bfd);
 		close(rc);
 		return 0;
 	}
 
-	conn_bfd->fd = rc;
-	conn_bfd->when = BSC_FD_READ;
-	conn_bfd->cb = ipc_sock_cb;
-	conn_bfd->data = state;
+	osmo_fd_setup(conn_bfd, rc, OSMO_FD_READ, ipc_sock_cb, state, 0);
 
 	if (osmo_fd_register(conn_bfd) != 0) {
-		LOGP(DMAIN, LOGL_ERROR,
+		LOGP(DDEV, LOGL_ERROR,
 		     "Failed to register new connection "
 		     "fd\n");
 		close(conn_bfd->fd);
@@ -262,10 +260,7 @@ int ipc_sock_accept(struct osmo_fd *bfd, unsigned int flags)
 		return -1;
 	}
 
-	LOGP(DMAIN, LOGL_NOTICE, "Unix socket connected to external osmo-trx\n");
-
-	/* send current info */
-	//IPC_tx_info_ind();
+	LOGP(DDEV, LOGL_NOTICE, "Unix socket connected to external osmo-trx\n");
 
 	return 0;
 }

Transceiver52M/device/ipc/ipc_sock.h

@@ -4,12 +4,14 @@
 *
 * SPDX-License-Identifier: 0BSD
 *
-    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 #ifndef IPC_SOCK_H
 #define IPC_SOCK_H

Transceiver52M/device/ipc/shm.c

@@ -4,23 +4,23 @@
 *
 * SPDX-License-Identifier: 0BSD
 *
-    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <stdint.h>
-#include <string.h>
-#include <stdlib.h>
 #include <stddef.h>
 #include <osmocom/core/talloc.h>
 
 #include "shm.h"
 
-//#define ENCDECDEBUG
+#define ENCDECDEBUG(...) //fprintf(stderr, __VA_ARGS__)
 
 /* Convert offsets to pointers */
 struct ipc_shm_stream *ipc_shm_decode_stream(void *tall_ctx, struct ipc_shm_raw_region *root_raw,
@@ -37,9 +37,7 @@ struct ipc_shm_stream *ipc_shm_decode_stream(void *tall_ctx, struct ipc_shm_raw_
 	stream->buffer_size = stream_raw->buffer_size;
 	stream->raw = stream_raw;
 	for (i = 0; i < stream->num_buffers; i++) {
-#ifdef ENCDECDEBUG
-		fprintf(stderr, "decode: smpl_buf %d at offset %u\n", i, stream_raw->buffer_offset[i]);
-#endif
+		ENCDECDEBUG("decode: smpl_buf %d at offset %u\n", i, stream_raw->buffer_offset[i]);
 		stream->buffers[i] =
 			(struct ipc_shm_raw_smpl_buf *)(((uint8_t *)root_raw) + stream_raw->buffer_offset[i]);
 	}
@@ -53,9 +51,7 @@ struct ipc_shm_channel *ipc_shm_decode_channel(void *tall_ctx, struct ipc_shm_ra
 	chan = talloc_zero(tall_ctx, struct ipc_shm_channel);
 	if (!chan)
 		return NULL;
-#ifdef ENCDECDEBUG
-	fprintf(stderr, "decode: streams at offset %u and %u\n", chan_raw->dl_buf_offset, chan_raw->ul_buf_offset);
-#endif
+	ENCDECDEBUG("decode: streams at offset %u and %u\n", chan_raw->dl_buf_offset, chan_raw->ul_buf_offset);
 	chan->dl_stream = ipc_shm_decode_stream(
 		chan, root_raw, (struct ipc_shm_raw_stream *)(((uint8_t *)root_raw) + chan_raw->dl_buf_offset));
 	chan->ul_stream = ipc_shm_decode_stream(
@@ -73,9 +69,7 @@ struct ipc_shm_region *ipc_shm_decode_region(void *tall_ctx, struct ipc_shm_raw_
 
 	root->num_chans = root_raw->num_chans;
 	for (i = 0; i < root->num_chans; i++) {
-#ifdef ENCDECDEBUG
-		fprintf(stderr, "decode: channel %d at offset %u\n", i, root_raw->chan_offset[i]);
-#endif
+		ENCDECDEBUG("decode: channel %d at offset %u\n", i, root_raw->chan_offset[i]);
 		root->channels[i] = ipc_shm_decode_channel(
 			root, root_raw,
 			(struct ipc_shm_raw_channel *)(((uint8_t *)root_raw) + root_raw->chan_offset[i]));
@@ -86,12 +80,9 @@ struct ipc_shm_region *ipc_shm_decode_region(void *tall_ctx, struct ipc_shm_raw_
 unsigned int ipc_shm_encode_smpl_buf(struct ipc_shm_raw_region *root_raw, struct ipc_shm_raw_smpl_buf *smpl_buf_raw,
 				     uint32_t buffer_size)
 {
-	uint8_t *start = (uint8_t *)smpl_buf_raw;
 	unsigned int offset = sizeof(struct ipc_shm_raw_smpl_buf);
 	offset = (((uintptr_t)offset + 7) & ~0x07ULL);
-#ifdef ENCDECDEBUG
-	fprintf(stderr, "encode: smpl_buf at offset %lu\n", (start - (uint8_t *)root_raw));
-#endif
+	ENCDECDEBUG("encode: smpl_buf at offset %u\n", offset);
 	offset += buffer_size * sizeof(uint16_t) * 2; /* samples */
 	return offset;
 }
@@ -103,9 +94,7 @@ unsigned int ipc_shm_encode_stream(struct ipc_shm_raw_region *root_raw, struct i
 	ptrdiff_t start = (ptrdiff_t)stream_raw;
 	unsigned int offset = sizeof(struct ipc_shm_raw_stream) + sizeof(uint32_t) * num_buffers;
 	offset = (((uintptr_t)offset + 7) & ~0x07ULL);
-#ifdef ENCDECDEBUG
-	fprintf(stderr, "encode: stream at offset %lu\n", (start - (ptrdiff_t)root_raw));
-#endif
+	ENCDECDEBUG("encode: stream at offset %lu\n", (start - (ptrdiff_t)root_raw));
 	if (root_raw) {
 		stream_raw->num_buffers = num_buffers;
 		stream_raw->buffer_size = buffer_size;
@@ -126,9 +115,7 @@ unsigned int ipc_shm_encode_channel(struct ipc_shm_raw_region *root_raw, struct
 	uint8_t *start = (uint8_t *)chan_raw;
 	unsigned int offset = sizeof(struct ipc_shm_raw_channel);
 	offset = (((uintptr_t)offset + 7) & ~0x07ULL);
-#ifdef ENCDECDEBUG
-	fprintf(stderr, "encode: channel at offset %lu\n", (start - (uint8_t *)root_raw));
-#endif
+	ENCDECDEBUG("encode: channel at offset %lu\n", (start - (uint8_t *)root_raw));
 	if (root_raw)
 		chan_raw->dl_buf_offset = (start + offset - (uint8_t *)root_raw);
 	offset += ipc_shm_encode_stream(root_raw, (struct ipc_shm_raw_stream *)(start + offset), num_buffers,
@@ -151,12 +138,9 @@ unsigned int ipc_shm_encode_region(struct ipc_shm_raw_region *root_raw, uint32_t
 	if (root_raw)
 		root_raw->num_chans = num_chans;
 	for (i = 0; i < num_chans; i++) {
-		uint32_t ofs = (start + offset - (uintptr_t)root_raw);
 		if (root_raw)
 			root_raw->chan_offset[i] = (start + offset - (uintptr_t)root_raw);
-#ifdef ENCDECDEBUG
-		fprintf(stderr, "encode: channel %d chan_offset[i]=%u\n", i, ofs);
-#endif
+		ENCDECDEBUG("encode: channel %d chan_offset[i]=%lu\n", i, start + offset - (uintptr_t)root_raw);
 		offset += ipc_shm_encode_channel(root_raw, (struct ipc_shm_raw_channel *)(start + offset), num_buffers,
 						 buffer_size);
 	}

Transceiver52M/device/ipc/shm.h

@@ -4,19 +4,21 @@
 *
 * SPDX-License-Identifier: 0BSD
 *
-    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 #pragma once
 
 #include <stdint.h>
 #include <unistd.h>
 #include <limits.h>
-//#include <pthread.h>
+#include <pthread.h>
 #include <semaphore.h>
 
 /* RAW structures */
@@ -27,9 +29,9 @@ struct ipc_shm_raw_smpl_buf {
 };
 
 struct ipc_shm_raw_stream {
-	pthread_mutex_t lock;
-	pthread_cond_t cf;
-	pthread_cond_t ce;
+	pthread_mutex_t lock; /* protects this struct */
+	pthread_cond_t cf; /* signals fill to reader */
+	pthread_cond_t ce; /* signals empty nbuf to writer */
 	uint32_t num_buffers;
 	uint32_t buffer_size; /* In samples */
 	uint32_t read_next;
@@ -77,8 +79,6 @@ struct ipc_shm_region *ipc_shm_decode_region(void *tall_ctx, struct ipc_shm_raw_
 //////////////////
 // Master socket
 //////////////////
-
-#define IPC_SOCK_PATH_PREFIX "/tmp/ipc_sock"
 #define IPC_SOCK_API_VERSION 1
 
 /* msg_type */
@@ -99,6 +99,11 @@ struct ipc_shm_region *ipc_shm_decode_region(void *tall_ctx, struct ipc_shm_raw_
 struct ipc_sk_if_info_chan {
 	char tx_path[MAX_NUM_RF_PATHS][RF_PATH_NAME_SIZE];
 	char rx_path[MAX_NUM_RF_PATHS][RF_PATH_NAME_SIZE];
+	double min_rx_gain;
+	double max_rx_gain;
+	double min_tx_gain;
+	double max_tx_gain;
+	double nominal_tx_power; /* dBm */
 } __attribute__((packed));
 
 struct ipc_sk_if_open_req_chan {
@@ -120,15 +125,11 @@ struct ipc_sk_if_info_req {
 
 struct ipc_sk_if_info_cnf {
 	uint32_t feature_mask;
-	double min_rx_gain;
-	double max_rx_gain;
-	double min_tx_gain;
-	double max_tx_gain;
-	double iq_scaling_val_rx;
+	double iq_scaling_val_rx; /* for scaling, sample format is 16 bit, but adc/dac might be less */
 	double iq_scaling_val_tx;
 	uint32_t max_num_chans;
 	char dev_desc[200];
-	struct ipc_sk_if_info_chan chan_info[0];
+	struct ipc_sk_if_info_chan chan_info[MAX_NUM_CHANS];
 } __attribute__((packed));
 
 struct ipc_sk_if_open_req {
@@ -139,14 +140,14 @@ struct ipc_sk_if_open_req {
 	uint32_t tx_sample_freq_num;
 	uint32_t tx_sample_freq_den;
 	uint32_t bandwidth;
-	struct ipc_sk_if_open_req_chan chan_info[0];
+	struct ipc_sk_if_open_req_chan chan_info[MAX_NUM_CHANS];
 } __attribute__((packed));
 
 struct ipc_sk_if_open_cnf {
 	uint8_t return_code;
 	uint32_t path_delay;
 	char shm_name[SHM_NAME_MAX];
-	struct ipc_sk_if_open_cnf_chan chan_info[0];
+	struct ipc_sk_if_open_cnf_chan chan_info[MAX_NUM_CHANS];
 } __attribute__((packed));
 
 struct ipc_sk_if {
@@ -167,17 +168,20 @@ struct ipc_sk_if {
 // Channel socket
 //////////////////
 #define IPC_IF_CHAN_MSG_OFFSET 50
-#define IPC_IF_MSG_START_REQ IPC_IF_CHAN_MSG_OFFSET + 0x00
-#define IPC_IF_MSG_START_CNF IPC_IF_CHAN_MSG_OFFSET + 0x01
-#define IPC_IF_MSG_STOP_REQ IPC_IF_CHAN_MSG_OFFSET + 0x02
-#define IPC_IF_MSG_STOP_CNF IPC_IF_CHAN_MSG_OFFSET + 0x03
-#define IPC_IF_MSG_SETGAIN_REQ IPC_IF_CHAN_MSG_OFFSET + 0x04
-#define IPC_IF_MSG_SETGAIN_CNF IPC_IF_CHAN_MSG_OFFSET + 0x05
-#define IPC_IF_MSG_SETFREQ_REQ IPC_IF_CHAN_MSG_OFFSET + 0x06
-#define IPC_IF_MSG_SETFREQ_CNF IPC_IF_CHAN_MSG_OFFSET + 0x07
+#define IPC_IF_MSG_START_REQ IPC_IF_CHAN_MSG_OFFSET + 0
+#define IPC_IF_MSG_START_CNF IPC_IF_CHAN_MSG_OFFSET + 1
+#define IPC_IF_MSG_STOP_REQ IPC_IF_CHAN_MSG_OFFSET + 2
+#define IPC_IF_MSG_STOP_CNF IPC_IF_CHAN_MSG_OFFSET + 3
+#define IPC_IF_MSG_SETGAIN_REQ IPC_IF_CHAN_MSG_OFFSET + 4
+#define IPC_IF_MSG_SETGAIN_CNF IPC_IF_CHAN_MSG_OFFSET + 5
+#define IPC_IF_MSG_SETFREQ_REQ IPC_IF_CHAN_MSG_OFFSET + 6
+#define IPC_IF_MSG_SETFREQ_CNF IPC_IF_CHAN_MSG_OFFSET + 7
 
-#define IPC_IF_NOTIFY_UNDERFLOW IPC_IF_CHAN_MSG_OFFSET + 0x08
-#define IPC_IF_NOTIFY_OVERFLOW IPC_IF_CHAN_MSG_OFFSET + 0x09
+#define IPC_IF_NOTIFY_UNDERFLOW IPC_IF_CHAN_MSG_OFFSET + 8
+#define IPC_IF_NOTIFY_OVERFLOW IPC_IF_CHAN_MSG_OFFSET + 9
+
+#define IPC_IF_MSG_SETTXATTN_REQ IPC_IF_CHAN_MSG_OFFSET + 10
+#define IPC_IF_MSG_SETTXATTN_CNF IPC_IF_CHAN_MSG_OFFSET + 11
 
 struct ipc_sk_chan_if_op_void {
 	// at least one dummy byte, to allow c/c++ compatibility
@@ -206,6 +210,10 @@ struct ipc_sk_chan_if_notfiy {
 	uint8_t dummy;
 } __attribute__((packed));
 
+struct ipc_sk_chan_if_tx_attenuation {
+	double attenuation;
+} __attribute__((packed));
+
 struct ipc_sk_chan_if {
 	uint8_t msg_type; /* message type */
 	uint8_t spare[2];
@@ -220,5 +228,7 @@ struct ipc_sk_chan_if {
 		struct ipc_sk_chan_if_freq_req set_freq_req;
 		struct ipc_sk_chan_if_freq_cnf set_freq_cnf;
 		struct ipc_sk_chan_if_notfiy notify;
+		struct ipc_sk_chan_if_tx_attenuation txatten_req;
+		struct ipc_sk_chan_if_tx_attenuation txatten_cnf;
 	} u;
 } __attribute__((packed));

Transceiver52M/device/ipc/uhdwrap.cpp

@@ -4,12 +4,14 @@
 *
 * SPDX-License-Identifier: 0BSD
 *
-    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 extern "C" {
 #include <osmocom/core/application.h>
@@ -29,7 +31,6 @@ extern "C" {
 #include "../uhd/UHDDevice.h"
 #include "uhdwrap.h"
 
-#include "trx_vty.h"
 #include "Logger.h"
 #include "Threads.h"
 #include "Utils.h"
@@ -106,6 +107,8 @@ extern "C" void *uhdwrap_open(struct ipc_sk_if_open_req *open_req)
 		rx_paths.push_back(open_req->chan_info[i].rx_path);
 	}
 
+	/* FIXME: this is actually the sps value, not the sample rate!
+	 * sample rate is looked up according to the sps rate by uhd backend */
 	rx_sps = open_req->rx_sample_freq_num / open_req->rx_sample_freq_den;
 	tx_sps = open_req->tx_sample_freq_num / open_req->tx_sample_freq_den;
 	uhd_wrap *uhd_wrap_dev =
@@ -136,7 +139,9 @@ extern "C" int32_t uhdwrap_read(void *dev, uint32_t num_chans)
 	}
 
 	int32_t read = d->wrap_read(&t);
-	if (read < 0)
+
+	/* multi channel rx on b210 will return 0 due to alignment adventures, do not put 0 samples into a ipc buffer... */
+	if (read <= 0)
 		return read;
 
 	for (uint32_t i = 0; i < num_chans; i++) {
@@ -150,7 +155,7 @@ extern "C" int32_t uhdwrap_write(void *dev, uint32_t num_chans, bool *underrun)
 	uhd_wrap *d = (uhd_wrap *)dev;
 
 	uint64_t timestamp;
-	int32_t len;
+	int32_t len = -1;
 	for (uint32_t i = 0; i < num_chans; i++) {
 		len = ipc_shm_read(ios_tx_to_device[i], (uint16_t *)&d->wrap_tx_buffs[i].front(), 5000, &timestamp, 1);
 		if (len < 0)
@@ -172,10 +177,16 @@ extern "C" double uhdwrap_set_freq(void *dev, double f, size_t chan, bool for_tx
 extern "C" double uhdwrap_set_gain(void *dev, double f, size_t chan, bool for_tx)
 {
 	uhd_wrap *d = (uhd_wrap *)dev;
-	if (for_tx)
-		return d->setTxGain(f, chan);
-	else
-		return d->setRxGain(f, chan);
+	//	if (for_tx)
+	//		return d->setTxGain(f, chan);
+	//	else
+	return d->setRxGain(f, chan);
+}
+
+extern "C" double uhdwrap_set_txatt(void *dev, double a, size_t chan)
+{
+	uhd_wrap *d = (uhd_wrap *)dev;
+	return d->setPowerAttenuation(a, chan);
 }
 
 extern "C" int32_t uhdwrap_start(void *dev, int chan)
@@ -220,10 +231,6 @@ extern "C" void uhdwrap_fill_info_cnf(struct ipc_sk_if *ipc_prim)
 	// at least one duplex channel
 	auto num_chans = rxchans == txchans ? txchans : 1;
 
-	ipc_prim->u.info_cnf.min_rx_gain = rx_range.start();
-	ipc_prim->u.info_cnf.max_rx_gain = rx_range.stop();
-	ipc_prim->u.info_cnf.min_tx_gain = tx_range.start();
-	ipc_prim->u.info_cnf.max_tx_gain = tx_range.stop();
 	ipc_prim->u.info_cnf.iq_scaling_val_rx = 0.3;
 	ipc_prim->u.info_cnf.iq_scaling_val_tx = 1;
 	ipc_prim->u.info_cnf.max_num_chans = num_chans;
@@ -238,6 +245,11 @@ extern "C" void uhdwrap_fill_info_cnf(struct ipc_sk_if *ipc_prim)
 		for (unsigned int j = 0; j < rxant.size(); j++) {
 			OSMO_STRLCPY_ARRAY(chan_info->rx_path[j], rxant[j].c_str());
 		}
+		chan_info->min_rx_gain = rx_range.start();
+		chan_info->max_rx_gain = rx_range.stop();
+		chan_info->min_tx_gain = tx_range.start();
+		chan_info->max_tx_gain = tx_range.stop();
+		chan_info->nominal_tx_power = 7.5; // FIXME: would require uhd dev + freq info
 		chan_info++;
 	}
 }

Transceiver52M/device/ipc/uhdwrap.h

@@ -4,12 +4,14 @@
 *
 * SPDX-License-Identifier: 0BSD
 *
-    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted.
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
-    IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
-    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
+* Permission to use, copy, modify, and/or distribute this software for any purpose
+* with or without fee is hereby granted.THE SOFTWARE IS PROVIDED "AS IS" AND THE
+* AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
+* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR
+* BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+* CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE
+* USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 #ifndef IPC_UHDWRAP_H
 #define IPC_UHDWRAP_H
@@ -74,6 +76,8 @@ int32_t uhdwrap_start(void *dev, int chan);
 int32_t uhdwrap_stop(void *dev, int chan);
 
 void uhdwrap_fill_info_cnf(struct ipc_sk_if *ipc_prim);
+
+double uhdwrap_set_txatt(void *dev, double a, size_t chan);
 #endif
 
 #endif // IPC_B210_H

Transceiver52M/device/lms/LMSDevice.cpp

@@ -23,7 +23,6 @@
 
 #include <map>
 
-#include "trx_vty.h"
 #include "Logger.h"
 #include "Threads.h"
 #include "LMSDevice.h"
@@ -32,6 +31,7 @@
 #include <lime/LimeSuite.h>
 
 extern "C" {
+#include "trx_vty.h"
 #include "osmo_signal.h"
 #include <osmocom/core/utils.h>
 }
@@ -40,8 +40,6 @@ extern "C" {
 #include "config.h"
 #endif
 
-using namespace std;
-
 #define MAX_ANTENNA_LIST_SIZE 10
 #define GSM_CARRIER_BW 270000.0 /* 270kHz */
 #define LMS_MIN_BW_SUPPORTED 2.5e6 /* 2.5mHz, minimum supported by LMS */
@@ -65,8 +63,6 @@ struct dev_desc {
 	 * LimeNET-Micro does not like selecting internal clock
 	 */
 	bool clock_src_int_usable;
-	/* Device specific maximum tx levels selected by phasenoise measurements, in dB */
-	double max_tx_gain;
 	/* Sample rate coef (without having TX/RX samples per symbol into account) */
 	double rate;
 	/* Sample rate coef (without having TX/RX samples per symbol into account), if multi-arfcn is enabled */
@@ -80,12 +76,41 @@ struct dev_desc {
 };
 
 static const std::map<enum lms_dev_type, struct dev_desc> dev_param_map {
-	{ LMS_DEV_SDR_USB,   { true,  true,  73.0, GSMRATE, MCBTS_SPACING, 8.9e-5, 7.9e-5, LMS_DEV_SDR_USB_PREFIX_NAME } },
-	{ LMS_DEV_SDR_MINI,  { false, true,  66.0, GSMRATE, MCBTS_SPACING, 8.9e-5, 8.2e-5, LMS_DEV_SDR_MINI_PREFIX_NAME } },
-	{ LMS_DEV_NET_MICRO, { true,  false, 71.0, GSMRATE, MCBTS_SPACING, 8.9e-5, 7.9e-5, LMS_DEV_NET_MICRO_PREFIX_NAME } },
-	{ LMS_DEV_UNKNOWN,   { true,  true,  73.0, GSMRATE, MCBTS_SPACING, 8.9e-5, 7.9e-5, "UNKNOWN" } },
+	{ LMS_DEV_SDR_USB,   { true,  true,  GSMRATE, MCBTS_SPACING, 8.9e-5, 7.9e-5, LMS_DEV_SDR_USB_PREFIX_NAME } },
+	{ LMS_DEV_SDR_MINI,  { false, true,  GSMRATE, MCBTS_SPACING, 8.9e-5, 8.2e-5, LMS_DEV_SDR_MINI_PREFIX_NAME } },
+	{ LMS_DEV_NET_MICRO, { true,  false, GSMRATE, MCBTS_SPACING, 8.9e-5, 7.9e-5, LMS_DEV_NET_MICRO_PREFIX_NAME } },
+	{ LMS_DEV_UNKNOWN,   { true,  true,  GSMRATE, MCBTS_SPACING, 8.9e-5, 7.9e-5, "UNKNOWN" } },
 };
 
+typedef std::tuple<lms_dev_type, enum gsm_band> dev_band_key;
+typedef std::map<dev_band_key, dev_band_desc>::const_iterator dev_band_map_it;
+static const std::map<dev_band_key, dev_band_desc> dev_band_nom_power_param_map {
+	{ std::make_tuple(LMS_DEV_SDR_USB, GSM_BAND_850),	{ 73.0, 11.2,  -6.0  } },
+	{ std::make_tuple(LMS_DEV_SDR_USB, GSM_BAND_900),	{ 73.0, 10.8,  -6.0  } },
+	{ std::make_tuple(LMS_DEV_SDR_USB, GSM_BAND_1800),	{ 65.0, -3.5,  -17.0 } }, /* FIXME: OS#4583: 1800Mhz is failing above TxGain=65, which is around -3.5dBm (already < 0 dBm) */
+	{ std::make_tuple(LMS_DEV_SDR_USB, GSM_BAND_1900),	{ 73.0, 1.7,   -17.0 } }, /* FIXME: OS#4583: 1900MHz is failing in all TxGain values */
+	{ std::make_tuple(LMS_DEV_SDR_MINI, GSM_BAND_850),	{ 66.0, 3.1,   -6.0  } }, /* FIXME: OS#4583: Ensure BAND2 is used at startup */
+	{ std::make_tuple(LMS_DEV_SDR_MINI, GSM_BAND_900),	{ 66.0, 2.8,   -6.0  } }, /* FIXME: OS#4583: Ensure BAND2 is used at startup */
+	{ std::make_tuple(LMS_DEV_SDR_MINI, GSM_BAND_1800),	{ 66.0, -11.6, -17.0 } }, /* OS#4583: Any of BAND1 or BAND2 is fine */
+	{ std::make_tuple(LMS_DEV_SDR_MINI, GSM_BAND_1900),	{ 66.0, -9.2,  -17.0 } }, /* FIXME: OS#4583: Ensure BAND1 is used at startup */
+	{ std::make_tuple(LMS_DEV_NET_MICRO, GSM_BAND_850),	{ 71.0, 6.8,   -6.0  } },
+	{ std::make_tuple(LMS_DEV_NET_MICRO, GSM_BAND_900),	{ 71.0, 6.8,   -6.0  } },
+	{ std::make_tuple(LMS_DEV_NET_MICRO, GSM_BAND_1800),	{ 65.0, -10.5, -17.0 } }, /* OS#4583: TxGain=71 (-4.4dBm) FAIL rms phase errors ~10° */
+	{ std::make_tuple(LMS_DEV_NET_MICRO, GSM_BAND_1900),	{ 71.0, -6.3,  -17.0 } }, /* FIXME: OS#4583: all FAIL, BAND1/BAND2 rms phase errors >23° */
+};
+
+/* So far measurements done for B210 show really close to linear relationship
+ * between gain and real output power, so we simply adjust the measured offset
+ */
+static double TxGain2TxPower(const dev_band_desc &desc, double tx_gain_db)
+{
+	return desc.nom_out_tx_power - (desc.nom_lms_tx_gain - tx_gain_db);
+}
+static double TxPower2TxGain(const dev_band_desc &desc, double tx_power_dbm)
+{
+	return desc.nom_lms_tx_gain - (desc.nom_out_tx_power - tx_power_dbm);
+}
+
 static enum lms_dev_type parse_dev_type(lms_device_t *m_lms_dev)
 {
 	std::map<enum lms_dev_type, struct dev_desc>::const_iterator it = dev_param_map.begin();
@@ -109,8 +134,9 @@ static enum lms_dev_type parse_dev_type(lms_device_t *m_lms_dev)
 LMSDevice::LMSDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface, size_t chan_num, double lo_offset,
 		     const std::vector<std::string>& tx_paths,
 		     const std::vector<std::string>& rx_paths):
-	RadioDevice(tx_sps, rx_sps, iface, chan_num, lo_offset, tx_paths, rx_paths),
-	m_lms_dev(NULL), started(false), m_dev_type(LMS_DEV_UNKNOWN)
+		     RadioDevice(tx_sps, rx_sps, iface, chan_num, lo_offset, tx_paths, rx_paths),
+		     m_lms_dev(NULL), started(false), band_ass_curr_sess(false), band((enum gsm_band)0),
+		     m_dev_type(LMS_DEV_UNKNOWN)
 {
 	LOGC(DDEV, INFO) << "creating LMS device...";
 
@@ -176,7 +202,7 @@ static void print_range(const char* name, lms_range_t *range)
 int info_list_find(lms_info_str_t* info_list, unsigned int count, const std::string &args)
 {
 	unsigned int i, j;
-	std::vector<string> filters;
+	std::vector<std::string> filters;
 
 	filters = comma_delimited_to_vector(args.c_str());
 
@@ -197,6 +223,47 @@ int info_list_find(lms_info_str_t* info_list, unsigned int count, const std::str
 	return -1;
 }
 
+void LMSDevice::assign_band_desc(enum gsm_band req_band)
+{
+	dev_band_map_it it;
+
+	it = dev_band_nom_power_param_map.find(dev_band_key(m_dev_type, req_band));
+	if (it == dev_band_nom_power_param_map.end()) {
+		dev_desc desc = dev_param_map.at(m_dev_type);
+		LOGC(DDEV, ERROR) << "No Tx Power measurements exist for device "
+				    << desc.name_prefix << " on band " << gsm_band_name(req_band)
+				    << ", using LimeSDR-USB ones as fallback";
+		it = dev_band_nom_power_param_map.find(dev_band_key(LMS_DEV_SDR_USB, req_band));
+	}
+	OSMO_ASSERT(it != dev_band_nom_power_param_map.end());
+	band_desc = it->second;
+}
+
+bool LMSDevice::set_band(enum gsm_band req_band)
+{
+	if (band_ass_curr_sess && req_band != band) {
+		LOGC(DDEV, ALERT) << "Requesting band " << gsm_band_name(req_band)
+				  << " different from previous band " << gsm_band_name(band);
+		return false;
+	}
+
+	if (req_band != band) {
+		band = req_band;
+		assign_band_desc(band);
+	}
+	band_ass_curr_sess = true;
+	return true;
+}
+
+void LMSDevice::get_dev_band_desc(dev_band_desc& desc)
+{
+	if (band == 0) {
+		LOGC(DDEV, ERROR) << "Power parameters requested before Tx Frequency was set! Providing band 900 by default...";
+		assign_band_desc(GSM_BAND_900);
+	}
+	desc = band_desc;
+}
+
 int LMSDevice::open(const std::string &args, int ref, bool swap_channels)
 {
 	lms_info_str_t* info_list;
@@ -210,11 +277,12 @@ int LMSDevice::open(const std::string &args, int ref, bool swap_channels)
 
 	LMS_RegisterLogHandler(&lms_log_callback);
 
-	if ((n = LMS_GetDeviceList(NULL)) < 0)
+	if ((rc = LMS_GetDeviceList(NULL)) < 0)
 		LOGC(DDEV, ERROR) << "LMS_GetDeviceList(NULL) failed";
-	LOGC(DDEV, INFO) << "Devices found: " << n;
-	if (n < 1)
+	LOGC(DDEV, INFO) << "Devices found: " << rc;
+	if (rc < 1)
 	    return -1;
+	n = rc;
 
 	info_list = new lms_info_str_t[n];
 
@@ -322,17 +390,20 @@ bool LMSDevice::start()
 	LOGC(DDEV, INFO) << "starting LMS...";
 
 	unsigned int i;
+	dev_band_desc desc;
 
 	if (started) {
 		LOGC(DDEV, ERR) << "Device already started";
 		return false;
 	}
 
+	get_dev_band_desc(desc);
+
 	/* configure the channels/streams */
 	for (i=0; i<chans; i++) {
 		/* Set gains for calibration/filter setup */
 		/* TX gain to maximum */
-		setTxGain(maxTxGain(), i);
+		LMS_SetGaindB(m_lms_dev, LMS_CH_TX, i, TxPower2TxGain(desc, desc.nom_out_tx_power));
 		/* RX gain to midpoint */
 		setRxGain((minRxGain() + maxRxGain()) / 2, i);
 
@@ -398,6 +469,8 @@ bool LMSDevice::stop()
 		LMS_DestroyStream(m_lms_dev, &m_lms_stream_rx[i]);
 	}
 
+	band_ass_curr_sess = false;
+
 	started = false;
 	return true;
 }
@@ -477,17 +550,6 @@ bool LMSDevice::do_filters(size_t chan)
 	return true;
 }
 
-
-double LMSDevice::maxTxGain()
-{
-	return dev_param_map.at(m_dev_type).max_tx_gain;
-}
-
-double LMSDevice::minTxGain()
-{
-	return 0.0;
-}
-
 double LMSDevice::maxRxGain()
 {
 	return 73.0;
@@ -498,22 +560,6 @@ double LMSDevice::minRxGain()
 	return 0.0;
 }
 
-double LMSDevice::setTxGain(double dB, size_t chan)
-{
-	if (dB > maxTxGain())
-		dB = maxTxGain();
-	if (dB < minTxGain())
-		dB = minTxGain();
-
-	LOGCHAN(chan, DDEV, NOTICE) << "Setting TX gain to " << dB << " dB";
-
-	if (LMS_SetGaindB(m_lms_dev, LMS_CH_TX, chan, dB) < 0)
-		LOGCHAN(chan, DDEV, ERR) << "Error setting TX gain to " << dB << " dB";
-	else
-		tx_gains[chan] = dB;
-	return tx_gains[chan];
-}
-
 double LMSDevice::setRxGain(double dB, size_t chan)
 {
 	if (dB > maxRxGain())
@@ -530,6 +576,63 @@ double LMSDevice::setRxGain(double dB, size_t chan)
 	return rx_gains[chan];
 }
 
+double LMSDevice::rssiOffset(size_t chan)
+{
+	double rssiOffset;
+	dev_band_desc desc;
+
+	if (chan >= rx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	rssiOffset = rx_gains[chan] + desc.rxgain2rssioffset_rel;
+	return rssiOffset;
+}
+
+double LMSDevice::setPowerAttenuation(int atten, size_t chan)
+{
+	double tx_power, dB;
+	dev_band_desc desc;
+
+	if (chan >= tx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	tx_power = desc.nom_out_tx_power - atten;
+	dB = TxPower2TxGain(desc, tx_power);
+
+	LOGCHAN(chan, DDEV, NOTICE) << "Setting TX gain to " << dB << " dB (~" << tx_power << " dBm)";
+
+	if (LMS_SetGaindB(m_lms_dev, LMS_CH_TX, chan, dB) < 0)
+		LOGCHAN(chan, DDEV, ERR) << "Error setting TX gain to " << dB << " dB (~" << tx_power << " dBm)";
+	else
+		tx_gains[chan] = dB;
+	return desc.nom_out_tx_power - TxGain2TxPower(desc, tx_gains[chan]);
+}
+
+double LMSDevice::getPowerAttenuation(size_t chan) {
+	dev_band_desc desc;
+	if (chan >= tx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	return desc.nom_out_tx_power - TxGain2TxPower(desc, tx_gains[chan]);
+}
+
+int LMSDevice::getNominalTxPower(size_t chan)
+{
+	dev_band_desc desc;
+	get_dev_band_desc(desc);
+
+	return desc.nom_out_tx_power;
+}
+
 void LMSDevice::log_ant_list(bool dir_tx, size_t chan, std::ostringstream& os)
 {
 	lms_name_t name_list[MAX_ANTENNA_LIST_SIZE]; /* large enough list for antenna names. */
@@ -896,8 +999,30 @@ bool LMSDevice::updateAlignment(TIMESTAMP timestamp)
 
 bool LMSDevice::setTxFreq(double wFreq, size_t chan)
 {
+	uint16_t req_arfcn;
+	enum gsm_band req_band;
+
+	if (chan >= chans) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return false;
+	}
+
 	LOGCHAN(chan, DDEV, NOTICE) << "Setting Tx Freq to " << wFreq << " Hz";
 
+	req_arfcn = gsm_freq102arfcn(wFreq / 1000 / 100 , 0);
+	if (req_arfcn == 0xffff) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown ARFCN for Tx Frequency " << wFreq / 1000 << " kHz";
+		return false;
+	}
+	if (gsm_arfcn2band_rc(req_arfcn, &req_band) < 0) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown GSM band for Tx Frequency " << wFreq
+					   << " Hz (ARFCN " << req_arfcn << " )";
+		return false;
+	}
+
+	if (!set_band(req_band))
+		return false;
+
 	if (LMS_SetLOFrequency(m_lms_dev, LMS_CH_TX, chan, wFreq) < 0) {
 		LOGCHAN(chan, DDEV, ERROR) << "Error setting Tx Freq to " << wFreq << " Hz";
 		return false;
@@ -908,8 +1033,25 @@ bool LMSDevice::setTxFreq(double wFreq, size_t chan)
 
 bool LMSDevice::setRxFreq(double wFreq, size_t chan)
 {
+	uint16_t req_arfcn;
+	enum gsm_band req_band;
+
 	LOGCHAN(chan, DDEV, NOTICE) << "Setting Rx Freq to " << wFreq << " Hz";
 
+	req_arfcn = gsm_freq102arfcn(wFreq / 1000 / 100, 1);
+	if (req_arfcn == 0xffff) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown ARFCN for Rx Frequency " << wFreq / 1000 << " kHz";
+		return false;
+	}
+	if (gsm_arfcn2band_rc(req_arfcn, &req_band) < 0) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown GSM band for Rx Frequency " << wFreq
+					   << " Hz (ARFCN " << req_arfcn << " )";
+		return false;
+	}
+
+	if (!set_band(req_band))
+		return false;
+
 	if (LMS_SetLOFrequency(m_lms_dev, LMS_CH_RX, chan, wFreq) < 0) {
 		LOGCHAN(chan, DDEV, ERROR) << "Error setting Rx Freq to " << wFreq << " Hz";
 		return false;

Transceiver52M/device/lms/LMSDevice.h

@@ -32,6 +32,10 @@
 #include <iostream>
 #include <lime/LimeSuite.h>
 
+extern "C" {
+#include <osmocom/gsm/gsm_utils.h>
+}
+
 /* Definition of LIMESDR_TX_AMPL limits maximum amplitude of I and Q
  * channels separately. Hence LIMESDR_TX_AMPL value must be 1/sqrt(2) =
  * 0.7071.... to get an amplitude of 1 of the complex signal:
@@ -48,6 +52,23 @@ enum lms_dev_type {
 	LMS_DEV_UNKNOWN,
 };
 
+struct dev_band_desc {
+	/* Maximum LimeSuite Tx Gain which can be set/used without distorting
+	   the output * signal, and the resulting real output power measured
+	   when that gain is used.
+	 */
+	double nom_lms_tx_gain;  /* dB */
+	double nom_out_tx_power; /* dBm */
+	/* Factor used to infer base real RSSI offset on the Rx path based on current
+	   configured RxGain. The resulting rssiOffset is added to the per burst
+	   calculated energy in upper layers. These values were empirically
+	   found and may change based on multiple factors, see OS#4468.
+	   Correct measured values only provided for LimeSDR-USB so far.
+	   rssiOffset = rxGain + rxgain2rssioffset_rel;
+	*/
+	double rxgain2rssioffset_rel; /* dB */
+};
+
 /** A class to handle a LimeSuite supported device */
 class LMSDevice:public RadioDevice {
 
@@ -66,6 +87,9 @@ private:
 	TIMESTAMP ts_initial, ts_offset;
 
 	std::vector<double> tx_gains, rx_gains;
+	bool band_ass_curr_sess; /* true if  "band" was set after last POWEROFF */
+	enum gsm_band band;
+	struct dev_band_desc band_desc;
 
 	enum lms_dev_type m_dev_type;
 
@@ -77,7 +101,9 @@ private:
 	void update_stream_stats_rx(size_t chan, bool *overrun);
 	void update_stream_stats_tx(size_t chan, bool *underrun);
 	bool do_clock_src_freq(enum ReferenceType ref, double freq);
-
+	void get_dev_band_desc(dev_band_desc& desc);
+	bool set_band(enum gsm_band req_band);
+	void assign_band_desc(enum gsm_band req_band);
 public:
 
 	/** Object constructor */
@@ -165,19 +191,12 @@ public:
 	/** return minimum Rx Gain **/
 	double minRxGain(void);
 
-	/** sets the transmit chan gain, returns the gain setting **/
-	double setTxGain(double dB, size_t chan = 0);
+	double rssiOffset(size_t chan);
 
-	/** get transmit gain */
-	double getTxGain(size_t chan = 0) {
-		return tx_gains[chan];
-	}
+	double setPowerAttenuation(int atten, size_t chan);
+	double getPowerAttenuation(size_t chan = 0);
 
-	/** return maximum Tx Gain **/
-	double maxTxGain(void);
-
-	/** return minimum Rx Gain **/
-	double minTxGain(void);
+	int getNominalTxPower(size_t chan = 0);
 
 	/** sets the RX path to use, returns true if successful and false otherwise */
 	bool setRxAntenna(const std::string & ant, size_t chan = 0);

Transceiver52M/device/lms/Makefile.am

@@ -1,7 +1,7 @@
 include $(top_srcdir)/Makefile.common
 
 AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/../common
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(LMS_CFLAGS)
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LMS_CFLAGS)
 
 noinst_HEADERS = LMSDevice.h
 

Transceiver52M/device/uhd/Makefile.am

@@ -1,7 +1,7 @@
 include $(top_srcdir)/Makefile.common
 
 AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/../common
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(UHD_CFLAGS)
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(UHD_CFLAGS)
 
 noinst_HEADERS = UHDDevice.h
 

Transceiver52M/device/uhd/UHDDevice.cpp

@@ -33,6 +33,12 @@
 #include "config.h"
 #endif
 
+extern "C" {
+#include <osmocom/core/utils.h>
+#include <osmocom/gsm/gsm_utils.h>
+#include <osmocom/vty/cpu_sched_vty.h>
+}
+
 #ifdef USE_UHD_3_11
 #include <uhd/utils/log_add.hpp>
 #include <uhd/utils/thread.hpp>
@@ -123,9 +129,23 @@ static const std::map<dev_key, dev_desc> dev_param_map {
 	{ std::make_tuple(B2XX_MCBTS, 4, 4), { 1, 51.2e6, MCBTS_SPACING*4, B2XX_TIMING_MCBTS, "B200/B210 4 SPS Multi-ARFCN" } },
 };
 
+typedef std::tuple<uhd_dev_type, enum gsm_band> dev_band_key;
+typedef std::map<dev_band_key, dev_band_desc>::const_iterator dev_band_map_it;
+static const std::map<dev_band_key, dev_band_desc> dev_band_nom_power_param_map {
+	{ std::make_tuple(B200, GSM_BAND_850),	{ 89.75, 13.3, -7.5  } },
+	{ std::make_tuple(B200, GSM_BAND_900),	{ 89.75, 13.3, -7.5  } },
+	{ std::make_tuple(B200, GSM_BAND_1800),	{ 89.75, 7.5,  -11.0 } },
+	{ std::make_tuple(B200, GSM_BAND_1900),	{ 89.75, 7.7,  -11.0 } },
+	{ std::make_tuple(B210, GSM_BAND_850),	{ 89.75, 13.3, -7.5  } },
+	{ std::make_tuple(B210, GSM_BAND_900),	{ 89.75, 13.3, -7.5  } },
+	{ std::make_tuple(B210, GSM_BAND_1800),	{ 89.75, 7.5,  -11.0 } },
+	{ std::make_tuple(B210, GSM_BAND_1900),	{ 89.75, 7.7,  -11.0 } },
+};
+
 void *async_event_loop(uhd_device *dev)
 {
 	set_selfthread_name("UHDAsyncEvent");
+	osmo_cpu_sched_vty_apply_localthread();
 
 	while (1) {
 		dev->recv_async_msg();
@@ -188,14 +208,25 @@ static void uhd_msg_handler(uhd::msg::type_t type, const std::string &msg)
 }
 #endif
 
+/* So far measurements done for B210 show really close to linear relationship
+ * between gain and real output power, so we simply adjust the measured offset
+ */
+static double TxGain2TxPower(const dev_band_desc &desc, double tx_gain_db)
+{
+	return desc.nom_out_tx_power - (desc.nom_uhd_tx_gain - tx_gain_db);
+}
+static double TxPower2TxGain(const dev_band_desc &desc, double tx_power_dbm)
+{
+	return desc.nom_uhd_tx_gain - (desc.nom_out_tx_power - tx_power_dbm);
+}
+
 uhd_device::uhd_device(size_t tx_sps, size_t rx_sps,
 		       InterfaceType iface, size_t chan_num, double lo_offset,
 		       const std::vector<std::string>& tx_paths,
 		       const std::vector<std::string>& rx_paths)
 	: RadioDevice(tx_sps, rx_sps, iface, chan_num, lo_offset, tx_paths, rx_paths),
-	  tx_gain_min(0.0), tx_gain_max(0.0),
-	  rx_gain_min(0.0), rx_gain_max(0.0),
-	  tx_spp(0), rx_spp(0),
+	  rx_gain_min(0.0), rx_gain_max(0.0), band_ass_curr_sess(false),
+	  band((enum gsm_band)0), tx_spp(0), rx_spp(0),
 	  started(false), aligned(false), drop_cnt(0),
 	  prev_ts(0,0), ts_initial(0), ts_offset(0), async_event_thrd(NULL)
 {
@@ -209,8 +240,50 @@ uhd_device::~uhd_device()
 		delete rx_buffers[i];
 }
 
+void uhd_device::assign_band_desc(enum gsm_band req_band)
+{
+	dev_band_map_it it;
+
+	it = dev_band_nom_power_param_map.find(dev_band_key(dev_type, req_band));
+	if (it == dev_band_nom_power_param_map.end()) {
+		dev_desc desc = dev_param_map.at(dev_key(dev_type, tx_sps, rx_sps));
+		LOGC(DDEV, ERROR) << "No Power parameters exist for device "
+				    << desc.str << " on band " << gsm_band_name(req_band)
+				    << ", using B210 ones as fallback";
+		it = dev_band_nom_power_param_map.find(dev_band_key(B210, req_band));
+	}
+	OSMO_ASSERT(it != dev_band_nom_power_param_map.end())
+	band_desc = it->second;
+}
+
+bool uhd_device::set_band(enum gsm_band req_band)
+{
+	if (band_ass_curr_sess && req_band != band) {
+		LOGC(DDEV, ALERT) << "Requesting band " << gsm_band_name(req_band)
+				  << " different from previous band " << gsm_band_name(band);
+		return false;
+	}
+
+	if (req_band != band) {
+		band = req_band;
+		assign_band_desc(band);
+	}
+	band_ass_curr_sess = true;
+	return true;
+}
+
+void uhd_device::get_dev_band_desc(dev_band_desc& desc)
+{
+	if (band == 0) {
+		LOGC(DDEV, ERROR) << "Power parameters requested before Tx Frequency was set! Providing band 900 by default...";
+		assign_band_desc(GSM_BAND_900);
+	}
+	desc = band_desc;
+}
+
 void uhd_device::init_gains()
 {
+	double tx_gain_min, tx_gain_max;
 	uhd::gain_range_t range;
 
 	if (dev_type == UMTRX) {
@@ -275,37 +348,6 @@ void uhd_device::set_rates()
 	LOGC(DDEV, INFO) << "Rates configured for " << desc.str;
 }
 
-double uhd_device::setTxGain(double db, size_t chan)
-{
-	if (chan >= tx_gains.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel" << chan;
-		return 0.0f;
-	}
-
-	if (dev_type == UMTRX) {
-		std::vector<std::string> gain_stages = usrp_dev->get_tx_gain_names(0);
-		if (gain_stages[0] == "VGA" || gain_stages[0] == "PA") {
-			usrp_dev->set_tx_gain(db, chan);
-		} else {
-			// New UHD versions support split configuration of
-			// Tx gain stages. We utilize this to set the gain
-			// configuration, optimal for the Tx signal quality.
-			// From our measurements, VGA1 must be 18dB plus-minus
-			// one and VGA2 is the best when 23dB or lower.
-			usrp_dev->set_tx_gain(UMTRX_VGA1_DEF, "VGA1", chan);
-			usrp_dev->set_tx_gain(db-UMTRX_VGA1_DEF, "VGA2", chan);
-		}
-	} else {
-		usrp_dev->set_tx_gain(db, chan);
-	}
-
-	tx_gains[chan] = usrp_dev->get_tx_gain(chan);
-
-	LOGC(DDEV, INFO) << "Set TX gain to " << tx_gains[chan] << "dB (asked for " << db << "dB)";
-
-	return tx_gains[chan];
-}
-
 double uhd_device::setRxGain(double db, size_t chan)
 {
 	if (chan >= rx_gains.size()) {
@@ -331,14 +373,76 @@ double uhd_device::getRxGain(size_t chan)
 	return rx_gains[chan];
 }
 
-double uhd_device::getTxGain(size_t chan)
+double uhd_device::rssiOffset(size_t chan)
 {
+	double rssiOffset;
+	dev_band_desc desc;
+
+	if (chan >= rx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	rssiOffset = rx_gains[chan] + desc.rxgain2rssioffset_rel;
+	return rssiOffset;
+}
+
+double uhd_device::setPowerAttenuation(int atten, size_t chan) {
+	double tx_power, db;
+	dev_band_desc desc;
+
+	if (chan >= tx_gains.size()) {
+		LOGC(DDEV, ALERT) << "Requested non-existent channel" << chan;
+		return 0.0f;
+	}
+
+	get_dev_band_desc(desc);
+	tx_power = desc.nom_out_tx_power - atten;
+	db = TxPower2TxGain(desc, tx_power);
+
+	if (dev_type == UMTRX) {
+		std::vector<std::string> gain_stages = usrp_dev->get_tx_gain_names(0);
+		if (gain_stages[0] == "VGA" || gain_stages[0] == "PA") {
+			usrp_dev->set_tx_gain(db, chan);
+		} else {
+			// New UHD versions support split configuration of
+			// Tx gain stages. We utilize this to set the gain
+			// configuration, optimal for the Tx signal quality.
+			// From our measurements, VGA1 must be 18dB plus-minus
+			// one and VGA2 is the best when 23dB or lower.
+			usrp_dev->set_tx_gain(UMTRX_VGA1_DEF, "VGA1", chan);
+			usrp_dev->set_tx_gain(db-UMTRX_VGA1_DEF, "VGA2", chan);
+		}
+	} else {
+		usrp_dev->set_tx_gain(db, chan);
+	}
+
+	tx_gains[chan] = usrp_dev->get_tx_gain(chan);
+
+	LOGC(DDEV, INFO) << "Set TX gain to " << tx_gains[chan] << "dB, ~"
+			 <<  TxGain2TxPower(desc, tx_gains[chan]) << " dBm "
+			 << "(asked for " << db << " dB, ~" << tx_power << " dBm)";
+
+	return desc.nom_out_tx_power - TxGain2TxPower(desc, tx_gains[chan]);
+}
+double uhd_device::getPowerAttenuation(size_t chan) {
+	dev_band_desc desc;
 	if (chan >= tx_gains.size()) {
 		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
 		return 0.0f;
 	}
 
-	return tx_gains[chan];
+	get_dev_band_desc(desc);
+	return desc.nom_out_tx_power - TxGain2TxPower(desc, tx_gains[chan]);
+}
+
+int uhd_device::getNominalTxPower(size_t chan)
+{
+	dev_band_desc desc;
+	get_dev_band_desc(desc);
+
+	return desc.nom_out_tx_power;
 }
 
 /*
@@ -447,6 +551,7 @@ void uhd_device::set_channels(bool swap)
 int uhd_device::open(const std::string &args, int ref, bool swap_channels)
 {
 	const char *refstr;
+	int clock_lock_attempts = 15;
 
 	/* Register msg handler. Different APIs depending on UHD version */
 #ifdef USE_UHD_3_11
@@ -519,6 +624,19 @@ int uhd_device::open(const std::string &args, int ref, bool swap_channels)
 
 	usrp_dev->set_clock_source(refstr);
 
+	std::vector<std::string> sensor_names = usrp_dev->get_mboard_sensor_names();
+	if (std::find(sensor_names.begin(), sensor_names.end(), "ref_locked") != sensor_names.end()) {
+		LOGC(DDEV, INFO) << "Waiting for clock reference lock (max " << clock_lock_attempts << "s)..." << std::flush;
+		while (!usrp_dev->get_mboard_sensor("ref_locked", 0).to_bool() && clock_lock_attempts--)
+			sleep(1);
+
+		if (!clock_lock_attempts) {
+			LOGC(DDEV, ALERT) << "Locking to external 10Mhz failed!";
+			return -1;
+		}
+	}
+	LOGC(DDEV, INFO) << "Selected clock source is " << usrp_dev->get_clock_source(0);
+
 	try {
 		set_rates();
         } catch (const std::exception &e) {
@@ -674,6 +792,12 @@ bool uhd_device::stop()
 	async_event_thrd->join();
 	delete async_event_thrd;
 
+	/* reset internal buffer timestamps */
+	for (size_t i = 0; i < rx_buffers.size(); i++)
+		rx_buffers[i]->reset();
+
+	band_ass_curr_sess = false;
+
 	started = false;
 	return true;
 }
@@ -952,23 +1076,60 @@ bool uhd_device::set_freq(double freq, size_t chan, bool tx)
 
 bool uhd_device::setTxFreq(double wFreq, size_t chan)
 {
+	uint16_t req_arfcn;
+	enum gsm_band req_band;
+
 	if (chan >= tx_freqs.size()) {
 		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
 		return false;
 	}
 	ScopedLock lock(tune_lock);
 
-	return set_freq(wFreq, chan, true);
+	req_arfcn = gsm_freq102arfcn(wFreq / 1000 / 100 , 0);
+	if (req_arfcn == 0xffff) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown ARFCN for Tx Frequency " << wFreq / 1000 << " kHz";
+		return false;
+	}
+	if (gsm_arfcn2band_rc(req_arfcn, &req_band) < 0) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown GSM band for Tx Frequency " << wFreq
+					   << " Hz (ARFCN " << req_arfcn << " )";
+		return false;
+	}
+
+	if (!set_band(req_band))
+		return false;
+
+	if (!set_freq(wFreq, chan, true))
+		return false;
+
+	return true;
 }
 
 bool uhd_device::setRxFreq(double wFreq, size_t chan)
 {
+	uint16_t req_arfcn;
+	enum gsm_band req_band;
+
 	if (chan >= rx_freqs.size()) {
 		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
 		return false;
 	}
 	ScopedLock lock(tune_lock);
 
+	req_arfcn = gsm_freq102arfcn(wFreq / 1000 / 100, 1);
+	if (req_arfcn == 0xffff) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown ARFCN for Rx Frequency " << wFreq / 1000 << " kHz";
+		return false;
+	}
+	if (gsm_arfcn2band_rc(req_arfcn, &req_band) < 0) {
+		LOGCHAN(chan, DDEV, ALERT) << "Unknown GSM band for Rx Frequency " << wFreq
+					   << " Hz (ARFCN " << req_arfcn << " )";
+		return false;
+	}
+
+	if (!set_band(req_band))
+		return false;
+
 	return set_freq(wFreq, chan, false);
 }
 
@@ -1000,7 +1161,14 @@ bool uhd_device::setRxAntenna(const std::string &ant, size_t chan)
 		return false;
 	}
 
-	avail = usrp_dev->get_rx_antennas(chan);
+	/* UHD may throw a LookupError/IndexError here (see OS#4636) */
+	try {
+		avail = usrp_dev->get_rx_antennas(chan);
+	} catch (const uhd::index_error &e) {
+		LOGC(DDEV, ALERT) << "UHD Error: " << e.what();
+		return false;
+	}
+
 	if (std::find(avail.begin(), avail.end(), ant) == avail.end()) {
 		LOGC(DDEV, ALERT) << "Requested non-existent Rx antenna " << ant << " on channel " << chan;
 		LOGC(DDEV, INFO) << "Available Rx antennas: ";
@@ -1036,7 +1204,14 @@ bool uhd_device::setTxAntenna(const std::string &ant, size_t chan)
 		return false;
 	}
 
-	avail = usrp_dev->get_tx_antennas(chan);
+	/* UHD may throw a LookupError/IndexError here (see OS#4636) */
+	try {
+		avail = usrp_dev->get_tx_antennas(chan);
+	} catch (const uhd::index_error &e) {
+		LOGC(DDEV, ALERT) << "UHD Error: " << e.what();
+		return false;
+	}
+
 	if (std::find(avail.begin(), avail.end(), ant) == avail.end()) {
 		LOGC(DDEV, ALERT) << "Requested non-existent Tx antenna " << ant << " on channel " << chan;
 		LOGC(DDEV, INFO) << "Available Tx antennas: ";

Transceiver52M/device/uhd/UHDDevice.h

@@ -37,6 +37,10 @@
 #include <uhd/property_tree.hpp>
 #include <uhd/usrp/multi_usrp.hpp>
 
+extern "C" {
+#include <osmocom/gsm/gsm_utils.h>
+}
+
 
 enum uhd_dev_type {
 	USRP1,
@@ -52,6 +56,21 @@ enum uhd_dev_type {
 	LIMESDR,
 };
 
+struct dev_band_desc {
+	/* Maximum UHD Tx Gain which can be set/used without distorting the
+	   output signal, and the resulting real output power measured when that
+	   gain is used. Correct measured values only provided for B210 so far. */
+	double nom_uhd_tx_gain;  /* dB */
+	double nom_out_tx_power; /* dBm */
+	/* Factor used to infer base real RSSI offset on the Rx path based on current
+	   configured RxGain. The resulting rssiOffset is added to the per burst
+	   calculated energy in upper layers. These values were empirically
+	   found and may change based on multiple factors, see OS#4468.
+	   rssiOffset = rxGain + rxgain2rssioffset_rel;
+	*/
+	double rxgain2rssioffset_rel; /* dB */
+};
+
 /*
     uhd_device - UHD implementation of the Device interface. Timestamped samples
                 are sent to and received from the device. An intermediate buffer
@@ -94,11 +113,12 @@ public:
 	double getRxGain(size_t chan);
 	double maxRxGain(void) { return rx_gain_max; }
 	double minRxGain(void) { return rx_gain_min; }
+	double rssiOffset(size_t chan);
 
-	double setTxGain(double db, size_t chan);
-	double getTxGain(size_t chan = 0);
-	double maxTxGain(void) { return tx_gain_max; }
-	double minTxGain(void) { return tx_gain_min; }
+	double setPowerAttenuation(int atten, size_t chan);
+	double getPowerAttenuation(size_t chan = 0);
+
+	int getNominalTxPower(size_t chan = 0);
 
 	double getTxFreq(size_t chan);
 	double getRxFreq(size_t chan);
@@ -136,11 +156,13 @@ protected:
 
 	double tx_rate, rx_rate;
 
-	double tx_gain_min, tx_gain_max;
 	double rx_gain_min, rx_gain_max;
 
 	std::vector<double> tx_gains, rx_gains;
 	std::vector<double> tx_freqs, rx_freqs;
+	bool band_ass_curr_sess; /* true if  "band" was set after last POWEROFF */
+	enum gsm_band band;
+	struct dev_band_desc band_desc;
 	size_t tx_spp, rx_spp;
 
 	bool started;
@@ -169,6 +191,9 @@ protected:
 
 	uhd::tune_request_t select_freq(double wFreq, size_t chan, bool tx);
 	bool set_freq(double freq, size_t chan, bool tx);
+	void get_dev_band_desc(dev_band_desc& desc);
+	bool set_band(enum gsm_band req_band);
+	void assign_band_desc(enum gsm_band req_band);
 
 	Thread *async_event_thrd;
 	Mutex tune_lock;

Transceiver52M/device/usrp1/Makefile.am

@@ -1,7 +1,7 @@
 include $(top_srcdir)/Makefile.common
 
 AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/../common
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(USRP_CFLAGS)
+AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(USRP_CFLAGS)
 
 rev2dir = $(datadir)/usrp/rev2
 rev4dir = $(datadir)/usrp/rev4

Transceiver52M/device/usrp1/USRPDevice.cpp

@@ -205,8 +205,8 @@ bool USRPDevice::start()
   writeLock.unlock();
 
   // Set gains to midpoint
-  setTxGain((minTxGain() + maxTxGain()) / 2);
-  setRxGain((minRxGain() + maxRxGain()) / 2);
+  setTxGain((m_dbTx->gain_min() + m_dbTx->gain_max()) / 2);
+  setRxGain((m_dbTx->gain_min() + m_dbTx->gain_max()) / 2);
 
   data = new short[currDataSize];
   dataStart = 0;
@@ -243,16 +243,6 @@ bool USRPDevice::stop()
 #endif
 }
 
-double USRPDevice::maxTxGain()
-{
-  return m_dbTx->gain_max();
-}
-
-double USRPDevice::minTxGain()
-{
-  return m_dbTx->gain_min();
-}
-
 double USRPDevice::maxRxGain()
 {
   return m_dbRx->gain_max();
@@ -271,10 +261,10 @@ double USRPDevice::setTxGain(double dB, size_t chan)
   }
 
   writeLock.lock();
-  if (dB > maxTxGain())
-    dB = maxTxGain();
-  if (dB < minTxGain())
-    dB = minTxGain();
+  if (dB > m_dbTx->gain_max())
+    dB = m_dbTx->gain_max();
+  if (dB < m_dbTx->gain_min())
+    dB = m_dbTx->gain_min();
 
   LOGC(DDEV, NOTICE) << "Setting TX gain to " << dB << " dB.";
 
@@ -314,6 +304,23 @@ double USRPDevice::setRxGain(double dB, size_t chan)
   return rxGain;
 }
 
+double USRPDevice::setPowerAttenuation(int atten, size_t chan) {
+      double rfGain;
+      rfGain = setTxGain(m_dbTx->gain_max() - atten, chan);
+      return m_dbTx->gain_max() - rfGain;
+}
+double USRPDevice::getPowerAttenuation(size_t chan) {
+      return m_dbTx->gain_max() - getTxGain(chan);
+}
+
+int USRPDevice::getNominalTxPower(size_t chan)
+{
+	/* TODO: return value based on some experimentally generated table depending on
+	 * band/arfcn, which is known here thanks to TXTUNE
+	 */
+	return 23;
+}
+
 bool USRPDevice::setRxAntenna(const std::string &ant, size_t chan)
 {
 	if (chan >= rx_paths.size()) {

Transceiver52M/device/usrp1/USRPDevice.h

@@ -85,6 +85,12 @@ private:
   int writeSamplesControl(std::vector<short *> &bufs, int len, bool *underrun,
                    TIMESTAMP timestamp = 0xffffffff, bool isControl = false);
 
+  /** sets the transmit chan gain, returns the gain setting **/
+  double setTxGain(double dB, size_t chan = 0);
+
+  /** get transmit gain */
+  double getTxGain(size_t chan = 0) { return txGain; }
+
 #ifdef SWLOOPBACK
   short loopbackBuffer[1000000];
   int loopbackBufferSize;
@@ -168,17 +174,12 @@ private:
   /** return minimum Rx Gain **/
   double minRxGain(void);
 
-  /** sets the transmit chan gain, returns the gain setting **/
-  double setTxGain(double dB, size_t chan = 0);
+  double rssiOffset(size_t chan) { return 0.0f;  } /* FIXME: not implemented */
 
-  /** get transmit gain */
-  double getTxGain(size_t chan = 0) { return txGain; }
+  double setPowerAttenuation(int atten, size_t chan);
+  double getPowerAttenuation(size_t chan=0);
 
-  /** return maximum Tx Gain **/
-  double maxTxGain(void);
-
-  /** return minimum Rx Gain **/
-  double minTxGain(void);
+  int getNominalTxPower(size_t chan = 0);
 
   /** sets the RX path to use, returns true if successful and false otherwise */
   bool setRxAntenna(const std::string &ant, size_t chan = 0);

Transceiver52M/osmo-trx.cpp

@@ -12,10 +12,6 @@
  * 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
@@ -55,6 +51,7 @@ extern "C" {
 #include <osmocom/ctrl/control_if.h>
 #include <osmocom/vty/stats.h>
 #include <osmocom/vty/command.h>
+#include <osmocom/vty/cpu_sched_vty.h>
 
 #include "convolve.h"
 #include "convert.h"
@@ -143,12 +140,8 @@ int makeTransceiver(struct trx_ctx *trx, RadioInterface *radio)
 {
 	VectorFIFO *fifo;
 
-	transceiver = new Transceiver(trx->cfg.base_port, trx->cfg.bind_addr,
-			      trx->cfg.remote_addr, trx->cfg.tx_sps,
-			      trx->cfg.rx_sps, trx->cfg.num_chans, GSM::Time(3,0),
-			      radio, trx->cfg.rssi_offset, trx->cfg.stack_size);
-	if (!transceiver->init(trx->cfg.filler, trx->cfg.rtsc,
-		       trx->cfg.rach_delay, trx->cfg.egprs, trx->cfg.ext_rach)) {
+	transceiver = new Transceiver(&trx->cfg, GSM::Time(3,0), radio);
+	if (!transceiver->init()) {
 		LOG(ALERT) << "Failed to initialize transceiver";
 		return -1;
 	}
@@ -180,6 +173,17 @@ static void sig_handler(int signo)
 		gshutdown = true;
 		break;
 	case SIGABRT:
+		/* in case of abort, we want to obtain a talloc report and
+		 * then run default SIGABRT handler, who will generate coredump
+		 * and abort the process. abort() should do this for us after we
+		 * return, but program wouldn't exit if an external SIGABRT is
+		 * received.
+		 */
+		talloc_report(tall_trx_ctx, stderr);
+		talloc_report_full(tall_trx_ctx, stderr);
+		signal(SIGABRT, SIG_DFL);
+		raise(SIGABRT);
+		break;
 	case SIGUSR1:
 		talloc_report(tall_trx_ctx, stderr);
 		talloc_report_full(tall_trx_ctx, stderr);
@@ -236,7 +240,7 @@ static void setup_signal_handlers()
 		exit(EXIT_FAILURE);
 	}
 
-	osmo_fd_setup(&signal_ofd, sfd, BSC_FD_READ, signalfd_callback, NULL, 0);
+	osmo_fd_setup(&signal_ofd, sfd, OSMO_FD_READ, signalfd_callback, NULL, 0);
 	if (osmo_fd_register(&signal_ofd) < 0) {
 		fprintf(stderr, "osmo_fd_register() failed.\n");
 		exit(EXIT_FAILURE);
@@ -245,10 +249,13 @@ static void setup_signal_handlers()
 
 static void print_help()
 {
-	fprintf(stdout, "Options:\n"
-		"  -h, --help      This text\n"
-		"  -C, --config    Filename The config file to use\n"
-		"  -V, --version   Print the version of OsmoTRX\n"
+	printf( "Some useful options:\n"
+		"  -h, --help			This text\n"
+		"  -C, --config			Filename The config file to use\n"
+		"  -V, --version		Print the version of OsmoTRX\n"
+		"\nVTY reference generation:\n"
+		"      --vty-ref-mode MODE	VTY reference generation mode (e.g. 'expert').\n"
+		"      --vty-ref-xml		Generate the VTY reference XML output and exit.\n"
 		);
 }
 
@@ -259,16 +266,44 @@ static void print_deprecated(char opt)
 		<< " All cmd line options are already being overridden by VTY options if set.";
 }
 
+static void handle_long_options(const char *prog_name, const int long_option)
+{
+	static int vty_ref_mode = VTY_REF_GEN_MODE_DEFAULT;
+
+	switch (long_option) {
+	case 1:
+		vty_ref_mode = get_string_value(vty_ref_gen_mode_names, optarg);
+		if (vty_ref_mode < 0) {
+			fprintf(stderr, "%s: Unknown VTY reference generation "
+				"mode '%s'\n", prog_name, optarg);
+			exit(2);
+		}
+		break;
+	case 2:
+		fprintf(stderr, "Generating the VTY reference in mode '%s' (%s)\n",
+			get_value_string(vty_ref_gen_mode_names, vty_ref_mode),
+			get_value_string(vty_ref_gen_mode_desc, vty_ref_mode));
+		vty_dump_xml_ref_mode(stdout, (enum vty_ref_gen_mode) vty_ref_mode);
+		exit(0);
+	default:
+		fprintf(stderr, "%s: error parsing cmdline options\n", prog_name);
+		exit(2);
+	}
+}
+
 static void handle_options(int argc, char **argv, struct trx_ctx* trx)
 {
 	int option;
 	unsigned int i;
 	std::vector<std::string> rx_paths, tx_paths;
 	bool rx_paths_set = false, tx_paths_set = false;
+	static int long_option = 0;
 	static struct option long_options[] = {
 		{"help", 0, 0, 'h'},
 		{"config", 1, 0, 'C'},
 		{"version", 0, 0, 'V'},
+		{"vty-ref-mode", 1, &long_option, 1},
+		{"vty-ref-xml", 0, &long_option, 2},
 		{NULL, 0, 0, 0}
 	};
 
@@ -279,6 +314,9 @@ static void handle_options(int argc, char **argv, struct trx_ctx* trx)
 			print_help();
 			exit(0);
 			break;
+		case 0:
+			handle_long_options(argv[0], long_option);
+			break;
 		case 'a':
 			print_deprecated(option);
 			osmo_talloc_replace_string(trx, &trx->cfg.dev_args, optarg);
@@ -345,6 +383,7 @@ static void handle_options(int argc, char **argv, struct trx_ctx* trx)
 		case 'R':
 			print_deprecated(option);
 			trx->cfg.rssi_offset = atof(optarg);
+			trx->cfg.force_rssi_offset = true;
 			break;
 		case 'S':
 			print_deprecated(option);
@@ -435,7 +474,9 @@ static int set_sched_rr(unsigned int prio)
 	int rc;
 	memset(&param, 0, sizeof(param));
 	param.sched_priority = prio;
-	LOG(INFO) << "Setting SCHED_RR priority " << param.sched_priority;
+	LOG(INFO) << "Setting SCHED_RR priority " << param.sched_priority
+		  << ". This setting is DEPRECATED, please use 'policy rr " << param.sched_priority
+		  << "' under the 'sched' VTY node instead.";
 	rc = sched_setscheduler(getpid(), SCHED_RR, &param);
 	if (rc != 0) {
 		LOG(ERROR) << "Config: Setting SCHED_RR failed";
@@ -444,6 +485,38 @@ static int set_sched_rr(unsigned int prio)
 	return 0;
 }
 
+static void print_simd_info(void)
+{
+#ifdef HAVE_SSE3
+	LOGP(DMAIN, LOGL_INFO, "SSE3 support compiled in");
+#ifdef HAVE___BUILTIN_CPU_SUPPORTS
+	if (__builtin_cpu_supports("sse3"))
+		LOGPC(DMAIN, LOGL_INFO, " and supported by CPU\n");
+	else
+		LOGPC(DMAIN, LOGL_INFO, ", but not supported by CPU\n");
+#else
+	LOGPC(DMAIN, LOGL_INFO, ", but runtime SIMD detection disabled\n");
+#endif
+#endif
+
+#ifdef HAVE_SSE4_1
+	LOGP(DMAIN, LOGL_INFO, "SSE4.1 support compiled in");
+#ifdef HAVE___BUILTIN_CPU_SUPPORTS
+	if (__builtin_cpu_supports("sse4.1"))
+		LOGPC(DMAIN, LOGL_INFO, " and supported by CPU\n");
+	else
+		LOGPC(DMAIN, LOGL_INFO, ", but not supported by CPU\n");
+#else
+	LOGPC(DMAIN, LOGL_INFO, ", but runtime SIMD detection disabled\n");
+#endif
+#endif
+
+#ifndef HAVE_ATOMIC_OPS
+#pragma message ("Built without atomic operation support. Using Mutex, it may affect performance!")
+	LOG(NOTICE) << "Built without atomic operation support. Using Mutex, it may affect performance!";
+#endif
+}
+
 static void print_config(struct trx_ctx *trx)
 {
 	unsigned int i;
@@ -465,8 +538,10 @@ static void print_config(struct trx_ctx *trx)
 	ost << "   Filler Burst TSC........ " << trx->cfg.rtsc << std::endl;
 	ost << "   Filler Burst RACH Delay. " << trx->cfg.rach_delay << std::endl;
 	ost << "   Multi-Carrier........... " << trx->cfg.multi_arfcn << std::endl;
-	ost << "   Tuning offset........... " << trx->cfg.offset << std::endl;
-	ost << "   RSSI to dBm offset...... " << trx->cfg.rssi_offset << std::endl;
+	ost << "   LO freq. offset......... " << trx->cfg.offset << std::endl;
+	if (trx->cfg.freq_offset_khz != 0)
+		ost << "   Tune freq. offset....... " << trx->cfg.freq_offset_khz << std::endl;
+	ost << "   RSSI to dBm offset...... " << trx->cfg.rssi_offset << (trx->cfg.force_rssi_offset ? "" : " (relative)") << std::endl;
 	ost << "   Swap channels........... " << trx->cfg.swap_channels << std::endl;
 	ost << "   Tx Antennas.............";
 	for (i = 0; i < trx->cfg.num_chans; i++) {
@@ -551,35 +626,6 @@ int main(int argc, char *argv[])
 
 	g_trx_ctx = vty_trx_ctx_alloc(tall_trx_ctx);
 
-#ifdef HAVE_SSE3
-	printf("Info: SSE3 support compiled in");
-#ifdef HAVE___BUILTIN_CPU_SUPPORTS
-	if (__builtin_cpu_supports("sse3"))
-		printf(" and supported by CPU\n");
-	else
-		printf(", but not supported by CPU\n");
-#else
-	printf(", but runtime SIMD detection disabled\n");
-#endif
-#endif
-
-#ifdef HAVE_SSE4_1
-	printf("Info: SSE4.1 support compiled in");
-#ifdef HAVE___BUILTIN_CPU_SUPPORTS
-	if (__builtin_cpu_supports("sse4.1"))
-		printf(" and supported by CPU\n");
-	else
-		printf(", but not supported by CPU\n");
-#else
-	printf(", but runtime SIMD detection disabled\n");
-#endif
-#endif
-
-#ifndef HAVE_ATOMIC_OPS
-#pragma message ("Built without atomic operation support. Using Mutex, it may affect performance!")
-	printf("Built without atomic operation support. Using Mutex, it may affect performance!\n");
-#endif
-
 	convolve_init();
 	convert_init();
 
@@ -589,6 +635,7 @@ int main(int argc, char *argv[])
 	vty_init(&g_vty_info);
 	logging_vty_add_cmds();
 	ctrl_vty_init(tall_trx_ctx);
+	osmo_cpu_sched_vty_init(tall_trx_ctx);
 	trx_vty_init(g_trx_ctx);
 
 	osmo_talloc_vty_add_cmds();
@@ -625,6 +672,7 @@ int main(int argc, char *argv[])
 			" but expect your config to break in the future.";
 	}
 
+	print_simd_info();
 	print_config(g_trx_ctx);
 
 	if (trx_validate_config(g_trx_ctx) < 0) {

Transceiver52M/proto_trxd.c

@@ -62,14 +62,14 @@ static void trxd_fill_burst_normalized255(uint8_t* soft_bits, const struct trx_u
 {
 	unsigned i;
 	for (i = 0; i < bi->nbits; i++)
-		soft_bits[i] = (char) round(bi->rx_burst[i] * 255.0);
+		soft_bits[i] = (uint8_t) round(bi->rx_burst[i] * 255.0);
 }
 
 bool trxd_send_burst_ind_v0(size_t chan, int fd, const struct trx_ul_burst_ind *bi) {
 	int rc;
 
 	/* v0 doesn't support idle frames, they are simply dropped, not sent */
-	if(bi->idle)
+	if (bi->idle)
 		return true;
 
 	/* +2: Historically (OpenBTS times), two extra non-used bytes are sent appended to each burst */

Transceiver52M/radioInterface.cpp

@@ -27,6 +27,9 @@
 #include <Threads.h>
 
 extern "C" {
+#include <osmocom/core/utils.h>
+#include <osmocom/vty/cpu_sched_vty.h>
+
 #include "convert.h"
 }
 
@@ -103,7 +106,7 @@ double RadioInterface::fullScaleOutputValue(void) {
 
 int RadioInterface::setPowerAttenuation(int atten, size_t chan)
 {
-  double rfGain, digAtten;
+  double rfAtten, digAtten;
 
   if (chan >= mChans) {
     LOG(ALERT) << "Invalid channel requested";
@@ -113,8 +116,8 @@ int RadioInterface::setPowerAttenuation(int atten, size_t chan)
   if (atten < 0.0)
     atten = 0.0;
 
-  rfGain = setTxGain(mDevice->maxTxGain() - (double) atten, chan);
-  digAtten = (double) atten - mDevice->maxTxGain() + rfGain;
+  rfAtten = mDevice->setPowerAttenuation((double) atten, chan);
+  digAtten = (double) atten - rfAtten;
 
   if (digAtten < 1.0)
     powerScaling[chan] = 1.0;
@@ -124,6 +127,16 @@ int RadioInterface::setPowerAttenuation(int atten, size_t chan)
   return atten;
 }
 
+int RadioInterface::getNominalTxPower(size_t chan)
+{
+  if (chan >= mChans) {
+    LOG(ALERT) << "Invalid channel requested";
+    return -1;
+  }
+
+    return mDevice->getNominalTxPower(chan);
+}
+
 int RadioInterface::radioifyVector(signalVector &wVector,
                                    size_t chan, bool zero)
 {
@@ -161,6 +174,7 @@ bool RadioInterface::tuneRx(double freq, size_t chan)
 void *AlignRadioServiceLoopAdapter(RadioInterface *radioInterface)
 {
   set_selfthread_name("AlignRadio");
+  OSMO_ASSERT(osmo_cpu_sched_vty_apply_localthread() == 0);
   while (1) {
     sleep(60);
     radioInterface->alignRadio();
@@ -308,9 +322,9 @@ double RadioInterface::setRxGain(double dB, size_t chan)
   return mDevice->setRxGain(dB, chan);
 }
 
-double RadioInterface::setTxGain(double dB, size_t chan)
+double RadioInterface::rssiOffset(size_t chan)
 {
-  return mDevice->setTxGain(dB, chan);
+	return mDevice->rssiOffset(chan);
 }
 
 /* Receive a timestamped chunk from the device */

Transceiver52M/radioInterface.h

@@ -109,6 +109,9 @@ public:
   /** set receive gain */
   virtual double setRxGain(double dB, size_t chan = 0);
 
+  /** return base RSSI offset to apply for received samples **/
+  virtual double rssiOffset(size_t chan = 0);
+
   /** drive transmission of GSM bursts */
   void driveTransmitRadio(std::vector<signalVector *> &bursts,
                           std::vector<bool> &zeros);
@@ -116,7 +119,9 @@ public:
   /** drive reception of GSM bursts. -1: Error. 0: Radio off. 1: Received something. */
   int driveReceiveRadio();
 
-  int setPowerAttenuation(int atten, size_t chan = 0);
+  /** set transmit power attenuation */
+  virtual int setPowerAttenuation(int atten, size_t chan = 0);
+  int getNominalTxPower(size_t chan = 0);
 
   /** returns the full-scale transmit amplitude **/
   double fullScaleInputValue();
@@ -134,9 +139,6 @@ protected:
   /** drive synchronization of Tx/Rx of USRP */
   void alignRadio();
 
-  /** set transmit gain */
-  virtual double setTxGain(double dB, size_t chan = 0);
-
   friend void *AlignRadioServiceLoopAdapter(RadioInterface*);
 };
 
@@ -166,7 +168,7 @@ private:
   bool pushBuffer();
   int pullBuffer();
   bool verify_arfcn_consistency(double freq, size_t chan, bool tx);
-  virtual double setTxGain(double dB, size_t chan);
+  virtual int setPowerAttenuation(int atten, size_t chan = 0);
 
   signalVector *outerSendBuffer;
   signalVector *outerRecvBuffer;
@@ -191,4 +193,5 @@ public:
   bool tuneTx(double freq, size_t chan);
   bool tuneRx(double freq, size_t chan);
   virtual double setRxGain(double dB, size_t chan);
+  virtual double rssiOffset(size_t chan = 0);
 };

Transceiver52M/radioInterfaceMulti.cpp

@@ -38,6 +38,7 @@ extern "C" {
 /* Universal resampling parameters */
 #define NUMCHUNKS				24
 
+/* number of narrow-band virtual ARFCNs in this wide-band multi-ARFCN device */
 #define MCHANS					4
 
 RadioInterfaceMulti::RadioInterfaceMulti(RadioDevice *radio, size_t tx_sps,
@@ -69,6 +70,10 @@ void RadioInterfaceMulti::close()
 	channelizer = NULL;
 	synthesis = NULL;
 
+
+	for (std::vector<signalVector*>::iterator it = history.begin(); it != history.end(); ++it)
+		delete *it;
+
 	mReceiveFIFO.resize(0);
 	powerScaling.resize(0);
 	history.resize(0);
@@ -79,6 +84,10 @@ void RadioInterfaceMulti::close()
 	RadioInterface::close();
 }
 
+/*! we re-map the physical channels from the filter bank to logical per-TRX channels
+ *  \param[in] pchan physical channel number within the channelizer
+ *  \param[in] chans total number of narrow-band ARFCN channels
+ *  \returns logical (TRX) channel number, or -1 in case there is none */
 static int getLogicalChan(size_t pchan, size_t chans)
 {
 	switch (chans) {
@@ -113,6 +122,9 @@ static int getLogicalChan(size_t pchan, size_t chans)
 	return -1;
 }
 
+/*! do we need to frequency shift our spectrum or not?
+ *  \param chans total number of channels
+ *  \returns 1 if we need to shift; 0 if not; -1 on error */
 static int getFreqShift(size_t chans)
 {
 	switch (chans) {
@@ -154,6 +166,7 @@ bool RadioInterfaceMulti::init(int type)
 	tx_freq_state.resize(mChans);
 	active.resize(MCHANS, false);
 
+	/* 4 == sps */
 	inchunk = RESAMP_INRATE * 4;
 	outchunk = RESAMP_OUTRATE * 4;
 
@@ -430,18 +443,19 @@ bool RadioInterfaceMulti::tuneRx(double freq, size_t chan)
 }
 
 double RadioInterfaceMulti::setRxGain(double db, size_t chan)
-{
-  if (chan == 0)
-    return mDevice->setRxGain(db);
-  else
-    return mDevice->getRxGain();
-}
-
-double RadioInterfaceMulti::setTxGain(double dB, size_t chan)
 {
 	if (chan == 0)
-		return mDevice->setTxGain(dB);
+		return mDevice->setRxGain(db);
 	else
-		return mDevice->getTxGain();
-
+		return mDevice->getRxGain();
+}
+
+double RadioInterfaceMulti::rssiOffset(size_t chan)
+{
+	return mDevice->rssiOffset(0);
+}
+
+int RadioInterfaceMulti::setPowerAttenuation(int atten, size_t chan)
+{
+	return RadioInterface::setPowerAttenuation(atten, 0);
 }

Transceiver52M/radioVector.cpp

@@ -120,38 +120,26 @@ GSM::Time VectorQueue::nextTime() const
 
 radioVector* VectorQueue::getStaleBurst(const GSM::Time& targTime)
 {
-	mLock.lock();
-	if ((mQ.size()==0)) {
-		mLock.unlock();
+	if ((mQ.size()==0))
 		return NULL;
-	}
 
 	if (mQ.top()->getTime() < targTime) {
 		radioVector* retVal = mQ.top();
 		mQ.pop();
-		mLock.unlock();
 		return retVal;
 	}
-	mLock.unlock();
-
 	return NULL;
 }
 
 radioVector* VectorQueue::getCurrentBurst(const GSM::Time& targTime)
 {
-	mLock.lock();
-	if ((mQ.size()==0)) {
-		mLock.unlock();
+	if ((mQ.size()==0))
 		return NULL;
-	}
 
 	if (mQ.top()->getTime() == targTime) {
 		radioVector* retVal = mQ.top();
 		mQ.pop();
-		mLock.unlock();
 		return retVal;
 	}
-	mLock.unlock();
-
 	return NULL;
 }

Transceiver52M/radioVector.h

@@ -65,6 +65,7 @@ public:
 	GSM::Time nextTime() const;
 	radioVector* getStaleBurst(const GSM::Time& targTime);
 	radioVector* getCurrentBurst(const GSM::Time& targTime);
+	Mutex *getMutex() const { return &mLock; };
 };
 
 #endif /* RADIOVECTOR_H */

Transceiver52M/sigProcLib.cpp

@@ -34,6 +34,7 @@
 #include "Resampler.h"
 
 extern "C" {
+#include <osmocom/core/panic.h>
 #include "convolve.h"
 #include "scale.h"
 #include "mult.h"
@@ -1460,25 +1461,30 @@ static signalVector *downsampleBurst(const signalVector &burst)
  * It is computed from the training sequence of each received burst,
  * by comparing the "ideal" training sequence with the actual one.
  */
-static float computeCI(const signalVector *burst, CorrelationSequence *sync,
-                       float toa, int start, complex xcorr)
+static float computeCI(const signalVector *burst, const CorrelationSequence *sync,
+                       float toa, int start, const complex &xcorr)
 {
+  const int N = sync->sequence->size();
   float S, C;
-  int ps;
-
   /* Integer position where the sequence starts */
-  ps = start + 1 - sync->sequence->size() + (int)roundf(toa);
+  const int ps = start + 1 - N + (int)roundf(toa);
 
   /* Estimate Signal power */
   S = 0.0f;
-  for (int i=0, j=ps; i<(int)sync->sequence->size(); i++,j++)
+  for (int i=0, j=ps; i<(int)N; i++,j++)
     S += (*burst)[j].norm2();
-  S /= sync->sequence->size();
+  S /= N;
 
   /* Esimate Carrier power */
-  C = xcorr.norm2() / ((sync->sequence->size() - 1) * sync->gain.abs());
+  C = xcorr.norm2() / ((N - 1) * sync->gain.abs());
 
-  /* Interference = Signal - Carrier, so C/I = C / (S - C) */
+  /* Interference = Signal - Carrier, so C/I = C / (S - C).
+   * Calculated in dB:
+   * C/I_dB = 10 * log10(C/I)
+   * C/I_dB = 10 * (1/log2(10)) * log2(C/I)
+   * C/I_dB = 10 * 0.30103 * log2(C/I)
+   * C/I_dB = 3.0103 * log2(C/I)
+   */
   return 3.0103f * log2f(C / (S - C));
 }
 
@@ -1491,7 +1497,7 @@ static float computeCI(const signalVector *burst, CorrelationSequence *sync,
  * and we run full interpolating peak detection.
  */
 static int detectBurst(const signalVector &burst,
-                       signalVector &corr, CorrelationSequence *sync,
+                       signalVector &corr, const CorrelationSequence *sync,
                        float thresh, int sps, int start, int len,
                        struct estim_burst_params *ebp)
 {
@@ -1500,12 +1506,18 @@ static int detectBurst(const signalVector &burst,
   complex xcorr;
   int rc = 1;
 
-  if (sps == 4) {
-    dec = downsampleBurst(burst);
-    corr_in = dec;
-    sps = 1;
-  } else {
+  switch (sps) {
+  case 1:
     corr_in = &burst;
+    break;
+  case 4:
+    dec = downsampleBurst(burst);
+     /* Running at the downsampled rate at this point: */
+     corr_in = dec;
+     sps = 1;
+     break;
+  default:
+     osmo_panic("%s:%d SPS %d not supported! Only 1 or 4 supported", __FILE__, __LINE__, sps);
   }
 
   /* Correlate */
@@ -1515,9 +1527,6 @@ static int detectBurst(const signalVector &burst,
     goto del_ret;
   }
 
-  /* Running at the downsampled rate at this point */
-  sps = 1;
-
   /* Peak detection - place restrictions at correlation edges */
   ebp->amp = fastPeakDetect(corr, &ebp->toa);
 
@@ -1586,7 +1595,7 @@ static int detectGeneralBurst(const signalVector &rxBurst, float thresh, int sps
   // and only report clipping if we can't demod.
   float maxAmpl = maxAmplitude(rxBurst);
   if (maxAmpl > CLIP_THRESH) {
-    LOG(DEBUG) << "max burst amplitude: " << maxAmpl << " is above the clipping threshold: " << CLIP_THRESH << std::endl;
+    LOG(INFO) << "max burst amplitude: " << maxAmpl << " is above the clipping threshold: " << CLIP_THRESH << std::endl;
     clipping = true;
   }
 
@@ -1792,15 +1801,15 @@ static SoftVector *signalToSoftVector(signalVector *dec)
  * stages.
  */
 static signalVector *demodCommon(const signalVector &burst, int sps,
-                                 complex chan, float toa)
+                                 const struct estim_burst_params *ebp)
 {
   signalVector *delay, *dec;
 
   if ((sps != 1) && (sps != 4))
     return NULL;
 
-  delay = delayVector(&burst, NULL, -toa * (float) sps);
-  scaleVector(*delay, (complex) 1.0 / chan);
+  delay = delayVector(&burst, NULL, -ebp->toa * (float) sps);
+  scaleVector(*delay, (complex) 1.0 / ebp->amp);
 
   if (sps == 1)
     return delay;
@@ -1816,13 +1825,13 @@ static signalVector *demodCommon(const signalVector &burst, int sps,
  * 4 SPS (if activated) to minimize distortion through the fractional
  * delay filters. Symbol rotation and after always operates at 1 SPS.
  */
-static SoftVector *demodGmskBurst(const signalVector &rxBurst,
-                                  int sps, complex channel, float TOA)
+static SoftVector *demodGmskBurst(const signalVector &rxBurst, int sps,
+				  const struct estim_burst_params *ebp)
 {
   SoftVector *bits;
   signalVector *dec;
 
-  dec = demodCommon(rxBurst, sps, channel, TOA);
+  dec = demodCommon(rxBurst, sps, ebp);
   if (!dec)
     return NULL;
 
@@ -1835,29 +1844,51 @@ static SoftVector *demodGmskBurst(const signalVector &rxBurst,
   return bits;
 }
 
+static float computeEdgeCI(const signalVector *rot)
+{
+  float err_pwr = 0.0f;
+  float step = 2.0f * M_PI_F / 8.0f;
+
+  for (size_t i = 8; i < rot->size() - 8; i++) {
+    /* Compute the ideal symbol */
+    complex sym = (*rot)[i];
+    float phase = step * roundf(sym.arg() / step);
+    complex ideal = complex(cos(phase), sin(phase));
+
+    /* Compute the error vector */
+    complex err = ideal - sym;
+
+    /* Accumulate power */
+    err_pwr += err.norm2();
+  }
+
+  return 3.0103f * log2f(1.0f * (rot->size() - 16) / err_pwr);
+}
+
 /*
  * Demodulate an 8-PSK burst. Prior to symbol rotation, operate at
  * 4 SPS (if activated) to minimize distortion through the fractional
  * delay filters. Symbol rotation and after always operates at 1 SPS.
  *
  * Allow 1 SPS demodulation here, but note that other parts of the
- * transceiver restrict EDGE operatoin to 4 SPS - 8-PSK distortion
+ * transceiver restrict EDGE operation to 4 SPS - 8-PSK distortion
  * through the fractional delay filters at 1 SPS renders signal
  * nearly unrecoverable.
  */
-static SoftVector *demodEdgeBurst(const signalVector &burst,
-                                  int sps, complex chan, float toa)
+static SoftVector *demodEdgeBurst(const signalVector &burst, int sps,
+                                  struct estim_burst_params *ebp)
 {
   SoftVector *bits;
   signalVector *dec, *rot, *eq;
 
-  dec = demodCommon(burst, sps, chan, toa);
+  dec = demodCommon(burst, sps, ebp);
   if (!dec)
     return NULL;
 
   /* Equalize and derotate */
   eq = convolve(dec, GSMPulse4->c0_inv, NULL, NO_DELAY);
   rot = derotateEdgeBurst(*eq, 1);
+  ebp->ci = computeEdgeCI(rot);
 
   /* Soft slice and normalize */
   bits = softSliceEdgeBurst(*rot);
@@ -1869,13 +1900,13 @@ static SoftVector *demodEdgeBurst(const signalVector &burst,
   return bits;
 }
 
-SoftVector *demodAnyBurst(const signalVector &burst, int sps, complex amp,
-                          float toa, CorrType type)
+SoftVector *demodAnyBurst(const signalVector &burst, CorrType type,
+                          int sps, struct estim_burst_params *ebp)
 {
   if (type == EDGE)
-    return demodEdgeBurst(burst, sps, amp, toa);
+    return demodEdgeBurst(burst, sps, ebp);
   else
-    return demodGmskBurst(burst, sps, amp, toa);
+    return demodGmskBurst(burst, sps, ebp);
 }
 
 bool sigProcLibSetup()

Transceiver52M/sigProcLib.h

@@ -134,7 +134,7 @@ int detectAnyBurst(const signalVector &burst,
                    struct estim_burst_params *ebp);
 
 /** Demodulate burst basde on type and output soft bits */
-SoftVector *demodAnyBurst(const signalVector &burst, int sps,
-                          complex amp, float toa, CorrType type);
+SoftVector *demodAnyBurst(const signalVector &burst, CorrType type,
+                          int sps, struct estim_burst_params *ebp);
 
 #endif /* SIGPROCLIB_H */

configure.ac

@@ -34,6 +34,8 @@ AC_CANONICAL_TARGET
 
 AM_INIT_AUTOMAKE([foreign subdir-objects])
 
+CFLAGS="$CFLAGS -std=gnu11"
+
 dnl Linux kernel KBuild style compile messages
 m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
 
@@ -80,18 +82,10 @@ AC_TYPE_SIZE_T
 AC_HEADER_TIME
 AC_C_BIGENDIAN
 
-# Check if gettid is available (despite not being documented in glibc doc, it requires __USE_GNU on some systems)
-# C compiler is used since __USE_GNU seems to be always defined for g++.
-save_CPPFLAGS=$CPPFLAGS
-AC_LANG_PUSH(C)
-CPPFLAGS="$CPPFLAGS -D_GNU_SOURCE"
-AC_CHECK_FUNCS([gettid])
-AC_LANG_POP(C)
-CPPFLAGS=$save_CPPFLAGS
-
-PKG_CHECK_MODULES(LIBOSMOCORE, libosmocore >= 1.3.0)
-PKG_CHECK_MODULES(LIBOSMOVTY, libosmovty >= 1.3.0)
-PKG_CHECK_MODULES(LIBOSMOCTRL, libosmoctrl >= 1.3.0)
+PKG_CHECK_MODULES(LIBOSMOCORE, libosmocore >= 1.6.0)
+PKG_CHECK_MODULES(LIBOSMOVTY, libosmovty >= 1.6.0)
+PKG_CHECK_MODULES(LIBOSMOCTRL, libosmoctrl >= 1.6.0)
+PKG_CHECK_MODULES(LIBOSMOCODING, libosmocoding >= 1.6.0)
 
 AC_ARG_ENABLE(sanitize,
 	[AS_HELP_STRING(
@@ -139,6 +133,11 @@ AC_ARG_WITH(lms, [
         [enable LimeSuite based transceiver])
 ])
 
+AC_ARG_WITH(ipc, [
+    AS_HELP_STRING([--with-ipc],
+        [enable IPC])
+])
+
 AC_ARG_WITH(singledb, [
     AS_HELP_STRING([--with-singledb],
         [enable single daughterboard use on USRP1])
@@ -178,7 +177,7 @@ AS_IF([test "x$with_lms" = "xyes"], [
     PKG_CHECK_MODULES(LMS, LimeSuite)
 ])
 
-AS_IF([test "x$with_uhd" != "xno"],[
+AS_IF([test "x$with_uhd" = "xyes"],[
     PKG_CHECK_MODULES(UHD, uhd >= 003.011,
         [AC_DEFINE(USE_UHD_3_11, 1, UHD version 3.11.0 or higher)],
         [PKG_CHECK_MODULES(UHD, uhd >= 003.009,
@@ -237,9 +236,10 @@ AS_IF([test "x$osmo_cv_cc_has___sync_fetch_and_and" = "xyes" && test "x$osmo_cv_
     AC_DEFINE(HAVE_ATOMIC_OPS, 1, [Support all required atomic operations], [AC_MSG_WARN("At least one aotmic operation missing, will use mutex")])
 ])
 
-AM_CONDITIONAL(DEVICE_UHD, [test "x$with_uhd" != "xno"])
+AM_CONDITIONAL(DEVICE_UHD, [test "x$with_uhd" = "xyes"])
 AM_CONDITIONAL(DEVICE_USRP1, [test "x$with_usrp1" = "xyes"])
 AM_CONDITIONAL(DEVICE_LMS, [test "x$with_lms" = "xyes"])
+AM_CONDITIONAL(DEVICE_IPC, [test "x$with_ipc" = "xyes"])
 AM_CONDITIONAL(ARCH_ARM, [test "x$with_neon" = "xyes" || test "x$with_neon_vfpv4" = "xyes"])
 AM_CONDITIONAL(ARCH_ARM_A15, [test "x$with_neon_vfpv4" = "xyes"])
 
@@ -328,6 +328,7 @@ AC_CONFIG_FILES([\
     tests/Makefile \
     tests/CommonLibs/Makefile \
     tests/Transceiver52M/Makefile \
+    utils/Makefile \
     doc/Makefile \
     doc/examples/Makefile \
     contrib/Makefile \
@@ -335,4 +336,5 @@ AC_CONFIG_FILES([\
 ])
 
 AC_OUTPUT(
-	doc/manuals/Makefile)
+	doc/manuals/Makefile
+	contrib/osmo-trx.spec)

contrib/jenkins.sh

@@ -85,11 +85,10 @@ export PKG_CONFIG_PATH="$inst/lib/pkgconfig:$PKG_CONFIG_PATH"
 export LD_LIBRARY_PATH="$inst/lib"
 export PATH="$inst/bin:$PATH"
 
-CONFIG="--enable-sanitize --enable-werror --with-uhd --with-usrp1 --with-lms $INSTR"
+CONFIG="--enable-sanitize --enable-werror --with-uhd --with-usrp1 --with-lms --with-ipc $INSTR"
 
 # Additional configure options and depends
 if [ "$WITH_MANUALS" = "1" ]; then
-	osmo-build-dep.sh osmo-gsm-manuals
 	CONFIG="$CONFIG --enable-manuals"
 fi
 
@@ -107,12 +106,13 @@ autoreconf --install --force
 $MAKE $PARALLEL_MAKE
 $MAKE check \
   || cat-testlogs.sh
-DISTCHECK_CONFIGURE_FLAGS="$CONFIG" $MAKE distcheck \
+DISTCHECK_CONFIGURE_FLAGS="$CONFIG" $MAKE $PARALLEL_MAKE distcheck \
   || cat-testlogs.sh
 
 if [ "$WITH_MANUALS" = "1" ] && [ "$PUBLISH" = "1" ]; then
 	make -C "$base/doc/manuals" publish
 fi
 
-$MAKE maintainer-clean
+$MAKE $PARALLEL_MAKE maintainer-clean
+
 osmo-clean-workspace.sh

contrib/osmo-trx.spec.in

@@ -0,0 +1,254 @@
+#
+# spec file for package osmo-trx
+#
+# Copyright (c) 2017, Martin Hauke <mardnh@gmx.de>
+#
+# All modifications and additions to the file contributed by third parties
+# remain the property of their copyright owners, unless otherwise agreed
+# upon. The license for this file, and modifications and additions to the
+# file, is the same license as for the pristine package itself (unless the
+# license for the pristine package is not an Open Source License, in which
+# case the license is the MIT License). An "Open Source License" is a
+# license that conforms to the Open Source Definition (Version 1.9)
+# published by the Open Source Initiative.
+
+Name:           osmo-trx
+Version:        @VERSION@
+Release:        0
+Summary:        SDR transceiver that implements Layer 1 of a GSM BTS
+License:        AGPL-3.0-or-later
+Group:          Productivity/Telephony/Servers
+URL:            https://osmocom.org/projects/osmotrx
+Source:         %{name}-%{version}.tar.xz
+BuildRequires:  autoconf
+BuildRequires:  automake
+BuildRequires:  fdupes
+BuildRequires:  gcc-c++
+BuildRequires:  libtool
+BuildRequires:  pkgconfig >= 0.20
+%if 0%{?suse_version}
+BuildRequires:  systemd-rpm-macros
+%endif
+%if ! 0%{?centos_ver}
+BuildRequires:  pkgconfig(LimeSuite)
+BuildRequires:  pkgconfig(usrp) >= 3.3
+%endif
+BuildRequires:  pkgconfig(fftw3f)
+BuildRequires:  pkgconfig(libosmocoding) >= 1.6.0
+BuildRequires:  pkgconfig(libosmocore) >= 1.6.0
+BuildRequires:  pkgconfig(libosmoctrl) >= 1.6.0
+BuildRequires:  pkgconfig(libosmovty) >= 1.6.0
+BuildRequires:  pkgconfig(libusb-1.0)
+BuildRequires:  pkgconfig(uhd)
+%{?systemd_requires}
+%if 0%{?suse_version} > 1325
+BuildRequires:  libboost_program_options-devel
+BuildRequires:  libboost_system-devel
+BuildRequires:  libboost_test-devel
+BuildRequires:  libboost_thread-devel
+%else
+BuildRequires:  boost-devel
+%endif
+
+%description
+OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+physical layer of a BTS comprising the following 3GPP specifications:
+
+TS 05.01 "Physical layer on the radio path"
+TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
+TS 05.04 "Modulation"
+TS 05.10 "Radio subsystem synchronization"
+
+In this context, BTS is "Base transceiver station". It's the stations that
+connect mobile phones to the mobile network.
+
+3GPP is the "3rd Generation Partnership Project" which is the collaboration
+between different telecommunication associations for developing new
+generations of mobile phone networks. (post-2G/GSM)
+
+%package uhd
+Summary:        SDR transceiver that implements Layer 1 of a GSM BTS (UHD)
+Group:          Productivity/Telephony/Servers
+Requires:       uhd-firmware
+
+%description uhd
+OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+physical layer of a BTS comprising the following 3GPP specifications:
+
+TS 05.01 "Physical layer on the radio path"
+TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
+TS 05.04 "Modulation"
+TS 05.10 "Radio subsystem synchronization"
+
+In this context, BTS is "Base transceiver station". It's the stations that
+connect mobile phones to the mobile network.
+
+3GPP is the "3rd Generation Partnership Project" which is the collaboration
+between different telecommunication associations for developing new
+generations of mobile phone networks. (post-2G/GSM)
+
+%if ! 0%{?centos_ver}
+%package usrp1
+Summary:        SDR transceiver that implements Layer 1 of a GSM BTS (USRP1)
+Group:          Productivity/Telephony/Servers
+
+%description usrp1
+OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+physical layer of a BTS comprising the following 3GPP specifications:
+
+TS 05.01 "Physical layer on the radio path"
+TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
+TS 05.04 "Modulation"
+TS 05.10 "Radio subsystem synchronization"
+
+In this context, BTS is "Base transceiver station". It's the stations that
+connect mobile phones to the mobile network.
+
+3GPP is the "3rd Generation Partnership Project" which is the collaboration
+between different telecommunication associations for developing new
+generations of mobile phone networks. (post-2G/GSM)
+
+%package lms
+Summary:        SDR transceiver that implements Layer 1 of a GSM BTS (LimeSuite)
+Group:          Productivity/Telephony/Servers
+
+%description lms
+OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+physical layer of a BTS comprising the following 3GPP specifications:
+
+TS 05.01 "Physical layer on the radio path"
+TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
+TS 05.04 "Modulation"
+TS 05.10 "Radio subsystem synchronization"
+
+In this context, BTS is "Base transceiver station". It's the stations that
+connect mobile phones to the mobile network.
+
+3GPP is the "3rd Generation Partnership Project" which is the collaboration
+between different telecommunication associations for developing new
+generations of mobile phone networks. (post-2G/GSM)
+%endif
+
+%package ipc
+Summary:        SDR transceiver that implements Layer 1 of a GSM BTS (IPC)
+Group:          Productivity/Telephony/Servers
+
+%description ipc
+OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+physical layer of a BTS comprising the following 3GPP specifications:
+
+TS 05.01 "Physical layer on the radio path"
+TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
+TS 05.04 "Modulation"
+TS 05.10 "Radio subsystem synchronization"
+
+In this context, BTS is "Base transceiver station". It's the stations that
+connect mobile phones to the mobile network.
+
+3GPP is the "3rd Generation Partnership Project" which is the collaboration
+between different telecommunication associations for developing new
+generations of mobile phone networks. (post-2G/GSM)
+
+%package ipc-test
+Summary:        SDR transceiver that implements Layer 1 of a GSM BTS (IPC) driver test utility
+Group:          Productivity/Telephony/Servers
+
+%description ipc-test
+OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+physical layer of a BTS comprising the following 3GPP specifications:
+
+This package include the test tools for osmo-trx-ipc
+
+%prep
+%setup -q
+
+%build
+echo "%{version}" >.tarball-version
+autoreconf -fi
+
+%if 0%{?centos_ver}
+%configure \
+  --docdir=%{_docdir}/%{name} \
+  --with-systemdsystemunitdir=%{_unitdir} \
+  --without-lms \
+  --with-uhd \
+  --without-usrp1 \
+  --with-ipc
+%else
+%configure \
+  --docdir=%{_docdir}/%{name} \
+  --with-systemdsystemunitdir=%{_unitdir} \
+  --with-lms \
+  --with-uhd \
+  --with-usrp1 \
+  --with-ipc
+%endif
+
+make %{?_smp_mflags} V=1
+
+%check
+make %{?_smp_mflags} check || (find . -name testsuite.log -exec cat {} +)
+
+%install
+%make_install
+%fdupes -s %{buildroot}/%{_datadir}
+
+%if 0%{?suse_version}
+%pre    lms %service_add_pre    osmo-trx-lms.service
+%post   lms %service_add_post   osmo-trx-lms.service
+%preun  lms %service_del_preun  osmo-trx-lms.service
+%postun lms %service_del_postun osmo-trx-lms.service
+%pre    uhd %service_add_pre    osmo-trx-uhd.service
+%post   uhd %service_add_post   osmo-trx-uhd.service
+%preun  uhd %service_del_preun  osmo-trx-uhd.service
+%postun uhd %service_del_postun osmo-trx-uhd.service
+%pre    usrp1 %service_add_pre    osmo-trx-usrp1.service
+%post   usrp1 %service_add_post   osmo-trx-usrp1.service
+%preun  usrp1 %service_del_preun  osmo-trx-usrp1.service
+%postun usrp1 %service_del_postun osmo-trx-usrp1.service
+%pre    ipc %service_add_pre    osmo-trx-ipc.service
+%post   ipc %service_add_post   osmo-trx-ipc.service
+%preun  ipc %service_del_preun  osmo-trx-ipc.service
+%postun ipc %service_del_postun osmo-trx-ipc.service
+%endif
+
+%files
+%license COPYING
+%doc README.md
+%doc %{_docdir}/%{name}/examples
+
+%if ! 0%{?centos_ver}
+%files lms
+%{_bindir}/osmo-trx-lms
+%dir %{_sysconfdir}/osmocom
+%config(noreplace) %{_sysconfdir}/osmocom/osmo-trx-lms.cfg
+%{_unitdir}/osmo-trx-lms.service
+%endif
+
+%files uhd
+%{_bindir}/osmo-trx-uhd
+%dir %{_sysconfdir}/osmocom
+%config(noreplace) %{_sysconfdir}/osmocom/osmo-trx-uhd.cfg
+%{_unitdir}/osmo-trx-uhd.service
+
+%if ! 0%{?centos_ver}
+%files usrp1
+%{_bindir}/osmo-trx-usrp1
+%dir %{_datadir}/usrp
+%dir %{_datadir}/usrp/rev2
+%dir %{_datadir}/usrp/rev4
+%{_datadir}/usrp/rev2/std_inband.rbf
+%{_datadir}/usrp/rev4/std_inband.rbf
+%{_unitdir}/osmo-trx-usrp1.service
+%endif
+
+%files ipc
+%{_bindir}/osmo-trx-ipc
+%dir %{_sysconfdir}/osmocom
+%config(noreplace) %{_sysconfdir}/osmocom/osmo-trx-ipc.cfg
+%{_unitdir}/osmo-trx-ipc.service
+
+%files ipc-test
+%{_bindir}/ipc-driver-test
+
+%changelog

contrib/systemd/Makefile.am

@@ -1,7 +1,8 @@
 EXTRA_DIST = \
   osmo-trx-lms.service \
   osmo-trx-uhd.service \
-  osmo-trx-usrp1.service
+  osmo-trx-usrp1.service \
+  osmo-trx-ipc.service
 
 if HAVE_SYSTEMD
 SYSTEMD_SERVICES =
@@ -18,5 +19,9 @@ if DEVICE_LMS
 SYSTEMD_SERVICES += osmo-trx-lms.service
 endif
 
+if DEVICE_IPC
+SYSTEMD_SERVICES += osmo-trx-ipc.service
+endif
+
 systemdsystemunit_DATA = $(SYSTEMD_SERVICES)
 endif # HAVE_SYSTEMD

contrib/systemd/osmo-trx-ipc.service

@@ -0,0 +1,11 @@
+[Unit]
+Description=Osmocom SDR BTS L1 Transceiver (IPC Backend)
+
+[Service]
+Type=simple
+Restart=always
+ExecStart=/usr/bin/osmo-trx-ipc -C /etc/osmocom/osmo-trx-ipc.cfg
+RestartSec=2
+
+[Install]
+WantedBy=multi-user.target

debian/changelog

@@ -1,3 +1,203 @@
+osmo-trx (1.4.0) unstable; urgency=medium
+
+  [ Pau Espin Pedrol ]
+  * Threads.cpp: Fix missing extern C around libosmocore include
+  * Drop logging pthread ID
+  * Threads: Avoid printing pthread_self()
+  * ipc: Makefile.am: Clean LDADD variable
+  * Use new stat item/ctr getter APIs
+  * detectBurst(): Clear downsampling code path
+  * detectBurst(): constify parameter
+  * computeCI(): Constify param and pass it as reference
+  * computeCI(): Rename verbose repeated getter to constant
+  * computeCI(): Constify read-only variable
+  * detectGeneralBurst(): Increase log level about clipping to INFO
+  * cosmetic: Fix typo in comment
+  * computeCI: Document hardcoded multiplier
+  * lms: Drop duplicated check
+  * lms,uhd: Validate band of RxFreq too
+  * lms,uhd: Skip re-assigning same band
+  * lms,uhd: Allow changing band between poweroff & poweron
+
+  [ Vadim Yanitskiy ]
+  * gitignore: remove non-existing 'doc/manuals/osmomsc-usermanual.xml'
+  * ctrl_sock_handle_rx(): fix missing space in LOGCHAN() statement
+  * trx_rate_ctr: use thread safe strerror() in device_sig_cb()
+  * IPCDevice: use thread safe strerror_r() instead of strerror()
+  * IPCDevice: check value returned from select()
+  * LMSDevice: LMS_GetDeviceList() may return a negative number
+
+  [ Eric ]
+  * add hidden fn adjustment command
+  * uhd: ensure configured clock source is actually used
+  * vty: printing fn offset should be signed
+  * lms: init band
+
+  [ Oliver Smith ]
+  * d/patches/build-for-debian8.patch: remove
+
+ -- Pau Espin Pedrol <pespin@sysmocom.de>  Tue, 16 Nov 2021 16:27:26 +0100
+
+osmo-trx (1.3.1) unstable; urgency=medium
+
+  * mark uhddev_ipc.cpp as BUILT_SOURCES
+
+ -- Harald Welte <laforge@osmocom.org>  Sun, 28 Feb 2021 11:32:11 +0100
+
+osmo-trx (1.3.0) unstable; urgency=medium
+
+  [ Pau Espin Pedrol ]
+  * Make logging category DLMS generic and reusable for other backends
+  * uhd: Use DEVDRV log category and support UHD >=3.11 logging framework
+  * uhd: Improve some logging lines printing UHD pretty-print output
+  * doc: clarify number of channels on B210 with multi-arfcn enabled
+  * radioInterfaceMulti: Fail to tune on freq not following multi-arfcn restrictions
+  * doc: Update vty reference xml file
+  * lms: Move initialization of field started to constructor
+  * lms: Drop unused define
+  * smpl_buf: Fix str_code() param and print unknown error val
+  * lms: Improve smpl_buf error logging
+  * lms: Change radioDevice constructor arg name to avoid masking instance attr
+  * lms: Make reference to std::vector unambiguous
+  * lms: Move rx_buffers allocation to constructor
+  * lms: Store device type specific parameters in one place
+  * lms: Make ts_offset and smpl rate coefs device-specific
+  * lms: Initial multi-arfcn support
+  * contrib/jenkins.sh: Reorder sanity checks
+  * debug.h: Avoid printing pthread_t type
+  * debug.h: Fix print format of chan in CLOGCHAN
+  * cosmetic: fix several typos found by codespell
+  * radioDevice: Drop unused RSSI param from readSamples API
+  * radioDevice: Drop unused isControl param from WriteSamples API
+  * Use OSMO_FD_READ instead of deprecated BSC_FD_READ
+  * Transceiver: Fix extra space in RSP NOISELEV error
+  * Transceiver: Implement TRXC cmd NOMTXPOWER
+  * UHDDevice: Implement getNominalTxPower() based on TxFrequency
+  * radioInterface: Operate on real Tx power attenuation rather than on device specific gains
+  * UHDDevice: Compute TxGain on UHD API based on expected Tx output power
+  * proto_trxd: Fix UndefinedBehaviorSanitizer from ubsan
+  * Transceiver: Allow sending negative nominal tx power in RSP NOMTXPOWER
+  * LMSDevice: Compute TxGain on LimeSuite API based on expected Tx output power
+  * Drop old TxGain APIs from parent radioDevice abstract class
+  * {UHD,LMS}Dervice: Log expected resulting TxPower when setting device specific TxGain
+  * cosmetic: trx_rate_ctr: Fix whitespace
+  * trx_rate_ctr: Fix immediate rescheduling on per-sec thresholds
+  * Rename device specific rate counter multi-thread helpers
+  * Introduce rate counter tx_stale_bursts
+  * TransceiverState: Initialize ctrs field in constructor
+  * doc/manuals: Update thread documentation after dropping CTRL sock threads
+  * trx_rate_ctr: Fix locking wrong mutex
+  * Introduce rate counters to detect issues in received Dl bursts from TRXD
+  * Transceiver: Fix race condition obtaining Dl burst from Upper layer
+  * Add rate counter for missing Txbursts when scheduled towards the radioInterface
+  * Transceiver: Provide initial value for TransceiverState::mFiller in constructor
+  * Transceiver: Use already obtained value from Rx msg structure
+  * Transceiver: Restrict conditions where FN gaps are detected
+  * trx_rate_ctr: Lower some log levels
+  * Introduce CTR log category
+  * Transceiver: Lower some log levels which have an associated counter
+  * Transceiver: Check log level before generating burst str representation
+  * Transceiver: Add several rate_ctr for rx error conditions
+  * Use new libosmovty cpu sched config features
+  * debian: Update debian8 osmo-trx specific patch
+  * jenkins.sh: Verify distro-specific patches apply
+  * ipc: fix var declaration in for loop
+  * Add support for TRXC MUTE command
+  * arch: x86: Fix convolve optimizations breaking signal
+  * contrib/jenkins: Enable parallel make in make distcheck
+  * Transceiver: Pass config struct instead of large list of params
+  * Calculate RSSI offset based on RxGain configuration
+  * main: generate coredump and exit upon SIGABRT received
+  * ipc: Fix wrong reference to BTS in log line
+  * ipc-driver-test: Allow setting dir prefix for UD socket
+  * radioInterfaceMulti: Fix memory leak upon close()
+  * ChannelizerBase: Fix memory leak
+  * Threads.cpp: Use already existing gettid wrapper function
+  * Replace my_gettid with libosmocore osmo_gettid API
+  * tests: Explicitly drop category from log
+  * tests: Replace deprecated API log_set_print_filename
+
+  [ Philipp Maier ]
+  * debug: use LOGL_NOTICE for log category DDEV
+  * doc: do not set the base-port of the trx
+  * doc: apply an rssi-offset of 28 by default.
+  * doc: switch log levels to notice
+  * Transceiver: Log when sending of CLK indications begins
+  * vty: add attributes to VTY commands indicating when they apply
+  * osmo-trx: add commandline option --vty-ref-xml
+
+  [ Eric ]
+  * configure.ac: fix libtool issue  with clang and sanitizer
+  * transceiver: check the right vector
+  * transceiver: get rid of the ctrl threads
+  * add kernel style .clang-format with 120 chars per line limit
+  * devices: reset internal smart sample buffers upon stop
+  * transceiver: optimize code if optimizations are enabled
+  * transceiver: initialize reorder flag so we don't miscount
+
+  [ Harald Welte ]
+  * PRBS tool sending PRBS sequence to TRX
+  * prbs-tool: Add error simulation capabilities
+  * utils: Ensure content of this directory is included in 'make dist'
+  * prbs-tool: Don't require C99
+  * RPM spec file: Require uhd-firmware for osmo-trx-uhd
+  * osmo-trx.spec.in: Use %config(noreplace) to retain current config file
+  * Fix build on Debian8
+  * [cosmetic] radioInterfaceMulti: More comments
+  * [cosmetic] radioIntefaceMulti: Fix whitespace / indent
+  * ipc: Use OSMO_FD_* instead of deprecated BSC_FD_*
+  * Use osmo_fd_setup() wherever applicable
+  * Use osmo_fd_*_{disable,enable}
+  * README update
+  * manual: Fix typo OsmTRX -> OsmoTRX
+
+  [ Oliver Smith ]
+  * contrib: import RPM spec
+  * contrib: integrate RPM spec
+  * Makefile.am: EXTRA_DIST: debian, contrib/*.spec.in
+  * contrib/jenkins: don't build osmo-gsm-manuals
+  * configure.ac: set -std=gnu11
+
+  [ Vadim Yanitskiy ]
+  * UHDDevice: catch LookupError/IndexError in set{Rx,Tx}Antenna()
+  * debian/control: change maintainer to the Osmocom team / mailing list
+  * proto_trxd: cosmetic: 'if' is not a function, add space
+  * vty: add multi-ARFCN specific warning for chan N > 0
+  * radioDevice: fix set_antennas(): consider MULTI_ARFCN mode
+  * device/lms: fix: 'trx_vty.h' header requires C linkage
+  * device/lms: fix missing semicolon in LMSDevice::assign_band_desc()
+  * device/lms: get rid of 'using namespace std'
+  * device/common/Makefile.am: remove $(LMS_CFLAGS) from AM_CXXFLAGS
+  * main: add --vty-ref-mode, use vty_dump_xml_ref_mode()
+  * device: drop unreasonable LIBOSMO{CTRL,VTY}_{CFLAGS,LIBS}
+  * Transceiver: use size_t and ARRAY_SIZE() in constructor
+  * Transceiver: explicitly init m{Rx,Tx}LowerLoopThread
+  * vty: fix documentation for 'swap-channels (disable|enable)'
+  * vty: fix documentation for 'egprs (disable|enable)'
+  * vty: fix documentation for 'rx-sps (1|4)' and 'tx-sps (1|4)'
+  * vty: cosmetic: use VTY_IPV4_CMD in 'bind-ip' / 'remote-ip'
+  * vty: fix documentation for 'multi-arfcn (disable|enable)'
+  * vty: remove groundless statement about filler type 'dummy'
+  * vty: auto-generate cmd and doc strings for cfg_filler_type_cmd
+  * vty: fix documentation for 'ext-rach (disable|enable)'
+  * main: use logging API to print SIMD info instead of printf()
+  * doc/manuals: generate XML VTY reference at build-time
+  * vty: fix swapped documentation for 'filler type' command
+  * Transceiver: fix integer division in addRadioVector()
+  * Transceiver: use proper factor for amplitude scaling
+  * Add a (hidden) VTY parameter for Rx/Tx freq. shifting
+
+  [ Eric Wild ]
+  * osmo-trx-ipc
+
+  [ Alexander Couzens ]
+  * osmo-trx.spec: move ipc-driver-test into package ipc-test
+
+  [ Sylvain Munaut ]
+  * sigProcLib: fix C/I computation for 8-PSK modulated bursts
+
+ -- Pau Espin Pedrol <pespin@espeweb.net>  Tue, 23 Feb 2021 14:27:15 +0100
+
 osmo-trx (1.2.0) unstable; urgency=medium
 
   [ Pau Espin Pedrol ]

debian/control

@@ -1,7 +1,7 @@
 Source: osmo-trx
 Section: net
 Priority: optional
-Maintainer: Ivan Klyuchnikov <ivan.kluchnikov@fairwaves.ru>
+Maintainer: Osmocom team <openbsc@lists.osmocom.org>
 Build-Depends: debhelper (>= 9),
                autotools-dev,
                autoconf-archive,
@@ -14,7 +14,7 @@ Build-Depends: debhelper (>= 9),
                libtalloc-dev,
                libusrp-dev,
                liblimesuite-dev,
-               libosmocore-dev (>= 1.3.0),
+               libosmocore-dev (>= 1.6.0),
                osmo-gsm-manuals-dev
 Standards-Version: 3.9.6
 Vcs-Browser: http://cgit.osmocom.org/osmo-trx
@@ -30,7 +30,7 @@ Package: osmo-trx-dbg
 Architecture: any
 Section: debug
 Priority: extra
-Depends: osmo-trx-uhd (= ${binary:Version}), osmo-trx-usrp1 (= ${binary:Version}), osmo-trx-lms (= ${binary:Version}), ${misc:Depends}
+Depends: osmo-trx-uhd (= ${binary:Version}), osmo-trx-usrp1 (= ${binary:Version}), osmo-trx-lms (= ${binary:Version}), osmo-trx-ipc (= ${binary:Version}), ${misc:Depends}
 Description: Debug symbols for the osmo-trx-*
  Make debugging possible
 
@@ -91,6 +91,25 @@ Description: SDR transceiver that implements Layer 1 of a GSM BTS (LimeSuite)
  between different telecommunication associations for developing new
  generations of mobile phone networks. (post-2G/GSM)
 
+Package: osmo-trx-ipc
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Description: SDR transceiver that implements Layer 1 of a GSM BTS (generic IPC)
+ OsmoTRX is a software-defined radio transceiver that implements the Layer 1
+ physical layer of a BTS comprising the following 3GPP specifications:
+ .
+ TS 05.01 "Physical layer on the radio path"
+ TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
+ TS 05.04 "Modulation"
+ TS 05.10 "Radio subsystem synchronization"
+ .
+ In this context, BTS is "Base transceiver station". It's the stations that
+ connect mobile phones to the mobile network.
+ .
+ 3GPP is the "3rd Generation Partnership Project" which is the collaboration
+ between different telecommunication associations for developing new
+ generations of mobile phone networks. (post-2G/GSM)
+
 Package: osmo-trx-doc
 Architecture: all
 Section: doc

debian/osmo-trx-ipc.install

@@ -0,0 +1,4 @@
+etc/osmocom/osmo-trx-ipc.cfg
+lib/systemd/system/osmo-trx-ipc.service
+/usr/bin/osmo-trx-ipc
+/usr/share/doc/osmo-trx/examples/osmo-trx-ipc/osmo-trx-ipc.cfg /usr/share/doc/osmo-trx/examples/osmo-trx-ipc/

debian/patches/build-for-debian8.patch

@@ -1,60 +0,0 @@
-diff --git a/debian/control b/debian/control
-index 8ff59f0..126c16a 100644
---- a/debian/control
-+++ b/debian/control
-@@ -13,7 +13,6 @@ Build-Depends: debhelper (>= 9),
-                libfftw3-dev,
-                libtalloc-dev,
-                libusrp-dev,
--               liblimesuite-dev,
-                libosmocore-dev (>= 1.3.0),
-                osmo-gsm-manuals-dev
- Standards-Version: 3.9.6
-@@ -30,7 +29,7 @@ Package: osmo-trx-dbg
- Architecture: any
- Section: debug
- Priority: extra
--Depends: osmo-trx-uhd (= ${binary:Version}), osmo-trx-usrp1 (= ${binary:Version}), osmo-trx-lms (= ${binary:Version}), ${misc:Depends}
-+Depends: osmo-trx-uhd (= ${binary:Version}), osmo-trx-usrp1 (= ${binary:Version}), ${misc:Depends}
- Description: Debug symbols for the osmo-trx-*
-  Make debugging possible
- 
-@@ -72,25 +71,6 @@ Description: SDR transceiver that implements Layer 1 of a GSM BTS (USRP1)
-  between different telecommunication associations for developing new
-  generations of mobile phone networks. (post-2G/GSM)
- 
--Package: osmo-trx-lms
--Architecture: any
--Depends: ${shlibs:Depends}, ${misc:Depends}
--Description: SDR transceiver that implements Layer 1 of a GSM BTS (LimeSuite)
-- OsmoTRX is a software-defined radio transceiver that implements the Layer 1
-- physical layer of a BTS comprising the following 3GPP specifications:
-- .
-- TS 05.01 "Physical layer on the radio path"
-- TS 05.02 "Multiplexing and Multiple Access on the Radio Path"
-- TS 05.04 "Modulation"
-- TS 05.10 "Radio subsystem synchronization"
-- .
-- In this context, BTS is "Base transceiver station". It's the stations that
-- connect mobile phones to the mobile network.
-- .
-- 3GPP is the "3rd Generation Partnership Project" which is the collaboration
-- between different telecommunication associations for developing new
-- generations of mobile phone networks. (post-2G/GSM)
--
- Package: osmo-trx-doc
- Architecture: all
- Section: doc
-diff --git a/debian/rules b/debian/rules
-index 627c0c8..d9285e2 100755
---- a/debian/rules
-+++ b/debian/rules
-@@ -9,7 +9,7 @@ override_dh_shlibdeps:
- 	dh_shlibdeps --dpkg-shlibdeps-params=--ignore-missing-info
- 
- override_dh_auto_configure:
--	dh_auto_configure -- --with-uhd --with-usrp1 --with-lms --with-systemdsystemunitdir=/lib/systemd/system --enable-manuals
-+	dh_auto_configure -- --with-uhd --with-usrp1 --with-systemdsystemunitdir=/lib/systemd/system --enable-manuals
- 
- override_dh_strip:
- 	dh_strip --dbg-package=osmo-trx-dbg

debian/patches/series

@@ -1 +0,0 @@
-# build-for-debian8.patch

debian/rules

@@ -9,7 +9,7 @@ override_dh_shlibdeps:
 	dh_shlibdeps --dpkg-shlibdeps-params=--ignore-missing-info
 
 override_dh_auto_configure:
-	dh_auto_configure -- --with-uhd --with-usrp1 --with-lms --with-systemdsystemunitdir=/lib/systemd/system --enable-manuals
+	dh_auto_configure -- --with-uhd --with-usrp1 --with-lms --with-ipc --with-systemdsystemunitdir=/lib/systemd/system --enable-manuals
 
 override_dh_strip:
 	dh_strip --dbg-package=osmo-trx-dbg

doc/examples/Makefile.am

@@ -14,6 +14,10 @@ if DEVICE_LMS
 OSMOCONF_FILES += osmo-trx-lms/osmo-trx-lms.cfg
 endif
 
+if DEVICE_IPC
+OSMOCONF_FILES += osmo-trx-ipc/osmo-trx-ipc.cfg
+endif
+
 osmoconf_DATA = $(OSMOCONF_FILES)
 EXTRA_DIST = $(OSMOCONF_FILES)
 

doc/examples/osmo-trx-ipc/osmo-trx-ipc.cfg

@@ -0,0 +1,32 @@
+log stderr
+ logging filter all 1
+ logging color 1
+ logging print category 1
+ logging timestamp 1
+ logging print file basename
+ logging level set-all notice
+!
+line vty
+ no login
+!
+cpu-sched
+ policy rr 18
+trx
+ bind-ip 127.0.0.1
+ remote-ip 127.0.0.1
+ ! 28 dB offset below is valid only for the B2xx in 1800 MHz band, see
+ ! https://osmocom.org/issues/4468 for more details
+ rssi-offset 28.000000
+ tx-sps 4
+ rx-sps 4
+ clock-ref external
+ egprs disable
+ ext-rach disable
+ dev-args ipc_msock=/tmp/ipc_sock0
+ multi-arfcn disable
+ chan 0
+  tx-path TX/RX
+  rx-path RX2
+ chan 1
+  tx-path TX/RX
+  rx-path RX2

doc/examples/osmo-trx-lms/osmo-trx-limesdr.cfg

@@ -4,18 +4,19 @@ log stderr
  logging print category 1
  logging timestamp 1
  logging print file basename
- logging level set-all info
+ logging level set-all notice
 !
 line vty
  no login
 !
+cpu-sched
+ policy rr 18
 trx
  bind-ip 127.0.0.1
  remote-ip 127.0.0.1
  egprs disable
  tx-sps 4
  rx-sps 4
- rt-prio 18
  chan 0
   tx-path BAND1
   rx-path LNAW

doc/examples/osmo-trx-uhd/osmo-trx-limesdr.cfg

@@ -4,18 +4,19 @@ log stderr
  logging print category 1
  logging timestamp 1
  logging print file basename
- logging level set-all info
+ logging level set-all notice
 !
 line vty
  no login
 !
+cpu-sched
+ policy rr 18
 trx
  bind-ip 127.0.0.1
  remote-ip 127.0.0.1
  egprs disable
  tx-sps 4
  rx-sps 4
- rt-prio 18
  chan 0
   tx-path BAND1
   rx-path LNAW

doc/examples/osmo-trx-uhd/osmo-trx-umtrx.cfg

@@ -4,11 +4,13 @@ log stderr
  logging print category 1
  logging timestamp 1
  logging print file basename
- logging level set-all info
+ logging level set-all notice
 !
 line vty
  no login
 !
+cpu-sched
+ policy rr 18
 trx
  bind-ip 127.0.0.1
  remote-ip 127.0.0.1
@@ -17,6 +19,5 @@ trx
  tx-sps 4
  rx-sps 4
  rssi-offset 38
- rt-prio 18
  chan 0
  chan 1

doc/examples/osmo-trx-uhd/osmo-trx-usrp_b200.cfg

@@ -4,21 +4,18 @@ log stderr
  logging print category 1
  logging timestamp 1
  logging print file basename
- logging level set-all info
+ logging level set-all notice
 !
 line vty
  no login
 !
+cpu-sched
+ policy rr 18
 trx
  bind-ip 127.0.0.1
  remote-ip 127.0.0.1
  egprs disable
- ! 28 dB offset below is valid only for the B2xx in 1800 MHz band, see
- ! https://osmocom.org/issues/4468 for more details
- rssi-offset 28.000000
  tx-sps 4
  rx-sps 4
  clock-ref external
- rt-prio 18
  chan 0
-

doc/manuals/Makefile.am

@@ -1,6 +1,5 @@
 EXTRA_DIST = osmotrx-usermanual.adoc \
     osmotrx-usermanual-docinfo.xml \
-    osmotrx-vty-reference.xml \
     chapters \
     vty
 
@@ -9,8 +8,24 @@ if BUILD_MANUALS
   ASCIIDOC_DEPS = $(srcdir)/chapters/*.adoc
   include $(OSMO_GSM_MANUALS_DIR)/build/Makefile.asciidoc.inc
 
-  VTY_REFERENCE = osmotrx-vty-reference.xml
-  include $(OSMO_GSM_MANUALS_DIR)/build/Makefile.vty-reference.inc
+  VARIANTS = $(NULL)
+
+if DEVICE_UHD
+  VARIANTS += uhd
+endif
+if DEVICE_USRP1
+  VARIANTS += usrp1
+endif
+if DEVICE_LMS
+  VARIANTS += lms
+endif
+if DEVICE_IPC
+  VARIANTS += ipc
+endif
+
+  # This is a significantly modified, multi-target adopted copy of
+  # $(OSMO_GSM_MANUALS_DIR)/build/Makefile.vty-reference.inc
+  include $(srcdir)/vty/Makefile.vty-reference.inc
 
   OSMO_REPOSITORY = osmo-trx
   include $(OSMO_GSM_MANUALS_DIR)/build/Makefile.common.inc

doc/manuals/chapters/code-architecture.adoc

@@ -39,8 +39,7 @@ trans [label="Transceiver"];
 radioiface [label="RadioInterface"];
 radiodev [label="RadioDevice"];
 
-trans:nw->trans:ne [label="Trx.ControlServiceLoop_0"];
-trans:nw->trans:ne [label="Trx.ControlServiceLoop_1"];
+trans:nw->trans:ne [label="Main"];
 trans:w->radioiface:w [label="Trx.TxPriorityQueueServiceLoop_0"];
 trans:w->radioiface:w [label="Trx.TxPriorityQueueServiceLoop_1"];
 radioiface:e->trans:e [label="Trx.RxServiceLoop_0"];
@@ -92,14 +91,6 @@ Static amount of Threads (1 per `Transceiver` instance):
 
 Dynamic amount of Threads (1 per RF logical channel on the `Transceiver` instance):
 
-* `ControlServiceLoop`: Handles commands from the Per-ARFCN Control Interface
-  socket (<<trx_if_control>>). Each thread is responsible for managing one
-  socket related to one ARFCN or which is the same, to one RF logical channel.
-  These are the only threads expected to use the private `start()` and `stop()`
-  methods of the `Transceiver()` class, since those methods don't stop any of
-  the `ControlServiceLoop` threads as they must keep running to handle new
-  commands (for instance, to re-start processing samples with the _POWERON_
-  command).
 * `RxServiceLoop`: Each thread of this type pulls bursts from the
   `RadioInterface` FIFO for one specific logical RF channel and handles it
   according to the slot and burst correlation type, finally sending proper data
@@ -108,6 +99,10 @@ Dynamic amount of Threads (1 per RF logical channel on the `Transceiver` instanc
   Manager UDP socket (<<trx_if>>), and fills the `RadioInterface` with it
   setting clock related information.
 
+All the Per-ARFCN Control Interface socket (<<trx_if_control>>) commands are
+handled by the event loop runnnig on the main thread. This is the only thread
+expected to use the private `start()` and `stop()` methods.
+
 [[code_component_radioiface]]
 === RadioInterface
 

doc/manuals/chapters/configuration.adoc

@@ -1,4 +1,4 @@
-== Configuring OsmTRX
+== Configuring OsmoTRX
 
 OsmoTRX will read the configuration at startup time and configure the
 transceiver accordingly after validating the configuration.