osmocom-analog/src/nmt/dms.c

/* NMT DMS (data service) processing
 *
 * (C) 2016 by Andreas Eversberg <jolly@eversberg.eu>
 * All Rights Reserved
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "../libsample/sample.h"
#include "../libdebug/debug.h"
#include "nmt.h"

#define MUTE_DURATION		0.300	/* 200ms, and about 95ms for the frame itself */

#define DMS_DOTTING		"101010101010101"
#define DMS_SYNC		"00101000111"

int dms_allow_loopback = 0;

/*
 * support
 */

/* calculate CRC from the bits of label and data and 16 zeroes.
 * the result is the remainder of the polynomial division and
 * conforms to DMS standard.
 */
static uint16_t crc16(uint8_t *bits, int len)
{
	uint16_t generator = 0x1021;
	uint16_t crc = 0; /* init crc register with 0 */
	int i;

	for (i = 0; i < len; i++) {
		/* check if MSB is set */
		if ((crc & 0x8000)) {   /* MSB set, shift it out of the register */
			/* shift in next bit of input stream */
			crc = (crc << 1) | bits[i];
			/* Perform the 'division' by XORing the crc register with the generator polynomial */
			crc = crc ^ generator;
		} else {   /* MSB not set, shift it out and shift in next bit of input stream. Same as above, just no division */
			crc = (crc << 1) | bits[i];
		}
	}

	return crc;
}

/*
 * frame handling
 */

/* print CT/DT frame in 8-bit or 7-bit mode. */
static const char *print_ct_dt(uint8_t s, uint8_t n, uint8_t *data, int eight_bits)
{
	static char text[128], *ct;

	if (s)
		ct = "    ";
	else switch (data[0]) {
	case 0:
		ct = "IDLE";
		break;
	case 73:
		ct = "ID  ";
		break;
	case 82:
		ct = "RAND";
		break;
	case 84:
		ct = "CT84";
		break;
	default:
		ct = "????";
	}

	if (!eight_bits || s == 0)
		sprintf(text, "%cT(%d) = %s %3d %3d %3d %3d %3d %3d %3d %3d", 'C' + s, n, ct, data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
	else
		sprintf(text, "%cT(%d) = %s 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x", 'C' + s, n, ct,
			((data[0] << 1) & 0x80) | data[1],
			((data[0] << 2) & 0x80) | data[2],
			((data[0] << 3) & 0x80) | data[3],
			((data[0] << 4) & 0x80) | data[4],
			((data[0] << 5) & 0x80) | data[5],
			((data[0] << 6) & 0x80) | data[6],
			((data[0] << 7) & 0x80) | data[7]);

	return text;
}

/* link DMS frame to list of TX frames */
void link_dms_frame(nmt_t *nmt, struct dms_frame *frame)
{
	dms_t *dms = &nmt->dms;
	struct dms_frame **framep;

	PDEBUG(DDMS, DEBUG_DEBUG, "link DMS frame\n");

	/* attach to end of list */
	framep = &dms->state.frame_list;
	while (*framep)
		framep = &((*framep)->next);
	*framep = frame;
}

/* unlink DMS frame from list of TX frames */
void unlink_dms_frame(nmt_t *nmt, struct dms_frame *frame)
{
	dms_t *dms = &nmt->dms;
	struct dms_frame **framep;

	PDEBUG(DDMS, DEBUG_DEBUG, "unlink DMS frame\n");

	/* unlink */
	framep = &dms->state.frame_list;
	while (*framep && *framep != frame)
		framep = &((*framep)->next);
	if (!(*framep)) {
		PDEBUG(DTRANS, DEBUG_ERROR, "Frame not in list, please fix!!\n");
		abort();
	}
	*framep = frame->next;
}

/* add DMS frame to list of TX frames */
static void dms_frame_add(nmt_t *nmt, int s, const uint8_t *data)
{
	dms_t *dms = &nmt->dms;
	struct dms_frame *dms_frame;

	dms_frame = calloc(1, sizeof(*dms_frame));
	if (!dms_frame) {
		PDEBUG(DDMS, DEBUG_ERROR, "No memory!\n");
			return;
	}

	dms_frame->s = s;
	dms_frame->n = dms->state.n_count;
	dms->state.n_count = (dms->state.n_count + 1) & 7;
	memcpy(dms_frame->data, data, 8);

	PDEBUG(DDMS, DEBUG_DEBUG, "add DMS %cT(%d) frame to queue\n", dms_frame->s + 'C', dms_frame->n);

	link_dms_frame(nmt, dms_frame);
}

/* delete DMS frame from list of TX frames */
static void dms_frame_delete(nmt_t *nmt, struct dms_frame *dms_frame)
{
	PDEBUG(DDMS, DEBUG_DEBUG, "delete DMS frame %cT(%d) from queue\n", dms_frame->s + 'C', dms_frame->n);

	unlink_dms_frame(nmt, dms_frame);

	free(dms_frame);
}

/* add DT frame */
static void dms_frame_add_dt(nmt_t *nmt, const uint8_t *data)
{
	dms_frame_add(nmt, 1, data);
}

/* add CT frame */
static void dms_frame_add_ct(nmt_t *nmt, const uint8_t *data)
{
	dms_frame_add(nmt, 0, data);
}

/* add ID frame */
static void dms_frame_add_id(nmt_t *nmt)
{
	uint8_t frame[8];

	frame[0] = 73; /* ID */
	frame[1] = 3; // FIXME: add real id
	frame[2] = 0;
	frame[3] = 0;
	frame[4] = 0;
	frame[5] = 0;
	frame[6] = 0;
	frame[7] = 0;
	dms_frame_add_ct(nmt, frame);
}

/* add RAND frame */
static void dms_frame_add_rand(nmt_t *nmt, int eight_bits)
{
	uint32_t rand = random();
	uint8_t frame[8];

	frame[0] = 82; /* RAND */
	frame[1] = (rand >> 17) & 0x40;
	frame[2] = (rand >> 16) & 0x7f;
	frame[3] = (rand >> 9) & 0x40;
	frame[4] = (rand >> 8) & 0x7f;
	frame[5] = (rand >> 1) & 0x40;
	frame[6] = rand & 0x7f;
	frame[7] = eight_bits ? '8' : '7';
	dms_frame_add_ct(nmt, frame);
}

/*
 * init and exit
 */

/* init instance */
int dms_init_sender(nmt_t __attribute__((unused)) *nmt)
{
	/* we need some simple random */
	srandom((unsigned int)(get_time() * 1000));

	return 0;
}

/* Cleanup transceiver instance. */
void dms_cleanup_sender(nmt_t *nmt)
{
	dms_reset(nmt);
}

/*
 * transmission of frames
 */

/* encode DT frame and schedule for next transmission */
static void dms_encode_dt(nmt_t *nmt, uint8_t d, uint8_t s, uint8_t n, uint8_t *_data)
{
	dms_t *dms = &nmt->dms;
	char frame[127];
	uint8_t data[12];
	uint8_t bits[63 + 16];
	uint16_t crc;
	int i, j;

	PDEBUG(DDMS, DEBUG_INFO, "Sending DMS frame: %s\n", print_ct_dt(s, n, _data, dms->state.eight_bits));

	/* generate label */
	data[0] = (d << 6) | (s << 5) | (3 << 3) | n;
	memcpy(data + 1, _data, 8);
	for (i = 0; i < 9; i++) {
		for (j = 0; j < 7; j++)
			bits[i * 7 + j] = (data[i] >> (6 - j)) & 1;
	}
	for (i = 0; i < 16; i++)
		bits[63 + i] = 0;
	crc = crc16(bits, 63 + 16);
	data[9] = crc >> 9;
	data[10] = crc >> 2;
	data[11] = crc & 0x3;

	/* create RR frame */
	// FIXME: no dotting on consecutive frames
	memcpy(frame, DMS_DOTTING, 15);
	memcpy(frame + 15, DMS_SYNC, 11);
	for (i = 0; i < 11; i++) {
		for (j = 0; j < 7; j++)
			frame[26 + j + i*9] = ((data[i] >> (6 - j)) & 1) | '0';
		frame[26 + 7 + i*9] = '1';
		frame[26 + 8 + i*9] = '1';
	}
	frame[125] = ((data[11] >> 1) & 1) | '0';
	frame[126] = (data[11] & 1) | '0';
#if 0
	for (i = 0; i < 127; i++) {
		if (i == 15 || i == 26 || (i - 26) % 9 == 6 || (i - 26) % 9 == 8)
			printf(" ");
		printf("%c", frame[i]);
	}
	printf("\n");
#endif

	/* store frame */
	memcpy(dms->tx_frame, frame, 127);
	dms->tx_frame_length = 127;
	dms->tx_frame_pos = 0;
	dms->tx_frame_valid = 1;
}

/* encode RR frame and schedule for next transmission */
static void dms_encode_rr(nmt_t *nmt, uint8_t d, uint8_t s, uint8_t n)
{
	dms_t *dms = &nmt->dms;
	uint8_t data;
	char frame[77], label[9];
	int parity, i;

	/* generate label */
	data = (d << 6) | (s << 5) | (1 << 3) | n;
	parity = '0';
	for (i = 0; i < 7; i++) {
		label[i] = ((data >> (6 - i)) & 1) | '0';
		if (label[i] == '1')
			parity ^= 1;
	}
	label[7] = '1';
	label[8] = '1';

	/* create RR frame */
	memcpy(frame, DMS_DOTTING, 15);
	memcpy(frame + 15, DMS_SYNC, 11);
	memcpy(frame + 26, label, 9);
	memcpy(frame + 35, label, 9);
	frame[44] = parity; frame[45] = parity;
	memcpy(frame + 46, frame + 15, 31);
#if 0
	for (i = 0; i < 77; i++) {
		if (i == 15 || i == 26 || i == 33 || i == 35
		 || i == 42 || i == 44 || i == 46 || i == 57
		 || i == 64 || i == 66 || i == 73 || i == 75)
			printf(" ");
		printf("%c", frame[i]);
	}
	printf("\n");
#endif

	/* store frame */
	memcpy(dms->tx_frame, frame, 77);
	dms->tx_frame_length = 77;
	dms->tx_frame_pos = 0;
	dms->tx_frame_valid = 1;
}

/* check if we have to transmit a frame and render it
 * also do nothing until a currently transmitted frame is completely
 * transmitted.
 *
 * this function is public, so it can be used by test routine.
 */
void trigger_frame_transmission(nmt_t *nmt)
{
	dms_t *dms = &nmt->dms;
	struct dms_frame *dms_frame;
	int i;

	/* ongoing transmission, so we wait */
	if (dms->tx_frame_valid)
		return;

	/* check for RR first, because high priority */
	if (dms->state.send_rr) {
		PDEBUG(DDMS, DEBUG_DEBUG, "Found pending RR(%d) frame, sending.\n", dms->state.n_r);
		dms->state.send_rr = 0;
		dms_encode_rr(nmt, dms->state.dir ^ 1, 1, dms->state.n_r);
		return;
	}

	/* get next frame to send */
	/* loop 4 times, because only 4 unacked frames may be transmitted */
	dms_frame = dms->state.frame_list;
	for (i = 0; i < 4 && dms_frame; i++) {
		/* stop before DT frame, if RAND was not acked */
		if (dms_frame->next && dms_frame->next->s == 1 && !dms->state.established)
			break;
		if (dms_frame->n == dms->state.n_s)
			break;
		dms_frame = dms_frame->next;
	}

	/* check if outstanding frame */
	if (!dms_frame) {
		PDEBUG(DDMS, DEBUG_DEBUG, "No pending RR/CT/DT frame found.\n");
		if (dms->state.tx_pending) {
			dms->state.tx_pending = 0;
			dms_all_sent(nmt);
		}
		return;
	}

	PDEBUG(DDMS, DEBUG_DEBUG, "Found pending %cT(%d) frame, sending.\n", dms_frame->s + 'C', dms_frame->n);

	/* sent next send state to next frame in buffer.
	 * if there is no next frame, set it to the first frame (cycle).
	 * also if RAND was not acked, but next frame is DT, send first frame.
	 */
	if (!dms_frame->next) {
		dms->state.n_s = dms->state.frame_list->n;
		PDEBUG(DDMS, DEBUG_DEBUG, " -> Next sequence number is %d, because this was the last frame in queue.\n", dms->state.n_s);
	} else if (!dms->state.established && dms_frame->next->s == 1) {
		dms->state.n_s = dms->state.frame_list->n;
		PDEBUG(DDMS, DEBUG_DEBUG, " -> Next sequence number is %d, because this was the last frame before DT queue, and RAND has not been acked yet.\n", dms->state.n_s);
	} else if (i == 3) {
		dms->state.n_s = dms->state.frame_list->n;
		PDEBUG(DDMS, DEBUG_DEBUG, " -> Next sequence number is %d, because we reached max number of unacknowledged frames.\n", dms->state.n_s);
	} else if (!dms->state.established && dms_frame->next->s == 0) {
		dms->state.n_s = dms_frame->next->n;
		PDEBUG(DDMS, DEBUG_DEBUG, " -> Next sequence number is %d, because this is the next CT frame in queue.\n", dms->state.n_s);
	} else {
		dms->state.n_s = dms_frame->next->n;
		PDEBUG(DDMS, DEBUG_DEBUG, " -> Next sequence number is %d, because this is the next frame in queue.\n", dms->state.n_s);
	}

	dms_encode_dt(nmt, dms->state.dir ^ 1, dms_frame->s, dms_frame->n, dms_frame->data);
}

/* send data using FSK */
int dms_send_bit(nmt_t *nmt)
{
	dms_t *dms = &nmt->dms;

	if (!dms->tx_frame_valid)
		return -1;

	if (!dms->tx_frame_length || dms->tx_frame_pos == dms->tx_frame_length) {
		dms->tx_frame_valid = 0;
		trigger_frame_transmission(nmt);
		if (!dms->tx_frame_valid)
			return -1;
	}

	return dms->tx_frame[dms->tx_frame_pos++];
}

/*
 * reception of frames
 */

/* decode DT frame from mobile */
static void dms_rx_dt(nmt_t *nmt, uint8_t d, uint8_t s, uint8_t n, uint8_t *data)
{
	dms_t *dms = &nmt->dms;
	int length;

	/* start transfer */
	if (!dms->state.started) {
		PDEBUG(DDMS, DEBUG_INFO, "Starting DMS transfer (mobile originated)\n");
		dms->state.started = 1;
		dms->state.established = 0;
		dms->state.dir = d;
		dms->state.n_r = 0;
		dms->state.n_s = 0;
		dms->state.n_a = 0;
		dms->state.n_count = 0;
		dms->state.rand_sent = 0;
	}

	if (dms->state.dir != d && !dms_allow_loopback) {
		/* drop frames with wrong direction indicator */
		PDEBUG(DDMS, DEBUG_INFO, "DMS frame ignored, direction indicator missmatch!\n");
		return;
	}

	if (dms->state.n_r != n) {
		/* ignore out of sequence frames */
		PDEBUG(DDMS, DEBUG_DEBUG, "DMS frame number missmatch (due to resending)\n");
	} else {
		PDEBUG(DDMS, DEBUG_INFO, "Received valid DMS frame: %s\n", print_ct_dt(s, n, data, dms->state.eight_bits));

		/* cycle sequence */
		dms->state.n_r = (n + 1) % 8;

		/* CT frames */
		if (s == 0) {
			switch (data[0]) {
			case 73: /* ID */
				break;
			case 82: /* RAND */
				PDEBUG(DDMS, DEBUG_DEBUG, "RAND frame has been received, so we can send/receive DT frame\n");
				/* when we sent RAND, we do not resend it again, this would be wrong */
				if (!dms->state.rand_sent) {
					dms_frame_add_rand(nmt, data[7]);
					dms->state.rand_sent = 1;
				}
				dms->state.established = 1;
				dms->state.eight_bits = (data[7] == '8') ? 1 : 0;
				break;
			default:
				;
			}
		} else {
			if (!dms->state.established)
				PDEBUG(DDMS, DEBUG_NOTICE, "Received DT frame, but RAND frame has not been received yet\n");
			else {
				if (!dms->state.eight_bits)
					length = 8;
				else {
					int i;

					for (i = 1; i < 8; i++)
						data[i] |= ((data[0] << i) & 0x80);
					length = 7;
					data++;
				}
				/* according to NMT Doc 450-3 10.8 remove trailing zeroes */
				while (length > 1) {
					if (data[length - 1] == 0)
						length--;
					else
						break;
				}
				dms_receive(nmt, data, length, dms->state.eight_bits);
			}
		}
	}

	/* schedule sending of RR frame */
	dms->state.send_rr = 1;
	/* now trigger frame transmission */
	trigger_frame_transmission(nmt);
}

/* decode RR frame from mobile */
static void dms_rx_rr(nmt_t *nmt, uint8_t d, uint8_t s, uint8_t n)
{
	dms_t *dms = &nmt->dms;
	struct dms_frame *dms_frame, *dms_frame_next;
	int i, j;

	if (!dms->state.started)
		return;

	if (dms->state.dir != d && !dms_allow_loopback) {
		/* drop frames with wrong direction indicator */
		PDEBUG(DDMS, DEBUG_INFO, "DMS frame ignored, direction indicator missmatch!\n");
		return;
	}

	/* check to which entry in the list of frames this ack belongs to */
	/* loop 4 times, because only 4 unacked frames may have been transmitted */
	dms_frame = dms->state.frame_list;
	for (i = 0; i < 4 && dms_frame; i++) {
		if (dms_frame->n == ((n - 1) & 7))
			break;
		dms_frame = dms_frame->next;
	}

	/* if we don't find a frame, it must have been already acked, so we igore RR */
	if (!dms_frame || i == 4) {
		PDEBUG(DDMS, DEBUG_DEBUG, "Received already acked DMS frame: RR(%d) (s = %d), ignoring\n", n, s);
		return;
	}

	PDEBUG(DDMS, DEBUG_INFO, "Received valid DMS frame: RR(%d) (s = %d)\n", n, s);

	/* flush all acked frames. */
	dms_frame = dms->state.frame_list;
	for (j = 0; j <= i; j++) {
		if (dms_frame->data[0] == 82) { /* RAND */
			PDEBUG(DDMS, DEBUG_DEBUG, "RAND frame has been acknowledged, so we can continue to send DT frame\n");
			dms->state.established = 1;
		}
		/* increment ack counter */
		dms->state.n_a = (dms_frame->n + 1) & 7;
		/* raise send counter if required */
		if (dms->state.n_s == dms_frame->n) {
			dms->state.n_s = dms->state.n_a;
			PDEBUG(DDMS, DEBUG_DEBUG, "Raising next frame to send to #%d\n", dms->state.n_s);
		}
		PDEBUG(DDMS, DEBUG_DEBUG, "Removing acked frame #%d\n", dms_frame->n);
		dms_frame_next = dms_frame->next;
		dms_frame_delete(nmt, dms_frame);
		dms_frame = dms_frame_next;
	}

	/* now trigger frame transmission */
	trigger_frame_transmission(nmt);
}

/* decode NR frame from mobile */
static void dms_rx_nr(nmt_t *nmt, uint8_t d, uint8_t s, uint8_t n)
{
	dms_t *dms = &nmt->dms;

	if (!dms->state.started)
		return;

	if (dms->state.dir != d && !dms_allow_loopback) {
		/* drop frames with wrong direction indicator */
		PDEBUG(DDMS, DEBUG_INFO, "DMS frame ignored, direction indicator missmatch!\n");
		return;
	}

	PDEBUG(DDMS, DEBUG_INFO, "Received valid DMS frame: NR(%d) (s = %d)\n", n, s);

	// FIXME: support NR

	/* now trigger frame transmission */
	trigger_frame_transmission(nmt);
}

/* Check for DMS SYNC bits, then collect data bits */
void fsk_receive_bit_dms(nmt_t *nmt, int bit, double quality, double level)
{
	dms_t *dms = &nmt->dms;
//	double frames_elapsed;
	int i;

//	printf("bit=%d quality=%.4f\n", bit, quality);
	/* we always search for sync, because the sync cannot show up inside the message itself */
	dms->rx_sync = (dms->rx_sync << 1) | bit;

	/* sync level and quality */
	dms->rx_sync_level[dms->rx_sync_count & 0xff] = level;
	dms->rx_sync_quality[dms->rx_sync_count & 0xff] = quality;
	dms->rx_sync_count++;

	/* check if pattern 00101000111 matches */
	if ((dms->rx_sync & 0x07ff) == 0x0147) {
		/* average level and quality */
		level = quality = 0;
		for (i = 0; i < 16; i++) {
			level += dms->rx_sync_level[(dms->rx_sync_count - 1 - i) & 0xff];
			quality += dms->rx_sync_quality[(dms->rx_sync_count - 1 - i) & 0xff];
		}
		level /= 16.0; quality /= 16.0;
//		printf("DMS sync (level = %.2f, quality = %.2f\n", level, quality);

		/* do not accept garbage */
		if (quality < 0.65)
			return;

		PDEBUG(DDSP, DEBUG_DEBUG, "DMS sync  RX Level: %.0f%% Quality=%.0f\n", level * 100.0 + 0.5, quality * 100.0 + 0.5);

		/* rest sync register */
		dms->rx_sync = 0;
		dms->rx_in_sync = 1;
		dms->rx_frame_count = 0;
		dms->rx_bit_count = 0;
		memset(dms->rx_frame, 0, sizeof(dms->rx_frame));
		memset(dms->rx_frame_level, 0, sizeof(dms->rx_frame_level));
		memset(dms->rx_frame_quality, 0, sizeof(dms->rx_frame_quality));

		/* set muting of receive path */
		nmt->rx_mute = (int)((double)nmt->sender.samplerate * MUTE_DURATION);
		return;
	}

	if (!dms->rx_in_sync)
		return;

	/* read bits */
	if (++dms->rx_bit_count <= 7)
		dms->rx_frame[dms->rx_frame_count] = (dms->rx_frame[dms->rx_frame_count] << 1) | bit;
	dms->rx_frame_level[dms->rx_frame_count] += level;
	dms->rx_frame_quality[dms->rx_frame_count] += quality;

	/* check label */
	if (dms->rx_frame_count == 0) {
		if (dms->rx_bit_count == 9) {
			dms->rx_bit_count = 0;
			dms->rx_label.d = (dms->rx_frame[0] >> 6) & 0x1;
			dms->rx_label.s = (dms->rx_frame[0] >> 5) & 0x1;
			dms->rx_label.p = (dms->rx_frame[0] >> 3) & 0x3;
			dms->rx_label.n = dms->rx_frame[0] & 0x7;
			PDEBUG(DDMS, DEBUG_DEBUG, "Got DMS label (d = %d, s = %d, p = %d, n = %d)\n", dms->rx_label.d,dms->rx_label.s,dms->rx_label.p,dms->rx_label.n);
			dms->rx_frame_count++;
			if (dms->rx_label.p == 0) {
				PDEBUG(DDMS, DEBUG_DEBUG, "Spare prefix '00' ignoring!\n");
				dms->rx_in_sync = 0;
			}
		}
		return;
	}

	if (dms->rx_label.p == 3) {
		/* read DT frame */
		if (dms->rx_frame_count <= 8) {
			if (dms->rx_bit_count == 9) {
				dms->rx_bit_count = 0;
				uint8_t c = dms->rx_frame[dms->rx_frame_count];
				PDEBUG(DDMS, DEBUG_DEBUG, "Got DMS word 0x%02x (%c)\n", c, (c >= 32 && c <= 126) ? c : '.');
				dms->rx_frame_count++;
			}
			return;
		}
		if (dms->rx_frame_count <= 10) {
			if (dms->rx_bit_count == 9) {
				dms->rx_bit_count = 0;
				PDEBUG(DDMS, DEBUG_DEBUG, "Got DMS CRC 0x%02x\n", dms->rx_frame[dms->rx_frame_count]);
				dms->rx_frame_count++;
			}
			return;
		}
		if (dms->rx_bit_count == 2) {
			uint16_t crc_got, crc_calc;
			uint8_t bits[63 + 16];
			int i, j;
			dms->rx_bit_count = 0;
			PDEBUG(DDMS, DEBUG_DEBUG, "Got DMS CRC 0x%x\n", dms->rx_frame[dms->rx_frame_count]);
			crc_got = (dms->rx_frame[9] << 9) | (dms->rx_frame[10] << 2) | dms->rx_frame[11];
			for (i = 0; i < 9; i++) {
				for (j = 0; j < 7; j++)
					bits[i * 7 + j] = (dms->rx_frame[i] >> (6 - j)) & 1;
			}
			for (i = 0; i < 16; i++)
				bits[63 + i] = 0;
			crc_calc = crc16(bits, 63 + 16);
			PDEBUG(DDMS, DEBUG_DEBUG, "DMS CRC = 0x%04x %s\n", crc_got, (crc_calc == crc_got) ? "(OK)" : "(CRC error)");
			if (crc_calc == crc_got)
				dms_rx_dt(nmt, dms->rx_label.d, dms->rx_label.s, dms->rx_label.n, dms->rx_frame + 1);
			dms->rx_in_sync = 0;
			return;
		}
		return;
	} else {
		/* read RR/NR frame */
		if (dms->rx_frame_count <= 1) {
			if (dms->rx_bit_count == 9) {
				dms->rx_bit_count = 0;
				if (dms->rx_frame[0] != dms->rx_frame[1]) {
					PDEBUG(DDMS, DEBUG_DEBUG, "Repeated DMS label missmatches!\n");
					dms->rx_in_sync = 0;
					return;
				}
				dms->rx_frame_count++;
				PDEBUG(DDMS, DEBUG_DEBUG, "Repeated label matches\n");
			}
			return;
		}
		if (dms->rx_bit_count == 2) {
			uint8_t parity_got, parity_calc = 0, bit;
			int i;
			dms->rx_bit_count = 0;
			parity_got = dms->rx_frame[2];
			PDEBUG(DDMS, DEBUG_DEBUG, "Got DMS parity 0x%x\n", dms->rx_frame[dms->rx_frame_count]);
			for (i = 0; i < 7; i++) {
				bit = (dms->rx_frame[0] >> i) & 1;
				if (bit)
					parity_calc ^= 0x3;
			}
			PDEBUG(DDMS, DEBUG_DEBUG, "DMS parity %s\n", (parity_calc == parity_got) ? "(OK)" : "(parity error)");
			if (parity_calc == parity_got) {
				if (dms->rx_label.p == 1)
					dms_rx_rr(nmt, dms->rx_label.d, dms->rx_label.s, dms->rx_label.n);
				else
					dms_rx_nr(nmt, dms->rx_label.d, dms->rx_label.s, dms->rx_label.n);
			}
			dms->rx_in_sync = 0;
			return;
		}
	}
}

/*
 * calls from upper layer
 */

/* recive data from upper layer to be sent as DT frames
 * the DT frames are generated */
void dms_send(nmt_t *nmt, const uint8_t *data, int length, int eight_bits)
{
	dms_t *dms = &nmt->dms;
	uint8_t frame[8];
	int i, copied;

	PDEBUG(DDMS, DEBUG_DEBUG, "Received message with %d digits of %d bits\n", length, (eight_bits) ? 8 : 7);

	/* active connection */
	if (dms->state.started) {
		if (dms->state.eight_bits != eight_bits) {
			PDEBUG(DDMS, DEBUG_ERROR, "DMS session active, but upper layer sends wrong bit format!\n");
			return;
		}
	}

	if (!dms->state.started) {
		PDEBUG(DDMS, DEBUG_DEBUG, "Transfer not started, so we send ID + RAND first\n");
		dms->state.started = 1;
		dms->state.established = 0;
		dms->state.eight_bits = eight_bits;
		dms->state.dir = 1; /* we send 0, we expect 1 */
		dms->state.n_r = 0;
		dms->state.n_s = 0;
		dms->state.n_a = 0;
		dms->state.n_count = 0;
		dms_frame_add_id(nmt);
		dms_frame_add_rand(nmt, eight_bits);
		dms->state.rand_sent = 1;
	}

	PDEBUG(DDMS, DEBUG_DEBUG, "Queueing message data as DT frames...\n");
	while (length) {
		if (eight_bits) {
			/* copy what we have */
			for (i = 1; i < 8 && length; i++) {
				frame[i] = *data++;
				length--;
			}
			copied = i - 1;
			/* padd with 0, if required */
			for (; i < 8; i++)
				frame[i] = 0;
			/* move the 8th bits to first character */
			frame[0] = 0;
			for (i = 1; i < 8; i++) {
				frame[0] |= (frame[i] & 0x80) >> i;
				frame[i] &= 0x7f;
			}
		} else {
			/* copy what we have */
			for (i = 0; i < 8 && length; i++) {
				frame[i] = (*data++) & 0x7f;
				length--;
			}
			copied = i;
			/* padd with 0, if required */
			for (; i < 8; i++)
				frame[i] = 0;
		}
		/* according to NMT Doc 450-3 10.8 trailing zeros are ignored.
		 * we put back the trailing zeros to the data buffer.
		 * except for a single zero, we keep it, because all digits
		 * 0 means a single zero is transmitted.
		 */
		for (i = 0; i < copied - 1; i++) {
			if (data[-1] == 0) {
				/* put back last take byte */
				data--;
				length++;
			}
		}
		dms_frame_add_dt(nmt, frame);
		/* indicate that we have pending data */
		dms->state.tx_pending = 1;
	}

	/* now trigger frame transmission */
	trigger_frame_transmission(nmt);
}

/* reset DMS instance */
void dms_reset(nmt_t *nmt)
{
	dms_t *dms = &nmt->dms;
	PDEBUG(DDMS, DEBUG_DEBUG, "Resetting DMS states\n");

	dms->rx_in_sync = 0;
	memset(&dms->state, 0, sizeof(dms->state));

	dms->tx_frame_valid = 0;

	while (dms->state.frame_list)
		dms_frame_delete(nmt, dms->state.frame_list);
}