osmo-trx/utils/prbs-tool.c

/* Dummy TRX for sening PRBS test sequences into osmo-bts-trx to test
 * the decoder/receiver processing in osmo-bts-trx as well as any
 * additional PRBS testing code.
 *
 * The purpose of this program is to use it as a mock dummy MS-side
 * transmitter of GSM bursts that contain encoded PRBS sequences,
 * similar to what one would normally do with an arbitrary
 * function/waveform generator or BERT tester in hardware.
 *
 * (C) 2017 by Harald Welte <laforge@gnumonks.org>
 * All Rights Reserved
 *
 * Licensed under terms of the GNU Generral Public License, Version 2,
 * or (at your option) any later version.
 */

#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <unistd.h>

#include <netinet/in.h>

#include <osmocom/core/bits.h>
#include <osmocom/core/utils.h>
#include <osmocom/core/prbs.h>
#include <osmocom/core/socket.h>
#include <osmocom/gsm/gsm_utils.h>
#include <osmocom/coding/gsm0503_coding.h>

/***********************************************************************
 * GSM Constants
 ***********************************************************************/

#define GSM_FR_BYTES	33
#define GSM_BURST_BITS	116
#define GSM_4BURST_BITS	(GSM_BURST_BITS*4)
#define GSM_BURST_LEN	148


/***********************************************************************
 * TRX Interface / Protocol
 ***********************************************************************/

#define TRX_BASE_PORT	5700
/* DATA port on the TRX side */
#define	TRX_PORT_CTRL_TRX(C) 	(TRX_BASE_PORT+(2*(C))+1)
#define	TRX_PORT_DATA_TRX(C) 	(TRX_BASE_PORT+(2*(C))+2)
#define	TRX_PORT_CTRL_BTS(C) 	(TRX_PORT_CTRL_TRX(C)+100)
#define	TRX_PORT_DATA_BTS(C) 	(TRX_PORT_DATA_TRX(C)+100)

struct trx_ul_msg {
	uint8_t		ts;
	uint32_t	fn;
	uint8_t		rssi;
	uint16_t	t_offs;
	uint8_t		bits[148];	/* 0..255, *NOT* sbit_t */
} __attribute__((packed));

struct trx_dl_msg {
	uint8_t		ts;
	uint32_t	fn;
	uint8_t		att_db;
	ubit_t		bits[148];
} __attribute__((packed));


/***********************************************************************
 * Helper Functions
 ***********************************************************************/

static int ubits2trxbits(uint8_t *sbits, const ubit_t *ubits, unsigned int count)
{
	unsigned int i;

	for (i = 0; i < count; i++) {
		if ((*ubits++) & 1) {
			*sbits++ = 255;
		} else {
			*sbits++ = 0;
		}
	}

	return count;
}

static int __attribute__((__unused__)) dec(const ubit_t *bursts_u)
{
	sbit_t bursts_s[GSM_4BURST_BITS*2];
	uint8_t dec_tch_data[GSM_FR_BYTES];
	int n_errors, n_bits_total;
	int rc;

	/* convert from u_bit (tx) to s_bit (rx)  */
	osmo_ubit2sbit(bursts_s, bursts_u, sizeof(bursts_s));

	rc = gsm0503_tch_fr_decode(dec_tch_data, bursts_s, 1, 0, &n_errors, &n_bits_total);
	printf("rc=%d, n_errors=%d, n_bits_total=%d: %s\n", rc, n_errors, n_bits_total,
		osmo_hexdump(dec_tch_data, sizeof(dec_tch_data)));

	return rc;
}

/*! \brief Training Sequences (TS 05.02 Chapter 5.2.3) */
static const ubit_t _sched_tsc[8][26] = {
	{ 0,0,1,0,0,1,0,1,1,1,0,0,0,0,1,0,0,0,1,0,0,1,0,1,1,1, },
	{ 0,0,1,0,1,1,0,1,1,1,0,1,1,1,1,0,0,0,1,0,1,1,0,1,1,1, },
	{ 0,1,0,0,0,0,1,1,1,0,1,1,1,0,1,0,0,1,0,0,0,0,1,1,1,0, },
	{ 0,1,0,0,0,1,1,1,1,0,1,1,0,1,0,0,0,1,0,0,0,1,1,1,1,0, },
	{ 0,0,0,1,1,0,1,0,1,1,1,0,0,1,0,0,0,0,0,1,1,0,1,0,1,1, },
	{ 0,1,0,0,1,1,1,0,1,0,1,1,0,0,0,0,0,1,0,0,1,1,1,0,1,0, },
	{ 1,0,1,0,0,1,1,1,1,1,0,1,1,0,0,0,1,0,1,0,0,1,1,1,1,1, },
	{ 1,1,1,0,1,1,1,1,0,0,0,1,0,0,1,0,1,1,1,0,1,1,1,1,0,0, },
};

/***********************************************************************
 * state + processing functions
 ***********************************************************************/

/* state we have to keep for one physical channel */
struct pchan_data {
	/* PRBS state */
	struct osmo_prbs_state st;
	/* unpacked PRBS bits, generated from PRBS */
	ubit_t prbs_u[4+260];
	/* packed frame (to be sent) */
	uint8_t tch_data[GSM_FR_BYTES];
	/* burst bits (ubit) to be transmitted */
	ubit_t bursts[GSM_4BURST_BITS*2]; /* 116 * 8 */
	/* burst bits (sbit) 'as if received' */
	sbit_t bursts_s[GSM_4BURST_BITS*2];
	/* next to-be transmitted burst number */
	unsigned int burst_nr;
	/* training sequence code */
	unsigned int tsc;

	/* loose 'count' bursts every 'nth_mframe' on TRX-BTS interface */
	struct {
		unsigned int count;
		unsigned int nth_mframe;
	} sim_lost_bursts;

	/* zero 'count' bursts every 'nth_mframe' on TRX-BTS interface */
	struct {
		unsigned int count;
		unsigned int nth_mframe;
	} sim_zero_bursts;

	/* flip every 'nth_bit' of the PRNG oudput before encoding */
	struct {
		unsigned int nth_bit;
		unsigned int i;
	} sim_flip_codec_bits;

	unsigned int i;
};

struct ts_data {
	struct pchan_data pchan[2];
};

struct trx_data {
	struct ts_data ts[8];
};

static struct trx_data g_trx_data;

/* initialize the state for one TRX */
static void trx_data_init(struct trx_data *trx)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(trx->ts); i++) {
		struct ts_data *ts = &trx->ts[i];
		int j;
		for (j = 0; j < ARRAY_SIZE(ts->pchan); j++) {
			struct pchan_data *pchan = &ts->pchan[j];

			memset(pchan, 0, sizeof(*pchan));
			osmo_prbs_state_init(&pchan->st, &osmo_prbs9);
			pchan->tsc = 7;
		}
	}
}

/* apply any intentional errors to the output of the PRBS sequence */
static void apply_errors_prbs(struct pchan_data *pchan)
{
	int i;

	for (i = 0; i < sizeof(pchan->prbs_u)-4; i++) {
		pchan->sim_flip_codec_bits.i++;
		if (pchan->sim_flip_codec_bits.i == pchan->sim_flip_codec_bits.nth_bit) {
			pchan->sim_flip_codec_bits.i = 0;
			pchan->prbs_u[4+i] ^= 0x01;
		}
	}
}

/*! obtain the next to-be-transmitted burst for the given pchan
 *  \param pchan physical channel on which we operate
 *  \param[in] fn frame number
 *  \param[out] burst_out caller-provided buffer for 148 unpacked output bits
 *  \retruns number of bits stored in \a burst_out */
static int pchan_get_next_burst(struct pchan_data *pchan, uint32_t fn, ubit_t *burst_out)
{
	uint32_t fn26 = fn % 26;
	int rc;

	if (fn26 == 0 || fn26 == 4 || fn26 == 8 || fn26 == 13 || fn26 == 17 || fn26 == 21)
		pchan->burst_nr = 0;

	if (fn26 == 12 || fn26 == 25) {
		memset(burst_out, 0, GSM_BURST_LEN);
		return GSM_BURST_LEN;
	}

	if (pchan->burst_nr == 0) {
		/* generate PRBS output in ubit format, skipping first nibble for 260-264 padding */
		const uint8_t prefix[] = { 0xd0 };
		osmo_pbit2ubit(pchan->prbs_u, prefix, 4);
		rc = osmo_prbs_get_ubits(pchan->prbs_u+4, sizeof(pchan->prbs_u)-4, &pchan->st);
		OSMO_ASSERT(rc == sizeof(pchan->prbs_u)-4);

		apply_errors_prbs(pchan);

		/* pack to PBIT format */
		rc = osmo_ubit2pbit(pchan->tch_data, pchan->prbs_u, sizeof(pchan->prbs_u));
		//memset(pchan->tch_data, 0xff, sizeof(pchan->tch_data));

		printf("%s\n", osmo_hexdump(pchan->tch_data, GSM_FR_BYTES));

		/* shift buffer by 4 bursts for interleaving */
		memcpy(pchan->bursts, pchan->bursts + GSM_4BURST_BITS, GSM_4BURST_BITS);
		memset(pchan->bursts + GSM_4BURST_BITS, 0, GSM_4BURST_BITS);

		/* encode block (codec frame) into four bursts */
		rc = gsm0503_tch_fr_encode(pchan->bursts, pchan->tch_data, GSM_FR_BYTES, 1);
		OSMO_ASSERT(rc == 0);
#if 0
		int i;
		for (i = 0; i < sizeof(pchan->bursts); i += GSM_BURST_BITS)
			printf("\t%s\n", osmo_ubit_dump(pchan->bursts + i, GSM_BURST_BITS));

		dec(pchan->bursts);
#endif
	}

	/* for all bursts: format 148 symbols from 116 input bits */
	ubit_t *burst = pchan->bursts  + pchan->burst_nr * GSM_BURST_BITS;
//	printf("TX(%u): %s\n", pchan->burst_nr, osmo_ubit_dump(burst, GSM_BURST_BITS));
	memset(burst_out, 0, 3);		/* guard bits */
	memcpy(burst_out+3, burst, 58);		/* firrst half */
	memcpy(burst_out+61, _sched_tsc[pchan->tsc], 26);	/* midamble */
	memcpy(burst_out+87, burst+58, 58);	/* second half */
	memset(burst_out+145, 0, 3);		/* guard bits */

	/* increment burst number for next call */
	pchan->burst_nr += 1;

	return GSM_BURST_LEN;
}

static int pchan_process_ts_fn(struct pchan_data *pchan, uint32_t fn, uint8_t *burst_t)
{
	ubit_t burst_u[GSM_BURST_LEN];
	int rc;

	rc = pchan_get_next_burst(pchan, fn, burst_u);
	OSMO_ASSERT(rc == sizeof(burst_u));

	/* convert from u_bit (tx) to s_bit (rx)  */
	ubits2trxbits(burst_t, burst_u, GSM_BURST_LEN);

	return GSM_BURST_LEN;
}

/* read TRX DL data from BTS, write TRX UL data to BTS */
static int read_and_process(int fd)
{
	/* receive (downlink) buffer */
	uint8_t rx_dl_buf[1024];
	struct trx_dl_msg *dl_msg = (struct trx_dl_msg *) rx_dl_buf;
	/* transmit (uplink) buffer */
	uint8_t tx_ul_buf[1024];
	struct trx_ul_msg *ul_msg = (struct trx_ul_msg *) tx_ul_buf;
	/* other variables */
	struct pchan_data *pchan;
	uint32_t fn;
	uint8_t rc;

	/* do a blocking read on the socket and receive DL from BTS */
	rc = read(fd, rx_dl_buf, sizeof(rx_dl_buf));
	if (rc < sizeof(*dl_msg))
		return rc;

	fn = ntohl(dl_msg->fn);

	if (dl_msg->ts >= ARRAY_SIZE(g_trx_data.ts))
		return -ENODEV;

	if (dl_msg->ts != 2)
		return 0;

	printf("FN=%s TS=%u\n", gsm_fn_as_gsmtime_str(fn), dl_msg->ts);

	/* FIXME: second pchan for TCH/H */
	pchan = &g_trx_data.ts[dl_msg->ts].pchan[0];

	rc = pchan_process_ts_fn(pchan, fn, (uint8_t *) ul_msg->bits);
	OSMO_ASSERT(rc == sizeof(ul_msg->bits));

	/* copy over timeslot and frame number */
	ul_msg->fn = htonl(fn);
	ul_msg->ts = dl_msg->ts;

	/* simulate lost frames on TRX <-> BTS interface */
	if (pchan->sim_lost_bursts.count) {
		/* count number of 26-multiframes */
		static int count = 0;
		if (fn % 26 == 0)
			count++;

		/* every 10th multiframe, drop two entire block of 8 bursts */
		if (count % pchan->sim_lost_bursts.nth_mframe == 0 &&
		    (fn % 26) <= pchan->sim_lost_bursts.count) {
			printf("===> SKIPPING BURST\n");
			return 0;
		}
	}

	/* simulate zero-ed frames on TRX <-> BTS interface */
	if (pchan->sim_zero_bursts.count) {
		/* count number of 26-multiframes */
		static int count = 0;
		if (fn % 26 == 0)
			count++;

		/* every 10th multiframe, drop two entire block of 8 bursts */
		if (count % pchan->sim_zero_bursts.nth_mframe == 0 &&
		    (fn % 26) <= pchan->sim_zero_bursts.count) {
			memset(ul_msg->bits, 0, sizeof(ul_msg->bits));
			printf("===> ZEROING BURST\n");
		}
	}

	/* write uplink message towards BTS */
	rc = write(fd, tx_ul_buf, sizeof(*ul_msg));
	if (rc < sizeof(*ul_msg))
		return -EIO;

	return 0;
}

static int open_trx_data_sock(unsigned int trx_nr, const char *bts_host)
{
	int rc;

	rc = osmo_sock_init2(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, TRX_PORT_DATA_TRX(trx_nr),
				bts_host, TRX_PORT_DATA_BTS(trx_nr),
				OSMO_SOCK_F_CONNECT | OSMO_SOCK_F_BIND);
	return rc;
}


int main(int argc, char **argv)
{
	int fd;

	trx_data_init(&g_trx_data);

	//g_trx_data.ts[2].pchan[0].sim_zero_bursts.count = 8;
	//g_trx_data.ts[2].pchan[0].sim_zero_bursts.nth_mframe = 10;
	g_trx_data.ts[2].pchan[0].sim_flip_codec_bits.nth_bit = 260*4;

	fd = open_trx_data_sock(0, "127.0.0.1");
	if (fd < 0)
		exit(1);

	while (1) {
		read_and_process(fd);
	}

	return 0;
}