Bump version: 0.2.0 → 0.3.0

Change-Id: I4dad76ed95dc585acfbd52d7eed4f2e6f9f5fd1f

.gitignore

@@ -2,9 +2,7 @@
 *.o
 *.lo
 *.la
-Transceiver52M/osmo-trx-uhd
-Transceiver52M/osmo-trx-usrp1
-Transceiver52M/osmo-trx-lms
+Transceiver52M/osmo-trx
 
 # tests
 tests/CommonLibs/BitVectorTest
@@ -18,7 +16,6 @@ tests/CommonLibs/URLEncodeTest
 tests/CommonLibs/VectorTest
 tests/CommonLibs/PRBSTest
 tests/Transceiver52M/convolve_test
-tests/Transceiver52M/LMSDeviceTest
 
 # automake/autoconf
 *.in
@@ -52,14 +49,3 @@ tests/testsuite.log
 
 # vim
 *.sw?
-
-# manuals
-doc/manuals/*.html
-doc/manuals/*.svg
-doc/manuals/*.pdf
-doc/manuals/*__*.png
-doc/manuals/*.check
-doc/manuals/generated/
-doc/manuals/osmomsc-usermanual.xml
-doc/manuals/common
-doc/manuals/build

AUTHORS

@@ -0,0 +1,127 @@
+#
+# Copyright 2008, 2009 Free Software Foundation, Inc.
+#
+# This file is part of GNU Radio
+#
+# GNU Radio is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3, or (at your option)
+# any later version.
+#
+# GNU Radio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+#
+
+David A. Burgess, dburgess@kestrelsp.com:
+    CLI/CLI.cpp
+    CLI/CLI.h
+    CommonLibs/Assert.h
+    CommonLibs/BitVector.cpp
+    CommonLibs/Interthread.h
+    CommonLibs/LinkedLists.cpp
+    CommonLibs/LinkedLists.h
+    CommonLibs/Regexp.h
+    CommonLibs/Sockets.cpp
+    CommonLibs/Sockets.h
+    CommonLibs/Threads.cpp
+    CommonLibs/Threads.h
+    CommonLibs/Timeval.cpp
+    CommonLibs/Timeval.h
+    CommonLibs/Vector.h
+    GSM/GSM610Tables.cpp
+    GSM/GSM610Tables.h
+    GSM/GSMCommon.cpp
+    GSM/GSMCommon.h
+    GSM/GSMConfig.h
+    GSM/GSML1FEC.cpp
+    GSM/GSML1FEC.h
+    GSM/GSML2LAPDm.cpp
+    GSM/GSML2LAPDm.h
+    GSM/GSML3CCElements.cpp
+    GSM/GSML3CCElements.h
+    GSM/GSML3CCMessages.cpp
+    GSM/GSML3CCMessages.h
+    GSM/GSML3CommonElements.cpp
+    GSM/GSML3CommonElements.h
+    GSM/GSML3MMElements.cpp
+    GSM/GSML3MMElements.h
+    GSM/GSML3MMMessages.cpp
+    GSM/GSML3MMMessages.h
+    GSM/GSML3Message.cpp
+    GSM/GSML3Message.h
+    GSM/GSML3RRElements.cpp
+    GSM/GSML3RRElements.h
+    GSM/GSML3RRMessages.cpp
+    GSM/GSML3RRMessages.h
+    GSM/GSMLogicalChannel.h
+    GSM/GSMTDMA.cpp
+    GSM/GSMTDMA.h
+    GSM/GSMTransfer.cpp
+    GSM/GSMTransfer.h
+    LICENSEBLOCK
+    TRXManager/TRXManager.cpp
+    Transceiver/Complex.h
+    tests/CommonLibs/BitVectorTest.cpp
+    tests/CommonLibs/InterthreadTest.cpp
+    tests/CommonLibs/SocketsTest.cpp
+    tests/CommonLibs/TimevalTest.cpp
+    tests/CommonLibs/VectorTest.cpp
+
+Harvind S. Samra, hssamra@kestrelsp.com:
+    GSM/GSMConfig.h
+    GSM/GSMTransfer.h
+    LICENSEBLOCK
+    Transceiver/ComplexTest.cpp
+    Transceiver/Transceiver.cpp
+    Transceiver/Transceiver.h
+    Transceiver/USRPDevice.cpp
+    Transceiver/USRPDevice.h
+    Transceiver/USRPping.cpp
+    Transceiver/radioInterface.cpp
+    Transceiver/radioInterface.h
+    Transceiver/rcvLPF_651.h
+    Transceiver/runTransceiver.cpp
+    Transceiver/sendLPF_961.h
+    Transceiver/sigProcLib.cpp
+    Transceiver/sigProcLib.h
+    Transceiver/sigProcLibTest.cpp
+    Transceiver/sweepGenerator.cpp
+    Transceiver/testRadio.cpp
+
+Raffi Sevlian, raffisev@gmail.com:
+    GSM/GSMCommon.h
+    GSM/GSMConfig.h
+    GSM/GSML1FEC.h
+    GSM/GSML3CCElements.cpp
+    GSM/GSML3CCElements.h
+    GSM/GSML3CCMessages.cpp
+    GSM/GSML3CCMessages.h
+    GSM/GSML3CommonElements.cpp
+    GSM/GSML3CommonElements.h
+    GSM/GSML3MMElements.cpp
+    GSM/GSML3MMElements.h
+    GSM/GSML3MMMessages.cpp
+    GSM/GSML3MMMessages.h
+    GSM/GSML3Message.cpp
+    GSM/GSML3Message.h
+    GSM/GSML3RRElements.cpp
+    GSM/GSML3RRElements.h
+    GSM/GSML3RRMessages.cpp
+    GSM/GSML3RRMessages.h
+    GSM/GSMLogicalChannel.h
+    GSM/GSMSAPMux.cpp
+    GSM/GSMSAPMux.h
+    GSM/GSMTransfer.h
+    LICENSEBLOCK
+    TRXManager/TRXManager.h
+
+Alon Levy, alonlevy1@gmail.com
+    RRLPMessages.cpp
+    RRLPMessages.h
+    RRLPTest.cpp

CommonLibs/BitVector.cpp

@@ -1,7 +1,6 @@
 /*
 * Copyright 2008, 2009 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
 *
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.

CommonLibs/BitVector.h

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008, 2009 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *

CommonLibs/Interthread.h

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008, 2011 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *

CommonLibs/LinkedLists.cpp

@@ -1,7 +1,6 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
 *
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
@@ -30,25 +29,6 @@
 #include "LinkedLists.h"
 
 
-PointerFIFO::~PointerFIFO()
-{
-	ListNode *node, *next;
-
-	node = mHead;
-	while (node != NULL) {
-		next = node->next();
-		delete node;
-		node = next;
-	}
-
-	node = mFreeList;
-	while (node != NULL) {
-		next = node->next();
-		delete node;
-		node = next;
-	}
-}
-
 void PointerFIFO::push_front(void* val)	// by pat
 {
 	// Pat added this routine for completeness, but never used or tested.

CommonLibs/LinkedLists.h

@@ -1,10 +1,7 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* 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 distribuion.
+* This software is distributed under multiple licenses; see the COPYING file in the main directory for licensing information for this specific distribuion.
 *
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
@@ -73,7 +70,6 @@ class PointerFIFO {
 		:mHead(NULL),mTail(NULL),mFreeList(NULL),
 		mSize(0)
 	{}
-	~PointerFIFO();
 
 	unsigned size() const { return mSize; }
 	unsigned totalSize() const { return 0; }	// Not used in this version.

CommonLibs/Logger.cpp

@@ -1,7 +1,8 @@
 /*
-* Copyright (C) 2018 sysmocom - s.f.m.c. GmbH
+* Copyright 2009, 2010 Free Software Foundation, Inc.
+* Copyright 2010 Kestrel Signal Processing, Inc.
+* Copyright 2011, 2012 Range Networks, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
 *
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
@@ -36,6 +37,57 @@
 
 using namespace std;
 
+Mutex gLogToLock;
+
+// Global log level threshold:
+int config_log_level;
+
+/** Names of the logging levels. */
+const char *levelNames[] = {
+	"EMERG", "ALERT", "CRIT", "ERR", "WARNING", "NOTICE", "INFO", "DEBUG"
+};
+int numLevels = 8;
+
+
+int levelStringToInt(const string& name)
+{
+	// Reverse search, since the numerically larger levels are more common.
+	for (int i=numLevels-1; i>=0; i--) {
+		if (name == levelNames[i]) return i;
+	}
+
+	// Common substitutions.
+	if (name=="INFORMATION") return 6;
+	if (name=="WARN") return 4;
+	if (name=="ERROR") return 3;
+	if (name=="CRITICAL") return 2;
+	if (name=="EMERGENCY") return 0;
+
+	// Unknown level.
+	return -1;
+}
+
+static std::string format(const char *fmt, ...)
+{
+	va_list ap;
+	char buf[300];
+	va_start(ap,fmt);
+	int n = vsnprintf(buf,300,fmt,ap);
+	va_end(ap);
+	if (n >= (300-4)) { strcpy(&buf[(300-4)],"..."); }
+	return std::string(buf);
+}
+
+const std::string timestr()
+{
+	struct timeval tv;
+	struct tm tm;
+	gettimeofday(&tv,NULL);
+	localtime_r(&tv.tv_sec,&tm);
+	unsigned tenths = tv.tv_usec / 100000;	// Rounding down is ok.
+	return format(" %02d:%02d:%02d.%1d",tm.tm_hour,tm.tm_min,tm.tm_sec,tenths);
+}
+
 std::ostream& operator<<(std::ostream& os, std::ostringstream& ss)
 {
 	return os << ss.str();
@@ -43,19 +95,34 @@ std::ostream& operator<<(std::ostream& os, std::ostringstream& ss)
 
 Log::~Log()
 {
-	int old_state;
+	// Anything at or above LOG_CRIT is an "alarm".
+	if (mPriority <= LOG_ERR) {
+		cerr << mStream.str() << endl;
+	}
+
 	int mlen = mStream.str().size();
 	int neednl = (mlen==0 || mStream.str()[mlen-1] != '\n');
-	const char *fmt = neednl ? "%s\n" : "%s";
-
-	log_mutex_lock_canceldisable(&old_state);
-	LOGPSRC(mCategory, mPriority, filename, line, fmt, mStream.str().c_str());
-	log_mutex_unlock_canceldisable(old_state);
+	ScopedLock lock(gLogToLock);
+	// The COUT() macro prevents messages from stomping each other but adds uninteresting thread numbers,
+	// so just use std::cout.
+	std::cout << mStream.str();
+	if (neednl) std::cout<<"\n";
 }
 
 ostringstream& Log::get()
 {
+	assert(mPriority<numLevels);
+	mStream << levelNames[mPriority] <<  ' ';
 	return mStream;
 }
 
+
+
+void gLogInit(const char* level, char *fn)
+{
+	// Set the level if one has been specified.
+	if (level)
+		config_log_level = levelStringToInt(level);
+}
+
 // vim: ts=4 sw=4

CommonLibs/Logger.h

@@ -2,8 +2,6 @@
 * Copyright 2009, 2010 Free Software Foundation, Inc.
 * Copyright 2010 Kestrel Signal Processing, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -25,6 +23,12 @@
 
 */
 
+// (pat) WARNING is stupidly defined in /usr/local/include/osipparser2/osip_const.h.
+// This must be outside the #ifndef LOGGER_H to fix it as long as Logger.h included after the above file.
+#ifdef WARNING
+#undef WARNING
+#endif
+
 #ifndef LOGGER_H
 #define LOGGER_H
 
@@ -33,33 +37,30 @@
 #include <sstream>
 #include <string>
 
-extern "C" {
-#include <osmocom/core/logging.h>
-#include "debug.h"
-}
+extern int config_log_level;
 
-/* Translation for old log statements */
-#ifndef LOGL_ALERT
-#define LOGL_ALERT LOGL_FATAL
+#define LOG_EMERG       0       /* system is unusable */
+#define LOG_ALERT       1       /* action must be taken immediately */
+#define LOG_CRIT        2       /* critical conditions */
+#define LOG_ERR         3       /* error conditions */
+#define LOG_WARNING     4       /* warning conditions */
+#define LOG_NOTICE      5       /* normal but significant condition */
+#define LOG_INFO        6       /* informational */
+#define LOG_DEBUG       7       /* debug-level messages */
+
+#define _LOG(level) \
+	Log(LOG_##level).get() << pthread_self() \
+	<< timestr() << " " __FILE__  ":"  << __LINE__ << ":" << __FUNCTION__ << ": "
+
+#define IS_LOG_LEVEL(wLevel) (config_log_level>=LOG_##wLevel)
+
+#ifdef NDEBUG
+#define LOG(wLevel) \
+	if (LOG_##wLevel!=LOG_DEBUG && IS_LOG_LEVEL(wLevel)) _LOG(wLevel)
+#else
+#define LOG(wLevel) \
+	if (IS_LOG_LEVEL(wLevel)) _LOG(wLevel)
 #endif
-#ifndef LOGL_ERR
-#define LOGL_ERR LOGL_ERROR
-#endif
-#ifndef LOGL_WARNING
-#define LOGL_WARNING LOGL_NOTICE
-#endif
-
-#define LOG(level) \
-	Log(DMAIN, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[tid=" << pthread_self() << "] "
-
-#define LOGC(category, level) \
-	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[tid=" << pthread_self() << "] "
-
-#define LOGLV(category, level) \
-	Log(category, level, __BASE_FILE__, __LINE__).get() <<  "[tid=" << pthread_self() << "] "
-
-#define LOGCHAN(chan, category, level) \
-	Log(category, LOGL_##level, __BASE_FILE__, __LINE__).get() <<  "[tid=" << pthread_self() << "][chan=" << chan << "] "
 
 /**
 	A C++ stream-based thread-safe logger.
@@ -73,16 +74,12 @@ class Log {
 	protected:
 
 	std::ostringstream mStream;		///< This is where we buffer up the log entry.
-	int mCategory;			///< Priority of current report.
-	int mPriority;			///< Category of current report.
-	const char *filename;		///< Source File Name of current report.
-	int line;			///< Line number in source file of current report.
+	int mPriority;					///< Priority of current report.
 
 	public:
 
-	Log(int wCategory, int wPriority, const char* filename, int line)
-		: mCategory(wCategory), mPriority(wPriority),
-		  filename(filename), line(line)
+	Log(int wPriority)
+		:mPriority(wPriority)
 	{ }
 
 	// Most of the work is in the destructor.
@@ -92,8 +89,16 @@ class Log {
 	std::ostringstream& get();
 };
 
+const std::string timestr();		// A timestamp to print in messages.
 std::ostream& operator<<(std::ostream& os, std::ostringstream& ss);
 
+/**@ Global control and initialization of the logging system. */
+//@{
+/** Initialize the global logging system. */
+void gLogInit(const char* level=NULL, char* fn=NULL);
+//@}
+
+
 #endif
 
 // vim: ts=4 sw=4

CommonLibs/Makefile.am

@@ -22,35 +22,29 @@
 include $(top_srcdir)/Makefile.common
 
 AM_CPPFLAGS = $(STD_DEFINES_AND_INCLUDES)
-AM_CXXFLAGS = -Wall -O3 -g -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
-AM_CFLAGS = $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
+AM_CXXFLAGS = -Wall -O3 -g -lpthread
+
+EXTRA_DIST = \
+	example.config \
+	README.common
 
 noinst_LTLIBRARIES = libcommon.la
 
 libcommon_la_SOURCES = \
 	BitVector.cpp \
 	LinkedLists.cpp \
+	Sockets.cpp \
 	Threads.cpp \
 	Timeval.cpp \
-	Logger.cpp \
-	Utils.cpp \
-	trx_rate_ctr.cpp \
-	trx_vty.c \
-	debug.c
-libcommon_la_LIBADD = $(LIBOSMOCORE_LIBS) $(LIBOSMOCTRL_LIBS) $(LIBOSMOVTY_LIBS)
+	Logger.cpp
 
 noinst_HEADERS = \
 	BitVector.h \
 	PRBS.h \
 	Interthread.h \
 	LinkedLists.h \
+	Sockets.h \
 	Threads.h \
 	Timeval.h \
 	Vector.h \
-	Logger.h \
-	Utils.h \
-	trx_rate_ctr.h \
-	trx_vty.h \
-	debug.h \
-	osmo_signal.h \
-	config_defs.h
+	Logger.h

CommonLibs/PRBS.h

@@ -1,8 +1,6 @@
 /*
  * Copyright (C) 2017 Alexander Chemeris <Alexander.Chemeris@fairwaves.co>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either

CommonLibs/Sockets.cpp

@@ -0,0 +1,287 @@
+/*
+* Copyright 2008, 2010 Free Software Foundation, Inc.
+*
+*
+* This software is distributed under the terms of the GNU Affero Public License.
+* See the COPYING file in the main directory for details.
+*
+* This use of this software may be subject to additional restrictions.
+* See the LEGAL file in the main directory for details.
+
+	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/>.
+
+*/
+
+
+
+#include <config.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <cstdio>
+#include <sys/select.h>
+
+#include "Threads.h"
+#include "Sockets.h"
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <string.h>
+#include <stdlib.h>
+
+
+
+
+
+
+bool resolveAddress(struct sockaddr_in *address, const char *hostAndPort)
+{
+	assert(address);
+	assert(hostAndPort);
+	char *copy = strdup(hostAndPort);
+	char *colon = strchr(copy,':');
+	if (!colon) return false;
+	*colon = '\0';
+	char *host = copy;
+	unsigned port = strtol(colon+1,NULL,10);
+	bool retVal = resolveAddress(address,host,port);
+	free(copy);
+	return retVal;
+}
+
+bool resolveAddress(struct sockaddr_in *address, const char *host, unsigned short port)
+{
+	assert(address);
+	assert(host);
+	// FIXME -- Need to ignore leading/trailing spaces in hostname.
+	struct hostent *hp;
+	int h_errno_local;
+#ifdef HAVE_GETHOSTBYNAME2_R
+	struct hostent hostData;
+	char tmpBuffer[2048];
+
+	// There are different flavors of gethostbyname_r(), but
+	// latest Linux use the following form:
+	if (gethostbyname2_r(host, AF_INET, &hostData, tmpBuffer, sizeof(tmpBuffer), &hp, &h_errno_local)!=0) {
+		CERR("WARNING -- gethostbyname2_r() failed for " << host << ", " << hstrerror(h_errno_local));
+		return false;
+	}
+#else
+	static Mutex sGethostbynameMutex;
+	// gethostbyname() is NOT thread-safe, so we should use a mutex here.
+	// Ideally it should be a global mutex for all non thread-safe socket
+	// operations and it should protect access to variables such as
+	// global h_errno.
+	sGethostbynameMutex.lock();
+	hp = gethostbyname(host);
+	h_errno_local = h_errno;
+	sGethostbynameMutex.unlock();
+#endif
+ 	if (hp==NULL) {
+		CERR("WARNING -- gethostbyname() failed for " << host << ", " << hstrerror(h_errno_local));
+		return false;
+	}
+	if (hp->h_addrtype != AF_INET) {
+		CERR("WARNING -- gethostbyname() resolved " << host << " to something other then AF_INET");
+ 		return false;
+ 	}
+	address->sin_family = hp->h_addrtype;
+	assert(sizeof(address->sin_addr) == hp->h_length);
+	memcpy(&(address->sin_addr), hp->h_addr_list[0], hp->h_length);
+	address->sin_port = htons(port);
+	return true;
+}
+
+
+
+DatagramSocket::DatagramSocket()
+{
+	memset(mDestination, 0, sizeof(mDestination));
+}
+
+
+
+
+
+void DatagramSocket::nonblocking()
+{
+	fcntl(mSocketFD,F_SETFL,O_NONBLOCK);
+}
+
+void DatagramSocket::blocking()
+{
+	fcntl(mSocketFD,F_SETFL,0);
+}
+
+void DatagramSocket::close()
+{
+	::close(mSocketFD);
+}
+
+
+DatagramSocket::~DatagramSocket()
+{
+	close();
+}
+
+
+
+
+
+int DatagramSocket::write( const char * message, size_t length )
+{
+	assert(length<=MAX_UDP_LENGTH);
+	int retVal = sendto(mSocketFD, message, length, 0,
+		(struct sockaddr *)mDestination, addressSize());
+	if (retVal == -1 ) perror("DatagramSocket::write() failed");
+	return retVal;
+}
+
+int DatagramSocket::writeBack( const char * message, size_t length )
+{
+	assert(length<=MAX_UDP_LENGTH);
+	int retVal = sendto(mSocketFD, message, length, 0,
+		(struct sockaddr *)mSource, addressSize());
+	if (retVal == -1 ) perror("DatagramSocket::write() failed");
+	return retVal;
+}
+
+
+
+int DatagramSocket::write( const char * message)
+{
+	size_t length=strlen(message)+1;
+	return write(message,length);
+}
+
+int DatagramSocket::writeBack( const char * message)
+{
+	size_t length=strlen(message)+1;
+	return writeBack(message,length);
+}
+
+
+
+int DatagramSocket::send(const struct sockaddr* dest, const char * message, size_t length )
+{
+	assert(length<=MAX_UDP_LENGTH);
+	int retVal = sendto(mSocketFD, message, length, 0, dest, addressSize());
+	if (retVal == -1 ) perror("DatagramSocket::send() failed");
+	return retVal;
+}
+
+int DatagramSocket::send(const struct sockaddr* dest, const char * message)
+{
+	size_t length=strlen(message)+1;
+	return send(dest,message,length);
+}
+
+int DatagramSocket::read(char* buffer, size_t length)
+{
+	socklen_t addr_len = sizeof(mSource);
+	int rd_length = recvfrom(mSocketFD, (void *) buffer, length, 0,
+		(struct sockaddr*) &mSource, &addr_len);
+
+	if ((rd_length==-1) && (errno!=EAGAIN)) {
+		perror("DatagramSocket::read() failed");
+		throw SocketError();
+	}
+	return rd_length;
+}
+
+int DatagramSocket::read(char* buffer, size_t length, unsigned timeout)
+{
+	fd_set fds;
+	FD_ZERO(&fds);
+	FD_SET(mSocketFD,&fds);
+	struct timeval tv;
+	tv.tv_sec = timeout/1000;
+	tv.tv_usec = (timeout%1000)*1000;
+	int sel = select(mSocketFD+1,&fds,NULL,NULL,&tv);
+	if (sel<0) {
+		perror("DatagramSocket::read() select() failed");
+		throw SocketError();
+	}
+	if (sel==0) return -1;
+	if (FD_ISSET(mSocketFD,&fds)) return read(buffer, length);
+	return -1;
+}
+
+
+
+
+
+
+UDPSocket::UDPSocket(const char *wSrcIP, unsigned short wSrcPort)
+	:DatagramSocket()
+{
+	open(wSrcPort, wSrcIP);
+}
+
+
+UDPSocket::UDPSocket(const char *wSrcIP, unsigned short wSrcPort,
+		     const char *wDestIP, unsigned short wDestPort)
+	:DatagramSocket()
+{
+	open(wSrcPort, wSrcIP);
+	destination(wDestPort, wDestIP);
+}
+
+
+
+void UDPSocket::destination( unsigned short wDestPort, const char * wDestIP )
+{
+	resolveAddress((sockaddr_in*)mDestination, wDestIP, wDestPort );
+}
+
+
+void UDPSocket::open(unsigned short localPort, const char *wlocalIP)
+{
+	// create
+	mSocketFD = socket(AF_INET,SOCK_DGRAM,0);
+	if (mSocketFD<0) {
+		perror("socket() failed");
+		throw SocketError();
+	}
+
+	// pat added: This lets the socket be reused immediately, which is needed if OpenBTS crashes.
+	int on = 1;
+	setsockopt(mSocketFD, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
+
+
+	// bind
+	struct sockaddr_in address;
+	size_t length = sizeof(address);
+	bzero(&address,length);
+	address.sin_family = AF_INET;
+	address.sin_addr.s_addr = inet_addr(wlocalIP);
+	address.sin_port = htons(localPort);
+	if (bind(mSocketFD,(struct sockaddr*)&address,length)<0) {
+		perror("bind() failed");
+		throw SocketError();
+	}
+}
+
+
+
+unsigned short UDPSocket::port() const
+{
+	struct sockaddr_in name;
+	socklen_t nameSize = sizeof(name);
+	int retVal = getsockname(mSocketFD, (struct sockaddr*)&name, &nameSize);
+	if (retVal==-1) throw SocketError();
+	return ntohs(name.sin_port);
+}
+
+// vim:ts=4:sw=4

CommonLibs/Sockets.h

@@ -0,0 +1,173 @@
+/*
+* Copyright 2008, 2010 Free Software Foundation, Inc.
+*
+* This software is distributed under the terms of the GNU Affero Public License.
+* See the COPYING file in the main directory for details.
+*
+* This use of this software may be subject to additional restrictions.
+* See the LEGAL file in the main directory for details.
+
+	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/>.
+
+*/
+
+
+#ifndef SOCKETS_H
+#define SOCKETS_H
+
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <errno.h>
+#include <list>
+#include <assert.h>
+#include <stdint.h>
+#include <stdio.h>
+
+
+
+
+
+#define MAX_UDP_LENGTH 1500
+
+/** A function to resolve IP host names. */
+bool resolveAddress(struct sockaddr_in *address, const char *host, unsigned short port);
+
+/** Resolve an address of the form "<host>:<port>". */
+bool resolveAddress(struct sockaddr_in *address, const char *hostAndPort);
+
+/** An exception to throw when a critical socket operation fails. */
+class SocketError {};
+#define SOCKET_ERROR {throw SocketError(); }
+
+/** Abstract class for connectionless sockets. */
+class DatagramSocket {
+
+protected:
+
+	int mSocketFD;				///< underlying file descriptor
+	char mDestination[256];		///< address to which packets are sent
+	char mSource[256];		///< return address of most recent received packet
+
+public:
+
+	/** An almost-does-nothing constructor. */
+	DatagramSocket();
+
+	virtual ~DatagramSocket();
+
+	/** Return the address structure size for this socket type. */
+	virtual size_t addressSize() const = 0;
+
+	/**
+		Send a binary packet.
+		@param buffer The data bytes to send to mDestination.
+		@param length Number of bytes to send, or strlen(buffer) if defaulted to -1.
+		@return number of bytes written, or -1 on error.
+	*/
+	int write( const char * buffer, size_t length);
+
+	/**
+		Send a C-style string packet.
+		@param buffer The data bytes to send to mDestination.
+		@return number of bytes written, or -1 on error.
+	*/
+	int write( const char * buffer);
+
+	/**
+		Send a binary packet.
+		@param buffer The data bytes to send to mSource.
+		@param length Number of bytes to send, or strlen(buffer) if defaulted to -1.
+		@return number of bytes written, or -1 on error.
+	*/
+	int writeBack(const char * buffer, size_t length);
+
+	/**
+		Send a C-style string packet.
+		@param buffer The data bytes to send to mSource.
+		@return number of bytes written, or -1 on error.
+	*/
+	int writeBack(const char * buffer);
+
+
+	/**
+		Receive a packet.
+		@param buffer A char[MAX_UDP_LENGTH] procured by the caller.
+		@return The number of bytes received or -1 on non-blocking pass.
+	*/
+	int read(char* buffer, size_t length);
+
+	/**
+		Receive a packet with a timeout.
+		@param buffer A char[MAX_UDP_LENGTH] procured by the caller.
+		@param maximum wait time in milliseconds
+		@return The number of bytes received or -1 on timeout.
+	*/
+	int read(char* buffer, size_t length, unsigned timeout);
+
+
+	/** Send a packet to a given destination, other than the default. */
+	int send(const struct sockaddr *dest, const char * buffer, size_t length);
+
+	/** Send a C-style string to a given destination, other than the default. */
+	int send(const struct sockaddr *dest, const char * buffer);
+
+	/** Make the socket non-blocking. */
+	void nonblocking();
+
+	/** Make the socket blocking (the default). */
+	void blocking();
+
+	/** Close the socket. */
+	void close();
+
+};
+
+
+
+/** UDP/IP User Datagram Socket */
+class UDPSocket : public DatagramSocket {
+
+public:
+
+	/** Open a USP socket with an OS-assigned port and no default destination. */
+	UDPSocket(const char *localIP, unsigned short localPort);
+
+	/** Given a full specification, open the socket and set the dest address. */
+	UDPSocket(const char *localIP, unsigned short localPort,
+		  const char *remoteIP, unsigned short remotePort);
+
+	/** Set the destination port. */
+	void destination( unsigned short wDestPort, const char * wDestIP );
+
+	/** Return the actual port number in use. */
+	unsigned short port() const;
+
+	/** Open and bind the UDP socket to a local port. */
+	void open(unsigned short localPort=0, const char *wlocalIP="127.0.0.1");
+
+	/** Give the return address of the most recently received packet. */
+	const struct sockaddr_in* source() const { return (const struct sockaddr_in*)mSource; }
+
+	size_t addressSize() const { return sizeof(struct sockaddr_in); }
+
+};
+
+#endif
+
+
+
+// vim:ts=4:sw=4

CommonLibs/Threads.cpp

@@ -1,7 +1,6 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
 *
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
@@ -25,17 +24,11 @@
 */
 
 
-#include <string.h>
-#include <sys/types.h>
+
+
 
 #include "Threads.h"
 #include "Timeval.h"
-#include "Logger.h"
-
-#ifndef gettid
-#include <sys/syscall.h>
-#define gettid() syscall(SYS_gettid)
-#endif
 
 
 using namespace std;
@@ -109,25 +102,6 @@ void Signal::wait(Mutex& wMutex, unsigned timeout) const
 	pthread_cond_timedwait(&mSignal,&wMutex.mMutex,&waitTime);
 }
 
-void set_selfthread_name(const char *name)
-{
-	pthread_t selfid = pthread_self();
-	pid_t tid = gettid();
-	if (pthread_setname_np(selfid, name) == 0) {
-		LOG(INFO) << "Thread "<< selfid << " (task " << tid << ") set name: " << name;
-	} else {
-		char buf[256];
-		int err = errno;
-		char* err_str = strerror_r(err, buf, sizeof(buf));
-		LOG(NOTICE) << "Thread "<< selfid << " (task " << tid << ") set name \"" << name << "\" failed: (" << err << ") " << err_str;
-	}
-}
-
-void thread_enable_cancel(bool cancel)
-{
-	cancel ? pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) :
-		 pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
-}
 
 void Thread::start(void *(*task)(void*), void *arg)
 {
@@ -136,10 +110,8 @@ void Thread::start(void *(*task)(void*), void *arg)
 	// (pat) Moved initialization to constructor to avoid crash in destructor.
 	//res = pthread_attr_init(&mAttrib);
 	//assert(!res);
-	if (mStackSize != 0) {
 	res = pthread_attr_setstacksize(&mAttrib, mStackSize);
 	assert(!res);
-	}
 	res = pthread_create(&mThread, &mAttrib, task, arg);
 	assert(!res);
 }

CommonLibs/Threads.h

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008, 2011 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -143,9 +141,6 @@ class Signal {
 #define START_THREAD(thread,function,argument) \
 	thread.start((void *(*)(void*))function, (void*)argument);
 
-void set_selfthread_name(const char *name);
-void thread_enable_cancel(bool cancel);
-
 /** A C++ wrapper for pthread threads.  */
 class Thread {
 
@@ -160,7 +155,7 @@ class Thread {
 	public:
 
 	/** Create a thread in a non-running state. */
-	Thread(size_t wStackSize = 0):mThread((pthread_t)0) {
+	Thread(size_t wStackSize = (65536*4)):mThread((pthread_t)0) {
 		pthread_attr_init(&mAttrib);	// (pat) moved this here.
 		mStackSize=wStackSize;
 	}

CommonLibs/Timeval.cpp

@@ -1,7 +1,6 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
 *
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
@@ -28,49 +27,43 @@
 
 #include "Timeval.h"
 
-extern "C" {
-#include <osmocom/core/timer.h>
-}
-
 using namespace std;
 
-void Timeval::now()
-{
-	osmo_clock_gettime(CLOCK_REALTIME, &mTimespec);
-}
-
 void Timeval::future(unsigned offset)
 {
 	now();
 	unsigned sec = offset/1000;
 	unsigned msec = offset%1000;
-	mTimespec.tv_nsec += msec*1000*1000;
-	mTimespec.tv_sec += sec;
-	if (mTimespec.tv_nsec > 1000*1000*1000) {
-		mTimespec.tv_nsec -= 1000*1000*1000;
-		mTimespec.tv_sec += 1;
+	mTimeval.tv_usec += msec*1000;
+	mTimeval.tv_sec += sec;
+	if (mTimeval.tv_usec>1000000) {
+		mTimeval.tv_usec -= 1000000;
+		mTimeval.tv_sec += 1;
 	}
 }
 
 
 struct timespec Timeval::timespec() const
 {
-	return mTimespec;
+	struct timespec retVal;
+	retVal.tv_sec = mTimeval.tv_sec;
+	retVal.tv_nsec = 1000 * (long)mTimeval.tv_usec;
+	return retVal;
 }
 
 
 bool Timeval::passed() const
 {
 	Timeval nowTime;
-	if (nowTime.mTimespec.tv_sec < mTimespec.tv_sec) return false;
-	if (nowTime.mTimespec.tv_sec > mTimespec.tv_sec) return true;
-	if (nowTime.mTimespec.tv_nsec >= mTimespec.tv_nsec) return true;
+	if (nowTime.mTimeval.tv_sec < mTimeval.tv_sec) return false;
+	if (nowTime.mTimeval.tv_sec > mTimeval.tv_sec) return true;
+	if (nowTime.mTimeval.tv_usec > mTimeval.tv_usec) return true;
 	return false;
 }
 
 double Timeval::seconds() const
 {
-	return ((double)mTimespec.tv_sec) + 1e-9*((double)mTimespec.tv_nsec);
+	return ((double)mTimeval.tv_sec) + 1e-6*((double)mTimeval.tv_usec);
 }
 
 
@@ -79,8 +72,8 @@ long Timeval::delta(const Timeval& other) const
 {
 	// 2^31 milliseconds is just over 4 years.
 	int32_t deltaS = other.sec() - sec();
-	int32_t deltaNs = other.nsec() - nsec();
-	return 1000*deltaS + deltaNs/1000000;
+	int32_t deltaUs = other.usec() - usec();
+	return 1000*deltaS + deltaUs/1000;
 }
 	
 
@@ -88,16 +81,15 @@ long Timeval::delta(const Timeval& other) const
 
 ostream& operator<<(ostream& os, const Timeval& tv)
 {
-	ios_base::fmtflags flags_backup = os.setf( ios::fixed, ios::floatfield );
+	os.setf( ios::fixed, ios::floatfield );
 	os << tv.seconds();
-	os.flags( flags_backup );
 	return os;
 }
 
 
 ostream& operator<<(ostream& os, const struct timespec& ts)
 {
-	os << ts.tv_sec << "," << ts.tv_nsec/1000;
+	os << ts.tv_sec << "," << ts.tv_nsec;
 	return os;
 }
 

CommonLibs/Timeval.h

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -44,12 +42,12 @@ class Timeval {
 
 	private:
 
-	struct timespec mTimespec;
+	struct timeval mTimeval;
 
 	public:
 
-	/** Set the value to current time. */
-	void now();
+	/** Set the value to gettimeofday. */
+	void now() { gettimeofday(&mTimeval,NULL); }
 
 	/** Set the value to gettimeofday plus an offset. */
 	void future(unsigned ms);
@@ -57,18 +55,16 @@ class Timeval {
 	//@{
 	Timeval(unsigned sec, unsigned usec)
 	{
-		mTimespec.tv_sec = sec;
-		mTimespec.tv_nsec = usec*1000;
+		mTimeval.tv_sec = sec;
+		mTimeval.tv_usec = usec;
 	}
 
 	Timeval(const struct timeval& wTimeval)
-	{
-		mTimespec.tv_sec = wTimeval.tv_sec;
-		mTimespec.tv_nsec = wTimeval.tv_sec*1000;
-	}
+		:mTimeval(wTimeval)
+	{}
 
 	/**
-		Create a Timespec offset into the future.
+		Create a Timeval offset into the future.
 		@param offset milliseconds
 	*/
 	Timeval(unsigned offset=0) { future(offset); }
@@ -80,9 +76,8 @@ class Timeval {
 	/** Return total seconds. */
 	double seconds() const;
 
-	uint32_t sec() const { return mTimespec.tv_sec; }
-	uint32_t usec() const { return mTimespec.tv_nsec / 1000; }
-	uint32_t nsec() const { return mTimespec.tv_nsec; }
+	uint32_t sec() const { return mTimeval.tv_sec; }
+	uint32_t usec() const { return mTimeval.tv_usec; }
 
 	/** Return differnce from other (other-self), in ms. */
 	long delta(const Timeval& other) const;
@@ -93,11 +88,11 @@ class Timeval {
 	/** Remaining time in ms. */
 	long remaining() const { return -elapsed(); }
 
-	/** Return true if the time has passed, as per clock_gettime(CLOCK_REALTIME). */
+	/** Return true if the time has passed, as per gettimeofday. */
 	bool passed() const;
 
 	/** Add a given number of minutes to the time. */
-	void addMinutes(unsigned minutes) { mTimespec.tv_sec += minutes*60; }
+	void addMinutes(unsigned minutes) { mTimeval.tv_sec += minutes*60; }
 
 };
 

CommonLibs/Utils.cpp

@@ -1,38 +0,0 @@
-/*
- * Copyright 2018 sysmocom - s.f.m.c. GmbH
- *
- * SPDX-License-Identifier: LGPL-2.1+
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include <vector>
-#include <string>
-#include <sstream>
-
-std::vector<std::string> comma_delimited_to_vector(const char* opt)
-{
-	std::string str = std::string(opt);
-	std::vector<std::string> result;
-	std::stringstream ss(str);
-
-	while( ss.good() )
-	{
-	    std::string substr;
-	    getline(ss, substr, ',');
-	    result.push_back(substr);
-	}
-	return result;
-}

CommonLibs/Utils.h

@@ -1,26 +0,0 @@
-/*
- * Copyright 2018 sysmocom - s.f.m.c. GmbH
- *
- * SPDX-License-Identifier: LGPL-2.1+
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#pragma once
-
-#include <vector>
-#include <string>
-
-std::vector<std::string> comma_delimited_to_vector(const char* opt);

CommonLibs/Vector.h

@@ -2,8 +2,6 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -34,14 +32,11 @@
 #include <string.h>
 #include <iostream>
 #include <assert.h>
-#include <stdlib.h>
-
 // We cant use Logger.h in this file...
 extern int gVectorDebug;
 #define BVDEBUG(msg) if (gVectorDebug) {std::cout << msg;}
 
-typedef void (*vector_free_func)(void* wData);
-typedef void *(*vector_alloc_func)(size_t newSize);
+
 
 /**
 	A simplified Vector template with aliases.
@@ -65,8 +60,6 @@ template <class T> class Vector {
 	T* mData;		///< allocated data block, if any
 	T* mStart;		///< start of useful data
 	T* mEnd;		///< end of useful data + 1
-	vector_alloc_func mAllocFunc; ///< function used to alloc new mData during resize.
-	vector_free_func mFreeFunc; ///< function used to free mData.
 
 	public:
 
@@ -92,19 +85,9 @@ template <class T> class Vector {
 	/** Change the size of the Vector, discarding content. */
 	void resize(size_t newSize)
 	{
-		if (mData!=NULL) {
-			if (mFreeFunc)
-				mFreeFunc(mData);
-			else
-				delete[] mData;
-		}
+		if (mData!=NULL) delete[] mData;
 		if (newSize==0) mData=NULL;
-		else {
-			if (mAllocFunc)
-				mData = (T*) mAllocFunc(newSize);
-			else
-				mData = new T[newSize];
-		}
+		else mData = new T[newSize];
 		mStart = mData;
 		mEnd = mStart + newSize;
 	}
@@ -124,7 +107,7 @@ template <class T> class Vector {
 	void clone(const Vector<T>& other)
 	{
 		resize(other.size());
-		other.copyTo(*this);
+		memcpy(mData,other.mStart,other.bytes());
 	}
 
 
@@ -133,31 +116,29 @@ template <class T> class Vector {
 	//@{
 
 	/** Build an empty Vector of a given size. */
-	Vector(size_t wSize=0, vector_alloc_func wAllocFunc=NULL, vector_free_func wFreeFunc=NULL)
-		:mData(NULL), mAllocFunc(wAllocFunc), mFreeFunc(wFreeFunc)
-	{ resize(wSize); }
+	Vector(size_t wSize=0):mData(NULL) { resize(wSize); }
 
 	/** Build a Vector by moving another. */
 	Vector(Vector<T>&& other)
-		:mData(other.mData),mStart(other.mStart),mEnd(other.mEnd), mAllocFunc(other.mAllocFunc),  mFreeFunc(other.mFreeFunc)
+		:mData(other.mData),mStart(other.mStart),mEnd(other.mEnd)
 	{ other.mData=NULL; }
 
 	/** Build a Vector by copying another. */
-	Vector(const Vector<T>& other):mData(NULL), mAllocFunc(other.mAllocFunc), mFreeFunc(other.mFreeFunc) { clone(other); }
+	Vector(const Vector<T>& other):mData(NULL) { clone(other); }
 
 	/** Build a Vector with explicit values. */
-	Vector(T* wData, T* wStart, T* wEnd, vector_alloc_func wAllocFunc=NULL, vector_free_func wFreeFunc=NULL)
-		:mData(wData),mStart(wStart),mEnd(wEnd), mAllocFunc(wAllocFunc), mFreeFunc(wFreeFunc)
+	Vector(T* wData, T* wStart, T* wEnd)
+		:mData(wData),mStart(wStart),mEnd(wEnd)
 	{ }
 
 	/** Build a vector from an existing block, NOT to be deleted upon destruction. */
-	Vector(T* wStart, size_t span, vector_alloc_func wAllocFunc=NULL, vector_free_func wFreeFunc=NULL)
-		:mData(NULL),mStart(wStart),mEnd(wStart+span),mAllocFunc(wAllocFunc), mFreeFunc(wFreeFunc)
+	Vector(T* wStart, size_t span)
+		:mData(NULL),mStart(wStart),mEnd(wStart+span)
 	{ }
 
 	/** Build a Vector by concatenation. */
-	Vector(const Vector<T>& other1, const Vector<T>& other2, vector_alloc_func wAllocFunc=NULL, vector_free_func wFreeFunc=NULL)
-		:mData(NULL), mAllocFunc(wAllocFunc), mFreeFunc(wFreeFunc)
+	Vector(const Vector<T>& other1, const Vector<T>& other2)
+		:mData(NULL)
 	{
 		resize(other1.size()+other2.size());
 		memcpy(mStart, other1.mStart, other1.bytes());
@@ -181,8 +162,6 @@ template <class T> class Vector {
 		mData=other.mData;
 		mStart=other.mStart;
 		mEnd=other.mEnd;
-		mAllocFunc=other.mAllocFunc;
-		mFreeFunc=other.mFreeFunc;
 		other.mData=NULL;
 	}
 
@@ -225,15 +204,10 @@ template <class T> class Vector {
 	*/
 	void copyToSegment(Vector<T>& other, size_t start, size_t span) const
 	{
-		unsigned int i;
-		T* dst = other.mStart + start;
-		T* src = mStart;
-		assert(dst+span<=other.mEnd);
+		T* base = other.mStart + start;
+		assert(base+span<=other.mEnd);
 		assert(mStart+span<=mEnd);
-		for (i = 0; i < span; i++, src++, dst++)
-			*dst = *src;
-		/*TODO if not non-trivially copyable type class, optimize:
-		memcpy(dst,mStart,span*sizeof(T)); */
+		memcpy(base,mStart,span*sizeof(T));
 	}
 
 	/** Copy all of this Vector to a segment of another Vector. */

CommonLibs/config_defs.h

@@ -1,20 +0,0 @@
-#pragma once
-
-/*
- * This file contains structures used by both VTY (C, dir CommonLibs) and
- * osmo-trx (CXX, dir Transceiver52)
- */
-
-enum FillerType {
-  FILLER_DUMMY,
-  FILLER_ZERO,
-  FILLER_NORM_RAND,
-  FILLER_EDGE_RAND,
-  FILLER_ACCESS_RAND,
-};
-
-enum ReferenceType {
-  REF_INTERNAL,
-  REF_EXTERNAL,
-  REF_GPS,
-};

CommonLibs/debug.c

@@ -1,107 +0,0 @@
-/*
- * Copyright (C) 2018-2019 sysmocom - s.f.m.c. GmbH
- * All Rights Reserved
- *
- * SPDX-License-Identifier: AGPL-3.0+
- *
- * Author: Pau Espin Pedrol <pespin@sysmocom.de>
- *
- * 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 <pthread.h>
-
-#include <osmocom/core/logging.h>
-#include <osmocom/core/utils.h>
-#include "debug.h"
-
-/* default categories */
-static const struct log_info_cat default_categories[] = {
-	[DMAIN] = {
-		.name = "DMAIN",
-		.description = "Main generic category",
-		.color = NULL,
-		.enabled = 1, .loglevel = LOGL_NOTICE,
-	},
-	[DTRXCTRL] = {
-			.name = "DTRXCTRL",
-			.description = "TRX CTRL interface",
-			.color = "\033[1;33m",
-			.enabled = 1, .loglevel = LOGL_NOTICE,
-	},
-	[DDEV] = {
-		.name = "DDEV",
-		.description = "Device/Driver specific code",
-		.color = NULL,
-		.enabled = 1, .loglevel = LOGL_INFO,
-	},
-	[DLMS] = {
-		.name = "DLMS",
-		.description = "Logging from within LimeSuite itself",
-		.color = NULL,
-		.enabled = 1, .loglevel = LOGL_NOTICE,
-	},
-};
-
-const struct log_info log_info = {
-	.cat = default_categories,
-	.num_cat = ARRAY_SIZE(default_categories),
-};
-
-pthread_mutex_t log_mutex;
-
-bool log_mutex_init() {
-	int rc;
-	pthread_mutexattr_t attr;
-
-	if ((rc = pthread_mutexattr_init(&attr))) {
-		fprintf(stderr, "pthread_mutexattr_init() failed: %d\n", rc);
-		return false;
-	}
-	if ((rc = pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE))) {
-		fprintf(stderr, "pthread_mutexattr_settype() failed: %d\n", rc);
-		return false;
-	}
-	if ((rc = pthread_mutex_init(&log_mutex, &attr))) {
-		fprintf(stderr, "pthread_mutex_init() failed: %d\n", rc);
-		return false;
-	}
-	if ((rc = pthread_mutexattr_destroy(&attr))) {
-		fprintf(stderr, "pthread_mutexattr_destroy() failed: %d\n", rc);
-		return false;
-	}
-	return true;
-	/* FIXME: do we need to call pthread_mutex_destroy() during process exit? */
-}
-
-/* If called inside a C++ destructor, use log_mutex_(un)lock_canceldisable() APIs instead.
-   See osmo-trx commit 86be40b4eb762d5c12e8e3f7388ca9f254e77b36 for more information */
-void log_mutex_lock() {
-	OSMO_ASSERT(!pthread_mutex_lock(&log_mutex));
-}
-
-void log_mutex_unlock() {
-	OSMO_ASSERT(!pthread_mutex_unlock(&log_mutex));
-}
-
-void log_mutex_lock_canceldisable(int *st) {
-	pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, st);
-	log_mutex_lock();
-}
-
-void log_mutex_unlock_canceldisable(int st) {
-	log_mutex_unlock();
-	pthread_setcancelstate(st, NULL);
-}

CommonLibs/debug.h

@@ -1,35 +0,0 @@
-#pragma once
-
-#include <stdbool.h>
-#include <pthread.h>
-
-#include <osmocom/core/logging.h>
-
-extern const struct log_info log_info;
-
-/* Debug Areas of the code */
-enum {
-	DMAIN,
-	DTRXCTRL,
-	DDEV,
-	DLMS,
-};
-
-
-bool log_mutex_init();
-void log_mutex_lock();
-void log_mutex_unlock();
-void log_mutex_lock_canceldisable(int *st);
-void log_mutex_unlock_canceldisable(int st);
-
-#define CLOGC(category, level, fmt, args...) do { \
-	log_mutex_lock(); \
-	LOGP(category, level, "[tid=%lu] " fmt, pthread_self(), ##args);  \
-	log_mutex_unlock(); \
-} while(0)
-
-#define CLOGCHAN(chan, category, level, fmt, args...) do { \
-	log_mutex_lock(); \
-	LOGP(category, level, "[tid=%lu][chan=%lu] " fmt, pthread_self(), chan, ##args);  \
-	log_mutex_unlock(); \
-} while(0)

CommonLibs/osmo_signal.h

@@ -1,57 +0,0 @@
-/* Generic signalling/notification infrastructure */
-/* (C) 2018 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>
- *
- * Author: Pau Espin Pedrol <pespin@sysmocom.de>
- *
- * All Rights Reserved
- *
- * 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/>.
- *
- */
-
-#pragma once
-
-#include <osmocom/core/signal.h>
-
-/* Signalling subsystems */
-enum signal_subsystems {
-	SS_MAIN,
-	SS_DEVICE,
-};
-
-/* SS_MAIN signals */
-enum SS_MAIN {
-	S_MAIN_STOP_REQUIRED, /* TRX fatal error, it should be stopped */
-};
-
-/* SS_DEVICE signals */
-enum SS_DEVICE {
-	/* Device internal counters changed. Counters are provided as cb data
-	   (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,
-};
-
-/* signal cb for signal <SS_DEVICE,S_DEVICE_COUNTER_CHANGE> */
-struct device_counters {
-	size_t chan;
-	unsigned int rx_overruns;
-	unsigned int tx_underruns;
-	unsigned int rx_dropped_events;
-	unsigned int rx_dropped_samples;
-	unsigned int tx_dropped_events;
-	unsigned int tx_dropped_samples;
-};

CommonLibs/trx_rate_ctr.cpp

@@ -1,336 +0,0 @@
-/*
- * Copyright (C) 2019 sysmocom - s.f.m.c. GmbH
- * All Rights Reserved
- *
- * SPDX-License-Identifier: AGPL-3.0+
- *
- * Author: Pau Espin Pedrol <pespin@sysmocom.de>
- *
- * 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.
- */
-
-/*
- * rate_ctr API uses several osmocom select loop features, and as a result,
- * calls to it must be done through the main thread (the one running the osmocom
- * loop in osmo-trx).
- * Since read/write from/to SDR is done in separate threads (even read and write
- * each use a different thread), we must use some sort of message passing system
- * between main thread feeding rate_ctr structures and the Rx/Tx threads
- * generating the events.
- * The idea is that upon read/write issues, lower layers (SDR APIs) provide us with
- * underrun/overrun/droppedPackets information, and in that case we pass that up
- * the stack through signal <SS_DEVICE,S_DEVICE_COUNTER_CHANGE> with signal_cb
- * being a pointer to a "struct device_counters" structure, which contains
- * device (implementation agnostic) statful counters for different kind of
- * statistics.
- * That signal is processed here in device_sig_cb, where a copy of the "struct
- * device_counters" structure is held and the main thread is instructed through
- * a timerfd to update rate_ctr APIs against this copy. All this is done inside
- * a mutex to avoid different race conditons (between Rx andTx threads, and
- * between Rx/Tx and main thread). For the same reason, callers of signal
- * <SS_DEVICE,S_DEVICE_COUNTER_CHANGE> (device_sig_cb), that is Rx/Tx threads,
- * must do so with PTHREAD_CANCEL_DISABLE, in order to avoid possible deadlocks
- * in case the main thread decides to cancel other threads due to a shutdown
- * operation (fi SIGKILL received)
- */
-
-#include <string.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-extern "C" {
-#include <osmocom/core/talloc.h>
-#include <osmocom/core/utils.h>
-#include <osmocom/core/rate_ctr.h>
-#include <osmocom/core/select.h>
-#include <osmocom/core/stats.h>
-#include <osmocom/core/timer.h>
-
-#include "osmo_signal.h"
-#include "trx_vty.h"
-#include "trx_rate_ctr.h"
-}
-#include "Threads.h"
-#include "Logger.h"
-
-/* Used in 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 size_t chan_len;
-static struct osmo_fd rate_ctr_timerfd;
-static Mutex rate_ctr_mutex;
-
-struct osmo_timer_list threshold_timer;
-static LLIST_HEAD(threshold_list);
-static int threshold_timer_sched_secs;
-static bool threshold_initied;
-
-const struct value_string rate_ctr_intv[] = {
-	{ RATE_CTR_INTV_SEC,	"per-second" },
-	{ RATE_CTR_INTV_MIN,	"per-minute" },
-	{ RATE_CTR_INTV_HOUR,	"per-hour" },
-	{ RATE_CTR_INTV_DAY, 	"per-day" },
-	{ 0, NULL }
-};
-
-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" },
-	{ 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" }
-};
-
-static const struct rate_ctr_group_desc trx_chan_ctr_group_desc = {
-	.group_name_prefix		= "trx:chan",
-	.group_description		= "osmo-trx statistics",
-	.class_id			= OSMO_STATS_CLASS_GLOBAL,
-	.num_ctr			= ARRAY_SIZE(trx_chan_ctr_desc),
-	.ctr_desc			= trx_chan_ctr_desc,
-};
-
-static int 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();
-	for (chan = 0; chan < chan_len; chan++) {
-		if (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);
-
-		/* Mark as done */
-		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();
-	return 0;
-}
-
-/* Callback function to be called every time we receive a signal from DEVICE */
-static int device_sig_cb(unsigned int subsys, unsigned int signal,
-			 void *handler_data, void *signal_data)
-{
-	struct device_counters *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};
-
-	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);
-		}
-		rate_ctr_mutex.unlock();
-		break;
-	default:
-		break;
-	}
-	return 0;
-}
-
-/************************************
- * ctr_threshold  APIs
- ************************************/
-static const char* ctr_threshold_2_vty_str(struct ctr_threshold *ctr)
-{
-	static char buf[256];
-	int rc = 0;
-	rc += snprintf(buf, sizeof(buf), "ctr-error-threshold %s", get_value_string(trx_chan_ctr_names, ctr->ctr_id));
-	rc += snprintf(buf + rc, sizeof(buf) - rc, " %d %s", ctr->val, get_value_string(rate_ctr_intv, ctr->intv));
-	return buf;
-}
-
-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!";
-
-	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->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)
-							   << " ("<< rate_ctr->intv[ctr_thr->intv].rate << " vs " << ctr_thr->val << ")";
-				osmo_signal_dispatch(SS_MAIN, S_MAIN_STOP_REQUIRED, NULL);
-				return;
-			}
-		}
-	}
-	osmo_timer_schedule(&threshold_timer, threshold_timer_sched_secs, 0);
-}
-
-static size_t ctr_threshold_2_seconds(struct ctr_threshold *ctr)
-{
-	size_t mult = 0;
-	switch (ctr->intv) {
-	case RATE_CTR_INTV_SEC:
-		mult = 1;
-		break;
-	case RATE_CTR_INTV_MIN:
-		mult = 60;
-		break;
-	case RATE_CTR_INTV_HOUR:
-		mult = 60*60;
-		break;
-	case RATE_CTR_INTV_DAY:
-		mult = 60*60*24;
-		break;
-	default:
-		OSMO_ASSERT(false);
-	}
-	return mult;
-}
-
-static void threshold_timer_update_intv() {
-	struct ctr_threshold *ctr, *min_ctr;
-	size_t secs, min_secs;
-
-	/* Avoid scheduling timer until itself and other structures are prepared
-	   by trx_rate_ctr_init */
-	if (!threshold_initied)
-		return;
-
-	if (llist_empty(&threshold_list)) {
-		if (osmo_timer_pending(&threshold_timer))
-			osmo_timer_del(&threshold_timer);
-		return;
-	}
-
-	min_ctr = llist_first_entry(&threshold_list, struct ctr_threshold, list);
-	min_secs = ctr_threshold_2_seconds(min_ctr);
-
-	llist_for_each_entry(ctr, &threshold_list, list) {
-		secs = ctr_threshold_2_seconds(ctr);
-		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 << " seconds";
-	osmo_timer_schedule(&threshold_timer, threshold_timer_sched_secs, 0);
-}
-
-/* Init rate_ctr subsystem. Expected to be called during process start by main thread before VTY is ready */
-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));
-	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;
-		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";
-			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";
-		exit(1);
-	}
-	osmo_signal_register_handler(SS_DEVICE, device_sig_cb, NULL);
-
-	/* Now set up threshold checks */
-	threshold_initied = true;
-	osmo_timer_setup(&threshold_timer, threshold_timer_cb, NULL);
-	threshold_timer_update_intv();
-}
-
-void trx_rate_ctr_threshold_add(struct ctr_threshold *ctr)
-{
-	struct ctr_threshold *new_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);
-	llist_add(&new_ctr->list, &threshold_list);
-	threshold_timer_update_intv();
-}
-
-int trx_rate_ctr_threshold_del(struct ctr_threshold *del_ctr)
-{
-	struct ctr_threshold *ctr;
-
-	llist_for_each_entry(ctr, &threshold_list, list) {
-		if (ctr->intv != del_ctr->intv ||
-		    ctr->ctr_id != del_ctr->ctr_id ||
-		    ctr->val != del_ctr->val)
-			continue;
-
-		LOGC(DMAIN, NOTICE) << "Deleting threshold check: " << ctr_threshold_2_vty_str(del_ctr);
-		llist_del(&ctr->list);
-		talloc_free(ctr);
-		threshold_timer_update_intv();
-		return 0;
-	}
-	return -1;
-}
-
-void trx_rate_ctr_threshold_write_config(struct vty *vty, char *indent_prefix)
-{
-	struct ctr_threshold *ctr;
-
-	llist_for_each_entry(ctr, &threshold_list, list) {
-		vty_out(vty, "%s%s%s", indent_prefix, ctr_threshold_2_vty_str(ctr), VTY_NEWLINE);
-	}
-}

CommonLibs/trx_rate_ctr.h

@@ -1,30 +0,0 @@
-#pragma once
-
-#include <osmocom/core/rate_ctr.h>
-#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,
-};
-
-struct ctr_threshold {
-	/*! Linked list of all counter groups in the system */
-	struct llist_head list;
-	enum rate_ctr_intv intv;
-	enum TrxCtr ctr_id;
-	uint32_t val;
-};
-
-extern const struct value_string rate_ctr_intv[];
-extern const struct value_string trx_chan_ctr_names[];
-
-struct trx_ctx;
-void trx_rate_ctr_init(void *ctx, struct trx_ctx* trx_ctx);
-void trx_rate_ctr_threshold_add(struct ctr_threshold *ctr);
-int trx_rate_ctr_threshold_del(struct ctr_threshold *del_ctr);
-void trx_rate_ctr_threshold_write_config(struct vty *vty, char *indent_prefix);

CommonLibs/trx_vty.c

@@ -1,729 +0,0 @@
-/*
- * Copyright (C) 2018-2019 sysmocom - s.f.m.c. GmbH
- * All Rights Reserved
- *
- * SPDX-License-Identifier: AGPL-3.0+
- *
- * Author: Pau Espin Pedrol <pespin@sysmocom.de>
- *
- * 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 <string.h>
-#include <stdint.h>
-#include <inttypes.h>
-#include <netinet/in.h>
-#include <arpa/inet.h>
-
-#include <osmocom/core/talloc.h>
-#include <osmocom/core/utils.h>
-#include <osmocom/core/rate_ctr.h>
-
-#include <osmocom/vty/command.h>
-#include <osmocom/vty/vty.h>
-#include <osmocom/vty/misc.h>
-
-#include "trx_rate_ctr.h"
-#include "trx_vty.h"
-#include "../config.h"
-
-static struct trx_ctx* g_trx_ctx;
-
-static const struct value_string clock_ref_names[] = {
-	{ REF_INTERNAL,	"internal" },
-	{ REF_EXTERNAL,	"external" },
-	{ REF_GPS,	"gpsdo" },
-	{ 0,		NULL }
-};
-
-static const struct value_string filler_names[] = {
-	{ FILLER_DUMMY,		"Dummy bursts" },
-	{ FILLER_ZERO,		"Disabled" },
-	{ FILLER_NORM_RAND,	"Normal bursts with random payload" },
-	{ FILLER_EDGE_RAND,	"EDGE bursts with random payload" },
-	{ FILLER_ACCESS_RAND,	"Access bursts with random payload" },
-	{ 0,			NULL }
-};
-
-struct trx_ctx *trx_from_vty(struct vty *v)
-{
-        /* It can't hurt to force callers to continue to pass the vty instance
-         * to this function, in case we'd like to retrieve the global
-         * trx instance from the vty at some point in the future. But
-         * until then, just return the global pointer, which should have been
-         * initialized by trx_vty_init().
-         */
-        OSMO_ASSERT(g_trx_ctx);
-        return g_trx_ctx;
-}
-
-enum trx_vty_node {
-	TRX_NODE = _LAST_OSMOVTY_NODE + 1,
-	CHAN_NODE,
-};
-
-static struct cmd_node trx_node = {
-	TRX_NODE,
-	"%s(config-trx)# ",
-	1,
-};
-
-static struct cmd_node chan_node = {
-	CHAN_NODE,
-	"%s(config-trx-chan)# ",
-	1,
-};
-
-DEFUN(cfg_trx, cfg_trx_cmd,
-	"trx",
-	"Configure the TRX\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (!trx)
-		return CMD_WARNING;
-
-	vty->node = TRX_NODE;
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_bind_ip, cfg_bind_ip_cmd,
-	"bind-ip A.B.C.D",
-	"Set the IP address for the local bind\n"
-	"IPv4 Address\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	osmo_talloc_replace_string(trx, &trx->cfg.bind_addr, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_remote_ip, cfg_remote_ip_cmd,
-	"remote-ip A.B.C.D",
-	"Set the IP address for the remote BTS\n"
-	"IPv4 Address\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	osmo_talloc_replace_string(trx, &trx->cfg.remote_addr, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_base_port, cfg_base_port_cmd,
-	"base-port <1-65535>",
-	"Set the TRX Base Port\n"
-	"TRX Base Port\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.base_port = atoi(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_dev_args, cfg_dev_args_cmd,
-	"dev-args DESC",
-	"Set the device-specific arguments to pass to the device\n"
-	"Device-specific arguments\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	osmo_talloc_replace_string(trx, &trx->cfg.dev_args, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_tx_sps, cfg_tx_sps_cmd,
-	"tx-sps (1|4)",
-	"Set the Tx Samples-per-Symbol\n"
-	"Tx Samples-per-Symbol\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.tx_sps = atoi(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_rx_sps, cfg_rx_sps_cmd,
-	"rx-sps (1|4)",
-	"Set the Rx Samples-per-Symbol\n"
-	"Rx Samples-per-Symbol\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.rx_sps = atoi(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_test_rtsc, cfg_test_rtsc_cmd,
-	"test rtsc <0-7>",
-	"Set the Random Normal Burst test mode with TSC\n"
-	"TSC\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (trx->cfg.rach_delay_set) {
-		vty_out(vty, "rach-delay and rtsc options are mutual-exclusive%s",
-			VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-
-	trx->cfg.rtsc_set = true;
-	trx->cfg.rtsc = atoi(argv[0]);
-	if (!trx->cfg.egprs) /* Don't override egprs which sets different filler */
-		trx->cfg.filler = FILLER_NORM_RAND;
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_test_rach_delay, cfg_test_rach_delay_cmd,
-	"test rach-delay <0-68>",
-	"Set the Random Access Burst test mode with delay\n"
-	"RACH delay\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (trx->cfg.rtsc_set) {
-		vty_out(vty, "rach-delay and rtsc options are mutual-exclusive%s",
-			VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-
-	if (trx->cfg.egprs) {
-		vty_out(vty, "rach-delay and egprs options are mutual-exclusive%s",
-			VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-
-	trx->cfg.rach_delay_set = true;
-	trx->cfg.rach_delay = atoi(argv[0]);
-	trx->cfg.filler = FILLER_ACCESS_RAND;
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_clock_ref, cfg_clock_ref_cmd,
-	"clock-ref (internal|external|gpsdo)",
-	"Set the Reference Clock\n"
-	"Enable internal referece (default)\n"
-	"Enable external 10 MHz reference\n"
-	"Enable GPSDO reference\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.clock_ref = get_string_value(clock_ref_names, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_multi_arfcn, cfg_multi_arfcn_cmd,
-	"multi-arfcn (disable|enable)",
-	"Enable multi-ARFCN transceiver (default=disable)\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (strcmp("disable", argv[0]) == 0) {
-		trx->cfg.multi_arfcn = false;
-		return CMD_SUCCESS;
-	}
-
-	if (trx->cfg.num_chans > TRX_MCHAN_MAX) {
-		vty_out(vty, "Up to %i channels are supported for multi-TRX mode%s",
-			TRX_MCHAN_MAX, VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-
-	trx->cfg.multi_arfcn = true;
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_offset, cfg_offset_cmd,
-	"offset FLOAT",
-	"Set the baseband frequency offset (default=0, auto)\n"
-	"Baseband Frequency Offset\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.offset = atof(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_rssi_offset, cfg_rssi_offset_cmd,
-	"rssi-offset FLOAT",
-	"Set the RSSI to dBm offset in dB (default=0)\n"
-	"RSSI to dBm offset in dB\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.rssi_offset = atof(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_swap_channels, cfg_swap_channels_cmd,
-	"swap-channels (disable|enable)",
-	"Swap channels (default=disable)\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (strcmp("disable", argv[0]) == 0) {
-		trx->cfg.swap_channels = false;
-	} else if (strcmp("enable", argv[0]) == 0) {
-		trx->cfg.swap_channels = true;
-	} else {
-		return CMD_WARNING;
-	}
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_egprs, cfg_egprs_cmd,
-	"egprs (disable|enable)",
-	"Enable EDGE receiver (default=disable)\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (strcmp("disable", argv[0]) == 0) {
-		trx->cfg.egprs = false;
-	} else if (strcmp("enable", argv[0]) == 0) {
-		trx->cfg.egprs = true;
-		trx->cfg.filler = FILLER_EDGE_RAND;
-	} else {
-		return CMD_WARNING;
-	}
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_ext_rach, cfg_ext_rach_cmd,
-	"ext-rach (disable|enable)",
-	"Enable extended (11-bit) RACH (default=disable)\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	if (strcmp("disable", argv[0]) == 0)
-		trx->cfg.ext_rach = false;
-
-	if (strcmp("enable", argv[0]) == 0)
-		trx->cfg.ext_rach = true;
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_rt_prio, cfg_rt_prio_cmd,
-	"rt-prio <1-32>",
-	"Set the SCHED_RR real-time priority\n"
-	"Real time priority\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.sched_rr = atoi(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_stack_size, cfg_stack_size_cmd,
-	"stack-size <0-2147483647>",
-	"Set the stack size per thread in BYTE, 0 = OS default\n"
-	"Stack size per thread in BYTE\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.stack_size = atoi(argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_filler, cfg_filler_cmd,
-	"filler dummy",
-	"Enable C0 filler table\n"
-	"Dummy method\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx->cfg.filler = FILLER_DUMMY;
-
-	return CMD_SUCCESS;
-}
-
-static int vty_ctr_name_2_id(const char* str) {
-	size_t i;
-	for (i = 0; trx_chan_ctr_names[i].str; i++) {
-		if (strstr(trx_chan_ctr_names[i].str, str)) {
-			return i;
-		}
-	}
-	return -1;
-}
-
-static int vty_intv_name_2_id(const char* str) {
-	size_t i;
-	for (i = 0; rate_ctr_intv[i].str; i++) {
-		if (strcmp(rate_ctr_intv[i].str, str) == 0) {
-			return i;
-		}
-	}
-	return -1;
-}
-
-#define THRESHOLD_ARGS "(rx_overruns|tx_underruns|rx_drop_events|rx_drop_samples|tx_drop_events|tx_drop_samples)"
-#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) \
-	THRESHOLD_STR_VAL(tx_underruns) \
-	THRESHOLD_STR_VAL(rx_drop_events) \
-	THRESHOLD_STR_VAL(rx_drop_samples) \
-	THRESHOLD_STR_VAL(tx_drop_events) \
-	THRESHOLD_STR_VAL(tx_drop_samples)
-#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 \
-	INTV_STR_VAL(per-second) \
-	INTV_STR_VAL(per-minute) \
-	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)
-{
-	int rc;
-	struct ctr_threshold ctr;
-
-	struct trx_ctx *trx = trx_from_vty(vty);
-	rc = vty_ctr_name_2_id(argv[0]);
-	if (rc < 0) {
-		vty_out(vty, "No valid ctr_name found for ctr-error-threshold %s%s",
-			argv[0], VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-	ctr.ctr_id = (enum TrxCtr)rc;
-	ctr.val = atoi(argv[1]);
-	rc = vty_intv_name_2_id(argv[2]);
-	if (rc < 0) {
-		vty_out(vty, "No valid time frame found for ctr-error-threshold %s %d %s%s",
-			argv[0], ctr.val, argv[2], VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-	ctr.intv = (enum rate_ctr_intv) rc;
-	trx_rate_ctr_threshold_add(&ctr);
-
-	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)
-{
-	int rc;
-	struct ctr_threshold ctr;
-
-	struct trx_ctx *trx = trx_from_vty(vty);
-	rc = vty_ctr_name_2_id(argv[0]);
-	if (rc < 0) {
-		vty_out(vty, "No valid ctr_name found for ctr-error-threshold %s%s",
-			argv[0], VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-	ctr.ctr_id = (enum TrxCtr)rc;
-	ctr.val = atoi(argv[1]);
-	rc = vty_intv_name_2_id(argv[2]);
-	if (rc < 0) {
-		vty_out(vty, "No valid time frame found for ctr-error-threshold %s %d %s%s",
-			argv[0], ctr.val, argv[2], VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-	ctr.intv = (enum rate_ctr_intv) rc;
-	if (trx_rate_ctr_threshold_del(&ctr) < 0) {
-		vty_out(vty, "no ctr-error-threshold: Entry to delete not found%s", VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_chan, cfg_chan_cmd,
-	"chan <0-100>",
-	"Select a channel to configure\n"
-	"Channel index\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-	int idx = atoi(argv[0]);
-
-	if (idx >= TRX_CHAN_MAX) {
-		vty_out(vty, "Chan list full.%s", VTY_NEWLINE);
-		return CMD_WARNING;
-	} else if (trx->cfg.multi_arfcn && trx->cfg.num_chans >= TRX_MCHAN_MAX) {
-		vty_out(vty, "Up to %i channels are supported for multi-TRX mode%s",
-			TRX_MCHAN_MAX, VTY_NEWLINE);
-		return CMD_WARNING;
-	}
-
-	if (trx->cfg.num_chans < idx) { /* Unexisting or creating non-consecutive */
-		vty_out(vty, "Non-existent or non-consecutive chan %d.%s",
-				idx, VTY_NEWLINE);
-		return CMD_WARNING;
-	} else if (trx->cfg.num_chans == idx)  { /* creating it */
-		trx->cfg.num_chans++;
-		trx->cfg.chans[idx].trx = trx;
-		trx->cfg.chans[idx].idx = idx;
-	}
-
-	vty->node = CHAN_NODE;
-	vty->index = &trx->cfg.chans[idx];
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_chan_rx_path, cfg_chan_rx_path_cmd,
-	"rx-path NAME",
-	"Set the Rx Path\n"
-	"Rx Path name\n")
-{
-	struct trx_chan *chan = vty->index;
-
-	osmo_talloc_replace_string(chan->trx, &chan->rx_path, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-DEFUN(cfg_chan_tx_path, cfg_chan_tx_path_cmd,
-	"tx-path NAME",
-	"Set the Tx Path\n"
-	"Tx Path name\n")
-{
-	struct trx_chan *chan = vty->index;
-
-	osmo_talloc_replace_string(chan->trx, &chan->tx_path, argv[0]);
-
-	return CMD_SUCCESS;
-}
-
-static int dummy_config_write(struct vty *v)
-{
-	return CMD_SUCCESS;
-}
-
-static int config_write_trx(struct vty *vty)
-{
-	struct trx_chan *chan;
-	int i;
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	vty_out(vty, "trx%s", VTY_NEWLINE);
-	if (trx->cfg.bind_addr)
-		vty_out(vty, " bind-ip %s%s", trx->cfg.bind_addr, VTY_NEWLINE);
-	if (trx->cfg.remote_addr)
-		vty_out(vty, " remote-ip %s%s", trx->cfg.remote_addr, VTY_NEWLINE);
-	if (trx->cfg.base_port != DEFAULT_TRX_PORT)
-		vty_out(vty, " base-port %u%s", trx->cfg.base_port, VTY_NEWLINE);
-	if (trx->cfg.dev_args)
-		vty_out(vty, " dev-args %s%s", trx->cfg.dev_args, VTY_NEWLINE);
-	if (trx->cfg.tx_sps != DEFAULT_TX_SPS)
-		vty_out(vty, " tx-sps %u%s", trx->cfg.tx_sps, VTY_NEWLINE);
-	if (trx->cfg.rx_sps != DEFAULT_RX_SPS)
-		vty_out(vty, " rx-sps %u%s", trx->cfg.rx_sps, VTY_NEWLINE);
-	if (trx->cfg.rtsc_set)
-		vty_out(vty, " test rtsc %u%s", trx->cfg.rtsc, VTY_NEWLINE);
-	if (trx->cfg.rach_delay_set)
-		vty_out(vty, " test rach-delay %u%s", trx->cfg.rach_delay, VTY_NEWLINE);
-	if (trx->cfg.clock_ref != REF_INTERNAL)
-		vty_out(vty, " clock-ref %s%s", get_value_string(clock_ref_names, trx->cfg.clock_ref), VTY_NEWLINE);
-	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);
-	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);
-	if (trx->cfg.sched_rr != 0)
-		vty_out(vty, " rt-prio %u%s", trx->cfg.sched_rr, VTY_NEWLINE);
-	if (trx->cfg.stack_size != 0)
-		vty_out(vty, " stack-size %u%s", trx->cfg.stack_size, VTY_NEWLINE);
-	trx_rate_ctr_threshold_write_config(vty, " ");
-
-	for (i = 0; i < trx->cfg.num_chans; i++) {
-		chan = &trx->cfg.chans[i];
-		vty_out(vty, " chan %u%s", chan->idx, VTY_NEWLINE);
-		if (chan->rx_path)
-			vty_out(vty, "  rx-path %s%s", chan->rx_path, VTY_NEWLINE);
-		if (chan->tx_path)
-			vty_out(vty, "  tx-path %s%s", chan->tx_path, VTY_NEWLINE);
-	}
-
-	return CMD_SUCCESS;
-}
-
-static void trx_dump_vty(struct vty *vty, struct trx_ctx *trx)
-{
-	struct trx_chan *chan;
-	int i;
-	vty_out(vty, "TRX Config:%s", VTY_NEWLINE);
-	vty_out(vty, " Local IP: %s%s", trx->cfg.bind_addr, VTY_NEWLINE);
-	vty_out(vty, " Remote IP: %s%s", trx->cfg.remote_addr, VTY_NEWLINE);
-	vty_out(vty, " TRX Base Port: %u%s", trx->cfg.base_port, VTY_NEWLINE);
-	vty_out(vty, " Device args: %s%s", trx->cfg.dev_args, VTY_NEWLINE);
-	vty_out(vty, " Tx Samples-per-Symbol: %u%s", trx->cfg.tx_sps, VTY_NEWLINE);
-	vty_out(vty, " Rx Samples-per-Symbol: %u%s", trx->cfg.rx_sps, VTY_NEWLINE);
-	vty_out(vty, " Test Mode: TSC: %u (%s)%s", trx->cfg.rtsc,
-		trx->cfg.rtsc_set ? "Enabled" : "Disabled", VTY_NEWLINE);
-	vty_out(vty, " Test Mode: RACH Delay: %u (%s)%s", trx->cfg.rach_delay,
-		trx->cfg.rach_delay_set ? "Enabled" : "Disabled", VTY_NEWLINE);
-	vty_out(vty, " C0 Filler Table: %s%s", get_value_string(filler_names, trx->cfg.filler), VTY_NEWLINE);
-	vty_out(vty, " Clock Reference: %s%s", get_value_string(clock_ref_names, trx->cfg.clock_ref), VTY_NEWLINE);
-	vty_out(vty, " Multi-Carrier: %s%s", trx->cfg.multi_arfcn ? "Enabled" : "Disabled", VTY_NEWLINE);
-	vty_out(vty, " Tuning offset: %f%s", trx->cfg.offset, VTY_NEWLINE);
-	vty_out(vty, " RSSI to dBm offset: %f%s", trx->cfg.rssi_offset, VTY_NEWLINE);
-	vty_out(vty, " Swap channels: %s%s", trx->cfg.swap_channels ? "Enabled" : "Disabled", VTY_NEWLINE);
-	vty_out(vty, " EDGE support: %s%s", trx->cfg.egprs ? "Enabled" : "Disabled", VTY_NEWLINE);
-	vty_out(vty, " Extended RACH support: %s%s", trx->cfg.ext_rach ? "Enabled" : "Disabled", VTY_NEWLINE);
-	vty_out(vty, " Real Time Priority: %u (%s)%s", trx->cfg.sched_rr,
-		trx->cfg.sched_rr ? "Enabled" : "Disabled", VTY_NEWLINE);
-	vty_out(vty, " Stack size per Thread in BYTE (0 = OS default): %u%s", trx->cfg.stack_size, VTY_NEWLINE);
-	vty_out(vty, " Channels: %u%s", trx->cfg.num_chans, VTY_NEWLINE);
-	for (i = 0; i < trx->cfg.num_chans; i++) {
-		chan = &trx->cfg.chans[i];
-		vty_out(vty, "  Channel %u:%s", chan->idx, VTY_NEWLINE);
-		if (chan->rx_path)
-			vty_out(vty, "   Rx Path: %s%s", chan->rx_path, VTY_NEWLINE);
-		if (chan->tx_path)
-			vty_out(vty, "   Tx Path: %s%s", chan->tx_path, VTY_NEWLINE);
-	}
-}
-
-DEFUN(show_trx, show_trx_cmd,
-	"show trx",
-	SHOW_STR "Display information on the TRX\n")
-{
-	struct trx_ctx *trx = trx_from_vty(vty);
-
-	trx_dump_vty(vty, trx);
-
-	return CMD_SUCCESS;
-}
-
-static int trx_vty_is_config_node(struct vty *vty, int node)
-{
-	switch (node) {
-	case TRX_NODE:
-	case CHAN_NODE:
-		return 1;
-	default:
-		return 0;
-	}
-}
-
-static int trx_vty_go_parent(struct vty *vty)
-{
-	switch (vty->node) {
-	case TRX_NODE:
-		vty->node = CONFIG_NODE;
-		vty->index = NULL;
-		vty->index_sub = NULL;
-		break;
-	case CHAN_NODE:
-		vty->node = TRX_NODE;
-		vty->index = NULL;
-		vty->index_sub = NULL;
-		break;
-	default:
-		vty->node = CONFIG_NODE;
-		vty->index = NULL;
-		vty->index_sub = NULL;
-	}
-
-	return vty->node;
-}
-
-static const char trx_copyright[] =
-	"Copyright (C) 2007-2014 Free Software Foundation, Inc.\r\n"
-	"Copyright (C) 2013 Thomas Tsou <tom@tsou.cc>\r\n"
-	"Copyright (C) 2015 Ettus Research LLC\r\n"
-	"Copyright (C) 2017-2018 by sysmocom s.f.m.c. GmbH <info@sysmocom.de>\r\n"
-	"License AGPLv3+: GNU AGPL version 3 or later <http://gnu.org/licenses/agpl-3.0.html>\r\n"
-	"This is free software: you are free to change and redistribute it.\r\n"
-	"There is NO WARRANTY, to the extent permitted by law.\r\n";
-
-struct vty_app_info g_vty_info = {
-	.name		= "OsmoTRX",
-	.version	= PACKAGE_VERSION,
-	.copyright	= trx_copyright,
-	.go_parent_cb	= trx_vty_go_parent,
-	.is_config_node	= trx_vty_is_config_node,
-};
-
-struct trx_ctx *vty_trx_ctx_alloc(void *talloc_ctx)
-{
-	struct trx_ctx * trx = talloc_zero(talloc_ctx, struct trx_ctx);
-
-	trx->cfg.bind_addr =  talloc_strdup(trx, DEFAULT_TRX_IP);
-	trx->cfg.remote_addr = talloc_strdup(trx, DEFAULT_TRX_IP);
-	trx->cfg.base_port = DEFAULT_TRX_PORT;
-	trx->cfg.tx_sps = DEFAULT_TX_SPS;
-	trx->cfg.rx_sps = DEFAULT_RX_SPS;
-	trx->cfg.filler = FILLER_ZERO;
-
-	return trx;
-}
-
-int trx_vty_init(struct trx_ctx* trx)
-{
-	g_trx_ctx = trx;
-	install_element_ve(&show_trx_cmd);
-
-	install_element(CONFIG_NODE, &cfg_trx_cmd);
-
-	install_node(&trx_node, config_write_trx);
-	install_element(TRX_NODE, &cfg_bind_ip_cmd);
-	install_element(TRX_NODE, &cfg_remote_ip_cmd);
-	install_element(TRX_NODE, &cfg_base_port_cmd);
-	install_element(TRX_NODE, &cfg_dev_args_cmd);
-	install_element(TRX_NODE, &cfg_tx_sps_cmd);
-	install_element(TRX_NODE, &cfg_rx_sps_cmd);
-	install_element(TRX_NODE, &cfg_test_rtsc_cmd);
-	install_element(TRX_NODE, &cfg_test_rach_delay_cmd);
-	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_rssi_offset_cmd);
-	install_element(TRX_NODE, &cfg_swap_channels_cmd);
-	install_element(TRX_NODE, &cfg_egprs_cmd);
-	install_element(TRX_NODE, &cfg_ext_rach_cmd);
-	install_element(TRX_NODE, &cfg_rt_prio_cmd);
-	install_element(TRX_NODE, &cfg_filler_cmd);
-	install_element(TRX_NODE, &cfg_ctr_error_threshold_cmd);
-	install_element(TRX_NODE, &cfg_no_ctr_error_threshold_cmd);
-	install_element(TRX_NODE, &cfg_stack_size_cmd);
-
-	install_element(TRX_NODE, &cfg_chan_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);
-
-	return 0;
-}

CommonLibs/trx_vty.h

@@ -1,73 +0,0 @@
-#pragma once
-
-#include <osmocom/vty/command.h>
-
-#include "config_defs.h"
-
-extern struct vty_app_info g_vty_info;
-
-/* Maximum number of physical RF channels */
-#define TRX_CHAN_MAX 8
-/* Maximum number of carriers in multi-ARFCN mode */
-#define TRX_MCHAN_MAX 3
-
-/* Samples-per-symbol for downlink path
- *     4 - Uses precision modulator (more computation, less distortion)
- *     1 - Uses minimized modulator (less computation, more distortion)
- *
- *     Other values are invalid. Receive path (uplink) is always
- *     downsampled to 1 sps. Default to 4 sps for all cases.
- */
-#define DEFAULT_TX_SPS		4
-
-/*
- * Samples-per-symbol for uplink (receiver) path
- *     Do not modify this value. EDGE configures 4 sps automatically on
- *     B200/B210 devices only. Use of 4 sps on the receive path for other
- *     configurations is not supported.
- */
-#define DEFAULT_RX_SPS		1
-
-/* Default configuration parameters */
-#define DEFAULT_TRX_PORT	5700
-#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;
-		bool rtsc_set;
-		unsigned int rach_delay;
-		bool rach_delay_set;
-		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;
-};
-
-int trx_vty_init(struct trx_ctx* trx);
-struct trx_ctx *vty_trx_ctx_alloc(void *talloc_ctx);

GSM/GSMCommon.cpp

@@ -2,8 +2,6 @@
 * Copyright 2008 Free Software Foundation, Inc.
 * Copyright 2011 Range Networks, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -56,10 +54,7 @@ const BitVector GSM::gEdgeTrainingSequence[] = {
 
 const BitVector GSM::gDummyBurst("0001111101101110110000010100100111000001001000100000001111100011100010111000101110001010111010010100011001100111001111010011111000100101111101010000");
 
-/* 3GPP TS 05.02, section 5.2.7 "Access burst (AB)", synch. sequence bits */
-const BitVector GSM::gRACHSynchSequenceTS0("01001011011111111001100110101010001111000");  /* GSM, GMSK (default) */
-const BitVector GSM::gRACHSynchSequenceTS1("01010100111110001000011000101111001001101");  /* EGPRS, 8-PSK */
-const BitVector GSM::gRACHSynchSequenceTS2("11101111001001110101011000001101101110111");  /* EGPRS, GMSK */
+const BitVector GSM::gRACHSynchSequence("01001011011111111001100110101010001111000");
 
 //                               |-head-||---------midamble----------------------||--------------data----------------||t|
 const BitVector GSM::gRACHBurst("0011101001001011011111111001100110101010001111000110111101111110000111001001010110011000");

GSM/GSMCommon.h

@@ -2,8 +2,6 @@
 /*
 * Copyright 2008-2011 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -54,9 +52,7 @@ extern const BitVector gEdgeTrainingSequence[];
 extern const BitVector gDummyBurst;
 
 /** Random access burst synch. sequence */
-extern const BitVector gRACHSynchSequenceTS0;
-extern const BitVector gRACHSynchSequenceTS1;
-extern const BitVector gRACHSynchSequenceTS2;
+extern const BitVector gRACHSynchSequence;
 /** Random access burst synch. sequence, GSM 05.02 5.2.7 */
 extern const BitVector gRACHBurst;
 

INSTALLATION

@@ -0,0 +1,19 @@
+Installation Requirements
+
+
+
+osmo-trx compiles to a simple Unix binary and does not require special
+installation.
+
+One some systems (Ubuntu), you will need to define LIBS = -lpthread prior to
+running configure.
+
+To run osmo-trx, the following should be installed:
+	libuhd (https://gnuradio.org).
+	This is part of the GNURadio installation.
+
+For information on specific executables, see tests/README.tests and
+apps/README.apps.
+
+See https://osmocom.org/projects/osmotrx/wiki/OsmoTRX for more
+information.

Makefile.am

@@ -28,20 +28,17 @@ AM_CXXFLAGS = -Wall -pthread
 
 # Order must be preserved
 SUBDIRS = \
-	doc \
 	CommonLibs \
 	GSM \
 	Transceiver52M \
-	contrib \
 	tests
 
 EXTRA_DIST = \
+	autogen.sh \
+	INSTALLATION \
 	LEGAL \
 	COPYING \
-	README.md
-
-AM_DISTCHECK_CONFIGURE_FLAGS = \
-	--with-systemdsystemunitdir=$$dc_install_base/$(systemdsystemunitdir)
+	README
 
 .PHONY: release
 

Makefile.common

@@ -18,6 +18,9 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+top_srcdir = $(abs_top_srcdir)
+top_builddir = $(abs_top_builddir)
+
 COMMON_INCLUDEDIR = $(top_srcdir)/CommonLibs
 GSM_INCLUDEDIR = $(top_srcdir)/GSM
 
@@ -30,9 +33,9 @@ COMMON_LA = $(top_builddir)/CommonLibs/libcommon.la
 GSM_LA = $(top_builddir)/GSM/libGSM.la
 
 if ARCH_ARM
-ARCH_LA = $(top_builddir)/Transceiver52M/arch/arm/libarch.la
+ARCH_LA = $(top_builddir)/Transceiver52M/arm/libarch.la
 else
-ARCH_LA = $(top_builddir)/Transceiver52M/arch/x86/libarch.la
+ARCH_LA = $(top_builddir)/Transceiver52M/x86/libarch.la
 endif
 
 MOSTLYCLEANFILES = *~

README

@@ -0,0 +1,116 @@
+This is the interface to the transcevier.
+
+Each TRX Manager UDP socket interface represents a single ARFCN.
+Each of these per-ARFCN interfaces is a pair of UDP sockets, one for control and one for data.
+Give a base port B (5700), the master clock interface is at port P=B.
+The TRX-side control interface for C(N) is on  port P=B+2N+1 and the data interface is on an odd numbered port P=B+2N+2.
+The corresponding core-side interface for every socket is at P+100.
+For any given build, the number of ARFCN interfaces can be fixed.
+
+
+
+Indications on the Master Clock Interface
+
+The master clock interface is output only (from the radio).
+Messages are "indications".
+
+CLOCK gives the current value of the transceiver clock to be used by the core.
+This message is sent whenever a trasmission packet arrives that is too late or too early.  The clock value is NOT the current transceiver time.  It is a time setting the the core should use to give better packet arrival times.
+IND CLOCK <totalFrames>
+
+
+
+Commands on the Per-ARFCN Control Interface
+
+The per-ARFCN control interface uses a command-reponse protocol.
+Commands are NULL-terminated ASCII strings, one per UDP socket.
+Each command has a corresponding response.
+Every command is of the form:
+
+CMD <cmdtype> [params]
+
+The <cmdtype> is the actual command.
+Parameters are optional depending on the commands type.
+Every response is of the form:
+
+RSP <cmdtype> <status> [result]
+
+The <status> is 0 for success and a non-zero error code for failure.
+Successful responses may include results, depending on the command type.
+
+
+Power Control
+
+POWEROFF shuts off transmitter power and stops the demodulator.
+CMD POWEROFF
+RSP POWEROFF <status>
+
+POWERON starts the transmitter and starts the demodulator.  Initial power level is very low.
+This command fails if the transmitter and receiver are not yet tuned.
+This command fails if the transmit or receive frequency creates a conflict with another ARFCN that is already runnng.
+If the transceiver is already on, it response with success to this command.
+CMD POWERON
+RSP POWERON <status>
+
+SETPOWER sets output power in dB wrt full scale.
+This command fails if the transmitter and receiver are not running.
+CMD SETPOWER <dB>
+RSP SETPOWER <status> <dB>
+
+ADJPOWER adjusts power by the given dB step.  Response returns resulting power level wrt full scale.
+This command fails if the transmitter and receiver are not running.
+CMD ADJPOWER <dBStep>
+RSP ADJPOWER <status> <dBLevel>
+
+
+Tuning Control
+
+RXTUNE tunes the receiver to a given frequency in kHz.
+This command fails if the receiver is already running.
+(To re-tune you stop the radio, re-tune, and restart.)
+This command fails if the transmit or receive frequency creates a conflict with another ARFCN that is already runnng.
+CMD RXTUNE <kHz>
+RSP RXTUNE <status> <kHz>
+
+TXTUNE tunes the transmitter to a given frequency in kHz.
+This command fails if the transmitter is already running.
+(To re-tune you stop the radio, re-tune, and restart.)
+This command fails if the transmit or receive frequency creates a conflict with another ARFCN that is already runnng.
+CMD TXTUNE <kHz>
+RSP TXTUNE <status> <kHz>
+
+
+Timeslot Control
+
+SETSLOT sets the format of the uplink timeslots in the ARFCN.
+The <timeslot> indicates the timeslot of interest.
+The <chantype> indicates the type of channel that occupies the timeslot.
+A chantype of zero indicates the timeslot is off.
+CMD SETSLOT <timeslot> <chantype>
+RSP SETSLOT <status> <timeslot> <chantype>
+
+
+Messages on the per-ARFCN Data Interface
+
+Messages on the data interface carry one radio burst per UDP message.
+
+
+Received Data Burst
+
+1 byte timeslot index
+4 bytes GSM frame number, big endian
+1 byte RSSI in -dBm
+2 bytes correlator timing offset in 1/256 symbol steps, 2's-comp, big endian
+148 bytes soft symbol estimates, 0 -> definite "0", 255 -> definite "1"
+
+
+Transmit Data Burst
+
+1 byte timeslot index
+4 bytes GSM frame number, big endian
+1 byte transmit level wrt ARFCN max, -dB (attenuation)
+148 bytes output symbol values, 0 & 1
+
+
+
+

README.md

@@ -1,66 +0,0 @@
-About OsmTRX
-============
-
-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"
-
-OsmoTRX is 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.
-
-Homepage
---------
-
-The official homepage of the project is
-<https://osmocom.org/projects/osmotrx/wiki/OsmoTRX>
-
-GIT Repository
---------------
-
-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/>
-
-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>.
-
-Mailing List
-------------
-
-Discussions related to OsmoTRX are happening on the openbsc@lists.osmocom.org
-mailing list, please see <https://lists.osmocom.org/mailman/listinfo/openbsc>
-for subscription options and the list archive.
-
-Please observe the [Osmocom Mailing List
-Rules](https://osmocom.org/projects/cellular-infrastructure/wiki/Mailing_List_Rules)
-when posting.
-
-Contributing
-------------
-
-Our coding standards are described at
-<https://osmocom.org/projects/cellular-infrastructure/wiki/Coding_standards>
-
-We us a gerrit based patch submission/review process for managing contributions.
-Please see <https://osmocom.org/projects/cellular-infrastructure/wiki/Gerrit>
-for more details
-
-The current patch queue for OsmoTRX can be seen at
-<https://gerrit.osmocom.org/q/project:osmo-trx+status:open>

Transceiver52M/Channelizer.cpp

@@ -4,8 +4,6 @@
  * Copyright (C) 2012-2014 Tom Tsou <tom@tsou.cc>
  * Copyright (C) 2015 Ettus Research LLC
  *
- * 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
@@ -30,8 +28,8 @@
 #include "Channelizer.h"
 
 extern "C" {
-#include "fft.h"
-#include "convolve.h"
+#include "common/fft.h"
+#include "common/convolve.h"
 }
 
 static void deinterleave(const float *in, size_t ilen,
@@ -90,7 +88,7 @@ bool Channelizer::rotate(const float *in, size_t len)
 		convolve_real(hInputs[i], blockLen,
 			      subFilters[i], hLen,
 			      hOutputs[i], blockLen,
-			      0, blockLen);
+			      0, blockLen, 1, 0);
 	}
 
 	cxvec_fft(fftHandle);

Transceiver52M/ChannelizerBase.cpp

@@ -4,8 +4,6 @@
  * Copyright (C) 2012-2014 Tom Tsou <tom@tsou.cc>
  * Copyright (C) 2015 Ettus Research LLC 
  *
- * 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
@@ -31,7 +29,7 @@
 #include "ChannelizerBase.h"
 
 extern "C" {
-#include "fft.h"
+#include "common/fft.h"
 }
 
 static float sinc(float x)
@@ -228,8 +226,7 @@ bool ChannelizerBase::checkLen(size_t innerLen, size_t outerLen)
  * Setup channelizer paramaters
  */
 ChannelizerBase::ChannelizerBase(size_t m, size_t blockLen, size_t hLen)
-	: subFilters(NULL), hInputs(NULL), hOutputs(NULL), hist(NULL),
-	  fftInput(NULL), fftOutput(NULL), fftHandle(NULL)
+	: fftInput(NULL), fftOutput(NULL), fftHandle(NULL)
 {
 	this->m = m;
 	this->hLen = hLen;
@@ -242,7 +239,7 @@ ChannelizerBase::~ChannelizerBase()
 
 	for (size_t i = 0; i < m; i++) {
 		free(subFilters[i]);
-		delete[] hist[i];
+		delete hist[i];
 	}
 
 	fft_free(fftInput);

Transceiver52M/Makefile.am

@@ -21,13 +21,28 @@
 
 include $(top_srcdir)/Makefile.common
 
-SUBDIRS = arch device
+AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/common
+AM_CXXFLAGS = -lpthread
 
-AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES) -I${srcdir}/arch/common -I${srcdir}/device/common
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
-AM_CFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS)
+SUBDIRS = arm x86
 
-noinst_LTLIBRARIES = libtransceiver_common.la
+if USRP1
+AM_CPPFLAGS += $(USRP_CFLAGS)
+else
+AM_CPPFLAGS += $(UHD_CFLAGS)
+endif
+
+rev2dir = $(datadir)/usrp/rev2
+rev4dir = $(datadir)/usrp/rev4
+
+dist_rev2_DATA = std_inband.rbf
+dist_rev4_DATA = std_inband.rbf
+
+EXTRA_DIST = \
+	README \
+	README.Talgorithm
+
+noinst_LTLIBRARIES = libtransceiver.la
 
 COMMON_SOURCES = \
 	radioInterface.cpp \
@@ -40,67 +55,49 @@ COMMON_SOURCES = \
 	ChannelizerBase.cpp \
 	Channelizer.cpp \
 	Synthesis.cpp \
-	proto_trxd.c
+	common/fft.c
 
-libtransceiver_common_la_SOURCES = \
+libtransceiver_la_SOURCES = \
 	$(COMMON_SOURCES) \
 	Resampler.cpp \
 	radioInterfaceResamp.cpp \
 	radioInterfaceMulti.cpp
 
+bin_PROGRAMS = osmo-trx
+
 noinst_HEADERS = \
 	Complex.h \
 	radioInterface.h \
 	radioVector.h \
 	radioClock.h \
+	radioDevice.h \
 	radioBuffer.h \
 	sigProcLib.h \
 	signalVector.h \
 	Transceiver.h \
+	USRPDevice.h \
 	Resampler.h \
 	ChannelizerBase.h \
 	Channelizer.h \
 	Synthesis.h \
-	proto_trxd.h
+	common/convolve.h \
+	common/convert.h \
+	common/scale.h \
+	common/mult.h \
+	common/fft.h
 
-COMMON_LDADD = \
-	libtransceiver_common.la \
+osmo_trx_SOURCES = osmo-trx.cpp
+osmo_trx_LDADD = \
+	libtransceiver.la \
 	$(ARCH_LA) \
 	$(GSM_LA) \
 	$(COMMON_LA) \
-	$(FFTWF_LIBS) \
-	$(LIBOSMOCORE_LIBS) \
-	$(LIBOSMOCTRL_LIBS) \
-	$(LIBOSMOVTY_LIBS)
+	$(FFTWF_LIBS)
 
-bin_PROGRAMS =
-
-if DEVICE_UHD
-bin_PROGRAMS += osmo-trx-uhd
-osmo_trx_uhd_SOURCES = osmo-trx.cpp
-osmo_trx_uhd_LDADD = \
-	$(builddir)/device/uhd/libdevice.la \
-	$(COMMON_LDADD) \
-	$(UHD_LIBS)
-osmo_trx_uhd_CPPFLAGS  = $(AM_CPPFLAGS) $(UHD_CFLAGS)
-endif
-
-if DEVICE_USRP1
-bin_PROGRAMS += osmo-trx-usrp1
-osmo_trx_usrp1_SOURCES = osmo-trx.cpp
-osmo_trx_usrp1_LDADD = \
-	$(builddir)/device/usrp1/libdevice.la \
-	$(COMMON_LDADD) \
-	$(USRP_LIBS)
-osmo_trx_usrp1_CPPFLAGS  = $(AM_CPPFLAGS) $(USRP_CFLAGS)
-endif
-
-if DEVICE_LMS
-bin_PROGRAMS += osmo-trx-lms
-osmo_trx_lms_SOURCES = osmo-trx.cpp
-osmo_trx_lms_LDADD = \
-	$(builddir)/device/lms/libdevice.la \
-	$(COMMON_LDADD) \
-	$(LMS_LIBS)
-osmo_trx_lms_CPPFLAGS  = $(AM_CPPFLAGS) $(LMS_CFLAGS)
+if USRP1
+libtransceiver_la_SOURCES += USRPDevice.cpp
+osmo_trx_LDADD += $(USRP_LIBS)
+else
+libtransceiver_la_SOURCES += UHDDevice.cpp
+osmo_trx_LDADD += $(UHD_LIBS)
 endif

Transceiver52M/README

@@ -0,0 +1,35 @@
+The Transceiver
+
+The transceiver consists of three modules:
+   --- transceiver
+   --- radioInterface
+   --- USRPDevice
+
+The USRPDevice module is basically a driver that reads/writes
+packets to a USRP with two RFX900 daughterboards, board 
+A is the Tx chain and board B is the Rx chain.  
+
+The radioInterface module is basically an interface b/w the
+transceiver and the USRP.   It operates the basestation clock
+based upon the sample count of received USRP samples.  Packets 
+from the USRP are queued and segmented into GSM bursts that are
+passed up to the transceiver; bursts from the transceiver are
+passed down to the USRP. 
+
+The transceiver basically operates "layer 0" of the GSM stack,
+performing the modulation, detection, and demodulation of GSM 
+bursts.  It communicates with the GSM stack via three UDP sockets,
+one socket for data, one for control messages, and one socket to
+pass clocking information.  The transceiver contains a priority
+queue to sort to-be-transmitted bursts, and a filler table to fill
+in timeslots that do not have bursts in the priority queue.  The
+transceiver tries to stay ahead of the basestation clock, adapting 
+its latency when underruns are reported by the radioInterface/USRP.
+Received bursts (from the radioInterface) pass through a simple 
+energy detector, a RACH or midamble correlator, and a DFE-based demodulator.
+
+NOTE: There's a SWLOOPBACK #define statement, where the USRP is replaced
+with a memory buffer.  In this mode, data written to the USRP is actually stored 
+in a buffer, and read commands to the USRP simply pull data from this buffer.
+This was very useful in early testing, and still may be useful in testing basic
+Transceiver and radioInterface functionality. 

Transceiver52M/Resampler.cpp

@@ -2,8 +2,6 @@
  * Rational Sample Rate Conversion
  * Copyright (C) 2012, 2013  Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -145,7 +143,7 @@ int Resampler::rotate(const float *in, size_t in_len, float *out, size_t out_len
 		convolve_real(in, in_len,
 			      reinterpret_cast<float *>(partitions[path]),
 			      filt_len, &out[2 * i], out_len - i,
-			      n, 1);
+			      n, 1, 1, 0);
 	}
 
 	return out_len;

Transceiver52M/Resampler.h

@@ -2,8 +2,6 @@
  * Rational Sample Rate Conversion
  * Copyright (C) 2012, 2013  Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either

Transceiver52M/Synthesis.cpp

@@ -4,8 +4,6 @@
  * Copyright (C) 2012-2014 Tom Tsou <tom@tsou.cc>
  * Copyright (C) 2015 Ettus Research LLC
  *
- * 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
@@ -31,8 +29,8 @@
 #include "Synthesis.h"
 
 extern "C" {
-#include "fft.h"
-#include "convolve.h"
+#include "common/fft.h"
+#include "common/convolve.h"
 }
 
 static void interleave(float **in, size_t ilen,
@@ -104,7 +102,7 @@ bool Synthesis::rotate(float *out, size_t len)
 		convolve_real(hInputs[i], blockLen,
 			      subFilters[i], hLen,
 			      hOutputs[i], blockLen,
-			      0, blockLen);
+			      0, blockLen, 1, 0);
 	}
 
 	/* Interleave into output vector */

Transceiver52M/Transceiver.cpp

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008, 2009, 2010 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: GPL-3.0+
-*
 * This software is distributed under the terms of the GNU Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -24,21 +22,11 @@
 */
 
 #include <stdio.h>
-#include <netinet/in.h>
 #include <iomanip>      // std::setprecision
 #include <fstream>
 #include "Transceiver.h"
 #include <Logger.h>
 
-extern "C" {
-#include "osmo_signal.h"
-#include "proto_trxd.h"
-
-#include <osmocom/core/utils.h>
-#include <osmocom/core/socket.h>
-#include <osmocom/core/bits.h>
-}
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -47,6 +35,12 @@ using namespace GSM;
 
 #define USB_LATENCY_INTRVL		10,0
 
+#if USE_UHD
+#  define USB_LATENCY_MIN		6,7
+#else
+#  define USB_LATENCY_MIN		1,1
+#endif
+
 /* Number of running values use in noise average */
 #define NOISE_CNT			20
 
@@ -77,7 +71,7 @@ TransceiverState::~TransceiverState()
   }
 }
 
-bool TransceiverState::init(FillerType filler, size_t sps, float scale, size_t rtsc, unsigned rach_delay)
+bool TransceiverState::init(int filler, size_t sps, float scale, size_t rtsc, unsigned rach_delay)
 {
   signalVector *burst;
 
@@ -87,19 +81,19 @@ bool TransceiverState::init(FillerType filler, size_t sps, float scale, size_t r
   for (size_t n = 0; n < 8; n++) {
     for (size_t i = 0; i < 102; i++) {
       switch (filler) {
-      case FILLER_DUMMY:
+      case Transceiver::FILLER_DUMMY:
         burst = generateDummyBurst(sps, n);
         break;
-      case FILLER_NORM_RAND:
+      case Transceiver::FILLER_NORM_RAND:
         burst = genRandNormalBurst(rtsc, sps, n);
         break;
-      case FILLER_EDGE_RAND:
+      case Transceiver::FILLER_EDGE_RAND:
         burst = generateEdgeBurst(rtsc);
         break;
-      case FILLER_ACCESS_RAND:
+      case Transceiver::FILLER_ACCESS_RAND:
         burst = genRandAccessBurst(rach_delay, sps, n);
         break;
-      case FILLER_ZERO:
+      case Transceiver::FILLER_ZERO:
       default:
         burst = generateEmptyBurst(sps, n);
       }
@@ -108,8 +102,8 @@ bool TransceiverState::init(FillerType filler, size_t sps, float scale, size_t r
       fillerTable[i][n] = burst;
     }
 
-    if ((filler == FILLER_NORM_RAND) ||
-        (filler == FILLER_EDGE_RAND)) {
+    if ((filler == Transceiver::FILLER_NORM_RAND) ||
+        (filler == Transceiver::FILLER_EDGE_RAND)) {
         chanType[n] = TSC;
     }
   }
@@ -123,12 +117,12 @@ Transceiver::Transceiver(int wBasePort,
                          size_t tx_sps, size_t rx_sps, size_t chans,
                          GSM::Time wTransmitLatency,
                          RadioInterface *wRadioInterface,
-                         double wRssiOffset, int wStackSize)
+                         double wRssiOffset)
   : 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),
+    mClockSocket(TRXAddress, wBasePort, GSMcoreAddress, wBasePort + 100),
+    mTransmitLatency(wTransmitLatency), mRadioInterface(wRadioInterface),
+    rssiOffset(wRssiOffset),
+    mSPSTx(tx_sps), mSPSRx(rx_sps), mChans(chans), mEdge(false), mOn(false), mForceClockInterface(false),
     mTxFreq(0.0), mRxFreq(0.0), mTSC(0), mMaxExpectedDelayAB(0), mMaxExpectedDelayNB(0),
     mWriteBurstToDiskMask(0)
 {
@@ -147,19 +141,14 @@ Transceiver::~Transceiver()
 
   sigProcLibDestroy();
 
-  if (mClockSocket >= 0)
-    close(mClockSocket);
-
   for (size_t i = 0; i < mChans; i++) {
     mControlServiceLoopThreads[i]->cancel();
     mControlServiceLoopThreads[i]->join();
     delete mControlServiceLoopThreads[i];
 
     mTxPriorityQueues[i].clear();
-    if (mCtrlSockets[i] >= 0)
-      close(mCtrlSockets[i]);
-    if (mDataSockets[i] >= 0)
-      close(mDataSockets[i]);
+    delete mCtrlSockets[i];
+    delete mDataSockets[i];
   }
 }
 
@@ -172,8 +161,7 @@ Transceiver::~Transceiver()
  * 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 filler, size_t rtsc, unsigned rach_delay, bool edge)
 {
   int d_srcport, d_dstport, c_srcport, c_dstport;
 
@@ -187,11 +175,10 @@ 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, -1);
+  mDataSockets.resize(mChans);
+  mCtrlSockets.resize(mChans);
   mControlServiceLoopThreads.resize(mChans);
   mTxPriorityQueueServiceLoopThreads.resize(mChans);
   mRxServiceLoopThreads.resize(mChans);
@@ -199,37 +186,20 @@ bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
   mTxPriorityQueues.resize(mChans);
   mReceiveFIFO.resize(mChans);
   mStates.resize(mChans);
-  mVersionTRXD.resize(mChans);
 
   /* Filler table retransmissions - support only on channel 0 */
   if (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,
-				    OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
-
   for (size_t i = 0; i < mChans; i++) {
     c_srcport = mBasePort + 2 * i + 1;
     c_dstport = mBasePort + 2 * i + 101;
     d_srcport = mBasePort + 2 * i + 2;
     d_dstport = mBasePort + 2 * i + 102;
 
-    mCtrlSockets[i] = osmo_sock_init2(AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP,
-                                      mLocalAddr.c_str(), c_srcport,
-                                      mRemoteAddr.c_str(), c_dstport,
-				      OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
-    if (mCtrlSockets[i] < 0)
-      return false;
-
-    mDataSockets[i] = osmo_sock_init2(AF_UNSPEC, SOCK_DGRAM, IPPROTO_UDP,
-                                      mLocalAddr.c_str(), d_srcport,
-                                      mRemoteAddr.c_str(), d_dstport,
-				      OSMO_SOCK_F_BIND | OSMO_SOCK_F_CONNECT);
-    if (mCtrlSockets[i] < 0)
-      return false;
+    mCtrlSockets[i] = new UDPSocket(mLocalAddr.c_str(), c_srcport, mRemoteAddr.c_str(), c_dstport);
+    mDataSockets[i] = new UDPSocket(mLocalAddr.c_str(), d_srcport, mRemoteAddr.c_str(), d_dstport);
   }
 
   /* Randomize the central clock */
@@ -241,12 +211,10 @@ bool Transceiver::init(FillerType filler, size_t rtsc, unsigned rach_delay,
 
   /* Start control threads */
   for (size_t i = 0; i < mChans; i++) {
-    TrxChanThParams *params = (TrxChanThParams *)malloc(sizeof(struct TrxChanThParams));
-    params->trx = this;
-    params->num = i;
-    mControlServiceLoopThreads[i] = new Thread(stackSize);
+    TransceiverChannel *chan = new TransceiverChannel(this, i);
+    mControlServiceLoopThreads[i] = new Thread(32768);
     mControlServiceLoopThreads[i]->start((void * (*)(void*))
-                                 ControlServiceLoopAdapter, (void*) params);
+                                 ControlServiceLoopAdapter, (void*) chan);
 
     if (i && filler == FILLER_DUMMY)
       filler = FILLER_ZERO;
@@ -286,8 +254,8 @@ bool Transceiver::start()
   }
 
   /* Device is running - launch I/O threads */
-  mRxLowerLoopThread = new Thread(stackSize);
-  mTxLowerLoopThread = new Thread(stackSize);
+  mRxLowerLoopThread = new Thread(32768);
+  mTxLowerLoopThread = new Thread(32768);
   mTxLowerLoopThread->start((void * (*)(void*))
                             TxLowerLoopAdapter,(void*) this);
   mRxLowerLoopThread->start((void * (*)(void*))
@@ -295,19 +263,15 @@ bool Transceiver::start()
 
   /* Launch uplink and downlink burst processing threads */
   for (size_t i = 0; i < mChans; i++) {
-    TrxChanThParams *params = (TrxChanThParams *)malloc(sizeof(struct TrxChanThParams));
-    params->trx = this;
-    params->num = i;
-    mRxServiceLoopThreads[i] = new Thread(stackSize);
+    TransceiverChannel *chan = new TransceiverChannel(this, i);
+    mRxServiceLoopThreads[i] = new Thread(32768);
     mRxServiceLoopThreads[i]->start((void * (*)(void*))
-                            RxUpperLoopAdapter, (void*) params);
+                            RxUpperLoopAdapter, (void*) chan);
 
-    params = (TrxChanThParams *)malloc(sizeof(struct TrxChanThParams));
-    params->trx = this;
-    params->num = i;
-    mTxPriorityQueueServiceLoopThreads[i] = new Thread(stackSize);
+    chan = new TransceiverChannel(this, i);
+    mTxPriorityQueueServiceLoopThreads[i] = new Thread(32768);
     mTxPriorityQueueServiceLoopThreads[i]->start((void * (*)(void*))
-                            TxUpperLoopAdapter, (void*) params);
+                            TxUpperLoopAdapter, (void*) chan);
   }
 
   mForceClockInterface = true;
@@ -415,8 +379,7 @@ void Transceiver::pushRadioVector(GSM::Time &nowTime)
     state = &mStates[i];
 
     while ((burst = mTxPriorityQueues[i].getStaleBurst(nowTime))) {
-      LOGCHAN(i, DMAIN, NOTICE) << "dumping STALE burst in TRX->SDR interface ("
-                  << burst->getTime() <<" vs " << nowTime << "), retrans=" << state->mRetrans;
+      LOG(NOTICE) << "dumping STALE burst in TRX->USRP interface";
       if (state->mRetrans)
         updateFillerTable(i, burst);
       delete burst;
@@ -524,16 +487,16 @@ CorrType Transceiver::expectedCorrType(GSM::Time currTime,
     break;
   case IV:
   case VI:
-    return mExtRACH ? EXT_RACH : RACH;
+    return RACH;
     break;
   case V: {
     int mod51 = burstFN % 51;
     if ((mod51 <= 36) && (mod51 >= 14))
-      return mExtRACH ? EXT_RACH : RACH;
+      return RACH;
     else if ((mod51 == 4) || (mod51 == 5))
-      return mExtRACH ? EXT_RACH : RACH;
+      return RACH;
     else if ((mod51 == 45) || (mod51 == 46))
-      return mExtRACH ? EXT_RACH : RACH;
+      return RACH;
     else if (mHandover[burstTN][sdcch4_subslot[burstFN % 102]])
       return RACH;
     else
@@ -551,7 +514,7 @@ CorrType Transceiver::expectedCorrType(GSM::Time currTime,
   case XIII: {
     int mod52 = burstFN % 52;
     if ((mod52 == 12) || (mod52 == 38))
-      return mExtRACH ? EXT_RACH : RACH;
+      return RACH;
     else if ((mod52 == 25) || (mod52 == 51))
       return IDLE;
     else
@@ -584,26 +547,27 @@ void writeToFile(radioVector *radio_burst, size_t chan)
  * Pull bursts from the FIFO and handle according to the slot
  * and burst correlation type. Equalzation is currently disabled.
  */
-bool Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
+SoftVector *Transceiver::pullRadioVector(GSM::Time &wTime, double &RSSI, bool &isRssiValid,
+                                         double &timingOffset, double &noise,
+                                         size_t chan)
 {
   int rc;
-  struct estim_burst_params ebp;
-  float max = -1.0, avg = 0.0;
-  unsigned max_toa;
+  complex amp;
+  float toa, max = -1.0, avg = 0.0;
   int max_i = -1;
   signalVector *burst;
-  GSM::Time burstTime;
-  SoftVector *rxBurst;
+  SoftVector *bits = NULL;
   TransceiverState *state = &mStates[chan];
+  isRssiValid = false;
 
   /* Blocking FIFO read */
   radioVector *radio_burst = mReceiveFIFO[chan]->read();
   if (!radio_burst)
-    return false;
+    return NULL;
 
   /* Set time and determine correlation type */
-  burstTime = radio_burst->getTime();
-  CorrType type = expectedCorrType(burstTime, chan);
+  GSM::Time time = radio_burst->getTime();
+  CorrType type = expectedCorrType(time, chan);
 
   /* Enable 8-PSK burst detection if EDGE is enabled */
   if (mEdge && (type == TSC))
@@ -612,29 +576,16 @@ bool Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
   /* Debug: dump bursts to disk */
   /* bits 0-7  - chan 0 timeslots
    * bits 8-15 - chan 1 timeslots */
-  if (mWriteBurstToDiskMask & ((1<<bi->tn) << (8*chan)))
+  if (mWriteBurstToDiskMask & ((1<<time.TN()) << (8*chan)))
     writeToFile(radio_burst, chan);
 
   /* No processing if the timeslot is off.
    * Not even power level or noise calculation. */
   if (type == OFF) {
     delete radio_burst;
-    return false;
+    return NULL;
   }
 
-  /* Initialize struct bi */
-  bi->nbits = 0;
-  bi->fn = burstTime.FN();
-  bi->tn = burstTime.TN();
-  bi->rssi = 0.0;
-  bi->toa = 0.0;
-  bi->noise = 0.0;
-  bi->idle = false;
-  bi->modulation = MODULATION_GMSK;
-  bi->tss = 0; /* TODO: we only support tss 0 right now */
-  bi->tsc = 0;
-  bi->ci = 0.0;
-
   /* 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);
@@ -647,64 +598,56 @@ bool Transceiver::pullRadioVector(size_t chan, struct trx_ul_burst_ind *bi)
 
   if (max_i < 0) {
     LOG(ALERT) << "Received empty burst";
-    goto ret_idle;
+    delete radio_burst;
+    return NULL;
   }
 
   /* Average noise on diversity paths and update global levels */
   burst = radio_burst->getVector(max_i);
   avg = sqrt(avg / radio_burst->chans());
 
+  wTime = time;
+  RSSI = 20.0 * log10(rxFullScale / avg);
+
+  /* RSSI estimation are valid */
+  isRssiValid = true;
+
   if (type == IDLE) {
     /* Update noise levels */
     state->mNoises.insert(avg);
     state->mNoiseLev = state->mNoises.avg();
+    noise = 20.0 * log10(rxFullScale / state->mNoiseLev);
+
+    delete radio_burst;
+    return NULL;
+  } else {
+    /* Do not update noise levels */
+    noise = 20.0 * log10(rxFullScale / state->mNoiseLev);
   }
 
-  bi->rssi = 20.0 * log10(rxFullScale / avg) + rssiOffset;
-  bi->noise = 20.0 * log10(rxFullScale / state->mNoiseLev) + rssiOffset;
-
-  if (type == IDLE)
-    goto ret_idle;
-
-  max_toa = (type == RACH || type == EXT_RACH) ?
-            mMaxExpectedDelayAB : mMaxExpectedDelayNB;
-
   /* Detect normal or RACH bursts */
-  rc = detectAnyBurst(*burst, mTSC, BURST_THRESH, mSPSRx, type, max_toa, &ebp);
-  if (rc <= 0) {
-    if (rc == -SIGERR_CLIP)
-      LOG(WARNING) << "Clipping detected on received RACH or Normal Burst";
-    else if (rc != SIGERR_NONE)
-      LOG(WARNING) << "Unhandled RACH or Normal Burst detection error";
-    goto ret_idle;
-  }
+  rc = detectAnyBurst(*burst, mTSC, BURST_THRESH, mSPSRx, type, amp, toa,
+                      (type==RACH)?mMaxExpectedDelayAB:mMaxExpectedDelayNB);
 
+  if (rc > 0) {
     type = (CorrType) rc;
-  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) {
-    bi->modulation = MODULATION_8PSK;
-    bi->nbits = EDGE_BURST_NBITS;
-  } else { /* size() here is actually gSlotLen + 8, due to guard periods */
-    bi->modulation = MODULATION_GMSK;
-    bi->nbits = gSlotLen;
+  } else if (rc <= 0) {
+    if (rc == -SIGERR_CLIP) {
+      LOG(WARNING) << "Clipping detected on received RACH or Normal Burst";
+    } else if (rc != SIGERR_NONE) {
+      LOG(WARNING) << "Unhandled RACH or Normal Burst detection error";
     }
 
-  // Convert -1..+1 soft bits to 0..1 soft bits
-  vectorSlicer(bi->rx_burst, rxBurst->begin(), bi->nbits);
-
-  delete rxBurst;
     delete radio_burst;
-  return true;
+    return NULL;
+  }
+
+  timingOffset = toa;
+
+  bits = demodAnyBurst(*burst, mSPSRx, amp, toa, type);
 
-ret_idle:
-  bi->idle = true;
   delete radio_burst;
-  return false;
+  return bits;
 }
 
 void Transceiver::reset()
@@ -714,68 +657,38 @@ void Transceiver::reset()
 }
 
 
-#define MAX_PACKET_LENGTH 100
-
-/**
- * Matches a buffer with a command.
- * @param  buf    a buffer to look command in
- * @param  cmd    a command to look in buffer
- * @param  params pointer to arguments, or NULL
- * @return        true if command matches, otherwise false
- */
-static bool match_cmd(char *buf,
-  const char *cmd, char **params)
-{
-  size_t cmd_len = strlen(cmd);
-
-  /* Check a command itself */
-  if (strncmp(buf, cmd, cmd_len))
-    return false;
-
-  /* A command has arguments */
-  if (params != NULL) {
-    /* Make sure there is a space */
-    if (buf[cmd_len] != ' ')
-      return false;
-
-    /* Update external pointer */
-    *params = buf + cmd_len + 1;
-  }
-
-  return true;
-}
-
 void Transceiver::driveControl(size_t chan)
 {
-  char buffer[MAX_PACKET_LENGTH + 1];
-  char response[MAX_PACKET_LENGTH + 1];
-  char *command, *params;
-  int msgLen;
+  int MAX_PACKET_LENGTH = 100;
 
-  /* Attempt to read from control socket */
-  msgLen = read(mCtrlSockets[chan], buffer, MAX_PACKET_LENGTH);
-  if (msgLen <= 0) {
-    LOGCHAN(chan, DTRXCTRL, WARNING) << "mCtrlSockets read(" << mCtrlSockets[chan] << ") failed: " << msgLen;
+  // check control socket
+  char buffer[MAX_PACKET_LENGTH];
+  int msgLen = -1;
+  buffer[0] = '\0';
+
+  msgLen = mCtrlSockets[chan]->read(buffer, sizeof(buffer));
+
+  if (msgLen < 1) {
     return;
   }
 
-  /* Zero-terminate received string */
-  buffer[msgLen] = '\0';
+  char cmdcheck[4];
+  char command[MAX_PACKET_LENGTH];
+  char response[MAX_PACKET_LENGTH];
 
-  /* Verify a command signature */
-  if (strncmp(buffer, "CMD ", 4)) {
-    LOGC(DTRXCTRL, WARNING) << "bogus message on control interface";
+  sscanf(buffer,"%3s %s",cmdcheck,command);
+
+  if (strcmp(cmdcheck,"CMD")!=0) {
+    LOG(WARNING) << "bogus message on control interface";
     return;
   }
+  LOG(INFO) << "command is " << buffer;
 
-  /* Set command pointer */
-  command = buffer + 4;
-  LOGCHAN(chan, DTRXCTRL, INFO) << "command is '" << command << "'";
-
-  if (match_cmd(command, "POWEROFF", NULL)) {
+  if (strcmp(command,"POWEROFF")==0) {
     stop();
     sprintf(response,"RSP POWEROFF 0");
-  } else if (match_cmd(command, "POWERON", NULL)) {
+  }
+  else if (strcmp(command,"POWERON")==0) {
     if (!start()) {
       sprintf(response,"RSP POWERON 1");
     } else {
@@ -785,43 +698,41 @@ void Transceiver::driveControl(size_t chan)
           mHandover[i][j] = false;
       }
     }
-  } else if (match_cmd(command, "HANDOVER", &params)) {
-    unsigned ts = 0, ss = 0;
-    sscanf(params, "%u %u", &ts, &ss);
-    if (ts > 7 || ss > 7) {
-      sprintf(response, "RSP NOHANDOVER 1 %u %u", ts, ss);
-    } else {
+  }
+  else if (strcmp(command,"HANDOVER")==0){
+    int ts=0,ss=0;
+    sscanf(buffer,"%3s %s %d %d",cmdcheck,command,&ts,&ss);
     mHandover[ts][ss] = true;
-      sprintf(response, "RSP HANDOVER 0 %u %u", ts, ss);
+    sprintf(response,"RSP HANDOVER 0 %d %d",ts,ss);
   }
-  } else if (match_cmd(command, "NOHANDOVER", &params)) {
-    unsigned ts = 0, ss = 0;
-    sscanf(params, "%u %u", &ts, &ss);
-    if (ts > 7 || ss > 7) {
-      sprintf(response, "RSP NOHANDOVER 1 %u %u", ts, ss);
-    } else {
+  else if (strcmp(command,"NOHANDOVER")==0){
+    int ts=0,ss=0;
+    sscanf(buffer,"%3s %s %d %d",cmdcheck,command,&ts,&ss);
     mHandover[ts][ss] = false;
-      sprintf(response, "RSP NOHANDOVER 0 %u %u", ts, ss);
+    sprintf(response,"RSP NOHANDOVER 0 %d %d",ts,ss);
   }
-  } else if (match_cmd(command, "SETMAXDLY", &params)) {
+  else if (strcmp(command,"SETMAXDLY")==0) {
     //set expected maximum time-of-arrival
     int maxDelay;
-    sscanf(params, "%d", &maxDelay);
+    sscanf(buffer,"%3s %s %d",cmdcheck,command,&maxDelay);
     mMaxExpectedDelayAB = maxDelay; // 1 GSM symbol is approx. 1 km
     sprintf(response,"RSP SETMAXDLY 0 %d",maxDelay);
-  } else if (match_cmd(command, "SETMAXDLYNB", &params)) {
+  }
+  else if (strcmp(command,"SETMAXDLYNB")==0) {
     //set expected maximum time-of-arrival
     int maxDelay;
-    sscanf(params, "%d", &maxDelay);
+    sscanf(buffer,"%3s %s %d",cmdcheck,command,&maxDelay);
     mMaxExpectedDelayNB = maxDelay; // 1 GSM symbol is approx. 1 km
     sprintf(response,"RSP SETMAXDLYNB 0 %d",maxDelay);
-  } else if (match_cmd(command, "SETRXGAIN", &params)) {
+  }
+  else if (strcmp(command,"SETRXGAIN")==0) {
     //set expected maximum time-of-arrival
     int newGain;
-    sscanf(params, "%d", &newGain);
+    sscanf(buffer,"%3s %s %d",cmdcheck,command,&newGain);
     newGain = mRadioInterface->setRxGain(newGain, chan);
     sprintf(response,"RSP SETRXGAIN 0 %d",newGain);
-  } else if (match_cmd(command, "NOISELEV", NULL)) {
+  }
+  else if (strcmp(command,"NOISELEV")==0) {
     if (mOn) {
       float lev = mStates[chan].mNoiseLev;
       sprintf(response,"RSP NOISELEV 0 %d",
@@ -830,111 +741,96 @@ void Transceiver::driveControl(size_t chan)
     else {
       sprintf(response,"RSP NOISELEV 1  0");
     }
-  } else if (match_cmd(command, "SETPOWER", &params)) {
+  }
+  else if (!strcmp(command, "SETPOWER")) {
     int power;
-    sscanf(params, "%d", &power);
+    sscanf(buffer, "%3s %s %d", cmdcheck, command, &power);
     power = mRadioInterface->setPowerAttenuation(power, chan);
     mStates[chan].mPower = power;
     sprintf(response, "RSP SETPOWER 0 %d", power);
-  } else if (match_cmd(command, "ADJPOWER", &params)) {
+  }
+  else if (!strcmp(command,"ADJPOWER")) {
     int power, step;
-    sscanf(params, "%d", &step);
+    sscanf(buffer, "%3s %s %d", cmdcheck, command, &step);
     power = mStates[chan].mPower + step;
     power = mRadioInterface->setPowerAttenuation(power, chan);
     mStates[chan].mPower = power;
     sprintf(response, "RSP ADJPOWER 0 %d", power);
-  } else if (match_cmd(command, "RXTUNE", &params)) {
+  }
+  else if (strcmp(command,"RXTUNE")==0) {
     // tune receiver
     int freqKhz;
-    sscanf(params, "%d", &freqKhz);
+    sscanf(buffer,"%3s %s %d",cmdcheck,command,&freqKhz);
     mRxFreq = freqKhz * 1e3;
     if (!mRadioInterface->tuneRx(mRxFreq, chan)) {
-       LOGC(DTRXCTRL, ALERT) << "RX failed to tune";
+       LOG(ALERT) << "RX failed to tune";
        sprintf(response,"RSP RXTUNE 1 %d",freqKhz);
     }
     else
        sprintf(response,"RSP RXTUNE 0 %d",freqKhz);
-  } else if (match_cmd(command, "TXTUNE", &params)) {
+  }
+  else if (strcmp(command,"TXTUNE")==0) {
     // tune txmtr
     int freqKhz;
-    sscanf(params, "%d", &freqKhz);
+    sscanf(buffer,"%3s %s %d",cmdcheck,command,&freqKhz);
     mTxFreq = freqKhz * 1e3;
     if (!mRadioInterface->tuneTx(mTxFreq, chan)) {
-       LOGC(DTRXCTRL, ALERT) << "TX failed to tune";
+       LOG(ALERT) << "TX failed to tune";
        sprintf(response,"RSP TXTUNE 1 %d",freqKhz);
     }
     else
        sprintf(response,"RSP TXTUNE 0 %d",freqKhz);
-  } else if (match_cmd(command, "SETTSC", &params)) {
+  }
+  else if (!strcmp(command,"SETTSC")) {
     // set TSC
     unsigned TSC;
-    sscanf(params, "%u", &TSC);
+    sscanf(buffer, "%3s %s %d", cmdcheck, command, &TSC);
     if (TSC > 7) {
       sprintf(response, "RSP SETTSC 1 %d", TSC);
     } else {
-      LOGC(DTRXCTRL, NOTICE) << "Changing TSC from " << mTSC << " to " << TSC;
+      LOG(NOTICE) << "Changing TSC from " << mTSC << " to " << TSC;
       mTSC = TSC;
       sprintf(response,"RSP SETTSC 0 %d", TSC);
     }
-  } else if (match_cmd(command, "SETSLOT", &params)) {
+  }
+  else if (strcmp(command,"SETSLOT")==0) {
     // set slot type
     int  corrCode;
     int  timeslot;
-    sscanf(params, "%d %d", &timeslot, &corrCode);
+    sscanf(buffer,"%3s %s %d %d",cmdcheck,command,&timeslot,&corrCode);
     if ((timeslot < 0) || (timeslot > 7)) {
-      LOGC(DTRXCTRL, WARNING) << "bogus message on control interface";
+      LOG(WARNING) << "bogus message on control interface";
       sprintf(response,"RSP SETSLOT 1 %d %d",timeslot,corrCode);
       return;
     }
     mStates[chan].chanType[timeslot] = (ChannelCombination) corrCode;
     setModulus(timeslot, chan);
     sprintf(response,"RSP SETSLOT 0 %d %d",timeslot,corrCode);
-  } else if (match_cmd(command, "SETFORMAT", &params)) {
-    // set TRXD protocol version
-    unsigned version_recv;
-    sscanf(params, "%u", &version_recv);
-    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;
-      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, "_SETBURSTTODISKMASK", &params)) {
+  else if (strcmp(command,"_SETBURSTTODISKMASK")==0) {
     // debug command! may change or disapear without notice
     // set a mask which bursts to dump to disk
     int mask;
-    sscanf(params, "%d", &mask);
+    sscanf(buffer,"%3s %s %d",cmdcheck,command,&mask);
     mWriteBurstToDiskMask = mask;
     sprintf(response,"RSP _SETBURSTTODISKMASK 0 %d",mask);
-  } else {
-    LOGC(DTRXCTRL, WARNING) << "bogus command " << command << " on control interface.";
+  }
+  else {
+    LOG(WARNING) << "bogus command " << command << " on control interface.";
     sprintf(response,"RSP ERR 1");
   }
 
-  LOGCHAN(chan, DTRXCTRL, INFO) << "response is '" << response << "'";
-  msgLen = write(mCtrlSockets[chan], response, strlen(response) + 1);
-  if (msgLen <= 0)
-    LOGCHAN(chan, DTRXCTRL, WARNING) << "mCtrlSockets write(" << mCtrlSockets[chan] << ") failed: " << msgLen;
+  mCtrlSockets[chan]->write(response, strlen(response) + 1);
 }
 
 bool Transceiver::driveTxPriorityQueue(size_t chan)
 {
-  int msgLen;
   int burstLen;
   char buffer[EDGE_BURST_NBITS + 50];
-  struct trxd_hdr_common *chdr;
-  uint32_t fn;
 
   // check data socket
-  msgLen = read(mDataSockets[chan], buffer, sizeof(buffer));
-  if (msgLen <= 0) {
-    LOGCHAN(chan, DTRXCTRL, WARNING) << "mDataSockets read(" << mCtrlSockets[chan] << ") failed: " << msgLen;
-    return false;
-  }
+  size_t msgLen = mDataSockets[chan]->read(buffer, sizeof(buffer));
 
   if (msgLen == gSlotLen + 1 + 4 + 1) {
     burstLen = gSlotLen;
@@ -948,27 +844,12 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
     return false;
   }
 
-  /* Common header part: HDR version, TDMA TN & FN */
-  chdr = (struct trxd_hdr_common *) buffer;
+  int timeSlot = (int) buffer[0];
+  uint64_t frameNum = 0;
+  for (int i = 0; i < 4; i++)
+    frameNum = (frameNum << 8) | (0x0ff & buffer[i+1]);
 
-  /* Convert TDMA FN to the host endianness */
-  fn = osmo_load32be(&chdr->fn);
-
-  /* Make sure we support the received header format */
-  switch (chdr->version) {
-  case 0:
-  /* Version 1 has the same format */
-  case 1:
-    break;
-
-  default:
-    LOG(ERR) << "Rx TRXD message with unknown header version " << chdr->version;
-    return false;
-  }
-
-  LOG(DEBUG) << "Rx TRXD message (hdr_ver=" << chdr->version << "): "
-             << "fn=" << fn << ", tn=" << chdr->tn << ", "
-             << "burst_len=" << burstLen;
+  LOG(DEBUG) << "rcvd. burst at: " << GSM::Time(frameNum,timeSlot);
 
   int RSSI = (int) buffer[5];
   BitVector newBurst(burstLen);
@@ -977,7 +858,7 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
   while (itr < newBurst.end())
     *itr++ = *bufferItr++;
 
-  GSM::Time currTime = GSM::Time(fn, chdr->tn);
+  GSM::Time currTime = GSM::Time(frameNum,timeSlot);
 
   addRadioVector(chan, newBurst, RSSI, currTime);
 
@@ -988,59 +869,74 @@ bool Transceiver::driveTxPriorityQueue(size_t chan)
 
 void Transceiver::driveReceiveRadio()
 {
-  int rc = mRadioInterface->driveReceiveRadio();
-  if (rc == 0) {
+  if (!mRadioInterface->driveReceiveRadio()) {
     usleep(100000);
-  } else if (rc < 0) {
-    LOG(FATAL) << "radio Interface receive failed, requesting stop.";
-    osmo_signal_dispatch(SS_MAIN, S_MAIN_STOP_REQUIRED, NULL);
   } else if (mForceClockInterface || mTransmitDeadlineClock > mLastClockUpdateTime + GSM::Time(216,0)) {
     mForceClockInterface = false;
     writeClockInterface();
   }
 }
 
-void Transceiver::logRxBurst(size_t chan, const struct trx_ul_burst_ind *bi)
+void Transceiver::logRxBurst(size_t chan, SoftVector *burst, GSM::Time time, double dbm,
+                             double rssi, double noise, double toa)
 {
-  std::ostringstream os;
-  for (size_t i=0; i < bi->nbits; i++) {
-    if (bi->rx_burst[i] > 0.5) os << "1";
-    else if (bi->rx_burst[i] > 0.25) os << "|";
-    else if (bi->rx_burst[i] > 0.0) os << "'";
-    else os << "-";
-  }
-
   LOG(DEBUG) << std::fixed << std::right
     << " chan: "   << chan
-    << " time: "   << bi->tn << ":" << bi->fn
-    << " RSSI: "   << std::setw(5) << std::setprecision(1) << (bi->rssi - rssiOffset)
-                   << "dBFS/" << std::setw(6) << -bi->rssi << "dBm"
-    << " noise: "  << std::setw(5) << std::setprecision(1) << (bi->noise - rssiOffset)
-                   << "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"
-    << " bits: "   << os;
+    << " time: "   << time
+    << " RSSI: "   << std::setw(5) << std::setprecision(1) << rssi
+                   << "dBFS/" << std::setw(6) << -dbm << "dBm"
+    << " noise: "  << std::setw(5) << std::setprecision(1) << noise
+                   << "dBFS/" << std::setw(6) << -(noise + rssiOffset) << "dBm"
+    << " TOA: "    << std::setw(5) << std::setprecision(2) << toa
+    << " bits: "   << *burst;
 }
 
 void Transceiver::driveReceiveFIFO(size_t chan)
 {
-  struct trx_ul_burst_ind bi;
+  SoftVector *rxBurst = NULL;
+  double RSSI; // in dBFS
+  double dBm;  // in dBm
+  double TOA;  // in symbols
+  int TOAint;  // in 1/256 symbols
+  double noise; // noise level in dBFS
+  GSM::Time burstTime;
+  bool isRssiValid; // are RSSI, noise and burstTime valid
+  unsigned nbits = gSlotLen;
 
-  if (!pullRadioVector(chan, &bi))
+  rxBurst = pullRadioVector(burstTime, RSSI, isRssiValid, TOA, noise, chan);
+  if (!rxBurst)
     return;
-  if (!bi.idle)
-       logRxBurst(chan, &bi);
 
-  switch (mVersionTRXD[chan]) {
-    case 0:
-      trxd_send_burst_ind_v0(chan, mDataSockets[chan], &bi);
-      break;
-    case 1:
-      trxd_send_burst_ind_v1(chan, mDataSockets[chan], &bi);
-      break;
-    default:
-      OSMO_ASSERT(false);
-  }
+  // Convert -1..+1 soft bits to 0..1 soft bits
+  vectorSlicer(rxBurst);
+
+  /*
+   * EDGE demodulator returns 444 (148 * 3) bits
+   */
+  if (rxBurst->size() == gSlotLen * 3)
+    nbits = gSlotLen * 3;
+
+  dBm = RSSI + rssiOffset;
+  logRxBurst(chan, rxBurst, burstTime, dBm, RSSI, noise, TOA);
+
+  TOAint = (int) (TOA * 256.0 + 0.5); // round to closest integer
+
+  char burstString[nbits + 10];
+  burstString[0] = burstTime.TN();
+  for (int i = 0; i < 4; i++)
+    burstString[1+i] = (burstTime.FN() >> ((3-i)*8)) & 0x0ff;
+  burstString[5] = (int)dBm;
+  burstString[6] = (TOAint >> 8) & 0x0ff;
+  burstString[7] = TOAint & 0x0ff;
+  SoftVector::iterator burstItr = rxBurst->begin();
+
+  for (unsigned i = 0; i < nbits; i++)
+    burstString[8 + i] = (char) round((*burstItr++) * 255.0);
+
+  burstString[nbits + 9] = '\0';
+  delete rxBurst;
+
+  mDataSockets[chan]->write(burstString, nbits + 10);
 }
 
 void Transceiver::driveTxFIFO()
@@ -1070,15 +966,14 @@ void Transceiver::driveTxFIFO()
           // only update latency at the defined frame interval
           if (radioClock->get() > mLatencyUpdateTime + GSM::Time(USB_LATENCY_INTRVL)) {
             mTransmitLatency = mTransmitLatency + GSM::Time(1,0);
-            LOG(INFO) << "new latency: " << mTransmitLatency << " (underrun "
-                      << radioClock->get() << " vs " << mLatencyUpdateTime + GSM::Time(USB_LATENCY_INTRVL) << ")";
+            LOG(INFO) << "new latency: " << mTransmitLatency;
             mLatencyUpdateTime = radioClock->get();
           }
         }
         else {
           // if underrun hasn't occurred in the last sec (216 frames) drop
           //    transmit latency by a timeslot
-          if (mTransmitLatency > mRadioInterface->minLatency()) {
+          if (mTransmitLatency > GSM::Time(USB_LATENCY_MIN)) {
               if (radioClock->get() > mLatencyUpdateTime + GSM::Time(216,0)) {
               mTransmitLatency.decTN();
               LOG(INFO) << "reduced latency: " << mTransmitLatency;
@@ -1100,31 +995,24 @@ void Transceiver::driveTxFIFO()
 
 void Transceiver::writeClockInterface()
 {
-  int msgLen;
   char command[50];
   // FIXME -- This should be adaptive.
   sprintf(command,"IND CLOCK %llu",(unsigned long long) (mTransmitDeadlineClock.FN()+2));
 
   LOG(INFO) << "ClockInterface: sending " << command;
 
-  msgLen = write(mClockSocket, command, strlen(command) + 1);
-  if (msgLen <= 0)
-    LOG(WARNING) << "mClockSocket write(" << mClockSocket << ") failed: " << msgLen;
+  mClockSocket.write(command, strlen(command) + 1);
 
   mLastClockUpdateTime = mTransmitDeadlineClock;
 
 }
 
-void *RxUpperLoopAdapter(TrxChanThParams *params)
+void *RxUpperLoopAdapter(TransceiverChannel *chan)
 {
-  char thread_name[16];
-  Transceiver *trx = params->trx;
-  size_t num = params->num;
+  Transceiver *trx = chan->trx;
+  size_t num = chan->num;
 
-  free(params);
-
-  snprintf(thread_name, 16, "RxUpper%zu", num);
-  set_selfthread_name(thread_name);
+  delete chan;
 
   trx->setPriority(0.42);
 
@@ -1137,8 +1025,6 @@ void *RxUpperLoopAdapter(TrxChanThParams *params)
 
 void *RxLowerLoopAdapter(Transceiver *transceiver)
 {
-  set_selfthread_name("RxLower");
-
   transceiver->setPriority(0.45);
 
   while (1) {
@@ -1150,8 +1036,6 @@ void *RxLowerLoopAdapter(Transceiver *transceiver)
 
 void *TxLowerLoopAdapter(Transceiver *transceiver)
 {
-  set_selfthread_name("TxLower");
-
   transceiver->setPriority(0.44);
 
   while (1) {
@@ -1161,16 +1045,12 @@ void *TxLowerLoopAdapter(Transceiver *transceiver)
   return NULL;
 }
 
-void *ControlServiceLoopAdapter(TrxChanThParams *params)
+void *ControlServiceLoopAdapter(TransceiverChannel *chan)
 {
-  char thread_name[16];
-  Transceiver *trx = params->trx;
-  size_t num = params->num;
+  Transceiver *trx = chan->trx;
+  size_t num = chan->num;
 
-  free(params);
-
-  snprintf(thread_name, 16, "CtrlService%zu", num);
-  set_selfthread_name(thread_name);
+  delete chan;
 
   while (1) {
     trx->driveControl(num);
@@ -1179,16 +1059,12 @@ void *ControlServiceLoopAdapter(TrxChanThParams *params)
   return NULL;
 }
 
-void *TxUpperLoopAdapter(TrxChanThParams *params)
+void *TxUpperLoopAdapter(TransceiverChannel *chan)
 {
-  char thread_name[16];
-  Transceiver *trx = params->trx;
-  size_t num = params->num;
+  Transceiver *trx = chan->trx;
+  size_t num = chan->num;
 
-  free(params);
-
-  snprintf(thread_name, 16, "TxUpper%zu", num);
-  set_selfthread_name(thread_name);
+  delete chan;
 
   trx->setPriority(0.40);
 

Transceiver52M/Transceiver.h

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: GPL-3.0+
-*
 * This software is distributed under the terms of the GNU Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -27,19 +25,25 @@
 #include "radioInterface.h"
 #include "Interthread.h"
 #include "GSMCommon.h"
+#include "Sockets.h"
 
 #include <sys/types.h>
 #include <sys/socket.h>
 
-extern "C" {
-#include <osmocom/core/signal.h>
-#include "config_defs.h"
-}
-
 class Transceiver;
 
 /** Channel descriptor for transceiver object and channel number pair */
-struct TrxChanThParams {
+struct TransceiverChannel {
+  TransceiverChannel(Transceiver *trx, int num)
+  {
+    this->trx = trx;
+    this->num = num;
+  }
+
+  ~TransceiverChannel()
+  {
+  }
+
   Transceiver *trx;
   size_t num;
 };
@@ -50,7 +54,7 @@ struct TransceiverState {
   ~TransceiverState();
 
   /* Initialize a multiframe slot in the filler table */
-  bool init(FillerType filler, size_t sps, float scale, size_t rtsc, unsigned rach_delay);
+  bool init(int filler, size_t sps, float scale, size_t rtsc, unsigned rach_delay);
 
   int chanType[8];
 
@@ -99,14 +103,13 @@ public:
               size_t tx_sps, size_t rx_sps, size_t chans,
               GSM::Time wTransmitLatency,
               RadioInterface *wRadioInterface,
-              double wRssiOffset, int stackSize);
+              double wRssiOffset);
 
   /** Destructor */
   ~Transceiver();
 
   /** Start the control loop */
-  bool init(FillerType filler, size_t rtsc, unsigned rach_delay,
-            bool edge, bool ext_rach);
+  bool init(int filler, size_t rtsc, unsigned rach_delay, bool edge);
 
   /** attach the radioInterface receive FIFO */
   bool receiveFIFO(VectorFIFO *wFIFO, size_t chan)
@@ -141,14 +144,22 @@ public:
     LOOPBACK            ///< similar go VII, used in loopback testing
   } ChannelCombination;
 
+  enum FillerType {
+    FILLER_DUMMY,
+    FILLER_ZERO,
+    FILLER_NORM_RAND,
+    FILLER_EDGE_RAND,
+    FILLER_ACCESS_RAND,
+  };
+
 private:
   int mBasePort;
   std::string mLocalAddr;
   std::string mRemoteAddr;
 
-  std::vector<int> mDataSockets;  ///< socket for writing to/reading from GSM core
-  std::vector<int> mCtrlSockets;  ///< socket for writing/reading control commands from GSM core
-  int mClockSocket;               ///< socket for writing clock updates to GSM core
+  std::vector<UDPSocket *> mDataSockets;  ///< socket for writing to/reading from GSM core
+  std::vector<UDPSocket *> mCtrlSockets;  ///< socket for writing/reading control commands from GSM core
+  UDPSocket mClockSocket;                 ///< socket for writing clock updates to GSM core
 
   std::vector<VectorQueue> mTxPriorityQueues;   ///< priority queue of transmit bursts received from GSM core
   std::vector<VectorFIFO *>  mReceiveFIFO;      ///< radioInterface FIFO of receive bursts
@@ -169,7 +180,6 @@ private:
   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,
@@ -182,7 +192,9 @@ private:
   void pushRadioVector(GSM::Time &nowTime);
 
   /** Pull and demodulate a burst from the receive FIFO */
-  bool pullRadioVector(size_t chan, struct trx_ul_burst_ind *ind);
+  SoftVector *pullRadioVector(GSM::Time &wTime, double &RSSI, bool &isRssiValid,
+                              double &timingOffset, double &noise,
+                              size_t chan = 0);
 
   /** Set modulus for specific timeslot */
   void setModulus(size_t timeslot, size_t chan);
@@ -197,7 +209,6 @@ private:
   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
@@ -209,7 +220,6 @@ private:
   unsigned mMaxExpectedDelayNB;        ///< maximum expected time-of-arrival offset in GSM symbols for Normal Bursts
   unsigned mWriteBurstToDiskMask;      ///< debug: bitmask to indicate which timeslots to dump to disk
 
-  std::vector<unsigned> mVersionTRXD;  ///< Format version to use for TRXD protocol communication, per channel
   std::vector<TransceiverState> mStates;
 
   /** Start and stop I/O threads through the control socket API */
@@ -238,11 +248,15 @@ protected:
   */
   bool driveTxPriorityQueue(size_t chan);
 
-  friend void *RxUpperLoopAdapter(TrxChanThParams *params);
-  friend void *TxUpperLoopAdapter(TrxChanThParams *params);
-  friend void *RxLowerLoopAdapter(Transceiver *transceiver);
-  friend void *TxLowerLoopAdapter(Transceiver *transceiver);
-  friend void *ControlServiceLoopAdapter(TrxChanThParams *params);
+  friend void *RxUpperLoopAdapter(TransceiverChannel *);
+
+  friend void *TxUpperLoopAdapter(TransceiverChannel *);
+
+  friend void *RxLowerLoopAdapter(Transceiver *);
+
+  friend void *TxLowerLoopAdapter(Transceiver *);
+
+  friend void *ControlServiceLoopAdapter(TransceiverChannel *);
 
 
   void reset();
@@ -250,17 +264,18 @@ protected:
   /** set priority on current thread */
   void setPriority(float prio = 0.5) { mRadioInterface->setPriority(prio); }
 
-  void logRxBurst(size_t chan, const struct trx_ul_burst_ind *bi);
+  void logRxBurst(size_t chan, SoftVector *burst, GSM::Time time, double dbm,
+                  double rssi, double noise, double toa);
 };
 
-void *RxUpperLoopAdapter(TrxChanThParams *params);
+void *RxUpperLoopAdapter(TransceiverChannel *);
 
 /** Main drive threads */
-void *RxLowerLoopAdapter(Transceiver *transceiver);
-void *TxLowerLoopAdapter(Transceiver *transceiver);
+void *RxLowerLoopAdapter(Transceiver *);
+void *TxLowerLoopAdapter(Transceiver *);
 
 /** control message handler thread loop */
-void *ControlServiceLoopAdapter(TrxChanThParams *params);
+void *ControlServiceLoopAdapter(TransceiverChannel *);
 
 /** transmit queueing thread loop */
-void *TxUpperLoopAdapter(TrxChanThParams *params);
+void *TxUpperLoopAdapter(TransceiverChannel *);

Transceiver52M/USRPDevice.cpp

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008, 2009 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -60,15 +58,12 @@ const dboardConfigType dboardConfig = TXA_RXB;
 
 const double USRPDevice::masterClockRate = 52.0e6;
 
-USRPDevice::USRPDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface,
-		       size_t chans, double lo_offset,
-		       const std::vector<std::string>& tx_paths,
-		       const std::vector<std::string>& rx_paths):
-		RadioDevice(tx_sps, rx_sps, iface, chans, lo_offset, tx_paths, rx_paths)
+USRPDevice::USRPDevice(size_t sps)
 {
-  LOGC(DDEV, INFO) << "creating USRP device...";
+  LOG(INFO) << "creating USRP device...";
 
-  decimRate = (unsigned int) round(masterClockRate/((GSMRATE) * (double) tx_sps));
+  this->sps = sps;
+  decimRate = (unsigned int) round(masterClockRate/((GSMRATE) * (double) sps));
   actualSampleRate = masterClockRate/decimRate;
   rxGain = 0;
 
@@ -78,9 +73,9 @@ USRPDevice::USRPDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface,
    * split sample rate Tx/Rx - 4/1 sps we need to need to
    * compensate for advance rather than delay.
    */
-  if (tx_sps == 1)
+  if (sps == 1)
     pingOffset = 272;
-  else if (tx_sps == 4)
+  else if (sps == 4)
     pingOffset = 269 - 7500;
   else
     pingOffset = 0;
@@ -97,32 +92,34 @@ int USRPDevice::open(const std::string &, int, bool)
 {
   writeLock.unlock();
 
-  LOGC(DDEV, INFO) << "opening USRP device..";
+  LOG(INFO) << "opening USRP device..";
 #ifndef SWLOOPBACK
   string rbf = "std_inband.rbf";
   //string rbf = "inband_1rxhb_1tx.rbf";
   m_uRx.reset();
+  if (!skipRx) {
   try {
     m_uRx = usrp_standard_rx_sptr(usrp_standard_rx::make(
-                                        0, decimRate * tx_sps, 1, -1,
+                                        0, decimRate * sps, 1, -1,
                                         usrp_standard_rx::FPGA_MODE_NORMAL,
                                         1024, 16 * 8, rbf));
     m_uRx->set_fpga_master_clock_freq(masterClockRate);
   }
 
   catch(...) {
-    LOGC(DDEV, ALERT) << "make failed on Rx";
+    LOG(ALERT) << "make failed on Rx";
     m_uRx.reset();
     return -1;
   }
 
   if (m_uRx->fpga_master_clock_freq() != masterClockRate)
   {
-    LOGC(DDEV, ALERT) << "WRONG FPGA clock freq = " << m_uRx->fpga_master_clock_freq()
+    LOG(ALERT) << "WRONG FPGA clock freq = " << m_uRx->fpga_master_clock_freq()
                << ", desired clock freq = " << masterClockRate;
     m_uRx.reset();
     return -1;
   }
+  }
 
   try {
     m_uTx = usrp_standard_tx_sptr(usrp_standard_tx::make(
@@ -132,20 +129,20 @@ int USRPDevice::open(const std::string &, int, bool)
   }
 
   catch(...) {
-    LOGC(DDEV, ALERT) << "make failed on Tx";
+    LOG(ALERT) << "make failed on Tx";
     m_uTx.reset();
     return -1;
   }
 
   if (m_uTx->fpga_master_clock_freq() != masterClockRate)
   {
-    LOGC(DDEV, ALERT) << "WRONG FPGA clock freq = " << m_uTx->fpga_master_clock_freq()
+    LOG(ALERT) << "WRONG FPGA clock freq = " << m_uTx->fpga_master_clock_freq()
                << ", desired clock freq = " << masterClockRate;
     m_uTx.reset();
     return -1;
   }
 
-  m_uRx->stop();
+  if (!skipRx) m_uRx->stop();
   m_uTx->stop();
 
 #endif
@@ -175,6 +172,8 @@ int USRPDevice::open(const std::string &, int, bool)
   m_dbTx = m_uTx->selected_subdev(txSubdevSpec);
   m_dbRx = m_uRx->selected_subdev(rxSubdevSpec);
 
+  samplesRead = 0;
+  samplesWritten = 0;
   started = false;
 
   return NORMAL;
@@ -184,12 +183,12 @@ int USRPDevice::open(const std::string &, int, bool)
 
 bool USRPDevice::start()
 {
-  LOGC(DDEV, INFO) << "starting USRP...";
+  LOG(INFO) << "starting USRP...";
 #ifndef SWLOOPBACK
-  if (!m_uRx) return false;
+  if (!m_uRx && !skipRx) return false;
   if (!m_uTx) return false;
 
-  m_uRx->stop();
+  if (!skipRx) m_uRx->stop();
   m_uTx->stop();
 
   writeLock.lock();
@@ -219,7 +218,10 @@ bool USRPDevice::start()
   isAligned = false;
 
 
+  if (!skipRx)
   started = (m_uRx->start() && m_uTx->start());
+  else
+  started = m_uTx->start();
   return started;
 #else
   gettimeofday(&lastReadTime,NULL);
@@ -265,7 +267,7 @@ double USRPDevice::minRxGain()
 double USRPDevice::setTxGain(double dB, size_t chan)
 {
   if (chan) {
-    LOGC(DDEV, ALERT) << "Invalid channel " << chan;
+    LOG(ALERT) << "Invalid channel " << chan;
     return 0.0;
   }
 
@@ -275,10 +277,10 @@ double USRPDevice::setTxGain(double dB, size_t chan)
   if (dB < minTxGain())
     dB = minTxGain();
 
-  LOGC(DDEV, NOTICE) << "Setting TX gain to " << dB << " dB.";
+  LOG(NOTICE) << "Setting TX gain to " << dB << " dB.";
 
   if (!m_dbTx->set_gain(dB))
-    LOGC(DDEV, ERR) << "Error setting TX gain";
+    LOG(ERR) << "Error setting TX gain";
 
   writeLock.unlock();
 
@@ -289,7 +291,7 @@ double USRPDevice::setTxGain(double dB, size_t chan)
 double USRPDevice::setRxGain(double dB, size_t chan)
 {
   if (chan) {
-    LOGC(DDEV, ALERT) << "Invalid channel " << chan;
+    LOG(ALERT) << "Invalid channel " << chan;
     return 0.0;
   }
 
@@ -301,10 +303,10 @@ double USRPDevice::setRxGain(double dB, size_t chan)
   if (dB < minRxGain())
     dB = minRxGain();
 
-  LOGC(DDEV, NOTICE) << "Setting RX gain to " << dB << " dB.";
+  LOG(NOTICE) << "Setting RX gain to " << dB << " dB.";
 
   if (!m_dbRx->set_gain(dB))
-    LOGC(DDEV, ERR) << "Error setting RX gain";
+    LOG(ERR) << "Error setting RX gain";
 
   writeLock.unlock();
 
@@ -314,51 +316,43 @@ double USRPDevice::setRxGain(double dB, size_t chan)
 bool USRPDevice::setRxAntenna(const std::string &ant, size_t chan)
 {
 	if (chan >= rx_paths.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		LOG(ALERT) << "Requested non-existent channel " << chan;
 		return false;
 	}
-	LOGC(DDEV, ALERT) << "Not implemented";
+	LOG(ALERT) << "Not implemented";
 	return true;
 }
 
 std::string USRPDevice::getRxAntenna(size_t chan)
 {
 	if (chan >= rx_paths.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		LOG(ALERT) << "Requested non-existent channel " << chan;
 		return "";
 	}
-	LOGC(DDEV, ALERT) << "Not implemented";
+	LOG(ALERT) << "Not implemented";
 	return "";
 }
 
 bool USRPDevice::setTxAntenna(const std::string &ant, size_t chan)
 {
 	if (chan >= tx_paths.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		LOG(ALERT) << "Requested non-existent channel " << chan;
 		return false;
 	}
-	LOGC(DDEV, ALERT) << "Not implemented";
+	LOG(ALERT) << "Not implemented";
 	return true;
 }
 
 std::string USRPDevice::getTxAntenna(size_t chan)
 {
 	if (chan >= tx_paths.size()) {
-		LOGC(DDEV, ALERT) << "Requested non-existent channel " << chan;
+		LOG(ALERT) << "Requested non-existent channel " << chan;
 		return "";
 	}
-	LOGC(DDEV, ALERT) << "Not implemented";
+	LOG(ALERT) << "Not implemented";
 	return "";
 }
 
-bool USRPDevice::requiresRadioAlign()
-{
-	return true;
-}
-
-GSM::Time USRPDevice::minLatency() {
-	return GSM::Time(1,1);
-}
 
 // NOTE: Assumes sequential reads
 int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
@@ -377,7 +371,7 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
     return len;
   }
 
-  *underrun = false;
+  if (underrun) *underrun = false;
 
   uint32_t readBuf[2000];
 
@@ -393,18 +387,18 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
 
     // read USRP packets, parse and save A/D data as needed
     readLen = m_uRx->read((void *)readBuf,readLen,overrun);
-    for (int pktNum = 0; pktNum < (readLen/512); pktNum++) {
+    for(int pktNum = 0; pktNum < (readLen/512); pktNum++) {
       // tmpBuf points to start of a USB packet
       uint32_t* tmpBuf = (uint32_t *) (readBuf+pktNum*512/4);
       TIMESTAMP pktTimestamp = usrp_to_host_u32(tmpBuf[1]);
       uint32_t word0 = usrp_to_host_u32(tmpBuf[0]);
       uint32_t chan = (word0 >> 16) & 0x1f;
       unsigned payloadSz = word0 & 0x1ff;
-      LOGC(DDEV, DEBUG) << "first two bytes: " << hex << word0 << " " << dec << pktTimestamp;
+      LOG(DEBUG) << "first two bytes: " << hex << word0 << " " << dec << pktTimestamp;
 
       bool incrementHi32 = ((lastPktTimestamp & 0x0ffffffffll) > pktTimestamp);
       if (incrementHi32 && (timeStart!=0)) {
-           LOGC(DDEV, DEBUG) << "high 32 increment!!!";
+           LOG(DEBUG) << "high 32 increment!!!";
            hi32Timestamp++;
       }
       pktTimestamp = (((TIMESTAMP) hi32Timestamp) << 32) | pktTimestamp;
@@ -416,19 +410,19 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
 	if ((word2 >> 16) == ((0x01 << 8) | 0x02)) {
           timestamp -= timestampOffset;
 	  timestampOffset = pktTimestamp - pingTimestamp + pingOffset;
-	  LOGC(DDEV, DEBUG) << "updating timestamp offset to: " << timestampOffset;
+	  LOG(DEBUG) << "updating timestamp offset to: " << timestampOffset;
           timestamp += timestampOffset;
 	  isAligned = true;
 	}
 	continue;
       }
       if (chan != 0) {
-	LOGC(DDEV, DEBUG) << "chan: " << chan << ", timestamp: " << pktTimestamp << ", sz:" << payloadSz;
+	LOG(DEBUG) << "chan: " << chan << ", timestamp: " << pktTimestamp << ", sz:" << payloadSz;
 	continue;
       }
       if ((word0 >> 28) & 0x04) {
-	*underrun = true;
-	LOGC(DDEV, DEBUG) << "UNDERRUN in TRX->USRP interface";
+	if (underrun) *underrun = true;
+	LOG(DEBUG) << "UNDERRUN in TRX->USRP interface";
       }
       if (RSSI) *RSSI = (word0 >> 21) & 0x3f;
 
@@ -449,7 +443,7 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
       if (pktTimestamp + payloadSz/2/sizeof(short) > timeEnd)
 	timeEnd = pktTimestamp+payloadSz/2/sizeof(short);
 
-      LOGC(DDEV, DEBUG) << "timeStart: " << timeStart << ", timeEnd: " << timeEnd << ", pktTimestamp: " << pktTimestamp;
+      LOG(DEBUG) << "timeStart: " << timeStart << ", timeEnd: " << timeEnd << ", pktTimestamp: " << pktTimestamp;
 
     }
   }
@@ -457,14 +451,14 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
   // copy desired data to buf
   unsigned bufStart = dataStart+(timestamp-timeStart);
   if (bufStart + len < currDataSize/2) {
-    LOGC(DDEV, DEBUG) << "bufStart: " << bufStart;
+    LOG(DEBUG) << "bufStart: " << bufStart;
     memcpy(buf,data+bufStart*2,len*2*sizeof(short));
     memset(data+bufStart*2,0,len*2*sizeof(short));
   }
   else {
-    LOGC(DDEV, DEBUG) << "len: " << len << ", currDataSize/2: " << currDataSize/2 << ", bufStart: " << bufStart;
+    LOG(DEBUG) << "len: " << len << ", currDataSize/2: " << currDataSize/2 << ", bufStart: " << bufStart;
     unsigned firstLength = (currDataSize/2-bufStart);
-    LOGC(DDEV, DEBUG) << "firstLength: " << firstLength;
+    LOG(DEBUG) << "firstLength: " << firstLength;
     memcpy(buf,data+bufStart*2,firstLength*2*sizeof(short));
     memset(data+bufStart*2,0,firstLength*2*sizeof(short));
     memcpy(buf+firstLength*2,data,(len-firstLength)*2*sizeof(short));
@@ -505,6 +499,7 @@ int USRPDevice::readSamples(std::vector<short *> &bufs, int len, bool *overrun,
     gettimeofday(&lastReadTime,NULL);
     firstRead = true;
   }
+  samplesRead += numSamples;
 
   return numSamples;
 #endif
@@ -554,12 +549,14 @@ int USRPDevice::writeSamples(std::vector<short *> &bufs, int len,
   }
   m_uTx->write((const void*) outPkt,sizeof(uint32_t)*128*numPkts,NULL);
 
+  samplesWritten += len/2/sizeof(short);
   writeLock.unlock();
 
   return len/2/sizeof(short);
 #else
   int retVal = len;
   memcpy(loopbackBuffer+loopbackBufferSize,buf,sizeof(short)*2*len);
+  samplesWritten += retVal;
   loopbackBufferSize += retVal*2;
 
   return retVal;
@@ -591,19 +588,19 @@ bool USRPDevice::setTxFreq(double wFreq, size_t chan)
   usrp_tune_result result;
 
   if (chan) {
-    LOGC(DDEV, ALERT) << "Invalid channel " << chan;
+    LOG(ALERT) << "Invalid channel " << chan;
     return false;
   }
 
   if (m_uTx->tune(txSubdevSpec.side, m_dbTx, wFreq, &result)) {
-    LOGC(DDEV, INFO) << "set TX: " << wFreq << std::endl
+    LOG(INFO) << "set TX: " << wFreq << std::endl
               << "    baseband freq: " << result.baseband_freq << std::endl
               << "    DDC freq:      " << result.dxc_freq << std::endl
               << "    residual freq: " << result.residual_freq;
     return true;
   }
   else {
-    LOGC(DDEV, ALERT) << "set TX: " << wFreq << " failed" << std::endl
+    LOG(ALERT) << "set TX: " << wFreq << "failed" << std::endl
                << "    baseband freq: " << result.baseband_freq << std::endl
                << "    DDC freq:      " << result.dxc_freq << std::endl
                << "    residual freq: " << result.residual_freq;
@@ -616,19 +613,19 @@ bool USRPDevice::setRxFreq(double wFreq, size_t chan)
   usrp_tune_result result;
 
   if (chan) {
-    LOGC(DDEV, ALERT) << "Invalid channel " << chan;
+    LOG(ALERT) << "Invalid channel " << chan;
     return false;
   }
 
   if (m_uRx->tune(0, m_dbRx, wFreq, &result)) {
-    LOGC(DDEV, INFO) << "set RX: " << wFreq << std::endl
+    LOG(INFO) << "set RX: " << wFreq << std::endl
               << "    baseband freq: " << result.baseband_freq << std::endl
               << "    DDC freq:      " << result.dxc_freq << std::endl
               << "    residual freq: " << result.residual_freq;
     return true;
   }
   else {
-    LOGC(DDEV, ALERT) << "set RX: " << wFreq << " failed" << std::endl
+    LOG(ALERT) << "set RX: " << wFreq << "failed" << std::endl
                << "    baseband freq: " << result.baseband_freq << std::endl
                << "    DDC freq:      " << result.dxc_freq << std::endl
                << "    residual freq: " << result.residual_freq;
@@ -643,21 +640,9 @@ bool USRPDevice::setRxFreq(double wFreq) { return true;};
 #endif
 
 RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps,
-			       InterfaceType iface, size_t chans, double lo_offset,
+			       InterfaceType iface, size_t chans, double offset,
 			       const std::vector<std::string>& tx_paths,
 			       const std::vector<std::string>& rx_paths)
 {
-	if (tx_sps != rx_sps) {
-		LOGC(DDEV, ERROR) << "USRP1 requires tx_sps == rx_sps";
-		return NULL;
-	}
-	if (chans != 1) {
-		LOGC(DDEV, ERROR) << "USRP1 supports only 1 channel";
-		return NULL;
-	}
-	if (lo_offset != 0.0) {
-		LOGC(DDEV, ERROR) << "USRP1 doesn't support lo_offset";
-		return NULL;
-	}
-	return new USRPDevice(tx_sps, rx_sps, iface, chans, lo_offset, tx_paths, rx_paths);
+	return new USRPDevice(tx_sps);
 }

Transceiver52M/USRPDevice.h

@@ -1,10 +1,7 @@
 /*
 * Copyright 2008 Free Software Foundation, Inc.
 *
-* 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 distribuion.
+* This software is distributed under multiple licenses; see the COPYING file in the main directory for licensing information for this specific distribuion.
 *
 * This use of this software may be subject to additional restrictions.
 * See the LEGAL file in the main directory for details.
@@ -51,10 +48,15 @@ private:
   usrp_subdev_spec rxSubdevSpec;
   usrp_subdev_spec txSubdevSpec;
 
+  int sps;
   double actualSampleRate;	///< the actual USRP sampling rate
   unsigned int decimRate;	///< the USRP decimation rate
 
+  unsigned long long samplesRead;	///< number of samples read from USRP
+  unsigned long long samplesWritten;	///< number of samples sent to USRP
+
   bool started;			///< flag indicates USRP has started
+  bool skipRx;			///< set if USRP is transmit-only.
 
   static const unsigned int currDataSize_log2 = 21;
   static const unsigned long currDataSize = (1 << currDataSize_log2);
@@ -94,9 +96,7 @@ private:
  public:
 
   /** Object constructor */
-  USRPDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface, size_t chans, double lo_offset,
-		const std::vector<std::string>& tx_paths,
-		const std::vector<std::string>& rx_paths);
+  USRPDevice(size_t sps);
 
   /** Instantiate the USRP */
   int open(const std::string &, int, bool);
@@ -191,16 +191,14 @@ private:
   /* return the used RX path */
   std::string getTxAntenna(size_t chan = 0);
 
-  /** return whether user drives synchronization of Tx/Rx of USRP */
-  bool requiresRadioAlign();
-
-  /** return whether user drives synchronization of Tx/Rx of USRP */
-  virtual GSM::Time minLatency();
-
   /** Return internal status values */
   inline double getTxFreq(size_t chan = 0) { return 0; }
   inline double getRxFreq(size_t chan = 0) { return 0; }
   inline double getSampleRate() { return actualSampleRate; }
+  inline double numberRead() { return samplesRead; }
+  inline double numberWritten() { return samplesWritten; }
+
+  std::vector<std::string> tx_paths, rx_paths;
 };
 
 #endif // _USRP_DEVICE_H_

Transceiver52M/arch/Makefile.am

@@ -1,8 +0,0 @@
-include $(top_srcdir)/Makefile.common
-
-SUBDIRS = common
-if ARCH_ARM
-SUBDIRS += arm
-else
-SUBDIRS += x86
-endif

Transceiver52M/arch/common/Makefile.am

@@ -1,15 +0,0 @@
-AM_CFLAGS = -Wall -std=gnu99
-
-noinst_LTLIBRARIES = libarch_common.la
-
-noinst_HEADERS = \
-        convolve.h \
-        convert.h \
-        scale.h \
-        mult.h \
-        fft.h
-
-libarch_common_la_SOURCES = \
-        convolve_base.c \
-        convert_base.c \
-        fft.c

Transceiver52M/arm/Makefile.am

@@ -1,17 +1,17 @@
+if ARCH_ARM
 if ARCH_ARM_A15
 ARCH_FLAGS = -mfpu=neon-vfpv4
 else
 ARCH_FLAGS = -mfpu=neon
 endif
 
-AM_CFLAGS = -Wall $(ARCH_FLAGS) -std=gnu99 -I${srcdir}/../common
+AM_CFLAGS = -Wall $(ARCH_FLAGS) -std=gnu99 -I../common
 AM_CCASFLAGS = $(ARCH_FLAGS)
 
 noinst_LTLIBRARIES = libarch.la
 
-libarch_la_LIBADD = $(top_builddir)/Transceiver52M/arch/common/libarch_common.la
-
 libarch_la_SOURCES = \
+	../common/convolve_base.c \
 	convert.c \
 	convert_neon.S \
 	convolve.c \
@@ -20,3 +20,4 @@ libarch_la_SOURCES = \
 	scale_neon.S \
 	mult.c \
 	mult_neon.S
+endif

Transceiver52M/arm/convert.c

@@ -2,8 +2,6 @@
  * NEON type conversions
  * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either

Transceiver52M/arm/convert_neon.S

@@ -2,8 +2,6 @@
  * NEON type conversions
  * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either

Transceiver52M/arm/convolve.c

@@ -2,8 +2,6 @@
  * NEON Convolution
  * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -31,15 +29,17 @@
 int _base_convolve_real(float *x, int x_len,
 			float *h, int h_len,
 			float *y, int y_len,
-			int start, int len);
+			int start, int len,
+			int step, int offset);
 
 int _base_convolve_complex(float *x, int x_len,
 			   float *h, int h_len,
 			   float *y, int y_len,
-			   int start, int len);
+			   int start, int len,
+			   int step, int offset);
 
 int bounds_check(int x_len, int h_len, int y_len,
-		 int start, int len);
+		 int start, int len, int step);
 
 #ifdef HAVE_NEON
 /* Calls into NEON assembler */
@@ -69,16 +69,18 @@ void convolve_init(void)
 int convolve_real(float *x, int x_len,
 		  float *h, int h_len,
 		  float *y, int y_len,
-		  int start, int len)
+		  int start, int len,
+		  int step, int offset)
 {
 	void (*conv_func)(float *, float *, float *, int) = NULL;
 
-	if (bounds_check(x_len, h_len, y_len, start, len) < 0)
+	if (bounds_check(x_len, h_len, y_len, start, len, step) < 0)
 		return -1;
 
 	memset(y, 0, len * 2 * sizeof(float));
 
 #ifdef HAVE_NEON
+	if (step <= 4) {
 		switch (h_len) {
 		case 4:
 			conv_func = neon_conv_real4;
@@ -96,6 +98,7 @@ int convolve_real(float *x, int x_len,
 			conv_func = neon_conv_real20;
 			break;
 		}
+	}
 #endif
 	if (conv_func) {
 		conv_func(&x[2 * (-(h_len - 1) + start)],
@@ -104,7 +107,7 @@ int convolve_real(float *x, int x_len,
 		_base_convolve_real(x, x_len,
 				    h, h_len,
 				    y, y_len,
-				    start, len);
+				    start, len, step, offset);
 	}
 
 	return len;
@@ -115,17 +118,18 @@ int convolve_real(float *x, int x_len,
 int convolve_complex(float *x, int x_len,
 		     float *h, int h_len,
 		     float *y, int y_len,
-		     int start, int len)
+		     int start, int len,
+		     int step, int offset)
 {
 	void (*conv_func)(float *, float *, float *, int, int) = NULL;
 
-	if (bounds_check(x_len, h_len, y_len, start, len) < 0)
+	if (bounds_check(x_len, h_len, y_len, start, len, step) < 0)
 		return -1;
 
 	memset(y, 0, len * 2 * sizeof(float));
 
 #ifdef HAVE_NEON
-	if (!(h_len % 4))
+	if (step <= 4 && !(h_len % 4))
 		conv_func = neon_conv_cmplx_4n;
 #endif
 	if (conv_func) {
@@ -135,7 +139,7 @@ int convolve_complex(float *x, int x_len,
 		_base_convolve_complex(x, x_len,
 				       h, h_len,
 				       y, y_len,
-				       start, len);
+				       start, len, step, offset);
 	}
 
 	return len;

Transceiver52M/arm/convolve_neon.S

@@ -2,8 +2,6 @@
  * NEON Convolution
  * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -94,8 +92,8 @@ neon_conv_real12:
 	vld2.32     {q8-q9}, [r4], r6
 	vld2.32   {q10-q11}, [r5], r6
 #ifdef HAVE_NEON_FMA
-	vmul.f32         q1,   q6, q0
-	vmul.f32         q3,   q7, q0
+	vfma.f32         q1,   q6, q0
+	vfma.f32         q3,   q7, q0
 	vfma.f32         q1,   q8, q2
 	vfma.f32         q3,   q9, q2
 	vfma.f32         q1,  q10, q4

Transceiver52M/arm/mult.c

@@ -2,8 +2,6 @@
  * NEON scaling
  * Copyright (C) 2012,2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either

Transceiver52M/arm/mult_neon.S

@@ -2,8 +2,6 @@
  * NEON complex multiplication 
  * Copyright (C) 2012,2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either

Transceiver52M/arm/scale.c

@@ -2,8 +2,6 @@
  * NEON scaling
  * Copyright (C) 2012,2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either

Transceiver52M/arm/scale_neon.S

@@ -2,8 +2,6 @@
  * ARM NEON Scaling
  * Copyright (C) 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either

Transceiver52M/common/convert_base.c

@@ -2,8 +2,6 @@
  * Conversion
  * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -33,3 +31,4 @@ void base_convert_short_float(float *out, const short *in, int len)
 	for (int i = 0; i < len; i++)
 		out[i] = in[i];
 }
+

Transceiver52M/common/convolve.h

@@ -1,27 +1,31 @@
 #ifndef _CONVOLVE_H_
 #define _CONVOLVE_H_
 
-void *convolve_h_alloc(size_t num);
+void *convolve_h_alloc(int num);
 
 int convolve_real(const float *x, int x_len,
 		  const float *h, int h_len,
 		  float *y, int y_len,
-		  int start, int len);
+		  int start, int len,
+		  int step, int offset);
 
 int convolve_complex(const float *x, int x_len,
 		     const float *h, int h_len,
 		     float *y, int y_len,
-		     int start, int len);
+		     int start, int len,
+		     int step, int offset);
 
 int base_convolve_real(const float *x, int x_len,
 		       const float *h, int h_len,
 		       float *y, int y_len,
-		       int start, int len);
+		       int start, int len,
+		       int step, int offset);
 
 int base_convolve_complex(const float *x, int x_len,
 			  const float *h, int h_len,
 			  float *y, int y_len,
-			  int start, int len);
+			  int start, int len,
+			  int step, int offset);
 
 void convolve_init(void);
 

Transceiver52M/common/convolve_base.c

@@ -2,8 +2,6 @@
  * Convolution
  * Copyright (C) 2012, 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -43,17 +41,17 @@ static void mac_cmplx(const float *x, const float *h, float *y)
 
 /* Base vector complex-complex multiply and accumulate */
 static void mac_real_vec_n(const float *x, const float *h, float *y,
-			   int len)
+			   int len, int step, int offset)
 {
-	for (int i=0; i<len; i++)
+	for (int i = offset; i < len; i += step)
 		mac_real(&x[2 * i], &h[2 * i], y);
 }
 
 /* Base vector complex-complex multiply and accumulate */
 static void mac_cmplx_vec_n(const float *x, const float *h, float *y,
-			    int len)
+			    int len, int step, int offset)
 {
-	for (int i=0; i<len; i++)
+	for (int i = offset; i < len; i += step)
 		mac_cmplx(&x[2 * i], &h[2 * i], y);
 }
 
@@ -61,12 +59,14 @@ static void mac_cmplx_vec_n(const float *x, const float *h, float *y,
 int _base_convolve_real(const float *x, int x_len,
 			const float *h, int h_len,
 			float *y, int y_len,
-			int start, int len)
+			int start, int len,
+			int step, int offset)
 {
 	for (int i = 0; i < len; i++) {
 		mac_real_vec_n(&x[2 * (i - (h_len - 1) + start)],
 			       h,
-			       &y[2 * i], h_len);
+			       &y[2 * i], h_len,
+			       step, offset);
 	}
 
 	return len;
@@ -76,13 +76,14 @@ int _base_convolve_real(const float *x, int x_len,
 int _base_convolve_complex(const float *x, int x_len,
 			   const float *h, int h_len,
 			   float *y, int y_len,
-			   int start, int len)
+			   int start, int len,
+			   int step, int offset)
 {
 	for (int i = 0; i < len; i++) {
 		mac_cmplx_vec_n(&x[2 * (i - (h_len - 1) + start)],
 				h,
 				&y[2 * i],
-				h_len);
+				h_len, step, offset);
 	}
 
 	return len;
@@ -90,10 +91,10 @@ int _base_convolve_complex(const float *x, int x_len,
 
 /* Buffer validity checks */
 int bounds_check(int x_len, int h_len, int y_len,
-		 int start, int len)
+		 int start, int len, int step)
 {
 	if ((x_len < 1) || (h_len < 1) ||
-	    (y_len < 1) || (len < 1)) {
+	    (y_len < 1) || (len < 1) || (step < 1)) {
 		fprintf(stderr, "Convolve: Invalid input\n");
 		return -1;
 	}
@@ -112,9 +113,10 @@ int bounds_check(int x_len, int h_len, int y_len,
 int base_convolve_real(const float *x, int x_len,
 		       const float *h, int h_len,
 		       float *y, int y_len,
-		       int start, int len)
+		       int start, int len,
+		       int step, int offset)
 {
-	if (bounds_check(x_len, h_len, y_len, start, len) < 0)
+	if (bounds_check(x_len, h_len, y_len, start, len, step) < 0)
 		return -1;
 
 	memset(y, 0, len * 2 * sizeof(float));
@@ -122,16 +124,17 @@ int base_convolve_real(const float *x, int x_len,
 	return _base_convolve_real(x, x_len,
 				   h, h_len,
 				   y, y_len,
-				   start, len);
+				   start, len, step, offset);
 }
 
 /* API: Non-aligned (no SSE) complex-complex */
 int base_convolve_complex(const float *x, int x_len,
 			  const float *h, int h_len,
 			  float *y, int y_len,
-			  int start, int len)
+			  int start, int len,
+			  int step, int offset)
 {
-	if (bounds_check(x_len, h_len, y_len, start, len) < 0)
+	if (bounds_check(x_len, h_len, y_len, start, len, step) < 0)
 		return -1;
 
 	memset(y, 0, len * 2 * sizeof(float));
@@ -139,11 +142,11 @@ int base_convolve_complex(const float *x, int x_len,
 	return _base_convolve_complex(x, x_len,
 				      h, h_len,
 				      y, y_len,
-				      start, len);
+				      start, len, step, offset);
 }
 
 /* Aligned filter tap allocation */
-void *convolve_h_alloc(size_t len)
+void *convolve_h_alloc(int len)
 {
 #ifdef HAVE_SSE3
 	return memalign(16, len * 2 * sizeof(float));

Transceiver52M/common/fft.c

@@ -3,8 +3,6 @@
  *
  * Copyright (C) 2012 Tom Tsou <tom@tsou.cc>
  * 
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * 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

Transceiver52M/device/Makefile.am

@@ -1,15 +0,0 @@
-include $(top_srcdir)/Makefile.common
-
-SUBDIRS = common
-
-if DEVICE_USRP1
-SUBDIRS += usrp1
-endif
-
-if DEVICE_UHD
-SUBDIRS += uhd
-endif
-
-if DEVICE_LMS
-SUBDIRS += lms
-endif

Transceiver52M/device/common/Makefile.am

@@ -1,12 +0,0 @@
-include $(top_srcdir)/Makefile.common
-
-AM_CPPFLAGS = -Wall $(STD_DEFINES_AND_INCLUDES)
-AM_CXXFLAGS = -lpthread $(LIBOSMOCORE_CFLAGS) $(LIBOSMOCTRL_CFLAGS) $(LIBOSMOVTY_CFLAGS) $(LMS_CFLAGS)
-
-
-noinst_HEADERS = radioDevice.h smpl_buf.h
-
-noinst_LTLIBRARIES = libdevice_common.la
-
-libdevice_common_la_SOURCES = \
-	smpl_buf.cpp

Transceiver52M/device/common/smpl_buf.cpp

@@ -1,171 +0,0 @@
-/*
- * Sample Buffer - Allows reading and writing of timed samples
- *
- * Copyright 2010,2011 Free Software Foundation, Inc.
- * Copyright (C) 2015 Ettus Research LLC
- * Copyright 2019 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
- *
- * Author: Tom Tsou <tom.tsou@ettus.com>
- *
- * 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/>.
- * See the COPYING file in the main directory for details.
- */
-
-#include "smpl_buf.h"
-#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)
-{
-	data = new uint32_t[len];
-}
-
-smpl_buf::~smpl_buf()
-{
-	delete[] data;
-}
-
-ssize_t smpl_buf::avail_smpls(TIMESTAMP timestamp) const
-{
-	if (timestamp < time_start)
-		return ERROR_TIMESTAMP;
-	else if (timestamp >= time_end)
-		return 0;
-	else
-		return time_end - timestamp;
-}
-
-ssize_t smpl_buf::read(void *buf, size_t len, TIMESTAMP timestamp)
-{
-	int type_sz = 2 * sizeof(short);
-
-	// Check for valid read
-	if (timestamp < time_start)
-		return ERROR_TIMESTAMP;
-	if (timestamp >= time_end)
-		return 0;
-	if (len >= buf_len)
-		return ERROR_READ;
-
-	// How many samples should be copied
-	size_t num_smpls = time_end - timestamp;
-	if (num_smpls > len)
-		num_smpls = len;
-
-	// Starting index
-	size_t read_start = (data_start + (timestamp - time_start)) % buf_len;
-
-	// Read it
-	if (read_start + num_smpls < buf_len) {
-		size_t numBytes = len * type_sz;
-		memcpy(buf, data + read_start, numBytes);
-	} else {
-		size_t first_cp = (buf_len - read_start) * type_sz;
-		size_t second_cp = len * type_sz - first_cp;
-
-		memcpy(buf, data + read_start, first_cp);
-		memcpy((char*) buf + first_cp, data, second_cp);
-	}
-
-	data_start = (read_start + len) % buf_len;
-	time_start = timestamp + len;
-
-	if (time_start > time_end)
-		return ERROR_READ;
-	else
-		return num_smpls;
-}
-
-ssize_t smpl_buf::write(void *buf, size_t len, TIMESTAMP timestamp)
-{
-	int type_sz = 2 * sizeof(short);
-
-	// Check for valid write
-	if ((len == 0) || (len >= buf_len))
-		return ERROR_WRITE;
-	if ((timestamp + len) <= time_end)
-		return ERROR_TIMESTAMP;
-
-	if (timestamp < time_end) {
-		LOGC(DDEV, ERR) << "Overwriting old buffer data: timestamp="
-				<< timestamp << " time_end=" << time_end;
-		// Do not return error here, because it's a rounding error and is not fatal
-	}
-	if (timestamp > time_end && time_end != 0) {
-		LOGC(DDEV, ERR) << "Skipping buffer data: timestamp="
-				<< timestamp << " time_end=" << time_end;
-		// Do not return error here, because it's a rounding error and is not fatal
-	}
-
-	// Starting index
-	size_t write_start = (data_start + (timestamp - time_start)) % buf_len;
-
-	// Write it
-	if ((write_start + len) < buf_len) {
-		size_t numBytes = len * type_sz;
-		memcpy(data + write_start, buf, numBytes);
-	} else {
-		size_t first_cp = (buf_len - write_start) * type_sz;
-		size_t second_cp = len * type_sz - first_cp;
-
-		memcpy(data + write_start, buf, first_cp);
-		memcpy(data, (char*) buf + first_cp, second_cp);
-	}
-
-	data_end = (write_start + len) % buf_len;
-	time_end = timestamp + len;
-
-	if (!data_start)
-		data_start = write_start;
-
-	if (((write_start + len) > buf_len) && (data_end > data_start))
-		return ERROR_OVERFLOW;
-	else if (time_end <= time_start)
-		return ERROR_WRITE;
-	else
-		return len;
-}
-
-std::string smpl_buf::str_status(TIMESTAMP timestamp) const
-{
-	std::ostringstream ost("Sample buffer: ");
-
-	ost << "timestamp = " << timestamp;
-	ost << ", length = " << buf_len;
-	ost << ", time_start = " << time_start;
-	ost << ", time_end = " << time_end;
-	ost << ", data_start = " << data_start;
-	ost << ", data_end = " << data_end;
-
-	return ost.str();
-}
-
-std::string smpl_buf::str_code(ssize_t code)
-{
-	switch (code) {
-	case ERROR_TIMESTAMP:
-		return "Sample buffer: Requested timestamp is not valid";
-	case ERROR_READ:
-		return "Sample buffer: Read error";
-	case ERROR_WRITE:
-		return "Sample buffer: Write error";
-	case ERROR_OVERFLOW:
-		return "Sample buffer: Overrun";
-	default:
-		return "Sample buffer: Unknown error";
-	}
-}

Transceiver52M/device/common/smpl_buf.h

@@ -1,89 +0,0 @@
-/*
- * Sample Buffer - Allows reading and writing of timed samples
- *
- * Copyright 2010,2011 Free Software Foundation, Inc.
- * Copyright (C) 2015 Ettus Research LLC
- * Copyright 2019 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
- *
- * Author: Tom Tsou <tom.tsou@ettus.com>
- *
- * 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/>.
- * See the COPYING file in the main directory for details.
- */
-
-#pragma once
-
-#include <unistd.h>
-
-#include "radioDevice.h"
-
-/*
-    Sample Buffer - Allows reading and writing of timed samples using osmo-trx
-                    timestamps. Time conversions are handled
-                    internally or accessable through the static convert calls.
-*/
-class smpl_buf {
-public:
-	/** Sample buffer constructor
-	    @param len number of 32-bit samples the buffer should hold
-	    @param timestamp
-	*/
-	smpl_buf(size_t len);
-	~smpl_buf();
-
-	/** Query number of samples available for reading
-	    @param timestamp time of first sample
-	    @return number of available samples or error
-	*/
-	ssize_t avail_smpls(TIMESTAMP timestamp) const;
-
-	/** Read and write
-	    @param buf pointer to buffer
-	    @param len number of samples desired to read or write
-	    @param timestamp time of first stample
-	    @return number of actual samples read or written or error
-	*/
-	ssize_t read(void *buf, size_t len, TIMESTAMP timestamp);
-	ssize_t write(void *buf, size_t len, TIMESTAMP timestamp);
-
-	/** Buffer status string
-	    @return a formatted string describing internal buffer state
-	*/
-	std::string str_status(TIMESTAMP timestamp) const;
-
-	/** Formatted error string
-	    @param code an error code
-	    @return a formatted error string
-	*/
-	static std::string str_code(ssize_t code);
-
-	enum err_code {
-		ERROR_TIMESTAMP = -1,
-		ERROR_READ = -2,
-		ERROR_WRITE = -3,
-		ERROR_OVERFLOW = -4
-	};
-
-private:
-	uint32_t *data;
-	size_t buf_len;
-
-	TIMESTAMP time_start;
-	TIMESTAMP time_end;
-
-	size_t data_start;
-	size_t data_end;
-};

Transceiver52M/device/lms/LMSDevice.cpp

@@ -1,821 +0,0 @@
-/*
-* Copyright 2018 sysmocom - s.f.m.c. GmbH
-*
-* 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/>.
-*/
-
-#include <stdint.h>
-#include <string.h>
-#include <stdlib.h>
-#include "Logger.h"
-#include "Threads.h"
-#include "LMSDevice.h"
-#include "Utils.h"
-
-#include <lime/LimeSuite.h>
-
-extern "C" {
-#include "osmo_signal.h"
-#include <osmocom/core/utils.h>
-}
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-using namespace std;
-
-#define MAX_ANTENNA_LIST_SIZE 10
-#define LMS_SAMPLE_RATE GSMRATE*32
-#define GSM_CARRIER_BW 270000.0 /* 270kHz */
-#define LMS_MIN_BW_SUPPORTED 2.5e6 /* 2.5mHz, minimum supported by LMS */
-#define LMS_CALIBRATE_BW_HZ OSMO_MAX(GSM_CARRIER_BW, LMS_MIN_BW_SUPPORTED)
-#define SAMPLE_BUF_SZ    (1 << 20) /* Size of Rx timestamp based Ring buffer, in bytes */
-
-LMSDevice::LMSDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface, size_t chans, double lo_offset,
-		     const std::vector<std::string>& tx_paths,
-		     const std::vector<std::string>& rx_paths):
-	RadioDevice(tx_sps, rx_sps, iface, chans, lo_offset, tx_paths, rx_paths),
-	m_lms_dev(NULL)
-{
-	LOGC(DDEV, INFO) << "creating LMS device...";
-
-	m_lms_stream_rx.resize(chans);
-	m_lms_stream_tx.resize(chans);
-
-	rx_buffers.resize(chans);
-}
-
-LMSDevice::~LMSDevice()
-{
-	unsigned int i;
-	LOGC(DDEV, INFO) << "Closing LMS device";
-	if (m_lms_dev) {
-		/* disable all channels */
-		for (i=0; i<chans; i++) {
-			LMS_EnableChannel(m_lms_dev, LMS_CH_RX, i, false);
-			LMS_EnableChannel(m_lms_dev, LMS_CH_TX, i, false);
-		}
-		LMS_Close(m_lms_dev);
-		m_lms_dev = NULL;
-	}
-
-	for (size_t i = 0; i < rx_buffers.size(); i++)
-		delete rx_buffers[i];
-}
-
-static void lms_log_callback(int lvl, const char *msg)
-{
-	/* map lime specific log levels */
-	static const int lvl_map[5] = {
-		[0] = LOGL_FATAL,
-		[LMS_LOG_ERROR] = LOGL_ERROR,
-		[LMS_LOG_WARNING] = LOGL_NOTICE,
-		[LMS_LOG_INFO] = LOGL_INFO,
-		[LMS_LOG_DEBUG] = LOGL_DEBUG,
-	};
-	/* protect against future higher log level values (lower importance) */
-	if ((unsigned int) lvl >= ARRAY_SIZE(lvl_map))
-		lvl = ARRAY_SIZE(lvl_map)-1;
-
-	LOGLV(DLMS, lvl_map[lvl]) << msg;
-}
-
-static void print_range(const char* name, lms_range_t *range)
-{
-	LOGC(DDEV, INFO) << name << ": Min=" << range->min << " Max=" << range->max
-		   << " Step=" << range->step;
-}
-
-/*! Find the device string that matches all filters from \a args.
- *  \param[in] info_list device addresses found by LMS_GetDeviceList()
- *  \param[in] count length of info_list
- *  \param[in] args dev-args value from osmo-trx.cfg, containing comma separated key=value pairs
- *  \return index of first matching device or -1 (no match) */
-int info_list_find(lms_info_str_t* info_list, unsigned int count, const std::string &args)
-{
-	unsigned int i, j;
-	vector<string> filters;
-
-	filters = comma_delimited_to_vector(args.c_str());
-
-	/* iterate over device addresses */
-	for (i=0; i < count; i++) {
-		/* check if all filters match */
-		bool match = true;
-		for (j=0; j < filters.size(); j++) {
-			if (!strstr(info_list[i], filters[j].c_str())) {
-				match = false;
-				break;
-			}
-		}
-
-		if (match)
-			return i;
-	}
-	return -1;
-}
-
-int LMSDevice::open(const std::string &args, int ref, bool swap_channels)
-{
-	lms_info_str_t* info_list;
-	const lms_dev_info_t* device_info;
-	lms_range_t range_sr;
-	float_type sr_host, sr_rf;
-	unsigned int i, n;
-	int rc, dev_id;
-
-	LOGC(DDEV, INFO) << "Opening LMS device..";
-
-	LMS_RegisterLogHandler(&lms_log_callback);
-
-	if ((n = LMS_GetDeviceList(NULL)) < 0)
-		LOGC(DDEV, ERROR) << "LMS_GetDeviceList(NULL) failed";
-	LOGC(DDEV, INFO) << "Devices found: " << n;
-	if (n < 1)
-	    return -1;
-
-	info_list = new lms_info_str_t[n];
-
-	if (LMS_GetDeviceList(info_list) < 0)
-		LOGC(DDEV, ERROR) << "LMS_GetDeviceList(info_list) failed";
-
-	for (i = 0; i < n; i++)
-		LOGC(DDEV, INFO) << "Device [" << i << "]: " << info_list[i];
-
-	dev_id = info_list_find(info_list, n, args);
-	if (dev_id == -1) {
-		LOGC(DDEV, ERROR) << "No LMS device found with address '" << args << "'";
-		delete[] info_list;
-		return -1;
-	}
-
-	LOGC(DDEV, INFO) << "Using device[" << dev_id << "]";
-	rc = LMS_Open(&m_lms_dev, info_list[dev_id], NULL);
-	if (rc != 0) {
-		LOGC(DDEV, ERROR) << "LMS_GetDeviceList() failed)";
-		delete [] info_list;
-		return -1;
-	}
-
-	delete [] info_list;
-
-	device_info = LMS_GetDeviceInfo(m_lms_dev);
-
-	if ((ref != REF_EXTERNAL) && (ref != REF_INTERNAL)){
-		LOGC(DDEV, ERROR) << "Invalid reference type";
-		goto out_close;
-	}
-
-	/* if reference clock is external setup must happen _before_ calling LMS_Init */
-	/* FIXME make external reference frequency configurable */
-	if (ref == REF_EXTERNAL) {
-		LOGC(DDEV, INFO) << "Setting External clock reference to 10MHz";
-		/* Assume an external 10 MHz reference clock */
-		if (LMS_SetClockFreq(m_lms_dev, LMS_CLOCK_EXTREF, 10000000.0) < 0)
-			goto out_close;
-	}
-
-	LOGC(DDEV, INFO) << "Init LMS device";
-	if (LMS_Init(m_lms_dev) != 0) {
-		LOGC(DDEV, ERROR) << "LMS_Init() failed";
-		goto out_close;
-	}
-
-	/* LimeSDR-Mini does not have switches but needs soldering to select external/internal clock */
-	/* LimeNET-Micro also does not like selecting internal clock*/
-	/* also set device specific maximum tx levels selected by phasenoise measurements*/
-	if (strncmp(device_info->deviceName,"LimeSDR-USB",11) == 0){
-		/* if reference clock is internal setup must happen _after_ calling LMS_Init */
-		/* according to lms using LMS_CLOCK_EXTREF with a frequency <= 0 is the correct way to set clock to internal reference*/
-		if (ref == REF_INTERNAL) {
-			LOGC(DDEV, INFO) << "Setting Internal clock reference";
-			if (LMS_SetClockFreq(m_lms_dev, LMS_CLOCK_EXTREF, -1) < 0)
-				goto out_close;
-		}
-		maxTxGainClamp = 73.0;
-	} else if (strncmp(device_info->deviceName,"LimeSDR-Mini",12) == 0)
-		maxTxGainClamp = 66.0;
-	else
-		maxTxGainClamp = 71.0; /* "LimeNET-Micro", etc FIXME pciE based LMS boards?*/
-
-	/* enable all used channels */
-	for (i=0; i<chans; i++) {
-		if (LMS_EnableChannel(m_lms_dev, LMS_CH_RX, i, true) < 0)
-			goto out_close;
-		if (LMS_EnableChannel(m_lms_dev, LMS_CH_TX, i, true) < 0)
-			goto out_close;
-	}
-
-	/* set samplerate */
-	if (LMS_GetSampleRateRange(m_lms_dev, LMS_CH_RX, &range_sr))
-		goto out_close;
-	print_range("Sample Rate", &range_sr);
-
-	LOGC(DDEV, INFO) << "Setting sample rate to " << GSMRATE*tx_sps << " " << tx_sps;
-	if (LMS_SetSampleRate(m_lms_dev, GSMRATE*tx_sps, 32) < 0)
-		goto out_close;
-
-	if (LMS_GetSampleRate(m_lms_dev, LMS_CH_RX, 0, &sr_host, &sr_rf))
-		goto out_close;
-	LOGC(DDEV, INFO) << "Sample Rate: Host=" << sr_host << " RF=" << sr_rf;
-
-	/* FIXME: make this device/model dependent, like UHDDevice:dev_param_map! */
-	ts_offset = static_cast<TIMESTAMP>(8.9e-5 * GSMRATE * tx_sps); /* time * sample_rate */
-
-	/* configure antennas */
-	if (!set_antennas()) {
-		LOGC(DDEV, FATAL) << "LMS antenna setting failed";
-		goto out_close;
-	}
-
-	/* 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));
-
-	started = false;
-
-	return NORMAL;
-
-out_close:
-	LOGC(DDEV, FATAL) << "Error in LMS open, closing: " << LMS_GetLastErrorMessage();
-	LMS_Close(m_lms_dev);
-	m_lms_dev = NULL;
-	return -1;
-}
-
-bool LMSDevice::start()
-{
-	LOGC(DDEV, INFO) << "starting LMS...";
-
-	unsigned int i;
-
-	if (started) {
-		LOGC(DDEV, ERR) << "Device already started";
-		return false;
-	}
-
-	/* configure the channels/streams */
-	for (i=0; i<chans; i++) {
-		/* Set gains for calibration/filter setup */
-		/* TX gain to maximum */
-		setTxGain(maxTxGain(), i);
-		/* RX gain to midpoint */
-		setRxGain((minRxGain() + maxRxGain()) / 2, i);
-
-		/* set up Rx and Tx filters */
-		if (!do_filters(i))
-			return false;
-		/* Perform Rx and Tx calibration */
-		if (!do_calib(i))
-			return false;
-
-		/* configure Streams */
-		m_lms_stream_rx[i] = {};
-		m_lms_stream_rx[i].isTx = false;
-		m_lms_stream_rx[i].channel = i;
-		m_lms_stream_rx[i].fifoSize = 1024 * 1024;
-		m_lms_stream_rx[i].throughputVsLatency = 0.3;
-		m_lms_stream_rx[i].dataFmt = lms_stream_t::LMS_FMT_I16;
-
-		m_lms_stream_tx[i] = {};
-		m_lms_stream_tx[i].isTx = true;
-		m_lms_stream_tx[i].channel = i;
-		m_lms_stream_tx[i].fifoSize = 1024 * 1024;
-		m_lms_stream_tx[i].throughputVsLatency = 0.3;
-		m_lms_stream_tx[i].dataFmt = lms_stream_t::LMS_FMT_I16;
-
-		if (LMS_SetupStream(m_lms_dev, &m_lms_stream_rx[i]) < 0)
-			return false;
-
-		if (LMS_SetupStream(m_lms_dev, &m_lms_stream_tx[i]) < 0)
-			return false;
-	}
-
-	/* now start the streams in a second loop, as we can no longer call
-	 * LMS_SetupStream() after LMS_StartStream() of the first stream */
-	for (i = 0; i < chans; i++) {
-		if (LMS_StartStream(&m_lms_stream_rx[i]) < 0)
-			return false;
-
-		if (LMS_StartStream(&m_lms_stream_tx[i]) < 0)
-			return false;
-	}
-
-	flush_recv(10);
-
-	started = true;
-	return true;
-}
-
-bool LMSDevice::stop()
-{
-	unsigned int i;
-
-	if (!started)
-		return true;
-
-	for (i=0; i<chans; i++) {
-		LMS_StopStream(&m_lms_stream_tx[i]);
-		LMS_StopStream(&m_lms_stream_rx[i]);
-	}
-
-	for (i=0; i<chans; i++) {
-		LMS_DestroyStream(m_lms_dev, &m_lms_stream_tx[i]);
-		LMS_DestroyStream(m_lms_dev, &m_lms_stream_rx[i]);
-	}
-
-	started = false;
-	return true;
-}
-
-/* do rx/tx calibration - depends on gain, freq and bw */
-bool LMSDevice::do_calib(size_t chan)
-{
-	LOGCHAN(chan, DDEV, INFO) << "Calibrating";
-	if (LMS_Calibrate(m_lms_dev, LMS_CH_RX, chan, LMS_CALIBRATE_BW_HZ, 0) < 0)
-		return false;
-	if (LMS_Calibrate(m_lms_dev, LMS_CH_TX, chan, LMS_CALIBRATE_BW_HZ, 0) < 0)
-		return false;
-	return true;
-}
-
-/* do rx/tx filter config - depends on bw only? */
-bool LMSDevice::do_filters(size_t chan)
-{
-	lms_range_t range_lpfbw_rx, range_lpfbw_tx;
-	float_type lpfbw_rx, lpfbw_tx;
-
-	LOGCHAN(chan, DDEV, INFO) << "Setting filters";
-	if (LMS_GetLPFBWRange(m_lms_dev, LMS_CH_RX, &range_lpfbw_rx))
-		return false;
-	print_range("LPFBWRange Rx", &range_lpfbw_rx);
-	if (LMS_GetLPFBWRange(m_lms_dev, LMS_CH_RX, &range_lpfbw_tx))
-		return false;
-	print_range("LPFBWRange Tx", &range_lpfbw_tx);
-
-	lpfbw_rx = OSMO_MIN(OSMO_MAX(1.4001e6, range_lpfbw_rx.min), range_lpfbw_rx.max);
-	lpfbw_tx = OSMO_MIN(OSMO_MAX(5.2e6, range_lpfbw_tx.min), range_lpfbw_tx.max);
-
-	LOGCHAN(chan, DDEV, INFO) << "LPFBW: Rx=" << lpfbw_rx << " Tx=" << lpfbw_tx;
-
-	LOGCHAN(chan, DDEV, INFO) << "Setting LPFBW";
-	if (LMS_SetLPFBW(m_lms_dev, LMS_CH_RX, chan, lpfbw_rx) < 0)
-		return false;
-	if (LMS_SetLPFBW(m_lms_dev, LMS_CH_TX, chan, lpfbw_tx) < 0)
-		return false;
-	return true;
-}
-
-
-double LMSDevice::maxTxGain()
-{
-	return maxTxGainClamp;
-}
-
-double LMSDevice::minTxGain()
-{
-	return 0.0;
-}
-
-double LMSDevice::maxRxGain()
-{
-	return 73.0;
-}
-
-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";
-
-	return dB;
-}
-
-double LMSDevice::setRxGain(double dB, size_t chan)
-{
-	if (dB > maxRxGain())
-		dB = maxRxGain();
-	if (dB < minRxGain())
-		dB = minRxGain();
-
-	LOGCHAN(chan, DDEV, NOTICE) << "Setting RX gain to " << dB << " dB";
-
-	if (LMS_SetGaindB(m_lms_dev, LMS_CH_RX, chan, dB) < 0)
-		LOGCHAN(chan, DDEV, ERR) << "Error setting RX gain to " << dB << " dB";
-
-	return dB;
-}
-
-int LMSDevice::get_ant_idx(const std::string & name, bool dir_tx, size_t chan)
-{
-	lms_name_t name_list[MAX_ANTENNA_LIST_SIZE]; /* large enough list for antenna names. */
-	const char* c_name = name.c_str();
-	int num_names;
-	int i;
-
-	num_names = LMS_GetAntennaList(m_lms_dev, dir_tx, chan, name_list);
-	for (i = 0; i < num_names; i++) {
-		if (!strcmp(c_name, name_list[i]))
-			return i;
-	}
-	return -1;
-}
-
-bool LMSDevice::flush_recv(size_t num_pkts)
-{
-	#define CHUNK 625
-	int len = CHUNK * tx_sps;
-	short *buffer = (short*) alloca(sizeof(short) * len * 2);
-	int rc;
-	lms_stream_meta_t rx_metadata = {};
-	rx_metadata.flushPartialPacket = false;
-	rx_metadata.waitForTimestamp = false;
-
-	ts_initial = 0;
-
-	while (!ts_initial || (num_pkts-- > 0)) {
-		rc = LMS_RecvStream(&m_lms_stream_rx[0], &buffer[0], len, &rx_metadata, 100);
-		LOGC(DDEV, DEBUG) << "Flush: Recv buffer of len " << rc << " at " << std::hex << rx_metadata.timestamp;
-		if (rc != len) {
-			LOGC(DDEV, ERROR) << "Flush: Device receive timed out";
-			return false;
-		}
-
-		ts_initial = rx_metadata.timestamp + len;
-	}
-
-	LOGC(DDEV, INFO) << "Initial timestamp " << ts_initial << std::endl;
-	return true;
-}
-
-bool LMSDevice::setRxAntenna(const std::string & ant, size_t chan)
-{
-	int idx;
-
-	if (chan >= rx_paths.size()) {
-		LOGC(DDEV, ERROR) << "Requested non-existent channel " << chan;
-		return false;
-	}
-
-	idx = get_ant_idx(ant, LMS_CH_RX, chan);
-	if (idx < 0) {
-		LOGCHAN(chan, DDEV, ERROR) << "Invalid Rx Antenna";
-		return false;
-	}
-
-	if (LMS_SetAntenna(m_lms_dev, LMS_CH_RX, chan, idx) < 0) {
-		LOGCHAN(chan, DDEV, ERROR) << "Unable to set Rx Antenna";
-	}
-
-	return true;
-}
-
-std::string LMSDevice::getRxAntenna(size_t chan)
-{
-	lms_name_t name_list[MAX_ANTENNA_LIST_SIZE]; /* large enough list for antenna names. */
-	int idx;
-
-	if (chan >= rx_paths.size()) {
-		LOGC(DDEV, ERROR) << "Requested non-existent channel " << chan;
-		return "";
-	}
-
-	idx = LMS_GetAntenna(m_lms_dev, LMS_CH_RX, chan);
-	if (idx < 0) {
-		LOGCHAN(chan, DDEV, ERROR) << "Error getting Rx Antenna";
-		return "";
-	}
-
-	if (LMS_GetAntennaList(m_lms_dev, LMS_CH_RX, chan, name_list) < idx) {
-		LOGCHAN(chan, DDEV, ERROR) << "Error getting Rx Antenna List";
-		return "";
-	}
-
-	return name_list[idx];
-}
-
-bool LMSDevice::setTxAntenna(const std::string & ant, size_t chan)
-{
-	int idx;
-
-	if (chan >= tx_paths.size()) {
-		LOGC(DDEV, ERROR) << "Requested non-existent channel " << chan;
-		return false;
-	}
-
-	idx = get_ant_idx(ant, LMS_CH_TX, chan);
-	if (idx < 0) {
-		LOGCHAN(chan, DDEV, ERROR) << "Invalid Rx Antenna";
-		return false;
-	}
-
-	if (LMS_SetAntenna(m_lms_dev, LMS_CH_TX, chan, idx) < 0) {
-		LOGCHAN(chan, DDEV, ERROR) << "Unable to set Rx Antenna";
-	}
-
-	return true;
-}
-
-std::string LMSDevice::getTxAntenna(size_t chan)
-{
-	lms_name_t name_list[MAX_ANTENNA_LIST_SIZE]; /* large enough list for antenna names. */
-	int idx;
-
-	if (chan >= tx_paths.size()) {
-		LOGC(DDEV, ERROR) << "Requested non-existent channel " << chan;
-		return "";
-	}
-
-	idx = LMS_GetAntenna(m_lms_dev, LMS_CH_TX, chan);
-	if (idx < 0) {
-		LOGCHAN(chan, DDEV, ERROR) << "Error getting Tx Antenna";
-		return "";
-	}
-
-	if (LMS_GetAntennaList(m_lms_dev, LMS_CH_TX, chan, name_list) < idx) {
-		LOGCHAN(chan, DDEV, ERROR) << "Error getting Tx Antenna List";
-		return "";
-	}
-
-	return name_list[idx];
-}
-
-bool LMSDevice::requiresRadioAlign()
-{
-	return false;
-}
-
-GSM::Time LMSDevice::minLatency() {
-	/* UNUSED on limesdr (only used on usrp1/2) */
-	return GSM::Time(0,0);
-}
-/*!
- * Issue tracking description of several events: https://github.com/myriadrf/LimeSuite/issues/265
- */
-void LMSDevice::update_stream_stats_rx(size_t chan, bool *overrun)
-{
-	lms_stream_status_t status;
-	bool changed = false;
-
-	if (LMS_GetStreamStatus(&m_lms_stream_rx[chan], &status) != 0) {
-		LOGCHAN(chan, DDEV, ERROR) << "Rx LMS_GetStreamStatus failed";
-		return;
-	}
-
-	/* FIFO overrun is counted when Rx FIFO is full but new data comes from
-	   the board and oldest samples in FIFO are overwritte. Value count
-	   since the last call to LMS_GetStreamStatus(stream). */
-	if (status.overrun) {
-		changed = true;
-		*overrun = true;
-		LOGCHAN(chan, DDEV, ERROR) << "Rx Overrun! ("
-					   << m_ctr[chan].rx_overruns << " -> "
-					   << status.overrun << ")";
-	}
-	m_ctr[chan].rx_overruns += status.overrun;
-
-	/* Dropped packets in Rx are counted when gaps in Rx timestamps are
-	   detected (likely because buffer oveflow in hardware). Value count
-	   since the last call to LMS_GetStreamStatus(stream). */
-	if (status.droppedPackets) {
-		changed = true;
-		LOGCHAN(chan, DDEV, ERROR) << "Rx Dropped packets by HW! ("
-					   << m_ctr[chan].rx_dropped_samples << " -> "
-					   << m_ctr[chan].rx_dropped_samples +
-					      status.droppedPackets
-					   << ")";
-		m_ctr[chan].rx_dropped_events++;
-	}
-	m_ctr[chan].rx_dropped_samples += status.droppedPackets;
-
-	if (changed)
-		osmo_signal_dispatch(SS_DEVICE, S_DEVICE_COUNTER_CHANGE, &m_ctr[chan]);
-
-}
-
-// NOTE: Assumes sequential reads
-int LMSDevice::readSamples(std::vector < short *>&bufs, int len, bool * overrun,
-			   TIMESTAMP timestamp, bool * underrun, unsigned *RSSI)
-{
-	int rc, num_smpls, expect_smpls;
-	ssize_t avail_smpls;
-	TIMESTAMP expect_timestamp;
-	unsigned int i;
-	lms_stream_meta_t rx_metadata = {};
-	rx_metadata.flushPartialPacket = false;
-	rx_metadata.waitForTimestamp = false;
-	rx_metadata.timestamp = 0;
-
-	if (bufs.size() != chans) {
-		LOGC(DDEV, ERROR) << "Invalid channel combination " << bufs.size();
-		return -1;
-	}
-
-	*overrun = false;
-	*underrun = false;
-
-	/* Check that timestamp is valid */
-	rc = rx_buffers[0]->avail_smpls(timestamp);
-	if (rc < 0) {
-		LOGC(DDEV, ERROR) << rx_buffers[0]->str_code(rc);
-		LOGC(DDEV, ERROR) << rx_buffers[0]->str_status(timestamp);
-		return 0;
-	}
-
-	for (i = 0; i<chans; i++) {
-		/* Receive samples from HW until we have enough */
-		while ((avail_smpls = rx_buffers[i]->avail_smpls(timestamp)) < len) {
-			thread_enable_cancel(false);
-			num_smpls = LMS_RecvStream(&m_lms_stream_rx[i], bufs[i], len - avail_smpls, &rx_metadata, 100);
-			update_stream_stats_rx(i, overrun);
-			thread_enable_cancel(true);
-			if (num_smpls <= 0) {
-				LOGCHAN(i, DDEV, ERROR) << "Device receive timed out (" << rc << " vs exp " << len << ").";
-				return -1;
-			}
-
-			LOGCHAN(i, DDEV, DEBUG) "Received timestamp = " << (TIMESTAMP)rx_metadata.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)rx_metadata.timestamp)
-				LOGCHAN(i, DDEV, ERROR) << "Unexpected recv buffer timestamp: expect "
-							<< expect_timestamp << " got " << (TIMESTAMP)rx_metadata.timestamp
-							<< ", diff=" << rx_metadata.timestamp - expect_timestamp;
-
-			rc = rx_buffers[i]->write(bufs[i], num_smpls, (TIMESTAMP)rx_metadata.timestamp);
-			if (rc < 0) {
-				LOGCHAN(i, DDEV, ERROR) << rx_buffers[i]->str_code(rc);
-				LOGCHAN(i, DDEV, ERROR) << rx_buffers[i]->str_status(timestamp);
-				if (rc != smpl_buf::ERROR_OVERFLOW)
-					return 0;
-			}
-		}
-	}
-
-	/* We have enough samples */
-	for (size_t i = 0; i < rx_buffers.size(); i++) {
-		rc = rx_buffers[i]->read(bufs[i], len, timestamp);
-		if ((rc < 0) || (rc != len)) {
-			LOGC(DDEV, ERROR) << rx_buffers[i]->str_code(rc);
-			LOGC(DDEV, ERROR) << rx_buffers[i]->str_status(timestamp);
-			return 0;
-		}
-	}
-
-	return len;
-}
-
-void LMSDevice::update_stream_stats_tx(size_t chan, bool *underrun)
-{
-	lms_stream_status_t status;
-	bool changed = false;
-
-	if (LMS_GetStreamStatus(&m_lms_stream_tx[chan], &status) != 0) {
-		LOGCHAN(chan, DDEV, ERROR) << "Tx LMS_GetStreamStatus failed";
-		return;
-	}
-
-	/* FIFO underrun is counted when Tx is running but FIFO is empty for
-	   >100 ms (500ms in older versions). Value count since the last call to
-	   LMS_GetStreamStatus(stream). */
-	if (status.underrun) {
-		changed = true;
-		*underrun = true;
-		LOGCHAN(chan, DDEV, ERROR) << "Tx Underrun! ("
-					   << m_ctr[chan].tx_underruns << " -> "
-					   << status.underrun << ")";
-	}
-	m_ctr[chan].tx_underruns += status.underrun;
-
-	/* Dropped packets in Tx are counted only when timestamps are enabled
-	   and SDR drops packet because of late timestamp. Value count since the
-	   last call to LMS_GetStreamStatus(stream). */
-	if (status.droppedPackets) {
-		changed = true;
-		LOGCHAN(chan, DDEV, ERROR) << "Tx Dropped packets by HW! ("
-					   << m_ctr[chan].tx_dropped_samples << " -> "
-					   << m_ctr[chan].tx_dropped_samples +
-					      status.droppedPackets
-					   << ")";
-		m_ctr[chan].tx_dropped_events++;
-	}
-	m_ctr[chan].tx_dropped_samples += status.droppedPackets;
-
-	if (changed)
-		osmo_signal_dispatch(SS_DEVICE, S_DEVICE_COUNTER_CHANGE, &m_ctr[chan]);
-
-}
-
-int LMSDevice::writeSamples(std::vector < short *>&bufs, int len,
-			    bool * underrun, unsigned long long timestamp,
-			    bool isControl)
-{
-	int rc = 0;
-	unsigned int i;
-	lms_stream_meta_t tx_metadata = {};
-	tx_metadata.flushPartialPacket = false;
-	tx_metadata.waitForTimestamp = true;
-	tx_metadata.timestamp = timestamp - ts_offset;	/* Shift Tx time by offset */
-
-	if (isControl) {
-		LOGC(DDEV, ERROR) << "Control packets not supported";
-		return 0;
-	}
-
-	if (bufs.size() != chans) {
-		LOGC(DDEV, ERROR) << "Invalid channel combination " << bufs.size();
-		return -1;
-	}
-
-	*underrun = false;
-
-	for (i = 0; i<chans; i++) {
-		LOGCHAN(i, DDEV, DEBUG) << "send buffer of len " << len << " timestamp " << std::hex << tx_metadata.timestamp;
-		thread_enable_cancel(false);
-		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;
-		}
-	}
-
-	return rc;
-}
-
-bool LMSDevice::updateAlignment(TIMESTAMP timestamp)
-{
-	return true;
-}
-
-bool LMSDevice::setTxFreq(double wFreq, size_t chan)
-{
-	LOGCHAN(chan, DDEV, NOTICE) << "Setting Tx Freq to " << wFreq << " Hz";
-
-	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;
-	}
-
-	return true;
-}
-
-bool LMSDevice::setRxFreq(double wFreq, size_t chan)
-{
-	LOGCHAN(chan, DDEV, NOTICE) << "Setting Rx Freq to " << wFreq << " Hz";
-
-	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;
-	}
-
-	return true;
-}
-
-RadioDevice *RadioDevice::make(size_t tx_sps, size_t rx_sps,
-			       InterfaceType iface, size_t chans, double lo_offset,
-			       const std::vector < std::string > &tx_paths,
-			       const std::vector < std::string > &rx_paths)
-{
-	if (tx_sps != rx_sps) {
-		LOGC(DDEV, ERROR) << "LMS Requires tx_sps == rx_sps";
-		return NULL;
-	}
-	if (lo_offset != 0.0) {
-		LOGC(DDEV, ERROR) << "LMS doesn't support lo_offset";
-		return NULL;
-	}
-	return new LMSDevice(tx_sps, rx_sps, iface, chans, lo_offset, tx_paths, rx_paths);
-}

Transceiver52M/device/lms/LMSDevice.h

@@ -1,204 +0,0 @@
-/*
-* Copyright 2018 sysmocom - s.f.m.c. GmbH
-*
-* 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 distribuion.
-*
-* 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.
-
-*/
-
-#ifndef _LMS_DEVICE_H_
-#define _LMS_DEVICE_H_
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#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>
-
-/* 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:
- * 	A^2 = I^2 + Q^2
- * 	A^2 = (1/sqrt(2))^2 + (1/sqrt(2))^2
- * 	A^2 = 1/2 + 1/2
- * 	A^2 = 1 */
-#define LIMESDR_TX_AMPL  0.707
-
-/** A class to handle a LimeSuite supported device */
-class LMSDevice:public RadioDevice {
-
-private:
-	lms_device_t *m_lms_dev;
-	std::vector<lms_stream_t> m_lms_stream_rx;
-	std::vector<lms_stream_t> m_lms_stream_tx;
-
-	std::vector<smpl_buf *> rx_buffers;
-
-	double actualSampleRate;	///< the actual USRP sampling rate
-
-	bool started;		///< flag indicates LMS has started
-	bool skipRx;		///< set if LMS is transmit-only.
-
-	TIMESTAMP ts_initial, ts_offset;
-
-	double rxGain;
-	double maxTxGainClamp;
-
-	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);
-	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);
-
-public:
-
-	/** Object constructor */
-	LMSDevice(size_t tx_sps, size_t rx_sps, InterfaceType iface, size_t chans, double lo_offset,
-		  const std::vector<std::string>& tx_paths,
-		  const std::vector<std::string>& rx_paths);
-	~LMSDevice();
-
-	/** Instantiate the LMS */
-	int open(const std::string &args, int ref, bool swap_channels);
-
-	/** Start the LMS */
-	bool start();
-
-	/** Stop the LMS */
-	bool stop();
-
-	/** Set priority not supported */
-	void setPriority(float prio = 0.5) {
-	}
-
-	enum TxWindowType getWindowType() {
-		return TX_WINDOW_LMS1;
-	}
-
-	/**
-	Read samples from the LMS.
-	@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 RSSI The received signal strength of the read result
-	@return The number of samples actually read
-	*/
-	int readSamples(std::vector < short *>&buf, int len, bool * overrun,
-			TIMESTAMP timestamp = 0xffffffff, bool * underrun =
-			NULL, unsigned *RSSI = NULL);
-	/**
-	Write samples to the LMS.
-	@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 timestamp The timestamp of the first sample of the data buffer.
-	@param isControl Set if data is a control packet, e.g. a ping command
-	@return The number of samples actually written
-	*/
-	int writeSamples(std::vector < short *>&bufs, int len, bool * underrun,
-			 TIMESTAMP timestamp = 0xffffffff, bool isControl =
-			 false);
-
-	/** Update the alignment between the read and write timestamps */
-	bool updateAlignment(TIMESTAMP timestamp);
-
-	/** Set the transmitter frequency */
-	bool setTxFreq(double wFreq, size_t chan = 0);
-
-	/** Set the receiver frequency */
-	bool setRxFreq(double wFreq, size_t chan = 0);
-
-	/** Returns the starting write Timestamp*/
-	TIMESTAMP initialWriteTimestamp(void) {
-		return ts_initial;
-	}
-
-	/** Returns the starting read Timestamp*/
-	TIMESTAMP initialReadTimestamp(void) {
-		return ts_initial;
-	}
-
-	/** returns the full-scale transmit amplitude **/
-	double fullScaleInputValue() {
-		return(double) SHRT_MAX * LIMESDR_TX_AMPL;
-	}
-
-	/** returns the full-scale receive amplitude **/
-	double fullScaleOutputValue() {
-		return (double) SHRT_MAX;
-	}
-
-	/** sets the receive chan gain, returns the gain setting **/
-	double setRxGain(double dB, size_t chan = 0);
-
-	/** get the current receive gain */
-	double getRxGain(size_t chan = 0) {
-		return rxGain;
-	}
-
-	/** return maximum Rx Gain **/
-	double maxRxGain(void);
-
-	/** return minimum Rx Gain **/
-	double minRxGain(void);
-
-	/** sets the transmit chan gain, returns the gain setting **/
-	double setTxGain(double dB, size_t chan = 0);
-
-	/** return maximum Tx Gain **/
-	double maxTxGain(void);
-
-	/** return minimum Rx Gain **/
-	double minTxGain(void);
-
-	/** sets the RX path to use, returns true if successful and false otherwise */
-	bool setRxAntenna(const std::string & ant, size_t chan = 0);
-
-	/* return the used RX path */
-	std::string getRxAntenna(size_t chan = 0);
-
-	/** sets the RX path to use, returns true if successful and false otherwise */
-	bool setTxAntenna(const std::string & ant, size_t chan = 0);
-
-	/* return the used RX path */
-	std::string getTxAntenna(size_t chan = 0);
-
-	/** return whether user drives synchronization of Tx/Rx of USRP */
-        bool requiresRadioAlign();
-
-        /** return whether user drives synchronization of Tx/Rx of USRP */
-        virtual GSM::Time minLatency();
-
-	/** Return internal status values */
-	inline double getTxFreq(size_t chan = 0) {
-		return 0;
-	}
-	inline double getRxFreq(size_t chan = 0) {
-		return 0;
-	}
-	inline double getSampleRate() {
-		return actualSampleRate;
-	}
-};
-
-#endif // _LMS_DEVICE_H_

Transceiver52M/device/lms/Makefile.am

@@ -1,11 +0,0 @@
-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)
-
-noinst_HEADERS = LMSDevice.h
-
-noinst_LTLIBRARIES = libdevice.la
-
-libdevice_la_SOURCES = LMSDevice.cpp
-libdevice_la_LIBADD = $(top_builddir)/Transceiver52M/device/common/libdevice_common.la

Transceiver52M/device/uhd/Makefile.am

@@ -1,11 +0,0 @@
-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)
-
-noinst_HEADERS = UHDDevice.h
-
-noinst_LTLIBRARIES = libdevice.la
-
-libdevice_la_SOURCES = UHDDevice.cpp
-libdevice_la_LIBADD = $(top_builddir)/Transceiver52M/device/common/libdevice_common.la

Transceiver52M/device/uhd/UHDDevice.h

@@ -1,175 +0,0 @@
-/*
- * Device support for Ettus Research UHD driver
- *
- * Copyright 2010,2011 Free Software Foundation, Inc.
- * Copyright (C) 2015 Ettus Research LLC
- * Copyright 2019 sysmocom - s.f.m.c. GmbH <info@sysmocom.de>
- *
- * Author: Tom Tsou <tom.tsou@ettus.com>
- *
- * 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/>.
- * See the COPYING file in the main directory for details.
- */
-
-#pragma once
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "radioDevice.h"
-#include "smpl_buf.h"
-
-#include <uhd/version.hpp>
-#include <uhd/property_tree.hpp>
-#include <uhd/usrp/multi_usrp.hpp>
-
-
-enum uhd_dev_type {
-	USRP1,
-	USRP2,
-	B100,
-	B200,
-	B210,
-	B2XX_MCBTS,
-	E1XX,
-	E3XX,
-	X3XX,
-	UMTRX,
-	LIMESDR,
-};
-
-/*
-    uhd_device - UHD implementation of the Device interface. Timestamped samples
-                are sent to and received from the device. An intermediate buffer
-                on the receive side collects and aligns packets of samples.
-                Events and errors such as underruns are reported asynchronously
-                by the device and received in a separate thread.
-*/
-class uhd_device : public RadioDevice {
-public:
-	uhd_device(size_t tx_sps, size_t rx_sps, InterfaceType type,
-		   size_t chans, double offset,
-		   const std::vector<std::string>& tx_paths,
-		   const std::vector<std::string>& rx_paths);
-	~uhd_device();
-
-	int open(const std::string &args, int ref, bool swap_channels);
-	bool start();
-	bool stop();
-	bool restart();
-	void setPriority(float prio);
-	enum TxWindowType getWindowType() { return tx_window; }
-
-	int readSamples(std::vector<short *> &bufs, int len, bool *overrun,
-			TIMESTAMP timestamp, bool *underrun, unsigned *RSSI);
-
-	int writeSamples(std::vector<short *> &bufs, int len, bool *underrun,
-			 TIMESTAMP timestamp, bool isControl);
-
-	bool updateAlignment(TIMESTAMP timestamp);
-
-	bool setTxFreq(double wFreq, size_t chan);
-	bool setRxFreq(double wFreq, size_t chan);
-
-	TIMESTAMP initialWriteTimestamp();
-	TIMESTAMP initialReadTimestamp();
-
-	double fullScaleInputValue();
-	double fullScaleOutputValue();
-
-	double setRxGain(double db, size_t chan);
-	double getRxGain(size_t chan);
-	double maxRxGain(void) { return rx_gain_max; }
-	double minRxGain(void) { return rx_gain_min; }
-
-	double setTxGain(double db, size_t chan);
-	double maxTxGain(void) { return tx_gain_max; }
-	double minTxGain(void) { return tx_gain_min; }
-
-	double getTxFreq(size_t chan);
-	double getRxFreq(size_t chan);
-	double getRxFreq();
-
-	bool setRxAntenna(const std::string &ant, size_t chan);
-	std::string getRxAntenna(size_t chan);
-	bool setTxAntenna(const std::string &ant, size_t chan);
-	std::string getTxAntenna(size_t chan);
-
-	bool requiresRadioAlign();
-
-	GSM::Time minLatency();
-
-	inline double getSampleRate() { return tx_rate; }
-
-	/** Receive and process asynchronous message
-	    @return true if message received or false on timeout or error
-	*/
-	bool recv_async_msg();
-
-	enum err_code {
-		ERROR_TIMING = -1,
-		ERROR_TIMEOUT = -2,
-		ERROR_UNRECOVERABLE = -3,
-		ERROR_UNHANDLED = -4,
-	};
-
-private:
-	uhd::usrp::multi_usrp::sptr usrp_dev;
-	uhd::tx_streamer::sptr tx_stream;
-	uhd::rx_streamer::sptr rx_stream;
-	enum TxWindowType tx_window;
-	enum uhd_dev_type dev_type;
-
-	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;
-	size_t tx_spp, rx_spp;
-
-	bool started;
-	bool aligned;
-
-	size_t drop_cnt;
-	uhd::time_spec_t prev_ts;
-
-	TIMESTAMP ts_initial, ts_offset;
-	std::vector<smpl_buf *> rx_buffers;
-	/* Sample buffers used to receive samples from UHD: */
-	std::vector<std::vector<short> > pkt_bufs;
-	/* Used to call UHD API: Buffer pointer of each elem in pkt_ptrs will
-	   point to corresponding buffer of vector pkt_bufs. */
-	std::vector<short *> pkt_ptrs;
-
-	void init_gains();
-	void set_channels(bool swap);
-	void set_rates();
-	bool parse_dev_type();
-	bool flush_recv(size_t num_pkts);
-	int check_rx_md_err(uhd::rx_metadata_t &md, ssize_t num_smpls);
-
-	std::string str_code(uhd::rx_metadata_t metadata);
-	std::string str_code(uhd::async_metadata_t metadata);
-
-	uhd::tune_request_t select_freq(double wFreq, size_t chan, bool tx);
-	bool set_freq(double freq, size_t chan, bool tx);
-
-	Thread *async_event_thrd;
-	Mutex tune_lock;
-};

Transceiver52M/device/usrp1/Makefile.am

@@ -1,16 +0,0 @@
-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)
-
-rev2dir = $(datadir)/usrp/rev2
-rev4dir = $(datadir)/usrp/rev4
-
-dist_rev2_DATA = std_inband.rbf
-dist_rev4_DATA = std_inband.rbf
-
-noinst_HEADERS = USRPDevice.h
-
-noinst_LTLIBRARIES = libdevice.la
-
-libdevice_la_SOURCES = USRPDevice.cpp

Transceiver52M/inband-signaling-usb

@@ -0,0 +1,314 @@
+This file specifies the format of USB packets used for in-band data
+transmission and signaling on the USRP.  All packets are 512-byte long,
+and are transfered using USB "bulk" transfers.
+
+IN packets are sent towards the host.
+OUT packets are sent away from the host.
+
+The layout is 32-bits wide.  All data is transmitted in little-endian
+format across the USB.
+
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |O|U|D|S|E|   RSSI    |  Chan   | mbz |  Tag  |   Payload Len   |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                           Timestamp                           |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                                                               |
+   +                                                               +
+   |                            Payload                            |
+   .                                                               .
+   .                                                               .
+   .                                                               .
+   |                                                               |
+   +             +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |      ...    |                                                 .
+   +-+-+-+-+-+-+-+                                                 .
+   .                                                               .
+   .                            Padding                            .
+   .                                                               .
+   |                                                               |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   
+
+  mbz   Must be Zero: these bits must be zero in both IN and OUT packets.
+
+  O     Overrun Flag: set in an IN packet if an overrun condition was
+        detected.  Must be zero in OUT packets.  Overrun occurs when
+        the FPGA has data to transmit to the host and there is no
+        buffer space available.  This generally indicates a problem on
+        the host.  Either it is not keeping up, or it has configured
+        the FPGA to transmit data at a higher rate than the transport
+        (USB) can support.
+
+  U     Underrun Flag: set in an IN packet if an underrun condition
+        was detected.  Must be zero in OUT packets.  Underrun occurs
+        when the FPGA runs out of samples, and it's not between
+        bursts.  See the "End of Burst flag" below.
+
+  D     Dropped Packet Flag: Set in an IN packet if the FPGA
+	discarded an OUT packet because its timestamp had already
+	passed.
+
+  S     Start of Burst Flag:  Set in an OUT packet if the data is the
+        first segment of what is logically a continuous burst of data.
+        Must be zero in IN packets.
+
+  E     End of Burst Flag:  Set in an OUT packet if the data is the
+        last segment of what is logically a continuous burst of data.
+        Must be zero in IN packets.  Underruns are not reported
+        when the FPGA runs out of samples between bursts.
+
+
+  RSSI  6-bit Received Strength Signal Indicator:  Must be zero in OUT
+        packets.  In IN packets, indicates RSSI as reported by front end.
+	FIXME The format and interpretation are to be determined.
+
+  Chan  5-bit logical channel number.  Channel number 0x1f is reserved
+        for control information.  See "Control Channel" below.  Other
+        channels are "data channels."  Each data channel is logically
+        independent of the others.  A data channel payload field
+        contains a sequence of homogeneous samples.  The format of the
+        samples is determined by the configuration associated with the
+        given channel.  It is often the case that the payload field
+        contains 32-bit complex samples, each containing 16-bit real
+        and imaginary components.
+
+  Tag   4-bit tag for matching IN packets with OUT packets.
+        [FIXME, write more...]
+
+  Payload Len: 9-bit field that specifies the length of the payload
+        field in bytes.  Must be in the range 0 to 504 inclusive.
+
+  Timestamp: 32-bit timestamp.
+	On IN packets, the timestamp indicates the time at which the
+	first sample of the packet was produced by the A/D converter(s)
+        for that channel.  On OUT packets, the timestamp specifies the
+        time at which the first sample in the packet should go out the
+        D/A converter(s) for that channel.  If a packet reaches the
+	head of the transmit queue, and the current time is later than
+	the timestamp, an error is assumed to have occurred and the
+	packet is discarded.  As a special case, the timestamp
+	0xffffffff is interpreted as "Now".
+
+	The time base is a free running 32-bit counter that is
+	incremented by the A/D sample-clock.
+
+  Payload: Variable length field.  Length is specified by the
+        Payload Len field.
+
+  Padding: This field is 504 - Payload Len bytes long, and its content
+        is unspecified.  This field pads the packet out to a constant
+        512 bytes.
+
+
+
+"Data Channel" payload format:
+-------------------------------
+
+If Chan != 0x1f, the packet is a "data packet" and the payload is a
+sequence of homogeneous samples.  The format of the samples is
+determined by the configuration associated with the given channel.  
+It is often the case that the payload field contains 32-bit complex
+samples, each containing 16-bit real and imaginary components.
+
+
+"Control Channel" payload format:
+---------------------------------
+
+If Chan == 0x1f, the packet is a "control packet".  The control channel
+payload consists of a sequence of 0 or more sub-packets.
+
+Each sub-packet starts on a 32-bit boundary, and consists of an 8-bit
+Opcode field, an 8-bit Length field, Length bytes of arguments, and 0,
+1, 2 or 3 bytes of padding to align the tail of the sub-packet to
+a 32-bit boundary.
+
+Control channel packets shall be processed at the head of the queue,
+and shall observe the timestamp semantics described above.
+
+
+General sub-packet format:
+--------------------------
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-//-+-+-+-+-+-+-+-+
+   |     Opcode    |    Length     |        <length bytes> ...    |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-//-+-+-+-+-+-+-+-+
+
+
+Specific sub-packet formats:
+----------------------------
+
+  RID: 6-bit Request-ID. Copied from request sub-packet into corresponding
+       reply sub-packet.  RID allows the host to match requests and replies.
+
+  Reg Number: 10-bit Register Number.
+
+
+
+Ping Fixed Length:
+
+    Opcode:	OP_PING_FIXED
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |       2       |    RID    |     Ping Value    |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+Ping Fixed Length Reply:
+
+    Opcode:	OP_PING_FIXED_REPLY
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |       2       |    RID    |     Ping Value    |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+Write Register:
+
+    Opcode:	OP_WRITE_REG
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |       6       |    mbz    |     Reg Number    |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                        Register Value                         |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+Write Register Masked:
+
+    Opcode:	OP_WRITE_REG_MASKED
+
+    REG[Num] = (REG[Num] & ~Mask) | (Value & Mask)
+
+    That is, only the register bits that correspond to 1's in the
+    mask are written with the new value.
+
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |      10       |    mbz    |     Reg Number    |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                         Register Value                        |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                           Mask Value                          |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+Read Register:
+
+    Opcode:	OP_READ_REG
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |       2       |    RID    |     Reg Number    |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+Read Register Reply:
+
+    Opcode:	OP_READ_REG_REPLY
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |       6       |    RID    |     Reg Number    |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |                        Register Value                         |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+I2C Write:
+
+    Opcode:	OP_I2C_WRITE
+    I2C Addr:   7-bit I2C address
+    Data:	The bytes to write to the I2C bus
+    Length:     Length of Data + 2
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |    Length     |       mbz       |   I2C Addr  |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |    Data ...			                           .
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+I2C Read:
+
+    Opcode:	OP_I2C_READ
+    I2C Addr:	7-bit I2C address
+    Nbytes:	Number of bytes to read from I2C bus
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |       3       |    RID    | mbz |   I2C Addr  |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Nbytes    |              unspecified padding              |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+I2C Read Reply:
+
+    Opcode:	OP_I2C_READ_REPLY
+    I2C Addr:	7-bit I2C address
+    Data:	Length - 2 bytes of data read from I2C bus.
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |     Length    |    RID    | mbz |   I2C Addr  |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |    Data ...			                           .
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+SPI Write:
+
+    Opcode:	      OP_SPI_WRITE
+    Enables:	      Which SPI enables to assert (mask)
+    Format:	      Specifies format of SPI data and Opt Header Bytes
+    Opt Header Bytes: 2-byte field containing optional Tx bytes; see Format
+    Data:	      The bytes to write to the SPI bus
+    Length:	      Length of Data + 6
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |    Length     |              mbz              |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |    Enables    |    Format     |        Opt Header Bytes       |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |    Data ...			                           .
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+SPI Read:
+
+    Opcode:	      OP_SPI_READ
+    Enables:	      Which SPI enables to assert (mask)
+    Format:	      Specifies format of SPI data and Opt Header Bytes
+    Opt Header Bytes: 2-byte field containing optional Tx bytes; see Format
+    Nbytes:	      Number of bytes to read from SPI bus.
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |       7       |    RID    |        mbz        |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |    Enables    |    Format     |        Opt Header Bytes       |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Nbytes    |              unspecified padding              |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+SPI Read Reply:
+
+    Opcode:   OP_SPI_READ_REPLY
+    Data:     Length - 2 bytes of data read from SPI bus.
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |     Length    |    RID    |        mbz        |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |    Data ...			                           .
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+
+
+Delay:
+
+    Opcode:	OP_DELAY
+    Ticks:	16-bit unsigned delay count
+
+    Delay Ticks clock ticks before executing next operation.
+
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+   |     Opcode    |       2       |            Ticks              |
+   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
+

Transceiver52M/osmo-trx.cpp

@@ -1,8 +1,6 @@
 /*
  * Copyright (C) 2013 Thomas Tsou <tom@tsou.cc>
  *
- * SPDX-License-Identifier: LGPL-2.1+
- *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
@@ -24,62 +22,147 @@
 
 #include "Transceiver.h"
 #include "radioDevice.h"
-#include "Utils.h"
 
 #include <time.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <getopt.h>
 #include <sched.h>
 #include <vector>
 #include <string>
 #include <sstream>
 #include <iostream>
-#include <sys/signalfd.h>
 
 #include <GSMCommon.h>
 #include <Logger.h>
 
 extern "C" {
-#include <osmocom/core/talloc.h>
-#include <osmocom/core/application.h>
-#include <osmocom/core/msgb.h>
-#include <osmocom/core/stats.h>
-#include <osmocom/vty/logging.h>
-#include <osmocom/vty/ports.h>
-#include <osmocom/vty/misc.h>
-#include <osmocom/vty/telnet_interface.h>
-#include <osmocom/ctrl/control_vty.h>
-#include <osmocom/ctrl/ports.h>
-#include <osmocom/ctrl/control_if.h>
-#include <osmocom/vty/stats.h>
-#include <osmocom/vty/command.h>
-
 #include "convolve.h"
 #include "convert.h"
-#include "trx_vty.h"
-#include "debug.h"
-#include "osmo_signal.h"
-#include "trx_rate_ctr.h"
 }
 
-#define DEFAULT_CONFIG_FILE	"osmo-trx.cfg"
+/* Samples-per-symbol for downlink path
+ *     4 - Uses precision modulator (more computation, less distortion)
+ *     1 - Uses minimized modulator (less computation, more distortion)
+ *
+ *     Other values are invalid. Receive path (uplink) is always
+ *     downsampled to 1 sps. Default to 4 sps for all cases.
+ */
+#define DEFAULT_TX_SPS		4
 
-#define charp2str(a) ((a) ? std::string(a) : std::string(""))
+/*
+ * Samples-per-symbol for uplink (receiver) path
+ *     Do not modify this value. EDGE configures 4 sps automatically on
+ *     B200/B210 devices only. Use of 4 sps on the receive path for other
+ *     configurations is not supported.
+ */
+#define DEFAULT_RX_SPS		1
 
-static char* config_file = (char*)DEFAULT_CONFIG_FILE;
+/* Default configuration parameters */
+#define DEFAULT_TRX_PORT	5700
+#define DEFAULT_TRX_IP		"127.0.0.1"
+#define DEFAULT_CHANS		1
+
+struct trx_config {
+	std::string log_level;
+	std::string local_addr;
+	std::string remote_addr;
+	std::string dev_args;
+	unsigned port;
+	unsigned tx_sps;
+	unsigned rx_sps;
+	unsigned chans;
+	unsigned rtsc;
+	unsigned rach_delay;
+	bool extref;
+	bool gpsref;
+	Transceiver::FillerType filler;
+	bool mcbts;
+	double offset;
+	double rssi_offset;
+	bool swap_channels;
+	bool edge;
+	int sched_rr;
+	std::vector<std::string> rx_paths;
+	std::vector<std::string> tx_paths;
+};
 
-struct osmo_fd signal_ofd;
 volatile bool gshutdown = false;
 
-static void *tall_trx_ctx;
-static struct trx_ctx *g_trx_ctx;
-static struct ctrl_handle *g_ctrlh;
+/* Setup configuration values
+ *     Don't query the existence of the Log.Level because it's a
+ *     mandatory value. That is, if it doesn't exist, the configuration
+ *     table will crash or will have already crashed. Everything else we
+ *     can survive without and use default values if the database entries
+ *     are empty.
+ */
+bool trx_setup_config(struct trx_config *config)
+{
+	std::string refstr, fillstr, divstr, mcstr, edgestr;
+	std::vector<std::string>::const_iterator si;
 
-static RadioDevice *usrp;
-static RadioInterface *radio;
-static Transceiver *transceiver;
+	if (config->mcbts && config->chans > 5) {
+		std::cout << "Unsupported number of channels" << std::endl;
+		return false;
+	}
+
+	edgestr = config->edge ? "Enabled" : "Disabled";
+	mcstr = config->mcbts ? "Enabled" : "Disabled";
+
+	if (config->extref)
+		refstr = "External";
+	else if (config->gpsref)
+		refstr = "GPS";
+	else
+		refstr = "Internal";
+
+	switch (config->filler) {
+	case Transceiver::FILLER_DUMMY:
+		fillstr = "Dummy bursts";
+		break;
+	case Transceiver::FILLER_ZERO:
+		fillstr = "Disabled";
+		break;
+	case Transceiver::FILLER_NORM_RAND:
+		fillstr = "Normal busrts with random payload";
+		break;
+	case Transceiver::FILLER_EDGE_RAND:
+		fillstr = "EDGE busrts with random payload";
+		break;
+	case Transceiver::FILLER_ACCESS_RAND:
+		fillstr = "Access busrts with random payload";
+		break;
+	}
+
+	std::ostringstream ost("");
+	ost << "Config Settings" << std::endl;
+	ost << "   Log Level............... " << config->log_level << std::endl;
+	ost << "   Device args............. " << config->dev_args << std::endl;
+	ost << "   TRX Base Port........... " << config->port << std::endl;
+	ost << "   TRX Address............. " << config->local_addr << std::endl;
+	ost << "   GSM Core Address........." << config->remote_addr << std::endl;
+	ost << "   Channels................ " << config->chans << std::endl;
+	ost << "   Tx Samples-per-Symbol... " << config->tx_sps << std::endl;
+	ost << "   Rx Samples-per-Symbol... " << config->rx_sps << std::endl;
+	ost << "   EDGE support............ " << edgestr << std::endl;
+	ost << "   Reference............... " << refstr << std::endl;
+	ost << "   C0 Filler Table......... " << fillstr << std::endl;
+	ost << "   Multi-Carrier........... " << mcstr << std::endl;
+	ost << "   Tuning offset........... " << config->offset << std::endl;
+	ost << "   RSSI to dBm offset...... " << config->rssi_offset << std::endl;
+	ost << "   Swap channels........... " << config->swap_channels << std::endl;
+	ost << "   Tx Antennas.............";
+		for (si = config->tx_paths.begin(); si != config->tx_paths.end(); ++si)
+			ost << " '" << ((*si != "") ? *si : "<default>") <<  "'";
+		ost << std::endl;
+	ost << "   Rx Antennas.............";
+		for (si = config->rx_paths.begin(); si != config->rx_paths.end(); ++si)
+			ost << " '" << ((*si != "") ? *si : "<default>") <<  "'";
+		ost << std::endl;
+
+	std::cout << ost << std::endl;
+	return true;
+}
 
 /* Create radio interface
  *     The interface consists of sample rate changes, frequency shifts,
@@ -88,24 +171,24 @@ static Transceiver *transceiver;
  *     The radio interface connects the main transceiver with the device
  *     object, which may be operating some other rate.
  */
-RadioInterface *makeRadioInterface(struct trx_ctx *trx,
+RadioInterface *makeRadioInterface(struct trx_config *config,
                                    RadioDevice *usrp, int type)
 {
 	RadioInterface *radio = NULL;
 
 	switch (type) {
 	case RadioDevice::NORMAL:
-		radio = new RadioInterface(usrp, trx->cfg.tx_sps,
-					   trx->cfg.rx_sps, trx->cfg.num_chans);
+		radio = new RadioInterface(usrp, config->tx_sps,
+					   config->rx_sps, config->chans);
 		break;
 	case RadioDevice::RESAMP_64M:
 	case RadioDevice::RESAMP_100M:
-		radio = new RadioInterfaceResamp(usrp, trx->cfg.tx_sps,
-						 trx->cfg.rx_sps);
+		radio = new RadioInterfaceResamp(usrp, config->tx_sps,
+						 config->rx_sps);
 		break;
 	case RadioDevice::MULTI_ARFCN:
-		radio = new RadioInterfaceMulti(usrp, trx->cfg.tx_sps,
-						trx->cfg.rx_sps, trx->cfg.num_chans);
+		radio = new RadioInterfaceMulti(usrp, config->tx_sps,
+						config->rx_sps, config->chans);
 		break;
 	default:
 		LOG(ALERT) << "Unsupported radio interface configuration";
@@ -120,287 +203,248 @@ RadioInterface *makeRadioInterface(struct trx_ctx *trx,
 	return radio;
 }
 
-/* Callback function to be called every time we receive a signal from TRANSC */
-static int transc_sig_cb(unsigned int subsys, unsigned int signal,
-		     void *handler_data, void *signal_data)
-{
-	switch (signal) {
-	case S_MAIN_STOP_REQUIRED:
-		gshutdown = true;
-                break;
-	default:
-                break;
-	}
-	return 0;
-}
-
 /* Create transceiver core
  *     The multi-threaded modem core operates at multiples of the GSM rate of
  *     270.8333 ksps and consists of GSM specific modulation, demodulation,
  *     and decoding schemes. Also included are the socket interfaces for
  *     connecting to the upper layer stack.
  */
-int makeTransceiver(struct trx_ctx *trx, RadioInterface *radio)
+Transceiver *makeTransceiver(struct trx_config *config, RadioInterface *radio)
 {
+	Transceiver *trx;
 	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)) {
+	trx = new Transceiver(config->port, config->local_addr.c_str(),
+			      config->remote_addr.c_str(), config->tx_sps,
+			      config->rx_sps, config->chans, GSM::Time(3,0),
+			      radio, config->rssi_offset);
+	if (!trx->init(config->filler, config->rtsc,
+		       config->rach_delay, config->edge)) {
 		LOG(ALERT) << "Failed to initialize transceiver";
-		return -1;
+		delete trx;
+		return NULL;
 	}
 
-	for (size_t i = 0; i < trx->cfg.num_chans; i++) {
+	for (size_t i = 0; i < config->chans; i++) {
 		fifo = radio->receiveFIFO(i);
-		if (fifo && transceiver->receiveFIFO(fifo, i))
+		if (fifo && trx->receiveFIFO(fifo, i))
 			continue;
 
 		LOG(ALERT) << "Could not attach FIFO to channel " << i;
-		return -1;
+		delete trx;
+		return NULL;
 	}
-	return 0;
+
+	return trx;
 }
 
 static void sig_handler(int signo)
 {
-
-	if (gshutdown)
-		/* We are in the middle of shutdown process, avoid any kind of extra
-		   action like printing */
-		return;
-
-	fprintf(stdout, "signal %d received\n", signo);
-	switch (signo) {
-	case SIGINT:
-	case SIGTERM:
-		fprintf(stdout, "shutting down\n");
+	fprintf(stdout, "Received shutdown signal");
 	gshutdown = true;
-		break;
-	case SIGABRT:
-	case SIGUSR1:
-		talloc_report(tall_trx_ctx, stderr);
-		talloc_report_full(tall_trx_ctx, stderr);
-		break;
-	case SIGUSR2:
-		talloc_report_full(tall_trx_ctx, stderr);
-		break;
-	case SIGHUP:
-		log_targets_reopen();
-	default:
-		break;
-	}
-
-}
-
-static int signalfd_callback(struct osmo_fd *ofd, unsigned int what)
-{
-	struct signalfd_siginfo fdsi;
-	ssize_t s;
-
-	s = read(ofd->fd, &fdsi, sizeof(struct signalfd_siginfo));
-	if (s < 0) {
-		LOG(FATAL) << "Failed to read from signalfd ("<< ofd->fd << "): " << errno;
-		gshutdown = true;
-		return 0;
-	}
-	sig_handler(fdsi.ssi_signo);
-	return 0;
 }
 
 static void setup_signal_handlers()
 {
-	sigset_t set;
-	int sfd;
-
-	signal(SIGABRT, &sig_handler);
-	osmo_init_ignore_signals();
-
-	/* Other threads created by this thread (main) will inherit a copy of the
-	signal mask. */
-	sigemptyset(&set);
-	sigaddset(&set, SIGINT);
-	sigaddset(&set, SIGTERM);
-	sigaddset(&set, SIGUSR1);
-	sigaddset(&set, SIGUSR2);
-	sigaddset(&set, SIGHUP);
-	if (pthread_sigmask(SIG_BLOCK, &set, NULL)) {
-		fprintf(stderr, "pthread_sigmask() failed.\n");
+	if (signal(SIGINT, sig_handler) == SIG_ERR) {
+		fprintf(stderr, "Failed to install SIGINT signal handler\n");
 		exit(EXIT_FAILURE);
 	}
-
-	if ((sfd = signalfd(-1, &set, 0)) == -1) {
-		fprintf(stderr, "signalfd() failed (%d).\n", errno);
-		exit(EXIT_FAILURE);
+	if (signal(SIGTERM, sig_handler) == SIG_ERR) {
+		fprintf(stderr, "Couldn't install SIGTERM signal handler\n");
+		exit( EXIT_FAILURE);
 	}
+}
 
-	osmo_fd_setup(&signal_ofd, sfd, BSC_FD_READ, signalfd_callback, NULL, 0);
-	if (osmo_fd_register(&signal_ofd) < 0) {
-		fprintf(stderr, "osmo_fd_register() failed.\n");
-		exit(EXIT_FAILURE);
+
+static std::vector<std::string> comma_delimited_to_vector(char* opt) {
+	std::string str = std::string(opt);
+	std::vector<std::string> result;
+	std::stringstream ss(str);
+
+	while( ss.good() )
+	{
+	    std::string substr;
+	    getline(ss, substr, ',');
+	    result.push_back(substr);
 	}
+	return result;
 }
 
 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"
-		);
+		"  -h    This text\n"
+		"  -a    UHD device args\n"
+		"  -l    Logging level (%s)\n"
+		"  -i    IP address of GSM core\n"
+		"  -j    IP address of osmo-trx\n"
+		"  -p    Base port number\n"
+		"  -e    Enable EDGE receiver\n"
+		"  -m    Enable multi-ARFCN transceiver (default=disabled)\n"
+		"  -x    Enable external 10 MHz reference\n"
+		"  -g    Enable GPSDO reference\n"
+		"  -s    Tx samples-per-symbol (1 or 4)\n"
+		"  -b    Rx samples-per-symbol (1 or 4)\n"
+		"  -c    Number of ARFCN channels (default=1)\n"
+		"  -f    Enable C0 filler table\n"
+		"  -o    Set baseband frequency offset (default=auto)\n"
+		"  -r    Random Normal Burst test mode with TSC\n"
+		"  -A    Random Access Burst test mode with delay\n"
+		"  -R    RSSI to dBm offset in dB (default=0)\n"
+		"  -S    Swap channels (UmTRX only)\n"
+		"  -t    SCHED_RR real-time priority (1..32)\n"
+		"  -y    comma-delimited list of Tx paths (num elements matches -c)\n"
+		"  -z    comma-delimited list of Rx paths (num elements matches -c)\n",
+		"EMERG, ALERT, CRT, ERR, WARNING, NOTICE, INFO, DEBUG");
 }
 
-static void print_deprecated(char opt)
-{
-	LOG(WARNING) << "Cmd line option '" << opt << "' is deprecated and will be soon removed."
-		<< " Please use VTY cfg option instead."
-		<< " All cmd line options are already being overridden by VTY options if set.";
-}
-
-static void handle_options(int argc, char **argv, struct trx_ctx* trx)
+static void handle_options(int argc, char **argv, struct trx_config *config)
 {
 	int option;
-	unsigned int i;
-	std::vector<std::string> rx_paths, tx_paths;
-	bool rx_paths_set = false, tx_paths_set = false;
-	static struct option long_options[] = {
-		{"help", 0, 0, 'h'},
-		{"config", 1, 0, 'C'},
-		{"version", 0, 0, 'V'},
-		{NULL, 0, 0, 0}
-	};
+	bool tx_path_set = false, rx_path_set = false;
 
-	while ((option = getopt_long(argc, argv, "ha:l:i:j:p:c:dmxgfo:s:b:r:A:R:Set:y:z:C:V", long_options,
-		NULL)) != -1) {
+	config->log_level = "NOTICE";
+	config->local_addr = DEFAULT_TRX_IP;
+	config->remote_addr = DEFAULT_TRX_IP;
+	config->port = DEFAULT_TRX_PORT;
+	config->tx_sps = DEFAULT_TX_SPS;
+	config->rx_sps = DEFAULT_RX_SPS;
+	config->chans = DEFAULT_CHANS;
+	config->rtsc = 0;
+	config->rach_delay = 0;
+	config->extref = false;
+	config->gpsref = false;
+	config->filler = Transceiver::FILLER_ZERO;
+	config->mcbts = false;
+	config->offset = 0.0;
+	config->rssi_offset = 0.0;
+	config->swap_channels = false;
+	config->edge = false;
+	config->sched_rr = -1;
+	config->tx_paths = std::vector<std::string>(DEFAULT_CHANS, "");
+	config->rx_paths = std::vector<std::string>(DEFAULT_CHANS, "");
+
+	while ((option = getopt(argc, argv, "ha:l:i:j:p:c:dmxgfo:s:b:r:A:R:Set:y:z:")) != -1) {
 		switch (option) {
 		case 'h':
 			print_help();
 			exit(0);
 			break;
 		case 'a':
-			print_deprecated(option);
-			osmo_talloc_replace_string(trx, &trx->cfg.dev_args, optarg);
+			config->dev_args = optarg;
 			break;
 		case 'l':
-			print_deprecated(option);
-			log_set_log_level(osmo_stderr_target, atoi(optarg));
+			config->log_level = optarg;
 			break;
 		case 'i':
-			print_deprecated(option);
-			osmo_talloc_replace_string(trx, &trx->cfg.remote_addr, optarg);
+			config->remote_addr = optarg;
 			break;
 		case 'j':
-			print_deprecated(option);
-			osmo_talloc_replace_string(trx, &trx->cfg.bind_addr, optarg);
+			config->local_addr = optarg;
 			break;
 		case 'p':
-			print_deprecated(option);
-			trx->cfg.base_port = atoi(optarg);
+			config->port = atoi(optarg);
 			break;
 		case 'c':
-			print_deprecated(option);
-			trx->cfg.num_chans = atoi(optarg);
+			config->chans = atoi(optarg);
 			break;
 		case 'm':
-			print_deprecated(option);
-			trx->cfg.multi_arfcn = true;
+			config->mcbts = true;
 			break;
 		case 'x':
-			print_deprecated(option);
-			trx->cfg.clock_ref = REF_EXTERNAL;
+			config->extref = true;
 			break;
 		case 'g':
-			print_deprecated(option);
-			trx->cfg.clock_ref = REF_GPS;
+			config->gpsref = true;
 			break;
 		case 'f':
-			print_deprecated(option);
-			trx->cfg.filler = FILLER_DUMMY;
+			config->filler = Transceiver::FILLER_DUMMY;
 			break;
 		case 'o':
-			print_deprecated(option);
-			trx->cfg.offset = atof(optarg);
+			config->offset = atof(optarg);
 			break;
 		case 's':
-			print_deprecated(option);
-			trx->cfg.tx_sps = atoi(optarg);
+			config->tx_sps = atoi(optarg);
 			break;
 		case 'b':
-			print_deprecated(option);
-			trx->cfg.rx_sps = atoi(optarg);
+			config->rx_sps = atoi(optarg);
 			break;
 		case 'r':
-			print_deprecated(option);
-			trx->cfg.rtsc_set = true;
-			trx->cfg.rtsc = atoi(optarg);
-			if (!trx->cfg.egprs) /* Don't override egprs which sets different filler */
-				trx->cfg.filler = FILLER_NORM_RAND;
+			config->rtsc = atoi(optarg);
+			config->filler = Transceiver::FILLER_NORM_RAND;
 			break;
 		case 'A':
-			print_deprecated(option);
-			trx->cfg.rach_delay_set = true;
-			trx->cfg.rach_delay = atoi(optarg);
-			trx->cfg.filler = FILLER_ACCESS_RAND;
+			config->rach_delay = atoi(optarg);
+			config->filler = Transceiver::FILLER_ACCESS_RAND;
 			break;
 		case 'R':
-			print_deprecated(option);
-			trx->cfg.rssi_offset = atof(optarg);
+			config->rssi_offset = atof(optarg);
 			break;
 		case 'S':
-			print_deprecated(option);
-			trx->cfg.swap_channels = true;
+			config->swap_channels = true;
 			break;
 		case 'e':
-			print_deprecated(option);
-			trx->cfg.egprs = true;
+			config->edge = true;
 			break;
 		case 't':
-			print_deprecated(option);
-			trx->cfg.sched_rr = atoi(optarg);
+			config->sched_rr = atoi(optarg);
 			break;
 		case 'y':
-			print_deprecated(option);
-			tx_paths = comma_delimited_to_vector(optarg);
-			tx_paths_set = true;
+			config->tx_paths = comma_delimited_to_vector(optarg);
+			tx_path_set = true;
 			break;
 		case 'z':
-			print_deprecated(option);
-			rx_paths = comma_delimited_to_vector(optarg);
-			rx_paths_set = true;
-			break;
-		case 'C':
-			config_file = optarg;
-			break;
-		case 'V':
-			print_version(1);
-			exit(0);
+			config->rx_paths = comma_delimited_to_vector(optarg);
+			rx_path_set = true;
 			break;
 		default:
-			goto bad_config;
+			print_help();
+			exit(0);
 		}
 	}
 
-	/* Cmd line option specific validation & setup */
+	/* Force 4 SPS for EDGE or multi-ARFCN configurations */
+	if ((config->edge) || (config->mcbts)) {
+		config->tx_sps = 4;
+		config->rx_sps = 4;
+	}
 
-	if (trx->cfg.num_chans > TRX_CHAN_MAX) {
-		LOG(ERROR) << "Too many channels requested, maximum is " <<  TRX_CHAN_MAX;
+	if (config->gpsref && config->extref) {
+		printf("External and GPSDO references unavailable at the same time\n\n");
 		goto bad_config;
 	}
-	if ((tx_paths_set && tx_paths.size() != trx->cfg.num_chans) ||
-	    (rx_paths_set && rx_paths.size() != trx->cfg.num_chans)) {
-		LOG(ERROR) << "Num of channels and num of Rx/Tx Antennas doesn't match";
+
+	if (config->edge && (config->filler == Transceiver::FILLER_NORM_RAND))
+		config->filler = Transceiver::FILLER_EDGE_RAND;
+
+	if ((config->tx_sps != 1) && (config->tx_sps != 4) &&
+	    (config->rx_sps != 1) && (config->rx_sps != 4)) {
+		printf("Unsupported samples-per-symbol %i\n\n", config->tx_sps);
 		goto bad_config;
 	}
-	for (i = 0; i < trx->cfg.num_chans; i++) {
-		trx->cfg.chans[i].trx = trx;
-		trx->cfg.chans[i].idx = i;
-		if (tx_paths_set)
-			osmo_talloc_replace_string(trx, &trx->cfg.chans[i].tx_path, tx_paths[i].c_str());
-		if (rx_paths_set)
-			osmo_talloc_replace_string(trx, &trx->cfg.chans[i].rx_path, rx_paths[i].c_str());
+
+	if (config->rtsc > 7) {
+		printf("Invalid training sequence %i\n\n", config->rtsc);
+		goto bad_config;
+	}
+
+	if (config->rach_delay > 68) {
+		printf("RACH delay is too big %i\n\n", config->rach_delay);
+		goto bad_config;
+	}
+
+	if (!tx_path_set) {
+		config->tx_paths = std::vector<std::string>(config->chans, "");
+	} else if (config->tx_paths.size() != config->chans) {
+		printf("Num of channels and num of Tx Antennas doesn't match\n\n");
+		goto bad_config;
+	}
+	if (!rx_path_set) {
+		config->rx_paths = std::vector<std::string>(config->chans, "");
+	} else if (config->rx_paths.size() != config->chans) {
+		printf("Num of channels and num of Rx Antennas doesn't match\n\n");
+		goto bad_config;
 	}
 
 	return;
@@ -410,142 +454,29 @@ bad_config:
 	exit(0);
 }
 
-int trx_validate_config(struct trx_ctx *trx)
-{
-	if (trx->cfg.multi_arfcn && trx->cfg.num_chans > TRX_MCHAN_MAX) {
-		LOG(ERROR) << "Unsupported number of channels";
-		return -1;
-	}
-
-	/* Force 4 SPS for EDGE or multi-ARFCN configurations */
-	if ((trx->cfg.egprs || trx->cfg.multi_arfcn) &&
-	    (trx->cfg.tx_sps!=4 || trx->cfg.rx_sps!=4)) {
-		LOG(ERROR) << "EDGE and Multi-Carrier options require 4 tx and rx sps. Check you config.";
-		return -1;
-	}
-
-	return 0;
-}
-
-static int set_sched_rr(unsigned int prio)
+static int set_sched_rr(int prio)
 {
 	struct sched_param param;
 	int rc;
 	memset(&param, 0, sizeof(param));
 	param.sched_priority = prio;
-	LOG(INFO) << "Setting SCHED_RR priority " << param.sched_priority;
+	printf("Setting SCHED_RR priority(%d)\n", param.sched_priority);
 	rc = sched_setscheduler(getpid(), SCHED_RR, &param);
 	if (rc != 0) {
-		LOG(ERROR) << "Config: Setting SCHED_RR failed";
+		std::cerr << "Config: Setting SCHED_RR failed" << std::endl;
 		return -1;
 	}
 	return 0;
 }
 
-static void print_config(struct trx_ctx *trx)
-{
-	unsigned int i;
-	std::ostringstream ost("");
-
-	ost << "Config Settings" << std::endl;
-	ost << "   Log Level............... " << (unsigned int) osmo_stderr_target->loglevel << std::endl;
-	ost << "   Device args............. " << charp2str(trx->cfg.dev_args) << std::endl;
-	ost << "   TRX Base Port........... " << trx->cfg.base_port << std::endl;
-	ost << "   TRX Address............. " << charp2str(trx->cfg.bind_addr) << std::endl;
-	ost << "   GSM BTS Address......... " << charp2str(trx->cfg.remote_addr) << std::endl;
-	ost << "   Channels................ " << trx->cfg.num_chans << std::endl;
-	ost << "   Tx Samples-per-Symbol... " << trx->cfg.tx_sps << std::endl;
-	ost << "   Rx Samples-per-Symbol... " << trx->cfg.rx_sps << std::endl;
-	ost << "   EDGE support............ " << trx->cfg.egprs << std::endl;
-	ost << "   Extended RACH support... " << trx->cfg.ext_rach << std::endl;
-	ost << "   Reference............... " << trx->cfg.clock_ref << std::endl;
-	ost << "   C0 Filler Table......... " << trx->cfg.filler << 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 << "   Swap channels........... " << trx->cfg.swap_channels << std::endl;
-	ost << "   Tx Antennas.............";
-	for (i = 0; i < trx->cfg.num_chans; i++) {
-		std::string p = charp2str(trx->cfg.chans[i].tx_path);
-		ost << " '" << ((p != "") ? p : "<default>") <<  "'";
-	}
-	ost << std::endl;
-	ost << "   Rx Antennas.............";
-	for (i = 0; i < trx->cfg.num_chans; i++) {
-		std::string p = charp2str(trx->cfg.chans[i].rx_path);
-		ost << " '" << ((p != "") ? p : "<default>") <<  "'";
-	}
-	ost << std::endl;
-
-	LOG(INFO) << ost << std::endl;
-}
-
-static void trx_stop()
-{
-	LOG(NOTICE) << "Shutting down transceiver..." << std::endl;
-
-	delete transceiver;
-	delete radio;
-	delete usrp;
-}
-
-static int trx_start(struct trx_ctx *trx)
-{
-	int type, chans;
-	unsigned int i;
-	std::vector<std::string> rx_paths, tx_paths;
-	RadioDevice::InterfaceType iface = RadioDevice::NORMAL;
-
-	/* Create the low level device object */
-	if (trx->cfg.multi_arfcn)
-		iface = RadioDevice::MULTI_ARFCN;
-
-	/* Generate vector of rx/tx_path: */
-	for (i = 0; i < trx->cfg.num_chans; i++) {
-		rx_paths.push_back(charp2str(trx->cfg.chans[i].rx_path));
-		tx_paths.push_back(charp2str(trx->cfg.chans[i].tx_path));
-	}
-
-	usrp = RadioDevice::make(trx->cfg.tx_sps, trx->cfg.rx_sps, iface,
-				 trx->cfg.num_chans, trx->cfg.offset,
-				 tx_paths, rx_paths);
-	type = usrp->open(charp2str(trx->cfg.dev_args), trx->cfg.clock_ref, trx->cfg.swap_channels);
-	if (type < 0) {
-		LOG(ALERT) << "Failed to create radio device" << std::endl;
-		goto shutdown;
-	}
-
-	/* Setup the appropriate device interface */
-	radio = makeRadioInterface(trx, usrp, type);
-	if (!radio)
-		goto shutdown;
-
-	/* Create the transceiver core */
-	if (makeTransceiver(trx, radio) < 0)
-		goto shutdown;
-
-	chans = transceiver->numChans();
-	LOG(NOTICE) << "-- Transceiver active with "
-		  << chans << " channel(s)" << std::endl;
-
-	return 0;
-
-shutdown:
-	trx_stop();
-	return -1;
-}
-
 int main(int argc, char *argv[])
 {
-	int rc;
-
-	tall_trx_ctx = talloc_named_const(NULL, 0, "OsmoTRX");
-	msgb_talloc_ctx_init(tall_trx_ctx, 0);
-	g_vty_info.tall_ctx = tall_trx_ctx;
-
-	setup_signal_handlers();
-
-	g_trx_ctx = vty_trx_ctx_alloc(tall_trx_ctx);
+	int type, chans, ref;
+	RadioDevice *usrp;
+	RadioInterface *radio = NULL;
+	Transceiver *trx = NULL;
+	RadioDevice::InterfaceType iface = RadioDevice::NORMAL;
+	struct trx_config config;
 
 #ifdef HAVE_SSE3
 	printf("Info: SSE3 support compiled in");
@@ -571,81 +502,70 @@ int main(int argc, char *argv[])
 #endif
 #endif
 
-	if (!log_mutex_init()) {
-		fprintf(stderr, "Failed to initialize log mutex!\n");
-		exit(2);
-	}
 	convolve_init();
 	convert_init();
 
-	osmo_init_logging2(tall_trx_ctx, &log_info);
-	osmo_stats_init(tall_trx_ctx);
-	vty_init(&g_vty_info);
-	ctrl_vty_init(tall_trx_ctx);
-	trx_vty_init(g_trx_ctx);
+	handle_options(argc, argv, &config);
 
-	logging_vty_add_cmds();
-	osmo_talloc_vty_add_cmds();
-	osmo_stats_vty_add_cmds();
-
-	handle_options(argc, argv, g_trx_ctx);
-
-	rate_ctr_init(tall_trx_ctx);
-
-	rc = vty_read_config_file(config_file, NULL);
-	if (rc < 0) {
-		fprintf(stderr, "Failed to open config file: '%s'\n", config_file);
-		exit(2);
-	}
-
-	rc = telnet_init_dynif(tall_trx_ctx, NULL, vty_get_bind_addr(), OSMO_VTY_PORT_TRX);
-	if (rc < 0)
-		exit(1);
-
-	g_ctrlh = ctrl_interface_setup_dynip(NULL, ctrl_vty_get_bind_addr(), OSMO_CTRL_PORT_TRX, NULL);
-	if (!g_ctrlh) {
-		LOG(ERROR) << "Failed to create CTRL interface.\n";
-		exit(1);
-	}
-
-	/* Backward compatibility: Hack to have 1 channel allocated by default.
-	 * Can be Dropped once we * get rid of "-c" cmdline param */
-	if (g_trx_ctx->cfg.num_chans == 0) {
-		g_trx_ctx->cfg.num_chans = 1;
-		g_trx_ctx->cfg.chans[0].trx = g_trx_ctx;
-		g_trx_ctx->cfg.chans[0].idx = 0;
-		LOG(ERROR) << "No explicit channel config found. Make sure you" \
-			" configure channels in VTY config. Using 1 channel as default," \
-			" but expect your config to break in the future.";
-	}
-
-	print_config(g_trx_ctx);
-
-	if (trx_validate_config(g_trx_ctx) < 0) {
-		LOG(ERROR) << "Config failure - exiting";
+	if (config.sched_rr != -1) {
+		if (set_sched_rr(config.sched_rr) < 0)
 			return EXIT_FAILURE;
 	}
 
-	if (g_trx_ctx->cfg.sched_rr) {
-		if (set_sched_rr(g_trx_ctx->cfg.sched_rr) < 0)
+	setup_signal_handlers();
+
+	/* Check database sanity */
+	if (!trx_setup_config(&config)) {
+		std::cerr << "Config: Database failure - exiting" << std::endl;
 		return EXIT_FAILURE;
 	}
 
-	osmo_signal_register_handler(SS_MAIN, transc_sig_cb, NULL);
-	trx_rate_ctr_init(tall_trx_ctx, g_trx_ctx);
+	gLogInit(config.log_level.c_str());
 
 	srandom(time(NULL));
 
-	if(trx_start(g_trx_ctx) < 0)
-		return EXIT_FAILURE;
+	/* Create the low level device object */
+	if (config.mcbts)
+		iface = RadioDevice::MULTI_ARFCN;
+
+	if (config.extref)
+		ref = RadioDevice::REF_EXTERNAL;
+	else if (config.gpsref)
+		ref = RadioDevice::REF_GPS;
+	else
+		ref = RadioDevice::REF_INTERNAL;
+
+	usrp = RadioDevice::make(config.tx_sps, config.rx_sps, iface,
+				 config.chans, config.offset, config.tx_paths, config.rx_paths);
+	type = usrp->open(config.dev_args, ref, config.swap_channels);
+	if (type < 0) {
+		LOG(ALERT) << "Failed to create radio device" << std::endl;
+		goto shutdown;
+	}
+
+	/* Setup the appropriate device interface */
+	radio = makeRadioInterface(&config, usrp, type);
+	if (!radio)
+		goto shutdown;
+
+	/* Create the transceiver core */
+	trx = makeTransceiver(&config, radio);
+	if (!trx)
+		goto shutdown;
+
+	chans = trx->numChans();
+	std::cout << "-- Transceiver active with "
+		  << chans << " channel(s)" << std::endl;
 
 	while (!gshutdown)
-		osmo_select_main(0);
+		sleep(1);
 
-	trx_stop();
+shutdown:
+	std::cout << "Shutting down transceiver..." << std::endl;
+
+	delete trx;
+	delete radio;
+	delete usrp;
 
-	osmo_fd_unregister(&signal_ofd);
-	osmo_fd_close(&signal_ofd);
-	osmo_signal_unregister_handler(SS_MAIN, transc_sig_cb, NULL);
 	return 0;
 }

Transceiver52M/proto_trxd.c

@@ -1,117 +0,0 @@
-/*
- * Copyright (C) 2019 sysmocom - s.f.m.c. GmbH
- * All Rights Reserved
- *
- * SPDX-License-Identifier: AGPL-3.0+
- *
- * Author: Pau Espin Pedrol <pespin@sysmocom.de>
- *
- * 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 "proto_trxd.h"
-
-#include <osmocom/core/bits.h>
-
-static void trxd_fill_common(struct trxd_hdr_common *common, const struct trx_ul_burst_ind *bi, uint8_t version)
-{
-	common->version = version & 0b1111;
-	common->reserved = 0;
-	common->tn = bi->tn;
-	osmo_store32be(bi->fn, &common->fn);
-}
-
-static void trxd_fill_v0_specific(struct trxd_hdr_v0_specific *v0, const struct trx_ul_burst_ind *bi)
-{
-	int toa_int;
-
-	/* in 1/256 symbols, round to closest integer */
-	toa_int = (int) (bi->toa * 256.0 + 0.5);
-	v0->rssi = bi->rssi;
-	osmo_store16be(toa_int, &v0->toa);
-}
-
-static void trxd_fill_v1_specific(struct trxd_hdr_v1_specific *v1, const struct trx_ul_burst_ind *bi)
-{
-	int16_t ci_int_cB;
-
-	/* deciBels->centiBels, round to closest integer */
-	ci_int_cB = (int16_t)((bi->ci * 10) + 0.5);
-
-	v1->idle = !!bi->idle;
-	v1->modulation = (bi->modulation == MODULATION_GMSK) ?
-					TRXD_MODULATION_GMSK(bi->tss) :
-					TRXD_MODULATION_8PSK(bi->tss);
-	v1->tsc = bi->tsc;
-	osmo_store16be(ci_int_cB, &v1->ci);
-}
-
-static void trxd_fill_burst_normalized255(uint8_t* soft_bits, const struct trx_ul_burst_ind *bi)
-{
-	unsigned i;
-	for (i = 0; i < bi->nbits; i++)
-		soft_bits[i] = (char) 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)
-		return true;
-
-	/* +2: Historically (OpenBTS times), two extra non-used bytes are sent appeneded to each burst */
-	char buf[sizeof(struct trxd_hdr_v0) + bi->nbits + 2];
-	struct trxd_hdr_v0* pkt = (struct trxd_hdr_v0*)buf;
-
-	trxd_fill_common(&pkt->common, bi, 0);
-	trxd_fill_v0_specific(&pkt->v0, bi);
-	trxd_fill_burst_normalized255(&pkt->soft_bits[0], bi);
-
-	/* +1: Historical reason. There's an uninitizalied byte in there: pkt->soft_bits[bi->nbits] */
-	pkt->soft_bits[bi->nbits + 1] = '\0';
-
-	rc = write(fd, buf, sizeof(struct trxd_hdr_v0) + bi->nbits + 2);
-	if (rc <= 0) {
-		CLOGCHAN(chan, DMAIN, LOGL_NOTICE, "mDataSockets write(%d) failed: %d\n", fd, rc);
-		return false;
-	}
-	return true;
-}
-
-bool trxd_send_burst_ind_v1(size_t chan, int fd, const struct trx_ul_burst_ind *bi) {
-	int rc;
-	size_t buf_len;
-
-	buf_len = sizeof(struct trxd_hdr_v1);
-	if (!bi->idle)
-		buf_len += bi->nbits;
-	char buf[buf_len];
-
-	struct trxd_hdr_v1* pkt = (struct trxd_hdr_v1*)buf;
-	trxd_fill_common(&pkt->common, bi, 1);
-	trxd_fill_v0_specific(&pkt->v0, bi);
-	trxd_fill_v1_specific(&pkt->v1, bi);
-
-	if (!bi->idle)
-		trxd_fill_burst_normalized255(&pkt->soft_bits[0], bi);
-
-	rc = write(fd, buf, buf_len);
-	if (rc <= 0) {
-		CLOGCHAN(chan, DMAIN, LOGL_NOTICE, "mDataSockets write(%d) failed: %d\n", fd, rc);
-		return false;
-	}
-	return true;
-}

Transceiver52M/proto_trxd.h

@@ -1,94 +0,0 @@
-#pragma once
-
-#include <stdint.h>
-#include <stdbool.h>
-#include <unistd.h>
-#include <math.h>
-
-#include <osmocom/core/endian.h>
-
-#include "debug.h"
-
-#define MAX_RX_BURST_BUF_SIZE 444 /* 444 = EDGE_BURST_NBITS */
-
-enum Modulation {
-	MODULATION_GMSK,
-	MODULATION_8PSK,
-/* Not supported yet:
-	MODULATION_AQPSK,
-	MODULATION_16QAM,
-	MODULATION_32QAM
-*/
-};
-
-struct trx_ul_burst_ind {
-	float rx_burst[MAX_RX_BURST_BUF_SIZE]; /* soft bits normalized 0..1 */
-	unsigned nbits; // number of symbols per slot in rxBurst, not counting guard periods
-	uint32_t fn; // TDMA frame number
-	uint8_t tn; // TDMA time-slot number
-	double rssi; // in dBFS
-	double toa;  // in symbols
-	double noise; // noise level in dBFS
-	bool idle; // true if no valid burst is included
-	enum Modulation modulation; // modulation type
-	uint8_t tss; // training sequence set
-	uint8_t tsc; // training sequence code
-	float ci; // Carrier-to-Interference ratio, in dB
-};
-
-bool trxd_send_burst_ind_v0(size_t chan, int fd, const struct trx_ul_burst_ind *bi);
-bool trxd_send_burst_ind_v1(size_t chan, int fd, const struct trx_ul_burst_ind *bi);
-
-/* The latest supported TRXD header format version */
-#define TRX_DATA_FORMAT_VER    1
-
-struct trxd_hdr_common {
-#if OSMO_IS_LITTLE_ENDIAN
-	uint8_t tn:3,
-		reserved:1,
-		version:4;
-#elif OSMO_IS_BIG_ENDIAN
-	uint8_t version:4,
-		reserved:1,
-		tn:3;
-#endif
-	uint32_t fn; /* big endian */
-} __attribute__ ((packed));
-
-struct trxd_hdr_v0_specific {
-	uint8_t rssi;
-	uint16_t toa; /* big endian */
-} __attribute__ ((packed));
-
-struct trxd_hdr_v0 {
-	struct trxd_hdr_common common;
-	struct trxd_hdr_v0_specific v0;
-	uint8_t soft_bits[0];
-} __attribute__ ((packed));
-
-
-#define TRXD_MODULATION_GMSK(ts_set) (0b0000 | (ts_set & 0b0011))
-#define TRXD_MODULATION_8PSK(ts_set) (0b0100 | (ts_set & 0b0001))
-#define TRXD_MODULATION_AQPSK(ts_set) (0b0110 | (ts_set & 0b0001))
-#define TRXD_MODULATION_16QAM(ts_set) (0b1000 | (ts_set & 0b0001))
-#define TRXD_MODULATION_32QAM(ts_set) (0b1010 | (ts_set & 0b0001))
-
-struct trxd_hdr_v1_specific {
-#if OSMO_IS_LITTLE_ENDIAN
-	uint8_t tsc:3,
-		modulation:4,
-		idle:1;
-#elif OSMO_IS_BIG_ENDIAN
-	uint8_t idle:1,
-		modulation:4,
-		tsc:3;
-#endif
-	int16_t ci;  /* big endian, in centiBels */
-} __attribute__ ((packed));
-
-struct trxd_hdr_v1 {
-	struct trxd_hdr_common common;
-	struct trxd_hdr_v0_specific v0;
-	struct trxd_hdr_v1_specific v1;
-	uint8_t soft_bits[0];
-} __attribute__ ((packed));

Transceiver52M/radioBuffer.cpp

@@ -5,8 +5,6 @@
  *
  * Author: Tom Tsou <tom@tsou.cc>
  *
- * 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

Transceiver52M/radioClock.cpp

@@ -4,8 +4,6 @@
  *
  * Copyright 2011 Free Software Foundation, Inc.
  *
- * 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

Transceiver52M/radioClock.h

@@ -4,8 +4,6 @@
  *
  * Copyright 2011 Free Software Foundation, Inc.
  *
- * 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

Transceiver52M/radioDevice.h

@@ -18,14 +18,6 @@
 #include <string>
 #include <vector>
 
-#include "GSMCommon.h"
-#include "Logger.h"
-
-extern "C" {
-#include "config_defs.h"
-#include "osmo_signal.h"
-}
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -41,7 +33,7 @@ class RadioDevice {
 
   public:
   /* Available transport bus types */
-  enum TxWindowType { TX_WINDOW_USRP1, TX_WINDOW_FIXED, TX_WINDOW_LMS1 };
+  enum TxWindowType { TX_WINDOW_USRP1, TX_WINDOW_FIXED };
 
   /* Radio interface types */
   enum InterfaceType {
@@ -51,6 +43,12 @@ class RadioDevice {
     MULTI_ARFCN,
   };
 
+  enum ReferenceType {
+    REF_INTERNAL,
+    REF_EXTERNAL,
+    REF_GPS,
+  };
+
   static RadioDevice *make(size_t tx_sps, size_t rx_sps, InterfaceType type,
                            size_t chans = 1, double offset = 0.0,
                            const std::vector<std::string>& tx_paths = std::vector<std::string>(1, ""),
@@ -152,64 +150,12 @@ class RadioDevice {
   /** return the used RX path */
   virtual std::string getTxAntenna(size_t chan = 0) = 0;
 
-  /** return whether user drives synchronization of Tx/Rx of USRP */
-  virtual bool requiresRadioAlign() = 0;
-
-  /** Minimum latency that the device can achieve */
-  virtual GSM::Time minLatency() = 0;
-
   /** Return internal status values */
   virtual double getTxFreq(size_t chan = 0) = 0;
   virtual double getRxFreq(size_t chan = 0) = 0;
   virtual double getSampleRate()=0;
-
-  protected:
-  size_t tx_sps, rx_sps;
-  InterfaceType iface;
-  size_t chans;
-  double lo_offset;
-  std::vector<std::string> tx_paths, rx_paths;
-  std::vector<struct device_counters> m_ctr;
-
-  RadioDevice(size_t tx_sps, size_t rx_sps, InterfaceType type, size_t chans, double offset,
-              const std::vector<std::string>& tx_paths,
-              const std::vector<std::string>& rx_paths):
-		tx_sps(tx_sps), rx_sps(rx_sps), iface(type), chans(chans), lo_offset(offset),
-		tx_paths(tx_paths), rx_paths(rx_paths)
-	{
-		m_ctr.resize(chans);
-		for (size_t i = 0; i < chans; i++) {
-			memset(&m_ctr[i], 0, sizeof(m_ctr[i]));
-			m_ctr[i].chan = i;
-		}
-	}
-
-  bool set_antennas() {
-	unsigned int i;
-
-	for (i = 0; i < tx_paths.size(); i++) {
-		if (tx_paths[i] == "")
-			continue;
-		LOG(DEBUG) << "Configuring channel " << i << " with antenna " << tx_paths[i];
-		if (!setTxAntenna(tx_paths[i], i)) {
-			LOG(ALERT) << "Failed configuring channel " << i << " with antenna " << tx_paths[i];
-			return false;
-		}
-	}
-
-	for (i = 0; i < rx_paths.size(); i++) {
-		if (rx_paths[i] == "")
-			continue;
-		LOG(DEBUG) << "Configuring channel " << i << " with antenna " << rx_paths[i];
-		if (!setRxAntenna(rx_paths[i], i)) {
-			LOG(ALERT) << "Failed configuring channel " << i << " with antenna " << rx_paths[i];
-			return false;
-		}
-	}
-	LOG(INFO) << "Antennas configured successfully";
-	return true;
-  }
-
+  virtual double numberRead()=0;
+  virtual double numberWritten()=0;
 
 };
 

Transceiver52M/radioInterface.cpp

@@ -4,8 +4,6 @@
  * Copyright (C) 2008-2014 Free Software Foundation, Inc.
  * Copyright (C) 2015 Ettus Research LLC
  *
- * 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
@@ -36,8 +34,7 @@ RadioInterface::RadioInterface(RadioDevice *wRadio, size_t tx_sps,
                                size_t rx_sps, size_t chans,
                                int wReceiveOffset, GSM::Time wStartTime)
   : mRadio(wRadio), mSPSTx(tx_sps), mSPSRx(rx_sps), mChans(chans),
-    underrun(false), overrun(false), writeTimestamp(0), readTimestamp(0),
-    receiveOffset(wReceiveOffset), mOn(false)
+    underrun(false), overrun(false), receiveOffset(wReceiveOffset), mOn(false)
 {
   mClock.set(wStartTime);
 }
@@ -78,14 +75,6 @@ bool RadioInterface::init(int type)
 
 void RadioInterface::close()
 {
-  for (std::vector<RadioBuffer*>::iterator it = sendBuffer.begin(); it != sendBuffer.end(); ++it)
-          delete *it;
-  for (std::vector<RadioBuffer*>::iterator it = recvBuffer.begin(); it != recvBuffer.end(); ++it)
-          delete *it;
-  for (std::vector<short*>::iterator it = convertSendBuffer.begin(); it != convertSendBuffer.end(); ++it)
-          delete[] *it;
-  for (std::vector<short*>::iterator it = convertRecvBuffer.begin(); it != convertRecvBuffer.end(); ++it)
-          delete[] *it;
   sendBuffer.resize(0);
   recvBuffer.resize(0);
   convertSendBuffer.resize(0);
@@ -156,32 +145,16 @@ bool RadioInterface::tuneRx(double freq, size_t chan)
   return mRadio->setRxFreq(freq, chan);
 }
 
-/** synchronization thread loop */
-void *AlignRadioServiceLoopAdapter(RadioInterface *radioInterface)
-{
-  set_selfthread_name("AlignRadio");
-  while (1) {
-    sleep(60);
-    radioInterface->alignRadio();
-    pthread_testcancel();
-  }
-  return NULL;
-}
-
-void RadioInterface::alignRadio() {
-  mRadio->updateAlignment(writeTimestamp+ (TIMESTAMP) 10000);
-}
-
 bool RadioInterface::start()
 {
   if (mOn)
     return true;
 
   LOG(INFO) << "Starting radio device";
-  if (mRadio->requiresRadioAlign())
-        mAlignRadioServiceLoopThread.start(
-                                (void * (*)(void*))AlignRadioServiceLoopAdapter,
+#ifdef USRP1
+  mAlignRadioServiceLoopThread.start((void * (*)(void*))AlignRadioServiceLoopAdapter,
                                      (void*)this);
+#endif
 
   if (!mRadio->start())
     return false;
@@ -218,6 +191,22 @@ bool RadioInterface::stop()
   return true;
 }
 
+#ifdef USRP1
+void *AlignRadioServiceLoopAdapter(RadioInterface *radioInterface)
+{
+  while (1) {
+    radioInterface->alignRadio();
+    pthread_testcancel();
+  }
+  return NULL;
+}
+
+void RadioInterface::alignRadio() {
+  sleep(60);
+  mRadio->updateAlignment(writeTimestamp+ (TIMESTAMP) 10000);
+}
+#endif
+
 void RadioInterface::driveTransmitRadio(std::vector<signalVector *> &bursts,
                                         std::vector<bool> &zeros)
 {
@@ -230,15 +219,14 @@ void RadioInterface::driveTransmitRadio(std::vector<signalVector *> &bursts,
   while (pushBuffer());
 }
 
-int RadioInterface::driveReceiveRadio()
+bool RadioInterface::driveReceiveRadio()
 {
   radioVector *burst = NULL;
 
   if (!mOn)
-    return 0;
+    return false;
 
-  if (pullBuffer() < 0)
-    return  -1;
+  pullBuffer();
 
   GSM::Time rcvClock = mClock.get();
   rcvClock.decTN(receiveOffset);
@@ -256,7 +244,7 @@ int RadioInterface::driveReceiveRadio()
    * Pre-allocate head room for the largest correlation size
    * so we can later avoid a re-allocation and copy
    * */
-  size_t head = GSM::gRACHSynchSequenceTS0.size();
+  size_t head = GSM::gRACHSynchSequence.size();
 
   /*
    * Form receive bursts and pass up to transceiver. Use repeating
@@ -283,7 +271,7 @@ int RadioInterface::driveReceiveRadio()
       burstSize = (symbolsPerSlot + (tN % 4 == 0)) * mSPSRx;
   }
 
-  return 1;
+  return true;
 }
 
 bool RadioInterface::isUnderrun()
@@ -313,14 +301,13 @@ double RadioInterface::getRxGain(size_t chan)
 }
 
 /* Receive a timestamped chunk from the device */
-int RadioInterface::pullBuffer()
+void RadioInterface::pullBuffer()
 {
   bool local_underrun;
-  int numRecv;
-  size_t segmentLen = recvBuffer[0]->getSegmentLen();
+  size_t numRecv, segmentLen = recvBuffer[0]->getSegmentLen();
 
   if (recvBuffer[0]->getFreeSegments() <= 0)
-    return -1;
+    return;
 
   /* Outer buffer access size is fixed */
   numRecv = mRadio->readSamples(convertRecvBuffer,
@@ -329,9 +316,9 @@ int RadioInterface::pullBuffer()
                                 readTimestamp,
                                 &local_underrun);
 
-  if ((size_t) numRecv != segmentLen) {
+  if (numRecv != segmentLen) {
           LOG(ALERT) << "Receive error " << numRecv;
-          return -1;
+          return;
   }
 
   for (size_t i = 0; i < mChans; i++) {
@@ -342,13 +329,11 @@ int RadioInterface::pullBuffer()
 
   underrun |= local_underrun;
   readTimestamp += numRecv;
-  return 0;
 }
 
 /* Send timestamped chunk to the device with arbitrary size */
 bool RadioInterface::pushBuffer()
 {
-  bool local_underrun;
   size_t numSent, segmentLen = sendBuffer[0]->getSegmentLen();
 
   if (sendBuffer[0]->getAvailSegments() < 1)
@@ -364,9 +349,8 @@ bool RadioInterface::pushBuffer()
   /* Send the all samples in the send buffer */
   numSent = mRadio->writeSamples(convertSendBuffer,
                                  segmentLen,
-                                 &local_underrun,
+                                 &underrun,
                                  writeTimestamp);
-  underrun |= local_underrun;
   writeTimestamp += numSent;
 
   return true;

Transceiver52M/radioInterface.h

@@ -71,7 +71,7 @@ private:
   virtual bool pushBuffer(void);
 
   /** pull GSM bursts from the receive buffer */
-  virtual int pullBuffer(void);
+  virtual void pullBuffer(void);
 
 public:
 
@@ -116,8 +116,8 @@ public:
   void driveTransmitRadio(std::vector<signalVector *> &bursts,
                           std::vector<bool> &zeros);
 
-  /** drive reception of GSM bursts. -1: Error. 0: Radio off. 1: Received something. */
-  int driveReceiveRadio();
+  /** drive reception of GSM bursts */
+  bool driveReceiveRadio();
 
   int setPowerAttenuation(int atten, size_t chan = 0);
 
@@ -133,23 +133,28 @@ public:
   /** get transport window type of attached device */ 
   enum RadioDevice::TxWindowType getWindowType() { return mRadio->getWindowType(); }
 
-  /** Minimum latency that the device can achieve */
-  GSM::Time minLatency()  { return mRadio->minLatency(); }
-
+#if USRP1
 protected:
+
   /** drive synchronization of Tx/Rx of USRP */
   void alignRadio();
 
   friend void *AlignRadioServiceLoopAdapter(RadioInterface*);
+#endif
 };
 
+#if USRP1
+/** synchronization thread loop */
+void *AlignRadioServiceLoopAdapter(RadioInterface*);
+#endif
+
 class RadioInterfaceResamp : public RadioInterface {
 private:
   signalVector *outerSendBuffer;
   signalVector *outerRecvBuffer;
 
   bool pushBuffer();
-  int pullBuffer();
+  void pullBuffer();
 
 public:
   RadioInterfaceResamp(RadioDevice* wRadio, size_t tx_sps, size_t rx_sps);
@@ -162,7 +167,7 @@ public:
 class RadioInterfaceMulti : public RadioInterface {
 private:
   bool pushBuffer();
-  int pullBuffer();
+  void pullBuffer();
 
   signalVector *outerSendBuffer;
   signalVector *outerRecvBuffer;

Transceiver52M/radioInterfaceMulti.cpp

@@ -5,8 +5,6 @@
  *
  * Author: Tom Tsou <tom.tsou@ettus.com>
  *
- * 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
@@ -227,15 +225,14 @@ bool RadioInterfaceMulti::init(int type)
 }
 
 /* Receive a timestamped chunk from the device */
-int RadioInterfaceMulti::pullBuffer()
+void RadioInterfaceMulti::pullBuffer()
 {
 	bool local_underrun;
 	size_t num;
 	float *buf;
-	unsigned int i;
 
 	if (recvBuffer[0]->getFreeSegments() <= 0)
-		return -1;
+		return;
 
 	/* Outer buffer access size is fixed */
 	num = mRadio->readSamples(convertRecvBuffer,
@@ -245,7 +242,7 @@ int RadioInterfaceMulti::pullBuffer()
 				  &local_underrun);
 	if (num != channelizer->inputLen()) {
 		LOG(ALERT) << "Receive error " << num << ", " << channelizer->inputLen();
-		return -1;
+		return;
 	}
 
 	convert_short_float((float *) outerRecvBuffer->begin(),
@@ -276,22 +273,10 @@ int RadioInterfaceMulti::pullBuffer()
 		buf = channelizer->outputBuffer(pchan);
 		size_t cLen = channelizer->outputLen();
 		size_t hLen = dnsampler->len();
+		size_t hSize = 2 * hLen * sizeof(float);
 
-		float *fdst = &buf[2 * -hLen];
-		complex *src = history[lchan]->begin();
-		for (i = 0; i < hLen; i++) {
-			fdst[0] = src->real();
-			fdst[1] = src->imag();
-			src++;
-			fdst += 2;
-		}
-		complex *dst = history[lchan]->begin();
-		float *fsrc = &buf[2 * (cLen - hLen)];
-		for (i = 0; i < hLen; i++) {
-			*dst = complex(fdst[0], fdst[1]);
-			fsrc += 2;
-			dst++;
-		}
+		memcpy(&buf[2 * -hLen], history[lchan]->begin(), hSize);
+		memcpy(history[lchan]->begin(), &buf[2 * (cLen - hLen)], hSize);
 
 		float *wr_segment = recvBuffer[lchan]->getWriteSegment();
 
@@ -303,7 +288,6 @@ int RadioInterfaceMulti::pullBuffer()
 			LOG(ALERT) << "Sample rate upsampling error";
 		}
 	}
-	return 0;
 }
 
 /* Send a timestamped chunk to the device */

Transceiver52M/radioInterfaceResamp.cpp

@@ -6,8 +6,6 @@
  *
  * Author: Tom Tsou <tom@tsou.cc>
  *
- * 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
@@ -162,13 +160,13 @@ bool RadioInterfaceResamp::init(int type)
 }
 
 /* Receive a timestamped chunk from the device */
-int RadioInterfaceResamp::pullBuffer()
+void RadioInterfaceResamp::pullBuffer()
 {
 	bool local_underrun;
 	int rc, num_recv;
 
 	if (recvBuffer[0]->getFreeSegments() <= 0)
-		return -1;
+		return;
 
 	/* Outer buffer access size is fixed */
 	num_recv = mRadio->readSamples(convertRecvBuffer,
@@ -178,7 +176,7 @@ int RadioInterfaceResamp::pullBuffer()
 				       &local_underrun);
 	if (num_recv != (int) resamp_outchunk) {
 		LOG(ALERT) << "Receive error " << num_recv;
-		return -1;
+		return;
 	}
 
 	convert_short_float((float *) outerRecvBuffer->begin(),
@@ -198,7 +196,6 @@ int RadioInterfaceResamp::pullBuffer()
 
 	/* Set history for the next chunk */
 	outerRecvBuffer->updateHistory();
-	return 0;
 }
 
 /* Send a timestamped chunk to the device */

Transceiver52M/radioVector.cpp

@@ -4,8 +4,6 @@
  *
  * Copyright 2011 Free Software Foundation, Inc.
  *
- * 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

Transceiver52M/radioVector.h

@@ -4,8 +4,6 @@
  *
  * Copyright 2011 Free Software Foundation, Inc.
  *
- * 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

Transceiver52M/sigProcLib.cpp

@@ -1,8 +1,6 @@
 /*
 * Copyright 2008, 2011 Free Software Foundation, Inc.
 *
-* SPDX-License-Identifier: AGPL-3.0+
-*
 * This software is distributed under the terms of the GNU Affero Public License.
 * See the COPYING file in the main directory for details.
 *
@@ -86,13 +84,14 @@ static Resampler *dnsampler = NULL;
  * perform 16-byte memory alignment required by many SSE instructions.
  */
 struct CorrelationSequence {
-  CorrelationSequence() : sequence(NULL), buffer(NULL), toa(0.0)
+  CorrelationSequence() : sequence(NULL), buffer(NULL)
   {
   }
 
   ~CorrelationSequence()
   {
     delete sequence;
+    free(buffer);
   }
 
   signalVector *sequence;
@@ -107,7 +106,8 @@ struct CorrelationSequence {
  * for SSE instructions.
  */
 struct PulseSequence {
-  PulseSequence() : c0(NULL), c1(NULL), c0_inv(NULL), empty(NULL)
+  PulseSequence() : c0(NULL), c1(NULL), c0_inv(NULL), empty(NULL),
+		    c0_buffer(NULL), c1_buffer(NULL), c0_inv_buffer(NULL)
   {
   }
 
@@ -117,17 +117,22 @@ struct PulseSequence {
     delete c1;
     delete c0_inv;
     delete empty;
+    free(c0_buffer);
+    free(c1_buffer);
   }
 
   signalVector *c0;
   signalVector *c1;
   signalVector *c0_inv;
   signalVector *empty;
+  void *c0_buffer;
+  void *c1_buffer;
+  void *c0_inv_buffer;
 };
 
 static CorrelationSequence *gMidambles[] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
 static CorrelationSequence *gEdgeMidambles[] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
-static CorrelationSequence *gRACHSequences[] = {NULL,NULL,NULL};
+static CorrelationSequence *gRACHSequence = NULL;
 static PulseSequence *GSMPulse1 = NULL;
 static PulseSequence *GSMPulse4 = NULL;
 
@@ -145,15 +150,11 @@ void sigProcLibDestroy()
     delayFilters[i] = NULL;
   }
 
-  for (int i = 0; i < 3; i++) {
-    delete gRACHSequences[i];
-    gRACHSequences[i] = NULL;
-  }
-
   delete GMSKRotation1;
   delete GMSKReverseRotation1;
   delete GMSKRotation4;
   delete GMSKReverseRotation4;
+  delete gRACHSequence;
   delete GSMPulse1;
   delete GSMPulse4;
   delete dnsampler;
@@ -162,6 +163,7 @@ void sigProcLibDestroy()
   GMSKRotation4 = NULL;
   GMSKReverseRotation4 = NULL;
   GMSKReverseRotation1 = NULL;
+  gRACHSequence = NULL;
   GSMPulse1 = NULL;
   GSMPulse4 = NULL;
 }
@@ -287,7 +289,8 @@ enum ConvType {
 
 static signalVector *convolve(const signalVector *x, const signalVector *h,
                               signalVector *y, ConvType spanType,
-                              size_t start = 0, size_t len = 0)
+                              size_t start = 0, size_t len = 0,
+                              size_t step = 1, int offset = 0)
 {
   int rc;
   size_t head = 0, tail = 0;
@@ -334,7 +337,7 @@ static signalVector *convolve(const signalVector *x, const signalVector *h,
   if (y && (len > y->size()))
     return NULL;
   if (!y) {
-    y = new signalVector(len, convolve_h_alloc, free);
+    y = new signalVector(len);
     alloc = true;
   }
 
@@ -355,22 +358,22 @@ static signalVector *convolve(const signalVector *x, const signalVector *h,
     rc = convolve_real((float *) _x->begin(), _x->size(),
                        (float *) h->begin(), h->size(),
                        (float *) y->begin(), y->size(),
-                       start, len);
+                       start, len, step, offset);
   } else if (!h->isReal() && h->isAligned()) {
     rc = convolve_complex((float *) _x->begin(), _x->size(),
                           (float *) h->begin(), h->size(),
                           (float *) y->begin(), y->size(),
-                          start, len);
+                          start, len, step, offset);
   } else if (h->isReal() && !h->isAligned()) {
     rc = base_convolve_real((float *) _x->begin(), _x->size(),
                             (float *) h->begin(), h->size(),
                             (float *) y->begin(), y->size(),
-                            start, len);
+                            start, len, step, offset);
   } else if (!h->isReal() && !h->isAligned()) {
     rc = base_convolve_complex((float *) _x->begin(), _x->size(),
                                (float *) h->begin(), h->size(),
                                (float *) y->begin(), y->size(),
-                               start, len);
+                               start, len, step, offset);
   } else {
     rc = -1;
   }
@@ -397,7 +400,8 @@ static bool generateInvertC0Pulse(PulseSequence *pulse)
   if (!pulse)
     return false;
 
-  pulse->c0_inv = new signalVector((complex *) convolve_h_alloc(5), 0, 5, convolve_h_alloc, free);
+  pulse->c0_inv_buffer = convolve_h_alloc(5);
+  pulse->c0_inv = new signalVector((complex *) pulse->c0_inv_buffer, 0, 5);
   pulse->c0_inv->isReal(true);
   pulse->c0_inv->setAligned(false);
 
@@ -426,7 +430,9 @@ static bool generateC1Pulse(int sps, PulseSequence *pulse)
     return false;
   }
 
-  pulse->c1 = new signalVector((complex *) convolve_h_alloc(len), 0, len, convolve_h_alloc, free);
+  pulse->c1_buffer = convolve_h_alloc(len);
+  pulse->c1 = new signalVector((complex *)
+                                  pulse->c1_buffer, 0, len);
   pulse->c1->isReal(true);
 
   /* Enable alignment for SSE usage */
@@ -480,7 +486,8 @@ static PulseSequence *generateGSMPulse(int sps)
     len = 4;
   }
 
-  pulse->c0 = new signalVector((complex *) convolve_h_alloc(len), 0, len, convolve_h_alloc, free);
+  pulse->c0_buffer = convolve_h_alloc(len);
+  pulse->c0 = new signalVector((complex *) pulse->c0_buffer, 0, len);
   pulse->c0->isReal(true);
 
   /* Enable alingnment for SSE usage */
@@ -532,17 +539,19 @@ static PulseSequence *generateGSMPulse(int sps)
   return pulse;
 }
 
-/* Convert -1..+1 soft bits to 0..1 soft bits */
-void vectorSlicer(float *dest, const float *src, size_t len)
+bool vectorSlicer(SoftVector *x)
 {
-	size_t i;
-	for (i = 0; i < len; i++) {
-		dest[i] = 0.5 * (src[i] + 1.0f);
-		if (dest[i] > 1.0)
-			dest[i] = 1.0;
-		else if (dest[i] < 0.0)
-			dest[i] = 0.0;
+  SoftVector::iterator xP = x->begin();
+  SoftVector::iterator xPEnd = x->end();
+  while (xP < xPEnd) {
+    *xP = 0.5 * (*xP + 1.0f);
+    if (*xP > 1.0)
+      *xP = 1.0;
+    if (*xP < 0.0)
+      *xP = 0.0;
+    xP++;
   }
+  return true;
 }
 
 static signalVector *rotateBurst(const BitVector &wBurst,
@@ -1007,7 +1016,7 @@ static void generateDelayFilters()
 
   for (int i = 0; i < DELAYFILTS; i++) {
     data = (complex *) convolve_h_alloc(h_len);
-    h = new signalVector(data, 0, h_len, convolve_h_alloc, free);
+    h = new signalVector(data, 0, h_len);
     h->setAligned(true);
     h->isReal(true);
 
@@ -1251,9 +1260,10 @@ static bool generateMidamble(int sps, int tsc)
 
   /* For SSE alignment, reallocate the midamble sequence on 16-byte boundary */
   data = (complex *) convolve_h_alloc(midMidamble->size());
-  _midMidamble = new signalVector(data, 0, midMidamble->size(), convolve_h_alloc, free);
+  _midMidamble = new signalVector(data, 0, midMidamble->size());
   _midMidamble->setAligned(true);
-  midMidamble->copyTo(*_midMidamble);
+  memcpy(_midMidamble->begin(), midMidamble->begin(),
+	 midMidamble->size() * sizeof(complex));
 
   autocorr = convolve(midamble, _midMidamble, NULL, NO_DELAY);
   if (!autocorr) {
@@ -1262,6 +1272,7 @@ static bool generateMidamble(int sps, int tsc)
   }
 
   gMidambles[tsc] = new CorrelationSequence;
+  gMidambles[tsc]->buffer = data;
   gMidambles[tsc]->sequence = _midMidamble;
   gMidambles[tsc]->gain = peakDetect(*autocorr, &toa, NULL);
 
@@ -1306,12 +1317,14 @@ static CorrelationSequence *generateEdgeMidamble(int tsc)
   conjugateVector(*midamble);
 
   data = (complex *) convolve_h_alloc(midamble->size());
-  _midamble = new signalVector(data, 0, midamble->size(), convolve_h_alloc, free);
+  _midamble = new signalVector(data, 0, midamble->size());
   _midamble->setAligned(true);
-  midamble->copyTo(*_midamble);
+  memcpy(_midamble->begin(), midamble->begin(),
+	 midamble->size() * sizeof(complex));
 
   /* Channel gain is an empirically measured value */
   seq = new CorrelationSequence;
+  seq->buffer = data;
   seq->sequence = _midamble;
   seq->gain = Complex<float>(-19.6432, 19.5006) / 1.18;
   seq->toa = 0;
@@ -1321,7 +1334,7 @@ static CorrelationSequence *generateEdgeMidamble(int tsc)
   return seq;
 }
 
-static bool generateRACHSequence(CorrelationSequence **seq, const BitVector &bv, int sps)
+static bool generateRACHSequence(int sps)
 {
   bool status = true;
   float toa;
@@ -1329,14 +1342,13 @@ static bool generateRACHSequence(CorrelationSequence **seq, const BitVector &bv,
   signalVector *autocorr = NULL;
   signalVector *seq0 = NULL, *seq1 = NULL, *_seq1 = NULL;
 
-  if (*seq != NULL)
-    delete *seq;
+  delete gRACHSequence;
 
-  seq0 = modulateBurst(bv, 0, sps, false);
+  seq0 = modulateBurst(gRACHSynchSequence, 0, sps, false);
   if (!seq0)
     return false;
 
-  seq1 = modulateBurst(bv.segment(0, 40), 0, sps, true);
+  seq1 = modulateBurst(gRACHSynchSequence.segment(0, 40), 0, sps, true);
   if (!seq1) {
     status = false;
     goto release;
@@ -1346,9 +1358,9 @@ static bool generateRACHSequence(CorrelationSequence **seq, const BitVector &bv,
 
   /* For SSE alignment, reallocate the midamble sequence on 16-byte boundary */
   data = (complex *) convolve_h_alloc(seq1->size());
-  _seq1 = new signalVector(data, 0, seq1->size(), convolve_h_alloc, free);
+  _seq1 = new signalVector(data, 0, seq1->size());
   _seq1->setAligned(true);
-  seq1->copyTo(*_seq1);
+  memcpy(_seq1->begin(), seq1->begin(), seq1->size() * sizeof(complex));
 
   autocorr = convolve(seq0, _seq1, autocorr, NO_DELAY);
   if (!autocorr) {
@@ -1356,18 +1368,19 @@ static bool generateRACHSequence(CorrelationSequence **seq, const BitVector &bv,
     goto release;
   }
 
-  *seq = new CorrelationSequence;
-  (*seq)->sequence = _seq1;
-  (*seq)->gain = peakDetect(*autocorr, &toa, NULL);
+  gRACHSequence = new CorrelationSequence;
+  gRACHSequence->sequence = _seq1;
+  gRACHSequence->buffer = data;
+  gRACHSequence->gain = peakDetect(*autocorr, &toa, NULL);
 
   /* For 1 sps only
    *     (Half of correlation length - 1) + midpoint of pulse shaping filer
    *     20.5 = (40 / 2 - 1) + 1.5
    */
   if (sps == 1)
-    (*seq)->toa = toa - 20.5;
+    gRACHSequence->toa = toa - 20.5;
   else
-    (*seq)->toa = 0.0;
+    gRACHSequence->toa = 0.0;
 
 release:
   delete autocorr;
@@ -1377,7 +1390,7 @@ release:
   if (!status) {
     delete _seq1;
     free(data);
-    *seq = NULL;
+    gRACHSequence = NULL;
   }
 
   return status;
@@ -1444,7 +1457,7 @@ static signalVector *downsampleBurst(const signalVector &burst)
 {
   signalVector in(DOWNSAMPLE_IN_LEN, dnsampler->len());
   signalVector *out = new signalVector(DOWNSAMPLE_OUT_LEN);
-  burst.copyToSegment(in, 0, DOWNSAMPLE_IN_LEN);
+  memcpy(in.begin(), burst.begin(), DOWNSAMPLE_IN_LEN * 2 * sizeof(float));
 
   if (dnsampler->rotate((float *) in.begin(), DOWNSAMPLE_IN_LEN,
                         (float *) out->begin(), DOWNSAMPLE_OUT_LEN) < 0) {
@@ -1455,33 +1468,6 @@ static signalVector *downsampleBurst(const signalVector &burst)
   return out;
 };
 
-/*
- * Computes C/I (Carrier-to-Interference ratio) in dB (deciBels).
- * 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)
-{
-  float S, C;
-  int ps;
-
-  /* Integer position where the sequence starts */
-  ps = start + 1 - sync->sequence->size() + (int)roundf(toa);
-
-  /* Estimate Signal power */
-  S = 0.0f;
-  for (int i=0, j=ps; i<(int)sync->sequence->size(); i++,j++)
-    S += (*burst)[j].norm2();
-  S /= sync->sequence->size();
-
-  /* Esimate Carrier power */
-  C = xcorr.norm2() / ((sync->sequence->size() - 1) * sync->gain.abs());
-
-  /* Interference = Signal - Carrier, so C/I = C / (S - C) */
-  return 3.0103f * log2f(C / (S - C));
-}
-
 /*
  * Detect a burst based on correlation and peak-to-average ratio
  *
@@ -1492,13 +1478,11 @@ static float computeCI(const signalVector *burst, CorrelationSequence *sync,
  */
 static int detectBurst(const signalVector &burst,
                        signalVector &corr, CorrelationSequence *sync,
-                       float thresh, int sps, int start, int len,
-                       struct estim_burst_params *ebp)
+                       float thresh, int sps, complex *amp, float *toa,
+                       int start, int len)
 {
   const signalVector *corr_in;
   signalVector *dec = NULL;
-  complex xcorr;
-  int rc = 1;
 
   if (sps == 4) {
     dec = downsampleBurst(burst);
@@ -1510,43 +1494,36 @@ static int detectBurst(const signalVector &burst,
 
   /* Correlate */
   if (!convolve(corr_in, sync->sequence, &corr,
-                CUSTOM, start, len)) {
-    rc = -1;
-    goto del_ret;
+                CUSTOM, start, len, 1, 0)) {
+    delete dec;
+    return -1;
   }
 
+  delete dec;
+
   /* Running at the downsampled rate at this point */
   sps = 1;
 
   /* Peak detection - place restrictions at correlation edges */
-  ebp->amp = fastPeakDetect(corr, &ebp->toa);
+  *amp = fastPeakDetect(corr, toa);
 
-  if ((ebp->toa < 3 * sps) || (ebp->toa > len - 3 * sps)) {
-    rc = 0;
-    goto del_ret;
-  }
+  if ((*toa < 3 * sps) || (*toa > len - 3 * sps))
+    return 0;
 
-  /* Peak-to-average ratio */
-  if (computePeakRatio(&corr, sps, ebp->toa, ebp->amp) < thresh) {
-    rc = 0;
-    goto del_ret;
-  }
+  /* Peak -to-average ratio */
+  if (computePeakRatio(&corr, sps, *toa, *amp) < thresh)
+    return 0;
 
-  /* Refine TOA and correlation value */
-  xcorr = peakDetect(corr, &ebp->toa, NULL);
-
-  /* Compute C/I */
-  ebp->ci = computeCI(corr_in, sync, ebp->toa, start, xcorr);
+  /* Compute peak-to-average ratio. Reject if we don't have enough values */
+  *amp = peakDetect(corr, toa, NULL);
 
   /* Normalize our channel gain */
-  ebp->amp = xcorr / sync->gain;
+  *amp = *amp / sync->gain;
 
   /* Compensate for residuate time lag */
-  ebp->toa = ebp->toa - sync->toa;
+  *toa = *toa - sync->toa;
 
-del_ret:
-  delete dec;
-  return rc;
+  return 1;
 }
 
 static float maxAmplitude(const signalVector &burst)
@@ -1570,10 +1547,13 @@ static float maxAmplitude(const signalVector &burst)
  *   head: Search symbols before target
  *   tail: Search symbols after target
  */
-static int detectGeneralBurst(const signalVector &rxBurst, float thresh, int sps,
+static int detectGeneralBurst(const signalVector &rxBurst,
+                              float thresh,
+                              int sps,
+                              complex &amp,
+                              float &toa,
                               int target, int head, int tail,
-                              CorrelationSequence *sync,
-                              struct estim_burst_params *ebp)
+                              CorrelationSequence *sync)
 {
   int rc, start, len;
   bool clipping = false;
@@ -1595,18 +1575,17 @@ static int detectGeneralBurst(const signalVector &rxBurst, float thresh, int sps
   signalVector corr(len);
 
   rc = detectBurst(rxBurst, corr, sync,
-                   thresh, sps, start, len, ebp);
+                   thresh, sps, &amp, &toa, start, len);
   if (rc < 0) {
     return -SIGERR_INTERNAL;
   } else if (!rc) {
-    ebp->amp = 0.0f;
-    ebp->toa = 0.0f;
-    ebp->ci = 0.0f;
+    amp = 0.0f;
+    toa = 0.0f;
     return clipping?-SIGERR_CLIP:SIGERR_NONE;
   }
 
   /* Subtract forward search bits from delay */
-  ebp->toa -= head;
+  toa -= head;
 
   return 1;
 }
@@ -1621,24 +1600,18 @@ static int detectGeneralBurst(const signalVector &rxBurst, float thresh, int sps
  *   tail: Search 8 symbols + maximum expected delay
  */
 static int detectRACHBurst(const signalVector &burst, float threshold, int sps,
-                           unsigned max_toa, bool ext, struct estim_burst_params *ebp)
+                           complex &amplitude, float &toa, unsigned max_toa)
 {
   int rc, target, head, tail;
-  int i, num_seq;
+  CorrelationSequence *sync;
 
   target = 8 + 40;
   head = 8;
   tail = 8 + max_toa;
-  num_seq = ext ? 3 : 1;
+  sync = gRACHSequence;
 
-  for (i = 0; i < num_seq; i++) {
-    rc = detectGeneralBurst(burst, threshold, sps, target, head, tail,
-                            gRACHSequences[i], ebp);
-    if (rc > 0) {
-      ebp->tsc = i;
-      break;
-    }
-  }
+  rc = detectGeneralBurst(burst, threshold, sps, amplitude, toa,
+                          target, head, tail, sync);
 
   return rc;
 }
@@ -1652,7 +1625,7 @@ static int detectRACHBurst(const signalVector &burst, float threshold, int sps,
  *   tail: Search 6 symbols + maximum expected delay
  */
 static int analyzeTrafficBurst(const signalVector &burst, unsigned tsc, float threshold,
-                               int sps, unsigned max_toa, struct estim_burst_params *ebp)
+                               int sps, complex &amplitude, float &toa, unsigned max_toa)
 {
   int rc, target, head, tail;
   CorrelationSequence *sync;
@@ -1665,13 +1638,13 @@ static int analyzeTrafficBurst(const signalVector &burst, unsigned tsc, float th
   tail = 6 + max_toa;
   sync = gMidambles[tsc];
 
-  ebp->tsc = tsc;
-  rc = detectGeneralBurst(burst, threshold, sps, target, head, tail, sync, ebp);
+  rc = detectGeneralBurst(burst, threshold, sps, amplitude, toa,
+                          target, head, tail, sync);
   return rc;
 }
 
 static int detectEdgeBurst(const signalVector &burst, unsigned tsc, float threshold,
-                           int sps, unsigned max_toa, struct estim_burst_params *ebp)
+                           int sps, complex &amplitude, float &toa, unsigned max_toa)
 {
   int rc, target, head, tail;
   CorrelationSequence *sync;
@@ -1684,31 +1657,32 @@ static int detectEdgeBurst(const signalVector &burst, unsigned tsc, float thresh
   tail = 6 + max_toa;
   sync = gEdgeMidambles[tsc];
 
-  ebp->tsc = tsc;
-  rc = detectGeneralBurst(burst, threshold, sps,
-                          target, head, tail, sync, ebp);
+  rc = detectGeneralBurst(burst, threshold, sps, amplitude, toa,
+                          target, head, tail, sync);
   return rc;
 }
 
 int detectAnyBurst(const signalVector &burst, unsigned tsc, float threshold,
-                   int sps, CorrType type, unsigned max_toa,
-                   struct estim_burst_params *ebp)
+                   int sps, CorrType type, complex &amp, float &toa,
+                   unsigned max_toa)
 {
   int rc = 0;
 
   switch (type) {
   case EDGE:
-    rc = detectEdgeBurst(burst, tsc, threshold, sps, max_toa, ebp);
+    rc = detectEdgeBurst(burst, tsc, threshold, sps,
+                         amp, toa, max_toa);
     if (rc > 0)
       break;
     else
       type = TSC;
   case TSC:
-    rc = analyzeTrafficBurst(burst, tsc, threshold, sps, max_toa, ebp);
+    rc = analyzeTrafficBurst(burst, tsc, threshold, sps,
+                             amp, toa, max_toa);
     break;
-  case EXT_RACH:
   case RACH:
-    rc = detectRACHBurst(burst, threshold, sps, max_toa, type == EXT_RACH, ebp);
+    rc = detectRACHBurst(burst, threshold, sps, amp, toa,
+                         max_toa);
     break;
   default:
     LOG(ERR) << "Invalid correlation type";
@@ -1886,10 +1860,7 @@ bool sigProcLibSetup()
   GSMPulse1 = generateGSMPulse(1);
   GSMPulse4 = generateGSMPulse(4);
 
-  generateRACHSequence(&gRACHSequences[0], gRACHSynchSequenceTS0, 1);
-  generateRACHSequence(&gRACHSequences[1], gRACHSynchSequenceTS1, 1);
-  generateRACHSequence(&gRACHSequences[2], gRACHSynchSequenceTS2, 1);
-
+  generateRACHSequence(1);
   for (int tsc = 0; tsc < 8; tsc++) {
     generateMidamble(1, tsc);
     gEdgeMidambles[tsc] = generateEdgeMidamble(tsc);

Transceiver52M/sigProcLib.h

@@ -29,7 +29,6 @@
 enum CorrType{
   OFF,         ///< timeslot is off
   TSC,         ///< timeslot should contain a normal burst
-  EXT_RACH,    ///< timeslot should contain an extended access burst
   RACH,        ///< timeslot should contain an access burst
   EDGE,        ///< timeslot should contain an EDGE burst
   IDLE         ///< timeslot is an idle (or dummy) burst
@@ -59,7 +58,7 @@ bool sigProcLibSetup();
 void sigProcLibDestroy(void);
 
 /** Operate soft slicer on a soft-bit vector */
-void vectorSlicer(float *dest, const float *src, size_t len);
+bool vectorSlicer(SoftVector *x);
 
 /** GMSK modulate a GSM burst of bits */
 signalVector *modulateBurst(const BitVector &wBurst,
@@ -101,26 +100,15 @@ void scaleVector(signalVector &x,
 */
 float energyDetect(const signalVector &rxBurst,
                    unsigned windowLength);
-
-/** Struct used to fill out parameters in detectAnyBurst(): estimated burst parameters
-@param amplitude The estimated amplitude of received TSC burst.
-@param toa The estimated time-of-arrival of received TSC burst (in symbols).
-@param tsc The TSC used to detect the burst.
-*/
-struct estim_burst_params {
-        complex amp;
-        float toa;
-        uint8_t tsc;
-        float ci;
-};
 /**
         8-PSK/GMSK/RACH burst detector
         @param burst The received GSM burst of interest
         @param tsc Midamble type (0..7) also known as TSC
         @param threshold The threshold that the received burst's post-correlator SNR is compared against to determine validity.
         @param sps The number of samples per GSM symbol.
+        @param amplitude The estimated amplitude of received TSC burst.
+        @param toa The estimate time-of-arrival of received TSC burst (in symbols).
         @param max_toa The maximum expected time-of-arrival (in symbols).
-        @param ebp The estimated parameters of the detected burst.
         @return positive value (CorrType) if threshold value is reached,
                 negative value (-SignalError) on error,
                 zero (SIGERR_NONE) if no burst is detected
@@ -130,8 +118,9 @@ int detectAnyBurst(const signalVector &burst,
                    float threshold,
                    int sps,
                    CorrType type,
-                   unsigned max_toa,
-                   struct estim_burst_params *ebp);
+                   complex &amp,
+                   float &toa,
+                   unsigned max_toa);
 
 /** Demodulate burst basde on type and output soft bits */
 SoftVector *demodAnyBurst(const signalVector &burst, int sps,

Transceiver52M/signalVector.cpp

@@ -1,20 +1,20 @@
 #include "signalVector.h"
 
-signalVector::signalVector(size_t size, vector_alloc_func wAllocFunc, vector_free_func wFreeFunc)
-	: Vector<complex>(size, wAllocFunc, wFreeFunc),
+signalVector::signalVector(size_t size)
+	: Vector<complex>(size),
 	  real(false), aligned(false), symmetry(NONE)
 {
 }
 
-signalVector::signalVector(size_t size, size_t start, vector_alloc_func wAllocFunc, vector_free_func wFreeFunc)
-	: Vector<complex>(size + start, wAllocFunc, wFreeFunc),
+signalVector::signalVector(size_t size, size_t start)
+	: Vector<complex>(size + start),
 	  real(false), aligned(false), symmetry(NONE)
 {
 	mStart = mData + start;
 }
 
-signalVector::signalVector(complex *data, size_t start, size_t span, vector_alloc_func wAllocFunc, vector_free_func wFreeFunc)
-	: Vector<complex>(data, data + start, data + start + span, wAllocFunc, wFreeFunc),
+signalVector::signalVector(complex *data, size_t start, size_t span)
+	: Vector<complex>(NULL, data + start, data + start + span),
 	  real(false), aligned(false), symmetry(NONE)
 {
 }
@@ -41,14 +41,7 @@ signalVector::signalVector(const signalVector &vector,
 void signalVector::operator=(const signalVector& vector)
 {
 	resize(vector.size() + vector.getStart());
-
-	unsigned int i;
-	complex *dst = mData;
-	complex *src = vector.mData;
-	for (i = 0; i < size(); i++, src++, dst++)
-		*dst = *src;
-	/* TODO: optimize for non non-trivially copyable types: */
-	/*memcpy(mData, vector.mData, bytes()); */
+	memcpy(mData, vector.mData, bytes());
 	mStart = mData + vector.getStart();
 }
 
@@ -65,13 +58,8 @@ size_t signalVector::getStart() const
 size_t signalVector::updateHistory()
 {
 	size_t num = getStart();
-	unsigned int i;
-	complex *dst = mData;
-	complex *src = mStart + this->size() - num;
-	for (i = 0; i < num; i++, src++, dst++)
-		*dst = *src;
-	/* TODO: optimize for non non-trivially copyable types: */
-	/*memmove(mData, mStart + this->size() - num, num * sizeof(complex)); */
+
+	memmove(mData, mStart + this->size() - num, num * sizeof(complex));
 
 	return num;
 }

Transceiver52M/signalVector.h

@@ -13,13 +13,13 @@ enum Symmetry {
 class signalVector: public Vector<complex> {
 public:
 	/** Default constructor */
-	signalVector(size_t size = 0, vector_alloc_func wAllocFunc = NULL, vector_free_func wFreeFunc = NULL);
+	signalVector(size_t size = 0);
 
 	/** Construct with head room */
-	signalVector(size_t size, size_t start, vector_alloc_func wAllocFunc = NULL, vector_free_func wFreeFunc = NULL);
+	signalVector(size_t size, size_t start);
 
 	/** Construct from existing buffer data (buffer not managed) */
-	signalVector(complex *data, size_t start, size_t span, vector_alloc_func wAllocFunc = NULL, vector_free_func wFreeFunc = NULL);
+	signalVector(complex *data, size_t start, size_t span);
 
 	/** Construct by from existing vector */
 	signalVector(const signalVector &vector);