aboutsummaryrefslogtreecommitdiffstats
path: root/tools/uhd_dump
diff options
context:
space:
mode:
Diffstat (limited to 'tools/uhd_dump')
-rw-r--r--tools/uhd_dump/Makefile23
-rw-r--r--tools/uhd_dump/chdr_log.c212
-rw-r--r--tools/uhd_dump/uhd_dump.c531
-rw-r--r--tools/uhd_dump/uhd_dump.h238
-rw-r--r--tools/uhd_dump/usrp3_regs.h51
5 files changed, 1055 insertions, 0 deletions
diff --git a/tools/uhd_dump/Makefile b/tools/uhd_dump/Makefile
new file mode 100644
index 000000000..93181570b
--- /dev/null
+++ b/tools/uhd_dump/Makefile
@@ -0,0 +1,23 @@
+INCLUDES = usrp3_regs.h uhd_dump.h
+
+BINARIES = chdr_log
+
+OBJECTS = uhd_dump.o
+
+CFLAGS = -g -O0 -Wall
+
+LDFLAGS = -lpcap -lm
+
+CC = cc
+
+.PHONY: all
+all: $(BINARIES)
+
+chdr_log: uhd_dump.o chdr_log.o $(INCLUDES)
+ $(CC) $(CFLAGS) -o $@ uhd_dump.o chdr_log.o $(LDFLAGS)
+
+
+
+clean:
+ rm $(BINARIES) $(BINARIES:%=%.o) $(OBJECTS)
+
diff --git a/tools/uhd_dump/chdr_log.c b/tools/uhd_dump/chdr_log.c
new file mode 100644
index 000000000..9a0834e9b
--- /dev/null
+++ b/tools/uhd_dump/chdr_log.c
@@ -0,0 +1,212 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <pcap.h>
+#include <netinet/in.h>
+#include <time.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "uhd_dump.h"
+
+//#define DEBUG 1
+
+void usage()
+{
+ fprintf(stderr,"Usage: chdr_dump [-h host_ip] filename.pcap\n");
+ exit(2);
+}
+
+int main(int argc, char *argv[])
+{
+ struct pbuf_info *packet_buffer; // Store all packets of interest here
+ struct in_addr host_addr; // Apparent Host IP addr in this capture
+ struct in_addr usrp_addr; // Apparent USRP IP addr in this capture
+ struct timeval *origin_ts; // Timestamp of first packet in file.
+ long long origin_ts_in_us;
+ int direction; // Flag to show direction of packet flow. 0=H->U, 1=U->H.
+ int packet_count[2]; // Number of packets that match filter
+ double size_average[2]; // Average size of packets Host to USRP
+ int size_histogram[90][2]; // Array captures histogram of packet sizes Host to USRP in 100 byte bins
+ int x; // Local integer scratch variables
+ char *conversion_error[1];
+ int c;
+ char buffer[26]; // Buffer to format GMT time stamp strings for output
+ double time_since_start; // Time elapsed in seconds since start
+
+ const struct ip_header *ip_header;
+
+ u32 *dump_header;
+
+
+ host_addr.s_addr = 0x0;
+ //usrp_addr.s_addr = 0x0;
+
+ while ((c = getopt(argc, argv, "h:u:")) != -1) {
+ switch(c) {
+ case 'h':
+ // Explicit IP address for host on command line
+ if (*optarg == '\0')
+ usage();
+ host_addr.s_addr = strtol(strtok(optarg,"."),conversion_error,10) ;
+ if (**conversion_error != '\0')
+ usage();
+ host_addr.s_addr = host_addr.s_addr | strtol(strtok(NULL,"."),conversion_error,10) << 8;
+ if (**conversion_error != '\0')
+ usage();
+ host_addr.s_addr = host_addr.s_addr | strtol(strtok(NULL,"."),conversion_error,10) << 16;
+ if (**conversion_error != '\0')
+ usage();
+ host_addr.s_addr = host_addr.s_addr | strtol(strtok(NULL,"\0"),conversion_error,10) << 24;
+ if (**conversion_error != '\0')
+ usage();
+ break;
+ case 'u':
+ // Explicit IP address for USRP on command line
+ if (*optarg == '\0')
+ usage();
+ usrp_addr.s_addr = strtol(strtok(optarg,"."),conversion_error,10) ;
+ if (**conversion_error != '\0')
+ usage();
+ usrp_addr.s_addr = usrp_addr.s_addr | strtol(strtok(NULL,"."),conversion_error,10) << 8;
+ if (**conversion_error != '\0')
+ usage();
+ usrp_addr.s_addr = usrp_addr.s_addr | strtol(strtok(NULL,"."),conversion_error,10) << 16;
+ if (**conversion_error != '\0')
+ usage();
+ usrp_addr.s_addr = usrp_addr.s_addr | strtol(strtok(NULL,"\0"),conversion_error,10) << 24;
+ if (**conversion_error != '\0')
+ usage();
+ break;
+
+ case'?':
+ default:
+ usage();
+ }
+ }
+
+ argc -= (optind - 1);
+ argv += (optind -1);
+
+
+ // Just a mandatory pcap filename for now, better parser and options later.
+ if (argc != 2) {
+ usage();
+ }
+
+
+ // Init packet buffer
+ packet_buffer = malloc(sizeof(struct pbuf_info));
+
+ // Init origin timestamp
+ origin_ts = malloc(sizeof(struct timeval));
+
+ // Go read matching packets from capture file into memory
+ get_udp_port_from_file(CHDR_PORT,argv[1],packet_buffer,origin_ts);
+
+ // Extract origin tome of first packet and convert to uS.
+ origin_ts_in_us = origin_ts->tv_sec * 1000000 + origin_ts->tv_usec;
+
+
+ // Count number of packets in capture
+ packet_buffer->current = packet_buffer->start;
+ x = 0;
+
+ while (packet_buffer->current != NULL) {
+ x++;
+ packet_buffer->current = packet_buffer->current->next;
+ }
+
+ fprintf(stdout,"\n===================================================================\n");
+ fprintf(stdout,"\n Total matching packet count in capture file: %d\n",x);
+ fprintf(stdout,"\n===================================================================\n\n");
+
+ // If no packets were CHDR then just exit now
+ if (x == 0) {
+ exit(0);
+ }
+
+ // Determine host and USRP IP addresses so that we can classify direction of packet flow later.
+ if (host_addr.s_addr == 0x0)
+ get_connection_endpoints(packet_buffer,&host_addr,&usrp_addr);
+
+ // Count packets in list.
+ // Build histogram of packet sizes
+ // Build histogram of Stream ID's
+ packet_buffer->current = packet_buffer->start;
+
+ for (x=0;x<90;x+=1)
+ size_histogram[x][H2U] = size_histogram[x][U2H] = 0;
+
+ size_average[H2U] = size_average[U2H] = 0;
+ packet_count[H2U] = packet_count[U2H] = 0;
+
+ while (packet_buffer->current != NULL) {
+
+ // Overlay IP header on packet payload
+ ip_header = (struct ip_header *)(packet_buffer->current->payload+ETH_SIZE);
+
+ // Identify packet direction
+ if (ip_header->ip_src.s_addr == host_addr.s_addr)
+ direction = H2U;
+ else
+ direction = U2H;
+
+ packet_count[direction]++;
+ size_average[direction]+=(double)packet_buffer->current->size;
+ if ((x=packet_buffer->current->size) > 9000)
+ fprintf(stderr,"Current packet size = %d at absolute time %s, relative time %f, exceeds MTU! Skip counting.",
+ x,format_gmt(&packet_buffer->current->ts,buffer),(relative_time(&packet_buffer->current->ts,origin_ts)));
+ else
+ size_histogram[x/100][direction]++;
+
+ packet_buffer->current = packet_buffer->current->next;
+
+ }
+
+ fprintf(stdout,"\n===================================================================\n");
+ fprintf(stdout,"\n Average packet size Host -> USRP: %d\n",(int)(size_average[H2U]/packet_count[H2U]));
+ fprintf(stdout,"\n Average packet size USRP -> Host: %d\n",(int)(size_average[U2H]/packet_count[U2H]));
+ fprintf(stdout,"\n===================================================================\n\n");
+
+ //
+ // Now produce packet by packet log
+ //
+ packet_buffer->current = packet_buffer->start;
+ x = 0;
+
+ while (packet_buffer->current != NULL) {
+ x++;
+
+ // Calculate time offset of this packet from start
+ time_since_start = ((double) packet_buffer->current->ts.tv_sec * 1000000 + packet_buffer->current->ts.tv_usec - origin_ts_in_us)/1000000;
+
+
+ dump_header = (u32 *) (packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE);
+
+ /* fprintf(stdout,"DUMP: %08x %08x %08x %08x %08x %08x\n", */
+ /* swapint((int) *(dump_header)), */
+ /* swapint((int) *(dump_header+1)), */
+ /* swapint((int) *(dump_header+2)), */
+ /* swapint((int) *(dump_header+3)), */
+ /* swapint((int) *(dump_header+4)), */
+ /* swapint((int) *(dump_header+5))); */
+
+ // Extract the device portion of the SID to see which packet flow this belongs in
+
+ fprintf(stdout,"%8d %f \t",x,time_since_start);
+ print_direction(packet_buffer,&host_addr,&usrp_addr);
+ fprintf(stdout,"\t");
+ print_size(packet_buffer);
+ fprintf(stdout,"\t");
+ print_sid(packet_buffer);
+ fprintf(stdout,"\t");
+ print_vita_header(packet_buffer,&host_addr);
+ fprintf(stdout,"\n");
+
+ packet_buffer->current = packet_buffer->current->next;
+
+ }
+ // Normal Exit
+ return(0);
+}
+
diff --git a/tools/uhd_dump/uhd_dump.c b/tools/uhd_dump/uhd_dump.c
new file mode 100644
index 000000000..3238d72cf
--- /dev/null
+++ b/tools/uhd_dump/uhd_dump.c
@@ -0,0 +1,531 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <pcap.h>
+#include <netinet/in.h>
+#include <time.h>
+#include <string.h>
+
+#include "uhd_dump.h"
+#include "usrp3_regs.h"
+
+
+// Swap endianness of 64bits
+unsigned long swaplong (unsigned long nLongNumber)
+{
+ union u {unsigned long vi; unsigned char c[sizeof(unsigned long)];};
+ union v {unsigned long ni; unsigned char d[sizeof(unsigned long)];};
+ union u un;
+ union v vn;
+ un.vi = nLongNumber;
+ vn.d[0]=un.c[7];
+ vn.d[1]=un.c[6];
+ vn.d[2]=un.c[5];
+ vn.d[3]=un.c[4];
+ vn.d[4]=un.c[3];
+ vn.d[5]=un.c[2];
+ vn.d[6]=un.c[1];
+ vn.d[7]=un.c[0];
+
+ return (vn.ni);
+}
+
+// Swap endianness of 32bits
+unsigned int swapint (unsigned int nIntNumber)
+{
+ union u {unsigned int vi; unsigned char c[sizeof(unsigned long)];};
+ union v {unsigned int ni; unsigned char d[sizeof(unsigned long)];};
+ union u un;
+ union v vn;
+ un.vi = nIntNumber;
+ vn.d[0]=un.c[3];
+ vn.d[1]=un.c[2];
+ vn.d[2]=un.c[1];
+ vn.d[3]=un.c[0];
+ return (vn.ni);
+}
+
+// Swap Endianness of 16bits
+unsigned short swapshort (unsigned short nShortNumber)
+{
+ union u {unsigned short vi; unsigned char c[sizeof(unsigned short)];};
+ union v {unsigned short ni; unsigned char d[sizeof(unsigned short)];};
+ union u un;
+ union v vn;
+ un.vi = nShortNumber;
+ vn.d[0]=un.c[1];
+ vn.d[1]=un.c[0];
+
+ return (vn.ni);
+}
+
+// Format time from pcap as ascii style.
+char *format_gmt(const struct timeval *ts, char *buffer)
+{
+ time_t seconds;
+ struct tm gmt;
+ seconds = ts->tv_sec;
+ if ((gmtime_r(&seconds, &gmt)) == NULL) {
+ fprintf(stderr, "Fatal time format conversion error.\n");
+ exit(2);
+ }
+ sprintf(buffer,
+ "%04i-%02i-%02iT%02i:%02i:%02i,%03iZ",
+ gmt.tm_year + 1900, gmt.tm_mon + 1, gmt.tm_mday,
+ gmt.tm_hour, gmt.tm_min, gmt.tm_sec, (int) (ts->tv_usec / 1000));
+ return (buffer);
+}
+
+// Takes 2 timeval absolute timevalues, and returns a double value thats the relative time
+// difference normalized to seconds.
+double relative_time(struct timeval *event_ts, struct timeval *origin_ts)
+{
+ struct timeval z;
+ double x;
+ timersub(event_ts,origin_ts,&z);
+ x = (double)z.tv_sec + (double)z.tv_usec/1000000;
+ return x;
+}
+
+// Convert timeval to double, normalized to seconds.
+double timeval2double(struct timeval *event_ts)
+{
+ double x;
+ x = (double)event_ts->tv_sec + (double)event_ts->tv_usec/1000000;
+ return x;
+}
+
+void get_packet(struct pbuf_info *packet_buffer , const struct pcap_pkthdr *header, const u_char *packet)
+{
+ // Get size of new packet
+ packet_buffer->current->size = header->caplen;
+ packet_buffer->current->orig_size = header->len;
+
+ // Allocate memory for packet
+ packet_buffer->current->payload = (char *)malloc((size_t)packet_buffer->current->size);
+
+ // Copy Packet into buffer
+ memcpy(packet_buffer->current->payload,packet,packet_buffer->current->size);
+ packet_buffer->current->ts = header->ts;
+
+ // Allocate memory for next pbuf in chain, init it and shift list.
+ packet_buffer->current->next = malloc(sizeof (struct pbuf));
+ packet_buffer->current->next->last = packet_buffer->current;
+ packet_buffer->current = packet_buffer->current->next;
+}
+
+// This grabs the (absolute) time stamp of the first packet in the cature file, which can be used to
+// derive times relative to the start of the capture file for cross correlation with interactive work
+// in Wireshark
+void get_start_time(struct timeval *ts , const struct pcap_pkthdr *header, const u_char *packet)
+{
+ *ts = header->ts;
+}
+
+void get_udp_port_from_file(const u16 udp_port, const char *filename, struct pbuf_info *packet_buffer, struct timeval *ts)
+{
+ pcap_t *handle; // Session handle
+ char errbuf[PCAP_ERRBUF_SIZE]; // Error string
+ char filter_exp[256]; // The ascii filter expression
+ struct bpf_program filter; // The compiled filter
+
+ // Open PCAP file for read capture time stamp of first packet
+ if ((handle = pcap_open_offline(filename,errbuf)) == NULL) {
+ fprintf(stderr,"Can't open pcap file for reading: %s\n",errbuf);
+ exit(2);
+ }
+
+ // Parse PCAP file with no filter to grab the time stamp of the first captured packet, which becomes the time origin
+ // local to the capture file.
+ if (pcap_dispatch(handle, 1, (pcap_handler) get_start_time, (u_char *)ts) == -1) {
+ fprintf(stderr, "Error parsing PCAP file: %s\n", pcap_geterr(handle));
+ exit(2);
+ }
+
+ // Close file again because no way to rewind file descriptor.
+ pcap_close(handle);
+
+ // Open PCAP file for read.
+ if ((handle = pcap_open_offline(filename,errbuf)) == NULL) {
+ fprintf(stderr,"Can't open pcap file for reading: %s\n",errbuf);
+ exit(2);
+ }
+
+ // Build ASCII filter expression from UDP port
+ sprintf(filter_exp,"udp port %d",udp_port);
+ printf("\nBPF filter is udp port %d\n",udp_port);
+
+ // Compile filter string to BPF
+ if (pcap_compile(handle, &filter, filter_exp, 0, 0) == -1) {
+ fprintf(stderr, "Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(handle));
+ exit(2);
+ }
+
+ // Apply filter
+ if (pcap_setfilter(handle, &filter) == -1) {
+ fprintf(stderr, "Couldn't install filter %s: %s\n", filter_exp, pcap_geterr(handle));
+ exit(2);
+ }
+
+ // Allocate and initialize packet buffer linked list
+ packet_buffer->start = packet_buffer->current = malloc(sizeof (struct pbuf));
+ packet_buffer->start->last = NULL;
+
+ // Parse PCAP file using filter, collect all interesting packets.
+ if (pcap_dispatch(handle, -1, (pcap_handler) get_packet, (u_char *)packet_buffer) == -1) {
+ fprintf(stderr, "Error parsing PCAP file: %s\n", pcap_geterr(handle));
+ exit(2);
+ }
+
+ // If no packets matched in the capture then linked list should be completely empty.
+ if ( packet_buffer->start == packet_buffer->current) {
+ free(packet_buffer->current);
+ packet_buffer->start = packet_buffer->current = NULL;
+ } else {
+ // Note the last used buffer in the list. Removed allocated but unused buffer from list and free
+ packet_buffer->end = packet_buffer->current->last;
+ packet_buffer->end->next = NULL;
+ free(packet_buffer->current);
+ }
+}
+
+//
+// Read a pcap file into memory.
+//
+void get_everything_from_file(const char *filename, struct pbuf_info *packet_buffer, struct timeval *ts)
+{
+ pcap_t *handle; // Session handle
+ char errbuf[PCAP_ERRBUF_SIZE]; // Error string
+
+ // Open PCAP file for read capture time stamp of first packet
+ if ((handle = pcap_open_offline(filename,errbuf)) == NULL) {
+ fprintf(stderr,"Can't open pcap file for reading: %s\n",errbuf);
+ exit(2);
+ }
+
+ // Parse PCAP file with no filter to grab the time stamp of the first captured packet, which becomes the time origin
+ // local to the capture file.
+ if (pcap_dispatch(handle, 1, (pcap_handler) get_start_time, (u_char *)ts) == -1) {
+ fprintf(stderr, "Error parsing PCAP file: %s\n", pcap_geterr(handle));
+ exit(2);
+ }
+
+ // Close file again because no way to rewind file descriptor.
+ pcap_close(handle);
+
+ // Open PCAP file for read
+ if ((handle = pcap_open_offline(filename,errbuf)) == NULL) {
+ fprintf(stderr,"Can't open pcap file for reading: %s\n",errbuf);
+ exit(2);
+ }
+
+ // Allocate and initialize packet buffer linked list
+ packet_buffer->start = packet_buffer->current = malloc(sizeof (struct pbuf));
+ packet_buffer->start->last = NULL;
+
+ // Parse PCAP file using filter, collect all interesting packets.
+ if (pcap_dispatch(handle, -1, (pcap_handler) get_packet, (u_char *)packet_buffer) == -1) {
+ fprintf(stderr, "Error parsing PCAP file: %s\n", pcap_geterr(handle));
+ exit(2);
+ }
+
+ // If no packets matched in the capture then linked list should be completely empty.
+ if ( packet_buffer->start == packet_buffer->current) {
+ free(packet_buffer->current);
+ packet_buffer->start = packet_buffer->current = NULL;
+ } else {
+ // Note the last used buffer in the list. Removed allocated but unused buffer from list and free
+ packet_buffer->end = packet_buffer->current->last;
+ packet_buffer->end->next = NULL;
+ free(packet_buffer->current);
+ }
+}
+
+
+// Debug
+void print_raw(const struct pbuf_info *packet_buffer, const int count)
+{
+ const u8 *raw;
+ int x;
+ raw = (u8 *) packet_buffer;
+ fprintf(stdout," ");
+ for (x = 0; x<count; x++)
+ fprintf(stdout,"%02x ",*(raw+x));
+}
+
+// Print to STDOUT the direction of this packet flow
+void print_direction(const struct pbuf_info *packet_buffer, const struct in_addr *host_addr, const struct in_addr *usrp_addr)
+{
+ const struct ip_header *ip_header;
+
+ // Overlay IP header on packet payload
+ ip_header = (struct ip_header *)(packet_buffer->current->payload+ETH_SIZE);
+
+ if ((host_addr->s_addr == ip_header->ip_src.s_addr) && (usrp_addr->s_addr == ip_header->ip_dst.s_addr))
+ fprintf(stdout,"Host->USRP");
+ else if ((host_addr->s_addr == ip_header->ip_dst.s_addr) && (usrp_addr->s_addr == ip_header->ip_src.s_addr))
+ fprintf(stdout,"USRP->Host");
+ else
+ fprintf(stdout,"UNKNOWN");
+}
+
+// Print to STDOUT the CHDR size in bytes
+void print_size(const struct pbuf_info *packet_buffer)
+{
+ const struct chdr_header *chdr_header;
+
+ // Overlay CHDR header on packet payload
+ chdr_header = (struct chdr_header *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE);
+
+ fprintf(stdout,"Size: %04d ",(swapint(chdr_header->chdr_type) & SIZE));
+}
+
+// Print to STDOUT the CHDR SID decode
+void print_sid(const struct pbuf_info *packet_buffer)
+{
+ const struct chdr_header *chdr_header;
+ const struct chdr_sid *chdr_sid;
+
+ // Overlay CHDR header on packet payload
+ chdr_header = (struct chdr_header *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE);
+
+ // Overlay CHDR SID definition on CHDR SID.
+ chdr_sid = (struct chdr_sid *)&(chdr_header->chdr_sid);
+
+ fprintf(stdout,"%02x.%02x->%02x.%02x",chdr_sid->src_device,chdr_sid->src_endpoint,chdr_sid->dst_device,chdr_sid->dst_endpoint);
+}
+
+// Print to STDOUT a decoded tx response packet payload.
+void print_tx_response(const struct tx_response *tx_response)
+{
+ switch(swapint(tx_response->error_code))
+ {
+ case TX_ACK: fprintf(stdout,"ACK "); break;
+ case TX_EOB: fprintf(stdout,"EOB "); break;
+ case TX_UNDERRUN: fprintf(stdout,"Underrun "); break;
+ case TX_SEQ_ERROR: fprintf(stdout,"Sequence Error "); break;
+ case TX_TIME_ERROR: fprintf(stdout,"Time Error "); break;
+ case TX_MIDBURST_SEQ_ERROR: fprintf(stdout,"Mid-Burst Seq Errror "); break;
+ default: fprintf(stdout,"Unknown Error ");
+ }
+ fprintf(stdout,"for SeqID = %03x ",swapint(tx_response->seq_id)&0xFFF);
+}
+
+
+
+// Returns Name of a register from it's address
+char *reg_addr_to_name(const u32 addr)
+{
+ int x;
+ x = 0;
+ while((reg_list[x].addr != addr) && (reg_list[x].addr != 999))
+ x++;
+ return(reg_list[x].name);
+}
+
+// Print to STDOUT decode of CHDR header including time if present.
+void print_vita_header(const struct pbuf_info *packet_buffer, const struct in_addr *host_addr)
+{
+ const struct ip_header *ip_header;
+ const struct chdr_header *chdr_header;
+ const struct chdr_sid *chdr_sid;
+ const struct radio_ctrl_payload *radio_ctrl_payload;
+ const struct radio_response *radio_response;
+ const struct tx_response *tx_response;
+ const struct src_flow_ctrl *src_flow_ctrl;
+ const struct vita_time *vita_time;
+ int direction;
+ u8 endpoint;
+ int has_time;
+
+ // Overlay IP header on packet payload
+ ip_header = (struct ip_header *)(packet_buffer->current->payload+ETH_SIZE);
+
+ // Overlay CHDR header on packet payload
+ chdr_header = (struct chdr_header *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE);
+
+ // Overlay CHDR SID definition on CHDR SID.
+ chdr_sid = (struct chdr_sid *)&(chdr_header->chdr_sid);
+
+ // Identify packet direction
+ if (ip_header->ip_src.s_addr == host_addr->s_addr)
+ direction = H2U;
+ else
+ direction = U2H;
+
+ // Decode packet type
+
+
+ if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) == EXT_CONTEXT) fprintf(stdout,"Context Ext ");
+ else fprintf(stdout,"IF Data ");
+
+ // Determine USRP Sink/Src Endpoint
+ if (direction==H2U)
+ endpoint = (chdr_sid->dst_endpoint) & 0x3;
+ else if (direction==U2H)
+ endpoint = (chdr_sid->src_endpoint) & 0x3;
+
+ // Look for CHDR EOB flags.
+ if ((swapint(chdr_header->chdr_type) & EOB) == EOB) fprintf(stdout,"EOB ");
+ else fprintf(stdout," ");
+
+ // Is there embeded VITA time?
+ if ((swapint(chdr_header->chdr_type) & HAS_TIME) == HAS_TIME) {
+ vita_time = (struct vita_time *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE+CHDR_SIZE);
+ fprintf(stdout,"Time=%016lx ",swaplong(vita_time->time));
+ has_time = 1;
+ } else {
+ fprintf(stdout," ");
+ has_time = 0;
+ }
+
+ fprintf(stdout,"SeqID=%03x ",(swapint(chdr_header->chdr_type)>>16)&0xFFF);
+
+ // Print Payload
+ if (endpoint == RADIO)
+ {
+ if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) != EXT_CONTEXT)
+ {
+ if (direction == H2U)
+ {
+ fprintf(stdout,"TX IF Data ");
+ }
+ else
+ // U2H
+ {
+ fprintf(stdout,"RX IF Data ");
+ }
+ }
+ else if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) == EXT_CONTEXT)
+ {
+ if (direction == H2U)
+ {
+ // BAD PACKET
+ }
+ else
+ // U2H
+ {
+ // TX Response packet.
+ tx_response = (struct tx_response *) (packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE+CHDR_SIZE+(has_time?VITA_TIME_SIZE:0));
+ print_tx_response(tx_response);
+ }
+ }
+ }
+ else if (endpoint == RADIO_CTRL)
+ {
+ fprintf(stdout,"\t\t\t");
+ if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) != EXT_CONTEXT)
+ {
+ // BAD PACKET
+ }
+ else if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) == EXT_CONTEXT)
+ {
+ if (direction == H2U)
+ {
+ radio_ctrl_payload = (struct radio_ctrl_payload *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE+CHDR_SIZE+(VITA_TIME_SIZE*has_time));
+ fprintf(stdout,"Radio Ctrl %s(0x%02x)=0x%08x",reg_addr_to_name(swapint(radio_ctrl_payload->addr)),(u8)swapint(radio_ctrl_payload->addr),swapint(radio_ctrl_payload->data));
+ }
+ else
+ // U2H
+ {
+ radio_response = (struct radio_response *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE+CHDR_SIZE+(VITA_TIME_SIZE*has_time));
+ fprintf(stdout,"Radio Response = 0x%016lx",swaplong(radio_response->data));
+ }
+ }
+ }
+ else if (endpoint == SRC_FLOW_CTRL)
+ {
+ if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) != EXT_CONTEXT)
+ {
+ // BAD PACKET
+ }
+ else if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) == EXT_CONTEXT)
+ {
+ if (direction == H2U)
+ {
+ src_flow_ctrl = (struct src_flow_ctrl *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE+CHDR_SIZE+(VITA_TIME_SIZE*has_time));
+ fprintf(stdout,"Src Flow Ctrl = 0x%04x",swapint(src_flow_ctrl->seq_id));
+ }
+ else
+ // U2H
+ {
+ // Bad Packet
+ }
+ }
+ }
+ //print_raw((struct pbuf_info *)vrt_header,16);
+}
+
+
+// Find IP addresses for Host and USRP in this Session
+
+void get_connection_endpoints( struct pbuf_info *packet_buffer, struct in_addr *host_addr, struct in_addr *usrp_addr)
+{
+ const struct ip_header *ip_header;
+ const struct chdr_header *chdr_header;
+ const struct chdr_sid *chdr_sid;
+
+ // Determine which side of the stream is Host and which is USRP by probing capture until a
+ // CHDR message type is discovered. The SID reveals which direction the packet is traveling.
+ // Then record apparent IP addresses of Host and USRP for future packet clasification.
+ packet_buffer->current = packet_buffer->start;
+
+ host_addr->s_addr = 0x0;
+ usrp_addr->s_addr = 0x0;
+
+ while (packet_buffer->current != NULL) {
+
+ // Overlay IP header on packet payload
+ ip_header = (struct ip_header *)(packet_buffer->current->payload+ETH_SIZE);
+
+ // Overlay CHDR header on packet payload
+ chdr_header = (struct chdr_header *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE);
+
+ // Overlay CHDR SID definition on CHDR SID.
+ chdr_sid = (struct chdr_sid *)&(chdr_header->chdr_sid);
+
+
+ // Catagorise stream
+ // CHDR is actually quite hard to conclusively detect, the following deductions help...
+ // For CHDR v2 bit 62 should always be 0 (reserved)
+ // Bit 47 should always be 0 because sizes > 8192 are unsupport be typical ethernet MTU's
+ // By convention currently the host uses SID address 0.x so the first packets in a new UHD session
+ // should flow from Host to Device hence [31:24] = 0.
+ if (
+ ((swapint(chdr_header->chdr_type) & 0x40000000) != 0x0) ||
+ ((swapint(chdr_header->chdr_type) & 0x8000) != 0x0) ||
+ ((swapint(chdr_header->chdr_sid) & 0xFF000000) != 0x0) ||
+ ((swapint(chdr_header->chdr_sid) & 0x0000FF00) == 0x0)
+ )
+ fprintf(stderr,"Current packet is not CHDR. Skipping.");
+ else
+ {
+ // Implicitly CHDR (At least that is our best guess)
+ // Go take a look at the SID and see who is boss.
+ if ((chdr_sid->src_device == 0) && (chdr_sid->dst_device != 0))
+ {
+ // Host->USRP
+ host_addr->s_addr = ip_header->ip_src.s_addr;
+ usrp_addr->s_addr = ip_header->ip_dst.s_addr;
+ break;
+ }
+ else if ((chdr_sid->src_device == 0) && (chdr_sid->dst_device != 0))
+ {
+ // USRP->Host
+ usrp_addr->s_addr = ip_header->ip_src.s_addr;
+ host_addr->s_addr = ip_header->ip_dst.s_addr;
+ break;
+ }
+ else
+ {
+ fprintf(stderr,"Malformed CHDR packet, SID is unexpected value: 0x%x",swapint(chdr_header->chdr_sid));
+ }
+ }
+ packet_buffer->current = packet_buffer->current->next;
+ }
+
+ if (host_addr->s_addr == 0) {
+ fprintf(stderr, "Could not identify Host/USRP direction in capture analysis, exiting.\n");
+ exit(2);
+ }
+}
diff --git a/tools/uhd_dump/uhd_dump.h b/tools/uhd_dump/uhd_dump.h
new file mode 100644
index 000000000..2c36f9a39
--- /dev/null
+++ b/tools/uhd_dump/uhd_dump.h
@@ -0,0 +1,238 @@
+
+#ifndef _UHD_DUMP_H_
+#define _UHD_DUMP_H_
+
+
+
+#define FALSE 0
+#define TRUE 1
+#define UNKNOWN 2
+
+// Define directions for Host->USRP & USRP->Host
+#define H2U 0
+#define U2H 1
+
+// Endpoint encodings for USRP3 from SID LSB's
+#define RADIO 0
+#define RADIO_CTRL 1
+#define SRC_FLOW_CTRL 2
+#define RESERVED 3
+
+/* // VRT Type definitions */
+/* #define IF_DATA_NO_SID 0 */
+/* #define IF_DATA_WITH_SID 1 */
+/* #define EXT_DATA_NO_SID 2 */
+/* #define EXT_DATA_WITH_SID 3 */
+/* #define IF_CONTEXT 4 */
+/* #define EXT_CONTEXT 5 */
+
+// CHDR bit masks
+#define EXT_CONTEXT 1<<31
+#define HAS_TIME 1<<29
+#define EOB 1<<28
+#define SIZE (1<<16)-1
+
+
+// UDP used as source for all CHDR comms.
+#define CHDR_PORT 49153
+
+typedef unsigned char bool;
+typedef unsigned char u8;
+typedef unsigned short u16;
+typedef unsigned int u32;
+typedef unsigned long u64;
+
+union ip_addr_decoder {
+ unsigned long s_addr;
+ unsigned char octet[4];
+};
+
+/*
+Ethernet header structure
+*/
+
+struct ethernet_header {
+ u8 eth_dst[6]; // MAC addr of destination
+ u8 eth_src[6]; // MAC addr of source
+ u16 eth_typ; // Payload protocol type
+};
+
+#define ETH_SIZE 14
+
+/*
+ IP Header strcture
+ NOTE: Network byte order (Big Endian)
+*/
+
+struct ip_header {
+ u8 ip_vhl; // [7:4] Version, [3:0] Header Length
+ u8 ip_tos; // Type of Service/DIff Serv/ECN
+ u16 ip_len; // Total Length
+ u16 ip_id; // Identification
+ u16 ip_off; // [15:14] Flags, [13:0] Fragment Offset
+ u8 ip_ttl; // Time To Live
+ u8 ip_pro; // Protocol
+ u16 ip_sum; // Checksum
+ struct in_addr ip_src; // IP Source address
+ struct in_addr ip_dst; // IP Destination address
+};
+
+#define IP_SIZE 20
+
+/*
+ UDP Header Structure
+ NOTE: Network byte order (Big Endian)
+*/
+
+struct udp_header {
+ u16 udp_src; // Source Port
+ u16 udp_dst; // Destination Port
+ u16 udp_len; // Length
+ u16 udp_sum; // Checksum
+};
+
+#define UDP_SIZE 8
+
+/* /\* */
+/* VITA49 VRLP Header */
+/* NOTE: Network byte order (Big Endian) */
+/* *\/ */
+
+/* struct vrlp_header { */
+/* u32 vrlp_start; // Hardcoded to ASCII "VRLP" */
+/* u32 vrlp_size; // [31:20] Frame Count, [19:0] Frame Size */
+/* }; */
+
+/* #define VRLP_SIZE 8 */
+
+/* #define VRLP_SEQID(x) (((x & 0xff)<<4) | ((x & 0xf000) >> 12)) */
+
+/* /\* */
+/* VITA49 VRLP Trailer */
+/* NOTE: Network byte order (Big Endian) */
+/* *\/ */
+
+/* struct vrlp_trailer { */
+/* u32 vrlp_end; // Hardcoded to ASCII "VEND" */
+/* }; */
+
+/* #define VRLP_TRAILER_SIZE 4 */
+
+/* /\* */
+/* VITA49 VRT Header */
+/* NOTE: Network byte order (Big Endian) */
+/* *\/ */
+
+/* struct vrt_header { */
+/* u8 vrt_type; // [7:4] type, [3] Class ID flag, [2] Trailer flag, [1] SOB, [0] EOB */
+/* u8 vrt_count; // [7:6] TSI, [5:4] TSF, [3:0] Packet Count modulo 16 */
+/* u16 vrt_size; // Number of 32bit words in VRT packet including headers and payload. */
+/* u32 vrt_sid; // Stream ID */
+/* }; */
+
+/* #define VRT_SIZE 8 */
+
+
+/*
+Ettus Research CHDR header
+NOTE: Little endian byte order (must be unswizzled)
+*/
+
+struct chdr_header {
+ u32 chdr_type;// [31] Ext Context, [30] RSVD, [29] Has_time, [28] EOB], [27:16] SEQ_ID, [15:0] Size
+ u32 chdr_sid; // Stream ID
+};
+
+#define CHDR_SIZE 8
+
+/*
+Break down SID into CHDR defined fields
+*/
+struct chdr_sid {
+ u8 src_device;
+ u8 src_endpoint;
+ u8 dst_device;
+ u8 dst_endpoint;
+};
+
+struct radio_ctrl_payload {
+ u32 addr;
+ u32 data;
+};
+
+struct radio_response {
+ u64 data;
+};
+
+struct tx_response {
+ u32 error_code;
+ u32 seq_id;
+};
+
+#define TX_ACK 0x00
+#define TX_EOB 0x01
+#define TX_UNDERRUN 0x02
+#define TX_SEQ_ERROR 0x04
+#define TX_TIME_ERROR 0x08
+#define TX_MIDBURST_SEQ_ERROR 0x20
+
+struct src_flow_ctrl {
+ u32 unused;
+ u32 seq_id;
+};
+
+struct vita_time {
+ u64 time;
+};
+
+#define VITA_TIME_SIZE 8
+#define RADIO_CTRL_SIZE 8
+#define RADIO_RESPONSE_SIZE 4
+
+
+/*
+ Packet storage
+*/
+
+struct pbuf {
+ struct pbuf *next;
+ struct pbuf *last;
+ struct timeval ts;
+ int size; // Size stored in pcap file
+ int orig_size; // Original capture size on the wire
+ char *payload;
+};
+
+struct pbuf_info {
+ struct pbuf *start;
+ struct pbuf *current;
+ struct pbuf *end;
+};
+
+struct radio_ctrl_names {
+ u32 addr;
+ char *name;
+};
+
+
+//
+// Prototypes
+//
+
+unsigned long swaplong (unsigned long);
+unsigned int swapint (unsigned int);
+unsigned short swapshort (unsigned short);
+char *format_gmt(const struct timeval *, char *);
+double timeval2double(struct timeval *);
+double relative_time(struct timeval *, struct timeval *);
+void get_packet(struct pbuf_info * , const struct pcap_pkthdr *, const u_char *);
+void get_start_time(struct timeval * , const struct pcap_pkthdr *, const u_char *);
+void get_udp_port_from_file(u16, const char *, struct pbuf_info *, struct timeval *);
+void get_everything_from_file(const char *, struct pbuf_info *, struct timeval *);
+void get_connection_endpoints( struct pbuf_info *, struct in_addr *, struct in_addr *);
+void print_direction(const struct pbuf_info *, const struct in_addr *, const struct in_addr *);
+void print_size( const struct pbuf_info *);
+void print_sid( const struct pbuf_info *);
+void print_vita_header( const struct pbuf_info *, const struct in_addr *);
+
+#endif
diff --git a/tools/uhd_dump/usrp3_regs.h b/tools/uhd_dump/usrp3_regs.h
new file mode 100644
index 000000000..5e3fc1cac
--- /dev/null
+++ b/tools/uhd_dump/usrp3_regs.h
@@ -0,0 +1,51 @@
+
+const struct radio_ctrl_names reg_list[] =
+ {
+ {5, "SR_DACSYNC"},
+ {6, "SR_LOOPBACK"},
+ {7, "SR_TEST"},
+ {8, "SR_SPI_DIVIDER"},
+ {9, "SR_SPI_CONFIG"},
+ {10, "SR_SPI_DATA"},
+ {16, "SR_GPIO_IDLE"},
+ {17, "SR_GPIO_RX"},
+ {18, "SR_GPIO_TX"},
+ {19, "SR_GPIO_FDX"},
+ {20, "SR_GPIO_DDR"},
+ {24, "SR_MISC_OUTS"},
+ {32, "SR_READBACK"},
+ {64, "SR_ERROR_POLICY"},
+ {66, "SR_CYCLES"},
+ {67, "SR_PACKETS"},
+ {96, "SR_RX_CTRL_CMD"},
+ {97, "SR_RX_CTRL_TIME_H"},
+ {98, "SR_RX_CTRL_TIME_L"},
+ {99, "SR_RX_CTRL_RX_HALT"},
+ {100, "SR_RX_CTRL_MAXLEN"},
+ {101, "SR_RX_CTRL_SID"},
+ {102, "SR_RX_CTRL_WINDOW_SIZE"},
+ {103, "SR_RX_CTRL_WINDOW_ENABLE"},
+ {128, "SR_TIME_HI"},
+ {129, "SR_TIME_LO"},
+ {130, "SR_TIME_CTRL"},
+ {144, "SR_RX_DSP_0"},
+ {145, "SR_RX_DSP_1"},
+ {146, "SR_RX_DSP_2"},
+ {147, "SR_RX_DSP_3"},
+ {184, "SR_TX_DSP_0"},
+ {185, "SR_TX_DSP_1"},
+ {186, "SR_TX_DSP_2"},
+ {196, "SR_LEDS_IDLE"},
+ {197, "SR_LEDS_RX"},
+ {198, "SR_LEDS_TX"},
+ {199, "SR_LEDS_FDX"},
+ {200, "SR_LEDS_DDR"},
+ {208, "SR_SWAP_IQ"},
+ {209, "SR_MAG_CORR"},
+ {210, "SR_PHASE_CORR"},
+ {211, "SR_RX_DC_OFFSET_I"},
+ {212, "SR_RX_DC_OFFSET_Q"},
+ {999, "NOT FOUND"}
+ }
+;
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-28 03:12:01 +0000