--- a/rvinterf/Makefile	Wed Nov 20 06:25:05 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,23 +0,0 @@
-CC=	gcc
-CFLAGS=	-O2
-PROGS=	rvtdump
-XPROGS=	etmsend
-INSTBIN=/usr/local/bin
-
-RVTDUMP_OBJS=	log.o openport.o packetrx.o packettx.o rvtdump.o rvtdump_tx.o \
-		trdump.o
-
-all:	${PROGS} ${XPROGS}
-
-rvtdump:	${RVTDUMP_OBJS}
-	${CC} ${CFLAGS} -o $@ ${RVTDUMP_OBJS}
-
-etmsend:	etmsend.c
-	${CC} ${CFLAGS} -o $@ $@.c
-
-install:	${PROGS}
-	mkdir -p ${INSTBIN}
-	install -c ${PROGS} ${INSTBIN}
-
-clean:
-	rm -f *.o *.out *errs ${PROGS} ${XPROGS}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/README	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,89 @@
+I (Spacefalcon the Outlaw, FreeCalypso developer) am still learning what kinds
+of traffic may be passed across TI's RVTMUX binary-packet serial interface.  We
+already know that much of this traffic is debug trace output, i.e.,
+unidirectional and essentially unconditional output from the GSM device.  All
+of the "standard" firmwares we have (mokoN, our leo2moko which functions almost
+identically, and Pirelli's fw) produce massive volumes of such trace output in
+normal operation.  We already know that this "unsolicited" trace output comes
+in at least 3 different flavors:
+
+* RiViera traces emitted by rvf_send_trace()
+* L1 traces
+* G23 traces
+
+The RVTMUX interface can be used for more than just trace output, though: any
+component in TI's fw suite can send and/or register to receive binary packets.
+As I slowly work my way through various components which comprise TI's Leonardo
+fw whose semi-source we use as our reference version, learning what they do and
+reintegrating them in our own gsm-fw, I will undoubtedly uncover additional uses
+to which the RVTMUX interface is put.
+
+Aside from the trivial provision in the RVT module itself whereby an external
+host can send a command to the target to set a filter masking some of the RV
+trace output, so far the only entity I've come across which accepts packets from
+an external host is ETM (Enhanced Test Mode).  ETM implements a registration
+system of its own, whereby other modules can register with ETM to receive
+certain external command messages passing first through RVT, then through ETM.
+
+Because I do not yet have a clear mental picture of *every* function for which
+the RVTMUX interface will ever be used, it is correspondingly impractical to
+decide on a once-and-for-all design of what the host-side software for talking
+to this interface should be like.  Therefore, it is currently premature to
+expect any stability in the present rvinterf subdirectory of freecalypso-sw; I
+may implement something one day, then toss it away the next day (without
+providing much in the way of backward compatibility) when I come up with some
+other idea.
+
+The current roadmap for what the rvinterf suite of host tools is envisioned to
+look like eventually is as follows:
+
+rvtdump		Opens the serial port, decodes TI's binary packet protocol, and
+		simply dumps every received/decoded packet on stdout in a human-
+		readable form.  No provision for sending anything to the target.
+		Intended use: observing the debug trace output which all TI
+		firmwares emit as standard "background noise".  This utility has
+		already been written, and it allows one to observe/log/study the
+		"noise" that appears on Pirelli's USB-serial port (running
+		Pirelli's original fw), as well as that emitted on the IrDA
+		(headset jack) port on the GTA02 by mokoN/leo2moko firmwares.
+
+rvinterf	My plan is to make a copy of rvtdump, called rvinterf, and have
+		it act very much like rvtdump: receive TI's packets from the
+		serial port, decode them and print the decoded form on stdout.
+		However, rvinterf will also create a listening UNIX domain
+		socket to which other programs in the present suite will
+		connect.  These other programs connecting through rvinterf will
+		be able to send packets to the target, as well as register to
+		receive certain kinds of target->host message packets.
+
+fc-tmsh		FreeCalypso Test Mode Shell is my vision for the utility which
+		will provide a practically usable interface to ETM.  ETM's
+		general mode of operation seems to be (weasel phrase inserted
+		because many other fw components may connect through ETM, and I
+		have yet to study all of them) command-response: an external
+		host sends a command to ETM, that command gets dispatched to the
+		proper registered handler, the command function is executed, a
+		response packet is composed, and finally that response is sent
+		back to the host.  But because all code on the target side is
+		under active development and debugging, we should not expect
+		perfect lock-step behaviour on the interface; instead, our
+		fc-tmsh should be fundamentally asynchronous: when the user
+		enters a command, the appropriate command packet is sent to the
+		target, but we are prepared for target->host messages at any
+		time, without enforcing strict correspondence to issued
+		commands: let the developer-operator sort that out instead.
+
+The usage scenario I envision is that one will need to run rvinterf first
+(either directly or through fc-xram) in one terminal window, leave it running,
+then run fc-tmsh in another terminal window, and have it connect to rvinterf
+via the local UNIX domain socket interface.  Why such complexity, why not have
+one program do everything?  I suspect that in many debug/experimentation
+sessions it will be necessary to use fc-tmsh on "noisy" targets, i.e., in
+scenarios where the target is continuously spewing its "normal" voluminous debug
+trace output, such that the "interesting" output as in responses to commands
+gets drowned in the noise.  In such a scenario it would be helpful to have one
+terminal window in which one sees the transcript of the fc-tmsh session,
+consisting of issued commands and received ETM responses without the general
+noise, and another window in which one sees all RVTMUX interface activity in
+real time - the latter would allow one to observe commands having side effects
+outside of ETM, such as crashing the whole fw. :-)

--- a/rvinterf/etmsend.c	Wed Nov 20 06:25:05 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,79 +0,0 @@
-/*
- * This program is a hack that sends a hand-crafted ETM packet
- * to the UNIX-local dgram socket established by rvtdump with -s option.
- */
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <stdio.h>
-#include <string.h>
-#include <strings.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include "pktmux.h"
-#include "txpkt.h"
-
-char sockpath[] = "/tmp/rvt_send_socket";
-
-u_char packet[MAX_PKT_TO_TARGET];
-int payload_len;
-
-main(argc, argv)
-	char **argv;
-{
-	int i, c, s;
-	struct sockaddr_un local;
-	unsigned int namelen;
-
-	if (argc < 2) {
-		fprintf(stderr, "usage: %s hexbytes...\n", argv[0]);
-		exit(1);
-	}
-	payload_len = argc - 1;
-	if (payload_len > MAX_PKT_TO_TARGET-2) {
-		fprintf(stderr,
-			"%s: too many bytes (packet length limit exceeded)\n",
-			argv[0]);
-		exit(1);
-	}
-
-	packet[0] = RVT_TM_HEADER;
-	for (i = 1; i <= payload_len; i++)
-		packet[i] = strtoul(argv[i], 0, 16);
-	c = 0;
-	for (i = 1; i <= payload_len; i++)
-		c ^= packet[i];
-	packet[payload_len+1] = c;
-
-	s = socket(AF_UNIX, SOCK_DGRAM, 0);
-	if (s < 0) {
-		perror("socket(AF_UNIX, SOCK_DGRAM, 0)");
-		exit(1);
-	}
-
-	local.sun_family = AF_UNIX;
-	strncpy(local.sun_path, sockpath, sizeof(local.sun_path));
-	local.sun_path[sizeof(local.sun_path) - 1] = '\0';
-
-	/* we use the same magic that X11 uses in Xtranssock.c for
-	 * calculating the proper length of the sockaddr */
-#if defined(BSD44SOCKETS) || defined(__UNIXWARE__)
-	local.sun_len = strlen(local.sun_path);
-#endif
-#if defined(BSD44SOCKETS) || defined(SUN_LEN)
-	namelen = SUN_LEN(&local);
-#else
-	namelen = strlen(local.sun_path) +
-		  offsetof(struct sockaddr_un, sun_path);
-#endif
-
-	i = sendto(s, packet, payload_len+2, 0,
-			(struct sockaddr *) &local, namelen);
-	if (i < 0) {
-		perror("sendto");
-		exit(1);
-	}
-
-	exit(0);
-}

--- a/rvinterf/log.c	Wed Nov 20 06:25:05 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,50 +0,0 @@
-/*
- * This module implements the logging function
- */
-
-#include <sys/types.h>
-#include <stdio.h>
-#include <string.h>
-#include <strings.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <time.h>
-
-extern char pr_item[];
-
-extern FILE *logF;
-extern time_t logtime;
-
-static struct tm last_tm;
-
-log_item()
-{
-	struct tm *curtm;
-
-	curtm = gmtime(&logtime);
-	if (curtm->tm_year != last_tm.tm_year ||
-	    curtm->tm_mon != last_tm.tm_mon ||
-	    curtm->tm_mday != last_tm.tm_mday)
-		fprintf(logF, "%d-%02d-%02d (gmtime):\n", curtm->tm_year + 1900,
-			curtm->tm_mon+1, curtm->tm_mday);
-	fprintf(logF, "[%02d:%02d:%02d] %s\n", curtm->tm_hour, curtm->tm_min,
-		curtm->tm_sec, pr_item);
-	bcopy(curtm, &last_tm, sizeof(struct tm));
-}
-
-log_sent_packet(pkt, pktlen)
-	u_char *pkt;
-{
-	int i;
-	char *dp;
-
-	dp = pr_item;
-	strcpy(dp, "Sent");
-	dp += 4;
-	for (i = 0; i < pktlen; i++) {
-		sprintf(dp, " %02X", pkt[i]);
-		dp += 3;
-	}
-	*dp = '\0';
-	print_item();
-}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/lowlevel/openport.c	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,82 @@
+/*
+ * This module takes care of opening the serial port and setting the
+ * proper "raw" termios modes, including the baud rate.
+ */
+
+#include <sys/types.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <termios.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <unistd.h>
+
+int target_fd;
+char *baudrate_name = "115200";
+
+static struct baudrate {
+	char	*name;
+	speed_t	termios_code;
+} baud_rate_table[] = {
+	{"19200",	B19200},
+	{"38400",	B38400},
+	{"57600",	B57600},
+	{"115200",	B115200},
+	/* non-standard high baud rates "remapped" by CP2102 usb2serial IC */
+	{"203125",	B230400},
+	{"406250",	B460800},
+	{"812500",	B921600},
+	/* table search terminator */
+	{NULL,		B0}
+};
+
+static speed_t
+get_baud_rate()
+{
+	struct baudrate *br;
+
+	for (br = baud_rate_table; br->name; br++)
+		if (!strcmp(br->name, baudrate_name))
+			break;
+	if (!br->name) {
+		fprintf(stderr, "baud rate \"%s\" unknown/unsupported\n",
+			baudrate_name);
+		exit(1);
+	}
+	return br->termios_code;
+}
+
+open_target_serial(ttydev)
+	char *ttydev;
+{
+	struct termios target_termios;
+	speed_t br_code;
+
+	br_code = get_baud_rate();
+	target_fd = open(ttydev, O_RDWR|O_NONBLOCK);
+	if (target_fd < 0) {
+		perror(ttydev);
+		exit(1);
+	}
+	target_termios.c_iflag = IGNBRK;
+	target_termios.c_oflag = 0;
+	target_termios.c_cflag = CLOCAL|HUPCL|CREAD|CS8;
+	target_termios.c_lflag = 0;
+	target_termios.c_cc[VMIN] = 1;
+	target_termios.c_cc[VTIME] = 0;
+	cfsetispeed(&target_termios, br_code);
+	cfsetospeed(&target_termios, br_code);
+	if (tcsetattr(target_fd, TCSAFLUSH, &target_termios) < 0) {
+		perror("initial tcsetattr on target");
+		exit(1);
+	}
+	return 0;
+}
+
+set_serial_nonblock(state)
+	int state;
+{
+	ioctl(target_fd, FIONBIO, &state);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/lowlevel/packetrx.c	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,88 @@
+/*
+ * This module handles the lowest level of serial packet Rx
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "pktmux.h"
+
+extern int target_fd;
+
+#define	MAXPKT	512
+u_char rxpkt[MAXPKT];
+size_t rxpkt_len;
+
+extern char pr_item[];
+
+static int in_pkt, dle_state, toobig;
+
+static void
+process_inbyte(inb)
+{
+	if (!in_pkt) {
+		if (inb != STX || dle_state) {
+			rxpkt_len++;
+			dle_state = (inb == DLE);
+			return;
+		}
+		if (rxpkt_len) {
+			sprintf(pr_item,
+				"Warning: Rx %u byte%s outside of a packet",
+				(unsigned)rxpkt_len, rxpkt_len != 1 ? "s" : "");
+			print_item();
+			rxpkt_len = 0;
+		}
+		in_pkt = 1;
+		toobig = 0;
+		return;
+	}
+	if (dle_state) {
+		dle_state = 0;
+		if (inb != STX && inb != DLE) {
+			sprintf(pr_item,
+				"Rx framing error: %02X after DLE\n", inb);
+			print_item();
+			in_pkt = 0;
+			rxpkt_len = 0;
+			return;
+		}
+		goto data;
+	}
+	if (inb == DLE) {
+		dle_state = 1;
+		return;
+	} else if (inb == STX) {
+		if (!rxpkt_len)
+			return;
+		in_pkt = 0;
+		handle_rx_packet();
+		rxpkt_len = 0;
+		return;
+	}
+data:	if (rxpkt_len >= MAXPKT) {
+		if (!toobig) {
+			sprintf(pr_item, "Error: Rx packet too big!\n");
+			print_item();
+			toobig = 1;
+		}
+		return;
+	}
+	rxpkt[rxpkt_len++] = inb;
+}
+
+void
+process_serial_rx()
+{
+	u_char rdbuf[512];
+	int cc, i;
+
+	cc = read(target_fd, rdbuf, sizeof rdbuf);
+	if (cc <= 0) {
+		perror("Error/EOF reading from target");
+		exit(1);
+	}
+	for (i = 0; i < cc; i++)
+		process_inbyte(rdbuf[i]);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/lowlevel/packettx.c	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,32 @@
+/*
+ * This module handles the lowest level of serial packet Tx
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "pktmux.h"
+#include "txpkt.h"
+
+extern int target_fd;
+
+send_pkt_to_target(pkt, pktlen)
+	u_char *pkt;
+{
+	u_char buf[MAX_PKT_TO_TARGET*2+2];
+	u_char *cp, *dp, *endp;
+	int c;
+
+	endp = pkt + pktlen;
+	dp = buf;
+	*dp++ = STX;
+	for (cp = pkt; cp < endp; cp++) {
+		c = *cp;
+		if (c == STX || c == DLE)
+			*dp++ = DLE;
+		*dp++ = c;
+	}
+	*dp++ = STX;
+	write(target_fd, buf, dp - buf);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/old/Makefile	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,23 @@
+CC=	gcc
+CFLAGS=	-O2
+PROGS=	rvtdump
+XPROGS=	etmsend
+INSTBIN=/usr/local/bin
+
+RVTDUMP_OBJS=	log.o openport.o packetrx.o packettx.o rvtdump.o rvtdump_tx.o \
+		trdump.o
+
+all:	${PROGS} ${XPROGS}
+
+rvtdump:	${RVTDUMP_OBJS}
+	${CC} ${CFLAGS} -o $@ ${RVTDUMP_OBJS}
+
+etmsend:	etmsend.c
+	${CC} ${CFLAGS} -o $@ $@.c
+
+install:	${PROGS}
+	mkdir -p ${INSTBIN}
+	install -c ${PROGS} ${INSTBIN}
+
+clean:
+	rm -f *.o *.out *errs ${PROGS} ${XPROGS}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/old/etmsend.c	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,79 @@
+/*
+ * This program is a hack that sends a hand-crafted ETM packet
+ * to the UNIX-local dgram socket established by rvtdump with -s option.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "pktmux.h"
+#include "txpkt.h"
+
+char sockpath[] = "/tmp/rvt_send_socket";
+
+u_char packet[MAX_PKT_TO_TARGET];
+int payload_len;
+
+main(argc, argv)
+	char **argv;
+{
+	int i, c, s;
+	struct sockaddr_un local;
+	unsigned int namelen;
+
+	if (argc < 2) {
+		fprintf(stderr, "usage: %s hexbytes...\n", argv[0]);
+		exit(1);
+	}
+	payload_len = argc - 1;
+	if (payload_len > MAX_PKT_TO_TARGET-2) {
+		fprintf(stderr,
+			"%s: too many bytes (packet length limit exceeded)\n",
+			argv[0]);
+		exit(1);
+	}
+
+	packet[0] = RVT_TM_HEADER;
+	for (i = 1; i <= payload_len; i++)
+		packet[i] = strtoul(argv[i], 0, 16);
+	c = 0;
+	for (i = 1; i <= payload_len; i++)
+		c ^= packet[i];
+	packet[payload_len+1] = c;
+
+	s = socket(AF_UNIX, SOCK_DGRAM, 0);
+	if (s < 0) {
+		perror("socket(AF_UNIX, SOCK_DGRAM, 0)");
+		exit(1);
+	}
+
+	local.sun_family = AF_UNIX;
+	strncpy(local.sun_path, sockpath, sizeof(local.sun_path));
+	local.sun_path[sizeof(local.sun_path) - 1] = '\0';
+
+	/* we use the same magic that X11 uses in Xtranssock.c for
+	 * calculating the proper length of the sockaddr */
+#if defined(BSD44SOCKETS) || defined(__UNIXWARE__)
+	local.sun_len = strlen(local.sun_path);
+#endif
+#if defined(BSD44SOCKETS) || defined(SUN_LEN)
+	namelen = SUN_LEN(&local);
+#else
+	namelen = strlen(local.sun_path) +
+		  offsetof(struct sockaddr_un, sun_path);
+#endif
+
+	i = sendto(s, packet, payload_len+2, 0,
+			(struct sockaddr *) &local, namelen);
+	if (i < 0) {
+		perror("sendto");
+		exit(1);
+	}
+
+	exit(0);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/old/log.c	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,50 @@
+/*
+ * This module implements the logging function
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+
+extern char pr_item[];
+
+extern FILE *logF;
+extern time_t logtime;
+
+static struct tm last_tm;
+
+log_item()
+{
+	struct tm *curtm;
+
+	curtm = gmtime(&logtime);
+	if (curtm->tm_year != last_tm.tm_year ||
+	    curtm->tm_mon != last_tm.tm_mon ||
+	    curtm->tm_mday != last_tm.tm_mday)
+		fprintf(logF, "%d-%02d-%02d (gmtime):\n", curtm->tm_year + 1900,
+			curtm->tm_mon+1, curtm->tm_mday);
+	fprintf(logF, "[%02d:%02d:%02d] %s\n", curtm->tm_hour, curtm->tm_min,
+		curtm->tm_sec, pr_item);
+	bcopy(curtm, &last_tm, sizeof(struct tm));
+}
+
+log_sent_packet(pkt, pktlen)
+	u_char *pkt;
+{
+	int i;
+	char *dp;
+
+	dp = pr_item;
+	strcpy(dp, "Sent");
+	dp += 4;
+	for (i = 0; i < pktlen; i++) {
+		sprintf(dp, " %02X", pkt[i]);
+		dp += 3;
+	}
+	*dp = '\0';
+	print_item();
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/old/openport.c	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,82 @@
+/*
+ * This module takes care of opening the serial port and setting the
+ * proper "raw" termios modes, including the baud rate.
+ */
+
+#include <sys/types.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <termios.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <unistd.h>
+
+int target_fd;
+char *baudrate_name = "115200";
+
+static struct baudrate {
+	char	*name;
+	speed_t	termios_code;
+} baud_rate_table[] = {
+	{"19200",	B19200},
+	{"38400",	B38400},
+	{"57600",	B57600},
+	{"115200",	B115200},
+	/* non-standard high baud rates "remapped" by CP2102 usb2serial IC */
+	{"203125",	B230400},
+	{"406250",	B460800},
+	{"812500",	B921600},
+	/* table search terminator */
+	{NULL,		B0}
+};
+
+static speed_t
+get_baud_rate()
+{
+	struct baudrate *br;
+
+	for (br = baud_rate_table; br->name; br++)
+		if (!strcmp(br->name, baudrate_name))
+			break;
+	if (!br->name) {
+		fprintf(stderr, "baud rate \"%s\" unknown/unsupported\n",
+			baudrate_name);
+		exit(1);
+	}
+	return br->termios_code;
+}
+
+open_target_serial(ttydev)
+	char *ttydev;
+{
+	struct termios target_termios;
+	speed_t br_code;
+
+	br_code = get_baud_rate();
+	target_fd = open(ttydev, O_RDWR|O_NONBLOCK);
+	if (target_fd < 0) {
+		perror(ttydev);
+		exit(1);
+	}
+	target_termios.c_iflag = IGNBRK;
+	target_termios.c_oflag = 0;
+	target_termios.c_cflag = CLOCAL|HUPCL|CREAD|CS8;
+	target_termios.c_lflag = 0;
+	target_termios.c_cc[VMIN] = 1;
+	target_termios.c_cc[VTIME] = 0;
+	cfsetispeed(&target_termios, br_code);
+	cfsetospeed(&target_termios, br_code);
+	if (tcsetattr(target_fd, TCSAFLUSH, &target_termios) < 0) {
+		perror("initial tcsetattr on target");
+		exit(1);
+	}
+	return 0;
+}
+
+set_serial_nonblock(state)
+	int state;
+{
+	ioctl(target_fd, FIONBIO, &state);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/old/packetrx.c	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,88 @@
+/*
+ * This module handles the lowest level of serial packet Rx
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "pktmux.h"
+
+extern int target_fd;
+
+#define	MAXPKT	512
+u_char rxpkt[MAXPKT];
+size_t rxpkt_len;
+
+extern char pr_item[];
+
+static int in_pkt, dle_state, toobig;
+
+static void
+process_inbyte(inb)
+{
+	if (!in_pkt) {
+		if (inb != STX || dle_state) {
+			rxpkt_len++;
+			dle_state = (inb == DLE);
+			return;
+		}
+		if (rxpkt_len) {
+			sprintf(pr_item,
+				"Warning: Rx %u byte%s outside of a packet",
+				(unsigned)rxpkt_len, rxpkt_len != 1 ? "s" : "");
+			print_item();
+			rxpkt_len = 0;
+		}
+		in_pkt = 1;
+		toobig = 0;
+		return;
+	}
+	if (dle_state) {
+		dle_state = 0;
+		if (inb != STX && inb != DLE) {
+			sprintf(pr_item,
+				"Rx framing error: %02X after DLE\n", inb);
+			print_item();
+			in_pkt = 0;
+			rxpkt_len = 0;
+			return;
+		}
+		goto data;
+	}
+	if (inb == DLE) {
+		dle_state = 1;
+		return;
+	} else if (inb == STX) {
+		if (!rxpkt_len)
+			return;
+		in_pkt = 0;
+		handle_rx_packet();
+		rxpkt_len = 0;
+		return;
+	}
+data:	if (rxpkt_len >= MAXPKT) {
+		if (!toobig) {
+			sprintf(pr_item, "Error: Rx packet too big!\n");
+			print_item();
+			toobig = 1;
+		}
+		return;
+	}
+	rxpkt[rxpkt_len++] = inb;
+}
+
+void
+process_serial_rx()
+{
+	u_char rdbuf[512];
+	int cc, i;
+
+	cc = read(target_fd, rdbuf, sizeof rdbuf);
+	if (cc <= 0) {
+		perror("Error/EOF reading from target");
+		exit(1);
+	}
+	for (i = 0; i < cc; i++)
+		process_inbyte(rdbuf[i]);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/old/packettx.c	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,32 @@
+/*
+ * This module handles the lowest level of serial packet Tx
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "pktmux.h"
+#include "txpkt.h"
+
+extern int target_fd;
+
+send_pkt_to_target(pkt, pktlen)
+	u_char *pkt;
+{
+	u_char buf[MAX_PKT_TO_TARGET*2+2];
+	u_char *cp, *dp, *endp;
+	int c;
+
+	endp = pkt + pktlen;
+	dp = buf;
+	*dp++ = STX;
+	for (cp = pkt; cp < endp; cp++) {
+		c = *cp;
+		if (c == STX || c == DLE)
+			*dp++ = DLE;
+		*dp++ = c;
+	}
+	*dp++ = STX;
+	write(target_fd, buf, dp - buf);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/old/pktmux.h	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,16 @@
+/*
+ * Definitions for the RVT MUX over-the-wire protocol
+ */
+
+#define	STX	0x02
+#define	DLE	0x10
+
+#define RVT_RV_HEADER        0x11
+#define RVT_L1_HEADER        0x12
+#define RVT_L23_HEADER       0x13
+#define RVT_TM_HEADER        0x14
+#define RVT_RNET_HEADER      0x15
+#define RVT_PROF_HEADER      0x16
+#define RVT_GTTBACK_HEADER   0x17
+#define RVT_OTHER_HEADER     0x18
+#define RVT_INVALID_HEADER   0xFF

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/old/rvtdump.c	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,123 @@
+/*
+ * This program reads bytes from a serial port, parses them assuming
+ * TI's RVT MUX format, and prints every decoded packet.
+ */
+
+#include <sys/types.h>
+#include <sys/errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <time.h>
+
+extern int target_fd;
+extern char *baudrate_name;
+
+extern char pr_item[];
+extern int sendsock_fd;
+
+char *logfname;
+FILE *logF;
+time_t logtime;
+int background, sendsock_enable;
+
+main(argc, argv)
+	char **argv;
+{
+	extern char *optarg;
+	extern int optind;
+	int c, maxfd;
+	fd_set fds;
+
+	while ((c = getopt(argc, argv, "bB:d:l:s")) != EOF)
+		switch (c) {
+		case 'b':
+			background++;
+			continue;
+		case 'B':
+			baudrate_name = optarg;
+			continue;
+		case 'd':
+			target_fd = atoi(optarg);
+			continue;
+		case 'l':
+			logfname = optarg;
+			continue;
+		case 's':
+			sendsock_enable++;
+			continue;
+		case '?':
+		default:
+usage:			fprintf(stderr,
+			"usage: %s [options] ttyport\n", argv[0]);
+			exit(1);
+		}
+	if (background && !logfname) {
+		fprintf(stderr, "%s: -b is meaningless without -l\n", argv[0]);
+		exit(1);
+	}
+	if (target_fd <= 0) {
+		if (argc - optind != 1)
+			goto usage;
+		open_target_serial(argv[optind]);
+	}
+
+	set_serial_nonblock(0);
+	setlinebuf(stdout);
+	if (logfname) {
+		logF = fopen(logfname, "w");
+		if (!logF) {
+			perror(logfname);
+			exit(1);
+		}
+		fprintf(logF, "*** Log of decoded RVT output ***\n");
+		setlinebuf(logF);
+	}
+	if (sendsock_enable)
+		create_send_socket();
+	if (background) {
+		c = fork();
+		if (c < 0) {
+			perror("fork");
+			exit(1);
+		}
+		if (c) {
+			printf("rvtdump forked into background (pid %d)\n", c);
+			exit(0);
+		}
+	}
+	maxfd = target_fd;
+	if (sendsock_fd > maxfd)
+		maxfd = sendsock_fd;
+	for (;;) {
+		FD_ZERO(&fds);
+		FD_SET(target_fd, &fds);
+		if (sendsock_enable)
+			FD_SET(sendsock_fd, &fds);
+		c = select(maxfd+1, &fds, 0, 0, 0);
+		time(&logtime);
+		if (c < 0) {
+			if (errno == EINTR)
+				continue;
+			perror("select");
+			exit(1);
+		}
+		if (FD_ISSET(target_fd, &fds))
+			process_serial_rx();
+		if (FD_ISSET(sendsock_fd, &fds))
+			handle_sendsock();
+	}
+}
+
+handle_rx_packet()
+{
+	print_rx_packet();
+}
+
+print_item()
+{
+	if (!background)
+		printf("%s\n", pr_item);
+	if (logF)
+		log_item();
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/old/rvtdump_tx.c	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,70 @@
+/*
+ * This module contains the implementation of the Tx extension to rvtdump
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "txpkt.h"
+
+static char sockpath[] = "/tmp/rvt_send_socket";
+
+int sendsock_fd;
+u_char sendsock_pkt[MAX_PKT_TO_TARGET];
+int sendsock_pktlen;
+
+create_send_socket()
+{
+	/* local socket binding voodoo copied from osmocon */
+	struct sockaddr_un local;
+	unsigned int namelen;
+	int rc;
+
+	sendsock_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
+	if (sendsock_fd < 0) {
+		perror("socket(AF_UNIX, SOCK_DGRAM, 0)");
+		exit(1);
+	}
+
+	local.sun_family = AF_UNIX;
+	strncpy(local.sun_path, sockpath, sizeof(local.sun_path));
+	local.sun_path[sizeof(local.sun_path) - 1] = '\0';
+	unlink(local.sun_path);
+
+	/* we use the same magic that X11 uses in Xtranssock.c for
+	 * calculating the proper length of the sockaddr */
+#if defined(BSD44SOCKETS) || defined(__UNIXWARE__)
+	local.sun_len = strlen(local.sun_path);
+#endif
+#if defined(BSD44SOCKETS) || defined(SUN_LEN)
+	namelen = SUN_LEN(&local);
+#else
+	namelen = strlen(local.sun_path) +
+		  offsetof(struct sockaddr_un, sun_path);
+#endif
+
+	rc = bind(sendsock_fd, (struct sockaddr *) &local, namelen);
+	if (rc != 0) {
+		perror("bind on local dgram socket");
+		exit(1);
+	}
+
+	return(0);
+}
+
+handle_sendsock()
+{
+	sendsock_pktlen = recv(sendsock_fd, sendsock_pkt, MAX_PKT_TO_TARGET, 0);
+	if (sendsock_pktlen <= 0) {
+		fprintf(stderr, "return value from recv on socket: %d\n",
+			sendsock_pktlen);
+		exit(1);
+	}
+	send_pkt_to_target(sendsock_pkt, sendsock_pktlen);
+	log_sent_packet(sendsock_pkt, sendsock_pktlen);
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/old/trdump.c	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,169 @@
+/*
+ * This module implements the basic dump of any incoming packets
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include "pktmux.h"
+
+extern u_char rxpkt[];
+extern size_t rxpkt_len;
+
+char pr_item[4096];
+
+void
+print_rv_trace()
+{
+	int i, c;
+	char *dp;
+
+	dp = pr_item;
+	strcpy(dp, "RV ");
+	dp += 3;
+	/* the SWE static ID is sent MSB first */
+	for (i = 1; i <= 4; i++) {
+		sprintf(dp, "%02X", rxpkt[i]);
+		dp += 2;
+	}
+	/* severity level */
+	sprintf(dp, " %d ", rxpkt[5]);
+	dp = index(dp, '\0');
+	for (i = 6; i < rxpkt_len; i++) {
+		c = rxpkt[i];
+		if (c & 0x80) {
+			*dp++ = 'M';
+			*dp++ = '-';
+			c &= 0x7F;
+		}
+		if (c < 0x20) {
+			*dp++ = '^';
+			*dp++ = c + '@';
+		} else if (c == 0x7F) {
+			*dp++ = '^';
+			*dp++ = '?';
+		} else
+			*dp++ = c;
+	}
+	*dp = '\0';
+	print_item();
+}
+
+void
+print_l1_trace()
+{
+	int i, c;
+	char *dp;
+
+	dp = pr_item;
+	strcpy(dp, "L1: ");
+	dp += 4;
+	for (i = 1; i < rxpkt_len; i++) {
+		if ((i+1 < rxpkt_len) &&
+		    (rxpkt[i] == '\r' && rxpkt[i+1] == '\n' ||
+		     rxpkt[i] == '\n' && rxpkt[i+1] == '\r')) {
+			*dp = '\0';
+			print_item();
+			if (i+2 == rxpkt_len)
+				return;
+			dp = pr_item;
+			*dp++ = '+';
+			*dp++ = ' ';
+			i++;
+			continue;
+		}
+		c = rxpkt[i];
+		if (c & 0x80) {
+			*dp++ = 'M';
+			*dp++ = '-';
+			c &= 0x7F;
+		}
+		if (c < 0x20) {
+			*dp++ = '^';
+			*dp++ = c + '@';
+		} else if (c == 0x7F) {
+			*dp++ = '^';
+			*dp++ = '?';
+		} else
+			*dp++ = c;
+	}
+	/* will get here only if no newline sequence at the end */
+	*dp = '\0';
+	print_item();
+}
+
+void
+print_g23_trace()
+{
+	int i;
+	char *dp;
+
+	dp = pr_item;
+	strcpy(dp, "G23:");
+	dp += 4;
+	for (i = 1; i < rxpkt_len; i++) {
+		sprintf(dp, " %02X", rxpkt[i]);
+		dp += 3;
+	}
+	*dp = '\0';
+	print_item();
+}
+
+void
+print_etm_output_raw()
+{
+	int i;
+	char *dp;
+
+	dp = pr_item;
+	strcpy(dp, "ETM:");
+	dp += 4;
+	for (i = 1; i < rxpkt_len; i++) {
+		sprintf(dp, " %02X", rxpkt[i]);
+		dp += 3;
+	}
+	*dp = '\0';
+	print_item();
+}
+
+void
+print_unknown_packet()
+{
+	int i;
+	char *dp;
+
+	dp = pr_item;
+	strcpy(dp, "UNK:");
+	dp += 4;
+	for (i = 0; i < rxpkt_len; i++) {
+		sprintf(dp, " %02X", rxpkt[i]);
+		dp += 3;
+	}
+	*dp = '\0';
+	print_item();
+}
+
+void
+print_rx_packet()
+{
+	switch (rxpkt[0]) {
+	case RVT_RV_HEADER:
+		if (rxpkt_len < 6)
+			goto unknown;
+		print_rv_trace();
+		return;
+	case RVT_L1_HEADER:
+		print_l1_trace();
+		return;
+	case RVT_L23_HEADER:
+		print_g23_trace();
+		return;
+	case RVT_TM_HEADER:
+		print_etm_output_raw();
+		return;
+	default:
+	unknown:
+		print_unknown_packet();
+	}
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/rvinterf/old/txpkt.h	Fri Nov 22 05:56:07 2013 +0000
@@ -0,0 +1,15 @@
+/*
+ * For sizing our buffers etc in rvinterf, we need a limit on the size of
+ * message packets we can send to the target.  As it happens, the packet
+ * Rx code in RVT on the target side also has a limit (quite naturally,
+ * as it needs to use a static buffer to reassemble incoming packets as
+ * they arrive at the UART in unpredictable interrupt-sized chunks), so
+ * we set our limit to match that in RVT.
+ */
+
+#define	MAX_PKT_TO_TARGET	255
+
+/*
+ * The above limit definition counts all bytes between the opening and
+ * closing STX flags, but not DLEs inserted for binary transparency.
+ */

--- a/rvinterf/openport.c	Wed Nov 20 06:25:05 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,82 +0,0 @@
-/*
- * This module takes care of opening the serial port and setting the
- * proper "raw" termios modes, including the baud rate.
- */
-
-#include <sys/types.h>
-#include <sys/file.h>
-#include <sys/ioctl.h>
-#include <termios.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <strings.h>
-#include <unistd.h>
-
-int target_fd;
-char *baudrate_name = "115200";
-
-static struct baudrate {
-	char	*name;
-	speed_t	termios_code;
-} baud_rate_table[] = {
-	{"19200",	B19200},
-	{"38400",	B38400},
-	{"57600",	B57600},
-	{"115200",	B115200},
-	/* non-standard high baud rates "remapped" by CP2102 usb2serial IC */
-	{"203125",	B230400},
-	{"406250",	B460800},
-	{"812500",	B921600},
-	/* table search terminator */
-	{NULL,		B0}
-};
-
-static speed_t
-get_baud_rate()
-{
-	struct baudrate *br;
-
-	for (br = baud_rate_table; br->name; br++)
-		if (!strcmp(br->name, baudrate_name))
-			break;
-	if (!br->name) {
-		fprintf(stderr, "baud rate \"%s\" unknown/unsupported\n",
-			baudrate_name);
-		exit(1);
-	}
-	return br->termios_code;
-}
-
-open_target_serial(ttydev)
-	char *ttydev;
-{
-	struct termios target_termios;
-	speed_t br_code;
-
-	br_code = get_baud_rate();
-	target_fd = open(ttydev, O_RDWR|O_NONBLOCK);
-	if (target_fd < 0) {
-		perror(ttydev);
-		exit(1);
-	}
-	target_termios.c_iflag = IGNBRK;
-	target_termios.c_oflag = 0;
-	target_termios.c_cflag = CLOCAL|HUPCL|CREAD|CS8;
-	target_termios.c_lflag = 0;
-	target_termios.c_cc[VMIN] = 1;
-	target_termios.c_cc[VTIME] = 0;
-	cfsetispeed(&target_termios, br_code);
-	cfsetospeed(&target_termios, br_code);
-	if (tcsetattr(target_fd, TCSAFLUSH, &target_termios) < 0) {
-		perror("initial tcsetattr on target");
-		exit(1);
-	}
-	return 0;
-}
-
-set_serial_nonblock(state)
-	int state;
-{
-	ioctl(target_fd, FIONBIO, &state);
-}

--- a/rvinterf/packetrx.c	Wed Nov 20 06:25:05 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,88 +0,0 @@
-/*
- * This module handles the lowest level of serial packet Rx
- */
-
-#include <sys/types.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include "pktmux.h"
-
-extern int target_fd;
-
-#define	MAXPKT	512
-u_char rxpkt[MAXPKT];
-size_t rxpkt_len;
-
-extern char pr_item[];
-
-static int in_pkt, dle_state, toobig;
-
-static void
-process_inbyte(inb)
-{
-	if (!in_pkt) {
-		if (inb != STX || dle_state) {
-			rxpkt_len++;
-			dle_state = (inb == DLE);
-			return;
-		}
-		if (rxpkt_len) {
-			sprintf(pr_item,
-				"Warning: Rx %u byte%s outside of a packet",
-				(unsigned)rxpkt_len, rxpkt_len != 1 ? "s" : "");
-			print_item();
-			rxpkt_len = 0;
-		}
-		in_pkt = 1;
-		toobig = 0;
-		return;
-	}
-	if (dle_state) {
-		dle_state = 0;
-		if (inb != STX && inb != DLE) {
-			sprintf(pr_item,
-				"Rx framing error: %02X after DLE\n", inb);
-			print_item();
-			in_pkt = 0;
-			rxpkt_len = 0;
-			return;
-		}
-		goto data;
-	}
-	if (inb == DLE) {
-		dle_state = 1;
-		return;
-	} else if (inb == STX) {
-		if (!rxpkt_len)
-			return;
-		in_pkt = 0;
-		handle_rx_packet();
-		rxpkt_len = 0;
-		return;
-	}
-data:	if (rxpkt_len >= MAXPKT) {
-		if (!toobig) {
-			sprintf(pr_item, "Error: Rx packet too big!\n");
-			print_item();
-			toobig = 1;
-		}
-		return;
-	}
-	rxpkt[rxpkt_len++] = inb;
-}
-
-void
-process_serial_rx()
-{
-	u_char rdbuf[512];
-	int cc, i;
-
-	cc = read(target_fd, rdbuf, sizeof rdbuf);
-	if (cc <= 0) {
-		perror("Error/EOF reading from target");
-		exit(1);
-	}
-	for (i = 0; i < cc; i++)
-		process_inbyte(rdbuf[i]);
-}

--- a/rvinterf/packettx.c	Wed Nov 20 06:25:05 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,32 +0,0 @@
-/*
- * This module handles the lowest level of serial packet Tx
- */
-
-#include <sys/types.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include "pktmux.h"
-#include "txpkt.h"
-
-extern int target_fd;
-
-send_pkt_to_target(pkt, pktlen)
-	u_char *pkt;
-{
-	u_char buf[MAX_PKT_TO_TARGET*2+2];
-	u_char *cp, *dp, *endp;
-	int c;
-
-	endp = pkt + pktlen;
-	dp = buf;
-	*dp++ = STX;
-	for (cp = pkt; cp < endp; cp++) {
-		c = *cp;
-		if (c == STX || c == DLE)
-			*dp++ = DLE;
-		*dp++ = c;
-	}
-	*dp++ = STX;
-	write(target_fd, buf, dp - buf);
-}

--- a/rvinterf/rvtdump.c	Wed Nov 20 06:25:05 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,123 +0,0 @@
-/*
- * This program reads bytes from a serial port, parses them assuming
- * TI's RVT MUX format, and prints every decoded packet.
- */
-
-#include <sys/types.h>
-#include <sys/errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <time.h>
-
-extern int target_fd;
-extern char *baudrate_name;
-
-extern char pr_item[];
-extern int sendsock_fd;
-
-char *logfname;
-FILE *logF;
-time_t logtime;
-int background, sendsock_enable;
-
-main(argc, argv)
-	char **argv;
-{
-	extern char *optarg;
-	extern int optind;
-	int c, maxfd;
-	fd_set fds;
-
-	while ((c = getopt(argc, argv, "bB:d:l:s")) != EOF)
-		switch (c) {
-		case 'b':
-			background++;
-			continue;
-		case 'B':
-			baudrate_name = optarg;
-			continue;
-		case 'd':
-			target_fd = atoi(optarg);
-			continue;
-		case 'l':
-			logfname = optarg;
-			continue;
-		case 's':
-			sendsock_enable++;
-			continue;
-		case '?':
-		default:
-usage:			fprintf(stderr,
-			"usage: %s [options] ttyport\n", argv[0]);
-			exit(1);
-		}
-	if (background && !logfname) {
-		fprintf(stderr, "%s: -b is meaningless without -l\n", argv[0]);
-		exit(1);
-	}
-	if (target_fd <= 0) {
-		if (argc - optind != 1)
-			goto usage;
-		open_target_serial(argv[optind]);
-	}
-
-	set_serial_nonblock(0);
-	setlinebuf(stdout);
-	if (logfname) {
-		logF = fopen(logfname, "w");
-		if (!logF) {
-			perror(logfname);
-			exit(1);
-		}
-		fprintf(logF, "*** Log of decoded RVT output ***\n");
-		setlinebuf(logF);
-	}
-	if (sendsock_enable)
-		create_send_socket();
-	if (background) {
-		c = fork();
-		if (c < 0) {
-			perror("fork");
-			exit(1);
-		}
-		if (c) {
-			printf("rvtdump forked into background (pid %d)\n", c);
-			exit(0);
-		}
-	}
-	maxfd = target_fd;
-	if (sendsock_fd > maxfd)
-		maxfd = sendsock_fd;
-	for (;;) {
-		FD_ZERO(&fds);
-		FD_SET(target_fd, &fds);
-		if (sendsock_enable)
-			FD_SET(sendsock_fd, &fds);
-		c = select(maxfd+1, &fds, 0, 0, 0);
-		time(&logtime);
-		if (c < 0) {
-			if (errno == EINTR)
-				continue;
-			perror("select");
-			exit(1);
-		}
-		if (FD_ISSET(target_fd, &fds))
-			process_serial_rx();
-		if (FD_ISSET(sendsock_fd, &fds))
-			handle_sendsock();
-	}
-}
-
-handle_rx_packet()
-{
-	print_rx_packet();
-}
-
-print_item()
-{
-	if (!background)
-		printf("%s\n", pr_item);
-	if (logF)
-		log_item();
-}

--- a/rvinterf/rvtdump_tx.c	Wed Nov 20 06:25:05 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,70 +0,0 @@
-/*
- * This module contains the implementation of the Tx extension to rvtdump
- */
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <stdio.h>
-#include <string.h>
-#include <strings.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include "txpkt.h"
-
-static char sockpath[] = "/tmp/rvt_send_socket";
-
-int sendsock_fd;
-u_char sendsock_pkt[MAX_PKT_TO_TARGET];
-int sendsock_pktlen;
-
-create_send_socket()
-{
-	/* local socket binding voodoo copied from osmocon */
-	struct sockaddr_un local;
-	unsigned int namelen;
-	int rc;
-
-	sendsock_fd = socket(AF_UNIX, SOCK_DGRAM, 0);
-	if (sendsock_fd < 0) {
-		perror("socket(AF_UNIX, SOCK_DGRAM, 0)");
-		exit(1);
-	}
-
-	local.sun_family = AF_UNIX;
-	strncpy(local.sun_path, sockpath, sizeof(local.sun_path));
-	local.sun_path[sizeof(local.sun_path) - 1] = '\0';
-	unlink(local.sun_path);
-
-	/* we use the same magic that X11 uses in Xtranssock.c for
-	 * calculating the proper length of the sockaddr */
-#if defined(BSD44SOCKETS) || defined(__UNIXWARE__)
-	local.sun_len = strlen(local.sun_path);
-#endif
-#if defined(BSD44SOCKETS) || defined(SUN_LEN)
-	namelen = SUN_LEN(&local);
-#else
-	namelen = strlen(local.sun_path) +
-		  offsetof(struct sockaddr_un, sun_path);
-#endif
-
-	rc = bind(sendsock_fd, (struct sockaddr *) &local, namelen);
-	if (rc != 0) {
-		perror("bind on local dgram socket");
-		exit(1);
-	}
-
-	return(0);
-}
-
-handle_sendsock()
-{
-	sendsock_pktlen = recv(sendsock_fd, sendsock_pkt, MAX_PKT_TO_TARGET, 0);
-	if (sendsock_pktlen <= 0) {
-		fprintf(stderr, "return value from recv on socket: %d\n",
-			sendsock_pktlen);
-		exit(1);
-	}
-	send_pkt_to_target(sendsock_pkt, sendsock_pktlen);
-	log_sent_packet(sendsock_pkt, sendsock_pktlen);
-}

--- a/rvinterf/trdump.c	Wed Nov 20 06:25:05 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,169 +0,0 @@
-/*
- * This module implements the basic dump of any incoming packets
- */
-
-#include <sys/types.h>
-#include <stdio.h>
-#include <string.h>
-#include <strings.h>
-#include "pktmux.h"
-
-extern u_char rxpkt[];
-extern size_t rxpkt_len;
-
-char pr_item[4096];
-
-void
-print_rv_trace()
-{
-	int i, c;
-	char *dp;
-
-	dp = pr_item;
-	strcpy(dp, "RV ");
-	dp += 3;
-	/* the SWE static ID is sent MSB first */
-	for (i = 1; i <= 4; i++) {
-		sprintf(dp, "%02X", rxpkt[i]);
-		dp += 2;
-	}
-	/* severity level */
-	sprintf(dp, " %d ", rxpkt[5]);
-	dp = index(dp, '\0');
-	for (i = 6; i < rxpkt_len; i++) {
-		c = rxpkt[i];
-		if (c & 0x80) {
-			*dp++ = 'M';
-			*dp++ = '-';
-			c &= 0x7F;
-		}
-		if (c < 0x20) {
-			*dp++ = '^';
-			*dp++ = c + '@';
-		} else if (c == 0x7F) {
-			*dp++ = '^';
-			*dp++ = '?';
-		} else
-			*dp++ = c;
-	}
-	*dp = '\0';
-	print_item();
-}
-
-void
-print_l1_trace()
-{
-	int i, c;
-	char *dp;
-
-	dp = pr_item;
-	strcpy(dp, "L1: ");
-	dp += 4;
-	for (i = 1; i < rxpkt_len; i++) {
-		if ((i+1 < rxpkt_len) &&
-		    (rxpkt[i] == '\r' && rxpkt[i+1] == '\n' ||
-		     rxpkt[i] == '\n' && rxpkt[i+1] == '\r')) {
-			*dp = '\0';
-			print_item();
-			if (i+2 == rxpkt_len)
-				return;
-			dp = pr_item;
-			*dp++ = '+';
-			*dp++ = ' ';
-			i++;
-			continue;
-		}
-		c = rxpkt[i];
-		if (c & 0x80) {
-			*dp++ = 'M';
-			*dp++ = '-';
-			c &= 0x7F;
-		}
-		if (c < 0x20) {
-			*dp++ = '^';
-			*dp++ = c + '@';
-		} else if (c == 0x7F) {
-			*dp++ = '^';
-			*dp++ = '?';
-		} else
-			*dp++ = c;
-	}
-	/* will get here only if no newline sequence at the end */
-	*dp = '\0';
-	print_item();
-}
-
-void
-print_g23_trace()
-{
-	int i;
-	char *dp;
-
-	dp = pr_item;
-	strcpy(dp, "G23:");
-	dp += 4;
-	for (i = 1; i < rxpkt_len; i++) {
-		sprintf(dp, " %02X", rxpkt[i]);
-		dp += 3;
-	}
-	*dp = '\0';
-	print_item();
-}
-
-void
-print_etm_output_raw()
-{
-	int i;
-	char *dp;
-
-	dp = pr_item;
-	strcpy(dp, "ETM:");
-	dp += 4;
-	for (i = 1; i < rxpkt_len; i++) {
-		sprintf(dp, " %02X", rxpkt[i]);
-		dp += 3;
-	}
-	*dp = '\0';
-	print_item();
-}
-
-void
-print_unknown_packet()
-{
-	int i;
-	char *dp;
-
-	dp = pr_item;
-	strcpy(dp, "UNK:");
-	dp += 4;
-	for (i = 0; i < rxpkt_len; i++) {
-		sprintf(dp, " %02X", rxpkt[i]);
-		dp += 3;
-	}
-	*dp = '\0';
-	print_item();
-}
-
-void
-print_rx_packet()
-{
-	switch (rxpkt[0]) {
-	case RVT_RV_HEADER:
-		if (rxpkt_len < 6)
-			goto unknown;
-		print_rv_trace();
-		return;
-	case RVT_L1_HEADER:
-		print_l1_trace();
-		return;
-	case RVT_L23_HEADER:
-		print_g23_trace();
-		return;
-	case RVT_TM_HEADER:
-		print_etm_output_raw();
-		return;
-	default:
-	unknown:
-		print_unknown_packet();
-	}
-}

--- a/rvinterf/txpkt.h	Wed Nov 20 06:25:05 2013 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,15 +0,0 @@
-/*
- * For sizing our buffers etc in rvinterf, we need a limit on the size of
- * message packets we can send to the target.  As it happens, the packet
- * Rx code in RVT on the target side also has a limit (quite naturally,
- * as it needs to use a static buffer to reassemble incoming packets as
- * they arrive at the UART in unpredictable interrupt-sized chunks), so
- * we set our limit to match that in RVT.
- */
-
-#define	MAX_PKT_TO_TARGET	255
-
-/*
- * The above limit definition counts all bytes between the opening and
- * closing STX flags, but not DLEs inserted for binary transparency.
- */